share/bison/yacc.c

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