]> git.saurik.com Git - bison.git/blobdiff - data/glr.c
projects / bison.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
* TODO: Remove dead items.
[bison.git] / data / glr.c
diff --git a/data/glr.c b/data/glr.c
index bc16ba1a4b6754106b7bff0b6885a5e4ad63b18a..e67573b6db9d5f41c09312d7d0e8a24ecf3fc2b4 100644 (file)
--- a/data/glr.c
+++ b/data/glr.c
@@ -1,7 +1,7 @@
 m4_divert(-1)                                                       -*- C -*-
 
 # GLR skeleton for Bison
 m4_divert(-1)                                                       -*- C -*-
 
 # GLR skeleton for Bison
-# Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+# Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
 
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -19,6 +19,8 @@ m4_divert(-1)                                                       -*- C -*-
 # 02110-1301  USA
 
 
 # 02110-1301  USA
 
 
+m4_include(b4_pkgdatadir/[c.m4])
+
 ## ---------------- ##
 ## Default values.  ##
 ## ---------------- ##
 ## ---------------- ##
 ## Default values.  ##
 ## ---------------- ##
@@ -92,13 +94,6 @@ m4_define([b4_pure_formals],
 [b4_pure_if([b4_location_if([, YYLTYPE *yylocp])])[]b4_user_formals])
 
 
 [b4_pure_if([b4_location_if([, YYLTYPE *yylocp])])[]b4_user_formals])
 
 
-# b4_lpure_formals
-# ----------------
-# Same as above, but on the look-ahead, hence yyllocp instead of yylocp.
-m4_define([b4_lpure_formals],
-[b4_pure_if([b4_location_if([YYLTYPE *yyllocp])])[]b4_user_formals])
-
-
 ## ----------------- ##
 ## Semantic Values.  ##
 ## ----------------- ##
 ## ----------------- ##
 ## Semantic Values.  ##
 ## ----------------- ##
@@ -149,7 +144,7 @@ m4_changecom()
 m4_divert(0)dnl
 @output @output_parser_name@
 b4_copyright([Skeleton parser for GLR parsing with Bison],
 m4_divert(0)dnl
 @output @output_parser_name@
 b4_copyright([Skeleton parser for GLR parsing with Bison],
-  [2002, 2003, 2004, 2005])
+  [2002, 2003, 2004, 2005, 2006])
 [
 /* This is the parser code for GLR (Generalized LR) parser.  */
 
 [
 /* This is the parser code for GLR (Generalized LR) parser.  */
 
@@ -176,18 +171,19 @@ m4_define([b4_shared_declarations],
 /* Copy the first part of user declarations.  */
 ]b4_pre_prologue[
 
 /* Copy the first part of user declarations.  */
 ]b4_pre_prologue[
 
-#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 ]m4_ifdef([b4_stype],
 ]m4_ifdef([b4_stype],
-[b4_syncline([b4_stype_line], [b4_file_name])
-typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])b4_stype YYSTYPE;
+[typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])
+b4_stype
 /* Line __line__ of glr.c.  */
 /* Line __line__ of glr.c.  */
-b4_syncline([@oline@], [@ofile@])],
+b4_syncline([@oline@], [@ofile@])
+       YYSTYPE;],
 [typedef int YYSTYPE;])[
 # define YYSTYPE_IS_DECLARED 1
 # define YYSTYPE_IS_TRIVIAL 1
 #endif
 
 [typedef int YYSTYPE;])[
 # define YYSTYPE_IS_DECLARED 1
 # define YYSTYPE_IS_TRIVIAL 1
 #endif
 
-#if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED)
+#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
 typedef struct YYLTYPE
 {
 ]b4_location_if([
 typedef struct YYLTYPE
 {
 ]b4_location_if([
@@ -257,7 +253,7 @@ b4_syncline([@oline@], [@ofile@])
 #endif
 
 /* Suppress unused-variable warnings by "using" E.  */
 #endif
 
 /* Suppress unused-variable warnings by "using" E.  */
-#ifndef lint
+#if ! defined lint || defined __GNUC__
 # define YYUSE(e) ((void) (e))
 #else
 # define YYUSE(e) /* empty */
 # define YYUSE(e) ((void) (e))
 #else
 # define YYUSE(e) /* empty */
@@ -306,7 +302,7 @@ b4_syncline([@oline@], [@ofile@])
 
 #ifndef __attribute__
 /* This feature is available in gcc versions 2.5 and later.  */
 
 #ifndef __attribute__
 /* This feature is available in gcc versions 2.5 and later.  */
-# if (!defined (__GNUC__) || __GNUC__ < 2 \
+# if (! defined __GNUC__ || __GNUC__ < 2 \
       || (__GNUC__ == 2 && __GNUC_MINOR__ < 5) || __STRICT_ANSI__)
 #  define __attribute__(Spec) /* empty */
 # endif
       || (__GNUC__ == 2 && __GNUC_MINOR__ < 5) || __STRICT_ANSI__)
 #  define __attribute__(Spec) /* empty */
 # endif
@@ -495,7 +491,7 @@ static const ]b4_int_type_for([b4_stos])[ yystos[] =
 #ifndef YYLLOC_DEFAULT
 # define YYLLOC_DEFAULT(Current, Rhs, N)                               \
     do                                                                 \
 #ifndef YYLLOC_DEFAULT
 # define YYLLOC_DEFAULT(Current, Rhs, N)                               \
     do                                                                 \
-      if (YYID (N))                                                    \
+      if (YYID (N))                                                    \
        {                                                               \
          (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
          (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
        {                                                               \
          (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
          (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
@@ -567,9 +563,9 @@ typedef enum { yyok, yyaccept, yyabort, yyerr } YYRESULTTAG;
 
 #if YYDEBUG
 
 
 #if YYDEBUG
 
-#if ! defined (YYFPRINTF)
+# ifndef YYFPRINTF
 #  define YYFPRINTF fprintf
 #  define YYFPRINTF fprintf
-#endif
+# endif
 
 # define YYDPRINTF(Args)                       \
 do {                                           \
 
 # define YYDPRINTF(Args)                       \
 do {                                           \
@@ -584,8 +580,8 @@ do {                                                                            \
   if (yydebug)                                                             \
     {                                                                      \
       YYFPRINTF (stderr, "%s ", Title);                                            \
   if (yydebug)                                                             \
     {                                                                      \
       YYFPRINTF (stderr, "%s ", Title);                                            \
-      yy_symbol_print (stderr,                                             \
-                 Type, Value]b4_location_if([, Location])[]b4_user_args[); \
+      yy_symbol_print (stderr, Type,                                       \
+                      Value]b4_location_if([, Location])[]b4_user_args[);  \
       YYFPRINTF (stderr, "\n");                                                    \
     }                                                                      \
 } while (YYID (0))
       YYFPRINTF (stderr, "\n");                                                    \
     }                                                                      \
 } while (YYID (0))
@@ -625,9 +621,9 @@ int yydebug;
 #define YYHEADROOM 2
 
 #ifndef YYSTACKEXPANDABLE
 #define YYHEADROOM 2
 
 #ifndef YYSTACKEXPANDABLE
-# if (! defined (__cplusplus) \
-      || (]b4_location_if([[defined (YYLTYPE_IS_TRIVIAL) && YYLTYPE_IS_TRIVIAL \
-         && ]])[defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL))
+# if (! defined __cplusplus \
+      || (]b4_location_if([[defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
+         && ]])[defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))
 #  define YYSTACKEXPANDABLE 1
 # else
 #  define YYSTACKEXPANDABLE 0
 #  define YYSTACKEXPANDABLE 1
 # else
 #  define YYSTACKEXPANDABLE 0
@@ -652,7 +648,7 @@ int yydebug;
 #if YYERROR_VERBOSE
 
 # ifndef yystpcpy
 #if YYERROR_VERBOSE
 
 # ifndef yystpcpy
-#  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
+#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
 #   define yystpcpy stpcpy
 #  else
 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
 #   define yystpcpy stpcpy
 #  else
 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
@@ -765,6 +761,11 @@ struct yyGLRState {
 
 struct yyGLRStateSet {
   yyGLRState** yystates;
 
 struct yyGLRStateSet {
   yyGLRState** yystates;
+  /** During nondeterministic operation, yylookaheadNeeds tracks which
+   *  stacks have actually needed the current lookahead.  During deterministic
+   *  operation, yylookaheadNeeds[0] is not maintained since it would merely
+   *  duplicate yychar != YYEMPTY.  */
+  yybool* yylookaheadNeeds;
   size_t yysize, yycapacity;
 };
 
   size_t yysize, yycapacity;
 };
 
@@ -775,6 +776,10 @@ struct yySemanticOption {
   yyRuleNum yyrule;
   /** The last RHS state in the list of states to be reduced.  */
   yyGLRState* yystate;
   yyRuleNum yyrule;
   /** The last RHS state in the list of states to be reduced.  */
   yyGLRState* yystate;
+  /** The lookahead for this reduction.  */
+  int yyrawchar;
+  YYSTYPE yyval;
+  YYLTYPE yyloc;
   /** Next sibling in chain of options.  To facilitate merging,
    *  options are chained in decreasing order by address.  */
   yySemanticOption* yynext;
   /** Next sibling in chain of options.  To facilitate merging,
    *  options are chained in decreasing order by address.  */
   yySemanticOption* yynext;
@@ -798,7 +803,6 @@ struct yyGLRStack {
   YYSTYPE yyval;
   YYLTYPE yyloc;
 ])[
   YYSTYPE yyval;
   YYLTYPE yyloc;
 ])[
-  yySymbol* yytokenp;
   YYJMP_BUF yyexception_buffer;
   yyGLRStackItem* yyitems;
   yyGLRStackItem* yynextFree;
   YYJMP_BUF yyexception_buffer;
   yyGLRStackItem* yyitems;
   yyGLRStackItem* yynextFree;
@@ -905,7 +909,7 @@ yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,
 # undef YYRECOVERING
 # define YYRECOVERING (yystackp->yyerrState != 0)
 # undef yyclearin
 # undef YYRECOVERING
 # define YYRECOVERING (yystackp->yyerrState != 0)
 # undef yyclearin
-# define yyclearin (yychar = *(yystackp->yytokenp) = YYEMPTY)
+# define yyclearin (yychar = YYEMPTY)
 # undef YYFILL
 # define YYFILL(N) yyfill (yyvsp, &yylow, N, yynormal)
 # undef YYBACKUP
 # undef YYFILL
 # define YYFILL(N) yyfill (yyvsp, &yylow, N, yynormal)
 # undef YYBACKUP
@@ -918,7 +922,7 @@ yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,
     *yyvalp = yyval_default;
   else
     *yyvalp = yyvsp[YYFILL (1-yyrhslen)].yystate.yysemantics.yysval;
     *yyvalp = yyval_default;
   else
     *yyvalp = yyvsp[YYFILL (1-yyrhslen)].yystate.yysemantics.yysval;
-  YYLLOC_DEFAULT (*yylocp, yyvsp - yyrhslen, yyrhslen);
+  YYLLOC_DEFAULT ((*yylocp), (yyvsp - yyrhslen), yyrhslen);
 ]b4_location_if([[  yystackp->yyerror_range[1].yystate.yyloc = *yylocp;
 ]])[
   switch (yyn)
 ]b4_location_if([[  yystackp->yyerror_range[1].yystate.yyloc = *yylocp;
 ]])[
   switch (yyn)
@@ -975,9 +979,12 @@ yydestroyGLRState (char const *yymsg, yyGLRState *yys]b4_user_formals[)
 #if YYDEBUG
       if (yydebug)
        {
 #if YYDEBUG
       if (yydebug)
        {
-         YYFPRINTF (stderr, "%s unresolved ", yymsg);
+         if (yys->yysemantics.yyfirstVal)
+           YYFPRINTF (stderr, "%s unresolved ", yymsg);
+         else
+           YYFPRINTF (stderr, "%s incomplete ", yymsg);
          yy_symbol_print (stderr, yystos[yys->yylrState],
          yy_symbol_print (stderr, yystos[yys->yylrState],
-                     &yys->yysemantics.yysval]b4_location_if([, &yys->yyloc])[]b4_user_args[);
+                          NULL]b4_location_if([, &yys->yyloc])[]b4_user_args[);
          YYFPRINTF (stderr, "\n");
        }
 #endif
          YYFPRINTF (stderr, "\n");
        }
 #endif
@@ -1096,14 +1103,26 @@ yynewGLRStackItem (yyGLRStack* yystackp, yybool yyisState)
   return yynewItem;
 }
 
   return yynewItem;
 }
 
+/** 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. */
 static void
 static void
-yyaddDeferredAction (yyGLRStack* yystackp, yyGLRState* yystate,
+yyaddDeferredAction (yyGLRStack* yystackp, size_t yyk, yyGLRState* yystate,
                     yyGLRState* rhs, yyRuleNum yyrule)
 {
   yySemanticOption* yynewOption =
     &yynewGLRStackItem (yystackp, yyfalse)->yyoption;
   yynewOption->yystate = rhs;
   yynewOption->yyrule = yyrule;
                     yyGLRState* rhs, yyRuleNum yyrule)
 {
   yySemanticOption* yynewOption =
     &yynewGLRStackItem (yystackp, yyfalse)->yyoption;
   yynewOption->yystate = rhs;
   yynewOption->yyrule = yyrule;
+  if (yystackp->yytops.yylookaheadNeeds[yyk])
+    {
+      yynewOption->yyrawchar = yychar;
+      yynewOption->yyval = yylval;
+      yynewOption->yyloc = yylloc;
+    }
+  else
+    yynewOption->yyrawchar = YYEMPTY;
   yynewOption->yynext = yystate->yysemantics.yyfirstVal;
   yystate->yysemantics.yyfirstVal = yynewOption;
 
   yynewOption->yynext = yystate->yysemantics.yyfirstVal;
   yystate->yysemantics.yyfirstVal = yynewOption;
 
@@ -1122,12 +1141,20 @@ yyinitStateSet (yyGLRStateSet* yyset)
   if (! yyset->yystates)
     return yyfalse;
   yyset->yystates[0] = NULL;
   if (! yyset->yystates)
     return yyfalse;
   yyset->yystates[0] = NULL;
+  yyset->yylookaheadNeeds =
+    (yybool*) YYMALLOC (16 * sizeof yyset->yylookaheadNeeds[0]);
+  if (! yyset->yylookaheadNeeds)
+    {
+      YYFREE (yyset->yystates);
+      return yyfalse;
+    }
   return yytrue;
 }
 
 static void yyfreeStateSet (yyGLRStateSet* yyset)
 {
   YYFREE (yyset->yystates);
   return yytrue;
 }
 
 static void yyfreeStateSet (yyGLRStateSet* yyset)
 {
   YYFREE (yyset->yystates);
+  YYFREE (yyset->yylookaheadNeeds);
 }
 
 /** Initialize STACK to a single empty stack, with total maximum
 }
 
 /** Initialize STACK to a single empty stack, with total maximum
@@ -1166,7 +1193,7 @@ yyexpandGLRStack (yyGLRStack* yystackp)
   size_t yysize, yynewSize;
   size_t yyn;
   yysize = yystackp->yynextFree - yystackp->yyitems;
   size_t yysize, yynewSize;
   size_t yyn;
   yysize = yystackp->yynextFree - yystackp->yyitems;
-  if (YYMAXDEPTH <= yysize)
+  if (YYMAXDEPTH - YYHEADROOM < yysize)
     yyMemoryExhausted (yystackp);
   yynewSize = 2*yysize;
   if (YYMAXDEPTH < yynewSize)
     yyMemoryExhausted (yystackp);
   yynewSize = 2*yysize;
   if (YYMAXDEPTH < yynewSize)
@@ -1274,6 +1301,13 @@ yyremoveDeletes (yyGLRStack* yystackp)
       else
        {
          yystackp->yytops.yystates[yyj] = yystackp->yytops.yystates[yyi];
       else
        {
          yystackp->yytops.yystates[yyj] = yystackp->yytops.yystates[yyi];
+         /* In the current implementation, it's unnecessary to copy
+            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.yylookaheadNeeds[yyj] =
+           yystackp->yytops.yylookaheadNeeds[yyi];
          if (yyj != yyi)
            {
              YYDPRINTF ((stderr, "Rename stack %lu -> %lu.\n",
          if (yyj != yyi)
            {
              YYDPRINTF ((stderr, "Rename stack %lu -> %lu.\n",
@@ -1322,7 +1356,7 @@ yyglrShiftDefer (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState,
   yystackp->yytops.yystates[yyk] = yynewState;
 
   /* Invokes YY_RESERVE_GLRSTACK.  */
   yystackp->yytops.yystates[yyk] = yynewState;
 
   /* Invokes YY_RESERVE_GLRSTACK.  */
-  yyaddDeferredAction (yystackp, yynewState, rhs, yyrule);
+  yyaddDeferredAction (yystackp, yyk, yynewState, rhs, yyrule);
 }
 
 /** Pop the symbols consumed by reduction #RULE from the top of stack
 }
 
 /** Pop the symbols consumed by reduction #RULE from the top of stack
@@ -1474,7 +1508,7 @@ yyglrReduce (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
              {
                if (yyp->yylrState == yynewLRState && yyp->yypred == yys)
                  {
              {
                if (yyp->yylrState == yynewLRState && yyp->yypred == yys)
                  {
-                   yyaddDeferredAction (yystackp, yyp, yys0, yyrule);
+                   yyaddDeferredAction (yystackp, yyk, yyp, yys0, yyrule);
                    yymarkStackDeleted (yystackp, yyk);
                    YYDPRINTF ((stderr, "Merging stack %lu into stack %lu.\n",
                                (unsigned long int) yyk,
                    yymarkStackDeleted (yystackp, yyk);
                    YYDPRINTF ((stderr, "Merging stack %lu into stack %lu.\n",
                                (unsigned long int) yyk,
@@ -1501,17 +1535,35 @@ yysplitStack (yyGLRStack* yystackp, size_t yyk)
   if (yystackp->yytops.yysize >= yystackp->yytops.yycapacity)
     {
       yyGLRState** yynewStates;
   if (yystackp->yytops.yysize >= yystackp->yytops.yycapacity)
     {
       yyGLRState** yynewStates;
-      if (! ((yystackp->yytops.yycapacity
-             <= (YYSIZEMAX / (2 * sizeof yynewStates[0])))
-            && (yynewStates =
-                (yyGLRState**) YYREALLOC (yystackp->yytops.yystates,
-                                          ((yystackp->yytops.yycapacity *= 2)
-                                           * sizeof yynewStates[0])))))
+      yybool* yynewLookaheadNeeds;
+
+      yynewStates = NULL;
+
+      if (yystackp->yytops.yycapacity
+         > (YYSIZEMAX / (2 * sizeof yynewStates[0])))
+       yyMemoryExhausted (yystackp);
+      yystackp->yytops.yycapacity *= 2;
+
+      yynewStates =
+       (yyGLRState**) YYREALLOC (yystackp->yytops.yystates,
+                                 (yystackp->yytops.yycapacity
+                                  * sizeof yynewStates[0]));
+      if (yynewStates == NULL)
        yyMemoryExhausted (yystackp);
       yystackp->yytops.yystates = yynewStates;
        yyMemoryExhausted (yystackp);
       yystackp->yytops.yystates = yynewStates;
+
+      yynewLookaheadNeeds =
+       (yybool*) YYREALLOC (yystackp->yytops.yylookaheadNeeds,
+                            (yystackp->yytops.yycapacity
+                             * sizeof yynewLookaheadNeeds[0]));
+      if (yynewLookaheadNeeds == NULL)
+       yyMemoryExhausted (yystackp);
+      yystackp->yytops.yylookaheadNeeds = yynewLookaheadNeeds;
     }
   yystackp->yytops.yystates[yystackp->yytops.yysize]
     = yystackp->yytops.yystates[yyk];
     }
   yystackp->yytops.yystates[yystackp->yytops.yysize]
     = yystackp->yytops.yystates[yyk];
+  yystackp->yytops.yylookaheadNeeds[yystackp->yytops.yysize]
+    = yystackp->yytops.yylookaheadNeeds[yyk];
   yystackp->yytops.yysize += 1;
   return yystackp->yytops.yysize-1;
 }
   yystackp->yytops.yysize += 1;
   return yystackp->yytops.yysize-1;
 }
@@ -1616,50 +1668,71 @@ yypreference (yySemanticOption* y0, yySemanticOption* y1)
   return 0;
 }
 
   return 0;
 }
 
-static YYRESULTTAG yyresolveValue (yySemanticOption* yyoptionList,
-                                  yyGLRStack* yystackp, YYSTYPE* yyvalp,
-                                  YYLTYPE* yylocp]b4_user_formals[);
+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.  */
 static YYRESULTTAG
 yyresolveStates (yyGLRState* yys, int yyn,
                 yyGLRStack* yystackp]b4_user_formals[)
 {
 static YYRESULTTAG
 yyresolveStates (yyGLRState* yys, int yyn,
                 yyGLRStack* yystackp]b4_user_formals[)
 {
-  YYRESULTTAG yyflag;
   if (0 < yyn)
     {
       YYASSERT (yys->yypred);
   if (0 < yyn)
     {
       YYASSERT (yys->yypred);
-      yyflag = yyresolveStates (yys->yypred, yyn-1, yystackp]b4_user_args[);
-      if (yyflag != yyok)
-       return yyflag;
+      YYCHK (yyresolveStates (yys->yypred, yyn-1, yystackp]b4_user_args[));
       if (! yys->yyresolved)
       if (! yys->yyresolved)
-       {
-         yyflag = yyresolveValue (yys->yysemantics.yyfirstVal, yystackp,
-                                  &yys->yysemantics.yysval, &yys->yyloc
-                                 ]b4_user_args[);
-         if (yyflag != yyok)
-           return yyflag;
-         yys->yyresolved = yytrue;
-       }
+       YYCHK (yyresolveValue (yys, yystackp]b4_user_args[));
     }
   return yyok;
 }
 
     }
   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
+ *  semantic values if invoked).  */
 static YYRESULTTAG
 yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystackp,
                 YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[)
 {
   yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1];
   int yynrhs;
 static YYRESULTTAG
 yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystackp,
                 YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[)
 {
   yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1];
   int yynrhs;
+  int yychar_current;
+  YYSTYPE yylval_current;
+  YYLTYPE yylloc_current;
+  YYRESULTTAG yyflag;
 
   yynrhs = yyrhsLength (yyopt->yyrule);
 
   yynrhs = yyrhsLength (yyopt->yyrule);
-  YYCHK (yyresolveStates (yyopt->yystate, yynrhs, yystackp]b4_user_args[));
+  yyflag = yyresolveStates (yyopt->yystate, yynrhs, yystackp]b4_user_args[);
+  if (yyflag != yyok)
+    {
+      yyGLRState *yys;
+      for (yys = yyopt->yystate; yynrhs > 0; yys = yys->yypred, yynrhs -= 1)
+       yydestroyGLRState ("Cleanup: popping", yys]b4_user_args[);
+      return yyflag;
+    }
+
   yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred = yyopt->yystate;]b4_location_if([[
   if (yynrhs == 0)
     /* Set default location.  */
     yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].yystate.yyloc = yyopt->yystate->yyloc;]])[
   yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred = yyopt->yystate;]b4_location_if([[
   if (yynrhs == 0)
     /* Set default location.  */
     yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].yystate.yyloc = yyopt->yystate->yyloc;]])[
-  return yyuserAction (yyopt->yyrule, yynrhs,
-                      yyrhsVals + YYMAXRHS + YYMAXLEFT - 1,
-                      yyvalp, yylocp, yystackp]b4_user_args[);
+  yychar_current = yychar;
+  yylval_current = yylval;
+  yylloc_current = yylloc;
+  yychar = yyopt->yyrawchar;
+  yylval = yyopt->yyval;
+  yylloc = yyopt->yyloc;
+  yyflag = yyuserAction (yyopt->yyrule, yynrhs,
+                          yyrhsVals + YYMAXRHS + YYMAXLEFT - 1,
+                          yyvalp, yylocp, yystackp]b4_user_args[);
+  yychar = yychar_current;
+  yylval = yylval_current;
+  yylloc = yylloc_current;
+  return yyflag;
 }
 
 #if YYDEBUG
 }
 
 #if YYDEBUG
@@ -1710,12 +1783,9 @@ yyreportTree (yySemanticOption* yyx, int yyindent)
 }
 #endif
 
 }
 #endif
 
-static void yyreportAmbiguity (yySemanticOption* yyx0, yySemanticOption* yyx1,
-                              yyGLRStack* yystackp]b4_pure_formals[)
-  __attribute__ ((__noreturn__));
-static void
-yyreportAmbiguity (yySemanticOption* yyx0, yySemanticOption* yyx1,
-                  yyGLRStack* yystackp]b4_pure_formals[)
+/*ARGSUSED*/ static YYRESULTTAG
+yyreportAmbiguity (yySemanticOption* yyx0,
+                  yySemanticOption* yyx1]b4_pure_formals[)
 {
   YYUSE (yyx0);
   YYUSE (yyx1);
 {
   YYUSE (yyx0);
   YYUSE (yyx1);
@@ -1728,19 +1798,79 @@ yyreportAmbiguity (yySemanticOption* yyx0, yySemanticOption* yyx1,
   yyreportTree (yyx1, 2);
   YYFPRINTF (stderr, "\n");
 #endif
   yyreportTree (yyx1, 2);
   YYFPRINTF (stderr, "\n");
 #endif
-  yyFail (yystackp][]b4_pure_args[, YY_("syntax is ambiguous"));
+
+  yyerror (]b4_yyerror_args[YY_("syntax is ambiguous"));
+  return yyabort;
 }
 
 }
 
+/** 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.  */
+static void
+yyresolveLocations (yyGLRState* yys1, int yyn1,
+                   yyGLRStack *yystackp]b4_user_formals[)
+{
+  if (0 < yyn1)
+    {
+      yyresolveLocations (yys1->yypred, yyn1 - 1, yystackp]b4_user_args[);
+      if (!yys1->yyresolved)
+       {
+         yySemanticOption *yyoption;
+         yyGLRStackItem yyrhsloc[1 + YYMAXRHS];
+         int yynrhs;
+         int yychar_current;
+         YYSTYPE yylval_current;
+         YYLTYPE yylloc_current;
+         yyoption = yys1->yysemantics.yyfirstVal;
+         YYASSERT (yyoption != NULL);
+         yynrhs = yyrhsLength (yyoption->yyrule);
+         if (yynrhs > 0)
+           {
+             yyGLRState *yys;
+             int yyn;
+             yyresolveLocations (yyoption->yystate, yynrhs,
+                                 yystackp]b4_user_args[);
+             for (yys = yyoption->yystate, yyn = yynrhs;
+                  yyn > 0;
+                  yys = yys->yypred, yyn -= 1)
+               yyrhsloc[yyn].yystate.yyloc = yys->yyloc;
+           }
+         else
+           {
+             yyGLRState *yyprevious = yyoption->yystate;
+             YYASSERT (yyprevious->yyresolved);
+             yyrhsloc[0].yystate.yyloc = yyprevious->yyloc;
+           }
+         yychar_current = yychar;
+         yylval_current = yylval;
+         yylloc_current = yylloc;
+         yychar = yyoption->yyrawchar;
+         yylval = yyoption->yyval;
+         yylloc = yyoption->yyloc;
+         YYLLOC_DEFAULT ((yys1->yyloc), yyrhsloc, yynrhs);
+         yychar = yychar_current;
+         yylval = yylval_current;
+         yylloc = yylloc_current;
+       }
+    }
+}
 
 
-/** Resolve the ambiguity represented by OPTIONLIST, perform the indicated
- *  actions, and return the result.  */
+/** 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
+ *  yydestroyGLRState can be invoked if necessary.  */
 static YYRESULTTAG
 static YYRESULTTAG
-yyresolveValue (yySemanticOption* yyoptionList, yyGLRStack* yystackp,
-               YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[)
+yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp]b4_user_formals[)
 {
 {
+  yySemanticOption* yyoptionList = yys->yysemantics.yyfirstVal;
   yySemanticOption* yybest;
   yySemanticOption** yypp;
   yybool yymerge;
   yySemanticOption* yybest;
   yySemanticOption** yypp;
   yybool yymerge;
+  YYSTYPE yysval;
+  YYRESULTTAG yyflag;
+  YYLTYPE *yylocp = &yys->yyloc;
 
   yybest = yyoptionList;
   yymerge = yyfalse;
 
   yybest = yyoptionList;
   yymerge = yyfalse;
@@ -1758,7 +1888,8 @@ yyresolveValue (yySemanticOption* yyoptionList, yyGLRStack* yystackp,
          switch (yypreference (yybest, yyp))
            {
            case 0:
          switch (yypreference (yybest, yyp))
            {
            case 0:
-             yyreportAmbiguity (yybest, yyp, yystackp]b4_pure_args[);
+             yyresolveLocations (yys, 1, yystackp]b4_user_args[);
+             return yyreportAmbiguity (yybest, yyp]b4_pure_args[);
              break;
            case 1:
              yymerge = yytrue;
              break;
            case 1:
              yymerge = yytrue;
@@ -1783,22 +1914,39 @@ yyresolveValue (yySemanticOption* yyoptionList, yyGLRStack* yystackp,
     {
       yySemanticOption* yyp;
       int yyprec = yydprec[yybest->yyrule];
     {
       yySemanticOption* yyp;
       int yyprec = yydprec[yybest->yyrule];
-      YYCHK (yyresolveAction (yybest, yystackp, yyvalp, yylocp]b4_user_args[));
-      for (yyp = yybest->yynext; yyp != NULL; yyp = yyp->yynext)
-       {
-         if (yyprec == yydprec[yyp->yyrule])
-           {
-             YYSTYPE yyval1;
-             YYLTYPE yydummy;
-             YYCHK (yyresolveAction (yyp, yystackp, &yyval1,
-                                     &yydummy]b4_user_args[));
-             yyuserMerge (yymerger[yyp->yyrule], yyvalp, &yyval1);
-           }
-       }
-      return yyok;
+      yyflag = yyresolveAction (yybest, yystackp, &yysval,
+                               yylocp]b4_user_args[);
+      if (yyflag == yyok)
+       for (yyp = yybest->yynext; yyp != NULL; yyp = yyp->yynext)
+         {
+           if (yyprec == yydprec[yyp->yyrule])
+             {
+               YYSTYPE yysval_other;
+               YYLTYPE yydummy;
+               yyflag = yyresolveAction (yyp, yystackp, &yysval_other,
+                                         &yydummy]b4_user_args[);
+               if (yyflag != yyok)
+                 {
+                   yydestruct ("Cleanup: discarding incompletely merged value for",
+                               yystos[yys->yylrState],
+                               &yysval]b4_location_if([, yylocp])[]b4_user_args[);
+                   break;
+                 }
+               yyuserMerge (yymerger[yyp->yyrule], &yysval, &yysval_other);
+             }
+         }
     }
   else
     }
   else
-    return yyresolveAction (yybest, yystackp, yyvalp, yylocp]b4_user_args[);
+    yyflag = yyresolveAction (yybest, yystackp, &yysval, yylocp]b4_user_args[);
+
+  if (yyflag == yyok)
+    {
+      yys->yyresolved = yytrue;
+      yys->yysemantics.yysval = yysval;
+    }
+  else
+    yys->yysemantics.yyfirstVal = NULL;
+  return yyflag;
 }
 
 static YYRESULTTAG
 }
 
 static YYRESULTTAG
@@ -1851,12 +1999,11 @@ yycompressStack (yyGLRStack* yystackp)
 
 static YYRESULTTAG
 yyprocessOneStack (yyGLRStack* yystackp, size_t yyk,
 
 static YYRESULTTAG
 yyprocessOneStack (yyGLRStack* yystackp, size_t yyk,
-                  size_t yyposn]b4_pure_formals[)
+                  size_t yyposn]b4_pure_formals[)
 {
   int yyaction;
   const short int* yyconflicts;
   yyRuleNum yyrule;
 {
   int yyaction;
   const short int* yyconflicts;
   yyRuleNum yyrule;
-  yySymbol* const yytokenp = yystackp->yytokenp;
 
   while (yystackp->yytops.yystates[yyk] != NULL)
     {
 
   while (yystackp->yytops.yystates[yyk] != NULL)
     {
@@ -1880,14 +2027,18 @@ yyprocessOneStack (yyGLRStack* yystackp, size_t yyk,
        }
       else
        {
        }
       else
        {
-         if (*yytokenp == YYEMPTY)
+         yySymbol yytoken;
+         yystackp->yytops.yylookaheadNeeds[yyk] = yytrue;
+         if (yychar == YYEMPTY)
            {
              YYDPRINTF ((stderr, "Reading a token: "));
              yychar = YYLEX;
            {
              YYDPRINTF ((stderr, "Reading a token: "));
              yychar = YYLEX;
-             *yytokenp = YYTRANSLATE (yychar);
-             YY_SYMBOL_PRINT ("Next token is", *yytokenp, &yylval, &yylloc);
+             yytoken = YYTRANSLATE (yychar);
+             YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
            }
            }
-         yygetLRActions (yystate, *yytokenp, &yyaction, &yyconflicts);
+         else
+           yytoken = YYTRANSLATE (yychar);
+         yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts);
 
          while (*yyconflicts != 0)
            {
 
          while (*yyconflicts != 0)
            {
@@ -1897,8 +2048,8 @@ yyprocessOneStack (yyGLRStack* yystackp, size_t yyk,
                          (unsigned long int) yyk));
              YYCHK (yyglrReduce (yystackp, yynewStack,
                                  *yyconflicts, yyfalse]b4_user_args[));
                          (unsigned long int) yyk));
              YYCHK (yyglrReduce (yystackp, yynewStack,
                                  *yyconflicts, yyfalse]b4_user_args[));
-             YYCHK (yyprocessOneStack (yystackp, yynewStack,
-                                       yyposn]b4_pure_args[));
+             YYCHK (yyprocessOneStack (yystackp, yynewStack,
+                                       yyposn]b4_pure_args[));
              yyconflicts += 1;
            }
 
              yyconflicts += 1;
            }
 
@@ -1912,8 +2063,8 @@ yyprocessOneStack (yyGLRStack* yystackp, size_t yyk,
              break;
            }
          else
              break;
            }
          else
-           YYCHK (yyglrReduce (yystackp, yyk, -yyaction,
-                               yyfalse]b4_user_args[));
+           YYCHK (yyglrReduce (yystackp, yyk, -yyaction,
+                               yyfalse]b4_user_args[));
        }
     }
   return yyok;
        }
     }
   return yyok;
@@ -1925,12 +2076,12 @@ yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
   if (yystackp->yyerrState == 0)
     {
 #if YYERROR_VERBOSE
   if (yystackp->yyerrState == 0)
     {
 #if YYERROR_VERBOSE
-      yySymbol* const yytokenp = yystackp->yytokenp;
       int yyn;
       yyn = yypact[yystackp->yytops.yystates[0]->yylrState];
       if (YYPACT_NINF < yyn && yyn < YYLAST)
        {
       int yyn;
       yyn = yypact[yystackp->yytops.yystates[0]->yylrState];
       if (YYPACT_NINF < yyn && yyn < YYLAST)
        {
-         size_t yysize0 = yytnamerr (NULL, yytokenName (*yytokenp));
+         yySymbol yytoken = YYTRANSLATE (yychar);
+         size_t yysize0 = yytnamerr (NULL, yytokenName (yytoken));
          size_t yysize = yysize0;
          size_t yysize1;
          yybool yysize_overflow = yyfalse;
          size_t yysize = yysize0;
          size_t yysize1;
          yybool yysize_overflow = yyfalse;
@@ -1958,7 +2109,7 @@ yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
          int yycount = 1;
 
          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
          int yycount = 1;
 
-         yyarg[0] = yytokenName (*yytokenp);
+         yyarg[0] = yytokenName (yytoken);
          yyfmt = yystpcpy (yyformat, yyunexpected);
 
          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
          yyfmt = yystpcpy (yyformat, yyunexpected);
 
          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
@@ -2026,7 +2177,6 @@ yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
 /*ARGSUSED*/ static void
 yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
 {
 /*ARGSUSED*/ static void
 yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
 {
-  yySymbol* const yytokenp = yystackp->yytokenp;
   size_t yyk;
   int yyj;
 
   size_t yyk;
   int yyj;
 
@@ -2035,29 +2185,31 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
        reductions.  Skip tokens until we can proceed.  */
     while (YYID (yytrue))
       {
        reductions.  Skip tokens until we can proceed.  */
     while (YYID (yytrue))
       {
-       if (*yytokenp == YYEOF)
+       yySymbol yytoken;
+       if (yychar == YYEOF)
          yyFail (yystackp][]b4_lpure_args[, NULL);
          yyFail (yystackp][]b4_lpure_args[, NULL);
-       if (*yytokenp != YYEMPTY)
+       if (yychar != YYEMPTY)
          {]b4_location_if([[
            /* We throw away the lookahead, but the error range
               of the shifted error token must take it into account.  */
            yyGLRState *yys = yystackp->yytops.yystates[0];
            yyGLRStackItem yyerror_range[3];
            yyerror_range[1].yystate.yyloc = yys->yyloc;
          {]b4_location_if([[
            /* We throw away the lookahead, but the error range
               of the shifted error token must take it into account.  */
            yyGLRState *yys = yystackp->yytops.yystates[0];
            yyGLRStackItem yyerror_range[3];
            yyerror_range[1].yystate.yyloc = yys->yyloc;
-           yyerror_range[2].yystate.yyloc = yylloc;
-           YYLLOC_DEFAULT (yys->yyloc, yyerror_range, 2);]])[
+           yyerror_range[2].yystate.yyloc = yylloc;
+           YYLLOC_DEFAULT ((yys->yyloc), yyerror_range, 2);]])[
+           yytoken = YYTRANSLATE (yychar);
            yydestruct ("Error: discarding",
            yydestruct ("Error: discarding",
-                       *yytokenp, &yylval]b4_location_if([, &yylloc])[]b4_user_args[);
+                       yytoken, &yylval]b4_location_if([, &yylloc])[]b4_user_args[);
          }
        YYDPRINTF ((stderr, "Reading a token: "));
        yychar = YYLEX;
          }
        YYDPRINTF ((stderr, "Reading a token: "));
        yychar = YYLEX;
-       *yytokenp = YYTRANSLATE (yychar);
-       YY_SYMBOL_PRINT ("Next token is", *yytokenp, &yylval, &yylloc);
+       yytoken = YYTRANSLATE (yychar);
+       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
        yyj = yypact[yystackp->yytops.yystates[0]->yylrState];
        if (yyis_pact_ninf (yyj))
          return;
        yyj = yypact[yystackp->yytops.yystates[0]->yylrState];
        if (yyis_pact_ninf (yyj))
          return;
-       yyj += *yytokenp;
-       if (yyj < 0 || YYLAST < yyj || yycheck[yyj] != *yytokenp)
+       yyj += yytoken;
+       if (yyj < 0 || YYLAST < yyj || yycheck[yyj] != yytoken)
          {
            if (yydefact[yystackp->yytops.yystates[0]->yylrState] != 0)
              return;
          {
            if (yydefact[yystackp->yytops.yystates[0]->yylrState] != 0)
              return;
@@ -2091,12 +2243,12 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
            {
              /* Shift the error token having adjusted its location.  */
              YYLTYPE yyerrloc;]b4_location_if([[
            {
              /* Shift the error token having adjusted its location.  */
              YYLTYPE yyerrloc;]b4_location_if([[
-             yystackp->yyerror_range[2].yystate.yyloc = yylloc;
-             YYLLOC_DEFAULT (yyerrloc, yystackp->yyerror_range, 2);]])[
+             yystackp->yyerror_range[2].yystate.yyloc = yylloc;
+             YYLLOC_DEFAULT (yyerrloc, (yystackp->yyerror_range), 2);]])[
              YY_SYMBOL_PRINT ("Shifting", yystos[yytable[yyj]],
              YY_SYMBOL_PRINT ("Shifting", yystos[yytable[yyj]],
-                              &yylval, &yyerrloc);
+                              &yylval, &yyerrloc);
              yyglrShift (yystackp, 0, yytable[yyj],
              yyglrShift (yystackp, 0, yytable[yyj],
-                         yys->yyposn, &yylval, &yyerrloc);
+                         yys->yyposn, &yylval, &yyerrloc);
              yys = yystackp->yytops.yystates[0];
              break;
            }
              yys = yystackp->yytops.yystates[0];
              break;
            }
@@ -2135,14 +2287,13 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
 ]b4_c_ansi_function_def([yyparse], [int], b4_parse_param)[
 {
   int yyresult;
 ]b4_c_ansi_function_def([yyparse], [int], b4_parse_param)[
 {
   int yyresult;
-  yySymbol yytoken;
   yyGLRStack yystack;
   yyGLRStack* const yystackp = &yystack;
   size_t yyposn;
 
   YYDPRINTF ((stderr, "Starting parse\n"));
 
   yyGLRStack yystack;
   yyGLRStack* const yystackp = &yystack;
   size_t yyposn;
 
   YYDPRINTF ((stderr, "Starting parse\n"));
 
-  yytoken = YYEMPTY;
+  yychar = YYEMPTY;
   yylval = yyval_default;
 ]b4_location_if([
 #if YYLTYPE_IS_TRIVIAL
   yylval = yyval_default;
 ]b4_location_if([
 #if YYLTYPE_IS_TRIVIAL
@@ -2169,7 +2320,6 @@ b4_syncline([@oline@], [@ofile@])])dnl
     case 2: goto yyexhaustedlab;
     default: goto yybuglab;
     }
     case 2: goto yyexhaustedlab;
     default: goto yybuglab;
     }
-  yystack.yytokenp = &yytoken;
   yyglrShift (&yystack, 0, 0, 0, &yylval, &yylloc);
   yyposn = 0;
 
   yyglrShift (&yystack, 0, 0, 0, &yylval, &yylloc);
   yyposn = 0;
 
@@ -2194,38 +2344,41 @@ b4_syncline([@oline@], [@ofile@])])dnl
              yyrule = yydefaultAction (yystate);
              if (yyrule == 0)
                {
              yyrule = yydefaultAction (yystate);
              if (yyrule == 0)
                {
-]b4_location_if([[               yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[
-                 yyreportSyntaxError (&yystack]b4_user_args[);
+]b4_location_if([[               yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[
+                 yyreportSyntaxError (&yystack]b4_user_args[);
                  goto yyuser_error;
                }
              YYCHK1 (yyglrReduce (&yystack, 0, yyrule, yytrue]b4_user_args[));
            }
          else
            {
                  goto yyuser_error;
                }
              YYCHK1 (yyglrReduce (&yystack, 0, yyrule, yytrue]b4_user_args[));
            }
          else
            {
-             if (yytoken == YYEMPTY)
+             yySymbol yytoken;
+             if (yychar == YYEMPTY)
                {
                  YYDPRINTF ((stderr, "Reading a token: "));
                  yychar = YYLEX;
                  yytoken = YYTRANSLATE (yychar);
                {
                  YYDPRINTF ((stderr, "Reading a token: "));
                  yychar = YYLEX;
                  yytoken = YYTRANSLATE (yychar);
-                 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
+                 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
                }
                }
+             else
+               yytoken = YYTRANSLATE (yychar);
              yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts);
              if (*yyconflicts != 0)
                break;
              if (yyisShiftAction (yyaction))
                {
              yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts);
              if (*yyconflicts != 0)
                break;
              if (yyisShiftAction (yyaction))
                {
-                 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
-                 if (yytoken != YYEOF)
-                   yytoken = YYEMPTY;
+                 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
+                 if (yychar != YYEOF)
+                   yychar = YYEMPTY;
                  yyposn += 1;
                  yyposn += 1;
-                 yyglrShift (&yystack, 0, yyaction, yyposn, &yylval, &yylloc);
+                 yyglrShift (&yystack, 0, yyaction, yyposn, &yylval, &yylloc);
                  if (0 < yystack.yyerrState)
                    yystack.yyerrState -= 1;
                }
              else if (yyisErrorAction (yyaction))
                {
                  if (0 < yystack.yyerrState)
                    yystack.yyerrState -= 1;
                }
              else if (yyisErrorAction (yyaction))
                {
-]b4_location_if([[               yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[
-                 yyreportSyntaxError (&yystack]b4_user_args[);
+]b4_location_if([[               yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[
+                 yyreportSyntaxError (&yystack]b4_user_args[);
                  goto yyuser_error;
                }
              else
                  goto yyuser_error;
                }
              else
@@ -2237,7 +2390,9 @@ b4_syncline([@oline@], [@ofile@])])dnl
        {
          yySymbol yytoken_to_shift;
          size_t yys;
        {
          yySymbol yytoken_to_shift;
          size_t yys;
-         size_t yyn = yystack.yytops.yysize;
+
+         for (yys = 0; yys < yystack.yytops.yysize; yys += 1)
+           yystackp->yytops.yylookaheadNeeds[yys] = yychar != YYEMPTY;
 
          /* yyprocessOneStack returns one of three things:
 
 
          /* yyprocessOneStack returns one of three things:
 
@@ -2255,23 +2410,33 @@ b4_syncline([@oline@], [@ofile@])])dnl
             Except in the first case, yyparse will invoke yyremoveDeletes and
             then shift the next token onto all remaining stacks.  This
             synchronization of the shift (that is, after all preceding
             Except in the first case, yyparse will invoke yyremoveDeletes and
             then shift the next token onto all remaining stacks.  This
             synchronization of the shift (that is, after all preceding
-            reductions on all stacks) helps prevents double destructor calls
+            reductions on all stacks) helps prevent double destructor calls
             on yylval in the event of memory exhaustion.  */
 
             on yylval in the event of memory exhaustion.  */
 
-         for (yys = 0; yys < yyn; yys += 1)
-           YYCHK1 (yyprocessOneStack (&yystack, yys, yyposn]b4_lpure_args[));
+         for (yys = 0; yys < yystack.yytops.yysize; yys += 1)
+           YYCHK1 (yyprocessOneStack (&yystack, yys, yyposn]b4_lpure_args[));
          yyremoveDeletes (&yystack);
          yyremoveDeletes (&yystack);
-         yyn = yystack.yytops.yysize;
+         if (yystack.yytops.yysize == 0)
+           {
+             yyundeleteLastStack (&yystack);
+             if (yystack.yytops.yysize == 0)
+               yyFail (&yystack][]b4_lpure_args[, YY_("syntax error"));
+             YYCHK1 (yyresolveStack (&yystack]b4_user_args[));
+             YYDPRINTF ((stderr, "Returning to deterministic operation.\n"));
+]b4_location_if([[           yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[
+             yyreportSyntaxError (&yystack]b4_user_args[);
+             goto yyuser_error;
+           }
 
          /* If any yyglrShift call fails, it will fail after shifting.  Thus,
             a copy of yylval will already be on stack 0 in the event of a
 
          /* If any yyglrShift call fails, it will fail after shifting.  Thus,
             a copy of yylval will already be on stack 0 in the event of a
-            failure in the following loop.  Thus, yytoken is set to YYEMPTY
+            failure in the following loop.  Thus, yychar is set to YYEMPTY
             before the loop to make sure the user destructor for yylval isn't
             called twice.  */
             before the loop to make sure the user destructor for yylval isn't
             called twice.  */
-         yytoken_to_shift = yytoken;
-         yytoken = YYEMPTY;
+         yytoken_to_shift = YYTRANSLATE (yychar);
+         yychar = YYEMPTY;
          yyposn += 1;
          yyposn += 1;
-         for (yys = 0; yys < yyn; yys += 1)
+         for (yys = 0; yys < yystack.yytops.yysize; yys += 1)
            {
              int yyaction;
              const short int* yyconflicts;
            {
              int yyaction;
              const short int* yyconflicts;
@@ -2280,25 +2445,15 @@ b4_syncline([@oline@], [@ofile@])])dnl
                              &yyconflicts);
              /* Note that yyconflicts were handled by yyprocessOneStack.  */
              YYDPRINTF ((stderr, "On stack %lu, ", (unsigned long int) yys));
                              &yyconflicts);
              /* Note that yyconflicts were handled by yyprocessOneStack.  */
              YYDPRINTF ((stderr, "On stack %lu, ", (unsigned long int) yys));
-             YY_SYMBOL_PRINT ("shifting", yytoken_to_shift, &yylval, &yylloc);
+             YY_SYMBOL_PRINT ("shifting", yytoken_to_shift, &yylval, &yylloc);
              yyglrShift (&yystack, yys, yyaction, yyposn,
              yyglrShift (&yystack, yys, yyaction, yyposn,
-                         &yylval, &yylloc);
+                         &yylval, &yylloc);
              YYDPRINTF ((stderr, "Stack %lu now in state #%d\n",
                          (unsigned long int) yys,
                          yystack.yytops.yystates[yys]->yylrState));
            }
              YYDPRINTF ((stderr, "Stack %lu now in state #%d\n",
                          (unsigned long int) yys,
                          yystack.yytops.yystates[yys]->yylrState));
            }
-         if (yystack.yytops.yysize == 0)
-           {
-             yyundeleteLastStack (&yystack);
-             if (yystack.yytops.yysize == 0)
-               yyFail (&yystack][]b4_lpure_args[, YY_("syntax error"));
-             YYCHK1 (yyresolveStack (&yystack]b4_user_args[));
-             YYDPRINTF ((stderr, "Returning to deterministic operation.\n"));
-]b4_location_if([[           yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[
-             yyreportSyntaxError (&yystack]b4_user_args[);
-             goto yyuser_error;
-           }
-         else if (yystack.yytops.yysize == 1)
+
+         if (yystack.yytops.yysize == 1)
            {
              YYCHK1 (yyresolveStack (&yystack]b4_user_args[));
              YYDPRINTF ((stderr, "Returning to deterministic operation.\n"));
            {
              YYCHK1 (yyresolveStack (&yystack]b4_user_args[));
              YYDPRINTF ((stderr, "Returning to deterministic operation.\n"));
@@ -2330,9 +2485,10 @@ b4_syncline([@oline@], [@ofile@])])dnl
   goto yyreturn;
 
  yyreturn:
   goto yyreturn;
 
  yyreturn:
-  if (yytoken != YYEOF && yytoken != YYEMPTY)
+  if (yychar != YYEOF && yychar != YYEMPTY)
     yydestruct ("Cleanup: discarding lookahead",
     yydestruct ("Cleanup: discarding lookahead",
-               yytoken, &yylval]b4_location_if([, &yylloc])[]b4_user_args[);
+               YYTRANSLATE (yychar),
+               &yylval]b4_location_if([, &yylloc])[]b4_user_args[);
 
   /* If the stack is well-formed, pop the stack until it is empty,
      destroying its entries as we go.  But free the stack regardless
 
   /* If the stack is well-formed, pop the stack until it is empty,
      destroying its entries as we go.  But free the stack regardless
@@ -2442,7 +2598,7 @@ b4_epilogue
 m4_if(b4_defines_flag, 0, [],
 [@output @output_header_name@
 b4_copyright([Skeleton parser for GLR parsing with Bison],
 m4_if(b4_defines_flag, 0, [],
 [@output @output_header_name@
 b4_copyright([Skeleton parser for GLR parsing with Bison],
-            [2002, 2003, 2004, 2005])[
+            [2002, 2003, 2004, 2005, 2006])[
 
 /* C GLR parser skeleton written by Paul Hilfinger.  */
 ]
 
 /* C GLR parser skeleton written by Paul Hilfinger.  */
 ]
bison