(symbol_user_token_number_set, symbol_make_alias, symbol_pack):

[bison.git] / data / glr.c

diff --git a/data/glr.c b/data/glr.c
index 7191458f6795822b3110d6f8c689df430cbbc1d5..ef8d731ee0280bf46d50d54ee51cb75308393f9a 100644 (file)
--- a/data/glr.c
+++ b/data/glr.c
@@ -146,7 +146,6 @@ b4_copyright([Skeleton parser for GLR parsing with Bison], [2002])
 [
 /* This is the parser code for GLR (Generalized LR) parser. */
 
 [
 /* This is the parser code for GLR (Generalized LR) parser. */
 

-#include <assert.h>

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>


@@ -243,10 +242,6 @@ b4_syncline([@oline@], [@ofile@])
 # define ATTRIBUTE_UNUSED __attribute__ ((__unused__))
 #endif
 
 # define ATTRIBUTE_UNUSED __attribute__ ((__unused__))
 #endif
 

-#if ! defined (__GNUC__)
-# define inline
-#endif
-

 /* YYFINAL -- State number of the termination state. */
 #define YYFINAL  ]b4_final_state_number[
 /* YYLAST -- Last index in YYTABLE.  */
 /* YYFINAL -- State number of the termination state. */
 #define YYFINAL  ]b4_final_state_number[
 /* YYLAST -- Last index in YYTABLE.  */


@@ -364,7 +359,7 @@ static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] =
 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
    positive, shift that token.  If negative, reduce the rule which
    number is the opposite.  If zero, do what YYDEFACT says.
 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
    positive, shift that token.  If negative, reduce the rule which
    number is the opposite.  If zero, do what YYDEFACT says.

-   If YYTABLE_NINF, parse error.  */
+   If YYTABLE_NINF, syntax error.  */

 #define YYTABLE_NINF ]b4_table_ninf[
 static const ]b4_int_type_for([b4_table])[ yytable[] =
 {
 #define YYTABLE_NINF ]b4_table_ninf[
 static const ]b4_int_type_for([b4_table])[ yytable[] =
 {


@@ -395,6 +390,13 @@ static const ]b4_int_type_for([b4_check])[ yycheck[] =
   ]b4_check[
 };
 
   ]b4_check[
 };
 

+/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
+   symbol of state STATE-NUM.  */
+static const ]b4_int_type_for([b4_stos])[ yystos[] =
+{
+  ]b4_stos[
+};
+

 \f
 /* Prevent warning if -Wmissing-prototypes.  */
 ]b4_c_ansi_function_decl([yyparse], [int], b4_parse_param)[
 \f
 /* Prevent warning if -Wmissing-prototypes.  */
 ]b4_c_ansi_function_decl([yyparse], [int], b4_parse_param)[


@@ -451,12 +453,37 @@ do {                                              \
   if (yydebug)                                 \
     YYFPRINTF Args;                            \
 } while (0)
   if (yydebug)                                 \
     YYFPRINTF Args;                            \
 } while (0)

+
+]b4_yysymprint_generate([b4_c_ansi_function_def])[
+
+# define YYDSYMPRINT(Args)                     \
+do {                                           \
+  if (yydebug)                                 \
+    yysymprint Args;                           \
+} while (0)
+
+# define YYDSYMPRINTF(Title, Token, Value, Location)           \
+do {                                                           \
+  if (yydebug)                                                 \
+    {                                                          \
+      YYFPRINTF (stderr, "%s ", Title);                                \
+      yysymprint (stderr,                                      \
+                  Token, Value]b4_location_if([, Location])[); \
+      YYFPRINTF (stderr, "\n");                                        \
+    }                                                          \
+} while (0)
+

 /* Nonzero means print parse trace.  It is left uninitialized so that
    multiple parsers can coexist.  */
 int yydebug;
 /* Nonzero means print parse trace.  It is left uninitialized so that
    multiple parsers can coexist.  */
 int yydebug;

+

 #else /* !YYDEBUG */
 #else /* !YYDEBUG */

+

   /* Avoid empty `if' bodies.  */
   /* Avoid empty `if' bodies.  */

-# define YYDPRINTF(Args)  {}
+# define YYDPRINTF(Args)
+# define YYDSYMPRINT(Args)
+# define YYDSYMPRINTF(Title, Token, Value, Location)
+

 #endif /* !YYDEBUG */
 
 /* YYINITDEPTH -- initial size of the parser's stacks.  */
 #endif /* !YYDEBUG */
 
 /* YYINITDEPTH -- initial size of the parser's stacks.  */


@@ -566,12 +593,12 @@ static void yyfreeGLRStack (yyGLRStack* yystack);
 static void
 yyFail (yyGLRStack* yystack]b4_pure_formals[, const char* yyformat, ...)
 {
 static void
 yyFail (yyGLRStack* yystack]b4_pure_formals[, const char* yyformat, ...)
 {

+  yystack->yyerrflag = 1;

   if (yyformat != NULL)
     {
       char yymsg[256];
       va_list yyap;
       va_start (yyap, yyformat);
   if (yyformat != NULL)
     {
       char yymsg[256];
       va_list yyap;
       va_start (yyap, yyformat);

-      yystack->yyerrflag = 1;

       vsprintf (yymsg, yyformat, yyap);
       yyerror (]b4_yyerror_args[yymsg);
     }
       vsprintf (yymsg, yyformat, yyap);
       yyerror (]b4_yyerror_args[yymsg);
     }


@@ -611,8 +638,6 @@ yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,
       *yyvalp = yyvsp[1-yyrhslen].yystate.yysemantics.yysval;
       *yylocp = yyvsp[1-yyrhslen].yystate.yyloc;
     }
       *yyvalp = yyvsp[1-yyrhslen].yystate.yysemantics.yysval;
       *yylocp = yyvsp[1-yyrhslen].yystate.yyloc;
     }

-# undef yyval
-# define yyval (*yyvalp)

 # undef yyerrok
 # define yyerrok (yystack->yyerrState = 0)
 # undef YYACCEPT
 # undef yyerrok
 # define yyerrok (yystack->yyerrState = 0)
 # undef YYACCEPT


@@ -639,7 +664,6 @@ yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,
      }
 
    return yyok;
      }
 
    return yyok;

-# undef yyval

 # undef yyerrok
 # undef YYABORT
 # undef YYACCEPT
 # undef yyerrok
 # undef YYABORT
 # undef YYACCEPT


@@ -669,6 +693,8 @@ yyuserMerge (int yyn, YYSTYPE* yy0, YYSTYPE* yy1)
 [
                              /* Bison grammar-table manipulation.  */
 
 [
                              /* Bison grammar-table manipulation.  */
 

+]b4_yydestruct_generate([b4_c_ansi_function_def])[
+

 /** Number of symbols composing the right hand side of rule #RULE. */
 static inline int
 yyrhsLength (yyRuleNum yyrule)
 /** Number of symbols composing the right hand side of rule #RULE. */
 static inline int
 yyrhsLength (yyRuleNum yyrule)


@@ -703,10 +729,10 @@ yydefaultAction (yyStateNum yystate)
   return yydefact[yystate];
 }
 
   return yydefact[yystate];
 }
 

-#define yyis_table_ninf(yyindex) \
+#define yyis_table_ninf(yytable_value) \

   ]m4_if(m4_eval(b4_table_ninf < b4_table_min), 1,
         0,
   ]m4_if(m4_eval(b4_table_ninf < b4_table_min), 1,
         0,

-        ((yyindex) == YYTABLE_NINF))[
+        ((yytable_value) == YYTABLE_NINF))[

 
 /** Set *YYACTION to the action to take in YYSTATE on seeing YYTOKEN.
  *  Result R means
 
 /** Set *YYACTION to the action to take in YYSTATE on seeing YYTOKEN.
  *  Result R means


@@ -726,7 +752,7 @@ yygetLRActions (yyStateNum yystate, int yytoken,
       *yyaction = -yydefact[yystate];
       *yyconflicts = yyconfl;
     }
       *yyaction = -yydefact[yystate];
       *yyconflicts = yyconfl;
     }

-  else if (! yyis_table_ninf (yyindex))
+  else if (! yyis_table_ninf (yytable[yyindex]))

     {
       *yyaction = yytable[yyindex];
       *yyconflicts = yyconfl + yyconflp[yyindex];
     {
       *yyaction = yytable[yyindex];
       *yyconflicts = yyconfl + yyconflp[yyindex];


@@ -763,14 +789,6 @@ yyisErrorAction (int yyaction)
 
                                /* GLRStates */
 
 
                                /* GLRStates */
 

-/** True iff the semantic value of the edge leading to STATE is
- *  resolved. */
-static inline bool
-yyhasResolvedValue (yyGLRState* yystate)
-{
-  return yystate->yyresolved;
-}
-

 static void
 yyaddDeferredAction (yyGLRStack* yystack, yyGLRState* yystate,
                     yyGLRState* rhs, yyRuleNum yyrule]b4_pure_formals[)
 static void
 yyaddDeferredAction (yyGLRStack* yystack, yyGLRState* yystate,
                     yyGLRState* rhs, yyRuleNum yyrule]b4_pure_formals[)


@@ -839,8 +857,7 @@ yyexpandGLRStack (yyGLRStack* yystack]b4_pure_formals[)
   size_t yyn;
   yysize = yystack->yynextFree - yystack->yyitems;
   if (YYMAXDEPTH <= yysize)
   size_t yyn;
   yysize = yystack->yynextFree - yystack->yyitems;
   if (YYMAXDEPTH <= yysize)

-    yyFail (yystack][]b4_pure_args[,
-           "parsing stack overflow (%d items)", yysize);
+    yyFail (yystack][]b4_pure_args[, "parser stack overflow");

   yynewSize = 2*yysize;
   if (YYMAXDEPTH < yynewSize)
     yynewSize = YYMAXDEPTH;
   yynewSize = 2*yysize;
   if (YYMAXDEPTH < yynewSize)
     yynewSize = YYMAXDEPTH;


@@ -887,8 +904,7 @@ yyexpandGLRStack (yyGLRStack* yystack]b4_pure_formals[)
 
 #else
 
 
 #else
 

-  yyFail (yystack][]b4_lpure_args[,
-          "parsing stack overflow (%d items)", yysize);
+  yyFail (yystack][]b4_lpure_args[, "parser stack overflow");

 #endif
 }
 
 #endif
 }
 


@@ -942,14 +958,18 @@ yyremoveDeletes (yyGLRStack* yystack)
       if (yystack->yytops.yystates[yyi] == NULL)
        {
          if (yyi == yyj)
       if (yystack->yytops.yystates[yyi] == NULL)
        {
          if (yyi == yyj)

-           YYDPRINTF ((stderr, "Removing dead stacks.\n"));
+           {
+             YYDPRINTF ((stderr, "Removing dead stacks.\n"));
+           }

          yystack->yytops.yysize -= 1;
        }
       else
        {
          yystack->yytops.yystates[yyj] = yystack->yytops.yystates[yyi];
          if (yyj != yyi)
          yystack->yytops.yysize -= 1;
        }
       else
        {
          yystack->yytops.yystates[yyj] = yystack->yytops.yystates[yyi];
          if (yyj != yyi)

-           YYDPRINTF ((stderr, "Rename stack %d -> %d.\n", yyi, yyj));
+           {
+             YYDPRINTF ((stderr, "Rename stack %d -> %d.\n", yyi, yyj));
+           }

          yyj += 1;
        }
       yyi += 1;
          yyj += 1;
        }
       yyi += 1;


@@ -1007,7 +1027,7 @@ yyglrShiftDefer (yyGLRStack* yystack, int yyk, yyStateNum yylrState,
  *  have been previously resolved. Set *VALP to the resulting value,
  *  and *LOCP to the computed location (if any).  Return value is as
  *  for userAction. */
  *  have been previously resolved. Set *VALP to the resulting value,
  *  and *LOCP to the computed location (if any).  Return value is as
  *  for userAction. */

-static inline int
+static inline YYRESULTTAG

 yydoAction (yyGLRStack* yystack, int yyk, yyRuleNum yyrule,
            YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[)
 {
 yydoAction (yyGLRStack* yystack, int yyk, yyRuleNum yyrule,
            YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[)
 {


@@ -1017,7 +1037,8 @@ yydoAction (yyGLRStack* yystack, int yyk, yyRuleNum yyrule,
     {
       /* Standard special case: single stack. */
       yyGLRStackItem* rhs = (yyGLRStackItem*) yystack->yytops.yystates[yyk];
     {
       /* Standard special case: single stack. */
       yyGLRStackItem* rhs = (yyGLRStackItem*) yystack->yytops.yystates[yyk];

-      assert (yyk == 0);
+      if (yyk != 0)
+       abort ();

       yystack->yynextFree -= yynrhs;
       yystack->yyspaceLeft += yynrhs;
       yystack->yytops.yystates[0] = & yystack->yynextFree[-1].yystate;
       yystack->yynextFree -= yynrhs;
       yystack->yyspaceLeft += yynrhs;
       yystack->yytops.yystates[0] = & yystack->yynextFree[-1].yystate;


@@ -1042,7 +1063,8 @@ yydoAction (yyGLRStack* yystack, int yyk, yyRuleNum yyrule,
       for (yyi = yynrhs-1, yys = yystack->yytops.yystates[yyk]; 0 <= yyi;
           yyi -= 1, yys = yys->yypred)
        {
       for (yyi = yynrhs-1, yys = yystack->yytops.yystates[yyk]; 0 <= yyi;
           yyi -= 1, yys = yys->yypred)
        {

-         assert (yys->yypred != NULL);
+         if (! yys->yypred)
+           abort ();

          yyrhsVals[yyi].yystate.yyresolved = yytrue;
          yyrhsVals[yyi].yystate.yysemantics.yysval = yys->yysemantics.yysval;
          yyrhsVals[yyi].yystate.yyloc = yys->yyloc;
          yyrhsVals[yyi].yystate.yyresolved = yytrue;
          yyrhsVals[yyi].yystate.yysemantics.yysval = yys->yysemantics.yysval;
          yyrhsVals[yyi].yystate.yyloc = yys->yyloc;


@@ -1081,12 +1103,12 @@ static inline void
 yy_reduce_print (size_t yyk, yyRuleNum yyrule)
 {
   int yyi;
 yy_reduce_print (size_t yyk, yyRuleNum yyrule)
 {
   int yyi;

-  YYDPRINTF ((stderr, "Reducing stack %d by rule %d (line %d),",
-             yyk, yyrule - 1, yyrline[yyrule]));
+  YYFPRINTF (stderr, "Reducing stack %d by rule %d (line %d), ",
+            yyk, yyrule - 1, yyrline[yyrule]);

   /* Print the symbols being reduced, and their result.  */
   for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
     YYFPRINTF (stderr, "%s ", yytokenName (yyrhs[yyi]));
   /* Print the symbols being reduced, and their result.  */
   for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
     YYFPRINTF (stderr, "%s ", yytokenName (yyrhs[yyi]));

-  YYFPRINTF (stderr, " -> %s\n", yytokenName (yyr1[yyrule]));
+  YYFPRINTF (stderr, "-> %s\n", yytokenName (yyr1[yyrule]));

 }
 #endif
 
 }
 #endif
 


@@ -1118,8 +1140,6 @@ yyglrReduce (yyGLRStack* yystack, size_t yyk, yyRuleNum yyrule,
                  yyLRgotoState (yystack->yytops.yystates[yyk]->yylrState,
                                 yylhsNonterm (yyrule)),
                  yyposn, yysval, &yyloc]b4_user_args[);
                  yyLRgotoState (yystack->yytops.yystates[yyk]->yylrState,
                                 yylhsNonterm (yyrule)),
                  yyposn, yysval, &yyloc]b4_user_args[);

-      YYDPRINTF ((stderr, "Stack %d entering state %d\n",
-                 yyk, yystack->yytops.yystates[yyk]->yylrState));

     }
   else
     {
     }
   else
     {


@@ -1132,7 +1152,8 @@ yyglrReduce (yyGLRStack* yystack, size_t yyk, yyRuleNum yyrule,
           0 < yyn; yyn -= 1)
        {
          yys = yys->yypred;
           0 < yyn; yyn -= 1)
        {
          yys = yys->yypred;

-         assert (yys != NULL);
+         if (! yys)
+           abort ();

        }
       yyupdateSplit (yystack, yys);
       yynewLRState = yyLRgotoState (yys->yylrState, yylhsNonterm (yyrule));
        }
       yyupdateSplit (yystack, yys);
       yynewLRState = yyLRgotoState (yys->yylrState, yylhsNonterm (yyrule));


@@ -1153,7 +1174,7 @@ yyglrReduce (yyGLRStack* yystack, size_t yyk, yyRuleNum yyrule,
                    yymarkStackDeleted (yystack, yyk);
                    YYDPRINTF ((stderr, "Merging stack %d into stack %d.\n",
                                yyk, yyi));
                    yymarkStackDeleted (yystack, yyk);
                    YYDPRINTF ((stderr, "Merging stack %d into stack %d.\n",
                                yyk, yyi));

-                   return 0;
+                   return yyok;

                  }
                yyp = yyp->yypred;
              }
                  }
                yyp = yyp->yypred;
              }


@@ -1161,7 +1182,7 @@ yyglrReduce (yyGLRStack* yystack, size_t yyk, yyRuleNum yyrule,
       yystack->yytops.yystates[yyk] = yys;
       yyglrShiftDefer (yystack, yyk, yynewLRState, yyposn, yys0, yyrule]b4_pure_args[);
     }
       yystack->yytops.yystates[yyk] = yys;
       yyglrShiftDefer (yystack, yyk, yynewLRState, yyposn, yys0, yyrule]b4_pure_args[);
     }

-  return 0;
+  return yyok;

 }
 
 static int
 }
 
 static int


@@ -1169,7 +1190,8 @@ yysplitStack (yyGLRStack* yystack, int yyk)
 {
   if (yystack->yysplitPoint == NULL)
     {
 {
   if (yystack->yysplitPoint == NULL)
     {

-      assert (yyk == 0);
+      if (yyk != 0)
+       abort ();

       yystack->yysplitPoint = yystack->yytops.yystates[yyk];
     }
   if (yystack->yytops.yysize >= yystack->yytops.yycapacity)
       yystack->yysplitPoint = yystack->yytops.yystates[yyk];
     }
   if (yystack->yytops.yysize >= yystack->yytops.yycapacity)


@@ -1227,7 +1249,7 @@ yymergeOptionSets (yySemanticOption* yyy0, yySemanticOption* yyy1)
        yySemanticOption* yyz;
        for (yyz = yys0->yysemantics.yyfirstVal; yyz->yynext != NULL;
             yyz = yyz->yynext)
        yySemanticOption* yyz;
        for (yyz = yys0->yysemantics.yyfirstVal; yyz->yynext != NULL;
             yyz = yyz->yynext)

-         ;
+         continue;

        yyz->yynext = yys1->yysemantics.yyfirstVal;
       }
 }
        yyz->yynext = yys1->yysemantics.yyfirstVal;
       }
 }


@@ -1267,7 +1289,8 @@ yyresolveStates (yyGLRState* yys, int yyn, yyGLRStack* yystack]b4_user_formals[)
   YYRESULTTAG yyflag;
   if (0 < yyn)
     {
   YYRESULTTAG yyflag;
   if (0 < yyn)
     {

-      assert (yys->yypred != NULL);
+      if (! yys->yypred)
+       abort ();

       yyflag = yyresolveStates (yys->yypred, yyn-1, yystack]b4_user_args[);
       if (yyflag != yyok)
        return yyflag;
       yyflag = yyresolveStates (yys->yypred, yyn-1, yystack]b4_user_args[);
       if (yyflag != yyok)
        return yyflag;


@@ -1297,7 +1320,8 @@ yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystack,
   for (yyi = yynrhs-1, yys = yyopt->yystate; 0 <= yyi;
        yyi -= 1, yys = yys->yypred)
     {
   for (yyi = yynrhs-1, yys = yyopt->yystate; 0 <= yyi;
        yyi -= 1, yys = yys->yypred)
     {

-      assert (yys->yypred != NULL);
+      if (! yys->yypred)
+       abort ();

       yyrhsVals[yyi].yystate.yyresolved = yytrue;
       yyrhsVals[yyi].yystate.yysemantics.yysval = yys->yysemantics.yysval;
       yyrhsVals[yyi].yystate.yyloc = yys->yyloc;
       yyrhsVals[yyi].yystate.yyresolved = yytrue;
       yyrhsVals[yyi].yystate.yysemantics.yysval = yys->yysemantics.yysval;
       yyrhsVals[yyi].yystate.yyloc = yys->yyloc;


@@ -1437,7 +1461,7 @@ yyresolveStack (yyGLRStack* yystack]b4_user_formals[)
       for (yyn = 0, yys = yystack->yytops.yystates[0];
           yys != yystack->yysplitPoint;
           yys = yys->yypred, yyn += 1)
       for (yyn = 0, yys = yystack->yytops.yystates[0];
           yys != yystack->yysplitPoint;
           yys = yys->yypred, yyn += 1)

-       ;
+       continue;

       YYCHK (yyresolveStates (yystack->yytops.yystates[0], yyn, yystack
                             ]b4_user_args[));
     }
       YYCHK (yyresolveStates (yystack->yytops.yystates[0], yyn, yystack
                             ]b4_user_args[));
     }


@@ -1487,8 +1511,10 @@ yyprocessOneStack (yyGLRStack* yystack, int yyk,
   while (yystack->yytops.yystates[yyk] != NULL)
     {
       yyStateNum yystate = yystack->yytops.yystates[yyk]->yylrState;
   while (yystack->yytops.yystates[yyk] != NULL)
     {
       yyStateNum yystate = yystack->yytops.yystates[yyk]->yylrState;

+      YYDPRINTF ((stderr, "Stack %d Entering state %d\n", yyk, yystate));

 
 

-      assert (yystate != YYFINAL);
+      if (yystate == YYFINAL)
+       abort ();

       if (yyisDefaultedState (yystate))
        {
          yyrule = yydefaultAction (yystate);
       if (yyisDefaultedState (yystate))
        {
          yyrule = yydefaultAction (yystate);


@@ -1507,8 +1533,7 @@ yyprocessOneStack (yyGLRStack* yystack, int yyk,
              YYDPRINTF ((stderr, "Reading a token: "));
              yychar = YYLEX;
              *yytokenp = YYTRANSLATE (yychar);
              YYDPRINTF ((stderr, "Reading a token: "));
              yychar = YYLEX;
              *yytokenp = YYTRANSLATE (yychar);

-             YYDPRINTF ((stderr, "Next token is %s\n",
-                         yytokenName (*yytokenp)));
+             YYDSYMPRINTF ("Next token is", *yytokenp, yylvalp, yyllocp);

            }
          yygetLRActions (yystate, *yytokenp, &yyaction, &yyconflicts);
 
            }
          yygetLRActions (yystate, *yytokenp, &yyaction, &yyconflicts);
 


@@ -1548,8 +1573,8 @@ yyprocessOneStack (yyGLRStack* yystack, int yyk,
 }
 
 static void
 }
 
 static void

-yyreportParseError (yyGLRStack* yystack,
-                   YYSTYPE* yylvalp, YYLTYPE* yyllocp]b4_user_formals[)
+yyreportSyntaxError (yyGLRStack* yystack,
+                    YYSTYPE* yylvalp, YYLTYPE* yyllocp]b4_user_formals[)

 {
   /* `Unused' warnings. */
   (void) yylvalp;
 {
   /* `Unused' warnings. */
   (void) yylvalp;


@@ -1570,7 +1595,7 @@ yyreportParseError (yyGLRStack* yystack,
          yycount = 0;
          /* Start YYX at -YYN if negative to avoid negative indexes in
             YYCHECK.  */
          yycount = 0;
          /* Start YYX at -YYN if negative to avoid negative indexes in
             YYCHECK.  */

-         yysize = sizeof ("parse error, unexpected ")
+         yysize = sizeof ("syntax error, unexpected ")

            + strlen (yytokenName (*yytokenp));
          yyprefix = ", expecting ";
          for (yyx = yyn < 0 ? -yyn : 0; yyx < yytname_size && yycount <= 5;
            + strlen (yytokenName (*yytokenp));
          yyprefix = ", expecting ";
          for (yyx = yyn < 0 ? -yyn : 0; yyx < yytname_size && yycount <= 5;


@@ -1579,7 +1604,8 @@ yyreportParseError (yyGLRStack* yystack,
              yysize += strlen (yytokenName (yyx)) + strlen (yyprefix),
                yycount += 1, yyprefix = " or ";
          yymsg = yyp = (char*) malloc (yysize);
              yysize += strlen (yytokenName (yyx)) + strlen (yyprefix),
                yycount += 1, yyprefix = " or ";
          yymsg = yyp = (char*) malloc (yysize);

-         sprintf (yyp, "parse error, unexpected %s", yytokenName (*yytokenp));
+         sprintf (yyp, "syntax error, unexpected %s",
+                  yytokenName (*yytokenp));

          yyp += strlen (yyp);
          if (yycount < 5)
            {
          yyp += strlen (yyp);
          if (yycount < 5)
            {


@@ -1597,7 +1623,7 @@ yyreportParseError (yyGLRStack* yystack,
        }
       else
 #endif
        }
       else
 #endif

-       yyerror (]b4_lyyerror_args["parse error");
+       yyerror (]b4_lyyerror_args["syntax error");

       yynerrs += 1;
     }
 }
       yynerrs += 1;
     }
 }


@@ -1606,8 +1632,8 @@ yyreportParseError (yyGLRStack* yystack,
    YYLVALP, and YYLLOCP point to the syntactic category, semantic
    value, and location of the lookahead.  */
 static void
    YYLVALP, and YYLLOCP point to the syntactic category, semantic
    value, and location of the lookahead.  */
 static void

-yyrecoverParseError (yyGLRStack* yystack,
-                    YYSTYPE* yylvalp, YYLTYPE* yyllocp]b4_user_formals[)
+yyrecoverSyntaxError (yyGLRStack* yystack,
+                     YYSTYPE* yylvalp, YYLTYPE* yyllocp]b4_user_formals[)

 {
   yySymbol* const yytokenp = yystack->yytokenp;
   size_t yyk;
 {
   yySymbol* const yytokenp = yystack->yytokenp;
   size_t yyk;


@@ -1621,14 +1647,32 @@ yyrecoverParseError (yyGLRStack* yystack,
     while (yytrue)
       {
        if (*yytokenp == YYEOF)
     while (yytrue)
       {
        if (*yytokenp == YYEOF)

-         yyFail (yystack][]b4_lpure_args[, NULL);
+         {
+           /* Now pop stack until we find a state that shifts the
+              error token.  */
+           while (yystack->yytops.yystates[0] != NULL)
+             {
+               yyGLRState *yys = yystack->yytops.yystates[0];
+               YYDSYMPRINTF ("Error: popping",
+                             yystos[yys->yylrState],
+                             &yys->yysemantics.yysval, &yys->yyloc);
+               yydestruct (yystos[yys->yylrState],
+                           &yys->yysemantics.yysval]b4_location_if([, &yys->yyloc])[);
+               yystack->yytops.yystates[0] = yys->yypred;
+               yystack->yynextFree -= 1;
+               yystack->yyspaceLeft += 1;
+             }
+           yyFail (yystack][]b4_lpure_args[, NULL);
+         }

        if (*yytokenp != YYEMPTY)
        if (*yytokenp != YYEMPTY)

-         YYDPRINTF ((stderr, "Discarding token %s\n",
-                     yytokenName (*yytokenp)));
+         {
+           YYDSYMPRINTF ("Error: discarding", *yytokenp, yylvalp, yyllocp);
+           yydestruct (*yytokenp, yylvalp]b4_location_if([, yyllocp])[);
+         }

        YYDPRINTF ((stderr, "Reading a token: "));
        yychar = YYLEX;
        *yytokenp = YYTRANSLATE (yychar);
        YYDPRINTF ((stderr, "Reading a token: "));
        yychar = YYLEX;
        *yytokenp = YYTRANSLATE (yychar);

-       YYDPRINTF ((stderr, "Next token is %s\n", yytokenName (*yytokenp)));
+       YYDSYMPRINTF ("Next token is", *yytokenp, yylvalp, yyllocp);

        yyj = yypact[yystack->yytops.yystates[0]->yylrState];
        if (yyis_pact_ninf (yyj))
          /* Something's not right; we shouldn't be here.  */
        yyj = yypact[yystack->yytops.yystates[0]->yylrState];
        if (yyis_pact_ninf (yyj))
          /* Something's not right; we shouldn't be here.  */


@@ -1657,20 +1701,26 @@ yyrecoverParseError (yyGLRStack* yystack,
   /* Now pop stack until we find a state that shifts the error token. */
   while (yystack->yytops.yystates[0] != NULL)
     {
   /* Now pop stack until we find a state that shifts the error token. */
   while (yystack->yytops.yystates[0] != NULL)
     {

-      yyj = yypact[yystack->yytops.yystates[0]->yylrState];
+      yyGLRState *yys = yystack->yytops.yystates[0];
+      yyj = yypact[yys->yylrState];

       if (! yyis_pact_ninf (yyj))
        {
          yyj += YYTERROR;
          if (0 <= yyj && yyj <= YYLAST && yycheck[yyj] == YYTERROR
              && yyisShiftAction (yytable[yyj]))
            {
       if (! yyis_pact_ninf (yyj))
        {
          yyj += YYTERROR;
          if (0 <= yyj && yyj <= YYLAST && yycheck[yyj] == YYTERROR
              && yyisShiftAction (yytable[yyj]))
            {

+             YYDPRINTF ((stderr, "Shifting error token, "));

              yyglrShift (yystack, 0, yytable[yyj],
              yyglrShift (yystack, 0, yytable[yyj],

-                         yystack->yytops.yystates[0]->yyposn,
-                         *yylvalp, yyllocp]b4_user_args[);
+                         yys->yyposn, *yylvalp, yyllocp]b4_user_args[);

              break;
            }
        }
              break;
            }
        }

-      yystack->yytops.yystates[0] = yystack->yytops.yystates[0]->yypred;
+      YYDSYMPRINTF ("Error: popping",
+                   yystos[yys->yylrState],
+                   &yys->yysemantics.yysval, &yys->yyloc);
+      yydestruct (yystos[yys->yylrState],
+                 &yys->yysemantics.yysval]b4_location_if([, &yys->yyloc])[);
+      yystack->yytops.yystates[0] = yys->yypred;

       yystack->yynextFree -= 1;
       yystack->yyspaceLeft += 1;
     }
       yystack->yynextFree -= 1;
       yystack->yyspaceLeft += 1;
     }


@@ -1732,7 +1782,6 @@ yyrecoverParseError (yyGLRStack* yystack,
       /* For efficiency, we have two loops, the first of which is
         specialized to deterministic operation (single stack, no
         potential ambiguity).  */
       /* For efficiency, we have two loops, the first of which is
         specialized to deterministic operation (single stack, no
         potential ambiguity).  */

-

       /* Standard mode */
       while (yytrue)
        {
       /* Standard mode */
       while (yytrue)
        {


@@ -1741,6 +1790,7 @@ yyrecoverParseError (yyGLRStack* yystack,
          const short* yyconflicts;
 
          yyStateNum yystate = yystack.yytops.yystates[0]->yylrState;
          const short* yyconflicts;
 
          yyStateNum yystate = yystack.yytops.yystates[0]->yylrState;

+          YYDPRINTF ((stderr, "Entering state %d\n", yystate));

          if (yystate == YYFINAL)
            goto yyDone;
          if (yyisDefaultedState (yystate))
          if (yystate == YYFINAL)
            goto yyDone;
          if (yyisDefaultedState (yystate))


@@ -1748,7 +1798,7 @@ yyrecoverParseError (yyGLRStack* yystack,
              yyrule = yydefaultAction (yystate);
              if (yyrule == 0)
                {
              yyrule = yydefaultAction (yystate);
              if (yyrule == 0)
                {

-                 yyreportParseError (&yystack, yylvalp, yyllocp]b4_user_args[);
+                 yyreportSyntaxError (&yystack, yylvalp, yyllocp]b4_user_args[);

                  goto yyuser_error;
                }
              YYCHK1 (yyglrReduce (&yystack, 0, yyrule, yytrue]b4_lpure_args[));
                  goto yyuser_error;
                }
              YYCHK1 (yyglrReduce (&yystack, 0, yyrule, yytrue]b4_lpure_args[));


@@ -1760,8 +1810,7 @@ yyrecoverParseError (yyGLRStack* yystack,
                  YYDPRINTF ((stderr, "Reading a token: "));
                  yychar = YYLEX;
                  yytoken = YYTRANSLATE (yychar);
                  YYDPRINTF ((stderr, "Reading a token: "));
                  yychar = YYLEX;
                  yytoken = YYTRANSLATE (yychar);

-                 YYDPRINTF ((stderr, "Next token is %s\n",
-                             yytokenName (yytoken)));
+                  YYDSYMPRINTF ("Next token is", yytoken, yylvalp, yyllocp);

                }
              yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts);
              if (*yyconflicts != 0)
                }
              yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts);
              if (*yyconflicts != 0)


@@ -1777,12 +1826,10 @@ yyrecoverParseError (yyGLRStack* yystack,
                              yylval, yyllocp]b4_user_args[);
                  if (0 < yystack.yyerrState)
                    yystack.yyerrState -= 1;
                              yylval, yyllocp]b4_user_args[);
                  if (0 < yystack.yyerrState)
                    yystack.yyerrState -= 1;

-                 YYDPRINTF ((stderr, "Entering state %d\n",
-                             yystack.yytops.yystates[0]->yylrState));

                }
              else if (yyisErrorAction (yyaction))
                {
                }
              else if (yyisErrorAction (yyaction))
                {

-                 yyreportParseError (&yystack, yylvalp, yyllocp]b4_user_args[);
+                 yyreportSyntaxError (&yystack, yylvalp, yyllocp]b4_user_args[);

                  goto yyuser_error;
                }
              else
                  goto yyuser_error;
                }
              else


@@ -1804,10 +1851,10 @@ yyrecoverParseError (yyGLRStack* yystack,
            {
              yyundeleteLastStack (&yystack);
              if (yystack.yytops.yysize == 0)
            {
              yyundeleteLastStack (&yystack);
              if (yystack.yytops.yysize == 0)

-               yyFail (&yystack][]b4_lpure_args[, "parse error");
+               yyFail (&yystack][]b4_lpure_args[, "syntax error");

              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"));

-             yyreportParseError (&yystack, yylvalp, yyllocp]b4_user_args[);
+             yyreportSyntaxError (&yystack, yylvalp, yyllocp]b4_user_args[);

              goto yyuser_error;
            }
          else if (yystack.yytops.yysize == 1)
              goto yyuser_error;
            }
          else if (yystack.yytops.yysize == 1)


@@ -1820,7 +1867,7 @@ yyrecoverParseError (yyGLRStack* yystack,
        }
       continue;
     yyuser_error:
        }
       continue;
     yyuser_error:

-      yyrecoverParseError (&yystack, yylvalp, yyllocp]b4_user_args[);
+      yyrecoverSyntaxError (&yystack, yylvalp, yyllocp]b4_user_args[);

       yyposn = yystack.yytops.yystates[0]->yyposn;
     }
  yyDone:
       yyposn = yystack.yytops.yystates[0]->yyposn;
     }
  yyDone: