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