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