quote consistently and make tests pass with new quoting from gnulib

[bison.git] / data / glr.c

diff --git a/data/glr.c b/data/glr.c
index 20f5043fa433fc7cc610e1feaa7626657afb4c07..17eff38744ea9cfd600d2808ce42292468a1cbdf 100644 (file)
--- a/data/glr.c
+++ b/data/glr.c
@@ -1,22 +1,21 @@
-m4_divert(-1)                                                       -*- C -*-
+                                                                    -*- C -*-

 
 # GLR skeleton for Bison
 
 # GLR skeleton for Bison

-# Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.

 
 

-# This program is free software; you can redistribute it and/or modify
+# Copyright (C) 2002-2012 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
 # it under the terms of the GNU General Public License as published by

-# the Free Software Foundation; either version 2 of the License, or
+# the Free Software Foundation, either version 3 of the License, or

 # (at your option) any later version.
 # (at your option) any later version.

-
+#

 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.

-
+#

 # You should have received a copy of the GNU General Public License
 # You should have received a copy of the GNU General Public License

-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-# 02110-1301  USA
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.

 
 
 m4_include(b4_pkgdatadir/[c.m4])
 
 
 m4_include(b4_pkgdatadir/[c.m4])


@@ -35,6 +34,13 @@ m4_define_default([b4_stack_depth_init],  [200])
 ## Pure/impure interfaces.  ##
 ## ------------------------ ##
 
 ## Pure/impure interfaces.  ##
 ## ------------------------ ##
 

+b4_define_flag_if([pure])
+# If glr.cc is including this file and thus has already set b4_pure_flag,
+# do not change the value of b4_pure_flag, and do not record a use of api.pure.
+m4_ifndef([b4_pure_flag],
+[b4_percent_define_default([[api.pure]], [[false]])
+ m4_define([b4_pure_flag],
+           [b4_percent_define_flag_if([[api.pure]], [[1]], [[0]])])])

 
 # b4_user_formals
 # ---------------
 
 # b4_user_formals
 # ---------------


@@ -52,7 +58,7 @@ m4_define([b4_user_formals],
 # Yes, this is quite ugly...
 m4_define([b4_lex_param],
 m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl
 # Yes, this is quite ugly...
 m4_define([b4_lex_param],
 m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl

-b4_location_if([, [[YYLTYPE *], [&yylloc]]])])dnl
+b4_locations_if([, [[YYLTYPE *], [&yylloc]]])])dnl

 m4_ifdef([b4_lex_param], [, ]b4_lex_param)))
 
 
 m4_ifdef([b4_lex_param], [, ]b4_lex_param)))
 
 


@@ -61,15 +67,15 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param)))
 # Optional effective arguments passed to yyerror: user args plus yylloc, and
 # a trailing comma.
 m4_define([b4_yyerror_args],
 # Optional effective arguments passed to yyerror: user args plus yylloc, and
 # a trailing comma.
 m4_define([b4_yyerror_args],

-[b4_pure_if([b4_location_if([yylocp, ])])dnl
+[b4_pure_if([b4_locations_if([yylocp, ])])dnl

 m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
 
 
 # b4_lyyerror_args
 # ----------------
 m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
 
 
 # b4_lyyerror_args
 # ----------------

-# Same as above, but on the look-ahead, hence &yylloc instead of yylocp.
+# Same as above, but on the lookahead, hence &yylloc instead of yylocp.

 m4_define([b4_lyyerror_args],
 m4_define([b4_lyyerror_args],

-[b4_pure_if([b4_location_if([&yylloc, ])])dnl
+[b4_pure_if([b4_locations_if([&yylloc, ])])dnl

 m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
 
 
 m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
 
 


@@ -77,21 +83,21 @@ m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
 # ------------
 # Same as b4_yyerror_args, but with a leading comma.
 m4_define([b4_pure_args],
 # ------------
 # Same as b4_yyerror_args, but with a leading comma.
 m4_define([b4_pure_args],

-[b4_pure_if([b4_location_if([, yylocp])])[]b4_user_args])
+[b4_pure_if([b4_locations_if([, yylocp])])[]b4_user_args])

 
 
 # b4_lpure_args
 # -------------
 
 
 # b4_lpure_args
 # -------------

-# Same as above, but on the look-ahead, hence &yylloc instead of yylocp.
+# Same as above, but on the lookahead, hence &yylloc instead of yylocp.

 m4_define([b4_lpure_args],
 m4_define([b4_lpure_args],

-[b4_pure_if([b4_location_if([, &yylloc])])[]b4_user_args])
+[b4_pure_if([b4_locations_if([, &yylloc])])[]b4_user_args])

 
 
 # b4_pure_formals
 # ---------------
 # Arguments passed to yyerror: user formals plus yylocp.
 m4_define([b4_pure_formals],
 
 
 # b4_pure_formals
 # ---------------
 # Arguments passed to yyerror: user formals plus yylocp.
 m4_define([b4_pure_formals],

-[b4_pure_if([b4_location_if([, YYLTYPE *yylocp])])[]b4_user_formals])
+[b4_pure_if([b4_locations_if([, YYLTYPE *yylocp])])[]b4_user_formals])

 
 
 ## ----------------- ##
 
 
 ## ----------------- ##


@@ -141,16 +147,17 @@ m4_define([b4_rhs_location],
 
 # We do want M4 expansion after # for CPP macros.
 m4_changecom()
 
 # We do want M4 expansion after # for CPP macros.
 m4_changecom()

-m4_divert(0)dnl
-@output @output_parser_name@
-b4_copyright([Skeleton parser for GLR parsing with Bison],
-  [2002, 2003, 2004, 2005, 2006])
+m4_divert_push(0)dnl
+@output(b4_parser_file_name@)@
+b4_copyright([Skeleton implementation for Bison GLR parsers in C],
+             [2002-2011])

 [
 [

-/* This is the parser code for GLR (Generalized LR) parser.  */
+/* C GLR parser skeleton written by Paul Hilfinger.  */

 
 ]b4_identification
 
 
 ]b4_identification
 

-m4_if(b4_prefix[], [yy], [],
+b4_percent_code_get([[top]])[]dnl
+m4_if(b4_prefix, [yy], [],

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


@@ -159,34 +166,36 @@ m4_if(b4_prefix[], [yy], [],
 #define yychar  b4_prefix[]char
 #define yydebug b4_prefix[]debug
 #define yynerrs b4_prefix[]nerrs
 #define yychar  b4_prefix[]char
 #define yydebug b4_prefix[]debug
 #define yynerrs b4_prefix[]nerrs

-#define yylloc  b4_prefix[]lloc])
+#define yylloc  b4_prefix[]lloc])[
+
+/* Copy the first part of user declarations.  */
+]b4_user_pre_prologue

 
 dnl # b4_shared_declarations
 dnl # ----------------------
 dnl # Declaration that might either go into the header (if --defines)
 dnl # or open coded in the parser body.
 m4_define([b4_shared_declarations],
 
 dnl # b4_shared_declarations
 dnl # ----------------------
 dnl # Declaration that might either go into the header (if --defines)
 dnl # or open coded in the parser body.
 m4_define([b4_shared_declarations],

-[b4_token_enums(b4_tokens)[
+[b4_percent_code_get([[requires]])[]dnl

 
 

-/* Copy the first part of user declarations.  */
-]b4_pre_prologue[
+b4_token_enums(b4_tokens)

 
 

-#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
+[#ifndef YYSTYPE

 ]m4_ifdef([b4_stype],
 ]m4_ifdef([b4_stype],

-[typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])
-b4_stype
-/* Line __line__ of glr.c.  */
-b4_syncline([@oline@], [@ofile@])
-       YYSTYPE;],
-[typedef int YYSTYPE;])[
-# define YYSTYPE_IS_DECLARED 1
-# define YYSTYPE_IS_TRIVIAL 1
+[[typedef union ]b4_union_name[
+{
+]b4_user_stype[
+} YYSTYPE;
+# define YYSTYPE_IS_TRIVIAL 1]],
+[m4_if(b4_tag_seen_flag, 0,
+[[typedef int YYSTYPE;
+# define YYSTYPE_IS_TRIVIAL 1]])])[

 #endif
 
 #endif
 

-#if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED)
+#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED

 typedef struct YYLTYPE
 {
 typedef struct YYLTYPE
 {

-]b4_location_if([
+]b4_locations_if([

   int first_line;
   int first_column;
   int last_line;
   int first_line;
   int first_column;
   int last_line;


@@ -198,15 +207,16 @@ typedef struct YYLTYPE
 # define YYLTYPE_IS_DECLARED 1
 # define YYLTYPE_IS_TRIVIAL 1
 #endif
 # define YYLTYPE_IS_DECLARED 1
 # define YYLTYPE_IS_TRIVIAL 1
 #endif

-]])

 
 

-m4_if(b4_defines_flag, 0,
-      [b4_shared_declarations],
-      [#include @output_header_name@])[
+]b4_percent_code_get([[provides]])[]dnl
+])
+
+b4_defines_if([[#include "@basename(]b4_spec_defines_file[@)"]],
+             [b4_shared_declarations])[

 
 /* Enabling traces.  */
 #ifndef YYDEBUG
 
 /* Enabling traces.  */
 #ifndef YYDEBUG

-# define YYDEBUG ]b4_debug[
+# define YYDEBUG ]b4_debug_flag[

 #endif
 
 /* Enabling verbose error messages.  */
 #endif
 
 /* Enabling verbose error messages.  */


@@ -214,7 +224,7 @@ m4_if(b4_defines_flag, 0,
 # undef YYERROR_VERBOSE
 # define YYERROR_VERBOSE 1
 #else
 # undef YYERROR_VERBOSE
 # define YYERROR_VERBOSE 1
 #else

-# define YYERROR_VERBOSE ]b4_error_verbose[
+# define YYERROR_VERBOSE ]b4_error_verbose_flag[

 #endif
 
 /* Enabling the token table.  */
 #endif
 
 /* Enabling the token table.  */


@@ -230,18 +240,15 @@ m4_if(b4_defines_flag, 0,
 static YYSTYPE yyval_default;
 
 /* Copy the second part of user declarations.  */
 static YYSTYPE yyval_default;
 
 /* Copy the second part of user declarations.  */

-]b4_post_prologue[
+]b4_user_post_prologue
+b4_percent_code_get[]dnl

 
 

-]/* Line __line__ of glr.c.  */
-b4_syncline([@oline@], [@ofile@])
-[
-#include <stdio.h>
+[#include <stdio.h>

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

-#include <stdarg.h>

 
 #ifndef YY_
 
 #ifndef YY_

-# if YYENABLE_NLS
+# if defined YYENABLE_NLS && YYENABLE_NLS

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


@@ -253,7 +260,7 @@ b4_syncline([@oline@], [@ofile@])
 #endif
 
 /* Suppress unused-variable warnings by "using" E.  */
 #endif
 
 /* Suppress unused-variable warnings by "using" E.  */

-#ifndef lint
+#if ! defined lint || defined __GNUC__

 # define YYUSE(e) ((void) (e))
 #else
 # define YYUSE(e) /* empty */
 # define YYUSE(e) ((void) (e))
 #else
 # define YYUSE(e) /* empty */


@@ -302,13 +309,14 @@ 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) \
+      || (defined __STRICT_ANSI__ && __STRICT_ANSI__))

 #  define __attribute__(Spec) /* empty */
 # endif
 #endif
 
 #  define __attribute__(Spec) /* empty */
 # endif
 #endif
 

-]b4_location_if([#define YYOPTIONAL_LOC(Name) Name],[
+]b4_locations_if([#define YYOPTIONAL_LOC(Name) Name],[

 #ifdef __cplusplus
 # define YYOPTIONAL_LOC(Name) /* empty */
 #else
 #ifdef __cplusplus
 # define YYOPTIONAL_LOC(Name) /* empty */
 #else


@@ -343,8 +351,7 @@ b4_syncline([@oline@], [@ofile@])
 #define YYMAXUTOK   ]b4_user_token_number_max[
 
 #define YYTRANSLATE(YYX)                                               \
 #define YYMAXUTOK   ]b4_user_token_number_max[
 
 #define YYTRANSLATE(YYX)                                               \

-  ((YYX <= 0) ? YYEOF :                                                        \
-   (unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
+  ((unsigned int) (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[] =


@@ -406,9 +413,9 @@ static const ]b4_int_type_for([b4_merger])[ yymerger[] =
   ]b4_merger[
 };
 
   ]b4_merger[
 };
 

-/* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
-   doesn't specify something else to do.  Zero means the default is an
-   error.  */
+/* YYDEFACT[S] -- default reduction number in state S.  Performed when
+   YYTABLE doesn't specify something else to do.  Zero means the default
+   is an error.  */

 static const ]b4_int_type_for([b4_defact])[ yydefact[] =
 {
   ]b4_defact[
 static const ]b4_int_type_for([b4_defact])[ yydefact[] =
 {
   ]b4_defact[


@@ -436,8 +443,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
 
 /* 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, syntax error.  */
+   number is the opposite.  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[] =
 {


@@ -486,7 +492,7 @@ static const ]b4_int_type_for([b4_stos])[ yystos[] =
    If N is 0, then set CURRENT to the empty location which ends
    the previous symbol: RHS[0] (always defined).  */
 
    If N is 0, then set CURRENT to the empty location which ends
    the previous symbol: RHS[0] (always defined).  */
 

-]b4_location_if([[
+]b4_locations_if([[

 #define YYRHSLOC(Rhs, K) ((Rhs)[K].yystate.yyloc)
 #ifndef YYLLOC_DEFAULT
 # define YYLLOC_DEFAULT(Current, Rhs, N)                               \
 #define YYRHSLOC(Rhs, K) ((Rhs)[K].yystate.yyloc)
 #ifndef YYLLOC_DEFAULT
 # define YYLLOC_DEFAULT(Current, Rhs, N)                               \


@@ -563,9 +569,9 @@ typedef enum { yyok, yyaccept, yyabort, yyerr } YYRESULTTAG;
 
 #if YYDEBUG
 
 
 #if YYDEBUG
 

-#if ! defined (YYFPRINTF)
+# ifndef YYFPRINTF

 #  define YYFPRINTF fprintf
 #  define YYFPRINTF fprintf

-#endif
+# endif

 
 # define YYDPRINTF(Args)                       \
 do {                                           \
 
 # define YYDPRINTF(Args)                       \
 do {                                           \


@@ -581,7 +587,7 @@ do {                                                                            \
     {                                                                      \
       YYFPRINTF (stderr, "%s ", Title);                                            \
       yy_symbol_print (stderr, Type,                                       \
     {                                                                      \
       YYFPRINTF (stderr, "%s ", Title);                                            \
       yy_symbol_print (stderr, Type,                                       \

-                      Value]b4_location_if([, Location])[]b4_user_args[);  \
+                      Value]b4_locations_if([, Location])[]b4_user_args[);  \

       YYFPRINTF (stderr, "\n");                                                    \
     }                                                                      \
 } while (YYID (0))
       YYFPRINTF (stderr, "\n");                                                    \
     }                                                                      \
 } while (YYID (0))


@@ -621,9 +627,9 @@ int yydebug;
 #define YYHEADROOM 2
 
 #ifndef YYSTACKEXPANDABLE
 #define YYHEADROOM 2
 
 #ifndef YYSTACKEXPANDABLE

-# if (! defined (__cplusplus) \
-      || (]b4_location_if([[defined (YYLTYPE_IS_TRIVIAL) && YYLTYPE_IS_TRIVIAL \
-         && ]])[defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL))
+# if (! defined __cplusplus \
+      || (]b4_locations_if([[defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
+         && ]])[defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))

 #  define YYSTACKEXPANDABLE 1
 # else
 #  define YYSTACKEXPANDABLE 0
 #  define YYSTACKEXPANDABLE 1
 # else
 #  define YYSTACKEXPANDABLE 0


@@ -648,7 +654,7 @@ int yydebug;
 #if YYERROR_VERBOSE
 
 # ifndef yystpcpy
 #if YYERROR_VERBOSE
 
 # ifndef yystpcpy

-#  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
+#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE

 #   define yystpcpy stpcpy
 #  else
 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
 #   define yystpcpy stpcpy
 #  else
 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in


@@ -761,6 +767,11 @@ struct yyGLRState {
 
 struct yyGLRStateSet {
   yyGLRState** yystates;
 
 struct yyGLRStateSet {
   yyGLRState** yystates;

+  /** During nondeterministic operation, yylookaheadNeeds tracks which
+   *  stacks have actually needed the current lookahead.  During deterministic
+   *  operation, yylookaheadNeeds[0] is not maintained since it would merely
+   *  duplicate yychar != YYEMPTY.  */
+  yybool* yylookaheadNeeds;

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


@@ -771,6 +782,10 @@ struct yySemanticOption {
   yyRuleNum yyrule;
   /** The last RHS state in the list of states to be reduced.  */
   yyGLRState* yystate;
   yyRuleNum yyrule;
   /** The last RHS state in the list of states to be reduced.  */
   yyGLRState* yystate;

+  /** The lookahead for this reduction.  */
+  int yyrawchar;
+  YYSTYPE yyval;
+  YYLTYPE yyloc;

   /** Next sibling in chain of options.  To facilitate merging,
    *  options are chained in decreasing order by address.  */
   yySemanticOption* yynext;
   /** Next sibling in chain of options.  To facilitate merging,
    *  options are chained in decreasing order by address.  */
   yySemanticOption* yynext;


@@ -785,7 +800,7 @@ union yyGLRStackItem {
 
 struct yyGLRStack {
   int yyerrState;
 
 struct yyGLRStack {
   int yyerrState;

-]b4_location_if([[  /* To compute the location of the error token.  */
+]b4_locations_if([[  /* To compute the location of the error token.  */

   yyGLRStackItem yyerror_range[3];]])[
 ]b4_pure_if(
 [
   yyGLRStackItem yyerror_range[3];]])[
 ]b4_pure_if(
 [


@@ -794,7 +809,6 @@ struct yyGLRStack {
   YYSTYPE yyval;
   YYLTYPE yyloc;
 ])[
   YYSTYPE yyval;
   YYLTYPE yyloc;
 ])[

-  yySymbol* yytokenp;

   YYJMP_BUF yyexception_buffer;
   yyGLRStackItem* yyitems;
   yyGLRStackItem* yynextFree;
   YYJMP_BUF yyexception_buffer;
   yyGLRStackItem* yyitems;
   yyGLRStackItem* yynextFree;


@@ -899,9 +913,9 @@ yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,
 # undef YYERROR
 # define YYERROR return yyerrok, yyerr
 # undef YYRECOVERING
 # undef YYERROR
 # define YYERROR return yyerrok, yyerr
 # undef YYRECOVERING

-# define YYRECOVERING (yystackp->yyerrState != 0)
+# define YYRECOVERING() (yystackp->yyerrState != 0)

 # undef yyclearin
 # undef yyclearin

-# define yyclearin (yychar = *(yystackp->yytokenp) = YYEMPTY)
+# define yyclearin (yychar = YYEMPTY)

 # undef YYFILL
 # define YYFILL(N) yyfill (yyvsp, &yylow, N, yynormal)
 # undef YYBACKUP
 # undef YYFILL
 # define YYFILL(N) yyfill (yyvsp, &yylow, N, yynormal)
 # undef YYBACKUP


@@ -914,14 +928,12 @@ yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,
     *yyvalp = yyval_default;
   else
     *yyvalp = yyvsp[YYFILL (1-yyrhslen)].yystate.yysemantics.yysval;
     *yyvalp = yyval_default;
   else
     *yyvalp = yyvsp[YYFILL (1-yyrhslen)].yystate.yysemantics.yysval;

-  YYLLOC_DEFAULT (*yylocp, yyvsp - yyrhslen, yyrhslen);
-]b4_location_if([[  yystackp->yyerror_range[1].yystate.yyloc = *yylocp;
+  YYLLOC_DEFAULT ((*yylocp), (yyvsp - yyrhslen), yyrhslen);
+]b4_locations_if([[  yystackp->yyerror_range[1].yystate.yyloc = *yylocp;

 ]])[
   switch (yyn)
     {
 ]])[
   switch (yyn)
     {

-      ]b4_actions
-/* Line __line__ of glr.c.  */
-b4_syncline([@oline@], [@ofile@])[
+      ]b4_user_actions[

       default: break;
     }
 
       default: break;
     }
 


@@ -965,15 +977,18 @@ yydestroyGLRState (char const *yymsg, yyGLRState *yys]b4_user_formals[)
 {
   if (yys->yyresolved)
     yydestruct (yymsg, yystos[yys->yylrState],
 {
   if (yys->yyresolved)
     yydestruct (yymsg, yystos[yys->yylrState],

-               &yys->yysemantics.yysval]b4_location_if([, &yys->yyloc])[]b4_user_args[);
+               &yys->yysemantics.yysval]b4_locations_if([, &yys->yyloc])[]b4_user_args[);

   else
     {
 #if YYDEBUG
       if (yydebug)
        {
   else
     {
 #if YYDEBUG
       if (yydebug)
        {

-         YYFPRINTF (stderr, "%s unresolved ", yymsg);
+         if (yys->yysemantics.yyfirstVal)
+           YYFPRINTF (stderr, "%s unresolved ", yymsg);
+         else
+           YYFPRINTF (stderr, "%s incomplete ", yymsg);

          yy_symbol_print (stderr, yystos[yys->yylrState],
          yy_symbol_print (stderr, yystos[yys->yylrState],

-                          &yys->yysemantics.yysval]b4_location_if([, &yys->yyloc])[]b4_user_args[);
+                          NULL]b4_locations_if([, &yys->yyloc])[]b4_user_args[);

          YYFPRINTF (stderr, "\n");
        }
 #endif
          YYFPRINTF (stderr, "\n");
        }
 #endif


@@ -998,17 +1013,15 @@ 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)])[
+#define yypact_value_is_default(yystate) \
+  ]b4_table_value_equals([[pact]], [[yystate]], [b4_pact_ninf])[

 
 /** True iff LR state STATE has only a default reduction (regardless
  *  of token).  */
 static inline yybool
 yyisDefaultedState (yyStateNum yystate)
 {
 
 /** True iff LR state STATE has only a default reduction (regardless
  *  of token).  */
 static inline yybool
 yyisDefaultedState (yyStateNum yystate)
 {

-  return yyis_pact_ninf (yypact[yystate]);
+  return yypact_value_is_default (yypact[yystate]);

 }
 
 /** The default reduction for STATE, assuming it has one.  */
 }
 
 /** The default reduction for STATE, assuming it has one.  */


@@ -1018,10 +1031,8 @@ 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],
-        [YYID (0)],
-        [((yytable_value) == YYTABLE_NINF)])[
+#define yytable_value_is_error(yytable_value) \
+  ]b4_table_value_equals([[table]], [[yytable_value]], [b4_table_ninf])[

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


@@ -1036,12 +1047,13 @@ yygetLRActions (yyStateNum yystate, int yytoken,
                int* yyaction, const short int** yyconflicts)
 {
   int yyindex = yypact[yystate] + yytoken;
                int* yyaction, const short int** yyconflicts)
 {
   int yyindex = yypact[yystate] + yytoken;

-  if (yyindex < 0 || YYLAST < yyindex || yycheck[yyindex] != yytoken)
+  if (yypact_value_is_default (yypact[yystate])
+      || yyindex < 0 || YYLAST < yyindex || yycheck[yyindex] != yytoken)

     {
       *yyaction = -yydefact[yystate];
       *yyconflicts = yyconfl;
     }
     {
       *yyaction = -yydefact[yystate];
       *yyconflicts = yyconfl;
     }

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

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


@@ -1092,14 +1104,26 @@ yynewGLRStackItem (yyGLRStack* yystackp, yybool yyisState)
   return yynewItem;
 }
 
   return yynewItem;
 }
 

+/** Add a new semantic action that will execute the action for rule
+ *  RULENUM on the semantic values in RHS to the list of
+ *  alternative actions for STATE.  Assumes that RHS comes from
+ *  stack #K of *STACKP. */

 static void
 static void

-yyaddDeferredAction (yyGLRStack* yystackp, yyGLRState* yystate,
+yyaddDeferredAction (yyGLRStack* yystackp, size_t yyk, yyGLRState* yystate,

                     yyGLRState* rhs, yyRuleNum yyrule)
 {
   yySemanticOption* yynewOption =
     &yynewGLRStackItem (yystackp, yyfalse)->yyoption;
   yynewOption->yystate = rhs;
   yynewOption->yyrule = yyrule;
                     yyGLRState* rhs, yyRuleNum yyrule)
 {
   yySemanticOption* yynewOption =
     &yynewGLRStackItem (yystackp, yyfalse)->yyoption;
   yynewOption->yystate = rhs;
   yynewOption->yyrule = yyrule;

+  if (yystackp->yytops.yylookaheadNeeds[yyk])
+    {
+      yynewOption->yyrawchar = yychar;
+      yynewOption->yyval = yylval;
+      yynewOption->yyloc = yylloc;
+    }
+  else
+    yynewOption->yyrawchar = YYEMPTY;

   yynewOption->yynext = yystate->yysemantics.yyfirstVal;
   yystate->yysemantics.yyfirstVal = yynewOption;
 
   yynewOption->yynext = yystate->yysemantics.yyfirstVal;
   yystate->yysemantics.yyfirstVal = yynewOption;
 


@@ -1118,12 +1142,20 @@ yyinitStateSet (yyGLRStateSet* yyset)
   if (! yyset->yystates)
     return yyfalse;
   yyset->yystates[0] = NULL;
   if (! yyset->yystates)
     return yyfalse;
   yyset->yystates[0] = NULL;

+  yyset->yylookaheadNeeds =
+    (yybool*) YYMALLOC (16 * sizeof yyset->yylookaheadNeeds[0]);
+  if (! yyset->yylookaheadNeeds)
+    {
+      YYFREE (yyset->yystates);
+      return yyfalse;
+    }

   return yytrue;
 }
 
 static void yyfreeStateSet (yyGLRStateSet* yyset)
 {
   YYFREE (yyset->yystates);
   return yytrue;
 }
 
 static void yyfreeStateSet (yyGLRStateSet* yyset)
 {
   YYFREE (yyset->yystates);

+  YYFREE (yyset->yylookaheadNeeds);

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


@@ -1162,7 +1194,7 @@ yyexpandGLRStack (yyGLRStack* yystackp)
   size_t yysize, yynewSize;
   size_t yyn;
   yysize = yystackp->yynextFree - yystackp->yyitems;
   size_t yysize, yynewSize;
   size_t yyn;
   yysize = yystackp->yynextFree - yystackp->yyitems;

-  if (YYMAXDEPTH <= yysize)
+  if (YYMAXDEPTH - YYHEADROOM < yysize)

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


@@ -1270,6 +1302,13 @@ yyremoveDeletes (yyGLRStack* yystackp)
       else
        {
          yystackp->yytops.yystates[yyj] = yystackp->yytops.yystates[yyi];
       else
        {
          yystackp->yytops.yystates[yyj] = yystackp->yytops.yystates[yyi];

+         /* In the current implementation, it's unnecessary to copy
+            yystackp->yytops.yylookaheadNeeds[yyi] since, after
+            yyremoveDeletes returns, the parser immediately either enters
+            deterministic operation or shifts a token.  However, it doesn't
+            hurt, and the code might evolve to need it.  */
+         yystackp->yytops.yylookaheadNeeds[yyj] =
+           yystackp->yytops.yylookaheadNeeds[yyi];

          if (yyj != yyi)
            {
              YYDPRINTF ((stderr, "Rename stack %lu -> %lu.\n",
          if (yyj != yyi)
            {
              YYDPRINTF ((stderr, "Rename stack %lu -> %lu.\n",


@@ -1318,7 +1357,7 @@ yyglrShiftDefer (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState,
   yystackp->yytops.yystates[yyk] = yynewState;
 
   /* Invokes YY_RESERVE_GLRSTACK.  */
   yystackp->yytops.yystates[yyk] = yynewState;
 
   /* Invokes YY_RESERVE_GLRSTACK.  */

-  yyaddDeferredAction (yystackp, yynewState, rhs, yyrule);
+  yyaddDeferredAction (yystackp, yyk, yynewState, 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


@@ -1354,7 +1393,7 @@ yydoAction (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
       yyGLRState* yys;
       yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1];
       yys = yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred
       yyGLRState* yys;
       yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1];
       yys = yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred

-       = yystackp->yytops.yystates[yyk];]b4_location_if([[
+       = yystackp->yytops.yystates[yyk];]b4_locations_if([[

       if (yynrhs == 0)
        /* Set default location.  */
        yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].yystate.yyloc = yys->yyloc;]])[
       if (yynrhs == 0)
        /* Set default location.  */
        yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].yystate.yyloc = yys->yyloc;]])[


@@ -1402,12 +1441,12 @@ yy_reduce_print (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
   /* The symbols being reduced.  */
   for (yyi = 0; yyi < yynrhs; yyi++)
     {
   /* The symbols being reduced.  */
   for (yyi = 0; yyi < yynrhs; yyi++)
     {

-      fprintf (stderr, "   $%d = ", yyi + 1);
+      YYFPRINTF (stderr, "   $%d = ", yyi + 1);

       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
                       &]b4_rhs_value(yynrhs, yyi + 1)[
       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
                       &]b4_rhs_value(yynrhs, yyi + 1)[

-                      ]b4_location_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl
+                      ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl

                       b4_user_args[);
                       b4_user_args[);

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

     }
 }
 #endif
     }
 }
 #endif


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

-                   yyaddDeferredAction (yystackp, yyp, yys0, yyrule);
+                   yyaddDeferredAction (yystackp, yyk, yyp, yys0, yyrule);

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


@@ -1497,17 +1536,35 @@ yysplitStack (yyGLRStack* yystackp, size_t yyk)
   if (yystackp->yytops.yysize >= yystackp->yytops.yycapacity)
     {
       yyGLRState** yynewStates;
   if (yystackp->yytops.yysize >= yystackp->yytops.yycapacity)
     {
       yyGLRState** yynewStates;

-      if (! ((yystackp->yytops.yycapacity
-             <= (YYSIZEMAX / (2 * sizeof yynewStates[0])))
-            && (yynewStates =
-                (yyGLRState**) YYREALLOC (yystackp->yytops.yystates,
-                                          ((yystackp->yytops.yycapacity *= 2)
-                                           * sizeof yynewStates[0])))))
+      yybool* yynewLookaheadNeeds;
+
+      yynewStates = NULL;
+
+      if (yystackp->yytops.yycapacity
+         > (YYSIZEMAX / (2 * sizeof yynewStates[0])))
+       yyMemoryExhausted (yystackp);
+      yystackp->yytops.yycapacity *= 2;
+
+      yynewStates =
+       (yyGLRState**) YYREALLOC (yystackp->yytops.yystates,
+                                 (yystackp->yytops.yycapacity
+                                  * sizeof yynewStates[0]));
+      if (yynewStates == NULL)

        yyMemoryExhausted (yystackp);
       yystackp->yytops.yystates = yynewStates;
        yyMemoryExhausted (yystackp);
       yystackp->yytops.yystates = yynewStates;

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

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

+  yystackp->yytops.yylookaheadNeeds[yystackp->yytops.yysize]
+    = yystackp->yytops.yylookaheadNeeds[yyk];

   yystackp->yytops.yysize += 1;
   return yystackp->yytops.yysize-1;
 }
   yystackp->yytops.yysize += 1;
   return yystackp->yytops.yysize-1;
 }


@@ -1612,50 +1669,71 @@ yypreference (yySemanticOption* y0, yySemanticOption* y1)
   return 0;
 }
 
   return 0;
 }
 

-static YYRESULTTAG yyresolveValue (yySemanticOption* yyoptionList,
-                                  yyGLRStack* yystackp, YYSTYPE* yyvalp,
-                                  YYLTYPE* yylocp]b4_user_formals[);
+static YYRESULTTAG yyresolveValue (yyGLRState* yys,
+                                  yyGLRStack* yystackp]b4_user_formals[);

 
 

+
+/** Resolve the previous N states starting at and including state S.  If result
+ *  != yyok, some states may have been left unresolved possibly with empty
+ *  semantic option chains.  Regardless of whether result = yyok, each state
+ *  has been left with consistent data so that yydestroyGLRState can be invoked
+ *  if necessary.  */

 static YYRESULTTAG
 yyresolveStates (yyGLRState* yys, int yyn,
                 yyGLRStack* yystackp]b4_user_formals[)
 {
 static YYRESULTTAG
 yyresolveStates (yyGLRState* yys, int yyn,
                 yyGLRStack* yystackp]b4_user_formals[)
 {

-  YYRESULTTAG yyflag;

   if (0 < yyn)
     {
       YYASSERT (yys->yypred);
   if (0 < yyn)
     {
       YYASSERT (yys->yypred);

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

       if (! yys->yyresolved)
       if (! yys->yyresolved)

-       {
-         yyflag = yyresolveValue (yys->yysemantics.yyfirstVal, yystackp,
-                                  &yys->yysemantics.yysval, &yys->yyloc
-                                 ]b4_user_args[);
-         if (yyflag != yyok)
-           return yyflag;
-         yys->yyresolved = yytrue;
-       }
+       YYCHK (yyresolveValue (yys, yystackp]b4_user_args[));

     }
   return yyok;
 }
 
     }
   return yyok;
 }
 

+/** Resolve the states for the RHS of OPT, perform its user action, and return
+ *  the semantic value and location.  Regardless of whether result = yyok, all
+ *  RHS states have been destroyed (assuming the user action destroys all RHS
+ *  semantic values if invoked).  */

 static YYRESULTTAG
 yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystackp,
                 YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[)
 {
   yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1];
   int yynrhs;
 static YYRESULTTAG
 yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystackp,
                 YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[)
 {
   yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1];
   int yynrhs;

+  int yychar_current;
+  YYSTYPE yylval_current;
+  YYLTYPE yylloc_current;
+  YYRESULTTAG yyflag;

 
   yynrhs = yyrhsLength (yyopt->yyrule);
 
   yynrhs = yyrhsLength (yyopt->yyrule);

-  YYCHK (yyresolveStates (yyopt->yystate, yynrhs, yystackp]b4_user_args[));
-  yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred = yyopt->yystate;]b4_location_if([[
+  yyflag = yyresolveStates (yyopt->yystate, yynrhs, yystackp]b4_user_args[);
+  if (yyflag != yyok)
+    {
+      yyGLRState *yys;
+      for (yys = yyopt->yystate; yynrhs > 0; yys = yys->yypred, yynrhs -= 1)
+       yydestroyGLRState ("Cleanup: popping", yys]b4_user_args[);
+      return yyflag;
+    }
+
+  yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred = yyopt->yystate;]b4_locations_if([[

   if (yynrhs == 0)
     /* Set default location.  */
     yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].yystate.yyloc = yyopt->yystate->yyloc;]])[
   if (yynrhs == 0)
     /* Set default location.  */
     yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].yystate.yyloc = yyopt->yystate->yyloc;]])[

-  return yyuserAction (yyopt->yyrule, yynrhs,
-                      yyrhsVals + YYMAXRHS + YYMAXLEFT - 1,
-                      yyvalp, yylocp, yystackp]b4_user_args[);
+  yychar_current = yychar;
+  yylval_current = yylval;
+  yylloc_current = yylloc;
+  yychar = yyopt->yyrawchar;
+  yylval = yyopt->yyval;
+  yylloc = yyopt->yyloc;
+  yyflag = yyuserAction (yyopt->yyrule, yynrhs,
+                          yyrhsVals + YYMAXRHS + YYMAXLEFT - 1,
+                          yyvalp, yylocp, yystackp]b4_user_args[);
+  yychar = yychar_current;
+  yylval = yylval_current;
+  yylloc = yylloc_current;
+  return yyflag;

 }
 
 #if YYDEBUG
 }
 
 #if YYDEBUG


@@ -1665,7 +1743,7 @@ yyreportTree (yySemanticOption* yyx, int yyindent)
   int yynrhs = yyrhsLength (yyx->yyrule);
   int yyi;
   yyGLRState* yys;
   int yynrhs = yyrhsLength (yyx->yyrule);
   int yyi;
   yyGLRState* yys;

-  yyGLRState* yystates[YYMAXRHS];
+  yyGLRState* yystates[1 + YYMAXRHS];

   yyGLRState yyleftmost_state;
 
   for (yyi = yynrhs, yys = yyx->yystate; 0 < yyi; yyi -= 1, yys = yys->yypred)
   yyGLRState yyleftmost_state;
 
   for (yyi = yynrhs, yys = yyx->yystate; 0 < yyi; yyi -= 1, yys = yys->yypred)


@@ -1681,11 +1759,11 @@ yyreportTree (yySemanticOption* yyx, int yyindent)
   if (yyx->yystate->yyposn < yys->yyposn + 1)
     YYFPRINTF (stderr, "%*s%s -> <Rule %d, empty>\n",
               yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)),
   if (yyx->yystate->yyposn < yys->yyposn + 1)
     YYFPRINTF (stderr, "%*s%s -> <Rule %d, empty>\n",
               yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)),

-              yyx->yyrule);
+              yyx->yyrule - 1);

   else
     YYFPRINTF (stderr, "%*s%s -> <Rule %d, tokens %lu .. %lu>\n",
               yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)),
   else
     YYFPRINTF (stderr, "%*s%s -> <Rule %d, tokens %lu .. %lu>\n",
               yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)),

-              yyx->yyrule, (unsigned long int) (yys->yyposn + 1),
+              yyx->yyrule - 1, (unsigned long int) (yys->yyposn + 1),

               (unsigned long int) yyx->yystate->yyposn);
   for (yyi = 1; yyi <= yynrhs; yyi += 1)
     {
               (unsigned long int) yyx->yystate->yyposn);
   for (yyi = 1; yyi <= yynrhs; yyi += 1)
     {


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

-static void yyreportAmbiguity (yySemanticOption* yyx0, yySemanticOption* yyx1,
-                              yyGLRStack* yystackp]b4_pure_formals[)
-  __attribute__ ((__noreturn__));
-static void
-yyreportAmbiguity (yySemanticOption* yyx0, yySemanticOption* yyx1,
-                  yyGLRStack* yystackp]b4_pure_formals[)
+/*ARGSUSED*/ static YYRESULTTAG
+yyreportAmbiguity (yySemanticOption* yyx0,
+                  yySemanticOption* yyx1]b4_pure_formals[)

 {
   YYUSE (yyx0);
   YYUSE (yyx1);
 {
   YYUSE (yyx0);
   YYUSE (yyx1);


@@ -1724,19 +1799,85 @@ yyreportAmbiguity (yySemanticOption* yyx0, yySemanticOption* yyx1,
   yyreportTree (yyx1, 2);
   YYFPRINTF (stderr, "\n");
 #endif
   yyreportTree (yyx1, 2);
   YYFPRINTF (stderr, "\n");
 #endif

-  yyFail (yystackp][]b4_pure_args[, YY_("syntax is ambiguous"));
-}

 
 

+  yyerror (]b4_yyerror_args[YY_("syntax is ambiguous"));
+  return yyabort;
+}]b4_locations_if([[

 
 

-/** Resolve the ambiguity represented by OPTIONLIST, perform the indicated
- *  actions, and return the result.  */
+/** Starting at and including state S1, resolve the location for each of the
+ *  previous N1 states that is unresolved.  The first semantic option of a state
+ *  is always chosen.  */
+static void
+yyresolveLocations (yyGLRState* yys1, int yyn1,
+                   yyGLRStack *yystackp]b4_user_formals[)
+{
+  if (0 < yyn1)
+    {
+      yyresolveLocations (yys1->yypred, yyn1 - 1, yystackp]b4_user_args[);
+      if (!yys1->yyresolved)
+       {
+         yySemanticOption *yyoption;
+         yyGLRStackItem yyrhsloc[1 + YYMAXRHS];
+         int yynrhs;
+         int yychar_current;
+         YYSTYPE yylval_current;
+         YYLTYPE yylloc_current;
+         yyoption = yys1->yysemantics.yyfirstVal;
+         YYASSERT (yyoption != NULL);
+         yynrhs = yyrhsLength (yyoption->yyrule);
+         if (yynrhs > 0)
+           {
+             yyGLRState *yys;
+             int yyn;
+             yyresolveLocations (yyoption->yystate, yynrhs,
+                                 yystackp]b4_user_args[);
+             for (yys = yyoption->yystate, yyn = yynrhs;
+                  yyn > 0;
+                  yys = yys->yypred, yyn -= 1)
+               yyrhsloc[yyn].yystate.yyloc = yys->yyloc;
+           }
+         else
+           {
+             /* Both yyresolveAction and yyresolveLocations traverse the GSS
+                in reverse rightmost order.  It is only necessary to invoke
+                yyresolveLocations on a subforest for which yyresolveAction
+                would have been invoked next had an ambiguity not been
+                detected.  Thus the location of the previous state (but not
+                necessarily the previous state itself) is guaranteed to be
+                resolved already.  */
+             yyGLRState *yyprevious = yyoption->yystate;
+             yyrhsloc[0].yystate.yyloc = yyprevious->yyloc;
+           }
+         yychar_current = yychar;
+         yylval_current = yylval;
+         yylloc_current = yylloc;
+         yychar = yyoption->yyrawchar;
+         yylval = yyoption->yyval;
+         yylloc = yyoption->yyloc;
+         YYLLOC_DEFAULT ((yys1->yyloc), yyrhsloc, yynrhs);
+         yychar = yychar_current;
+         yylval = yylval_current;
+         yylloc = yylloc_current;
+       }
+    }
+}]])[
+
+/** Resolve the ambiguity represented in state S, perform the indicated
+ *  actions, and set the semantic value of S.  If result != yyok, the chain of
+ *  semantic options in S has been cleared instead or it has been left
+ *  unmodified except that redundant options may have been removed.  Regardless
+ *  of whether result = yyok, S has been left with consistent data so that
+ *  yydestroyGLRState can be invoked if necessary.  */

 static YYRESULTTAG
 static YYRESULTTAG

-yyresolveValue (yySemanticOption* yyoptionList, yyGLRStack* yystackp,
-               YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[)
+yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp]b4_user_formals[)

 {
 {

+  yySemanticOption* yyoptionList = yys->yysemantics.yyfirstVal;

   yySemanticOption* yybest;
   yySemanticOption** yypp;
   yybool yymerge;
   yySemanticOption* yybest;
   yySemanticOption** yypp;
   yybool yymerge;

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

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


@@ -1753,8 +1894,9 @@ yyresolveValue (yySemanticOption* yyoptionList, yyGLRStack* yystackp,
        {
          switch (yypreference (yybest, yyp))
            {
        {
          switch (yypreference (yybest, yyp))
            {

-           case 0:
-             yyreportAmbiguity (yybest, yyp, yystackp]b4_pure_args[);
+           case 0:]b4_locations_if([[
+             yyresolveLocations (yys, 1, yystackp]b4_user_args[);]])[
+             return yyreportAmbiguity (yybest, yyp]b4_pure_args[);

              break;
            case 1:
              yymerge = yytrue;
              break;
            case 1:
              yymerge = yytrue;


@@ -1779,22 +1921,39 @@ yyresolveValue (yySemanticOption* yyoptionList, yyGLRStack* yystackp,
     {
       yySemanticOption* yyp;
       int yyprec = yydprec[yybest->yyrule];
     {
       yySemanticOption* yyp;
       int yyprec = yydprec[yybest->yyrule];

-      YYCHK (yyresolveAction (yybest, yystackp, yyvalp, yylocp]b4_user_args[));
-      for (yyp = yybest->yynext; yyp != NULL; yyp = yyp->yynext)
-       {
-         if (yyprec == yydprec[yyp->yyrule])
-           {
-             YYSTYPE yyval1;
-             YYLTYPE yydummy;
-             YYCHK (yyresolveAction (yyp, yystackp, &yyval1,
-                                     &yydummy]b4_user_args[));
-             yyuserMerge (yymerger[yyp->yyrule], yyvalp, &yyval1);
-           }
-       }
-      return yyok;
+      yyflag = yyresolveAction (yybest, yystackp, &yysval,
+                               yylocp]b4_user_args[);
+      if (yyflag == yyok)
+       for (yyp = yybest->yynext; yyp != NULL; yyp = yyp->yynext)
+         {
+           if (yyprec == yydprec[yyp->yyrule])
+             {
+               YYSTYPE yysval_other;
+               YYLTYPE yydummy;
+               yyflag = yyresolveAction (yyp, yystackp, &yysval_other,
+                                         &yydummy]b4_user_args[);
+               if (yyflag != yyok)
+                 {
+                   yydestruct ("Cleanup: discarding incompletely merged value for",
+                               yystos[yys->yylrState],
+                               &yysval]b4_locations_if([, yylocp])[]b4_user_args[);
+                   break;
+                 }
+               yyuserMerge (yymerger[yyp->yyrule], &yysval, &yysval_other);
+             }
+         }

     }
   else
     }
   else

-    return yyresolveAction (yybest, yystackp, yyvalp, yylocp]b4_user_args[);
+    yyflag = yyresolveAction (yybest, yystackp, &yysval, yylocp]b4_user_args[);
+
+  if (yyflag == yyok)
+    {
+      yys->yyresolved = yytrue;
+      yys->yysemantics.yysval = yysval;
+    }
+  else
+    yys->yysemantics.yyfirstVal = NULL;
+  return yyflag;

 }
 
 static YYRESULTTAG
 }
 
 static YYRESULTTAG


@@ -1852,7 +2011,6 @@ yyprocessOneStack (yyGLRStack* yystackp, size_t yyk,
   int yyaction;
   const short int* yyconflicts;
   yyRuleNum yyrule;
   int yyaction;
   const short int* yyconflicts;
   yyRuleNum yyrule;

-  yySymbol* const yytokenp = yystackp->yytokenp;

 
   while (yystackp->yytops.yystates[yyk] != NULL)
     {
 
   while (yystackp->yytops.yystates[yyk] != NULL)
     {


@@ -1876,14 +2034,26 @@ yyprocessOneStack (yyGLRStack* yystackp, size_t yyk,
        }
       else
        {
        }
       else
        {

-         if (*yytokenp == YYEMPTY)
+         yySymbol yytoken;
+         yystackp->yytops.yylookaheadNeeds[yyk] = yytrue;
+         if (yychar == YYEMPTY)

            {
              YYDPRINTF ((stderr, "Reading a token: "));
              yychar = YYLEX;
            {
              YYDPRINTF ((stderr, "Reading a token: "));
              yychar = YYLEX;

-             *yytokenp = YYTRANSLATE (yychar);
-             YY_SYMBOL_PRINT ("Next token is", *yytokenp, &yylval, &yylloc);

            }
            }

-         yygetLRActions (yystate, *yytokenp, &yyaction, &yyconflicts);
+
+         if (yychar <= YYEOF)
+           {
+             yychar = yytoken = YYEOF;
+             YYDPRINTF ((stderr, "Now at end of input.\n"));
+           }
+         else
+           {
+             yytoken = YYTRANSLATE (yychar);
+             YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
+           }
+
+         yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts);

 
          while (*yyconflicts != 0)
            {
 
          while (*yyconflicts != 0)
            {


@@ -1918,111 +2088,138 @@ yyprocessOneStack (yyGLRStack* yystackp, size_t yyk,
 /*ARGSUSED*/ static void
 yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
 {
 /*ARGSUSED*/ static void
 yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
 {

-  if (yystackp->yyerrState == 0)
+  if (yystackp->yyerrState != 0)
+    return;
+#if ! YYERROR_VERBOSE
+  yyerror (]b4_lyyerror_args[YY_("syntax error"));
+#else
+  yySymbol yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
+  size_t yysize0 = yytnamerr (NULL, yytokenName (yytoken));
+  size_t yysize = yysize0;
+  size_t yysize1;
+  yybool yysize_overflow = yyfalse;
+  char* yymsg = NULL;
+  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
+  /* Internationalized format string. */
+  const char *yyformat = 0;
+  /* Arguments of yyformat. */
+  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
+  /* Number of reported tokens (one for the "unexpected", one per
+     "expected").  */
+  int yycount = 0;
+
+  /* There are many possibilities here to consider:
+     - If this state is a consistent state with a default action, then
+       the only way this function was invoked is if the default action
+       is an error action.  In that case, don't check for expected
+       tokens because there are none.
+     - The only way there can be no lookahead present (in yychar) is if
+       this state is a consistent state with a default action.  Thus,
+       detecting the absence of a lookahead is sufficient to determine
+       that there is no unexpected or expected token to report.  In that
+       case, just report a simple "syntax error".
+     - Don't assume there isn't a lookahead just because this state is a
+       consistent state with a default action.  There might have been a
+       previous inconsistent state, consistent state with a non-default
+       action, or user semantic action that manipulated yychar.
+     - Of course, the expected token list depends on states to have
+       correct lookahead information, and it depends on the parser not
+       to perform extra reductions after fetching a lookahead from the
+       scanner and before detecting a syntax error.  Thus, state merging
+       (from LALR or IELR) and default reductions corrupt the expected
+       token list.  However, the list is correct for canonical LR with
+       one exception: it will still contain any token that will not be
+       accepted due to an error action in a later state.
+  */
+  if (yytoken != YYEMPTY)

     {
     {

-#if YYERROR_VERBOSE
-      yySymbol* const yytokenp = yystackp->yytokenp;
-      int yyn;
-      yyn = yypact[yystackp->yytops.yystates[0]->yylrState];
-      if (YYPACT_NINF < yyn && yyn < YYLAST)
-       {
-         size_t yysize0 = yytnamerr (NULL, yytokenName (*yytokenp));
-         size_t yysize = yysize0;
-         size_t yysize1;
-         yybool yysize_overflow = yyfalse;
-         char* yymsg = NULL;
-         enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
-         char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
-         int yyx;
-         char *yyfmt;
-         char const *yyf;
-         static char const yyunexpected[] = "syntax error, unexpected %s";
-         static char const yyexpecting[] = ", expecting %s";
-         static char const yyor[] = " or %s";
-         char yyformat[sizeof yyunexpected
-                       + sizeof yyexpecting - 1
-                       + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
-                          * (sizeof yyor - 1))];
-         char const *yyprefix = yyexpecting;
-
-         /* Start YYX at -YYN if negative to avoid negative indexes in
-            YYCHECK.  */
-         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 = 1;
-
-         yyarg[0] = yytokenName (*yytokenp);
-         yyfmt = yystpcpy (yyformat, yyunexpected);
-
-         for (yyx = yyxbegin; yyx < yyxend; ++yyx)
-           if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
-             {
-               if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
-                 {
-                   yycount = 1;
-                   yysize = yysize0;
-                   yyformat[sizeof yyunexpected - 1] = '\0';
-                   break;
-                 }
-               yyarg[yycount++] = yytokenName (yyx);
-               yysize1 = yysize + yytnamerr (NULL, yytokenName (yyx));
-               yysize_overflow |= yysize1 < yysize;
-               yysize = yysize1;
-               yyfmt = yystpcpy (yyfmt, yyprefix);
-               yyprefix = yyor;
-             }
+      int yyn = yypact[yystackp->yytops.yystates[0]->yylrState];
+      yyarg[yycount++] = yytokenName (yytoken);
+      if (!yypact_value_is_default (yyn))
+        {
+          /* Start YYX at -YYN if negative to avoid negative indexes in
+             YYCHECK.  In other words, skip the first -YYN actions for this
+             state because they are default actions.  */
+          int yyxbegin = yyn < 0 ? -yyn : 0;
+          /* Stay within bounds of both yycheck and yytname.  */
+          int yychecklim = YYLAST - yyn + 1;
+          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
+          int yyx;
+          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
+            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
+                && !yytable_value_is_error (yytable[yyx + yyn]))
+              {
+                if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
+                  {
+                    yycount = 1;
+                    yysize = yysize0;
+                    break;
+                  }
+                yyarg[yycount++] = yytokenName (yyx);
+                yysize1 = yysize + yytnamerr (NULL, yytokenName (yyx));
+                yysize_overflow |= yysize1 < yysize;
+                yysize = yysize1;
+              }
+        }
+    }

 
 

-         yyf = YY_(yyformat);
-         yysize1 = yysize + strlen (yyf);
-         yysize_overflow |= yysize1 < yysize;
-         yysize = yysize1;
+  switch (yycount)
+    {
+#define YYCASE_(N, S)                   \
+      case N:                           \
+        yyformat = S;                   \
+      break
+      YYCASE_(0, YY_("syntax error"));
+      YYCASE_(1, YY_("syntax error, unexpected %s"));
+      YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
+      YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
+      YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
+      YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
+#undef YYCASE_
+    }

 
 

-         if (!yysize_overflow)
-           yymsg = (char *) YYMALLOC (yysize);
+  yysize1 = yysize + strlen (yyformat);
+  yysize_overflow |= yysize1 < yysize;
+  yysize = yysize1;

 
 

-         if (yymsg)
-           {
-             char *yyp = yymsg;
-             int yyi = 0;
-             while ((*yyp = *yyf))
-               {
-                 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
-                   {
-                     yyp += yytnamerr (yyp, yyarg[yyi++]);
-                     yyf += 2;
-                   }
-                 else
-                   {
-                     yyp++;
-                     yyf++;
-                   }
-               }
-             yyerror (]b4_lyyerror_args[yymsg);
-             YYFREE (yymsg);
-           }
-         else
-           {
-             yyerror (]b4_lyyerror_args[YY_("syntax error"));
-             yyMemoryExhausted (yystackp);
-           }
-       }
-      else
-#endif /* YYERROR_VERBOSE */
-       yyerror (]b4_lyyerror_args[YY_("syntax error"));
-      yynerrs += 1;
+  if (!yysize_overflow)
+    yymsg = (char *) YYMALLOC (yysize);
+
+  if (yymsg)
+    {
+      char *yyp = yymsg;
+      int yyi = 0;
+      while ((*yyp = *yyformat))
+        {
+          if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
+            {
+              yyp += yytnamerr (yyp, yyarg[yyi++]);
+              yyformat += 2;
+            }
+          else
+            {
+              yyp++;
+              yyformat++;
+            }
+        }
+      yyerror (]b4_lyyerror_args[yymsg);
+      YYFREE (yymsg);

     }
     }

+  else
+    {
+      yyerror (]b4_lyyerror_args[YY_("syntax error"));
+      yyMemoryExhausted (yystackp);
+    }
+#endif /* YYERROR_VERBOSE */
+  yynerrs += 1;

 }
 
 /* Recover from a syntax error on *YYSTACKP, assuming that *YYSTACKP->YYTOKENP,
    yylval, and yylloc are the syntactic category, semantic value, and location
 }
 
 /* Recover from a syntax error on *YYSTACKP, assuming that *YYSTACKP->YYTOKENP,
    yylval, and yylloc are the syntactic category, semantic value, and location

-   of the look-ahead.  */
+   of the lookahead.  */

 /*ARGSUSED*/ static void
 yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
 {
 /*ARGSUSED*/ static void
 yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
 {

-  yySymbol* const yytokenp = yystackp->yytokenp;

   size_t yyk;
   int yyj;
 
   size_t yyk;
   int yyj;
 


@@ -2031,34 +2228,44 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
        reductions.  Skip tokens until we can proceed.  */
     while (YYID (yytrue))
       {
        reductions.  Skip tokens until we can proceed.  */
     while (YYID (yytrue))
       {

-       if (*yytokenp == YYEOF)
+       yySymbol yytoken;
+       if (yychar == YYEOF)

          yyFail (yystackp][]b4_lpure_args[, NULL);
          yyFail (yystackp][]b4_lpure_args[, NULL);

-       if (*yytokenp != YYEMPTY)
-         {]b4_location_if([[
+       if (yychar != YYEMPTY)
+         {]b4_locations_if([[

            /* We throw away the lookahead, but the error range
               of the shifted error token must take it into account.  */
            yyGLRState *yys = yystackp->yytops.yystates[0];
            yyGLRStackItem yyerror_range[3];
            yyerror_range[1].yystate.yyloc = yys->yyloc;
            yyerror_range[2].yystate.yyloc = yylloc;
            /* We throw away the lookahead, but the error range
               of the shifted error token must take it into account.  */
            yyGLRState *yys = yystackp->yytops.yystates[0];
            yyGLRStackItem yyerror_range[3];
            yyerror_range[1].yystate.yyloc = yys->yyloc;
            yyerror_range[2].yystate.yyloc = yylloc;

-           YYLLOC_DEFAULT (yys->yyloc, yyerror_range, 2);]])[
+           YYLLOC_DEFAULT ((yys->yyloc), yyerror_range, 2);]])[
+           yytoken = YYTRANSLATE (yychar);

            yydestruct ("Error: discarding",
            yydestruct ("Error: discarding",

-                       *yytokenp, &yylval]b4_location_if([, &yylloc])[]b4_user_args[);
+                       yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);

          }
        YYDPRINTF ((stderr, "Reading a token: "));
        yychar = YYLEX;
          }
        YYDPRINTF ((stderr, "Reading a token: "));
        yychar = YYLEX;

-       *yytokenp = YYTRANSLATE (yychar);
-       YY_SYMBOL_PRINT ("Next token is", *yytokenp, &yylval, &yylloc);
+       if (yychar <= YYEOF)
+         {
+           yychar = yytoken = YYEOF;
+           YYDPRINTF ((stderr, "Now at end of input.\n"));
+         }
+       else
+         {
+           yytoken = YYTRANSLATE (yychar);
+           YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
+         }

        yyj = yypact[yystackp->yytops.yystates[0]->yylrState];
        yyj = yypact[yystackp->yytops.yystates[0]->yylrState];

-       if (yyis_pact_ninf (yyj))
+       if (yypact_value_is_default (yyj))

          return;
          return;

-       yyj += *yytokenp;
-       if (yyj < 0 || YYLAST < yyj || yycheck[yyj] != *yytokenp)
+       yyj += yytoken;
+       if (yyj < 0 || YYLAST < yyj || yycheck[yyj] != yytoken)

          {
            if (yydefact[yystackp->yytops.yystates[0]->yylrState] != 0)
              return;
          }
          {
            if (yydefact[yystackp->yytops.yystates[0]->yylrState] != 0)
              return;
          }

-       else if (yytable[yyj] != 0 && ! yyis_table_ninf (yytable[yyj]))
+       else if (! yytable_value_is_error (yytable[yyj]))

          return;
       }
 
          return;
       }
 


@@ -2079,16 +2286,16 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
     {
       yyGLRState *yys = yystackp->yytops.yystates[0];
       yyj = yypact[yys->yylrState];
     {
       yyGLRState *yys = yystackp->yytops.yystates[0];
       yyj = yypact[yys->yylrState];

-      if (! yyis_pact_ninf (yyj))
+      if (! yypact_value_is_default (yyj))

        {
          yyj += YYTERROR;
          if (0 <= yyj && yyj <= YYLAST && yycheck[yyj] == YYTERROR
              && yyisShiftAction (yytable[yyj]))
            {
              /* Shift the error token having adjusted its location.  */
        {
          yyj += YYTERROR;
          if (0 <= yyj && yyj <= YYLAST && yycheck[yyj] == YYTERROR
              && yyisShiftAction (yytable[yyj]))
            {
              /* Shift the error token having adjusted its location.  */

-             YYLTYPE yyerrloc;]b4_location_if([[
+             YYLTYPE yyerrloc;]b4_locations_if([[

              yystackp->yyerror_range[2].yystate.yyloc = yylloc;
              yystackp->yyerror_range[2].yystate.yyloc = yylloc;

-             YYLLOC_DEFAULT (yyerrloc, yystackp->yyerror_range, 2);]])[
+             YYLLOC_DEFAULT (yyerrloc, (yystackp->yyerror_range), 2);]])[

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


@@ -2097,8 +2304,9 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
              break;
            }
        }
              break;
            }
        }

-]b4_location_if([[      yystackp->yyerror_range[1].yystate.yyloc = yys->yyloc;]])[
-      yydestroyGLRState ("Error: popping", yys]b4_user_args[);
+]b4_locations_if([[      yystackp->yyerror_range[1].yystate.yyloc = yys->yyloc;]])[
+      if (yys->yypred != NULL)
+       yydestroyGLRState ("Error: popping", yys]b4_user_args[);

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


@@ -2131,30 +2339,27 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
 ]b4_c_ansi_function_def([yyparse], [int], b4_parse_param)[
 {
   int yyresult;
 ]b4_c_ansi_function_def([yyparse], [int], b4_parse_param)[
 {
   int yyresult;

-  yySymbol yytoken;

   yyGLRStack yystack;
   yyGLRStack* const yystackp = &yystack;
   size_t yyposn;
 
   YYDPRINTF ((stderr, "Starting parse\n"));
 
   yyGLRStack yystack;
   yyGLRStack* const yystackp = &yystack;
   size_t yyposn;
 
   YYDPRINTF ((stderr, "Starting parse\n"));
 

-  yytoken = YYEMPTY;
+  yychar = YYEMPTY;

   yylval = yyval_default;
   yylval = yyval_default;

-]b4_location_if([
-#if YYLTYPE_IS_TRIVIAL
-  yylloc.first_line   = yylloc.last_line   = 1;
-  yylloc.first_column = yylloc.last_column = 0;
+]b4_locations_if([
+#if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
+  yylloc.first_line   = yylloc.last_line   = ]b4_location_initial_line[;
+  yylloc.first_column = yylloc.last_column = ]b4_location_initial_column[;

 #endif
 ])
 m4_ifdef([b4_initial_action], [
 m4_pushdef([b4_at_dollar],     [yylloc])dnl
 m4_pushdef([b4_dollar_dollar], [yylval])dnl
   /* User initialization code.  */
 #endif
 ])
 m4_ifdef([b4_initial_action], [
 m4_pushdef([b4_at_dollar],     [yylloc])dnl
 m4_pushdef([b4_dollar_dollar], [yylval])dnl
   /* User initialization code.  */

-  b4_initial_action
+  b4_user_initial_action

 m4_popdef([b4_dollar_dollar])dnl
 m4_popdef([b4_dollar_dollar])dnl

-m4_popdef([b4_at_dollar])dnl
-/* Line __line__ of glr.c.  */
-b4_syncline([@oline@], [@ofile@])])dnl
+m4_popdef([b4_at_dollar])])dnl

 [
   if (! yyinitGLRStack (yystackp, YYINITDEPTH))
     goto yyexhaustedlab;
 [
   if (! yyinitGLRStack (yystackp, YYINITDEPTH))
     goto yyexhaustedlab;


@@ -2165,7 +2370,6 @@ b4_syncline([@oline@], [@ofile@])])dnl
     case 2: goto yyexhaustedlab;
     default: goto yybuglab;
     }
     case 2: goto yyexhaustedlab;
     default: goto yybuglab;
     }

-  yystack.yytokenp = &yytoken;

   yyglrShift (&yystack, 0, 0, 0, &yylval, &yylloc);
   yyposn = 0;
 
   yyglrShift (&yystack, 0, 0, 0, &yylval, &yylloc);
   yyposn = 0;
 


@@ -2190,7 +2394,7 @@ b4_syncline([@oline@], [@ofile@])])dnl
              yyrule = yydefaultAction (yystate);
              if (yyrule == 0)
                {
              yyrule = yydefaultAction (yystate);
              if (yyrule == 0)
                {

-]b4_location_if([[               yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[
+]b4_locations_if([[              yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[

                  yyreportSyntaxError (&yystack]b4_user_args[);
                  goto yyuser_error;
                }
                  yyreportSyntaxError (&yystack]b4_user_args[);
                  goto yyuser_error;
                }


@@ -2198,21 +2402,31 @@ b4_syncline([@oline@], [@ofile@])])dnl
            }
          else
            {
            }
          else
            {

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

                {
                  YYDPRINTF ((stderr, "Reading a token: "));
                  yychar = YYLEX;
                {
                  YYDPRINTF ((stderr, "Reading a token: "));
                  yychar = YYLEX;

+               }
+
+             if (yychar <= YYEOF)
+               {
+                 yychar = yytoken = YYEOF;
+                 YYDPRINTF ((stderr, "Now at end of input.\n"));
+               }
+             else
+               {

                  yytoken = YYTRANSLATE (yychar);
                  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
                }
                  yytoken = YYTRANSLATE (yychar);
                  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
                }

+

              yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts);
              if (*yyconflicts != 0)
                break;
              if (yyisShiftAction (yyaction))
                {
                  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
              yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts);
              if (*yyconflicts != 0)
                break;
              if (yyisShiftAction (yyaction))
                {
                  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);

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

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


@@ -2220,7 +2434,7 @@ b4_syncline([@oline@], [@ofile@])])dnl
                }
              else if (yyisErrorAction (yyaction))
                {
                }
              else if (yyisErrorAction (yyaction))
                {

-]b4_location_if([[               yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[
+]b4_locations_if([[              yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[

                  yyreportSyntaxError (&yystack]b4_user_args[);
                  goto yyuser_error;
                }
                  yyreportSyntaxError (&yystack]b4_user_args[);
                  goto yyuser_error;
                }


@@ -2233,7 +2447,9 @@ b4_syncline([@oline@], [@ofile@])])dnl
        {
          yySymbol yytoken_to_shift;
          size_t yys;
        {
          yySymbol yytoken_to_shift;
          size_t yys;

-         size_t yyn = yystack.yytops.yysize;
+
+         for (yys = 0; yys < yystack.yytops.yysize; yys += 1)
+           yystackp->yytops.yylookaheadNeeds[yys] = yychar != YYEMPTY;

 
          /* yyprocessOneStack returns one of three things:
 
 
          /* yyprocessOneStack returns one of three things:
 


@@ -2251,23 +2467,33 @@ b4_syncline([@oline@], [@ofile@])])dnl
             Except in the first case, yyparse will invoke yyremoveDeletes and
             then shift the next token onto all remaining stacks.  This
             synchronization of the shift (that is, after all preceding
             Except in the first case, yyparse will invoke yyremoveDeletes and
             then shift the next token onto all remaining stacks.  This
             synchronization of the shift (that is, after all preceding

-            reductions on all stacks) helps prevents double destructor calls
+            reductions on all stacks) helps prevent double destructor calls

             on yylval in the event of memory exhaustion.  */
 
             on yylval in the event of memory exhaustion.  */
 

-         for (yys = 0; yys < yyn; yys += 1)
+         for (yys = 0; yys < yystack.yytops.yysize; yys += 1)

            YYCHK1 (yyprocessOneStack (&yystack, yys, yyposn]b4_lpure_args[));
          yyremoveDeletes (&yystack);
            YYCHK1 (yyprocessOneStack (&yystack, yys, yyposn]b4_lpure_args[));
          yyremoveDeletes (&yystack);

-         yyn = yystack.yytops.yysize;
+         if (yystack.yytops.yysize == 0)
+           {
+             yyundeleteLastStack (&yystack);
+             if (yystack.yytops.yysize == 0)
+               yyFail (&yystack][]b4_lpure_args[, YY_("syntax error"));
+             YYCHK1 (yyresolveStack (&yystack]b4_user_args[));
+             YYDPRINTF ((stderr, "Returning to deterministic operation.\n"));
+]b4_locations_if([[          yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[
+             yyreportSyntaxError (&yystack]b4_user_args[);
+             goto yyuser_error;
+           }

 
          /* If any yyglrShift call fails, it will fail after shifting.  Thus,
             a copy of yylval will already be on stack 0 in the event of a
 
          /* If any yyglrShift call fails, it will fail after shifting.  Thus,
             a copy of yylval will already be on stack 0 in the event of a

-            failure in the following loop.  Thus, yytoken is set to YYEMPTY
+            failure in the following loop.  Thus, yychar is set to YYEMPTY

             before the loop to make sure the user destructor for yylval isn't
             called twice.  */
             before the loop to make sure the user destructor for yylval isn't
             called twice.  */

-         yytoken_to_shift = yytoken;
-         yytoken = YYEMPTY;
+         yytoken_to_shift = YYTRANSLATE (yychar);
+         yychar = YYEMPTY;

          yyposn += 1;
          yyposn += 1;

-         for (yys = 0; yys < yyn; yys += 1)
+         for (yys = 0; yys < yystack.yytops.yysize; yys += 1)

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


@@ -2283,18 +2509,8 @@ b4_syncline([@oline@], [@ofile@])])dnl
                          (unsigned long int) yys,
                          yystack.yytops.yystates[yys]->yylrState));
            }
                          (unsigned long int) yys,
                          yystack.yytops.yystates[yys]->yylrState));
            }

-         if (yystack.yytops.yysize == 0)
-           {
-             yyundeleteLastStack (&yystack);
-             if (yystack.yytops.yysize == 0)
-               yyFail (&yystack][]b4_lpure_args[, YY_("syntax error"));
-             YYCHK1 (yyresolveStack (&yystack]b4_user_args[));
-             YYDPRINTF ((stderr, "Returning to deterministic operation.\n"));
-]b4_location_if([[           yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[
-             yyreportSyntaxError (&yystack]b4_user_args[);
-             goto yyuser_error;
-           }
-         else if (yystack.yytops.yysize == 1)
+
+         if (yystack.yytops.yysize == 1)

            {
              YYCHK1 (yyresolveStack (&yystack]b4_user_args[));
              YYDPRINTF ((stderr, "Returning to deterministic operation.\n"));
            {
              YYCHK1 (yyresolveStack (&yystack]b4_user_args[));
              YYDPRINTF ((stderr, "Returning to deterministic operation.\n"));


@@ -2326,9 +2542,10 @@ b4_syncline([@oline@], [@ofile@])])dnl
   goto yyreturn;
 
  yyreturn:
   goto yyreturn;
 
  yyreturn:

-  if (yytoken != YYEOF && yytoken != YYEMPTY)
+  if (yychar != YYEMPTY)

     yydestruct ("Cleanup: discarding lookahead",
     yydestruct ("Cleanup: discarding lookahead",

-               yytoken, &yylval]b4_location_if([, &yylloc])[]b4_user_args[);
+               YYTRANSLATE (yychar),
+               &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);

 
   /* If the stack is well-formed, pop the stack until it is empty,
      destroying its entries as we go.  But free the stack regardless
 
   /* If the stack is well-formed, pop the stack until it is empty,
      destroying its entries as we go.  But free the stack regardless


@@ -2346,8 +2563,9 @@ b4_syncline([@oline@], [@ofile@])])dnl
                while (yystates[yyk])
                  {
                    yyGLRState *yys = yystates[yyk];
                while (yystates[yyk])
                  {
                    yyGLRState *yys = yystates[yyk];

-]b4_location_if([[                 yystack.yyerror_range[1].yystate.yyloc = yys->yyloc;]]
-)[                 yydestroyGLRState ("Cleanup: popping", yys]b4_user_args[);
+]b4_locations_if([[                yystack.yyerror_range[1].yystate.yyloc = yys->yyloc;]]
+)[                 if (yys->yypred != NULL)
+                     yydestroyGLRState ("Cleanup: popping", yys]b4_user_args[);

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


@@ -2358,11 +2576,12 @@ b4_syncline([@oline@], [@ofile@])])dnl
       yyfreeGLRStack (&yystack);
     }
 
       yyfreeGLRStack (&yystack);
     }
 

-  return yyresult;
+  /* Make sure YYID is used.  */
+  return YYID (yyresult);

 }
 
 /* DEBUGGING ONLY */
 }
 
 /* DEBUGGING ONLY */

-#ifdef YYDEBUG
+#if YYDEBUG

 static void yypstack (yyGLRStack* yystackp, size_t yyk)
   __attribute__ ((__unused__));
 static void yypdumpstack (yyGLRStack* yystackp) __attribute__ ((__unused__));
 static void yypstack (yyGLRStack* yystackp, size_t yyk)
   __attribute__ ((__unused__));
 static void yypdumpstack (yyGLRStack* yystackp) __attribute__ ((__unused__));


@@ -2373,19 +2592,20 @@ yy_yypstack (yyGLRState* yys)
   if (yys->yypred)
     {
       yy_yypstack (yys->yypred);
   if (yys->yypred)
     {
       yy_yypstack (yys->yypred);

-      fprintf (stderr, " -> ");
+      YYFPRINTF (stderr, " -> ");

     }
     }

-  fprintf (stderr, "%d@@%lu", yys->yylrState, (unsigned long int) yys->yyposn);
+  YYFPRINTF (stderr, "%d@@%lu", yys->yylrState,
+             (unsigned long int) yys->yyposn);

 }
 
 static void
 yypstates (yyGLRState* yyst)
 {
   if (yyst == NULL)
 }
 
 static void
 yypstates (yyGLRState* yyst)
 {
   if (yyst == NULL)

-    fprintf (stderr, "<null>");
+    YYFPRINTF (stderr, "<null>");

   else
     yy_yypstack (yyst);
   else
     yy_yypstack (yyst);

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

 }
 
 static void
 }
 
 static void


@@ -2405,49 +2625,54 @@ yypdumpstack (yyGLRStack* yystackp)
   size_t yyi;
   for (yyp = yystackp->yyitems; yyp < yystackp->yynextFree; yyp += 1)
     {
   size_t yyi;
   for (yyp = yystackp->yyitems; yyp < yystackp->yynextFree; yyp += 1)
     {

-      fprintf (stderr, "%3lu. ", (unsigned long int) (yyp - yystackp->yyitems));
+      YYFPRINTF (stderr, "%3lu. ",
+                 (unsigned long int) (yyp - yystackp->yyitems));

       if (*(yybool *) yyp)
        {
       if (*(yybool *) yyp)
        {

-         fprintf (stderr, "Res: %d, LR State: %d, posn: %lu, pred: %ld",
-                  yyp->yystate.yyresolved, yyp->yystate.yylrState,
-                  (unsigned long int) yyp->yystate.yyposn,
-                  (long int) YYINDEX (yyp->yystate.yypred));
+         YYFPRINTF (stderr, "Res: %d, LR State: %d, posn: %lu, pred: %ld",
+                    yyp->yystate.yyresolved, yyp->yystate.yylrState,
+                    (unsigned long int) yyp->yystate.yyposn,
+                    (long int) YYINDEX (yyp->yystate.yypred));

          if (! yyp->yystate.yyresolved)
          if (! yyp->yystate.yyresolved)

-           fprintf (stderr, ", firstVal: %ld",
-                    (long int) YYINDEX (yyp->yystate.yysemantics.yyfirstVal));
+           YYFPRINTF (stderr, ", firstVal: %ld",
+                      (long int) YYINDEX (yyp->yystate
+                                             .yysemantics.yyfirstVal));

        }
       else
        {
        }
       else
        {

-         fprintf (stderr, "Option. rule: %d, state: %ld, next: %ld",
-                  yyp->yyoption.yyrule,
-                  (long int) YYINDEX (yyp->yyoption.yystate),
-                  (long int) YYINDEX (yyp->yyoption.yynext));
+         YYFPRINTF (stderr, "Option. rule: %d, state: %ld, next: %ld",
+                    yyp->yyoption.yyrule - 1,
+                    (long int) YYINDEX (yyp->yyoption.yystate),
+                    (long int) YYINDEX (yyp->yyoption.yynext));

        }
        }

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

     }
     }

-  fprintf (stderr, "Tops:");
+  YYFPRINTF (stderr, "Tops:");

   for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1)
   for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1)

-    fprintf (stderr, "%lu: %ld; ", (unsigned long int) yyi,
-            (long int) YYINDEX (yystackp->yytops.yystates[yyi]));
-  fprintf (stderr, "\n");
+    YYFPRINTF (stderr, "%lu: %ld; ", (unsigned long int) yyi,
+              (long int) YYINDEX (yystackp->yytops.yystates[yyi]));
+  YYFPRINTF (stderr, "\n");

 }
 #endif
 ]
 
 b4_epilogue
 }
 #endif
 ]
 
 b4_epilogue

-m4_if(b4_defines_flag, 0, [],
-[@output @output_header_name@
-b4_copyright([Skeleton parser for GLR parsing with Bison],
-            [2002, 2003, 2004, 2005, 2006])[
-
-/* C GLR parser skeleton written by Paul Hilfinger.  */
-]
+dnl
+dnl glr.cc produces its own header.
+dnl
+m4_if(b4_skeleton, ["glr.c"],
+[b4_defines_if(
+[@output(b4_spec_defines_file@)@
+b4_copyright([Skeleton interface for Bison GLR parsers in C],
+             [2002-2011])

 
 b4_shared_declarations
 
 
 b4_shared_declarations
 

-extern YYSTYPE b4_prefix[]lval;
+b4_pure_if([],
+[[extern YYSTYPE ]b4_prefix[lval;]])

 
 

-b4_location_if([b4_pure_if([],
-[extern YYLTYPE b4_prefix[]lloc;])
-])
+b4_locations_if([b4_pure_if([],
+[extern YYLTYPE ]b4_prefix[lloc;])

 ])
 ])

+])])
+m4_divert_pop(0)