data/yacc.c

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