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