src/bison.simple

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