]> git.saurik.com Git - bison.git/blobdiff - data/glr.c
projects / bison.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
(yyexpandGLRStack) [!YYSTACKEXPANDABLE]:
[bison.git] / data / glr.c
diff --git a/data/glr.c b/data/glr.c
index 0db475756f553ae91b4e74bc83dbf635de5c4254..d04edbd08ac12e0011a0b295348f57d0a3445a98 100644 (file)
--- a/data/glr.c
+++ b/data/glr.c
@@ -1,8 +1,7 @@
 m4_divert(-1)                                                       -*- C -*-
 m4_divert(-1)                                                       -*- C -*-
-m4_include([c.m4])
 
 # GLR skeleton for Bison
 
 # GLR skeleton for Bison
-# Copyright (C) 2002 Free Software Foundation, Inc.
+# Copyright (C) 2002, 2003 Free Software Foundation, Inc.
 
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -28,9 +27,6 @@ m4_include([c.m4])
 m4_define_default([b4_stack_depth_max], [10000])
 m4_define_default([b4_stack_depth_init],  [200])
 
 m4_define_default([b4_stack_depth_max], [10000])
 m4_define_default([b4_stack_depth_init],  [200])
 
-# Location type.
-m4_define_default([b4_location_type], [yyltype])
-
 
 
 ## ------------------------ ##
 
 
 ## ------------------------ ##
@@ -115,7 +111,7 @@ m4_define([b4_lhs_value],
 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
 # symbols on RHS.
 m4_define([b4_rhs_value],
 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
 # symbols on RHS.
 m4_define([b4_rhs_value],
-[yyvsp@<:@m4_eval([$2 - $1])@:>@.yystate.yysemantics.yysval[]m4_ifval([$3], [.$3])])
+[yyvsp@{YYFILL (m4_eval([$2 - $1]))@}.yystate.yysemantics.yysval[]m4_ifval([$3], [.$3])])
 
 
 
 
 
 
@@ -135,43 +131,16 @@ m4_define([b4_lhs_location],
 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
 # on RHS.
 m4_define([b4_rhs_location],
 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
 # on RHS.
 m4_define([b4_rhs_location],
-[yyvsp@<:@m4_eval([$2 - $1])@:>@.yystate.yyloc])
-
-
-
-## ------------------- ##
-## Output file names.  ##
-## ------------------- ##
-
-m4_define_default([b4_input_suffix], [.y])
-
-m4_define_default([b4_output_parser_suffix],
-[m4_translit(b4_input_suffix, [yY], [cC])])
-
-m4_define_default([b4_output_parser_name],
-[b4_output_prefix[]b4_output_infix[]b4_output_parser_suffix[]])
-
-
-m4_define_default([b4_output_header_suffix],
-[m4_translit(b4_input_suffix, [yY], [hH])])
-
-m4_define_default([b4_output_header_name],
-[b4_output_prefix[]b4_output_infix[]b4_output_header_suffix[]])
-
-m4_define_default([b4_header_guard],
-                  [m4_bpatsubst(m4_toupper([BISON_]b4_output_header_name),
-                                [[^ABCDEFGHIJKLMNOPQRSTUVWXYZ]], [_])])
-
+[yyvsp@{YYFILL (m4_eval([$2 - $1]))@}.yystate.yyloc])
 
 # We do want M4 expansion after # for CPP macros.
 m4_changecom()
 m4_divert(0)dnl
 
 # We do want M4 expansion after # for CPP macros.
 m4_changecom()
 m4_divert(0)dnl
-#output "b4_output_parser_name"
-b4_copyright([Skeleton parser for GLR parsing with Bison], [2002])
+@output @output_parser_name@
+b4_copyright([Skeleton parser for GLR parsing with Bison], [2002, 2003])
 [
 /* 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>
@@ -209,32 +178,32 @@ b4_pre_prologue[
 # define YYERROR_VERBOSE ]b4_error_verbose[
 #endif
 
 # define YYERROR_VERBOSE ]b4_error_verbose[
 #endif
 
-#ifndef YYSTYPE
+#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
 ]m4_ifdef([b4_stype],
 [b4_syncline([b4_stype_line], [b4_filename])
 ]m4_ifdef([b4_stype],
 [b4_syncline([b4_stype_line], [b4_filename])
-typedef union b4_stype yystype;
-/* Line __line__ of __file__.  */
-b4_syncline([__oline__], [__ofile__])],
-[typedef int yystype;])[
-# define YYSTYPE yystype
+typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])b4_stype YYSTYPE;
+/* Line __line__ of glr.c.  */
+b4_syncline([@oline@], [@ofile@])],
+[typedef int YYSTYPE;])[
+# define YYSTYPE_IS_DECLARED 1
 # define YYSTYPE_IS_TRIVIAL 1
 #endif
 
 # define YYSTYPE_IS_TRIVIAL 1
 #endif
 
-#ifndef YYLTYPE
-typedef struct yyltype
+#if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED)
+typedef struct YYLTYPE
 {
   int first_line;
   int first_column;
   int last_line;
   int last_column;
 {
   int first_line;
   int first_column;
   int last_line;
   int last_column;
-} yyltype;
-# define YYLTYPE ]b4_location_type[
+} YYLTYPE;
+# define YYLTYPE_IS_DECLARED 1
 # define YYLTYPE_IS_TRIVIAL 1
 #endif
 
 /* Default (constant) values used for initialization for null
 # define YYLTYPE_IS_TRIVIAL 1
 #endif
 
 /* Default (constant) values used for initialization for null
-   right-hand sides.  Unlike the standard bison.simple template,
-   here we set the default values of the $$ and $@ to zeroed-out
+   right-hand sides.  Unlike the standard yacc.c template,
+   here we set the default values of $$ and $@@ to zeroed-out
    values.  Since the default value of these quantities is undefined,
    this behavior is technically correct. */
 static YYSTYPE yyval_default;
    values.  Since the default value of these quantities is undefined,
    this behavior is technically correct. */
 static YYSTYPE yyval_default;
@@ -243,14 +212,16 @@ static YYLTYPE yyloc_default;
 /* Copy the second part of user declarations.  */
 ]b4_post_prologue[
 
 /* Copy the second part of user declarations.  */
 ]b4_post_prologue[
 
-]/* Line __line__ of __file__.  */
-b4_syncline([__oline__], [__ofile__])
+]/* Line __line__ of glr.c.  */
+b4_syncline([@oline@], [@ofile@])
 [
 [
-#if ! defined (__cplusplus)
-   typedef char bool;
-#  define yytrue 1
-#  define yyfalse 0
+#ifdef __cplusplus
+   typedef bool yybool;
+#else
+   typedef unsigned char yybool;
 #endif
 #endif
+#define yytrue 1
+#define yyfalse 0
 
 /*-----------------.
 | GCC extensions.  |
 
 /*-----------------.
 | GCC extensions.  |
@@ -268,10 +239,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.  */
@@ -292,8 +259,9 @@ b4_syncline([__oline__], [__ofile__])
 #define YYUNDEFTOK  ]b4_undef_token_number[
 #define YYMAXUTOK   ]b4_user_token_number_max[
 
 #define YYUNDEFTOK  ]b4_undef_token_number[
 #define YYMAXUTOK   ]b4_user_token_number_max[
 
-#define YYTRANSLATE(YYX) \
-  ((unsigned)(YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
+#define YYTRANSLATE(YYX)                                               \
+  ((YYX <= 0) ? YYEOF :                                                        \
+   (unsigned)(YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 
 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
 static const ]b4_int_type_for([b4_translate])[ yytranslate[] =
 
 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
 static const ]b4_int_type_for([b4_translate])[ yytranslate[] =
@@ -329,8 +297,6 @@ static const char *const yytname[] =
 {
   ]b4_tname[
 };
 {
   ]b4_tname[
 };
-
-#define yytname_size ((int) (sizeof (yytname) / sizeof (yytname[0])))
 #endif
 
 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 #endif
 
 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
@@ -388,7 +354,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[] =
 {
@@ -419,6 +385,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)[
@@ -475,12 +448,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.  */
@@ -510,8 +508,9 @@ int yydebug;
    properly redirected to new data. */
 #define YYHEADROOM 2
 
    properly redirected to new data. */
 #define YYHEADROOM 2
 
-#if ! defined (YYSTACKEXPANDABLE) \
-    && (! defined (__cplusplus) || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))
+#if (! defined (YYSTACKEXPANDABLE) \
+     && (! defined (__cplusplus) \
+        || (]b4_location_if([YYLTYPE_IS_TRIVIAL && ])[YYSTYPE_IS_TRIVIAL)))
 #define YYSTACKEXPANDABLE 1
 #else
 #define YYSTACKEXPANDABLE 0
 #define YYSTACKEXPANDABLE 1
 #else
 #define YYSTACKEXPANDABLE 0
@@ -536,8 +535,8 @@ typedef struct yyGLRStack yyGLRStack;
 typedef struct yyGLRStateSet yyGLRStateSet;
 
 struct yyGLRState {
 typedef struct yyGLRStateSet yyGLRStateSet;
 
 struct yyGLRState {
-  bool yyisState;
-  bool yyresolved;
+  yybool yyisState;
+  yybool yyresolved;
   yyStateNum yylrState;
   yyGLRState* yypred;
   size_t yyposn;
   yyStateNum yylrState;
   yyGLRState* yypred;
   size_t yyposn;
@@ -554,7 +553,7 @@ struct yyGLRStateSet {
 };
 
 struct yySemanticOption {
 };
 
 struct yySemanticOption {
-  bool yyisState;
+  yybool yyisState;
   yyRuleNum yyrule;
   yyGLRState* yystate;
   yySemanticOption* yynext;
   yyRuleNum yyrule;
   yyGLRState* yystate;
   yySemanticOption* yynext;
@@ -590,12 +589,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);
     }
@@ -612,18 +611,40 @@ yytokenName (yySymbol yytoken)
 }
 #endif
 
 }
 #endif
 
+/** Fill in YYVSP[YYLOW1 .. YYLOW0-1] from the chain of states starting
+ *  at YYVSP[YYLOW0].yystate.yypred.  Leaves YYVSP[YYLOW1].yystate.yypred
+ *  containing the pointer to the next state in the chain. Assumes
+ *  YYLOW1 < YYLOW0.  For convenience, returns YYLOW1. */
+static int
+yyfill (yyGLRStackItem* yyvsp, int yylow0, int yylow1)
+{
+  yyGLRState* s;
+  int i;
+  s = yyvsp[yylow0].yystate.yypred;
+  for (i = yylow0-1; i >= yylow1; i -= 1)
+    {
+      if (! s->yyresolved)
+       abort ();
+      yyvsp[i].yystate.yyresolved = yytrue;
+      yyvsp[i].yystate.yysemantics.yysval = s->yysemantics.yysval;
+      yyvsp[i].yystate.yyloc = s->yyloc;
+      s = yyvsp[i].yystate.yypred = s->yypred;
+    }
+  return yylow1;
+}
+
 /** Perform user action for rule number YYN, with RHS length YYRHSLEN,
  *  and top stack item YYVSP.  YYLVALP points to place to put semantic
  *  value ($$), and yylocp points to place for location information
 /** Perform user action for rule number YYN, with RHS length YYRHSLEN,
  *  and top stack item YYVSP.  YYLVALP points to place to put semantic
  *  value ($$), and yylocp points to place for location information
- *  (@$). Returns yyok for normal return, yyaccept for YYACCEPT,
+ *  (@@$). Returns yyok for normal return, yyaccept for YYACCEPT,
  *  yyerr for YYERROR, yyabort for YYABORT. */
 static YYRESULTTAG
 yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,
              YYSTYPE* yyvalp, YYLTYPE* yylocp, yyGLRStack* yystack
               ]b4_user_formals[)
 {
  *  yyerr for YYERROR, yyabort for YYABORT. */
 static YYRESULTTAG
 yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,
              YYSTYPE* yyvalp, YYLTYPE* yylocp, yyGLRStack* yystack
               ]b4_user_formals[)
 {
-  /* Avoid `unused' warnings in there are no $n. */
-  (void) yystack;
+  int yynormal = (yystack->yysplitPoint == NULL);
+  int yylow;
 
   if (yyrhslen == 0)
     {
 
   if (yyrhslen == 0)
     {
@@ -635,8 +656,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
@@ -649,6 +668,9 @@ yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,
 # define YYRECOVERING (yystack->yyerrState != 0)
 # undef yyclearin
 # define yyclearin (yychar = *(yystack->yytokenp) = YYEMPTY)
 # define YYRECOVERING (yystack->yyerrState != 0)
 # undef yyclearin
 # define yyclearin (yychar = *(yystack->yytokenp) = YYEMPTY)
+# undef YYFILL
+# define YYFILL(N)                                                          \
+  ((yynormal || yylow <= (N)) ? (N) : (yylow = yyfill (yyvsp, yylow, N)))
 # undef YYBACKUP
 # define YYBACKUP(Token, Value)                                                     \
   do {                                                                      \
 # undef YYBACKUP
 # define YYBACKUP(Token, Value)                                                     \
   do {                                                                      \
@@ -657,13 +679,13 @@ yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,
   } while (0)
 
 ]
   } while (0)
 
 ]
+   yylow = 1;
    switch (yyn)
      {
        b4_actions
      }
 
    return yyok;
    switch (yyn)
      {
        b4_actions
      }
 
    return yyok;
-# undef yyval
 # undef yyerrok
 # undef YYABORT
 # undef YYACCEPT
 # undef yyerrok
 # undef YYABORT
 # undef YYACCEPT
@@ -671,8 +693,8 @@ yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,
 # undef YYBACKUP
 # undef yyclearin
 # undef YYRECOVERING
 # undef YYBACKUP
 # undef yyclearin
 # undef YYRECOVERING
-/* Line __line__ of __file__.  */
-b4_syncline([__oline__], [__ofile__])
+/* Line __line__ of glr.c.  */
+b4_syncline([@oline@], [@ofile@])
 }
 \f
 
 }
 \f
 
@@ -693,6 +715,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)
@@ -707,12 +731,17 @@ yylhsNonterm (yyRuleNum yyrule)
   return yyr1[yyrule];
 }
 
   return yyr1[yyrule];
 }
 
+#define yyis_pact_ninf(yystate) \
+  ]m4_if(m4_eval(b4_pact_ninf < b4_pact_min), 1,
+        0,
+        ((yystate) == YYPACT_NINF))[
+
 /** True iff LR state STATE has only a default reduction (regardless
  *  of token). */
 /** True iff LR state STATE has only a default reduction (regardless
  *  of token). */
-static inline bool
+static inline yybool
 yyisDefaultedState (yyStateNum yystate)
 {
 yyisDefaultedState (yyStateNum yystate)
 {
-  return yypact[yystate] == YYPACT_NINF;
+  return yyis_pact_ninf (yypact[yystate]);
 }
 
 /** The default reduction for STATE, assuming it has one. */
 }
 
 /** The default reduction for STATE, assuming it has one. */
@@ -722,6 +751,11 @@ yydefaultAction (yyStateNum yystate)
   return yydefact[yystate];
 }
 
   return yydefact[yystate];
 }
 
+#define yyis_table_ninf(yytable_value) \
+  ]m4_if(m4_eval(b4_table_ninf < b4_table_min), 1,
+        0,
+        ((yytable_value) == YYTABLE_NINF))[
+
 /** Set *YYACTION to the action to take in YYSTATE on seeing YYTOKEN.
  *  Result R means
  *    R < 0:  Reduce on rule -R.
 /** Set *YYACTION to the action to take in YYSTATE on seeing YYTOKEN.
  *  Result R means
  *    R < 0:  Reduce on rule -R.
@@ -740,7 +774,7 @@ yygetLRActions (yyStateNum yystate, int yytoken,
       *yyaction = -yydefact[yystate];
       *yyconflicts = yyconfl;
     }
       *yyaction = -yydefact[yystate];
       *yyconflicts = yyconfl;
     }
-  else if (yytable[yyindex] != YYTABLE_NINF)
+  else if (! yyis_table_ninf (yytable[yyindex]))
     {
       *yyaction = yytable[yyindex];
       *yyconflicts = yyconfl + yyconflp[yyindex];
     {
       *yyaction = yytable[yyindex];
       *yyconflicts = yyconfl + yyconflp[yyindex];
@@ -763,13 +797,13 @@ yyLRgotoState (yyStateNum yystate, yySymbol yylhs)
     return yydefgoto[yylhs - YYNTOKENS];
 }
 
     return yydefgoto[yylhs - YYNTOKENS];
 }
 
-static inline bool
+static inline yybool
 yyisShiftAction (int yyaction)
 {
   return 0 < yyaction;
 }
 
 yyisShiftAction (int yyaction)
 {
   return 0 < yyaction;
 }
 
-static inline bool
+static inline yybool
 yyisErrorAction (int yyaction)
 {
   return yyaction == 0;
 yyisErrorAction (int yyaction)
 {
   return yyaction == 0;
@@ -777,14 +811,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[)
@@ -853,8 +879,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;
@@ -864,7 +889,7 @@ yyexpandGLRStack (yyGLRStack* yystack]b4_pure_formals[)
        yyn -= 1, yyp0 += 1, yyp1 += 1)
     {
       *yyp1 = *yyp0;
        yyn -= 1, yyp0 += 1, yyp1 += 1)
     {
       *yyp1 = *yyp0;
-      if (*(bool*) yyp0)
+      if (*(yybool *) yyp0)
        {
          yyGLRState* yys0 = &yyp0->yystate;
          yyGLRState* yys1 = &yyp1->yystate;
        {
          yyGLRState* yys0 = &yyp0->yystate;
          yyGLRState* yys1 = &yyp1->yystate;
@@ -901,8 +926,7 @@ yyexpandGLRStack (yyGLRStack* yystack]b4_pure_formals[)
 
 #else
 
 
 #else
 
-  yyFail (yystack][]b4_lpure_args[,
-          "parsing stack overflow (%d items)", yysize);
+  yyFail (yystack][]b4_pure_args[, "parser stack overflow");
 #endif
 }
 
 #endif
 }
 
@@ -956,14 +980,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;
@@ -993,9 +1021,9 @@ yyglrShift (yyGLRStack* yystack, int yyk, yyStateNum yylrState, size_t yyposn,
     yyexpandGLRStack (yystack]b4_pure_args[);
 }
 
     yyexpandGLRStack (yystack]b4_pure_args[);
 }
 
-/** Shift to a new state on stack #K of STACK, to a new state
- *  corresponding to LR state LRSTATE, at input position POSN, with
- * the (unresolved) semantic value of RHS under the action for RULE. */
+/** Shift stack #K of YYSTACK, to a new state corresponding to LR
+ *  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,
                 size_t yyposn, yyGLRState* rhs, yyRuleNum yyrule]b4_pure_formals[)
 static inline void
 yyglrShiftDefer (yyGLRStack* yystack, int yyk, yyStateNum yylrState,
                 size_t yyposn, yyGLRState* rhs, yyRuleNum yyrule]b4_pure_formals[)
@@ -1021,7 +1049,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[)
 {
@@ -1031,7 +1059,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;
@@ -1052,14 +1081,13 @@ yydoAction (yyGLRStack* yystack, int yyk, yyRuleNum yyrule,
     {
       int yyi;
       yyGLRState* yys;
     {
       int yyi;
       yyGLRState* yys;
-      yyGLRStackItem yyrhsVals[YYMAXRHS];
-      for (yyi = yynrhs-1, yys = yystack->yytops.yystates[yyk]; 0 <= yyi;
-          yyi -= 1, yys = yys->yypred)
+      yyGLRStackItem yyrhsVals[YYMAXRHS+1];
+      yys = yyrhsVals[YYMAXRHS].yystate.yypred = yystack->yytops.yystates[yyk];
+      for (yyi = 0; yyi < yynrhs; yyi += 1)
        {
        {
-         assert (yys->yypred != NULL);
-         yyrhsVals[yyi].yystate.yyresolved = yytrue;
-         yyrhsVals[yyi].yystate.yysemantics.yysval = yys->yysemantics.yysval;
-         yyrhsVals[yyi].yystate.yyloc = yys->yyloc;
+         yys = yys->yypred;
+         if (yys == NULL)
+           abort ();
        }
       yyupdateSplit (yystack, yys);
       yystack->yytops.yystates[yyk] = yys;
        }
       yyupdateSplit (yystack, yys);
       yystack->yytops.yystates[yyk] = yys;
@@ -1070,10 +1098,10 @@ yydoAction (yyGLRStack* yystack, int yyk, yyRuleNum yyrule,
        }
       else
        {
        }
       else
        {
-         *yyvalp = yyrhsVals[0].yystate.yysemantics.yysval;
-         *yylocp = yyrhsVals[0].yystate.yyloc;
+         *yyvalp = yyrhsVals[1].yystate.yysemantics.yysval;
+         *yylocp = yyrhsVals[1].yystate.yyloc;
        }
        }
-      return yyuserAction (yyrule, yynrhs, yyrhsVals + (yynrhs-1),
+      return yyuserAction (yyrule, yynrhs, yyrhsVals + YYMAXRHS - 1,
                           yyvalp, yylocp, yystack]b4_user_args[);
     }
 }
                           yyvalp, yylocp, yystack]b4_user_args[);
     }
 }
@@ -1095,12 +1123,13 @@ 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]));
+  unsigned int yylno = yyrline[yyrule];
+  YYFPRINTF (stderr, "Reducing stack %d by rule %d (line %u), ",
+            yyk, yyrule - 1, yylno);
   /* 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
 
@@ -1117,7 +1146,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,
-             bool yyforceEval]b4_pure_formals[)
+             yybool yyforceEval]b4_pure_formals[)
 {
   size_t yyposn = yystack->yytops.yystates[yyk]->yyposn;
 
 {
   size_t yyposn = yystack->yytops.yystates[yyk]->yyposn;
 
@@ -1132,8 +1161,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
     {
@@ -1146,7 +1173,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 == NULL)
+           abort ();
        }
       yyupdateSplit (yystack, yys);
       yynewLRState = yyLRgotoState (yys->yylrState, yylhsNonterm (yyrule));
        }
       yyupdateSplit (yystack, yys);
       yynewLRState = yyLRgotoState (yys->yylrState, yylhsNonterm (yyrule));
@@ -1167,7 +1195,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;
              }
@@ -1175,7 +1203,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
@@ -1183,7 +1211,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)
@@ -1203,7 +1232,7 @@ yysplitStack (yyGLRStack* yystack, int yyk)
 /** True iff Y0 and Y1 represent identical options at the top level.
  *  That is, they represent the same rule applied to RHS symbols
  *  that produce the same terminal symbols. */
 /** True iff Y0 and Y1 represent identical options at the top level.
  *  That is, they represent the same rule applied to RHS symbols
  *  that produce the same terminal symbols. */
-static bool
+static yybool
 yyidenticalOptions (yySemanticOption* yyy0, yySemanticOption* yyy1)
 {
   if (yyy0->yyrule == yyy1->yyrule)
 yyidenticalOptions (yySemanticOption* yyy0, yySemanticOption* yyy1)
 {
   if (yyy0->yyrule == yyy1->yyrule)
@@ -1241,7 +1270,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;
       }
 }
@@ -1281,7 +1310,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 == NULL)
+       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;
@@ -1302,21 +1332,13 @@ static YYRESULTTAG
 yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystack,
                 YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[)
 {
 yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystack,
                 YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[)
 {
-  yyGLRStackItem yyrhsVals[YYMAXRHS];
-  int yynrhs, yyi;
-  yyGLRState* yys;
+  yyGLRStackItem yyrhsVals[YYMAXRHS+1];
+  int yynrhs;
 
   yynrhs = yyrhsLength (yyopt->yyrule);
   YYCHK (yyresolveStates (yyopt->yystate, yynrhs, yystack]b4_user_args[));
 
   yynrhs = yyrhsLength (yyopt->yyrule);
   YYCHK (yyresolveStates (yyopt->yystate, yynrhs, yystack]b4_user_args[));
-  for (yyi = yynrhs-1, yys = yyopt->yystate; 0 <= yyi;
-       yyi -= 1, yys = yys->yypred)
-    {
-      assert (yys->yypred != NULL);
-      yyrhsVals[yyi].yystate.yyresolved = yytrue;
-      yyrhsVals[yyi].yystate.yysemantics.yysval = yys->yysemantics.yysval;
-      yyrhsVals[yyi].yystate.yyloc = yys->yyloc;
-    }
-  return yyuserAction (yyopt->yyrule, yynrhs, yyrhsVals + (yynrhs-1),
+  yyrhsVals[YYMAXRHS].yystate.yypred = yyopt->yystate;
+  return yyuserAction (yyopt->yyrule, yynrhs, yyrhsVals + YYMAXRHS - 1,
                       yyvalp, yylocp, yystack]b4_user_args[);
 }
 
                       yyvalp, yylocp, yystack]b4_user_args[);
 }
 
@@ -1451,7 +1473,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[));
     }
@@ -1501,8 +1523,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);
@@ -1520,9 +1544,8 @@ yyprocessOneStack (yyGLRStack* yystack, int yyk,
            {
              YYDPRINTF ((stderr, "Reading a token: "));
              yychar = YYLEX;
            {
              YYDPRINTF ((stderr, "Reading a token: "));
              yychar = YYLEX;
-             *yytokenp = YYTRANSLATE(yychar);
-             YYDPRINTF ((stderr, "Next token is %s\n",
-                         yytokenName (*yytokenp)));
+             *yytokenp = YYTRANSLATE (yychar);
+             YYDSYMPRINTF ("Next token is", *yytokenp, yylvalp, yyllocp);
            }
          yygetLRActions (yystate, *yytokenp, &yyaction, &yyconflicts);
 
            }
          yygetLRActions (yystate, *yytokenp, &yyaction, &yyconflicts);
 
@@ -1562,8 +1585,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;
@@ -1573,46 +1596,66 @@ yyreportParseError (yyGLRStack* yystack,
     {
 #if YYERROR_VERBOSE
       yySymbol* const yytokenp = yystack->yytokenp;
     {
 #if YYERROR_VERBOSE
       yySymbol* const yytokenp = yystack->yytokenp;
-      int yyn, yyx, yycount;
-      size_t yysize;
-      const char* yyprefix;
-      char* yyp;
-      char* yymsg;
+      int yyn;
       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)
        {
-         yycount = 0;
+         size_t yysize = 0;
+         const char* yyprefix;
+         char* yymsg;
+         int yyx;
+
          /* Start YYX at -YYN if negative to avoid negative indexes in
             YYCHECK.  */
          /* Start YYX at -YYN if negative to avoid negative indexes in
             YYCHECK.  */
-         yysize = sizeof ("parse error, unexpected ")
-           + strlen (yytokenName (*yytokenp));
+         int yyxbegin = yyn < 0 ? -yyn : 0;
+
+         /* Stay within bounds of both yycheck and yytname.  */
+         int yychecklim = YYLAST - yyn;
+         int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
+         int yycount = 0;
+
          yyprefix = ", expecting ";
          yyprefix = ", expecting ";
-         for (yyx = yyn < 0 ? -yyn : 0; yyx < yytname_size && yycount <= 5;
-              yyx += 1)
+         for (yyx = yyxbegin; yyx < yyxend; ++yyx)
            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
-             yysize += strlen (yytokenName (yyx)) + strlen (yyprefix),
-               yycount += 1, yyprefix = " or ";
-         yymsg = yyp = (char*) malloc (yysize);
-         sprintf (yyp, "parse error, unexpected %s",
-                  yytokenName (*yytokenp));
-         yyp += strlen (yyp);
-         if (yycount < 5)
-           {
-             yyprefix = ", expecting ";
-             for (yyx = yyn < 0 ? -yyn : 0; yyx < yytname_size; yyx += 1)
-               if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
+             {
+               yysize += strlen (yyprefix) + strlen (yytokenName (yyx));
+               yycount += 1;
+               if (yycount == 5)
                  {
                  {
-                   sprintf (yyp, "%s%s", yyprefix, yytokenName (yyx));
-                   yyp += strlen (yyp);
-                   yyprefix = " or ";
+                   yysize = 0;
+                   break;
                  }
                  }
+               yyprefix = " or ";
+             }
+         yysize += (sizeof ("syntax error, unexpected ")
+                    + strlen (yytokenName (*yytokenp)));
+         yymsg = (char*) malloc (yysize);
+         if (yymsg != 0)
+           {
+             char* yyp = yymsg;
+             sprintf (yyp, "syntax error, unexpected %s",
+                      yytokenName (*yytokenp));
+             yyp += strlen (yyp);
+             if (yycount < 5)
+               {
+                 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 ";
+                     }
+               }
+             yyerror (]b4_lyyerror_args[yymsg);
+             free (yymsg);
            }
            }
-         yyerror (]b4_lyyerror_args[yymsg);
-         free (yymsg);
+         else
+           yyerror (]b4_lyyerror_args["syntax error; also virtual memory exhausted");
        }
       else
        }
       else
-#endif
-       yyerror (]b4_lyyerror_args["parse error");
+#endif /* YYERROR_VERBOSE */
+       yyerror (]b4_lyyerror_args["syntax error");
       yynerrs += 1;
     }
 }
       yynerrs += 1;
     }
 }
@@ -1621,8 +1664,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;
@@ -1636,16 +1679,34 @@ 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];
        yyj = yypact[yystack->yytops.yystates[0]->yylrState];
-       if (yyj == YYPACT_NINF)
+       if (yyis_pact_ninf (yyj))
          /* Something's not right; we shouldn't be here.  */
          yyFail (yystack][]b4_lpure_args[, NULL);
        yyj += *yytokenp;
          /* Something's not right; we shouldn't be here.  */
          yyFail (yystack][]b4_lpure_args[, NULL);
        yyj += *yytokenp;
@@ -1654,7 +1715,7 @@ yyrecoverParseError (yyGLRStack* yystack,
            if (yydefact[yystack->yytops.yystates[0]->yylrState] != 0)
              return;
          }
            if (yydefact[yystack->yytops.yystates[0]->yylrState] != 0)
              return;
          }
-       else if (yytable[yyj] != 0 && yytable[yyj] != YYTABLE_NINF)
+       else if (yytable[yyj] != 0 && ! yyis_table_ninf (yytable[yyj]))
          return;
       }
 
          return;
       }
 
@@ -1672,16 +1733,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] + YYTERROR;
-      if (yyj != YYPACT_NINF + YYTERROR && yyj >= 0 && yyj <= YYLAST &&
-         yycheck[yyj] == YYTERROR && yyisShiftAction (yytable[yyj]))
+      yyGLRState *yys = yystack->yytops.yystates[0];
+      yyj = yypact[yys->yylrState];
+      if (! yyis_pact_ninf (yyj))
        {
        {
-         yyglrShift (yystack, 0, yytable[yyj],
-                     yystack->yytops.yystates[0]->yyposn,
-                     *yylvalp, yyllocp]b4_user_args[);
-         break;
+         yyj += YYTERROR;
+         if (0 <= yyj && yyj <= YYLAST && yycheck[yyj] == YYTERROR
+             && yyisShiftAction (yytable[yyj]))
+           {
+             YYDPRINTF ((stderr, "Shifting error token, "));
+             yyglrShift (yystack, 0, yytable[yyj],
+                         yys->yyposn, *yylvalp, yyllocp]b4_user_args[);
+             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;
     }
@@ -1743,7 +1814,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)
        {
@@ -1752,6 +1822,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))
@@ -1759,7 +1830,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[));
@@ -1771,8 +1842,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)
@@ -1788,12 +1858,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
@@ -1815,10 +1883,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)
@@ -1831,7 +1899,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:
@@ -1853,7 +1921,7 @@ yy_yypstack (yyGLRState* yys)
       yy_yypstack (yys->yypred);
       fprintf (stderr, " -> ");
     }
       yy_yypstack (yys->yypred);
       fprintf (stderr, " -> ");
     }
-  fprintf (stderr, "%d@%lu", yys->yylrState, (unsigned long) yys->yyposn);
+  fprintf (stderr, "%d@@%lu", yys->yylrState, (unsigned long) yys->yyposn);
 }
 
 static void
 }
 
 static void
@@ -1884,7 +1952,7 @@ yypdumpstack (yyGLRStack* yystack)
   for (yyp = yystack->yyitems; yyp < yystack->yynextFree; yyp += 1)
     {
       fprintf (stderr, "%3lu. ", (unsigned long) (yyp - yystack->yyitems));
   for (yyp = yystack->yyitems; yyp < yystack->yynextFree; yyp += 1)
     {
       fprintf (stderr, "%3lu. ", (unsigned long) (yyp - yystack->yyitems));
-      if (*(bool*) yyp)
+      if (*(yybool *) yyp)
        {
          fprintf (stderr, "Res: %d, LR State: %d, posn: %lu, pred: %ld",
                   yyp->yystate.yyresolved, yyp->yystate.yylrState,
        {
          fprintf (stderr, "Res: %d, LR State: %d, posn: %lu, pred: %ld",
                   yyp->yystate.yyresolved, yyp->yystate.yylrState,
@@ -1913,40 +1981,39 @@ yypdumpstack (yyGLRStack* yystack)
 
 b4_epilogue
 m4_if(b4_defines_flag, 0, [],
 
 b4_epilogue
 m4_if(b4_defines_flag, 0, [],
-[#output "b4_output_header_name"
-b4_copyright([Skeleton parser for GLR parsing with Bison], [2002])
-#ifndef b4_header_guard
-# define b4_header_guard
+[@output @output_header_name@
+b4_copyright([Skeleton parser for GLR parsing with Bison], [2002, 2003])
 
 b4_token_defines(b4_tokens)
 
 
 b4_token_defines(b4_tokens)
 
-#ifndef YYSTYPE
+#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
 m4_ifdef([b4_stype],
 [b4_syncline([b4_stype_line], [b4_filename])
 m4_ifdef([b4_stype],
 [b4_syncline([b4_stype_line], [b4_filename])
-typedef union b4_stype yystype;
-/* Line __line__ of __file__.  */
-b4_syncline([__oline__], [__ofile__])],
-[typedef int yystype;])
-# define YYSTYPE yystype
+typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])b4_stype YYSTYPE;
+/* Line __line__ of glr.c.  */
+b4_syncline([@oline@], [@ofile@])],
+[typedef int YYSTYPE;])
+# define YYSTYPE_IS_DECLARED 1
+# define YYSTYPE_IS_TRIVIAL 1
 #endif
 
 b4_pure_if([],
 [extern YYSTYPE b4_prefix[]lval;])
 
 b4_location_if(
 #endif
 
 b4_pure_if([],
 [extern YYSTYPE b4_prefix[]lval;])
 
 b4_location_if(
-[#ifndef YYLTYPE
-typedef struct yyltype
+[#if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED)
+typedef struct YYLTYPE
 {
   int first_line;
   int first_column;
   int last_line;
   int last_column;
 {
   int first_line;
   int first_column;
   int last_line;
   int last_column;
-} yyltype;
-# define YYLTYPE yyltype
+} YYLTYPE;
+# define YYLTYPE_IS_DECLARED 1
+# define YYLTYPE_IS_TRIVIAL 1
 #endif
 
 m4_if(b4_pure, [0],
 [extern YYLTYPE b4_prefix[]lloc;])
 ])
 #endif
 
 m4_if(b4_pure, [0],
 [extern YYLTYPE b4_prefix[]lloc;])
 ])
-#endif /* not b4_header_guard */
 ])
 ])
bison