ghc/utils/ugen/syntax.tab.c

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