* data/glr.c (b4_syncline): Fix (swap) the definition of

[bison.git] / data / glr.c

diff --git a/data/glr.c b/data/glr.c
index 29cd122073f84be9d23985769c47eea409e35519..d39b5e0c899352de6b1a854782f61e277a582a40 100644 (file)
--- a/data/glr.c
+++ b/data/glr.c
@@ -142,12 +142,6 @@ b4_copyright([Skeleton parser for GLR parsing with Bison],
 [
 /* This is the parser code for GLR (Generalized LR) parser. */
 
 [
 /* This is the parser code for GLR (Generalized LR) parser. */
 

-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdarg.h>
-#include <setjmp.h>
-

 ]b4_identification
 m4_if(b4_prefix[], [yy], [],
 [/* Substitute the variable and function names.  */
 ]b4_identification
 m4_if(b4_prefix[], [yy], [],
 [/* Substitute the variable and function names.  */


@@ -218,6 +212,12 @@ static YYSTYPE yyval_default;
 ]/* Line __line__ of glr.c.  */
 b4_syncline([@oline@], [@ofile@])
 [
 ]/* Line __line__ of glr.c.  */
 b4_syncline([@oline@], [@ofile@])
 [

+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <setjmp.h>
+

 #ifndef YYFREE
 # define YYFREE free
 #endif
 #ifndef YYFREE
 # define YYFREE free
 #endif


@@ -228,6 +228,8 @@ b4_syncline([@oline@], [@ofile@])
 # define YYREALLOC realloc
 #endif
 
 # define YYREALLOC realloc
 #endif
 

+#define YYSIZEMAX ((size_t) -1)
+

 #ifdef __cplusplus
    typedef bool yybool;
 #else
 #ifdef __cplusplus
    typedef bool yybool;
 #else


@@ -245,6 +247,13 @@ b4_syncline([@oline@], [@ofile@])
 # if !defined (__GNUC__) || __GNUC__ < 2 || \
 (__GNUC__ == 2 && __GNUC_MINOR__ < 5) || __STRICT_ANSI__
 #  define __attribute__(Spec) /* empty */
 # if !defined (__GNUC__) || __GNUC__ < 2 || \
 (__GNUC__ == 2 && __GNUC_MINOR__ < 5) || __STRICT_ANSI__
 #  define __attribute__(Spec) /* empty */

+# else
+]b4_location_if([#  define YYOPTIONAL_LOC(Name) Name],[
+#  if defined (__cplusplus)
+#   define YYOPTIONAL_LOC(Name) /* empty */
+#  else
+#   define YYOPTIONAL_LOC(Name) Name ATTRIBUTE_UNUSED
+#  endif])[

 # endif
 #endif
 
 # endif
 #endif
 


@@ -542,7 +551,7 @@ int yydebug;
 
 /* Minimum number of free items on the stack allowed after an
    allocation.  This is to allow allocation and initialization
 
 /* Minimum number of free items on the stack allowed after an
    allocation.  This is to allow allocation and initialization

-   to be completed by functions that call expandGLRStack before the
+   to be completed by functions that call yyexpandGLRStack before the

    stack is expanded, thus insuring that all necessary pointers get
    properly redirected to new data. */
 #define YYHEADROOM 2
    stack is expanded, thus insuring that all necessary pointers get
    properly redirected to new data. */
 #define YYHEADROOM 2


@@ -556,6 +565,30 @@ int yydebug;
 #define YYSTACKEXPANDABLE 0
 #endif
 
 #define YYSTACKEXPANDABLE 0
 #endif
 

+#if YYERROR_VERBOSE
+
+# ifndef yystpcpy
+#  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
+   YYDEST.  */
+static char *
+yystpcpy (char *yydest, const char *yysrc)
+{
+  char *yyd = yydest;
+  const char *yys = yysrc;
+
+  while ((*yyd++ = *yys++) != '\0')
+    continue;
+
+  return yyd - 1;
+}
+#  endif
+# endif
+
+#endif /* !YYERROR_VERBOSE */
+

 /** State numbers, as in LALR(1) machine */
 typedef int yyStateNum;
 
 /** State numbers, as in LALR(1) machine */
 typedef int yyStateNum;
 


@@ -636,34 +669,31 @@ struct yyGLRStack {
   jmp_buf yyexception_buffer;
   yyGLRStackItem* yyitems;
   yyGLRStackItem* yynextFree;
   jmp_buf yyexception_buffer;
   yyGLRStackItem* yyitems;
   yyGLRStackItem* yynextFree;

-  int yyspaceLeft;
+  size_t yyspaceLeft;

   yyGLRState* yysplitPoint;
   yyGLRState* yylastDeleted;
   yyGLRStateSet yytops;
 };
 
   yyGLRState* yysplitPoint;
   yyGLRState* yylastDeleted;
   yyGLRStateSet yytops;
 };
 

-static void yyinitGLRStack (yyGLRStack* yystack, size_t yysize);

 static void yyexpandGLRStack (yyGLRStack* yystack]b4_pure_formals[);
 static void yyexpandGLRStack (yyGLRStack* yystack]b4_pure_formals[);

-static void yyfreeGLRStack (yyGLRStack* yystack);

 
 static void
 
 static void

-yyFail (yyGLRStack* yystack]b4_pure_formals[, const char* yyformat, ...)
+yyFail (yyGLRStack* yystack]b4_pure_formals[, const char* yymsg)

 {
   yystack->yyerrflag = 1;
 {
   yystack->yyerrflag = 1;

-  if (yyformat != NULL)
-    {
-      char yymsg[256];
-      va_list yyap;
-      va_start (yyap, yyformat);
-      vsprintf (yymsg, yyformat, yyap);
-      yyerror (]b4_yyerror_args[yymsg);
-    }
+  if (yymsg != NULL)
+    yyerror (]b4_yyerror_args[yymsg);

   longjmp (yystack->yyexception_buffer, 1);
 }
 
   longjmp (yystack->yyexception_buffer, 1);
 }
 

+static void
+yyStackOverflow (yyGLRStack* yystack]b4_pure_formals[)
+{
+  yyFail (yystack]b4_pure_args[, "parser stack overflow");
+}
+

 #if YYDEBUG || YYERROR_VERBOSE
 #if YYDEBUG || YYERROR_VERBOSE

-/** A printable representation of TOKEN.  Valid until next call to
- *  tokenName. */
+/** A printable representation of TOKEN.  */

 static inline const char*
 yytokenName (yySymbol yytoken)
 {
 static inline const char*
 yytokenName (yySymbol yytoken)
 {


@@ -719,7 +749,7 @@ yyfill (yyGLRStackItem *yyvsp, int *yylow, int yylow1, yybool yynormal)
 static YYRESULTTAG
 yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,
              YYSTYPE* yyvalp,
 static YYRESULTTAG
 yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,
              YYSTYPE* yyvalp,

-             YYLTYPE* yylocp]b4_location_if(, [ ATTRIBUTE_UNUSED])[,
+             YYLTYPE* YYOPTIONAL_LOC (yylocp),

              yyGLRStack* yystack
               ]b4_user_formals[)
 {
              yyGLRStack* yystack
               ]b4_user_formals[)
 {


@@ -902,13 +932,16 @@ yyaddDeferredAction (yyGLRStack* yystack, yyGLRState* yystate,
                                /* GLRStacks */
 
 /** Initialize SET to a singleton set containing an empty stack. */
                                /* GLRStacks */
 
 /** Initialize SET to a singleton set containing an empty stack. */

-static void
+static yybool

 yyinitStateSet (yyGLRStateSet* yyset)
 {
   yyset->yysize = 1;
   yyset->yycapacity = 16;
   yyset->yystates = (yyGLRState**) YYMALLOC (16 * sizeof yyset->yystates[0]);
 yyinitStateSet (yyGLRStateSet* yyset)
 {
   yyset->yysize = 1;
   yyset->yycapacity = 16;
   yyset->yystates = (yyGLRState**) YYMALLOC (16 * sizeof yyset->yystates[0]);

+  if (! yyset->yystates)
+    return yyfalse;

   yyset->yystates[0] = NULL;
   yyset->yystates[0] = NULL;

+  return yytrue;

 }
 
 static void yyfreeStateSet (yyGLRStateSet* yyset)
 }
 
 static void yyfreeStateSet (yyGLRStateSet* yyset)


@@ -918,7 +951,7 @@ static void yyfreeStateSet (yyGLRStateSet* yyset)
 
 /** Initialize STACK to a single empty stack, with total maximum
  *  capacity for all stacks of SIZE. */
 
 /** Initialize STACK to a single empty stack, with total maximum
  *  capacity for all stacks of SIZE. */

-static void
+static yybool

 yyinitGLRStack (yyGLRStack* yystack, size_t yysize)
 {
   yystack->yyerrflag = 0;
 yyinitGLRStack (yyGLRStack* yystack, size_t yysize)
 {
   yystack->yyerrflag = 0;


@@ -929,7 +962,7 @@ yyinitGLRStack (yyGLRStack* yystack, size_t yysize)
     (yyGLRStackItem*) YYMALLOC (yysize * sizeof yystack->yynextFree[0]);
   yystack->yysplitPoint = NULL;
   yystack->yylastDeleted = NULL;
     (yyGLRStackItem*) YYMALLOC (yysize * sizeof yystack->yynextFree[0]);
   yystack->yysplitPoint = NULL;
   yystack->yylastDeleted = NULL;

-  yyinitStateSet (&yystack->yytops);
+  return yyinitStateSet (&yystack->yytops) && yystack->yyitems;

 }
 
 #define YYRELOC(YYFROMITEMS,YYTOITEMS,YYX,YYTYPE) \
 }
 
 #define YYRELOC(YYFROMITEMS,YYTOITEMS,YYX,YYTYPE) \


@@ -944,18 +977,20 @@ static void
 yyexpandGLRStack (yyGLRStack* yystack]b4_pure_formals[)
 {
 #if YYSTACKEXPANDABLE
 yyexpandGLRStack (yyGLRStack* yystack]b4_pure_formals[)
 {
 #if YYSTACKEXPANDABLE

-  yyGLRStack yynewStack;
+  yyGLRStackItem* yynewItems;

   yyGLRStackItem* yyp0, *yyp1;
   size_t yysize, yynewSize;
   size_t yyn;
   yysize = yystack->yynextFree - yystack->yyitems;
   if (YYMAXDEPTH <= yysize)
   yyGLRStackItem* yyp0, *yyp1;
   size_t yysize, yynewSize;
   size_t yyn;
   yysize = yystack->yynextFree - yystack->yyitems;
   if (YYMAXDEPTH <= yysize)

-    yyFail (yystack][]b4_pure_args[, "parser stack overflow");
+    yyStackOverflow (yystack]b4_pure_args[);

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

-  yyinitGLRStack (&yynewStack, yynewSize);
-  for (yyp0 = yystack->yyitems, yyp1 = yynewStack.yyitems, yyn = yysize;
+  yynewItems = (yyGLRStackItem*) YYMALLOC (yynewSize * sizeof yynewItems[0]);
+  if (! yynewItems)
+    yyStackOverflow (yystack]b4_pure_args[);
+  for (yyp0 = yystack->yyitems, yyp1 = yynewItems, yyn = yysize;

        0 < yyn;
        yyn -= 1, yyp0 += 1, yyp1 += 1)
     {
        0 < yyn;
        yyn -= 1, yyp0 += 1, yyp1 += 1)
     {


@@ -982,22 +1017,22 @@ yyexpandGLRStack (yyGLRStack* yystack]b4_pure_formals[)
        }
     }
   if (yystack->yysplitPoint != NULL)
        }
     }
   if (yystack->yysplitPoint != NULL)

-    yystack->yysplitPoint = YYRELOC (yystack->yyitems, yynewStack.yyitems,
+    yystack->yysplitPoint = YYRELOC (yystack->yyitems, yynewItems,

                                 yystack->yysplitPoint, yystate);
 
   for (yyn = 0; yyn < yystack->yytops.yysize; yyn += 1)
     if (yystack->yytops.yystates[yyn] != NULL)
       yystack->yytops.yystates[yyn] =
                                 yystack->yysplitPoint, yystate);
 
   for (yyn = 0; yyn < yystack->yytops.yysize; yyn += 1)
     if (yystack->yytops.yystates[yyn] != NULL)
       yystack->yytops.yystates[yyn] =

-       YYRELOC (yystack->yyitems, yynewStack.yyitems,
+       YYRELOC (yystack->yyitems, yynewItems,

                 yystack->yytops.yystates[yyn], yystate);
   YYFREE (yystack->yyitems);
                 yystack->yytops.yystates[yyn], yystate);
   YYFREE (yystack->yyitems);

-  yystack->yyitems = yynewStack.yyitems;
-  yystack->yynextFree = yynewStack.yynextFree + yysize;
-  yystack->yyspaceLeft = yynewStack.yyspaceLeft - yysize;
+  yystack->yyitems = yynewItems;
+  yystack->yynextFree = yynewItems + yysize;
+  yystack->yyspaceLeft = yynewSize - yysize;

 
 #else
 
 
 #else
 

-  yyFail (yystack][]b4_pure_args[, "parser stack overflow");
+  yyStackOverflow (yystack]b4_pure_args[);

 #endif
 }
 
 #endif
 }
 


@@ -1020,7 +1055,7 @@ yyupdateSplit (yyGLRStack* yystack, yyGLRState* yys)
 
 /** Invalidate stack #K in STACK. */
 static inline void
 
 /** Invalidate stack #K in STACK. */
 static inline void

-yymarkStackDeleted (yyGLRStack* yystack, int yyk)
+yymarkStackDeleted (yyGLRStack* yystack, size_t yyk)

 {
   if (yystack->yytops.yystates[yyk] != NULL)
     yystack->yylastDeleted = yystack->yytops.yystates[yyk];
 {
   if (yystack->yytops.yystates[yyk] != NULL)
     yystack->yylastDeleted = yystack->yytops.yystates[yyk];


@@ -1073,7 +1108,8 @@ yyremoveDeletes (yyGLRStack* yystack)
 /** Shift to a new state on stack #K of STACK, corresponding to LR state
  * LRSTATE, at input position POSN, with (resolved) semantic value SVAL. */
 static inline void
 /** Shift to a new state on stack #K of STACK, corresponding to LR state
  * LRSTATE, at input position POSN, with (resolved) semantic value SVAL. */
 static inline void

-yyglrShift (yyGLRStack* yystack, int yyk, yyStateNum yylrState, size_t yyposn,
+yyglrShift (yyGLRStack* yystack, size_t yyk, yyStateNum yylrState,
+           size_t yyposn,

            YYSTYPE yysval, YYLTYPE* yylocp]b4_user_formals[)
 {
   yyGLRStackItem* yynewItem;
            YYSTYPE yysval, YYLTYPE* yylocp]b4_user_formals[)
 {
   yyGLRStackItem* yynewItem;


@@ -1097,7 +1133,7 @@ yyglrShift (yyGLRStack* yystack, int yyk, yyStateNum yylrState, size_t yyposn,
  *  state YYLRSTATE, at input position YYPOSN, with the (unresolved)
  *  semantic value of YYRHS under the action for YYRULE. */
 static inline void
  *  state YYLRSTATE, at input position YYPOSN, with the (unresolved)
  *  semantic value of YYRHS under the action for YYRULE. */
 static inline void

-yyglrShiftDefer (yyGLRStack* yystack, int yyk, yyStateNum yylrState,
+yyglrShiftDefer (yyGLRStack* yystack, size_t yyk, yyStateNum yylrState,

                 size_t yyposn, yyGLRState* rhs, yyRuleNum yyrule]b4_pure_formals[)
 {
   yyGLRStackItem* yynewItem;
                 size_t yyposn, yyGLRState* rhs, yyRuleNum yyrule]b4_pure_formals[)
 {
   yyGLRStackItem* yynewItem;


@@ -1122,7 +1158,7 @@ yyglrShiftDefer (yyGLRStack* yystack, int yyk, yyStateNum yylrState,
  *  and *LOCP to the computed location (if any).  Return value is as
  *  for userAction. */
 static inline YYRESULTTAG
  *  and *LOCP to the computed location (if any).  Return value is as
  *  for userAction. */
 static inline YYRESULTTAG

-yydoAction (yyGLRStack* yystack, int yyk, yyRuleNum yyrule,
+yydoAction (yyGLRStack* yystack, size_t yyk, yyRuleNum yyrule,

            YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[)
 {
   int yynrhs = yyrhsLength (yyrule);
            YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[)
 {
   int yynrhs = yyrhsLength (yyrule);


@@ -1256,8 +1292,8 @@ yyglrReduce (yyGLRStack* yystack, size_t yyk, yyRuleNum yyrule,
   return yyok;
 }
 
   return yyok;
 }
 

-static int
-yysplitStack (yyGLRStack* yystack, int yyk)
+static size_t
+yysplitStack (yyGLRStack* yystack, size_t yyk]b4_pure_formals[)

 {
   if (yystack->yysplitPoint == NULL)
     {
 {
   if (yystack->yysplitPoint == NULL)
     {


@@ -1266,11 +1302,15 @@ yysplitStack (yyGLRStack* yystack, int yyk)
     }
   if (yystack->yytops.yysize >= yystack->yytops.yycapacity)
     {
     }
   if (yystack->yytops.yysize >= yystack->yytops.yycapacity)
     {

-      yystack->yytops.yycapacity *= 2;
-      yystack->yytops.yystates =
-       (yyGLRState**) YYREALLOC (yystack->yytops.yystates,
-                                 (yystack->yytops.yycapacity
-                                  * sizeof yystack->yytops.yystates[0]));
+      yyGLRState** yynewStates;
+      if (! ((yystack->yytops.yycapacity
+             <= (YYSIZEMAX / (2 * sizeof yynewStates[0])))
+            && (yynewStates =
+                (yyGLRState**) YYREALLOC (yystack->yytops.yystates,
+                                          ((yystack->yytops.yycapacity *= 2)
+                                           * sizeof yynewStates[0])))))
+       yyStackOverflow (yystack]b4_pure_args[);
+      yystack->yytops.yystates = yynewStates;

     }
   yystack->yytops.yystates[yystack->yytops.yysize]
     = yystack->yytops.yystates[yyk];
     }
   yystack->yytops.yystates[yystack->yytops.yysize]
     = yystack->yytops.yystates[yyk];


@@ -1496,10 +1536,10 @@ yyresolveValue (yySemanticOption* yyoptionList, yyGLRStack* yystack,
 {
   yySemanticOption* yybest;
   yySemanticOption* yyp;
 {
   yySemanticOption* yybest;
   yySemanticOption* yyp;

-  int yymerge;
+  yybool yymerge;

 
   yybest = yyoptionList;
 
   yybest = yyoptionList;

-  yymerge = 0;
+  yymerge = yyfalse;

   for (yyp = yyoptionList->yynext; yyp != NULL; yyp = yyp->yynext)
     {
       if (yyidenticalOptions (yybest, yyp))
   for (yyp = yyoptionList->yynext; yyp != NULL; yyp = yyp->yynext)
     {
       if (yyidenticalOptions (yybest, yyp))


@@ -1511,13 +1551,13 @@ yyresolveValue (yySemanticOption* yyoptionList, yyGLRStack* yystack,
            yyreportAmbiguity (yybest, yyp, yystack]b4_pure_args[);
            break;
          case 1:
            yyreportAmbiguity (yybest, yyp, yystack]b4_pure_args[);
            break;
          case 1:

-           yymerge = 1;
+           yymerge = yytrue;

            break;
          case 2:
            break;
          case 3:
            yybest = yyp;
            break;
          case 2:
            break;
          case 3:
            yybest = yyp;

-           yymerge = 0;
+           yymerge = yyfalse;

            break;
          }
     }
            break;
          }
     }


@@ -1591,9 +1631,9 @@ yycompressStack (yyGLRStack* yystack)
 }
 
 static YYRESULTTAG
 }
 
 static YYRESULTTAG

-yyprocessOneStack (yyGLRStack* yystack, int yyk,
+yyprocessOneStack (yyGLRStack* yystack, size_t yyk,

                   size_t yyposn, YYSTYPE* yylvalp, YYLTYPE* yyllocp
                   size_t yyposn, YYSTYPE* yylvalp, YYLTYPE* yyllocp

-                 ]b4_user_formals[)
+                 ]b4_pure_formals[)

 {
   int yyaction;
   const short int* yyconflicts;
 {
   int yyaction;
   const short int* yyconflicts;


@@ -1603,7 +1643,8 @@ 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));
+      YYDPRINTF ((stderr, "Stack %lu Entering state %d\n",
+                 (unsigned long int) yyk, yystate));

 
       YYASSERT (yystate != YYFINAL);
 
 
       YYASSERT (yystate != YYFINAL);
 


@@ -1612,7 +1653,8 @@ yyprocessOneStack (yyGLRStack* yystack, int yyk,
          yyrule = yydefaultAction (yystate);
          if (yyrule == 0)
            {
          yyrule = yydefaultAction (yystate);
          if (yyrule == 0)
            {

-             YYDPRINTF ((stderr, "Stack %d dies.\n", yyk));
+             YYDPRINTF ((stderr, "Stack %lu dies.\n",
+                         (unsigned long int) yyk));

              yymarkStackDeleted (yystack, yyk);
              return yyok;
            }
              yymarkStackDeleted (yystack, yyk);
              return yyok;
            }


@@ -1632,19 +1674,20 @@ yyprocessOneStack (yyGLRStack* yystack, int yyk,
 
          while (*yyconflicts != 0)
            {
 
          while (*yyconflicts != 0)
            {

-             int yynewStack = yysplitStack (yystack, yyk);
-             YYDPRINTF ((stderr, "Splitting off stack %d from %d.\n",
-                         yynewStack, yyk));
+             size_t yynewStack = yysplitStack (yystack, yyk]b4_pure_args[);
+             YYDPRINTF ((stderr, "Splitting off stack %lu from %lu.\n",
+                         (unsigned long int) yynewStack,
+                         (unsigned long int) yyk));

              YYCHK (yyglrReduce (yystack, yynewStack,
                                  *yyconflicts, yyfalse]b4_lpure_args[));
              YYCHK (yyprocessOneStack (yystack, yynewStack, yyposn,
              YYCHK (yyglrReduce (yystack, yynewStack,
                                  *yyconflicts, yyfalse]b4_lpure_args[));
              YYCHK (yyprocessOneStack (yystack, yynewStack, yyposn,

-                                       yylvalp, yyllocp]b4_user_args[));
+                                       yylvalp, yyllocp]b4_pure_args[));

              yyconflicts += 1;
            }
 
          if (yyisShiftAction (yyaction))
            {
              yyconflicts += 1;
            }
 
          if (yyisShiftAction (yyaction))
            {

-             YYDPRINTF ((stderr, "On stack %d, ", yyk));
+             YYDPRINTF ((stderr, "On stack %lu, ", (unsigned long int) yyk));

              YY_SYMBOL_PRINT ("shifting", *yytokenp, yylvalp, yyllocp);
              yyglrShift (yystack, yyk, yyaction, yyposn+1,
                          *yylvalp, yyllocp]b4_user_args[);
              YY_SYMBOL_PRINT ("shifting", *yytokenp, yylvalp, yyllocp);
              yyglrShift (yystack, yyk, yyaction, yyposn+1,
                          *yylvalp, yyllocp]b4_user_args[);


@@ -1654,7 +1697,8 @@ yyprocessOneStack (yyGLRStack* yystack, int yyk,
            }
          else if (yyisErrorAction (yyaction))
            {
            }
          else if (yyisErrorAction (yyaction))
            {

-             YYDPRINTF ((stderr, "Stack %d dies.\n", yyk));
+             YYDPRINTF ((stderr, "Stack %lu dies.\n",
+                         (unsigned long int) yyk));

              yymarkStackDeleted (yystack, yyk);
              break;
            }
              yymarkStackDeleted (yystack, yyk);
              break;
            }


@@ -1681,10 +1725,24 @@ yyreportSyntaxError (yyGLRStack* yystack,
       yyn = yypact[yystack->yytops.yystates[0]->yylrState];
       if (YYPACT_NINF < yyn && yyn < YYLAST)
        {
       yyn = yypact[yystack->yytops.yystates[0]->yylrState];
       if (YYPACT_NINF < yyn && yyn < YYLAST)
        {

-         size_t yysize = 0;
-         const char* yyprefix;
-         char* yymsg;
+         size_t yysize0 = strlen (yytokenName (*yytokenp));
+         size_t yysize = yysize0;
+         size_t yysize1;
+         yybool yysize_overflow = yyfalse;
+         char* yymsg = NULL;
+         enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
+         char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];

          int yyx;
          int yyx;

+         char *yyfmt;
+         char const *yyf;
+         static char const yyunexpected[] = "syntax error, unexpected %s";
+         static char const yyexpecting[] = ", expecting %s";
+         static char const yyor[] = " or %s";
+         char yyformat[sizeof yyunexpected
+                       + sizeof yyexpecting - 1
+                       + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
+                          * (sizeof yyor - 1))];
+         char const *yyprefix = yyexpecting;

 
          /* Start YYX at -YYN if negative to avoid negative indexes in
             YYCHECK.  */
 
          /* Start YYX at -YYN if negative to avoid negative indexes in
             YYCHECK.  */


@@ -1693,41 +1751,53 @@ yyreportSyntaxError (yyGLRStack* yystack,
          /* Stay within bounds of both yycheck and yytname.  */
          int yychecklim = YYLAST - yyn;
          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
          /* Stay within bounds of both yycheck and yytname.  */
          int yychecklim = YYLAST - yyn;
          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;

-         int yycount = 0;
+         int yycount = 1;
+
+         yyarg[0] = yytokenName (*yytokenp);
+         yyfmt = yystpcpy (yyformat, yyunexpected);

 
 

-         yyprefix = ", expecting ";

          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
              {
          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
              {

-               yysize += strlen (yyprefix) + strlen (yytokenName (yyx));
-               yycount += 1;
-               if (yycount == 5)
+               if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)

                  {
                  {

-                   yysize = 0;
+                   yycount = 1;
+                   yysize = yysize0;
+                   yyformat[sizeof yyunexpected - 1] = '\0';

                    break;
                  }
                    break;
                  }

-               yyprefix = " or ";
+               yyarg[yycount++] = yytokenName (yyx);
+               yysize1 = yysize + strlen (yytokenName (yyx));
+               yysize_overflow |= yysize1 < yysize;
+               yysize = yysize1;
+               yyfmt = yystpcpy (yyfmt, yyprefix);
+               yyprefix = yyor;

              }
              }

-         yysize += (sizeof ("syntax error, unexpected ")
-                    + strlen (yytokenName (*yytokenp)));
-         yymsg = (char*) YYMALLOC (yysize);
-         if (yymsg != 0)
+
+         yyf = yyformat;
+         yysize1 = yysize + (yyfmt - yyformat);
+         yysize_overflow |= yysize1 < yysize;
+         yysize = yysize1;
+
+         if (!yysize_overflow)
+           yymsg = (char *) YYMALLOC (yysize);
+
+         if (yymsg)

            {
            {

-             char* yyp = yymsg;
-             sprintf (yyp, "syntax error%s%s",
-                      (*yytokenp == YYEMPTY ? "" : ", unexpected "),
-                      yytokenName (*yytokenp));
-             yyp += strlen (yyp);
-             if (yycount < 5)
+             char *yyp = yymsg;
+             int yyi = 0;
+             while ((*yyp = *yyf))

                {
                {

-                 yyprefix = ", expecting ";
-                 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
-                   if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
-                     {
-                       sprintf (yyp, "%s%s", yyprefix, yytokenName (yyx));
-                       yyp += strlen (yyp);
-                       yyprefix = " or ";
-                     }
+                 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
+                   {
+                     yyp = yystpcpy (yyp, yyarg[yyi++]);
+                     yyf += 2;
+                   }
+                 else
+                   {
+                     yyp++;
+                     yyf++;
+                   }

                }
              yyerror (]b4_lyyerror_args[yymsg);
              YYFREE (yymsg);
                }
              yyerror (]b4_lyyerror_args[yymsg);
              YYFREE (yymsg);


@@ -1748,7 +1818,7 @@ yyreportSyntaxError (yyGLRStack* yystack,
 static void
 yyrecoverSyntaxError (yyGLRStack* yystack,
                      YYSTYPE* yylvalp,
 static void
 yyrecoverSyntaxError (yyGLRStack* yystack,
                      YYSTYPE* yylvalp,

-                     YYLTYPE* yyllocp]b4_location_if(, [ ATTRIBUTE_UNUSED])[
+                     YYLTYPE* YYOPTIONAL_LOC (yyllocp)

                      ]b4_user_formals[)
 {
   yySymbol* const yytokenp = yystack->yytokenp;
                      ]b4_user_formals[)
 {
   yySymbol* const yytokenp = yystack->yytokenp;


@@ -1891,14 +1961,17 @@ yyrecoverSyntaxError (yyGLRStack* yystack,
   YYSTYPE* const yylvalp = &yylval;
   YYLTYPE* const yyllocp = &yylloc;
 
   YYSTYPE* const yylvalp = &yylval;
   YYLTYPE* const yyllocp = &yylloc;
 

-  yyinitGLRStack (&yystack, YYINITDEPTH);
-  yystack.yytokenp = &yytoken;
-

   YYDPRINTF ((stderr, "Starting parse\n"));
 
   YYDPRINTF ((stderr, "Starting parse\n"));
 

+  yytoken = YYEMPTY;
+

   if (setjmp (yystack.yyexception_buffer) != 0)
     goto yyDone;
 
   if (setjmp (yystack.yyexception_buffer) != 0)
     goto yyDone;
 

+  if (! yyinitGLRStack (&yystack, YYINITDEPTH))
+    goto yyDone;
+  yystack.yytokenp = &yytoken;
+

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


@@ -1917,7 +1990,6 @@ m4_popdef([b4_at_dollar])dnl
 b4_syncline([@oline@], [@ofile@])])dnl
 [
   yyglrShift (&yystack, 0, 0, 0, yylval, &yylloc]b4_user_args[);
 b4_syncline([@oline@], [@ofile@])])dnl
 [
   yyglrShift (&yystack, 0, 0, 0, yylval, &yylloc]b4_user_args[);

-  yytoken = YYEMPTY;

   yyposn = 0;
 
   while (yytrue)
   yyposn = 0;
 
   while (yytrue)


@@ -1985,11 +2057,11 @@ b4_syncline([@oline@], [@ofile@])])dnl
 
       while (yytrue)
        {
 
       while (yytrue)
        {

-         int yys;
-         int yyn = yystack.yytops.yysize;
+         size_t yys;
+         size_t yyn = yystack.yytops.yysize;

          for (yys = 0; yys < yyn; yys += 1)
            YYCHK1 (yyprocessOneStack (&yystack, yys, yyposn,
          for (yys = 0; yys < yyn; yys += 1)
            YYCHK1 (yyprocessOneStack (&yystack, yys, yyposn,

-                                      yylvalp, yyllocp]b4_user_args[));
+                                      yylvalp, yyllocp]b4_lpure_args[));

          yytoken = YYEMPTY;
          yyposn += 1;
          yyremoveDeletes (&yystack);
          yytoken = YYEMPTY;
          yyposn += 1;
          yyremoveDeletes (&yystack);


@@ -2029,7 +2101,7 @@ b4_syncline([@oline@], [@ofile@])])dnl
 
 /* DEBUGGING ONLY */
 #ifdef YYDEBUG
 
 /* DEBUGGING ONLY */
 #ifdef YYDEBUG

-static void yypstack (yyGLRStack* yystack, int yyk) ATTRIBUTE_UNUSED;
+static void yypstack (yyGLRStack* yystack, size_t yyk) ATTRIBUTE_UNUSED;

 static void yypdumpstack (yyGLRStack* yystack) ATTRIBUTE_UNUSED;
 
 static void
 static void yypdumpstack (yyGLRStack* yystack) ATTRIBUTE_UNUSED;
 
 static void


@@ -2054,7 +2126,7 @@ yypstates (yyGLRState* yyst)
 }
 
 static void
 }
 
 static void

-yypstack (yyGLRStack* yystack, int yyk)
+yypstack (yyGLRStack* yystack, size_t yyk)

 {
   yypstates (yystack->yytops.yystates[yyk]);
 }
 {
   yypstates (yystack->yytops.yystates[yyk]);
 }