gbarr is maintaining IO.
[p5sagit/p5-mst-13.2.git] / perly.c
CommitLineData
0de566d7 1/* perly.c
2 *
3 * Copyright (c) 2004 Larry Wall
4 *
5 * You may distribute under the terms of either the GNU General Public
6 * License or the Artistic License, as specified in the README file.
7 *
8 * Note that this file was originally generated as an output from
9 * GNU bison version 1.875, but now the code is statically maintained
10 * and edited; the bits that are dependent on perly.y are now #included
11 * from the files perly.tab and perly.act.
12 *
13 * Here is an important copyright statement from the original, generated
14 * file:
15 *
16 * As a special exception, when this file is copied by Bison into a
17 * Bison output file, you may use that output file without
18 * restriction. This special exception was added by the Free
19 * Software Foundation in version 1.24 of Bison.
20 */
21
22
23/* allow stack size to grow effectively without limit */
24#define YYMAXDEPTH 10000000
25
79072805 26#include "EXTERN.h"
864dbfa3 27#define PERL_IN_PERLY_C
79072805 28#include "perl.h"
09bef843 29
0de566d7 30typedef signed char yysigned_char;
31
32#ifdef DEBUGGING
33# define YYDEBUG 1
93a17b20 34#else
0de566d7 35# define YYDEBUG 0
93a17b20 36#endif
09bef843 37
0de566d7 38/* contains all the parser state tables; auto-generated from perly.y */
39#include "perly.tab"
40
41# define YYSIZE_T size_t
42
43#define yyerrok (yyerrstatus = 0)
44#define yyclearin (yychar = YYEMPTY)
45#define YYEMPTY (-2)
46#define YYEOF 0
47
48#define YYACCEPT goto yyacceptlab
49#define YYABORT goto yyabortlab
50#define YYERROR goto yyerrlab1
51
52
53/* Like YYERROR except do call yyerror. This remains here temporarily
54 to ease the transition to the new meaning of YYERROR, for GCC.
55 Once GCC version 2 has supplanted version 1, this can go. */
56
57#define YYFAIL goto yyerrlab
58
59#define YYRECOVERING() (!!yyerrstatus)
60
61#define YYBACKUP(Token, Value) \
62do \
63 if (yychar == YYEMPTY && yylen == 1) { \
64 yychar = (Token); \
65 yylval = (Value); \
66 yytoken = YYTRANSLATE (yychar); \
67 YYPOPSTACK; \
68 goto yybackup; \
69 } \
70 else { \
71 yyerror ("syntax error: cannot back up"); \
72 YYERROR; \
73 } \
74while (0)
75
76#define YYTERROR 1
77#define YYERRCODE 256
78
0de566d7 79/* Enable debugging if requested. */
9388183f 80#ifdef DEBUGGING
0de566d7 81
82# define yydebug (DEBUG_p_TEST)
83
84# define YYFPRINTF PerlIO_printf
85
86# define YYDPRINTF(Args) \
87do { \
88 if (yydebug) \
89 YYFPRINTF Args; \
90} while (0)
91
92# define YYDSYMPRINT(Args) \
93do { \
94 if (yydebug) \
95 yysymprint Args; \
96} while (0)
97
9388183f 98# define YYDSYMPRINTF(Title, Token, Value) \
0de566d7 99do { \
100 if (yydebug) { \
101 YYFPRINTF (Perl_debug_log, "%s ", Title); \
9388183f 102 yysymprint (aTHX_ Perl_debug_log, Token, Value); \
0de566d7 103 YYFPRINTF (Perl_debug_log, "\n"); \
104 } \
105} while (0)
106
107/*--------------------------------.
108| Print this symbol on YYOUTPUT. |
109`--------------------------------*/
110
111static void
df35152e 112yysymprint (pTHX_ PerlIO *yyoutput, int yytype, const YYSTYPE *yyvaluep)
0de566d7 113{
0de566d7 114 if (yytype < YYNTOKENS) {
115 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
116# ifdef YYPRINT
117 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
9388183f 118# else
e4584336 119 YYFPRINTF (yyoutput, "0x%"UVxf, (UV)yyvaluep->ival);
0de566d7 120# endif
121 }
122 else
123 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
124
0de566d7 125 YYFPRINTF (yyoutput, ")");
126}
127
128
9388183f 129/* yy_stack_print()
130 * print the top 8 items on the parse stack. The args have the same
131 * meanings as the local vars in yyparse() of the same name */
0de566d7 132
133static void
df35152e 134yy_stack_print (pTHX_ const short *yyss, const short *yyssp, const YYSTYPE *yyvs, const char**yyns)
0de566d7 135{
9388183f 136 int i;
137 int start = 1;
138 int count = (int)(yyssp - yyss);
139
140 if (count > 8) {
141 start = count - 8 + 1;
142 count = 8;
143 }
144
145 PerlIO_printf(Perl_debug_log, "\nindex:");
146 for (i=0; i < count; i++)
147 PerlIO_printf(Perl_debug_log, " %8d", start+i);
148 PerlIO_printf(Perl_debug_log, "\nstate:");
149 for (i=0, yyss += start; i < count; i++, yyss++)
150 PerlIO_printf(Perl_debug_log, " %8d", *yyss);
151 PerlIO_printf(Perl_debug_log, "\ntoken:");
152 for (i=0, yyns += start; i < count; i++, yyns++)
153 PerlIO_printf(Perl_debug_log, " %8.8s", *yyns);
154 PerlIO_printf(Perl_debug_log, "\nvalue:");
155 for (i=0, yyvs += start; i < count; i++, yyvs++)
e4584336 156 PerlIO_printf(Perl_debug_log, " %8"UVxf, (UV)yyvs->ival);
9388183f 157 PerlIO_printf(Perl_debug_log, "\n\n");
0de566d7 158}
159
9388183f 160# define YY_STACK_PRINT(yyss, yyssp, yyvs, yyns) \
0de566d7 161do { \
9388183f 162 if (yydebug && DEBUG_v_TEST) \
163 yy_stack_print (aTHX_ (yyss), (yyssp), (yyvs), (yyns)); \
0de566d7 164} while (0)
165
09bef843 166
0de566d7 167/*------------------------------------------------.
168| Report that the YYRULE is going to be reduced. |
169`------------------------------------------------*/
170
171static void
172yy_reduce_print (pTHX_ int yyrule)
173{
174 int yyi;
df35152e 175 const unsigned int yylineno = yyrline[yyrule];
0de566d7 176 YYFPRINTF (Perl_debug_log, "Reducing stack by rule %d (line %u), ",
177 yyrule - 1, yylineno);
178 /* Print the symbols being reduced, and their result. */
179 for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
180 YYFPRINTF (Perl_debug_log, "%s ", yytname [yyrhs[yyi]]);
181 YYFPRINTF (Perl_debug_log, "-> %s\n", yytname [yyr1[yyrule]]);
182}
183
184# define YY_REDUCE_PRINT(Rule) \
185do { \
186 if (yydebug) \
187 yy_reduce_print (aTHX_ Rule); \
188} while (0)
189
190#else /* !DEBUGGING */
191# define YYDPRINTF(Args)
192# define YYDSYMPRINT(Args)
9388183f 193# define YYDSYMPRINTF(Title, Token, Value)
194# define YY_STACK_PRINT(yyss, yyssp, yyvs, yyns)
0de566d7 195# define YY_REDUCE_PRINT(Rule)
196#endif /* !DEBUGGING */
197
198
199/* YYINITDEPTH -- initial size of the parser's stacks. */
200#ifndef YYINITDEPTH
201# define YYINITDEPTH 200
09bef843 202#endif
09bef843 203
0de566d7 204
205#if YYERROR_VERBOSE
206# ifndef yystrlen
207# if defined (__GLIBC__) && defined (_STRING_H)
208# define yystrlen strlen
209# else
210/* Return the length of YYSTR. */
211static YYSIZE_T
212yystrlen (const char *yystr)
213{
214 register const char *yys = yystr;
215
216 while (*yys++ != '\0')
217 continue;
218
219 return yys - yystr - 1;
220}
221# endif
222# endif
223
224# ifndef yystpcpy
225# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
226# define yystpcpy stpcpy
227# else
228/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
229 YYDEST. */
230static char *
231yystpcpy (pTHX_ char *yydest, const char *yysrc)
232{
233 register char *yyd = yydest;
234 register const char *yys = yysrc;
235
236 while ((*yyd++ = *yys++) != '\0')
237 continue;
238
239 return yyd - 1;
240}
241# endif
242# endif
243
244#endif /* !YYERROR_VERBOSE */
245
0de566d7 246/*----------.
247| yyparse. |
248`----------*/
249
79072805 250int
0de566d7 251Perl_yyparse (pTHX)
79072805 252{
0de566d7 253 int yychar; /* The lookahead symbol. */
254 YYSTYPE yylval; /* The semantic value of the lookahead symbol. */
255 int yynerrs; /* Number of syntax errors so far. */
256 register int yystate;
257 register int yyn;
258 int yyresult;
259
260 /* Number of tokens to shift before error messages enabled. */
261 int yyerrstatus;
262 /* Lookahead token as an internal (translated) token number. */
263 int yytoken = 0;
264
265 /* two stacks and their tools:
a0288114 266 yyss: related to states,
267 yyvs: related to semantic values,
0de566d7 268
269 Refer to the stacks thru separate pointers, to allow yyoverflow
270 to reallocate them elsewhere. */
271
272 /* The state stack. */
273 short *yyss;
93a17b20 274 register short *yyssp;
0de566d7 275
276 /* The semantic value stack. */
277 YYSTYPE *yyvs;
93a17b20 278 register YYSTYPE *yyvsp;
a0d0e21e 279
0de566d7 280 /* for ease of re-allocation and automatic freeing, have two SVs whose
281 * SvPVX points to the stacks */
282 SV *yyss_sv, *yyvs_sv;
283
9388183f 284#ifdef DEBUGGING
285 /* maintain also a stack of token/rule names for debugging with -Dpv */
e1ec3a88 286 const char **yyns, **yynsp;
9388183f 287 SV *yyns_sv;
288# define YYPOPSTACK (yyvsp--, yyssp--, yynsp--)
289#else
290# define YYPOPSTACK (yyvsp--, yyssp--)
291#endif
292
0de566d7 293
294 YYSIZE_T yystacksize = YYINITDEPTH;
295
296 /* The variables used to return semantic value and location from the
297 action routines. */
298 YYSTYPE yyval;
299
300
301 /* When reducing, the number of symbols on the RHS of the reduced
302 rule. */
303 int yylen;
304
305 YYDPRINTF ((Perl_debug_log, "Starting parse\n"));
306
0de566d7 307 ENTER; /* force stack free before we return */
12fbd33b 308 SAVEVPTR(PL_yycharp);
309 SAVEVPTR(PL_yylvalp);
310 PL_yycharp = &yychar; /* so PL_yyerror() can access it */
311 PL_yylvalp = &yylval; /* so various functions in toke.c can access it */
312
9388183f 313 yyss_sv = NEWSV(73, YYINITDEPTH * sizeof(short));
314 yyvs_sv = NEWSV(73, YYINITDEPTH * sizeof(YYSTYPE));
0de566d7 315 SAVEFREESV(yyss_sv);
316 SAVEFREESV(yyvs_sv);
317 yyss = (short *) SvPVX(yyss_sv);
318 yyvs = (YYSTYPE *) SvPVX(yyvs_sv);
9388183f 319 /* note that elements zero of yyvs and yyns are not used */
320 yyssp = yyss;
321 yyvsp = yyvs;
322#ifdef DEBUGGING
323 yyns_sv = NEWSV(73, YYINITDEPTH * sizeof(char *));
324 SAVEFREESV(yyns_sv);
a28509cc 325 /* XXX This seems strange to cast char * to char ** */
94a11853 326 yyns = (const char **) SvPVX(yyns_sv);
9388183f 327 yynsp = yyns;
328#endif
79072805 329
0de566d7 330 yystate = 0;
331 yyerrstatus = 0;
93a17b20 332 yynerrs = 0;
0de566d7 333 yychar = YYEMPTY; /* Cause a token to be read. */
334
79072805 335
9388183f 336
337 YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate));
0de566d7 338
339 goto yysetstate;
340
341/*------------------------------------------------------------.
342| yynewstate -- Push a new state, which is found in yystate. |
343`------------------------------------------------------------*/
344 yynewstate:
345 /* In all cases, when you get here, the value and location stacks
346 have just been pushed. so pushing a state here evens the stacks.
347 */
348 yyssp++;
349
350 yysetstate:
351 *yyssp = yystate;
352
353 if (yyss + yystacksize - 1 <= yyssp) {
354 /* Get the current used size of the three stacks, in elements. */
df35152e 355 const YYSIZE_T yysize = yyssp - yyss + 1;
0de566d7 356
357 /* Extend the stack our own way. */
358 if (YYMAXDEPTH <= yystacksize)
359 goto yyoverflowlab;
360 yystacksize *= 2;
361 if (YYMAXDEPTH < yystacksize)
362 yystacksize = YYMAXDEPTH;
363
364 SvGROW(yyss_sv, yystacksize * sizeof(short));
365 SvGROW(yyvs_sv, yystacksize * sizeof(YYSTYPE));
366 yyss = (short *) SvPVX(yyss_sv);
367 yyvs = (YYSTYPE *) SvPVX(yyvs_sv);
9388183f 368#ifdef DEBUGGING
369 SvGROW(yyns_sv, yystacksize * sizeof(char *));
a28509cc 370 /* XXX This seems strange to cast char * to char ** */
94a11853 371 yyns = (const char **) SvPVX(yyns_sv);
9388183f 372 if (! yyns)
373 goto yyoverflowlab;
374 yynsp = yyns + yysize - 1;
375#endif
0de566d7 376 if (!yyss || ! yyvs)
377 goto yyoverflowlab;
378
379 yyssp = yyss + yysize - 1;
380 yyvsp = yyvs + yysize - 1;
381
382
383 YYDPRINTF ((Perl_debug_log, "Stack size increased to %lu\n",
384 (unsigned long int) yystacksize));
385
386 if (yyss + yystacksize - 1 <= yyssp)
387 YYABORT;
93a17b20 388 }
0de566d7 389
0de566d7 390 goto yybackup;
391
392 /*-----------.
393 | yybackup. |
394 `-----------*/
395 yybackup:
396
397/* Do appropriate processing given the current state. */
398/* Read a lookahead token if we need one and don't already have one. */
399/* yyresume: */
400
401 /* First try to decide what to do without reference to lookahead token. */
402
403 yyn = yypact[yystate];
404 if (yyn == YYPACT_NINF)
405 goto yydefault;
406
407 /* Not known => get a lookahead token if don't already have one. */
408
409 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
410 if (yychar == YYEMPTY) {
411 YYDPRINTF ((Perl_debug_log, "Reading a token: "));
12fbd33b 412 yychar = yylex();
413# ifdef EBCDIC
414 if (yychar >= 0 && yychar < 255) {
415 yychar = NATIVE_TO_ASCII(yychar);
416 }
417# endif
0de566d7 418 }
419
420 if (yychar <= YYEOF) {
421 yychar = yytoken = YYEOF;
422 YYDPRINTF ((Perl_debug_log, "Now at end of input.\n"));
93a17b20 423 }
0de566d7 424 else {
425 yytoken = YYTRANSLATE (yychar);
9388183f 426 YYDSYMPRINTF ("Next token is", yytoken, &yylval);
93a17b20 427 }
771df094 428
0de566d7 429 /* If the proper action on seeing token YYTOKEN is to reduce or to
430 detect an error, take that action. */
431 yyn += yytoken;
432 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
433 goto yydefault;
434 yyn = yytable[yyn];
435 if (yyn <= 0) {
436 if (yyn == 0 || yyn == YYTABLE_NINF)
437 goto yyerrlab;
438 yyn = -yyn;
439 goto yyreduce;
440 }
7b57b0ea 441
0de566d7 442 if (yyn == YYFINAL)
443 YYACCEPT;
771df094 444
0de566d7 445 /* Shift the lookahead token. */
446 YYDPRINTF ((Perl_debug_log, "Shifting token %s, ", yytname[yytoken]));
447
448 /* Discard the token being shifted unless it is eof. */
449 if (yychar != YYEOF)
450 yychar = YYEMPTY;
451
452 *++yyvsp = yylval;
9388183f 453#ifdef DEBUGGING
e1ec3a88 454 *++yynsp = (const char *)(yytname[yytoken]);
9388183f 455#endif
0de566d7 456
457
458 /* Count tokens shifted since error; after three, turn off error
459 status. */
460 if (yyerrstatus)
461 yyerrstatus--;
462
463 yystate = yyn;
9388183f 464 YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate));
465
0de566d7 466 goto yynewstate;
467
468
469 /*-----------------------------------------------------------.
470 | yydefault -- do the default action for the current state. |
471 `-----------------------------------------------------------*/
472 yydefault:
473 yyn = yydefact[yystate];
474 if (yyn == 0)
475 goto yyerrlab;
476 goto yyreduce;
477
478
479 /*-----------------------------.
480 | yyreduce -- Do a reduction. |
481 `-----------------------------*/
482 yyreduce:
483 /* yyn is the number of a rule to reduce with. */
484 yylen = yyr2[yyn];
485
486 /* If YYLEN is nonzero, implement the default value of the action:
a0288114 487 "$$ = $1".
0de566d7 488
489 Otherwise, the following line sets YYVAL to garbage.
490 This behavior is undocumented and Bison
491 users should not rely upon it. Assigning to YYVAL
492 unconditionally makes the parser a bit smaller, and it avoids a
493 GCC warning that YYVAL may be used uninitialized. */
494 yyval = yyvsp[1-yylen];
495
496
497 YY_REDUCE_PRINT (yyn);
498 switch (yyn) {
499
500/* contains all the rule actions; auto-generated from perly.y */
501
502#define dep() deprecate("\"do\" to call subroutines")
503#include "perly.act"
7b57b0ea 504
93a17b20 505 }
0de566d7 506
507 yyvsp -= yylen;
508 yyssp -= yylen;
9388183f 509#ifdef DEBUGGING
510 yynsp -= yylen;
511#endif
0de566d7 512
0de566d7 513
514 *++yyvsp = yyval;
9388183f 515#ifdef DEBUGGING
e1ec3a88 516 *++yynsp = (const char *)(yytname [yyr1[yyn]]);
9388183f 517#endif
0de566d7 518
a0288114 519 /* Now shift the result of the reduction. Determine what state
0de566d7 520 that goes to, based on the state we popped back to and the rule
521 number reduced by. */
522
523 yyn = yyr1[yyn];
524
525 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
526 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
527 yystate = yytable[yystate];
93a17b20 528 else
0de566d7 529 yystate = yydefgoto[yyn - YYNTOKENS];
530
9388183f 531 YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate));
532
533#ifdef DEBUGGING
534 /* tmp push yystate for stack print; this is normally pushed later in
535 * yynewstate */
536 yyssp++;
537 *yyssp = yystate;
538 YY_STACK_PRINT (yyss, yyssp, yyvs, yyns);
539 yyssp--;
540#endif
541
0de566d7 542 goto yynewstate;
543
544
545 /*------------------------------------.
546 | yyerrlab -- here on detecting error |
547 `------------------------------------*/
548 yyerrlab:
549 /* If not already recovering from an error, report this error. */
550 if (!yyerrstatus) {
551 ++yynerrs;
552#if YYERROR_VERBOSE
553 yyn = yypact[yystate];
554
555 if (YYPACT_NINF < yyn && yyn < YYLAST) {
556 YYSIZE_T yysize = 0;
df35152e 557 const int yytype = YYTRANSLATE (yychar);
0de566d7 558 char *yymsg;
559 int yyx, yycount;
560
561 yycount = 0;
562 /* Start YYX at -YYN if negative to avoid negative indexes in
563 YYCHECK. */
564 for (yyx = yyn < 0 ? -yyn : 0;
565 yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
566 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
567 yysize += yystrlen (yytname[yyx]) + 15, yycount++;
568 yysize += yystrlen ("syntax error, unexpected ") + 1;
569 yysize += yystrlen (yytname[yytype]);
4b711db3 570 Newx(yymsg, yysize, char *);
0de566d7 571 if (yymsg != 0) {
df35152e 572 const char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
0de566d7 573 yyp = yystpcpy (yyp, yytname[yytype]);
574
575 if (yycount < 5) {
576 yycount = 0;
577 for (yyx = yyn < 0 ? -yyn : 0;
578 yyx < (int) (sizeof (yytname) / sizeof (char *));
579 yyx++)
580 {
581 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) {
582 const char *yyq = ! yycount ?
583 ", expecting " : " or ";
584 yyp = yystpcpy (yyp, yyq);
585 yyp = yystpcpy (yyp, yytname[yyx]);
586 yycount++;
587 }
588 }
ecb2f335 589 }
0de566d7 590 yyerror (yymsg);
591 YYSTACK_FREE (yymsg);
592 }
593 else
594 yyerror ("syntax error; also virtual memory exhausted");
595 }
596 else
597#endif /* YYERROR_VERBOSE */
598 yyerror ("syntax error");
93a17b20 599 }
0de566d7 600
601
602 if (yyerrstatus == 3) {
603 /* If just tried and failed to reuse lookahead token after an
604 error, discard it. */
605
606 /* Return failure if at end of input. */
607 if (yychar == YYEOF) {
608 /* Pop the error token. */
609 YYPOPSTACK;
610 /* Pop the rest of the stack. */
611 while (yyss < yyssp) {
9388183f 612 YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp);
0de566d7 613 YYPOPSTACK;
614 }
615 YYABORT;
616 }
617
9388183f 618 YYDSYMPRINTF ("Error: discarding", yytoken, &yylval);
0de566d7 619 yychar = YYEMPTY;
620
93a17b20 621 }
0de566d7 622
623 /* Else will try to reuse lookahead token after shifting the error
624 token. */
625 goto yyerrlab1;
626
627
628 /*----------------------------------------------------.
629 | yyerrlab1 -- error raised explicitly by an action. |
630 `----------------------------------------------------*/
631 yyerrlab1:
632 yyerrstatus = 3; /* Each real token shifted decrements this. */
633
634 for (;;) {
635 yyn = yypact[yystate];
636 if (yyn != YYPACT_NINF) {
637 yyn += YYTERROR;
638 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) {
639 yyn = yytable[yyn];
640 if (0 < yyn)
641 break;
642 }
643 }
644
645 /* Pop the current state because it cannot handle the error token. */
646 if (yyssp == yyss)
647 YYABORT;
648
9388183f 649 YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp);
0de566d7 650 yyvsp--;
9388183f 651#ifdef DEBUGGING
652 yynsp--;
653#endif
0de566d7 654 yystate = *--yyssp;
655
9388183f 656 YY_STACK_PRINT (yyss, yyssp, yyvs, yyns);
93a17b20 657 }
0de566d7 658
659 if (yyn == YYFINAL)
660 YYACCEPT;
661
662 YYDPRINTF ((Perl_debug_log, "Shifting error token, "));
663
664 *++yyvsp = yylval;
9388183f 665#ifdef DEBUGGING
666 *++yynsp ="<err>";
667#endif
0de566d7 668
669 yystate = yyn;
9388183f 670 YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate));
671
0de566d7 672 goto yynewstate;
673
674
675 /*-------------------------------------.
676 | yyacceptlab -- YYACCEPT comes here. |
677 `-------------------------------------*/
678 yyacceptlab:
679 yyresult = 0;
680 goto yyreturn;
681
682 /*-----------------------------------.
683 | yyabortlab -- YYABORT comes here. |
684 `-----------------------------------*/
685 yyabortlab:
686 yyresult = 1;
687 goto yyreturn;
688
689 /*----------------------------------------------.
690 | yyoverflowlab -- parser overflow comes here. |
691 `----------------------------------------------*/
692 yyoverflowlab:
693 yyerror ("parser stack overflow");
694 yyresult = 2;
695 /* Fall through. */
696
697 yyreturn:
698
12fbd33b 699 LEAVE; /* force stack free before we return */
e1f15930 700
0de566d7 701 return yyresult;
e1f15930 702}
66610fdd 703
704/*
705 * Local variables:
706 * c-indentation-style: bsd
707 * c-basic-offset: 4
708 * indent-tabs-mode: t
709 * End:
710 *
37442d52 711 * ex: set ts=8 sts=4 sw=4 noet:
712 */