X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/c66dfaddf449920bea03c0aa3b55467e2f21c98e..455671735e6f4e9712c2f5ac1bc153b07b33e67b:/data/glr.c diff --git a/data/glr.c b/data/glr.c index daa46279..e67573b6 100644 --- a/data/glr.c +++ b/data/glr.c @@ -171,7 +171,7 @@ m4_define([b4_shared_declarations], /* Copy the first part of user declarations. */ ]b4_pre_prologue[ -#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) +#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED ]m4_ifdef([b4_stype], [typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ]) b4_stype @@ -183,7 +183,7 @@ b4_syncline([@oline@], [@ofile@]) # define YYSTYPE_IS_TRIVIAL 1 #endif -#if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED) +#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED typedef struct YYLTYPE { ]b4_location_if([ @@ -253,7 +253,7 @@ b4_syncline([@oline@], [@ofile@]) #endif /* Suppress unused-variable warnings by "using" E. */ -#if !defined (lint) || defined (__GNUC__) +#if ! defined lint || defined __GNUC__ # define YYUSE(e) ((void) (e)) #else # define YYUSE(e) /* empty */ @@ -302,7 +302,7 @@ b4_syncline([@oline@], [@ofile@]) #ifndef __attribute__ /* This feature is available in gcc versions 2.5 and later. */ -# if (!defined (__GNUC__) || __GNUC__ < 2 \ +# if (! defined __GNUC__ || __GNUC__ < 2 \ || (__GNUC__ == 2 && __GNUC_MINOR__ < 5) || __STRICT_ANSI__) # define __attribute__(Spec) /* empty */ # endif @@ -563,9 +563,9 @@ typedef enum { yyok, yyaccept, yyabort, yyerr } YYRESULTTAG; #if YYDEBUG -#if ! defined (YYFPRINTF) +# ifndef YYFPRINTF # define YYFPRINTF fprintf -#endif +# endif # define YYDPRINTF(Args) \ do { \ @@ -621,9 +621,9 @@ int yydebug; #define YYHEADROOM 2 #ifndef YYSTACKEXPANDABLE -# if (! defined (__cplusplus) \ - || (]b4_location_if([[defined (YYLTYPE_IS_TRIVIAL) && YYLTYPE_IS_TRIVIAL \ - && ]])[defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)) +# if (! defined __cplusplus \ + || (]b4_location_if([[defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \ + && ]])[defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)) # define YYSTACKEXPANDABLE 1 # else # define YYSTACKEXPANDABLE 0 @@ -648,7 +648,7 @@ int yydebug; #if YYERROR_VERBOSE # ifndef yystpcpy -# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE) +# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE # define yystpcpy stpcpy # else /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in @@ -803,7 +803,6 @@ struct yyGLRStack { YYSTYPE yyval; YYLTYPE yyloc; ])[ - yySymbol* yytokenp; YYJMP_BUF yyexception_buffer; yyGLRStackItem* yyitems; yyGLRStackItem* yynextFree; @@ -910,7 +909,7 @@ yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp, # undef YYRECOVERING # define YYRECOVERING (yystackp->yyerrState != 0) # undef yyclearin -# define yyclearin (yychar = *(yystackp->yytokenp) = YYEMPTY) +# define yyclearin (yychar = YYEMPTY) # undef YYFILL # define YYFILL(N) yyfill (yyvsp, &yylow, N, yynormal) # undef YYBACKUP @@ -923,7 +922,7 @@ yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp, *yyvalp = yyval_default; else *yyvalp = yyvsp[YYFILL (1-yyrhslen)].yystate.yysemantics.yysval; - YYLLOC_DEFAULT (*yylocp, yyvsp - yyrhslen, yyrhslen); + YYLLOC_DEFAULT ((*yylocp), (yyvsp - yyrhslen), yyrhslen); ]b4_location_if([[ yystackp->yyerror_range[1].yystate.yyloc = *yylocp; ]])[ switch (yyn) @@ -980,7 +979,10 @@ yydestroyGLRState (char const *yymsg, yyGLRState *yys]b4_user_formals[) #if YYDEBUG if (yydebug) { - YYFPRINTF (stderr, "%s unresolved ", yymsg); + if (yys->yysemantics.yyfirstVal) + YYFPRINTF (stderr, "%s unresolved ", yymsg); + else + YYFPRINTF (stderr, "%s incomplete ", yymsg); yy_symbol_print (stderr, yystos[yys->yylrState], NULL]b4_location_if([, &yys->yyloc])[]b4_user_args[); YYFPRINTF (stderr, "\n"); @@ -1191,7 +1193,7 @@ yyexpandGLRStack (yyGLRStack* yystackp) size_t yysize, yynewSize; size_t yyn; yysize = yystackp->yynextFree - yystackp->yyitems; - if (YYMAXDEPTH <= yysize) + if (YYMAXDEPTH - YYHEADROOM < yysize) yyMemoryExhausted (yystackp); yynewSize = 2*yysize; if (YYMAXDEPTH < yynewSize) @@ -1667,9 +1669,14 @@ yypreference (yySemanticOption* y0, yySemanticOption* y1) } static YYRESULTTAG yyresolveValue (yyGLRState* yys, - yyGLRStack* yystackp, YYSTYPE* yyvalp, - YYLTYPE* yylocp]b4_user_formals[); + yyGLRStack* yystackp]b4_user_formals[); + +/** Resolve the previous N states starting at and including state S. If result + * != yyok, some states may have been left unresolved possibly with empty + * semantic option chains. Regardless of whether result = yyok, each state + * has been left with consistent data so that yydestroyGLRState can be invoked + * if necessary. */ static YYRESULTTAG yyresolveStates (yyGLRState* yys, int yyn, yyGLRStack* yystackp]b4_user_formals[) @@ -1679,22 +1686,15 @@ yyresolveStates (yyGLRState* yys, int yyn, YYASSERT (yys->yypred); YYCHK (yyresolveStates (yys->yypred, yyn-1, yystackp]b4_user_args[)); if (! yys->yyresolved) - { - YYSTYPE yysval; - YYRESULTTAG yyflag = yyresolveValue (yys, yystackp, &yysval, - &yys->yyloc]b4_user_args[); - if (yyflag != yyok) - { - yys->yysemantics.yyfirstVal = NULL; - return yyflag; - } - yys->yysemantics.yysval = yysval; - yys->yyresolved = yytrue; - } + YYCHK (yyresolveValue (yys, yystackp]b4_user_args[)); } return yyok; } +/** Resolve the states for the RHS of OPT, perform its user action, and return + * the semantic value and location. Regardless of whether result = yyok, all + * RHS states have been destroyed (assuming the user action destroys all RHS + * semantic values if invoked). */ static YYRESULTTAG yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystackp, YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[) @@ -1704,10 +1704,18 @@ yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystackp, int yychar_current; YYSTYPE yylval_current; YYLTYPE yylloc_current; - YYRESULTTAG yyresult; + YYRESULTTAG yyflag; yynrhs = yyrhsLength (yyopt->yyrule); - YYCHK (yyresolveStates (yyopt->yystate, yynrhs, yystackp]b4_user_args[)); + yyflag = yyresolveStates (yyopt->yystate, yynrhs, yystackp]b4_user_args[); + if (yyflag != yyok) + { + yyGLRState *yys; + for (yys = yyopt->yystate; yynrhs > 0; yys = yys->yypred, yynrhs -= 1) + yydestroyGLRState ("Cleanup: popping", yys]b4_user_args[); + return yyflag; + } + yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred = yyopt->yystate;]b4_location_if([[ if (yynrhs == 0) /* Set default location. */ @@ -1718,13 +1726,13 @@ yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystackp, yychar = yyopt->yyrawchar; yylval = yyopt->yyval; yylloc = yyopt->yyloc; - yyresult = yyuserAction (yyopt->yyrule, yynrhs, + yyflag = yyuserAction (yyopt->yyrule, yynrhs, yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, yyvalp, yylocp, yystackp]b4_user_args[); yychar = yychar_current; yylval = yylval_current; yylloc = yylloc_current; - return yyresult; + return yyflag; } #if YYDEBUG @@ -1775,12 +1783,9 @@ yyreportTree (yySemanticOption* yyx, int yyindent) } #endif -static void yyreportAmbiguity (yySemanticOption* yyx0, yySemanticOption* yyx1, - yyGLRStack* yystackp]b4_pure_formals[) - __attribute__ ((__noreturn__)); -/*ARGSUSED*/ static void -yyreportAmbiguity (yySemanticOption* yyx0, yySemanticOption* yyx1, - yyGLRStack* yystackp]b4_pure_formals[) +/*ARGSUSED*/ static YYRESULTTAG +yyreportAmbiguity (yySemanticOption* yyx0, + yySemanticOption* yyx1]b4_pure_formals[) { YYUSE (yyx0); YYUSE (yyx1); @@ -1793,20 +1798,79 @@ yyreportAmbiguity (yySemanticOption* yyx0, yySemanticOption* yyx1, yyreportTree (yyx1, 2); YYFPRINTF (stderr, "\n"); #endif - yyFail (yystackp][]b4_pure_args[, YY_("syntax is ambiguous")); + + yyerror (]b4_yyerror_args[YY_("syntax is ambiguous")); + return yyabort; } +/** 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* yys1, int yyn1, + yyGLRStack *yystackp]b4_user_formals[) +{ + if (0 < yyn1) + { + yyresolveLocations (yys1->yypred, yyn1 - 1, yystackp]b4_user_args[); + if (!yys1->yyresolved) + { + yySemanticOption *yyoption; + yyGLRStackItem yyrhsloc[1 + YYMAXRHS]; + int yynrhs; + int yychar_current; + YYSTYPE yylval_current; + YYLTYPE yylloc_current; + yyoption = yys1->yysemantics.yyfirstVal; + YYASSERT (yyoption != NULL); + yynrhs = yyrhsLength (yyoption->yyrule); + if (yynrhs > 0) + { + yyGLRState *yys; + int yyn; + yyresolveLocations (yyoption->yystate, yynrhs, + yystackp]b4_user_args[); + for (yys = yyoption->yystate, yyn = yynrhs; + yyn > 0; + yys = yys->yypred, yyn -= 1) + yyrhsloc[yyn].yystate.yyloc = yys->yyloc; + } + else + { + yyGLRState *yyprevious = yyoption->yystate; + YYASSERT (yyprevious->yyresolved); + yyrhsloc[0].yystate.yyloc = yyprevious->yyloc; + } + yychar_current = yychar; + yylval_current = yylval; + yylloc_current = yylloc; + yychar = yyoption->yyrawchar; + yylval = yyoption->yyval; + yylloc = yyoption->yyloc; + YYLLOC_DEFAULT ((yys1->yyloc), yyrhsloc, yynrhs); + yychar = yychar_current; + yylval = yylval_current; + yylloc = yylloc_current; + } + } +} /** Resolve the ambiguity represented in state S, perform the indicated - * actions, and return the result. */ + * actions, and set the semantic value of S. If result != yyok, the chain of + * semantic options in S has been cleared instead or it has been left + * unmodified except that redundant options may have been removed. Regardless + * of whether result = yyok, S has been left with consistent data so that + * yydestroyGLRState can be invoked if necessary. */ static YYRESULTTAG -yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp, YYSTYPE* yyvalp, - YYLTYPE* yylocp]b4_user_formals[) +yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp]b4_user_formals[) { yySemanticOption* yyoptionList = yys->yysemantics.yyfirstVal; yySemanticOption* yybest; yySemanticOption** yypp; yybool yymerge; + YYSTYPE yysval; + YYRESULTTAG yyflag; + YYLTYPE *yylocp = &yys->yyloc; yybest = yyoptionList; yymerge = yyfalse; @@ -1824,7 +1888,8 @@ yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp, YYSTYPE* yyvalp, switch (yypreference (yybest, yyp)) { case 0: - yyreportAmbiguity (yybest, yyp, yystackp]b4_pure_args[); + yyresolveLocations (yys, 1, yystackp]b4_user_args[); + return yyreportAmbiguity (yybest, yyp]b4_pure_args[); break; case 1: yymerge = yytrue; @@ -1849,29 +1914,39 @@ yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp, YYSTYPE* yyvalp, { yySemanticOption* yyp; int yyprec = yydprec[yybest->yyrule]; - YYCHK (yyresolveAction (yybest, yystackp, yyvalp, yylocp]b4_user_args[)); - for (yyp = yybest->yynext; yyp != NULL; yyp = yyp->yynext) - { - if (yyprec == yydprec[yyp->yyrule]) - { - YYSTYPE yyval1; - YYLTYPE yydummy; - YYRESULTTAG yyflag = yyresolveAction (yyp, yystackp, &yyval1, - &yydummy]b4_user_args[); - if (yyflag != yyok) - { - yydestruct ("Cleanup: discarding merged value", - yystos[yys->yylrState], - yyvalp]b4_location_if([, yylocp])[]b4_user_args[); - return yyflag; - } - yyuserMerge (yymerger[yyp->yyrule], yyvalp, &yyval1); - } - } - return yyok; + yyflag = yyresolveAction (yybest, yystackp, &yysval, + yylocp]b4_user_args[); + if (yyflag == yyok) + for (yyp = yybest->yynext; yyp != NULL; yyp = yyp->yynext) + { + if (yyprec == yydprec[yyp->yyrule]) + { + YYSTYPE yysval_other; + YYLTYPE yydummy; + yyflag = yyresolveAction (yyp, yystackp, &yysval_other, + &yydummy]b4_user_args[); + if (yyflag != yyok) + { + yydestruct ("Cleanup: discarding incompletely merged value for", + yystos[yys->yylrState], + &yysval]b4_location_if([, yylocp])[]b4_user_args[); + break; + } + yyuserMerge (yymerger[yyp->yyrule], &yysval, &yysval_other); + } + } + } + else + yyflag = yyresolveAction (yybest, yystackp, &yysval, yylocp]b4_user_args[); + + if (yyflag == yyok) + { + yys->yyresolved = yytrue; + yys->yysemantics.yysval = yysval; } else - return yyresolveAction (yybest, yystackp, yyvalp, yylocp]b4_user_args[); + yys->yysemantics.yyfirstVal = NULL; + return yyflag; } static YYRESULTTAG @@ -1929,7 +2004,6 @@ yyprocessOneStack (yyGLRStack* yystackp, size_t yyk, int yyaction; const short int* yyconflicts; yyRuleNum yyrule; - yySymbol* const yytokenp = yystackp->yytokenp; while (yystackp->yytops.yystates[yyk] != NULL) { @@ -1953,15 +2027,18 @@ yyprocessOneStack (yyGLRStack* yystackp, size_t yyk, } else { + yySymbol yytoken; yystackp->yytops.yylookaheadNeeds[yyk] = yytrue; - if (*yytokenp == YYEMPTY) + if (yychar == YYEMPTY) { YYDPRINTF ((stderr, "Reading a token: ")); yychar = YYLEX; - *yytokenp = YYTRANSLATE (yychar); - YY_SYMBOL_PRINT ("Next token is", *yytokenp, &yylval, &yylloc); + yytoken = YYTRANSLATE (yychar); + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); } - yygetLRActions (yystate, *yytokenp, &yyaction, &yyconflicts); + else + yytoken = YYTRANSLATE (yychar); + yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts); while (*yyconflicts != 0) { @@ -1999,12 +2076,12 @@ yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[) if (yystackp->yyerrState == 0) { #if YYERROR_VERBOSE - yySymbol* const yytokenp = yystackp->yytokenp; int yyn; yyn = yypact[yystackp->yytops.yystates[0]->yylrState]; if (YYPACT_NINF < yyn && yyn < YYLAST) { - size_t yysize0 = yytnamerr (NULL, yytokenName (*yytokenp)); + yySymbol yytoken = YYTRANSLATE (yychar); + size_t yysize0 = yytnamerr (NULL, yytokenName (yytoken)); size_t yysize = yysize0; size_t yysize1; yybool yysize_overflow = yyfalse; @@ -2032,7 +2109,7 @@ yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[) int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; int yycount = 1; - yyarg[0] = yytokenName (*yytokenp); + yyarg[0] = yytokenName (yytoken); yyfmt = yystpcpy (yyformat, yyunexpected); for (yyx = yyxbegin; yyx < yyxend; ++yyx) @@ -2100,7 +2177,6 @@ yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[) /*ARGSUSED*/ static void yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[) { - yySymbol* const yytokenp = yystackp->yytokenp; size_t yyk; int yyj; @@ -2109,9 +2185,10 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[) reductions. Skip tokens until we can proceed. */ while (YYID (yytrue)) { - if (*yytokenp == YYEOF) + yySymbol yytoken; + if (yychar == YYEOF) yyFail (yystackp][]b4_lpure_args[, NULL); - if (*yytokenp != YYEMPTY) + if (yychar != YYEMPTY) {]b4_location_if([[ /* We throw away the lookahead, but the error range of the shifted error token must take it into account. */ @@ -2119,19 +2196,20 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[) yyGLRStackItem yyerror_range[3]; yyerror_range[1].yystate.yyloc = yys->yyloc; yyerror_range[2].yystate.yyloc = yylloc; - YYLLOC_DEFAULT (yys->yyloc, yyerror_range, 2);]])[ + YYLLOC_DEFAULT ((yys->yyloc), yyerror_range, 2);]])[ + yytoken = YYTRANSLATE (yychar); yydestruct ("Error: discarding", - *yytokenp, &yylval]b4_location_if([, &yylloc])[]b4_user_args[); + yytoken, &yylval]b4_location_if([, &yylloc])[]b4_user_args[); } YYDPRINTF ((stderr, "Reading a token: ")); yychar = YYLEX; - *yytokenp = YYTRANSLATE (yychar); - YY_SYMBOL_PRINT ("Next token is", *yytokenp, &yylval, &yylloc); + yytoken = YYTRANSLATE (yychar); + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); yyj = yypact[yystackp->yytops.yystates[0]->yylrState]; if (yyis_pact_ninf (yyj)) return; - yyj += *yytokenp; - if (yyj < 0 || YYLAST < yyj || yycheck[yyj] != *yytokenp) + yyj += yytoken; + if (yyj < 0 || YYLAST < yyj || yycheck[yyj] != yytoken) { if (yydefact[yystackp->yytops.yystates[0]->yylrState] != 0) return; @@ -2166,7 +2244,7 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[) /* Shift the error token having adjusted its location. */ YYLTYPE yyerrloc;]b4_location_if([[ yystackp->yyerror_range[2].yystate.yyloc = yylloc; - YYLLOC_DEFAULT (yyerrloc, yystackp->yyerror_range, 2);]])[ + YYLLOC_DEFAULT (yyerrloc, (yystackp->yyerror_range), 2);]])[ YY_SYMBOL_PRINT ("Shifting", yystos[yytable[yyj]], &yylval, &yyerrloc); yyglrShift (yystackp, 0, yytable[yyj], @@ -2209,7 +2287,6 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[) ]b4_c_ansi_function_def([yyparse], [int], b4_parse_param)[ { int yyresult; - yySymbol yytoken; yyGLRStack yystack; yyGLRStack* const yystackp = &yystack; size_t yyposn; @@ -2217,7 +2294,6 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[) YYDPRINTF ((stderr, "Starting parse\n")); yychar = YYEMPTY; - yytoken = YYEMPTY; yylval = yyval_default; ]b4_location_if([ #if YYLTYPE_IS_TRIVIAL @@ -2244,7 +2320,6 @@ b4_syncline([@oline@], [@ofile@])])dnl case 2: goto yyexhaustedlab; default: goto yybuglab; } - yystack.yytokenp = &yytoken; yyglrShift (&yystack, 0, 0, 0, &yylval, &yylloc); yyposn = 0; @@ -2277,24 +2352,24 @@ b4_syncline([@oline@], [@ofile@])])dnl } else { - if (yytoken == YYEMPTY) + yySymbol yytoken; + if (yychar == YYEMPTY) { YYDPRINTF ((stderr, "Reading a token: ")); yychar = YYLEX; yytoken = YYTRANSLATE (yychar); YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); } + else + yytoken = YYTRANSLATE (yychar); yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts); if (*yyconflicts != 0) break; if (yyisShiftAction (yyaction)) { YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); - if (yytoken != YYEOF) - { - yychar = YYEMPTY; - yytoken = YYEMPTY; - } + if (yychar != YYEOF) + yychar = YYEMPTY; yyposn += 1; yyglrShift (&yystack, 0, yyaction, yyposn, &yylval, &yylloc); if (0 < yystack.yyerrState) @@ -2315,9 +2390,8 @@ b4_syncline([@oline@], [@ofile@])])dnl { yySymbol yytoken_to_shift; size_t yys; - size_t yyn = yystack.yytops.yysize; - for (yys = 0; yys < yyn; yys += 1) + for (yys = 0; yys < yystack.yytops.yysize; yys += 1) yystackp->yytops.yylookaheadNeeds[yys] = yychar != YYEMPTY; /* yyprocessOneStack returns one of three things: @@ -2336,24 +2410,33 @@ b4_syncline([@oline@], [@ofile@])])dnl Except in the first case, yyparse will invoke yyremoveDeletes and then shift the next token onto all remaining stacks. This synchronization of the shift (that is, after all preceding - reductions on all stacks) helps prevents double destructor calls + reductions on all stacks) helps prevent double destructor calls on yylval in the event of memory exhaustion. */ - for (yys = 0; yys < yyn; yys += 1) + for (yys = 0; yys < yystack.yytops.yysize; yys += 1) YYCHK1 (yyprocessOneStack (&yystack, yys, yyposn]b4_lpure_args[)); yyremoveDeletes (&yystack); - yyn = yystack.yytops.yysize; + if (yystack.yytops.yysize == 0) + { + yyundeleteLastStack (&yystack); + if (yystack.yytops.yysize == 0) + 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;]])[ + yyreportSyntaxError (&yystack]b4_user_args[); + goto yyuser_error; + } /* If any yyglrShift call fails, it will fail after shifting. Thus, a copy of yylval will already be on stack 0 in the event of a - failure in the following loop. Thus, yytoken is set to YYEMPTY + failure in the following loop. Thus, yychar is set to YYEMPTY before the loop to make sure the user destructor for yylval isn't called twice. */ - yytoken_to_shift = yytoken; + yytoken_to_shift = YYTRANSLATE (yychar); yychar = YYEMPTY; - yytoken = YYEMPTY; yyposn += 1; - for (yys = 0; yys < yyn; yys += 1) + for (yys = 0; yys < yystack.yytops.yysize; yys += 1) { int yyaction; const short int* yyconflicts; @@ -2369,18 +2452,8 @@ b4_syncline([@oline@], [@ofile@])])dnl (unsigned long int) yys, yystack.yytops.yystates[yys]->yylrState)); } - if (yystack.yytops.yysize == 0) - { - yyundeleteLastStack (&yystack); - if (yystack.yytops.yysize == 0) - 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;]])[ - yyreportSyntaxError (&yystack]b4_user_args[); - goto yyuser_error; - } - else if (yystack.yytops.yysize == 1) + + if (yystack.yytops.yysize == 1) { YYCHK1 (yyresolveStack (&yystack]b4_user_args[)); YYDPRINTF ((stderr, "Returning to deterministic operation.\n")); @@ -2412,9 +2485,10 @@ b4_syncline([@oline@], [@ofile@])])dnl goto yyreturn; yyreturn: - if (yytoken != YYEOF && yytoken != YYEMPTY) + if (yychar != YYEOF && yychar != YYEMPTY) yydestruct ("Cleanup: discarding lookahead", - yytoken, &yylval]b4_location_if([, &yylloc])[]b4_user_args[); + YYTRANSLATE (yychar), + &yylval]b4_location_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