X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/21964f4394e980974e3e4641b570703fac370b44..41cce2f604996c7713d9025f8a719ea56d83783e:/data/glr.c diff --git a/data/glr.c b/data/glr.c index 94e033cd..eb495448 100644 --- a/data/glr.c +++ b/data/glr.c @@ -38,7 +38,12 @@ m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[yylvalp]]][]dnl b4_location_if([, [[YYLTYPE *], [yyllocp]]])])dnl m4_ifdef([b4_lex_param], [, ]b4_lex_param))) -m4_define_default([b4_parse_param]) +# Yes, this is quite ugly... + m4_define_default([b4_parse_param]) +m4_ifdef([b4_parse_param], +[m4_define([b4_parse_param], + b4_parse_param)]) + ## ----------------- ## @@ -173,11 +178,10 @@ typedef union b4_stype yystype; #ifndef YYLTYPE typedef struct yyltype { -]b4_location_if([ int first_line; int first_column; int last_line; - int last_column;])[ + int last_column; } yyltype; # define YYLTYPE ]b4_location_type[ # define YYLTYPE_IS_TRIVIAL 1 @@ -231,6 +235,7 @@ static YYLTYPE yyloc_default; /* YYFINAL -- State number of the termination state. */ #define YYFINAL ]b4_final_state_number[ +/* YYLAST -- Last index in YYTABLE. */ #define YYLAST ]b4_last[ /* YYNTOKENS -- Number of terminals. */ @@ -376,28 +381,17 @@ static const ]b4_int_type_for([b4_check])[ yycheck[] = }; -/* The user can define YYPARSE_PARAM as the name of an argument to be passed - into yyparse. The argument should have type void *. - It should actually point to an object. - Grammar actions can access the variable by casting it - to the proper pointer type. */ - -#ifdef YYPARSE_PARAM -# define YYPARSE_PARAM_ARG void *YYPARSE_PARAM -#else /* !YYPARSE_PARAM */ -# define YYPARSE_PARAM_ARG void -#endif /* !YYPARSE_PARAM */ - -/* Prevent warning if -Wstrict-prototypes. */ -#ifdef __GNUC__ -# ifdef YYPARSE_PARAM -int yyparse (void *); -# else -int yyparse (void); -# endif -#endif +/* Prevent warning if -Wmissing-prototypes. */ +]b4_c_ansi_function_decl([yyparse], [int], b4_parse_param) + +m4_ifset([b4_parse_param], +[#define YY_USER_FORMALS , b4_c_ansi_formals(b4_parse_param) +#define YY_USER_ARGS , b4_c_args(b4_parse_param)], +[#define YY_USER_FORMALS +#define YY_USER_ARGS]) + -/* Error token number */ +[/* Error token number */ #define YYTERROR 1 /* YYLLOC_DEFAULT -- Compute the default location (before the actions @@ -593,7 +587,8 @@ yytokenName (yySymbol yytoken) * yyerr for YYERROR, yyabort for YYABORT. */ static YYRESULTTAG yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp, - YYSTYPE* yyvalp, YYLTYPE* yylocp, yyGLRStack* yystack) + YYSTYPE* yyvalp, YYLTYPE* yylocp, yyGLRStack* yystack + YY_USER_FORMALS) { /* Avoid `unused' warnings in there are no $n. */ (void) yystack; @@ -739,7 +734,7 @@ yyLRgotoState (yyStateNum yystate, yySymbol yylhs) static inline bool yyisShiftAction (int yyaction) { - return yyaction > 0; + return 0 < yyaction; } static inline bool @@ -825,14 +820,14 @@ yyexpandGLRStack (yyGLRStack* yystack) size_t yysize, yynewSize; size_t yyn; yysize = yystack->yynextFree - yystack->yyitems; - if (yysize >= YYMAXDEPTH) + if (YYMAXDEPTH <= yysize) yyFail (yystack, "parsing stack overflow (%d items)", yysize); yynewSize = 2*yysize; - if (yynewSize > YYMAXDEPTH) + if (YYMAXDEPTH < yynewSize) yynewSize = YYMAXDEPTH; yyinitGLRStack (&yynewStack, yynewSize); for (yyp0 = yystack->yyitems, yyp1 = yynewStack.yyitems, yyn = yysize; - yyn > 0; + 0 < yyn; yyn -= 1, yyp0 += 1, yyp1 += 1) { *yyp1 = *yyp0; @@ -995,7 +990,7 @@ yyglrShiftDefer (yyGLRStack* yystack, int yyk, yyStateNum yylrState, * for userAction. */ static inline int yydoAction (yyGLRStack* yystack, int yyk, yyRuleNum yyrule, - YYSTYPE* yyvalp, YYLTYPE* yylocp) + YYSTYPE* yyvalp, YYLTYPE* yylocp YY_USER_FORMALS) { int yynrhs = yyrhsLength (yyrule); @@ -1017,14 +1012,15 @@ yydoAction (yyGLRStack* yystack, int yyk, yyRuleNum yyrule, *yyvalp = rhs[1-yynrhs].yystate.yysemantics.yysval; *yylocp = rhs[1-yynrhs].yystate.yyloc; } - return yyuserAction (yyrule, yynrhs, rhs, yyvalp, yylocp, yystack); + return yyuserAction (yyrule, yynrhs, rhs, + yyvalp, yylocp, yystack YY_USER_ARGS); } else { int yyi; yyGLRState* yys; yyGLRStackItem yyrhsVals[YYMAXRHS]; - for (yyi = yynrhs-1, yys = yystack->yytops.yystates[yyk]; yyi >= 0; + for (yyi = yynrhs-1, yys = yystack->yytops.yystates[yyk]; 0 <= yyi; yyi -= 1, yys = yys->yypred) { assert (yys->yypred != NULL); @@ -1045,10 +1041,36 @@ yydoAction (yyGLRStack* yystack, int yyk, yyRuleNum yyrule, *yylocp = yyrhsVals[0].yystate.yyloc; } return yyuserAction (yyrule, yynrhs, yyrhsVals + (yynrhs-1), - yyvalp, yylocp, yystack); + yyvalp, yylocp, yystack YY_USER_ARGS); } } +#if !YYDEBUG +# define YY_REDUCE_PRINT(K, Rule) +#else +# define YY_REDUCE_PRINT(K, Rule) \ +do { \ + if (yydebug) \ + yy_reduce_print (K, Rule); \ +} while (0) + +/*----------------------------------------------------------. +| Report that the RULE is going to be reduced on stack #K. | +`----------------------------------------------------------*/ + +static inline void +yy_reduce_print (size_t yyk, yyRuleNum yyrule) +{ + int yyi; + YYDPRINTF ((stderr, "Reducing stack %d by rule %d (line %d),", + yyk, yyrule - 1, yyrline[yyrule])); + /* Print the symbols being reduced, and their result. */ + for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++) + YYFPRINTF (stderr, "%s ", yytokenName (yyrhs[yyi])); + YYFPRINTF (stderr, " -> %s\n", yytokenName (yyr1[yyrule])); +} +#endif + /** Pop items off stack #K of STACK according to grammar rule RULE, * and push back on the resulting nonterminal symbol. Perform the * semantic action associated with RULE and store its value with the @@ -1062,7 +1084,7 @@ yydoAction (yyGLRStack* yystack, int yyk, yyRuleNum yyrule, */ static inline YYRESULTTAG yyglrReduce (yyGLRStack* yystack, size_t yyk, yyRuleNum yyrule, - bool yyforceEval) + bool yyforceEval YY_USER_FORMALS) { size_t yyposn = yystack->yytops.yystates[yyk]->yyposn; @@ -1071,19 +1093,8 @@ yyglrReduce (yyGLRStack* yystack, size_t yyk, yyRuleNum yyrule, YYSTYPE yysval; YYLTYPE yyloc; -#if YYDEBUG - if (yydebug) - { - int yyi; - YYDPRINTF ((stderr, "Reducing stack %d by rule %d (line %d),", - yyk, yyrule - 1, yyrline[yyrule])); - /* Print the symbols being reduced, and their result. */ - for (yyi = yyprhs[yyrule]; yyrhs[yyi] >= 0; yyi++) - YYFPRINTF (stderr, "%s ", yytokenName (yyrhs[yyi])); - YYFPRINTF (stderr, " -> %s\n", yytokenName (yyr1[yyrule])); - } -#endif - YYCHK (yydoAction (yystack, yyk, yyrule, &yysval, &yyloc)); + YY_REDUCE_PRINT (yyk, yyrule); + YYCHK (yydoAction (yystack, yyk, yyrule, &yysval, &yyloc YY_USER_ARGS)); yyglrShift (yystack, yyk, yyLRgotoState (yystack->yytops.yystates[yyk]->yylrState, yylhsNonterm (yyrule)), @@ -1099,7 +1110,7 @@ yyglrReduce (yyGLRStack* yystack, size_t yyk, yyRuleNum yyrule, yyStateNum yynewLRState; for (yys = yystack->yytops.yystates[yyk], yyn = yyrhsLength (yyrule); - yyn > 0; yyn -= 1) + 0 < yyn; yyn -= 1) { yys = yys->yypred; assert (yys != NULL); @@ -1222,29 +1233,30 @@ yypreference (yySemanticOption* y0, yySemanticOption* y1) return 0; if (p0 < p1) return 3; - if (p0 > p1) + if (p1 < p0) return 2; return 0; } static YYRESULTTAG yyresolveValue (yySemanticOption* yyoptionList, yyGLRStack* yystack, YYSTYPE* yyvalp, - YYLTYPE* yylocp); + YYLTYPE* yylocp YY_USER_FORMALS); static YYRESULTTAG -yyresolveStates (yyGLRState* yys, int yyn, yyGLRStack* yystack) +yyresolveStates (yyGLRState* yys, int yyn, yyGLRStack* yystack YY_USER_FORMALS) { YYRESULTTAG yyflag; - if (yyn > 0) + if (0 < yyn) { assert (yys->yypred != NULL); - yyflag = yyresolveStates (yys->yypred, yyn-1, yystack); + yyflag = yyresolveStates (yys->yypred, yyn-1, yystack YY_USER_ARGS); if (yyflag != yyok) return yyflag; if (! yys->yyresolved) { yyflag = yyresolveValue (yys->yysemantics.yyfirstVal, yystack, - &yys->yysemantics.yysval, &yys->yyloc); + &yys->yysemantics.yysval, &yys->yyloc + YY_USER_ARGS); if (yyflag != yyok) return yyflag; yys->yyresolved = yytrue; @@ -1255,15 +1267,15 @@ yyresolveStates (yyGLRState* yys, int yyn, yyGLRStack* yystack) static YYRESULTTAG yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystack, - YYSTYPE* yyvalp, YYLTYPE* yylocp) + YYSTYPE* yyvalp, YYLTYPE* yylocp YY_USER_FORMALS) { yyGLRStackItem yyrhsVals[YYMAXRHS]; int yynrhs, yyi; yyGLRState* yys; yynrhs = yyrhsLength (yyopt->yyrule); - YYCHK (yyresolveStates (yyopt->yystate, yynrhs, yystack)); - for (yyi = yynrhs-1, yys = yyopt->yystate; yyi >= 0; + YYCHK (yyresolveStates (yyopt->yystate, yynrhs, yystack YY_USER_ARGS)); + for (yyi = yynrhs-1, yys = yyopt->yystate; 0 <= yyi; yyi -= 1, yys = yys->yypred) { assert (yys->yypred != NULL); @@ -1272,7 +1284,7 @@ yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystack, yyrhsVals[yyi].yystate.yyloc = yys->yyloc; } return yyuserAction (yyopt->yyrule, yynrhs, yyrhsVals + (yynrhs-1), - yyvalp, yylocp, yystack); + yyvalp, yylocp, yystack YY_USER_ARGS); } #if YYDEBUG @@ -1287,21 +1299,22 @@ static yyGLRState YYLEFTMOST_STATE = } }; -static void yyreportTree (yySemanticOption* yyx, int yyindent) +static void +yyreportTree (yySemanticOption* yyx, int yyindent) { int yynrhs = yyrhsLength (yyx->yyrule); int yyi; yyGLRState* yys; yyGLRState* yystates[YYMAXRHS]; - for (yyi = yynrhs, yys = yyx->yystate; yyi > 0; yyi -= 1, yys = yys->yypred) + for (yyi = yynrhs, yys = yyx->yystate; 0 < yyi; yyi -= 1, yys = yys->yypred) yystates[yyi] = yys; if (yys == NULL) yystates[0] = &YYLEFTMOST_STATE; else yystates[0] = yys; - if (yys->yyposn+1 > yyx->yystate->yyposn) + if (yyx->yystate->yyposn < yys->yyposn + 1) YYFPRINTF (stderr, "%*s%s -> \n", yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)), yyx->yyrule); @@ -1351,7 +1364,7 @@ yyreportAmbiguity (yySemanticOption* yyx0, yySemanticOption* yyx1, * actions, and return the result. */ static YYRESULTTAG yyresolveValue (yySemanticOption* yyoptionList, yyGLRStack* yystack, - YYSTYPE* yyvalp, YYLTYPE* yylocp) + YYSTYPE* yyvalp, YYLTYPE* yylocp YY_USER_FORMALS) { yySemanticOption* yybest; yySemanticOption* yyp; @@ -1384,25 +1397,25 @@ yyresolveValue (yySemanticOption* yyoptionList, yyGLRStack* yystack, if (yymerge) { int yyprec = yydprec[yybest->yyrule]; - YYCHK (yyresolveAction (yybest, yystack, yyvalp, yylocp)); + YYCHK (yyresolveAction (yybest, yystack, yyvalp, yylocp YY_USER_ARGS)); for (yyp = yybest->yynext; yyp != NULL; yyp = yyp->yynext) { if (yyprec == yydprec[yyp->yyrule]) { YYSTYPE yyval1; YYLTYPE yydummy; - YYCHK (yyresolveAction (yyp, yystack, &yyval1, &yydummy)); + YYCHK (yyresolveAction (yyp, yystack, &yyval1, &yydummy YY_USER_ARGS)); *yyvalp = yyuserMerge (yymerger[yyp->yyrule], yyvalp, &yyval1); } } return yyok; } else - return yyresolveAction (yybest, yystack, yyvalp, yylocp); + return yyresolveAction (yybest, yystack, yyvalp, yylocp YY_USER_ARGS); } static YYRESULTTAG -yyresolveStack (yyGLRStack* yystack) +yyresolveStack (yyGLRStack* yystack YY_USER_FORMALS) { if (yystack->yysplitPoint != NULL) { @@ -1413,7 +1426,8 @@ yyresolveStack (yyGLRStack* yystack) yys != yystack->yysplitPoint; yys = yys->yypred, yyn += 1) ; - YYCHK (yyresolveStates (yystack->yytops.yystates[0], yyn, yystack)); + YYCHK (yyresolveStates (yystack->yytops.yystates[0], yyn, yystack + YY_USER_ARGS)); } return yyok; } @@ -1450,7 +1464,8 @@ yycompressStack (yyGLRStack* yystack) static YYRESULTTAG yyprocessOneStack (yyGLRStack* yystack, int yyk, - size_t yyposn, YYSTYPE* yylvalp, YYLTYPE* yyllocp) + size_t yyposn, YYSTYPE* yylvalp, YYLTYPE* yyllocp + YY_USER_FORMALS) { int yyaction; const short* yyconflicts; @@ -1471,7 +1486,7 @@ yyprocessOneStack (yyGLRStack* yystack, int yyk, yymarkStackDeleted (yystack, yyk); return yyok; } - YYCHK (yyglrReduce (yystack, yyk, yyrule, yyfalse)); + YYCHK (yyglrReduce (yystack, yyk, yyrule, yyfalse YY_USER_ARGS)); } else { @@ -1490,9 +1505,10 @@ yyprocessOneStack (yyGLRStack* yystack, int yyk, int yynewStack = yysplitStack (yystack, yyk); YYDPRINTF ((stderr, "Splitting off stack %d from %d.\n", yynewStack, yyk)); - YYCHK (yyglrReduce (yystack, yynewStack, *yyconflicts, yyfalse)); + YYCHK (yyglrReduce (yystack, yynewStack, + *yyconflicts, yyfalse YY_USER_ARGS)); YYCHK (yyprocessOneStack (yystack, yynewStack, yyposn, - yylvalp, yyllocp)); + yylvalp, yyllocp YY_USER_ARGS)); yyconflicts += 1; } @@ -1512,7 +1528,7 @@ yyprocessOneStack (yyGLRStack* yystack, int yyk, break; } else - YYCHK (yyglrReduce (yystack, yyk, -yyaction, yyfalse)); + YYCHK (yyglrReduce (yystack, yyk, -yyaction, yyfalse YY_USER_ARGS)); } } return yyok; @@ -1659,8 +1675,12 @@ yyrecoverParseError (yyGLRStack* yystack, YYSTYPE* yylvalp, YYLTYPE* yyllocp) } \ } while (0) -int -yyparse (YYPARSE_PARAM_ARG) + +/*----------. +| yyparse. | +`----------*/ + +]b4_c_ansi_function_def([yyparse], [int], b4_parse_param)[ { yySymbol yytoken; yyGLRStack yystack; @@ -1712,7 +1732,7 @@ yyparse (YYPARSE_PARAM_ARG) yyreportParseError (&yystack, yylvalp, yyllocp); goto yyuser_error; } - YYCHK1 (yyglrReduce (&yystack, 0, yyrule, yytrue)); + YYCHK1 (yyglrReduce (&yystack, 0, yyrule, yytrue YY_USER_ARGS)); } else { @@ -1735,7 +1755,7 @@ yyparse (YYPARSE_PARAM_ARG) yytoken = YYEMPTY; yyposn += 1; yyglrShift (&yystack, 0, yyaction, yyposn, yylval, yyllocp); - if (yystack.yyerrState > 0) + if (0 < yystack.yyerrState) yystack.yyerrState -= 1; YYDPRINTF ((stderr, "Entering state %d\n", yystack.yytops.yystates[0]->yylrState)); @@ -1746,7 +1766,7 @@ yyparse (YYPARSE_PARAM_ARG) goto yyuser_error; } else - YYCHK1 (yyglrReduce (&yystack, 0, -yyaction, yytrue)); + YYCHK1 (yyglrReduce (&yystack, 0, -yyaction, yytrue YY_USER_ARGS)); } } @@ -1756,7 +1776,7 @@ yyparse (YYPARSE_PARAM_ARG) int yyn = yystack.yytops.yysize; for (yys = 0; yys < yyn; yys += 1) YYCHK1 (yyprocessOneStack (&yystack, yys, yyposn, - yylvalp, yyllocp)); + yylvalp, yyllocp YY_USER_ARGS)); yytoken = YYEMPTY; yyposn += 1; yyremoveDeletes (&yystack); @@ -1765,14 +1785,14 @@ yyparse (YYPARSE_PARAM_ARG) yyundeleteLastStack (&yystack); if (yystack.yytops.yysize == 0) yyFail (&yystack, "parse error"); - YYCHK1 (yyresolveStack (&yystack)); + YYCHK1 (yyresolveStack (&yystack YY_USER_ARGS)); YYDPRINTF ((stderr, "Returning to deterministic operation.\n")); yyreportParseError (&yystack, yylvalp, yyllocp); goto yyuser_error; } else if (yystack.yytops.yysize == 1) { - YYCHK1 (yyresolveStack (&yystack)); + YYCHK1 (yyresolveStack (&yystack YY_USER_ARGS)); YYDPRINTF ((stderr, "Returning to deterministic operation.\n")); yycompressStack (&yystack); break; @@ -1858,7 +1878,6 @@ yypdumpstack (yyGLRStack* yystack) (long) YYINDEX (yystack->yytops.yystates[yyi])); fprintf (stderr, "\n"); } - ] b4_epilogue