1 mike 1.2 /* -*-C-*- Note some compilers choke on comments on `#line' lines. */
2 #line 3 "bison.simple"
3 /* This file comes from bison-@bison_version@. */
4
5 /* Skeleton output parser for bison,
6 Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
11 any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
22 mike 1.2
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 mike 1.2 #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 mike 1.2 #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 mike 1.2 #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 mike 1.2 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 mike 1.2 #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 mike 1.2
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 mike 1.2 #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 mike 1.2 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 mike 1.2 }
212
213 #endif
214 #endif
215
216 #line 217 "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 mike 1.2 #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 mike 1.2 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 mike 1.2 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 mike 1.2
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 mike 1.2
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 mike 1.2 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 mike 1.2 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 mike 1.2 __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 mike 1.2 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 mike 1.2 /* 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 mike 1.2 #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 mike 1.2 }
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 mike 1.2 }
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 mike 1.2 #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 mike 1.2 #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 "bison.simple"
543
544 yyvsp -= yylen;
545 yyssp -= yylen;
546 #ifdef YYLSP_NEEDED
547 mike 1.2 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 mike 1.2 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 mike 1.2 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 mike 1.2
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 mike 1.2 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 mike 1.2
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 mike 1.2
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 mike 1.2 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 mike 1.2 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 mike 1.2 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 mike 1.2 free (yyls);
758 #endif
759 }
760 return 1;
761 }
|
Return to
bison.simple
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / WQL