Undo previous change, then add comment as to why the

[bison.git] / data / glr.c

diff --git a/data/glr.c b/data/glr.c
index 23f5669f3cd4f3c6ec12cede02e7e618f7d7304e..342e5b16dd58e896c7c85dbbf6a34e4e6ad6152e 100644 (file)
--- a/data/glr.c
+++ b/data/glr.c
@@ -172,6 +172,11 @@ b4_pre_prologue[
 # define YYERROR_VERBOSE ]b4_error_verbose[
 #endif
 
 # define YYERROR_VERBOSE ]b4_error_verbose[
 #endif
 

+/* Enabling the token table.  */
+#ifndef YYTOKEN_TABLE
+# define YYTOKEN_TABLE ]b4_token_table[
+#endif
+

 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
 ]m4_ifdef([b4_stype],
 [b4_syncline([b4_stype_line], [b4_filename])
 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
 ]m4_ifdef([b4_stype],
 [b4_syncline([b4_stype_line], [b4_filename])


@@ -218,6 +223,18 @@ b4_syncline([@oline@], [@ofile@])
 #include <stdarg.h>
 #include <setjmp.h>
 
 #include <stdarg.h>
 #include <setjmp.h>
 

+#ifndef YY_
+# if YYENABLE_NLS
+#  if ENABLE_NLS
+#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
+#   define YY_(msgid) dgettext ("bison-runtime", msgid)
+#  endif
+# endif
+# ifndef YY_
+#  define YY_(msgid) msgid
+# endif
+#endif
+

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


@@ -244,27 +261,23 @@ 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 || \
-(__GNUC__ == 2 && __GNUC_MINOR__ < 5) || __STRICT_ANSI__
+# if (!defined (__GNUC__) || __GNUC__ < 2 \
+      || (__GNUC__ == 2 && __GNUC_MINOR__ < 5) || __STRICT_ANSI__)

 #  define __attribute__(Spec) /* empty */
 #  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
 

+]b4_location_if([#define YYOPTIONAL_LOC(Name) Name],[
+#ifdef __cplusplus
+# define YYOPTIONAL_LOC(Name) /* empty */
+#else
+# define YYOPTIONAL_LOC(Name) Name __attribute__ ((__unused__))
+#endif])[
+

 #ifndef YYASSERT
 # define YYASSERT(condition) ((void) ((condition) || (abort (), 0)))
 #endif
 
 #ifndef YYASSERT
 # define YYASSERT(condition) ((void) ((condition) || (abort (), 0)))
 #endif
 

-#ifndef ATTRIBUTE_UNUSED
-# define ATTRIBUTE_UNUSED __attribute__ ((__unused__))
-#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.  */


@@ -319,8 +332,8 @@ static const ]b4_int_type_for([b4_rline])[ yyrline[] =
 };
 #endif
 
 };
 #endif
 

-#if (YYDEBUG) || YYERROR_VERBOSE
-/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
+#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
+/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.

    First, the terminals, then, starting at YYNTOKENS, nonterminals. */
 static const char *const yytname[] =
 {
    First, the terminals, then, starting at YYNTOKENS, nonterminals. */
 static const char *const yytname[] =
 {


@@ -519,6 +532,7 @@ do {                                                                \
       YYFPRINTF (stderr, "%s ", Title);                                \
       yysymprint (stderr,                                      \
                   Type, Value]b4_location_if([, Location])[);  \
       YYFPRINTF (stderr, "%s ", Title);                                \
       yysymprint (stderr,                                      \
                   Type, Value]b4_location_if([, Location])[);  \

+      YYFPRINTF (stderr, "\n");                                        \

     }                                                          \
 } while (0)
 
     }                                                          \
 } while (0)
 


@@ -588,6 +602,54 @@ yystpcpy (char *yydest, const char *yysrc)
 #  endif
 # endif
 
 #  endif
 # endif
 

+# ifndef yytnamerr
+/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
+   quotes and backslashes, so that it's suitable for yyerror.  The
+   heuristic is that double-quoting is unnecessary unless the string
+   contains an apostrophe, a comma, or backslash (other than
+   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
+   null, do not copy; instead, return the length of what the result
+   would have been.  */
+static size_t
+yytnamerr (char *yyres, const char *yystr)
+{
+  if (*yystr == '"')
+    {
+      size_t yyn = 0;
+      char const *yyp = yystr;
+
+      for (;;)
+       switch (*++yyp)
+         {
+         case '\'':
+         case ',':
+           goto do_not_strip_quotes;
+
+         case '\\':
+           if (*++yyp != '\\')
+             goto do_not_strip_quotes;
+           /* Fall through.  */
+         default:
+           if (yyres)
+             yyres[yyn] = *yyp;
+           yyn++;
+           break;
+
+         case '"':
+           if (yyres)
+             yyres[yyn] = '\0';
+           return yyn;
+         }
+    do_not_strip_quotes: ;
+    }
+
+  if (! yyres)
+    return strlen (yystr);
+
+  return yystpcpy (yyres, yystr) - yyres;
+}
+# endif
+

 #endif /* !YYERROR_VERBOSE */
 
 /** State numbers, as in LALR(1) machine */
 #endif /* !YYERROR_VERBOSE */
 
 /** State numbers, as in LALR(1) machine */


@@ -675,8 +737,10 @@ struct yyGLRStack {
   yyGLRStateSet yytops;
 };
 
   yyGLRStateSet yytops;
 };
 

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

 
 

+static void yyFail (yyGLRStack* yystack]b4_pure_formals[, const char* yymsg)
+  __attribute__ ((__noreturn__));

 static void
 yyFail (yyGLRStack* yystack]b4_pure_formals[, const char* yymsg)
 {
 static void
 yyFail (yyGLRStack* yystack]b4_pure_formals[, const char* yymsg)
 {


@@ -685,8 +749,10 @@ yyFail (yyGLRStack* yystack]b4_pure_formals[, const char* yymsg)
   longjmp (yystack->yyexception_buffer, 1);
 }
 
   longjmp (yystack->yyexception_buffer, 1);
 }
 

+static void yyMemoryExhausted (yyGLRStack* yystack)
+  __attribute__ ((__noreturn__));

 static void
 static void

-yyStackOverflow (yyGLRStack* yystack]b4_pure_formals[)
+yyMemoryExhausted (yyGLRStack* yystack)

 {
   longjmp (yystack->yyexception_buffer, 2);
 }
 {
   longjmp (yystack->yyexception_buffer, 2);
 }


@@ -707,7 +773,7 @@ yytokenName (yySymbol yytoken)
  *  at YYVSP[YYLOW0].yystate.yypred.  Leaves YYVSP[YYLOW1].yystate.yypred
  *  containing the pointer to the next state in the chain. Assumes
  *  YYLOW1 < YYLOW0.  */
  *  at YYVSP[YYLOW0].yystate.yypred.  Leaves YYVSP[YYLOW1].yystate.yypred
  *  containing the pointer to the next state in the chain. Assumes
  *  YYLOW1 < YYLOW0.  */

-static void yyfillin (yyGLRStackItem *, int, int) ATTRIBUTE_UNUSED;
+static void yyfillin (yyGLRStackItem *, int, int) __attribute__ ((__unused__));

 static void
 yyfillin (yyGLRStackItem *yyvsp, int yylow0, int yylow1)
 {
 static void
 yyfillin (yyGLRStackItem *yyvsp, int yylow0, int yylow1)
 {


@@ -728,7 +794,7 @@ yyfillin (yyGLRStackItem *yyvsp, int yylow0, int yylow1)
    YYVSP[YYLOW1 .. *YYLOW-1] as in yyfillin and set *YYLOW = YYLOW1.
    For convenience, always return YYLOW1.  */
 static inline int yyfill (yyGLRStackItem *, int *, int, yybool)
    YYVSP[YYLOW1 .. *YYLOW-1] as in yyfillin and set *YYLOW = YYLOW1.
    For convenience, always return YYLOW1.  */
 static inline int yyfill (yyGLRStackItem *, int *, int, yybool)

-     ATTRIBUTE_UNUSED;
+     __attribute__ ((__unused__));

 static inline int
 yyfill (yyGLRStackItem *yyvsp, int *yylow, int yylow1, yybool yynormal)
 {
 static inline int
 yyfill (yyGLRStackItem *yyvsp, int *yylow, int yylow1, yybool yynormal)
 {


@@ -752,7 +818,8 @@ yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,
              yyGLRStack* yystack
               ]b4_user_formals[)
 {
              yyGLRStack* yystack
               ]b4_user_formals[)
 {

-  yybool yynormal ATTRIBUTE_UNUSED = (yystack->yysplitPoint == NULL);
+  yybool yynormal __attribute__ ((__unused__)) =
+    (yystack->yysplitPoint == NULL);

   int yylow;
 
 # undef yyerrok
   int yylow;
 
 # undef yyerrok


@@ -771,7 +838,7 @@ yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,
 # define YYFILL(N) yyfill (yyvsp, &yylow, N, yynormal)
 # undef YYBACKUP
 # define YYBACKUP(Token, Value)                                                     \
 # define YYFILL(N) yyfill (yyvsp, &yylow, N, yynormal)
 # undef YYBACKUP
 # define YYBACKUP(Token, Value)                                                     \

-  return yyerror (]b4_yyerror_args["syntax error: cannot back up"),         \
+  return yyerror (]b4_yyerror_args[YY_("syntax error: cannot back up")),     \

         yyerrok, yyerr
 
   yylow = 1;
         yyerrok, yyerr
 
   yylow = 1;


@@ -819,13 +886,44 @@ yyuserMerge (int yyn, YYSTYPE* yy0, YYSTYPE* yy1)
 
 ]b4_yydestruct_generate([b4_c_ansi_function_def])[
 
 
 ]b4_yydestruct_generate([b4_c_ansi_function_def])[
 

-/** Number of symbols composing the right hand side of rule #RULE. */
+/** Number of symbols composing the right hand side of rule #RULE.  */

 static inline int
 yyrhsLength (yyRuleNum yyrule)
 {
   return yyr2[yyrule];
 }
 
 static inline int
 yyrhsLength (yyRuleNum yyrule)
 {
   return yyr2[yyrule];
 }
 

+static void
+yydestroyGLRState (char const *yymsg, yyGLRState *yys)
+{
+  if (yys->yyresolved)
+    yydestruct (yymsg, yystos[yys->yylrState],
+               &yys->yysemantics.yysval]b4_location_if([, &yys->yyloc])[);
+  else
+    {
+#if YYDEBUG
+      if (yydebug)
+       {
+         YYFPRINTF (stderr, "%s unresolved ", yymsg);
+         yysymprint (stderr, yystos[yys->yylrState],
+                     &yys->yysemantics.yysval]b4_location_if([, &yys->yyloc])[);
+         YYFPRINTF (stderr, "\n");
+       }
+#endif
+
+      if (yys->yysemantics.yyfirstVal)
+        {
+          yySemanticOption *yyoption = yys->yysemantics.yyfirstVal;
+          yyGLRState *yyrhs;
+          int yyn;
+          for (yyrhs = yyoption->yystate, yyn = yyrhsLength (yyoption->yyrule);
+               yyn > 0;
+               yyrhs = yyrhs->yypred, yyn -= 1)
+            yydestroyGLRState (yymsg, yyrhs);
+        }
+    }
+}
+

 /** Left-hand-side symbol for rule #RULE. */
 static inline yySymbol
 yylhsNonterm (yyRuleNum yyrule)
 /** Left-hand-side symbol for rule #RULE. */
 static inline yySymbol
 yylhsNonterm (yyRuleNum yyrule)


@@ -915,7 +1013,7 @@ yyisErrorAction (int yyaction)
 
 static void
 yyaddDeferredAction (yyGLRStack* yystack, yyGLRState* yystate,
 
 static void
 yyaddDeferredAction (yyGLRStack* yystack, yyGLRState* yystate,

-                    yyGLRState* rhs, yyRuleNum yyrule]b4_pure_formals[)
+                    yyGLRState* rhs, yyRuleNum yyrule)

 {
   yySemanticOption* yynewItem;
   yynewItem = &yystack->yynextFree->yyoption;
 {
   yySemanticOption* yynewItem;
   yynewItem = &yystack->yynextFree->yyoption;


@@ -927,7 +1025,7 @@ yyaddDeferredAction (yyGLRStack* yystack, yyGLRState* yystate,
   yynewItem->yynext = yystate->yysemantics.yyfirstVal;
   yystate->yysemantics.yyfirstVal = yynewItem;
   if (yystack->yyspaceLeft < YYHEADROOM)
   yynewItem->yynext = yystate->yysemantics.yyfirstVal;
   yystate->yysemantics.yyfirstVal = yynewItem;
   if (yystack->yyspaceLeft < YYHEADROOM)

-    yyexpandGLRStack (yystack]b4_pure_args[);
+    yyexpandGLRStack (yystack);

 }
 
                                /* GLRStacks */
 }
 
                                /* GLRStacks */


@@ -958,11 +1056,14 @@ yyinitGLRStack (yyGLRStack* yystack, size_t yysize)
   yystack->yyerrState = 0;
   yynerrs = 0;
   yystack->yyspaceLeft = yysize;
   yystack->yyerrState = 0;
   yynerrs = 0;
   yystack->yyspaceLeft = yysize;

-  yystack->yynextFree = yystack->yyitems =
+  yystack->yyitems =

     (yyGLRStackItem*) YYMALLOC (yysize * sizeof yystack->yynextFree[0]);
     (yyGLRStackItem*) YYMALLOC (yysize * sizeof yystack->yynextFree[0]);

+  if (!yystack->yyitems)
+    return yyfalse;
+  yystack->yynextFree = yystack->yyitems;

   yystack->yysplitPoint = NULL;
   yystack->yylastDeleted = NULL;
   yystack->yysplitPoint = NULL;
   yystack->yylastDeleted = NULL;

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

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


@@ -974,7 +1075,7 @@ yyinitGLRStack (yyGLRStack* yystack, size_t yysize)
     allocation, so that we can avoid having external pointers exist
     across an allocation. */
 static void
     allocation, so that we can avoid having external pointers exist
     across an allocation. */
 static void

-yyexpandGLRStack (yyGLRStack* yystack]b4_pure_formals[)
+yyexpandGLRStack (yyGLRStack* yystack)

 {
 #if YYSTACKEXPANDABLE
   yyGLRStackItem* yynewItems;
 {
 #if YYSTACKEXPANDABLE
   yyGLRStackItem* yynewItems;


@@ -983,13 +1084,13 @@ 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)

-    yyStackOverflow (yystack]b4_pure_args[);
+    yyMemoryExhausted (yystack);

   yynewSize = 2*yysize;
   if (YYMAXDEPTH < yynewSize)
     yynewSize = YYMAXDEPTH;
   yynewItems = (yyGLRStackItem*) YYMALLOC (yynewSize * sizeof yynewItems[0]);
   if (! yynewItems)
   yynewSize = 2*yysize;
   if (YYMAXDEPTH < yynewSize)
     yynewSize = YYMAXDEPTH;
   yynewItems = (yyGLRStackItem*) YYMALLOC (yynewSize * sizeof yynewItems[0]);
   if (! yynewItems)

-    yyStackOverflow (yystack]b4_pure_args[);
+    yyMemoryExhausted (yystack);

   for (yyp0 = yystack->yyitems, yyp1 = yynewItems, yyn = yysize;
        0 < yyn;
        yyn -= 1, yyp0 += 1, yyp1 += 1)
   for (yyp0 = yystack->yyitems, yyp1 = yynewItems, yyn = yysize;
        0 < yyn;
        yyn -= 1, yyp0 += 1, yyp1 += 1)


@@ -1031,8 +1132,7 @@ yyexpandGLRStack (yyGLRStack* yystack]b4_pure_formals[)
   yystack->yyspaceLeft = yynewSize - yysize;
 
 #else
   yystack->yyspaceLeft = yynewSize - yysize;
 
 #else

-
-  yyStackOverflow (yystack]b4_pure_args[);
+  yyMemoryExhausted (yystack);

 #endif
 }
 
 #endif
 }
 


@@ -1110,7 +1210,7 @@ yyremoveDeletes (yyGLRStack* yystack)
 static inline void
 yyglrShift (yyGLRStack* yystack, size_t yyk, yyStateNum yylrState,
            size_t yyposn,
 static inline void
 yyglrShift (yyGLRStack* yystack, size_t yyk, yyStateNum yylrState,
            size_t yyposn,

-           YYSTYPE yysval, YYLTYPE* yylocp]b4_user_formals[)
+           YYSTYPE yysval, YYLTYPE* yylocp)

 {
   yyGLRStackItem* yynewItem;
 
 {
   yyGLRStackItem* yynewItem;
 


@@ -1126,7 +1226,7 @@ yyglrShift (yyGLRStack* yystack, size_t yyk, yyStateNum yylrState,
   yynewItem->yystate.yysemantics.yysval = yysval;
   yynewItem->yystate.yyloc = *yylocp;
   if (yystack->yyspaceLeft < YYHEADROOM)
   yynewItem->yystate.yysemantics.yysval = yysval;
   yynewItem->yystate.yyloc = *yylocp;
   if (yystack->yyspaceLeft < YYHEADROOM)

-    yyexpandGLRStack (yystack]b4_pure_args[);
+    yyexpandGLRStack (yystack);

 }
 
 /** Shift stack #K of YYSTACK, to a new state corresponding to LR
 }
 
 /** Shift stack #K of YYSTACK, to a new state corresponding to LR


@@ -1134,7 +1234,7 @@ yyglrShift (yyGLRStack* yystack, size_t yyk, yyStateNum yylrState,
  *  semantic value of YYRHS under the action for YYRULE. */
 static inline void
 yyglrShiftDefer (yyGLRStack* yystack, size_t yyk, yyStateNum yylrState,
  *  semantic value of YYRHS under the action for YYRULE. */
 static inline void
 yyglrShiftDefer (yyGLRStack* yystack, size_t yyk, yyStateNum yylrState,

-                size_t yyposn, yyGLRState* rhs, yyRuleNum yyrule]b4_pure_formals[)
+                size_t yyposn, yyGLRState* rhs, yyRuleNum yyrule)

 {
   yyGLRStackItem* yynewItem;
 
 {
   yyGLRStackItem* yynewItem;
 


@@ -1148,7 +1248,7 @@ yyglrShiftDefer (yyGLRStack* yystack, size_t yyk, yyStateNum yylrState,
   yystack->yytops.yystates[yyk] = &yynewItem->yystate;
   yystack->yynextFree += 1;
   yystack->yyspaceLeft -= 1;
   yystack->yytops.yystates[yyk] = &yynewItem->yystate;
   yystack->yynextFree += 1;
   yystack->yyspaceLeft -= 1;

-  yyaddDeferredAction (yystack, &yynewItem->yystate, rhs, yyrule]b4_pure_args[);
+  yyaddDeferredAction (yystack, &yynewItem->yystate, rhs, yyrule);

 }
 
 /** Pop the symbols consumed by reduction #RULE from the top of stack
 }
 
 /** Pop the symbols consumed by reduction #RULE from the top of stack


@@ -1233,7 +1333,7 @@ yy_reduce_print (size_t yyk, yyRuleNum yyrule)
  */
 static inline YYRESULTTAG
 yyglrReduce (yyGLRStack* yystack, size_t yyk, yyRuleNum yyrule,
  */
 static inline YYRESULTTAG
 yyglrReduce (yyGLRStack* yystack, size_t yyk, yyRuleNum yyrule,

-             yybool yyforceEval]b4_pure_formals[)
+             yybool yyforceEval]b4_user_formals[)

 {
   size_t yyposn = yystack->yytops.yystates[yyk]->yyposn;
 
 {
   size_t yyposn = yystack->yytops.yystates[yyk]->yyposn;
 


@@ -1247,7 +1347,7 @@ yyglrReduce (yyGLRStack* yystack, size_t yyk, yyRuleNum yyrule,
       yyglrShift (yystack, yyk,
                  yyLRgotoState (yystack->yytops.yystates[yyk]->yylrState,
                                 yylhsNonterm (yyrule)),
       yyglrShift (yystack, yyk,
                  yyLRgotoState (yystack->yytops.yystates[yyk]->yylrState,
                                 yylhsNonterm (yyrule)),

-                 yyposn, yysval, &yyloc]b4_user_args[);
+                 yyposn, yysval, &yyloc);

     }
   else
     {
     }
   else
     {


@@ -1276,7 +1376,7 @@ yyglrReduce (yyGLRStack* yystack, size_t yyk, yyRuleNum yyrule,
              {
                if (yyp->yylrState == yynewLRState && yyp->yypred == yys)
                  {
              {
                if (yyp->yylrState == yynewLRState && yyp->yypred == yys)
                  {

-                   yyaddDeferredAction (yystack, yyp, yys0, yyrule]b4_pure_args[);
+                   yyaddDeferredAction (yystack, yyp, yys0, yyrule);

                    yymarkStackDeleted (yystack, yyk);
                    YYDPRINTF ((stderr, "Merging stack %lu into stack %lu.\n",
                                (unsigned long int) yyk,
                    yymarkStackDeleted (yystack, yyk);
                    YYDPRINTF ((stderr, "Merging stack %lu into stack %lu.\n",
                                (unsigned long int) yyk,


@@ -1287,13 +1387,13 @@ yyglrReduce (yyGLRStack* yystack, size_t yyk, yyRuleNum yyrule,
              }
          }
       yystack->yytops.yystates[yyk] = yys;
              }
          }
       yystack->yytops.yystates[yyk] = yys;

-      yyglrShiftDefer (yystack, yyk, yynewLRState, yyposn, yys0, yyrule]b4_pure_args[);
+      yyglrShiftDefer (yystack, yyk, yynewLRState, yyposn, yys0, yyrule);

     }
   return yyok;
 }
 
 static size_t
     }
   return yyok;
 }
 
 static size_t

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

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


@@ -1309,7 +1409,7 @@ yysplitStack (yyGLRStack* yystack, size_t yyk]b4_pure_formals[)
                 (yyGLRState**) YYREALLOC (yystack->yytops.yystates,
                                           ((yystack->yytops.yycapacity *= 2)
                                            * sizeof yynewStates[0])))))
                 (yyGLRState**) YYREALLOC (yystack->yytops.yystates,
                                           ((yystack->yytops.yycapacity *= 2)
                                            * sizeof yynewStates[0])))))

-       yyStackOverflow (yystack]b4_pure_args[);
+       yyMemoryExhausted (yystack);

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


@@ -1508,6 +1608,9 @@ yyreportTree (yySemanticOption* yyx, int yyindent)
 }
 #endif
 
 }
 #endif
 

+static void yyreportAmbiguity (yySemanticOption* yyx0, yySemanticOption* yyx1,
+                              yyGLRStack* yystack]b4_pure_formals[)
+  __attribute__ ((__noreturn__));

 static void
 yyreportAmbiguity (yySemanticOption* yyx0, yySemanticOption* yyx1,
                   yyGLRStack* yystack]b4_pure_formals[)
 static void
 yyreportAmbiguity (yySemanticOption* yyx0, yySemanticOption* yyx1,
                   yyGLRStack* yystack]b4_pure_formals[)


@@ -1524,7 +1627,7 @@ yyreportAmbiguity (yySemanticOption* yyx0, yySemanticOption* yyx1,
   yyreportTree (yyx1, 2);
   YYFPRINTF (stderr, "\n");
 #endif
   yyreportTree (yyx1, 2);
   YYFPRINTF (stderr, "\n");
 #endif

-  yyFail (yystack][]b4_pure_args[, "ambiguity detected");
+  yyFail (yystack][]b4_pure_args[, YY_("syntax is ambiguous"));

 }
 
 
 }
 
 


@@ -1535,35 +1638,44 @@ yyresolveValue (yySemanticOption* yyoptionList, yyGLRStack* yystack,
                YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[)
 {
   yySemanticOption* yybest;
                YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[)
 {
   yySemanticOption* yybest;

-  yySemanticOption* yyp;
+  yySemanticOption** yypp;

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

-  for (yyp = yyoptionList->yynext; yyp != NULL; yyp = yyp->yynext)
+  for (yypp = &yyoptionList->yynext; *yypp != NULL; )

     {
     {

+      yySemanticOption* yyp = *yypp;
+

       if (yyidenticalOptions (yybest, yyp))
       if (yyidenticalOptions (yybest, yyp))

-       yymergeOptionSets (yybest, yyp);
+       {
+         yymergeOptionSets (yybest, yyp);
+         *yypp = yyp->yynext;
+       }

       else
       else

-       switch (yypreference (yybest, yyp))
-         {
-         case 0:
-           yyreportAmbiguity (yybest, yyp, yystack]b4_pure_args[);
-           break;
-         case 1:
-           yymerge = yytrue;
-           break;
-         case 2:
-           break;
-         case 3:
-           yybest = yyp;
-           yymerge = yyfalse;
-           break;
-         }
+       {
+         switch (yypreference (yybest, yyp))
+           {
+           case 0:
+             yyreportAmbiguity (yybest, yyp, yystack]b4_pure_args[);
+             break;
+           case 1:
+             yymerge = yytrue;
+             break;
+           case 2:
+             break;
+           case 3:
+             yybest = yyp;
+             yymerge = yyfalse;
+             break;
+           }
+         yypp = &yyp->yynext;
+       }

     }
 
   if (yymerge)
     {
     }
 
   if (yymerge)
     {

+      yySemanticOption* yyp;

       int yyprec = yydprec[yybest->yyrule];
       YYCHK (yyresolveAction (yybest, yystack, yyvalp, yylocp]b4_user_args[));
       for (yyp = yybest->yynext; yyp != NULL; yyp = yyp->yynext)
       int yyprec = yydprec[yybest->yyrule];
       YYCHK (yyresolveAction (yybest, yystack, yyvalp, yylocp]b4_user_args[));
       for (yyp = yybest->yynext; yyp != NULL; yyp = yyp->yynext)


@@ -1658,7 +1770,7 @@ yyprocessOneStack (yyGLRStack* yystack, size_t yyk,
              yymarkStackDeleted (yystack, yyk);
              return yyok;
            }
              yymarkStackDeleted (yystack, yyk);
              return yyok;
            }

-         YYCHK (yyglrReduce (yystack, yyk, yyrule, yyfalse]b4_lpure_args[));
+         YYCHK (yyglrReduce (yystack, yyk, yyrule, yyfalse]b4_user_args[));

        }
       else
        {
        }
       else
        {


@@ -1668,18 +1780,17 @@ yyprocessOneStack (yyGLRStack* yystack, size_t yyk,
              yychar = YYLEX;
              *yytokenp = YYTRANSLATE (yychar);
              YY_SYMBOL_PRINT ("Next token is", *yytokenp, yylvalp, yyllocp);
              yychar = YYLEX;
              *yytokenp = YYTRANSLATE (yychar);
              YY_SYMBOL_PRINT ("Next token is", *yytokenp, yylvalp, yyllocp);

-             YYDPRINTF ((stderr, "\n"));

            }
          yygetLRActions (yystate, *yytokenp, &yyaction, &yyconflicts);
 
          while (*yyconflicts != 0)
            {
            }
          yygetLRActions (yystate, *yytokenp, &yyaction, &yyconflicts);
 
          while (*yyconflicts != 0)
            {

-             size_t yynewStack = yysplitStack (yystack, yyk]b4_pure_args[);
+             size_t yynewStack = yysplitStack (yystack, yyk);

              YYDPRINTF ((stderr, "Splitting off stack %lu from %lu.\n",
                          (unsigned long int) yynewStack,
                          (unsigned long int) yyk));
              YYCHK (yyglrReduce (yystack, yynewStack,
              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[));
+                                 *yyconflicts, yyfalse]b4_user_args[));

              YYCHK (yyprocessOneStack (yystack, yynewStack, yyposn,
                                        yylvalp, yyllocp]b4_pure_args[));
              yyconflicts += 1;
              YYCHK (yyprocessOneStack (yystack, yynewStack, yyposn,
                                        yylvalp, yyllocp]b4_pure_args[));
              yyconflicts += 1;


@@ -1690,8 +1801,9 @@ yyprocessOneStack (yyGLRStack* yystack, size_t yyk,
              YYDPRINTF ((stderr, "On stack %lu, ", (unsigned long int) yyk));
              YY_SYMBOL_PRINT ("shifting", *yytokenp, yylvalp, yyllocp);
              yyglrShift (yystack, yyk, yyaction, yyposn+1,
              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[);
-             YYDPRINTF ((stderr, ", now in state #%d\n",
+                         *yylvalp, yyllocp);
+             YYDPRINTF ((stderr, "Stack %lu now in state #%d\n",
+                         (unsigned long int) yyk,

                          yystack->yytops.yystates[yyk]->yylrState));
              break;
            }
                          yystack->yytops.yystates[yyk]->yylrState));
              break;
            }


@@ -1703,7 +1815,7 @@ yyprocessOneStack (yyGLRStack* yystack, size_t yyk,
              break;
            }
          else
              break;
            }
          else

-           YYCHK (yyglrReduce (yystack, yyk, -yyaction, yyfalse]b4_lpure_args[));
+           YYCHK (yyglrReduce (yystack, yyk, -yyaction, yyfalse]b4_user_args[));

        }
     }
   return yyok;
        }
     }
   return yyok;


@@ -1725,7 +1837,7 @@ 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 yysize0 = strlen (yytokenName (*yytokenp));
+         size_t yysize0 = yytnamerr (NULL, yytokenName (*yytokenp));

          size_t yysize = yysize0;
          size_t yysize1;
          yybool yysize_overflow = yyfalse;
          size_t yysize = yysize0;
          size_t yysize1;
          yybool yysize_overflow = yyfalse;


@@ -1767,15 +1879,15 @@ yyreportSyntaxError (yyGLRStack* yystack,
                    break;
                  }
                yyarg[yycount++] = yytokenName (yyx);
                    break;
                  }
                yyarg[yycount++] = yytokenName (yyx);

-               yysize1 = yysize + strlen (yytokenName (yyx));
+               yysize1 = yysize + yytnamerr (NULL, yytokenName (yyx));

                yysize_overflow |= yysize1 < yysize;
                yysize = yysize1;
                yyfmt = yystpcpy (yyfmt, yyprefix);
                yyprefix = yyor;
              }
 
                yysize_overflow |= yysize1 < yysize;
                yysize = yysize1;
                yyfmt = yystpcpy (yyfmt, yyprefix);
                yyprefix = yyor;
              }
 

-         yyf = yyformat;
-         yysize1 = yysize + (yyfmt - yyformat);
+         yyf = YY_(yyformat);
+         yysize1 = yysize + strlen (yyf);

          yysize_overflow |= yysize1 < yysize;
          yysize = yysize1;
 
          yysize_overflow |= yysize1 < yysize;
          yysize = yysize1;
 


@@ -1790,7 +1902,7 @@ yyreportSyntaxError (yyGLRStack* yystack,
                {
                  if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
                    {
                {
                  if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
                    {

-                     yyp = yystpcpy (yyp, yyarg[yyi++]);
+                     yyp += yytnamerr (yyp, yyarg[yyi++]);

                      yyf += 2;
                    }
                  else
                      yyf += 2;
                    }
                  else


@@ -1803,11 +1915,14 @@ yyreportSyntaxError (yyGLRStack* yystack,
              YYFREE (yymsg);
            }
          else
              YYFREE (yymsg);
            }
          else

-           yyerror (]b4_lyyerror_args["syntax error; also virtual memory exhausted");
+           {
+             yyerror (]b4_lyyerror_args[YY_("syntax error"));
+             yyMemoryExhausted (yystack);
+           }

        }
       else
 #endif /* YYERROR_VERBOSE */
        }
       else
 #endif /* YYERROR_VERBOSE */

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

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


@@ -1831,21 +1946,7 @@ yyrecoverSyntaxError (yyGLRStack* yystack,
     while (yytrue)
       {
        if (*yytokenp == YYEOF)
     while (yytrue)
       {
        if (*yytokenp == YYEOF)

-         {
-           /* Now pop stack until empty and fail. */
-           while (yystack->yytops.yystates[0] != NULL)
-             {
-               yyGLRState *yys = yystack->yytops.yystates[0];
-]b4_location_if([[             yystack->yyerror_range[1].yystate.yyloc = yys->yyloc;]])[
-               yydestruct ("Error: popping",
-                            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);
-         }
+         yyFail (yystack][]b4_lpure_args[, NULL);

        if (*yytokenp != YYEMPTY)
          {]b4_location_if([[
            /* We throw away the lookahead, but the error range
        if (*yytokenp != YYEMPTY)
          {]b4_location_if([[
            /* We throw away the lookahead, but the error range


@@ -1862,7 +1963,6 @@ yyrecoverSyntaxError (yyGLRStack* yystack,
        yychar = YYLEX;
        *yytokenp = YYTRANSLATE (yychar);
        YY_SYMBOL_PRINT ("Next token is", *yytokenp, yylvalp, yyllocp);
        yychar = YYLEX;
        *yytokenp = YYTRANSLATE (yychar);
        YY_SYMBOL_PRINT ("Next token is", *yytokenp, yylvalp, yyllocp);

-       YYDPRINTF ((stderr, "\n"));

        yyj = yypact[yystack->yytops.yystates[0]->yylrState];
        if (yyis_pact_ninf (yyj))
          return;
        yyj = yypact[yystack->yytops.yystates[0]->yylrState];
        if (yyis_pact_ninf (yyj))
          return;


@@ -1905,17 +2005,14 @@ yyrecoverSyntaxError (yyGLRStack* yystack,
              YYLLOC_DEFAULT (yyerrloc, yystack->yyerror_range, 2);]])[
              YY_SYMBOL_PRINT ("Shifting", yystos[yytable[yyj]],
                               yylvalp, &yyerrloc);
              YYLLOC_DEFAULT (yyerrloc, yystack->yyerror_range, 2);]])[
              YY_SYMBOL_PRINT ("Shifting", yystos[yytable[yyj]],
                               yylvalp, &yyerrloc);

-             YYDPRINTF ((stderr, "\n"));

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

-                         yys->yyposn, *yylvalp, &yyerrloc]b4_user_args[);
+                         yys->yyposn, *yylvalp, &yyerrloc);

              yys = yystack->yytops.yystates[0];
              break;
            }
        }
 ]b4_location_if([[      yystack->yyerror_range[1].yystate.yyloc = yys->yyloc;]])[
              yys = yystack->yytops.yystates[0];
              break;
            }
        }
 ]b4_location_if([[      yystack->yyerror_range[1].yystate.yyloc = yys->yyloc;]])[

-      yydestruct ("Error: popping",
-                 yystos[yys->yylrState],
-                 &yys->yysemantics.yysval]b4_location_if([, &yys->yyloc])[);
+      yydestroyGLRState ("Error: popping", yys);

       yystack->yytops.yystates[0] = yys->yypred;
       yystack->yynextFree -= 1;
       yystack->yyspaceLeft += 1;
       yystack->yytops.yystates[0] = yys->yypred;
       yystack->yynextFree -= 1;
       yystack->yyspaceLeft += 1;


@@ -1981,14 +2078,14 @@ m4_popdef([b4_at_dollar])dnl
 b4_syncline([@oline@], [@ofile@])])dnl
 [
   if (! yyinitGLRStack (&yystack, YYINITDEPTH))
 b4_syncline([@oline@], [@ofile@])])dnl
 [
   if (! yyinitGLRStack (&yystack, YYINITDEPTH))

-    goto yyoverflowlab;
+    goto yyexhaustedlab;

   switch (setjmp (yystack.yyexception_buffer))
     {
     case 1: goto yyabortlab;
   switch (setjmp (yystack.yyexception_buffer))
     {
     case 1: goto yyabortlab;

-    case 2: goto yyoverflowlab;
+    case 2: goto yyexhaustedlab;

     }
   yystack.yytokenp = &yytoken;
     }
   yystack.yytokenp = &yytoken;

-  yyglrShift (&yystack, 0, 0, 0, yylval, &yylloc]b4_user_args[);
+  yyglrShift (&yystack, 0, 0, 0, yylval, &yylloc);

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


@@ -2016,7 +2113,7 @@ b4_syncline([@oline@], [@ofile@])])dnl
                  yyreportSyntaxError (&yystack, yylvalp, yyllocp]b4_user_args[);
                  goto yyuser_error;
                }
                  yyreportSyntaxError (&yystack, yylvalp, yyllocp]b4_user_args[);
                  goto yyuser_error;
                }

-             YYCHK1 (yyglrReduce (&yystack, 0, yyrule, yytrue]b4_lpure_args[));
+             YYCHK1 (yyglrReduce (&yystack, 0, yyrule, yytrue]b4_user_args[));

            }
          else
            {
            }
          else
            {


@@ -2026,7 +2123,6 @@ b4_syncline([@oline@], [@ofile@])])dnl
                  yychar = YYLEX;
                  yytoken = YYTRANSLATE (yychar);
                   YY_SYMBOL_PRINT ("Next token is", yytoken, yylvalp, yyllocp);
                  yychar = YYLEX;
                  yytoken = YYTRANSLATE (yychar);
                   YY_SYMBOL_PRINT ("Next token is", yytoken, yylvalp, yyllocp);

-                  YYDPRINTF ((stderr, "\n"));

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


@@ -2034,12 +2130,10 @@ b4_syncline([@oline@], [@ofile@])])dnl
              if (yyisShiftAction (yyaction))
                {
                  YY_SYMBOL_PRINT ("Shifting", yytoken, yylvalp, yyllocp);
              if (yyisShiftAction (yyaction))
                {
                  YY_SYMBOL_PRINT ("Shifting", yytoken, yylvalp, yyllocp);

-                 YYDPRINTF ((stderr, "\n"));

                  if (yytoken != YYEOF)
                    yytoken = YYEMPTY;
                  yyposn += 1;
                  if (yytoken != YYEOF)
                    yytoken = YYEMPTY;
                  yyposn += 1;

-                 yyglrShift (&yystack, 0, yyaction, yyposn,
-                             yylval, yyllocp]b4_user_args[);
+                 yyglrShift (&yystack, 0, yyaction, yyposn, yylval, yyllocp);

                  if (0 < yystack.yyerrState)
                    yystack.yyerrState -= 1;
                }
                  if (0 < yystack.yyerrState)
                    yystack.yyerrState -= 1;
                }


@@ -2050,7 +2144,7 @@ b4_syncline([@oline@], [@ofile@])])dnl
                  goto yyuser_error;
                }
              else
                  goto yyuser_error;
                }
              else

-               YYCHK1 (yyglrReduce (&yystack, 0, -yyaction, yytrue]b4_lpure_args[));
+               YYCHK1 (yyglrReduce (&yystack, 0, -yyaction, yytrue]b4_user_args[));

            }
        }
 
            }
        }
 


@@ -2068,7 +2162,7 @@ b4_syncline([@oline@], [@ofile@])])dnl
            {
              yyundeleteLastStack (&yystack);
              if (yystack.yytops.yysize == 0)
            {
              yyundeleteLastStack (&yystack);
              if (yystack.yytops.yysize == 0)

-               yyFail (&yystack][]b4_lpure_args[, "syntax error");
+               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 = *yyllocp;]])[
              YYCHK1 (yyresolveStack (&yystack]b4_user_args[));
              YYDPRINTF ((stderr, "Returning to deterministic operation.\n"));
 ]b4_location_if([[           yystack.yyerror_range[1].yystate.yyloc = *yyllocp;]])[


@@ -2097,24 +2191,43 @@ b4_syncline([@oline@], [@ofile@])])dnl
   yyresult = 1;
   goto yyreturn;
 
   yyresult = 1;
   goto yyreturn;
 

- yyoverflowlab:
-  yyerror (]b4_lyyerror_args["parser stack overflow");
+ yyexhaustedlab:
+  yyerror (]b4_lyyerror_args[YY_("memory exhausted"));

   yyresult = 2;
   /* Fall through.  */
 
  yyreturn:
   if (yytoken != YYEOF && yytoken != YYEMPTY)
   yyresult = 2;
   /* Fall through.  */
 
  yyreturn:
   if (yytoken != YYEOF && yytoken != YYEMPTY)

-    yydestruct ("Error: discarding lookahead",
+    yydestruct ("Cleanup: discarding lookahead",

                 yytoken, yylvalp]b4_location_if([, yyllocp])[);
 
                 yytoken, yylvalp]b4_location_if([, yyllocp])[);
 

-  yyfreeGLRStack (&yystack);
+  /* If the stack is well-formed, pop the stack until it is empty,
+     destroying its entries as we go.  But free the stack regardless
+     of whether it is well-formed.  */
+  if (yystack.yyitems)
+    {
+      yyGLRState** yystates = yystack.yytops.yystates;
+      if (yystates)
+       while (yystates[0])
+         {
+           yyGLRState *yys = yystates[0];
+]b4_location_if([[       yystack.yyerror_range[1].yystate.yyloc = yys->yyloc;]]
+)[         yydestroyGLRState ("Cleanup: popping", yys);
+           yystates[0] = yys->yypred;
+           yystack.yynextFree -= 1;
+           yystack.yyspaceLeft += 1;
+         }
+      yyfreeGLRStack (&yystack);
+    }
+

   return yyresult;
 }
 
 /* DEBUGGING ONLY */
 #ifdef YYDEBUG
   return yyresult;
 }
 
 /* DEBUGGING ONLY */
 #ifdef YYDEBUG

-static void yypstack (yyGLRStack* yystack, size_t yyk) ATTRIBUTE_UNUSED;
-static void yypdumpstack (yyGLRStack* yystack) ATTRIBUTE_UNUSED;
+static void yypstack (yyGLRStack* yystack, size_t yyk)
+  __attribute__ ((__unused__));
+static void yypdumpstack (yyGLRStack* yystack) __attribute__ ((__unused__));

 
 static void
 yy_yypstack (yyGLRState* yys)
 
 static void
 yy_yypstack (yyGLRState* yys)