X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/7db2ed2d82f65d980ab93645e288b0b75c74e3e6..2a1fe6ed6f0688bbf05f94228b54642fd699dd13:/data/glr.c diff --git a/data/glr.c b/data/glr.c index 2d30eb9e..680d1207 100644 --- a/data/glr.c +++ b/data/glr.c @@ -108,11 +108,12 @@ b4_copyright([Skeleton parser for GLR parsing with Bison], [2002]) /* This is the parser code for GLR (Generalized LR) parser. */ /* FIXME: minimize these */ -#include +#include #include -#include #include -#include +#include +#include +#include /* Identify Bison output. */ #define YYBISON 1 @@ -135,10 +136,10 @@ b4_copyright([Skeleton parser for GLR parsing with Bison], [2002]) #define yynerrs b4_prefix[]nerrs b4_location_if([#define yylloc b4_prefix[]lloc])]) -/* Copy the first part of user declarations. */ -b4_pre_prologue +b4_token_defines(b4_tokens) -b4_token_defines(b4_tokens)[ +/* Copy the first part of user declarations. */ +b4_pre_prologue[ /* Enabling traces. */ #ifndef YYDEBUG @@ -168,10 +169,10 @@ typedef union b4_stype yystype; typedef struct yyltype { ]b4_location_if([ - int yyfirst_line; - int yyfirst_column; - int yylast_line; - int yylast_column;])[ + int first_line; + int first_column; + int last_line; + int last_column;])[ } yyltype; # define YYLTYPE ]b4_ltype[ # define YYLTYPE_IS_TRIVIAL 1 @@ -241,7 +242,7 @@ static YYLTYPE yyloc_default; ((unsigned)(YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ -static const ]b4_uint_type(b4_translate_max)[ yytranslate[] = +static const ]b4_int_type_for([b4_translate])[ yytranslate[] = { ]b4_translate[ }; @@ -249,19 +250,19 @@ static const ]b4_uint_type(b4_translate_max)[ yytranslate[] = #if YYDEBUG /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in YYRHS. */ -static const ]b4_uint_type(b4_prhs_max)[ yyprhs[] = +static const ]b4_int_type_for([b4_prhs])[ yyprhs[] = { ]b4_prhs[ }; /* YYRHS -- A `-1'-separated list of the rules' RHS. */ -static const ]b4_sint_type(b4_rhs_max)[ yyrhs[] = +static const ]b4_int_type_for([b4_rhs])[ yyrhs[] = { ]b4_rhs[ }; /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ -static const ]b4_uint_type(b4_rline_max)[ yyrline[] = +static const ]b4_int_type_for([b4_rline])[ yyrline[] = { ]b4_rline[ }; @@ -279,25 +280,25 @@ static const char *const yytname[] = #endif /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ -static const ]b4_uint_type(b4_r1_max)[ yyr1[] = +static const ]b4_int_type_for([b4_r1])[ yyr1[] = { ]b4_r1[ }; /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ -static const ]b4_uint_type(b4_r2_max)[ yyr2[] = +static const ]b4_int_type_for([b4_r2])[ yyr2[] = { ]b4_r2[ }; /* YYDPREC[RULE-NUM] -- Dynamic precedence of rule #RULE-NUM (0 if none). */ -static const short yydprec[] = +static const ]b4_int_type_for([b4_dprec])[ yydprec[] = { ]b4_dprec[ }; /* YYMERGER[RULE-NUM] -- Index of merging function for rule #RULE-NUM. */ -static const short yymerger[] = +static const ]b4_int_type_for([b4_merger])[ yymerger[] = { ]b4_merger[ }; @@ -305,34 +306,37 @@ static const short yymerger[] = /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE doesn't specify something else to do. Zero means the default is an error. */ -static const short yydefact[] = +static const ]b4_int_type_for([b4_defact])[ yydefact[] = { ]b4_defact[ }; -/* YYPGOTO[NTERM-NUM]. */ -static const short yydefgoto[] = +/* YYPDEFGOTO[NTERM-NUM]. */ +static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] = { ]b4_defgoto[ }; /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing STATE-NUM. */ -static const short yypact[] = +#define YYPACT_NINF ]b4_pact_ninf[ +static const ]b4_int_type_for([b4_pact])[ yypact[] = { ]b4_pact[ }; /* YYPGOTO[NTERM-NUM]. */ -static const short yypgoto[] = +static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] = { ]b4_pgoto[ }; /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If positive, shift that token. If negative, reduce the rule which - number is the opposite. If zero, do what YYDEFACT says. */ -static const short yytable[] = + number is the opposite. If zero, do what YYDEFACT says. + If YYTABLE_NINF, parse error. */ +#define YYTABLE_NINF ]b4_table_ninf[ +static const ]b4_int_type_for([b4_table])[ yytable[] = { ]b4_table[ }; @@ -341,19 +345,22 @@ static const short yytable[] = of conflicting reductions corresponding to action entry for state STATE-NUM in yytable. 0 means no conflicts. The list in yyconfl is terminated by a rule number of 0. */ -static const short yyconflp[] = +static const ]b4_int_type_for([b4_conflict_list_heads])[ yyconflp[] = { ]b4_conflict_list_heads[ }; /* YYCONFL[I] -- lists of conflicting rule numbers, each terminated by 0, pointed into by YYCONFLP. */ -static const short yyconfl[] = +]dnl Do not use b4_int_type_for here, since there are places where +dnl pointers onto yyconfl are taken, which type is "short *". +dnl We probably ought to introduce a type for confl. +[static const short yyconfl[] = { ]b4_conflicting_rules[ }; -static const short yycheck[] = +static const ]b4_int_type_for([b4_check])[ yycheck[] = { ]b4_check[ }; @@ -389,11 +396,11 @@ int yyparse (void); #define YYRHSLOC(yyRhs,YYK) (yyRhs[YYK].yystate.yyloc) #ifndef YYLLOC_DEFAULT -# define YYLLOC_DEFAULT(yyCurrent, yyRhs, YYN) \ - yyCurrent.yyfirst_line = YYRHSLOC(yyRhs,1).yyfirst_line; \ - yyCurrent.yyfirst_column = YYRHSLOC(yyRhs,1).yyfirst_column; \ - yyCurrent.yylast_line = YYRHSLOC(yyRhs,YYN).yylast_line; \ - yyCurrent.yylast_column = YYRHSLOC(yyRhs,YYN).yylast_column; +# define YYLLOC_DEFAULT(yyCurrent, yyRhs, YYN) \ + yyCurrent.first_line = YYRHSLOC(yyRhs,1).first_line; \ + yyCurrent.first_column = YYRHSLOC(yyRhs,1).first_column; \ + yyCurrent.last_line = YYRHSLOC(yyRhs,YYN).last_line; \ + yyCurrent.last_column = YYRHSLOC(yyRhs,YYN).last_column; #endif /* YYLEX -- calling `yylex' with the right arguments. */ @@ -676,7 +683,7 @@ yylhsNonterm (yyRuleNum yyrule) static inline bool yyisDefaultedState (yyStateNum yystate) { - return yypact[yystate] == YYFLAG; + return yypact[yystate] == YYPACT_NINF; } /** The default reduction for STATE, assuming it has one. */ @@ -686,7 +693,7 @@ yydefaultAction (yyStateNum yystate) return yydefact[yystate]; } -/** Set *ACTION to the action to take in STATE on seeing TOKEN. +/** Set *YYACTION to the action to take in YYSTATE on seeing YYTOKEN. * Result R means * R < 0: Reduce on rule -R. * R = 0: Error. @@ -699,16 +706,21 @@ yygetLRActions (yyStateNum yystate, int yytoken, int* yyaction, const short** yyconflicts) { int yyindex = yypact[yystate] + yytoken; - if (yyindex < 0 || yyindex > YYLAST || yycheck[yyindex] != yytoken) + if (yyindex < 0 || YYLAST < yyindex || yycheck[yyindex] != yytoken) { *yyaction = -yydefact[yystate]; *yyconflicts = yyconfl; } - else + else if (yytable[yyindex] != YYTABLE_NINF) { *yyaction = yytable[yyindex]; *yyconflicts = yyconfl + yyconflp[yyindex]; } + else + { + *yyaction = 0; + *yyconflicts = yyconfl + yyconflp[yyindex]; + } } static inline yyStateNum @@ -716,7 +728,7 @@ yyLRgotoState (yyStateNum yystate, yySymbol yylhs) { int yyr; yyr = yypgoto[yylhs - YYNTOKENS] + yystate; - if (yyr >= 0 && yyr <= YYLAST && yycheck[yyr] == yystate) + if (0 <= yyr && yyr <= YYLAST && yycheck[yyr] == yystate) return yytable[yyr]; else return yydefgoto[yylhs - YYNTOKENS]; @@ -731,7 +743,7 @@ yyisShiftAction (int yyaction) static inline bool yyisErrorAction (int yyaction) { - return yyaction == 0 || yyaction == YYFLAG; + return yyaction == 0; } /* GLRStates */ @@ -1057,13 +1069,25 @@ 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)); yyglrShift (yystack, yyk, yyLRgotoState (yystack->yytops.yystates[yyk]->yylrState, yylhsNonterm (yyrule)), yyposn, yysval, &yyloc); - YYDPRINTF ((stderr, "Reduced stack %d by rule #%d. Now in state %d.\n", - yyk, yyrule-1, yystack->yytops.yystates[yyk]->yylrState)); + YYDPRINTF ((stderr, "Stack %d entering state %d\n", + yyk, yystack->yytops.yystates[yyk]->yylrState)); } else { @@ -1250,7 +1274,7 @@ yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystack, } #if YYDEBUG -static yyGLRState YYLEFTMOST_STATE = { 0, NULL, -1, 0, { NULL } }; +static yyGLRState YYLEFTMOST_STATE = { 0, 0, -1, NULL, 0, { NULL } }; static void yyreportTree (yySemanticOption* yyx, int yyindent) { @@ -1442,9 +1466,11 @@ yyprocessOneStack (yyGLRStack* yystack, int yyk, { if (*yytokenp == YYEMPTY) { + YYDPRINTF ((stderr, "Reading a token: ")); yychar = YYLEX; *yytokenp = YYTRANSLATE(yychar); - YYDPRINTF ((stderr, "Read token %s\n", yytokenName (*yytokenp))); + YYDPRINTF ((stderr, "Next token is %s\n", + yytokenName (*yytokenp))); } yygetLRActions (yystate, *yytokenp, &yyaction, &yyconflicts); @@ -1461,7 +1487,7 @@ yyprocessOneStack (yyGLRStack* yystack, int yyk, if (yyisShiftAction (yyaction)) { - YYDPRINTF ((stderr, "Shifted token %s on stack %d, ", + YYDPRINTF ((stderr, "Shifting token %s on stack %d, ", yytokenName (*yytokenp), yyk)); yyglrShift (yystack, yyk, yyaction, yyposn+1, *yylvalp, yyllocp); YYDPRINTF ((stderr, "which is now in state #%d\n", @@ -1492,12 +1518,13 @@ yyreportParseError (yyGLRStack* yystack, YYSTYPE* yylvalp, YYLTYPE* yyllocp) { #if YYERROR_VERBOSE yySymbol* const yytokenp = yystack->yytokenp; - int yyn, yyx, yycount, yysize; + int yyn, yyx, yycount; + size_t yysize; const char* yyprefix; char* yyp; char* yymsg; yyn = yypact[yystack->yytops.yystates[0]->yylrState]; - if (yyn > YYFLAG && yyn < YYLAST) + if (YYPACT_NINF < yyn && yyn < YYLAST) { yycount = 0; /* Start YYX at -YYN if negative to avoid negative indexes in @@ -1507,7 +1534,7 @@ yyreportParseError (yyGLRStack* yystack, YYSTYPE* yylvalp, YYLTYPE* yyllocp) yyprefix = ", expecting "; for (yyx = yyn < 0 ? -yyn : 0; yyx < yytname_size && yycount <= 5; yyx += 1) - if (yycheck[yyx + yyn] == yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) yysize += strlen (yytokenName (yyx)) + strlen (yyprefix), yycount += 1, yyprefix = " or "; yymsg = yyp = (char*) malloc (yysize); @@ -1517,7 +1544,7 @@ yyreportParseError (yyGLRStack* yystack, YYSTYPE* yylvalp, YYLTYPE* yyllocp) { yyprefix = ", expecting "; for (yyx = yyn < 0 ? -yyn : 0; yyx < yytname_size; yyx += 1) - if (yycheck[yyx + yyn] == yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) { yyp += sprintf (yyp, "%s%s", yyprefix, yytokenName (yyx)); yyprefix = " or "; @@ -1533,13 +1560,9 @@ yyreportParseError (yyGLRStack* yystack, YYSTYPE* yylvalp, YYLTYPE* yyllocp) } } -/* Recover from a syntax error on STACK, assuming that TOKENP, +/* Recover from a syntax error on YYSTACK, assuming that YYTOKENP, YYLVALP, and YYLLOCP point to the syntactic category, semantic - value, and location of the lookahead. - NOTE: This uses the panic-mode recovery algorithm described in the - Bison documentation, which differs from what is in bison.simple. - Specifically, this routine performs no reductions before shifting - the error token. */ + value, and location of the lookahead. */ static void yyrecoverParseError (yyGLRStack* yystack, YYSTYPE* yylvalp, YYLTYPE* yyllocp) { @@ -1550,21 +1573,22 @@ yyrecoverParseError (yyGLRStack* yystack, YYSTYPE* yylvalp, YYLTYPE* yyllocp) if (yystack->yyerrState == 0) yystack->yyerrState = 3; else if (yystack->yyerrState == 3) - { - /* We just shifted the error token and (perhaps) took some - reductions. Skip tokens until we can proceed. */ - do { + /* We just shifted the error token and (perhaps) took some + reductions. Skip tokens until we can proceed. */ + while (yytrue) + { if (*yytokenp == YYEOF) yyFail (yystack, NULL); if (*yytokenp != YYEMPTY) YYDPRINTF ((stderr, "Discarding token %s\n", yytokenName (*yytokenp))); + YYDPRINTF ((stderr, "Reading a token: ")); yychar = YYLEX; *yytokenp = YYTRANSLATE (yychar); - YYDPRINTF ((stderr, "Read token %s\n", yytokenName (*yytokenp))); + YYDPRINTF ((stderr, "Next token is %s\n", yytokenName (*yytokenp))); yyj = yypact[yystack->yytops.yystates[0]->yylrState]; - if (yyj == YYFLAG) - /* Something's not right; we shouldn't be here */ + if (yyj == YYPACT_NINF) + /* Something's not right; we shouldn't be here. */ yyFail (yystack, NULL); yyj += *yytokenp; if (yyj < 0 || yyj > YYLAST || yycheck[yyj] != *yytokenp) @@ -1572,12 +1596,11 @@ yyrecoverParseError (yyGLRStack* yystack, YYSTYPE* yylvalp, YYLTYPE* yyllocp) if (yydefact[yystack->yytops.yystates[0]->yylrState] != 0) return; } - else if (yytable[yyj] != 0 && yytable[yyj] != YYFLAG) + else if (yytable[yyj] != 0 && yytable[yyj] != YYTABLE_NINF) return; - } while (yytrue); - } + } - /* Reduce to one stack */ + /* Reduce to one stack. */ for (yyk = 0; yyk < yystack->yytops.yysize; yyk += 1) if (yystack->yytops.yystates[yyk] != NULL) break; @@ -1592,7 +1615,7 @@ yyrecoverParseError (yyGLRStack* yystack, YYSTYPE* yylvalp, YYLTYPE* yyllocp) while (yystack->yytops.yystates[0] != NULL) { yyj = yypact[yystack->yytops.yystates[0]->yylrState] + YYTERROR; - if (yyj != YYFLAG + YYTERROR && yyj >= 0 && yyj <= YYLAST && + if (yyj != YYPACT_NINF + YYTERROR && yyj >= 0 && yyj <= YYLAST && yycheck[yyj] == YYTERROR && yyisShiftAction (yytable[yyj])) { yyglrShift (yystack, 0, yytable[yyj], @@ -1643,6 +1666,8 @@ yyparse (YYPARSE_PARAM_ARG) yyinitGLRStack (&yystack, YYINITDEPTH); yystack.yytokenp = &yytoken; + YYDPRINTF ((stderr, "Starting parse\n")); + if (setjmp (yystack.yyexception_buffer) != 0) goto yyDone; @@ -1680,9 +1705,10 @@ yyparse (YYPARSE_PARAM_ARG) { if (yytoken == YYEMPTY) { + YYDPRINTF ((stderr, "Reading a token: ")); yychar = YYLEX; yytoken = YYTRANSLATE (yychar); - YYDPRINTF ((stderr, "Read token %s\n", + YYDPRINTF ((stderr, "Next token is %s\n", yytokenName (yytoken))); } yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts); @@ -1690,7 +1716,7 @@ yyparse (YYPARSE_PARAM_ARG) break; if (yyisShiftAction (yyaction)) { - YYDPRINTF ((stderr, "Shifted token %s. ", + YYDPRINTF ((stderr, "Shifting token %s, ", yytokenName (yytoken))); if (yytoken != YYEOF) yytoken = YYEMPTY; @@ -1698,7 +1724,7 @@ yyparse (YYPARSE_PARAM_ARG) yyglrShift (&yystack, 0, yyaction, yyposn, yylval, yyllocp); if (yystack.yyerrState > 0) yystack.yyerrState -= 1; - YYDPRINTF ((stderr, "Now in state #%d\n", + YYDPRINTF ((stderr, "Entering state %d\n", yystack.yytops.yystates[0]->yylrState)); } else if (yyisErrorAction (yyaction)) @@ -1756,20 +1782,19 @@ static void yypstack (yyGLRStack* yystack, int yyk) ATTRIBUTE_UNUSED; static void yypdumpstack (yyGLRStack* yystack) ATTRIBUTE_UNUSED; static void -yypstates (yyGLRState* yyst) +yy_yypstack (yyGLRState* yys) { - static void - yy_yypstack (yyGLRState* yys) + if (yys->yypred) { - if (yys->yypred == NULL) - fprintf (stderr, "%d@%d", yys->yylrState, yys->yyposn); - else - { - yy_yypstack (yys->yypred); - fprintf (stderr, " -> %d@%d", yys->yylrState, yys->yyposn); - } + yy_yypstack (yys->yypred); + fprintf (stderr, " -> "); } + fprintf (stderr, "%d@%lu", yys->yylrState, (unsigned long) yys->yyposn); +} +static void +yypstates (yyGLRState* yyst) +{ if (yyst == NULL) fprintf (stderr, ""); else @@ -1794,28 +1819,30 @@ yypdumpstack (yyGLRStack* yystack) size_t yyi; for (yyp = yystack->yyitems; yyp < yystack->yynextFree; yyp += 1) { - fprintf (stderr, "%3d. ", yyp - yystack->yyitems); + fprintf (stderr, "%3lu. ", (unsigned long) (yyp - yystack->yyitems)); if (*(bool*) yyp) { - fprintf (stderr, "Res: %d, LR State: %d, posn: %d, pred: %d", + fprintf (stderr, "Res: %d, LR State: %d, posn: %lu, pred: %ld", yyp->yystate.yyresolved, yyp->yystate.yylrState, - yyp->yystate.yyposn, - YYINDEX(yyp->yystate.yypred)); + (unsigned long) yyp->yystate.yyposn, + (long) YYINDEX (yyp->yystate.yypred)); if (! yyp->yystate.yyresolved) - fprintf (stderr, ", firstVal: %d", - YYINDEX (yyp->yystate.yysemantics.yyfirstVal)); + fprintf (stderr, ", firstVal: %ld", + (long) YYINDEX (yyp->yystate.yysemantics.yyfirstVal)); } else { - fprintf (stderr, "Option. rule: %d, state: %d, next: %d", - yyp->yyoption.yyrule, YYINDEX (yyp->yyoption.yystate), - YYINDEX (yyp->yyoption.yynext)); + fprintf (stderr, "Option. rule: %d, state: %ld, next: %ld", + yyp->yyoption.yyrule, + (long) YYINDEX (yyp->yyoption.yystate), + (long) YYINDEX (yyp->yyoption.yynext)); } fprintf (stderr, "\n"); } fprintf (stderr, "Tops:"); for (yyi = 0; yyi < yystack->yytops.yysize; yyi += 1) - fprintf (stderr, "%d: %d; ", yyi, YYINDEX (yystack->yytops.yystates[yyi])); + fprintf (stderr, "%lu: %ld; ", (unsigned long) yyi, + (long) YYINDEX (yystack->yytops.yystates[yyi])); fprintf (stderr, "\n"); } @@ -1847,10 +1874,10 @@ b4_location_if( [#ifndef YYLTYPE typedef struct yyltype { - int yyfirst_line; - int yyfirst_column; - int yylast_line; - int yylast_column; + int first_line; + int first_column; + int last_line; + int last_column; } yyltype; # define YYLTYPE yyltype #endif