variant: fix G++ 4.4 warnings

[bison.git] / data / glr.c

diff --git a/data/glr.c b/data/glr.c
index d94228ffc70ad2dd875e13e55a07dc94f6656cb0..7ab3823589e99d7f05fa02aa69e70e2737fec23a 100644 (file)
--- a/data/glr.c
+++ b/data/glr.c
@@ -2,7 +2,7 @@
 
 # GLR skeleton for Bison
 
 
 # GLR skeleton for Bison
 

-# Copyright (C) 2002-2012 Free Software Foundation, Inc.
+# Copyright (C) 2002-2013 Free Software Foundation, Inc.

 
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by


@@ -18,7 +18,10 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 

-m4_include(b4_pkgdatadir/[c.m4])
+# If we are loaded by glr.cc, do not override c++.m4 definitions by
+# those of c.m4.
+m4_if(b4_skeleton, ["glr.c"],
+      [m4_include(b4_pkgdatadir/[c.m4])])

 
 ## ---------------- ##
 ## Default values.  ##
 
 ## ---------------- ##
 ## Default values.  ##


@@ -49,17 +52,7 @@ m4_ifndef([b4_pure_flag],
 # This is not shared with yacc.c in c.m4 because  GLR relies on ISO C
 # formal argument declarations.
 m4_define([b4_user_formals],
 # This is not shared with yacc.c in c.m4 because  GLR relies on ISO C
 # formal argument declarations.
 m4_define([b4_user_formals],

-[m4_ifset([b4_parse_param], [, b4_c_ansi_formals(b4_parse_param)])])
-
-
-# b4_lex_param
-# ------------
-# Accumule in b4_lex_param all the yylex arguments.
-# Yes, this is quite ugly...
-m4_define([b4_lex_param],
-m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl
-b4_locations_if([, [[YYLTYPE *], [&yylloc]]])])dnl
-m4_ifdef([b4_lex_param], [, ]b4_lex_param)))
+[m4_ifset([b4_parse_param], [, b4_formals(b4_parse_param)])])

 
 
 # b4_yyerror_args
 
 
 # b4_yyerror_args


@@ -68,7 +61,7 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param)))
 # a trailing comma.
 m4_define([b4_yyerror_args],
 [b4_pure_if([b4_locations_if([yylocp, ])])dnl
 # a trailing comma.
 m4_define([b4_yyerror_args],
 [b4_pure_if([b4_locations_if([yylocp, ])])dnl

-m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
+m4_ifset([b4_parse_param], [b4_args(b4_parse_param), ])])

 
 
 # b4_lyyerror_args
 
 
 # b4_lyyerror_args


@@ -76,7 +69,7 @@ m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
 # Same as above, but on the lookahead, hence &yylloc instead of yylocp.
 m4_define([b4_lyyerror_args],
 [b4_pure_if([b4_locations_if([&yylloc, ])])dnl
 # Same as above, but on the lookahead, hence &yylloc instead of yylocp.
 m4_define([b4_lyyerror_args],
 [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_args(b4_parse_param), ])])

 
 
 # b4_pure_args
 
 
 # b4_pure_args


@@ -93,13 +86,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,84 +155,61 @@ 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.  glr.cc has its own definition.
+m4_if(b4_skeleton, ["glr.c"],
+[m4_define([b4_shared_declarations],
+[b4_declare_yydebug[
+]b4_percent_code_get([[requires]])[
+]b4_token_enums[
+]b4_declare_yylstype[
+]b4_function_declare(b4_prefix[parse], [int], b4_parse_param)[
+]b4_percent_code_get([[provides]])[]dnl
+])
+])

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

-# We do want M4 expansion after # for CPP macros.
-m4_changecom()
-m4_divert_push(0)dnl
-@output(b4_parser_file_name@)@
+b4_output_begin([b4_parser_file_name])

 b4_copyright([Skeleton implementation for Bison GLR parsers in C],
 b4_copyright([Skeleton implementation for Bison GLR parsers in C],

-             [2002-2012])
-[
+             [2002-2013])[
+

 /* C GLR parser skeleton written by Paul Hilfinger.  */
 
 ]b4_identification
 
 /* C GLR parser skeleton written by Paul Hilfinger.  */
 
 ]b4_identification
 

-b4_percent_code_get([[top]])[]dnl
-m4_if(b4_prefix, [yy], [],
-[/* Substitute the variable and function names.  */
-#define yyparse b4_prefix[]parse
-#define yylex   b4_prefix[]lex
-#define yyerror b4_prefix[]error
-#define yylval  b4_prefix[]lval
-#define yychar  b4_prefix[]char
-#define yydebug b4_prefix[]debug
-#define yynerrs b4_prefix[]nerrs
-#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_token_enums(b4_tokens)
-
-[#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_shared_declarations])[
-
-/* Enabling traces.  */
-#ifndef YYDEBUG
-# define YYDEBUG ]b4_parse_trace_if([1], [0])[
-#endif
+b4_percent_code_get([[top]])[
+]m4_if(b4_api_prefix, [yy], [],
+[[/* Substitute the type names.  */
+#define YYSTYPE ]b4_api_PREFIX[STYPE]b4_locations_if([[
+#define YYLTYPE ]b4_api_PREFIX[LTYPE]])])[
+]m4_if(b4_prefix, [yy], [],
+[[/* Substitute the variable and function names.  */
+#define yyparse ]b4_prefix[parse
+#define yylex   ]b4_prefix[lex
+#define yyerror ]b4_prefix[error
+#define yydebug ]b4_prefix[debug
+]]b4_pure_if([], [[
+#define yylval  ]b4_prefix[lval
+#define yychar  ]b4_prefix[char
+#define yynerrs ]b4_prefix[nerrs]b4_locations_if([[
+#define yylloc  ]b4_prefix[lloc]])]))[
+
+/* First part of user declarations.  */
+]b4_user_pre_prologue[
+
+]b4_null_define[
+
+]b4_defines_if([[#include "@basename(]b4_spec_defines_file[@)"]],
+               [b4_shared_declarations])[

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


@@ -235,17 +219,12 @@ b4_defines_if([[#include "@basename(]b4_spec_defines_file[@)"]],
 # define YYERROR_VERBOSE ]b4_error_verbose_if([1], [0])[
 #endif
 
 # define YYERROR_VERBOSE ]b4_error_verbose_if([1], [0])[
 #endif
 

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

 /* Default (constant) value used for initialization for null
 /* Default (constant) value used for initialization for null

-   right-hand sides.  Unlike the standard yacc.c template,
-   here we set the default value of $$ to a zeroed-out value.
-   Since the default value is undefined, this behavior is
-   technically correct.  */
-static YYSTYPE yyval_default;
+   right-hand sides.  Unlike the standard yacc.c template, here we set
+   the default value of $$ to a zeroed-out value.  Since the default
+   value is undefined, this behavior is technically correct.  */
+static YYSTYPE yyval_default;]b4_locations_if([[
+static YYLTYPE yyloc_default][]b4_yyloc_default;])[

 
 /* Copy the second part of user declarations.  */
 ]b4_user_post_prologue
 
 /* Copy the second part of user declarations.  */
 ]b4_user_post_prologue


@@ -259,29 +238,19 @@ b4_percent_code_get[]dnl
 # if defined YYENABLE_NLS && YYENABLE_NLS
 #  if ENABLE_NLS
 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
 # if defined YYENABLE_NLS && YYENABLE_NLS
 #  if ENABLE_NLS
 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */

-#   define YY_(msgid) dgettext ("bison-runtime", msgid)
+#   define YY_(Msgid) dgettext ("bison-runtime", Msgid)

 #  endif
 # endif
 # ifndef YY_
 #  endif
 # endif
 # ifndef YY_

-#  define YY_(msgid) msgid
+#  define YY_(Msgid) Msgid

 # endif
 #endif
 
 /* Suppress unused-variable warnings by "using" E.  */
 # endif
 #endif
 
 /* Suppress unused-variable warnings by "using" E.  */

-#if ! defined lint || defined __GNUC__
-# define YYUSE(e) ((void) (e))
-#else
-# define YYUSE(e) /* empty */
-#endif
-
-/* Identity function, used to suppress warnings about constant conditions.  */
-#ifndef lint
-# define YYID(n) (n)
+#ifdef __GNUC__
+# define YYUSE(E) ((void) (E))

 #else
 #else

-]b4_c_function_def([YYID], [static int], [[int i], [i]])[
-{
-  return i;
-}
+# define YYUSE(E) /* empty */

 #endif
 
 #ifndef YYFREE
 #endif
 
 #ifndef YYFREE


@@ -307,8 +276,9 @@ b4_percent_code_get[]dnl
 #ifndef YYSETJMP
 # include <setjmp.h>
 # define YYJMP_BUF jmp_buf
 #ifndef YYSETJMP
 # include <setjmp.h>
 # define YYJMP_BUF jmp_buf

-# define YYSETJMP(env) setjmp (env)
-# define YYLONGJMP(env, val) longjmp (env, val)
+# define YYSETJMP(Env) setjmp (Env)
+/* Pacify clang.  */
+# define YYLONGJMP(Env, Val) (longjmp (Env, Val), YYASSERT (0))

 #endif
 
 /*-----------------.
 #endif
 
 /*-----------------.


@@ -318,21 +288,13 @@ 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
 

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

 #ifndef YYASSERT
 #ifndef YYASSERT

-# define YYASSERT(condition) ((void) ((condition) || (abort (), 0)))
+# define YYASSERT(Condition) ((void) ((Condition) || (abort (), 0)))

 #endif
 
 /* YYFINAL -- State number of the termination state.  */
 #endif
 
 /* YYFINAL -- State number of the termination state.  */


@@ -367,7 +329,7 @@ static const ]b4_int_type_for([b4_translate])[ yytranslate[] =
   ]b4_translate[
 };
 
   ]b4_translate[
 };
 

-#if YYDEBUG
+#if ]b4_api_PREFIX[DEBUG

 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 static const ]b4_int_type_for([b4_rline])[ yyrline[] =
 {
 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 static const ]b4_int_type_for([b4_rline])[ yyrline[] =
 {


@@ -375,7 +337,7 @@ static const ]b4_int_type_for([b4_rline])[ yyrline[] =
 };
 #endif
 
 };
 #endif
 

-#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
+#if ]b4_api_PREFIX[DEBUG || YYERROR_VERBOSE || ]b4_token_table_flag[

 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
 static const char *const yytname[] =
 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
 static const char *const yytname[] =


@@ -420,66 +382,20 @@ static const ]b4_int_type_for([b4_conflict_list_heads])[ yyconflp[] =
 /* YYCONFL[I] -- lists of conflicting rule numbers, each terminated by
    0, pointed into by YYCONFLP.  */
 ]dnl Do not use b4_int_type_for here, since there are places where
 /* YYCONFL[I] -- lists of conflicting rule numbers, each terminated by
    0, pointed into by YYCONFLP.  */
 ]dnl Do not use b4_int_type_for here, since there are places where

-dnl pointers onto yyconfl are taken, which type is "short int *".
+dnl pointers onto yyconfl are taken, whose type is "short int *".

 dnl We probably ought to introduce a type for confl.
 [static const short int yyconfl[] =
 {
   ]b4_conflicting_rules[
 };
 dnl We probably ought to introduce a type for confl.
 [static const short int yyconfl[] =
 {
   ]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
 

-/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
-   If N is 0, then set CURRENT to the empty location which ends
-   the previous symbol: RHS[0] (always defined).  */
-

 ]b4_locations_if([[
 ]b4_locations_if([[

-#define YYRHSLOC(Rhs, K) ((Rhs)[K].yystate.yyloc)
-#ifndef YYLLOC_DEFAULT
-# define YYLLOC_DEFAULT(Current, Rhs, N)                                \
-    do                                                                  \
-      if (YYID (N))                                                     \
-        {                                                               \
-          (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
-          (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
-          (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
-          (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
-        }                                                               \
-      else                                                              \
-        {                                                               \
-          (Current).first_line   = (Current).last_line   =              \
-            YYRHSLOC (Rhs, 0).last_line;                                \
-          (Current).first_column = (Current).last_column =              \
-            YYRHSLOC (Rhs, 0).last_column;                              \
-        }                                                               \
-    while (YYID (0))
-
-/* YY_LOCATION_PRINT -- Print the location on the stream.
-   This macro was not mandated originally: define only if we know
-   we won't break user code: when these are the locations we know.  */
-
-# define YY_LOCATION_PRINT(File, Loc)                   \
-    fprintf (File, "%d.%d-%d.%d",                       \
-             (Loc).first_line, (Loc).first_column,      \
-             (Loc).last_line,  (Loc).last_column)
-#endif
-]],[
-#ifndef YYLLOC_DEFAULT
-# define YYLLOC_DEFAULT(Current, Rhs, N) ((void) 0)
-#endif
-])[
-
-#ifndef YY_LOCATION_PRINT
-# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
-#endif
-
-
-/* YYLEX -- calling `yylex' with the right arguments.  */
-#define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[
+]b4_yylloc_default_define[
+# define YYRHSLOC(Rhs, K) ((Rhs)[K].yystate.yyloc)
+]])[

 
 ]b4_pure_if(
 [
 
 ]b4_pure_if(
 [


@@ -496,9 +412,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;])[


@@ -513,43 +428,50 @@ typedef enum { yyok, yyaccept, yyabort, yyerr } YYRESULTTAG;
     YYRESULTTAG yychk_flag = YYE;               \
     if (yychk_flag != yyok)                     \
       return yychk_flag;                        \
     YYRESULTTAG yychk_flag = YYE;               \
     if (yychk_flag != yyok)                     \
       return yychk_flag;                        \

-  } while (YYID (0))
+  } while (0)

 
 

-#if YYDEBUG
+#if ]b4_api_PREFIX[DEBUG

 
 # ifndef YYFPRINTF
 #  define YYFPRINTF fprintf
 # endif
 
 
 # ifndef YYFPRINTF
 #  define YYFPRINTF fprintf
 # endif
 

+]b4_yy_location_print_define[
+

 # define YYDPRINTF(Args)                        \
   do {                                          \
     if (yydebug)                                \
       YYFPRINTF Args;                           \
 # define YYDPRINTF(Args)                        \
   do {                                          \
     if (yydebug)                                \
       YYFPRINTF Args;                           \

-  } while (YYID (0))
+  } while (0)

 
 

-]b4_yy_symbol_print_generate([b4_c_ansi_function_def])[
+]b4_yy_symbol_print_define[

 
 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                  \
   do {                                                                  \
     if (yydebug)                                                        \
       {                                                                 \
         YYFPRINTF (stderr, "%s ", Title);                               \
 
 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                  \
   do {                                                                  \
     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");                                       \
       }                                                                 \
         YYFPRINTF (stderr, "\n");                                       \
       }                                                                 \

-  } while (YYID (0))
+  } while (0)

 
 /* Nonzero means print parse trace.  It is left uninitialized so that
    multiple parsers can coexist.  */
 int yydebug;
 
 
 /* Nonzero means print parse trace.  It is left uninitialized so that
    multiple parsers can coexist.  */
 int yydebug;
 

-#else /* !YYDEBUG */
+struct yyGLRStack;
+static void yypstack (struct yyGLRStack* yystackp, size_t yyk)
+  __attribute__ ((__unused__));
+static void yypdumpstack (struct yyGLRStack* yystackp)
+  __attribute__ ((__unused__));
+
+#else /* !]b4_api_PREFIX[DEBUG */

 
 # define YYDPRINTF(Args)
 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
 
 
 # define YYDPRINTF(Args)
 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
 

-#endif /* !YYDEBUG */
+#endif /* !]b4_api_PREFIX[DEBUG */

 
 /* YYINITDEPTH -- initial size of the parser's stacks.  */
 #ifndef YYINITDEPTH
 
 /* YYINITDEPTH -- initial size of the parser's stacks.  */
 #ifndef YYINITDEPTH


@@ -583,13 +505,13 @@ int yydebug;
   do {                                                  \
     if (Yystack->yyspaceLeft < YYHEADROOM)              \
       yyexpandGLRStack (Yystack);                       \
   do {                                                  \
     if (Yystack->yyspaceLeft < YYHEADROOM)              \
       yyexpandGLRStack (Yystack);                       \

-  } while (YYID (0))
+  } while (0)

 #else
 # define YY_RESERVE_GLRSTACK(Yystack)                   \
   do {                                                  \
     if (Yystack->yyspaceLeft < YYHEADROOM)              \
       yyMemoryExhausted (Yystack);                      \
 #else
 # define YY_RESERVE_GLRSTACK(Yystack)                   \
   do {                                                  \
     if (Yystack->yyspaceLeft < YYHEADROOM)              \
       yyMemoryExhausted (Yystack);                      \

-  } while (YYID (0))
+  } while (0)

 #endif
 
 
 #endif
 
 


@@ -702,9 +624,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 +648,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 +670,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 +691,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);
 }


@@ -782,7 +704,7 @@ yyMemoryExhausted (yyGLRStack* yystackp)
   YYLONGJMP (yystackp->yyexception_buffer, 2);
 }
 
   YYLONGJMP (yystackp->yyexception_buffer, 2);
 }
 

-#if YYDEBUG || YYERROR_VERBOSE
+#if ]b4_api_PREFIX[DEBUG || YYERROR_VERBOSE

 /** A printable representation of TOKEN.  */
 static inline const char*
 yytokenName (yySymbol yytoken)
 /** A printable representation of TOKEN.  */
 static inline const char*
 yytokenName (yySymbol yytoken)


@@ -801,12 +723,11 @@ 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)
     {
   for (i = yylow0-1; i >= yylow1; i -= 1)
     {

-#if YYDEBUG
+#if ]b4_api_PREFIX[DEBUG

       yyvsp[i].yystate.yylrState = s->yylrState;
 #endif
       yyvsp[i].yystate.yyresolved = s->yyresolved;
       yyvsp[i].yystate.yylrState = s->yylrState;
 #endif
       yyvsp[i].yystate.yyresolved = s->yyresolved;


@@ -815,8 +736,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;
     }
 }


@@ -842,18 +763,17 @@ yyfill (yyGLRStackItem *yyvsp, int *yylow, int yylow1, yybool yynormal)
  *  value ($$), and yylocp points to place for location information
  *  (@@$).  Returns yyok for normal return, yyaccept for YYACCEPT,
  *  yyerr for YYERROR, yyabort for YYABORT.  */
  *  value ($$), and yylocp points to place for location information
  *  (@@$).  Returns yyok for normal return, yyaccept for YYACCEPT,
  *  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[)
+static YYRESULTTAG
+yyuserAction (yyRuleNum yyn, size_t yyrhslen, yyGLRStackItem* yyvsp,
+              yyGLRStack* yystackp,
+              YYSTYPE* yyvalp]b4_locuser_formals[)

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

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

   int yylow;
   int yylow;

-]b4_parse_param_use[]dnl
-[# undef yyerrok
+]b4_parse_param_use([yyvalp], [yylocp])dnl
+[  YYUSE (yyrhslen);
+# undef yyerrok

 # define yyerrok (yystackp->yyerrState = 0)
 # undef YYACCEPT
 # define YYACCEPT return yyaccept
 # define yyerrok (yystackp->yyerrState = 0)
 # undef YYACCEPT
 # define YYACCEPT return yyaccept


@@ -876,9 +796,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)
     {


@@ -895,9 +815,9 @@ yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,
 # undef yyclearin
 # undef YYRECOVERING
 }
 # undef yyclearin
 # undef YYRECOVERING
 }

-\f

 
 

-/*ARGSUSED*/ static void
+
+static void

 yyuserMerge (int yyn, YYSTYPE* yy0, YYSTYPE* yy1)
 {
   YYUSE (yy0);
 yyuserMerge (int yyn, YYSTYPE* yy0, YYSTYPE* yy1)
 {
   YYUSE (yy0);


@@ -905,14 +825,14 @@ yyuserMerge (int yyn, YYSTYPE* yy0, YYSTYPE* yy1)
 
   switch (yyn)
     {
 
   switch (yyn)
     {

-      ]b4_mergers[
+]b4_mergers[

       default: break;
     }
 }
 
                               /* Bison grammar-table manipulation.  */
 
       default: break;
     }
 }
 
                               /* Bison grammar-table manipulation.  */
 

-]b4_yydestruct_generate([b4_c_ansi_function_def])[
+]b4_yydestruct_define[

 
 /** Number of symbols composing the right hand side of rule #RULE.  */
 static inline int
 
 /** Number of symbols composing the right hand side of rule #RULE.  */
 static inline int


@@ -926,10 +846,10 @@ 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
     {
   else
     {

-#if YYDEBUG
+#if ]b4_api_PREFIX[DEBUG

       if (yydebug)
         {
           if (yys->yysemantics.yyfirstVal)
       if (yydebug)
         {
           if (yys->yysemantics.yyfirstVal)


@@ -937,7 +857,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


@@ -962,8 +882,8 @@ yylhsNonterm (yyRuleNum yyrule)
   return yyr1[yyrule];
 }
 
   return yyr1[yyrule];
 }
 

-#define yypact_value_is_default(yystate) \
-  ]b4_table_value_equals([[pact]], [[yystate]], [b4_pact_ninf])[
+#define yypact_value_is_default(Yystate) \
+  ]b4_table_value_equals([[pact]], [[Yystate]], [b4_pact_ninf])[

 
 /** True iff LR state YYSTATE has only a default reduction (regardless
  *  of token).  */
 
 /** True iff LR state YYSTATE has only a default reduction (regardless
  *  of token).  */


@@ -980,8 +900,8 @@ yydefaultAction (yyStateNum yystate)
   return yydefact[yystate];
 }
 
   return yydefact[yystate];
 }
 

-#define yytable_value_is_error(yytable_value) \
-  ]b4_table_value_equals([[table]], [[yytable_value]], [b4_table_ninf])[
+#define yytable_value_is_error(Yytable_value) \
+  ]b4_table_value_equals([[table]], [[Yytable_value]], [b4_table_ninf])[

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


@@ -1068,8 +988,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 +1010,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 +1040,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 +1060,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 +1080,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 +1126,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 +1134,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 +1145,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 +1160,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 +1195,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 +1203,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,34 +1223,34 @@ 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.  */
   yyaddDeferredAction (yystackp, yyk, yynewState, yyrhs, yyrule);
 }
 
   yystackp->yytops.yystates[yyk] = yynewState;
 
   /* Invokes YY_RESERVE_GLRSTACK.  */
   yyaddDeferredAction (yystackp, yyk, yynewState, yyrhs, yyrule);
 }
 

-#if !YYDEBUG
+#if !]b4_api_PREFIX[DEBUG

 # define YY_REDUCE_PRINT(Args)
 #else
 # define YY_REDUCE_PRINT(Args)          \
 do {                                    \
   if (yydebug)                          \
     yy_reduce_print Args;               \
 # define YY_REDUCE_PRINT(Args)
 #else
 # define YY_REDUCE_PRINT(Args)          \
 do {                                    \
   if (yydebug)                          \
     yy_reduce_print Args;               \

-} while (YYID (0))
+} while (0)

 
 /*----------------------------------------------------------------------.
 | Report that stack #YYK of *YYSTACKP is going to be reduced by YYRULE. |
 `----------------------------------------------------------------------*/
 
 
 /*----------------------------------------------------------------------.
 | Report that stack #YYK of *YYSTACKP is going to be reduced by YYRULE. |
 `----------------------------------------------------------------------*/
 

-/*ARGSUSED*/ static inline void
-yy_reduce_print (int yynormal, yyGLRStackItem* yyvsp, size_t yyk, yyRuleNum yyrule]b4_user_formals[)
+static inline void
+yy_reduce_print (int yynormal, yyGLRStackItem* yyvsp, size_t yyk,
+                 yyRuleNum yyrule]b4_user_formals[)

 {
   int yynrhs = yyrhsLength (yyrule);]b4_locations_if([
   int yylow = 1;])[
   int yyi;
 {
   int yynrhs = yyrhsLength (yyrule);]b4_locations_if([
   int yylow = 1;])[
   int yyi;

-]b4_parse_param_use[]dnl
-[  YYFPRINTF (stderr, "Reducing stack %lu by rule %d (line %lu):\n",
+  YYFPRINTF (stderr, "Reducing stack %lu by rule %d (line %lu):\n",

              (unsigned long int) yyk, yyrule - 1,
              (unsigned long int) yyrline[yyrule]);
   if (! yynormal)
              (unsigned long int) yyk, yyrule - 1,
              (unsigned long int) yyrline[yyrule]);
   if (! yynormal)


@@ -1359,11 +1279,11 @@ yy_reduce_print (int yynormal, yyGLRStackItem* yyvsp, size_t yyk, yyRuleNum yyru
  *  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 +1292,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 +1314,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 +1335,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 +1353,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
     {


@@ -1452,13 +1371,14 @@ yyglrReduce (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
       yyupdateSplit (yystackp, yys);
       yynewLRState = yyLRgotoState (yys->yylrState, yylhsNonterm (yyrule));
       YYDPRINTF ((stderr,
       yyupdateSplit (yystackp, yys);
       yynewLRState = yyLRgotoState (yys->yylrState, yylhsNonterm (yyrule));
       YYDPRINTF ((stderr,

-                  "Reduced stack %lu by rule #%d; action deferred.  Now in state %d.\n",
+                  "Reduced stack %lu by rule #%d; action deferred.  "
+                  "Now in state %d.\n",

                   (unsigned long int) yyk, yyrule - 1, yynewLRState));
       for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1)
                   (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)


@@ -1482,7 +1402,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];


@@ -1492,7 +1412,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])))


@@ -1503,7 +1423,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;
 


@@ -1511,7 +1431,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;
     }


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

-          yySemanticOption** yyz0p;
-          yySemanticOption* yyz1;
-          yyz0p = &yys0->yysemantics.yyfirstVal;
-          yyz1 = yys1->yysemantics.yyfirstVal;
-          while (YYID (yytrue))
+          yySemanticOption** yyz0p = &yys0->yysemantics.yyfirstVal;
+          yySemanticOption* yyz1 = yys1->yysemantics.yyfirstVal;
+          while (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;


@@ -1653,17 +1571,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;


@@ -1676,22 +1589,24 @@ 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;
 }
 

-#if YYDEBUG
+#if ]b4_api_PREFIX[DEBUG

 static void
 yyreportTree (yySemanticOption* yyx, int yyindent)
 {
 static void
 yyreportTree (yySemanticOption* yyx, int yyindent)
 {


@@ -1703,7 +1618,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;


@@ -1726,10 +1641,10 @@ yyreportTree (yySemanticOption* yyx, int yyindent)
         {
           if (yystates[yyi-1]->yyposn+1 > yystates[yyi]->yyposn)
             YYFPRINTF (stderr, "%*s%s <empty>\n", yyindent+2, "",
         {
           if (yystates[yyi-1]->yyposn+1 > yystates[yyi]->yyposn)
             YYFPRINTF (stderr, "%*s%s <empty>\n", yyindent+2, "",

-                       yytokenName (yystos[yystates[yyi-1]->yylrState]));
+                       yytokenName (yystos[yystates[yyi]->yylrState]));

           else
             YYFPRINTF (stderr, "%*s%s <tokens %lu .. %lu>\n", yyindent+2, "",
           else
             YYFPRINTF (stderr, "%*s%s <tokens %lu .. %lu>\n", yyindent+2, "",

-                       yytokenName (yystos[yystates[yyi-1]->yylrState]),
+                       yytokenName (yystos[yystates[yyi]->yylrState]),

                        (unsigned long int) (yystates[yyi-1]->yyposn + 1),
                        (unsigned long int) yystates[yyi]->yyposn);
         }
                        (unsigned long int) (yystates[yyi-1]->yyposn + 1),
                        (unsigned long int) yystates[yyi]->yyposn);
         }


@@ -1739,14 +1654,14 @@ yyreportTree (yySemanticOption* yyx, int yyindent)
 }
 #endif
 
 }
 #endif
 

-/*ARGSUSED*/ static YYRESULTTAG
+static YYRESULTTAG

 yyreportAmbiguity (yySemanticOption* yyx0,
                    yySemanticOption* yyx1]b4_pure_formals[)
 {
   YYUSE (yyx0);
   YYUSE (yyx1);
 
 yyreportAmbiguity (yySemanticOption* yyx0,
                    yySemanticOption* yyx1]b4_pure_formals[)
 {
   YYUSE (yyx0);
   YYUSE (yyx1);
 

-#if YYDEBUG
+#if ]b4_api_PREFIX[DEBUG

   YYFPRINTF (stderr, "Ambiguity detected.\n");
   YYFPRINTF (stderr, "Option 1,\n");
   yyreportTree (yyx0, 2);
   YYFPRINTF (stderr, "Ambiguity detected.\n");
   YYFPRINTF (stderr, "Option 1,\n");
   yyreportTree (yyx0, 2);


@@ -1771,14 +1686,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)
             {


@@ -1803,16 +1714,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;
+          }

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


@@ -1828,16 +1741,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;
 


@@ -1877,22 +1788,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);


@@ -1900,7 +1809,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)
     {


@@ -1908,14 +1817,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;


@@ -1935,10 +1844,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;


@@ -1946,10 +1855,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;


@@ -1964,7 +1873,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",


@@ -1986,7 +1895,9 @@ yyprocessOneStack (yyGLRStack* yystackp, size_t yyk,
           yyflag = yyglrReduce (yystackp, yyk, yyrule, yyimmediate[yyrule]]b4_user_args[);
           if (yyflag == yyerr)
             {
           yyflag = yyglrReduce (yystackp, yyk, yyrule, yyimmediate[yyrule]]b4_user_args[);
           if (yyflag == yyerr)
             {

-              YYDPRINTF ((stderr, "Stack %lu dies (predicate failure or explicit user error).\n",
+              YYDPRINTF ((stderr,
+                          "Stack %lu dies "
+                          "(predicate failure or explicit user error).\n",

                           (unsigned long int) yyk));
               yymarkStackDeleted (yystackp, yyk);
               return yyok;
                           (unsigned long int) yyk));
               yymarkStackDeleted (yystackp, yyk);
               return yyok;


@@ -2004,7 +1915,7 @@ yyprocessOneStack (yyGLRStack* yystackp, size_t yyk,
           if (yychar == YYEMPTY)
             {
               YYDPRINTF ((stderr, "Reading a token: "));
           if (yychar == YYEMPTY)
             {
               YYDPRINTF ((stderr, "Reading a token: "));

-              yychar = YYLEX;
+              yychar = ]b4_lex[;

             }
 
           if (yychar <= YYEOF)
             }
 
           if (yychar <= YYEOF)


@@ -2059,7 +1970,9 @@ yyprocessOneStack (yyGLRStack* yystackp, size_t yyk,
                                                 yyimmediate[-yyaction]]b4_user_args[);
               if (yyflag == yyerr)
                 {
                                                 yyimmediate[-yyaction]]b4_user_args[);
               if (yyflag == yyerr)
                 {

-                  YYDPRINTF ((stderr, "Stack %lu dies (predicate failure or explicit user error).\n",
+                  YYDPRINTF ((stderr,
+                              "Stack %lu dies "
+                              "(predicate failure or explicit user error).\n",

                               (unsigned long int) yyk));
                   yymarkStackDeleted (yystackp, yyk);
                   break;
                               (unsigned long int) yyk));
                   yymarkStackDeleted (yystackp, yyk);
                   break;


@@ -2072,7 +1985,7 @@ yyprocessOneStack (yyGLRStack* yystackp, size_t yyk,
   return yyok;
 }
 
   return yyok;
 }
 

-/*ARGSUSED*/ static void
+static void

 yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
 {
   if (yystackp->yyerrState != 0)
 yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
 {
   if (yystackp->yyerrState != 0)


@@ -2080,15 +1993,15 @@ yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
 #if ! YYERROR_VERBOSE
   yyerror (]b4_lyyerror_args[YY_("syntax error"));
 #else
 #if ! YYERROR_VERBOSE
   yyerror (]b4_lyyerror_args[YY_("syntax error"));
 #else

+  {

   yySymbol yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
   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 yysize = yysize0;

-  size_t yysize1;

   yybool yysize_overflow = yyfalse;
   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


@@ -2143,9 +2056,11 @@ yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
                     break;
                   }
                 yyarg[yycount++] = yytokenName (yyx);
                     break;
                   }
                 yyarg[yycount++] = yytokenName (yyx);

-                yysize1 = yysize + yytnamerr (NULL, yytokenName (yyx));
-                yysize_overflow |= yysize1 < yysize;
-                yysize = yysize1;
+                {
+                  size_t yysz = yysize + yytnamerr (YY_NULL, yytokenName (yyx));
+                  yysize_overflow |= yysz < yysize;
+                  yysize = yysz;
+                }

               }
         }
     }
               }
         }
     }


@@ -2165,9 +2080,11 @@ yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
 #undef YYCASE_
     }
 
 #undef YYCASE_
     }
 

-  yysize1 = yysize + strlen (yyformat);
-  yysize_overflow |= yysize1 < yysize;
-  yysize = yysize1;
+  {
+    size_t yysz = yysize + strlen (yyformat);
+    yysize_overflow |= yysz < yysize;
+    yysize = yysz;
+  }

 
   if (!yysize_overflow)
     yymsg = (char *) YYMALLOC (yysize);
 
   if (!yysize_overflow)
     yymsg = (char *) YYMALLOC (yysize);


@@ -2197,6 +2114,7 @@ yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
       yyerror (]b4_lyyerror_args[YY_("syntax error"));
       yyMemoryExhausted (yystackp);
     }
       yyerror (]b4_lyyerror_args[YY_("syntax error"));
       yyMemoryExhausted (yystackp);
     }

+  }

 #endif /* YYERROR_VERBOSE */
   yynerrs += 1;
 }
 #endif /* YYERROR_VERBOSE */
   yynerrs += 1;
 }


@@ -2204,7 +2122,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
    of the lookahead.  */
 /* Recover from a syntax error on *YYSTACKP, assuming that *YYSTACKP->YYTOKENP,
    yylval, and yylloc are the syntactic category, semantic value, and location
    of the lookahead.  */

-/*ARGSUSED*/ static void
+static void

 yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
 {
   size_t yyk;
 yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
 {
   size_t yyk;


@@ -2213,11 +2131,11 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
   if (yystackp->yyerrState == 3)
     /* We just shifted the error token and (perhaps) took some
        reductions.  Skip tokens until we can proceed.  */
   if (yystackp->yyerrState == 3)
     /* We just shifted the error token and (perhaps) took some
        reductions.  Skip tokens until we can proceed.  */

-    while (YYID (yytrue))
+    while (yytrue)

       {
         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


@@ -2229,10 +2147,10 @@ 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: "));
           }
         YYDPRINTF ((stderr, "Reading a token: "));

-        yychar = YYLEX;
+        yychar = ]b4_lex[;

         if (yychar <= YYEOF)
           {
             yychar = yytoken = YYEOF;
         if (yychar <= YYEOF)
           {
             yychar = yytoken = YYEOF;


@@ -2258,10 +2176,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);


@@ -2269,7 +2187,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];


@@ -2279,27 +2197,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)                                                          \


@@ -2316,13 +2235,13 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
     default:                                                                 \
       goto yybuglab;                                                         \
     }                                                                        \
     default:                                                                 \
       goto yybuglab;                                                         \
     }                                                                        \

-  } while (YYID (0))
+  } while (0)

 
 /*----------.
 | yyparse.  |
 `----------*/
 
 
 /*----------.
 | yyparse.  |
 `----------*/
 

-]b4_c_ansi_function_def([yyparse], [int], b4_parse_param)[
+]b4_function_define([yyparse], [int], b4_parse_param)[

 {
   int yyresult;
   yyGLRStack yystack;
 {
   int yyresult;
   yyGLRStack yystack;


@@ -2332,20 +2251,13 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
   YYDPRINTF ((stderr, "Starting parse\n"));
 
   yychar = YYEMPTY;
   YYDPRINTF ((stderr, "Starting parse\n"));
 
   yychar = YYEMPTY;

-  yylval = yyval_default;
-]b4_locations_if([
-#if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
-  yylloc.first_line   = yylloc.last_line   = ]b4_location_initial_line[;
-  yylloc.first_column = yylloc.last_column = ]b4_location_initial_column[;
-#endif
-])
-m4_ifdef([b4_initial_action], [
-m4_pushdef([b4_at_dollar],     [yylloc])dnl
-m4_pushdef([b4_dollar_dollar], [yylval])dnl
+  yylval = yyval_default;]b4_locations_if([
+  yylloc = yyloc_default;])[
+]m4_ifdef([b4_initial_action], [
+b4_dollar_pushdef([yylval], [], [yylloc])dnl

   /* User initialization code.  */
   b4_user_initial_action
   /* User initialization code.  */
   b4_user_initial_action

-m4_popdef([b4_dollar_dollar])dnl
-m4_popdef([b4_at_dollar])])dnl
+b4_dollar_popdef])[]dnl

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


@@ -2356,16 +2268,16 @@ 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;
 
   yyposn = 0;
 

-  while (YYID (yytrue))
+  while (yytrue)

     {
       /* For efficiency, we have two loops, the first of which is
          specialized to deterministic operation (single stack, no
          potential ambiguity).  */
       /* Standard mode */
     {
       /* For efficiency, we have two loops, the first of which is
          specialized to deterministic operation (single stack, no
          potential ambiguity).  */
       /* Standard mode */

-      while (YYID (yytrue))
+      while (yytrue)

         {
           yyRuleNum yyrule;
           int yyaction;
         {
           yyRuleNum yyrule;
           int yyaction;


@@ -2392,7 +2304,7 @@ m4_popdef([b4_at_dollar])])dnl
               if (yychar == YYEMPTY)
                 {
                   YYDPRINTF ((stderr, "Reading a token: "));
               if (yychar == YYEMPTY)
                 {
                   YYDPRINTF ((stderr, "Reading a token: "));

-                  yychar = YYLEX;
+                  yychar = ]b4_lex[;

                 }
 
               if (yychar <= YYEOF)
                 }
 
               if (yychar <= YYEOF)


@@ -2414,7 +2326,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;
                 }


@@ -2429,7 +2341,7 @@ m4_popdef([b4_at_dollar])])dnl
             }
         }
 
             }
         }
 

-      while (YYID (yytrue))
+      while (yytrue)

         {
           yySymbol yytoken_to_shift;
           size_t yys;
         {
           yySymbol yytoken_to_shift;
           size_t yys;


@@ -2490,7 +2402,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));


@@ -2530,8 +2442,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


@@ -2550,7 +2461,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;


@@ -2562,16 +2473,11 @@ m4_popdef([b4_at_dollar])])dnl
       yyfreeGLRStack (&yystack);
     }
 
       yyfreeGLRStack (&yystack);
     }
 

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

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

-#if YYDEBUG
-static void yypstack (yyGLRStack* yystackp, size_t yyk)
-  __attribute__ ((__unused__));
-static void yypdumpstack (yyGLRStack* yystackp) __attribute__ ((__unused__));
-
+#if ]b4_api_PREFIX[DEBUG

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


@@ -2587,7 +2493,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);


@@ -2601,7 +2507,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


@@ -2640,23 +2546,35 @@ yypdumpstack (yyGLRStack* yystackp)
   YYFPRINTF (stderr, "\n");
 }
 #endif
   YYFPRINTF (stderr, "\n");
 }
 #endif

+
+#undef yylval
+#undef yychar
+#undef yynerrs]b4_locations_if([
+#undef yylloc])
+
+m4_if(b4_prefix, [yy], [],
+[[/* Substitute the variable and function names.  */
+#define yyparse ]b4_prefix[parse
+#define yylex   ]b4_prefix[lex
+#define yyerror ]b4_prefix[error
+#define yylval  ]b4_prefix[lval
+#define yychar  ]b4_prefix[char
+#define yydebug ]b4_prefix[debug
+#define yynerrs ]b4_prefix[nerrs]b4_locations_if([[
+#define yylloc  ]b4_prefix[lloc]])])[
+

 ]b4_epilogue[]dnl
 ]b4_epilogue[]dnl

-dnl
-dnl glr.cc produces its own header.
-dnl
+b4_output_end()
+
+# glr.cc produces its own header.

 m4_if(b4_skeleton, ["glr.c"],
 [b4_defines_if(
 m4_if(b4_skeleton, ["glr.c"],
 [b4_defines_if(

-[@output(b4_spec_defines_file@)@
+[b4_output_begin([b4_spec_defines_file])

 b4_copyright([Skeleton interface for Bison GLR parsers in C],
 b4_copyright([Skeleton interface for Bison GLR parsers in C],

-             [2002-2012])
-
-b4_shared_declarations
+             [2002-2013])[

 
 

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