(?p{}) has been deprecated for a long time.
[p5sagit/p5-mst-13.2.git] / perly.c
CommitLineData
0de566d7 1/* perly.c
2 *
bc641c27 3 * Copyright (c) 2004, 2005, 2006, 2007, by Larry Wall and others
0de566d7 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
f05e27e5 10 * and edited; the bits that are dependent on perly.y are now
11 * #included from the files perly.tab and perly.act.
0de566d7 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.
bc463c31 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,
f05e27e5 23 * but which includes extra code for dumping the parse tree.
24 * This is controlled by the PERL_IN_MADLY_C define.
0de566d7 25 */
26
79072805 27#include "EXTERN.h"
864dbfa3 28#define PERL_IN_PERLY_C
79072805 29#include "perl.h"
09bef843 30
3797f23d 31typedef unsigned char yytype_uint8;
32typedef signed char yytype_int8;
33typedef unsigned short int yytype_uint16;
34typedef short int yytype_int16;
0de566d7 35typedef signed char yysigned_char;
36
37#ifdef DEBUGGING
38# define YYDEBUG 1
93a17b20 39#else
0de566d7 40# define YYDEBUG 0
93a17b20 41#endif
09bef843 42
f05e27e5 43/* contains all the parser state tables; auto-generated from perly.y */
44#include "perly.tab"
0de566d7 45
46# define YYSIZE_T size_t
47
0de566d7 48#define YYEOF 0
07a06489 49#define YYTERROR 1
0de566d7 50
51#define YYACCEPT goto yyacceptlab
52#define YYABORT goto yyabortlab
53#define YYERROR goto yyerrlab1
54
0de566d7 55/* Enable debugging if requested. */
9388183f 56#ifdef DEBUGGING
0de566d7 57
58# define yydebug (DEBUG_p_TEST)
59
60# define YYFPRINTF PerlIO_printf
61
62# define YYDPRINTF(Args) \
63do { \
64 if (yydebug) \
65 YYFPRINTF Args; \
66} while (0)
67
9388183f 68# define YYDSYMPRINTF(Title, Token, Value) \
0de566d7 69do { \
70 if (yydebug) { \
71 YYFPRINTF (Perl_debug_log, "%s ", Title); \
356f4fed 72 yysymprint (aTHX_ Perl_debug_log, Token, Value); \
0de566d7 73 YYFPRINTF (Perl_debug_log, "\n"); \
74 } \
75} while (0)
76
77/*--------------------------------.
78| Print this symbol on YYOUTPUT. |
79`--------------------------------*/
80
81static void
356f4fed 82yysymprint(pTHX_ PerlIO * const yyoutput, int yytype, const YYSTYPE * const yyvaluep)
0de566d7 83{
0de566d7 84 if (yytype < YYNTOKENS) {
85 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
86# ifdef YYPRINT
87 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
9388183f 88# else
e4584336 89 YYFPRINTF (yyoutput, "0x%"UVxf, (UV)yyvaluep->ival);
0de566d7 90# endif
91 }
92 else
93 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
94
0de566d7 95 YYFPRINTF (yyoutput, ")");
96}
97
98
9388183f 99/* yy_stack_print()
1654d593 100 * print the top 8 items on the parse stack.
101 */
0de566d7 102
103static void
1654d593 104yy_stack_print (pTHX_ const yy_parser *parser)
0de566d7 105{
1654d593 106 const yy_stack_frame *ps, *min;
9388183f 107
2d29f438 108 min = parser->ps - 8 + 1;
22735491 109 if (min <= parser->stack)
110 min = parser->stack + 1;
9388183f 111
112 PerlIO_printf(Perl_debug_log, "\nindex:");
1654d593 113 for (ps = min; ps <= parser->ps; ps++)
00c0e1ee 114 PerlIO_printf(Perl_debug_log, " %8d", (int)(ps - parser->stack));
1654d593 115
9388183f 116 PerlIO_printf(Perl_debug_log, "\nstate:");
1654d593 117 for (ps = min; ps <= parser->ps; ps++)
118 PerlIO_printf(Perl_debug_log, " %8d", ps->state);
119
9388183f 120 PerlIO_printf(Perl_debug_log, "\ntoken:");
1654d593 121 for (ps = min; ps <= parser->ps; ps++)
122 PerlIO_printf(Perl_debug_log, " %8.8s", ps->name);
123
9388183f 124 PerlIO_printf(Perl_debug_log, "\nvalue:");
1654d593 125 for (ps = min; ps <= parser->ps; ps++) {
126 switch (yy_type_tab[yystos[ps->state]]) {
d5c6462e 127 case toketype_opval:
21612876 128 PerlIO_printf(Perl_debug_log, " %8.8s",
1654d593 129 ps->val.opval
130 ? PL_op_name[ps->val.opval->op_type]
670f3923 131 : "(Nullop)"
21612876 132 );
d5c6462e 133 break;
134#ifndef PERL_IN_MADLY_C
135 case toketype_p_tkval:
136 PerlIO_printf(Perl_debug_log, " %8.8s",
1654d593 137 ps->val.pval ? ps->val.pval : "(NULL)");
d5c6462e 138 break;
139
140 case toketype_i_tkval:
141#endif
142 case toketype_ival:
1654d593 143 PerlIO_printf(Perl_debug_log, " %8"IVdf, (IV)ps->val.ival);
d5c6462e 144 break;
145 default:
1654d593 146 PerlIO_printf(Perl_debug_log, " %8"UVxf, (UV)ps->val.ival);
d5c6462e 147 }
21612876 148 }
9388183f 149 PerlIO_printf(Perl_debug_log, "\n\n");
0de566d7 150}
151
1654d593 152# define YY_STACK_PRINT(parser) \
153do { \
154 if (yydebug && DEBUG_v_TEST) \
155 yy_stack_print (aTHX_ parser); \
0de566d7 156} while (0)
157
09bef843 158
0de566d7 159/*------------------------------------------------.
160| Report that the YYRULE is going to be reduced. |
161`------------------------------------------------*/
162
163static void
164yy_reduce_print (pTHX_ int yyrule)
165{
166 int yyi;
df35152e 167 const unsigned int yylineno = yyrline[yyrule];
0de566d7 168 YYFPRINTF (Perl_debug_log, "Reducing stack by rule %d (line %u), ",
169 yyrule - 1, yylineno);
170 /* Print the symbols being reduced, and their result. */
171 for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
172 YYFPRINTF (Perl_debug_log, "%s ", yytname [yyrhs[yyi]]);
173 YYFPRINTF (Perl_debug_log, "-> %s\n", yytname [yyr1[yyrule]]);
174}
175
176# define YY_REDUCE_PRINT(Rule) \
177do { \
178 if (yydebug) \
179 yy_reduce_print (aTHX_ Rule); \
180} while (0)
181
182#else /* !DEBUGGING */
183# define YYDPRINTF(Args)
9388183f 184# define YYDSYMPRINTF(Title, Token, Value)
1654d593 185# define YY_STACK_PRINT(parser)
0de566d7 186# define YY_REDUCE_PRINT(Rule)
187#endif /* !DEBUGGING */
188
718a7425 189/* called during cleanup (via SAVEDESTRUCTOR_X) to free any items on the
190 * parse stack, thus avoiding leaks if we die */
191
192static void
22735491 193S_clear_yystack(pTHX_ const yy_parser *parser)
718a7425 194{
1654d593 195 yy_stack_frame *ps = parser->ps;
670f3923 196 int i;
718a7425 197
199e78b7 198 if (!parser->stack || ps == parser->stack)
718a7425 199 return;
1654d593 200
718a7425 201 YYDPRINTF ((Perl_debug_log, "clearing the parse stack\n"));
670f3923 202
7e5d8ed2 203 /* Freeing ops on the stack, and the op_latefree / op_latefreed /
204 * op_attached flags:
670f3923 205 *
206 * When we pop tokens off the stack during error recovery, or when
207 * we pop all the tokens off the stack after a die during a shift or
7e5d8ed2 208 * reduce (i.e. Perl_croak somewhere in yylex() or in one of the
209 * newFOO() functions), then it's possible that some of these tokens are
670f3923 210 * of type opval, pointing to an OP. All these ops are orphans; each is
211 * its own miniature subtree that has not yet been attached to a
7e5d8ed2 212 * larger tree. In this case, we should clearly free the op (making
213 * sure, for each op we free that we have PL_comppad pointing to the
670f3923 214 * right place for freeing any SVs attached to the op in threaded
215 * builds.
216 *
7e5d8ed2 217 * However, there is a particular problem if we die in newFOO() called
670f3923 218 * by a reducing action; e.g.
219 *
220 * foo : bar baz boz
221 * { $$ = newFOO($1,$2,$3) }
222 *
223 * where
7e5d8ed2 224 * OP *newFOO { ....; if (...) croak; .... }
670f3923 225 *
226 * In this case, when we come to clean bar baz and boz off the stack,
227 * we don't know whether newFOO() has already:
228 * * freed them
7e5d8ed2 229 * * left them as is
670f3923 230 * * attached them to part of a larger tree
7e5d8ed2 231 * * attached them to PL_compcv
232 * * attached them to PL_compcv then freed it (as in BEGIN {die } )
670f3923 233 *
234 * To get round this problem, we set the flag op_latefree on every op
235 * that gets pushed onto the parser stack. If op_free() sees this
236 * flag, it clears the op and frees any children,, but *doesn't* free
237 * the op itself; instead it sets the op_latefreed flag. This means
238 * that we can safely call op_free() multiple times on each stack op.
239 * So, when clearing the stack, we first, for each op that was being
240 * reduced, call op_free with op_latefree=1. This ensures that all ops
241 * hanging off these op are freed, but the reducing ops themselces are
242 * just undefed. Then we set op_latefreed=0 on *all* ops on the stack
7e5d8ed2 243 * and free them. A little thought should convince you that this
244 * two-part approach to the reducing ops should handle the first three
245 * cases above safely.
246 *
247 * In the case of attaching to PL_compcv (currently just newATTRSUB
248 * does this), then we set the op_attached flag on the op that has
249 * been so attached, then avoid doing the final op_free during
250 * cleanup, on the assumption that it will happen (or has already
251 * happened) when PL_compcv is freed.
252 *
253 * Note this is fairly fragile mechanism. A more robust approach
254 * would be to use two of these flag bits as 2-bit reference count
255 * field for each op, indicating whether it is pointed to from:
256 * * a parent op
257 * * the parser stack
258 * * a CV
259 * but this would involve reworking all code (core and external) that
260 * manipulate op trees.
0aded6e1 261 *
262 * XXX DAPM 17/1/07 I've decided its too fragile for now, and so have
263 * disabled it */
264
265#define DISABLE_STACK_FREE
670f3923 266
0aded6e1 267
268#ifdef DISABLE_STACK_FREE
269 ps -= parser->yylen;
270 PERL_UNUSED_VAR(i);
271#else
7e5d8ed2 272 /* clear any reducing ops (1st pass) */
670f3923 273
5912531f 274 for (i=0; i< parser->yylen; i++) {
1654d593 275 if (yy_type_tab[yystos[ps[-i].state]] == toketype_opval
276 && ps[-i].val.opval) {
7e5d8ed2 277 if ( ! (ps[-i].val.opval->op_attached
278 && !ps[-i].val.opval->op_latefreed))
279 {
280 if (ps[-i].comppad != PL_comppad) {
281 PAD_RESTORE_LOCAL(ps[-i].comppad);
282 }
283 op_free(ps[-i].val.opval);
670f3923 284 }
670f3923 285 }
286 }
0aded6e1 287#endif
670f3923 288
289 /* now free whole the stack, including the just-reduced ops */
290
22735491 291 while (ps > parser->stack) {
1654d593 292 if (yy_type_tab[yystos[ps->state]] == toketype_opval
293 && ps->val.opval)
670f3923 294 {
1654d593 295 if (ps->comppad != PL_comppad) {
296 PAD_RESTORE_LOCAL(ps->comppad);
718a7425 297 }
298 YYDPRINTF ((Perl_debug_log, "(freeing op)\n"));
0aded6e1 299#ifndef DISABLE_STACK_FREE
1654d593 300 ps->val.opval->op_latefree = 0;
7e5d8ed2 301 if (!(ps->val.opval->op_attached && !ps->val.opval->op_latefreed))
0aded6e1 302#endif
7e5d8ed2 303 op_free(ps->val.opval);
718a7425 304 }
1654d593 305 ps--;
718a7425 306 }
307}
308
22735491 309/* delete a parser object */
310
93c535ac 311#ifndef PERL_IN_MADLY_C
acdf0a21 312void
313Perl_parser_free(pTHX_ const yy_parser *parser)
22735491 314{
315 S_clear_yystack(aTHX_ parser);
316 Safefree(parser->stack);
7d84b8ac 317 Safefree(parser->lex_brackstack);
318 Safefree(parser->lex_casestack);
22735491 319 PL_parser = parser->old_parser;
7d84b8ac 320 Safefree(parser);
22735491 321}
93c535ac 322#endif
718a7425 323
0de566d7 324/*----------.
325| yyparse. |
326`----------*/
327
79072805 328int
bc463c31 329#ifdef PERL_IN_MADLY_C
330Perl_madparse (pTHX)
331#else
0de566d7 332Perl_yyparse (pTHX)
bc463c31 333#endif
79072805 334{
97aff369 335 dVAR;
0de566d7 336 register int yystate;
337 register int yyn;
338 int yyresult;
339
0de566d7 340 /* Lookahead token as an internal (translated) token number. */
714c8e96 341 int yytoken = 0;
0de566d7 342
5912531f 343 register yy_parser *parser; /* the parser object */
1654d593 344 register yy_stack_frame *ps; /* current parser stack frame */
a0d0e21e 345
1654d593 346#define YYPOPSTACK parser->ps = --ps
347#define YYPUSHSTACK parser->ps = ++ps
0de566d7 348
acdf0a21 349 /* The variable used to return semantic value and location from the
5912531f 350 action routines: ie $$. */
0de566d7 351 YYSTYPE yyval;
352
bc463c31 353#ifndef PERL_IN_MADLY_C
354# ifdef PERL_MAD
00e74f14 355 if (PL_madskills)
356 return madparse();
bc463c31 357# endif
81d86705 358#endif
359
0de566d7 360 YYDPRINTF ((Perl_debug_log, "Starting parse\n"));
361
acdf0a21 362 parser = PL_parser;
363 ps = parser->ps;
1654d593 364
22735491 365 ENTER; /* force parser free before we return */
7c197c94 366 SAVEPARSER(parser);
0de566d7 367
0de566d7 368/*------------------------------------------------------------.
369| yynewstate -- Push a new state, which is found in yystate. |
370`------------------------------------------------------------*/
371 yynewstate:
0de566d7 372
1654d593 373 yystate = ps->state;
05a03161 374
670f3923 375 YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate));
0de566d7 376
0aded6e1 377#ifndef DISABLE_STACK_FREE
1654d593 378 if (yy_type_tab[yystos[yystate]] == toketype_opval && ps->val.opval) {
379 ps->val.opval->op_latefree = 1;
380 ps->val.opval->op_latefreed = 0;
670f3923 381 }
0aded6e1 382#endif
670f3923 383
5912531f 384 parser->yylen = 0;
0de566d7 385
1654d593 386 {
22735491 387 size_t size = ps - parser->stack + 1;
0de566d7 388
1654d593 389 /* grow the stack? We always leave 1 spare slot,
390 * in case of a '' -> 'foo' reduction */
0de566d7 391
85c508c3 392 if (size >= (size_t)parser->stack_size - 1) {
1654d593 393 /* this will croak on insufficient memory */
394 parser->stack_size *= 2;
22735491 395 Renew(parser->stack, parser->stack_size, yy_stack_frame);
396 ps = parser->ps = parser->stack + size -1;
670f3923 397
1654d593 398 YYDPRINTF((Perl_debug_log,
399 "parser stack size increased to %lu frames\n",
400 (unsigned long int)parser->stack_size));
401 }
93a17b20 402 }
0de566d7 403
0de566d7 404/* Do appropriate processing given the current state. */
405/* Read a lookahead token if we need one and don't already have one. */
0de566d7 406
407 /* First try to decide what to do without reference to lookahead token. */
408
409 yyn = yypact[yystate];
410 if (yyn == YYPACT_NINF)
411 goto yydefault;
412
413 /* Not known => get a lookahead token if don't already have one. */
414
415 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
5912531f 416 if (parser->yychar == YYEMPTY) {
0de566d7 417 YYDPRINTF ((Perl_debug_log, "Reading a token: "));
f05e27e5 418#ifdef PERL_IN_MADLY_C
5912531f 419 parser->yychar = PL_madskills ? madlex() : yylex();
f05e27e5 420#else
5912531f 421 parser->yychar = yylex();
81d86705 422#endif
bc463c31 423
12fbd33b 424# ifdef EBCDIC
5912531f 425 if (parser->yychar >= 0 && parser->yychar < 255) {
426 parser->yychar = NATIVE_TO_ASCII(parser->yychar);
12fbd33b 427 }
428# endif
0de566d7 429 }
430
5912531f 431 if (parser->yychar <= YYEOF) {
432 parser->yychar = yytoken = YYEOF;
0de566d7 433 YYDPRINTF ((Perl_debug_log, "Now at end of input.\n"));
93a17b20 434 }
0de566d7 435 else {
5912531f 436 yytoken = YYTRANSLATE (parser->yychar);
437 YYDSYMPRINTF ("Next token is", yytoken, &parser->yylval);
93a17b20 438 }
771df094 439
0de566d7 440 /* If the proper action on seeing token YYTOKEN is to reduce or to
441 detect an error, take that action. */
442 yyn += yytoken;
443 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
444 goto yydefault;
445 yyn = yytable[yyn];
446 if (yyn <= 0) {
447 if (yyn == 0 || yyn == YYTABLE_NINF)
448 goto yyerrlab;
449 yyn = -yyn;
450 goto yyreduce;
451 }
7b57b0ea 452
0de566d7 453 if (yyn == YYFINAL)
454 YYACCEPT;
771df094 455
0de566d7 456 /* Shift the lookahead token. */
457 YYDPRINTF ((Perl_debug_log, "Shifting token %s, ", yytname[yytoken]));
458
459 /* Discard the token being shifted unless it is eof. */
5912531f 460 if (parser->yychar != YYEOF)
461 parser->yychar = YYEMPTY;
0de566d7 462
1654d593 463 YYPUSHSTACK;
464 ps->state = yyn;
5912531f 465 ps->val = parser->yylval;
1654d593 466 ps->comppad = PL_comppad;
9388183f 467#ifdef DEBUGGING
1654d593 468 ps->name = (const char *)(yytname[yytoken]);
9388183f 469#endif
0de566d7 470
0de566d7 471 /* Count tokens shifted since error; after three, turn off error
472 status. */
5912531f 473 if (parser->yyerrstatus)
474 parser->yyerrstatus--;
0de566d7 475
0de566d7 476 goto yynewstate;
477
478
479 /*-----------------------------------------------------------.
480 | yydefault -- do the default action for the current state. |
481 `-----------------------------------------------------------*/
482 yydefault:
483 yyn = yydefact[yystate];
484 if (yyn == 0)
485 goto yyerrlab;
486 goto yyreduce;
487
488
489 /*-----------------------------.
490 | yyreduce -- Do a reduction. |
491 `-----------------------------*/
492 yyreduce:
493 /* yyn is the number of a rule to reduce with. */
5912531f 494 parser->yylen = yyr2[yyn];
0de566d7 495
496 /* If YYLEN is nonzero, implement the default value of the action:
a0288114 497 "$$ = $1".
0de566d7 498
499 Otherwise, the following line sets YYVAL to garbage.
500 This behavior is undocumented and Bison
501 users should not rely upon it. Assigning to YYVAL
502 unconditionally makes the parser a bit smaller, and it avoids a
503 GCC warning that YYVAL may be used uninitialized. */
5912531f 504 yyval = ps[1-parser->yylen].val;
0de566d7 505
1654d593 506 YY_STACK_PRINT(parser);
0de566d7 507 YY_REDUCE_PRINT (yyn);
718a7425 508
0de566d7 509 switch (yyn) {
510
0de566d7 511
512#define dep() deprecate("\"do\" to call subroutines")
f05e27e5 513
bc463c31 514#ifdef PERL_IN_MADLY_C
f05e27e5 515# define IVAL(i) (i)->tk_lval.ival
516# define PVAL(p) (p)->tk_lval.pval
517# define TOKEN_GETMAD(a,b,c) token_getmad((a),(b),(c))
518# define TOKEN_FREE(a) token_free(a)
519# define OP_GETMAD(a,b,c) op_getmad((a),(b),(c))
520# define IF_MAD(a,b) (a)
521# define DO_MAD(a) a
522# define MAD
bc463c31 523#else
f05e27e5 524# define IVAL(i) (i)
525# define PVAL(p) (p)
526# define TOKEN_GETMAD(a,b,c)
527# define TOKEN_FREE(a)
528# define OP_GETMAD(a,b,c)
529# define IF_MAD(a,b) (b)
530# define DO_MAD(a)
531# undef MAD
bc463c31 532#endif
7b57b0ea 533
f05e27e5 534/* contains all the rule actions; auto-generated from perly.y */
535#include "perly.act"
536
93a17b20 537 }
0de566d7 538
0aded6e1 539#ifndef DISABLE_STACK_FREE
670f3923 540 /* any just-reduced ops with the op_latefreed flag cleared need to be
541 * freed; the rest need the flag resetting */
542 {
543 int i;
5912531f 544 for (i=0; i< parser->yylen; i++) {
1654d593 545 if (yy_type_tab[yystos[ps[-i].state]] == toketype_opval
546 && ps[-i].val.opval)
670f3923 547 {
1654d593 548 ps[-i].val.opval->op_latefree = 0;
549 if (ps[-i].val.opval->op_latefreed)
550 op_free(ps[-i].val.opval);
670f3923 551 }
552 }
553 }
0aded6e1 554#endif
670f3923 555
5912531f 556 parser->ps = ps -= (parser->yylen-1);
0de566d7 557
05a03161 558 /* Now shift the result of the reduction. Determine what state
559 that goes to, based on the state we popped back to and the rule
560 number reduced by. */
561
1654d593 562 ps->val = yyval;
563 ps->comppad = PL_comppad;
9388183f 564#ifdef DEBUGGING
1654d593 565 ps->name = (const char *)(yytname [yyr1[yyn]]);
9388183f 566#endif
0de566d7 567
568 yyn = yyr1[yyn];
569
1654d593 570 yystate = yypgoto[yyn - YYNTOKENS] + ps[-1].state;
571 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == ps[-1].state)
0de566d7 572 yystate = yytable[yystate];
93a17b20 573 else
0de566d7 574 yystate = yydefgoto[yyn - YYNTOKENS];
1654d593 575 ps->state = yystate;
05a03161 576
0de566d7 577 goto yynewstate;
578
579
580 /*------------------------------------.
581 | yyerrlab -- here on detecting error |
582 `------------------------------------*/
583 yyerrlab:
584 /* If not already recovering from an error, report this error. */
5912531f 585 if (!parser->yyerrstatus) {
07a06489 586 yyerror ("syntax error");
93a17b20 587 }
0de566d7 588
589
5912531f 590 if (parser->yyerrstatus == 3) {
0de566d7 591 /* If just tried and failed to reuse lookahead token after an
592 error, discard it. */
593
594 /* Return failure if at end of input. */
5912531f 595 if (parser->yychar == YYEOF) {
0de566d7 596 /* Pop the error token. */
597 YYPOPSTACK;
598 /* Pop the rest of the stack. */
22735491 599 while (ps > parser->stack) {
1654d593 600 YYDSYMPRINTF ("Error: popping", yystos[ps->state], &ps->val);
601 if (yy_type_tab[yystos[ps->state]] == toketype_opval
602 && ps->val.opval)
670f3923 603 {
0539ab63 604 YYDPRINTF ((Perl_debug_log, "(freeing op)\n"));
1654d593 605 if (ps->comppad != PL_comppad) {
606 PAD_RESTORE_LOCAL(ps->comppad);
718a7425 607 }
1654d593 608 ps->val.opval->op_latefree = 0;
609 op_free(ps->val.opval);
0539ab63 610 }
0de566d7 611 YYPOPSTACK;
612 }
613 YYABORT;
614 }
615
5912531f 616 YYDSYMPRINTF ("Error: discarding", yytoken, &parser->yylval);
617 parser->yychar = YYEMPTY;
0de566d7 618
93a17b20 619 }
0de566d7 620
621 /* Else will try to reuse lookahead token after shifting the error
622 token. */
623 goto yyerrlab1;
624
625
626 /*----------------------------------------------------.
627 | yyerrlab1 -- error raised explicitly by an action. |
628 `----------------------------------------------------*/
629 yyerrlab1:
5912531f 630 parser->yyerrstatus = 3; /* Each real token shifted decrements this. */
0de566d7 631
632 for (;;) {
633 yyn = yypact[yystate];
634 if (yyn != YYPACT_NINF) {
635 yyn += YYTERROR;
636 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) {
637 yyn = yytable[yyn];
638 if (0 < yyn)
639 break;
640 }
641 }
642
643 /* Pop the current state because it cannot handle the error token. */
22735491 644 if (ps == parser->stack)
0de566d7 645 YYABORT;
646
1654d593 647 YYDSYMPRINTF ("Error: popping", yystos[ps->state], &ps->val);
648 if (yy_type_tab[yystos[ps->state]] == toketype_opval && ps->val.opval) {
0539ab63 649 YYDPRINTF ((Perl_debug_log, "(freeing op)\n"));
1654d593 650 if (ps->comppad != PL_comppad) {
651 PAD_RESTORE_LOCAL(ps->comppad);
718a7425 652 }
1654d593 653 ps->val.opval->op_latefree = 0;
654 op_free(ps->val.opval);
0539ab63 655 }
1654d593 656 YYPOPSTACK;
657 yystate = ps->state;
0de566d7 658
1654d593 659 YY_STACK_PRINT(parser);
93a17b20 660 }
0de566d7 661
662 if (yyn == YYFINAL)
663 YYACCEPT;
664
665 YYDPRINTF ((Perl_debug_log, "Shifting error token, "));
666
1654d593 667 YYPUSHSTACK;
668 ps->state = yyn;
5912531f 669 ps->val = parser->yylval;
1654d593 670 ps->comppad = PL_comppad;
9388183f 671#ifdef DEBUGGING
1654d593 672 ps->name ="<err>";
9388183f 673#endif
0de566d7 674
0de566d7 675 goto yynewstate;
676
677
678 /*-------------------------------------.
679 | yyacceptlab -- YYACCEPT comes here. |
680 `-------------------------------------*/
681 yyacceptlab:
682 yyresult = 0;
22735491 683 parser->ps = parser->stack; /* disable cleanup */
0de566d7 684 goto yyreturn;
685
686 /*-----------------------------------.
687 | yyabortlab -- YYABORT comes here. |
688 `-----------------------------------*/
689 yyabortlab:
690 yyresult = 1;
691 goto yyreturn;
692
0de566d7 693 yyreturn:
22735491 694 LEAVE; /* force parser free before we return */
0de566d7 695 return yyresult;
e1f15930 696}
66610fdd 697
698/*
699 * Local variables:
700 * c-indentation-style: bsd
701 * c-basic-offset: 4
702 * indent-tabs-mode: t
703 * End:
704 *
37442d52 705 * ex: set ts=8 sts=4 sw=4 noet:
706 */