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 #define YYTRANSLATE(X) \
 336   ((unsigned)(X) <= YYMAXUTOK ? yytranslate[[X]] : YYUNDEFTOK)
 337
 338 /* YYTRANSLATE[[YYLEX]] -- Bison symbol number corresponding to YYLEX.  */
 339 static const b4_uint_type(b4_translate_max) yytranslate[[]] =
 340 {
 341   b4_translate
 342 };
 343
 344 #if YYDEBUG
 345 /* YYPRHS[[YYN]] -- Index of the first RHS symbol of rule number YYN in
 346    YYRHS.  */
 347 static const b4_uint_type(b4_prhs_max) yyprhs[[]] =
 348 {
 349   b4_prhs
 350 };
 351
 352 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
 353 static const b4_sint_type(b4_rhs_max) yyrhs[[]] =
 354 {
 355   b4_rhs
 356 };
 357
 358 /* YYRLINE[[YYN]] -- source line where rule number YYN was defined.  */
 359 static const b4_uint_type(b4_rline_max) yyrline[[]] =
 360 {
 361   b4_rline
 362 };
 363 #endif
 364
 365 #if (YYDEBUG) || YYERROR_VERBOSE
 366 /* YYTNME[[SYMBOL-NUM]] -- String name of the symbol SYMBOL-NUM.
 367    First, the terminals, then, starting at YYNTOKENS, nonterminals. */
 368 static const char *const yytname[[]] =
 369 {
 370   b4_tname
 371 };
 372 #endif
 373
 374 /* YYTOKNUM[[YYN]] -- Index in YYTNAME corresponding to YYLEX.  */
 375 static const short yytoknum[[]] =
 376 {
 377   b4_toknum
 378 };
 379
 380 /* YYR1[[YYN]] -- Symbol number of symbol that rule YYN derives.  */
 381 static const b4_uint_type(b4_r1_max) yyr1[[]] =
 382 {
 383   b4_r1
 384 };
 385
 386 /* YYR2[[YYN]] -- Number of symbols composing right hand side of rule YYN.  */
 387 static const b4_uint_type(b4_r2_max) yyr2[[]] =
 388 {
 389   b4_r2
 390 };
 391
 392 /* YYDEFACT[[S]] -- default rule to reduce with in state S when YYTABLE
 393    doesn't specify something else to do.  Zero means the default is an
 394    error.  */
 395 static const short yydefact[[]] =
 396 {
 397   b4_defact
 398 };
 399
 400 /* YYPGOTO[[NTERM-NUM]]. */
 401 static const short yydefgoto[[]] =
 402 {
 403   b4_defgoto
 404 };
 405
 406 /* YYPACT[[STATE-NUM]] -- Index in YYTABLE of the portion describing
 407    STATE-NUM.  */
 408 static const short yypact[[]] =
 409 {
 410   b4_pact
 411 };
 412
 413 /* YYPGOTO[[NTERM-NUM]].  */
 414 static const short yypgoto[[]] =
 415 {
 416   b4_pgoto
 417 };
 418
 419 /* YYTABLE[[YYPACT[STATE-NUM]]].  What to do in state STATE-NUM.  If
 420    positive, shift that token.  If negative, reduce the rule which
 421    number is the opposite.  If zero, do what YYDEFACT says.  */
 422 static const short yytable[[]] =
 423 {
 424   b4_table
 425 };
 426
 427 static const short yycheck[[]] =
 428 {
 429   b4_check
 430 };
 431
 432
 433 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
 434 # define YYSIZE_T __SIZE_TYPE__
 435 #endif
 436 #if ! defined (YYSIZE_T) && defined (size_t)
 437 # define YYSIZE_T size_t
 438 #endif
 439 #if ! defined (YYSIZE_T)
 440 # if defined (__STDC__) || defined (__cplusplus)
 441 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
 442 #  define YYSIZE_T size_t
 443 # endif
 444 #endif
 445 #if ! defined (YYSIZE_T)
 446 # define YYSIZE_T unsigned int
 447 #endif
 448
 449 #define yyerrok         (yyerrstatus = 0)
 450 #define yyclearin       (yychar = YYEMPTY)
 451 #define YYEMPTY         -2
 452 #define YYEOF           0
 453
 454 #define YYACCEPT        goto yyacceptlab
 455 #define YYABORT         goto yyabortlab
 456 #define YYERROR         goto yyerrlab1
 457
 458 /* Like YYERROR except do call yyerror.  This remains here temporarily
 459    to ease the transition to the new meaning of YYERROR, for GCC.
 460    Once GCC version 2 has supplanted version 1, this can go.  */
 461
 462 #define YYFAIL          goto yyerrlab
 463
 464 #define YYRECOVERING()  (!!yyerrstatus)
 465
 466 #define YYBACKUP(Token, Value)                                  \
 467 do                                                              \
 468   if (yychar == YYEMPTY && yylen == 1)                          \
 469     {                                                           \
 470       yychar = (Token);                                         \
 471       yylval = (Value);                                         \
 472       yychar1 = YYTRANSLATE (yychar);                           \
 473       YYPOPSTACK;                                               \
 474       goto yybackup;                                            \
 475     }                                                           \
 476   else                                                          \
 477     {                                                           \
 478       yyerror ("syntax error: cannot back up");                 \
 479       YYERROR;                                                  \
 480     }                                                           \
 481 while (0)
 482
 483 #define YYTERROR        1
 484 #define YYERRCODE       256
 485
 486 /* YYLLOC_DEFAULT -- Compute the default location (before the actions
 487    are run).  */
 488
 489 #ifndef YYLLOC_DEFAULT
 490 # define YYLLOC_DEFAULT(Current, Rhs, N)           \
 491   Current.first_line   = Rhs[[1]].first_line;      \
 492   Current.first_column = Rhs[[1]].first_column;    \
 493   Current.last_line    = Rhs[[N]].last_line;       \
 494   Current.last_column  = Rhs[[N]].last_column;
 495 #endif
 496
 497 /* YYLEX -- calling `yylex' with the right arguments.  */
 498
 499 #if YYPURE
 500 # if YYLSP_NEEDED
 501 #  ifdef YYLEX_PARAM
 502 #   define YYLEX                yylex (&yylval, &yylloc, YYLEX_PARAM)
 503 #  else
 504 #   define YYLEX                yylex (&yylval, &yylloc)
 505 #  endif
 506 # else /* !YYLSP_NEEDED */
 507 #  ifdef YYLEX_PARAM
 508 #   define YYLEX                yylex (&yylval, YYLEX_PARAM)
 509 #  else
 510 #   define YYLEX                yylex (&yylval)
 511 #  endif
 512 # endif /* !YYLSP_NEEDED */
 513 #else /* !YYPURE */
 514 # define YYLEX                  yylex ()
 515 #endif /* !YYPURE */
 516
 517 /* Enable debugging if requested.  */
 518 #if YYDEBUG
 519
 520 # ifndef YYFPRINTF
 521 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
 522 #  define YYFPRINTF fprintf
 523 # endif
 524
 525 # define YYDPRINTF(Args)                        \
 526 do {                                            \
 527   if (yydebug)                                  \
 528     YYFPRINTF Args;                             \
 529 } while (0)
 530 /* Nonzero means print parse trace.  It is left uninitialized so that
 531    multiple parsers can coexist.  */
 532 int yydebug;
 533 #else /* !YYDEBUG */
 534 # define YYDPRINTF(Args)
 535 #endif /* !YYDEBUG */
 536
 537 /* YYINITDEPTH -- initial size of the parser's stacks.  */
 538 #ifndef YYINITDEPTH
 539 # define YYINITDEPTH b4_initdepth
 540 #endif
 541
 542 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
 543    if the built-in stack extension method is used).
 544
 545    Do not make this value too large; the results are undefined if
 546    SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
 547    evaluated with infinite-precision integer arithmetic.  */
 548
 549 #if YYMAXDEPTH == 0
 550 # undef YYMAXDEPTH
 551 #endif
 552
 553 #ifndef YYMAXDEPTH
 554 # define YYMAXDEPTH b4_maxdepth
 555 #endif
 556
 557 \f
 558
 559 #if YYERROR_VERBOSE
 560
 561 # ifndef yystrlen
 562 #  if defined (__GLIBC__) && defined (_STRING_H)
 563 #   define yystrlen strlen
 564 #  else
 565 /* Return the length of YYSTR.  */
 566 static YYSIZE_T
 567 #   if defined (__STDC__) || defined (__cplusplus)
 568 yystrlen (const char *yystr)
 569 #   else
 570 yystrlen (yystr)
 571      const char *yystr;
 572 #   endif
 573 {
 574   register const char *yys = yystr;
 575
 576   while (*yys++ != '\0')
 577     continue;
 578
 579   return yys - yystr - 1;
 580 }
 581 #  endif
 582 # endif
 583
 584 # ifndef yystpcpy
 585 #  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
 586 #   define yystpcpy stpcpy
 587 #  else
 588 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
 589    YYDEST.  */
 590 static char *
 591 #   if defined (__STDC__) || defined (__cplusplus)
 592 yystpcpy (char *yydest, const char *yysrc)
 593 #   else
 594 yystpcpy (yydest, yysrc)
 595      char *yydest;
 596      const char *yysrc;
 597 #   endif
 598 {
 599   register char *yyd = yydest;
 600   register const char *yys = yysrc;
 601
 602   while ((*yyd++ = *yys++) != '\0')
 603     continue;
 604
 605   return yyd - 1;
 606 }
 607 #  endif
 608 # endif
 609
 610 #endif /* !YYERROR_VERBOSE */
 611
 612 \f
 613
 614 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
 615    into yyparse.  The argument should have type void *.
 616    It should actually point to an object.
 617    Grammar actions can access the variable by casting it
 618    to the proper pointer type.  */
 619
 620 #ifdef YYPARSE_PARAM
 621 # if defined (__STDC__) || defined (__cplusplus)
 622 #  define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
 623 #  define YYPARSE_PARAM_DECL
 624 # else
 625 #  define YYPARSE_PARAM_ARG YYPARSE_PARAM
 626 #  define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
 627 # endif
 628 #else /* !YYPARSE_PARAM */
 629 # define YYPARSE_PARAM_ARG
 630 # define YYPARSE_PARAM_DECL
 631 #endif /* !YYPARSE_PARAM */
 632
 633 /* Prevent warning if -Wstrict-prototypes.  */
 634 #ifdef __GNUC__
 635 # ifdef YYPARSE_PARAM
 636 int yyparse (void *);
 637 # else
 638 int yyparse (void);
 639 # endif
 640 #endif
 641
 642 /* YY_DECL_VARIABLES -- depending whether we use a pure parser,
 643    variables are global, or local to YYPARSE.  */
 644
 645 #define YY_DECL_NON_LSP_VARIABLES                       \
 646 /* The lookahead symbol.  */                            \
 647 int yychar;                                             \
 648                                                         \
 649 /* The semantic value of the lookahead symbol.  */      \
 650 YYSTYPE yylval;                                         \
 651                                                         \
 652 /* Number of parse errors so far.  */                   \
 653 int yynerrs;
 654
 655 #if YYLSP_NEEDED
 656 # define YY_DECL_VARIABLES                      \
 657 YY_DECL_NON_LSP_VARIABLES                       \
 658                                                 \
 659 /* Location data for the lookahead symbol.  */  \
 660 YYLTYPE yylloc;
 661 #else
 662 # define YY_DECL_VARIABLES                      \
 663 YY_DECL_NON_LSP_VARIABLES
 664 #endif
 665
 666 /* If nonreentrant, generate the variables here.  */
 667
 668 #if !YYPURE
 669 YY_DECL_VARIABLES
 670 #endif  /* !YYPURE */
 671
 672 int
 673 yyparse (YYPARSE_PARAM_ARG)
 674      YYPARSE_PARAM_DECL
 675 {[
 676   /* If reentrant, generate the variables here.  */
 677 #if YYPURE
 678   YY_DECL_VARIABLES
 679 #endif  /* !YYPURE */
 680
 681   register int yystate;
 682   register int yyn;
 683   int yyresult;
 684   /* Number of tokens to shift before error messages enabled.  */
 685   int yyerrstatus;
 686   /* Lookahead token as an internal (translated) token number.  */
 687   int yychar1 = 0;
 688
 689   /* Three stacks and their tools:
 690      `yyss': related to states,
 691      `yyvs': related to semantic values,
 692      `yyls': related to locations.
 693
 694      Refer to the stacks thru separate pointers, to allow yyoverflow
 695      to reallocate them elsewhere.  */
 696
 697   /* The state stack.  */
 698   short yyssa[YYINITDEPTH];
 699   short *yyss = yyssa;
 700   register short *yyssp;
 701
 702   /* The semantic value stack.  */
 703   YYSTYPE yyvsa[YYINITDEPTH];
 704   YYSTYPE *yyvs = yyvsa;
 705   register YYSTYPE *yyvsp;
 706
 707 #if YYLSP_NEEDED
 708   /* The location stack.  */
 709   YYLTYPE yylsa[YYINITDEPTH];
 710   YYLTYPE *yyls = yylsa;
 711   YYLTYPE *yylsp;
 712 #endif
 713
 714 #if YYLSP_NEEDED
 715 # define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
 716 #else
 717 # define YYPOPSTACK   (yyvsp--, yyssp--)
 718 #endif
 719
 720   YYSIZE_T yystacksize = YYINITDEPTH;
 721
 722   /* The variables used to return semantic value and location from the
 723      action routines.  */
 724   YYSTYPE yyval;
 725 #if YYLSP_NEEDED
 726   YYLTYPE yyloc;
 727 #endif
 728
 729   /* When reducing, the number of symbols on the RHS of the reduced
 730      rule.  */
 731   int yylen;
 732
 733   YYDPRINTF ((stderr, "Starting parse\n"));
 734
 735   yystate = 0;
 736   yyerrstatus = 0;
 737   yynerrs = 0;
 738   yychar = YYEMPTY;             /* Cause a token to be read.  */
 739
 740   /* Initialize stack pointers.
 741      Waste one element of value and location stack
 742      so that they stay on the same level as the state stack.
 743      The wasted elements are never initialized.  */
 744
 745   yyssp = yyss;
 746   yyvsp = yyvs;
 747 #if YYLSP_NEEDED
 748   yylsp = yyls;
 749 #endif
 750   goto yysetstate;
 751
 752 /*------------------------------------------------------------.
 753 | yynewstate -- Push a new state, which is found in yystate.  |
 754 `------------------------------------------------------------*/
 755  yynewstate:
 756   /* In all cases, when you get here, the value and location stacks
 757      have just been pushed. so pushing a state here evens the stacks.
 758      */
 759   yyssp++;
 760
 761  yysetstate:
 762   *yyssp = yystate;
 763
 764   if (yyssp >= yyss + yystacksize - 1)
 765     {
 766       /* Get the current used size of the three stacks, in elements.  */
 767       YYSIZE_T yysize = yyssp - yyss + 1;
 768
 769 #ifdef yyoverflow
 770       {
 771         /* Give user a chance to reallocate the stack. Use copies of
 772            these so that the &'s don't force the real ones into
 773            memory.  */
 774         YYSTYPE *yyvs1 = yyvs;
 775         short *yyss1 = yyss;
 776
 777         /* Each stack pointer address is followed by the size of the
 778            data in use in that stack, in bytes.  */
 779 # if YYLSP_NEEDED
 780         YYLTYPE *yyls1 = yyls;
 781         /* This used to be a conditional around just the two extra args,
 782            but that might be undefined if yyoverflow is a macro.  */
 783         yyoverflow ("parser stack overflow",
 784                     &yyss1, yysize * sizeof (*yyssp),
 785                     &yyvs1, yysize * sizeof (*yyvsp),
 786                     &yyls1, yysize * sizeof (*yylsp),
 787                     &yystacksize);
 788         yyls = yyls1;
 789 # else
 790         yyoverflow ("parser stack overflow",
 791                     &yyss1, yysize * sizeof (*yyssp),
 792                     &yyvs1, yysize * sizeof (*yyvsp),
 793                     &yystacksize);
 794 # endif
 795         yyss = yyss1;
 796         yyvs = yyvs1;
 797       }
 798 #else /* no yyoverflow */
 799 # ifndef YYSTACK_RELOCATE
 800       goto yyoverflowlab;
 801 # else
 802       /* Extend the stack our own way.  */
 803       if (yystacksize >= YYMAXDEPTH)
 804         goto yyoverflowlab;
 805       yystacksize *= 2;
 806       if (yystacksize > YYMAXDEPTH)
 807         yystacksize = YYMAXDEPTH;
 808
 809       {
 810         short *yyss1 = yyss;
 811         union yyalloc *yyptr =
 812           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
 813         if (! yyptr)
 814           goto yyoverflowlab;
 815         YYSTACK_RELOCATE (yyss);
 816         YYSTACK_RELOCATE (yyvs);
 817 #  if YYLSP_NEEDED
 818         YYSTACK_RELOCATE (yyls);
 819 #  endif
 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 #if YYLSP_NEEDED
 830       yylsp = yyls + yysize - 1;
 831 #endif
 832
 833       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
 834                   (unsigned long int) yystacksize));
 835
 836       if (yyssp >= yyss + yystacksize - 1)
 837         YYABORT;
 838     }
 839
 840   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
 841
 842   goto yybackup;
 843
 844 /*-----------.
 845 | yybackup.  |
 846 `-----------*/
 847 yybackup:
 848
 849 /* Do appropriate processing given the current state.  */
 850 /* Read a lookahead token if we need one and don't already have one.  */
 851 /* yyresume: */
 852
 853   /* First try to decide what to do without reference to lookahead token.  */
 854
 855   yyn = yypact[yystate];
 856   if (yyn == YYFLAG)
 857     goto yydefault;
 858
 859   /* Not known => get a lookahead token if don't already have one.  */
 860
 861   /* yychar is either YYEMPTY or YYEOF
 862      or a valid token in external form.  */
 863
 864   if (yychar == YYEMPTY)
 865     {
 866       YYDPRINTF ((stderr, "Reading a token: "));
 867       yychar = YYLEX;
 868     }
 869
 870   /* Convert token to internal form (in yychar1) for indexing tables with.  */
 871
 872   if (yychar <= 0)              /* This means end of input.  */
 873     {
 874       yychar1 = 0;
 875       yychar = YYEOF;           /* Don't call YYLEX any more.  */
 876
 877       YYDPRINTF ((stderr, "Now at end of input.\n"));
 878     }
 879   else
 880     {
 881       yychar1 = YYTRANSLATE (yychar);
 882
 883 #if YYDEBUG
 884      /* We have to keep this `#if YYDEBUG', since we use variables
 885         which are defined only if `YYDEBUG' is set.  */
 886       if (yydebug)
 887         {
 888           YYFPRINTF (stderr, "Next token is %d (%s",
 889                      yychar, yytname[yychar1]);
 890           /* Give the individual parser a way to print the precise
 891              meaning of a token, for further debugging info.  */
 892 # ifdef YYPRINT
 893           YYPRINT (stderr, yychar, yylval);
 894 # endif
 895           YYFPRINTF (stderr, ")\n");
 896         }
 897 #endif
 898     }
 899
 900   yyn += yychar1;
 901   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
 902     goto yydefault;
 903
 904   yyn = yytable[yyn];
 905
 906   /* yyn is what to do for this token type in this state.
 907      Negative => reduce, -yyn is rule number.
 908      Positive => shift, yyn is new state.
 909        New state is final state => don't bother to shift,
 910        just return success.
 911      0, or most negative number => error.  */
 912
 913   if (yyn < 0)
 914     {
 915       if (yyn == YYFLAG)
 916         goto yyerrlab;
 917       yyn = -yyn;
 918       goto yyreduce;
 919     }
 920   else if (yyn == 0)
 921     goto yyerrlab;
 922
 923   if (yyn == YYFINAL)
 924     YYACCEPT;
 925
 926   /* Shift the lookahead token.  */
 927   YYDPRINTF ((stderr, "Shifting token %d (%s), ",
 928               yychar, yytname[yychar1]));
 929
 930   /* Discard the token being shifted unless it is eof.  */
 931   if (yychar != YYEOF)
 932     yychar = YYEMPTY;
 933
 934   *++yyvsp = yylval;
 935 #if YYLSP_NEEDED
 936   *++yylsp = yylloc;
 937 #endif
 938
 939   /* Count tokens shifted since error; after three, turn off error
 940      status.  */
 941   if (yyerrstatus)
 942     yyerrstatus--;
 943
 944   yystate = yyn;
 945   goto yynewstate;
 946
 947
 948 /*-----------------------------------------------------------.
 949 | yydefault -- do the default action for the current state.  |
 950 `-----------------------------------------------------------*/
 951 yydefault:
 952   yyn = yydefact[yystate];
 953   if (yyn == 0)
 954     goto yyerrlab;
 955   goto yyreduce;
 956
 957
 958 /*-----------------------------.
 959 | yyreduce -- Do a reduction.  |
 960 `-----------------------------*/
 961 yyreduce:
 962   /* yyn is the number of a rule to reduce with.  */
 963   yylen = yyr2[yyn];
 964
 965   /* If YYLEN is nonzero, implement the default value of the action:
 966      `$$ = $1'.
 967
 968      Otherwise, the following line sets YYVAL to the semantic value of
 969      the lookahead token.  This behavior is undocumented and Bison
 970      users should not rely upon it.  Assigning to YYVAL
 971      unconditionally makes the parser a bit smaller, and it avoids a
 972      GCC warning that YYVAL may be used uninitialized.  */
 973   yyval = yyvsp[1-yylen];
 974
 975 #if YYLSP_NEEDED
 976   /* Default location. */
 977   YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
 978 #endif
 979
 980 #if YYDEBUG
 981   /* We have to keep this `#if YYDEBUG', since we use variables which
 982      are defined only if `YYDEBUG' is set.  */
 983   if (yydebug)
 984     {
 985       int yyi;
 986
 987       YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
 988                  yyn - 1, yyrline[yyn]);
 989
 990       /* Print the symbols being reduced, and their result.  */
 991       for (yyi = yyprhs[yyn]; yyrhs[yyi] >= 0; yyi++)
 992         YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
 993       YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
 994     }
 995 #endif
 996   switch (yyn)
 997     ]{
 998       b4_actions
 999     }
1000
1001 /* Line __line__ of __file__.  */
1002 #line __oline__ "__ofile__"
1003 \f
1004 [  yyvsp -= yylen;
1005   yyssp -= yylen;
1006 #if YYLSP_NEEDED
1007   yylsp -= yylen;
1008 #endif
1009
1010 #if YYDEBUG
1011   if (yydebug)
1012     {
1013       short *yyssp1 = yyss - 1;
1014       YYFPRINTF (stderr, "state stack now");
1015       while (yyssp1 != yyssp)
1016         YYFPRINTF (stderr, " %d", *++yyssp1);
1017       YYFPRINTF (stderr, "\n");
1018     }
1019 #endif
1020
1021   *++yyvsp = yyval;
1022 #if YYLSP_NEEDED
1023   *++yylsp = yyloc;
1024 #endif
1025
1026   /* Now `shift' the result of the reduction.  Determine what state
1027      that goes to, based on the state we popped back to and the rule
1028      number reduced by.  */
1029
1030   yyn = yyr1[yyn];
1031
1032   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1033   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1034     yystate = yytable[yystate];
1035   else
1036     yystate = yydefgoto[yyn - YYNTOKENS];
1037
1038   goto yynewstate;
1039
1040
1041 /*------------------------------------.
1042 | yyerrlab -- here on detecting error |
1043 `------------------------------------*/
1044 yyerrlab:
1045   /* If not already recovering from an error, report this error.  */
1046   if (!yyerrstatus)
1047     {
1048       ++yynerrs;
1049
1050 #if YYERROR_VERBOSE
1051       yyn = yypact[yystate];
1052
1053       if (yyn > YYFLAG && yyn < YYLAST)
1054         {
1055           YYSIZE_T yysize = 0;
1056           char *yymsg;
1057           int yyx, yycount;
1058
1059           yycount = 0;
1060           /* Start YYX at -YYN if negative to avoid negative indexes in
1061              YYCHECK.  */
1062           for (yyx = yyn < 0 ? -yyn : 0;
1063                yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
1064             if (yycheck[yyx + yyn] == yyx)
1065               yysize += yystrlen (yytname[yyx]) + 15, yycount++;
1066           yysize += yystrlen ("parse error, unexpected ") + 1;
1067           yysize += yystrlen (yytname[YYTRANSLATE (yychar)]);
1068           yymsg = (char *) YYSTACK_ALLOC (yysize);
1069           if (yymsg != 0)
1070             {
1071               char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
1072               yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]);
1073
1074               if (yycount < 5)
1075                 {
1076                   yycount = 0;
1077                   for (yyx = yyn < 0 ? -yyn : 0;
1078                        yyx < (int) (sizeof (yytname) / sizeof (char *));
1079                        yyx++)
1080                     if (yycheck[yyx + yyn] == yyx)
1081                       {
1082                         const char *yyq = ! yycount ? ", expecting " : " or ";
1083                         yyp = yystpcpy (yyp, yyq);
1084                         yyp = yystpcpy (yyp, yytname[yyx]);
1085                         yycount++;
1086                       }
1087                 }
1088               yyerror (yymsg);
1089               YYSTACK_FREE (yymsg);
1090             }
1091           else
1092             yyerror ("parse error; also virtual memory exhausted");
1093         }
1094       else
1095 #endif /* YYERROR_VERBOSE */
1096         yyerror ("parse error");
1097     }
1098   goto yyerrlab1;
1099
1100
1101 /*----------------------------------------------------.
1102 | yyerrlab1 -- error raised explicitly by an action.  |
1103 `----------------------------------------------------*/
1104 yyerrlab1:
1105   if (yyerrstatus == 3)
1106     {
1107       /* If just tried and failed to reuse lookahead token after an
1108          error, discard it.  */
1109
1110       /* Return failure if at end of input.  */
1111       if (yychar == YYEOF)
1112         YYABORT;
1113       YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
1114                   yychar, yytname[yychar1]));
1115       yychar = YYEMPTY;
1116     }
1117
1118   /* Else will try to reuse lookahead token after shifting the error
1119      token.  */
1120
1121   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
1122
1123   for (;;)
1124     {
1125       yyn = yypact[yystate];
1126       if (yyn != YYFLAG)
1127         {
1128           yyn += YYTERROR;
1129           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1130             {
1131               yyn = yytable[yyn];
1132               if (0 < yyn)
1133                 break;
1134             }
1135         }
1136
1137       /* Pop the current state because it cannot handle the error token.  */
1138       if (yyssp == yyss)
1139         YYABORT;
1140       yyvsp--;
1141       yystate = *--yyssp;
1142 #if YYLSP_NEEDED
1143       yylsp--;
1144 #endif
1145
1146 #if YYDEBUG
1147       if (yydebug)
1148         {
1149           short *yyssp1 = yyss - 1;
1150           YYFPRINTF (stderr, "Error: state stack now");
1151           while (yyssp1 != yyssp)
1152             YYFPRINTF (stderr, " %d", *++yyssp1);
1153           YYFPRINTF (stderr, "\n");
1154         }
1155 #endif
1156     }
1157
1158   if (yyn == YYFINAL)
1159     YYACCEPT;
1160
1161   YYDPRINTF ((stderr, "Shifting error token, "));
1162
1163   *++yyvsp = yylval;
1164 #if YYLSP_NEEDED
1165   *++yylsp = yylloc;
1166 #endif
1167
1168   yystate = yyn;
1169   goto yynewstate;
1170
1171
1172 /*-------------------------------------.
1173 | yyacceptlab -- YYACCEPT comes here.  |
1174 `-------------------------------------*/
1175 yyacceptlab:
1176   yyresult = 0;
1177   goto yyreturn;
1178
1179 /*-----------------------------------.
1180 | yyabortlab -- YYABORT comes here.  |
1181 `-----------------------------------*/
1182 yyabortlab:
1183   yyresult = 1;
1184   goto yyreturn;
1185
1186 /*---------------------------------------------.
1187 | yyoverflowab -- parser overflow comes here.  |
1188 `---------------------------------------------*/
1189 yyoverflowlab:
1190   yyerror ("parser stack overflow");
1191   yyresult = 2;
1192   /* Fall through.  */
1193
1194 yyreturn:
1195 #ifndef yyoverflow
1196   if (yyss != yyssa)
1197     YYSTACK_FREE (yyss);
1198 #endif
1199   return yyresult;
1200 ]}
1201
1202 b4_epilogue
1203 m4_if(b4_defines_flag, 0, [],
1204 [#output "b4_output_header_name"
1205 #ifndef b4_header_guard
1206 # define b4_header_guard
1207
1208 b4_token_defines(b4_tokens)
1209
1210 #ifndef YYSTYPE
1211 m4_ifdef([b4_stype_line],
1212 [#line b4_stype_line "b4_filename"
1213 ])dnl
1214 typedef b4_stype
1215 yystype;
1216 # define YYSTYPE yystype
1217 #endif
1218
1219 m4_if(b4_pure, [0],
1220 [extern YYSTYPE b4_prefix[]lval;])
1221
1222 m4_if(b4_locations_flag, [0], [],
1223 [#ifndef YYLTYPE
1224 typedef struct yyltype
1225 {
1226   int first_line;
1227   int first_column;
1228   int last_line;
1229   int last_column;
1230 } yyltype;
1231 # define YYLTYPE yyltype
1232 #endif
1233
1234 m4_if(b4_pure, [0],
1235 [extern YYLTYPE b4_prefix[]lloc;])
1236 ])
1237 #endif /* not b4_header_guard */
1238 ])