* data/glr.c: Switch to Bison 2.2 special-exception language in

[bison.git] / data / glr.c

diff --git a/data/glr.c b/data/glr.c
index b82f5edee2862e56548512982c3126b26c35838e..29ea3bc7b4ba8ce3e9a7eb0bea6933d704804e5e 100644 (file)
--- a/data/glr.c
+++ b/data/glr.c
@@ -143,14 +143,27 @@ m4_define([b4_rhs_location],
 m4_changecom()
 m4_divert(0)dnl
 @output @output_parser_name@
 m4_changecom()
 m4_divert(0)dnl
 @output @output_parser_name@

-b4_copyright([Skeleton parser for GLR parsing with Bison],
+b4_copyright([Skeleton implementation for Bison GLR parsers in C],

   [2002, 2003, 2004, 2005, 2006])
 [
   [2002, 2003, 2004, 2005, 2006])
 [

-/* This is the parser code for GLR (Generalized LR) parser.  */
+/* As a special exception, you may create a larger work that contains
+   part or all of the Bison parser skeleton and distribute that work
+   under terms of your choice, so long as that work isn't itself a
+   parser generator using the skeleton or a modified version thereof
+   as a parser skeleton.  Alternatively, if you modify or redistribute
+   the parser skeleton itself, you may (at your option) remove this
+   special exception, which will cause the skeleton and the resulting
+   Bison output files to be licensed under the GNU General Public
+   License without this special exception.
+
+   This special exception was added by the Free Software Foundation in
+   version 2.2 of Bison.  */
+
+/* C GLR parser skeleton written by Paul Hilfinger.  */

 
 ]b4_identification
 
 
 ]b4_identification
 

-m4_if(b4_prefix[], [yy], [],
+m4_if(b4_prefix, [yy], [],

 [/* Substitute the variable and function names.  */
 #define yyparse b4_prefix[]parse
 #define yylex   b4_prefix[]lex
 [/* Substitute the variable and function names.  */
 #define yyparse b4_prefix[]parse
 #define yylex   b4_prefix[]lex


@@ -171,7 +184,7 @@ 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],
 [typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])
 b4_stype
 ]m4_ifdef([b4_stype],
 [typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])
 b4_stype


@@ -183,7 +196,7 @@ b4_syncline([@oline@], [@ofile@])
 # define YYSTYPE_IS_TRIVIAL 1
 #endif
 
 # 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([


@@ -253,7 +266,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 */


@@ -302,7 +315,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


@@ -563,9 +576,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 {                                           \


@@ -621,9 +634,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


@@ -648,7 +661,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


@@ -761,11 +774,11 @@ struct yyGLRState {
 
 struct yyGLRStateSet {
   yyGLRState** yystates;
 
 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
    *  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.  */
    *  duplicate yychar != YYEMPTY.  */

-  yybool* yylookaheadStatuses;
+  yybool* yylookaheadNeeds;

   size_t yysize, yycapacity;
 };
 
   size_t yysize, yycapacity;
 };
 


@@ -803,7 +816,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;


@@ -910,7 +922,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


@@ -923,7 +935,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)


@@ -980,7 +992,10 @@ 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],
                           NULL]b4_location_if([, &yys->yyloc])[]b4_user_args[);
          YYFPRINTF (stderr, "\n");
          yy_symbol_print (stderr, yystos[yys->yylrState],
                           NULL]b4_location_if([, &yys->yyloc])[]b4_user_args[);
          YYFPRINTF (stderr, "\n");


@@ -1103,7 +1118,7 @@ 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
 
 /** 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 
+ *  alternative actions for STATE.  Assumes that RHS comes from

  *  stack #K of *STACKP. */
 static void
 yyaddDeferredAction (yyGLRStack* yystackp, size_t yyk, yyGLRState* yystate,
  *  stack #K of *STACKP. */
 static void
 yyaddDeferredAction (yyGLRStack* yystackp, size_t yyk, yyGLRState* yystate,


@@ -1113,7 +1128,7 @@ yyaddDeferredAction (yyGLRStack* yystackp, size_t yyk, yyGLRState* yystate,
     &yynewGLRStackItem (yystackp, yyfalse)->yyoption;
   yynewOption->yystate = rhs;
   yynewOption->yyrule = yyrule;
     &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;
     {
       yynewOption->yyrawchar = yychar;
       yynewOption->yyval = yylval;


@@ -1139,9 +1154,9 @@ yyinitStateSet (yyGLRStateSet* yyset)
   if (! yyset->yystates)
     return yyfalse;
   yyset->yystates[0] = NULL;
   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;
     {
       YYFREE (yyset->yystates);
       return yyfalse;


@@ -1152,7 +1167,7 @@ yyinitStateSet (yyGLRStateSet* yyset)
 static void yyfreeStateSet (yyGLRStateSet* yyset)
 {
   YYFREE (yyset->yystates);
 static void yyfreeStateSet (yyGLRStateSet* yyset)
 {
   YYFREE (yyset->yystates);

-  YYFREE (yyset->yylookaheadStatuses);
+  YYFREE (yyset->yylookaheadNeeds);

 }
 
 /** Initialize STACK to a single empty stack, with total maximum
 }
 
 /** Initialize STACK to a single empty stack, with total maximum


@@ -1191,7 +1206,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)


@@ -1300,12 +1315,12 @@ yyremoveDeletes (yyGLRStack* yystackp)
        {
          yystackp->yytops.yystates[yyj] = yystackp->yytops.yystates[yyi];
          /* In the current implementation, it's unnecessary to copy
        {
          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.  */
             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",
          if (yyj != yyi)
            {
              YYDPRINTF ((stderr, "Rename stack %lu -> %lu.\n",


@@ -1533,26 +1548,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;

-      yybool* yynewLookaheadStatuses;
-      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;

-      if (! (yynewLookaheadStatuses =
-            (yybool*) YYREALLOC (yystackp->yytops.yylookaheadStatuses,
-                                 ((yystackp->yytops.yycapacity)
-                                  * sizeof yynewLookaheadStatuses[0]))))
+
+      yynewLookaheadNeeds =
+       (yybool*) YYREALLOC (yystackp->yytops.yylookaheadNeeds,
+                            (yystackp->yytops.yycapacity
+                             * sizeof yynewLookaheadNeeds[0]));
+      if (yynewLookaheadNeeds == NULL)

        yyMemoryExhausted (yystackp);
        yyMemoryExhausted (yystackp);

-      yystackp->yytops.yylookaheadStatuses = yynewLookaheadStatuses;
+      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.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;
 }
   yystackp->yytops.yysize += 1;
   return yystackp->yytops.yysize-1;
 }


@@ -1658,9 +1682,14 @@ yypreference (yySemanticOption* y0, yySemanticOption* y1)
 }
 
 static YYRESULTTAG yyresolveValue (yyGLRState* yys,
 }
 
 static YYRESULTTAG yyresolveValue (yyGLRState* yys,

-                                  yyGLRStack* yystackp, YYSTYPE* yyvalp,
-                                  YYLTYPE* yylocp]b4_user_formals[);
+                                  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[)


@@ -1670,22 +1699,15 @@ yyresolveStates (yyGLRState* yys, int yyn,
       YYASSERT (yys->yypred);
       YYCHK (yyresolveStates (yys->yypred, yyn-1, yystackp]b4_user_args[));
       if (! yys->yyresolved)
       YYASSERT (yys->yypred);
       YYCHK (yyresolveStates (yys->yypred, yyn-1, yystackp]b4_user_args[));
       if (! yys->yyresolved)

-       {
-         YYSTYPE yysval;
-         YYRESULTTAG yyflag = yyresolveValue (yys, yystackp, &yysval,
-                                              &yys->yyloc]b4_user_args[);
-         if (yyflag != yyok)
-           {
-             yys->yysemantics.yyfirstVal = NULL;
-             return yyflag;
-           }
-         yys->yysemantics.yysval = yysval;
-         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[)
 static YYRESULTTAG
 yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystackp,
                 YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[)


@@ -1695,10 +1717,18 @@ yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystackp,
   int yychar_current;
   YYSTYPE yylval_current;
   YYLTYPE yylloc_current;
   int yychar_current;
   YYSTYPE yylval_current;
   YYLTYPE yylloc_current;

-  YYRESULTTAG yyresult;
+  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].yystate.yypred = yyopt->yystate;]b4_location_if([[
   if (yynrhs == 0)
     /* Set default location.  */


@@ -1709,13 +1739,13 @@ yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystackp,
   yychar = yyopt->yyrawchar;
   yylval = yyopt->yyval;
   yylloc = yyopt->yyloc;
   yychar = yyopt->yyrawchar;
   yylval = yyopt->yyval;
   yylloc = yyopt->yyloc;

-  yyresult = yyuserAction (yyopt->yyrule, yynrhs,
+  yyflag = yyuserAction (yyopt->yyrule, yynrhs,

                           yyrhsVals + YYMAXRHS + YYMAXLEFT - 1,
                           yyvalp, yylocp, yystackp]b4_user_args[);
   yychar = yychar_current;
   yylval = yylval_current;
   yylloc = yylloc_current;
                           yyrhsVals + YYMAXRHS + YYMAXLEFT - 1,
                           yyvalp, yylocp, yystackp]b4_user_args[);
   yychar = yychar_current;
   yylval = yylval_current;
   yylloc = yylloc_current;

-  return yyresult;
+  return yyflag;

 }
 
 #if YYDEBUG
 }
 
 #if YYDEBUG


@@ -1766,12 +1796,9 @@ yyreportTree (yySemanticOption* yyx, int yyindent)
 }
 #endif
 
 }
 #endif
 

-static void yyreportAmbiguity (yySemanticOption* yyx0, yySemanticOption* yyx1,
-                              yyGLRStack* yystackp]b4_pure_formals[)
-  __attribute__ ((__noreturn__));
-/*ARGSUSED*/ 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);


@@ -1784,20 +1811,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 in state S, perform the indicated
 
 /** Resolve the ambiguity represented in state S, perform the indicated

- *  actions, and return the result.  */
+ *  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 (yyGLRState* yys, 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* yyoptionList = yys->yysemantics.yyfirstVal;
   yySemanticOption* yybest;
   yySemanticOption** yypp;
   yybool yymerge;

+  YYSTYPE yysval;
+  YYRESULTTAG yyflag;
+  YYLTYPE *yylocp = &yys->yyloc;

 
   yybest = yyoptionList;
   yymerge = yyfalse;
 
   yybest = yyoptionList;
   yymerge = yyfalse;


@@ -1815,7 +1901,8 @@ yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp, YYSTYPE* yyvalp,
          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;


@@ -1840,29 +1927,39 @@ yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp, YYSTYPE* yyvalp,
     {
       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;
-             YYRESULTTAG yyflag = yyresolveAction (yyp, yystackp, &yyval1,
-                                                   &yydummy]b4_user_args[);
-             if (yyflag != yyok)
-               {
-                 yydestruct ("Cleanup: discarding merged value",
-                             yystos[yys->yylrState],
-                             yyvalp]b4_location_if([, yylocp])[]b4_user_args[);
-                 return yyflag;
-               }
-             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
+    yyflag = yyresolveAction (yybest, yystackp, &yysval, yylocp]b4_user_args[);
+
+  if (yyflag == yyok)
+    {
+      yys->yyresolved = yytrue;
+      yys->yysemantics.yysval = yysval;

     }
   else
     }
   else

-    return yyresolveAction (yybest, yystackp, yyvalp, yylocp]b4_user_args[);
+    yys->yysemantics.yyfirstVal = NULL;
+  return yyflag;

 }
 
 static YYRESULTTAG
 }
 
 static YYRESULTTAG


@@ -1920,7 +2017,6 @@ yyprocessOneStack (yyGLRStack* yystackp, size_t yyk,
   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)
     {


@@ -1944,15 +2040,18 @@ yyprocessOneStack (yyGLRStack* yystackp, size_t yyk,
        }
       else
        {
        }
       else
        {

-         yystackp->yytops.yylookaheadStatuses[yyk] = yytrue;
-         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)
            {


@@ -1990,12 +2089,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;


@@ -2023,7 +2122,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)


@@ -2091,7 +2190,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;
 


@@ -2100,9 +2198,10 @@ 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.  */
          {]b4_location_if([[
            /* We throw away the lookahead, but the error range
               of the shifted error token must take it into account.  */


@@ -2110,19 +2209,20 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
            yyGLRStackItem yyerror_range[3];
            yyerror_range[1].yystate.yyloc = yys->yyloc;
            yyerror_range[2].yystate.yyloc = yylloc;
            yyGLRStackItem yyerror_range[3];
            yyerror_range[1].yystate.yyloc = yys->yyloc;
            yyerror_range[2].yystate.yyloc = yylloc;

-           YYLLOC_DEFAULT (yys->yyloc, yyerror_range, 2);]])[
+           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;


@@ -2157,7 +2257,7 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
              /* Shift the error token having adjusted its location.  */
              YYLTYPE yyerrloc;]b4_location_if([[
              yystackp->yyerror_range[2].yystate.yyloc = yylloc;
              /* 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);]])[
+             YYLLOC_DEFAULT (yyerrloc, (yystackp->yyerror_range), 2);]])[

              YY_SYMBOL_PRINT ("Shifting", yystos[yytable[yyj]],
                               &yylval, &yyerrloc);
              yyglrShift (yystackp, 0, yytable[yyj],
              YY_SYMBOL_PRINT ("Shifting", yystos[yytable[yyj]],
                               &yylval, &yyerrloc);
              yyglrShift (yystackp, 0, yytable[yyj],


@@ -2200,7 +2300,6 @@ 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;
   yyGLRStack yystack;
   yyGLRStack* const yystackp = &yystack;
   size_t yyposn;


@@ -2208,7 +2307,6 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
   YYDPRINTF ((stderr, "Starting parse\n"));
 
   yychar = YYEMPTY;
   YYDPRINTF ((stderr, "Starting parse\n"));
 
   yychar = YYEMPTY;

-  yytoken = YYEMPTY;

   yylval = yyval_default;
 ]b4_location_if([
 #if YYLTYPE_IS_TRIVIAL
   yylval = yyval_default;
 ]b4_location_if([
 #if YYLTYPE_IS_TRIVIAL


@@ -2235,7 +2333,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;
 


@@ -2268,24 +2365,24 @@ b4_syncline([@oline@], [@ofile@])])dnl
            }
          else
            {
            }
          else
            {

-             if (yytoken == YYEMPTY)
+             yySymbol yytoken;
+             if (yychar == YYEMPTY)

                {
                  YYDPRINTF ((stderr, "Reading a token: "));
                  yychar = YYLEX;
                  yytoken = YYTRANSLATE (yychar);
                  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
                }
                {
                  YYDPRINTF ((stderr, "Reading a token: "));
                  yychar = YYLEX;
                  yytoken = YYTRANSLATE (yychar);
                  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))
                {
                  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
              yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts);
              if (*yyconflicts != 0)
                break;
              if (yyisShiftAction (yyaction))
                {
                  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);

-                 if (yytoken != YYEOF)
-                   {
-                     yychar = YYEMPTY;
-                     yytoken = YYEMPTY;
-                   }
+                 if (yychar != YYEOF)
+                   yychar = YYEMPTY;

                  yyposn += 1;
                  yyglrShift (&yystack, 0, yyaction, yyposn, &yylval, &yylloc);
                  if (0 < yystack.yyerrState)
                  yyposn += 1;
                  yyglrShift (&yystack, 0, yyaction, yyposn, &yylval, &yylloc);
                  if (0 < yystack.yyerrState)


@@ -2306,10 +2403,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 < yyn; yys += 1)
-           yystackp->yytops.yylookaheadStatuses[yys] = yychar != YYEMPTY;
+         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:
 


@@ -2327,24 +2423,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)
+         for (yys = 0; yys < yystack.yytops.yysize; yys += 1)

            YYCHK1 (yyprocessOneStack (&yystack, yys, yyposn]b4_lpure_args[));
          yyremoveDeletes (&yystack);
            YYCHK1 (yyprocessOneStack (&yystack, yys, yyposn]b4_lpure_args[));
          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_to_shift = YYTRANSLATE (yychar);

          yychar = YYEMPTY;
          yychar = YYEMPTY;

-         yytoken = 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;


@@ -2360,18 +2465,8 @@ b4_syncline([@oline@], [@ofile@])])dnl
                          (unsigned long int) yys,
                          yystack.yytops.yystates[yys]->yylrState));
            }
                          (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"));


@@ -2403,9 +2498,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


@@ -2514,10 +2610,21 @@ yypdumpstack (yyGLRStack* yystackp)
 b4_epilogue
 m4_if(b4_defines_flag, 0, [],
 [@output @output_header_name@
 b4_epilogue
 m4_if(b4_defines_flag, 0, [],
 [@output @output_header_name@

-b4_copyright([Skeleton parser for GLR parsing with Bison],
-            [2002, 2003, 2004, 2005, 2006])[
-
-/* C GLR parser skeleton written by Paul Hilfinger.  */
+b4_copyright([Skeleton interface for Bison GLR parsers in C],
+  [2002, 2003, 2004, 2005, 2006])
+[
+/* As a special exception, you may create a larger work that contains
+   part or all of the Bison parser skeleton and distribute that work
+   under terms of your choice, so long as that work isn't itself a
+   parser generator using the skeleton or a modified version thereof
+   as a parser skeleton.  Alternatively, if you modify or redistribute
+   the parser skeleton itself, you may (at your option) remove this
+   special exception, which will cause the skeleton and the resulting
+   Bison output files to be licensed under the GNU General Public
+   License without this special exception.
+
+   This special exception was added by the Free Software Foundation in
+   version 2.2 of Bison.  */

 ]
 
 b4_shared_declarations
 ]
 
 b4_shared_declarations