src/bison.simple

   1 /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
   2 #line 3 "bison.simple"
   3
   4 /* Skeleton output parser for bison,
   5    Copyright (C) 1984, 1989, 1990 Bob Corbett and Richard Stallman
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 1, or (at your option)
  10    any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21
  22 #ifndef alloca
  23 #ifdef __GNUC__
  24 #define alloca __builtin_alloca
  25 #else /* not GNU C.  */
  26 #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi)
  27 #include <alloca.h>
  28 #else /* not sparc */
  29 #if defined (MSDOS) && !defined (__TURBOC__)
  30 #include <malloc.h>
  31 #else /* not MSDOS, or __TURBOC__ */
  32 #if defined(_AIX)
  33 #include <malloc.h>
  34  #pragma alloca
  35 #else /* not MSDOS, __TURBOC__, or _AIX */
  36 #ifdef __hpux
  37 #ifdef __cplusplus
  38 extern "C" {
  39 void *alloca (unsigned int);
  40 };
  41 #else /* not __cplusplus */
  42 void *alloca ();
  43 #endif /* not __cplusplus */
  44 #endif /* __hpux */
  45 #endif /* not _AIX */
  46 #endif /* not MSDOS, or __TURBOC__ */
  47 #endif /* not sparc.  */
  48 #endif /* not GNU C.  */
  49 #endif /* alloca not defined.  */
  50
  51 /* This is the parser code that is written into each bison parser
  52   when the %semantic_parser declaration is not specified in the grammar.
  53   It was written by Richard Stallman by simplifying the hairy parser
  54   used when %semantic_parser is specified.  */
  55
  56 /* Note: there must be only one dollar sign in this file.
  57    It is replaced by the list of actions, each action
  58    as one case of the switch.  */
  59
  60 #define yyerrok         (yyerrstatus = 0)
  61 #define yyclearin       (yychar = YYEMPTY)
  62 #define YYEMPTY         -2
  63 #define YYEOF           0
  64 #define YYACCEPT        return(0)
  65 #define YYABORT         return(1)
  66 #define YYERROR         goto yyerrlab1
  67 /* Like YYERROR except do call yyerror.
  68    This remains here temporarily to ease the
  69    transition to the new meaning of YYERROR, for GCC.
  70    Once GCC version 2 has supplanted version 1, this can go.  */
  71 #define YYFAIL          goto yyerrlab
  72 #define YYRECOVERING()  (!!yyerrstatus)
  73 #define YYBACKUP(token, value) \
  74 do                                                              \
  75   if (yychar == YYEMPTY && yylen == 1)                          \
  76     { yychar = (token), yylval = (value);                       \
  77       yychar1 = YYTRANSLATE (yychar);                           \
  78       YYPOPSTACK;                                               \
  79       goto yybackup;                                            \
  80     }                                                           \
  81   else                                                          \
  82     { yyerror ("syntax error: cannot back up"); YYERROR; }      \
  83 while (0)
  84
  85 #define YYTERROR        1
  86 #define YYERRCODE       256
  87
  88 #ifndef YYPURE
  89 #define YYLEX           yylex()
  90 #endif
  91
  92 #ifdef YYPURE
  93 #ifdef YYLSP_NEEDED
  94 #define YYLEX           yylex(&yylval, &yylloc)
  95 #else
  96 #define YYLEX           yylex(&yylval)
  97 #endif
  98 #endif
  99
 100 /* If nonreentrant, generate the variables here */
 101
 102 #ifndef YYPURE
 103
 104 int     yychar;                 /*  the lookahead symbol                */
 105 YYSTYPE yylval;                 /*  the semantic value of the           */
 106                                 /*  lookahead symbol                    */
 107
 108 #ifdef YYLSP_NEEDED
 109 YYLTYPE yylloc;                 /*  location data for the lookahead     */
 110                                 /*  symbol                              */
 111 #endif
 112
 113 int yynerrs;                    /*  number of parse errors so far       */
 114 #endif  /* not YYPURE */
 115
 116 #if YYDEBUG != 0
 117 int yydebug;                    /*  nonzero means print parse trace     */
 118 /* Since this is uninitialized, it does not stop multiple parsers
 119    from coexisting.  */
 120 #endif
 121
 122 /*  YYINITDEPTH indicates the initial size of the parser's stacks       */
 123
 124 #ifndef YYINITDEPTH
 125 #define YYINITDEPTH 200
 126 #endif
 127
 128 /*  YYMAXDEPTH is the maximum size the stacks can grow to
 129     (effective only if the built-in stack extension method is used).  */
 130
 131 #if YYMAXDEPTH == 0
 132 #undef YYMAXDEPTH
 133 #endif
 134
 135 #ifndef YYMAXDEPTH
 136 #define YYMAXDEPTH 10000
 137 #endif
 138
 139 /* Prevent warning if -Wstrict-prototypes.  */
 140 #ifdef __GNUC__
 141 int yyparse (void);
 142 #endif
 143 \f
 144 #if __GNUC__ > 1                /* GNU C and GNU C++ define this.  */
 145 #define __yy_bcopy(FROM,TO,COUNT)       __builtin_memcpy(TO,FROM,COUNT)
 146 #else                           /* not GNU C or C++ */
 147 #ifndef __cplusplus
 148
 149 /* This is the most reliable way to avoid incompatibilities
 150    in available built-in functions on various systems.  */
 151 static void
 152 __yy_bcopy (from, to, count)
 153      char *from;
 154      char *to;
 155      int count;
 156 {
 157   register char *f = from;
 158   register char *t = to;
 159   register int i = count;
 160
 161   while (i-- > 0)
 162     *t++ = *f++;
 163 }
 164
 165 #else /* __cplusplus */
 166
 167 /* This is the most reliable way to avoid incompatibilities
 168    in available built-in functions on various systems.  */
 169 static void
 170 __yy_bcopy (char *from, char *to, int count)
 171 {
 172   register char *f = from;
 173   register char *t = to;
 174   register int i = count;
 175
 176   while (i-- > 0)
 177     *t++ = *f++;
 178 }
 179
 180 #endif
 181 #endif
 182 \f
 183 #line 184 "bison.simple"
 184 int
 185 yyparse()
 186 {
 187   register int yystate;
 188   register int yyn;
 189   register short *yyssp;
 190   register YYSTYPE *yyvsp;
 191   int yyerrstatus;      /*  number of tokens to shift before error messages enabled */
 192   int yychar1;          /*  lookahead token as an internal (translated) token number */
 193
 194   short yyssa[YYINITDEPTH];     /*  the state stack                     */
 195   YYSTYPE yyvsa[YYINITDEPTH];   /*  the semantic value stack            */
 196
 197   short *yyss = yyssa;          /*  refer to the stacks thru separate pointers */
 198   YYSTYPE *yyvs = yyvsa;        /*  to allow yyoverflow to reallocate them elsewhere */
 199
 200 #ifdef YYLSP_NEEDED
 201   YYLTYPE yylsa[YYINITDEPTH];   /*  the location stack                  */
 202   YYLTYPE *yyls = yylsa;
 203   YYLTYPE *yylsp;
 204
 205 #define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
 206 #else
 207 #define YYPOPSTACK   (yyvsp--, yyssp--)
 208 #endif
 209
 210   int yystacksize = YYINITDEPTH;
 211
 212 #ifdef YYPURE
 213   int yychar;
 214   YYSTYPE yylval;
 215   int yynerrs;
 216 #ifdef YYLSP_NEEDED
 217   YYLTYPE yylloc;
 218 #endif
 219 #endif
 220
 221   YYSTYPE yyval;                /*  the variable used to return         */
 222                                 /*  semantic values from the action     */
 223                                 /*  routines                            */
 224
 225   int yylen;
 226
 227 #if YYDEBUG != 0
 228   if (yydebug)
 229     fprintf(stderr, "Starting parse\n");
 230 #endif
 231
 232   yystate = 0;
 233   yyerrstatus = 0;
 234   yynerrs = 0;
 235   yychar = YYEMPTY;             /* Cause a token to be read.  */
 236
 237   /* Initialize stack pointers.
 238      Waste one element of value and location stack
 239      so that they stay on the same level as the state stack.
 240      The wasted elements are never initialized.  */
 241
 242   yyssp = yyss - 1;
 243   yyvsp = yyvs;
 244 #ifdef YYLSP_NEEDED
 245   yylsp = yyls;
 246 #endif
 247
 248 /* Push a new state, which is found in  yystate  .  */
 249 /* In all cases, when you get here, the value and location stacks
 250    have just been pushed. so pushing a state here evens the stacks.  */
 251 yynewstate:
 252
 253   *++yyssp = yystate;
 254
 255   if (yyssp >= yyss + yystacksize - 1)
 256     {
 257       /* Give user a chance to reallocate the stack */
 258       /* Use copies of these so that the &'s don't force the real ones into memory. */
 259       YYSTYPE *yyvs1 = yyvs;
 260       short *yyss1 = yyss;
 261 #ifdef YYLSP_NEEDED
 262       YYLTYPE *yyls1 = yyls;
 263 #endif
 264
 265       /* Get the current used size of the three stacks, in elements.  */
 266       int size = yyssp - yyss + 1;
 267
 268 #ifdef yyoverflow
 269       /* Each stack pointer address is followed by the size of
 270          the data in use in that stack, in bytes.  */
 271       yyoverflow("parser stack overflow",
 272                  &yyss1, size * sizeof (*yyssp),
 273                  &yyvs1, size * sizeof (*yyvsp),
 274 #ifdef YYLSP_NEEDED
 275                  &yyls1, size * sizeof (*yylsp),
 276 #endif
 277                  &yystacksize);
 278
 279       yyss = yyss1; yyvs = yyvs1;
 280 #ifdef YYLSP_NEEDED
 281       yyls = yyls1;
 282 #endif
 283 #else /* no yyoverflow */
 284       /* Extend the stack our own way.  */
 285       if (yystacksize >= YYMAXDEPTH)
 286         {
 287           yyerror("parser stack overflow");
 288           return 2;
 289         }
 290       yystacksize *= 2;
 291       if (yystacksize > YYMAXDEPTH)
 292         yystacksize = YYMAXDEPTH;
 293       yyss = (short *) alloca (yystacksize * sizeof (*yyssp));
 294       __yy_bcopy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp));
 295       yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp));
 296       __yy_bcopy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp));
 297 #ifdef YYLSP_NEEDED
 298       yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp));
 299       __yy_bcopy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp));
 300 #endif
 301 #endif /* no yyoverflow */
 302
 303       yyssp = yyss + size - 1;
 304       yyvsp = yyvs + size - 1;
 305 #ifdef YYLSP_NEEDED
 306       yylsp = yyls + size - 1;
 307 #endif
 308
 309 #if YYDEBUG != 0
 310       if (yydebug)
 311         fprintf(stderr, "Stack size increased to %d\n", yystacksize);
 312 #endif
 313
 314       if (yyssp >= yyss + yystacksize - 1)
 315         YYABORT;
 316     }
 317
 318 #if YYDEBUG != 0
 319   if (yydebug)
 320     fprintf(stderr, "Entering state %d\n", yystate);
 321 #endif
 322
 323   goto yybackup;
 324  yybackup:
 325
 326 /* Do appropriate processing given the current state.  */
 327 /* Read a lookahead token if we need one and don't already have one.  */
 328 /* yyresume: */
 329
 330   /* First try to decide what to do without reference to lookahead token.  */
 331
 332   yyn = yypact[yystate];
 333   if (yyn == YYFLAG)
 334     goto yydefault;
 335
 336   /* Not known => get a lookahead token if don't already have one.  */
 337
 338   /* yychar is either YYEMPTY or YYEOF
 339      or a valid token in external form.  */
 340
 341   if (yychar == YYEMPTY)
 342     {
 343 #if YYDEBUG != 0
 344       if (yydebug)
 345         fprintf(stderr, "Reading a token: ");
 346 #endif
 347       yychar = YYLEX;
 348     }
 349
 350   /* Convert token to internal form (in yychar1) for indexing tables with */
 351
 352   if (yychar <= 0)              /* This means end of input. */
 353     {
 354       yychar1 = 0;
 355       yychar = YYEOF;           /* Don't call YYLEX any more */
 356
 357 #if YYDEBUG != 0
 358       if (yydebug)
 359         fprintf(stderr, "Now at end of input.\n");
 360 #endif
 361     }
 362   else
 363     {
 364       yychar1 = YYTRANSLATE(yychar);
 365
 366 #if YYDEBUG != 0
 367       if (yydebug)
 368         {
 369           fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
 370           /* Give the individual parser a way to print the precise meaning
 371              of a token, for further debugging info.  */
 372 #ifdef YYPRINT
 373           YYPRINT (stderr, yychar, yylval);
 374 #endif
 375           fprintf (stderr, ")\n");
 376         }
 377 #endif
 378     }
 379
 380   yyn += yychar1;
 381   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
 382     goto yydefault;
 383
 384   yyn = yytable[yyn];
 385
 386   /* yyn is what to do for this token type in this state.
 387      Negative => reduce, -yyn is rule number.
 388      Positive => shift, yyn is new state.
 389        New state is final state => don't bother to shift,
 390        just return success.
 391      0, or most negative number => error.  */
 392
 393   if (yyn < 0)
 394     {
 395       if (yyn == YYFLAG)
 396         goto yyerrlab;
 397       yyn = -yyn;
 398       goto yyreduce;
 399     }
 400   else if (yyn == 0)
 401     goto yyerrlab;
 402
 403   if (yyn == YYFINAL)
 404     YYACCEPT;
 405
 406   /* Shift the lookahead token.  */
 407
 408 #if YYDEBUG != 0
 409   if (yydebug)
 410     fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
 411 #endif
 412
 413   /* Discard the token being shifted unless it is eof.  */
 414   if (yychar != YYEOF)
 415     yychar = YYEMPTY;
 416
 417   *++yyvsp = yylval;
 418 #ifdef YYLSP_NEEDED
 419   *++yylsp = yylloc;
 420 #endif
 421
 422   /* count tokens shifted since error; after three, turn off error status.  */
 423   if (yyerrstatus) yyerrstatus--;
 424
 425   yystate = yyn;
 426   goto yynewstate;
 427
 428 /* Do the default action for the current state.  */
 429 yydefault:
 430
 431   yyn = yydefact[yystate];
 432   if (yyn == 0)
 433     goto yyerrlab;
 434
 435 /* Do a reduction.  yyn is the number of a rule to reduce with.  */
 436 yyreduce:
 437   yylen = yyr2[yyn];
 438   yyval = yyvsp[1-yylen]; /* implement default value of the action */
 439
 440 #if YYDEBUG != 0
 441   if (yydebug)
 442     {
 443       int i;
 444
 445       fprintf (stderr, "Reducing via rule %d (line %d), ",
 446                yyn, yyrline[yyn]);
 447
 448       /* Print the symbols being reduced, and their result.  */
 449       for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
 450         fprintf (stderr, "%s ", yytname[yyrhs[i]]);
 451       fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
 452     }
 453 #endif
 454
 455 $   /* the action file gets copied in in place of this dollarsign */
 456 #line 457 "bison.simple"
 457 \f
 458   yyvsp -= yylen;
 459   yyssp -= yylen;
 460 #ifdef YYLSP_NEEDED
 461   yylsp -= yylen;
 462 #endif
 463
 464 #if YYDEBUG != 0
 465   if (yydebug)
 466     {
 467       short *ssp1 = yyss - 1;
 468       fprintf (stderr, "state stack now");
 469       while (ssp1 != yyssp)
 470         fprintf (stderr, " %d", *++ssp1);
 471       fprintf (stderr, "\n");
 472     }
 473 #endif
 474
 475   *++yyvsp = yyval;
 476
 477 #ifdef YYLSP_NEEDED
 478   yylsp++;
 479   if (yylen == 0)
 480     {
 481       yylsp->first_line = yylloc.first_line;
 482       yylsp->first_column = yylloc.first_column;
 483       yylsp->last_line = (yylsp-1)->last_line;
 484       yylsp->last_column = (yylsp-1)->last_column;
 485       yylsp->text = 0;
 486     }
 487   else
 488     {
 489       yylsp->last_line = (yylsp+yylen-1)->last_line;
 490       yylsp->last_column = (yylsp+yylen-1)->last_column;
 491     }
 492 #endif
 493
 494   /* Now "shift" the result of the reduction.
 495      Determine what state that goes to,
 496      based on the state we popped back to
 497      and the rule number reduced by.  */
 498
 499   yyn = yyr1[yyn];
 500
 501   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
 502   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
 503     yystate = yytable[yystate];
 504   else
 505     yystate = yydefgoto[yyn - YYNTBASE];
 506
 507   goto yynewstate;
 508
 509 yyerrlab:   /* here on detecting error */
 510
 511   if (! yyerrstatus)
 512     /* If not already recovering from an error, report this error.  */
 513     {
 514       ++yynerrs;
 515
 516 #ifdef YYERROR_VERBOSE
 517       yyn = yypact[yystate];
 518
 519       if (yyn > YYFLAG && yyn < YYLAST)
 520         {
 521           int size = 0;
 522           char *msg;
 523           int x, count;
 524
 525           count = 0;
 526           /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
 527           for (x = (yyn < 0 ? -yyn : 0);
 528                x < (sizeof(yytname) / sizeof(char *)); x++)
 529             if (yycheck[x + yyn] == x)
 530               size += strlen(yytname[x]) + 15, count++;
 531           msg = (char *) malloc(size + 15);
 532           if (msg != 0)
 533             {
 534               strcpy(msg, "parse error");
 535
 536               if (count < 5)
 537                 {
 538                   count = 0;
 539                   for (x = (yyn < 0 ? -yyn : 0);
 540                        x < (sizeof(yytname) / sizeof(char *)); x++)
 541                     if (yycheck[x + yyn] == x)
 542                       {
 543                         strcat(msg, count == 0 ? ", expecting `" : " or `");
 544                         strcat(msg, yytname[x]);
 545                         strcat(msg, "'");
 546                         count++;
 547                       }
 548                 }
 549               yyerror(msg);
 550               free(msg);
 551             }
 552           else
 553             yyerror ("parse error; also virtual memory exceeded");
 554         }
 555       else
 556 #endif /* YYERROR_VERBOSE */
 557         yyerror("parse error");
 558     }
 559
 560   goto yyerrlab1;
 561 yyerrlab1:   /* here on error raised explicitly by an action */
 562
 563   if (yyerrstatus == 3)
 564     {
 565       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
 566
 567       /* return failure if at end of input */
 568       if (yychar == YYEOF)
 569         YYABORT;
 570
 571 #if YYDEBUG != 0
 572       if (yydebug)
 573         fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
 574 #endif
 575
 576       yychar = YYEMPTY;
 577     }
 578
 579   /* Else will try to reuse lookahead token
 580      after shifting the error token.  */
 581
 582   yyerrstatus = 3;              /* Each real token shifted decrements this */
 583
 584   goto yyerrhandle;
 585
 586 yyerrdefault:  /* current state does not do anything special for the error token. */
 587
 588 #if 0
 589   /* This is wrong; only states that explicitly want error tokens
 590      should shift them.  */
 591   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
 592   if (yyn) goto yydefault;
 593 #endif
 594
 595 yyerrpop:   /* pop the current state because it cannot handle the error token */
 596
 597   if (yyssp == yyss) YYABORT;
 598   yyvsp--;
 599   yystate = *--yyssp;
 600 #ifdef YYLSP_NEEDED
 601   yylsp--;
 602 #endif
 603
 604 #if YYDEBUG != 0
 605   if (yydebug)
 606     {
 607       short *ssp1 = yyss - 1;
 608       fprintf (stderr, "Error: state stack now");
 609       while (ssp1 != yyssp)
 610         fprintf (stderr, " %d", *++ssp1);
 611       fprintf (stderr, "\n");
 612     }
 613 #endif
 614
 615 yyerrhandle:
 616
 617   yyn = yypact[yystate];
 618   if (yyn == YYFLAG)
 619     goto yyerrdefault;
 620
 621   yyn += YYTERROR;
 622   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
 623     goto yyerrdefault;
 624
 625   yyn = yytable[yyn];
 626   if (yyn < 0)
 627     {
 628       if (yyn == YYFLAG)
 629         goto yyerrpop;
 630       yyn = -yyn;
 631       goto yyreduce;
 632     }
 633   else if (yyn == 0)
 634     goto yyerrpop;
 635
 636   if (yyn == YYFINAL)
 637     YYACCEPT;
 638
 639 #if YYDEBUG != 0
 640   if (yydebug)
 641     fprintf(stderr, "Shifting error token, ");
 642 #endif
 643
 644   *++yyvsp = yylval;
 645 #ifdef YYLSP_NEEDED
 646   *++yylsp = yylloc;
 647 #endif
 648
 649   yystate = yyn;
 650   goto yynewstate;
 651 }