X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/1a05945136faf21ac5e3a07cfcdee8ee2e8ab6ae..e0045d49b691d5ead26f5cd411007844fb4a3d9b:/data/glr.c diff --git a/data/glr.c b/data/glr.c index a137bbf7..3ce4703d 100644 --- a/data/glr.c +++ b/data/glr.c @@ -172,6 +172,11 @@ 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]) @@ -264,7 +269,7 @@ b4_syncline([@oline@], [@ofile@]) # if defined (__cplusplus) # define YYOPTIONAL_LOC(Name) /* empty */ # else -# define YYOPTIONAL_LOC(Name) Name ATTRIBUTE_UNUSED +# define YYOPTIONAL_LOC(Name) Name __attribute__ ((__unused__)) # endif])[ # endif #endif @@ -273,10 +278,6 @@ b4_syncline([@oline@], [@ofile@]) # 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 +332,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[] = { @@ -600,6 +601,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 */ @@ -687,8 +736,10 @@ 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) { @@ -697,6 +748,8 @@ yyFail (yyGLRStack* yystack]b4_pure_formals[, const char* yymsg) longjmp (yystack->yyexception_buffer, 1); } +static void yyMemoryExhausted (yyGLRStack* yystack) + __attribute__ ((__noreturn__)); static void yyMemoryExhausted (yyGLRStack* yystack) { @@ -719,7 +772,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 +793,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 +817,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 @@ -927,7 +981,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 +993,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 +1024,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 +1043,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; @@ -1043,7 +1100,6 @@ yyexpandGLRStack (yyGLRStack* yystack]b4_pure_formals[) yystack->yyspaceLeft = yynewSize - yysize; #else - yyMemoryExhausted (yystack); #endif } @@ -1122,7 +1178,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 +1194,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 +1202,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 +1216,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 +1301,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 +1315,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 +1344,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 +1355,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) { @@ -1520,6 +1576,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[) @@ -1670,7 +1729,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 { @@ -1686,12 +1745,12 @@ yyprocessOneStack (yyGLRStack* yystack, size_t yyk, 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,7 +1761,7 @@ 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[); + *yylvalp, yyllocp); YYDPRINTF ((stderr, ", now in state #%d\n", yystack->yytops.yystates[yyk]->yylrState)); break; @@ -1715,7 +1774,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 +1796,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 +1838,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 +1861,7 @@ yyreportSyntaxError (yyGLRStack* yystack, { if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) { - yyp = yystpcpy (yyp, yyarg[yyi++]); + yyp += yytnamerr (yyp, yyarg[yyi++]); yyf += 2; } else @@ -1846,21 +1905,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 @@ -1922,7 +1967,7 @@ yyrecoverSyntaxError (yyGLRStack* yystack, 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; } @@ -2003,7 +2048,7 @@ b4_syncline([@oline@], [@ofile@])])dnl case 2: goto yyexhaustedlab; } yystack.yytokenp = &yytoken; - yyglrShift (&yystack, 0, 0, 0, yylval, &yylloc]b4_user_args[); + yyglrShift (&yystack, 0, 0, 0, yylval, &yylloc); yyposn = 0; while (yytrue) @@ -2031,7 +2076,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 { @@ -2053,8 +2098,7 @@ b4_syncline([@oline@], [@ofile@])])dnl 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; } @@ -2065,7 +2109,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[)); } } @@ -2122,14 +2166,35 @@ b4_syncline([@oline@], [@ofile@])])dnl yydestruct ("Error: 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;]] +)[ yydestruct ("Error: popping", + yystos[yys->yylrState], + &yys->yysemantics.yysval]b4_location_if([, &yys->yyloc])[); + 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)