Annotation of win32/tools/usr/share/bison.simple, revision 1.2
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;
1.2 ! paf 278: YYSTYPE yylval=0; /*paf:calm down, vc7 warning level 4*/
1.1 parser 279: int yynerrs;
280: #ifdef YYLSP_NEEDED
281: YYLTYPE yylloc;
282: #endif
283: #endif
284:
1.2 ! paf 285: YYSTYPE yyval=0; /*paf:calm down, vc7 warning level 4*/ /* the variable used to return */
1.1 parser 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