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