X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/8710fc41aaebc5d167a2783a4b8b60849a803869..34ec3579275891fed1f23538990ebd0c1d695ada:/data/glr.c?ds=sidebyside diff --git a/data/glr.c b/data/glr.c index a810bcdc..7c3d998d 100644 --- a/data/glr.c +++ b/data/glr.c @@ -52,7 +52,7 @@ m4_define([b4_user_formals], # Yes, this is quite ugly... m4_define([b4_lex_param], m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl -b4_location_if([, [[YYLTYPE *], [&yylloc]]])])dnl +b4_locations_if([, [[YYLTYPE *], [&yylloc]]])])dnl m4_ifdef([b4_lex_param], [, ]b4_lex_param))) @@ -61,15 +61,15 @@ 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_location_if([yylocp, ])])dnl +[b4_pure_if([b4_locations_if([yylocp, ])])dnl m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])]) # b4_lyyerror_args # ---------------- -# Same as above, but on the look-ahead, hence &yylloc instead of yylocp. +# Same as above, but on the lookahead, hence &yylloc instead of yylocp. m4_define([b4_lyyerror_args], -[b4_pure_if([b4_location_if([&yylloc, ])])dnl +[b4_pure_if([b4_locations_if([&yylloc, ])])dnl m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])]) @@ -77,21 +77,21 @@ 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_location_if([, yylocp])])[]b4_user_args]) +[b4_pure_if([b4_locations_if([, yylocp])])[]b4_user_args]) # b4_lpure_args # ------------- -# Same as above, but on the look-ahead, hence &yylloc instead of yylocp. +# Same as above, but on the lookahead, hence &yylloc instead of yylocp. m4_define([b4_lpure_args], -[b4_pure_if([b4_location_if([, &yylloc])])[]b4_user_args]) +[b4_pure_if([b4_locations_if([, &yylloc])])[]b4_user_args]) # b4_pure_formals # --------------- # Arguments passed to yyerror: user formals plus yylocp. m4_define([b4_pure_formals], -[b4_pure_if([b4_location_if([, YYLTYPE *yylocp])])[]b4_user_formals]) +[b4_pure_if([b4_locations_if([, YYLTYPE *yylocp])])[]b4_user_formals]) ## ----------------- ## @@ -143,14 +143,14 @@ m4_define([b4_rhs_location], m4_changecom() m4_divert(0)dnl @output @output_parser_name@ -b4_copyright([Skeleton parser for GLR parsing with Bison], +b4_copyright([Skeleton implementation for Bison GLR parsers in C], [2002, 2003, 2004, 2005, 2006]) [ -/* This is the parser code for GLR (Generalized LR) parser. */ +/* C GLR parser skeleton written by Paul Hilfinger. */ ]b4_identification -m4_if(b4_prefix[], [yy], [], +m4_if(b4_prefix, [yy], [], [/* Substitute the variable and function names. */ #define yyparse b4_prefix[]parse #define yylex b4_prefix[]lex @@ -159,34 +159,37 @@ m4_if(b4_prefix[], [yy], [], #define yychar b4_prefix[]char #define yydebug b4_prefix[]debug #define yynerrs b4_prefix[]nerrs -#define yylloc b4_prefix[]lloc]) +#define yylloc b4_prefix[]lloc])[ + +/* Copy the first part of user declarations. */ +]b4_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_token_enums(b4_tokens)[ +[m4_ifdef([b4_start_header], +[[/* Copy the %start-header blocks. */ +]b4_start_header])[]dnl -/* Copy the first part of user declarations. */ -]b4_pre_prologue[ +b4_token_enums(b4_tokens) -#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED +[#ifndef YYSTYPE ]m4_ifdef([b4_stype], -[typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ]) -b4_stype -/* Line __line__ of glr.c. */ -b4_syncline([@oline@], [@ofile@]) - YYSTYPE;], -[typedef int YYSTYPE;])[ -# define YYSTYPE_IS_DECLARED 1 -# define YYSTYPE_IS_TRIVIAL 1 +[[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]])])[ #endif #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED typedef struct YYLTYPE { -]b4_location_if([ +]b4_locations_if([ int first_line; int first_column; int last_line; @@ -198,15 +201,18 @@ typedef struct YYLTYPE # define YYLTYPE_IS_DECLARED 1 # define YYLTYPE_IS_TRIVIAL 1 #endif -]]) -m4_if(b4_defines_flag, 0, - [b4_shared_declarations], - [#include @output_header_name@])[ +]m4_ifdef([b4_end_header], +[[/* Copy the %end-header blocks. */ +]b4_end_header])[]dnl +]) + +b4_defines_if([#include @output_header_name@], + [b4_shared_declarations])[ /* Enabling traces. */ #ifndef YYDEBUG -# define YYDEBUG ]b4_debug[ +# define YYDEBUG ]b4_debug_flag[ #endif /* Enabling verbose error messages. */ @@ -214,7 +220,7 @@ m4_if(b4_defines_flag, 0, # undef YYERROR_VERBOSE # define YYERROR_VERBOSE 1 #else -# define YYERROR_VERBOSE ]b4_error_verbose[ +# define YYERROR_VERBOSE ]b4_error_verbose_flag[ #endif /* Enabling the token table. */ @@ -230,11 +236,8 @@ m4_if(b4_defines_flag, 0, static YYSTYPE yyval_default; /* Copy the second part of user declarations. */ -]b4_post_prologue[ +]b4_user_post_prologue[ -]/* Line __line__ of glr.c. */ -b4_syncline([@oline@], [@ofile@]) -[ #include #include #include @@ -308,7 +311,7 @@ b4_syncline([@oline@], [@ofile@]) # endif #endif -]b4_location_if([#define YYOPTIONAL_LOC(Name) Name],[ +]b4_locations_if([#define YYOPTIONAL_LOC(Name) Name],[ #ifdef __cplusplus # define YYOPTIONAL_LOC(Name) /* empty */ #else @@ -486,7 +489,7 @@ static const ]b4_int_type_for([b4_stos])[ yystos[] = If N is 0, then set CURRENT to the empty location which ends the previous symbol: RHS[0] (always defined). */ -]b4_location_if([[ +]b4_locations_if([[ #define YYRHSLOC(Rhs, K) ((Rhs)[K].yystate.yyloc) #ifndef YYLLOC_DEFAULT # define YYLLOC_DEFAULT(Current, Rhs, N) \ @@ -581,7 +584,7 @@ do { \ { \ YYFPRINTF (stderr, "%s ", Title); \ yy_symbol_print (stderr, Type, \ - Value]b4_location_if([, Location])[]b4_user_args[); \ + Value]b4_locations_if([, Location])[]b4_user_args[); \ YYFPRINTF (stderr, "\n"); \ } \ } while (YYID (0)) @@ -622,7 +625,7 @@ int yydebug; #ifndef YYSTACKEXPANDABLE # if (! defined __cplusplus \ - || (]b4_location_if([[defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \ + || (]b4_locations_if([[defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \ && ]])[defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)) # define YYSTACKEXPANDABLE 1 # else @@ -794,7 +797,7 @@ union yyGLRStackItem { struct yyGLRStack { int yyerrState; -]b4_location_if([[ /* To compute the location of the error token. */ +]b4_locations_if([[ /* To compute the location of the error token. */ yyGLRStackItem yyerror_range[3];]])[ ]b4_pure_if( [ @@ -907,7 +910,7 @@ yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp, # undef YYERROR # define YYERROR return yyerrok, yyerr # undef YYRECOVERING -# define YYRECOVERING (yystackp->yyerrState != 0) +# define YYRECOVERING() (yystackp->yyerrState != 0) # undef yyclearin # define yyclearin (yychar = YYEMPTY) # undef YYFILL @@ -923,13 +926,11 @@ yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp, else *yyvalp = yyvsp[YYFILL (1-yyrhslen)].yystate.yysemantics.yysval; YYLLOC_DEFAULT ((*yylocp), (yyvsp - yyrhslen), yyrhslen); -]b4_location_if([[ yystackp->yyerror_range[1].yystate.yyloc = *yylocp; +]b4_locations_if([[ yystackp->yyerror_range[1].yystate.yyloc = *yylocp; ]])[ switch (yyn) { - ]b4_actions -/* Line __line__ of glr.c. */ -b4_syncline([@oline@], [@ofile@])[ + ]b4_user_actions[ default: break; } @@ -973,7 +974,7 @@ yydestroyGLRState (char const *yymsg, yyGLRState *yys]b4_user_formals[) { if (yys->yyresolved) yydestruct (yymsg, yystos[yys->yylrState], - &yys->yysemantics.yysval]b4_location_if([, &yys->yyloc])[]b4_user_args[); + &yys->yysemantics.yysval]b4_locations_if([, &yys->yyloc])[]b4_user_args[); else { #if YYDEBUG @@ -984,7 +985,7 @@ yydestroyGLRState (char const *yymsg, yyGLRState *yys]b4_user_formals[) else YYFPRINTF (stderr, "%s incomplete ", yymsg); yy_symbol_print (stderr, yystos[yys->yylrState], - NULL]b4_location_if([, &yys->yyloc])[]b4_user_args[); + NULL]b4_locations_if([, &yys->yyloc])[]b4_user_args[); YYFPRINTF (stderr, "\n"); } #endif @@ -1392,7 +1393,7 @@ yydoAction (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule, yyGLRState* yys; yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1]; yys = yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred - = yystackp->yytops.yystates[yyk];]b4_location_if([[ + = yystackp->yytops.yystates[yyk];]b4_locations_if([[ if (yynrhs == 0) /* Set default location. */ yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].yystate.yyloc = yys->yyloc;]])[ @@ -1443,7 +1444,7 @@ yy_reduce_print (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule, fprintf (stderr, " $%d = ", yyi + 1); yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], &]b4_rhs_value(yynrhs, yyi + 1)[ - ]b4_location_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl + ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl b4_user_args[); fprintf (stderr, "\n"); } @@ -1716,7 +1717,7 @@ yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystackp, return yyflag; } - yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred = yyopt->yystate;]b4_location_if([[ + yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred = yyopt->yystate;]b4_locations_if([[ if (yynrhs == 0) /* Set default location. */ yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].yystate.yyloc = yyopt->yystate->yyloc;]])[ @@ -1742,7 +1743,7 @@ yyreportTree (yySemanticOption* yyx, int yyindent) int yynrhs = yyrhsLength (yyx->yyrule); int yyi; yyGLRState* yys; - yyGLRState* yystates[YYMAXRHS]; + yyGLRState* yystates[1 + YYMAXRHS]; yyGLRState yyleftmost_state; for (yyi = yynrhs, yys = yyx->yystate; 0 < yyi; yyi -= 1, yys = yys->yypred) @@ -1758,11 +1759,11 @@ yyreportTree (yySemanticOption* yyx, int yyindent) if (yyx->yystate->yyposn < yys->yyposn + 1) YYFPRINTF (stderr, "%*s%s -> \n", yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)), - yyx->yyrule); + yyx->yyrule - 1); else YYFPRINTF (stderr, "%*s%s -> \n", yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)), - yyx->yyrule, (unsigned long int) (yys->yyposn + 1), + yyx->yyrule - 1, (unsigned long int) (yys->yyposn + 1), (unsigned long int) yyx->yystate->yyposn); for (yyi = 1; yyi <= yynrhs; yyi += 1) { @@ -1803,43 +1804,49 @@ yyreportAmbiguity (yySemanticOption* yyx0, return yyabort; } -/** Starting at and including state S, resolve the location for each of the - * previous N states that is unresolved. The first semantic option of a state +/** Starting at and including state S1, resolve the location for each of the + * previous N1 states that is unresolved. The first semantic option of a state * is always chosen. */ static void -yyresolveLocations (yyGLRState* yys, int yyn, +yyresolveLocations (yyGLRState* yys1, int yyn1, yyGLRStack *yystackp]b4_user_formals[) { - if (0 < yyn) + if (0 < yyn1) { - yyresolveLocations (yys->yypred, yyn-1, yystackp]b4_user_args[); - if (!yys->yyresolved) + yyresolveLocations (yys1->yypred, yyn1 - 1, yystackp]b4_user_args[); + if (!yys1->yyresolved) { yySemanticOption *yyoption; - yyGLRStackItem yyrhs[1 + YYMAXRHS]; + yyGLRStackItem yyrhsloc[1 + YYMAXRHS]; int yynrhs; int yychar_current; YYSTYPE yylval_current; YYLTYPE yylloc_current; - yyoption = yys->yysemantics.yyfirstVal; + yyoption = yys1->yysemantics.yyfirstVal; YYASSERT (yyoption != NULL); yynrhs = yyrhsLength (yyoption->yyrule); if (yynrhs > 0) { yyGLRState *yys; - int yyi; + int yyn; yyresolveLocations (yyoption->yystate, yynrhs, yystackp]b4_user_args[); - for (yys = yyoption->yystate, yyi = yynrhs; - yyi >= 1; - yys = yys->yypred, yyi -= 1) - yyrhs[yyi].yystate.yyloc = yys->yyloc; + for (yys = yyoption->yystate, yyn = yynrhs; + yyn > 0; + yys = yys->yypred, yyn -= 1) + yyrhsloc[yyn].yystate.yyloc = yys->yyloc; } else { + /* Both yyresolveAction and yyresolveLocations traverse the GSS + in reverse rightmost order. It is only necessary to invoke + yyresolveLocations on a subforest for which yyresolveAction + would have been invoked next had an ambiguity not been + detected. Thus the location of the previous state (but not + necessarily the previous state itself) is guaranteed to be + resolved already. */ yyGLRState *yyprevious = yyoption->yystate; - YYASSERT (yyprevious->yyresolved); - yyrhs[0].yystate.yyloc = yyprevious->yyloc; + yyrhsloc[0].yystate.yyloc = yyprevious->yyloc; } yychar_current = yychar; yylval_current = yylval; @@ -1847,7 +1854,7 @@ yyresolveLocations (yyGLRState* yys, int yyn, yychar = yyoption->yyrawchar; yylval = yyoption->yyval; yylloc = yyoption->yyloc; - YYLLOC_DEFAULT ((yys->yyloc), yyrhs, yynrhs); + YYLLOC_DEFAULT ((yys1->yyloc), yyrhsloc, yynrhs); yychar = yychar_current; yylval = yylval_current; yylloc = yylloc_current; @@ -1929,7 +1936,7 @@ yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp]b4_user_formals[) { yydestruct ("Cleanup: discarding incompletely merged value for", yystos[yys->yylrState], - &yysval]b4_location_if([, yylocp])[]b4_user_args[); + &yysval]b4_locations_if([, yylocp])[]b4_user_args[); break; } yyuserMerge (yymerger[yyp->yyrule], &yysval, &yysval_other); @@ -2078,7 +2085,7 @@ yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[) #if YYERROR_VERBOSE int yyn; yyn = yypact[yystackp->yytops.yystates[0]->yylrState]; - if (YYPACT_NINF < yyn && yyn < YYLAST) + if (YYPACT_NINF < yyn && yyn <= YYLAST) { yySymbol yytoken = YYTRANSLATE (yychar); size_t yysize0 = yytnamerr (NULL, yytokenName (yytoken)); @@ -2105,7 +2112,7 @@ yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[) int yyxbegin = yyn < 0 ? -yyn : 0; /* Stay within bounds of both yycheck and yytname. */ - int yychecklim = YYLAST - yyn; + int yychecklim = YYLAST - yyn + 1; int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; int yycount = 1; @@ -2173,7 +2180,7 @@ yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[) /* Recover from a syntax error on *YYSTACKP, assuming that *YYSTACKP->YYTOKENP, yylval, and yylloc are the syntactic category, semantic value, and location - of the look-ahead. */ + of the lookahead. */ /*ARGSUSED*/ static void yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[) { @@ -2189,7 +2196,7 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[) if (yychar == YYEOF) yyFail (yystackp][]b4_lpure_args[, NULL); if (yychar != YYEMPTY) - {]b4_location_if([[ + {]b4_locations_if([[ /* We throw away the lookahead, but the error range of the shifted error token must take it into account. */ yyGLRState *yys = yystackp->yytops.yystates[0]; @@ -2199,7 +2206,7 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[) YYLLOC_DEFAULT ((yys->yyloc), yyerror_range, 2);]])[ yytoken = YYTRANSLATE (yychar); yydestruct ("Error: discarding", - yytoken, &yylval]b4_location_if([, &yylloc])[]b4_user_args[); + yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[); } YYDPRINTF ((stderr, "Reading a token: ")); yychar = YYLEX; @@ -2242,7 +2249,7 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[) && yyisShiftAction (yytable[yyj])) { /* Shift the error token having adjusted its location. */ - YYLTYPE yyerrloc;]b4_location_if([[ + YYLTYPE yyerrloc;]b4_locations_if([[ yystackp->yyerror_range[2].yystate.yyloc = yylloc; YYLLOC_DEFAULT (yyerrloc, (yystackp->yyerror_range), 2);]])[ YY_SYMBOL_PRINT ("Shifting", yystos[yytable[yyj]], @@ -2253,8 +2260,9 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[) break; } } -]b4_location_if([[ yystackp->yyerror_range[1].yystate.yyloc = yys->yyloc;]])[ - yydestroyGLRState ("Error: popping", yys]b4_user_args[); +]b4_locations_if([[ yystackp->yyerror_range[1].yystate.yyloc = yys->yyloc;]])[ + if (yys->yypred != NULL) + yydestroyGLRState ("Error: popping", yys]b4_user_args[); yystackp->yytops.yystates[0] = yys->yypred; yystackp->yynextFree -= 1; yystackp->yyspaceLeft += 1; @@ -2295,21 +2303,19 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[) yychar = YYEMPTY; yylval = yyval_default; -]b4_location_if([ +]b4_locations_if([ #if YYLTYPE_IS_TRIVIAL - yylloc.first_line = yylloc.last_line = 1; - yylloc.first_column = yylloc.last_column = 0; + yylloc.first_line = yylloc.last_line = ]b4_location_initial_line[; + yylloc.first_column = yylloc.last_column = ]b4_location_initial_column[; #endif ]) m4_ifdef([b4_initial_action], [ m4_pushdef([b4_at_dollar], [yylloc])dnl m4_pushdef([b4_dollar_dollar], [yylval])dnl /* User initialization code. */ - b4_initial_action + b4_user_initial_action m4_popdef([b4_dollar_dollar])dnl -m4_popdef([b4_at_dollar])dnl -/* Line __line__ of glr.c. */ -b4_syncline([@oline@], [@ofile@])])dnl +m4_popdef([b4_at_dollar])])dnl [ if (! yyinitGLRStack (yystackp, YYINITDEPTH)) goto yyexhaustedlab; @@ -2344,7 +2350,7 @@ b4_syncline([@oline@], [@ofile@])])dnl yyrule = yydefaultAction (yystate); if (yyrule == 0) { -]b4_location_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[ +]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[ yyreportSyntaxError (&yystack]b4_user_args[); goto yyuser_error; } @@ -2368,8 +2374,7 @@ b4_syncline([@oline@], [@ofile@])])dnl if (yyisShiftAction (yyaction)) { YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); - if (yychar != YYEOF) - yychar = YYEMPTY; + yychar = YYEMPTY; yyposn += 1; yyglrShift (&yystack, 0, yyaction, yyposn, &yylval, &yylloc); if (0 < yystack.yyerrState) @@ -2377,7 +2382,7 @@ b4_syncline([@oline@], [@ofile@])])dnl } else if (yyisErrorAction (yyaction)) { -]b4_location_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[ +]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[ yyreportSyntaxError (&yystack]b4_user_args[); goto yyuser_error; } @@ -2423,7 +2428,7 @@ b4_syncline([@oline@], [@ofile@])])dnl yyFail (&yystack][]b4_lpure_args[, YY_("syntax error")); YYCHK1 (yyresolveStack (&yystack]b4_user_args[)); YYDPRINTF ((stderr, "Returning to deterministic operation.\n")); -]b4_location_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[ +]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[ yyreportSyntaxError (&yystack]b4_user_args[); goto yyuser_error; } @@ -2485,10 +2490,10 @@ b4_syncline([@oline@], [@ofile@])])dnl goto yyreturn; yyreturn: - if (yychar != YYEOF && yychar != YYEMPTY) + if (yychar != YYEMPTY) yydestruct ("Cleanup: discarding lookahead", YYTRANSLATE (yychar), - &yylval]b4_location_if([, &yylloc])[]b4_user_args[); + &yylval]b4_locations_if([, &yylloc])[]b4_user_args[); /* If the stack is well-formed, pop the stack until it is empty, destroying its entries as we go. But free the stack regardless @@ -2506,8 +2511,9 @@ b4_syncline([@oline@], [@ofile@])])dnl while (yystates[yyk]) { yyGLRState *yys = yystates[yyk]; -]b4_location_if([[ yystack.yyerror_range[1].yystate.yyloc = yys->yyloc;]] -)[ yydestroyGLRState ("Cleanup: popping", yys]b4_user_args[); +]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yys->yyloc;]] +)[ if (yys->yypred != NULL) + yydestroyGLRState ("Cleanup: popping", yys]b4_user_args[); yystates[yyk] = yys->yypred; yystack.yynextFree -= 1; yystack.yyspaceLeft += 1; @@ -2518,7 +2524,8 @@ b4_syncline([@oline@], [@ofile@])])dnl yyfreeGLRStack (&yystack); } - return yyresult; + /* Make sure YYID is used. */ + return YYID (yyresult); } /* DEBUGGING ONLY */ @@ -2579,7 +2586,7 @@ yypdumpstack (yyGLRStack* yystackp) else { fprintf (stderr, "Option. rule: %d, state: %ld, next: %ld", - yyp->yyoption.yyrule, + yyp->yyoption.yyrule - 1, (long int) YYINDEX (yyp->yyoption.yystate), (long int) YYINDEX (yyp->yyoption.yynext)); } @@ -2595,19 +2602,16 @@ yypdumpstack (yyGLRStack* yystackp) ] b4_epilogue -m4_if(b4_defines_flag, 0, [], +b4_defines_if( [@output @output_header_name@ -b4_copyright([Skeleton parser for GLR parsing with Bison], - [2002, 2003, 2004, 2005, 2006])[ - -/* C GLR parser skeleton written by Paul Hilfinger. */ -] +b4_copyright([Skeleton interface for Bison GLR parsers in C], + [2002, 2003, 2004, 2005, 2006]) b4_shared_declarations extern YYSTYPE b4_prefix[]lval; -b4_location_if([b4_pure_if([], +b4_locations_if([b4_pure_if([], [extern YYLTYPE b4_prefix[]lloc;]) ]) ])