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