X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/087dcd78685097983821e5d540f9ff3385931833..7aaaad6c6dc0fae412d608dcf20a3977d8902cd1:/data/glr.c diff --git a/data/glr.c b/data/glr.c index 699d7304..2aa12b50 100644 --- a/data/glr.c +++ b/data/glr.c @@ -123,7 +123,15 @@ m4_define([b4_locuser_args], # -------------------- # Expansion of $$. m4_define([b4_lhs_value], -[((*yyvalp)[]m4_ifval([$1], [.$1]))]) +[b4_symbol_value([(*yyvalp)], [$1])]) + + +# b4_rhs_data(RULE-LENGTH, NUM) +# ----------------------------- +# Expand to the semantic stack place that contains value and location +# of symbol number NUM in a rule of length RULE-LENGTH. +m4_define([b4_rhs_data], +[((yyGLRStackItem const *)yyvsp)@{YYFILL (b4_subtract([$2], [$1]))@}.yystate]) # b4_rhs_value(RULE-LENGTH, NUM, [TYPE]) @@ -131,7 +139,7 @@ m4_define([b4_lhs_value], # Expansion of $NUM, where the current rule has RULE-LENGTH # symbols on RHS. m4_define([b4_rhs_value], -[(((yyGLRStackItem const *)yyvsp)@{YYFILL (($2) - ($1))@}.yystate.yysemantics.yysval[]m4_ifval([$3], [.$3]))]) +[b4_symbol_value([b4_rhs_data([$1], [$2]).yysemantics.yysval], [$3])]) @@ -151,7 +159,7 @@ m4_define([b4_lhs_location], # Expansion of @NUM, where the current rule has RULE-LENGTH symbols # on RHS. m4_define([b4_rhs_location], -[(((yyGLRStackItem const *)yyvsp)@{YYFILL (($2) - ($1))@}.yystate.yyloc)]) +[(b4_rhs_data([$1], [$2]).yyloc)]) ## -------------- ## @@ -205,14 +213,14 @@ b4_percent_code_get([[top]])[ ]b4_null_define[ ]b4_defines_if([[#include "@basename(]b4_spec_defines_file[@)"]], - [b4_shared_declarations])[ + [b4_shared_declarations])[ /* Enabling verbose error messages. */ #ifdef YYERROR_VERBOSE # undef YYERROR_VERBOSE # define YYERROR_VERBOSE 1 #else -# define YYERROR_VERBOSE ]b4_error_verbose_flag[ +# define YYERROR_VERBOSE ]b4_error_verbose_if([1], [0])[ #endif /* Default (constant) value used for initialization for null @@ -342,19 +350,6 @@ static const ]b4_int_type_for([b4_translate])[ yytranslate[] = }; #if YYDEBUG -/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in - YYRHS. */ -static const ]b4_int_type_for([b4_prhs])[ yyprhs[] = -{ - ]b4_prhs[ -}; - -/* YYRHS -- A `-1'-separated list of the rules' RHS. */ -static const ]b4_int_type_for([b4_rhs])[ yyrhs[] = -{ - ]b4_rhs[ -}; - /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ static const ]b4_int_type_for([b4_rline])[ yyrline[] = { @@ -371,17 +366,10 @@ static const char *const yytname[] = }; #endif -/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ -static const ]b4_int_type_for([b4_r1])[ yyr1[] = -{ - ]b4_r1[ -}; +#define YYPACT_NINF ]b4_pact_ninf[ +#define YYTABLE_NINF ]b4_table_ninf[ -/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ -static const ]b4_int_type_for([b4_r2])[ yyr2[] = -{ - ]b4_r2[ -}; +]b4_parser_tables_define[ /* YYDPREC[RULE-NUM] -- Dynamic precedence of rule #RULE-NUM (0 if none). */ static const ]b4_int_type_for([b4_dprec])[ yydprec[] = @@ -395,41 +383,11 @@ static const ]b4_int_type_for([b4_merger])[ yymerger[] = ]b4_merger[ }; -/* YYDEFACT[S] -- default reduction number in state S. Performed when - YYTABLE doesn't specify something else to do. Zero means the default - is an error. */ -static const ]b4_int_type_for([b4_defact])[ yydefact[] = +/* YYIMMEDIATE[RULE-NUM] -- True iff rule #RULE-NUM is not to be deferred, as + in the case of predicates. */ +static const yybool yyimmediate[] = { - ]b4_defact[ -}; - -/* 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. */ -#define YYPACT_NINF ]b4_pact_ninf[ -static const ]b4_int_type_for([b4_pact])[ yypact[] = -{ - ]b4_pact[ -}; - -/* YYPGOTO[NTERM-NUM]. */ -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 YYTABLE_NINF, syntax error. */ -#define YYTABLE_NINF ]b4_table_ninf[ -static const ]b4_int_type_for([b4_table])[ yytable[] = -{ - ]b4_table[ + ]b4_immediate[ }; /* YYCONFLP[YYPACT[STATE-NUM]] -- Pointer into YYCONFL of start of @@ -450,19 +408,6 @@ dnl We probably ought to introduce a type for confl. { ]b4_conflicting_rules[ }; - -static const ]b4_int_type_for([b4_check])[ yycheck[] = -{ - ]b4_check[ -}; - -/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing - symbol of state STATE-NUM. */ -static const ]b4_int_type_for([b4_stos])[ yystos[] = -{ - ]b4_stos[ -}; - /* Error token number */ #define YYTERROR 1 @@ -541,9 +486,12 @@ static const int YYEMPTY = -2; typedef enum { yyok, yyaccept, yyabort, yyerr } YYRESULTTAG; -#define YYCHK(YYE) \ - do { YYRESULTTAG yyflag = YYE; if (yyflag != yyok) return yyflag; } \ - while (YYID (0)) +#define YYCHK(YYE) \ + do { \ + YYRESULTTAG yychk_flag = YYE; \ + if (yychk_flag != yyok) \ + return yychk_flag; \ + } while (YYID (0)) #if YYDEBUG @@ -552,22 +500,22 @@ typedef enum { yyok, yyaccept, yyabort, yyerr } YYRESULTTAG; # endif # define YYDPRINTF(Args) \ -do { \ - if (yydebug) \ - YYFPRINTF Args; \ -} while (YYID (0)) + do { \ + if (yydebug) \ + YYFPRINTF Args; \ + } while (YYID (0)) ]b4_yy_symbol_print_generate([b4_c_ansi_function_def])[ -# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ -do { \ - if (yydebug) \ - { \ - YYFPRINTF (stderr, "%s ", Title); \ - yy_symbol_print (stderr, Type, Value]b4_locuser_args([Location])[); \ - YYFPRINTF (stderr, "\n"); \ - } \ -} while (YYID (0)) +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ + do { \ + if (yydebug) \ + { \ + YYFPRINTF (stderr, "%s ", Title); \ + yy_symbol_print (stderr, Type, Value]b4_locuser_args([Location])[); \ + YYFPRINTF (stderr, "\n"); \ + } \ + } while (YYID (0)) /* Nonzero means print parse trace. It is left uninitialized so that multiple parsers can coexist. */ @@ -604,13 +552,7 @@ int yydebug; #define YYHEADROOM 2 #ifndef YYSTACKEXPANDABLE -# if (! defined __cplusplus \ - || (]b4_locations_if([[defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \ - && ]])[defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)) # define YYSTACKEXPANDABLE 1 -# else -# define YYSTACKEXPANDABLE 0 -# endif #endif #if YYSTACKEXPANDABLE @@ -707,7 +649,7 @@ typedef int yyStateNum; typedef int yyRuleNum; /** Grammar symbol */ -typedef short int yySymbol; +typedef int yySymbol; /** Item references, as in LALR(1) machine */ typedef short int yyItemNum; @@ -728,7 +670,7 @@ struct yyGLRState { yyStateNum yylrState; /** Preceding state in this stack */ yyGLRState* yypred; - /** Source position of the first token produced by my symbol */ + /** Source position of the last token produced by my symbol */ size_t yyposn; union { /** First in a chain of alternative reductions producing the @@ -840,9 +782,16 @@ yyfillin (yyGLRStackItem *yyvsp, int yylow0, int yylow1) yyGLRState *s = yyvsp[yylow0].yystate.yypred; for (i = yylow0-1; i >= yylow1; i -= 1) { - YYASSERT (s->yyresolved); - yyvsp[i].yystate.yyresolved = yytrue; - yyvsp[i].yystate.yysemantics.yysval = s->yysemantics.yysval;]b4_locations_if([[ +#if YYDEBUG + yyvsp[i].yystate.yylrState = s->yylrState; +#endif + yyvsp[i].yystate.yyresolved = s->yyresolved; + if (s->yyresolved) + yyvsp[i].yystate.yysemantics.yysval = s->yysemantics.yysval; + else + /* The effect of using yysval or yyloc (in an immediate rule) is + * undefined. */ + yyvsp[i].yystate.yysemantics.yyfirstVal = YY_NULL;]b4_locations_if([[ yyvsp[i].yystate.yyloc = s->yyloc;]])[ s = yyvsp[i].yystate.yypred = s->yypred; } @@ -877,7 +826,7 @@ yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp, yybool yynormal __attribute__ ((__unused__)) = (yystackp->yysplitPoint == YY_NULL); int yylow; -]b4_parse_param_use[]dnl +]b4_parse_param_use([yyvalp], [yylocp])dnl [# undef yyerrok # define yyerrok (yystackp->yyerrState = 0) # undef YYACCEPT @@ -980,7 +929,7 @@ yydestroyGLRState (char const *yymsg, yyGLRState *yys]b4_user_formals[) } } -/** Left-hand-side symbol for rule #RULE. */ +/** Left-hand-side symbol for rule #YYRULE. */ static inline yySymbol yylhsNonterm (yyRuleNum yyrule) { @@ -990,7 +939,7 @@ yylhsNonterm (yyRuleNum yyrule) #define yypact_value_is_default(yystate) \ ]b4_table_value_equals([[pact]], [[yystate]], [b4_pact_ninf])[ -/** True iff LR state STATE has only a default reduction (regardless +/** True iff LR state YYSTATE has only a default reduction (regardless * of token). */ static inline yybool yyisDefaultedState (yyStateNum yystate) @@ -998,7 +947,7 @@ yyisDefaultedState (yyStateNum yystate) return yypact_value_is_default (yypact[yystate]); } -/** The default reduction for STATE, assuming it has one. */ +/** The default reduction for YYSTATE, assuming it has one. */ static inline yyRuleNum yydefaultAction (yyStateNum yystate) { @@ -1013,8 +962,8 @@ yydefaultAction (yyStateNum yystate) * R < 0: Reduce on rule -R. * R = 0: Error. * R > 0: Shift to state R. - * Set *CONFLICTS to a pointer into yyconfl to 0-terminated list of - * conflicting reductions. + * Set *YYCONFLICTS to a pointer into yyconfl to a 0-terminated list + * of conflicting reductions. */ static inline void yygetLRActions (yyStateNum yystate, int yytoken, @@ -1042,8 +991,7 @@ yygetLRActions (yyStateNum yystate, int yytoken, static inline yyStateNum yyLRgotoState (yyStateNum yystate, yySymbol yylhs) { - int yyr; - yyr = yypgoto[yylhs - YYNTOKENS] + yystate; + int yyr = yypgoto[yylhs - YYNTOKENS] + yystate; if (0 <= yyr && yyr <= YYLAST && yycheck[yyr] == yystate) return yytable[yyr]; else @@ -1064,9 +1012,10 @@ yyisErrorAction (int yyaction) /* GLRStates */ -/** Return a fresh GLRStackItem. Callers should call - * YY_RESERVE_GLRSTACK afterwards to make sure there is sufficient - * headroom. */ +/** Return a fresh GLRStackItem in YYSTACKP. The item is an LR state + * if YYISSTATE, and otherwise a semantic option. Callers should call + * YY_RESERVE_GLRSTACK afterwards to make sure there is sufficient + * headroom. */ static inline yyGLRStackItem* yynewGLRStackItem (yyGLRStack* yystackp, yybool yyisState) @@ -1079,16 +1028,16 @@ yynewGLRStackItem (yyGLRStack* yystackp, yybool yyisState) } /** Add a new semantic action that will execute the action for rule - * RULENUM on the semantic values in RHS to the list of - * alternative actions for STATE. Assumes that RHS comes from - * stack #K of *STACKP. */ + * YYRULE on the semantic values in YYRHS to the list of + * alternative actions for YYSTATE. Assumes that YYRHS comes from + * stack #YYK of *YYSTACKP. */ static void yyaddDeferredAction (yyGLRStack* yystackp, size_t yyk, yyGLRState* yystate, - yyGLRState* rhs, yyRuleNum yyrule) + yyGLRState* yyrhs, yyRuleNum yyrule) { yySemanticOption* yynewOption = &yynewGLRStackItem (yystackp, yyfalse)->yyoption; - yynewOption->yystate = rhs; + yynewOption->yystate = yyrhs; yynewOption->yyrule = yyrule; if (yystackp->yytops.yylookaheadNeeds[yyk]) { @@ -1106,7 +1055,7 @@ yyaddDeferredAction (yyGLRStack* yystackp, size_t yyk, yyGLRState* yystate, /* GLRStacks */ -/** Initialize SET to a singleton set containing an empty stack. */ +/** Initialize YYSET to a singleton set containing an empty stack. */ static yybool yyinitStateSet (yyGLRStateSet* yyset) { @@ -1132,8 +1081,8 @@ static void yyfreeStateSet (yyGLRStateSet* yyset) YYFREE (yyset->yylookaheadNeeds); } -/** Initialize STACK to a single empty stack, with total maximum - * capacity for all stacks of SIZE. */ +/** Initialize *YYSTACKP to a single empty stack, with total maximum + * capacity for all stacks of YYSIZE. */ static yybool yyinitGLRStack (yyGLRStack* yystackp, size_t yysize) { @@ -1155,7 +1104,7 @@ yyinitGLRStack (yyGLRStack* yystackp, size_t yysize) # define YYRELOC(YYFROMITEMS,YYTOITEMS,YYX,YYTYPE) \ &((YYTOITEMS) - ((YYFROMITEMS) - (yyGLRStackItem*) (YYX)))->YYTYPE -/** If STACK is expandable, extend it. WARNING: Pointers into the +/** If *YYSTACKP is expandable, extend it. WARNING: Pointers into the stack from outside should be considered invalid after this call. We always expand when there are 1 or fewer items left AFTER an allocation, so that we can avoid having external pointers exist @@ -1225,9 +1174,9 @@ yyfreeGLRStack (yyGLRStack* yystackp) yyfreeStateSet (&yystackp->yytops); } -/** Assuming that S is a GLRState somewhere on STACK, update the - * splitpoint of STACK, if needed, so that it is at least as deep as - * S. */ +/** Assuming that YYS is a GLRState somewhere on *YYSTACKP, update the + * splitpoint of *YYSTACKP, if needed, so that it is at least as deep as + * YYS. */ static inline void yyupdateSplit (yyGLRStack* yystackp, yyGLRState* yys) { @@ -1235,7 +1184,7 @@ yyupdateSplit (yyGLRStack* yystackp, yyGLRState* yys) yystackp->yysplitPoint = yys; } -/** Invalidate stack #K in STACK. */ +/** Invalidate stack #YYK in *YYSTACKP. */ static inline void yymarkStackDeleted (yyGLRStack* yystackp, size_t yyk) { @@ -1244,8 +1193,8 @@ yymarkStackDeleted (yyGLRStack* yystackp, size_t yyk) yystackp->yytops.yystates[yyk] = YY_NULL; } -/** Undelete the last stack that was marked as deleted. Can only be - done once after a deletion, and only when all other stacks have +/** Undelete the last stack in *YYSTACKP that was marked as deleted. Can + only be done once after a deletion, and only when all other stacks have been deleted. */ static void yyundeleteLastStack (yyGLRStack* yystackp) @@ -1294,8 +1243,9 @@ yyremoveDeletes (yyGLRStack* yystackp) } } -/** Shift to a new state on stack #K of STACK, corresponding to LR state - * LRSTATE, at input position POSN, with (resolved) semantic value SVAL. */ +/** Shift to a new state on stack #YYK of *YYSTACKP, corresponding to LR + * state YYLRSTATE, at input position YYPOSN, with (resolved) semantic + * value *YYVALP and source location *YYLOCP. */ static inline void yyglrShift (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState, size_t yyposn, @@ -1314,12 +1264,12 @@ yyglrShift (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState, YY_RESERVE_GLRSTACK (yystackp); } -/** Shift stack #K of YYSTACK, to a new state corresponding to LR +/** Shift stack #YYK of *YYSTACKP, to a new state corresponding to LR * state YYLRSTATE, at input position YYPOSN, with the (unresolved) * semantic value of YYRHS under the action for YYRULE. */ static inline void yyglrShiftDefer (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState, - size_t yyposn, yyGLRState* rhs, yyRuleNum yyrule) + size_t yyposn, yyGLRState* yyrhs, yyRuleNum yyrule) { yyGLRState* yynewState = &yynewGLRStackItem (yystackp, yytrue)->yystate; @@ -1331,14 +1281,55 @@ yyglrShiftDefer (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState, yystackp->yytops.yystates[yyk] = yynewState; /* Invokes YY_RESERVE_GLRSTACK. */ - yyaddDeferredAction (yystackp, yyk, yynewState, rhs, yyrule); + yyaddDeferredAction (yystackp, yyk, yynewState, yyrhs, yyrule); } -/** Pop the symbols consumed by reduction #RULE from the top of stack - * #K of STACK, and perform the appropriate semantic action on their +#if !YYDEBUG +# define YY_REDUCE_PRINT(Args) +#else +# define YY_REDUCE_PRINT(Args) \ +do { \ + if (yydebug) \ + yy_reduce_print Args; \ +} while (YYID (0)) + +/*----------------------------------------------------------------------. +| Report that stack #YYK of *YYSTACKP is going to be reduced by YYRULE. | +`----------------------------------------------------------------------*/ + +/*ARGSUSED*/ static inline void +yy_reduce_print (int yynormal, yyGLRStackItem* yyvsp, size_t yyk, + yyRuleNum yyrule]b4_user_formals[) +{ + int yynrhs = yyrhsLength (yyrule);]b4_locations_if([ + int yylow = 1;])[ + int yyi; + YYFPRINTF (stderr, "Reducing stack %lu by rule %d (line %lu):\n", + (unsigned long int) yyk, yyrule - 1, + (unsigned long int) yyrline[yyrule]); + if (! yynormal) + yyfillin (yyvsp, 1, -yynrhs); + /* The symbols being reduced. */ + for (yyi = 0; yyi < yynrhs; yyi++) + { + YYFPRINTF (stderr, " $%d = ", yyi + 1); + yy_symbol_print (stderr, + yystos[yyvsp[yyi - yynrhs + 1].yystate.yylrState], + &yyvsp[yyi - yynrhs + 1].yystate.yysemantics.yysval + ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl + b4_user_args[); + if (!yyvsp[yyi - yynrhs + 1].yystate.yyresolved) + YYFPRINTF (stderr, " (unresolved)"); + YYFPRINTF (stderr, "\n"); + } +} +#endif + +/** Pop the symbols consumed by reduction #YYRULE from the top of stack + * #YYK of *YYSTACKP, and perform the appropriate semantic action on their * semantic values. Assumes that all ambiguities in semantic values - * have been previously resolved. Set *VALP to the resulting value, - * and *LOCP to the computed location (if any). Return value is as + * have been previously resolved. Set *YYVALP to the resulting value, + * and *YYLOCP to the computed location (if any). Return value is as * for userAction. */ static inline YYRESULTTAG yydoAction (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule, @@ -1349,20 +1340,17 @@ yydoAction (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule, if (yystackp->yysplitPoint == YY_NULL) { /* Standard special case: single stack. */ - yyGLRStackItem* rhs = (yyGLRStackItem*) yystackp->yytops.yystates[yyk]; + yyGLRStackItem* yyrhs = (yyGLRStackItem*) yystackp->yytops.yystates[yyk]; YYASSERT (yyk == 0); yystackp->yynextFree -= yynrhs; yystackp->yyspaceLeft += yynrhs; yystackp->yytops.yystates[0] = & yystackp->yynextFree[-1].yystate; - return yyuserAction (yyrule, yynrhs, rhs, yystackp, + YY_REDUCE_PRINT ((1, yyrhs, yyk, yyrule]b4_user_args[)); + return yyuserAction (yyrule, yynrhs, yyrhs, yystackp, yyvalp]b4_locuser_args[); } else { - /* At present, doAction is never called in nondeterministic - * mode, so this branch is never taken. It is here in - * anticipation of a future feature that will allow immediate - * evaluation of selected actions in nondeterministic mode. */ int yyi; yyGLRState* yys; yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1]; @@ -1378,62 +1366,21 @@ yydoAction (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule, } yyupdateSplit (yystackp, yys); yystackp->yytops.yystates[yyk] = yys; + YY_REDUCE_PRINT ((0, yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, yyk, yyrule]b4_user_args[)); return yyuserAction (yyrule, yynrhs, yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, yystackp, yyvalp]b4_locuser_args[); } } -#if !YYDEBUG -# define YY_REDUCE_PRINT(Args) -#else -# define YY_REDUCE_PRINT(Args) \ -do { \ - if (yydebug) \ - yy_reduce_print Args; \ -} while (YYID (0)) - -/*----------------------------------------------------------. -| Report that the RULE is going to be reduced on stack #K. | -`----------------------------------------------------------*/ - -/*ARGSUSED*/ static inline void -yy_reduce_print (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule, - YYSTYPE* yyvalp]b4_locuser_formals[) -{ - int yynrhs = yyrhsLength (yyrule); - yybool yynormal __attribute__ ((__unused__)) = - (yystackp->yysplitPoint == YY_NULL); - yyGLRStackItem* yyvsp = (yyGLRStackItem*) yystackp->yytops.yystates[yyk]; - int yylow = 1; - int yyi; - YYUSE (yyvalp);]b4_locations_if([ - YYUSE (yylocp);])[ -]b4_parse_param_use[]dnl -[ YYFPRINTF (stderr, "Reducing stack %lu by rule %d (line %lu):\n", - (unsigned long int) yyk, yyrule - 1, - (unsigned long int) yyrline[yyrule]); - /* The symbols being reduced. */ - for (yyi = 0; yyi < yynrhs; yyi++) - { - YYFPRINTF (stderr, " $%d = ", yyi + 1); - yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], - &]b4_rhs_value(yynrhs, yyi + 1)[ - ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl - b4_user_args[); - YYFPRINTF (stderr, "\n"); - } -} -#endif - -/** Pop items off stack #K of STACK according to grammar rule RULE, +/** Pop items off stack #YYK of *YYSTACKP according to grammar rule YYRULE, * and push back on the resulting nonterminal symbol. Perform the - * semantic action associated with RULE and store its value with the - * newly pushed state, if FORCEEVAL or if STACK is currently + * semantic action associated with YYRULE and store its value with the + * newly pushed state, if YYFORCEEVAL or if *YYSTACKP is currently * unambiguous. Otherwise, store the deferred semantic action with * the new state. If the new state would have an identical input * position, LR state, and predecessor to an existing state on the stack, - * it is identified with that existing state, eliminating stack #K from - * the STACK. In this case, the (necessarily deferred) semantic value is + * it is identified with that existing state, eliminating stack #YYK from + * *YYSTACKP. In this case, the semantic value is * added to the options for the existing state's semantic value. */ static inline YYRESULTTAG @@ -1444,11 +1391,18 @@ yyglrReduce (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule, if (yyforceEval || yystackp->yysplitPoint == YY_NULL) { + YYRESULTTAG yyflag; YYSTYPE yysval;]b4_locations_if([ YYLTYPE yyloc;])[ - YY_REDUCE_PRINT ((yystackp, yyk, yyrule, &yysval]b4_locuser_args([&yyloc])[)); - YYCHK (yydoAction (yystackp, yyk, yyrule, &yysval]b4_locuser_args([&yyloc])[)); + yyflag = yydoAction (yystackp, yyk, yyrule, &yysval]b4_locuser_args([&yyloc])[); + if (yyflag == yyerr && yystackp->yysplitPoint != YY_NULL) + { + YYDPRINTF ((stderr, "Parse on stack %lu rejected by rule #%d.\n", + (unsigned long int) yyk, yyrule - 1)); + } + if (yyflag != yyok) + return yyflag; YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyrule], &yysval, &yyloc); yyglrShift (yystackp, yyk, yyLRgotoState (yystackp->yytops.yystates[yyk]->yylrState, @@ -1471,7 +1425,8 @@ yyglrReduce (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule, yyupdateSplit (yystackp, yys); yynewLRState = yyLRgotoState (yys->yylrState, yylhsNonterm (yyrule)); YYDPRINTF ((stderr, - "Reduced stack %lu by rule #%d; action deferred. Now in state %d.\n", + "Reduced stack %lu by rule #%d; action deferred. " + "Now in state %d.\n", (unsigned long int) yyk, yyrule - 1, yynewLRState)); for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1) if (yyi != yyk && yystackp->yytops.yystates[yyi] != YY_NULL) @@ -1542,7 +1497,7 @@ yysplitStack (yyGLRStack* yystackp, size_t yyk) return yystackp->yytops.yysize-1; } -/** True iff Y0 and Y1 represent identical options at the top level. +/** True iff YYY0 and YYY1 represent identical options at the top level. * That is, they represent the same rule applied to RHS symbols * that produce the same terminal symbols. */ static yybool @@ -1564,8 +1519,8 @@ yyidenticalOptions (yySemanticOption* yyy0, yySemanticOption* yyy1) return yyfalse; } -/** Assuming identicalOptions (Y0,Y1), destructively merge the - * alternative semantic values for the RHS-symbols of Y1 and Y0. */ +/** Assuming identicalOptions (YYY0,YYY1), destructively merge the + * alternative semantic values for the RHS-symbols of YYY1 and YYY0. */ static void yymergeOptionSets (yySemanticOption* yyy0, yySemanticOption* yyy1) { @@ -1644,11 +1599,11 @@ static YYRESULTTAG yyresolveValue (yyGLRState* yys, 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. */ +/** Resolve the previous YYN states starting at and including state YYS + * on *YYSTACKP. 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[) @@ -1663,9 +1618,10 @@ yyresolveStates (yyGLRState* yys, int yyn, 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 +/** Resolve the states for the RHS of YYOPT on *YYSTACKP, perform its + * user action, and return the semantic value and location in *YYVALP + * and *YYLOCP. 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, @@ -1739,11 +1695,11 @@ yyreportTree (yySemanticOption* yyx, int yyindent) { if (yystates[yyi-1]->yyposn+1 > yystates[yyi]->yyposn) YYFPRINTF (stderr, "%*s%s \n", yyindent+2, "", - yytokenName (yyrhs[yyprhs[yyx->yyrule]+yyi-1])); + yytokenName (yystos[yystates[yyi]->yylrState])); else YYFPRINTF (stderr, "%*s%s \n", yyindent+2, "", - yytokenName (yyrhs[yyprhs[yyx->yyrule]+yyi-1]), - (unsigned long int) (yystates[yyi - 1]->yyposn + 1), + yytokenName (yystos[yystates[yyi]->yylrState]), + (unsigned long int) (yystates[yyi-1]->yyposn + 1), (unsigned long int) yystates[yyi]->yyposn); } else @@ -1772,9 +1728,9 @@ yyreportAmbiguity (yySemanticOption* yyx0, return yyabort; }]b4_locations_if([[ -/** 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. */ +/** Resolve the locations for each of the YYN1 states in *YYSTACKP, + * ending at YYS1. Has no effect on previously resolved states. + * The first semantic option of a state is always chosen. */ static void yyresolveLocations (yyGLRState* yys1, int yyn1, yyGLRStack *yystackp]b4_user_formals[) @@ -1828,11 +1784,12 @@ yyresolveLocations (yyGLRState* yys1, int yyn1, } }]])[ -/** Resolve the ambiguity represented in state S, perform the indicated - * 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 +/** Resolve the ambiguity represented in state YYS in *YYSTACKP, + * perform the indicated actions, and set the semantic value of YYS. + * If result != yyok, the chain of semantic options in YYS has been + * cleared instead or it has been left unmodified except that + * redundant options may have been removed. Regardless of whether + * result = yyok, YYS has been left with consistent data so that * yydestroyGLRState can be invoked if necessary. */ static YYRESULTTAG yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp]b4_user_formals[) @@ -1970,10 +1927,6 @@ static YYRESULTTAG yyprocessOneStack (yyGLRStack* yystackp, size_t yyk, size_t yyposn]b4_pure_formals[) { - int yyaction; - const short int* yyconflicts; - yyRuleNum yyrule; - while (yystackp->yytops.yystates[yyk] != YY_NULL) { yyStateNum yystate = yystackp->yytops.yystates[yyk]->yylrState; @@ -1984,7 +1937,8 @@ yyprocessOneStack (yyGLRStack* yystackp, size_t yyk, if (yyisDefaultedState (yystate)) { - yyrule = yydefaultAction (yystate); + YYRESULTTAG yyflag; + yyRuleNum yyrule = yydefaultAction (yystate); if (yyrule == 0) { YYDPRINTF ((stderr, "Stack %lu dies.\n", @@ -1992,11 +1946,25 @@ yyprocessOneStack (yyGLRStack* yystackp, size_t yyk, yymarkStackDeleted (yystackp, yyk); return yyok; } - YYCHK (yyglrReduce (yystackp, yyk, yyrule, yyfalse]b4_user_args[)); + yyflag = yyglrReduce (yystackp, yyk, yyrule, yyimmediate[yyrule]]b4_user_args[); + if (yyflag == yyerr) + { + YYDPRINTF ((stderr, + "Stack %lu dies " + "(predicate failure or explicit user error).\n", + (unsigned long int) yyk)); + yymarkStackDeleted (yystackp, yyk); + return yyok; + } + if (yyflag != yyok) + return yyflag; } else { yySymbol yytoken; + int yyaction; + const short int* yyconflicts; + yystackp->yytops.yylookaheadNeeds[yyk] = yytrue; if (yychar == YYEMPTY) { @@ -2019,14 +1987,25 @@ yyprocessOneStack (yyGLRStack* yystackp, size_t yyk, while (*yyconflicts != 0) { + YYRESULTTAG yyflag; size_t yynewStack = yysplitStack (yystackp, yyk); YYDPRINTF ((stderr, "Splitting off stack %lu from %lu.\n", (unsigned long int) yynewStack, (unsigned long int) yyk)); - YYCHK (yyglrReduce (yystackp, yynewStack, - *yyconflicts, yyfalse]b4_user_args[)); - YYCHK (yyprocessOneStack (yystackp, yynewStack, - yyposn]b4_pure_args[)); + yyflag = yyglrReduce (yystackp, yynewStack, + *yyconflicts, + yyimmediate[*yyconflicts]]b4_user_args[); + if (yyflag == yyok) + YYCHK (yyprocessOneStack (yystackp, yynewStack, + yyposn]b4_pure_args[)); + else if (yyflag == yyerr) + { + YYDPRINTF ((stderr, "Stack %lu dies.\n", + (unsigned long int) yynewStack)); + yymarkStackDeleted (yystackp, yynewStack); + } + else + return yyflag; yyconflicts += 1; } @@ -2040,8 +2019,21 @@ yyprocessOneStack (yyGLRStack* yystackp, size_t yyk, break; } else - YYCHK (yyglrReduce (yystackp, yyk, -yyaction, - yyfalse]b4_user_args[)); + { + YYRESULTTAG yyflag = yyglrReduce (yystackp, yyk, -yyaction, + yyimmediate[-yyaction]]b4_user_args[); + if (yyflag == yyerr) + { + YYDPRINTF ((stderr, + "Stack %lu dies " + "(predicate failure or explicit user error).\n", + (unsigned long int) yyk)); + yymarkStackDeleted (yystackp, yyk); + break; + } + else if (yyflag != yyok) + return yyflag; + } } } return yyok; @@ -2294,7 +2286,6 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[) } \ } while (YYID (0)) - /*----------. | yyparse. | `----------*/ @@ -2616,9 +2607,7 @@ yypdumpstack (yyGLRStack* yystackp) YYFPRINTF (stderr, "\n"); } #endif -] - -b4_epilogue +]b4_epilogue[]dnl dnl dnl glr.cc produces its own header. dnl