src/bison.simple

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