On Wed, 11 Jan 2006, Joel E. Denny wrote: > On Wed, 11 Jan 2006, Paul Hilfinger wrote: > > > > I agree about yylookaheadStatuses. However, yylookaheadAvailable sounds > > > like it means yychar != YYEMPTY. The polarity of yylookaheadUnused is > > > confusing, and it sounds like it might indicate whether the lookahead has > > > been shifted. How about yylookaheadNeeds, which follows from my comments > > > above its declaration and maintains the plural? I'm open to other > > > suggestions of course. > > > > That one's fine. > > OK, I'll rename it.
I installed this. Joel 2006-01-12 Joel E. Denny <[EMAIL PROTECTED]> * data/glr.c (yyGLRStateSet): Rename yylookaheadStatuses to yylookaheadNeeds. All uses updated. (yysplitStack): Rename local yynewLookaheadStatuses to yynewLookaheadNeeds. * data/glr-regression.at (Incorrect lookahead during nondeterministic GLR): In comments, change `lookahead status' to `lookahead need'. Index: data/glr.c =================================================================== RCS file: /sources/bison/bison/data/glr.c,v retrieving revision 1.158 diff -p -u -r1.158 glr.c --- data/glr.c 12 Jan 2006 00:16:35 -0000 1.158 +++ data/glr.c 12 Jan 2006 01:20:07 -0000 @@ -761,11 +761,11 @@ struct yyGLRState { struct yyGLRStateSet { yyGLRState** yystates; - /** During nondeterministic operation, yylookaheadStatuses tracks which + /** During nondeterministic operation, yylookaheadNeeds tracks which * stacks have actually needed the current lookahead. During deterministic - * operation, yylookaheadStatuses[0] is not maintained since it would merely + * operation, yylookaheadNeeds[0] is not maintained since it would merely * duplicate yychar != YYEMPTY. */ - yybool* yylookaheadStatuses; + yybool* yylookaheadNeeds; size_t yysize, yycapacity; }; @@ -1113,7 +1113,7 @@ yyaddDeferredAction (yyGLRStack* yystack &yynewGLRStackItem (yystackp, yyfalse)->yyoption; yynewOption->yystate = rhs; yynewOption->yyrule = yyrule; - if (yystackp->yytops.yylookaheadStatuses[yyk]) + if (yystackp->yytops.yylookaheadNeeds[yyk]) { yynewOption->yyrawchar = yychar; yynewOption->yyval = yylval; @@ -1139,9 +1139,9 @@ yyinitStateSet (yyGLRStateSet* yyset) if (! yyset->yystates) return yyfalse; yyset->yystates[0] = NULL; - yyset->yylookaheadStatuses = - (yybool*) YYMALLOC (16 * sizeof yyset->yylookaheadStatuses[0]); - if (! yyset->yylookaheadStatuses) + yyset->yylookaheadNeeds = + (yybool*) YYMALLOC (16 * sizeof yyset->yylookaheadNeeds[0]); + if (! yyset->yylookaheadNeeds) { YYFREE (yyset->yystates); return yyfalse; @@ -1152,7 +1152,7 @@ yyinitStateSet (yyGLRStateSet* yyset) static void yyfreeStateSet (yyGLRStateSet* yyset) { YYFREE (yyset->yystates); - YYFREE (yyset->yylookaheadStatuses); + YYFREE (yyset->yylookaheadNeeds); } /** Initialize STACK to a single empty stack, with total maximum @@ -1300,12 +1300,12 @@ yyremoveDeletes (yyGLRStack* yystackp) { yystackp->yytops.yystates[yyj] = yystackp->yytops.yystates[yyi]; /* In the current implementation, it's unnecessary to copy - yystackp->yytops.yylookaheadStatuses[yyi] since, after + yystackp->yytops.yylookaheadNeeds[yyi] since, after yyremoveDeletes returns, the parser immediately either enters deterministic operation or shifts a token. However, it doesn't hurt, and the code might evolve to need it. */ - yystackp->yytops.yylookaheadStatuses[yyj] = - yystackp->yytops.yylookaheadStatuses[yyi]; + yystackp->yytops.yylookaheadNeeds[yyj] = + yystackp->yytops.yylookaheadNeeds[yyi]; if (yyj != yyi) { YYDPRINTF ((stderr, "Rename stack %lu -> %lu.\n", @@ -1533,7 +1533,7 @@ yysplitStack (yyGLRStack* yystackp, size if (yystackp->yytops.yysize >= yystackp->yytops.yycapacity) { yyGLRState** yynewStates; - yybool* yynewLookaheadStatuses; + yybool* yynewLookaheadNeeds; yynewStates = NULL; @@ -1550,18 +1550,18 @@ yysplitStack (yyGLRStack* yystackp, size yyMemoryExhausted (yystackp); yystackp->yytops.yystates = yynewStates; - yynewLookaheadStatuses = - (yybool*) YYREALLOC (yystackp->yytops.yylookaheadStatuses, + yynewLookaheadNeeds = + (yybool*) YYREALLOC (yystackp->yytops.yylookaheadNeeds, (yystackp->yytops.yycapacity - * sizeof yynewLookaheadStatuses[0])); - if (yynewLookaheadStatuses == NULL) + * sizeof yynewLookaheadNeeds[0])); + if (yynewLookaheadNeeds == NULL) yyMemoryExhausted (yystackp); - yystackp->yytops.yylookaheadStatuses = yynewLookaheadStatuses; + yystackp->yytops.yylookaheadNeeds = yynewLookaheadNeeds; } yystackp->yytops.yystates[yystackp->yytops.yysize] = yystackp->yytops.yystates[yyk]; - yystackp->yytops.yylookaheadStatuses[yystackp->yytops.yysize] - = yystackp->yytops.yylookaheadStatuses[yyk]; + yystackp->yytops.yylookaheadNeeds[yystackp->yytops.yysize] + = yystackp->yytops.yylookaheadNeeds[yyk]; yystackp->yytops.yysize += 1; return yystackp->yytops.yysize-1; } @@ -1953,7 +1953,7 @@ yyprocessOneStack (yyGLRStack* yystackp, } else { - yystackp->yytops.yylookaheadStatuses[yyk] = yytrue; + yystackp->yytops.yylookaheadNeeds[yyk] = yytrue; if (*yytokenp == YYEMPTY) { YYDPRINTF ((stderr, "Reading a token: ")); @@ -2318,7 +2318,7 @@ b4_syncline([EMAIL PROTECTED]@], [EMAIL PROTECTED]@])])dnl size_t yyn = yystack.yytops.yysize; for (yys = 0; yys < yyn; yys += 1) - yystackp->yytops.yylookaheadStatuses[yys] = yychar != YYEMPTY; + yystackp->yytops.yylookaheadNeeds[yys] = yychar != YYEMPTY; /* yyprocessOneStack returns one of three things: Index: tests/glr-regression.at =================================================================== RCS file: /sources/bison/bison/tests/glr-regression.at,v retrieving revision 1.26 diff -p -u -r1.26 glr-regression.at --- tests/glr-regression.at 8 Jan 2006 23:16:51 -0000 1.26 +++ tests/glr-regression.at 12 Jan 2006 01:20:07 -0000 @@ -1151,17 +1151,17 @@ AT_SETUP([Incorrect lookahead during non AT_DATA_GRAMMAR([glr-regr14.y], [[ /* Tests: - - Conflicting actions (split-off parse, which copies lookahead status, + - Conflicting actions (split-off parse, which copies lookahead need, which is necessarily yytrue) and nonconflicting actions (non-split-off parse) for nondefaulted state: yychar != YYEMPTY. - - Merged deferred actions (lookahead status and RHS from different stack + - Merged deferred actions (lookahead need and RHS from different stack than the target state) and nonmerged deferred actions (same stack). - Defaulted state after lookahead: yychar != YYEMPTY. - Defaulted state after shift: yychar == YYEMPTY. - - yychar != YYEMPTY but lookahead status is yyfalse (a previous stack has + - yychar != YYEMPTY but lookahead need is yyfalse (a previous stack has seen the lookahead but current stack has not). - Exceeding stack capacity (stack explosion), and thus reallocating - lookahead status array. + lookahead need array. Note that it does not seem possible to see the initial yychar value during nondeterministic operation since: - In order to preserve the initial yychar, only defaulted states may be @@ -1193,8 +1193,7 @@ start: } ; -/* When merging the 2 deferred actions, the lookahead statuses are - different. */ +/* When merging the 2 deferred actions, the lookahead needs are different. */ merge: nonconflict1 'a' 'b' nonconflict2 %dprec 1 { USE ($2); USE ($3); @@ -1232,7 +1231,7 @@ defstate_look: } ; -/* yychar != YYEMPTY but lookahead status is yyfalse. */ +/* yychar != YYEMPTY but lookahead need is yyfalse. */ defstate_shift: { print_look_ahead ("defstate_shift <- empty string"); _______________________________________________ Help-bison@gnu.org http://lists.gnu.org/mailman/listinfo/help-bison