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