This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
perly.c: Disarm the YYDEBUG defines in perly.h
[perl5.git] / perly.c
CommitLineData
0de566d7
DM
1/* perly.c
2 *
2eee27d7
SS
3 * Copyright (c) 2004, 2005, 2006, 2007, 2008,
4 * 2009, 2010, 2011 by Larry Wall and others
0de566d7
DM
5 *
6 * You may distribute under the terms of either the GNU General Public
7 * License or the Artistic License, as specified in the README file.
8 *
9 * Note that this file was originally generated as an output from
10 * GNU bison version 1.875, but now the code is statically maintained
f05e27e5
DM
11 * and edited; the bits that are dependent on perly.y are now
12 * #included from the files perly.tab and perly.act.
0de566d7
DM
13 *
14 * Here is an important copyright statement from the original, generated
15 * file:
16 *
17 * As a special exception, when this file is copied by Bison into a
18 * Bison output file, you may use that output file without
19 * restriction. This special exception was added by the Free
20 * Software Foundation in version 1.24 of Bison.
bc463c31
DM
21 *
22 * Note that this file is also #included in madly.c, to allow compilation
23 * of a second parser, Perl_madparse, that is identical to Perl_yyparse,
f05e27e5
DM
24 * but which includes extra code for dumping the parse tree.
25 * This is controlled by the PERL_IN_MADLY_C define.
0de566d7
DM
26 */
27
79072805 28#include "EXTERN.h"
864dbfa3 29#define PERL_IN_PERLY_C
79072805 30#include "perl.h"
09bef843 31
3797f23d
DM
32typedef unsigned char yytype_uint8;
33typedef signed char yytype_int8;
34typedef unsigned short int yytype_uint16;
35typedef short int yytype_int16;
0de566d7
DM
36typedef signed char yysigned_char;
37
28ac2b49
Z
38/* YYINITDEPTH -- initial size of the parser's stacks. */
39#define YYINITDEPTH 200
40
599f1ac6
FC
41#ifdef YYDEBUG
42# undef YYDEBUG
43#endif
44#ifdef DEBUGGING
45# define YYDEBUG 1
46#else
47# define YYDEBUG 0
48#endif
49
b3045d9c
FC
50#ifndef YY_NULL
51# define YY_NULL 0
93a17b20 52#endif
09bef843 53
f05e27e5
DM
54/* contains all the parser state tables; auto-generated from perly.y */
55#include "perly.tab"
0de566d7
DM
56
57# define YYSIZE_T size_t
58
0de566d7 59#define YYEOF 0
07a06489 60#define YYTERROR 1
0de566d7
DM
61
62#define YYACCEPT goto yyacceptlab
63#define YYABORT goto yyabortlab
64#define YYERROR goto yyerrlab1
65
0de566d7 66/* Enable debugging if requested. */
9388183f 67#ifdef DEBUGGING
0de566d7
DM
68
69# define yydebug (DEBUG_p_TEST)
70
71# define YYFPRINTF PerlIO_printf
72
73# define YYDPRINTF(Args) \
74do { \
75 if (yydebug) \
76 YYFPRINTF Args; \
77} while (0)
78
9388183f 79# define YYDSYMPRINTF(Title, Token, Value) \
0de566d7
DM
80do { \
81 if (yydebug) { \
82 YYFPRINTF (Perl_debug_log, "%s ", Title); \
356f4fed 83 yysymprint (aTHX_ Perl_debug_log, Token, Value); \
0de566d7
DM
84 YYFPRINTF (Perl_debug_log, "\n"); \
85 } \
86} while (0)
87
88/*--------------------------------.
89| Print this symbol on YYOUTPUT. |
90`--------------------------------*/
91
92static void
356f4fed 93yysymprint(pTHX_ PerlIO * const yyoutput, int yytype, const YYSTYPE * const yyvaluep)
0de566d7 94{
0de566d7
DM
95 if (yytype < YYNTOKENS) {
96 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
97# ifdef YYPRINT
98 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
9388183f 99# else
e4584336 100 YYFPRINTF (yyoutput, "0x%"UVxf, (UV)yyvaluep->ival);
0de566d7
DM
101# endif
102 }
103 else
104 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
105
0de566d7
DM
106 YYFPRINTF (yyoutput, ")");
107}
108
109
9388183f 110/* yy_stack_print()
1654d593
DM
111 * print the top 8 items on the parse stack.
112 */
0de566d7
DM
113
114static void
1654d593 115yy_stack_print (pTHX_ const yy_parser *parser)
0de566d7 116{
1654d593 117 const yy_stack_frame *ps, *min;
9388183f 118
2d29f438 119 min = parser->ps - 8 + 1;
22735491
DM
120 if (min <= parser->stack)
121 min = parser->stack + 1;
9388183f
CB
122
123 PerlIO_printf(Perl_debug_log, "\nindex:");
1654d593 124 for (ps = min; ps <= parser->ps; ps++)
00c0e1ee 125 PerlIO_printf(Perl_debug_log, " %8d", (int)(ps - parser->stack));
1654d593 126
9388183f 127 PerlIO_printf(Perl_debug_log, "\nstate:");
1654d593
DM
128 for (ps = min; ps <= parser->ps; ps++)
129 PerlIO_printf(Perl_debug_log, " %8d", ps->state);
130
9388183f 131 PerlIO_printf(Perl_debug_log, "\ntoken:");
1654d593
DM
132 for (ps = min; ps <= parser->ps; ps++)
133 PerlIO_printf(Perl_debug_log, " %8.8s", ps->name);
134
9388183f 135 PerlIO_printf(Perl_debug_log, "\nvalue:");
1654d593
DM
136 for (ps = min; ps <= parser->ps; ps++) {
137 switch (yy_type_tab[yystos[ps->state]]) {
d5c6462e 138 case toketype_opval:
21612876 139 PerlIO_printf(Perl_debug_log, " %8.8s",
1654d593
DM
140 ps->val.opval
141 ? PL_op_name[ps->val.opval->op_type]
670f3923 142 : "(Nullop)"
21612876 143 );
d5c6462e
DM
144 break;
145#ifndef PERL_IN_MADLY_C
d5c6462e
DM
146 case toketype_i_tkval:
147#endif
148 case toketype_ival:
1654d593 149 PerlIO_printf(Perl_debug_log, " %8"IVdf, (IV)ps->val.ival);
d5c6462e
DM
150 break;
151 default:
1654d593 152 PerlIO_printf(Perl_debug_log, " %8"UVxf, (UV)ps->val.ival);
d5c6462e 153 }
21612876 154 }
9388183f 155 PerlIO_printf(Perl_debug_log, "\n\n");
0de566d7
DM
156}
157
1654d593
DM
158# define YY_STACK_PRINT(parser) \
159do { \
160 if (yydebug && DEBUG_v_TEST) \
161 yy_stack_print (aTHX_ parser); \
0de566d7
DM
162} while (0)
163
09bef843 164
0de566d7
DM
165/*------------------------------------------------.
166| Report that the YYRULE is going to be reduced. |
167`------------------------------------------------*/
168
169static void
170yy_reduce_print (pTHX_ int yyrule)
171{
172 int yyi;
df35152e 173 const unsigned int yylineno = yyrline[yyrule];
0de566d7
DM
174 YYFPRINTF (Perl_debug_log, "Reducing stack by rule %d (line %u), ",
175 yyrule - 1, yylineno);
176 /* Print the symbols being reduced, and their result. */
177 for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
178 YYFPRINTF (Perl_debug_log, "%s ", yytname [yyrhs[yyi]]);
179 YYFPRINTF (Perl_debug_log, "-> %s\n", yytname [yyr1[yyrule]]);
180}
181
182# define YY_REDUCE_PRINT(Rule) \
183do { \
184 if (yydebug) \
185 yy_reduce_print (aTHX_ Rule); \
186} while (0)
187
188#else /* !DEBUGGING */
189# define YYDPRINTF(Args)
9388183f 190# define YYDSYMPRINTF(Title, Token, Value)
1654d593 191# define YY_STACK_PRINT(parser)
0de566d7
DM
192# define YY_REDUCE_PRINT(Rule)
193#endif /* !DEBUGGING */
194
718a7425
DM
195/* called during cleanup (via SAVEDESTRUCTOR_X) to free any items on the
196 * parse stack, thus avoiding leaks if we die */
197
198static void
22735491 199S_clear_yystack(pTHX_ const yy_parser *parser)
718a7425 200{
1654d593 201 yy_stack_frame *ps = parser->ps;
0934c9d9 202 int i = 0;
718a7425 203
28ac2b49 204 if (!parser->stack)
718a7425 205 return;
1654d593 206
718a7425 207 YYDPRINTF ((Perl_debug_log, "clearing the parse stack\n"));
670f3923 208
8c63ea58
GG
209 for (i=0; i< parser->yylen; i++) {
210 SvREFCNT_dec(ps[-i].compcv);
211 }
0aded6e1 212 ps -= parser->yylen;
670f3923
DM
213
214 /* now free whole the stack, including the just-reduced ops */
215
22735491 216 while (ps > parser->stack) {
503de470 217 LEAVE_SCOPE(ps->savestack_ix);
1654d593
DM
218 if (yy_type_tab[yystos[ps->state]] == toketype_opval
219 && ps->val.opval)
670f3923 220 {
8c63ea58
GG
221 if (ps->compcv != PL_compcv) {
222 PL_compcv = ps->compcv;
223 PAD_SET_CUR_NOSAVE(CvPADLIST(PL_compcv), 1);
718a7425
DM
224 }
225 YYDPRINTF ((Perl_debug_log, "(freeing op)\n"));
571a568a 226 op_free(ps->val.opval);
718a7425 227 }
8c63ea58 228 SvREFCNT_dec(ps->compcv);
1654d593 229 ps--;
718a7425 230 }
28ac2b49
Z
231
232 Safefree(parser->stack);
718a7425
DM
233}
234
718a7425 235
0de566d7
DM
236/*----------.
237| yyparse. |
238`----------*/
239
79072805 240int
bc463c31 241#ifdef PERL_IN_MADLY_C
28ac2b49 242Perl_madparse (pTHX_ int gramtype)
bc463c31 243#else
28ac2b49 244Perl_yyparse (pTHX_ int gramtype)
bc463c31 245#endif
79072805 246{
97aff369 247 dVAR;
eb578fdb
KW
248 int yystate;
249 int yyn;
0de566d7
DM
250 int yyresult;
251
0de566d7 252 /* Lookahead token as an internal (translated) token number. */
714c8e96 253 int yytoken = 0;
0de566d7 254
eb578fdb
KW
255 yy_parser *parser; /* the parser object */
256 yy_stack_frame *ps; /* current parser stack frame */
a0d0e21e 257
1654d593
DM
258#define YYPOPSTACK parser->ps = --ps
259#define YYPUSHSTACK parser->ps = ++ps
0de566d7 260
acdf0a21 261 /* The variable used to return semantic value and location from the
5912531f 262 action routines: ie $$. */
0de566d7
DM
263 YYSTYPE yyval;
264
bc463c31
DM
265#ifndef PERL_IN_MADLY_C
266# ifdef PERL_MAD
00e74f14 267 if (PL_madskills)
28ac2b49 268 return madparse(gramtype);
bc463c31 269# endif
81d86705
NC
270#endif
271
0de566d7
DM
272 YYDPRINTF ((Perl_debug_log, "Starting parse\n"));
273
acdf0a21 274 parser = PL_parser;
1654d593 275
28ac2b49
Z
276 ENTER; /* force parser state cleanup/restoration before we return */
277 SAVEPPTR(parser->yylval.pval);
278 SAVEINT(parser->yychar);
279 SAVEINT(parser->yyerrstatus);
280 SAVEINT(parser->stack_size);
281 SAVEINT(parser->yylen);
282 SAVEVPTR(parser->stack);
283 SAVEVPTR(parser->ps);
284
285 /* initialise state for this parse */
286 parser->yychar = gramtype;
287 parser->yyerrstatus = 0;
288 parser->stack_size = YYINITDEPTH;
289 parser->yylen = 0;
290 Newx(parser->stack, YYINITDEPTH, yy_stack_frame);
291 ps = parser->ps = parser->stack;
292 ps->state = 0;
e3abe207 293 SAVEDESTRUCTOR_X(S_clear_yystack, parser);
0de566d7 294
0de566d7
DM
295/*------------------------------------------------------------.
296| yynewstate -- Push a new state, which is found in yystate. |
297`------------------------------------------------------------*/
298 yynewstate:
0de566d7 299
1654d593 300 yystate = ps->state;
05a03161 301
670f3923 302 YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate));
0de566d7 303
5912531f 304 parser->yylen = 0;
0de566d7 305
1654d593 306 {
22735491 307 size_t size = ps - parser->stack + 1;
0de566d7 308
1654d593
DM
309 /* grow the stack? We always leave 1 spare slot,
310 * in case of a '' -> 'foo' reduction */
0de566d7 311
85c508c3 312 if (size >= (size_t)parser->stack_size - 1) {
1654d593
DM
313 /* this will croak on insufficient memory */
314 parser->stack_size *= 2;
22735491
DM
315 Renew(parser->stack, parser->stack_size, yy_stack_frame);
316 ps = parser->ps = parser->stack + size -1;
670f3923 317
1654d593
DM
318 YYDPRINTF((Perl_debug_log,
319 "parser stack size increased to %lu frames\n",
320 (unsigned long int)parser->stack_size));
321 }
93a17b20 322 }
0de566d7 323
0de566d7
DM
324/* Do appropriate processing given the current state. */
325/* Read a lookahead token if we need one and don't already have one. */
0de566d7
DM
326
327 /* First try to decide what to do without reference to lookahead token. */
328
329 yyn = yypact[yystate];
330 if (yyn == YYPACT_NINF)
331 goto yydefault;
332
333 /* Not known => get a lookahead token if don't already have one. */
334
335 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
5912531f 336 if (parser->yychar == YYEMPTY) {
0de566d7 337 YYDPRINTF ((Perl_debug_log, "Reading a token: "));
f05e27e5 338#ifdef PERL_IN_MADLY_C
5912531f 339 parser->yychar = PL_madskills ? madlex() : yylex();
f05e27e5 340#else
5912531f 341 parser->yychar = yylex();
81d86705 342#endif
bc463c31 343
12fbd33b 344# ifdef EBCDIC
5912531f
DM
345 if (parser->yychar >= 0 && parser->yychar < 255) {
346 parser->yychar = NATIVE_TO_ASCII(parser->yychar);
12fbd33b
DM
347 }
348# endif
0de566d7
DM
349 }
350
5912531f
DM
351 if (parser->yychar <= YYEOF) {
352 parser->yychar = yytoken = YYEOF;
0de566d7 353 YYDPRINTF ((Perl_debug_log, "Now at end of input.\n"));
93a17b20 354 }
0de566d7 355 else {
5912531f
DM
356 yytoken = YYTRANSLATE (parser->yychar);
357 YYDSYMPRINTF ("Next token is", yytoken, &parser->yylval);
93a17b20 358 }
771df094 359
0de566d7
DM
360 /* If the proper action on seeing token YYTOKEN is to reduce or to
361 detect an error, take that action. */
362 yyn += yytoken;
363 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
364 goto yydefault;
365 yyn = yytable[yyn];
366 if (yyn <= 0) {
367 if (yyn == 0 || yyn == YYTABLE_NINF)
368 goto yyerrlab;
369 yyn = -yyn;
370 goto yyreduce;
371 }
7b57b0ea 372
0de566d7
DM
373 if (yyn == YYFINAL)
374 YYACCEPT;
771df094 375
0de566d7
DM
376 /* Shift the lookahead token. */
377 YYDPRINTF ((Perl_debug_log, "Shifting token %s, ", yytname[yytoken]));
378
379 /* Discard the token being shifted unless it is eof. */
5912531f
DM
380 if (parser->yychar != YYEOF)
381 parser->yychar = YYEMPTY;
0de566d7 382
1654d593
DM
383 YYPUSHSTACK;
384 ps->state = yyn;
5912531f 385 ps->val = parser->yylval;
ec8ec19f 386 ps->compcv = (CV*)SvREFCNT_inc(PL_compcv);
503de470 387 ps->savestack_ix = PL_savestack_ix;
9388183f 388#ifdef DEBUGGING
1654d593 389 ps->name = (const char *)(yytname[yytoken]);
9388183f 390#endif
0de566d7 391
0de566d7
DM
392 /* Count tokens shifted since error; after three, turn off error
393 status. */
5912531f
DM
394 if (parser->yyerrstatus)
395 parser->yyerrstatus--;
0de566d7 396
0de566d7
DM
397 goto yynewstate;
398
399
400 /*-----------------------------------------------------------.
401 | yydefault -- do the default action for the current state. |
402 `-----------------------------------------------------------*/
403 yydefault:
404 yyn = yydefact[yystate];
405 if (yyn == 0)
406 goto yyerrlab;
407 goto yyreduce;
408
409
410 /*-----------------------------.
411 | yyreduce -- Do a reduction. |
412 `-----------------------------*/
413 yyreduce:
414 /* yyn is the number of a rule to reduce with. */
5912531f 415 parser->yylen = yyr2[yyn];
0de566d7
DM
416
417 /* If YYLEN is nonzero, implement the default value of the action:
a0288114 418 "$$ = $1".
0de566d7
DM
419
420 Otherwise, the following line sets YYVAL to garbage.
421 This behavior is undocumented and Bison
422 users should not rely upon it. Assigning to YYVAL
423 unconditionally makes the parser a bit smaller, and it avoids a
424 GCC warning that YYVAL may be used uninitialized. */
5912531f 425 yyval = ps[1-parser->yylen].val;
0de566d7 426
1654d593 427 YY_STACK_PRINT(parser);
0de566d7 428 YY_REDUCE_PRINT (yyn);
718a7425 429
0de566d7
DM
430 switch (yyn) {
431
0de566d7
DM
432
433#define dep() deprecate("\"do\" to call subroutines")
f05e27e5 434
bc463c31 435#ifdef PERL_IN_MADLY_C
f05e27e5
DM
436# define IVAL(i) (i)->tk_lval.ival
437# define PVAL(p) (p)->tk_lval.pval
438# define TOKEN_GETMAD(a,b,c) token_getmad((a),(b),(c))
439# define TOKEN_FREE(a) token_free(a)
440# define OP_GETMAD(a,b,c) op_getmad((a),(b),(c))
441# define IF_MAD(a,b) (a)
442# define DO_MAD(a) a
443# define MAD
bc463c31 444#else
f05e27e5
DM
445# define IVAL(i) (i)
446# define PVAL(p) (p)
447# define TOKEN_GETMAD(a,b,c)
448# define TOKEN_FREE(a)
449# define OP_GETMAD(a,b,c)
450# define IF_MAD(a,b) (b)
451# define DO_MAD(a)
452# undef MAD
bc463c31 453#endif
7b57b0ea 454
f05e27e5
DM
455/* contains all the rule actions; auto-generated from perly.y */
456#include "perly.act"
457
93a17b20 458 }
0de566d7 459
670f3923
DM
460 {
461 int i;
5912531f 462 for (i=0; i< parser->yylen; i++) {
8c63ea58 463 SvREFCNT_dec(ps[-i].compcv);
670f3923
DM
464 }
465 }
466
5912531f 467 parser->ps = ps -= (parser->yylen-1);
0de566d7 468
05a03161
DM
469 /* Now shift the result of the reduction. Determine what state
470 that goes to, based on the state we popped back to and the rule
471 number reduced by. */
472
1654d593 473 ps->val = yyval;
ec8ec19f 474 ps->compcv = (CV*)SvREFCNT_inc(PL_compcv);
503de470 475 ps->savestack_ix = PL_savestack_ix;
9388183f 476#ifdef DEBUGGING
1654d593 477 ps->name = (const char *)(yytname [yyr1[yyn]]);
9388183f 478#endif
0de566d7
DM
479
480 yyn = yyr1[yyn];
481
1654d593
DM
482 yystate = yypgoto[yyn - YYNTOKENS] + ps[-1].state;
483 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == ps[-1].state)
0de566d7 484 yystate = yytable[yystate];
93a17b20 485 else
0de566d7 486 yystate = yydefgoto[yyn - YYNTOKENS];
1654d593 487 ps->state = yystate;
05a03161 488
0de566d7
DM
489 goto yynewstate;
490
491
492 /*------------------------------------.
493 | yyerrlab -- here on detecting error |
494 `------------------------------------*/
495 yyerrlab:
496 /* If not already recovering from an error, report this error. */
5912531f 497 if (!parser->yyerrstatus) {
07a06489 498 yyerror ("syntax error");
93a17b20 499 }
0de566d7
DM
500
501
5912531f 502 if (parser->yyerrstatus == 3) {
0de566d7
DM
503 /* If just tried and failed to reuse lookahead token after an
504 error, discard it. */
505
506 /* Return failure if at end of input. */
5912531f 507 if (parser->yychar == YYEOF) {
0de566d7 508 /* Pop the error token. */
8c63ea58 509 SvREFCNT_dec(ps->compcv);
0de566d7
DM
510 YYPOPSTACK;
511 /* Pop the rest of the stack. */
22735491 512 while (ps > parser->stack) {
1654d593 513 YYDSYMPRINTF ("Error: popping", yystos[ps->state], &ps->val);
503de470 514 LEAVE_SCOPE(ps->savestack_ix);
1654d593
DM
515 if (yy_type_tab[yystos[ps->state]] == toketype_opval
516 && ps->val.opval)
670f3923 517 {
0539ab63 518 YYDPRINTF ((Perl_debug_log, "(freeing op)\n"));
8c63ea58
GG
519 if (ps->compcv != PL_compcv) {
520 PL_compcv = ps->compcv;
521 PAD_SET_CUR_NOSAVE(CvPADLIST(PL_compcv), 1);
718a7425 522 }
1654d593 523 op_free(ps->val.opval);
0539ab63 524 }
8c63ea58 525 SvREFCNT_dec(ps->compcv);
0de566d7
DM
526 YYPOPSTACK;
527 }
528 YYABORT;
529 }
530
5912531f
DM
531 YYDSYMPRINTF ("Error: discarding", yytoken, &parser->yylval);
532 parser->yychar = YYEMPTY;
0de566d7 533
93a17b20 534 }
0de566d7
DM
535
536 /* Else will try to reuse lookahead token after shifting the error
537 token. */
538 goto yyerrlab1;
539
540
541 /*----------------------------------------------------.
542 | yyerrlab1 -- error raised explicitly by an action. |
543 `----------------------------------------------------*/
544 yyerrlab1:
5912531f 545 parser->yyerrstatus = 3; /* Each real token shifted decrements this. */
0de566d7
DM
546
547 for (;;) {
548 yyn = yypact[yystate];
549 if (yyn != YYPACT_NINF) {
550 yyn += YYTERROR;
551 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) {
552 yyn = yytable[yyn];
553 if (0 < yyn)
554 break;
555 }
556 }
557
558 /* Pop the current state because it cannot handle the error token. */
22735491 559 if (ps == parser->stack)
0de566d7
DM
560 YYABORT;
561
1654d593 562 YYDSYMPRINTF ("Error: popping", yystos[ps->state], &ps->val);
503de470 563 LEAVE_SCOPE(ps->savestack_ix);
1654d593 564 if (yy_type_tab[yystos[ps->state]] == toketype_opval && ps->val.opval) {
0539ab63 565 YYDPRINTF ((Perl_debug_log, "(freeing op)\n"));
8c63ea58
GG
566 if (ps->compcv != PL_compcv) {
567 PL_compcv = ps->compcv;
568 PAD_SET_CUR_NOSAVE(CvPADLIST(PL_compcv), 1);
718a7425 569 }
1654d593 570 op_free(ps->val.opval);
0539ab63 571 }
8c63ea58 572 SvREFCNT_dec(ps->compcv);
1654d593
DM
573 YYPOPSTACK;
574 yystate = ps->state;
0de566d7 575
1654d593 576 YY_STACK_PRINT(parser);
93a17b20 577 }
0de566d7
DM
578
579 if (yyn == YYFINAL)
580 YYACCEPT;
581
582 YYDPRINTF ((Perl_debug_log, "Shifting error token, "));
583
1654d593
DM
584 YYPUSHSTACK;
585 ps->state = yyn;
5912531f 586 ps->val = parser->yylval;
ec8ec19f 587 ps->compcv = (CV*)SvREFCNT_inc(PL_compcv);
503de470 588 ps->savestack_ix = PL_savestack_ix;
9388183f 589#ifdef DEBUGGING
1654d593 590 ps->name ="<err>";
9388183f 591#endif
0de566d7 592
0de566d7
DM
593 goto yynewstate;
594
595
596 /*-------------------------------------.
597 | yyacceptlab -- YYACCEPT comes here. |
598 `-------------------------------------*/
599 yyacceptlab:
600 yyresult = 0;
8c63ea58
GG
601 for (ps=parser->ps; ps > parser->stack; ps--) {
602 SvREFCNT_dec(ps->compcv);
603 }
22735491 604 parser->ps = parser->stack; /* disable cleanup */
0de566d7
DM
605 goto yyreturn;
606
607 /*-----------------------------------.
608 | yyabortlab -- YYABORT comes here. |
609 `-----------------------------------*/
610 yyabortlab:
611 yyresult = 1;
612 goto yyreturn;
613
0de566d7 614 yyreturn:
e3abe207 615 LEAVE; /* force parser stack cleanup before we return */
0de566d7 616 return yyresult;
e1f15930 617}
66610fdd
RGS
618
619/*
620 * Local variables:
621 * c-indentation-style: bsd
622 * c-basic-offset: 4
14d04a33 623 * indent-tabs-mode: nil
66610fdd
RGS
624 * End:
625 *
14d04a33 626 * ex: set ts=8 sts=4 sw=4 et:
37442d52 627 */