-*- C -*-

# GLR skeleton for Bison

# Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software

# Foundation, Inc.

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program. If not, see <http://www.gnu.org/licenses/>.

m4_include(b4_pkgdatadir/[c.m4])

## ---------------- ##

## Default values. ##

## ---------------- ##

# Stack parameters.

m4_define_default([b4_stack_depth_max], [10000])

m4_define_default([b4_stack_depth_init], [200])

## ------------------------ ##

## Pure/impure interfaces. ##

## ------------------------ ##

b4_define_flag_if([pure])

# If glr.cc is including this file and thus has already set b4_pure_flag, don't

# change the value of b4_pure_flag, and don't record a use of api.pure.

m4_ifndef([b4_pure_flag],

[b4_percent_define_default([[api.pure]], [[false]])

m4_define([b4_pure_flag],

[b4_percent_define_flag_if([[api.pure]], [[1]], [[0]])])])

# ---------------

# The possible parse-params formal arguments preceded by a comma.

#

# This is not shared with yacc.c in c.m4 because GLR relies on ISO C

# formal argument declarations.

m4_define([b4_user_formals],

[m4_ifset([b4_parse_param], [, b4_c_ansi_formals(b4_parse_param)])])

# ------------

# Accumule in b4_lex_param all the yylex arguments.

# Yes, this is quite ugly...

m4_define([b4_lex_param],

m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl

b4_locations_if([, [[YYLTYPE *], [&yylloc]]])])dnl

m4_ifdef([b4_lex_param], [, ]b4_lex_param)))

# ---------------

# Optional effective arguments passed to yyerror: user args plus yylloc, and

# a trailing comma.

m4_define([b4_yyerror_args],

[b4_pure_if([b4_locations_if([yylocp, ])])dnl

m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])

# ----------------

# Same as above, but on the lookahead, hence &yylloc instead of yylocp.

m4_define([b4_lyyerror_args],

[b4_pure_if([b4_locations_if([&yylloc, ])])dnl

m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])

# ------------

# Same as b4_yyerror_args, but with a leading comma.

m4_define([b4_pure_args],

[b4_pure_if([b4_locations_if([, yylocp])])[]b4_user_args])

# -------------

# Same as above, but on the lookahead, hence &yylloc instead of yylocp.

m4_define([b4_lpure_args],

[b4_pure_if([b4_locations_if([, &yylloc])])[]b4_user_args])

# ---------------

# Arguments passed to yyerror: user formals plus yylocp.

m4_define([b4_pure_formals],

[b4_pure_if([b4_locations_if([, YYLTYPE *yylocp])])[]b4_user_formals])

## ----------------- ##

## Semantic Values. ##

## ----------------- ##

# b4_lhs_value([TYPE])

# --------------------

# Expansion of $<TYPE>$.

m4_define([b4_lhs_value],

[((*yyvalp)[]m4_ifval([$1], [.$1]))])

# b4_rhs_value(RULE-LENGTH, NUM, [TYPE])

# --------------------------------------

# Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH

# symbols on RHS.

m4_define([b4_rhs_value],

[(((yyGLRStackItem const *)yyvsp)@{YYFILL (($2) - ($1))@}.yystate.yysemantics.yysval[]m4_ifval([$3], [.$3]))])

## ----------- ##

## Locations. ##

## ----------- ##

# b4_lhs_location()

# -----------------

# Expansion of @$.

m4_define([b4_lhs_location],

[(*yylocp)])

# b4_rhs_location(RULE-LENGTH, NUM)

# ---------------------------------

# Expansion of @NUM, where the current rule has RULE-LENGTH symbols

# on RHS.

m4_define([b4_rhs_location],

[(((yyGLRStackItem const *)yyvsp)@{YYFILL (($2) - ($1))@}.yystate.yyloc)])

## -------------- ##

## Output files. ##

## -------------- ##

# We do want M4 expansion after # for CPP macros.

m4_changecom()

m4_divert_push(0)dnl

@output(b4_parser_file_name@)

b4_copyright([Skeleton implementation for Bison GLR parsers in C],

[2002, 2003, 2004, 2005, 2006])

[

]b4_identification

b4_percent_code_get([[top]])[]dnl

m4_if(b4_prefix, [yy], [],

#define yylloc b4_prefix[]lloc])[

]b4_user_pre_prologue

dnl # b4_shared_declarations

dnl # ----------------------

dnl # Declaration that might either go into the header (if --defines)

dnl # or open coded in the parser body.

m4_define([b4_shared_declarations],

[b4_percent_code_get([[requires]])[]dnl

b4_token_enums(b4_tokens)

[#ifndef YYSTYPE

]m4_ifdef([b4_stype],

[[typedef union ]b4_union_name[

{

]b4_user_stype[

} YYSTYPE;

# define YYSTYPE_IS_TRIVIAL 1]],

[m4_if(b4_tag_seen_flag, 0,

[[typedef int YYSTYPE;

# define YYSTYPE_IS_TRIVIAL 1]])])[

#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED

typedef struct YYLTYPE

} YYLTYPE;

# define YYLTYPE_IS_DECLARED 1

# define YYLTYPE_IS_TRIVIAL 1

]b4_percent_code_get([[provides]])[]dnl

])

b4_defines_if([[#include "@basename(]b4_spec_defines_file[@)"]],

[b4_shared_declarations])[

#ifndef YYDEBUG

# define YYDEBUG ]b4_debug_flag[

#ifdef YYERROR_VERBOSE

# undef YYERROR_VERBOSE

# define YYERROR_VERBOSE 1

# define YYERROR_VERBOSE ]b4_error_verbose_flag[

#ifndef YYTOKEN_TABLE

# define YYTOKEN_TABLE ]b4_token_table[

static YYSTYPE yyval_default;

]b4_user_post_prologue

b4_percent_code_get[]dnl

[#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#ifndef YY_

# if YYENABLE_NLS

# if ENABLE_NLS

# include <libintl.h> /* INFRINGES ON USER NAME SPACE */

# define YY_(msgid) dgettext ("bison-runtime", msgid)

# ifndef YY_

# define YY_(msgid) msgid

#if ! defined lint || defined __GNUC__

# define YYUSE(e) ((void) (e))

# define YYUSE(e) /* empty */

#ifndef lint

# define YYID(n) (n)

]b4_c_function_def([YYID], [static int], [[int i], [i]])[

{

return i;

}

#ifndef YYFREE

# define YYFREE free

#ifndef YYMALLOC

# define YYMALLOC malloc

#ifndef YYREALLOC

# define YYREALLOC realloc

#define YYSIZEMAX ((size_t) -1)

#ifdef __cplusplus

typedef bool yybool;

typedef unsigned char yybool;

#define yytrue 1

#define yyfalse 0

#ifndef YYSETJMP

# include <setjmp.h>

# define YYJMP_BUF jmp_buf

# define YYSETJMP(env) setjmp (env)

# define YYLONGJMP(env, val) longjmp (env, val)

#ifndef __attribute__

# if (! defined __GNUC__ || __GNUC__ < 2 \

|| (__GNUC__ == 2 && __GNUC_MINOR__ < 5) || __STRICT_ANSI__)

# define __attribute__(Spec) /* empty */

]b4_locations_if([#define YYOPTIONAL_LOC(Name) Name],[

#ifdef __cplusplus

# define YYOPTIONAL_LOC(Name) /* empty */

# define YYOPTIONAL_LOC(Name) Name __attribute__ ((__unused__))

#endif])[

#ifndef YYASSERT

# define YYASSERT(condition) ((void) ((condition) || (abort (), 0)))

#define YYFINAL ]b4_final_state_number[

#define YYLAST ]b4_last[

#define YYNTOKENS ]b4_tokens_number[

#define YYNNTS ]b4_nterms_number[

#define YYNRULES ]b4_rules_number[

#define YYNSTATES ]b4_states_number[

#define YYMAXRHS ]b4_r2_max[

#define YYMAXLEFT ]b4_max_left_semantic_context[

#define YYUNDEFTOK ]b4_undef_token_number[

#define YYMAXUTOK ]b4_user_token_number_max[

#define YYTRANSLATE(YYX) \

((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)

static const ]b4_int_type_for([b4_translate])[ yytranslate[] =

{

]b4_translate[

};

#if YYDEBUG

static const ]b4_int_type_for([b4_prhs])[ yyprhs[] =

{

]b4_prhs[

};

static const ]b4_int_type_for([b4_rhs])[ yyrhs[] =

{

]b4_rhs[

};

static const ]b4_int_type_for([b4_rline])[ yyrline[] =

{

]b4_rline[

};

#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE

static const char *const yytname[] =

{

]b4_tname[

};

static const ]b4_int_type_for([b4_r1])[ yyr1[] =

{

]b4_r1[

};

static const ]b4_int_type_for([b4_r2])[ yyr2[] =

{

]b4_r2[

};

static const ]b4_int_type_for([b4_dprec])[ yydprec[] =

{

]b4_dprec[

};

static const ]b4_int_type_for([b4_merger])[ yymerger[] =

{

]b4_merger[

};

static const ]b4_int_type_for([b4_defact])[ yydefact[] =

{

]b4_defact[

};

static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] =

{

]b4_defgoto[

};

#define YYPACT_NINF ]b4_pact_ninf[

static const ]b4_int_type_for([b4_pact])[ yypact[] =

{

]b4_pact[

};

static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] =

{

]b4_pgoto[

};

#define YYTABLE_NINF ]b4_table_ninf[

static const ]b4_int_type_for([b4_table])[ yytable[] =

{

]b4_table[

};

static const ]b4_int_type_for([b4_conflict_list_heads])[ yyconflp[] =

{

]b4_conflict_list_heads[

};

]dnl Do not use b4_int_type_for here, since there are places where

dnl pointers onto yyconfl are taken, which type is "short int *".

dnl We probably ought to introduce a type for confl.

[static const short int yyconfl[] =

{

]b4_conflicting_rules[

};

static const ]b4_int_type_for([b4_check])[ yycheck[] =

{

]b4_check[

};

static const ]b4_int_type_for([b4_stos])[ yystos[] =

{

]b4_stos[

};



]b4_c_ansi_function_decl([yyparse], [int], b4_parse_param)[

#define YYTERROR 1

]b4_locations_if([[

#define YYRHSLOC(Rhs, K) ((Rhs)[K].yystate.yyloc)

#ifndef YYLLOC_DEFAULT

# define YYLLOC_DEFAULT(Current, Rhs, N) \

do \

if (YYID (N)) \

{ \

(Current).first_line = YYRHSLOC (Rhs, 1).first_line; \

(Current).first_column = YYRHSLOC (Rhs, 1).first_column; \

(Current).last_line = YYRHSLOC (Rhs, N).last_line; \

(Current).last_column = YYRHSLOC (Rhs, N).last_column; \

} \

else \

{ \

(Current).first_line = (Current).last_line = \

YYRHSLOC (Rhs, 0).last_line; \

(Current).first_column = (Current).last_column = \

YYRHSLOC (Rhs, 0).last_column; \

} \

while (YYID (0))

# define YY_LOCATION_PRINT(File, Loc) \

fprintf (File, "%d.%d-%d.%d", \

(Loc).first_line, (Loc).first_column, \

(Loc).last_line, (Loc).last_column)

]],[

#ifndef YYLLOC_DEFAULT

# define YYLLOC_DEFAULT(Current, Rhs, N) ((void) 0)

])[

#ifndef YY_LOCATION_PRINT

# define YY_LOCATION_PRINT(File, Loc) ((void) 0)

#define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[

]b4_pure_if(

[

#undef yynerrs

#define yynerrs (yystackp->yyerrcnt)

#undef yychar

#define yychar (yystackp->yyrawchar)

#undef yylval

#define yylval (yystackp->yyval)

#undef yylloc

#define yylloc (yystackp->yyloc)

m4_if(b4_prefix[], [yy], [],

[#define b4_prefix[]nerrs yynerrs

#define b4_prefix[]char yychar

#define b4_prefix[]lval yylval

#define b4_prefix[]lloc yylloc])],

[YYSTYPE yylval;

YYLTYPE yylloc;

int yynerrs;

int yychar;])[

static const int YYEOF = 0;

static const int YYEMPTY = -2;

typedef enum { yyok, yyaccept, yyabort, yyerr } YYRESULTTAG;

#define YYCHK(YYE) \

do { YYRESULTTAG yyflag = YYE; if (yyflag != yyok) return yyflag; } \

while (YYID (0))

#if YYDEBUG

# ifndef YYFPRINTF

# define YYFPRINTF fprintf

# define YYDPRINTF(Args) \

do { \

if (yydebug) \

YYFPRINTF Args; \

} while (YYID (0))

]b4_yy_symbol_print_generate([b4_c_ansi_function_def])[

# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \

do { \

if (yydebug) \

{ \

YYFPRINTF (stderr, "%s ", Title); \

yy_symbol_print (stderr, Type, \

Value]b4_locations_if([, Location])[]b4_user_args[); \

YYFPRINTF (stderr, "\n"); \

} \

} while (YYID (0))

int yydebug;

#else /* !YYDEBUG */

# define YYDPRINTF(Args)

# define YY_SYMBOL_PRINT(Title, Type, Value, Location)

#endif /* !YYDEBUG */

#ifndef YYINITDEPTH

# define YYINITDEPTH ]b4_stack_depth_init[

#ifndef YYMAXDEPTH

# define YYMAXDEPTH ]b4_stack_depth_max[

#define YYHEADROOM 2

#ifndef YYSTACKEXPANDABLE

# if (! defined __cplusplus \

|| (]b4_locations_if([[defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \

&& ]])[defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))

# define YYSTACKEXPANDABLE 1

# define YYSTACKEXPANDABLE 0

#if YYSTACKEXPANDABLE

# define YY_RESERVE_GLRSTACK(Yystack) \

do { \

if (Yystack->yyspaceLeft < YYHEADROOM) \

yyexpandGLRStack (Yystack); \

} while (YYID (0))

# define YY_RESERVE_GLRSTACK(Yystack) \

do { \

if (Yystack->yyspaceLeft < YYHEADROOM) \

yyMemoryExhausted (Yystack); \

} while (YYID (0))

#if YYERROR_VERBOSE

# ifndef yystpcpy

# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE

# define yystpcpy stpcpy

static char *

yystpcpy (char *yydest, const char *yysrc)

{

char *yyd = yydest;

const char *yys = yysrc;

while ((*yyd++ = *yys++) != '\0')

continue;

return yyd - 1;

}

# ifndef yytnamerr

static size_t

yytnamerr (char *yyres, const char *yystr)

{

if (*yystr == '"')

{

size_t yyn = 0;

char const *yyp = yystr;

for (;;)

switch (*++yyp)

{

case '\'':

case ',':

goto do_not_strip_quotes;

case '\\':

if (*++yyp != '\\')

goto do_not_strip_quotes;

/* Fall through. */

default:

if (yyres)

yyres[yyn] = *yyp;

yyn++;

break;

case '"':

if (yyres)

yyres[yyn] = '\0';

return yyn;

}

do_not_strip_quotes: ;

}

if (! yyres)

return strlen (yystr);

return yystpcpy (yyres, yystr) - yyres;

}

#endif /* !YYERROR_VERBOSE */

typedef int yyStateNum;

typedef int yyRuleNum;

typedef short int yySymbol;

typedef short int yyItemNum;

typedef struct yyGLRState yyGLRState;

typedef struct yyGLRStateSet yyGLRStateSet;

typedef struct yySemanticOption yySemanticOption;

typedef union yyGLRStackItem yyGLRStackItem;

typedef struct yyGLRStack yyGLRStack;

struct yyGLRState {

};

struct yyGLRStateSet {

};

struct yySemanticOption {

};

union yyGLRStackItem {

yyGLRState yystate;

yySemanticOption yyoption;

};

struct yyGLRStack {

};

#if YYSTACKEXPANDABLE

static void yyexpandGLRStack (yyGLRStack* yystackp);

static void yyFail (yyGLRStack* yystackp]b4_pure_formals[, const char* yymsg)

__attribute__ ((__noreturn__));

static void

yyFail (yyGLRStack* yystackp]b4_pure_formals[, const char* yymsg)

{

if (yymsg != NULL)

yyerror (]b4_yyerror_args[yymsg);

YYLONGJMP (yystackp->yyexception_buffer, 1);

}

static void yyMemoryExhausted (yyGLRStack* yystackp)

__attribute__ ((__noreturn__));

static void

yyMemoryExhausted (yyGLRStack* yystackp)

{

YYLONGJMP (yystackp->yyexception_buffer, 2);

}

#if YYDEBUG || YYERROR_VERBOSE

static inline const char*

yytokenName (yySymbol yytoken)

{

if (yytoken == YYEMPTY)

return "";

return yytname[yytoken];

}

static void yyfillin (yyGLRStackItem *, int, int) __attribute__ ((__unused__));

static void

yyfillin (yyGLRStackItem *yyvsp, int yylow0, int yylow1)

{

yyGLRState* s;

int i;

s = yyvsp[yylow0].yystate.yypred;

for (i = yylow0-1; i >= yylow1; i -= 1)

{

YYASSERT (s->yyresolved);

yyvsp[i].yystate.yyresolved = yytrue;

yyvsp[i].yystate.yysemantics.yysval = s->yysemantics.yysval;

yyvsp[i].yystate.yyloc = s->yyloc;

s = yyvsp[i].yystate.yypred = s->yypred;

}

}

static inline int yyfill (yyGLRStackItem *, int *, int, yybool)

__attribute__ ((__unused__));

static inline int

yyfill (yyGLRStackItem *yyvsp, int *yylow, int yylow1, yybool yynormal)

{

if (!yynormal && yylow1 < *yylow)

{

yyfillin (yyvsp, *yylow, yylow1);

*yylow = yylow1;

}

return yylow1;

}

/*ARGSUSED*/ static YYRESULTTAG

yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,

]b4_user_formals[)

{

yybool yynormal __attribute__ ((__unused__)) =

(yystackp->yysplitPoint == NULL);

int yylow;

]b4_parse_param_use[]dnl

[# undef yyerrok

# define yyerrok (yystackp->yyerrState = 0)

# undef YYACCEPT

# define YYACCEPT return yyaccept

# undef YYABORT

# define YYABORT return yyabort

# undef YYERROR

# define YYERROR return yyerrok, yyerr

# undef YYRECOVERING

# define YYRECOVERING() (yystackp->yyerrState != 0)

# undef yyclearin

# define yyclearin (yychar = YYEMPTY)

# undef YYFILL

# define YYFILL(N) yyfill (yyvsp, &yylow, N, yynormal)

# undef YYBACKUP

# define YYBACKUP(Token, Value) \

return yyerror (]b4_yyerror_args[YY_("syntax error: cannot back up")), \

yyerrok, yyerr

yylow = 1;

if (yyrhslen == 0)

*yyvalp = yyval_default;

else

*yyvalp = yyvsp[YYFILL (1-yyrhslen)].yystate.yysemantics.yysval;

YYLLOC_DEFAULT ((*yylocp), (yyvsp - yyrhslen), yyrhslen);

]b4_locations_if([[ yystackp->yyerror_range[1].yystate.yyloc = *yylocp;

]])[

switch (yyn)

{

]b4_user_actions[

default: break;

}

return yyok;

# undef yyerrok

# undef YYABORT

# undef YYACCEPT

# undef YYERROR

# undef YYBACKUP

# undef yyclearin

# undef YYRECOVERING

}



/*ARGSUSED*/ static void

yyuserMerge (int yyn, YYSTYPE* yy0, YYSTYPE* yy1)

{

YYUSE (yy0);

YYUSE (yy1);

switch (yyn)

{

]b4_mergers[

default: break;

}

}

/* Bison grammar-table manipulation. */

]b4_yydestruct_generate([b4_c_ansi_function_def])[

static inline int

yyrhsLength (yyRuleNum yyrule)

{

return yyr2[yyrule];

}

static void

yydestroyGLRState (char const *yymsg, yyGLRState *yys]b4_user_formals[)

{

if (yys->yyresolved)

yydestruct (yymsg, yystos[yys->yylrState],

&yys->yysemantics.yysval]b4_locations_if([, &yys->yyloc])[]b4_user_args[);

else

{

#if YYDEBUG

if (yydebug)

{

if (yys->yysemantics.yyfirstVal)

YYFPRINTF (stderr, "%s unresolved ", yymsg);

else

YYFPRINTF (stderr, "%s incomplete ", yymsg);

yy_symbol_print (stderr, yystos[yys->yylrState],

NULL]b4_locations_if([, &yys->yyloc])[]b4_user_args[);

YYFPRINTF (stderr, "\n");

}

if (yys->yysemantics.yyfirstVal)

{

yySemanticOption *yyoption = yys->yysemantics.yyfirstVal;

yyGLRState *yyrh;

int yyn;