news: fixes.

[bison.git] / data / glr.c

diff --git a/data/glr.c b/data/glr.c
index b92586882203c1f620848cc8ee692c55a8e864ab..f4efca2c02a4379bd40484c944ce21b5f4219c19 100644 (file)
--- a/data/glr.c
+++ b/data/glr.c
@@ -93,13 +93,27 @@ m4_define([b4_lpure_args],
 [b4_pure_if([b4_locations_if([, &yylloc])])[]b4_user_args])
 
 
 [b4_pure_if([b4_locations_if([, &yylloc])])[]b4_user_args])
 
 

+

 # b4_pure_formals
 # ---------------
 # b4_pure_formals
 # ---------------

-# Arguments passed to yyerror: user formals plus yylocp.
+# Arguments passed to yyerror: user formals plus yylocp with leading comma.

 m4_define([b4_pure_formals],
 [b4_pure_if([b4_locations_if([, YYLTYPE *yylocp])])[]b4_user_formals])
 
 
 m4_define([b4_pure_formals],
 [b4_pure_if([b4_locations_if([, YYLTYPE *yylocp])])[]b4_user_formals])
 
 

+# b4_locuser_formals(LOC = yylocp)
+# --------------------------------
+m4_define([b4_locuser_formals],
+[b4_locations_if([, YYLTYPE *m4_default([$1], [yylocp])])[]b4_user_formals])
+
+
+# b4_locuser_args(LOC = yylocp)
+# -----------------------------
+m4_define([b4_locuser_args],
+[b4_locations_if([, m4_default([$1], [yylocp])])[]b4_user_args])
+
+
+

 ## ----------------- ##
 ## Semantic Values.  ##
 ## ----------------- ##
 ## ----------------- ##
 ## Semantic Values.  ##
 ## ----------------- ##


@@ -148,6 +162,23 @@ m4_define([b4_rhs_location],
 [(b4_rhs_data([$1], [$2]).yyloc)])
 
 
 [(b4_rhs_data([$1], [$2]).yyloc)])
 
 

+## -------------- ##
+## Declarations.  ##
+## -------------- ##
+
+# b4_shared_declarations
+# ----------------------
+# Declaration that might either go into the header (if --defines)
+# or open coded in the parser body.
+m4_define([b4_shared_declarations],
+[b4_declare_yydebug[
+]b4_percent_code_get([[requires]])[
+]b4_token_enums(b4_tokens)[
+]b4_declare_yylstype[
+]b4_c_ansi_function_decl(b4_prefix[parse], [int], b4_parse_param)[
+]b4_percent_code_get([[provides]])[]dnl
+])
+

 
 ## -------------- ##
 ## Output files.  ##
 
 ## -------------- ##
 ## Output files.  ##


@@ -177,56 +208,13 @@ m4_if(b4_prefix, [yy], [],
 #define yylloc  b4_prefix[]lloc])[
 
 /* Copy the first part of user declarations.  */
 #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],
-[b4_percent_code_get([[requires]])[]dnl
+]b4_user_pre_prologue[

 
 

-b4_token_enums(b4_tokens)
+]b4_null_define[

 
 

-[#ifndef YYSTYPE
-]m4_ifdef([b4_stype],
-[[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
-{
-]b4_locations_if([
-  int first_line;
-  int first_column;
-  int last_line;
-  int last_column;
-],[
-  char yydummy;
-])[
-} YYLTYPE;
-# define YYLTYPE_IS_DECLARED 1
-# define YYLTYPE_IS_TRIVIAL 1
-#endif
-
-]b4_percent_code_get([[provides]])[]dnl
-])
-
-b4_defines_if([[#include "@basename(]b4_spec_defines_file[@)"]],
+]b4_defines_if([[#include "@basename(]b4_spec_defines_file[@)"]],

               [b4_shared_declarations])[
 
               [b4_shared_declarations])[
 

-/* Enabling traces.  */
-#ifndef YYDEBUG
-# define YYDEBUG ]b4_parse_trace_if([1], [0])[
-#endif
-

 /* Enabling verbose error messages.  */
 #ifdef YYERROR_VERBOSE
 # undef YYERROR_VERBOSE
 /* Enabling verbose error messages.  */
 #ifdef YYERROR_VERBOSE
 # undef YYERROR_VERBOSE


@@ -318,8 +306,7 @@ b4_percent_code_get[]dnl
 #ifndef __attribute__
 /* This feature is available in gcc versions 2.5 and later.  */
 # if (! defined __GNUC__ || __GNUC__ < 2 \
 #ifndef __attribute__
 /* This feature is available in gcc versions 2.5 and later.  */
 # if (! defined __GNUC__ || __GNUC__ < 2 \

-      || (__GNUC__ == 2 && __GNUC_MINOR__ < 5) \
-      || (defined __STRICT_ANSI__ && __STRICT_ANSI__))
+      || (__GNUC__ == 2 && __GNUC_MINOR__ < 5))

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


@@ -427,9 +414,6 @@ dnl We probably ought to introduce a type for confl.
   ]b4_conflicting_rules[
 };
 \f
   ]b4_conflicting_rules[
 };
 \f

-/* Prevent warning if -Wmissing-prototypes.  */
-]b4_c_ansi_function_decl([yyparse], [int], b4_parse_param)[
-

 /* Error token number */
 #define YYTERROR 1
 
 /* Error token number */
 #define YYTERROR 1
 


@@ -496,9 +480,8 @@ m4_if(b4_prefix[], [yy], [],
 #define b4_prefix[]char yychar
 #define b4_prefix[]lval yylval
 #define b4_prefix[]lloc yylloc])],
 #define b4_prefix[]char yychar
 #define b4_prefix[]lval yylval
 #define b4_prefix[]lloc yylloc])],

-[YYSTYPE yylval;
-
-YYLTYPE yylloc;
+[YYSTYPE yylval;]b4_locations_if([[
+YYLTYPE yylloc;]])[

 
 int yynerrs;
 int yychar;])[
 
 int yynerrs;
 int yychar;])[


@@ -534,8 +517,7 @@ typedef enum { yyok, yyaccept, yyabort, yyerr } YYRESULTTAG;
     if (yydebug)                                                        \
       {                                                                 \
         YYFPRINTF (stderr, "%s ", Title);                               \
     if (yydebug)                                                        \
       {                                                                 \
         YYFPRINTF (stderr, "%s ", Title);                               \

-        yy_symbol_print (stderr, Type,                                  \
-                         Value]b4_locations_if([, Location])[]b4_user_args[); \
+        yy_symbol_print (stderr, Type, Value]b4_locuser_args([Location])[);        \

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


@@ -702,9 +684,9 @@ struct yyGLRState {
     yySemanticOption* yyfirstVal;
     /** Semantic value for this state.  */
     YYSTYPE yysval;
     yySemanticOption* yyfirstVal;
     /** Semantic value for this state.  */
     YYSTYPE yysval;

-  } yysemantics;
+  } yysemantics;]b4_locations_if([[

   /** Source location for this state.  */
   /** Source location for this state.  */

-  YYLTYPE yyloc;
+  YYLTYPE yyloc;]])[

 };
 
 struct yyGLRStateSet {
 };
 
 struct yyGLRStateSet {


@@ -726,8 +708,8 @@ struct yySemanticOption {
   yyGLRState* yystate;
   /** The lookahead for this reduction.  */
   int yyrawchar;
   yyGLRState* yystate;
   /** The lookahead for this reduction.  */
   int yyrawchar;

-  YYSTYPE yyval;
-  YYLTYPE yyloc;
+  YYSTYPE yyval;]b4_locations_if([[
+  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;


@@ -748,8 +730,8 @@ struct yyGLRStack {
 [
   int yyerrcnt;
   int yyrawchar;
 [
   int yyerrcnt;
   int yyrawchar;

-  YYSTYPE yyval;
-  YYLTYPE yyloc;
+  YYSTYPE yyval;]b4_locations_if([[
+  YYLTYPE yyloc;]])[

 ])[
   YYJMP_BUF yyexception_buffer;
   yyGLRStackItem* yyitems;
 ])[
   YYJMP_BUF yyexception_buffer;
   yyGLRStackItem* yyitems;


@@ -769,7 +751,7 @@ static void yyFail (yyGLRStack* yystackp]b4_pure_formals[, const char* yymsg)
 static void
 yyFail (yyGLRStack* yystackp]b4_pure_formals[, const char* yymsg)
 {
 static void
 yyFail (yyGLRStack* yystackp]b4_pure_formals[, const char* yymsg)
 {

-  if (yymsg != NULL)
+  if (yymsg != YY_NULL)

     yyerror (]b4_yyerror_args[yymsg);
   YYLONGJMP (yystackp->yyexception_buffer, 1);
 }
     yyerror (]b4_yyerror_args[yymsg);
   YYLONGJMP (yystackp->yyexception_buffer, 1);
 }


@@ -801,9 +783,8 @@ static void yyfillin (yyGLRStackItem *, int, int) __attribute__ ((__unused__));
 static void
 yyfillin (yyGLRStackItem *yyvsp, int yylow0, int yylow1)
 {
 static void
 yyfillin (yyGLRStackItem *yyvsp, int yylow0, int yylow1)
 {

-  yyGLRState* s;

   int i;
   int i;

-  s = yyvsp[yylow0].yystate.yypred;
+  yyGLRState *s = yyvsp[yylow0].yystate.yypred;

   for (i = yylow0-1; i >= yylow1; i -= 1)
     {
 #if YYDEBUG
   for (i = yylow0-1; i >= yylow1; i -= 1)
     {
 #if YYDEBUG


@@ -815,8 +796,8 @@ yyfillin (yyGLRStackItem *yyvsp, int yylow0, int yylow1)
       else
         /* The effect of using yysval or yyloc (in an immediate rule) is
          * undefined.  */
       else
         /* The effect of using yysval or yyloc (in an immediate rule) is
          * undefined.  */

-        yyvsp[i].yystate.yysemantics.yyfirstVal = NULL;
-      yyvsp[i].yystate.yyloc = s->yyloc;
+        yyvsp[i].yystate.yysemantics.yyfirstVal = YY_NULL;]b4_locations_if([[
+      yyvsp[i].yystate.yyloc = s->yyloc;]])[

       s = yyvsp[i].yystate.yypred = s->yypred;
     }
 }
       s = yyvsp[i].yystate.yypred = s->yypred;
     }
 }


@@ -844,13 +825,11 @@ yyfill (yyGLRStackItem *yyvsp, int *yylow, int yylow1, yybool yynormal)
  *  yyerr for YYERROR, yyabort for YYABORT.  */
 /*ARGSUSED*/ static YYRESULTTAG
 yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,
  *  yyerr for YYERROR, yyabort for YYABORT.  */
 /*ARGSUSED*/ static YYRESULTTAG
 yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,

-              YYSTYPE* yyvalp,
-              YYLTYPE* YYOPTIONAL_LOC (yylocp),
-              yyGLRStack* yystackp
-              ]b4_user_formals[)
+              yyGLRStack* yystackp,
+              YYSTYPE* yyvalp]b4_locuser_formals[)

 {
   yybool yynormal __attribute__ ((__unused__)) =
 {
   yybool yynormal __attribute__ ((__unused__)) =

-    (yystackp->yysplitPoint == NULL);
+    (yystackp->yysplitPoint == YY_NULL);

   int yylow;
 ]b4_parse_param_use([yyvalp], [yylocp])dnl
 [# undef yyerrok
   int yylow;
 ]b4_parse_param_use([yyvalp], [yylocp])dnl
 [# undef yyerrok


@@ -876,9 +855,9 @@ yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,
   if (yyrhslen == 0)
     *yyvalp = yyval_default;
   else
   if (yyrhslen == 0)
     *yyvalp = yyval_default;
   else

-    *yyvalp = yyvsp[YYFILL (1-yyrhslen)].yystate.yysemantics.yysval;
+    *yyvalp = yyvsp[YYFILL (1-yyrhslen)].yystate.yysemantics.yysval;]b4_locations_if([[

   YYLLOC_DEFAULT ((*yylocp), (yyvsp - yyrhslen), yyrhslen);
   YYLLOC_DEFAULT ((*yylocp), (yyvsp - yyrhslen), yyrhslen);

-]b4_locations_if([[  yystackp->yyerror_range[1].yystate.yyloc = *yylocp;
+  yystackp->yyerror_range[1].yystate.yyloc = *yylocp;

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


@@ -926,7 +905,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_locations_if([, &yys->yyloc])[]b4_user_args[);
+                &yys->yysemantics.yysval]b4_locuser_args([&yys->yyloc])[);

   else
     {
 #if YYDEBUG
   else
     {
 #if YYDEBUG


@@ -937,7 +916,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_locations_if([, &yys->yyloc])[]b4_user_args[);
+                           YY_NULL]b4_locuser_args([&yys->yyloc])[);

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


@@ -1068,8 +1047,8 @@ yyaddDeferredAction (yyGLRStack* yystackp, size_t yyk, yyGLRState* yystate,
   if (yystackp->yytops.yylookaheadNeeds[yyk])
     {
       yynewOption->yyrawchar = yychar;
   if (yystackp->yytops.yylookaheadNeeds[yyk])
     {
       yynewOption->yyrawchar = yychar;

-      yynewOption->yyval = yylval;
-      yynewOption->yyloc = yylloc;
+      yynewOption->yyval = yylval;]b4_locations_if([
+      yynewOption->yyloc = yylloc;])[

     }
   else
     yynewOption->yyrawchar = YYEMPTY;
     }
   else
     yynewOption->yyrawchar = YYEMPTY;


@@ -1090,7 +1069,7 @@ yyinitStateSet (yyGLRStateSet* yyset)
   yyset->yystates = (yyGLRState**) YYMALLOC (16 * sizeof yyset->yystates[0]);
   if (! yyset->yystates)
     return yyfalse;
   yyset->yystates = (yyGLRState**) YYMALLOC (16 * sizeof yyset->yystates[0]);
   if (! yyset->yystates)
     return yyfalse;

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

   yyset->yylookaheadNeeds =
     (yybool*) YYMALLOC (16 * sizeof yyset->yylookaheadNeeds[0]);
   if (! yyset->yylookaheadNeeds)
   yyset->yylookaheadNeeds =
     (yybool*) YYMALLOC (16 * sizeof yyset->yylookaheadNeeds[0]);
   if (! yyset->yylookaheadNeeds)


@@ -1120,8 +1099,8 @@ yyinitGLRStack (yyGLRStack* yystackp, size_t yysize)
   if (!yystackp->yyitems)
     return yyfalse;
   yystackp->yynextFree = yystackp->yyitems;
   if (!yystackp->yyitems)
     return yyfalse;
   yystackp->yynextFree = yystackp->yyitems;

-  yystackp->yysplitPoint = NULL;
-  yystackp->yylastDeleted = NULL;
+  yystackp->yysplitPoint = YY_NULL;
+  yystackp->yylastDeleted = YY_NULL;

   return yyinitStateSet (&yystackp->yytops);
 }
 
   return yyinitStateSet (&yystackp->yytops);
 }
 


@@ -1140,9 +1119,9 @@ yyexpandGLRStack (yyGLRStack* yystackp)
 {
   yyGLRStackItem* yynewItems;
   yyGLRStackItem* yyp0, *yyp1;
 {
   yyGLRStackItem* yynewItems;
   yyGLRStackItem* yyp0, *yyp1;

-  size_t yysize, yynewSize;
+  size_t yynewSize;

   size_t yyn;
   size_t yyn;

-  yysize = yystackp->yynextFree - yystackp->yyitems;
+  size_t yysize = yystackp->yynextFree - yystackp->yyitems;

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


@@ -1160,29 +1139,29 @@ yyexpandGLRStack (yyGLRStack* yystackp)
         {
           yyGLRState* yys0 = &yyp0->yystate;
           yyGLRState* yys1 = &yyp1->yystate;
         {
           yyGLRState* yys0 = &yyp0->yystate;
           yyGLRState* yys1 = &yyp1->yystate;

-          if (yys0->yypred != NULL)
+          if (yys0->yypred != YY_NULL)

             yys1->yypred =
               YYRELOC (yyp0, yyp1, yys0->yypred, yystate);
             yys1->yypred =
               YYRELOC (yyp0, yyp1, yys0->yypred, yystate);

-          if (! yys0->yyresolved && yys0->yysemantics.yyfirstVal != NULL)
+          if (! yys0->yyresolved && yys0->yysemantics.yyfirstVal != YY_NULL)

             yys1->yysemantics.yyfirstVal =
             yys1->yysemantics.yyfirstVal =

-              YYRELOC(yyp0, yyp1, yys0->yysemantics.yyfirstVal, yyoption);
+              YYRELOC (yyp0, yyp1, yys0->yysemantics.yyfirstVal, yyoption);

         }
       else
         {
           yySemanticOption* yyv0 = &yyp0->yyoption;
           yySemanticOption* yyv1 = &yyp1->yyoption;
         }
       else
         {
           yySemanticOption* yyv0 = &yyp0->yyoption;
           yySemanticOption* yyv1 = &yyp1->yyoption;

-          if (yyv0->yystate != NULL)
+          if (yyv0->yystate != YY_NULL)

             yyv1->yystate = YYRELOC (yyp0, yyp1, yyv0->yystate, yystate);
             yyv1->yystate = YYRELOC (yyp0, yyp1, yyv0->yystate, yystate);

-          if (yyv0->yynext != NULL)
+          if (yyv0->yynext != YY_NULL)

             yyv1->yynext = YYRELOC (yyp0, yyp1, yyv0->yynext, yyoption);
         }
     }
             yyv1->yynext = YYRELOC (yyp0, yyp1, yyv0->yynext, yyoption);
         }
     }

-  if (yystackp->yysplitPoint != NULL)
+  if (yystackp->yysplitPoint != YY_NULL)

     yystackp->yysplitPoint = YYRELOC (yystackp->yyitems, yynewItems,
                                  yystackp->yysplitPoint, yystate);
 
   for (yyn = 0; yyn < yystackp->yytops.yysize; yyn += 1)
     yystackp->yysplitPoint = YYRELOC (yystackp->yyitems, yynewItems,
                                  yystackp->yysplitPoint, yystate);
 
   for (yyn = 0; yyn < yystackp->yytops.yysize; yyn += 1)

-    if (yystackp->yytops.yystates[yyn] != NULL)
+    if (yystackp->yytops.yystates[yyn] != YY_NULL)

       yystackp->yytops.yystates[yyn] =
         YYRELOC (yystackp->yyitems, yynewItems,
                  yystackp->yytops.yystates[yyn], yystate);
       yystackp->yytops.yystates[yyn] =
         YYRELOC (yystackp->yyitems, yynewItems,
                  yystackp->yytops.yystates[yyn], yystate);


@@ -1206,7 +1185,7 @@ yyfreeGLRStack (yyGLRStack* yystackp)
 static inline void
 yyupdateSplit (yyGLRStack* yystackp, yyGLRState* yys)
 {
 static inline void
 yyupdateSplit (yyGLRStack* yystackp, yyGLRState* yys)
 {

-  if (yystackp->yysplitPoint != NULL && yystackp->yysplitPoint > yys)
+  if (yystackp->yysplitPoint != YY_NULL && yystackp->yysplitPoint > yys)

     yystackp->yysplitPoint = yys;
 }
 
     yystackp->yysplitPoint = yys;
 }
 


@@ -1214,9 +1193,9 @@ yyupdateSplit (yyGLRStack* yystackp, yyGLRState* yys)
 static inline void
 yymarkStackDeleted (yyGLRStack* yystackp, size_t yyk)
 {
 static inline void
 yymarkStackDeleted (yyGLRStack* yystackp, size_t yyk)
 {

-  if (yystackp->yytops.yystates[yyk] != NULL)
+  if (yystackp->yytops.yystates[yyk] != YY_NULL)

     yystackp->yylastDeleted = yystackp->yytops.yystates[yyk];
     yystackp->yylastDeleted = yystackp->yytops.yystates[yyk];

-  yystackp->yytops.yystates[yyk] = NULL;
+  yystackp->yytops.yystates[yyk] = YY_NULL;

 }
 
 /** Undelete the last stack in *YYSTACKP that was marked as deleted.  Can
 }
 
 /** Undelete the last stack in *YYSTACKP that was marked as deleted.  Can


@@ -1225,12 +1204,12 @@ yymarkStackDeleted (yyGLRStack* yystackp, size_t yyk)
 static void
 yyundeleteLastStack (yyGLRStack* yystackp)
 {
 static void
 yyundeleteLastStack (yyGLRStack* yystackp)
 {

-  if (yystackp->yylastDeleted == NULL || yystackp->yytops.yysize != 0)
+  if (yystackp->yylastDeleted == YY_NULL || yystackp->yytops.yysize != 0)

     return;
   yystackp->yytops.yystates[0] = yystackp->yylastDeleted;
   yystackp->yytops.yysize = 1;
   YYDPRINTF ((stderr, "Restoring last deleted stack as stack #0.\n"));
     return;
   yystackp->yytops.yystates[0] = yystackp->yylastDeleted;
   yystackp->yytops.yysize = 1;
   YYDPRINTF ((stderr, "Restoring last deleted stack as stack #0.\n"));

-  yystackp->yylastDeleted = NULL;
+  yystackp->yylastDeleted = YY_NULL;

 }
 
 static inline void
 }
 
 static inline void


@@ -1240,7 +1219,7 @@ yyremoveDeletes (yyGLRStack* yystackp)
   yyi = yyj = 0;
   while (yyj < yystackp->yytops.yysize)
     {
   yyi = yyj = 0;
   while (yyj < yystackp->yytops.yysize)
     {

-      if (yystackp->yytops.yystates[yyi] == NULL)
+      if (yystackp->yytops.yystates[yyi] == YY_NULL)

         {
           if (yyi == yyj)
             {
         {
           if (yyi == yyj)
             {


@@ -1275,7 +1254,7 @@ yyremoveDeletes (yyGLRStack* yystackp)
 static inline void
 yyglrShift (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState,
             size_t yyposn,
 static inline void
 yyglrShift (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState,
             size_t yyposn,

-            YYSTYPE* yyvalp, YYLTYPE* yylocp)
+            YYSTYPE* yyvalp]b4_locations_if([, YYLTYPE* yylocp])[)

 {
   yyGLRState* yynewState = &yynewGLRStackItem (yystackp, yytrue)->yystate;
 
 {
   yyGLRState* yynewState = &yynewGLRStackItem (yystackp, yytrue)->yystate;
 


@@ -1283,8 +1262,8 @@ yyglrShift (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState,
   yynewState->yyposn = yyposn;
   yynewState->yyresolved = yytrue;
   yynewState->yypred = yystackp->yytops.yystates[yyk];
   yynewState->yyposn = yyposn;
   yynewState->yyresolved = yytrue;
   yynewState->yypred = yystackp->yytops.yystates[yyk];

-  yynewState->yysemantics.yysval = *yyvalp;
-  yynewState->yyloc = *yylocp;
+  yynewState->yysemantics.yysval = *yyvalp;]b4_locations_if([
+  yynewState->yyloc = *yylocp;])[

   yystackp->yytops.yystates[yyk] = yynewState;
 
   YY_RESERVE_GLRSTACK (yystackp);
   yystackp->yytops.yystates[yyk] = yynewState;
 
   YY_RESERVE_GLRSTACK (yystackp);


@@ -1303,7 +1282,7 @@ yyglrShiftDefer (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState,
   yynewState->yyposn = yyposn;
   yynewState->yyresolved = yyfalse;
   yynewState->yypred = yystackp->yytops.yystates[yyk];
   yynewState->yyposn = yyposn;
   yynewState->yyresolved = yyfalse;
   yynewState->yypred = yystackp->yytops.yystates[yyk];

-  yynewState->yysemantics.yyfirstVal = NULL;
+  yynewState->yysemantics.yyfirstVal = YY_NULL;

   yystackp->yytops.yystates[yyk] = yynewState;
 
   /* Invokes YY_RESERVE_GLRSTACK.  */
   yystackp->yytops.yystates[yyk] = yynewState;
 
   /* Invokes YY_RESERVE_GLRSTACK.  */


@@ -1359,11 +1338,11 @@ yy_reduce_print (int yynormal, yyGLRStackItem* yyvsp, size_t yyk,
  *  for userAction.  */
 static inline YYRESULTTAG
 yydoAction (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
  *  for userAction.  */
 static inline YYRESULTTAG
 yydoAction (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,

-            YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[)
+            YYSTYPE* yyvalp]b4_locuser_formals[)

 {
   int yynrhs = yyrhsLength (yyrule);
 
 {
   int yynrhs = yyrhsLength (yyrule);
 

-  if (yystackp->yysplitPoint == NULL)
+  if (yystackp->yysplitPoint == YY_NULL)

     {
       /* Standard special case: single stack.  */
       yyGLRStackItem* yyrhs = (yyGLRStackItem*) yystackp->yytops.yystates[yyk];
     {
       /* Standard special case: single stack.  */
       yyGLRStackItem* yyrhs = (yyGLRStackItem*) yystackp->yytops.yystates[yyk];


@@ -1372,8 +1351,8 @@ yydoAction (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
       yystackp->yyspaceLeft += yynrhs;
       yystackp->yytops.yystates[0] = & yystackp->yynextFree[-1].yystate;
       YY_REDUCE_PRINT ((1, yyrhs, yyk, yyrule]b4_user_args[));
       yystackp->yyspaceLeft += yynrhs;
       yystackp->yytops.yystates[0] = & yystackp->yynextFree[-1].yystate;
       YY_REDUCE_PRINT ((1, yyrhs, yyk, yyrule]b4_user_args[));

-      return yyuserAction (yyrule, yynrhs, yyrhs,
-                           yyvalp, yylocp, yystackp]b4_user_args[);
+      return yyuserAction (yyrule, yynrhs, yyrhs, yystackp,
+                           yyvalp]b4_locuser_args[);

     }
   else
     {
     }
   else
     {


@@ -1394,7 +1373,7 @@ yydoAction (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
       yystackp->yytops.yystates[yyk] = yys;
       YY_REDUCE_PRINT ((0, yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, yyk, yyrule]b4_user_args[));
       return yyuserAction (yyrule, yynrhs, yyrhsVals + YYMAXRHS + YYMAXLEFT - 1,
       yystackp->yytops.yystates[yyk] = yys;
       YY_REDUCE_PRINT ((0, yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, yyk, yyrule]b4_user_args[));
       return yyuserAction (yyrule, yynrhs, yyrhsVals + YYMAXRHS + YYMAXLEFT - 1,

-                           yyvalp, yylocp, yystackp]b4_user_args[);
+                           yystackp, yyvalp]b4_locuser_args[);

     }
 }
 
     }
 }
 


@@ -1415,15 +1394,14 @@ yyglrReduce (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
 {
   size_t yyposn = yystackp->yytops.yystates[yyk]->yyposn;
 
 {
   size_t yyposn = yystackp->yytops.yystates[yyk]->yyposn;
 

-  if (yyforceEval || yystackp->yysplitPoint == NULL)
+  if (yyforceEval || yystackp->yysplitPoint == YY_NULL)

     {
       YYRESULTTAG yyflag;
     {
       YYRESULTTAG yyflag;

-      YYSTYPE yysval;
-      YYLTYPE yyloc;
+      YYSTYPE yysval;]b4_locations_if([
+      YYLTYPE yyloc;])[

 
 

-      yyflag = yydoAction (yystackp, yyk, yyrule, &yysval,
-                           &yyloc]b4_user_args[);
-      if (yyflag == yyerr && yystackp->yysplitPoint != NULL)
+      yyflag = yydoAction (yystackp, yyk, yyrule, &yysval]b4_locuser_args([&yyloc])[);
+      if (yyflag == yyerr && yystackp->yysplitPoint != YY_NULL)

         {
           YYDPRINTF ((stderr, "Parse on stack %lu rejected by rule #%d.\n",
                      (unsigned long int) yyk, yyrule - 1));
         {
           YYDPRINTF ((stderr, "Parse on stack %lu rejected by rule #%d.\n",
                      (unsigned long int) yyk, yyrule - 1));


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

-                  yyposn, &yysval, &yyloc);
+                  yyposn, &yysval]b4_locations_if([, &yyloc])[);

     }
   else
     {
     }
   else
     {


@@ -1456,10 +1434,10 @@ yyglrReduce (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
                   "Now in state %d.\n",
                   (unsigned long int) yyk, yyrule - 1, yynewLRState));
       for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1)
                   "Now in state %d.\n",
                   (unsigned long int) yyk, yyrule - 1, yynewLRState));
       for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1)

-        if (yyi != yyk && yystackp->yytops.yystates[yyi] != NULL)
+        if (yyi != yyk && yystackp->yytops.yystates[yyi] != YY_NULL)

           {
           {

-            yyGLRState* yyp, *yysplit = yystackp->yysplitPoint;
-            yyp = yystackp->yytops.yystates[yyi];
+            yyGLRState *yysplit = yystackp->yysplitPoint;
+            yyGLRState *yyp = yystackp->yytops.yystates[yyi];

             while (yyp != yys && yyp != yysplit && yyp->yyposn >= yyposn)
               {
                 if (yyp->yylrState == yynewLRState && yyp->yypred == yys)
             while (yyp != yys && yyp != yysplit && yyp->yyposn >= yyposn)
               {
                 if (yyp->yylrState == yynewLRState && yyp->yypred == yys)


@@ -1483,7 +1461,7 @@ yyglrReduce (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
 static size_t
 yysplitStack (yyGLRStack* yystackp, size_t yyk)
 {
 static size_t
 yysplitStack (yyGLRStack* yystackp, size_t yyk)
 {

-  if (yystackp->yysplitPoint == NULL)
+  if (yystackp->yysplitPoint == YY_NULL)

     {
       YYASSERT (yyk == 0);
       yystackp->yysplitPoint = yystackp->yytops.yystates[yyk];
     {
       YYASSERT (yyk == 0);
       yystackp->yysplitPoint = yystackp->yytops.yystates[yyk];


@@ -1493,7 +1471,7 @@ yysplitStack (yyGLRStack* yystackp, size_t yyk)
       yyGLRState** yynewStates;
       yybool* yynewLookaheadNeeds;
 
       yyGLRState** yynewStates;
       yybool* yynewLookaheadNeeds;
 

-      yynewStates = NULL;
+      yynewStates = YY_NULL;

 
       if (yystackp->yytops.yycapacity
           > (YYSIZEMAX / (2 * sizeof yynewStates[0])))
 
       if (yystackp->yytops.yycapacity
           > (YYSIZEMAX / (2 * sizeof yynewStates[0])))


@@ -1504,7 +1482,7 @@ yysplitStack (yyGLRStack* yystackp, size_t yyk)
         (yyGLRState**) YYREALLOC (yystackp->yytops.yystates,
                                   (yystackp->yytops.yycapacity
                                    * sizeof yynewStates[0]));
         (yyGLRState**) YYREALLOC (yystackp->yytops.yystates,
                                   (yystackp->yytops.yycapacity
                                    * sizeof yynewStates[0]));

-      if (yynewStates == NULL)
+      if (yynewStates == YY_NULL)

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


@@ -1512,7 +1490,7 @@ yysplitStack (yyGLRStack* yystackp, size_t yyk)
         (yybool*) YYREALLOC (yystackp->yytops.yylookaheadNeeds,
                              (yystackp->yytops.yycapacity
                               * sizeof yynewLookaheadNeeds[0]));
         (yybool*) YYREALLOC (yystackp->yytops.yylookaheadNeeds,
                              (yystackp->yytops.yycapacity
                               * sizeof yynewLookaheadNeeds[0]));

-      if (yynewLookaheadNeeds == NULL)
+      if (yynewLookaheadNeeds == YY_NULL)

         yyMemoryExhausted (yystackp);
       yystackp->yytops.yylookaheadNeeds = yynewLookaheadNeeds;
     }
         yyMemoryExhausted (yystackp);
       yystackp->yytops.yylookaheadNeeds = yynewLookaheadNeeds;
     }


@@ -1572,15 +1550,13 @@ yymergeOptionSets (yySemanticOption* yyy0, yySemanticOption* yyy1)
         }
       else
         {
         }
       else
         {

-          yySemanticOption** yyz0p;
-          yySemanticOption* yyz1;
-          yyz0p = &yys0->yysemantics.yyfirstVal;
-          yyz1 = yys1->yysemantics.yyfirstVal;
+          yySemanticOption** yyz0p = &yys0->yysemantics.yyfirstVal;
+          yySemanticOption* yyz1 = yys1->yysemantics.yyfirstVal;

           while (YYID (yytrue))
             {
           while (YYID (yytrue))
             {

-              if (yyz1 == *yyz0p || yyz1 == NULL)
+              if (yyz1 == *yyz0p || yyz1 == YY_NULL)

                 break;
                 break;

-              else if (*yyz0p == NULL)
+              else if (*yyz0p == YY_NULL)

                 {
                   *yyz0p = yyz1;
                   break;
                 {
                   *yyz0p = yyz1;
                   break;


@@ -1654,17 +1630,12 @@ yyresolveStates (yyGLRState* yys, int yyn,
  *  semantic values if invoked).  */
 static YYRESULTTAG
 yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystackp,
  *  semantic values if invoked).  */
 static YYRESULTTAG
 yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystackp,

-                 YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[)
+                 YYSTYPE* yyvalp]b4_locuser_formals[)

 {
   yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1];
 {
   yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1];

-  int yynrhs;
-  int yychar_current;
-  YYSTYPE yylval_current;
-  YYLTYPE yylloc_current;
-  YYRESULTTAG yyflag;
-
-  yynrhs = yyrhsLength (yyopt->yyrule);
-  yyflag = yyresolveStates (yyopt->yystate, yynrhs, yystackp]b4_user_args[);
+  int yynrhs = yyrhsLength (yyopt->yyrule);
+  YYRESULTTAG yyflag =
+    yyresolveStates (yyopt->yystate, yynrhs, yystackp]b4_user_args[);

   if (yyflag != yyok)
     {
       yyGLRState *yys;
   if (yyflag != yyok)
     {
       yyGLRState *yys;


@@ -1677,18 +1648,20 @@ yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystackp,
   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;]])[

-  yychar_current = yychar;
-  yylval_current = yylval;
-  yylloc_current = yylloc;
-  yychar = yyopt->yyrawchar;
-  yylval = yyopt->yyval;
-  yylloc = yyopt->yyloc;
-  yyflag = yyuserAction (yyopt->yyrule, yynrhs,
+  {
+    int yychar_current = yychar;
+    YYSTYPE yylval_current = yylval;]b4_locations_if([
+    YYLTYPE yylloc_current = yylloc;])[
+    yychar = yyopt->yyrawchar;
+    yylval = yyopt->yyval;]b4_locations_if([
+    yylloc = yyopt->yyloc;])[
+    yyflag = yyuserAction (yyopt->yyrule, yynrhs,

                            yyrhsVals + YYMAXRHS + YYMAXLEFT - 1,
                            yyrhsVals + YYMAXRHS + YYMAXLEFT - 1,

-                           yyvalp, yylocp, yystackp]b4_user_args[);
-  yychar = yychar_current;
-  yylval = yylval_current;
-  yylloc = yylloc_current;
+                           yystackp, yyvalp]b4_locuser_args[);
+    yychar = yychar_current;
+    yylval = yylval_current;]b4_locations_if([
+    yylloc = yylloc_current;])[
+  }

   return yyflag;
 }
 
   return yyflag;
 }
 


@@ -1704,7 +1677,7 @@ yyreportTree (yySemanticOption* yyx, int yyindent)
 
   for (yyi = yynrhs, yys = yyx->yystate; 0 < yyi; yyi -= 1, yys = yys->yypred)
     yystates[yyi] = yys;
 
   for (yyi = yynrhs, yys = yyx->yystate; 0 < yyi; yyi -= 1, yys = yys->yypred)
     yystates[yyi] = yys;

-  if (yys == NULL)
+  if (yys == YY_NULL)

     {
       yyleftmost_state.yyposn = 0;
       yystates[0] = &yyleftmost_state;
     {
       yyleftmost_state.yyposn = 0;
       yystates[0] = &yyleftmost_state;


@@ -1772,14 +1745,10 @@ yyresolveLocations (yyGLRState* yys1, int yyn1,
       yyresolveLocations (yys1->yypred, yyn1 - 1, yystackp]b4_user_args[);
       if (!yys1->yyresolved)
         {
       yyresolveLocations (yys1->yypred, yyn1 - 1, yystackp]b4_user_args[);
       if (!yys1->yyresolved)
         {

-          yySemanticOption *yyoption;

           yyGLRStackItem yyrhsloc[1 + YYMAXRHS];
           int yynrhs;
           yyGLRStackItem yyrhsloc[1 + YYMAXRHS];
           int yynrhs;

-          int yychar_current;
-          YYSTYPE yylval_current;
-          YYLTYPE yylloc_current;
-          yyoption = yys1->yysemantics.yyfirstVal;
-          YYASSERT (yyoption != NULL);
+          yySemanticOption *yyoption = yys1->yysemantics.yyfirstVal;
+          YYASSERT (yyoption != YY_NULL);

           yynrhs = yyrhsLength (yyoption->yyrule);
           if (yynrhs > 0)
             {
           yynrhs = yyrhsLength (yyoption->yyrule);
           if (yynrhs > 0)
             {


@@ -1804,16 +1773,18 @@ yyresolveLocations (yyGLRState* yys1, int yyn1,
               yyGLRState *yyprevious = yyoption->yystate;
               yyrhsloc[0].yystate.yyloc = yyprevious->yyloc;
             }
               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;
+          {
+            int yychar_current = yychar;
+            YYSTYPE yylval_current = yylval;
+            YYLTYPE 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;
+          }

         }
     }
 }]])[
         }
     }
 }]])[


@@ -1829,16 +1800,14 @@ static YYRESULTTAG
 yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp]b4_user_formals[)
 {
   yySemanticOption* yyoptionList = yys->yysemantics.yyfirstVal;
 yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp]b4_user_formals[)
 {
   yySemanticOption* yyoptionList = yys->yysemantics.yyfirstVal;

-  yySemanticOption* yybest;
+  yySemanticOption* yybest = yyoptionList;

   yySemanticOption** yypp;
   yySemanticOption** yypp;

-  yybool yymerge;
+  yybool yymerge = yyfalse;

   YYSTYPE yysval;
   YYSTYPE yysval;

-  YYRESULTTAG yyflag;
-  YYLTYPE *yylocp = &yys->yyloc;
+  YYRESULTTAG yyflag;]b4_locations_if([
+  YYLTYPE *yylocp = &yys->yyloc;])[

 
 

-  yybest = yyoptionList;
-  yymerge = yyfalse;
-  for (yypp = &yyoptionList->yynext; *yypp != NULL; )
+  for (yypp = &yyoptionList->yynext; *yypp != YY_NULL; )

     {
       yySemanticOption* yyp = *yypp;
 
     {
       yySemanticOption* yyp = *yypp;
 


@@ -1878,22 +1847,20 @@ yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp]b4_user_formals[)
     {
       yySemanticOption* yyp;
       int yyprec = yydprec[yybest->yyrule];
     {
       yySemanticOption* yyp;
       int yyprec = yydprec[yybest->yyrule];

-      yyflag = yyresolveAction (yybest, yystackp, &yysval,
-                                yylocp]b4_user_args[);
+      yyflag = yyresolveAction (yybest, yystackp, &yysval]b4_locuser_args[);

       if (yyflag == yyok)
       if (yyflag == yyok)

-        for (yyp = yybest->yynext; yyp != NULL; yyp = yyp->yynext)
+        for (yyp = yybest->yynext; yyp != YY_NULL; yyp = yyp->yynext)

           {
             if (yyprec == yydprec[yyp->yyrule])
               {
           {
             if (yyprec == yydprec[yyp->yyrule])
               {

-                YYSTYPE yysval_other;
-                YYLTYPE yydummy;
-                yyflag = yyresolveAction (yyp, yystackp, &yysval_other,
-                                          &yydummy]b4_user_args[);
+                YYSTYPE yysval_other;]b4_locations_if([
+                YYLTYPE yydummy;])[
+                yyflag = yyresolveAction (yyp, yystackp, &yysval_other]b4_locuser_args([&yydummy])[);

                 if (yyflag != yyok)
                   {
                     yydestruct ("Cleanup: discarding incompletely merged value for",
                                 yystos[yys->yylrState],
                 if (yyflag != yyok)
                   {
                     yydestruct ("Cleanup: discarding incompletely merged value for",
                                 yystos[yys->yylrState],

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

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


@@ -1901,7 +1868,7 @@ yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp]b4_user_formals[)
           }
     }
   else
           }
     }
   else

-    yyflag = yyresolveAction (yybest, yystackp, &yysval, yylocp]b4_user_args[);
+    yyflag = yyresolveAction (yybest, yystackp, &yysval]b4_locuser_args([yylocp])[);

 
   if (yyflag == yyok)
     {
 
   if (yyflag == yyok)
     {


@@ -1909,14 +1876,14 @@ yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp]b4_user_formals[)
       yys->yysemantics.yysval = yysval;
     }
   else
       yys->yysemantics.yysval = yysval;
     }
   else

-    yys->yysemantics.yyfirstVal = NULL;
+    yys->yysemantics.yyfirstVal = YY_NULL;

   return yyflag;
 }
 
 static YYRESULTTAG
 yyresolveStack (yyGLRStack* yystackp]b4_user_formals[)
 {
   return yyflag;
 }
 
 static YYRESULTTAG
 yyresolveStack (yyGLRStack* yystackp]b4_user_formals[)
 {

-  if (yystackp->yysplitPoint != NULL)
+  if (yystackp->yysplitPoint != YY_NULL)

     {
       yyGLRState* yys;
       int yyn;
     {
       yyGLRState* yys;
       int yyn;


@@ -1936,10 +1903,10 @@ yycompressStack (yyGLRStack* yystackp)
 {
   yyGLRState* yyp, *yyq, *yyr;
 
 {
   yyGLRState* yyp, *yyq, *yyr;
 

-  if (yystackp->yytops.yysize != 1 || yystackp->yysplitPoint == NULL)
+  if (yystackp->yytops.yysize != 1 || yystackp->yysplitPoint == YY_NULL)

     return;
 
     return;
 

-  for (yyp = yystackp->yytops.yystates[0], yyq = yyp->yypred, yyr = NULL;
+  for (yyp = yystackp->yytops.yystates[0], yyq = yyp->yypred, yyr = YY_NULL;

        yyp != yystackp->yysplitPoint;
        yyr = yyp, yyp = yyq, yyq = yyp->yypred)
     yyp->yypred = yyr;
        yyp != yystackp->yysplitPoint;
        yyr = yyp, yyp = yyq, yyq = yyp->yypred)
     yyp->yypred = yyr;


@@ -1947,10 +1914,10 @@ yycompressStack (yyGLRStack* yystackp)
   yystackp->yyspaceLeft += yystackp->yynextFree - yystackp->yyitems;
   yystackp->yynextFree = ((yyGLRStackItem*) yystackp->yysplitPoint) + 1;
   yystackp->yyspaceLeft -= yystackp->yynextFree - yystackp->yyitems;
   yystackp->yyspaceLeft += yystackp->yynextFree - yystackp->yyitems;
   yystackp->yynextFree = ((yyGLRStackItem*) yystackp->yysplitPoint) + 1;
   yystackp->yyspaceLeft -= yystackp->yynextFree - yystackp->yyitems;

-  yystackp->yysplitPoint = NULL;
-  yystackp->yylastDeleted = NULL;
+  yystackp->yysplitPoint = YY_NULL;
+  yystackp->yylastDeleted = YY_NULL;

 
 

-  while (yyr != NULL)
+  while (yyr != YY_NULL)

     {
       yystackp->yynextFree->yystate = *yyr;
       yyr = yyr->yypred;
     {
       yystackp->yynextFree->yystate = *yyr;
       yyr = yyr->yypred;


@@ -1965,7 +1932,7 @@ static YYRESULTTAG
 yyprocessOneStack (yyGLRStack* yystackp, size_t yyk,
                    size_t yyposn]b4_pure_formals[)
 {
 yyprocessOneStack (yyGLRStack* yystackp, size_t yyk,
                    size_t yyposn]b4_pure_formals[)
 {

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

     {
       yyStateNum yystate = yystackp->yytops.yystates[yyk]->yylrState;
       YYDPRINTF ((stderr, "Stack %lu Entering state %d\n",
     {
       yyStateNum yystate = yystackp->yytops.yystates[yyk]->yylrState;
       YYDPRINTF ((stderr, "Stack %lu Entering state %d\n",


@@ -2086,14 +2053,14 @@ yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
   yyerror (]b4_lyyerror_args[YY_("syntax error"));
 #else
   yySymbol yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
   yyerror (]b4_lyyerror_args[YY_("syntax error"));
 #else
   yySymbol yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);

-  size_t yysize0 = yytnamerr (NULL, yytokenName (yytoken));
+  size_t yysize0 = yytnamerr (YY_NULL, yytokenName (yytoken));

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

-  char* yymsg = NULL;
+  char* yymsg = YY_NULL;

   enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
   /* Internationalized format string. */
   enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
   /* Internationalized format string. */

-  const char *yyformat = 0;
+  const char *yyformat = YY_NULL;

   /* Arguments of yyformat. */
   char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
   /* Number of reported tokens (one for the "unexpected", one per
   /* Arguments of yyformat. */
   char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
   /* Number of reported tokens (one for the "unexpected", one per


@@ -2148,7 +2115,7 @@ yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
                     break;
                   }
                 yyarg[yycount++] = yytokenName (yyx);
                     break;
                   }
                 yyarg[yycount++] = yytokenName (yyx);

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

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


@@ -2222,7 +2189,7 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
       {
         yySymbol yytoken;
         if (yychar == YYEOF)
       {
         yySymbol yytoken;
         if (yychar == YYEOF)

-          yyFail (yystackp][]b4_lpure_args[, NULL);
+          yyFail (yystackp][]b4_lpure_args[, YY_NULL);

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


@@ -2234,7 +2201,7 @@ 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_locations_if([, &yylloc])[]b4_user_args[);
+                        yytoken, &yylval]b4_locuser_args([&yylloc])[);

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


@@ -2263,10 +2230,10 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
 
   /* Reduce to one stack.  */
   for (yyk = 0; yyk < yystackp->yytops.yysize; yyk += 1)
 
   /* Reduce to one stack.  */
   for (yyk = 0; yyk < yystackp->yytops.yysize; yyk += 1)

-    if (yystackp->yytops.yystates[yyk] != NULL)
+    if (yystackp->yytops.yystates[yyk] != YY_NULL)

       break;
   if (yyk >= yystackp->yytops.yysize)
       break;
   if (yyk >= yystackp->yytops.yysize)

-    yyFail (yystackp][]b4_lpure_args[, NULL);
+    yyFail (yystackp][]b4_lpure_args[, YY_NULL);

   for (yyk += 1; yyk < yystackp->yytops.yysize; yyk += 1)
     yymarkStackDeleted (yystackp, yyk);
   yyremoveDeletes (yystackp);
   for (yyk += 1; yyk < yystackp->yytops.yysize; yyk += 1)
     yymarkStackDeleted (yystackp, yyk);
   yyremoveDeletes (yystackp);


@@ -2274,7 +2241,7 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
 
   /* Now pop stack until we find a state that shifts the error token.  */
   yystackp->yyerrState = 3;
 
   /* Now pop stack until we find a state that shifts the error token.  */
   yystackp->yyerrState = 3;

-  while (yystackp->yytops.yystates[0] != NULL)
+  while (yystackp->yytops.yystates[0] != YY_NULL)

     {
       yyGLRState *yys = yystackp->yytops.yystates[0];
       yyj = yypact[yys->yylrState];
     {
       yyGLRState *yys = yystackp->yytops.yystates[0];
       yyj = yypact[yys->yylrState];


@@ -2284,27 +2251,28 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
           if (0 <= yyj && yyj <= YYLAST && yycheck[yyj] == YYTERROR
               && yyisShiftAction (yytable[yyj]))
             {
           if (0 <= yyj && yyj <= YYLAST && yycheck[yyj] == YYTERROR
               && yyisShiftAction (yytable[yyj]))
             {

-              /* Shift the error token having adjusted its location.  */
-              YYLTYPE yyerrloc;]b4_locations_if([[
+              /* Shift the error token.  */]b4_locations_if([[
+              /* First adjust its location.*/
+              YYLTYPE yyerrloc;

               yystackp->yyerror_range[2].yystate.yyloc = yylloc;
               YYLLOC_DEFAULT (yyerrloc, (yystackp->yyerror_range), 2);]])[
               YY_SYMBOL_PRINT ("Shifting", yystos[yytable[yyj]],
                                &yylval, &yyerrloc);
               yyglrShift (yystackp, 0, yytable[yyj],
               yystackp->yyerror_range[2].yystate.yyloc = yylloc;
               YYLLOC_DEFAULT (yyerrloc, (yystackp->yyerror_range), 2);]])[
               YY_SYMBOL_PRINT ("Shifting", yystos[yytable[yyj]],
                                &yylval, &yyerrloc);
               yyglrShift (yystackp, 0, yytable[yyj],

-                          yys->yyposn, &yylval, &yyerrloc);
+                          yys->yyposn, &yylval]b4_locations_if([, &yyerrloc])[);

               yys = yystackp->yytops.yystates[0];
               break;
             }
               yys = yystackp->yytops.yystates[0];
               break;
             }

-        }
-]b4_locations_if([[      yystackp->yyerror_range[1].yystate.yyloc = yys->yyloc;]])[
-      if (yys->yypred != NULL)
+        }]b4_locations_if([[
+      yystackp->yyerror_range[1].yystate.yyloc = yys->yyloc;]])[
+      if (yys->yypred != YY_NULL)

         yydestroyGLRState ("Error: popping", yys]b4_user_args[);
       yystackp->yytops.yystates[0] = yys->yypred;
       yystackp->yynextFree -= 1;
       yystackp->yyspaceLeft += 1;
     }
         yydestroyGLRState ("Error: popping", yys]b4_user_args[);
       yystackp->yytops.yystates[0] = yys->yypred;
       yystackp->yynextFree -= 1;
       yystackp->yyspaceLeft += 1;
     }

-  if (yystackp->yytops.yystates[0] == NULL)
-    yyFail (yystackp][]b4_lpure_args[, NULL);
+  if (yystackp->yytops.yystates[0] == YY_NULL)
+    yyFail (yystackp][]b4_lpure_args[, YY_NULL);

 }
 
 #define YYCHK1(YYE)                                                          \
 }
 
 #define YYCHK1(YYE)                                                          \


@@ -2361,7 +2329,7 @@ m4_popdef([b4_at_dollar])])dnl
     case 2: goto yyexhaustedlab;
     default: goto yybuglab;
     }
     case 2: goto yyexhaustedlab;
     default: goto yybuglab;
     }

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

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


@@ -2419,7 +2387,7 @@ m4_popdef([b4_at_dollar])])dnl
                   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
                   yychar = YYEMPTY;
                   yyposn += 1;
                   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
                   yychar = YYEMPTY;
                   yyposn += 1;

-                  yyglrShift (&yystack, 0, yyaction, yyposn, &yylval, &yylloc);
+                  yyglrShift (&yystack, 0, yyaction, yyposn, &yylval]b4_locations_if([, &yylloc])[);

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


@@ -2495,7 +2463,7 @@ m4_popdef([b4_at_dollar])])dnl
               YYDPRINTF ((stderr, "On stack %lu, ", (unsigned long int) yys));
               YY_SYMBOL_PRINT ("shifting", yytoken_to_shift, &yylval, &yylloc);
               yyglrShift (&yystack, yys, yyaction, yyposn,
               YYDPRINTF ((stderr, "On stack %lu, ", (unsigned long int) yys));
               YY_SYMBOL_PRINT ("shifting", yytoken_to_shift, &yylval, &yylloc);
               yyglrShift (&yystack, yys, yyaction, yyposn,

-                          &yylval, &yylloc);
+                          &yylval]b4_locations_if([, &yylloc])[);

               YYDPRINTF ((stderr, "Stack %lu now in state #%d\n",
                           (unsigned long int) yys,
                           yystack.yytops.yystates[yys]->yylrState));
               YYDPRINTF ((stderr, "Stack %lu now in state #%d\n",
                           (unsigned long int) yys,
                           yystack.yytops.yystates[yys]->yylrState));


@@ -2535,8 +2503,7 @@ m4_popdef([b4_at_dollar])])dnl
  yyreturn:
   if (yychar != YYEMPTY)
     yydestruct ("Cleanup: discarding lookahead",
  yyreturn:
   if (yychar != YYEMPTY)
     yydestruct ("Cleanup: discarding lookahead",

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

 
   /* 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


@@ -2555,7 +2522,7 @@ m4_popdef([b4_at_dollar])])dnl
                   {
                     yyGLRState *yys = yystates[yyk];
 ]b4_locations_if([[                 yystack.yyerror_range[1].yystate.yyloc = yys->yyloc;]]
                   {
                     yyGLRState *yys = yystates[yyk];
 ]b4_locations_if([[                 yystack.yyerror_range[1].yystate.yyloc = yys->yyloc;]]

-)[                  if (yys->yypred != NULL)
+)[                  if (yys->yypred != YY_NULL)

                       yydestroyGLRState ("Cleanup: popping", yys]b4_user_args[);
                     yystates[yyk] = yys->yypred;
                     yystack.yynextFree -= 1;
                       yydestroyGLRState ("Cleanup: popping", yys]b4_user_args[);
                     yystates[yyk] = yys->yypred;
                     yystack.yynextFree -= 1;


@@ -2592,7 +2559,7 @@ yy_yypstack (yyGLRState* yys)
 static void
 yypstates (yyGLRState* yyst)
 {
 static void
 yypstates (yyGLRState* yyst)
 {

-  if (yyst == NULL)
+  if (yyst == YY_NULL)

     YYFPRINTF (stderr, "<null>");
   else
     yy_yypstack (yyst);
     YYFPRINTF (stderr, "<null>");
   else
     yy_yypstack (yyst);


@@ -2606,7 +2573,7 @@ yypstack (yyGLRStack* yystackp, size_t yyk)
 }
 
 #define YYINDEX(YYX)                                                         \
 }
 
 #define YYINDEX(YYX)                                                         \

-    ((YYX) == NULL ? -1 : (yyGLRStackItem*) (YYX) - yystackp->yyitems)
+    ((YYX) == YY_NULL ? -1 : (yyGLRStackItem*) (YYX) - yystackp->yyitems)

 
 
 static void
 
 
 static void


@@ -2653,15 +2620,12 @@ m4_if(b4_skeleton, ["glr.c"],
 [b4_defines_if(
 [@output(b4_spec_defines_file@)@
 b4_copyright([Skeleton interface for Bison GLR parsers in C],
 [b4_defines_if(
 [@output(b4_spec_defines_file@)@
 b4_copyright([Skeleton interface for Bison GLR parsers in C],

-             [2002-2012])
-
-b4_shared_declarations
-
-b4_pure_if([],
-[[extern YYSTYPE ]b4_prefix[lval;]])
-
-b4_locations_if([b4_pure_if([],
-[extern YYLTYPE ]b4_prefix[lloc;])
-])
-])])[]dnl
+             [2002-2012])[
+
+]b4_cpp_guard_open([b4_spec_defines_file])[
+]b4_shared_declarations[
+]b4_pure_if([], [[extern YYSTYPE ]b4_prefix[lval;
+]b4_locations_if([[extern YYLTYPE ]b4_prefix[lloc;]])])[
+]b4_cpp_guard_close([b4_spec_defines_file])[
+]])])

 m4_divert_pop(0)
 m4_divert_pop(0)