src/bison.simple

   1 /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
   2 #line
   3 /* This file comes from bison-@bison_version@.  */
   4
   5 /* Skeleton output parser for bison,
   6    Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2, or (at your option)
  11    any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 /* As a special exception, when this file is copied by Bison into a
  24    Bison output file, you may use that output file without restriction.
  25    This special exception was added by the Free Software Foundation
  26    in version 1.24 of Bison.  */
  27
  28 /* This is the parser code that is written into each bison parser when
  29    the %semantic_parser declaration is not specified in the grammar.
  30    It was written by Richard Stallman by simplifying the hairy parser
  31    used when %semantic_parser is specified.  */
  32
  33 #ifndef YYSTACK_USE_ALLOCA
  34 # ifdef alloca
  35 #  define YYSTACK_USE_ALLOCA
  36 # else /* alloca not defined */
  37 #  ifdef __GNUC__
  38 #   define YYSTACK_USE_ALLOCA
  39 #   define alloca __builtin_alloca
  40 #  else /* not GNU C.  */
  41 #   if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
  42 #    define YYSTACK_USE_ALLOCA
  43 #    include <alloca.h>
  44 #   else /* not sparc */
  45      /* We think this test detects Watcom and Microsoft C.  */
  46      /* This used to test MSDOS, but that is a bad idea since that
  47         symbol is in the user namespace.  */
  48 #    if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
  49 #     if 0
  50        /* No need for malloc.h, which pollutes the namespace; instead,
  51           just don't use alloca.  */
  52 #      include <malloc.h>
  53 #     endif
  54 #    else /* not MSDOS, or __TURBOC__ */
  55 #     if defined(_AIX)
  56        /* I don't know what this was needed for, but it pollutes the
  57           namespace.  So I turned it off.  rms, 2 May 1997.  */
  58        /* #include <malloc.h>  */
  59  #pragma alloca
  60 #      define YYSTACK_USE_ALLOCA
  61 #     else /* not MSDOS, or __TURBOC__, or _AIX */
  62 #      if 0
  63         /* haible@ilog.fr says this works for HPUX 9.05 and up, and on
  64            HPUX 10.  Eventually we can turn this on.  */
  65 #       ifdef __hpux
  66 #        define YYSTACK_USE_ALLOCA
  67 #        define alloca __builtin_alloca
  68 #       endif /* __hpux */
  69 #      endif
  70 #     endif /* not _AIX */
  71 #    endif /* not MSDOS, or __TURBOC__ */
  72 #   endif /* not sparc */
  73 #  endif /* not GNU C */
  74 # endif /* alloca not defined */
  75 #endif /* YYSTACK_USE_ALLOCA not defined */
  76
  77 #ifdef YYSTACK_USE_ALLOCA
  78 # define YYSTACK_ALLOC alloca
  79 #else
  80 # define YYSTACK_ALLOC malloc
  81 #endif
  82
  83 /* Note: there must be only one dollar sign in this file.
  84    It is replaced by the list of actions, each action
  85    as one case of the switch.  */
  86
  87 #define yyerrok         (yyerrstatus = 0)
  88 #define yyclearin       (yychar = YYEMPTY)
  89 #define YYEMPTY         -2
  90 #define YYEOF           0
  91 #define YYACCEPT        goto yyacceptlab
  92 #define YYABORT         goto yyabortlab
  93 #define YYERROR         goto yyerrlab1
  94 /* Like YYERROR except do call yyerror.  This remains here temporarily
  95    to ease the transition to the new meaning of YYERROR, for GCC.
  96    Once GCC version 2 has supplanted version 1, this can go.  */
  97 #define YYFAIL          goto yyerrlab
  98 #define YYRECOVERING()  (!!yyerrstatus)
  99 #define YYBACKUP(Token, Value) \
 100 do                                                              \
 101   if (yychar == YYEMPTY && yylen == 1)                          \
 102     {                                                           \
 103       yychar = (Token);                                         \
 104       yylval = (Value);                                         \
 105       yychar1 = YYTRANSLATE (yychar);                           \
 106       YYPOPSTACK;                                               \
 107       goto yybackup;                                            \
 108     }                                                           \
 109   else                                                          \
 110     {                                                           \
 111       yyerror ("syntax error: cannot back up");                 \
 112       YYERROR;                                                  \
 113     }                                                           \
 114 while (0)
 115
 116 #define YYTERROR        1
 117 #define YYERRCODE       256
 118
 119 #ifndef YYPURE
 120 # define YYLEX          yylex ()
 121 #endif
 122
 123 #ifdef YYPURE
 124 # ifdef YYLSP_NEEDED
 125 #  ifdef YYLEX_PARAM
 126 #   define YYLEX                yylex (&yylval, &yylloc, YYLEX_PARAM)
 127 #  else
 128 #   define YYLEX                yylex (&yylval, &yylloc)
 129 #  endif
 130 # else /* !YYLSP_NEEDED */
 131 #  ifdef YYLEX_PARAM
 132 #   define YYLEX                yylex (&yylval, YYLEX_PARAM)
 133 #  else
 134 #   define YYLEX                yylex (&yylval)
 135 #  endif
 136 # endif /* !YYLSP_NEEDED */
 137 #endif
 138
 139 /* If nonreentrant, generate the variables here. */
 140
 141 #ifndef YYPURE
 142 /* The lookahead symbol.  */
 143 int yychar;
 144
 145 /* The semantic value of the lookahead symbol. */
 146 YYSTYPE yylval;
 147
 148 # ifdef YYLSP_NEEDED
 149 /* Location data for the lookahead symbol.  */
 150 YYLTYPE yylloc;
 151 # endif
 152
 153 /* Number of parse errors so far.  */
 154 int yynerrs;
 155 #endif  /* !YYPURE */
 156
 157 /* Enable debugging if requested.  */
 158 #if YYDEBUG
 159 # define YYDPRINTF(Args)                        \
 160 do {                                            \
 161   if (yydebug)                                  \
 162     fprintf Args;                               \
 163 } while (0)
 164 /* Nonzero means print parse trace. [The following comment makes no
 165    sense to me.  Could someone clarify it?  --akim] Since this is
 166    uninitialized, it does not stop multiple parsers from coexisting.
 167    */
 168 int yydebug;
 169 #else /* !YYDEBUG */
 170 # define YYDPRINTF(Args)
 171 #endif /* !YYDEBUG */
 172
 173 /* YYINITDEPTH -- initial size of the parser's stacks.  */
 174 #ifndef YYINITDEPTH
 175 # define YYINITDEPTH 200
 176 #endif
 177
 178 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
 179    if the built-in stack extension method is used).  */
 180 #if YYMAXDEPTH == 0
 181 # undef YYMAXDEPTH
 182 #endif
 183
 184 #ifndef YYMAXDEPTH
 185 # define YYMAXDEPTH 10000
 186 #endif
 187 \f
 188 /* Define __yy_memcpy.  Note that the size argument
 189    should be passed with type unsigned int, because that is what the non-GCC
 190    definitions require.  With GCC, __builtin_memcpy takes an arg
 191    of type size_t, but it can handle unsigned int.  */
 192
 193 #if __GNUC__ > 1                /* GNU C and GNU C++ define this.  */
 194 # define __yy_memcpy(To, From, Count)   __builtin_memcpy (To, From, Count)
 195 #else                           /* not GNU C or C++ */
 196 # ifndef __cplusplus
 197
 198 /* This is the most reliable way to avoid incompatibilities
 199    in available built-in functions on various systems.  */
 200 static void
 201 __yy_memcpy (to, from, count)
 202      char *to;
 203      char *from;
 204      unsigned int count;
 205 {
 206   register char *f = from;
 207   register char *t = to;
 208   register int i = count;
 209
 210   while (i-- > 0)
 211     *t++ = *f++;
 212 }
 213
 214 # else /* __cplusplus */
 215
 216 /* This is the most reliable way to avoid incompatibilities
 217    in available built-in functions on various systems.  */
 218 static void
 219 __yy_memcpy (char *to, char *from, unsigned int count)
 220 {
 221   register char *t = to;
 222   register char *f = from;
 223   register int i = count;
 224
 225   while (i-- > 0)
 226     *t++ = *f++;
 227 }
 228
 229 # endif
 230 #endif
 231 \f
 232 #line
 233
 234 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
 235    into yyparse.  The argument should have type void *.
 236    It should actually point to an object.
 237    Grammar actions can access the variable by casting it
 238    to the proper pointer type.  */
 239
 240 #ifdef YYPARSE_PARAM
 241 # ifdef __cplusplus
 242 #  define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
 243 #  define YYPARSE_PARAM_DECL
 244 # else /* !__cplusplus */
 245 #  define YYPARSE_PARAM_ARG YYPARSE_PARAM
 246 #  define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
 247 # endif /* !__cplusplus */
 248 #else /* !YYPARSE_PARAM */
 249 # define YYPARSE_PARAM_ARG
 250 # define YYPARSE_PARAM_DECL
 251 #endif /* !YYPARSE_PARAM */
 252
 253 /* Prevent warning if -Wstrict-prototypes.  */
 254 #ifdef __GNUC__
 255 # ifdef YYPARSE_PARAM
 256 int yyparse (void *);
 257 # else
 258 int yyparse (void);
 259 # endif
 260 #endif
 261
 262 int
 263 yyparse (YYPARSE_PARAM_ARG)
 264      YYPARSE_PARAM_DECL
 265 {
 266   register int yystate;
 267   register int yyn;
 268   /* Number of tokens to shift before error messages enabled.  */
 269   int yyerrstatus;
 270   /* Lookahead token as an internal (translated) token number.  */
 271   int yychar1 = 0;
 272
 273   /* Three stacks and their tools:
 274      `yyss': related to states,
 275      `yysv': related to semantic values,
 276      `yyls': related to locations.
 277
 278      Refer to the stacks thru separate pointers, to allow yyoverflow
 279      to reallocate them elsewhere.  */
 280
 281   /* The state stack. */
 282   short yyssa[YYINITDEPTH];
 283   short *yyss = yyssa;
 284   register short *yyssp;
 285
 286   /* The semantic value stack.  */
 287   YYSTYPE yyvsa[YYINITDEPTH];
 288   YYSTYPE *yyvs = yyvsa;
 289   register YYSTYPE *yyvsp;
 290
 291 #ifdef YYLSP_NEEDED
 292   /* The location stack.  */
 293   YYLTYPE yylsa[YYINITDEPTH];
 294   YYLTYPE *yyls = yylsa;
 295   YYLTYPE *yylsp;
 296 #endif
 297
 298 #ifdef YYLSP_NEEDED
 299 # define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
 300 #else
 301 # define YYPOPSTACK   (yyvsp--, yyssp--)
 302 #endif
 303
 304   int yystacksize = YYINITDEPTH;
 305   int yyfree_stacks = 0;
 306
 307 #ifdef YYPURE
 308   int yychar;
 309   YYSTYPE yylval;
 310   int yynerrs;
 311 # ifdef YYLSP_NEEDED
 312   YYLTYPE yylloc;
 313 # endif
 314 #endif
 315
 316
 317   /* The variables used to return semantic value and location from the
 318      action routines.  */
 319   YYSTYPE yyval;
 320 # ifdef YYLSP_NEEDED
 321   YYLTYPE yyloc;
 322 # endif
 323
 324   /* When reducing, the number of symbols on the RHS of the reduced
 325      rule. */
 326   int yylen;
 327
 328   YYDPRINTF ((stderr, "Starting parse\n"));
 329
 330   yystate = 0;
 331   yyerrstatus = 0;
 332   yynerrs = 0;
 333   yychar = YYEMPTY;             /* Cause a token to be read.  */
 334
 335   /* Initialize stack pointers.
 336      Waste one element of value and location stack
 337      so that they stay on the same level as the state stack.
 338      The wasted elements are never initialized.  */
 339
 340   yyssp = yyss - 1;
 341   yyvsp = yyvs;
 342 #ifdef YYLSP_NEEDED
 343   yylsp = yyls;
 344 #endif
 345
 346
 347 /*------------------------------------------------------------.
 348 | yynewstate -- Push a new state, which is found in yystate.  |
 349 `------------------------------------------------------------*/
 350 yynewstate:
 351   /* In all cases, when you get here, the value and location stacks
 352      have just been pushed. so pushing a state here evens the stacks.
 353      */
 354   *++yyssp = yystate;
 355
 356   if (yyssp >= yyss + yystacksize - 1)
 357     {
 358       /* Give user a chance to reallocate the stack. Use copies of
 359          these so that the &'s don't force the real ones into memory.
 360          */
 361       YYSTYPE *yyvs1 = yyvs;
 362       short *yyss1 = yyss;
 363 #ifdef YYLSP_NEEDED
 364       YYLTYPE *yyls1 = yyls;
 365 #endif
 366
 367       /* Get the current used size of the three stacks, in elements.  */
 368       int size = yyssp - yyss + 1;
 369
 370 #ifdef yyoverflow
 371       /* Each stack pointer address is followed by the size of
 372          the data in use in that stack, in bytes.  */
 373 # ifdef YYLSP_NEEDED
 374       /* This used to be a conditional around just the two extra args,
 375          but that might be undefined if yyoverflow is a macro.  */
 376       yyoverflow ("parser stack overflow",
 377                   &yyss1, size * sizeof (*yyssp),
 378                   &yyvs1, size * sizeof (*yyvsp),
 379                   &yyls1, size * sizeof (*yylsp),
 380                   &yystacksize);
 381 # else
 382       yyoverflow ("parser stack overflow",
 383                   &yyss1, size * sizeof (*yyssp),
 384                   &yyvs1, size * sizeof (*yyvsp),
 385                   &yystacksize);
 386 # endif
 387
 388       yyss = yyss1; yyvs = yyvs1;
 389 # ifdef YYLSP_NEEDED
 390       yyls = yyls1;
 391 # endif
 392 #else /* no yyoverflow */
 393       /* Extend the stack our own way.  */
 394       if (yystacksize >= YYMAXDEPTH)
 395         {
 396           yyerror ("parser stack overflow");
 397           if (yyfree_stacks)
 398             {
 399               free (yyss);
 400               free (yyvs);
 401 # ifdef YYLSP_NEEDED
 402               free (yyls);
 403 # endif
 404             }
 405           return 2;
 406         }
 407       yystacksize *= 2;
 408       if (yystacksize > YYMAXDEPTH)
 409         yystacksize = YYMAXDEPTH;
 410 # ifndef YYSTACK_USE_ALLOCA
 411       yyfree_stacks = 1;
 412 # endif
 413       yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
 414       __yy_memcpy ((char *)yyss, (char *)yyss1,
 415                    size * (unsigned int) sizeof (*yyssp));
 416       yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
 417       __yy_memcpy ((char *)yyvs, (char *)yyvs1,
 418                    size * (unsigned int) sizeof (*yyvsp));
 419 # ifdef YYLSP_NEEDED
 420       yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
 421       __yy_memcpy ((char *)yyls, (char *)yyls1,
 422                    size * (unsigned int) sizeof (*yylsp));
 423 # endif
 424 #endif /* no yyoverflow */
 425
 426       yyssp = yyss + size - 1;
 427       yyvsp = yyvs + size - 1;
 428 #ifdef YYLSP_NEEDED
 429       yylsp = yyls + size - 1;
 430 #endif
 431
 432       YYDPRINTF ((stderr, "Stack size increased to %d\n", yystacksize));
 433
 434       if (yyssp >= yyss + yystacksize - 1)
 435         YYABORT;
 436     }
 437
 438   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
 439
 440   goto yybackup;
 441
 442
 443 /*-----------.
 444 | yybackup.  |
 445 `-----------*/
 446 yybackup:
 447
 448 /* Do appropriate processing given the current state.  */
 449 /* Read a lookahead token if we need one and don't already have one.  */
 450 /* yyresume: */
 451
 452   /* First try to decide what to do without reference to lookahead token.  */
 453
 454   yyn = yypact[yystate];
 455   if (yyn == YYFLAG)
 456     goto yydefault;
 457
 458   /* Not known => get a lookahead token if don't already have one.  */
 459
 460   /* yychar is either YYEMPTY or YYEOF
 461      or a valid token in external form.  */
 462
 463   if (yychar == YYEMPTY)
 464     {
 465       YYDPRINTF ((stderr, "Reading a token: "));
 466       yychar = YYLEX;
 467     }
 468
 469   /* Convert token to internal form (in yychar1) for indexing tables with */
 470
 471   if (yychar <= 0)              /* This means end of input. */
 472     {
 473       yychar1 = 0;
 474       yychar = YYEOF;           /* Don't call YYLEX any more */
 475
 476       YYDPRINTF ((stderr, "Now at end of input.\n"));
 477     }
 478   else
 479     {
 480       yychar1 = YYTRANSLATE (yychar);
 481
 482 #if YYDEBUG
 483      /* We have to keep this `#if YYDEBUG', since we use variables
 484         which are defined only if `YYDEBUG' is set.  */
 485       if (yydebug)
 486         {
 487           fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
 488           /* Give the individual parser a way to print the precise
 489              meaning of a token, for further debugging info.  */
 490 # ifdef YYPRINT
 491           YYPRINT (stderr, yychar, yylval);
 492 # endif
 493           fprintf (stderr, ")\n");
 494         }
 495 #endif
 496     }
 497
 498   yyn += yychar1;
 499   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
 500     goto yydefault;
 501
 502   yyn = yytable[yyn];
 503
 504   /* yyn is what to do for this token type in this state.
 505      Negative => reduce, -yyn is rule number.
 506      Positive => shift, yyn is new state.
 507        New state is final state => don't bother to shift,
 508        just return success.
 509      0, or most negative number => error.  */
 510
 511   if (yyn < 0)
 512     {
 513       if (yyn == YYFLAG)
 514         goto yyerrlab;
 515       yyn = -yyn;
 516       goto yyreduce;
 517     }
 518   else if (yyn == 0)
 519     goto yyerrlab;
 520
 521   if (yyn == YYFINAL)
 522     YYACCEPT;
 523
 524   /* Shift the lookahead token.  */
 525   YYDPRINTF ((stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]));
 526
 527   /* Discard the token being shifted unless it is eof.  */
 528   if (yychar != YYEOF)
 529     yychar = YYEMPTY;
 530
 531   *++yyvsp = yylval;
 532 #ifdef YYLSP_NEEDED
 533   *++yylsp = yylloc;
 534 #endif
 535
 536   /* Count tokens shifted since error; after three, turn off error
 537      status.  */
 538   if (yyerrstatus)
 539     yyerrstatus--;
 540
 541   yystate = yyn;
 542   goto yynewstate;
 543
 544
 545 /*-----------------------------------------------------------.
 546 | yydefault -- do the default action for the current state.  |
 547 `-----------------------------------------------------------*/
 548 yydefault:
 549   yyn = yydefact[yystate];
 550   if (yyn == 0)
 551     goto yyerrlab;
 552   goto yyreduce;
 553
 554
 555 /*-----------------------------.
 556 | yyreduce -- Do a reduction.  |
 557 `-----------------------------*/
 558 yyreduce:
 559   /* yyn is the number of a rule to reduce with.  */
 560   yylen = yyr2[yyn];
 561
 562   /* If YYLEN is nonzero, implement the default value of the action:
 563      `{dollar}{dollar} = {dollar}1'.
 564
 565      Otherwise, the following line sets YYVAL to the semantic value of
 566      the lookahead token.  This behavior is undocumented and Bison
 567      users should not rely upon it.  Assigning to YYVAL
 568      unconditionally makes the parser a bit smaller, and it avoids a
 569      GCC warning that YYVAL may be used uninitialized.  */
 570   yyval = yyvsp[1-yylen];
 571 #ifdef YYLSP_NEEDED
 572   /* Implement default location.  If the rhs is empty, extend YYLOC to
 573      YYLLOC, which corresponds to the current token, otherwise
 574      implement `@{dollar} = Starts at @1, ends at @YYLEN'.  */
 575   if (yylen > 0)
 576     {
 577       yyloc = yylsp[1-yylen];
 578       yyloc.last_line = yylsp[0].last_line;
 579       yyloc.last_column = yylsp[0].last_column;
 580     }
 581   else
 582     {
 583       yyloc.last_line = yylsp[0].last_line;
 584       yyloc.last_column = yylsp[0].last_column;
 585       yyloc.text = 0;
 586     }
 587 #endif
 588
 589 #if YYDEBUG
 590   /* We have to keep this `#if YYDEBUG', since we use variables which
 591      are defined only if `YYDEBUG' is set.  */
 592   if (yydebug)
 593     {
 594       int i;
 595
 596       fprintf (stderr, "Reducing via rule %d (line %d), ",
 597                yyn, yyrline[yyn]);
 598
 599       /* Print the symbols being reduced, and their result.  */
 600       for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
 601         fprintf (stderr, "%s ", yytname[yyrhs[i]]);
 602       fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
 603     }
 604 #endif
 605 $ /* The action file replaces this line marked with this dollarsign. */
 606 #line
 607 \f
 608   yyvsp -= yylen;
 609   yyssp -= yylen;
 610 #ifdef YYLSP_NEEDED
 611   yylsp -= yylen;
 612 #endif
 613
 614 #if YYDEBUG
 615   if (yydebug)
 616     {
 617       short *ssp1 = yyss - 1;
 618       fprintf (stderr, "state stack now");
 619       while (ssp1 != yyssp)
 620         fprintf (stderr, " %d", *++ssp1);
 621       fprintf (stderr, "\n");
 622     }
 623 #endif
 624
 625   *++yyvsp = yyval;
 626 #ifdef YYLSP_NEEDED
 627   *++yylsp = yyloc;
 628 #endif
 629
 630   /* Now `shift' the result of the reduction.  Determine what state
 631      that goes to, based on the state we popped back to and the rule
 632      number reduced by.  */
 633
 634   yyn = yyr1[yyn];
 635
 636   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
 637   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
 638     yystate = yytable[yystate];
 639   else
 640     yystate = yydefgoto[yyn - YYNTBASE];
 641
 642   goto yynewstate;
 643
 644
 645 /*------------------------------------.
 646 | yyerrlab -- here on detecting error |
 647 `------------------------------------*/
 648 yyerrlab:
 649   /* If not already recovering from an error, report this error.  */
 650   if (!yyerrstatus)
 651     {
 652       ++yynerrs;
 653
 654 #ifdef YYERROR_VERBOSE
 655       yyn = yypact[yystate];
 656
 657       if (yyn > YYFLAG && yyn < YYLAST)
 658         {
 659           int size = 0;
 660           char *msg;
 661           int x, count;
 662
 663           count = 0;
 664           /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
 665           for (x = (yyn < 0 ? -yyn : 0);
 666                x < (sizeof (yytname) / sizeof (char *)); x++)
 667             if (yycheck[x + yyn] == x)
 668               size += strlen (yytname[x]) + 15, count++;
 669           size += strlen ("parse error, unexpected `") + 1;
 670           size += strlen (yytname[YYTRANSLATE (yychar)]);
 671           msg = (char *) malloc (size);
 672           if (msg != 0)
 673             {
 674               strcpy (msg, "parse error, unexpected `");
 675               strcat (msg, yytname[YYTRANSLATE (yychar)]);
 676               strcat (msg, "'");
 677
 678               if (count < 5)
 679                 {
 680                   count = 0;
 681                   for (x = (yyn < 0 ? -yyn : 0);
 682                        x < (sizeof (yytname) / sizeof (char *)); x++)
 683                     if (yycheck[x + yyn] == x)
 684                       {
 685                         strcat (msg, count == 0 ? ", expecting `" : " or `");
 686                         strcat (msg, yytname[x]);
 687                         strcat (msg, "'");
 688                         count++;
 689                       }
 690                 }
 691               yyerror (msg);
 692               free (msg);
 693             }
 694           else
 695             yyerror ("parse error; also virtual memory exceeded");
 696         }
 697       else
 698 #endif /* YYERROR_VERBOSE */
 699         yyerror ("parse error");
 700     }
 701   goto yyerrlab1;
 702
 703
 704 /*--------------------------------------------------.
 705 | yyerrlab1 -- error raised explicitly by an action |
 706 `--------------------------------------------------*/
 707 yyerrlab1:
 708   if (yyerrstatus == 3)
 709     {
 710       /* If just tried and failed to reuse lookahead token after an
 711          error, discard it.  */
 712
 713       /* return failure if at end of input */
 714       if (yychar == YYEOF)
 715         YYABORT;
 716       YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
 717                   yychar, yytname[yychar1]));
 718       yychar = YYEMPTY;
 719     }
 720
 721   /* Else will try to reuse lookahead token after shifting the error
 722      token.  */
 723
 724   yyerrstatus = 3;              /* Each real token shifted decrements this */
 725
 726   goto yyerrhandle;
 727
 728
 729 /*-------------------------------------------------------------------.
 730 | yyerrdefault -- current state does not do anything special for the |
 731 | error token.                                                       |
 732 `-------------------------------------------------------------------*/
 733 yyerrdefault:
 734 #if 0
 735   /* This is wrong; only states that explicitly want error tokens
 736      should shift them.  */
 737
 738   /* If its default is to accept any token, ok.  Otherwise pop it.  */
 739   yyn = yydefact[yystate];
 740   if (yyn)
 741     goto yydefault;
 742 #endif
 743
 744
 745 /*---------------------------------------------------------------.
 746 | yyerrpop -- pop the current state because it cannot handle the |
 747 | error token                                                    |
 748 `---------------------------------------------------------------*/
 749 yyerrpop:
 750   if (yyssp == yyss)
 751     YYABORT;
 752   yyvsp--;
 753   yystate = *--yyssp;
 754 #ifdef YYLSP_NEEDED
 755   yylsp--;
 756 #endif
 757
 758 #if YYDEBUG
 759   if (yydebug)
 760     {
 761       short *ssp1 = yyss - 1;
 762       fprintf (stderr, "Error: state stack now");
 763       while (ssp1 != yyssp)
 764         fprintf (stderr, " %d", *++ssp1);
 765       fprintf (stderr, "\n");
 766     }
 767 #endif
 768
 769 /*--------------.
 770 | yyerrhandle.  |
 771 `--------------*/
 772 yyerrhandle:
 773   yyn = yypact[yystate];
 774   if (yyn == YYFLAG)
 775     goto yyerrdefault;
 776
 777   yyn += YYTERROR;
 778   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
 779     goto yyerrdefault;
 780
 781   yyn = yytable[yyn];
 782   if (yyn < 0)
 783     {
 784       if (yyn == YYFLAG)
 785         goto yyerrpop;
 786       yyn = -yyn;
 787       goto yyreduce;
 788     }
 789   else if (yyn == 0)
 790     goto yyerrpop;
 791
 792   if (yyn == YYFINAL)
 793     YYACCEPT;
 794
 795   YYDPRINTF ((stderr, "Shifting error token, "));
 796
 797   *++yyvsp = yylval;
 798 #ifdef YYLSP_NEEDED
 799   *++yylsp = yylloc;
 800 #endif
 801
 802   yystate = yyn;
 803   goto yynewstate;
 804
 805
 806 /*-------------------------------------.
 807 | yyacceptlab -- YYACCEPT comes here.  |
 808 `-------------------------------------*/
 809 yyacceptlab:
 810   if (yyfree_stacks)
 811     {
 812       free (yyss);
 813       free (yyvs);
 814 #ifdef YYLSP_NEEDED
 815       free (yyls);
 816 #endif
 817     }
 818   return 0;
 819
 820
 821 /*-----------------------------------.
 822 | yyabortlab -- YYABORT comes here.  |
 823 `-----------------------------------*/
 824 yyabortlab:
 825   if (yyfree_stacks)
 826     {
 827       free (yyss);
 828       free (yyvs);
 829 #ifdef YYLSP_NEEDED
 830       free (yyls);
 831 #endif
 832     }
 833   return 1;
 834 }