data/yacc.c

   1                                                              -*- C -*-
   2 # Yacc compatible skeleton for Bison
   3
   4 # Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
   5 # 2007, 2008 Free Software Foundation, Inc.
   6
   7 m4_pushdef([b4_copyright_years],
   8 [1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008])
   9
  10 # This program is free software: you can redistribute it and/or modify
  11 # it under the terms of the GNU General Public License as published by
  12 # the Free Software Foundation, either version 3 of the License, or
  13 # (at your option) any later version.
  14 #
  15 # This program is distributed in the hope that it will be useful,
  16 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 # GNU General Public License for more details.
  19 #
  20 # You should have received a copy of the GNU General Public License
  21 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22
  23 # Check the value of %define api.push_pull.
  24 b4_percent_define_default([[api.push_pull]], [[pull]])
  25 b4_percent_define_check_values([[[[api.push_pull]],
  26                                [[pull]], [[push]], [[both]]]])
  27 b4_define_flag_if([pull]) m4_define([b4_pull_flag], [[1]])
  28 b4_define_flag_if([push]) m4_define([b4_push_flag], [[1]])
  29 m4_case(b4_percent_define_get([[api.push_pull]]),
  30         [pull], [m4_define([b4_push_flag], [[0]])],
  31         [push], [m4_define([b4_pull_flag], [[0]])])
  32
  33 # Handle BISON_USE_PUSH_FOR_PULL for the test suite.  So that push parsing
  34 # tests function as written, don't let BISON_USE_PUSH_FOR_PULL modify Bison's
  35 # behavior at all when push parsing is already requested.
  36 b4_define_flag_if([use_push_for_pull])
  37 b4_use_push_for_pull_if([
  38   b4_push_if([m4_define([b4_use_push_for_pull_flag], [[0]])],
  39              [m4_define([b4_push_flag], [[1]])])])
  40
  41 m4_include(b4_pkgdatadir/[c.m4])
  42
  43 ## ---------------- ##
  44 ## Default values.  ##
  45 ## ---------------- ##
  46
  47 # Stack parameters.
  48 m4_define_default([b4_stack_depth_max], [10000])
  49 m4_define_default([b4_stack_depth_init],  [200])
  50
  51
  52 ## ------------------------ ##
  53 ## Pure/impure interfaces.  ##
  54 ## ------------------------ ##
  55
  56 b4_percent_define_default([[api.pure]], [[false]])
  57 b4_define_flag_if([pure])
  58 m4_define([b4_pure_flag],
  59           [b4_percent_define_flag_if([[api.pure]], [[1]], [[0]])])
  60
  61 # b4_yacc_pure_if(IF-TRUE, IF-FALSE)
  62 # ----------------------------------
  63 # Expand IF-TRUE, if %pure-parser and %parse-param, IF-FALSE otherwise.
  64 m4_define([b4_yacc_pure_if],
  65 [b4_pure_if([m4_ifset([b4_parse_param],
  66                       [$1], [$2])],
  67             [$2])])
  68
  69
  70 # b4_yyerror_args
  71 # ---------------
  72 # Arguments passed to yyerror: user args plus yylloc.
  73 m4_define([b4_yyerror_args],
  74 [b4_yacc_pure_if([b4_locations_if([&yylloc, ])])dnl
  75 m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
  76
  77
  78 # b4_lex_param
  79 # ------------
  80 # Accumulate in b4_lex_param all the yylex arguments.
  81 # b4_lex_param arrives quoted twice, but we want to keep only one level.
  82 m4_define([b4_lex_param],
  83 m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl
  84 b4_locations_if([, [[YYLTYPE *], [&yylloc]]])m4_ifdef([b4_lex_param], [, ])])dnl
  85 m4_ifdef([b4_lex_param], b4_lex_param)))
  86
  87
  88 ## ------------ ##
  89 ## Data Types.  ##
  90 ## ------------ ##
  91
  92 # b4_int_type(MIN, MAX)
  93 # ---------------------
  94 # Return the smallest int type able to handle numbers ranging from
  95 # MIN to MAX (included).  Overwrite the version from c.m4, which
  96 # uses only C89 types, so that the user can override the shorter
  97 # types, and so that pre-C89 compilers are handled correctly.
  98 m4_define([b4_int_type],
  99 [m4_if(b4_ints_in($@,      [0],   [255]), [1], [yytype_uint8],
 100        b4_ints_in($@,   [-128],   [127]), [1], [yytype_int8],
 101
 102        b4_ints_in($@,      [0], [65535]), [1], [yytype_uint16],
 103        b4_ints_in($@, [-32768], [32767]), [1], [yytype_int16],
 104
 105        m4_eval([0 <= $1]),                [1], [unsigned int],
 106
 107                                                [int])])
 108
 109
 110 ## ----------------- ##
 111 ## Semantic Values.  ##
 112 ## ----------------- ##
 113
 114
 115 # b4_lhs_value([TYPE])
 116 # --------------------
 117 # Expansion of $<TYPE>$.
 118 m4_define([b4_lhs_value],
 119 [b4_symbol_value(yyval, [$1])])
 120
 121
 122 # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
 123 # --------------------------------------
 124 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
 125 # symbols on RHS.
 126 m4_define([b4_rhs_value],
 127           [b4_symbol_value([yyvsp@{b4_subtract([$2], [$1])@}], [$3])])
 128
 129
 130
 131 ## ----------- ##
 132 ## Locations.  ##
 133 ## ----------- ##
 134
 135 # b4_lhs_location()
 136 # -----------------
 137 # Expansion of @$.
 138 m4_define([b4_lhs_location],
 139 [(yyloc)])
 140
 141
 142 # b4_rhs_location(RULE-LENGTH, NUM)
 143 # ---------------------------------
 144 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
 145 # on RHS.
 146 m4_define([b4_rhs_location],
 147           [(yylsp@{b4_subtract([$2], [$1])@})])
 148
 149
 150
 151 ## --------------------------------------------------------- ##
 152 ## Defining symbol actions, e.g., printers and destructors.  ##
 153 ## --------------------------------------------------------- ##
 154
 155 # We do want M4 expansion after # for CPP macros.
 156 m4_changecom()
 157 m4_divert_push(0)dnl
 158 @output(b4_parser_file_name@)@
 159 b4_copyright([Implementation for Bison's Yacc-like parsers in C])dnl'
 160 [
 161
 162 /* C LALR(1) parser skeleton written by Richard Stallman, by
 163    simplifying the original so-called "semantic" parser.  */
 164
 165 /* All symbols defined below should begin with yy or YY, to avoid
 166    infringing on user name space.  This should be done even for local
 167    variables, as they might otherwise be expanded by user macros.
 168    There are some unavoidable exceptions within include files to
 169    define necessary library symbols; they are noted "INFRINGES ON
 170    USER NAME SPACE" below.  */
 171
 172 ]b4_identification
 173 b4_percent_code_get([[top]])[]dnl
 174 m4_if(b4_prefix, [yy], [],
 175 [[/* Substitute the variable and function names.  */
 176 ]b4_pull_if([[#define yyparse         ]b4_prefix[parse
 177 ]])b4_push_if([[#define yypush_parse    ]b4_prefix[push_parse
 178 ]b4_pull_if([[#define yypull_parse    ]b4_prefix[pull_parse
 179 ]])[#define yypstate_new    ]b4_prefix[pstate_new
 180 #define yypstate_delete ]b4_prefix[pstate_delete
 181 #define yypstate        ]b4_prefix[pstate
 182 ]])[#define yylex           ]b4_prefix[lex
 183 #define yyerror         ]b4_prefix[error
 184 #define yylval          ]b4_prefix[lval
 185 #define yychar          ]b4_prefix[char
 186 #define yydebug         ]b4_prefix[debug
 187 #define yynerrs         ]b4_prefix[nerrs
 188 ]b4_locations_if([[#define yylloc          ]b4_prefix[lloc]])])[
 189
 190 /* Copy the first part of user declarations.  */
 191 ]b4_user_pre_prologue[
 192
 193 /* Enabling traces.  */
 194 #ifndef YYDEBUG
 195 # define YYDEBUG ]b4_debug_flag[
 196 #endif
 197
 198 /* Enabling verbose error messages.  */
 199 #ifdef YYERROR_VERBOSE
 200 # undef YYERROR_VERBOSE
 201 # define YYERROR_VERBOSE 1
 202 #else
 203 # define YYERROR_VERBOSE ]b4_error_verbose_flag[
 204 #endif
 205
 206 /* Enabling the token table.  */
 207 #ifndef YYTOKEN_TABLE
 208 # define YYTOKEN_TABLE ]b4_token_table[
 209 #endif
 210
 211 ]b4_percent_code_get([[requires]])[]dnl
 212
 213 b4_token_enums_defines(b4_tokens)[
 214
 215 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 216 ]m4_ifdef([b4_stype],
 217 [[typedef union ]b4_union_name[
 218 {
 219 ]b4_user_stype[
 220 } YYSTYPE;
 221 # define YYSTYPE_IS_TRIVIAL 1]],
 222 [m4_if(b4_tag_seen_flag, 0,
 223 [[typedef int YYSTYPE;
 224 # define YYSTYPE_IS_TRIVIAL 1]])])[
 225 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
 226 # define YYSTYPE_IS_DECLARED 1
 227 #endif]b4_locations_if([[
 228
 229 #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
 230 typedef struct YYLTYPE
 231 {
 232   int first_line;
 233   int first_column;
 234   int last_line;
 235   int last_column;
 236 } YYLTYPE;
 237 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
 238 # define YYLTYPE_IS_DECLARED 1
 239 # define YYLTYPE_IS_TRIVIAL 1
 240 #endif]])b4_push_if([[
 241
 242 #ifndef YYPUSH_DECLS
 243 #  define YYPUSH_DECLS
 244 struct yypstate;
 245 typedef struct yypstate yypstate;
 246 enum { YYPUSH_MORE = 4 };
 247
 248 ]b4_pull_if([b4_c_function_decl([[yyparse]], [[int]], b4_parse_param)
 249 ])b4_c_function_decl([[yypush_parse]], [[int]],
 250   [[[yypstate *yyps]], [[yyps]]]b4_pure_if([,
 251   [[[int yypushed_char]], [[yypushed_char]]],
 252   [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
 253   [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [,
 254   b4_parse_param]))
 255 b4_pull_if([b4_c_function_decl([[yypull_parse]], [[int]],
 256   [[[yypstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [,
 257   b4_parse_param]))])
 258 b4_c_function_decl([[yypstate_new]], [[yypstate *]], [[[void]], []])
 259 b4_c_function_decl([[yypstate_delete]], [[void]],
 260                    [[[yypstate *yyps]], [[yyps]]])[
 261 #endif]])
 262
 263 b4_percent_code_get([[provides]])[]dnl
 264
 265 [/* Copy the second part of user declarations.  */
 266 ]b4_user_post_prologue
 267 b4_percent_code_get[]dnl
 268
 269 [#ifdef short
 270 # undef short
 271 #endif
 272
 273 #ifdef YYTYPE_UINT8
 274 typedef YYTYPE_UINT8 yytype_uint8;
 275 #else
 276 typedef unsigned char yytype_uint8;
 277 #endif
 278
 279 #ifdef YYTYPE_INT8
 280 typedef YYTYPE_INT8 yytype_int8;
 281 #elif ]b4_c_modern[
 282 typedef signed char yytype_int8;
 283 #else
 284 typedef short int yytype_int8;
 285 #endif
 286
 287 #ifdef YYTYPE_UINT16
 288 typedef YYTYPE_UINT16 yytype_uint16;
 289 #else
 290 typedef unsigned short int yytype_uint16;
 291 #endif
 292
 293 #ifdef YYTYPE_INT16
 294 typedef YYTYPE_INT16 yytype_int16;
 295 #else
 296 typedef short int yytype_int16;
 297 #endif
 298
 299 #ifndef YYSIZE_T
 300 # ifdef __SIZE_TYPE__
 301 #  define YYSIZE_T __SIZE_TYPE__
 302 # elif defined size_t
 303 #  define YYSIZE_T size_t
 304 # elif ! defined YYSIZE_T && ]b4_c_modern[
 305 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
 306 #  define YYSIZE_T size_t
 307 # else
 308 #  define YYSIZE_T unsigned int
 309 # endif
 310 #endif
 311
 312 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
 313
 314 #ifndef YY_
 315 # if YYENABLE_NLS
 316 #  if ENABLE_NLS
 317 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
 318 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
 319 #  endif
 320 # endif
 321 # ifndef YY_
 322 #  define YY_(msgid) msgid
 323 # endif
 324 #endif
 325
 326 /* Suppress unused-variable warnings by "using" E.  */
 327 #if ! defined lint || defined __GNUC__
 328 # define YYUSE(e) ((void) (e))
 329 #else
 330 # define YYUSE(e) /* empty */
 331 #endif
 332
 333 /* Identity function, used to suppress warnings about constant conditions.  */
 334 #ifndef lint
 335 # define YYID(n) (n)
 336 #else
 337 ]b4_c_function_def([YYID], [static int], [[int yyi], [yyi]])[
 338 {
 339   return yyi;
 340 }
 341 #endif
 342
 343 #if ! defined yyoverflow || YYERROR_VERBOSE
 344
 345 ]b4_push_if([],
 346 [[/* The parser invokes alloca or malloc; define the necessary symbols.  */
 347
 348 # ifdef YYSTACK_USE_ALLOCA
 349 #  if YYSTACK_USE_ALLOCA
 350 #   ifdef __GNUC__
 351 #    define YYSTACK_ALLOC __builtin_alloca
 352 #   elif defined __BUILTIN_VA_ARG_INCR
 353 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
 354 #   elif defined _AIX
 355 #    define YYSTACK_ALLOC __alloca
 356 #   elif defined _MSC_VER
 357 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
 358 #    define alloca _alloca
 359 #   else
 360 #    define YYSTACK_ALLOC alloca
 361 #    if ! defined _ALLOCA_H && ! defined _STDLIB_H && ]b4_c_modern[
 362 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 363 #     ifndef _STDLIB_H
 364 #      define _STDLIB_H 1
 365 #     endif
 366 #    endif
 367 #   endif
 368 #  endif
 369 # endif
 370
 371 ]])dnl
 372 [# ifdef YYSTACK_ALLOC
 373    /* Pacify GCC's `empty if-body' warning.  */
 374 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
 375 #  ifndef YYSTACK_ALLOC_MAXIMUM
 376     /* The OS might guarantee only one guard page at the bottom of the stack,
 377        and a page size can be as small as 4096 bytes.  So we cannot safely
 378        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
 379        to allow for a few compiler-allocated temporary stack slots.  */
 380 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
 381 #  endif
 382 # else
 383 #  define YYSTACK_ALLOC YYMALLOC
 384 #  define YYSTACK_FREE YYFREE
 385 #  ifndef YYSTACK_ALLOC_MAXIMUM
 386 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
 387 #  endif
 388 #  if (defined __cplusplus && ! defined _STDLIB_H \
 389        && ! ((defined YYMALLOC || defined malloc) \
 390              && (defined YYFREE || defined free)))
 391 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 392 #   ifndef _STDLIB_H
 393 #    define _STDLIB_H 1
 394 #   endif
 395 #  endif
 396 #  ifndef YYMALLOC
 397 #   define YYMALLOC malloc
 398 #   if ! defined malloc && ! defined _STDLIB_H && ]b4_c_modern[
 399 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
 400 #   endif
 401 #  endif
 402 #  ifndef YYFREE
 403 #   define YYFREE free
 404 #   if ! defined free && ! defined _STDLIB_H && ]b4_c_modern[
 405 void free (void *); /* INFRINGES ON USER NAME SPACE */
 406 #   endif
 407 #  endif
 408 # endif
 409 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
 410
 411
 412 #if (! defined yyoverflow \
 413      && (! defined __cplusplus \
 414          || (]b4_locations_if([[defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
 415              && ]])[defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
 416
 417 /* A type that is properly aligned for any stack member.  */
 418 union yyalloc
 419 {
 420   yytype_int16 yyss_alloc;
 421   YYSTYPE yyvs_alloc;]b4_locations_if([
 422   YYLTYPE yyls_alloc;])[
 423 };
 424
 425 /* The size of the maximum gap between one aligned stack and the next.  */
 426 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
 427
 428 /* The size of an array large to enough to hold all stacks, each with
 429    N elements.  */
 430 ]b4_locations_if(
 431 [# define YYSTACK_BYTES(N) \
 432      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
 433       + 2 * YYSTACK_GAP_MAXIMUM)],
 434 [# define YYSTACK_BYTES(N) \
 435      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
 436       + YYSTACK_GAP_MAXIMUM)])[
 437
 438 /* Copy COUNT objects from FROM to TO.  The source and destination do
 439    not overlap.  */
 440 # ifndef YYCOPY
 441 #  if defined __GNUC__ && 1 < __GNUC__
 442 #   define YYCOPY(To, From, Count) \
 443       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
 444 #  else
 445 #   define YYCOPY(To, From, Count)              \
 446       do                                        \
 447         {                                       \
 448           YYSIZE_T yyi;                         \
 449           for (yyi = 0; yyi < (Count); yyi++)   \
 450             (To)[yyi] = (From)[yyi];            \
 451         }                                       \
 452       while (YYID (0))
 453 #  endif
 454 # endif
 455
 456 /* Relocate STACK from its old location to the new one.  The
 457    local variables YYSIZE and YYSTACKSIZE give the old and new number of
 458    elements in the stack, and YYPTR gives the new location of the
 459    stack.  Advance YYPTR to a properly aligned location for the next
 460    stack.  */
 461 # define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
 462     do                                                                  \
 463       {                                                                 \
 464         YYSIZE_T yynewbytes;                                            \
 465         YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
 466         Stack = &yyptr->Stack_alloc;                                    \
 467         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
 468         yyptr += yynewbytes / sizeof (*yyptr);                          \
 469       }                                                                 \
 470     while (YYID (0))
 471
 472 #endif
 473
 474 /* YYFINAL -- State number of the termination state.  */
 475 #define YYFINAL  ]b4_final_state_number[
 476 /* YYLAST -- Last index in YYTABLE.  */
 477 #define YYLAST   ]b4_last[
 478
 479 /* YYNTOKENS -- Number of terminals.  */
 480 #define YYNTOKENS  ]b4_tokens_number[
 481 /* YYNNTS -- Number of nonterminals.  */
 482 #define YYNNTS  ]b4_nterms_number[
 483 /* YYNRULES -- Number of rules.  */
 484 #define YYNRULES  ]b4_rules_number[
 485 /* YYNSTATES -- Number of states.  */
 486 #define YYNSTATES  ]b4_states_number[
 487
 488 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
 489    by yylex, with out-of-bounds checking.  */
 490 #define YYUNDEFTOK  ]b4_undef_token_number[
 491 #define YYMAXUTOK   ]b4_user_token_number_max[
 492
 493 #define YYTRANSLATE(YYX)                                                \
 494   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 495
 496 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
 497    as returned by yylex, without out-of-bounds checking.  */
 498 static const ]b4_int_type_for([b4_translate])[ yytranslate[] =
 499 {
 500   ]b4_translate[
 501 };
 502
 503 #if YYDEBUG
 504 ]b4_integral_parser_table_define([rline], [b4_rline],
 505      [YYRLINE[YYN] -- Source line where rule number YYN was defined.])[
 506 #endif
 507
 508 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
 509 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
 510    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
 511 static const char *const yytname[] =
 512 {
 513   ]b4_tname[
 514 };
 515 #endif
 516
 517 # ifdef YYPRINT
 518 /* YYTOKNUM[NUM] -- (External) token number corresponding to the
 519    (internal) symbol number NUM (which must be that of a token).  */
 520 static const ]b4_int_type_for([b4_toknum])[ yytoknum[] =
 521 {
 522   ]b4_toknum[
 523 };
 524 # endif
 525
 526 #define YYPACT_NINF ]b4_pact_ninf[
 527
 528 #define YYTABLE_NINF ]b4_table_ninf[
 529
 530 ]b4_parser_tables_define[
 531
 532 #define yyerrok         (yyerrstatus = 0)
 533 #define yyclearin       (yychar = YYEMPTY)
 534 #define YYEMPTY         (-2)
 535 #define YYEOF           0
 536
 537 #define YYACCEPT        goto yyacceptlab
 538 #define YYABORT         goto yyabortlab
 539 #define YYERROR         goto yyerrorlab
 540
 541
 542 /* Like YYERROR except do call yyerror.  This remains here temporarily
 543    to ease the transition to the new meaning of YYERROR, for GCC.
 544    Once GCC version 2 has supplanted version 1, this can go.  */
 545
 546 #define YYFAIL          goto yyerrlab
 547
 548 #define YYRECOVERING()  (!!yyerrstatus)
 549
 550 #define YYBACKUP(Token, Value)                                  \
 551 do                                                              \
 552   if (yychar == YYEMPTY && yylen == 1)                          \
 553     {                                                           \
 554       yychar = (Token);                                         \
 555       yylval = (Value);                                         \
 556       yytoken = YYTRANSLATE (yychar);                           \
 557       YYPOPSTACK (1);                                           \
 558       goto yybackup;                                            \
 559     }                                                           \
 560   else                                                          \
 561     {                                                           \
 562       yyerror (]b4_yyerror_args[YY_("syntax error: cannot back up")); \
 563       YYERROR;                                                  \
 564     }                                                           \
 565 while (YYID (0))
 566
 567
 568 #define YYTERROR        1
 569 #define YYERRCODE       256
 570
 571
 572 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
 573    If N is 0, then set CURRENT to the empty location which ends
 574    the previous symbol: RHS[0] (always defined).  */
 575
 576 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
 577 #ifndef YYLLOC_DEFAULT
 578 # define YYLLOC_DEFAULT(Current, Rhs, N)                                \
 579     do                                                                  \
 580       if (YYID (N))                                                    \
 581         {                                                               \
 582           (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
 583           (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
 584           (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
 585           (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
 586         }                                                               \
 587       else                                                              \
 588         {                                                               \
 589           (Current).first_line   = (Current).last_line   =              \
 590             YYRHSLOC (Rhs, 0).last_line;                                \
 591           (Current).first_column = (Current).last_column =              \
 592             YYRHSLOC (Rhs, 0).last_column;                              \
 593         }                                                               \
 594     while (YYID (0))
 595 #endif
 596
 597
 598 /* YY_LOCATION_PRINT -- Print the location on the stream.
 599    This macro was not mandated originally: define only if we know
 600    we won't break user code: when these are the locations we know.  */
 601
 602 #ifndef YY_LOCATION_PRINT
 603 # if YYLTYPE_IS_TRIVIAL
 604 #  define YY_LOCATION_PRINT(File, Loc)                  \
 605      fprintf (File, "%d.%d-%d.%d",                      \
 606               (Loc).first_line, (Loc).first_column,     \
 607               (Loc).last_line,  (Loc).last_column)
 608 # else
 609 #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
 610 # endif
 611 #endif
 612
 613
 614 /* YYLEX -- calling `yylex' with the right arguments.  */
 615
 616 #ifdef YYLEX_PARAM
 617 # define YYLEX yylex (]b4_pure_if([&yylval[]b4_locations_if([, &yylloc]), ])[YYLEX_PARAM)
 618 #else
 619 # define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[
 620 #endif
 621
 622 /* Enable debugging if requested.  */
 623 #if YYDEBUG
 624
 625 # ifndef YYFPRINTF
 626 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
 627 #  define YYFPRINTF fprintf
 628 # endif
 629
 630 # define YYDPRINTF(Args)                        \
 631 do {                                            \
 632   if (yydebug)                                  \
 633     YYFPRINTF Args;                             \
 634 } while (YYID (0))
 635
 636 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
 637 do {                                                                      \
 638   if (yydebug)                                                            \
 639     {                                                                     \
 640       YYFPRINTF (stderr, "%s ", Title);                                   \
 641       yy_symbol_print (stderr,                                            \
 642                   Type, Value]b4_locations_if([, Location])[]b4_user_args[); \
 643       YYFPRINTF (stderr, "\n");                                           \
 644     }                                                                     \
 645 } while (YYID (0))
 646
 647 ]b4_yy_symbol_print_generate([b4_c_function_def])[
 648
 649 /*------------------------------------------------------------------.
 650 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
 651 | TOP (included).                                                   |
 652 `------------------------------------------------------------------*/
 653
 654 ]b4_c_function_def([yy_stack_print], [static void],
 655                    [[yytype_int16 *yybottom], [yybottom]],
 656                    [[yytype_int16 *yytop],    [yytop]])[
 657 {
 658   YYFPRINTF (stderr, "Stack now");
 659   for (; yybottom <= yytop; yybottom++)
 660     {
 661       int yybot = *yybottom;
 662       YYFPRINTF (stderr, " %d", yybot);
 663     }
 664   YYFPRINTF (stderr, "\n");
 665 }
 666
 667 # define YY_STACK_PRINT(Bottom, Top)                            \
 668 do {                                                            \
 669   if (yydebug)                                                  \
 670     yy_stack_print ((Bottom), (Top));                           \
 671 } while (YYID (0))
 672
 673
 674 /*------------------------------------------------.
 675 | Report that the YYRULE is going to be reduced.  |
 676 `------------------------------------------------*/
 677
 678 ]b4_c_function_def([yy_reduce_print], [static void],
 679                    [[yytype_int16 *yyssp], [yyssp]],
 680                    [[YYSTYPE *yyvsp], [yyvsp]],
 681     b4_locations_if([[[YYLTYPE *yylsp], [yylsp]],
 682                    ])[[int yyrule], [yyrule]]m4_ifset([b4_parse_param], [,
 683                    b4_parse_param]))[
 684 {
 685   unsigned long int yylno = yyrline[yyrule];
 686   int yynrhs = yyr2[yyrule];
 687   int yyi;
 688   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
 689              yyrule - 1, yylno);
 690   /* The symbols being reduced.  */
 691   for (yyi = 0; yyi < yynrhs; yyi++)
 692     {
 693       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
 694       yy_symbol_print (stderr,
 695                        yystos[yyssp[yyi + 1 - yynrhs]],
 696                        &]b4_rhs_value(yynrhs, yyi + 1)[
 697                        ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl
 698                        b4_user_args[);
 699       YYFPRINTF (stderr, "\n");
 700     }
 701 }
 702
 703 # define YY_REDUCE_PRINT(Rule)          \
 704 do {                                    \
 705   if (yydebug)                          \
 706     yy_reduce_print (yyssp, yyvsp, ]b4_locations_if([yylsp, ])[Rule]b4_user_args[); \
 707 } while (YYID (0))
 708
 709 /* Nonzero means print parse trace.  It is left uninitialized so that
 710    multiple parsers can coexist.  */
 711 int yydebug;
 712 #else /* !YYDEBUG */
 713 # define YYDPRINTF(Args)
 714 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
 715 # define YY_STACK_PRINT(Bottom, Top)
 716 # define YY_REDUCE_PRINT(Rule)
 717 #endif /* !YYDEBUG */
 718
 719
 720 /* YYINITDEPTH -- initial size of the parser's stacks.  */
 721 #ifndef YYINITDEPTH
 722 # define YYINITDEPTH ]b4_stack_depth_init[
 723 #endif
 724
 725 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
 726    if the built-in stack extension method is used).
 727
 728    Do not make this value too large; the results are undefined if
 729    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
 730    evaluated with infinite-precision integer arithmetic.  */
 731
 732 #ifndef YYMAXDEPTH
 733 # define YYMAXDEPTH ]b4_stack_depth_max[
 734 #endif
 735
 736 \f
 737
 738 #if YYERROR_VERBOSE
 739
 740 # ifndef yystrlen
 741 #  if defined __GLIBC__ && defined _STRING_H
 742 #   define yystrlen strlen
 743 #  else
 744 /* Return the length of YYSTR.  */
 745 ]b4_c_function_def([yystrlen], [static YYSIZE_T],
 746    [[const char *yystr], [yystr]])[
 747 {
 748   YYSIZE_T yylen;
 749   for (yylen = 0; yystr[yylen]; yylen++)
 750     continue;
 751   return yylen;
 752 }
 753 #  endif
 754 # endif
 755
 756 # ifndef yystpcpy
 757 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
 758 #   define yystpcpy stpcpy
 759 #  else
 760 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
 761    YYDEST.  */
 762 ]b4_c_function_def([yystpcpy], [static char *],
 763    [[char *yydest], [yydest]], [[const char *yysrc], [yysrc]])[
 764 {
 765   char *yyd = yydest;
 766   const char *yys = yysrc;
 767
 768   while ((*yyd++ = *yys++) != '\0')
 769     continue;
 770
 771   return yyd - 1;
 772 }
 773 #  endif
 774 # endif
 775
 776 # ifndef yytnamerr
 777 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
 778    quotes and backslashes, so that it's suitable for yyerror.  The
 779    heuristic is that double-quoting is unnecessary unless the string
 780    contains an apostrophe, a comma, or backslash (other than
 781    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
 782    null, do not copy; instead, return the length of what the result
 783    would have been.  */
 784 static YYSIZE_T
 785 yytnamerr (char *yyres, const char *yystr)
 786 {
 787   if (*yystr == '"')
 788     {
 789       YYSIZE_T yyn = 0;
 790       char const *yyp = yystr;
 791
 792       for (;;)
 793         switch (*++yyp)
 794           {
 795           case '\'':
 796           case ',':
 797             goto do_not_strip_quotes;
 798
 799           case '\\':
 800             if (*++yyp != '\\')
 801               goto do_not_strip_quotes;
 802             /* Fall through.  */
 803           default:
 804             if (yyres)
 805               yyres[yyn] = *yyp;
 806             yyn++;
 807             break;
 808
 809           case '"':
 810             if (yyres)
 811               yyres[yyn] = '\0';
 812             return yyn;
 813           }
 814     do_not_strip_quotes: ;
 815     }
 816
 817   if (! yyres)
 818     return yystrlen (yystr);
 819
 820   return yystpcpy (yyres, yystr) - yyres;
 821 }
 822 # endif
 823
 824 /* Copy into YYRESULT an error message about the unexpected token
 825    YYTOKEN while in state YYSTATE.  Return the number of bytes copied,
 826    including the terminating null byte.  If YYRESULT is null, do not
 827    copy anything; just return the number of bytes that would be
 828    copied.  As a special case, return 0 if an ordinary "syntax error"
 829    message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
 830    size calculation.  */
 831 static YYSIZE_T
 832 yysyntax_error (char *yyresult, int yystate, int yytoken)
 833 {
 834   int yyn = yypact[yystate];
 835
 836   if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
 837     return 0;
 838   else
 839     {
 840       YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
 841       YYSIZE_T yysize = yysize0;
 842       YYSIZE_T yysize1;
 843       int yysize_overflow = 0;
 844       enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
 845       /* Internationalized format string. */
 846       const char *yyformat = 0;
 847       /* Arguments of yyformat. */
 848       char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
 849
 850       /* Start YYX at -YYN if negative to avoid negative indexes in
 851          YYCHECK.  */
 852       int yyxbegin = yyn < 0 ? -yyn : 0;
 853
 854       /* Stay within bounds of both yycheck and yytname.  */
 855       int yychecklim = YYLAST - yyn + 1;
 856       int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
 857       /* Number of reported tokens (one for the "unexpected", one per
 858          "expected"). */
 859       int yycount = 0;
 860       int yyx;
 861
 862       yyarg[yycount++] = yytname[yytoken];
 863
 864       for (yyx = yyxbegin; yyx < yyxend; ++yyx)
 865         if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
 866           {
 867             if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
 868               {
 869                 yycount = 1;
 870                 yysize = yysize0;
 871                 break;
 872               }
 873             yyarg[yycount++] = yytname[yyx];
 874             yysize1 = yysize + yytnamerr (0, yytname[yyx]);
 875             yysize_overflow |= (yysize1 < yysize);
 876             yysize = yysize1;
 877           }
 878
 879         switch (yycount)
 880         {
 881 #define YYCASE_(N, S)                           \
 882           case N:                               \
 883             yyformat = S;                       \
 884           break
 885           YYCASE_(1, YY_("syntax error, unexpected %s"));
 886           YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
 887           YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
 888           YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
 889           YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
 890 #undef YYCASE_
 891         }
 892
 893       yysize1 = yysize + yystrlen (yyformat);
 894       yysize_overflow |= (yysize1 < yysize);
 895       yysize = yysize1;
 896
 897       if (yysize_overflow)
 898         return YYSIZE_MAXIMUM;
 899
 900       if (yyresult)
 901         {
 902           /* Avoid sprintf, as that infringes on the user's name space.
 903              Don't have undefined behavior even if the translation
 904              produced a string with the wrong number of "%s"s.  */
 905           char *yyp = yyresult;
 906           int yyi = 0;
 907           while ((*yyp = *yyformat) != '\0')
 908             if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
 909               {
 910                 yyp += yytnamerr (yyp, yyarg[yyi++]);
 911                 yyformat += 2;
 912               }
 913             else
 914               {
 915                 yyp++;
 916                 yyformat++;
 917               }
 918         }
 919       return yysize;
 920     }
 921 }
 922 #endif /* YYERROR_VERBOSE */
 923 \f
 924
 925 ]b4_yydestruct_generate([b4_c_function_def])[
 926
 927 ]b4_push_if([],
 928 [[/* Prevent warnings from -Wmissing-prototypes.  */
 929 #ifdef YYPARSE_PARAM
 930 ]b4_c_function_decl([yyparse], [int],
 931    [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])[
 932 #else /* ! YYPARSE_PARAM */
 933 ]b4_c_function_decl([yyparse], [int], b4_parse_param)[
 934 #endif /* ! YYPARSE_PARAM */]])
 935
 936 m4_divert_push([KILL])# ======================== M4 code.
 937 # b4_declare_scanner_communication_variables
 938 # ------------------------------------------
 939 # Declare the variables that are global, or local to YYPARSE if
 940 # pure-parser.
 941 m4_define([b4_declare_scanner_communication_variables],
 942 [[/* The lookahead symbol.  */
 943 int yychar;
 944
 945 /* The semantic value of the lookahead symbol.  */
 946 YYSTYPE yylval;
 947 ]b4_locations_if([[
 948 /* Location data for the lookahead symbol.  */
 949 YYLTYPE yylloc;
 950 ]])b4_pure_if([], [[
 951 /* Number of syntax errors so far.  */
 952 int yynerrs;
 953 ]])])
 954
 955 # b4_declare_parser_state_variables
 956 # ---------------------------------
 957 # Declare all the variables that are needed to maintain the parser state
 958 # between calls to yypush_parse.
 959 m4_define([b4_declare_parser_state_variables],
 960 [b4_pure_if([[    /* Number of syntax errors so far.  */
 961     int yynerrs;
 962 ]])[
 963     int yystate;
 964     /* Number of tokens to shift before error messages enabled.  */
 965     int yyerrstatus;
 966
 967     /* The stacks and their tools:
 968        `yyss': related to states.
 969        `yyvs': related to semantic values.]b4_locations_if([[
 970        `yyls': related to locations.]])[
 971
 972        Refer to the stacks thru separate pointers, to allow yyoverflow
 973        to reallocate them elsewhere.  */
 974
 975     /* The state stack.  */
 976     yytype_int16 yyssa[YYINITDEPTH];
 977     yytype_int16 *yyss;
 978     yytype_int16 *yyssp;
 979
 980     /* The semantic value stack.  */
 981     YYSTYPE yyvsa[YYINITDEPTH];
 982     YYSTYPE *yyvs;
 983     YYSTYPE *yyvsp;
 984 ]b4_locations_if([[
 985     /* The location stack.  */
 986     YYLTYPE yylsa[YYINITDEPTH];
 987     YYLTYPE *yyls;
 988     YYLTYPE *yylsp;
 989
 990     /* The locations where the error started and ended.  */
 991     YYLTYPE yyerror_range[2];
 992 ]])[
 993     YYSIZE_T yystacksize;
 994 ]])
 995
 996 m4_divert_pop([KILL])dnl# ====================== End of M4 code.
 997
 998 b4_pure_if([], [b4_declare_scanner_communication_variables])
 999
1000 b4_push_if(
1001 [[struct yypstate
1002   {
1003     ]b4_declare_parser_state_variables[
1004     /* Used to determine if this is the first time this instance has
1005        been used.  */
1006     int yynew;
1007   };]b4_pure_if([], [[
1008
1009 static char yypstate_allocated = 0;]])b4_pull_if([
1010
1011 b4_c_function_def([[yyparse]], [[int]], b4_parse_param)[
1012 {
1013   return yypull_parse (0]m4_ifset([b4_parse_param],
1014                                   [[, ]b4_c_args(b4_parse_param)])[);
1015 }
1016
1017 ]b4_c_function_def([[yypull_parse]], [[int]],
1018   [[[yypstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [,
1019   b4_parse_param]))[
1020 {
1021   int yystatus;
1022   yypstate *yyps_local;]b4_pure_if([[
1023   int yychar;
1024   YYSTYPE yylval;]b4_locations_if([[
1025   YYLTYPE yylloc;]])])[
1026   if (yyps == 0)
1027     {
1028       yyps_local = yypstate_new ();
1029       if (!yyps_local)
1030         {]b4_pure_if([[
1031           yyerror (]b4_yyerror_args[YY_("memory exhausted"));]], [[
1032           if (!yypstate_allocated)
1033             yyerror (]b4_yyerror_args[YY_("memory exhausted"));]])[
1034           return 2;
1035         }
1036     }
1037   else
1038     yyps_local = yyps;
1039   do {
1040     yychar = YYLEX;
1041     yystatus =
1042       yypush_parse (yyps_local]b4_pure_if([[, yychar, &yylval]b4_locations_if([[, &yylloc]])])m4_ifset([b4_parse_param], [, b4_c_args(b4_parse_param)])[);
1043   } while (yystatus == YYPUSH_MORE);
1044   if (yyps == 0)
1045     yypstate_delete (yyps_local);
1046   return yystatus;
1047 }]])[
1048
1049 /* Initialize the parser data structure.  */
1050 ]b4_c_function_def([[yypstate_new]], [[yypstate *]])[
1051 {
1052   yypstate *yyps;]b4_pure_if([], [[
1053   if (yypstate_allocated)
1054     return 0;]])[
1055   yyps = (yypstate *) malloc (sizeof *yyps);
1056   if (!yyps)
1057     return 0;
1058   yyps->yynew = 1;]b4_pure_if([], [[
1059   yypstate_allocated = 1;]])[
1060   return yyps;
1061 }
1062
1063 ]b4_c_function_def([[yypstate_delete]], [[void]],
1064                    [[[yypstate *yyps]], [[yyps]]])[
1065 {
1066 #ifndef yyoverflow
1067   /* If the stack was reallocated but the parse did not complete, then the
1068      stack still needs to be freed.  */
1069   if (!yyps->yynew && yyps->yyss != yyps->yyssa)
1070     YYSTACK_FREE (yyps->yyss);
1071 #endif
1072   free (yyps);]b4_pure_if([], [[
1073   yypstate_allocated = 0;]])[
1074 }
1075
1076 ]b4_pure_if([[#define ]b4_prefix[nerrs yyps->]b4_prefix[nerrs
1077 ]])[#define yystate yyps->yystate
1078 #define yyerrstatus yyps->yyerrstatus
1079 #define yyssa yyps->yyssa
1080 #define yyss yyps->yyss
1081 #define yyssp yyps->yyssp
1082 #define yyvsa yyps->yyvsa
1083 #define yyvs yyps->yyvs
1084 #define yyvsp yyps->yyvsp
1085 ]b4_locations_if([[#define yylsa yyps->yylsa
1086 #define yyls yyps->yyls
1087 #define yylsp yyps->yylsp
1088 #define yyerror_range yyps->yyerror_range
1089 ]])[#define yystacksize yyps->yystacksize
1090 ]])[
1091 /*-------------------------.
1092 | yyparse or yypush_parse.  |
1093 `-------------------------*/
1094 ]b4_push_if([
1095 b4_c_function_def([[yypush_parse]], [[int]],
1096   [[[yypstate *yyps]], [[yyps]]]b4_pure_if([,
1097   [[[int yypushed_char]], [[yypushed_char]]],
1098   [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
1099   [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [,
1100   b4_parse_param]))], [
1101 #ifdef YYPARSE_PARAM
1102 b4_c_function_def([yyparse], [int], [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])
1103 #else /* ! YYPARSE_PARAM */
1104 b4_c_function_def([yyparse], [int], b4_parse_param)
1105 #endif])[
1106 {
1107 ]b4_pure_if([b4_declare_scanner_communication_variables])
1108 b4_push_if([b4_pure_if([], [[  int yypushed_char = yychar;
1109   YYSTYPE yypushed_val = yylval;
1110   ]b4_locations_if([[YYLTYPE yypushed_loc = yylloc;
1111 ]])])],
1112   [b4_declare_parser_state_variables])[
1113   int yyn;
1114   int yyresult;
1115   /* Lookahead token as an internal (translated) token number.  */
1116   int yytoken;
1117   /* The variables used to return semantic value and location from the
1118      action routines.  */
1119   YYSTYPE yyval;]b4_locations_if([[
1120   YYLTYPE yyloc;]])[
1121
1122 #if YYERROR_VERBOSE
1123   /* Buffer for error messages, and its allocated size.  */
1124   char yymsgbuf[128];
1125   char *yymsg = yymsgbuf;
1126   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1127 #endif
1128
1129 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N)]b4_locations_if([, yylsp -= (N)])[)
1130
1131   /* The number of symbols on the RHS of the reduced rule.
1132      Keep to zero when no symbol should be popped.  */
1133   int yylen = 0;]b4_push_if([[
1134
1135   if (!yyps->yynew)
1136     {
1137       yyn = yypact[yystate];
1138       goto yyread_pushed_token;
1139     }]])[
1140
1141   yytoken = 0;
1142   yyss = yyssa;
1143   yyvs = yyvsa;]b4_locations_if([[
1144   yyls = yylsa;]])[
1145   yystacksize = YYINITDEPTH;
1146
1147   YYDPRINTF ((stderr, "Starting parse\n"));
1148
1149   yystate = 0;
1150   yyerrstatus = 0;
1151   yynerrs = 0;
1152   yychar = YYEMPTY; /* Cause a token to be read.  */
1153
1154   /* Initialize stack pointers.
1155      Waste one element of value and location stack
1156      so that they stay on the same level as the state stack.
1157      The wasted elements are never initialized.  */
1158   yyssp = yyss;
1159   yyvsp = yyvs;]b4_locations_if([[
1160   yylsp = yyls;
1161
1162 #if YYLTYPE_IS_TRIVIAL
1163   /* Initialize the default location before parsing starts.  */
1164   yylloc.first_line   = yylloc.last_line   = ]b4_location_initial_line[;
1165   yylloc.first_column = yylloc.last_column = ]b4_location_initial_column[;
1166 #endif]])
1167 m4_ifdef([b4_initial_action],[
1168 m4_pushdef([b4_at_dollar],     [m4_define([b4_at_dollar_used])yylloc])dnl
1169 m4_pushdef([b4_dollar_dollar], [m4_define([b4_dollar_dollar_used])yylval])dnl
1170 /* User initialization code.  */
1171 b4_user_initial_action
1172 m4_popdef([b4_dollar_dollar])dnl
1173 m4_popdef([b4_at_dollar])])dnl
1174 m4_ifdef([b4_dollar_dollar_used],[[  yyvsp[0] = yylval;
1175 ]])dnl
1176 m4_ifdef([b4_at_dollar_used], [[  yylsp[0] = yylloc;
1177 ]])[
1178   goto yysetstate;
1179
1180 /*------------------------------------------------------------.
1181 | yynewstate -- Push a new state, which is found in yystate.  |
1182 `------------------------------------------------------------*/
1183  yynewstate:
1184   /* In all cases, when you get here, the value and location stacks
1185      have just been pushed.  So pushing a state here evens the stacks.  */
1186   yyssp++;
1187
1188  yysetstate:
1189   *yyssp = yystate;
1190
1191   if (yyss + yystacksize - 1 <= yyssp)
1192     {
1193       /* Get the current used size of the three stacks, in elements.  */
1194       YYSIZE_T yysize = yyssp - yyss + 1;
1195
1196 #ifdef yyoverflow
1197       {
1198         /* Give user a chance to reallocate the stack.  Use copies of
1199            these so that the &'s don't force the real ones into
1200            memory.  */
1201         YYSTYPE *yyvs1 = yyvs;
1202         yytype_int16 *yyss1 = yyss;]b4_locations_if([
1203         YYLTYPE *yyls1 = yyls;])[
1204
1205         /* Each stack pointer address is followed by the size of the
1206            data in use in that stack, in bytes.  This used to be a
1207            conditional around just the two extra args, but that might
1208            be undefined if yyoverflow is a macro.  */
1209         yyoverflow (YY_("memory exhausted"),
1210                     &yyss1, yysize * sizeof (*yyssp),
1211                     &yyvs1, yysize * sizeof (*yyvsp),]b4_locations_if([
1212                     &yyls1, yysize * sizeof (*yylsp),])[
1213                     &yystacksize);
1214 ]b4_locations_if([
1215         yyls = yyls1;])[
1216         yyss = yyss1;
1217         yyvs = yyvs1;
1218       }
1219 #else /* no yyoverflow */
1220 # ifndef YYSTACK_RELOCATE
1221       goto yyexhaustedlab;
1222 # else
1223       /* Extend the stack our own way.  */
1224       if (YYMAXDEPTH <= yystacksize)
1225         goto yyexhaustedlab;
1226       yystacksize *= 2;
1227       if (YYMAXDEPTH < yystacksize)
1228         yystacksize = YYMAXDEPTH;
1229
1230       {
1231         yytype_int16 *yyss1 = yyss;
1232         union yyalloc *yyptr =
1233           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1234         if (! yyptr)
1235           goto yyexhaustedlab;
1236         YYSTACK_RELOCATE (yyss_alloc, yyss);
1237         YYSTACK_RELOCATE (yyvs_alloc, yyvs);]b4_locations_if([
1238         YYSTACK_RELOCATE (yyls_alloc, yyls);])[
1239 #  undef YYSTACK_RELOCATE
1240         if (yyss1 != yyssa)
1241           YYSTACK_FREE (yyss1);
1242       }
1243 # endif
1244 #endif /* no yyoverflow */
1245
1246       yyssp = yyss + yysize - 1;
1247       yyvsp = yyvs + yysize - 1;]b4_locations_if([
1248       yylsp = yyls + yysize - 1;])[
1249
1250       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1251                   (unsigned long int) yystacksize));
1252
1253       if (yyss + yystacksize - 1 <= yyssp)
1254         YYABORT;
1255     }
1256
1257   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1258
1259   if (yystate == YYFINAL)
1260     YYACCEPT;
1261
1262   goto yybackup;
1263
1264 /*-----------.
1265 | yybackup.  |
1266 `-----------*/
1267 yybackup:
1268
1269   /* Do appropriate processing given the current state.  Read a
1270      lookahead token if we need one and don't already have one.  */
1271
1272   /* First try to decide what to do without reference to lookahead token.  */
1273   yyn = yypact[yystate];
1274   if (yyn == YYPACT_NINF)
1275     goto yydefault;
1276
1277   /* Not known => get a lookahead token if don't already have one.  */
1278
1279   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
1280   if (yychar == YYEMPTY)
1281     {]b4_push_if([[
1282       if (!yyps->yynew)
1283         {]b4_use_push_for_pull_if([], [[
1284           YYDPRINTF ((stderr, "Return for a new token:\n"));]])[
1285           yyresult = YYPUSH_MORE;
1286           goto yypushreturn;
1287         }
1288       yyps->yynew = 0;]b4_pure_if([], [[
1289       /* Restoring the pushed token is only necessary for the first
1290          yypush_parse invocation since subsequent invocations don't overwrite
1291          it before jumping to yyread_pushed_token.  */
1292       yychar = yypushed_char;
1293       yylval = yypushed_val;]b4_locations_if([[
1294       yylloc = yypushed_loc;]])])[
1295 yyread_pushed_token:]])[
1296       YYDPRINTF ((stderr, "Reading a token: "));]b4_push_if([b4_pure_if([[
1297       yychar = yypushed_char;
1298       if (yypushed_val)
1299         yylval = *yypushed_val;]b4_locations_if([[
1300       if (yypushed_loc)
1301         yylloc = *yypushed_loc;]])])], [[
1302       yychar = YYLEX;]])[
1303     }
1304
1305   if (yychar <= YYEOF)
1306     {
1307       yychar = yytoken = YYEOF;
1308       YYDPRINTF ((stderr, "Now at end of input.\n"));
1309     }
1310   else
1311     {
1312       yytoken = YYTRANSLATE (yychar);
1313       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1314     }
1315
1316   /* If the proper action on seeing token YYTOKEN is to reduce or to
1317      detect an error, take that action.  */
1318   yyn += yytoken;
1319   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1320     goto yydefault;
1321   yyn = yytable[yyn];
1322   if (yyn <= 0)
1323     {
1324       if (yyn == 0 || yyn == YYTABLE_NINF)
1325         goto yyerrlab;
1326       yyn = -yyn;
1327       goto yyreduce;
1328     }
1329
1330   /* Count tokens shifted since error; after three, turn off error
1331      status.  */
1332   if (yyerrstatus)
1333     yyerrstatus--;
1334
1335   /* Shift the lookahead token.  */
1336   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1337
1338   /* Discard the shifted token.  */
1339   yychar = YYEMPTY;
1340
1341   yystate = yyn;
1342   *++yyvsp = yylval;
1343 ]b4_locations_if([  *++yylsp = yylloc;])[
1344   goto yynewstate;
1345
1346
1347 /*-----------------------------------------------------------.
1348 | yydefault -- do the default action for the current state.  |
1349 `-----------------------------------------------------------*/
1350 yydefault:
1351   yyn = yydefact[yystate];
1352   if (yyn == 0)
1353     goto yyerrlab;
1354   goto yyreduce;
1355
1356
1357 /*-----------------------------.
1358 | yyreduce -- Do a reduction.  |
1359 `-----------------------------*/
1360 yyreduce:
1361   /* yyn is the number of a rule to reduce with.  */
1362   yylen = yyr2[yyn];
1363
1364   /* If YYLEN is nonzero, implement the default value of the action:
1365      `$$ = $1'.
1366
1367      Otherwise, the following line sets YYVAL to garbage.
1368      This behavior is undocumented and Bison
1369      users should not rely upon it.  Assigning to YYVAL
1370      unconditionally makes the parser a bit smaller, and it avoids a
1371      GCC warning that YYVAL may be used uninitialized.  */
1372   yyval = yyvsp[1-yylen];
1373
1374 ]b4_locations_if(
1375 [[  /* Default location.  */
1376   YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);]])[
1377   YY_REDUCE_PRINT (yyn);
1378   switch (yyn)
1379     {
1380       ]b4_user_actions[
1381       default: break;
1382     }
1383   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1384
1385   YYPOPSTACK (yylen);
1386   yylen = 0;
1387   YY_STACK_PRINT (yyss, yyssp);
1388
1389   *++yyvsp = yyval;]b4_locations_if([
1390   *++yylsp = yyloc;])[
1391
1392   /* Now `shift' the result of the reduction.  Determine what state
1393      that goes to, based on the state we popped back to and the rule
1394      number reduced by.  */
1395
1396   yyn = yyr1[yyn];
1397
1398   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1399   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1400     yystate = yytable[yystate];
1401   else
1402     yystate = yydefgoto[yyn - YYNTOKENS];
1403
1404   goto yynewstate;
1405
1406
1407 /*------------------------------------.
1408 | yyerrlab -- here on detecting error |
1409 `------------------------------------*/
1410 yyerrlab:
1411   /* If not already recovering from an error, report this error.  */
1412   if (!yyerrstatus)
1413     {
1414       ++yynerrs;
1415 #if ! YYERROR_VERBOSE
1416       yyerror (]b4_yyerror_args[YY_("syntax error"));
1417 #else
1418       {
1419         YYSIZE_T yysize = yysyntax_error (0, yystate, yytoken);
1420         if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
1421           {
1422             YYSIZE_T yyalloc = 2 * yysize;
1423             if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
1424               yyalloc = YYSTACK_ALLOC_MAXIMUM;
1425             if (yymsg != yymsgbuf)
1426               YYSTACK_FREE (yymsg);
1427             yymsg = (char *) YYSTACK_ALLOC (yyalloc);
1428             if (yymsg)
1429               yymsg_alloc = yyalloc;
1430             else
1431               {
1432                 yymsg = yymsgbuf;
1433                 yymsg_alloc = sizeof yymsgbuf;
1434               }
1435           }
1436
1437         if (0 < yysize && yysize <= yymsg_alloc)
1438           {
1439             (void) yysyntax_error (yymsg, yystate, yytoken);
1440             yyerror (]b4_yyerror_args[yymsg);
1441           }
1442         else
1443           {
1444             yyerror (]b4_yyerror_args[YY_("syntax error"));
1445             if (yysize != 0)
1446               goto yyexhaustedlab;
1447           }
1448       }
1449 #endif
1450     }
1451
1452 ]b4_locations_if([[  yyerror_range[0] = yylloc;]])[
1453
1454   if (yyerrstatus == 3)
1455     {
1456       /* If just tried and failed to reuse lookahead token after an
1457          error, discard it.  */
1458
1459       if (yychar <= YYEOF)
1460         {
1461           /* Return failure if at end of input.  */
1462           if (yychar == YYEOF)
1463             YYABORT;
1464         }
1465       else
1466         {
1467           yydestruct ("Error: discarding",
1468                       yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
1469           yychar = YYEMPTY;
1470         }
1471     }
1472
1473   /* Else will try to reuse lookahead token after shifting the error
1474      token.  */
1475   goto yyerrlab1;
1476
1477
1478 /*---------------------------------------------------.
1479 | yyerrorlab -- error raised explicitly by YYERROR.  |
1480 `---------------------------------------------------*/
1481 yyerrorlab:
1482
1483   /* Pacify compilers like GCC when the user code never invokes
1484      YYERROR and the label yyerrorlab therefore never appears in user
1485      code.  */
1486   if (/*CONSTCOND*/ 0)
1487      goto yyerrorlab;
1488
1489 ]b4_locations_if([[  yyerror_range[0] = yylsp[1-yylen];
1490 ]])[  /* Do not reclaim the symbols of the rule which action triggered
1491      this YYERROR.  */
1492   YYPOPSTACK (yylen);
1493   yylen = 0;
1494   YY_STACK_PRINT (yyss, yyssp);
1495   yystate = *yyssp;
1496   goto yyerrlab1;
1497
1498
1499 /*-------------------------------------------------------------.
1500 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
1501 `-------------------------------------------------------------*/
1502 yyerrlab1:
1503   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
1504
1505   for (;;)
1506     {
1507       yyn = yypact[yystate];
1508       if (yyn != YYPACT_NINF)
1509         {
1510           yyn += YYTERROR;
1511           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1512             {
1513               yyn = yytable[yyn];
1514               if (0 < yyn)
1515                 break;
1516             }
1517         }
1518
1519       /* Pop the current state because it cannot handle the error token.  */
1520       if (yyssp == yyss)
1521         YYABORT;
1522
1523 ]b4_locations_if([[      yyerror_range[0] = *yylsp;]])[
1524       yydestruct ("Error: popping",
1525                   yystos[yystate], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[);
1526       YYPOPSTACK (1);
1527       yystate = *yyssp;
1528       YY_STACK_PRINT (yyss, yyssp);
1529     }
1530
1531   *++yyvsp = yylval;
1532 ]b4_locations_if([[
1533   yyerror_range[1] = yylloc;
1534   /* Using YYLLOC is tempting, but would change the location of
1535      the lookahead.  YYLOC is available though.  */
1536   YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);
1537   *++yylsp = yyloc;]])[
1538
1539   /* Shift the error token.  */
1540   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1541
1542   yystate = yyn;
1543   goto yynewstate;
1544
1545
1546 /*-------------------------------------.
1547 | yyacceptlab -- YYACCEPT comes here.  |
1548 `-------------------------------------*/
1549 yyacceptlab:
1550   yyresult = 0;
1551   goto yyreturn;
1552
1553 /*-----------------------------------.
1554 | yyabortlab -- YYABORT comes here.  |
1555 `-----------------------------------*/
1556 yyabortlab:
1557   yyresult = 1;
1558   goto yyreturn;
1559
1560 #if !defined(yyoverflow) || YYERROR_VERBOSE
1561 /*-------------------------------------------------.
1562 | yyexhaustedlab -- memory exhaustion comes here.  |
1563 `-------------------------------------------------*/
1564 yyexhaustedlab:
1565   yyerror (]b4_yyerror_args[YY_("memory exhausted"));
1566   yyresult = 2;
1567   /* Fall through.  */
1568 #endif
1569
1570 yyreturn:
1571   if (yychar != YYEMPTY)
1572      yydestruct ("Cleanup: discarding lookahead",
1573                  yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
1574   /* Do not reclaim the symbols of the rule which action triggered
1575      this YYABORT or YYACCEPT.  */
1576   YYPOPSTACK (yylen);
1577   YY_STACK_PRINT (yyss, yyssp);
1578   while (yyssp != yyss)
1579     {
1580       yydestruct ("Cleanup: popping",
1581                   yystos[*yyssp], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[);
1582       YYPOPSTACK (1);
1583     }
1584 #ifndef yyoverflow
1585   if (yyss != yyssa)
1586     YYSTACK_FREE (yyss);
1587 #endif
1588 ]b4_push_if([[  yyps->yynew = 1;
1589
1590 yypushreturn:
1591 ]])[#if YYERROR_VERBOSE
1592   if (yymsg != yymsgbuf)
1593     YYSTACK_FREE (yymsg);
1594 #endif
1595   /* Make sure YYID is used.  */
1596   return YYID (yyresult);
1597 }
1598
1599
1600 ]b4_epilogue
1601 b4_defines_if(
1602 [@output(b4_spec_defines_file@)@
1603 b4_copyright([Interface for Bison's Yacc-like parsers in C])dnl'
1604
1605 b4_percent_code_get([[requires]])[]dnl
1606
1607 b4_token_enums_defines(b4_tokens)
1608
1609 [#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
1610 ]m4_ifdef([b4_stype],
1611 [[typedef union ]b4_union_name[
1612 {
1613 ]b4_user_stype[
1614 } YYSTYPE;
1615 # define YYSTYPE_IS_TRIVIAL 1]],
1616 [m4_if(b4_tag_seen_flag, 0,
1617 [[typedef int YYSTYPE;
1618 # define YYSTYPE_IS_TRIVIAL 1]])])[
1619 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
1620 # define YYSTYPE_IS_DECLARED 1
1621 #endif
1622
1623 ]b4_pure_if([], [[extern YYSTYPE ]b4_prefix[lval;]])
1624
1625 b4_locations_if(
1626 [#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
1627 typedef struct YYLTYPE
1628 {
1629   int first_line;
1630   int first_column;
1631   int last_line;
1632   int last_column;
1633 } YYLTYPE;
1634 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
1635 # define YYLTYPE_IS_DECLARED 1
1636 # define YYLTYPE_IS_TRIVIAL 1
1637 #endif
1638
1639 ]b4_pure_if([], [[extern YYLTYPE ]b4_prefix[lloc;]])
1640 )dnl b4_locations_if
1641 b4_push_if([[
1642 #ifndef YYPUSH_DECLS
1643 #  define YYPUSH_DECLS
1644 struct ]b4_prefix[pstate;
1645 typedef struct ]b4_prefix[pstate ]b4_prefix[pstate;
1646 enum { YYPUSH_MORE = 4 };
1647 ]b4_pull_if([b4_c_function_decl([b4_prefix[parse]], [[int]], b4_parse_param)
1648 ])b4_c_function_decl([b4_prefix[push_parse]], [[int]],
1649   [[b4_prefix[pstate *yyps]], [[yyps]]]b4_pure_if([,
1650   [[[int yypushed_char]], [[yypushed_char]]],
1651   [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
1652   [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [,
1653   b4_parse_param]))
1654 b4_pull_if([b4_c_function_decl([b4_prefix[pull_parse]], [[int]],
1655   [[b4_prefix[pstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [,
1656   b4_parse_param]))])
1657 b4_c_function_decl([b4_prefix[pstate_new]], [b4_prefix[pstate *]],
1658                     [[[void]], []])
1659 b4_c_function_decl([b4_prefix[pstate_delete]], [[void]],
1660                    [[b4_prefix[pstate *yyps]], [[yyps]]])[
1661 #endif
1662 ]])
1663 b4_percent_code_get([[provides]])[]dnl
1664 ])dnl b4_defines_if
1665 m4_divert_pop(0)
1666 m4_popdef([b4_copyright_years])