X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/30757c8c9355d76b2875757261c1d78e630690f4..b50d2359d7608270561abd5c3cbf6e84834c2019:/data/glr.c diff --git a/data/glr.c b/data/glr.c index c6fe4c3d..0f466131 100644 --- a/data/glr.c +++ b/data/glr.c @@ -154,7 +154,7 @@ m4_if(b4_prefix[], [yy], [], #define yynerrs b4_prefix[]nerrs #define yylloc b4_prefix[]lloc]) -b4_token_defines(b4_tokens) +b4_token_enums(b4_tokens) /* Copy the first part of user declarations. */ b4_pre_prologue[ @@ -172,9 +172,14 @@ b4_pre_prologue[ # define YYERROR_VERBOSE ]b4_error_verbose[ #endif +/* Enabling the token table. */ +#ifndef YYTOKEN_TABLE +# define YYTOKEN_TABLE ]b4_token_table[ +#endif + #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) ]m4_ifdef([b4_stype], -[b4_syncline([b4_stype_line], [b4_filename]) +[b4_syncline([b4_stype_line], [b4_file_name]) typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])b4_stype YYSTYPE; /* Line __line__ of glr.c. */ b4_syncline([@oline@], [@ofile@])], @@ -216,7 +221,6 @@ b4_syncline([@oline@], [@ofile@]) #include #include #include -#include #ifndef YY_ # if YYENABLE_NLS @@ -250,33 +254,36 @@ b4_syncline([@oline@], [@ofile@]) #define yytrue 1 #define yyfalse 0 +#ifndef YYSETJMP +# include +# define YYJMP_BUF jmp_buf +# define YYSETJMP(env) setjmp (env) +# define YYLONGJMP(env, val) longjmp (env, val) +#endif + /*-----------------. | GCC extensions. | `-----------------*/ #ifndef __attribute__ /* This feature is available in gcc versions 2.5 and later. */ -# if !defined (__GNUC__) || __GNUC__ < 2 || \ -(__GNUC__ == 2 && __GNUC_MINOR__ < 5) || __STRICT_ANSI__ +# if (!defined (__GNUC__) || __GNUC__ < 2 \ + || (__GNUC__ == 2 && __GNUC_MINOR__ < 5) || __STRICT_ANSI__) # define __attribute__(Spec) /* empty */ -# else -]b4_location_if([# define YYOPTIONAL_LOC(Name) Name],[ -# if defined (__cplusplus) -# define YYOPTIONAL_LOC(Name) /* empty */ -# else -# define YYOPTIONAL_LOC(Name) Name ATTRIBUTE_UNUSED -# endif])[ # endif #endif +]b4_location_if([#define YYOPTIONAL_LOC(Name) Name],[ +#ifdef __cplusplus +# define YYOPTIONAL_LOC(Name) /* empty */ +#else +# define YYOPTIONAL_LOC(Name) Name __attribute__ ((__unused__)) +#endif])[ + #ifndef YYASSERT # define YYASSERT(condition) ((void) ((condition) || (abort (), 0))) #endif -#ifndef ATTRIBUTE_UNUSED -# define ATTRIBUTE_UNUSED __attribute__ ((__unused__)) -#endif - /* YYFINAL -- State number of the termination state. */ #define YYFINAL ]b4_final_state_number[ /* YYLAST -- Last index in YYTABLE. */ @@ -331,8 +338,8 @@ static const ]b4_int_type_for([b4_rline])[ yyrline[] = }; #endif -#if (YYDEBUG) || YYERROR_VERBOSE -/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. +#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE +/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. First, the terminals, then, starting at YYNTOKENS, nonterminals. */ static const char *const yytname[] = { @@ -531,6 +538,7 @@ do { \ YYFPRINTF (stderr, "%s ", Title); \ yysymprint (stderr, \ Type, Value]b4_location_if([, Location])[); \ + YYFPRINTF (stderr, "\n"); \ } \ } while (0) @@ -600,6 +608,54 @@ yystpcpy (char *yydest, const char *yysrc) # endif # endif +# ifndef yytnamerr +/* Copy to YYRES the contents of YYSTR after stripping away unnecessary + quotes and backslashes, so that it's suitable for yyerror. The + heuristic is that double-quoting is unnecessary unless the string + contains an apostrophe, a comma, or backslash (other than + backslash-backslash). YYSTR is taken from yytname. If YYRES is + null, do not copy; instead, return the length of what the result + would have been. */ +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 + #endif /* !YYERROR_VERBOSE */ /** State numbers, as in LALR(1) machine */ @@ -678,7 +734,7 @@ struct yyGLRStack { int yyrawchar; ])[ yySymbol* yytokenp; - jmp_buf yyexception_buffer; + YYJMP_BUF yyexception_buffer; yyGLRStackItem* yyitems; yyGLRStackItem* yynextFree; size_t yyspaceLeft; @@ -687,20 +743,24 @@ struct yyGLRStack { yyGLRStateSet yytops; }; -static void yyexpandGLRStack (yyGLRStack* yystack]b4_pure_formals[); +static void yyexpandGLRStack (yyGLRStack* yystack); +static void yyFail (yyGLRStack* yystack]b4_pure_formals[, const char* yymsg) + __attribute__ ((__noreturn__)); static void yyFail (yyGLRStack* yystack]b4_pure_formals[, const char* yymsg) { if (yymsg != NULL) yyerror (]b4_yyerror_args[yymsg); - longjmp (yystack->yyexception_buffer, 1); + YYLONGJMP (yystack->yyexception_buffer, 1); } +static void yyMemoryExhausted (yyGLRStack* yystack) + __attribute__ ((__noreturn__)); static void -yyStackOverflow (yyGLRStack* yystack]b4_pure_formals[) +yyMemoryExhausted (yyGLRStack* yystack) { - longjmp (yystack->yyexception_buffer, 2); + YYLONGJMP (yystack->yyexception_buffer, 2); } #if YYDEBUG || YYERROR_VERBOSE @@ -719,7 +779,7 @@ yytokenName (yySymbol yytoken) * at YYVSP[YYLOW0].yystate.yypred. Leaves YYVSP[YYLOW1].yystate.yypred * containing the pointer to the next state in the chain. Assumes * YYLOW1 < YYLOW0. */ -static void yyfillin (yyGLRStackItem *, int, int) ATTRIBUTE_UNUSED; +static void yyfillin (yyGLRStackItem *, int, int) __attribute__ ((__unused__)); static void yyfillin (yyGLRStackItem *yyvsp, int yylow0, int yylow1) { @@ -740,7 +800,7 @@ yyfillin (yyGLRStackItem *yyvsp, int yylow0, int yylow1) YYVSP[YYLOW1 .. *YYLOW-1] as in yyfillin and set *YYLOW = YYLOW1. For convenience, always return YYLOW1. */ static inline int yyfill (yyGLRStackItem *, int *, int, yybool) - ATTRIBUTE_UNUSED; + __attribute__ ((__unused__)); static inline int yyfill (yyGLRStackItem *yyvsp, int *yylow, int yylow1, yybool yynormal) { @@ -764,7 +824,8 @@ yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp, yyGLRStack* yystack ]b4_user_formals[) { - yybool yynormal ATTRIBUTE_UNUSED = (yystack->yysplitPoint == NULL); + yybool yynormal __attribute__ ((__unused__)) = + (yystack->yysplitPoint == NULL); int yylow; # undef yyerrok @@ -831,13 +892,44 @@ yyuserMerge (int yyn, YYSTYPE* yy0, YYSTYPE* yy1) ]b4_yydestruct_generate([b4_c_ansi_function_def])[ -/** Number of symbols composing the right hand side of rule #RULE. */ +/** Number of symbols composing the right hand side of rule #RULE. */ static inline int yyrhsLength (yyRuleNum yyrule) { return yyr2[yyrule]; } +static void +yydestroyGLRState (char const *yymsg, yyGLRState *yys) +{ + if (yys->yyresolved) + yydestruct (yymsg, yystos[yys->yylrState], + &yys->yysemantics.yysval]b4_location_if([, &yys->yyloc])[); + else + { +#if YYDEBUG + if (yydebug) + { + YYFPRINTF (stderr, "%s unresolved ", yymsg); + yysymprint (stderr, yystos[yys->yylrState], + &yys->yysemantics.yysval]b4_location_if([, &yys->yyloc])[); + YYFPRINTF (stderr, "\n"); + } +#endif + + if (yys->yysemantics.yyfirstVal) + { + yySemanticOption *yyoption = yys->yysemantics.yyfirstVal; + yyGLRState *yyrh; + int yyn; + for (yyrh = yyoption->yystate, yyn = yyrhsLength (yyoption->yyrule); + yyn > 0; + yyrh = yyrh->yypred, yyn -= 1) + yydestroyGLRState (yymsg, yyrh); + } + } +} + /** Left-hand-side symbol for rule #RULE. */ static inline yySymbol yylhsNonterm (yyRuleNum yyrule) @@ -927,7 +1019,7 @@ yyisErrorAction (int yyaction) static void yyaddDeferredAction (yyGLRStack* yystack, yyGLRState* yystate, - yyGLRState* rhs, yyRuleNum yyrule]b4_pure_formals[) + yyGLRState* rhs, yyRuleNum yyrule) { yySemanticOption* yynewItem; yynewItem = &yystack->yynextFree->yyoption; @@ -939,7 +1031,7 @@ yyaddDeferredAction (yyGLRStack* yystack, yyGLRState* yystate, yynewItem->yynext = yystate->yysemantics.yyfirstVal; yystate->yysemantics.yyfirstVal = yynewItem; if (yystack->yyspaceLeft < YYHEADROOM) - yyexpandGLRStack (yystack]b4_pure_args[); + yyexpandGLRStack (yystack); } /* GLRStacks */ @@ -970,11 +1062,14 @@ yyinitGLRStack (yyGLRStack* yystack, size_t yysize) yystack->yyerrState = 0; yynerrs = 0; yystack->yyspaceLeft = yysize; - yystack->yynextFree = yystack->yyitems = + yystack->yyitems = (yyGLRStackItem*) YYMALLOC (yysize * sizeof yystack->yynextFree[0]); + if (!yystack->yyitems) + return yyfalse; + yystack->yynextFree = yystack->yyitems; yystack->yysplitPoint = NULL; yystack->yylastDeleted = NULL; - return yyinitStateSet (&yystack->yytops) && yystack->yyitems; + return yyinitStateSet (&yystack->yytops); } #define YYRELOC(YYFROMITEMS,YYTOITEMS,YYX,YYTYPE) \ @@ -986,7 +1081,7 @@ yyinitGLRStack (yyGLRStack* yystack, size_t yysize) allocation, so that we can avoid having external pointers exist across an allocation. */ static void -yyexpandGLRStack (yyGLRStack* yystack]b4_pure_formals[) +yyexpandGLRStack (yyGLRStack* yystack) { #if YYSTACKEXPANDABLE yyGLRStackItem* yynewItems; @@ -995,13 +1090,13 @@ yyexpandGLRStack (yyGLRStack* yystack]b4_pure_formals[) size_t yyn; yysize = yystack->yynextFree - yystack->yyitems; if (YYMAXDEPTH <= yysize) - yyStackOverflow (yystack]b4_pure_args[); + yyMemoryExhausted (yystack); yynewSize = 2*yysize; if (YYMAXDEPTH < yynewSize) yynewSize = YYMAXDEPTH; yynewItems = (yyGLRStackItem*) YYMALLOC (yynewSize * sizeof yynewItems[0]); if (! yynewItems) - yyStackOverflow (yystack]b4_pure_args[); + yyMemoryExhausted (yystack); for (yyp0 = yystack->yyitems, yyp1 = yynewItems, yyn = yysize; 0 < yyn; yyn -= 1, yyp0 += 1, yyp1 += 1) @@ -1043,8 +1138,7 @@ yyexpandGLRStack (yyGLRStack* yystack]b4_pure_formals[) yystack->yyspaceLeft = yynewSize - yysize; #else - - yyStackOverflow (yystack]b4_pure_args[); + yyMemoryExhausted (yystack); #endif } @@ -1122,7 +1216,7 @@ yyremoveDeletes (yyGLRStack* yystack) static inline void yyglrShift (yyGLRStack* yystack, size_t yyk, yyStateNum yylrState, size_t yyposn, - YYSTYPE yysval, YYLTYPE* yylocp]b4_user_formals[) + YYSTYPE yysval, YYLTYPE* yylocp) { yyGLRStackItem* yynewItem; @@ -1138,7 +1232,7 @@ yyglrShift (yyGLRStack* yystack, size_t yyk, yyStateNum yylrState, yynewItem->yystate.yysemantics.yysval = yysval; yynewItem->yystate.yyloc = *yylocp; if (yystack->yyspaceLeft < YYHEADROOM) - yyexpandGLRStack (yystack]b4_pure_args[); + yyexpandGLRStack (yystack); } /** Shift stack #K of YYSTACK, to a new state corresponding to LR @@ -1146,7 +1240,7 @@ yyglrShift (yyGLRStack* yystack, size_t yyk, yyStateNum yylrState, * semantic value of YYRHS under the action for YYRULE. */ static inline void yyglrShiftDefer (yyGLRStack* yystack, size_t yyk, yyStateNum yylrState, - size_t yyposn, yyGLRState* rhs, yyRuleNum yyrule]b4_pure_formals[) + size_t yyposn, yyGLRState* rhs, yyRuleNum yyrule) { yyGLRStackItem* yynewItem; @@ -1160,7 +1254,7 @@ yyglrShiftDefer (yyGLRStack* yystack, size_t yyk, yyStateNum yylrState, yystack->yytops.yystates[yyk] = &yynewItem->yystate; yystack->yynextFree += 1; yystack->yyspaceLeft -= 1; - yyaddDeferredAction (yystack, &yynewItem->yystate, rhs, yyrule]b4_pure_args[); + yyaddDeferredAction (yystack, &yynewItem->yystate, rhs, yyrule); } /** Pop the symbols consumed by reduction #RULE from the top of stack @@ -1245,7 +1339,7 @@ yy_reduce_print (size_t yyk, yyRuleNum yyrule) */ static inline YYRESULTTAG yyglrReduce (yyGLRStack* yystack, size_t yyk, yyRuleNum yyrule, - yybool yyforceEval]b4_pure_formals[) + yybool yyforceEval]b4_user_formals[) { size_t yyposn = yystack->yytops.yystates[yyk]->yyposn; @@ -1259,7 +1353,7 @@ yyglrReduce (yyGLRStack* yystack, size_t yyk, yyRuleNum yyrule, yyglrShift (yystack, yyk, yyLRgotoState (yystack->yytops.yystates[yyk]->yylrState, yylhsNonterm (yyrule)), - yyposn, yysval, &yyloc]b4_user_args[); + yyposn, yysval, &yyloc); } else { @@ -1288,7 +1382,7 @@ yyglrReduce (yyGLRStack* yystack, size_t yyk, yyRuleNum yyrule, { if (yyp->yylrState == yynewLRState && yyp->yypred == yys) { - yyaddDeferredAction (yystack, yyp, yys0, yyrule]b4_pure_args[); + yyaddDeferredAction (yystack, yyp, yys0, yyrule); yymarkStackDeleted (yystack, yyk); YYDPRINTF ((stderr, "Merging stack %lu into stack %lu.\n", (unsigned long int) yyk, @@ -1299,13 +1393,13 @@ yyglrReduce (yyGLRStack* yystack, size_t yyk, yyRuleNum yyrule, } } yystack->yytops.yystates[yyk] = yys; - yyglrShiftDefer (yystack, yyk, yynewLRState, yyposn, yys0, yyrule]b4_pure_args[); + yyglrShiftDefer (yystack, yyk, yynewLRState, yyposn, yys0, yyrule); } return yyok; } static size_t -yysplitStack (yyGLRStack* yystack, size_t yyk]b4_pure_formals[) +yysplitStack (yyGLRStack* yystack, size_t yyk) { if (yystack->yysplitPoint == NULL) { @@ -1321,7 +1415,7 @@ yysplitStack (yyGLRStack* yystack, size_t yyk]b4_pure_formals[) (yyGLRState**) YYREALLOC (yystack->yytops.yystates, ((yystack->yytops.yycapacity *= 2) * sizeof yynewStates[0]))))) - yyStackOverflow (yystack]b4_pure_args[); + yyMemoryExhausted (yystack); yystack->yytops.yystates = yynewStates; } yystack->yytops.yystates[yystack->yytops.yysize] @@ -1520,6 +1614,9 @@ yyreportTree (yySemanticOption* yyx, int yyindent) } #endif +static void yyreportAmbiguity (yySemanticOption* yyx0, yySemanticOption* yyx1, + yyGLRStack* yystack]b4_pure_formals[) + __attribute__ ((__noreturn__)); static void yyreportAmbiguity (yySemanticOption* yyx0, yySemanticOption* yyx1, yyGLRStack* yystack]b4_pure_formals[) @@ -1536,7 +1633,7 @@ yyreportAmbiguity (yySemanticOption* yyx0, yySemanticOption* yyx1, yyreportTree (yyx1, 2); YYFPRINTF (stderr, "\n"); #endif - yyFail (yystack][]b4_pure_args[, YY_("ambiguity detected")); + yyFail (yystack][]b4_pure_args[, YY_("syntax is ambiguous")); } @@ -1547,35 +1644,49 @@ yyresolveValue (yySemanticOption* yyoptionList, yyGLRStack* yystack, YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[) { yySemanticOption* yybest; - yySemanticOption* yyp; + yySemanticOption** yypp; yybool yymerge; yybest = yyoptionList; yymerge = yyfalse; - for (yyp = yyoptionList->yynext; yyp != NULL; yyp = yyp->yynext) + for (yypp = &yyoptionList->yynext; *yypp != NULL; ) { + yySemanticOption* yyp = *yypp; + if (yyidenticalOptions (yybest, yyp)) - yymergeOptionSets (yybest, yyp); + { + yymergeOptionSets (yybest, yyp); + *yypp = yyp->yynext; + } else - switch (yypreference (yybest, yyp)) - { - case 0: - yyreportAmbiguity (yybest, yyp, yystack]b4_pure_args[); - break; - case 1: - yymerge = yytrue; - break; - case 2: - break; - case 3: - yybest = yyp; - yymerge = yyfalse; - break; - } + { + switch (yypreference (yybest, yyp)) + { + case 0: + yyreportAmbiguity (yybest, yyp, yystack]b4_pure_args[); + break; + case 1: + yymerge = yytrue; + break; + case 2: + break; + case 3: + yybest = yyp; + yymerge = yyfalse; + break; + default: + /* This cannot happen so it is not worth a YYASSERT (yyfalse), + but some compilers complain if the default case is + omitted. */ + break; + } + yypp = &yyp->yynext; + } } if (yymerge) { + yySemanticOption* yyp; int yyprec = yydprec[yybest->yyrule]; YYCHK (yyresolveAction (yybest, yystack, yyvalp, yylocp]b4_user_args[)); for (yyp = yybest->yynext; yyp != NULL; yyp = yyp->yynext) @@ -1670,7 +1781,7 @@ yyprocessOneStack (yyGLRStack* yystack, size_t yyk, yymarkStackDeleted (yystack, yyk); return yyok; } - YYCHK (yyglrReduce (yystack, yyk, yyrule, yyfalse]b4_lpure_args[)); + YYCHK (yyglrReduce (yystack, yyk, yyrule, yyfalse]b4_user_args[)); } else { @@ -1680,18 +1791,17 @@ yyprocessOneStack (yyGLRStack* yystack, size_t yyk, yychar = YYLEX; *yytokenp = YYTRANSLATE (yychar); YY_SYMBOL_PRINT ("Next token is", *yytokenp, yylvalp, yyllocp); - YYDPRINTF ((stderr, "\n")); } yygetLRActions (yystate, *yytokenp, &yyaction, &yyconflicts); while (*yyconflicts != 0) { - size_t yynewStack = yysplitStack (yystack, yyk]b4_pure_args[); + size_t yynewStack = yysplitStack (yystack, yyk); YYDPRINTF ((stderr, "Splitting off stack %lu from %lu.\n", (unsigned long int) yynewStack, (unsigned long int) yyk)); YYCHK (yyglrReduce (yystack, yynewStack, - *yyconflicts, yyfalse]b4_lpure_args[)); + *yyconflicts, yyfalse]b4_user_args[)); YYCHK (yyprocessOneStack (yystack, yynewStack, yyposn, yylvalp, yyllocp]b4_pure_args[)); yyconflicts += 1; @@ -1702,8 +1812,9 @@ yyprocessOneStack (yyGLRStack* yystack, size_t yyk, YYDPRINTF ((stderr, "On stack %lu, ", (unsigned long int) yyk)); YY_SYMBOL_PRINT ("shifting", *yytokenp, yylvalp, yyllocp); yyglrShift (yystack, yyk, yyaction, yyposn+1, - *yylvalp, yyllocp]b4_user_args[); - YYDPRINTF ((stderr, ", now in state #%d\n", + *yylvalp, yyllocp); + YYDPRINTF ((stderr, "Stack %lu now in state #%d\n", + (unsigned long int) yyk, yystack->yytops.yystates[yyk]->yylrState)); break; } @@ -1715,7 +1826,7 @@ yyprocessOneStack (yyGLRStack* yystack, size_t yyk, break; } else - YYCHK (yyglrReduce (yystack, yyk, -yyaction, yyfalse]b4_lpure_args[)); + YYCHK (yyglrReduce (yystack, yyk, -yyaction, yyfalse]b4_user_args[)); } } return yyok; @@ -1737,7 +1848,7 @@ yyreportSyntaxError (yyGLRStack* yystack, yyn = yypact[yystack->yytops.yystates[0]->yylrState]; if (YYPACT_NINF < yyn && yyn < YYLAST) { - size_t yysize0 = strlen (yytokenName (*yytokenp)); + size_t yysize0 = yytnamerr (NULL, yytokenName (*yytokenp)); size_t yysize = yysize0; size_t yysize1; yybool yysize_overflow = yyfalse; @@ -1779,7 +1890,7 @@ yyreportSyntaxError (yyGLRStack* yystack, break; } yyarg[yycount++] = yytokenName (yyx); - yysize1 = yysize + strlen (yytokenName (yyx)); + yysize1 = yysize + yytnamerr (NULL, yytokenName (yyx)); yysize_overflow |= yysize1 < yysize; yysize = yysize1; yyfmt = yystpcpy (yyfmt, yyprefix); @@ -1802,7 +1913,7 @@ yyreportSyntaxError (yyGLRStack* yystack, { if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) { - yyp = yystpcpy (yyp, yyarg[yyi++]); + yyp += yytnamerr (yyp, yyarg[yyi++]); yyf += 2; } else @@ -1815,7 +1926,10 @@ yyreportSyntaxError (yyGLRStack* yystack, YYFREE (yymsg); } else - yyerror (]b4_lyyerror_args[YY_("syntax error; also memory exhausted")); + { + yyerror (]b4_lyyerror_args[YY_("syntax error")); + yyMemoryExhausted (yystack); + } } else #endif /* YYERROR_VERBOSE */ @@ -1843,21 +1957,7 @@ yyrecoverSyntaxError (yyGLRStack* yystack, while (yytrue) { if (*yytokenp == YYEOF) - { - /* Now pop stack until empty and fail. */ - while (yystack->yytops.yystates[0] != NULL) - { - yyGLRState *yys = yystack->yytops.yystates[0]; -]b4_location_if([[ yystack->yyerror_range[1].yystate.yyloc = yys->yyloc;]])[ - yydestruct ("Error: popping", - yystos[yys->yylrState], - &yys->yysemantics.yysval]b4_location_if([, &yys->yyloc])[); - yystack->yytops.yystates[0] = yys->yypred; - yystack->yynextFree -= 1; - yystack->yyspaceLeft += 1; - } - yyFail (yystack][]b4_lpure_args[, NULL); - } + yyFail (yystack][]b4_lpure_args[, NULL); if (*yytokenp != YYEMPTY) {]b4_location_if([[ /* We throw away the lookahead, but the error range @@ -1874,7 +1974,6 @@ yyrecoverSyntaxError (yyGLRStack* yystack, yychar = YYLEX; *yytokenp = YYTRANSLATE (yychar); YY_SYMBOL_PRINT ("Next token is", *yytokenp, yylvalp, yyllocp); - YYDPRINTF ((stderr, "\n")); yyj = yypact[yystack->yytops.yystates[0]->yylrState]; if (yyis_pact_ninf (yyj)) return; @@ -1917,17 +2016,14 @@ yyrecoverSyntaxError (yyGLRStack* yystack, YYLLOC_DEFAULT (yyerrloc, yystack->yyerror_range, 2);]])[ YY_SYMBOL_PRINT ("Shifting", yystos[yytable[yyj]], yylvalp, &yyerrloc); - YYDPRINTF ((stderr, "\n")); yyglrShift (yystack, 0, yytable[yyj], - yys->yyposn, *yylvalp, &yyerrloc]b4_user_args[); + yys->yyposn, *yylvalp, &yyerrloc); yys = yystack->yytops.yystates[0]; break; } } ]b4_location_if([[ yystack->yyerror_range[1].yystate.yyloc = yys->yyloc;]])[ - yydestruct ("Error: popping", - yystos[yys->yylrState], - &yys->yysemantics.yysval]b4_location_if([, &yys->yyloc])[); + yydestroyGLRState ("Error: popping", yys); yystack->yytops.yystates[0] = yys->yypred; yystack->yynextFree -= 1; yystack->yyspaceLeft += 1; @@ -1939,7 +2035,7 @@ yyrecoverSyntaxError (yyGLRStack* yystack, #define YYCHK1(YYE) \ do { \ switch (YYE) { \ - default: \ + case yyok: \ break; \ case yyabort: \ goto yyabortlab; \ @@ -1947,6 +2043,8 @@ yyrecoverSyntaxError (yyGLRStack* yystack, goto yyacceptlab; \ case yyerr: \ goto yyuser_error; \ + default: \ + goto yybuglab; \ } \ } while (0) @@ -1993,14 +2091,16 @@ m4_popdef([b4_at_dollar])dnl b4_syncline([@oline@], [@ofile@])])dnl [ if (! yyinitGLRStack (&yystack, YYINITDEPTH)) - goto yyoverflowlab; - switch (setjmp (yystack.yyexception_buffer)) + goto yyexhaustedlab; + switch (YYSETJMP (yystack.yyexception_buffer)) { + case 0: break; case 1: goto yyabortlab; - case 2: goto yyoverflowlab; + case 2: goto yyexhaustedlab; + default: goto yybuglab; } yystack.yytokenp = &yytoken; - yyglrShift (&yystack, 0, 0, 0, yylval, &yylloc]b4_user_args[); + yyglrShift (&yystack, 0, 0, 0, yylval, &yylloc); yyposn = 0; while (yytrue) @@ -2028,7 +2128,7 @@ b4_syncline([@oline@], [@ofile@])])dnl yyreportSyntaxError (&yystack, yylvalp, yyllocp]b4_user_args[); goto yyuser_error; } - YYCHK1 (yyglrReduce (&yystack, 0, yyrule, yytrue]b4_lpure_args[)); + YYCHK1 (yyglrReduce (&yystack, 0, yyrule, yytrue]b4_user_args[)); } else { @@ -2038,7 +2138,6 @@ b4_syncline([@oline@], [@ofile@])])dnl yychar = YYLEX; yytoken = YYTRANSLATE (yychar); YY_SYMBOL_PRINT ("Next token is", yytoken, yylvalp, yyllocp); - YYDPRINTF ((stderr, "\n")); } yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts); if (*yyconflicts != 0) @@ -2046,12 +2145,10 @@ b4_syncline([@oline@], [@ofile@])])dnl if (yyisShiftAction (yyaction)) { YY_SYMBOL_PRINT ("Shifting", yytoken, yylvalp, yyllocp); - YYDPRINTF ((stderr, "\n")); if (yytoken != YYEOF) yytoken = YYEMPTY; yyposn += 1; - yyglrShift (&yystack, 0, yyaction, yyposn, - yylval, yyllocp]b4_user_args[); + yyglrShift (&yystack, 0, yyaction, yyposn, yylval, yyllocp); if (0 < yystack.yyerrState) yystack.yyerrState -= 1; } @@ -2062,7 +2159,7 @@ b4_syncline([@oline@], [@ofile@])])dnl goto yyuser_error; } else - YYCHK1 (yyglrReduce (&yystack, 0, -yyaction, yytrue]b4_lpure_args[)); + YYCHK1 (yyglrReduce (&yystack, 0, -yyaction, yytrue]b4_user_args[)); } } @@ -2105,28 +2202,51 @@ b4_syncline([@oline@], [@ofile@])])dnl yyresult = 0; goto yyreturn; + yybuglab: + YYASSERT (yyfalse); + /* Fall through. */ + yyabortlab: yyresult = 1; goto yyreturn; - yyoverflowlab: - yyerror (]b4_lyyerror_args[YY_("parser stack overflow")); + yyexhaustedlab: + yyerror (]b4_lyyerror_args[YY_("memory exhausted")); yyresult = 2; /* Fall through. */ yyreturn: if (yytoken != YYEOF && yytoken != YYEMPTY) - yydestruct ("Error: discarding lookahead", + yydestruct ("Cleanup: discarding lookahead", yytoken, yylvalp]b4_location_if([, yyllocp])[); - yyfreeGLRStack (&yystack); + /* If the stack is well-formed, pop the stack until it is empty, + destroying its entries as we go. But free the stack regardless + of whether it is well-formed. */ + if (yystack.yyitems) + { + yyGLRState** yystates = yystack.yytops.yystates; + if (yystates) + while (yystates[0]) + { + yyGLRState *yys = yystates[0]; +]b4_location_if([[ yystack.yyerror_range[1].yystate.yyloc = yys->yyloc;]] +)[ yydestroyGLRState ("Cleanup: popping", yys); + yystates[0] = yys->yypred; + yystack.yynextFree -= 1; + yystack.yyspaceLeft += 1; + } + yyfreeGLRStack (&yystack); + } + return yyresult; } /* DEBUGGING ONLY */ #ifdef YYDEBUG -static void yypstack (yyGLRStack* yystack, size_t yyk) ATTRIBUTE_UNUSED; -static void yypdumpstack (yyGLRStack* yystack) ATTRIBUTE_UNUSED; +static void yypstack (yyGLRStack* yystack, size_t yyk) + __attribute__ ((__unused__)); +static void yypdumpstack (yyGLRStack* yystack) __attribute__ ((__unused__)); static void yy_yypstack (yyGLRState* yys) @@ -2201,11 +2321,11 @@ m4_if(b4_defines_flag, 0, [], b4_copyright([Skeleton parser for GLR parsing with Bison], [2002, 2003, 2004, 2005]) -b4_token_defines(b4_tokens) +b4_token_enums(b4_tokens) #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) m4_ifdef([b4_stype], -[b4_syncline([b4_stype_line], [b4_filename]) +[b4_syncline([b4_stype_line], [b4_file_name]) typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])b4_stype YYSTYPE; /* Line __line__ of glr.c. */ b4_syncline([@oline@], [@ofile@])],