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