tests: fix maintainer-xml-check for recent changes.

[bison.git] / data / yacc.c

diff --git a/data/yacc.c b/data/yacc.c
index 75c194f5ff334c29e88fd9ff7047bdc318e2dcae..4274673d95fbc0f569a92aae96fc048360557356 100644 (file)
--- a/data/yacc.c
+++ b/data/yacc.c
@@ -1,26 +1,42 @@
-m4_divert(-1)                                                       -*- C -*-
-m4_include([c.m4])
+                                                             -*- C -*-

 
 # Yacc compatible skeleton for Bison
 
 # Yacc compatible skeleton for Bison

-# Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002
-# Free Software Foundation, Inc.

 
 

-# This program is free software; you can redistribute it and/or modify
+# Copyright (C) 1984, 1989-1990, 2000-2010 Free Software Foundation,
+# Inc.
+
+# This program is free software: you can redistribute it and/or modify

 # it under the terms of the GNU General Public License as published by
 # it under the terms of the GNU General Public License as published by

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

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

-
+#

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

-
+#

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

-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-# 02111-1307  USA
-
-
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# Check the value of %define api.push-pull.
+b4_percent_define_default([[api.push-pull]], [[pull]])
+b4_percent_define_check_values([[[[api.push-pull]],
+                                 [[pull]], [[push]], [[both]]]])
+b4_define_flag_if([pull]) m4_define([b4_pull_flag], [[1]])
+b4_define_flag_if([push]) m4_define([b4_push_flag], [[1]])
+m4_case(b4_percent_define_get([[api.push-pull]]),
+        [pull], [m4_define([b4_push_flag], [[0]])],
+        [push], [m4_define([b4_pull_flag], [[0]])])
+
+# Handle BISON_USE_PUSH_FOR_PULL for the test suite.  So that push parsing
+# tests function as written, don't let BISON_USE_PUSH_FOR_PULL modify Bison's
+# behavior at all when push parsing is already requested.
+b4_define_flag_if([use_push_for_pull])
+b4_use_push_for_pull_if([
+  b4_push_if([m4_define([b4_use_push_for_pull_flag], [[0]])],
+             [m4_define([b4_push_flag], [[1]])])])
+
+m4_include(b4_pkgdatadir/[c.m4])

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


@@ -30,15 +46,63 @@ m4_include([c.m4])
 m4_define_default([b4_stack_depth_max], [10000])
 m4_define_default([b4_stack_depth_init],  [200])
 
 m4_define_default([b4_stack_depth_max], [10000])
 m4_define_default([b4_stack_depth_init],  [200])
 

-# Location type.
-m4_define_default([b4_location_type], [yyltype])

 
 

-# Accumule in b4_lex_param all the yylex arguments.
-# Yes, this is quite ugly...
+## ------------------------ ##
+## Pure/impure interfaces.  ##
+## ------------------------ ##
+
+b4_percent_define_default([[api.pure]], [[false]])
+b4_define_flag_if([pure])
+m4_define([b4_pure_flag],
+          [b4_percent_define_flag_if([[api.pure]], [[1]], [[0]])])
+
+# b4_yacc_pure_if(IF-TRUE, IF-FALSE)
+# ----------------------------------
+# Expand IF-TRUE, if %pure-parser and %parse-param, IF-FALSE otherwise.
+m4_define([b4_yacc_pure_if],
+[b4_pure_if([m4_ifset([b4_parse_param],
+                     [$1], [$2])],
+           [$2])])
+
+
+# b4_yyerror_args
+# ---------------
+# Arguments passed to yyerror: user args plus yylloc.
+m4_define([b4_yyerror_args],
+[b4_yacc_pure_if([b4_locations_if([&yylloc, ])])dnl
+m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
+
+
+# b4_lex_param
+# ------------
+# Accumulate in b4_lex_param all the yylex arguments.
+# b4_lex_param arrives quoted twice, but we want to keep only one level.

 m4_define([b4_lex_param],
 m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl
 m4_define([b4_lex_param],
 m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl

-b4_location_if([, [[YYLTYPE *], [&yylloc]]])])dnl
-m4_ifdef([b4_lex_param], [, ]b4_lex_param)))
+b4_locations_if([, [[YYLTYPE *], [&yylloc]]])m4_ifdef([b4_lex_param], [, ])])dnl
+m4_ifdef([b4_lex_param], b4_lex_param)))
+
+
+## ------------ ##
+## Data Types.  ##
+## ------------ ##
+
+# b4_int_type(MIN, MAX)
+# ---------------------
+# Return the smallest int type able to handle numbers ranging from
+# MIN to MAX (included).  Overwrite the version from c.m4, which
+# uses only C89 types, so that the user can override the shorter
+# types, and so that pre-C89 compilers are handled correctly.
+m4_define([b4_int_type],
+[m4_if(b4_ints_in($@,      [0],   [255]), [1], [yytype_uint8],
+       b4_ints_in($@,   [-128],   [127]), [1], [yytype_int8],
+
+       b4_ints_in($@,      [0], [65535]), [1], [yytype_uint16],
+       b4_ints_in($@, [-32768], [32767]), [1], [yytype_int16],
+
+       m4_eval([0 <= $1]),                [1], [unsigned int],
+
+                                              [int])])

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


@@ -50,7 +114,7 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param)))
 # --------------------
 # Expansion of $<TYPE>$.
 m4_define([b4_lhs_value],
 # --------------------
 # Expansion of $<TYPE>$.
 m4_define([b4_lhs_value],

-[yyval[]m4_ifval([$1], [.$1])])
+[(yyval[]m4_ifval([$1], [.$1]))])

 
 
 # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
 
 
 # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])


@@ -58,7 +122,7 @@ m4_define([b4_lhs_value],
 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
 # symbols on RHS.
 m4_define([b4_rhs_value],
 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
 # symbols on RHS.
 m4_define([b4_rhs_value],

-[yyvsp@<:@m4_eval([$2 - $1])@:>@m4_ifval([$3], [.$3])])
+[(yyvsp@{($2) - ($1)@}m4_ifval([$3], [.$3]))])

 
 
 
 
 
 


@@ -70,7 +134,7 @@ m4_define([b4_rhs_value],
 # -----------------
 # Expansion of @$.
 m4_define([b4_lhs_location],
 # -----------------
 # Expansion of @$.
 m4_define([b4_lhs_location],

-[yyloc])
+[(yyloc)])

 
 
 # b4_rhs_location(RULE-LENGTH, NUM)
 
 
 # b4_rhs_location(RULE-LENGTH, NUM)


@@ -78,69 +142,85 @@ m4_define([b4_lhs_location],
 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
 # on RHS.
 m4_define([b4_rhs_location],
 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
 # on RHS.
 m4_define([b4_rhs_location],

-[yylsp@<:@m4_eval([$2 - $1])@:>@])
+[(yylsp@{($2) - ($1)@})])

 
 
 
 

+## ------------------ ##
+## Parser variables.  ##
+## ------------------ ##

 
 

-## ------------------- ##
-## Output file names.  ##
-## ------------------- ##
+# b4_declare_scanner_communication_variables
+# ------------------------------------------
+# Declare the variables that are global, or local to YYPARSE if
+# pure-parser.
+m4_define([b4_declare_scanner_communication_variables], [[
+/* The lookahead symbol.  */
+int yychar;

 
 

-m4_define_default([b4_input_suffix], [.y])
+/* The semantic value of the lookahead symbol.  */
+YYSTYPE yylval;]b4_locations_if([[

 
 

-m4_define_default([b4_output_parser_suffix],
-[m4_translit(b4_input_suffix, [yY], [cC])])
+/* Location data for the lookahead symbol.  */
+YYLTYPE yylloc;]])b4_pure_if([], [[

 
 

-m4_define_default([b4_output_parser_name],
-[b4_output_prefix[]b4_output_infix[]b4_output_parser_suffix[]])
+/* Number of syntax errors so far.  */
+int yynerrs;]])])

 
 
 
 

-m4_define_default([b4_output_header_suffix],
-[m4_translit(b4_input_suffix, [yY], [hH])])
+# b4_declare_parser_state_variables
+# ---------------------------------
+# Declare all the variables that are needed to maintain the parser state
+# between calls to yypush_parse.
+m4_define([b4_declare_parser_state_variables], [b4_pure_if([[
+    /* Number of syntax errors so far.  */
+    int yynerrs;
+]])[
+    int yystate;
+    /* Number of tokens to shift before error messages enabled.  */
+    int yyerrstatus;

 
 

-m4_define_default([b4_output_header_name],
-[b4_output_prefix[]b4_output_infix[]b4_output_header_suffix[]])
+    /* The stacks and their tools:
+       `yyss': related to states.
+       `yyvs': related to semantic values.]b4_locations_if([[
+       `yyls': related to locations.]])[

 
 

-m4_define_default([b4_header_guard],
-                  [m4_bpatsubst(m4_toupper([BISON_]b4_output_header_name),
-                                [[^ABCDEFGHIJKLMNOPQRSTUVWXYZ]], [_])])
+       Refer to the stacks thru separate pointers, to allow yyoverflow
+       to reallocate them elsewhere.  */

 
 

+    /* The state stack.  */
+    yytype_int16 yyssa[YYINITDEPTH];
+    yytype_int16 *yyss;
+    yytype_int16 *yyssp;

 
 

+    /* The semantic value stack.  */
+    YYSTYPE yyvsa[YYINITDEPTH];
+    YYSTYPE *yyvs;
+    YYSTYPE *yyvsp;]b4_locations_if([[

 
 

-## --------------------------------------------------------- ##
-## Defining symbol actions, e.g., printers and destructors.  ##
-## --------------------------------------------------------- ##
+    /* The location stack.  */
+    YYLTYPE yylsa[YYINITDEPTH];
+    YYLTYPE *yyls;
+    YYLTYPE *yylsp;

 
 

-# b4_symbol_actions(FILENAME, LINENO,
-#                   SYMBOL-TAG, SYMBOL-NUM,
-#                   SYMBOL-ACTION, SYMBOL-TYPENAME)
-# -------------------------------------------------
-m4_define([b4_symbol_actions],
-[m4_pushdef([b4_dollar_dollar], [yyvalue.$6])dnl
-m4_pushdef([b4_at_dollar], [yylocation])dnl
-      case $4: /* $3 */
-#line $2 "$1"
-        $5;
-#line __oline__ "__ofile__"
-        break;
-m4_popdef([b4_at_dollar])dnl
-m4_popdef([b4_dollar_dollar])dnl
-])
+    /* The locations where the error started and ended.  */
+    YYLTYPE yyerror_range[2];]])[

 
 

+    YYSIZE_T yystacksize;]])

 
 
 
 

-m4_divert(0)dnl
-#output "b4_output_parser_name"
-b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
-             [1984, 1989, 1990, 2000, 2001, 2002])
+## --------------------------------------------------------- ##
+## Defining symbol actions, e.g., printers and destructors.  ##
+## --------------------------------------------------------- ##

 
 

-/* As a special exception, when this file is copied by Bison into a
-   Bison output file, you may use that output file without restriction.
-   This special exception was added by the Free Software Foundation
-   in version 1.24 of Bison.  */
+# We do want M4 expansion after # for CPP macros.
+m4_changecom()
+m4_divert_push(0)dnl
+@output(b4_parser_file_name@)@
+b4_copyright([Skeleton implementation for Bison's Yacc-like parsers in C],
+             [1984, 1989-1990, 2000-2010])[

 
 

-/* Written by Richard Stallman by simplifying the original so called
-   ``semantic'' parser.  */
+/* C LALR(1) parser skeleton written by Richard Stallman, by
+   simplifying the original so-called "semantic" parser.  */

 
 /* All symbols defined below should begin with yy or YY, to avoid
    infringing on user name space.  This should be done even for local
 
 /* All symbols defined below should begin with yy or YY, to avoid
    infringing on user name space.  This should be done even for local


@@ -149,35 +229,30 @@ b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
    define necessary library symbols; they are noted "INFRINGES ON
    USER NAME SPACE" below.  */
 
    define necessary library symbols; they are noted "INFRINGES ON
    USER NAME SPACE" below.  */
 

-/* Identify Bison output.  */
-#define YYBISON        1
-
-/* Pure parsers.  */
-#define YYPURE b4_pure
-
-/* Using locations.  */
-#define YYLSP_NEEDED b4_locations_flag
-
-m4_if(b4_prefix[], [yy], [],
-[/* If NAME_PREFIX is specified substitute the variables and functions
-   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_location_if([#define yylloc b4_prefix[]lloc])])
-
-b4_token_defines(b4_tokens)
+]b4_identification
+b4_percent_code_get([[top]])[]dnl
+m4_if(b4_prefix, [yy], [],
+[[/* Substitute the variable and function names.  */]b4_pull_if([[
+#define yyparse         ]b4_prefix[parse]])b4_push_if([[
+#define yypush_parse    ]b4_prefix[push_parse]b4_pull_if([[
+#define yypull_parse    ]b4_prefix[pull_parse]])[
+#define yypstate_new    ]b4_prefix[pstate_new
+#define yypstate_delete ]b4_prefix[pstate_delete
+#define yypstate        ]b4_prefix[pstate]])[
+#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]])])[

 
 /* Copy the first part of user declarations.  */
 
 /* Copy the first part of user declarations.  */

-b4_pre_prologue
+]b4_user_pre_prologue[

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

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

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


@@ -185,111 +260,256 @@ b4_pre_prologue
 # undef YYERROR_VERBOSE
 # define YYERROR_VERBOSE 1
 #else
 # undef YYERROR_VERBOSE
 # define YYERROR_VERBOSE 1
 #else

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

 #endif
 
 #endif
 

-#ifndef YYSTYPE
-m4_ifdef([b4_stype],
-[#line b4_stype_line "b4_filename"
-typedef union b4_stype yystype;
-/* Line __line__ of __file__.  */
-#line __oline__ "__ofile__"],
-[typedef int yystype;])
-# define YYSTYPE yystype
-# define YYSTYPE_IS_TRIVIAL 1
+/* Enabling the token table.  */
+#ifndef YYTOKEN_TABLE
+# define YYTOKEN_TABLE ]b4_token_table[

 #endif
 
 #endif
 

-#ifndef YYLTYPE
-typedef struct yyltype
+]b4_percent_code_get([[requires]])[]dnl
+
+b4_token_enums_defines(b4_tokens)[
+
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+]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]])])[
+# define yystype YYSTYPE /* obsolescent; will be withdrawn */
+# define YYSTYPE_IS_DECLARED 1
+#endif]b4_locations_if([[
+
+#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
+typedef struct YYLTYPE

 {
   int first_line;
   int first_column;
   int last_line;
   int last_column;
 {
   int first_line;
   int first_column;
   int last_line;
   int last_column;

-} yyltype;
-# define YYLTYPE b4_location_type
+} YYLTYPE;
+# define yyltype YYLTYPE /* obsolescent; will be withdrawn */
+# define YYLTYPE_IS_DECLARED 1

 # define YYLTYPE_IS_TRIVIAL 1
 # define YYLTYPE_IS_TRIVIAL 1

+#endif]])b4_push_if([[
+
+#ifndef YYPUSH_DECLS
+#  define YYPUSH_DECLS
+struct yypstate;
+typedef struct yypstate yypstate;
+enum { YYPUSH_MORE = 4 };
+
+]b4_pull_if([b4_c_function_decl([[yyparse]], [[int]], b4_parse_param)
+])b4_c_function_decl([[yypush_parse]], [[int]],
+  [[[yypstate *yyps]], [[yyps]]]b4_pure_if([,
+  [[[int yypushed_char]], [[yypushed_char]]],
+  [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
+  [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [,
+  b4_parse_param]))
+b4_pull_if([b4_c_function_decl([[yypull_parse]], [[int]],
+  [[[yypstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [,
+  b4_parse_param]))])
+b4_c_function_decl([[yypstate_new]], [[yypstate *]], [[[void]], []])
+b4_c_function_decl([[yypstate_delete]], [[void]],
+                   [[[yypstate *yyps]], [[yyps]]])[
+#endif]])
+
+b4_percent_code_get([[provides]])[]dnl
+
+[/* Copy the second part of user declarations.  */
+]b4_user_post_prologue
+b4_percent_code_get[]dnl
+
+[#ifdef short
+# undef short

 #endif
 
 #endif
 

-/* Copy the second part of user declarations.  */
-b4_post_prologue
+#ifdef YYTYPE_UINT8
+typedef YYTYPE_UINT8 yytype_uint8;
+#else
+typedef unsigned char yytype_uint8;
+#endif

 
 

-/* Line __line__ of __file__.  */
-#line __oline__ "__ofile__"
+#ifdef YYTYPE_INT8
+typedef YYTYPE_INT8 yytype_int8;
+#elif ]b4_c_modern[
+typedef signed char yytype_int8;
+#else
+typedef short int yytype_int8;
+#endif

 
 

-#if ! defined (yyoverflow) || YYERROR_VERBOSE
+#ifdef YYTYPE_UINT16
+typedef YYTYPE_UINT16 yytype_uint16;
+#else
+typedef unsigned short int yytype_uint16;
+#endif

 
 

-/* The parser invokes alloca or malloc; define the necessary symbols.  */
+#ifdef YYTYPE_INT16
+typedef YYTYPE_INT16 yytype_int16;
+#else
+typedef short int yytype_int16;
+#endif

 
 

-# if YYSTACK_USE_ALLOCA
-#  define YYSTACK_ALLOC alloca
+#ifndef YYSIZE_T
+# ifdef __SIZE_TYPE__
+#  define YYSIZE_T __SIZE_TYPE__
+# elif defined size_t
+#  define YYSIZE_T size_t
+# elif ! defined YYSIZE_T && ]b4_c_modern[
+#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+#  define YYSIZE_T size_t

 # else
 # else

-#  ifndef YYSTACK_USE_ALLOCA
-#   if defined (alloca) || defined (_ALLOCA_H)
-#    define YYSTACK_ALLOC alloca
+#  define YYSIZE_T unsigned int
+# endif
+#endif
+
+#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
+
+#ifndef YY_
+# if defined YYENABLE_NLS && YYENABLE_NLS
+#  if ENABLE_NLS
+#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
+#   define YY_(msgid) dgettext ("bison-runtime", msgid)
+#  endif
+# endif
+# ifndef YY_
+#  define YY_(msgid) msgid
+# 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)
+#else
+]b4_c_function_def([YYID], [static int], [[int yyi], [yyi]])[
+{
+  return yyi;
+}
+#endif
+
+#if ! defined yyoverflow || YYERROR_VERBOSE
+
+]b4_push_if([],
+[[/* The parser invokes alloca or malloc; define the necessary symbols.  */
+
+# ifdef YYSTACK_USE_ALLOCA
+#  if YYSTACK_USE_ALLOCA
+#   ifdef __GNUC__
+#    define YYSTACK_ALLOC __builtin_alloca
+#   elif defined __BUILTIN_VA_ARG_INCR
+#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
+#   elif defined _AIX
+#    define YYSTACK_ALLOC __alloca
+#   elif defined _MSC_VER
+#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
+#    define alloca _alloca

 #   else
 #   else

-#    ifdef __GNUC__
-#     define YYSTACK_ALLOC __builtin_alloca
+#    define YYSTACK_ALLOC alloca
+#    if ! defined _ALLOCA_H && ! defined _STDLIB_H && ]b4_c_modern[
+#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+#     ifndef _STDLIB_H
+#      define _STDLIB_H 1
+#     endif

 #    endif
 #   endif
 #  endif
 # endif
 
 #    endif
 #   endif
 #  endif
 # endif
 

-# ifdef YYSTACK_ALLOC
-   /* Pacify GCC's `empty if-body' warning. */
-#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
+]])dnl
+[# ifdef YYSTACK_ALLOC
+   /* Pacify GCC's `empty if-body' warning.  */
+#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+    /* The OS might guarantee only one guard page at the bottom of the stack,
+       and a page size can be as small as 4096 bytes.  So we cannot safely
+       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
+       to allow for a few compiler-allocated temporary stack slots.  */
+#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
+#  endif

 # else
 # else

-#  if defined (__STDC__) || defined (__cplusplus)
+#  define YYSTACK_ALLOC YYMALLOC
+#  define YYSTACK_FREE YYFREE
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
+#  endif
+#  if (defined __cplusplus && ! defined _STDLIB_H \
+       && ! ((defined YYMALLOC || defined malloc) \
+            && (defined YYFREE || defined free)))

 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */

-#   define YYSIZE_T size_t
+#   ifndef _STDLIB_H
+#    define _STDLIB_H 1
+#   endif
+#  endif
+#  ifndef YYMALLOC
+#   define YYMALLOC malloc
+#   if ! defined malloc && ! defined _STDLIB_H && ]b4_c_modern[
+void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+#  ifndef YYFREE
+#   define YYFREE free
+#   if ! defined free && ! defined _STDLIB_H && ]b4_c_modern[
+void free (void *); /* INFRINGES ON USER NAME SPACE */
+#   endif

 #  endif
 #  endif

-#  define YYSTACK_ALLOC malloc
-#  define YYSTACK_FREE free

 # endif
 # endif

-#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
+#endif /* ! defined yyoverflow || YYERROR_VERBOSE */

 
 
 
 

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

 
 /* A type that is properly aligned for any stack member.  */
 union yyalloc
 {
 
 /* A type that is properly aligned for any stack member.  */
 union yyalloc
 {

-  short yyss;
-  YYSTYPE yyvs;
-  b4_location_if([  YYLTYPE yyls;
-])dnl
+  yytype_int16 yyss_alloc;
+  YYSTYPE yyvs_alloc;]b4_locations_if([
+  YYLTYPE yyls_alloc;])[

 };
 
 /* The size of the maximum gap between one aligned stack and the next.  */
 };
 
 /* The size of the maximum gap between one aligned stack and the next.  */

-# define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1)
+# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)

 
 /* The size of an array large to enough to hold all stacks, each with
    N elements.  */
 
 /* The size of an array large to enough to hold all stacks, each with
    N elements.  */

-b4_location_if(
+]b4_locations_if(

 [# define YYSTACK_BYTES(N) \
 [# define YYSTACK_BYTES(N) \

-     ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE))     \
-      + 2 * YYSTACK_GAP_MAX)],
+     ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
+      + 2 * YYSTACK_GAP_MAXIMUM)],

 [# define YYSTACK_BYTES(N) \
 [# define YYSTACK_BYTES(N) \

-     ((N) * (sizeof (short) + sizeof (YYSTYPE))                                \
-      + YYSTACK_GAP_MAX)])
+     ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
+      + YYSTACK_GAP_MAXIMUM)])[

 
 /* Copy COUNT objects from FROM to TO.  The source and destination do
    not overlap.  */
 # ifndef YYCOPY
 
 /* Copy COUNT objects from FROM to TO.  The source and destination do
    not overlap.  */
 # ifndef YYCOPY

-#  if 1 < __GNUC__
+#  if defined __GNUC__ && 1 < __GNUC__

 #   define YYCOPY(To, From, Count) \
       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
 #  else
 #   define YYCOPY(To, From, Count)             \
       do                                       \
        {                                       \
 #   define YYCOPY(To, From, Count) \
       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
 #  else
 #   define YYCOPY(To, From, Count)             \
       do                                       \
        {                                       \

-         register YYSIZE_T yyi;                \
+         YYSIZE_T yyi;                         \

          for (yyi = 0; yyi < (Count); yyi++)   \
          for (yyi = 0; yyi < (Count); yyi++)   \

-           (To)[[yyi]] = (From)[[yyi]];        \
+           (To)[yyi] = (From)[yyi];            \

        }                                       \
        }                                       \

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

 #  endif
 # endif
 
 #  endif
 # endif
 


@@ -298,182 +518,176 @@ b4_location_if(
    elements in the stack, and YYPTR gives the new location of the
    stack.  Advance YYPTR to a properly aligned location for the next
    stack.  */
    elements in the stack, and YYPTR gives the new location of the
    stack.  Advance YYPTR to a properly aligned location for the next
    stack.  */

-# define YYSTACK_RELOCATE(Stack)                                       \
+# define YYSTACK_RELOCATE(Stack_alloc, Stack)                          \

     do                                                                 \
       {                                                                        \
        YYSIZE_T yynewbytes;                                            \
     do                                                                 \
       {                                                                        \
        YYSIZE_T yynewbytes;                                            \

-       YYCOPY (&yyptr->Stack, Stack, yysize);                          \
-       Stack = &yyptr->Stack;                                          \
-       yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX;   \
+       YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
+       Stack = &yyptr->Stack_alloc;                                    \
+       yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \

        yyptr += yynewbytes / sizeof (*yyptr);                          \
       }                                                                        \
        yyptr += yynewbytes / sizeof (*yyptr);                          \
       }                                                                        \

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

 
 #endif
 
 
 #endif
 

-#if defined (__STDC__) || defined (__cplusplus)
-   typedef signed char yysigned_char;
-#else
-   typedef short yysigned_char;
-#endif
-
-/* YYFINAL -- State number of the termination state. */
-#define YYFINAL  b4_final_state_number
-#define YYLAST   b4_last
+/* YYFINAL -- State number of the termination state.  */
+#define YYFINAL  ]b4_final_state_number[
+/* YYLAST -- Last index in YYTABLE.  */
+#define YYLAST   ]b4_last[

 
 

-/* YYNTOKENS -- Number of terminals. */
-#define YYNTOKENS  b4_tokens_number
-/* YYNNTS -- Number of nonterminals. */
-#define YYNNTS  b4_nterms_number
-/* YYNRULES -- Number of rules. */
-#define YYNRULES  b4_rules_number
-/* YYNRULES -- Number of states. */
-#define YYNSTATES  b4_states_number
+/* YYNTOKENS -- Number of terminals.  */
+#define YYNTOKENS  ]b4_tokens_number[
+/* YYNNTS -- Number of nonterminals.  */
+#define YYNNTS  ]b4_nterms_number[
+/* YYNRULES -- Number of rules.  */
+#define YYNRULES  ]b4_rules_number[
+/* YYNRULES -- Number of states.  */
+#define YYNSTATES  ]b4_states_number[

 
 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 
 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */

-#define YYUNDEFTOK  b4_undef_token_number
-#define YYMAXUTOK   b4_user_token_number_max
+#define YYUNDEFTOK  ]b4_undef_token_number[
+#define YYMAXUTOK   ]b4_user_token_number_max[

 
 

-#define YYTRANSLATE(X) \
-  ((unsigned)(X) <= YYMAXUTOK ? yytranslate[[X]] : YYUNDEFTOK)
+#define YYTRANSLATE(YYX)                                               \
+  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)

 
 

-/* YYTRANSLATE[[YYLEX]] -- Bison symbol number corresponding to YYLEX.  */
-static const b4_int_type_for([b4_translate]) yytranslate[[]] =
+/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
+static const ]b4_int_type_for([b4_translate])[ yytranslate[] =

 {
 {

-  b4_translate
+  ]b4_translate[

 };
 
 #if YYDEBUG
 };
 
 #if YYDEBUG

-/* YYPRHS[[YYN]] -- Index of the first RHS symbol of rule number YYN in
+/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in

    YYRHS.  */
    YYRHS.  */

-static const b4_int_type_for([b4_prhs]) yyprhs[[]] =
+static const ]b4_int_type_for([b4_prhs])[ yyprhs[] =

 {
 {

-  b4_prhs
+  ]b4_prhs[

 };
 
 };
 

-/* YYRHS -- A `-1'-separated list of the rules' RHS. */
-static const b4_int_type_for([b4_rhs]) yyrhs[[]] =
+/* YYRHS -- A `-1'-separated list of the rules' RHS.  */
+static const ]b4_int_type_for([b4_rhs])[ yyrhs[] =

 {
 {

-  b4_rhs
+  ]b4_rhs[

 };
 
 };
 

-/* 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[] =

 {
 {

-  b4_rline
+  ]b4_rline[

 };
 #endif
 
 };
 #endif
 

-#if YYDEBUG || YYERROR_VERBOSE
-/* YYTNME[[SYMBOL-NUM]] -- String name of the symbol SYMBOL-NUM.
-   First, the terminals, then, starting at YYNTOKENS, nonterminals. */
-static const char *const yytname[[]] =
+#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
+/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
+   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
+static const char *const yytname[] =

 {
 {

-  b4_tname
+  ]b4_tname[

 };
 #endif
 
 # ifdef YYPRINT
 };
 #endif
 
 # ifdef YYPRINT

-/* YYTOKNUM[[YYLEX-NUM]] -- Internal token number corresponding to
+/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to

    token YYLEX-NUM.  */
    token YYLEX-NUM.  */

-static const b4_int_type_for([b4_toknum]) yytoknum[[]] =
+static const ]b4_int_type_for([b4_toknum])[ yytoknum[] =

 {
 {

-  b4_toknum
+  ]b4_toknum[

 };
 # endif
 
 };
 # endif
 

-/* YYR1[[YYN]] -- Symbol number of symbol that rule YYN derives.  */
-static const b4_int_type_for([b4_r1]) yyr1[[]] =
+/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
+static const ]b4_int_type_for([b4_r1])[ yyr1[] =

 {
 {

-  b4_r1
+  ]b4_r1[

 };
 
 };
 

-/* YYR2[[YYN]] -- Number of symbols composing right hand side of rule YYN.  */
-static const b4_int_type_for([b4_r2]) yyr2[[]] =
+/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
+static const ]b4_int_type_for([b4_r2])[ yyr2[] =

 {
 {

-  b4_r2
+  ]b4_r2[

 };
 
 };
 

-/* YYDEFACT[[STATE-NAME]] -- Default rule to reduce with in state
-   STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
+/* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
+   Performed when YYTABLE doesn't specify something else to do.  Zero

    means the default is an error.  */
    means the default is an error.  */

-static const b4_int_type_for([b4_defact]) yydefact[[]] =
+static const ]b4_int_type_for([b4_defact])[ yydefact[] =

 {
 {

-  b4_defact
+  ]b4_defact[

 };
 
 };
 

-/* YYDEFGOTO[[NTERM-NUM]]. */
-static const b4_int_type_for([b4_defgoto]) yydefgoto[[]] =
+/* YYDEFGOTO[NTERM-NUM].  */
+static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] =

 {
 {

-  b4_defgoto
+  ]b4_defgoto[

 };
 
 };
 

-/* YYPACT[[STATE-NUM]] -- Index in YYTABLE of the portion describing
+/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing

    STATE-NUM.  */
    STATE-NUM.  */

-#define YYPACT_NINF b4_pact_ninf
-static const b4_int_type_for([b4_pact]) yypact[[]] =
+#define YYPACT_NINF ]b4_pact_ninf[
+static const ]b4_int_type_for([b4_pact])[ yypact[] =

 {
 {

-  b4_pact
+  ]b4_pact[

 };
 
 };
 

-/* YYPGOTO[[NTERM-NUM]].  */
-static const b4_int_type_for([b4_pgoto]) yypgoto[[]] =
+/* YYPGOTO[NTERM-NUM].  */
+static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] =

 {
 {

-  b4_pgoto
+  ]b4_pgoto[

 };
 
 };
 

-/* YYTABLE[[YYPACT[STATE-NUM]]].  What to do in state STATE-NUM.  If
+/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If

    positive, shift that token.  If negative, reduce the rule which
    positive, shift that token.  If negative, reduce the rule which

-   number is the opposite.  If zero, do what YYDEFACT says.
-   If YYTABLE_NINF, parse error.  */
-#define YYTABLE_NINF b4_table_ninf
-static const b4_int_type_for([b4_table]) yytable[[]] =
+   number is the opposite.  If YYTABLE_NINF, syntax error.  */
+#define YYTABLE_NINF ]b4_table_ninf[
+static const ]b4_int_type_for([b4_table])[ yytable[] =

 {
 {

-  b4_table
+  ]b4_table[

 };
 
 };
 

-static const b4_int_type_for([b4_check]) yycheck[[]] =
+#define yypact_value_is_default(yystate) \
+  ]b4_table_value_equals([[pact]], [[yystate]], [b4_pact_ninf])[
+
+#define yytable_value_is_error(yytable_value) \
+  ]b4_table_value_equals([[table]], [[yytable_value]], [b4_table_ninf])[
+
+static const ]b4_int_type_for([b4_check])[ yycheck[] =

 {
 {

-  b4_check
+  ]b4_check[

 };
 
 };
 

-/* YYSTOS[[STATE-NUM]] -- The (internal number of the) accessing
+/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing

    symbol of state STATE-NUM.  */
    symbol of state STATE-NUM.  */

-static const b4_int_type_for([b4_stos]) yystos[[]] =
+static const ]b4_int_type_for([b4_stos])[ yystos[] =

 {
 {

-  b4_stos
+  ]b4_stos[

 };
 
 };
 

-#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
-# define YYSIZE_T __SIZE_TYPE__
-#endif
-#if ! defined (YYSIZE_T) && defined (size_t)
-# define YYSIZE_T size_t
-#endif
-#if ! defined (YYSIZE_T)
-# if defined (__STDC__) || defined (__cplusplus)
-#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
-#  define YYSIZE_T size_t
-# endif
-#endif
-#if ! defined (YYSIZE_T)
-# define YYSIZE_T unsigned int
-#endif
-

 #define yyerrok                (yyerrstatus = 0)
 #define yyclearin      (yychar = YYEMPTY)
 #define yyerrok                (yyerrstatus = 0)
 #define yyclearin      (yychar = YYEMPTY)

-#define YYEMPTY                -2
+#define YYEMPTY                (-2)

 #define YYEOF          0
 
 #define YYACCEPT       goto yyacceptlab
 #define YYABORT                goto yyabortlab
 #define YYEOF          0
 
 #define YYACCEPT       goto yyacceptlab
 #define YYABORT                goto yyabortlab

-#define YYERROR                goto yyerrlab1
+#define YYERROR                goto yyerrorlab
+

 
 /* Like YYERROR except do call yyerror.  This remains here temporarily
    to ease the transition to the new meaning of YYERROR, for GCC.
 
 /* Like YYERROR except do call yyerror.  This remains here temporarily
    to ease the transition to the new meaning of YYERROR, for GCC.

-   Once GCC version 2 has supplanted version 1, this can go.  */
+   Once GCC version 2 has supplanted version 1, this can go.  However,
+   YYFAIL appears to be in use.  Nevertheless, it is formally deprecated
+   in Bison 2.4.2's NEWS entry, where a plan to phase it out is
+   discussed.  */

 
 #define YYFAIL         goto yyerrlab
 
 #define YYFAIL         goto yyerrlab

+#if defined YYFAIL
+  /* This is here to suppress warnings from the GCC cpp's
+     -Wunused-macros.  Normally we don't worry about that warning, but
+     some users do, and we want to make it easy for users to remove
+     YYFAIL uses, which will produce warnings from Bison 2.5.  */
+#endif

 
 #define YYRECOVERING()  (!!yyerrstatus)
 
 
 #define YYRECOVERING()  (!!yyerrstatus)
 


@@ -483,37 +697,76 @@ do                                                                \
     {                                                          \
       yychar = (Token);                                                \
       yylval = (Value);                                                \
     {                                                          \
       yychar = (Token);                                                \
       yylval = (Value);                                                \

-      yychar1 = YYTRANSLATE (yychar);                          \
-      YYPOPSTACK;                                              \
+      YYPOPSTACK (1);                                          \

       goto yybackup;                                           \
     }                                                          \
   else                                                         \
       goto yybackup;                                           \
     }                                                          \
   else                                                         \

-    {                                                          \
-      yyerror ("syntax error: cannot back up");                        \
+    {                                                          \
+      yyerror (]b4_yyerror_args[YY_("syntax error: cannot back up")); \

       YYERROR;                                                 \
     }                                                          \
       YYERROR;                                                 \
     }                                                          \

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

 
 #define YYTERROR       1
 #define YYERRCODE      256
 
 
 #define YYTERROR       1
 #define YYERRCODE      256
 

-/* YYLLOC_DEFAULT -- Compute the default location (before the actions
-   are run).  */

 
 

+/* 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).  */
+
+#define YYRHSLOC(Rhs, K) ((Rhs)[K])

 #ifndef YYLLOC_DEFAULT
 #ifndef YYLLOC_DEFAULT

-# define YYLLOC_DEFAULT(Current, Rhs, N)           \
-  Current.first_line   = Rhs[[1]].first_line;      \
-  Current.first_column = Rhs[[1]].first_column;    \
-  Current.last_line    = Rhs[[N]].last_line;       \
-  Current.last_column  = Rhs[[N]].last_column;
-#endif
+# 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))
+#endif]b4_locations_if([[
+
+
+/* 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.  */
+
+#ifndef YY_LOCATION_PRINT
+# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
+#  define YY_LOCATION_PRINT(File, Loc)                 \
+     fprintf (File, "%d.%d-%d.%d",                     \
+             (Loc).first_line, (Loc).first_column,     \
+             (Loc).last_line,  (Loc).last_column)
+# else
+#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
+# endif
+#endif]], [[
+
+
+/* This macro is provided for backward compatibility. */
+
+#ifndef YY_LOCATION_PRINT
+# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
+#endif]])[
+

 
 /* YYLEX -- calling `yylex' with the right arguments.  */
 
 #ifdef YYLEX_PARAM
 
 /* YYLEX -- calling `yylex' with the right arguments.  */
 
 #ifdef YYLEX_PARAM

-# define YYLEX yylex (b4_pure_if([&yylval[]b4_location_if([, &yylloc]), ])YYLEX_PARAM)
+# define YYLEX yylex (]b4_pure_if([&yylval[]b4_locations_if([, &yylloc]), ])[YYLEX_PARAM)

 #else
 #else

-# define YYLEX b4_c_function_call([yylex], [int], b4_lex_param)
+# define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[

 #endif
 
 /* Enable debugging if requested.  */
 #endif
 
 /* Enable debugging if requested.  */


@@ -528,38 +781,104 @@ while (0)
 do {                                           \
   if (yydebug)                                 \
     YYFPRINTF Args;                            \
 do {                                           \
   if (yydebug)                                 \
     YYFPRINTF Args;                            \

-} while (0)
-# define YYDSYMPRINT(Args)                     \
-do {                                           \
-  if (yydebug)                                 \
-    yysymprint Args;                           \
-} while (0)
+} while (YYID (0))
+
+# 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[); \
+      YYFPRINTF (stderr, "\n");                                                  \
+    }                                                                    \
+} while (YYID (0))
+
+]b4_yy_symbol_print_generate([b4_c_function_def])[
+
+/*------------------------------------------------------------------.
+| yy_stack_print -- Print the state stack from its BOTTOM up to its |
+| TOP (included).                                                   |
+`------------------------------------------------------------------*/
+
+]b4_c_function_def([yy_stack_print], [static void],
+                  [[yytype_int16 *yybottom], [yybottom]],
+                  [[yytype_int16 *yytop],    [yytop]])[
+{
+  YYFPRINTF (stderr, "Stack now");
+  for (; yybottom <= yytop; yybottom++)
+    {
+      int yybot = *yybottom;
+      YYFPRINTF (stderr, " %d", yybot);
+    }
+  YYFPRINTF (stderr, "\n");
+}
+
+# define YY_STACK_PRINT(Bottom, Top)                           \
+do {                                                           \
+  if (yydebug)                                                 \
+    yy_stack_print ((Bottom), (Top));                          \
+} while (YYID (0))
+
+
+/*------------------------------------------------.
+| Report that the YYRULE is going to be reduced.  |
+`------------------------------------------------*/
+
+]b4_c_function_def([yy_reduce_print], [static void],
+                  [[YYSTYPE *yyvsp], [yyvsp]],
+    b4_locations_if([[[YYLTYPE *yylsp], [yylsp]],
+                  ])[[int yyrule], [yyrule]]m4_ifset([b4_parse_param], [,
+                  b4_parse_param]))[
+{
+  int yynrhs = yyr2[yyrule];
+  int yyi;
+  unsigned long int yylno = yyrline[yyrule];
+  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
+            yyrule - 1, yylno);
+  /* The symbols being reduced.  */
+  for (yyi = 0; yyi < yynrhs; yyi++)
+    {
+      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
+      yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
+                      &]b4_rhs_value(yynrhs, yyi + 1)[
+                      ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl
+                      b4_user_args[);
+      YYFPRINTF (stderr, "\n");
+    }
+}
+
+# define YY_REDUCE_PRINT(Rule)         \
+do {                                   \
+  if (yydebug)                         \
+    yy_reduce_print (yyvsp, ]b4_locations_if([yylsp, ])[Rule]b4_user_args[); \
+} while (YYID (0))
+

 /* Nonzero means print parse trace.  It is left uninitialized so that
    multiple parsers can coexist.  */
 int yydebug;
 #else /* !YYDEBUG */
 # define YYDPRINTF(Args)
 /* Nonzero means print parse trace.  It is left uninitialized so that
    multiple parsers can coexist.  */
 int yydebug;
 #else /* !YYDEBUG */
 # define YYDPRINTF(Args)

-# define YYDSYMPRINT(Args)
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
+# define YY_STACK_PRINT(Bottom, Top)
+# define YY_REDUCE_PRINT(Rule)

 #endif /* !YYDEBUG */
 
 #endif /* !YYDEBUG */
 

+

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

-# define YYINITDEPTH b4_stack_depth_init
+# define YYINITDEPTH ]b4_stack_depth_init[

 #endif
 
 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
    if the built-in stack extension method is used).
 
    Do not make this value too large; the results are undefined if
 #endif
 
 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
    if the built-in stack extension method is used).
 
    Do not make this value too large; the results are undefined if

-   SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
+   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)

    evaluated with infinite-precision integer arithmetic.  */
 
    evaluated with infinite-precision integer arithmetic.  */
 

-#if YYMAXDEPTH == 0
-# undef YYMAXDEPTH
-#endif
-

 #ifndef YYMAXDEPTH
 #ifndef YYMAXDEPTH

-# define YYMAXDEPTH b4_stack_depth_max
+# define YYMAXDEPTH ]b4_stack_depth_max[

 #endif
 
 \f
 #endif
 
 \f


@@ -567,45 +886,32 @@ int yydebug;
 #if YYERROR_VERBOSE
 
 # ifndef yystrlen
 #if YYERROR_VERBOSE
 
 # ifndef yystrlen

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

 #   define yystrlen strlen
 #  else
 /* Return the length of YYSTR.  */
 #   define yystrlen strlen
 #  else
 /* Return the length of YYSTR.  */

-static YYSIZE_T
-#   if defined (__STDC__) || defined (__cplusplus)
-yystrlen (const char *yystr)
-#   else
-yystrlen (yystr)
-     const char *yystr;
-#   endif
+]b4_c_function_def([yystrlen], [static YYSIZE_T],
+   [[const char *yystr], [yystr]])[

 {
 {

-  register const char *yys = yystr;
-
-  while (*yys++ != '\0')
+  YYSIZE_T yylen;
+  for (yylen = 0; yystr[yylen]; yylen++)

     continue;
     continue;

-
-  return yys - yystr - 1;
+  return yylen;

 }
 #  endif
 # endif
 
 # ifndef yystpcpy
 }
 #  endif
 # endif
 
 # ifndef yystpcpy

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

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

-static char *
-#   if defined (__STDC__) || defined (__cplusplus)
-yystpcpy (char *yydest, const char *yysrc)
-#   else
-yystpcpy (yydest, yysrc)
-     char *yydest;
-     const char *yysrc;
-#   endif
+]b4_c_function_def([yystpcpy], [static char *],
+   [[char *yydest], [yydest]], [[const char *yysrc], [yysrc]])[

 {
 {

-  register char *yyd = yydest;
-  register const char *yys = yysrc;
+  char *yyd = yydest;
+  const char *yys = yysrc;

 
   while ((*yyd++ = *yys++) != '\0')
     continue;
 
   while ((*yyd++ = *yys++) != '\0')
     continue;


@@ -615,188 +921,373 @@ yystpcpy (yydest, yysrc)
 #  endif
 # endif
 
 #  endif
 # endif
 

-#endif /* !YYERROR_VERBOSE */
+# ifndef yytnamerr
+/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
+   quotes and backslashes, so that it's suitable for yyerror.  The
+   heuristic is that double-quoting is unnecessary unless the string
+   contains an apostrophe, a comma, or backslash (other than
+   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
+   null, do not copy; instead, return the length of what the result
+   would have been.  */
+static YYSIZE_T
+yytnamerr (char *yyres, const char *yystr)
+{
+  if (*yystr == '"')
+    {
+      YYSIZE_T yyn = 0;
+      char const *yyp = yystr;
+
+      for (;;)
+       switch (*++yyp)
+         {
+         case '\'':
+         case ',':
+           goto do_not_strip_quotes;
+
+         case '\\':
+           if (*++yyp != '\\')
+             goto do_not_strip_quotes;
+           /* Fall through.  */
+         default:
+           if (yyres)
+             yyres[yyn] = *yyp;
+           yyn++;
+           break;
+
+         case '"':
+           if (yyres)
+             yyres[yyn] = '\0';
+           return yyn;
+         }
+    do_not_strip_quotes: ;
+    }

 
 

-\f
+  if (! yyres)
+    return yystrlen (yystr);

 
 

-#if YYDEBUG
-/*-----------------------------.
-| Print this symbol on YYOUT.  |
-`-----------------------------*/
+  return yystpcpy (yyres, yystr) - yyres;
+}
+# endif

 
 

-b4_c_function([yysymprint],
-             [static void],
-             [[FILE*],   [yyout]],
-             [[int],     [yytype]],
-             [[YYSTYPE], [yyvalue]]b4_location_if([,
-             [[YYLTYPE], [yylocation]]]))
+/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
+   about the unexpected token YYTOKEN while in state YYSTATE.
+
+   Return 0 if *YYMSG was successfully written.  Return 1 if an ordinary
+   "syntax error" message will suffice instead.  Return 2 if *YYMSG is
+   not large enough to hold the message.  In the last case, also set
+   *YYMSG_ALLOC to either (a) the required number of bytes or (b) zero
+   if the required number of bytes is too large to store.  */
+static int
+yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
+                int yystate, int yytoken)

 {
 {

-  /* Pacify ``unused variable'' warnings.  */
-  (void) yyvalue;
-b4_location_if([  (void) yylocation;
-])dnl
+  int yyn = yypact[yystate];

 
 

-  if (yytype < YYNTOKENS)
-    {
-      YYFPRINTF (yyout, "token %s (", yytname[[yytype]]);
-# ifdef YYPRINT
-      YYPRINT (yyout, yytoknum[[yytype]], yyvalue);
-# endif
-    }
+  if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
+    return 1;

   else
   else

-    YYFPRINTF (yyout, "nterm %s (", yytname[[yytype]]);
-
-  switch (yytype)

     {
     {

-m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
-      default:
-        break;
-    }
-  YYFPRINTF (yyout, ")");
-}
-#endif /* YYDEBUG. */
-
+      YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
+      YYSIZE_T yysize = yysize0;
+      YYSIZE_T yysize1;
+      enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
+      /* Internationalized format string. */
+      const char *yyformat = 0;
+      /* Arguments of yyformat. */
+      char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
+
+      /* Start YYX at -YYN if negative to avoid negative indexes in
+        YYCHECK.  In other words, skip the first -YYN actions for this
+        state because they are default actions.  */
+      int yyxbegin = yyn < 0 ? -yyn : 0;
+
+      /* Stay within bounds of both yycheck and yytname.  */
+      int yychecklim = YYLAST - yyn + 1;
+      int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
+      /* Number of reported tokens (one for the "unexpected", one per
+         "expected"). */
+      int yycount = 0;
+      int yyx;
+
+      yyarg[yycount++] = yytname[yytoken];
+
+      for (yyx = yyxbegin; yyx < yyxend; ++yyx)
+       if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
+           && !yytable_value_is_error (yytable[yyx + yyn]))
+         {
+           if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
+             {
+               yycount = 1;
+               yysize = yysize0;
+               break;
+             }
+           yyarg[yycount++] = yytname[yyx];
+           yysize1 = yysize + yytnamerr (0, yytname[yyx]);
+           if (! (yysize <= yysize1
+                  && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+             {
+               /* Overflow.  */
+               *yymsg_alloc = 0;
+               return 2;
+             }
+           yysize = yysize1;
+         }
+
+      switch (yycount)
+        {
+#define YYCASE_(N, S)                           \
+          case N:                               \
+            yyformat = S;                       \
+          break
+          YYCASE_(1, YY_("syntax error, unexpected %s"));
+          YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
+          YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
+          YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
+          YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
+#undef YYCASE_
+        }

 
 

-/*-----------------------------------------------.
-| Release the memory associated to this symbol.  |
-`-----------------------------------------------*/
+      yysize1 = yysize + yystrlen (yyformat);
+      if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+        {
+          /* Overflow.  */
+          *yymsg_alloc = 0;
+          return 2;
+        }
+      yysize = yysize1;

 
 

-b4_c_function([yydestruct],
-             [static void],
-             [[int],     [yytype]],
-             [[YYSTYPE], [yyvalue]]b4_location_if([,
-             [[YYLTYPE], [yylocation]]]))
-{
-  /* Pacify ``unused variable'' warnings.  */
-  (void) yyvalue;
-b4_location_if([  (void) yylocation;
-])dnl
+      if (*yymsg_alloc < yysize)
+        {
+          *yymsg_alloc = 2 * yysize;
+          if (! (yysize <= *yymsg_alloc
+                 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
+            *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
+          return 2;
+        }

 
 

-  switch (yytype)
-    {
-m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))dnl
-      default:
-        break;
+      /* Avoid sprintf, as that infringes on the user's name space.
+         Don't have undefined behavior even if the translation
+         produced a string with the wrong number of "%s"s.  */
+      {
+        char *yyp = *yymsg;
+        int yyi = 0;
+        while ((*yyp = *yyformat) != '\0')
+          if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
+            {
+              yyp += yytnamerr (yyp, yyarg[yyi++]);
+              yyformat += 2;
+            }
+          else
+            {
+              yyp++;
+              yyformat++;
+            }
+      }
+      return 0;

     }
 }
     }
 }

-
+#endif /* YYERROR_VERBOSE */

 \f
 
 \f
 

-/* The user can define YYPARSE_PARAM as the name of an argument to be passed
-   into yyparse.  The argument should have type void *.
-   It should actually point to an object.
-   Grammar actions can access the variable by casting it
-   to the proper pointer type.  */
+]b4_yydestruct_generate([b4_c_function_def])b4_push_if([], [[

 
 

+
+/* Prevent warnings from -Wmissing-prototypes.  */

 #ifdef YYPARSE_PARAM
 #ifdef YYPARSE_PARAM

-# if defined (__STDC__) || defined (__cplusplus)
-#  define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
-#  define YYPARSE_PARAM_DECL
-# else
-#  define YYPARSE_PARAM_ARG YYPARSE_PARAM
-#  define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
-# endif
-#else /* !YYPARSE_PARAM */
-# define YYPARSE_PARAM_ARG
-# define YYPARSE_PARAM_DECL
-#endif /* !YYPARSE_PARAM */
-
-/* Prevent warning if -Wstrict-prototypes.  */
-#ifdef __GNUC__
-# ifdef YYPARSE_PARAM
-int yyparse (void *);
-# else
-int yyparse (void);
-# endif
-#endif
+]b4_c_function_decl([yyparse], [int],
+                    [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])[
+#else /* ! YYPARSE_PARAM */
+]b4_c_function_decl([yyparse], [int], b4_parse_param)[
+#endif /* ! YYPARSE_PARAM */]])b4_pure_if([], [

 
 

-m4_divert_push([KILL])# ======================== M4 code.
-# b4_declare_parser_variables
-# ---------------------------
-# Declare the variables that are global, or local to YYPARSE if
-#  pure-parser
-m4_define([b4_declare_parser_variables],
-[/* The lookahead symbol.  */
-int yychar;
+b4_declare_scanner_communication_variables])[]b4_push_if([[

 
 

-/* The semantic value of the lookahead symbol.  */
-YYSTYPE yylval;

 
 

-/* Number of parse errors so far.  */
-int yynerrs;b4_location_if([
-/* Location data for the lookahead symbol.  */
-YYLTYPE yylloc;])
-])
-m4_divert_pop([KILL])dnl# ====================== End of M4 code.
-
-b4_pure_if([],
-           [b4_declare_parser_variables])
-
-int
-yyparse (YYPARSE_PARAM_ARG)
-     YYPARSE_PARAM_DECL
-{[
-  ]b4_pure_if([b4_declare_parser_variables])[
-  register int yystate;
-  register int yyn;
-  int yyresult;
-  /* Number of tokens to shift before error messages enabled.  */
-  int yyerrstatus;
-  /* Lookahead token as an internal (translated) token number.  */
-  int yychar1 = 0;
+struct yypstate
+  {]b4_declare_parser_state_variables[
+    /* Used to determine if this is the first time this instance has
+       been used.  */
+    int yynew;
+  };]b4_pure_if([], [[
+
+static char yypstate_allocated = 0;]])b4_pull_if([

 
 

-  /* Three stacks and their tools:
-     `yyss': related to states,
-     `yyvs': related to semantic values,
-     `yyls': related to locations.
+b4_c_function_def([[yyparse]], [[int]], b4_parse_param)[
+{
+  return yypull_parse (0]m4_ifset([b4_parse_param],
+                                  [[, ]b4_c_args(b4_parse_param)])[);
+}

 
 

-     Refer to the stacks thru separate pointers, to allow yyoverflow
-     to reallocate them elsewhere.  */
+]b4_c_function_def([[yypull_parse]], [[int]],
+  [[[yypstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [,
+  b4_parse_param]))[
+{
+  int yystatus;
+  yypstate *yyps_local;]b4_pure_if([[
+  int yychar;
+  YYSTYPE yylval;]b4_locations_if([[
+  YYLTYPE yylloc;]])])[
+  if (yyps == 0)
+    {
+      yyps_local = yypstate_new ();
+      if (!yyps_local)
+        {]b4_pure_if([[
+          yyerror (]b4_yyerror_args[YY_("memory exhausted"));]], [[
+          if (!yypstate_allocated)
+            yyerror (]b4_yyerror_args[YY_("memory exhausted"));]])[
+          return 2;
+        }
+    }
+  else
+    yyps_local = yyps;
+  do {
+    yychar = YYLEX;
+    yystatus =
+      yypush_parse (yyps_local]b4_pure_if([[, yychar, &yylval]b4_locations_if([[, &yylloc]])])m4_ifset([b4_parse_param], [, b4_c_args(b4_parse_param)])[);
+  } while (yystatus == YYPUSH_MORE);
+  if (yyps == 0)
+    yypstate_delete (yyps_local);
+  return yystatus;
+}]])[
+
+/* Initialize the parser data structure.  */
+]b4_c_function_def([[yypstate_new]], [[yypstate *]])[
+{
+  yypstate *yyps;]b4_pure_if([], [[
+  if (yypstate_allocated)
+    return 0;]])[
+  yyps = (yypstate *) malloc (sizeof *yyps);
+  if (!yyps)
+    return 0;
+  yyps->yynew = 1;]b4_pure_if([], [[
+  yypstate_allocated = 1;]])[
+  return yyps;
+}

 
 

-  /* The state stack.  */
-  short        yyssa[YYINITDEPTH];
-  short *yyss = yyssa;
-  register short *yyssp;
+]b4_c_function_def([[yypstate_delete]], [[void]],
+                   [[[yypstate *yyps]], [[yyps]]])[
+{
+#ifndef yyoverflow
+  /* If the stack was reallocated but the parse did not complete, then the
+     stack still needs to be freed.  */
+  if (!yyps->yynew && yyps->yyss != yyps->yyssa)
+    YYSTACK_FREE (yyps->yyss);
+#endif
+  free (yyps);]b4_pure_if([], [[
+  yypstate_allocated = 0;]])[
+}
+]b4_pure_if([[
+#define ]b4_prefix[nerrs yyps->]b4_prefix[nerrs]])[
+#define yystate yyps->yystate
+#define yyerrstatus yyps->yyerrstatus
+#define yyssa yyps->yyssa
+#define yyss yyps->yyss
+#define yyssp yyps->yyssp
+#define yyvsa yyps->yyvsa
+#define yyvs yyps->yyvs
+#define yyvsp yyps->yyvsp]b4_locations_if([[
+#define yylsa yyps->yylsa
+#define yyls yyps->yyls
+#define yylsp yyps->yylsp
+#define yyerror_range yyps->yyerror_range]])[
+#define yystacksize yyps->yystacksize
+
+
+/*---------------.
+| yypush_parse.  |
+`---------------*/
+
+]b4_c_function_def([[yypush_parse]], [[int]],
+  [[[yypstate *yyps]], [[yyps]]]b4_pure_if([,
+  [[[int yypushed_char]], [[yypushed_char]]],
+  [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
+  [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [,
+  b4_parse_param]))], [[
+
+
+/*----------.
+| yyparse.  |
+`----------*/

 
 

-  /* The semantic value stack.  */
-  YYSTYPE yyvsa[YYINITDEPTH];
-  YYSTYPE *yyvs = yyvsa;
-  register YYSTYPE *yyvsp;
+#ifdef YYPARSE_PARAM
+]b4_c_function_def([yyparse], [int],
+                   [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])[
+#else /* ! YYPARSE_PARAM */
+]b4_c_function_def([yyparse], [int], b4_parse_param)[
+#endif]])[
+{]b4_pure_if([b4_declare_scanner_communication_variables
+])b4_push_if([b4_pure_if([], [[
+  int yypushed_char = yychar;
+  YYSTYPE yypushed_val = yylval;]b4_locations_if([[
+  YYLTYPE yypushed_loc = yylloc;]])
+])],
+  [b4_declare_parser_state_variables
+])[
+  int yyn;
+  int yyresult;
+  /* Lookahead token as an internal (translated) token number.  */
+  int yytoken;
+  /* The variables used to return semantic value and location from the
+     action routines.  */
+  YYSTYPE yyval;]b4_locations_if([[
+  YYLTYPE yyloc;]])[

 
 

-]b4_location_if(
-[[  /* The location stack.  */
-  YYLTYPE yylsa[YYINITDEPTH];
-  YYLTYPE *yyls = yylsa;
-  YYLTYPE *yylsp;]])[
+#if YYERROR_VERBOSE
+  /* Buffer for error messages, and its allocated size.  */
+  char yymsgbuf[128];
+  char *yymsg = yymsgbuf;
+  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
+#endif

 
 

-#define YYPOPSTACK   (yyvsp--, yyssp--]b4_location_if([, yylsp--])[)
+#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N)]b4_locations_if([, yylsp -= (N)])[)

 
 

-  YYSIZE_T yystacksize = YYINITDEPTH;
+  /* The number of symbols on the RHS of the reduced rule.
+     Keep to zero when no symbol should be popped.  */
+  int yylen = 0;]b4_push_if([[

 
 

-  /* The variables used to return semantic value and location from the
-     action routines.  */
-  YYSTYPE yyval;
-]b4_location_if([  YYLTYPE yyloc;])[
+  if (!yyps->yynew)
+    {
+      yyn = yypact[yystate];
+      goto yyread_pushed_token;
+    }]])[

 
 

-  /* When reducing, the number of symbols on the RHS of the reduced
-     rule.  */
-  int yylen;
+  yytoken = 0;
+  yyss = yyssa;
+  yyvs = yyvsa;]b4_locations_if([[
+  yyls = yylsa;]])[
+  yystacksize = YYINITDEPTH;

 
   YYDPRINTF ((stderr, "Starting parse\n"));
 
   yystate = 0;
   yyerrstatus = 0;
   yynerrs = 0;
 
   YYDPRINTF ((stderr, "Starting parse\n"));
 
   yystate = 0;
   yyerrstatus = 0;
   yynerrs = 0;

-  yychar = YYEMPTY;            /* Cause a token to be read.  */
+  yychar = YYEMPTY; /* Cause a token to be read.  */

 
   /* Initialize stack pointers.
      Waste one element of value and location stack
      so that they stay on the same level as the state stack.
      The wasted elements are never initialized.  */
 
   /* Initialize stack pointers.
      Waste one element of value and location stack
      so that they stay on the same level as the state stack.
      The wasted elements are never initialized.  */

-

   yyssp = yyss;
   yyssp = yyss;

-  yyvsp = yyvs;
-]b4_location_if([  yylsp = yyls;])[
+  yyvsp = yyvs;]b4_locations_if([[
+  yylsp = yyls;
+
+#if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
+  /* Initialize the default location before parsing starts.  */
+  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],     [m4_define([b4_at_dollar_used])yylloc])dnl
+m4_pushdef([b4_dollar_dollar], [m4_define([b4_dollar_dollar_used])yylval])dnl
+/* User initialization code.  */
+b4_user_initial_action
+m4_popdef([b4_dollar_dollar])dnl
+m4_popdef([b4_at_dollar])])dnl
+m4_ifdef([b4_dollar_dollar_used],[[  yyvsp[0] = yylval;
+]])dnl
+m4_ifdef([b4_at_dollar_used], [[  yylsp[0] = yylloc;
+]])[

   goto yysetstate;
 
 /*------------------------------------------------------------.
   goto yysetstate;
 
 /*------------------------------------------------------------.


@@ -804,60 +1295,60 @@ yyparse (YYPARSE_PARAM_ARG)
 `------------------------------------------------------------*/
  yynewstate:
   /* In all cases, when you get here, the value and location stacks
 `------------------------------------------------------------*/
  yynewstate:
   /* In all cases, when you get here, the value and location stacks

-     have just been pushed. so pushing a state here evens the stacks.
-     */
+     have just been pushed.  So pushing a state here evens the stacks.  */

   yyssp++;
 
  yysetstate:
   *yyssp = yystate;
 
   yyssp++;
 
  yysetstate:
   *yyssp = yystate;
 

-  if (yyssp >= yyss + yystacksize - 1)
+  if (yyss + yystacksize - 1 <= yyssp)

     {
       /* Get the current used size of the three stacks, in elements.  */
       YYSIZE_T yysize = yyssp - yyss + 1;
 
 #ifdef yyoverflow
       {
     {
       /* Get the current used size of the three stacks, in elements.  */
       YYSIZE_T yysize = yyssp - yyss + 1;
 
 #ifdef yyoverflow
       {

-       /* Give user a chance to reallocate the stack. Use copies of
+       /* Give user a chance to reallocate the stack.  Use copies of

           these so that the &'s don't force the real ones into
           memory.  */
        YYSTYPE *yyvs1 = yyvs;
           these so that the &'s don't force the real ones into
           memory.  */
        YYSTYPE *yyvs1 = yyvs;

-       short *yyss1 = yyss;
-]b4_location_if([      YYLTYPE *yyls1 = yyls;])[
+       yytype_int16 *yyss1 = yyss;]b4_locations_if([
+       YYLTYPE *yyls1 = yyls;])[

 
        /* Each stack pointer address is followed by the size of the
           data in use in that stack, in bytes.  This used to be a
           conditional around just the two extra args, but that might
           be undefined if yyoverflow is a macro.  */
 
        /* Each stack pointer address is followed by the size of the
           data in use in that stack, in bytes.  This used to be a
           conditional around just the two extra args, but that might
           be undefined if yyoverflow is a macro.  */

-       yyoverflow ("parser stack overflow",
+       yyoverflow (YY_("memory exhausted"),

                    &yyss1, yysize * sizeof (*yyssp),
                    &yyss1, yysize * sizeof (*yyssp),

-                   &yyvs1, yysize * sizeof (*yyvsp),
-]b4_location_if([                  &yyls1, yysize * sizeof (*yylsp),])[
+                   &yyvs1, yysize * sizeof (*yyvsp),]b4_locations_if([
+                   &yyls1, yysize * sizeof (*yylsp),])[

                    &yystacksize);
                    &yystacksize);

-]b4_location_if([      yyls = yyls1;])[
+]b4_locations_if([
+       yyls = yyls1;])[

        yyss = yyss1;
        yyvs = yyvs1;
       }
 #else /* no yyoverflow */
 # ifndef YYSTACK_RELOCATE
        yyss = yyss1;
        yyvs = yyvs1;
       }
 #else /* no yyoverflow */
 # ifndef YYSTACK_RELOCATE

-      goto yyoverflowlab;
+      goto yyexhaustedlab;

 # else
       /* Extend the stack our own way.  */
 # else
       /* Extend the stack our own way.  */

-      if (yystacksize >= YYMAXDEPTH)
-       goto yyoverflowlab;
+      if (YYMAXDEPTH <= yystacksize)
+       goto yyexhaustedlab;

       yystacksize *= 2;
       yystacksize *= 2;

-      if (yystacksize > YYMAXDEPTH)
+      if (YYMAXDEPTH < yystacksize)

        yystacksize = YYMAXDEPTH;
 
       {
        yystacksize = YYMAXDEPTH;
 
       {

-       short *yyss1 = yyss;
+       yytype_int16 *yyss1 = yyss;

        union yyalloc *yyptr =
          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
        if (! yyptr)
        union yyalloc *yyptr =
          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
        if (! yyptr)

-         goto yyoverflowlab;
-       YYSTACK_RELOCATE (yyss);
-       YYSTACK_RELOCATE (yyvs);
-]b4_location_if([      YYSTACK_RELOCATE (yyls);])[
+         goto yyexhaustedlab;
+       YYSTACK_RELOCATE (yyss_alloc, yyss);
+       YYSTACK_RELOCATE (yyvs_alloc, yyvs);]b4_locations_if([
+       YYSTACK_RELOCATE (yyls_alloc, yyls);])[

 #  undef YYSTACK_RELOCATE
        if (yyss1 != yyssa)
          YYSTACK_FREE (yyss1);
 #  undef YYSTACK_RELOCATE
        if (yyss1 != yyssa)
          YYSTACK_FREE (yyss1);


@@ -866,18 +1357,21 @@ yyparse (YYPARSE_PARAM_ARG)
 #endif /* no yyoverflow */
 
       yyssp = yyss + yysize - 1;
 #endif /* no yyoverflow */
 
       yyssp = yyss + yysize - 1;

-      yyvsp = yyvs + yysize - 1;
-]b4_location_if([      yylsp = yyls + yysize - 1;])[
+      yyvsp = yyvs + yysize - 1;]b4_locations_if([
+      yylsp = yyls + yysize - 1;])[

 
       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
                  (unsigned long int) yystacksize));
 
 
       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
                  (unsigned long int) yystacksize));
 

-      if (yyssp >= yyss + yystacksize - 1)
+      if (yyss + yystacksize - 1 <= yyssp)

        YYABORT;
     }
 
   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
 
        YYABORT;
     }
 
   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
 

+  if (yystate == YYFINAL)
+    YYACCEPT;
+

   goto yybackup;
 
 /*-----------.
   goto yybackup;
 
 /*-----------.


@@ -885,81 +1379,81 @@ yyparse (YYPARSE_PARAM_ARG)
 `-----------*/
 yybackup:
 
 `-----------*/
 yybackup:
 

-/* Do appropriate processing given the current state.  */
-/* Read a lookahead token if we need one and don't already have one.  */
-/* yyresume: */
+  /* Do appropriate processing given the current state.  Read a
+     lookahead token if we need one and don't already have one.  */

 
   /* First try to decide what to do without reference to lookahead token.  */
 
   /* First try to decide what to do without reference to lookahead token.  */

-

   yyn = yypact[yystate];
   yyn = yypact[yystate];

-  if (yyn == YYPACT_NINF)
+  if (yypact_value_is_default (yyn))

     goto yydefault;
 
   /* Not known => get a lookahead token if don't already have one.  */
 
     goto yydefault;
 
   /* Not known => get a lookahead token if don't already have one.  */
 

-  /* yychar is either YYEMPTY or YYEOF
-     or a valid token in external form.  */
-
+  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */

   if (yychar == YYEMPTY)
   if (yychar == YYEMPTY)

-    {
-      YYDPRINTF ((stderr, "Reading a token: "));
-      yychar = YYLEX;
+    {]b4_push_if([[
+      if (!yyps->yynew)
+        {]b4_use_push_for_pull_if([], [[
+          YYDPRINTF ((stderr, "Return for a new token:\n"));]])[
+          yyresult = YYPUSH_MORE;
+          goto yypushreturn;
+        }
+      yyps->yynew = 0;]b4_pure_if([], [[
+      /* Restoring the pushed token is only necessary for the first
+         yypush_parse invocation since subsequent invocations don't overwrite
+         it before jumping to yyread_pushed_token.  */
+      yychar = yypushed_char;
+      yylval = yypushed_val;]b4_locations_if([[
+      yylloc = yypushed_loc;]])])[
+yyread_pushed_token:]])[
+      YYDPRINTF ((stderr, "Reading a token: "));]b4_push_if([b4_pure_if([[
+      yychar = yypushed_char;
+      if (yypushed_val)
+        yylval = *yypushed_val;]b4_locations_if([[
+      if (yypushed_loc)
+        yylloc = *yypushed_loc;]])])], [[
+      yychar = YYLEX;]])[

     }
 
     }
 

-  /* Convert token to internal form (in yychar1) for indexing tables with.  */
-
-  if (yychar <= 0)             /* This means end of input.  */
+  if (yychar <= YYEOF)

     {
     {

-      yychar1 = 0;
-      yychar = YYEOF;          /* Don't call YYLEX any more.  */
-
+      yychar = yytoken = YYEOF;

       YYDPRINTF ((stderr, "Now at end of input.\n"));
     }
   else
     {
       YYDPRINTF ((stderr, "Now at end of input.\n"));
     }
   else
     {

-      yychar1 = YYTRANSLATE (yychar);
-
-      /* We have to keep this `#if YYDEBUG', since we use variables
-        which are defined only if `YYDEBUG' is set.  */
-      YYDPRINTF ((stderr, "Next token is "));
-      YYDSYMPRINT ((stderr, yychar1, yylval]b4_location_if([, yyloc])[));
-      YYDPRINTF ((stderr, "\n"));
+      yytoken = YYTRANSLATE (yychar);
+      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);

     }
 
     }
 

-  /* If the proper action on seeing token YYCHAR1 is to reduce or to
+  /* If the proper action on seeing token YYTOKEN is to reduce or to

      detect an error, take that action.  */
      detect an error, take that action.  */

-  yyn += yychar1;
-  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yychar1)
+  yyn += yytoken;
+  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)

     goto yydefault;
   yyn = yytable[yyn];
   if (yyn <= 0)
     {
     goto yydefault;
   yyn = yytable[yyn];
   if (yyn <= 0)
     {

-      if (yyn == 0 || yyn == YYTABLE_NINF)
+      if (yytable_value_is_error (yyn))

        goto yyerrlab;
       yyn = -yyn;
       goto yyreduce;
     }
 
        goto yyerrlab;
       yyn = -yyn;
       goto yyreduce;
     }
 

-  if (yyn == YYFINAL)
-    YYACCEPT;
-
-  /* Shift the lookahead token.  */
-  YYDPRINTF ((stderr, "Shifting token %d (%s), ",
-             yychar, yytname[yychar1]));
-
-  /* Discard the token being shifted unless it is eof.  */
-  if (yychar != YYEOF)
-    yychar = YYEMPTY;
-
-  *++yyvsp = yylval;
-]b4_location_if([  *++yylsp = yylloc;])[
-

   /* Count tokens shifted since error; after three, turn off error
      status.  */
   if (yyerrstatus)
     yyerrstatus--;
 
   /* Count tokens shifted since error; after three, turn off error
      status.  */
   if (yyerrstatus)
     yyerrstatus--;
 

+  /* Shift the lookahead token.  */
+  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
+
+  /* Discard the shifted token.  */
+  yychar = YYEMPTY;
+

   yystate = yyn;
   yystate = yyn;

+  *++yyvsp = yylval;
+]b4_locations_if([  *++yylsp = yylloc;])[

   goto yynewstate;
 
 
   goto yynewstate;
 
 


@@ -990,51 +1484,34 @@ yyreduce:
      GCC warning that YYVAL may be used uninitialized.  */
   yyval = yyvsp[1-yylen];
 
      GCC warning that YYVAL may be used uninitialized.  */
   yyval = yyvsp[1-yylen];
 

-]b4_location_if(
-[  /* Default location. */
-  YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);])[
-
-#if YYDEBUG
-  /* We have to keep this `#if YYDEBUG', since we use variables which
-     are defined only if `YYDEBUG' is set.  */
-  if (yydebug)
-    {
-      int yyi;
-
-      YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
-                yyn - 1, yyrline[yyn]);
-
-      /* Print the symbols being reduced, and their result.  */
-      for (yyi = yyprhs[yyn]; yyrhs[yyi] >= 0; yyi++)
-       YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
-      YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
-    }
-#endif
+]b4_locations_if(
+[[  /* Default location.  */
+  YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);]])[
+  YY_REDUCE_PRINT (yyn);

   switch (yyn)
   switch (yyn)

-    ]{
-      b4_actions
-    }
-
-/* Line __line__ of __file__.  */
-#line __oline__ "__ofile__"
-\f
-[  yyvsp -= yylen;
-  yyssp -= yylen;
-]b4_location_if([  yylsp -= yylen;])[
-
-#if YYDEBUG
-  if (yydebug)

     {
     {

-      short *yyssp1 = yyss - 1;
-      YYFPRINTF (stderr, "state stack now");
-      while (yyssp1 != yyssp)
-       YYFPRINTF (stderr, " %d", *++yyssp1);
-      YYFPRINTF (stderr, "\n");
+      ]b4_user_actions[
+      default: break;

     }
     }

-#endif
-
-  *++yyvsp = yyval;
-]b4_location_if([  *++yylsp = yyloc;])[
+  /* User semantic actions sometimes alter yychar, and that requires
+     that yytoken be updated with the new translation.  We take the
+     approach of translating immediately before every use of yytoken.
+     One alternative is translating here after every semantic action,
+     but that translation would be missed if the semantic action invokes
+     YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
+     if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
+     incorrect destructor might then be invoked immediately.  In the
+     case of YYERROR or YYBACKUP, subsequent parser actions might lead
+     to an incorrect destructor call or verbose syntax error message
+     before the lookahead is translated.  */
+  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
+
+  YYPOPSTACK (yylen);
+  yylen = 0;
+  YY_STACK_PRINT (yyss, yyssp);
+
+  *++yyvsp = yyval;]b4_locations_if([
+  *++yylsp = yyloc;])[

 
   /* Now `shift' the result of the reduction.  Determine what state
      that goes to, based on the state we popped back to and the rule
 
   /* Now `shift' the result of the reduction.  Determine what state
      that goes to, based on the state we popped back to and the rule


@@ -1055,105 +1532,99 @@ yyreduce:
 | yyerrlab -- here on detecting error |
 `------------------------------------*/
 yyerrlab:
 | yyerrlab -- here on detecting error |
 `------------------------------------*/
 yyerrlab:

+  /* Make sure we have latest lookahead translation.  See comments at
+     user semantic actions for why this is necessary.  */
+  yytoken = YYTRANSLATE (yychar);
+

   /* If not already recovering from an error, report this error.  */
   if (!yyerrstatus)
     {
       ++yynerrs;
   /* If not already recovering from an error, report this error.  */
   if (!yyerrstatus)
     {
       ++yynerrs;

-#if YYERROR_VERBOSE
-      yyn = yypact[yystate];
-
-      if (YYPACT_NINF < yyn && yyn < YYLAST)
-       {
-         YYSIZE_T yysize = 0;
-         int yytype = YYTRANSLATE (yychar);
-         char *yymsg;
-         int yyx, yycount;
-
-         yycount = 0;
-         /* Start YYX at -YYN if negative to avoid negative indexes in
-            YYCHECK.  */
-         for (yyx = yyn < 0 ? -yyn : 0;
-              yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
-           if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
-             yysize += yystrlen (yytname[yyx]) + 15, yycount++;
-         yysize += yystrlen ("parse error, unexpected ") + 1;
-         yysize += yystrlen (yytname[yytype]);
-         yymsg = (char *) YYSTACK_ALLOC (yysize);
-         if (yymsg != 0)
-           {
-             char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
-             yyp = yystpcpy (yyp, yytname[yytype]);
-
-             if (yycount < 5)
-               {
-                 yycount = 0;
-                 for (yyx = yyn < 0 ? -yyn : 0;
-                      yyx < (int) (sizeof (yytname) / sizeof (char *));
-                      yyx++)
-                   if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
-                     {
-                       const char *yyq = ! yycount ? ", expecting " : " or ";
-                       yyp = yystpcpy (yyp, yyq);
-                       yyp = yystpcpy (yyp, yytname[yyx]);
-                       yycount++;
-                     }
-               }
-             yyerror (yymsg);
-             YYSTACK_FREE (yymsg);
-           }
-         else
-           yyerror ("parse error; also virtual memory exhausted");
-       }
-      else
-#endif /* YYERROR_VERBOSE */
-       yyerror ("parse error");
+#if ! YYERROR_VERBOSE
+      yyerror (]b4_yyerror_args[YY_("syntax error"));
+#else
+      while (1)
+        {
+          int yysyntax_error_status =
+            yysyntax_error (&yymsg_alloc, &yymsg, yystate, yytoken);
+          if (yysyntax_error_status == 2 && 0 < yymsg_alloc)
+            {
+              if (yymsg != yymsgbuf)
+                YYSTACK_FREE (yymsg);
+              yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
+              if (yymsg)
+                continue;
+              yymsg = yymsgbuf;
+              yymsg_alloc = sizeof yymsgbuf;
+            }
+          if (yysyntax_error_status == 0)
+            yyerror (]b4_yyerror_args[yymsg);
+          else
+            yyerror (]b4_yyerror_args[YY_("syntax error"));
+          if (yysyntax_error_status == 2)
+            goto yyexhaustedlab;
+          break;
+        }
+#endif

     }
     }

-  goto yyerrlab1;

 
 

+]b4_locations_if([[  yyerror_range[0] = yylloc;]])[

 
 

-/*----------------------------------------------------.
-| yyerrlab1 -- error raised explicitly by an action.  |
-`----------------------------------------------------*/
-yyerrlab1:

   if (yyerrstatus == 3)
     {
       /* If just tried and failed to reuse lookahead token after an
         error, discard it.  */
 
   if (yyerrstatus == 3)
     {
       /* If just tried and failed to reuse lookahead token after an
         error, discard it.  */
 

-      /* Return failure if at end of input.  */
-      if (yychar == YYEOF)
-        {
-         /* Pop the error token.  */
-          YYPOPSTACK;
-         /* Pop the rest of the stack.  */
-         while (yyssp > yyss)
-           {
-             YYDPRINTF ((stderr, "Error: popping "));
-             YYDSYMPRINT ((stderr,
-                           yystos[*yyssp],
-                           *yyvsp]b4_location_if([, *yylsp])[));
-             YYDPRINTF ((stderr, "\n"));
-             yydestruct (yystos[*yyssp], *yyvsp]b4_location_if([, *yylsp])[);
-             YYPOPSTACK;
-           }
-         YYABORT;
-        }
-
-      YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
-                 yychar, yytname[yychar1]));
-      yydestruct (yychar1, yylval]b4_location_if([, yylloc])[);
-      yychar = YYEMPTY;
+      if (yychar <= YYEOF)
+       {
+         /* Return failure if at end of input.  */
+         if (yychar == YYEOF)
+           YYABORT;
+       }
+      else
+       {
+         yydestruct ("Error: discarding",
+                     yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
+         yychar = YYEMPTY;
+       }

     }
 
   /* Else will try to reuse lookahead token after shifting the error
      token.  */
     }
 
   /* Else will try to reuse lookahead token after shifting the error
      token.  */

+  goto yyerrlab1;
+
+
+/*---------------------------------------------------.
+| yyerrorlab -- error raised explicitly by YYERROR.  |
+`---------------------------------------------------*/
+yyerrorlab:
+
+  /* Pacify compilers like GCC when the user code never invokes
+     YYERROR and the label yyerrorlab therefore never appears in user
+     code.  */
+  if (/*CONSTCOND*/ 0)
+     goto yyerrorlab;
+
+]b4_locations_if([[  yyerror_range[0] = yylsp[1-yylen];
+]])[  /* Do not reclaim the symbols of the rule which action triggered
+     this YYERROR.  */
+  YYPOPSTACK (yylen);
+  yylen = 0;
+  YY_STACK_PRINT (yyss, yyssp);
+  yystate = *yyssp;
+  goto yyerrlab1;
+

 
 

+/*-------------------------------------------------------------.
+| yyerrlab1 -- common code for both syntax error and YYERROR.  |
+`-------------------------------------------------------------*/
+yyerrlab1:

   yyerrstatus = 3;     /* Each real token shifted decrements this.  */
 
   for (;;)
     {
       yyn = yypact[yystate];
   yyerrstatus = 3;     /* Each real token shifted decrements this.  */
 
   for (;;)
     {
       yyn = yypact[yystate];

-      if (yyn != YYPACT_NINF)
+      if (!yypact_value_is_default (yyn))

        {
          yyn += YYTERROR;
          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
        {
          yyn += YYTERROR;
          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)


@@ -1168,35 +1639,24 @@ yyerrlab1:
       if (yyssp == yyss)
        YYABORT;
 
       if (yyssp == yyss)
        YYABORT;
 

-      YYDPRINTF ((stderr, "Error: popping "));
-      YYDSYMPRINT ((stderr,
-                   yystos[*yyssp], *yyvsp]b4_location_if([, *yylsp])[));
-      YYDPRINTF ((stderr, "\n"));
-
-      yydestruct (yystos[yystate], *yyvsp]b4_location_if([, *yylsp])[);
-      yyvsp--;
-      yystate = *--yyssp;
-]b4_location_if([      yylsp--;])[
-
-#if YYDEBUG
-      if (yydebug)
-       {
-         short *yyssp1 = yyss - 1;
-         YYFPRINTF (stderr, "Error: state stack now");
-         while (yyssp1 != yyssp)
-           YYFPRINTF (stderr, " %d", *++yyssp1);
-         YYFPRINTF (stderr, "\n");
-       }
-#endif
+]b4_locations_if([[      yyerror_range[0] = *yylsp;]])[
+      yydestruct ("Error: popping",
+                 yystos[yystate], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[);
+      YYPOPSTACK (1);
+      yystate = *yyssp;
+      YY_STACK_PRINT (yyss, yyssp);

     }
 
     }
 

-  if (yyn == YYFINAL)
-    YYACCEPT;
-
-  YYDPRINTF ((stderr, "Shifting error token, "));
-

   *++yyvsp = yylval;
   *++yyvsp = yylval;

-]b4_location_if([  *++yylsp = yylloc;])[
+]b4_locations_if([[
+  yyerror_range[1] = yylloc;
+  /* Using YYLLOC is tempting, but would change the location of
+     the lookahead.  YYLOC is available though.  */
+  YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);
+  *++yylsp = yyloc;]])[
+
+  /* Shift the error token.  */
+  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);

 
   yystate = yyn;
   goto yynewstate;
 
   yystate = yyn;
   goto yynewstate;


@@ -1216,68 +1676,115 @@ yyabortlab:
   yyresult = 1;
   goto yyreturn;
 
   yyresult = 1;
   goto yyreturn;
 

-#ifndef yyoverflow
-/*----------------------------------------------.
-| yyoverflowlab -- parser overflow comes here.  |
-`----------------------------------------------*/
-yyoverflowlab:
-  yyerror ("parser stack overflow");
+#if !defined(yyoverflow) || YYERROR_VERBOSE
+/*-------------------------------------------------.
+| yyexhaustedlab -- memory exhaustion comes here.  |
+`-------------------------------------------------*/
+yyexhaustedlab:
+  yyerror (]b4_yyerror_args[YY_("memory exhausted"));

   yyresult = 2;
   /* Fall through.  */
 #endif
 
 yyreturn:
   yyresult = 2;
   /* Fall through.  */
 #endif
 
 yyreturn:

+  if (yychar != YYEMPTY)
+    {
+      /* Make sure we have latest lookahead translation.  See comments at
+         user semantic actions for why this is necessary.  */
+      yytoken = YYTRANSLATE (yychar);
+      yydestruct ("Cleanup: discarding lookahead",
+                  yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
+    }
+  /* Do not reclaim the symbols of the rule which action triggered
+     this YYABORT or YYACCEPT.  */
+  YYPOPSTACK (yylen);
+  YY_STACK_PRINT (yyss, yyssp);
+  while (yyssp != yyss)
+    {
+      yydestruct ("Cleanup: popping",
+                 yystos[*yyssp], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[);
+      YYPOPSTACK (1);
+    }

 #ifndef yyoverflow
   if (yyss != yyssa)
     YYSTACK_FREE (yyss);
 #ifndef yyoverflow
   if (yyss != yyssa)
     YYSTACK_FREE (yyss);

+#endif]b4_push_if([[
+  yyps->yynew = 1;
+
+yypushreturn:]])[
+#if YYERROR_VERBOSE
+  if (yymsg != yymsgbuf)
+    YYSTACK_FREE (yymsg);

 #endif
 #endif

-  return yyresult;
-]}
-
-
-b4_epilogue
-m4_if(b4_defines_flag, 0, [],
-[#output "b4_output_header_name"
-b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
-             [1984, 1989, 1990, 2000, 2001, 2002])
-
-/* As a special exception, when this file is copied by Bison into a
-   Bison output file, you may use that output file without restriction.
-   This special exception was added by the Free Software Foundation
-   in version 1.24 of Bison.  */
-
-#ifndef b4_header_guard
-# define b4_header_guard
-
-b4_token_defines(b4_tokens)
-
-#ifndef YYSTYPE
-m4_ifdef([b4_stype],
-[#line b4_stype_line "b4_filename"
-typedef union b4_stype yystype;
-/* Line __line__ of __file__.  */
-#line __oline__ "__ofile__"],
-[typedef int yystype;])
-# define YYSTYPE yystype
+  /* Make sure YYID is used.  */
+  return YYID (yyresult);
+}
+
+
+]b4_epilogue
+b4_defines_if(
+[@output(b4_spec_defines_file@)@
+b4_copyright([Skeleton interface for Bison's Yacc-like parsers in C],
+             [1984, 1989-1990, 2000-2010])
+
+b4_percent_code_get([[requires]])[]dnl
+
+b4_token_enums_defines(b4_tokens)
+
+[#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+]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]])])[
+# define yystype YYSTYPE /* obsolescent; will be withdrawn */
+# define YYSTYPE_IS_DECLARED 1

 #endif
 
 #endif
 

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

 
 

-b4_location_if(
-[#ifndef YYLTYPE
-typedef struct yyltype
+b4_locations_if(
+[#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
+typedef struct YYLTYPE

 {
   int first_line;
   int first_column;
   int last_line;
   int last_column;
 {
   int first_line;
   int first_column;
   int last_line;
   int last_column;

-} yyltype;
-# define YYLTYPE yyltype
+} YYLTYPE;
+# define yyltype YYLTYPE /* obsolescent; will be withdrawn */
+# define YYLTYPE_IS_DECLARED 1
+# define YYLTYPE_IS_TRIVIAL 1

 #endif
 
 #endif
 

-m4_if(b4_pure, [0],
-[extern YYLTYPE b4_prefix[]lloc;])
-])
-#endif /* not b4_header_guard */
-])
+]b4_pure_if([], [[extern YYLTYPE ]b4_prefix[lloc;]])
+)dnl b4_locations_if
+b4_push_if([[
+#ifndef YYPUSH_DECLS
+#  define YYPUSH_DECLS
+struct ]b4_prefix[pstate;
+typedef struct ]b4_prefix[pstate ]b4_prefix[pstate;
+enum { YYPUSH_MORE = 4 };
+]b4_pull_if([b4_c_function_decl([b4_prefix[parse]], [[int]], b4_parse_param)
+])b4_c_function_decl([b4_prefix[push_parse]], [[int]],
+  [[b4_prefix[pstate *yyps]], [[yyps]]]b4_pure_if([,
+  [[[int yypushed_char]], [[yypushed_char]]],
+  [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
+  [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [,
+  b4_parse_param]))
+b4_pull_if([b4_c_function_decl([b4_prefix[pull_parse]], [[int]],
+  [[b4_prefix[pstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [,
+  b4_parse_param]))])
+b4_c_function_decl([b4_prefix[pstate_new]], [b4_prefix[pstate *]],
+                    [[[void]], []])
+b4_c_function_decl([b4_prefix[pstate_delete]], [[void]],
+                   [[b4_prefix[pstate *yyps]], [[yyps]]])[
+#endif
+]])
+b4_percent_code_get([[provides]])[]dnl
+])dnl b4_defines_if
+m4_divert_pop(0)