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