2006-10-16 Paolo Bonzini <bonzini@gnu.org>

[bison.git] / data / glr.c

diff --git a/data/glr.c b/data/glr.c
index aab6779ce6293769a635a2aee6a897992f062202..406e33939ac9a208fa6869baf65ef7679c6c1428 100644 (file)
--- a/data/glr.c
+++ b/data/glr.c
@@ -52,7 +52,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 +61,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 +77,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])

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


@@ -143,14 +143,14 @@ m4_define([b4_rhs_location],
 m4_changecom()
 m4_divert(0)dnl
 @output @output_parser_name@
 m4_changecom()
 m4_divert(0)dnl
 @output @output_parser_name@

-b4_copyright([Skeleton parser for GLR parsing with Bison],
+b4_copyright([Skeleton implementation for Bison GLR parsers in C],

   [2002, 2003, 2004, 2005, 2006])
 [
   [2002, 2003, 2004, 2005, 2006])
 [

-/* 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], [],
+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 +159,37 @@ 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)[
+[m4_ifdef([b4_requires],
+[[/* Copy the %requires blocks.  */
+]b4_user_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
 
 #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
 typedef struct YYLTYPE
 {
 #endif
 
 #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
 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 +201,18 @@ 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@])[
+]m4_ifdef([b4_provides],
+[[/* Copy the %provides blocks.  */
+]b4_user_provides])[]dnl
+])
+
+b4_defines_if([#include @output_header_name@],
+             [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 +220,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,15 +236,11 @@ 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[

 
 

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

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

-#include <stdarg.h>

 
 #ifndef YY_
 # if YYENABLE_NLS
 
 #ifndef YY_
 # if YYENABLE_NLS


@@ -308,7 +310,7 @@ b4_syncline([@oline@], [@ofile@])
 # endif
 #endif
 
 # 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 +345,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[] =


@@ -486,7 +487,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)                               \


@@ -581,7 +582,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))


@@ -622,7 +623,7 @@ int yydebug;
 
 #ifndef YYSTACKEXPANDABLE
 # if (! defined __cplusplus \
 
 #ifndef YYSTACKEXPANDABLE
 # if (! defined __cplusplus \

-      || (]b4_location_if([[defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
+      || (]b4_locations_if([[defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \

          && ]])[defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))
 #  define YYSTACKEXPANDABLE 1
 # else
          && ]])[defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))
 #  define YYSTACKEXPANDABLE 1
 # else


@@ -794,7 +795,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(
 [


@@ -907,7 +908,7 @@ 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
 # define yyclearin (yychar = YYEMPTY)
 # undef YYFILL
 # undef yyclearin
 # define yyclearin (yychar = YYEMPTY)
 # undef YYFILL


@@ -923,13 +924,11 @@ yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,
   else
     *yyvalp = yyvsp[YYFILL (1-yyrhslen)].yystate.yysemantics.yysval;
   YYLLOC_DEFAULT ((*yylocp), (yyvsp - yyrhslen), yyrhslen);
   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;
+]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;
     }
 


@@ -973,7 +972,7 @@ 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
   else
     {
 #if YYDEBUG


@@ -984,7 +983,7 @@ yydestroyGLRState (char const *yymsg, yyGLRState *yys]b4_user_formals[)
          else
            YYFPRINTF (stderr, "%s incomplete ", yymsg);
          yy_symbol_print (stderr, yystos[yys->yylrState],
          else
            YYFPRINTF (stderr, "%s incomplete ", yymsg);
          yy_symbol_print (stderr, yystos[yys->yylrState],

-                          NULL]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


@@ -1392,7 +1391,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;]])[


@@ -1443,7 +1442,7 @@ yy_reduce_print (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
       fprintf (stderr, "   $%d = ", yyi + 1);
       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
                       &]b4_rhs_value(yynrhs, yyi + 1)[
       fprintf (stderr, "   $%d = ", 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[);
       fprintf (stderr, "\n");
     }
                       b4_user_args[);
       fprintf (stderr, "\n");
     }


@@ -1716,7 +1715,7 @@ yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystackp,
       return yyflag;
     }
 
       return yyflag;
     }
 

-  yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred = yyopt->yystate;]b4_location_if([[
+  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;]])[


@@ -1742,7 +1741,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)


@@ -1758,11 +1757,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)
     {


@@ -1803,6 +1802,63 @@ yyreportAmbiguity (yySemanticOption* yyx0,
   return yyabort;
 }
 
   return yyabort;
 }
 

+/** 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
 
 /** Resolve the ambiguity represented in state S, perform the indicated
  *  actions, and set the semantic value of S.  If result != yyok, the chain of


@@ -1837,6 +1893,7 @@ yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp]b4_user_formals[)
          switch (yypreference (yybest, yyp))
            {
            case 0:
          switch (yypreference (yybest, yyp))
            {
            case 0:

+             yyresolveLocations (yys, 1, yystackp]b4_user_args[);

              return yyreportAmbiguity (yybest, yyp]b4_pure_args[);
              break;
            case 1:
              return yyreportAmbiguity (yybest, yyp]b4_pure_args[);
              break;
            case 1:


@@ -1877,7 +1934,7 @@ yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp]b4_user_formals[)
                  {
                    yydestruct ("Cleanup: discarding incompletely merged value for",
                                yystos[yys->yylrState],
                  {
                    yydestruct ("Cleanup: discarding incompletely merged value for",
                                yystos[yys->yylrState],

-                               &yysval]b4_location_if([, yylocp])[]b4_user_args[);
+                               &yysval]b4_locations_if([, yylocp])[]b4_user_args[);

                    break;
                  }
                yyuserMerge (yymerger[yyp->yyrule], &yysval, &yysval_other);
                    break;
                  }
                yyuserMerge (yymerger[yyp->yyrule], &yysval, &yysval_other);


@@ -1981,11 +2038,19 @@ yyprocessOneStack (yyGLRStack* yystackp, size_t yyk,
            {
              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);
            }

-         else
-           yytoken = YYTRANSLATE (yychar);
+

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


@@ -2026,7 +2091,7 @@ yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
 #if YYERROR_VERBOSE
       int yyn;
       yyn = yypact[yystackp->yytops.yystates[0]->yylrState];
 #if YYERROR_VERBOSE
       int yyn;
       yyn = yypact[yystackp->yytops.yystates[0]->yylrState];

-      if (YYPACT_NINF < yyn && yyn < YYLAST)
+      if (YYPACT_NINF < yyn && yyn <= YYLAST)

        {
          yySymbol yytoken = YYTRANSLATE (yychar);
          size_t yysize0 = yytnamerr (NULL, yytokenName (yytoken));
        {
          yySymbol yytoken = YYTRANSLATE (yychar);
          size_t yysize0 = yytnamerr (NULL, yytokenName (yytoken));


@@ -2053,7 +2118,7 @@ yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
          int yyxbegin = yyn < 0 ? -yyn : 0;
 
          /* Stay within bounds of both yycheck and yytname.  */
          int yyxbegin = yyn < 0 ? -yyn : 0;
 
          /* Stay within bounds of both yycheck and yytname.  */

-         int yychecklim = YYLAST - yyn;
+         int yychecklim = YYLAST - yyn + 1;

          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
          int yycount = 1;
 
          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
          int yycount = 1;
 


@@ -2121,7 +2186,7 @@ yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
 
 /* 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[)
 {


@@ -2137,7 +2202,7 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
        if (yychar == YYEOF)
          yyFail (yystackp][]b4_lpure_args[, NULL);
        if (yychar != YYEMPTY)
        if (yychar == YYEOF)
          yyFail (yystackp][]b4_lpure_args[, NULL);
        if (yychar != YYEMPTY)

-         {]b4_location_if([[
+         {]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];
            /* 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];


@@ -2147,12 +2212,20 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
            YYLLOC_DEFAULT ((yys->yyloc), yyerror_range, 2);]])[
            yytoken = YYTRANSLATE (yychar);
            yydestruct ("Error: discarding",
            YYLLOC_DEFAULT ((yys->yyloc), yyerror_range, 2);]])[
            yytoken = YYTRANSLATE (yychar);
            yydestruct ("Error: discarding",

-                       yytoken, &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;

-       yytoken = YYTRANSLATE (yychar);
-       YY_SYMBOL_PRINT ("Next token is", yytoken, &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];
        if (yyis_pact_ninf (yyj))
          return;
        yyj = yypact[yystackp->yytops.yystates[0]->yylrState];
        if (yyis_pact_ninf (yyj))
          return;


@@ -2190,7 +2263,7 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
              && yyisShiftAction (yytable[yyj]))
            {
              /* Shift the error token having adjusted its location.  */
              && 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;
              YYLLOC_DEFAULT (yyerrloc, (yystackp->yyerror_range), 2);]])[
              YY_SYMBOL_PRINT ("Shifting", yystos[yytable[yyj]],
              yystackp->yyerror_range[2].yystate.yyloc = yylloc;
              YYLLOC_DEFAULT (yyerrloc, (yystackp->yyerror_range), 2);]])[
              YY_SYMBOL_PRINT ("Shifting", yystos[yytable[yyj]],


@@ -2201,8 +2274,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;


@@ -2243,21 +2317,19 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
 
   yychar = YYEMPTY;
   yylval = yyval_default;
 
   yychar = YYEMPTY;
   yylval = yyval_default;

-]b4_location_if([
+]b4_locations_if([

 #if YYLTYPE_IS_TRIVIAL
 #if YYLTYPE_IS_TRIVIAL

-  yylloc.first_line   = yylloc.last_line   = 1;
-  yylloc.first_column = yylloc.last_column = 0;
+  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;


@@ -2292,7 +2364,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;
                }


@@ -2305,19 +2377,26 @@ b4_syncline([@oline@], [@ofile@])])dnl
                {
                  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);
                }

-             else
-               yytoken = YYTRANSLATE (yychar);
+

              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 (yychar != YYEOF)
-                   yychar = 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)


@@ -2325,7 +2404,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;
                }


@@ -2338,9 +2417,8 @@ 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 < yyn; yys += 1)
+         for (yys = 0; yys < yystack.yytops.yysize; yys += 1)

            yystackp->yytops.yylookaheadNeeds[yys] = yychar != YYEMPTY;
 
          /* yyprocessOneStack returns one of three things:
            yystackp->yytops.yylookaheadNeeds[yys] = yychar != YYEMPTY;
 
          /* yyprocessOneStack returns one of three things:


@@ -2359,13 +2437,23 @@ 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


@@ -2375,7 +2463,7 @@ b4_syncline([@oline@], [@ofile@])])dnl
          yytoken_to_shift = YYTRANSLATE (yychar);
          yychar = YYEMPTY;
          yyposn += 1;
          yytoken_to_shift = YYTRANSLATE (yychar);
          yychar = YYEMPTY;
          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;


@@ -2391,18 +2479,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"));


@@ -2434,10 +2512,10 @@ b4_syncline([@oline@], [@ofile@])])dnl
   goto yyreturn;
 
  yyreturn:
   goto yyreturn;
 
  yyreturn:

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

     yydestruct ("Cleanup: discarding lookahead",
                YYTRANSLATE (yychar),
     yydestruct ("Cleanup: discarding lookahead",
                YYTRANSLATE (yychar),

-               &yylval]b4_location_if([, &yylloc])[]b4_user_args[);
+               &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


@@ -2455,8 +2533,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;


@@ -2467,7 +2546,8 @@ b4_syncline([@oline@], [@ofile@])])dnl
       yyfreeGLRStack (&yystack);
     }
 
       yyfreeGLRStack (&yystack);
     }
 

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

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


@@ -2528,7 +2608,7 @@ yypdumpstack (yyGLRStack* yystackp)
       else
        {
          fprintf (stderr, "Option. rule: %d, state: %ld, next: %ld",
       else
        {
          fprintf (stderr, "Option. rule: %d, state: %ld, next: %ld",

-                  yyp->yyoption.yyrule,
+                  yyp->yyoption.yyrule - 1,

                   (long int) YYINDEX (yyp->yyoption.yystate),
                   (long int) YYINDEX (yyp->yyoption.yynext));
        }
                   (long int) YYINDEX (yyp->yyoption.yystate),
                   (long int) YYINDEX (yyp->yyoption.yynext));
        }


@@ -2544,19 +2624,16 @@ yypdumpstack (yyGLRStack* yystackp)
 ]
 
 b4_epilogue
 ]
 
 b4_epilogue

-m4_if(b4_defines_flag, 0, [],
+b4_defines_if(

 [@output @output_header_name@
 [@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.  */
-]
+b4_copyright([Skeleton interface for Bison GLR parsers in C],
+  [2002, 2003, 2004, 2005, 2006])

 
 b4_shared_declarations
 
 extern YYSTYPE b4_prefix[]lval;
 
 
 b4_shared_declarations
 
 extern YYSTYPE b4_prefix[]lval;
 

-b4_location_if([b4_pure_if([],
+b4_locations_if([b4_pure_if([],

 [extern YYLTYPE b4_prefix[]lloc;])
 ])
 ])
 [extern YYLTYPE b4_prefix[]lloc;])
 ])
 ])