Home | History | Annotate | Download | only in data
      1                                                              -*- C -*-
      2 
      3 # Yacc compatible skeleton for Bison
      4 
      5 # Copyright (C) 1984, 1989-1990, 2000-2012 Free Software Foundation,
      6 # Inc.
      7 
      8 # This program is free software: you can redistribute it and/or modify
      9 # it under the terms of the GNU General Public License as published by
     10 # the Free Software Foundation, either version 3 of the License, or
     11 # (at your option) any later version.
     12 #
     13 # This program is distributed in the hope that it will be useful,
     14 # but WITHOUT ANY WARRANTY; without even the implied warranty of
     15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     16 # GNU General Public License for more details.
     17 #
     18 # You should have received a copy of the GNU General Public License
     19 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
     20 
     21 # Check the value of %define api.push-pull.
     22 b4_percent_define_default([[api.push-pull]], [[pull]])
     23 b4_percent_define_check_values([[[[api.push-pull]],
     24                                  [[pull]], [[push]], [[both]]]])
     25 b4_define_flag_if([pull]) m4_define([b4_pull_flag], [[1]])
     26 b4_define_flag_if([push]) m4_define([b4_push_flag], [[1]])
     27 m4_case(b4_percent_define_get([[api.push-pull]]),
     28         [pull], [m4_define([b4_push_flag], [[0]])],
     29         [push], [m4_define([b4_pull_flag], [[0]])])
     30 
     31 # Handle BISON_USE_PUSH_FOR_PULL for the test suite.  So that push parsing
     32 # tests function as written, do not let BISON_USE_PUSH_FOR_PULL modify the
     33 # behavior of Bison at all when push parsing is already requested.
     34 b4_define_flag_if([use_push_for_pull])
     35 b4_use_push_for_pull_if([
     36   b4_push_if([m4_define([b4_use_push_for_pull_flag], [[0]])],
     37              [m4_define([b4_push_flag], [[1]])])])
     38 
     39 # Check the value of %define parse.lac and friends, where LAC stands for
     40 # lookahead correction.
     41 b4_percent_define_default([[parse.lac]], [[none]])
     42 b4_percent_define_default([[parse.lac.es-capacity-initial]], [[20]])
     43 b4_percent_define_default([[parse.lac.memory-trace]], [[failures]])
     44 b4_percent_define_check_values([[[[parse.lac]], [[full]], [[none]]]],
     45                                [[[[parse.lac.memory-trace]],
     46                                  [[failures]], [[full]]]])
     47 b4_define_flag_if([lac])
     48 m4_define([b4_lac_flag],
     49           [m4_if(b4_percent_define_get([[parse.lac]]),
     50                  [none], [[0]], [[1]])])
     51 
     52 m4_include(b4_pkgdatadir/[c.m4])
     53 
     54 ## ---------------- ##
     55 ## Default values.  ##
     56 ## ---------------- ##
     57 
     58 # Stack parameters.
     59 m4_define_default([b4_stack_depth_max], [10000])
     60 m4_define_default([b4_stack_depth_init],  [200])
     61 
     62 
     63 ## ------------------------ ##
     64 ## Pure/impure interfaces.  ##
     65 ## ------------------------ ##
     66 
     67 b4_percent_define_default([[api.pure]], [[false]])
     68 b4_percent_define_check_values([[[[api.pure]],
     69                                  [[false]], [[true]], [[]], [[full]]]])
     70 
     71 m4_define([b4_pure_flag], [[0]])
     72 m4_case(b4_percent_define_get([[api.pure]]),
     73         [false], [m4_define([b4_pure_flag], [[0]])],
     74         [true],  [m4_define([b4_pure_flag], [[1]])],
     75         [],      [m4_define([b4_pure_flag], [[1]])],
     76         [full],  [m4_define([b4_pure_flag], [[2]])])
     77 
     78 m4_define([b4_pure_if],
     79 [m4_case(b4_pure_flag,
     80          [0], [$2],
     81          [1], [$1],
     82          [2], [$1])])
     83          [m4_fatal([invalid api.pure value: ]$1)])])
     84 
     85 # b4_yyerror_arg_loc_if(ARG)
     86 # --------------------------
     87 # Expand ARG iff yyerror is to be given a location as argument.
     88 m4_define([b4_yyerror_arg_loc_if],
     89 [b4_locations_if([m4_case(b4_pure_flag,
     90                           [1], [m4_ifset([b4_parse_param], [$1])],
     91                           [2], [$1])])])
     92 
     93 # b4_yyerror_args
     94 # ---------------
     95 # Arguments passed to yyerror: user args plus yylloc.
     96 m4_define([b4_yyerror_args],
     97 [b4_yyerror_arg_loc_if([&yylloc, ])dnl
     98 m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
     99 
    100 
    101 # b4_lex_param
    102 # ------------
    103 # Accumulate in b4_lex_param all the yylex arguments.
    104 # b4_lex_param arrives quoted twice, but we want to keep only one level.
    105 m4_define([b4_lex_param],
    106 m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl
    107 b4_locations_if([, [[YYLTYPE *], [&yylloc]]])m4_ifdef([b4_lex_param], [, ])])dnl
    108 m4_ifdef([b4_lex_param], b4_lex_param)))
    109 
    110 
    111 ## ------------ ##
    112 ## Data Types.  ##
    113 ## ------------ ##
    114 
    115 # b4_int_type(MIN, MAX)
    116 # ---------------------
    117 # Return the smallest int type able to handle numbers ranging from
    118 # MIN to MAX (included).  Overwrite the version from c.m4, which
    119 # uses only C89 types, so that the user can override the shorter
    120 # types, and so that pre-C89 compilers are handled correctly.
    121 m4_define([b4_int_type],
    122 [m4_if(b4_ints_in($@,      [0],   [255]), [1], [yytype_uint8],
    123        b4_ints_in($@,   [-128],   [127]), [1], [yytype_int8],
    124 
    125        b4_ints_in($@,      [0], [65535]), [1], [yytype_uint16],
    126        b4_ints_in($@, [-32768], [32767]), [1], [yytype_int16],
    127 
    128        m4_eval([0 <= $1]),                [1], [unsigned int],
    129 
    130 					       [int])])
    131 
    132 
    133 ## ----------------- ##
    134 ## Semantic Values.  ##
    135 ## ----------------- ##
    136 
    137 
    138 # b4_lhs_value([TYPE])
    139 # --------------------
    140 # Expansion of $<TYPE>$.
    141 m4_define([b4_lhs_value],
    142 [(yyval[]m4_ifval([$1], [.$1]))])
    143 
    144 
    145 # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
    146 # --------------------------------------
    147 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
    148 # symbols on RHS.
    149 m4_define([b4_rhs_value],
    150 [(yyvsp@{($2) - ($1)@}m4_ifval([$3], [.$3]))])
    151 
    152 
    153 
    154 ## ----------- ##
    155 ## Locations.  ##
    156 ## ----------- ##
    157 
    158 # b4_lhs_location()
    159 # -----------------
    160 # Expansion of @$.
    161 m4_define([b4_lhs_location],
    162 [(yyloc)])
    163 
    164 
    165 # b4_rhs_location(RULE-LENGTH, NUM)
    166 # ---------------------------------
    167 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
    168 # on RHS.
    169 m4_define([b4_rhs_location],
    170 [(yylsp@{($2) - ($1)@})])
    171 
    172 
    173 ## -------------- ##
    174 ## Declarations.  ##
    175 ## -------------- ##
    176 
    177 # b4_declare_scanner_communication_variables
    178 # ------------------------------------------
    179 # Declare the variables that are global, or local to YYPARSE if
    180 # pure-parser.
    181 m4_define([b4_declare_scanner_communication_variables], [[
    182 /* The lookahead symbol.  */
    183 int yychar;
    184 
    185 ]b4_pure_if([[
    186 #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
    187 /* Suppress an incorrect diagnostic about yylval being uninitialized.  */
    188 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
    189     _Pragma ("GCC diagnostic push") \
    190     _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
    191     _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
    192 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
    193     _Pragma ("GCC diagnostic pop")
    194 #else
    195 /* Default value used for initialization, for pacifying older GCCs
    196    or non-GCC compilers.  */
    197 static YYSTYPE yyval_default;
    198 # define YY_INITIAL_VALUE(Value) = Value
    199 #endif]b4_locations_if([[
    200 static YYLTYPE yyloc_default][]b4_yyloc_default[;]])])[
    201 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
    202 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
    203 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
    204 #endif
    205 #ifndef YY_INITIAL_VALUE
    206 # define YY_INITIAL_VALUE(Value) /* Nothing. */
    207 #endif
    208 
    209 /* The semantic value of the lookahead symbol.  */
    210 YYSTYPE yylval YY_INITIAL_VALUE(yyval_default);]b4_locations_if([[
    211 
    212 /* Location data for the lookahead symbol.  */
    213 YYLTYPE yylloc]b4_pure_if([ = yyloc_default], [b4_yyloc_default])[;
    214 ]])b4_pure_if([], [[
    215 
    216 /* Number of syntax errors so far.  */
    217 int yynerrs;]])])
    218 
    219 
    220 # b4_declare_parser_state_variables
    221 # ---------------------------------
    222 # Declare all the variables that are needed to maintain the parser state
    223 # between calls to yypush_parse.
    224 m4_define([b4_declare_parser_state_variables], [b4_pure_if([[
    225     /* Number of syntax errors so far.  */
    226     int yynerrs;
    227 ]])[
    228     int yystate;
    229     /* Number of tokens to shift before error messages enabled.  */
    230     int yyerrstatus;
    231 
    232     /* The stacks and their tools:
    233        `yyss': related to states.
    234        `yyvs': related to semantic values.]b4_locations_if([[
    235        `yyls': related to locations.]])[
    236 
    237        Refer to the stacks through separate pointers, to allow yyoverflow
    238        to reallocate them elsewhere.  */
    239 
    240     /* The state stack.  */
    241     yytype_int16 yyssa[YYINITDEPTH];
    242     yytype_int16 *yyss;
    243     yytype_int16 *yyssp;
    244 
    245     /* The semantic value stack.  */
    246     YYSTYPE yyvsa[YYINITDEPTH];
    247     YYSTYPE *yyvs;
    248     YYSTYPE *yyvsp;]b4_locations_if([[
    249 
    250     /* The location stack.  */
    251     YYLTYPE yylsa[YYINITDEPTH];
    252     YYLTYPE *yyls;
    253     YYLTYPE *yylsp;
    254 
    255     /* The locations where the error started and ended.  */
    256     YYLTYPE yyerror_range[3];]])[
    257 
    258     YYSIZE_T yystacksize;]b4_lac_if([[
    259 
    260     yytype_int16 yyesa@{]b4_percent_define_get([[parse.lac.es-capacity-initial]])[@};
    261     yytype_int16 *yyes;
    262     YYSIZE_T yyes_capacity;]])])
    263 
    264 
    265 # b4_declare_yyparse_push_
    266 # ------------------------
    267 # Declaration of yyparse (and dependencies) when using the push parser
    268 # (including in pull mode).
    269 m4_define([b4_declare_yyparse_push_],
    270 [[#ifndef YYPUSH_MORE_DEFINED
    271 # define YYPUSH_MORE_DEFINED
    272 enum { YYPUSH_MORE = 4 };
    273 #endif
    274 
    275 typedef struct ]b4_prefix[pstate ]b4_prefix[pstate;
    276 
    277 ]b4_pull_if([b4_c_function_decl([b4_prefix[parse]], [[int]], b4_parse_param)
    278 ])b4_c_function_decl([b4_prefix[push_parse]], [[int]],
    279   [[b4_prefix[pstate *ps]], [[ps]]]b4_pure_if([,
    280   [[[int pushed_char]], [[pushed_char]]],
    281   [[b4_api_PREFIX[STYPE const *pushed_val]], [[pushed_val]]]b4_locations_if([,
    282   [[b4_api_PREFIX[LTYPE *pushed_loc]], [[pushed_loc]]]])])m4_ifset([b4_parse_param], [,
    283   b4_parse_param]))
    284 b4_pull_if([b4_c_function_decl([b4_prefix[pull_parse]], [[int]],
    285   [[b4_prefix[pstate *ps]], [[ps]]]m4_ifset([b4_parse_param], [,
    286   b4_parse_param]))])
    287 b4_c_function_decl([b4_prefix[pstate_new]], [b4_prefix[pstate *]],
    288                     [[[void]], []])
    289 b4_c_function_decl([b4_prefix[pstate_delete]], [[void]],
    290                    [[b4_prefix[pstate *ps]], [[ps]]])dnl
    291 ])
    292 
    293 # b4_declare_yyparse_
    294 # -------------------
    295 # When not the push parser.
    296 m4_define([b4_declare_yyparse_],
    297 [[#ifdef YYPARSE_PARAM
    298 ]b4_c_function_decl(b4_prefix[parse], [int],
    299                     [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])[
    300 #else /* ! YYPARSE_PARAM */
    301 ]b4_c_function_decl(b4_prefix[parse], [int], b4_parse_param)[
    302 #endif /* ! YYPARSE_PARAM */]dnl
    303 ])
    304 
    305 
    306 # b4_declare_yyparse
    307 # ------------------
    308 m4_define([b4_declare_yyparse],
    309 [b4_push_if([b4_declare_yyparse_push_],
    310             [b4_declare_yyparse_])[]dnl
    311 ])
    312 
    313 
    314 # b4_shared_declarations
    315 # ----------------------
    316 # Declaration that might either go into the header (if --defines)
    317 # or open coded in the parser body.
    318 m4_define([b4_shared_declarations],
    319 [b4_cpp_guard_open([b4_spec_defines_file])[
    320 ]b4_declare_yydebug[
    321 ]b4_percent_code_get([[requires]])[
    322 ]b4_token_enums_defines(b4_tokens)[
    323 ]b4_declare_yylstype[
    324 ]b4_declare_yyparse[
    325 ]b4_percent_code_get([[provides]])[
    326 ]b4_cpp_guard_close([b4_spec_defines_file])[]dnl
    327 ])
    328 
    329 
    330 ## -------------- ##
    331 ## Output files.  ##
    332 ## -------------- ##
    333 
    334 b4_output_begin([b4_parser_file_name])
    335 b4_copyright([Bison implementation for Yacc-like parsers in C],
    336              [1984, 1989-1990, 2000-2012])[
    337 
    338 /* C LALR(1) parser skeleton written by Richard Stallman, by
    339    simplifying the original so-called "semantic" parser.  */
    340 
    341 /* All symbols defined below should begin with yy or YY, to avoid
    342    infringing on user name space.  This should be done even for local
    343    variables, as they might otherwise be expanded by user macros.
    344    There are some unavoidable exceptions within include files to
    345    define necessary library symbols; they are noted "INFRINGES ON
    346    USER NAME SPACE" below.  */
    347 
    348 ]b4_identification
    349 b4_percent_code_get([[top]])[]dnl
    350 m4_if(b4_api_prefix, [yy], [],
    351 [[/* Substitute the type names.  */
    352 #define YYSTYPE         ]b4_api_PREFIX[STYPE]b4_locations_if([[
    353 #define YYLTYPE         ]b4_api_PREFIX[LTYPE]])])[
    354 ]m4_if(b4_prefix, [yy], [],
    355 [[/* Substitute the variable and function names.  */]b4_pull_if([[
    356 #define yyparse         ]b4_prefix[parse]])b4_push_if([[
    357 #define yypush_parse    ]b4_prefix[push_parse]b4_pull_if([[
    358 #define yypull_parse    ]b4_prefix[pull_parse]])[
    359 #define yypstate_new    ]b4_prefix[pstate_new
    360 #define yypstate_delete ]b4_prefix[pstate_delete
    361 #define yypstate        ]b4_prefix[pstate]])[
    362 #define yylex           ]b4_prefix[lex
    363 #define yyerror         ]b4_prefix[error
    364 #define yylval          ]b4_prefix[lval
    365 #define yychar          ]b4_prefix[char
    366 #define yydebug         ]b4_prefix[debug
    367 #define yynerrs         ]b4_prefix[nerrs]b4_locations_if([[
    368 #define yylloc          ]b4_prefix[lloc]])])[
    369 
    370 /* Copy the first part of user declarations.  */
    371 ]b4_user_pre_prologue[
    372 
    373 ]b4_null_define[
    374 
    375 /* Enabling verbose error messages.  */
    376 #ifdef YYERROR_VERBOSE
    377 # undef YYERROR_VERBOSE
    378 # define YYERROR_VERBOSE 1
    379 #else
    380 # define YYERROR_VERBOSE ]b4_error_verbose_flag[
    381 #endif
    382 
    383 ]m4_ifval(m4_quote(b4_spec_defines_file),
    384 [[/* In a future release of Bison, this section will be replaced
    385    by #include "@basename(]b4_spec_defines_file[@)".  */
    386 ]])dnl
    387 b4_shared_declarations[
    388 
    389 /* Copy the second part of user declarations.  */
    390 ]b4_user_post_prologue
    391 b4_percent_code_get[]dnl
    392 
    393 [#ifdef short
    394 # undef short
    395 #endif
    396 
    397 #ifdef YYTYPE_UINT8
    398 typedef YYTYPE_UINT8 yytype_uint8;
    399 #else
    400 typedef unsigned char yytype_uint8;
    401 #endif
    402 
    403 #ifdef YYTYPE_INT8
    404 typedef YYTYPE_INT8 yytype_int8;
    405 #elif ]b4_c_modern[
    406 typedef signed char yytype_int8;
    407 #else
    408 typedef short int yytype_int8;
    409 #endif
    410 
    411 #ifdef YYTYPE_UINT16
    412 typedef YYTYPE_UINT16 yytype_uint16;
    413 #else
    414 typedef unsigned short int yytype_uint16;
    415 #endif
    416 
    417 #ifdef YYTYPE_INT16
    418 typedef YYTYPE_INT16 yytype_int16;
    419 #else
    420 typedef short int yytype_int16;
    421 #endif
    422 
    423 #ifndef YYSIZE_T
    424 # ifdef __SIZE_TYPE__
    425 #  define YYSIZE_T __SIZE_TYPE__
    426 # elif defined size_t
    427 #  define YYSIZE_T size_t
    428 # elif ! defined YYSIZE_T && ]b4_c_modern[
    429 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
    430 #  define YYSIZE_T size_t
    431 # else
    432 #  define YYSIZE_T unsigned int
    433 # endif
    434 #endif
    435 
    436 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
    437 
    438 #ifndef YY_
    439 # if defined YYENABLE_NLS && YYENABLE_NLS
    440 #  if ENABLE_NLS
    441 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
    442 #   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
    443 #  endif
    444 # endif
    445 # ifndef YY_
    446 #  define YY_(Msgid) Msgid
    447 # endif
    448 #endif
    449 
    450 /* Suppress unused-variable warnings by "using" E.  */
    451 #if ! defined lint || defined __GNUC__
    452 # define YYUSE(E) ((void) (E))
    453 #else
    454 # define YYUSE(E) /* empty */
    455 #endif
    456 
    457 /* Identity function, used to suppress warnings about constant conditions.  */
    458 #ifndef lint
    459 # define YYID(N) (N)
    460 #else
    461 ]b4_c_function_def([YYID], [static int], [[int yyi], [yyi]])[
    462 {
    463   return yyi;
    464 }
    465 #endif
    466 
    467 #if ]b4_lac_if([[1]], [[! defined yyoverflow || YYERROR_VERBOSE]])[
    468 
    469 /* The parser invokes alloca or malloc; define the necessary symbols.  */]dnl
    470 b4_push_if([], [b4_lac_if([], [[
    471 
    472 # ifdef YYSTACK_USE_ALLOCA
    473 #  if YYSTACK_USE_ALLOCA
    474 #   ifdef __GNUC__
    475 #    define YYSTACK_ALLOC __builtin_alloca
    476 #   elif defined __BUILTIN_VA_ARG_INCR
    477 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
    478 #   elif defined _AIX
    479 #    define YYSTACK_ALLOC __alloca
    480 #   elif defined _MSC_VER
    481 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
    482 #    define alloca _alloca
    483 #   else
    484 #    define YYSTACK_ALLOC alloca
    485 #    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && ]b4_c_modern[
    486 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
    487       /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
    488 #     ifndef EXIT_SUCCESS
    489 #      define EXIT_SUCCESS 0
    490 #     endif
    491 #    endif
    492 #   endif
    493 #  endif
    494 # endif]])])[
    495 
    496 # ifdef YYSTACK_ALLOC
    497    /* Pacify GCC's `empty if-body' warning.  */
    498 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
    499 #  ifndef YYSTACK_ALLOC_MAXIMUM
    500     /* The OS might guarantee only one guard page at the bottom of the stack,
    501        and a page size can be as small as 4096 bytes.  So we cannot safely
    502        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
    503        to allow for a few compiler-allocated temporary stack slots.  */
    504 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
    505 #  endif
    506 # else
    507 #  define YYSTACK_ALLOC YYMALLOC
    508 #  define YYSTACK_FREE YYFREE
    509 #  ifndef YYSTACK_ALLOC_MAXIMUM
    510 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
    511 #  endif
    512 #  if (defined __cplusplus && ! defined EXIT_SUCCESS \
    513        && ! ((defined YYMALLOC || defined malloc) \
    514 	     && (defined YYFREE || defined free)))
    515 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
    516 #   ifndef EXIT_SUCCESS
    517 #    define EXIT_SUCCESS 0
    518 #   endif
    519 #  endif
    520 #  ifndef YYMALLOC
    521 #   define YYMALLOC malloc
    522 #   if ! defined malloc && ! defined EXIT_SUCCESS && ]b4_c_modern[
    523 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
    524 #   endif
    525 #  endif
    526 #  ifndef YYFREE
    527 #   define YYFREE free
    528 #   if ! defined free && ! defined EXIT_SUCCESS && ]b4_c_modern[
    529 void free (void *); /* INFRINGES ON USER NAME SPACE */
    530 #   endif
    531 #  endif
    532 # endif]b4_lac_if([[
    533 # define YYCOPY_NEEDED 1]])[
    534 #endif]b4_lac_if([], [[ /* ! defined yyoverflow || YYERROR_VERBOSE */]])[
    535 
    536 
    537 #if (! defined yyoverflow \
    538      && (! defined __cplusplus \
    539 	 || (]b4_locations_if([[defined ]b4_api_PREFIX[LTYPE_IS_TRIVIAL && ]b4_api_PREFIX[LTYPE_IS_TRIVIAL \
    540 	     && ]])[defined ]b4_api_PREFIX[STYPE_IS_TRIVIAL && ]b4_api_PREFIX[STYPE_IS_TRIVIAL)))
    541 
    542 /* A type that is properly aligned for any stack member.  */
    543 union yyalloc
    544 {
    545   yytype_int16 yyss_alloc;
    546   YYSTYPE yyvs_alloc;]b4_locations_if([
    547   YYLTYPE yyls_alloc;])[
    548 };
    549 
    550 /* The size of the maximum gap between one aligned stack and the next.  */
    551 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
    552 
    553 /* The size of an array large to enough to hold all stacks, each with
    554    N elements.  */
    555 ]b4_locations_if(
    556 [# define YYSTACK_BYTES(N) \
    557      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
    558       + 2 * YYSTACK_GAP_MAXIMUM)],
    559 [# define YYSTACK_BYTES(N) \
    560      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
    561       + YYSTACK_GAP_MAXIMUM)])[
    562 
    563 # define YYCOPY_NEEDED 1
    564 
    565 /* Relocate STACK from its old location to the new one.  The
    566    local variables YYSIZE and YYSTACKSIZE give the old and new number of
    567    elements in the stack, and YYPTR gives the new location of the
    568    stack.  Advance YYPTR to a properly aligned location for the next
    569    stack.  */
    570 # define YYSTACK_RELOCATE(Stack_alloc, Stack)				\
    571     do									\
    572       {									\
    573 	YYSIZE_T yynewbytes;						\
    574 	YYCOPY (&yyptr->Stack_alloc, Stack, yysize);			\
    575 	Stack = &yyptr->Stack_alloc;					\
    576 	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
    577 	yyptr += yynewbytes / sizeof (*yyptr);				\
    578       }									\
    579     while (YYID (0))
    580 
    581 #endif
    582 
    583 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
    584 /* Copy COUNT objects from SRC to DST.  The source and destination do
    585    not overlap.  */
    586 # ifndef YYCOPY
    587 #  if defined __GNUC__ && 1 < __GNUC__
    588 #   define YYCOPY(Dst, Src, Count) \
    589       __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
    590 #  else
    591 #   define YYCOPY(Dst, Src, Count)              \
    592       do                                        \
    593         {                                       \
    594           YYSIZE_T yyi;                         \
    595           for (yyi = 0; yyi < (Count); yyi++)   \
    596             (Dst)[yyi] = (Src)[yyi];            \
    597         }                                       \
    598       while (YYID (0))
    599 #  endif
    600 # endif
    601 #endif /* !YYCOPY_NEEDED */
    602 
    603 /* YYFINAL -- State number of the termination state.  */
    604 #define YYFINAL  ]b4_final_state_number[
    605 /* YYLAST -- Last index in YYTABLE.  */
    606 #define YYLAST   ]b4_last[
    607 
    608 /* YYNTOKENS -- Number of terminals.  */
    609 #define YYNTOKENS  ]b4_tokens_number[
    610 /* YYNNTS -- Number of nonterminals.  */
    611 #define YYNNTS  ]b4_nterms_number[
    612 /* YYNRULES -- Number of rules.  */
    613 #define YYNRULES  ]b4_rules_number[
    614 /* YYNRULES -- Number of states.  */
    615 #define YYNSTATES  ]b4_states_number[
    616 
    617 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
    618 #define YYUNDEFTOK  ]b4_undef_token_number[
    619 #define YYMAXUTOK   ]b4_user_token_number_max[
    620 
    621 #define YYTRANSLATE(YYX)						\
    622   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
    623 
    624 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
    625 static const ]b4_int_type_for([b4_translate])[ yytranslate[] =
    626 {
    627   ]b4_translate[
    628 };
    629 
    630 #if ]b4_api_PREFIX[DEBUG
    631 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
    632    YYRHS.  */
    633 static const ]b4_int_type_for([b4_prhs])[ yyprhs[] =
    634 {
    635   ]b4_prhs[
    636 };
    637 
    638 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
    639 static const ]b4_int_type_for([b4_rhs])[ yyrhs[] =
    640 {
    641   ]b4_rhs[
    642 };
    643 
    644 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
    645 static const ]b4_int_type_for([b4_rline])[ yyrline[] =
    646 {
    647   ]b4_rline[
    648 };
    649 #endif
    650 
    651 #if ]b4_api_PREFIX[DEBUG || YYERROR_VERBOSE || ]b4_token_table_flag[
    652 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
    653    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
    654 static const char *const yytname[] =
    655 {
    656   ]b4_tname[
    657 };
    658 #endif
    659 
    660 # ifdef YYPRINT
    661 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
    662    token YYLEX-NUM.  */
    663 static const ]b4_int_type_for([b4_toknum])[ yytoknum[] =
    664 {
    665   ]b4_toknum[
    666 };
    667 # endif
    668 
    669 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
    670 static const ]b4_int_type_for([b4_r1])[ yyr1[] =
    671 {
    672   ]b4_r1[
    673 };
    674 
    675 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
    676 static const ]b4_int_type_for([b4_r2])[ yyr2[] =
    677 {
    678   ]b4_r2[
    679 };
    680 
    681 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
    682    Performed when YYTABLE doesn't specify something else to do.  Zero
    683    means the default is an error.  */
    684 static const ]b4_int_type_for([b4_defact])[ yydefact[] =
    685 {
    686   ]b4_defact[
    687 };
    688 
    689 /* YYDEFGOTO[NTERM-NUM].  */
    690 static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] =
    691 {
    692   ]b4_defgoto[
    693 };
    694 
    695 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
    696    STATE-NUM.  */
    697 #define YYPACT_NINF ]b4_pact_ninf[
    698 static const ]b4_int_type_for([b4_pact])[ yypact[] =
    699 {
    700   ]b4_pact[
    701 };
    702 
    703 /* YYPGOTO[NTERM-NUM].  */
    704 static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] =
    705 {
    706   ]b4_pgoto[
    707 };
    708 
    709 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
    710    positive, shift that token.  If negative, reduce the rule which
    711    number is the opposite.  If YYTABLE_NINF, syntax error.  */
    712 #define YYTABLE_NINF ]b4_table_ninf[
    713 static const ]b4_int_type_for([b4_table])[ yytable[] =
    714 {
    715   ]b4_table[
    716 };
    717 
    718 #define yypact_value_is_default(Yystate) \
    719   ]b4_table_value_equals([[pact]], [[Yystate]], [b4_pact_ninf])[
    720 
    721 #define yytable_value_is_error(Yytable_value) \
    722   ]b4_table_value_equals([[table]], [[Yytable_value]], [b4_table_ninf])[
    723 
    724 static const ]b4_int_type_for([b4_check])[ yycheck[] =
    725 {
    726   ]b4_check[
    727 };
    728 
    729 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
    730    symbol of state STATE-NUM.  */
    731 static const ]b4_int_type_for([b4_stos])[ yystos[] =
    732 {
    733   ]b4_stos[
    734 };
    735 
    736 #define yyerrok		(yyerrstatus = 0)
    737 #define yyclearin	(yychar = YYEMPTY)
    738 #define YYEMPTY		(-2)
    739 #define YYEOF		0
    740 
    741 #define YYACCEPT	goto yyacceptlab
    742 #define YYABORT		goto yyabortlab
    743 #define YYERROR		goto yyerrorlab
    744 
    745 
    746 /* Like YYERROR except do call yyerror.  This remains here temporarily
    747    to ease the transition to the new meaning of YYERROR, for GCC.
    748    Once GCC version 2 has supplanted version 1, this can go.  However,
    749    YYFAIL appears to be in use.  Nevertheless, it is formally deprecated
    750    in Bison 2.4.2's NEWS entry, where a plan to phase it out is
    751    discussed.  */
    752 
    753 #define YYFAIL		goto yyerrlab
    754 #if defined YYFAIL
    755   /* This is here to suppress warnings from the GCC cpp's
    756      -Wunused-macros.  Normally we don't worry about that warning, but
    757      some users do, and we want to make it easy for users to remove
    758      YYFAIL uses, which will produce warnings from Bison 2.5.  */
    759 #endif
    760 
    761 #define YYRECOVERING()  (!!yyerrstatus)
    762 
    763 #define YYBACKUP(Token, Value)                                  \
    764 do                                                              \
    765   if (yychar == YYEMPTY)                                        \
    766     {                                                           \
    767       yychar = (Token);                                         \
    768       yylval = (Value);                                         \
    769       YYPOPSTACK (yylen);                                       \
    770       yystate = *yyssp;                                         \]b4_lac_if([[
    771       YY_LAC_DISCARD ("YYBACKUP");                              \]])[
    772       goto yybackup;                                            \
    773     }                                                           \
    774   else                                                          \
    775     {                                                           \
    776       yyerror (]b4_yyerror_args[YY_("syntax error: cannot back up")); \
    777       YYERROR;							\
    778     }								\
    779 while (YYID (0))
    780 
    781 /* Error token number */
    782 #define YYTERROR	1
    783 #define YYERRCODE	256
    784 
    785 ]b4_locations_if([[
    786 ]b4_yylloc_default_define[
    787 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
    788 ]])[
    789 ]b4_yy_location_print_define[
    790 
    791 /* YYLEX -- calling `yylex' with the right arguments.  */
    792 #ifdef YYLEX_PARAM
    793 # define YYLEX yylex (]b4_pure_if([&yylval[]b4_locations_if([, &yylloc]), ])[YYLEX_PARAM)
    794 #else
    795 # define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[
    796 #endif
    797 
    798 /* Enable debugging if requested.  */
    799 #if ]b4_api_PREFIX[DEBUG
    800 
    801 # ifndef YYFPRINTF
    802 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
    803 #  define YYFPRINTF fprintf
    804 # endif
    805 
    806 # define YYDPRINTF(Args)			\
    807 do {						\
    808   if (yydebug)					\
    809     YYFPRINTF Args;				\
    810 } while (YYID (0))
    811 
    812 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)			  \
    813 do {									  \
    814   if (yydebug)								  \
    815     {									  \
    816       YYFPRINTF (stderr, "%s ", Title);					  \
    817       yy_symbol_print (stderr,						  \
    818 		  Type, Value]b4_locations_if([, Location])[]b4_user_args[); \
    819       YYFPRINTF (stderr, "\n");						  \
    820     }									  \
    821 } while (YYID (0))
    822 
    823 ]b4_yy_symbol_print_generate([b4_c_function_def])[
    824 
    825 /*------------------------------------------------------------------.
    826 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
    827 | TOP (included).                                                   |
    828 `------------------------------------------------------------------*/
    829 
    830 ]b4_c_function_def([yy_stack_print], [static void],
    831 		   [[yytype_int16 *yybottom], [yybottom]],
    832 		   [[yytype_int16 *yytop],    [yytop]])[
    833 {
    834   YYFPRINTF (stderr, "Stack now");
    835   for (; yybottom <= yytop; yybottom++)
    836     {
    837       int yybot = *yybottom;
    838       YYFPRINTF (stderr, " %d", yybot);
    839     }
    840   YYFPRINTF (stderr, "\n");
    841 }
    842 
    843 # define YY_STACK_PRINT(Bottom, Top)				\
    844 do {								\
    845   if (yydebug)							\
    846     yy_stack_print ((Bottom), (Top));				\
    847 } while (YYID (0))
    848 
    849 
    850 /*------------------------------------------------.
    851 | Report that the YYRULE is going to be reduced.  |
    852 `------------------------------------------------*/
    853 
    854 ]b4_c_function_def([yy_reduce_print], [static void],
    855 		   [[YYSTYPE *yyvsp], [yyvsp]],
    856     b4_locations_if([[[YYLTYPE *yylsp], [yylsp]],
    857 		   ])[[int yyrule], [yyrule]]m4_ifset([b4_parse_param], [,
    858 		   b4_parse_param]))[
    859 {
    860   int yynrhs = yyr2[yyrule];
    861   int yyi;
    862   unsigned long int yylno = yyrline[yyrule];
    863   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
    864 	     yyrule - 1, yylno);
    865   /* The symbols being reduced.  */
    866   for (yyi = 0; yyi < yynrhs; yyi++)
    867     {
    868       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
    869       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
    870 		       &]b4_rhs_value(yynrhs, yyi + 1)[
    871 		       ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl
    872 		       b4_user_args[);
    873       YYFPRINTF (stderr, "\n");
    874     }
    875 }
    876 
    877 # define YY_REDUCE_PRINT(Rule)		\
    878 do {					\
    879   if (yydebug)				\
    880     yy_reduce_print (yyvsp, ]b4_locations_if([yylsp, ])[Rule]b4_user_args[); \
    881 } while (YYID (0))
    882 
    883 /* Nonzero means print parse trace.  It is left uninitialized so that
    884    multiple parsers can coexist.  */
    885 int yydebug;
    886 #else /* !]b4_api_PREFIX[DEBUG */
    887 # define YYDPRINTF(Args)
    888 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
    889 # define YY_STACK_PRINT(Bottom, Top)
    890 # define YY_REDUCE_PRINT(Rule)
    891 #endif /* !]b4_api_PREFIX[DEBUG */
    892 
    893 
    894 /* YYINITDEPTH -- initial size of the parser's stacks.  */
    895 #ifndef	YYINITDEPTH
    896 # define YYINITDEPTH ]b4_stack_depth_init[
    897 #endif
    898 
    899 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
    900    if the built-in stack extension method is used).
    901 
    902    Do not make this value too large; the results are undefined if
    903    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
    904    evaluated with infinite-precision integer arithmetic.  */
    905 
    906 #ifndef YYMAXDEPTH
    907 # define YYMAXDEPTH ]b4_stack_depth_max[
    908 #endif]b4_lac_if([[
    909 
    910 /* Given a state stack such that *YYBOTTOM is its bottom, such that
    911    *YYTOP is either its top or is YYTOP_EMPTY to indicate an empty
    912    stack, and such that *YYCAPACITY is the maximum number of elements it
    913    can hold without a reallocation, make sure there is enough room to
    914    store YYADD more elements.  If not, allocate a new stack using
    915    YYSTACK_ALLOC, copy the existing elements, and adjust *YYBOTTOM,
    916    *YYTOP, and *YYCAPACITY to reflect the new capacity and memory
    917    location.  If *YYBOTTOM != YYBOTTOM_NO_FREE, then free the old stack
    918    using YYSTACK_FREE.  Return 0 if successful or if no reallocation is
    919    required.  Return 1 if memory is exhausted.  */
    920 static int
    921 yy_lac_stack_realloc (YYSIZE_T *yycapacity, YYSIZE_T yyadd,
    922 #if ]b4_api_PREFIX[DEBUG
    923                       char const *yydebug_prefix,
    924                       char const *yydebug_suffix,
    925 #endif
    926                       yytype_int16 **yybottom,
    927                       yytype_int16 *yybottom_no_free,
    928                       yytype_int16 **yytop, yytype_int16 *yytop_empty)
    929 {
    930   YYSIZE_T yysize_old =
    931     *yytop == yytop_empty ? 0 : *yytop - *yybottom + 1;
    932   YYSIZE_T yysize_new = yysize_old + yyadd;
    933   if (*yycapacity < yysize_new)
    934     {
    935       YYSIZE_T yyalloc = 2 * yysize_new;
    936       yytype_int16 *yybottom_new;
    937       /* Use YYMAXDEPTH for maximum stack size given that the stack
    938          should never need to grow larger than the main state stack
    939          needs to grow without LAC.  */
    940       if (YYMAXDEPTH < yysize_new)
    941         {
    942           YYDPRINTF ((stderr, "%smax size exceeded%s", yydebug_prefix,
    943                       yydebug_suffix));
    944           return 1;
    945         }
    946       if (YYMAXDEPTH < yyalloc)
    947         yyalloc = YYMAXDEPTH;
    948       yybottom_new =
    949         (yytype_int16*) YYSTACK_ALLOC (yyalloc * sizeof *yybottom_new);
    950       if (!yybottom_new)
    951         {
    952           YYDPRINTF ((stderr, "%srealloc failed%s", yydebug_prefix,
    953                       yydebug_suffix));
    954           return 1;
    955         }
    956       if (*yytop != yytop_empty)
    957         {
    958           YYCOPY (yybottom_new, *yybottom, yysize_old);
    959           *yytop = yybottom_new + (yysize_old - 1);
    960         }
    961       if (*yybottom != yybottom_no_free)
    962         YYSTACK_FREE (*yybottom);
    963       *yybottom = yybottom_new;
    964       *yycapacity = yyalloc;]m4_if(b4_percent_define_get([[parse.lac.memory-trace]]),
    965                                    [full], [[
    966       YYDPRINTF ((stderr, "%srealloc to %lu%s", yydebug_prefix,
    967                   (unsigned long int) yyalloc, yydebug_suffix));]])[
    968     }
    969   return 0;
    970 }
    971 
    972 /* Establish the initial context for the current lookahead if no initial
    973    context is currently established.
    974 
    975    We define a context as a snapshot of the parser stacks.  We define
    976    the initial context for a lookahead as the context in which the
    977    parser initially examines that lookahead in order to select a
    978    syntactic action.  Thus, if the lookahead eventually proves
    979    syntactically unacceptable (possibly in a later context reached via a
    980    series of reductions), the initial context can be used to determine
    981    the exact set of tokens that would be syntactically acceptable in the
    982    lookahead's place.  Moreover, it is the context after which any
    983    further semantic actions would be erroneous because they would be
    984    determined by a syntactically unacceptable token.
    985 
    986    YY_LAC_ESTABLISH should be invoked when a reduction is about to be
    987    performed in an inconsistent state (which, for the purposes of LAC,
    988    includes consistent states that don't know they're consistent because
    989    their default reductions have been disabled).  Iff there is a
    990    lookahead token, it should also be invoked before reporting a syntax
    991    error.  This latter case is for the sake of the debugging output.
    992 
    993    For parse.lac=full, the implementation of YY_LAC_ESTABLISH is as
    994    follows.  If no initial context is currently established for the
    995    current lookahead, then check if that lookahead can eventually be
    996    shifted if syntactic actions continue from the current context.
    997    Report a syntax error if it cannot.  */
    998 #define YY_LAC_ESTABLISH                                         \
    999 do {                                                             \
   1000   if (!yy_lac_established)                                       \
   1001     {                                                            \
   1002       YYDPRINTF ((stderr,                                        \
   1003                   "LAC: initial context established for %s\n",   \
   1004                   yytname[yytoken]));                            \
   1005       yy_lac_established = 1;                                    \
   1006       {                                                          \
   1007         int yy_lac_status =                                      \
   1008           yy_lac (yyesa, &yyes, &yyes_capacity, yyssp, yytoken); \
   1009         if (yy_lac_status == 2)                                  \
   1010           goto yyexhaustedlab;                                   \
   1011         if (yy_lac_status == 1)                                  \
   1012           goto yyerrlab;                                         \
   1013       }                                                          \
   1014     }                                                            \
   1015 } while (YYID (0))
   1016 
   1017 /* Discard any previous initial lookahead context because of Event,
   1018    which may be a lookahead change or an invalidation of the currently
   1019    established initial context for the current lookahead.
   1020 
   1021    The most common example of a lookahead change is a shift.  An example
   1022    of both cases is syntax error recovery.  That is, a syntax error
   1023    occurs when the lookahead is syntactically erroneous for the
   1024    currently established initial context, so error recovery manipulates
   1025    the parser stacks to try to find a new initial context in which the
   1026    current lookahead is syntactically acceptable.  If it fails to find
   1027    such a context, it discards the lookahead.  */
   1028 #if ]b4_api_PREFIX[DEBUG
   1029 # define YY_LAC_DISCARD(Event)                                           \
   1030 do {                                                                     \
   1031   if (yy_lac_established)                                                \
   1032     {                                                                    \
   1033       if (yydebug)                                                       \
   1034         YYFPRINTF (stderr, "LAC: initial context discarded due to "      \
   1035                    Event "\n");                                          \
   1036       yy_lac_established = 0;                                            \
   1037     }                                                                    \
   1038 } while (YYID (0))
   1039 #else
   1040 # define YY_LAC_DISCARD(Event) yy_lac_established = 0
   1041 #endif
   1042 
   1043 /* Given the stack whose top is *YYSSP, return 0 iff YYTOKEN can
   1044    eventually (after perhaps some reductions) be shifted, return 1 if
   1045    not, or return 2 if memory is exhausted.  As preconditions and
   1046    postconditions: *YYES_CAPACITY is the allocated size of the array to
   1047    which *YYES points, and either *YYES = YYESA or *YYES points to an
   1048    array allocated with YYSTACK_ALLOC.  yy_lac may overwrite the
   1049    contents of either array, alter *YYES and *YYES_CAPACITY, and free
   1050    any old *YYES other than YYESA.  */
   1051 static int
   1052 yy_lac (yytype_int16 *yyesa, yytype_int16 **yyes,
   1053         YYSIZE_T *yyes_capacity, yytype_int16 *yyssp, int yytoken)
   1054 {
   1055   yytype_int16 *yyes_prev = yyssp;
   1056   yytype_int16 *yyesp = yyes_prev;
   1057   YYDPRINTF ((stderr, "LAC: checking lookahead %s:", yytname[yytoken]));
   1058   if (yytoken == YYUNDEFTOK)
   1059     {
   1060       YYDPRINTF ((stderr, " Always Err\n"));
   1061       return 1;
   1062     }
   1063   while (1)
   1064     {
   1065       int yyrule = yypact[*yyesp];
   1066       if (yypact_value_is_default (yyrule)
   1067           || (yyrule += yytoken) < 0 || YYLAST < yyrule
   1068           || yycheck[yyrule] != yytoken)
   1069         {
   1070           yyrule = yydefact[*yyesp];
   1071           if (yyrule == 0)
   1072             {
   1073               YYDPRINTF ((stderr, " Err\n"));
   1074               return 1;
   1075             }
   1076         }
   1077       else
   1078         {
   1079           yyrule = yytable[yyrule];
   1080           if (yytable_value_is_error (yyrule))
   1081             {
   1082               YYDPRINTF ((stderr, " Err\n"));
   1083               return 1;
   1084             }
   1085           if (0 < yyrule)
   1086             {
   1087               YYDPRINTF ((stderr, " S%d\n", yyrule));
   1088               return 0;
   1089             }
   1090           yyrule = -yyrule;
   1091         }
   1092       {
   1093         YYSIZE_T yylen = yyr2[yyrule];
   1094         YYDPRINTF ((stderr, " R%d", yyrule - 1));
   1095         if (yyesp != yyes_prev)
   1096           {
   1097             YYSIZE_T yysize = yyesp - *yyes + 1;
   1098             if (yylen < yysize)
   1099               {
   1100                 yyesp -= yylen;
   1101                 yylen = 0;
   1102               }
   1103             else
   1104               {
   1105                 yylen -= yysize;
   1106                 yyesp = yyes_prev;
   1107               }
   1108           }
   1109         if (yylen)
   1110           yyesp = yyes_prev -= yylen;
   1111       }
   1112       {
   1113         int yystate;
   1114         {
   1115           int yylhs = yyr1[yyrule] - YYNTOKENS;
   1116           yystate = yypgoto[yylhs] + *yyesp;
   1117           if (yystate < 0 || YYLAST < yystate
   1118               || yycheck[yystate] != *yyesp)
   1119             yystate = yydefgoto[yylhs];
   1120           else
   1121             yystate = yytable[yystate];
   1122         }
   1123         if (yyesp == yyes_prev)
   1124           {
   1125             yyesp = *yyes;
   1126             *yyesp = yystate;
   1127           }
   1128         else
   1129           {
   1130             if (yy_lac_stack_realloc (yyes_capacity, 1,
   1131 #if ]b4_api_PREFIX[DEBUG
   1132                                       " (", ")",
   1133 #endif
   1134                                       yyes, yyesa, &yyesp, yyes_prev))
   1135               {
   1136                 YYDPRINTF ((stderr, "\n"));
   1137                 return 2;
   1138               }
   1139             *++yyesp = yystate;
   1140           }
   1141         YYDPRINTF ((stderr, " G%d", yystate));
   1142       }
   1143     }
   1144 }]])[
   1145 
   1146 
   1147 #if YYERROR_VERBOSE
   1148 
   1149 # ifndef yystrlen
   1150 #  if defined __GLIBC__ && defined _STRING_H
   1151 #   define yystrlen strlen
   1152 #  else
   1153 /* Return the length of YYSTR.  */
   1154 ]b4_c_function_def([yystrlen], [static YYSIZE_T],
   1155    [[const char *yystr], [yystr]])[
   1156 {
   1157   YYSIZE_T yylen;
   1158   for (yylen = 0; yystr[yylen]; yylen++)
   1159     continue;
   1160   return yylen;
   1161 }
   1162 #  endif
   1163 # endif
   1164 
   1165 # ifndef yystpcpy
   1166 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
   1167 #   define yystpcpy stpcpy
   1168 #  else
   1169 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
   1170    YYDEST.  */
   1171 ]b4_c_function_def([yystpcpy], [static char *],
   1172    [[char *yydest], [yydest]], [[const char *yysrc], [yysrc]])[
   1173 {
   1174   char *yyd = yydest;
   1175   const char *yys = yysrc;
   1176 
   1177   while ((*yyd++ = *yys++) != '\0')
   1178     continue;
   1179 
   1180   return yyd - 1;
   1181 }
   1182 #  endif
   1183 # endif
   1184 
   1185 # ifndef yytnamerr
   1186 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
   1187    quotes and backslashes, so that it's suitable for yyerror.  The
   1188    heuristic is that double-quoting is unnecessary unless the string
   1189    contains an apostrophe, a comma, or backslash (other than
   1190    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
   1191    null, do not copy; instead, return the length of what the result
   1192    would have been.  */
   1193 static YYSIZE_T
   1194 yytnamerr (char *yyres, const char *yystr)
   1195 {
   1196   if (*yystr == '"')
   1197     {
   1198       YYSIZE_T yyn = 0;
   1199       char const *yyp = yystr;
   1200 
   1201       for (;;)
   1202 	switch (*++yyp)
   1203 	  {
   1204 	  case '\'':
   1205 	  case ',':
   1206 	    goto do_not_strip_quotes;
   1207 
   1208 	  case '\\':
   1209 	    if (*++yyp != '\\')
   1210 	      goto do_not_strip_quotes;
   1211 	    /* Fall through.  */
   1212 	  default:
   1213 	    if (yyres)
   1214 	      yyres[yyn] = *yyp;
   1215 	    yyn++;
   1216 	    break;
   1217 
   1218 	  case '"':
   1219 	    if (yyres)
   1220 	      yyres[yyn] = '\0';
   1221 	    return yyn;
   1222 	  }
   1223     do_not_strip_quotes: ;
   1224     }
   1225 
   1226   if (! yyres)
   1227     return yystrlen (yystr);
   1228 
   1229   return yystpcpy (yyres, yystr) - yyres;
   1230 }
   1231 # endif
   1232 
   1233 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
   1234    about the unexpected token YYTOKEN for the state stack whose top is
   1235    YYSSP.]b4_lac_if([[  In order to see if a particular token T is a
   1236    valid looakhead, invoke yy_lac (YYESA, YYES, YYES_CAPACITY, YYSSP, T).]])[
   1237 
   1238    Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
   1239    not large enough to hold the message.  In that case, also set
   1240    *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
   1241    required number of bytes is too large to store]b4_lac_if([[ or if
   1242    yy_lac returned 2]])[.  */
   1243 static int
   1244 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
   1245                 ]b4_lac_if([[yytype_int16 *yyesa, yytype_int16 **yyes,
   1246                 YYSIZE_T *yyes_capacity, ]])[yytype_int16 *yyssp, int yytoken)
   1247 {
   1248   YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]);
   1249   YYSIZE_T yysize = yysize0;
   1250   enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
   1251   /* Internationalized format string. */
   1252   const char *yyformat = YY_NULL;
   1253   /* Arguments of yyformat. */
   1254   char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
   1255   /* Number of reported tokens (one for the "unexpected", one per
   1256      "expected"). */
   1257   int yycount = 0;
   1258 
   1259   /* There are many possibilities here to consider:
   1260      - Assume YYFAIL is not used.  It's too flawed to consider.  See
   1261        <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
   1262        for details.  YYERROR is fine as it does not invoke this
   1263        function.
   1264      - If this state is a consistent state with a default action, then
   1265        the only way this function was invoked is if the default action
   1266        is an error action.  In that case, don't check for expected
   1267        tokens because there are none.
   1268      - The only way there can be no lookahead present (in yychar) is if
   1269        this state is a consistent state with a default action.  Thus,
   1270        detecting the absence of a lookahead is sufficient to determine
   1271        that there is no unexpected or expected token to report.  In that
   1272        case, just report a simple "syntax error".
   1273      - Don't assume there isn't a lookahead just because this state is a
   1274        consistent state with a default action.  There might have been a
   1275        previous inconsistent state, consistent state with a non-default
   1276        action, or user semantic action that manipulated yychar.]b4_lac_if([[
   1277        In the first two cases, it might appear that the current syntax
   1278        error should have been detected in the previous state when yy_lac
   1279        was invoked.  However, at that time, there might have been a
   1280        different syntax error that discarded a different initial context
   1281        during error recovery, leaving behind the current lookahead.]], [[
   1282      - Of course, the expected token list depends on states to have
   1283        correct lookahead information, and it depends on the parser not
   1284        to perform extra reductions after fetching a lookahead from the
   1285        scanner and before detecting a syntax error.  Thus, state merging
   1286        (from LALR or IELR) and default reductions corrupt the expected
   1287        token list.  However, the list is correct for canonical LR with
   1288        one exception: it will still contain any token that will not be
   1289        accepted due to an error action in a later state.]])[
   1290   */
   1291   if (yytoken != YYEMPTY)
   1292     {
   1293       int yyn = yypact[*yyssp];]b4_lac_if([[
   1294       YYDPRINTF ((stderr, "Constructing syntax error message\n"));]])[
   1295       yyarg[yycount++] = yytname[yytoken];
   1296       if (!yypact_value_is_default (yyn))
   1297         {]b4_lac_if([], [[
   1298           /* Start YYX at -YYN if negative to avoid negative indexes in
   1299              YYCHECK.  In other words, skip the first -YYN actions for
   1300              this state because they are default actions.  */
   1301           int yyxbegin = yyn < 0 ? -yyn : 0;
   1302           /* Stay within bounds of both yycheck and yytname.  */
   1303           int yychecklim = YYLAST - yyn + 1;
   1304           int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;]])[
   1305           int yyx;]b4_lac_if([[
   1306 
   1307           for (yyx = 0; yyx < YYNTOKENS; ++yyx)
   1308             if (yyx != YYTERROR && yyx != YYUNDEFTOK)
   1309               {
   1310                 {
   1311                   int yy_lac_status = yy_lac (yyesa, yyes, yyes_capacity,
   1312                                               yyssp, yyx);
   1313                   if (yy_lac_status == 2)
   1314                     return 2;
   1315                   if (yy_lac_status == 1)
   1316                     continue;
   1317                 }]], [[
   1318 
   1319           for (yyx = yyxbegin; yyx < yyxend; ++yyx)
   1320             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
   1321                 && !yytable_value_is_error (yytable[yyx + yyn]))
   1322               {]])[
   1323                 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
   1324                   {
   1325                     yycount = 1;
   1326                     yysize = yysize0;
   1327                     break;
   1328                   }
   1329                 yyarg[yycount++] = yytname[yyx];
   1330                 {
   1331                   YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]);
   1332                   if (! (yysize <= yysize1
   1333                          && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
   1334                     return 2;
   1335                   yysize = yysize1;
   1336                 }
   1337               }
   1338         }]b4_lac_if([[
   1339 # if ]b4_api_PREFIX[DEBUG
   1340       else if (yydebug)
   1341         YYFPRINTF (stderr, "No expected tokens.\n");
   1342 # endif]])[
   1343     }
   1344 
   1345   switch (yycount)
   1346     {
   1347 # define YYCASE_(N, S)                      \
   1348       case N:                               \
   1349         yyformat = S;                       \
   1350       break
   1351       YYCASE_(0, YY_("syntax error"));
   1352       YYCASE_(1, YY_("syntax error, unexpected %s"));
   1353       YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
   1354       YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
   1355       YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
   1356       YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
   1357 # undef YYCASE_
   1358     }
   1359 
   1360   {
   1361     YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
   1362     if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
   1363       return 2;
   1364     yysize = yysize1;
   1365   }
   1366 
   1367   if (*yymsg_alloc < yysize)
   1368     {
   1369       *yymsg_alloc = 2 * yysize;
   1370       if (! (yysize <= *yymsg_alloc
   1371              && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
   1372         *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
   1373       return 1;
   1374     }
   1375 
   1376   /* Avoid sprintf, as that infringes on the user's name space.
   1377      Don't have undefined behavior even if the translation
   1378      produced a string with the wrong number of "%s"s.  */
   1379   {
   1380     char *yyp = *yymsg;
   1381     int yyi = 0;
   1382     while ((*yyp = *yyformat) != '\0')
   1383       if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
   1384         {
   1385           yyp += yytnamerr (yyp, yyarg[yyi++]);
   1386           yyformat += 2;
   1387         }
   1388       else
   1389         {
   1390           yyp++;
   1391           yyformat++;
   1392         }
   1393   }
   1394   return 0;
   1395 }
   1396 #endif /* YYERROR_VERBOSE */
   1397 
   1398 ]b4_yydestruct_generate([b4_c_function_def])[
   1399 
   1400 ]b4_pure_if([], [
   1401 
   1402 b4_declare_scanner_communication_variables])[]b4_push_if([[
   1403 
   1404 struct yypstate
   1405   {]b4_declare_parser_state_variables[
   1406     /* Used to determine if this is the first time this instance has
   1407        been used.  */
   1408     int yynew;
   1409   };]b4_pure_if([], [[
   1410 
   1411 static char yypstate_allocated = 0;]])b4_pull_if([
   1412 
   1413 b4_c_function_def([[yyparse]], [[int]], b4_parse_param)[
   1414 {
   1415   return yypull_parse (YY_NULL]m4_ifset([b4_parse_param],
   1416                                   [[, ]b4_c_args(b4_parse_param)])[);
   1417 }
   1418 
   1419 ]b4_c_function_def([[yypull_parse]], [[int]],
   1420   [[[yypstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [,
   1421   b4_parse_param]))[
   1422 {
   1423   int yystatus;
   1424   yypstate *yyps_local;]b4_pure_if([[
   1425   int yychar;
   1426   YYSTYPE yylval;]b4_locations_if([[
   1427   static YYLTYPE yyloc_default][]b4_yyloc_default[;
   1428   YYLTYPE yylloc = yyloc_default;]])])[
   1429   if (yyps)
   1430     yyps_local = yyps;
   1431   else
   1432     {
   1433       yyps_local = yypstate_new ();
   1434       if (!yyps_local)
   1435         {]b4_pure_if([[
   1436           yyerror (]b4_yyerror_args[YY_("memory exhausted"));]], [[
   1437           if (!yypstate_allocated)
   1438             yyerror (]b4_yyerror_args[YY_("memory exhausted"));]])[
   1439           return 2;
   1440         }
   1441     }
   1442   do {
   1443     yychar = YYLEX;
   1444     yystatus =
   1445       yypush_parse (yyps_local]b4_pure_if([[, yychar, &yylval]b4_locations_if([[, &yylloc]])])m4_ifset([b4_parse_param], [, b4_c_args(b4_parse_param)])[);
   1446   } while (yystatus == YYPUSH_MORE);
   1447   if (!yyps)
   1448     yypstate_delete (yyps_local);
   1449   return yystatus;
   1450 }]])[
   1451 
   1452 /* Initialize the parser data structure.  */
   1453 ]b4_c_function_def([[yypstate_new]], [[yypstate *]])[
   1454 {
   1455   yypstate *yyps;]b4_pure_if([], [[
   1456   if (yypstate_allocated)
   1457     return YY_NULL;]])[
   1458   yyps = (yypstate *) malloc (sizeof *yyps);
   1459   if (!yyps)
   1460     return YY_NULL;
   1461   yyps->yynew = 1;]b4_pure_if([], [[
   1462   yypstate_allocated = 1;]])[
   1463   return yyps;
   1464 }
   1465 
   1466 ]b4_c_function_def([[yypstate_delete]], [[void]],
   1467                    [[[yypstate *yyps]], [[yyps]]])[
   1468 {
   1469 #ifndef yyoverflow
   1470   /* If the stack was reallocated but the parse did not complete, then the
   1471      stack still needs to be freed.  */
   1472   if (!yyps->yynew && yyps->yyss != yyps->yyssa)
   1473     YYSTACK_FREE (yyps->yyss);
   1474 #endif]b4_lac_if([[
   1475   if (!yyps->yynew && yyps->yyes != yyps->yyesa)
   1476     YYSTACK_FREE (yyps->yyes);]])[
   1477   free (yyps);]b4_pure_if([], [[
   1478   yypstate_allocated = 0;]])[
   1479 }
   1480 ]b4_pure_if([[
   1481 #define ]b4_prefix[nerrs yyps->]b4_prefix[nerrs]])[
   1482 #define yystate yyps->yystate
   1483 #define yyerrstatus yyps->yyerrstatus
   1484 #define yyssa yyps->yyssa
   1485 #define yyss yyps->yyss
   1486 #define yyssp yyps->yyssp
   1487 #define yyvsa yyps->yyvsa
   1488 #define yyvs yyps->yyvs
   1489 #define yyvsp yyps->yyvsp]b4_locations_if([[
   1490 #define yylsa yyps->yylsa
   1491 #define yyls yyps->yyls
   1492 #define yylsp yyps->yylsp
   1493 #define yyerror_range yyps->yyerror_range]])[
   1494 #define yystacksize yyps->yystacksize]b4_lac_if([[
   1495 #define yyesa yyps->yyesa
   1496 #define yyes yyps->yyes
   1497 #define yyes_capacity yyps->yyes_capacity]])[
   1498 
   1499 
   1500 /*---------------.
   1501 | yypush_parse.  |
   1502 `---------------*/
   1503 
   1504 ]b4_c_function_def([[yypush_parse]], [[int]],
   1505   [[[yypstate *yyps]], [[yyps]]]b4_pure_if([,
   1506   [[[int yypushed_char]], [[yypushed_char]]],
   1507   [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
   1508   [[[YYLTYPE *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [,
   1509   b4_parse_param]))], [[
   1510 
   1511 
   1512 /*----------.
   1513 | yyparse.  |
   1514 `----------*/
   1515 
   1516 #ifdef YYPARSE_PARAM
   1517 ]b4_c_function_def([yyparse], [int],
   1518                    [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])[
   1519 #else /* ! YYPARSE_PARAM */
   1520 ]b4_c_function_def([yyparse], [int], b4_parse_param)[
   1521 #endif]])[
   1522 {]b4_pure_if([b4_declare_scanner_communication_variables
   1523 ])b4_push_if([b4_pure_if([], [[
   1524   int yypushed_char = yychar;
   1525   YYSTYPE yypushed_val = yylval;]b4_locations_if([[
   1526   YYLTYPE yypushed_loc = yylloc;]])
   1527 ])],
   1528   [b4_declare_parser_state_variables
   1529 ])b4_lac_if([[
   1530   int yy_lac_established = 0;]])[
   1531   int yyn;
   1532   int yyresult;
   1533   /* Lookahead token as an internal (translated) token number.  */
   1534   int yytoken = 0;
   1535   /* The variables used to return semantic value and location from the
   1536      action routines.  */
   1537   YYSTYPE yyval;]b4_locations_if([[
   1538   YYLTYPE yyloc;]])[
   1539 
   1540 #if YYERROR_VERBOSE
   1541   /* Buffer for error messages, and its allocated size.  */
   1542   char yymsgbuf[128];
   1543   char *yymsg = yymsgbuf;
   1544   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
   1545 #endif
   1546 
   1547 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N)]b4_locations_if([, yylsp -= (N)])[)
   1548 
   1549   /* The number of symbols on the RHS of the reduced rule.
   1550      Keep to zero when no symbol should be popped.  */
   1551   int yylen = 0;]b4_push_if([[
   1552 
   1553   if (!yyps->yynew)
   1554     {
   1555       yyn = yypact[yystate];
   1556       goto yyread_pushed_token;
   1557     }]])[
   1558 
   1559   yyssp = yyss = yyssa;
   1560   yyvsp = yyvs = yyvsa;]b4_locations_if([[
   1561   yylsp = yyls = yylsa;]])[
   1562   yystacksize = YYINITDEPTH;]b4_lac_if([[
   1563 
   1564   yyes = yyesa;
   1565   yyes_capacity = sizeof yyesa / sizeof *yyes;
   1566   if (YYMAXDEPTH < yyes_capacity)
   1567     yyes_capacity = YYMAXDEPTH;]])[
   1568 
   1569   YYDPRINTF ((stderr, "Starting parse\n"));
   1570 
   1571   yystate = 0;
   1572   yyerrstatus = 0;
   1573   yynerrs = 0;
   1574   yychar = YYEMPTY; /* Cause a token to be read.  */
   1575 ]m4_ifdef([b4_initial_action], [
   1576 b4_dollar_pushdef([m4_define([b4_dollar_dollar_used])yylval], [],
   1577                   [b4_push_if([b4_pure_if([*])yypushed_loc], [yylloc])])dnl
   1578 /* User initialization code.  */
   1579 b4_user_initial_action
   1580 b4_dollar_popdef[]dnl
   1581 m4_ifdef([b4_dollar_dollar_used],[[  yyvsp[0] = yylval;
   1582 ]])])dnl
   1583 b4_locations_if([[  yylsp[0] = ]b4_push_if([b4_pure_if([*])yypushed_loc], [yylloc])[;
   1584 ]])dnl
   1585 [  goto yysetstate;
   1586 
   1587 /*------------------------------------------------------------.
   1588 | yynewstate -- Push a new state, which is found in yystate.  |
   1589 `------------------------------------------------------------*/
   1590  yynewstate:
   1591   /* In all cases, when you get here, the value and location stacks
   1592      have just been pushed.  So pushing a state here evens the stacks.  */
   1593   yyssp++;
   1594 
   1595  yysetstate:
   1596   *yyssp = yystate;
   1597 
   1598   if (yyss + yystacksize - 1 <= yyssp)
   1599     {
   1600       /* Get the current used size of the three stacks, in elements.  */
   1601       YYSIZE_T yysize = yyssp - yyss + 1;
   1602 
   1603 #ifdef yyoverflow
   1604       {
   1605 	/* Give user a chance to reallocate the stack.  Use copies of
   1606 	   these so that the &'s don't force the real ones into
   1607 	   memory.  */
   1608 	YYSTYPE *yyvs1 = yyvs;
   1609 	yytype_int16 *yyss1 = yyss;]b4_locations_if([
   1610 	YYLTYPE *yyls1 = yyls;])[
   1611 
   1612 	/* Each stack pointer address is followed by the size of the
   1613 	   data in use in that stack, in bytes.  This used to be a
   1614 	   conditional around just the two extra args, but that might
   1615 	   be undefined if yyoverflow is a macro.  */
   1616 	yyoverflow (YY_("memory exhausted"),
   1617 		    &yyss1, yysize * sizeof (*yyssp),
   1618 		    &yyvs1, yysize * sizeof (*yyvsp),]b4_locations_if([
   1619 		    &yyls1, yysize * sizeof (*yylsp),])[
   1620 		    &yystacksize);
   1621 ]b4_locations_if([
   1622 	yyls = yyls1;])[
   1623 	yyss = yyss1;
   1624 	yyvs = yyvs1;
   1625       }
   1626 #else /* no yyoverflow */
   1627 # ifndef YYSTACK_RELOCATE
   1628       goto yyexhaustedlab;
   1629 # else
   1630       /* Extend the stack our own way.  */
   1631       if (YYMAXDEPTH <= yystacksize)
   1632 	goto yyexhaustedlab;
   1633       yystacksize *= 2;
   1634       if (YYMAXDEPTH < yystacksize)
   1635 	yystacksize = YYMAXDEPTH;
   1636 
   1637       {
   1638 	yytype_int16 *yyss1 = yyss;
   1639 	union yyalloc *yyptr =
   1640 	  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
   1641 	if (! yyptr)
   1642 	  goto yyexhaustedlab;
   1643 	YYSTACK_RELOCATE (yyss_alloc, yyss);
   1644 	YYSTACK_RELOCATE (yyvs_alloc, yyvs);]b4_locations_if([
   1645 	YYSTACK_RELOCATE (yyls_alloc, yyls);])[
   1646 #  undef YYSTACK_RELOCATE
   1647 	if (yyss1 != yyssa)
   1648 	  YYSTACK_FREE (yyss1);
   1649       }
   1650 # endif
   1651 #endif /* no yyoverflow */
   1652 
   1653       yyssp = yyss + yysize - 1;
   1654       yyvsp = yyvs + yysize - 1;]b4_locations_if([
   1655       yylsp = yyls + yysize - 1;])[
   1656 
   1657       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
   1658 		  (unsigned long int) yystacksize));
   1659 
   1660       if (yyss + yystacksize - 1 <= yyssp)
   1661 	YYABORT;
   1662     }
   1663 
   1664   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
   1665 
   1666   if (yystate == YYFINAL)
   1667     YYACCEPT;
   1668 
   1669   goto yybackup;
   1670 
   1671 /*-----------.
   1672 | yybackup.  |
   1673 `-----------*/
   1674 yybackup:
   1675 
   1676   /* Do appropriate processing given the current state.  Read a
   1677      lookahead token if we need one and don't already have one.  */
   1678 
   1679   /* First try to decide what to do without reference to lookahead token.  */
   1680   yyn = yypact[yystate];
   1681   if (yypact_value_is_default (yyn))
   1682     goto yydefault;
   1683 
   1684   /* Not known => get a lookahead token if don't already have one.  */
   1685 
   1686   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
   1687   if (yychar == YYEMPTY)
   1688     {]b4_push_if([[
   1689       if (!yyps->yynew)
   1690         {]b4_use_push_for_pull_if([], [[
   1691           YYDPRINTF ((stderr, "Return for a new token:\n"));]])[
   1692           yyresult = YYPUSH_MORE;
   1693           goto yypushreturn;
   1694         }
   1695       yyps->yynew = 0;]b4_pure_if([], [[
   1696       /* Restoring the pushed token is only necessary for the first
   1697          yypush_parse invocation since subsequent invocations don't overwrite
   1698          it before jumping to yyread_pushed_token.  */
   1699       yychar = yypushed_char;
   1700       yylval = yypushed_val;]b4_locations_if([[
   1701       yylloc = yypushed_loc;]])])[
   1702 yyread_pushed_token:]])[
   1703       YYDPRINTF ((stderr, "Reading a token: "));]b4_push_if([b4_pure_if([[
   1704       yychar = yypushed_char;
   1705       if (yypushed_val)
   1706         yylval = *yypushed_val;]b4_locations_if([[
   1707       if (yypushed_loc)
   1708         yylloc = *yypushed_loc;]])])], [[
   1709       yychar = YYLEX;]])[
   1710     }
   1711 
   1712   if (yychar <= YYEOF)
   1713     {
   1714       yychar = yytoken = YYEOF;
   1715       YYDPRINTF ((stderr, "Now at end of input.\n"));
   1716     }
   1717   else
   1718     {
   1719       yytoken = YYTRANSLATE (yychar);
   1720       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
   1721     }
   1722 
   1723   /* If the proper action on seeing token YYTOKEN is to reduce or to
   1724      detect an error, take that action.  */
   1725   yyn += yytoken;
   1726   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)]b4_lac_if([[
   1727     {
   1728       YY_LAC_ESTABLISH;
   1729       goto yydefault;
   1730     }]], [[
   1731     goto yydefault;]])[
   1732   yyn = yytable[yyn];
   1733   if (yyn <= 0)
   1734     {
   1735       if (yytable_value_is_error (yyn))
   1736         goto yyerrlab;]b4_lac_if([[
   1737       YY_LAC_ESTABLISH;]])[
   1738       yyn = -yyn;
   1739       goto yyreduce;
   1740     }
   1741 
   1742   /* Count tokens shifted since error; after three, turn off error
   1743      status.  */
   1744   if (yyerrstatus)
   1745     yyerrstatus--;
   1746 
   1747   /* Shift the lookahead token.  */
   1748   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
   1749 
   1750   /* Discard the shifted token.  */
   1751   yychar = YYEMPTY;]b4_lac_if([[
   1752   YY_LAC_DISCARD ("shift");]])[
   1753 
   1754   yystate = yyn;
   1755   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
   1756   *++yyvsp = yylval;
   1757   YY_IGNORE_MAYBE_UNINITIALIZED_END
   1758 ]b4_locations_if([  *++yylsp = yylloc;])[
   1759   goto yynewstate;
   1760 
   1761 
   1762 /*-----------------------------------------------------------.
   1763 | yydefault -- do the default action for the current state.  |
   1764 `-----------------------------------------------------------*/
   1765 yydefault:
   1766   yyn = yydefact[yystate];
   1767   if (yyn == 0)
   1768     goto yyerrlab;
   1769   goto yyreduce;
   1770 
   1771 
   1772 /*-----------------------------.
   1773 | yyreduce -- Do a reduction.  |
   1774 `-----------------------------*/
   1775 yyreduce:
   1776   /* yyn is the number of a rule to reduce with.  */
   1777   yylen = yyr2[yyn];
   1778 
   1779   /* If YYLEN is nonzero, implement the default value of the action:
   1780      `$$ = $1'.
   1781 
   1782      Otherwise, the following line sets YYVAL to garbage.
   1783      This behavior is undocumented and Bison
   1784      users should not rely upon it.  Assigning to YYVAL
   1785      unconditionally makes the parser a bit smaller, and it avoids a
   1786      GCC warning that YYVAL may be used uninitialized.  */
   1787   yyval = yyvsp[1-yylen];
   1788 
   1789 ]b4_locations_if(
   1790 [[  /* Default location.  */
   1791   YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);]])[
   1792   YY_REDUCE_PRINT (yyn);]b4_lac_if([[
   1793   {
   1794     int yychar_backup = yychar;
   1795     switch (yyn)
   1796       {
   1797         ]b4_user_actions[
   1798         default: break;
   1799       }
   1800     if (yychar_backup != yychar)
   1801       YY_LAC_DISCARD ("yychar change");
   1802   }]], [[
   1803   switch (yyn)
   1804     {
   1805       ]b4_user_actions[
   1806       default: break;
   1807     }]])[
   1808   /* User semantic actions sometimes alter yychar, and that requires
   1809      that yytoken be updated with the new translation.  We take the
   1810      approach of translating immediately before every use of yytoken.
   1811      One alternative is translating here after every semantic action,
   1812      but that translation would be missed if the semantic action invokes
   1813      YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
   1814      if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
   1815      incorrect destructor might then be invoked immediately.  In the
   1816      case of YYERROR or YYBACKUP, subsequent parser actions might lead
   1817      to an incorrect destructor call or verbose syntax error message
   1818      before the lookahead is translated.  */
   1819   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
   1820 
   1821   YYPOPSTACK (yylen);
   1822   yylen = 0;
   1823   YY_STACK_PRINT (yyss, yyssp);
   1824 
   1825   *++yyvsp = yyval;]b4_locations_if([
   1826   *++yylsp = yyloc;])[
   1827 
   1828   /* Now `shift' the result of the reduction.  Determine what state
   1829      that goes to, based on the state we popped back to and the rule
   1830      number reduced by.  */
   1831 
   1832   yyn = yyr1[yyn];
   1833 
   1834   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
   1835   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
   1836     yystate = yytable[yystate];
   1837   else
   1838     yystate = yydefgoto[yyn - YYNTOKENS];
   1839 
   1840   goto yynewstate;
   1841 
   1842 
   1843 /*------------------------------------.
   1844 | yyerrlab -- here on detecting error |
   1845 `------------------------------------*/
   1846 yyerrlab:
   1847   /* Make sure we have latest lookahead translation.  See comments at
   1848      user semantic actions for why this is necessary.  */
   1849   yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
   1850 
   1851   /* If not already recovering from an error, report this error.  */
   1852   if (!yyerrstatus)
   1853     {
   1854       ++yynerrs;
   1855 #if ! YYERROR_VERBOSE
   1856       yyerror (]b4_yyerror_args[YY_("syntax error"));
   1857 #else
   1858 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \]b4_lac_if([[
   1859                                         yyesa, &yyes, &yyes_capacity, \]])[
   1860                                         yyssp, yytoken)
   1861       {
   1862         char const *yymsgp = YY_("syntax error");
   1863         int yysyntax_error_status;]b4_lac_if([[
   1864         if (yychar != YYEMPTY)
   1865           YY_LAC_ESTABLISH;]])[
   1866         yysyntax_error_status = YYSYNTAX_ERROR;
   1867         if (yysyntax_error_status == 0)
   1868           yymsgp = yymsg;
   1869         else if (yysyntax_error_status == 1)
   1870           {
   1871             if (yymsg != yymsgbuf)
   1872               YYSTACK_FREE (yymsg);
   1873             yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
   1874             if (!yymsg)
   1875               {
   1876                 yymsg = yymsgbuf;
   1877                 yymsg_alloc = sizeof yymsgbuf;
   1878                 yysyntax_error_status = 2;
   1879               }
   1880             else
   1881               {
   1882                 yysyntax_error_status = YYSYNTAX_ERROR;
   1883                 yymsgp = yymsg;
   1884               }
   1885           }
   1886         yyerror (]b4_yyerror_args[yymsgp);
   1887         if (yysyntax_error_status == 2)
   1888           goto yyexhaustedlab;
   1889       }
   1890 # undef YYSYNTAX_ERROR
   1891 #endif
   1892     }
   1893 
   1894 ]b4_locations_if([[  yyerror_range[1] = yylloc;]])[
   1895 
   1896   if (yyerrstatus == 3)
   1897     {
   1898       /* If just tried and failed to reuse lookahead token after an
   1899 	 error, discard it.  */
   1900 
   1901       if (yychar <= YYEOF)
   1902 	{
   1903 	  /* Return failure if at end of input.  */
   1904 	  if (yychar == YYEOF)
   1905 	    YYABORT;
   1906 	}
   1907       else
   1908 	{
   1909 	  yydestruct ("Error: discarding",
   1910 		      yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
   1911 	  yychar = YYEMPTY;
   1912 	}
   1913     }
   1914 
   1915   /* Else will try to reuse lookahead token after shifting the error
   1916      token.  */
   1917   goto yyerrlab1;
   1918 
   1919 
   1920 /*---------------------------------------------------.
   1921 | yyerrorlab -- error raised explicitly by YYERROR.  |
   1922 `---------------------------------------------------*/
   1923 yyerrorlab:
   1924 
   1925   /* Pacify compilers like GCC when the user code never invokes
   1926      YYERROR and the label yyerrorlab therefore never appears in user
   1927      code.  */
   1928   if (/*CONSTCOND*/ 0)
   1929      goto yyerrorlab;
   1930 
   1931 ]b4_locations_if([[  yyerror_range[1] = yylsp[1-yylen];
   1932 ]])[  /* Do not reclaim the symbols of the rule which action triggered
   1933      this YYERROR.  */
   1934   YYPOPSTACK (yylen);
   1935   yylen = 0;
   1936   YY_STACK_PRINT (yyss, yyssp);
   1937   yystate = *yyssp;
   1938   goto yyerrlab1;
   1939 
   1940 
   1941 /*-------------------------------------------------------------.
   1942 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
   1943 `-------------------------------------------------------------*/
   1944 yyerrlab1:
   1945   yyerrstatus = 3;	/* Each real token shifted decrements this.  */
   1946 
   1947   for (;;)
   1948     {
   1949       yyn = yypact[yystate];
   1950       if (!yypact_value_is_default (yyn))
   1951 	{
   1952 	  yyn += YYTERROR;
   1953 	  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
   1954 	    {
   1955 	      yyn = yytable[yyn];
   1956 	      if (0 < yyn)
   1957 		break;
   1958 	    }
   1959 	}
   1960 
   1961       /* Pop the current state because it cannot handle the error token.  */
   1962       if (yyssp == yyss)
   1963 	YYABORT;
   1964 
   1965 ]b4_locations_if([[      yyerror_range[1] = *yylsp;]])[
   1966       yydestruct ("Error: popping",
   1967 		  yystos[yystate], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[);
   1968       YYPOPSTACK (1);
   1969       yystate = *yyssp;
   1970       YY_STACK_PRINT (yyss, yyssp);
   1971     }]b4_lac_if([[
   1972 
   1973   /* If the stack popping above didn't lose the initial context for the
   1974      current lookahead token, the shift below will for sure.  */
   1975   YY_LAC_DISCARD ("error recovery");]])[
   1976 
   1977   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
   1978   *++yyvsp = yylval;
   1979   YY_IGNORE_MAYBE_UNINITIALIZED_END
   1980 ]b4_locations_if([[
   1981   yyerror_range[2] = yylloc;
   1982   /* Using YYLLOC is tempting, but would change the location of
   1983      the lookahead.  YYLOC is available though.  */
   1984   YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
   1985   *++yylsp = yyloc;]])[
   1986 
   1987   /* Shift the error token.  */
   1988   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
   1989 
   1990   yystate = yyn;
   1991   goto yynewstate;
   1992 
   1993 
   1994 /*-------------------------------------.
   1995 | yyacceptlab -- YYACCEPT comes here.  |
   1996 `-------------------------------------*/
   1997 yyacceptlab:
   1998   yyresult = 0;
   1999   goto yyreturn;
   2000 
   2001 /*-----------------------------------.
   2002 | yyabortlab -- YYABORT comes here.  |
   2003 `-----------------------------------*/
   2004 yyabortlab:
   2005   yyresult = 1;
   2006   goto yyreturn;
   2007 
   2008 #if ]b4_lac_if([[1]], [[!defined yyoverflow || YYERROR_VERBOSE]])[
   2009 /*-------------------------------------------------.
   2010 | yyexhaustedlab -- memory exhaustion comes here.  |
   2011 `-------------------------------------------------*/
   2012 yyexhaustedlab:
   2013   yyerror (]b4_yyerror_args[YY_("memory exhausted"));
   2014   yyresult = 2;
   2015   /* Fall through.  */
   2016 #endif
   2017 
   2018 yyreturn:
   2019   if (yychar != YYEMPTY)
   2020     {
   2021       /* Make sure we have latest lookahead translation.  See comments at
   2022          user semantic actions for why this is necessary.  */
   2023       yytoken = YYTRANSLATE (yychar);
   2024       yydestruct ("Cleanup: discarding lookahead",
   2025                   yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
   2026     }
   2027   /* Do not reclaim the symbols of the rule which action triggered
   2028      this YYABORT or YYACCEPT.  */
   2029   YYPOPSTACK (yylen);
   2030   YY_STACK_PRINT (yyss, yyssp);
   2031   while (yyssp != yyss)
   2032     {
   2033       yydestruct ("Cleanup: popping",
   2034 		  yystos[*yyssp], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[);
   2035       YYPOPSTACK (1);
   2036     }
   2037 #ifndef yyoverflow
   2038   if (yyss != yyssa)
   2039     YYSTACK_FREE (yyss);
   2040 #endif]b4_lac_if([[
   2041   if (yyes != yyesa)
   2042     YYSTACK_FREE (yyes);]])b4_push_if([[
   2043   yyps->yynew = 1;
   2044 
   2045 yypushreturn:]])[
   2046 #if YYERROR_VERBOSE
   2047   if (yymsg != yymsgbuf)
   2048     YYSTACK_FREE (yymsg);
   2049 #endif
   2050   /* Make sure YYID is used.  */
   2051   return YYID (yyresult);
   2052 }
   2053 
   2054 
   2055 ]b4_epilogue[]dnl
   2056 b4_output_end()
   2057 
   2058 b4_defines_if(
   2059 [b4_output_begin([b4_spec_defines_file])[
   2060 ]b4_copyright([Bison interface for Yacc-like parsers in C],
   2061               [1984, 1989-1990, 2000-2012])[
   2062 
   2063 ]b4_shared_declarations[
   2064 ]b4_output_end()
   2065 ])
   2066