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