data/bison.simple

   1 m4_divert(-1)                                                       -*- C -*-
   2
   3 # b4_sint_type(MAX)
   4 # -----------------
   5 # Return the smallest signed int type able to handle the number MAX.
   6 m4_define([b4_sint_type],
   7 [m4_if(m4_eval([$1 <= 127]),        [1], [signed char],
   8        m4_eval([$1 <= 32767]),      [1], [signed short],
   9        [signed int])])
  10
  11
  12 # b4_uint_type(MAX)
  13 # -----------------
  14 # Return the smallest unsigned int type able to handle the number MAX.
  15 m4_define([b4_uint_type],
  16 [m4_if(m4_eval([$1 <= 255]),        [1], [unsigned char],
  17        m4_eval([$1 <= 65535]),      [1], [unsigned short],
  18        [unsigned int])])
  19
  20
  21 # b4_lhs_value([TYPE])
  22 # --------------------
  23 # Expansion of $<TYPE>$.
  24 m4_define([b4_lhs_value],
  25 [yyval[]m4_ifval([$1], [.$1])])
  26
  27
  28 # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
  29 # --------------------------------------
  30 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
  31 # symbols on RHS.
  32 m4_define([b4_rhs_value],
  33 [yyvsp@<:@m4_eval([$2 - $1])@:>@m4_ifval([$3], [.$3])])
  34
  35
  36
  37 ## ----------- ##
  38 ## Locations.  ##
  39 ## ----------- ##
  40
  41 # b4_location_if(IF-TRUE, IF-FALSE)
  42 # ---------------------------------
  43 # Expand IF-TRUE, if locations are used, IF-FALSE otherwise.
  44 m4_define([b4_location_if],
  45 [m4_if(b4_locations_flag, [1],
  46        [$1],
  47        [$2])])
  48
  49
  50 # b4_lhs_location()
  51 # -----------------
  52 # Expansion of @$.
  53 m4_define([b4_lhs_location],
  54 [yyloc])
  55
  56
  57 # b4_rhs_location(RULE-LENGTH, NUM)
  58 # ---------------------------------
  59 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
  60 # on RHS.
  61 m4_define([b4_rhs_location],
  62 [yylsp@<:@m4_eval([$2 - $1])@:>@])
  63
  64
  65
  66 ## -------------- ##
  67 ## %pure-parser.  ##
  68 ## -------------- ##
  69
  70 # b4_pure_if(IF-TRUE, IF-FALSE)
  71 # -----------------------------
  72 # Expand IF-TRUE, if %pure-parser, IF-FALSE otherwise.
  73 m4_define([b4_pure_if],
  74 [m4_if(b4_pure, [1],
  75        [$1],
  76        [$2])])
  77
  78
  79 ## ------------------- ##
  80 ## Output file names.  ##
  81 ## ------------------- ##
  82
  83 m4_define_default([b4_input_suffix], [.y])
  84
  85 m4_define_default([b4_output_parser_suffix],
  86 [m4_translit(b4_input_suffix, [yY], [cC])])
  87
  88 m4_define_default([b4_output_parser_name],
  89 [b4_output_prefix[]b4_output_infix[]b4_output_parser_suffix[]])
  90
  91
  92 m4_define_default([b4_output_header_suffix],
  93 [m4_translit(b4_input_suffix, [yY], [hH])])
  94
  95 m4_define_default([b4_output_header_name],
  96 [b4_output_prefix[]b4_output_infix[]b4_output_header_suffix[]])
  97
  98 m4_define_default([b4_header_guard],
  99                   [m4_bpatsubst(m4_toupper([BISON_]b4_output_header_name),
 100                                 [[^ABCDEFGHIJKLMNOPQRSTUVWXYZ]], [_])])
 101
 102
 103 ## ------------------------- ##
 104 ## Assigning token numbers.  ##
 105 ## ------------------------- ##
 106
 107 # b4_token_define(TOKEN-NAME, TOKEN-NUMBER)
 108 # -----------------------------------------
 109 # Output the definition of this token as #define.
 110 m4_define([b4_token_define],
 111 [#define $1 $2
 112 ])
 113
 114
 115 # b4_token_enum(TOKEN-NAME, TOKEN-NUMBER)
 116 # ---------------------------------------
 117 # Output the definition of this token as an enum.
 118 m4_define([b4_token_enum],
 119 [$1 = $2])
 120
 121
 122 # b4_token_defines(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER)
 123 # -------------------------------------------------------
 124 # Output the definition of the tokens (if there are) as enums and #define.
 125 m4_define([b4_token_defines],
 126 [m4_if([$@], [[]], [],
 127 [/* Tokens.  */
 128 #ifndef YYTOKENTYPE
 129 # if defined (__STDC__) || defined (__cplusplus)
 130    /* Put the tokens into the symbol table, so that GDB and other debuggers
 131       know about them.  */
 132    enum yytokentype {
 133 m4_map_sep([     b4_token_enum], [,
 134 ],
 135            [$@])
 136    };
 137 # endif
 138   /* POSIX requires `int' for tokens in interfaces.  */
 139 # define YYTOKENTYPE int
 140 #endif /* !YYTOKENTYPE */
 141 m4_map([b4_token_define], [$@])
 142 ])
 143 ])
 144
 145
 146 m4_divert(0)dnl
 147 #output "b4_output_parser_name"
 148 /* A Bison parser, made from b4_filename
 149    by GNU bison b4_version.  */
 150
 151 /* Skeleton output parser for Bison,
 152    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software
 153    Foundation, Inc.
 154
 155    This program is free software; you can redistribute it and/or modify
 156    it under the terms of the GNU General Public License as published by
 157    the Free Software Foundation; either version 2, or (at your option)
 158    any later version.
 159
 160    This program is distributed in the hope that it will be useful,
 161    but WITHOUT ANY WARRANTY; without even the implied warranty of
 162    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 163    GNU General Public License for more details.
 164
 165    You should have received a copy of the GNU General Public License
 166    along with this program; if not, write to the Free Software
 167    Foundation, Inc., 59 Temple Place - Suite 330,
 168    Boston, MA 02111-1307, USA.  */
 169
 170 /* As a special exception, when this file is copied by Bison into a
 171    Bison output file, you may use that output file without restriction.
 172    This special exception was added by the Free Software Foundation
 173    in version 1.24 of Bison.  */
 174
 175 /* This is the parser code that is written into each bison parser when
 176    the %semantic_parser declaration is not specified in the grammar.
 177    It was written by Richard Stallman by simplifying the original so
 178    called ``semantic'' parser.  */
 179
 180 /* All symbols defined below should begin with yy or YY, to avoid
 181    infringing on user name space.  This should be done even for local
 182    variables, as they might otherwise be expanded by user macros.
 183    There are some unavoidable exceptions within include files to
 184    define necessary library symbols; they are noted "INFRINGES ON
 185    USER NAME SPACE" below.  */
 186
 187 /* Identify Bison output.  */
 188 #define YYBISON 1
 189
 190 /* Pure parsers.  */
 191 #define YYPURE  b4_pure
 192
 193 /* Using locations.  */
 194 #define YYLSP_NEEDED b4_locations_flag
 195
 196 m4_if(b4_prefix[], [yy], [],
 197 [/* If NAME_PREFIX is specified substitute the variables and functions
 198    names.  */
 199 #define yyparse b4_prefix[]parse
 200 #define yylex   b4_prefix[]lex
 201 #define yyerror b4_prefix[]error
 202 #define yylval  b4_prefix[]lval
 203 #define yychar  b4_prefix[]char
 204 #define yydebug b4_prefix[]debug
 205 #define yynerrs b4_prefix[]nerrs
 206 b4_location_if([#define yylloc b4_prefix[]lloc])])
 207
 208 /* Copy the first part of user declarations.  */
 209 b4_pre_prologue
 210
 211 b4_token_defines(b4_tokens)
 212
 213 /* Enabling traces.  */
 214 #ifndef YYDEBUG
 215 # define YYDEBUG b4_debug
 216 #endif
 217
 218 /* Enabling verbose error messages.  */
 219 #ifdef YYERROR_VERBOSE
 220 # undef YYERROR_VERBOSE
 221 # define YYERROR_VERBOSE 1
 222 #else
 223 # define YYERROR_VERBOSE b4_error_verbose
 224 #endif
 225
 226 #ifndef YYSTYPE
 227 m4_ifdef([b4_stype],
 228 [#line b4_stype_line "b4_filename"
 229 typedef union b4_stype yystype;
 230 /* Line __line__ of __file__.  */
 231 #line __oline__ "__ofile__"],
 232 [typedef int yystype;])
 233 # define YYSTYPE yystype
 234 # define YYSTYPE_IS_TRIVIAL 1
 235 #endif
 236
 237 #ifndef YYLTYPE
 238 typedef struct yyltype
 239 {
 240   int first_line;
 241   int first_column;
 242   int last_line;
 243   int last_column;
 244 } yyltype;
 245 # define YYLTYPE b4_ltype
 246 # define YYLTYPE_IS_TRIVIAL 1
 247 #endif
 248
 249 /* Copy the second part of user declarations.  */
 250 b4_post_prologue
 251
 252 /* Line __line__ of __file__.  */
 253 #line __oline__ "__ofile__"
 254
 255 #if ! defined (yyoverflow) || YYERROR_VERBOSE
 256
 257 /* The parser invokes alloca or malloc; define the necessary symbols.  */
 258
 259 # if YYSTACK_USE_ALLOCA
 260 #  define YYSTACK_ALLOC alloca
 261 # else
 262 #  ifndef YYSTACK_USE_ALLOCA
 263 #   if defined (alloca) || defined (_ALLOCA_H)
 264 #    define YYSTACK_ALLOC alloca
 265 #   else
 266 #    ifdef __GNUC__
 267 #     define YYSTACK_ALLOC __builtin_alloca
 268 #    endif
 269 #   endif
 270 #  endif
 271 # endif
 272
 273 # ifdef YYSTACK_ALLOC
 274    /* Pacify GCC's `empty if-body' warning. */
 275 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
 276 # else
 277 #  if defined (__STDC__) || defined (__cplusplus)
 278 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 279 #   define YYSIZE_T size_t
 280 #  endif
 281 #  define YYSTACK_ALLOC malloc
 282 #  define YYSTACK_FREE free
 283 # endif
 284 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
 285
 286
 287 #if (! defined (yyoverflow) \
 288      && (! defined (__cplusplus) \
 289          || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
 290
 291 /* A type that is properly aligned for any stack member.  */
 292 union yyalloc
 293 {
 294   short yyss;
 295   YYSTYPE yyvs;
 296   b4_location_if([  YYLTYPE yyls;
 297 ])dnl
 298 };
 299
 300 /* The size of the maximum gap between one aligned stack and the next.  */
 301 # define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1)
 302
 303 /* The size of an array large to enough to hold all stacks, each with
 304    N elements.  */
 305 b4_location_if(
 306 [# define YYSTACK_BYTES(N) \
 307      ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE))      \
 308       + 2 * YYSTACK_GAP_MAX)],
 309 [# define YYSTACK_BYTES(N) \
 310      ((N) * (sizeof (short) + sizeof (YYSTYPE))                         \
 311       + YYSTACK_GAP_MAX)])
 312
 313 /* Copy COUNT objects from FROM to TO.  The source and destination do
 314    not overlap.  */
 315 # ifndef YYCOPY
 316 #  if 1 < __GNUC__
 317 #   define YYCOPY(To, From, Count) \
 318       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
 319 #  else
 320 #   define YYCOPY(To, From, Count)              \
 321       do                                        \
 322         {                                       \
 323           register YYSIZE_T yyi;                \
 324           for (yyi = 0; yyi < (Count); yyi++)   \
 325             (To)[[yyi]] = (From)[[yyi]];        \
 326         }                                       \
 327       while (0)
 328 #  endif
 329 # endif
 330
 331 /* Relocate STACK from its old location to the new one.  The
 332    local variables YYSIZE and YYSTACKSIZE give the old and new number of
 333    elements in the stack, and YYPTR gives the new location of the
 334    stack.  Advance YYPTR to a properly aligned location for the next
 335    stack.  */
 336 # define YYSTACK_RELOCATE(Stack)                                        \
 337     do                                                                  \
 338       {                                                                 \
 339         YYSIZE_T yynewbytes;                                            \
 340         YYCOPY (&yyptr->Stack, Stack, yysize);                          \
 341         Stack = &yyptr->Stack;                                          \
 342         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX;   \
 343         yyptr += yynewbytes / sizeof (*yyptr);                          \
 344       }                                                                 \
 345     while (0)
 346
 347 #endif
 348
 349 /* YYFINAL -- State number of the termination state. */
 350 #define YYFINAL  b4_final
 351 #define YYFLAG   b4_flag
 352 #define YYLAST   b4_last
 353
 354 /* YYNTOKENS -- Number of terminals. */
 355 #define YYNTOKENS  b4_ntokens
 356 /* YYNNTS -- Number of nonterminals. */
 357 #define YYNNTS  b4_nnts
 358 /* YYNRULES -- Number of rules. */
 359 #define YYNRULES  b4_nrules
 360 /* YYNRULES -- Number of states. */
 361 #define YYNSTATES  b4_nstates
 362
 363 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 364 #define YYUNDEFTOK  b4_undef_token_number
 365 #define YYMAXUTOK   b4_user_token_number_max
 366
 367 #define YYTRANSLATE(X) \
 368   ((unsigned)(X) <= YYMAXUTOK ? yytranslate[[X]] : YYUNDEFTOK)
 369
 370 /* YYTRANSLATE[[YYLEX]] -- Bison symbol number corresponding to YYLEX.  */
 371 static const b4_uint_type(b4_translate_max) yytranslate[[]] =
 372 {
 373   b4_translate
 374 };
 375
 376 #if YYDEBUG
 377 /* YYPRHS[[YYN]] -- Index of the first RHS symbol of rule number YYN in
 378    YYRHS.  */
 379 static const b4_uint_type(b4_prhs_max) yyprhs[[]] =
 380 {
 381   b4_prhs
 382 };
 383
 384 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
 385 static const b4_sint_type(b4_rhs_max) yyrhs[[]] =
 386 {
 387   b4_rhs
 388 };
 389
 390 /* YYRLINE[[YYN]] -- source line where rule number YYN was defined.  */
 391 static const b4_uint_type(b4_rline_max) yyrline[[]] =
 392 {
 393   b4_rline
 394 };
 395 #endif
 396
 397 #if YYDEBUG || YYERROR_VERBOSE
 398 /* YYTNME[[SYMBOL-NUM]] -- String name of the symbol SYMBOL-NUM.
 399    First, the terminals, then, starting at YYNTOKENS, nonterminals. */
 400 static const char *const yytname[[]] =
 401 {
 402   b4_tname
 403 };
 404 #endif
 405
 406 /* YYTOKNUM[[YYLEX-NUM]] -- Internal token number corresponding to
 407    token YYLEX-NUM.  */
 408 static const short yytoknum[[]] =
 409 {
 410   b4_toknum
 411 };
 412
 413 /* YYR1[[YYN]] -- Symbol number of symbol that rule YYN derives.  */
 414 static const b4_uint_type(b4_r1_max) yyr1[[]] =
 415 {
 416   b4_r1
 417 };
 418
 419 /* YYR2[[YYN]] -- Number of symbols composing right hand side of rule YYN.  */
 420 static const b4_uint_type(b4_r2_max) yyr2[[]] =
 421 {
 422   b4_r2
 423 };
 424
 425 /* YYDEFACT[[STATE-NAME]] -- Default rule to reduce with in state
 426    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
 427    means the default is an error.  */
 428 static const short yydefact[[]] =
 429 {
 430   b4_defact
 431 };
 432
 433 /* YYPGOTO[[NTERM-NUM]]. */
 434 static const short yydefgoto[[]] =
 435 {
 436   b4_defgoto
 437 };
 438
 439 /* YYPACT[[STATE-NUM]] -- Index in YYTABLE of the portion describing
 440    STATE-NUM.  */
 441 static const short yypact[[]] =
 442 {
 443   b4_pact
 444 };
 445
 446 /* YYPGOTO[[NTERM-NUM]].  */
 447 static const short yypgoto[[]] =
 448 {
 449   b4_pgoto
 450 };
 451
 452 /* YYTABLE[[YYPACT[STATE-NUM]]].  What to do in state STATE-NUM.  If
 453    positive, shift that token.  If negative, reduce the rule which
 454    number is the opposite.  If zero, do what YYDEFACT says.  */
 455 static const short yytable[[]] =
 456 {
 457   b4_table
 458 };
 459
 460 static const short yycheck[[]] =
 461 {
 462   b4_check
 463 };
 464
 465 /* YYSTOS[[STATE-NUM]] -- The (internal number of the) accessing
 466    symbol of state STATE-NUM.  */
 467 static const b4_uint_type(b4_stos_max) yystos[[]] =
 468 {
 469   b4_stos
 470 };
 471
 472 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
 473 # define YYSIZE_T __SIZE_TYPE__
 474 #endif
 475 #if ! defined (YYSIZE_T) && defined (size_t)
 476 # define YYSIZE_T size_t
 477 #endif
 478 #if ! defined (YYSIZE_T)
 479 # if defined (__STDC__) || defined (__cplusplus)
 480 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
 481 #  define YYSIZE_T size_t
 482 # endif
 483 #endif
 484 #if ! defined (YYSIZE_T)
 485 # define YYSIZE_T unsigned int
 486 #endif
 487
 488 #define yyerrok         (yyerrstatus = 0)
 489 #define yyclearin       (yychar = YYEMPTY)
 490 #define YYEMPTY         -2
 491 #define YYEOF           0
 492
 493 #define YYACCEPT        goto yyacceptlab
 494 #define YYABORT         goto yyabortlab
 495 #define YYERROR         goto yyerrlab1
 496
 497 /* Like YYERROR except do call yyerror.  This remains here temporarily
 498    to ease the transition to the new meaning of YYERROR, for GCC.
 499    Once GCC version 2 has supplanted version 1, this can go.  */
 500
 501 #define YYFAIL          goto yyerrlab
 502
 503 #define YYRECOVERING()  (!!yyerrstatus)
 504
 505 #define YYBACKUP(Token, Value)                                  \
 506 do                                                              \
 507   if (yychar == YYEMPTY && yylen == 1)                          \
 508     {                                                           \
 509       yychar = (Token);                                         \
 510       yylval = (Value);                                         \
 511       yychar1 = YYTRANSLATE (yychar);                           \
 512       YYPOPSTACK;                                               \
 513       goto yybackup;                                            \
 514     }                                                           \
 515   else                                                          \
 516     {                                                           \
 517       yyerror ("syntax error: cannot back up");                 \
 518       YYERROR;                                                  \
 519     }                                                           \
 520 while (0)
 521
 522 #define YYTERROR        1
 523 #define YYERRCODE       256
 524
 525 /* YYLLOC_DEFAULT -- Compute the default location (before the actions
 526    are run).  */
 527
 528 #ifndef YYLLOC_DEFAULT
 529 # define YYLLOC_DEFAULT(Current, Rhs, N)           \
 530   Current.first_line   = Rhs[[1]].first_line;      \
 531   Current.first_column = Rhs[[1]].first_column;    \
 532   Current.last_line    = Rhs[[N]].last_line;       \
 533   Current.last_column  = Rhs[[N]].last_column;
 534 #endif
 535
 536 /* YYLEX -- calling `yylex' with the right arguments.  */
 537
 538 b4_pure_if(
 539 [#ifdef YYLEX_PARAM
 540 # define YYLEX  yylex (&yylval, b4_location_if([&yylloc, ])YYLEX_PARAM)
 541 #else
 542 # define YYLEX  yylex (&yylval, b4_location_if([&yylloc, ]))
 543 #endif],
 544 [#define YYLEX  yylex ()])
 545
 546 /* Enable debugging if requested.  */
 547 #if YYDEBUG
 548
 549 # ifndef YYFPRINTF
 550 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
 551 #  define YYFPRINTF fprintf
 552 # endif
 553
 554 # define YYDPRINTF(Args)                        \
 555 do {                                            \
 556   if (yydebug)                                  \
 557     YYFPRINTF Args;                             \
 558 } while (0)
 559 /* Nonzero means print parse trace.  It is left uninitialized so that
 560    multiple parsers can coexist.  */
 561 int yydebug;
 562 #else /* !YYDEBUG */
 563 # define YYDPRINTF(Args)
 564 #endif /* !YYDEBUG */
 565
 566 /* YYINITDEPTH -- initial size of the parser's stacks.  */
 567 #ifndef YYINITDEPTH
 568 # define YYINITDEPTH b4_initdepth
 569 #endif
 570
 571 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
 572    if the built-in stack extension method is used).
 573
 574    Do not make this value too large; the results are undefined if
 575    SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
 576    evaluated with infinite-precision integer arithmetic.  */
 577
 578 #if YYMAXDEPTH == 0
 579 # undef YYMAXDEPTH
 580 #endif
 581
 582 #ifndef YYMAXDEPTH
 583 # define YYMAXDEPTH b4_maxdepth
 584 #endif
 585
 586 \f
 587
 588 #if YYERROR_VERBOSE
 589
 590 # ifndef yystrlen
 591 #  if defined (__GLIBC__) && defined (_STRING_H)
 592 #   define yystrlen strlen
 593 #  else
 594 /* Return the length of YYSTR.  */
 595 static YYSIZE_T
 596 #   if defined (__STDC__) || defined (__cplusplus)
 597 yystrlen (const char *yystr)
 598 #   else
 599 yystrlen (yystr)
 600      const char *yystr;
 601 #   endif
 602 {
 603   register const char *yys = yystr;
 604
 605   while (*yys++ != '\0')
 606     continue;
 607
 608   return yys - yystr - 1;
 609 }
 610 #  endif
 611 # endif
 612
 613 # ifndef yystpcpy
 614 #  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
 615 #   define yystpcpy stpcpy
 616 #  else
 617 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
 618    YYDEST.  */
 619 static char *
 620 #   if defined (__STDC__) || defined (__cplusplus)
 621 yystpcpy (char *yydest, const char *yysrc)
 622 #   else
 623 yystpcpy (yydest, yysrc)
 624      char *yydest;
 625      const char *yysrc;
 626 #   endif
 627 {
 628   register char *yyd = yydest;
 629   register const char *yys = yysrc;
 630
 631   while ((*yyd++ = *yys++) != '\0')
 632     continue;
 633
 634   return yyd - 1;
 635 }
 636 #  endif
 637 # endif
 638
 639 #endif /* !YYERROR_VERBOSE */
 640
 641 \f
 642
 643 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
 644    into yyparse.  The argument should have type void *.
 645    It should actually point to an object.
 646    Grammar actions can access the variable by casting it
 647    to the proper pointer type.  */
 648
 649 #ifdef YYPARSE_PARAM
 650 # if defined (__STDC__) || defined (__cplusplus)
 651 #  define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
 652 #  define YYPARSE_PARAM_DECL
 653 # else
 654 #  define YYPARSE_PARAM_ARG YYPARSE_PARAM
 655 #  define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
 656 # endif
 657 #else /* !YYPARSE_PARAM */
 658 # define YYPARSE_PARAM_ARG
 659 # define YYPARSE_PARAM_DECL
 660 #endif /* !YYPARSE_PARAM */
 661
 662 /* Prevent warning if -Wstrict-prototypes.  */
 663 #ifdef __GNUC__
 664 # ifdef YYPARSE_PARAM
 665 int yyparse (void *);
 666 # else
 667 int yyparse (void);
 668 # endif
 669 #endif
 670 static void yydestructor (int symbol_type, YYSTYPE symbol_value);
 671
 672 m4_divert_push([KILL])# ======================== M4 code.
 673 # b4_declare_parser_variables
 674 # ---------------------------
 675 # Declare the variables that are global, or local to YYPARSE if
 676 #  pure-parser
 677 m4_define([b4_declare_parser_variables],
 678 [/* The lookahead symbol.  */
 679 int yychar;
 680
 681 /* The semantic value of the lookahead symbol.  */
 682 YYSTYPE yylval;
 683
 684 /* Number of parse errors so far.  */
 685 int yynerrs;b4_location_if([
 686 /* Location data for the lookahead symbol.  */
 687 YYLTYPE yylloc;])
 688 ])
 689 m4_divert_pop([KILL])dnl# ====================== End of M4 code.
 690
 691 b4_pure_if([],
 692            [b4_declare_parser_variables])
 693
 694 int
 695 yyparse (YYPARSE_PARAM_ARG)
 696      YYPARSE_PARAM_DECL
 697 {[
 698   ]b4_pure_if([b4_declare_parser_variables])[
 699   register int yystate;
 700   register int yyn;
 701   int yyresult;
 702   /* Number of tokens to shift before error messages enabled.  */
 703   int yyerrstatus;
 704   /* Lookahead token as an internal (translated) token number.  */
 705   int yychar1 = 0;
 706
 707   /* Three stacks and their tools:
 708      `yyss': related to states,
 709      `yyvs': related to semantic values,
 710      `yyls': related to locations.
 711
 712      Refer to the stacks thru separate pointers, to allow yyoverflow
 713      to reallocate them elsewhere.  */
 714
 715   /* The state stack.  */
 716   short yyssa[YYINITDEPTH];
 717   short *yyss = yyssa;
 718   register short *yyssp;
 719
 720   /* The semantic value stack.  */
 721   YYSTYPE yyvsa[YYINITDEPTH];
 722   YYSTYPE *yyvs = yyvsa;
 723   register YYSTYPE *yyvsp;
 724
 725 ]b4_location_if(
 726 [[  /* The location stack.  */
 727   YYLTYPE yylsa[YYINITDEPTH];
 728   YYLTYPE *yyls = yylsa;
 729   YYLTYPE *yylsp;]])[
 730
 731 #define YYPOPSTACK   (yyvsp--, yyssp--]b4_location_if([, yylsp--])[)
 732
 733   YYSIZE_T yystacksize = YYINITDEPTH;
 734
 735   /* The variables used to return semantic value and location from the
 736      action routines.  */
 737   YYSTYPE yyval;
 738 ]b4_location_if([  YYLTYPE yyloc;])[
 739
 740   /* When reducing, the number of symbols on the RHS of the reduced
 741      rule.  */
 742   int yylen;
 743
 744   YYDPRINTF ((stderr, "Starting parse\n"));
 745
 746   yystate = 0;
 747   yyerrstatus = 0;
 748   yynerrs = 0;
 749   yychar = YYEMPTY;             /* Cause a token to be read.  */
 750
 751   /* Initialize stack pointers.
 752      Waste one element of value and location stack
 753      so that they stay on the same level as the state stack.
 754      The wasted elements are never initialized.  */
 755
 756   yyssp = yyss;
 757   yyvsp = yyvs;
 758 ]b4_location_if([  yylsp = yyls;])[
 759   goto yysetstate;
 760
 761 /*------------------------------------------------------------.
 762 | yynewstate -- Push a new state, which is found in yystate.  |
 763 `------------------------------------------------------------*/
 764  yynewstate:
 765   /* In all cases, when you get here, the value and location stacks
 766      have just been pushed. so pushing a state here evens the stacks.
 767      */
 768   yyssp++;
 769
 770  yysetstate:
 771   *yyssp = yystate;
 772
 773   if (yyssp >= yyss + yystacksize - 1)
 774     {
 775       /* Get the current used size of the three stacks, in elements.  */
 776       YYSIZE_T yysize = yyssp - yyss + 1;
 777
 778 #ifdef yyoverflow
 779       {
 780         /* Give user a chance to reallocate the stack. Use copies of
 781            these so that the &'s don't force the real ones into
 782            memory.  */
 783         YYSTYPE *yyvs1 = yyvs;
 784         short *yyss1 = yyss;
 785 ]b4_location_if([       YYLTYPE *yyls1 = yyls;])[
 786
 787         /* Each stack pointer address is followed by the size of the
 788            data in use in that stack, in bytes.  This used to be a
 789            conditional around just the two extra args, but that might
 790            be undefined if yyoverflow is a macro.  */
 791         yyoverflow ("parser stack overflow",
 792                     &yyss1, yysize * sizeof (*yyssp),
 793                     &yyvs1, yysize * sizeof (*yyvsp),
 794 ]b4_location_if([                   &yyls1, yysize * sizeof (*yylsp),])[
 795                     &yystacksize);
 796 ]b4_location_if([       yyls = yyls1;])[
 797         yyss = yyss1;
 798         yyvs = yyvs1;
 799       }
 800 #else /* no yyoverflow */
 801 # ifndef YYSTACK_RELOCATE
 802       goto yyoverflowlab;
 803 # else
 804       /* Extend the stack our own way.  */
 805       if (yystacksize >= YYMAXDEPTH)
 806         goto yyoverflowlab;
 807       yystacksize *= 2;
 808       if (yystacksize > YYMAXDEPTH)
 809         yystacksize = YYMAXDEPTH;
 810
 811       {
 812         short *yyss1 = yyss;
 813         union yyalloc *yyptr =
 814           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
 815         if (! yyptr)
 816           goto yyoverflowlab;
 817         YYSTACK_RELOCATE (yyss);
 818         YYSTACK_RELOCATE (yyvs);
 819 ]b4_location_if([       YYSTACK_RELOCATE (yyls);])[
 820 #  undef YYSTACK_RELOCATE
 821         if (yyss1 != yyssa)
 822           YYSTACK_FREE (yyss1);
 823       }
 824 # endif
 825 #endif /* no yyoverflow */
 826
 827       yyssp = yyss + yysize - 1;
 828       yyvsp = yyvs + yysize - 1;
 829 ]b4_location_if([      yylsp = yyls + yysize - 1;])[
 830
 831       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
 832                   (unsigned long int) yystacksize));
 833
 834       if (yyssp >= yyss + yystacksize - 1)
 835         YYABORT;
 836     }
 837
 838   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
 839
 840   goto yybackup;
 841
 842 /*-----------.
 843 | yybackup.  |
 844 `-----------*/
 845 yybackup:
 846
 847 /* Do appropriate processing given the current state.  */
 848 /* Read a lookahead token if we need one and don't already have one.  */
 849 /* yyresume: */
 850
 851   /* First try to decide what to do without reference to lookahead token.  */
 852
 853   yyn = yypact[yystate];
 854   if (yyn == YYFLAG)
 855     goto yydefault;
 856
 857   /* Not known => get a lookahead token if don't already have one.  */
 858
 859   /* yychar is either YYEMPTY or YYEOF
 860      or a valid token in external form.  */
 861
 862   if (yychar == YYEMPTY)
 863     {
 864       YYDPRINTF ((stderr, "Reading a token: "));
 865       yychar = YYLEX;
 866     }
 867
 868   /* Convert token to internal form (in yychar1) for indexing tables with.  */
 869
 870   if (yychar <= 0)              /* This means end of input.  */
 871     {
 872       yychar1 = 0;
 873       yychar = YYEOF;           /* Don't call YYLEX any more.  */
 874
 875       YYDPRINTF ((stderr, "Now at end of input.\n"));
 876     }
 877   else
 878     {
 879       yychar1 = YYTRANSLATE (yychar);
 880
 881 #if YYDEBUG
 882      /* We have to keep this `#if YYDEBUG', since we use variables
 883         which are defined only if `YYDEBUG' is set.  */
 884       if (yydebug)
 885         {
 886           YYFPRINTF (stderr, "Next token is %d (%s",
 887                      yychar, yytname[yychar1]);
 888           /* Give the individual parser a way to print the precise
 889              meaning of a token, for further debugging info.  */
 890 # ifdef YYPRINT
 891           YYPRINT (stderr, yychar, yylval);
 892 # endif
 893           YYFPRINTF (stderr, ")\n");
 894         }
 895 #endif
 896     }
 897
 898   yyn += yychar1;
 899   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
 900     goto yydefault;
 901
 902   yyn = yytable[yyn];
 903
 904   /* yyn is what to do for this token type in this state.
 905      Negative => reduce, -yyn is rule number.
 906      Positive => shift, yyn is new state.
 907        New state is final state => don't bother to shift,
 908        just return success.
 909      0, or most negative number => error.  */
 910
 911   if (yyn < 0)
 912     {
 913       if (yyn == YYFLAG)
 914         goto yyerrlab;
 915       yyn = -yyn;
 916       goto yyreduce;
 917     }
 918   else if (yyn == 0)
 919     goto yyerrlab;
 920
 921   if (yyn == YYFINAL)
 922     YYACCEPT;
 923
 924   /* Shift the lookahead token.  */
 925   YYDPRINTF ((stderr, "Shifting token %d (%s), ",
 926               yychar, yytname[yychar1]));
 927
 928   /* Discard the token being shifted unless it is eof.  */
 929   if (yychar != YYEOF)
 930     yychar = YYEMPTY;
 931
 932   *++yyvsp = yylval;
 933 ]b4_location_if([  *++yylsp = yylloc;])[
 934
 935   /* Count tokens shifted since error; after three, turn off error
 936      status.  */
 937   if (yyerrstatus)
 938     yyerrstatus--;
 939
 940   yystate = yyn;
 941   goto yynewstate;
 942
 943
 944 /*-----------------------------------------------------------.
 945 | yydefault -- do the default action for the current state.  |
 946 `-----------------------------------------------------------*/
 947 yydefault:
 948   yyn = yydefact[yystate];
 949   if (yyn == 0)
 950     goto yyerrlab;
 951   goto yyreduce;
 952
 953
 954 /*-----------------------------.
 955 | yyreduce -- Do a reduction.  |
 956 `-----------------------------*/
 957 yyreduce:
 958   /* yyn is the number of a rule to reduce with.  */
 959   yylen = yyr2[yyn];
 960
 961   /* If YYLEN is nonzero, implement the default value of the action:
 962      `$$ = $1'.
 963
 964      Otherwise, the following line sets YYVAL to the semantic value of
 965      the lookahead token.  This behavior is undocumented and Bison
 966      users should not rely upon it.  Assigning to YYVAL
 967      unconditionally makes the parser a bit smaller, and it avoids a
 968      GCC warning that YYVAL may be used uninitialized.  */
 969   yyval = yyvsp[1-yylen];
 970
 971 ]b4_location_if(
 972 [  /* Default location. */
 973   YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);])[
 974
 975 #if YYDEBUG
 976   /* We have to keep this `#if YYDEBUG', since we use variables which
 977      are defined only if `YYDEBUG' is set.  */
 978   if (yydebug)
 979     {
 980       int yyi;
 981
 982       YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
 983                  yyn - 1, yyrline[yyn]);
 984
 985       /* Print the symbols being reduced, and their result.  */
 986       for (yyi = yyprhs[yyn]; yyrhs[yyi] >= 0; yyi++)
 987         YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
 988       YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
 989     }
 990 #endif
 991   switch (yyn)
 992     ]{
 993       b4_actions
 994     }
 995
 996 /* Line __line__ of __file__.  */
 997 #line __oline__ "__ofile__"
 998 \f
 999 [  yyvsp -= yylen;
1000   yyssp -= yylen;
1001 ]b4_location_if([  yylsp -= yylen;])[
1002
1003 #if YYDEBUG
1004   if (yydebug)
1005     {
1006       short *yyssp1 = yyss - 1;
1007       YYFPRINTF (stderr, "state stack now");
1008       while (yyssp1 != yyssp)
1009         YYFPRINTF (stderr, " %d", *++yyssp1);
1010       YYFPRINTF (stderr, "\n");
1011     }
1012 #endif
1013
1014   *++yyvsp = yyval;
1015 ]b4_location_if([  *++yylsp = yyloc;])[
1016
1017   /* Now `shift' the result of the reduction.  Determine what state
1018      that goes to, based on the state we popped back to and the rule
1019      number reduced by.  */
1020
1021   yyn = yyr1[yyn];
1022
1023   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1024   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1025     yystate = yytable[yystate];
1026   else
1027     yystate = yydefgoto[yyn - YYNTOKENS];
1028
1029   goto yynewstate;
1030
1031
1032 /*------------------------------------.
1033 | yyerrlab -- here on detecting error |
1034 `------------------------------------*/
1035 yyerrlab:
1036   /* If not already recovering from an error, report this error.  */
1037   if (!yyerrstatus)
1038     {
1039       ++yynerrs;
1040
1041 #if YYERROR_VERBOSE
1042       yyn = yypact[yystate];
1043
1044       if (yyn > YYFLAG && yyn < YYLAST)
1045         {
1046           YYSIZE_T yysize = 0;
1047           char *yymsg;
1048           int yyx, yycount;
1049
1050           yycount = 0;
1051           /* Start YYX at -YYN if negative to avoid negative indexes in
1052              YYCHECK.  */
1053           for (yyx = yyn < 0 ? -yyn : 0;
1054                yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
1055             if (yycheck[yyx + yyn] == yyx)
1056               yysize += yystrlen (yytname[yyx]) + 15, yycount++;
1057           yysize += yystrlen ("parse error, unexpected ") + 1;
1058           yysize += yystrlen (yytname[YYTRANSLATE (yychar)]);
1059           yymsg = (char *) YYSTACK_ALLOC (yysize);
1060           if (yymsg != 0)
1061             {
1062               char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
1063               yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]);
1064
1065               if (yycount < 5)
1066                 {
1067                   yycount = 0;
1068                   for (yyx = yyn < 0 ? -yyn : 0;
1069                        yyx < (int) (sizeof (yytname) / sizeof (char *));
1070                        yyx++)
1071                     if (yycheck[yyx + yyn] == yyx)
1072                       {
1073                         const char *yyq = ! yycount ? ", expecting " : " or ";
1074                         yyp = yystpcpy (yyp, yyq);
1075                         yyp = yystpcpy (yyp, yytname[yyx]);
1076                         yycount++;
1077                       }
1078                 }
1079               yyerror (yymsg);
1080               YYSTACK_FREE (yymsg);
1081             }
1082           else
1083             yyerror ("parse error; also virtual memory exhausted");
1084         }
1085       else
1086 #endif /* YYERROR_VERBOSE */
1087         yyerror ("parse error");
1088     }
1089   goto yyerrlab1;
1090
1091
1092 /*----------------------------------------------------.
1093 | yyerrlab1 -- error raised explicitly by an action.  |
1094 `----------------------------------------------------*/
1095 yyerrlab1:
1096   if (yyerrstatus == 3)
1097     {
1098       /* If just tried and failed to reuse lookahead token after an
1099          error, discard it.  */
1100
1101       /* Return failure if at end of input.  */
1102       if (yychar == YYEOF)
1103         {
1104           /* Pop the error token.  */
1105           YYPOPSTACK;
1106           /* Pop the rest of the stack.  */
1107           while (yyssp > yyss)
1108             {
1109 #if YYDEBUG
1110               if (yydebug)
1111                 {
1112                   if (yystos[*yyssp] < YYNTOKENS)
1113                     {
1114                       YYFPRINTF (stderr, "Error: popping token %d (%s",
1115                                  yytoknum[yystos[*yyssp]],
1116                                  yytname[yystos[*yyssp]]);
1117 # ifdef YYPRINT
1118                       YYPRINT (stderr, yytoknum[yystos[*yyssp]], *yyvsp);
1119 # endif
1120                       YYFPRINTF (stderr, ")\n");
1121                     }
1122                   else
1123                     {
1124                       YYFPRINTF (stderr, "Error: popping nonterminal (%s)\n",
1125                                  yytname[yystos[*yyssp]]);
1126                     }
1127                 }
1128 #endif
1129               yydestructor (yystos[*yyssp], *yyvsp);
1130               YYPOPSTACK;
1131             }
1132           YYABORT;
1133         }
1134
1135       YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
1136                   yychar, yytname[yychar1]));
1137       yydestructor (yychar1, yylval);
1138       yychar = YYEMPTY;
1139     }
1140
1141   /* Else will try to reuse lookahead token after shifting the error
1142      token.  */
1143
1144   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
1145
1146   for (;;)
1147     {
1148       yyn = yypact[yystate];
1149       if (yyn != YYFLAG)
1150         {
1151           yyn += YYTERROR;
1152           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1153             {
1154               yyn = yytable[yyn];
1155               if (0 < yyn)
1156                 break;
1157             }
1158         }
1159
1160       /* Pop the current state because it cannot handle the error token.  */
1161       if (yyssp == yyss)
1162         YYABORT;
1163
1164 #if YYDEBUG
1165       if (yydebug)
1166         {
1167           if (yystos[yystate] < YYNTOKENS)
1168             {
1169               YYFPRINTF (stderr, "Error: popping token %d (%s",
1170                          yytoknum[yystos[yystate]], yytname[yystos[yystate]]);
1171 # ifdef YYPRINT
1172               YYPRINT (stderr, yytoknum[yystos[yystate]], *yyvsp);
1173 # endif
1174               YYFPRINTF (stderr, ")\n");
1175             }
1176           else
1177             {
1178               YYFPRINTF (stderr, "Error: popping nonterminal (%s)\n",
1179                          yytname[yystos[yystate]]);
1180             }
1181         }
1182 #endif
1183
1184       yydestructor (yystos[yystate], *yyvsp);
1185       yyvsp--;
1186       yystate = *--yyssp;
1187 ]b4_location_if([      yylsp--;])[
1188
1189 #if YYDEBUG
1190       if (yydebug)
1191         {
1192           short *yyssp1 = yyss - 1;
1193           YYFPRINTF (stderr, "Error: state stack now");
1194           while (yyssp1 != yyssp)
1195             YYFPRINTF (stderr, " %d", *++yyssp1);
1196           YYFPRINTF (stderr, "\n");
1197         }
1198 #endif
1199     }
1200
1201   if (yyn == YYFINAL)
1202     YYACCEPT;
1203
1204   YYDPRINTF ((stderr, "Shifting error token, "));
1205
1206   *++yyvsp = yylval;
1207 ]b4_location_if([  *++yylsp = yylloc;])[
1208
1209   yystate = yyn;
1210   goto yynewstate;
1211
1212
1213 /*-------------------------------------.
1214 | yyacceptlab -- YYACCEPT comes here.  |
1215 `-------------------------------------*/
1216 yyacceptlab:
1217   yyresult = 0;
1218   goto yyreturn;
1219
1220 /*-----------------------------------.
1221 | yyabortlab -- YYABORT comes here.  |
1222 `-----------------------------------*/
1223 yyabortlab:
1224   yyresult = 1;
1225   goto yyreturn;
1226
1227 #ifndef yyoverflow
1228 /*----------------------------------------------.
1229 | yyoverflowlab -- parser overflow comes here.  |
1230 `----------------------------------------------*/
1231 yyoverflowlab:
1232   yyerror ("parser stack overflow");
1233   yyresult = 2;
1234   /* Fall through.  */
1235 #endif
1236
1237 yyreturn:
1238 #ifndef yyoverflow
1239   if (yyss != yyssa)
1240     YYSTACK_FREE (yyss);
1241 #endif
1242   return yyresult;
1243 ]}
1244
1245
1246 /*-------------------------------------------------.
1247 | Release the memory associated to SYMBOL-NUMBER.  |
1248 `-------------------------------------------------*/
1249
1250 m4_divert_push([KILL])# M4 code.
1251 # b4_symbol_destructor(SYMBOL-NUMBER, DESTRUCTOR, TYPE-NAME)
1252 # ----------------------------------------------------------
1253 m4_define([b4_symbol_destructor],
1254 [m4_pushdef([b4_dollar_dollar], [symbol_value.$6])dnl
1255       case $4: /* $3 */
1256 #line $2 "$1"
1257         $5;
1258 #line __oline__ "__ofile__"
1259         break;
1260 m4_popdef([b4_dollar_dollar])])
1261
1262 m4_divert_pop([KILL])dnl# End of M4 code.
1263 static void
1264 yydestructor (int symbol_type, YYSTYPE symbol_value)
1265 {
1266   switch (symbol_type)
1267     {
1268 m4_map([b4_symbol_destructor], m4_defn([b4_symbol_destructors]))dnl
1269       default:
1270         YYDPRINTF ((stderr, "yydestructor: unknown symbol type: %d (%s)\n",
1271                     symbol_type, yytname[[symbol_type]]));
1272         break;
1273     }
1274 }
1275
1276 b4_epilogue
1277 m4_if(b4_defines_flag, 0, [],
1278 [#output "b4_output_header_name"
1279 #ifndef b4_header_guard
1280 # define b4_header_guard
1281
1282 b4_token_defines(b4_tokens)
1283
1284 #ifndef YYSTYPE
1285 m4_ifdef([b4_stype],
1286 [#line b4_stype_line "b4_filename"
1287 typedef union b4_stype yystype;
1288 /* Line __line__ of __file__.  */
1289 #line __oline__ "__ofile__"],
1290 [typedef int yystype;])
1291 # define YYSTYPE yystype
1292 #endif
1293
1294 b4_pure_if([],
1295 [extern YYSTYPE b4_prefix[]lval;])
1296
1297 b4_location_if(
1298 [#ifndef YYLTYPE
1299 typedef struct yyltype
1300 {
1301   int first_line;
1302   int first_column;
1303   int last_line;
1304   int last_column;
1305 } yyltype;
1306 # define YYLTYPE yyltype
1307 #endif
1308
1309 m4_if(b4_pure, [0],
1310 [extern YYLTYPE b4_prefix[]lloc;])
1311 ])
1312 #endif /* not b4_header_guard */
1313 ])