This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
optimising yyparse: avoid a < 0 check
[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 21 *
0de566d7
DM
22 */
23
79072805 24#include "EXTERN.h"
864dbfa3 25#define PERL_IN_PERLY_C
79072805 26#include "perl.h"
30d9c59b 27#include "feature.h"
d3d9da4a 28#include "keywords.h"
09bef843 29
3797f23d
DM
30typedef unsigned char yytype_uint8;
31typedef signed char yytype_int8;
32typedef unsigned short int yytype_uint16;
33typedef short int yytype_int16;
0de566d7
DM
34typedef signed char yysigned_char;
35
28ac2b49
Z
36/* YYINITDEPTH -- initial size of the parser's stacks. */
37#define YYINITDEPTH 200
38
599f1ac6
FC
39#ifdef YYDEBUG
40# undef YYDEBUG
41#endif
42#ifdef DEBUGGING
43# define YYDEBUG 1
44#else
45# define YYDEBUG 0
46#endif
47
b3045d9c
FC
48#ifndef YY_NULL
49# define YY_NULL 0
93a17b20 50#endif
09bef843 51
f39ff1f3
DM
52#ifndef YY_NULLPTR
53# define YY_NULLPTR NULL
54#endif
55
f05e27e5
DM
56/* contains all the parser state tables; auto-generated from perly.y */
57#include "perly.tab"
0de566d7
DM
58
59# define YYSIZE_T size_t
60
0de566d7 61#define YYEOF 0
07a06489 62#define YYTERROR 1
0de566d7
DM
63
64#define YYACCEPT goto yyacceptlab
65#define YYABORT goto yyabortlab
66#define YYERROR goto yyerrlab1
67
0de566d7 68/* Enable debugging if requested. */
9388183f 69#ifdef DEBUGGING
0de566d7
DM
70
71# define yydebug (DEBUG_p_TEST)
72
73# define YYFPRINTF PerlIO_printf
74
75# define YYDPRINTF(Args) \
76do { \
77 if (yydebug) \
78 YYFPRINTF Args; \
79} while (0)
80
9388183f 81# define YYDSYMPRINTF(Title, Token, Value) \
0de566d7
DM
82do { \
83 if (yydebug) { \
84 YYFPRINTF (Perl_debug_log, "%s ", Title); \
356f4fed 85 yysymprint (aTHX_ Perl_debug_log, Token, Value); \
0de566d7
DM
86 YYFPRINTF (Perl_debug_log, "\n"); \
87 } \
88} while (0)
89
90/*--------------------------------.
91| Print this symbol on YYOUTPUT. |
92`--------------------------------*/
93
94static void
356f4fed 95yysymprint(pTHX_ PerlIO * const yyoutput, int yytype, const YYSTYPE * const yyvaluep)
0de566d7 96{
dc3bf405 97 PERL_UNUSED_CONTEXT;
0de566d7
DM
98 if (yytype < YYNTOKENS) {
99 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
100# ifdef YYPRINT
101 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
9388183f 102# else
147e3846 103 YYFPRINTF (yyoutput, "0x%" UVxf, (UV)yyvaluep->ival);
0de566d7
DM
104# endif
105 }
106 else
107 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
108
0de566d7
DM
109 YYFPRINTF (yyoutput, ")");
110}
111
112
9388183f 113/* yy_stack_print()
1654d593
DM
114 * print the top 8 items on the parse stack.
115 */
0de566d7
DM
116
117static void
1654d593 118yy_stack_print (pTHX_ const yy_parser *parser)
0de566d7 119{
1654d593 120 const yy_stack_frame *ps, *min;
9388183f 121
2d29f438 122 min = parser->ps - 8 + 1;
22735491
DM
123 if (min <= parser->stack)
124 min = parser->stack + 1;
9388183f
CB
125
126 PerlIO_printf(Perl_debug_log, "\nindex:");
1654d593 127 for (ps = min; ps <= parser->ps; ps++)
00c0e1ee 128 PerlIO_printf(Perl_debug_log, " %8d", (int)(ps - parser->stack));
1654d593 129
9388183f 130 PerlIO_printf(Perl_debug_log, "\nstate:");
1654d593
DM
131 for (ps = min; ps <= parser->ps; ps++)
132 PerlIO_printf(Perl_debug_log, " %8d", ps->state);
133
9388183f 134 PerlIO_printf(Perl_debug_log, "\ntoken:");
1654d593
DM
135 for (ps = min; ps <= parser->ps; ps++)
136 PerlIO_printf(Perl_debug_log, " %8.8s", ps->name);
137
9388183f 138 PerlIO_printf(Perl_debug_log, "\nvalue:");
1654d593
DM
139 for (ps = min; ps <= parser->ps; ps++) {
140 switch (yy_type_tab[yystos[ps->state]]) {
d5c6462e 141 case toketype_opval:
21612876 142 PerlIO_printf(Perl_debug_log, " %8.8s",
1654d593
DM
143 ps->val.opval
144 ? PL_op_name[ps->val.opval->op_type]
670f3923 145 : "(Nullop)"
21612876 146 );
d5c6462e 147 break;
d5c6462e 148 case toketype_ival:
147e3846 149 PerlIO_printf(Perl_debug_log, " %8" IVdf, (IV)ps->val.ival);
d5c6462e
DM
150 break;
151 default:
147e3846 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. */
f39ff1f3
DM
177#if PERL_BISON_VERSION >= 30000 /* 3.0+ */
178 for (yyi = 0; yyi < yyr2[yyrule]; yyi++)
179 YYFPRINTF (Perl_debug_log, "%s ",
180 yytname [yystos[(PL_parser->ps)[yyi + 1 - yyr2[yyrule]].state]]);
181#else
0de566d7
DM
182 for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
183 YYFPRINTF (Perl_debug_log, "%s ", yytname [yyrhs[yyi]]);
f39ff1f3 184#endif
0de566d7
DM
185 YYFPRINTF (Perl_debug_log, "-> %s\n", yytname [yyr1[yyrule]]);
186}
187
188# define YY_REDUCE_PRINT(Rule) \
189do { \
190 if (yydebug) \
191 yy_reduce_print (aTHX_ Rule); \
192} while (0)
193
194#else /* !DEBUGGING */
195# define YYDPRINTF(Args)
9388183f 196# define YYDSYMPRINTF(Title, Token, Value)
1654d593 197# define YY_STACK_PRINT(parser)
0de566d7
DM
198# define YY_REDUCE_PRINT(Rule)
199#endif /* !DEBUGGING */
200
718a7425
DM
201/* called during cleanup (via SAVEDESTRUCTOR_X) to free any items on the
202 * parse stack, thus avoiding leaks if we die */
203
204static void
22735491 205S_clear_yystack(pTHX_ const yy_parser *parser)
718a7425 206{
1654d593 207 yy_stack_frame *ps = parser->ps;
0934c9d9 208 int i = 0;
718a7425 209
28ac2b49 210 if (!parser->stack)
718a7425 211 return;
1654d593 212
718a7425 213 YYDPRINTF ((Perl_debug_log, "clearing the parse stack\n"));
670f3923 214
8c63ea58
GG
215 for (i=0; i< parser->yylen; i++) {
216 SvREFCNT_dec(ps[-i].compcv);
217 }
0aded6e1 218 ps -= parser->yylen;
670f3923
DM
219
220 /* now free whole the stack, including the just-reduced ops */
221
22735491 222 while (ps > parser->stack) {
503de470 223 LEAVE_SCOPE(ps->savestack_ix);
1654d593
DM
224 if (yy_type_tab[yystos[ps->state]] == toketype_opval
225 && ps->val.opval)
670f3923 226 {
a293d0fd 227 if (ps->compcv && (ps->compcv != PL_compcv)) {
8c63ea58
GG
228 PL_compcv = ps->compcv;
229 PAD_SET_CUR_NOSAVE(CvPADLIST(PL_compcv), 1);
325e1816 230 PL_comppad_name = PadlistNAMES(CvPADLIST(PL_compcv));
718a7425
DM
231 }
232 YYDPRINTF ((Perl_debug_log, "(freeing op)\n"));
571a568a 233 op_free(ps->val.opval);
718a7425 234 }
8c63ea58 235 SvREFCNT_dec(ps->compcv);
1654d593 236 ps--;
718a7425 237 }
28ac2b49
Z
238
239 Safefree(parser->stack);
718a7425
DM
240}
241
718a7425 242
0de566d7
DM
243/*----------.
244| yyparse. |
245`----------*/
246
79072805 247int
28ac2b49 248Perl_yyparse (pTHX_ int gramtype)
79072805 249{
d3d9da4a 250 dVAR;
eb578fdb
KW
251 int yystate;
252 int yyn;
0de566d7
DM
253 int yyresult;
254
0de566d7 255 /* Lookahead token as an internal (translated) token number. */
714c8e96 256 int yytoken = 0;
0de566d7 257
eb578fdb
KW
258 yy_parser *parser; /* the parser object */
259 yy_stack_frame *ps; /* current parser stack frame */
a0d0e21e 260
1654d593
DM
261#define YYPOPSTACK parser->ps = --ps
262#define YYPUSHSTACK parser->ps = ++ps
0de566d7 263
acdf0a21 264 /* The variable used to return semantic value and location from the
5912531f 265 action routines: ie $$. */
0de566d7
DM
266 YYSTYPE yyval;
267
0de566d7
DM
268 YYDPRINTF ((Perl_debug_log, "Starting parse\n"));
269
acdf0a21 270 parser = PL_parser;
1654d593 271
28ac2b49
Z
272 ENTER; /* force parser state cleanup/restoration before we return */
273 SAVEPPTR(parser->yylval.pval);
274 SAVEINT(parser->yychar);
275 SAVEINT(parser->yyerrstatus);
28ac2b49
Z
276 SAVEINT(parser->yylen);
277 SAVEVPTR(parser->stack);
0e0707c5 278 SAVEVPTR(parser->stack_max1);
28ac2b49
Z
279 SAVEVPTR(parser->ps);
280
281 /* initialise state for this parse */
282 parser->yychar = gramtype;
283 parser->yyerrstatus = 0;
28ac2b49
Z
284 parser->yylen = 0;
285 Newx(parser->stack, YYINITDEPTH, yy_stack_frame);
0e0707c5 286 parser->stack_max1 = parser->stack + YYINITDEPTH - 1;
28ac2b49
Z
287 ps = parser->ps = parser->stack;
288 ps->state = 0;
e3abe207 289 SAVEDESTRUCTOR_X(S_clear_yystack, parser);
0de566d7 290
0de566d7
DM
291/*------------------------------------------------------------.
292| yynewstate -- Push a new state, which is found in yystate. |
293`------------------------------------------------------------*/
294 yynewstate:
0de566d7 295
1654d593 296 yystate = ps->state;
05a03161 297
670f3923 298 YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate));
0de566d7 299
5912531f 300 parser->yylen = 0;
0de566d7 301
1654d593 302 {
1654d593 303 /* grow the stack? We always leave 1 spare slot,
0e0707c5
DM
304 * in case of a '' -> 'foo' reduction.
305 * Note that stack_max1 points to the (top-1)th allocated stack
306 * element to make this check fast */
0de566d7 307
0e0707c5
DM
308 if (ps >= parser->stack_max1) {
309 Size_t pos = ps - parser->stack;
310 Size_t newsize = 2 * (parser->stack_max1 + 2 - parser->stack);
1654d593 311 /* this will croak on insufficient memory */
0e0707c5
DM
312 Renew(parser->stack, newsize, yy_stack_frame);
313 ps = parser->ps = parser->stack + pos;
314 parser->stack_max1 = parser->stack + newsize - 1;
670f3923 315
1654d593
DM
316 YYDPRINTF((Perl_debug_log,
317 "parser stack size increased to %lu frames\n",
0e0707c5 318 (unsigned long int)newsize));
1654d593 319 }
93a17b20 320 }
0de566d7 321
0de566d7
DM
322/* Do appropriate processing given the current state. */
323/* Read a lookahead token if we need one and don't already have one. */
0de566d7
DM
324
325 /* First try to decide what to do without reference to lookahead token. */
326
327 yyn = yypact[yystate];
328 if (yyn == YYPACT_NINF)
329 goto yydefault;
330
331 /* Not known => get a lookahead token if don't already have one. */
332
333 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
5912531f 334 if (parser->yychar == YYEMPTY) {
37b6dcb8 335 YYDPRINTF ((Perl_debug_log, "Reading a token:\n"));
5912531f 336 parser->yychar = yylex();
0de566d7
DM
337 }
338
5912531f
DM
339 if (parser->yychar <= YYEOF) {
340 parser->yychar = yytoken = YYEOF;
0de566d7 341 YYDPRINTF ((Perl_debug_log, "Now at end of input.\n"));
93a17b20 342 }
0de566d7 343 else {
100b2bb8
KW
344 /* perly.tab is shipped based on an ASCII system, so need to index it
345 * with characters translated to ASCII. Although it's not designed for
346 * this purpose, we can use NATIVE_TO_UNI here. It returns its
347 * argument on ASCII platforms, and on EBCDIC translates native to
348 * ascii in the 0-255 range, leaving everything else unchanged. This
349 * jibes with yylex() returning some bare characters in that range, but
350 * all tokens it returns are either 0, or above 255. There could be a
351 * problem if NULs weren't 0, or were ever returned as raw chars by
352 * yylex() */
353 yytoken = YYTRANSLATE (NATIVE_TO_UNI(parser->yychar));
5912531f 354 YYDSYMPRINTF ("Next token is", yytoken, &parser->yylval);
93a17b20 355 }
771df094 356
0de566d7 357 /* If the proper action on seeing token YYTOKEN is to reduce or to
73f23431
DM
358 * detect an error, take that action.
359 * Casting yyn to unsigned allows a >=0 test to be included as
360 * part of the <=YYLAST test for speed */
0de566d7 361 yyn += yytoken;
73f23431 362 if ((unsigned int)yyn > YYLAST || yycheck[yyn] != yytoken)
0de566d7
DM
363 goto yydefault;
364 yyn = yytable[yyn];
365 if (yyn <= 0) {
366 if (yyn == 0 || yyn == YYTABLE_NINF)
367 goto yyerrlab;
368 yyn = -yyn;
369 goto yyreduce;
370 }
7b57b0ea 371
0de566d7
DM
372 if (yyn == YYFINAL)
373 YYACCEPT;
771df094 374
0de566d7
DM
375 /* Shift the lookahead token. */
376 YYDPRINTF ((Perl_debug_log, "Shifting token %s, ", yytname[yytoken]));
377
378 /* Discard the token being shifted unless it is eof. */
5912531f
DM
379 if (parser->yychar != YYEOF)
380 parser->yychar = YYEMPTY;
0de566d7 381
1654d593
DM
382 YYPUSHSTACK;
383 ps->state = yyn;
5912531f 384 ps->val = parser->yylval;
ec8ec19f 385 ps->compcv = (CV*)SvREFCNT_inc(PL_compcv);
503de470 386 ps->savestack_ix = PL_savestack_ix;
9388183f 387#ifdef DEBUGGING
1654d593 388 ps->name = (const char *)(yytname[yytoken]);
9388183f 389#endif
0de566d7 390
0de566d7
DM
391 /* Count tokens shifted since error; after three, turn off error
392 status. */
5912531f
DM
393 if (parser->yyerrstatus)
394 parser->yyerrstatus--;
0de566d7 395
0de566d7
DM
396 goto yynewstate;
397
398
399 /*-----------------------------------------------------------.
400 | yydefault -- do the default action for the current state. |
401 `-----------------------------------------------------------*/
402 yydefault:
403 yyn = yydefact[yystate];
404 if (yyn == 0)
405 goto yyerrlab;
406 goto yyreduce;
407
408
409 /*-----------------------------.
410 | yyreduce -- Do a reduction. |
411 `-----------------------------*/
412 yyreduce:
413 /* yyn is the number of a rule to reduce with. */
5912531f 414 parser->yylen = yyr2[yyn];
0de566d7
DM
415
416 /* If YYLEN is nonzero, implement the default value of the action:
a0288114 417 "$$ = $1".
0de566d7
DM
418
419 Otherwise, the following line sets YYVAL to garbage.
420 This behavior is undocumented and Bison
421 users should not rely upon it. Assigning to YYVAL
422 unconditionally makes the parser a bit smaller, and it avoids a
423 GCC warning that YYVAL may be used uninitialized. */
5912531f 424 yyval = ps[1-parser->yylen].val;
0de566d7 425
1654d593 426 YY_STACK_PRINT(parser);
0de566d7 427 YY_REDUCE_PRINT (yyn);
718a7425 428
0de566d7
DM
429 switch (yyn) {
430
f05e27e5
DM
431/* contains all the rule actions; auto-generated from perly.y */
432#include "perly.act"
433
93a17b20 434 }
0de566d7 435
670f3923
DM
436 {
437 int i;
5912531f 438 for (i=0; i< parser->yylen; i++) {
8c63ea58 439 SvREFCNT_dec(ps[-i].compcv);
670f3923
DM
440 }
441 }
442
5912531f 443 parser->ps = ps -= (parser->yylen-1);
0de566d7 444
05a03161
DM
445 /* Now shift the result of the reduction. Determine what state
446 that goes to, based on the state we popped back to and the rule
447 number reduced by. */
448
1654d593 449 ps->val = yyval;
ec8ec19f 450 ps->compcv = (CV*)SvREFCNT_inc(PL_compcv);
503de470 451 ps->savestack_ix = PL_savestack_ix;
9388183f 452#ifdef DEBUGGING
1654d593 453 ps->name = (const char *)(yytname [yyr1[yyn]]);
9388183f 454#endif
0de566d7
DM
455
456 yyn = yyr1[yyn];
457
1654d593
DM
458 yystate = yypgoto[yyn - YYNTOKENS] + ps[-1].state;
459 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == ps[-1].state)
0de566d7 460 yystate = yytable[yystate];
93a17b20 461 else
0de566d7 462 yystate = yydefgoto[yyn - YYNTOKENS];
1654d593 463 ps->state = yystate;
05a03161 464
0de566d7
DM
465 goto yynewstate;
466
467
468 /*------------------------------------.
469 | yyerrlab -- here on detecting error |
470 `------------------------------------*/
471 yyerrlab:
472 /* If not already recovering from an error, report this error. */
5912531f 473 if (!parser->yyerrstatus) {
07a06489 474 yyerror ("syntax error");
93a17b20 475 }
0de566d7
DM
476
477
5912531f 478 if (parser->yyerrstatus == 3) {
0de566d7
DM
479 /* If just tried and failed to reuse lookahead token after an
480 error, discard it. */
481
482 /* Return failure if at end of input. */
5912531f 483 if (parser->yychar == YYEOF) {
0de566d7 484 /* Pop the error token. */
8c63ea58 485 SvREFCNT_dec(ps->compcv);
0de566d7
DM
486 YYPOPSTACK;
487 /* Pop the rest of the stack. */
22735491 488 while (ps > parser->stack) {
1654d593 489 YYDSYMPRINTF ("Error: popping", yystos[ps->state], &ps->val);
503de470 490 LEAVE_SCOPE(ps->savestack_ix);
1654d593
DM
491 if (yy_type_tab[yystos[ps->state]] == toketype_opval
492 && ps->val.opval)
670f3923 493 {
0539ab63 494 YYDPRINTF ((Perl_debug_log, "(freeing op)\n"));
8c63ea58
GG
495 if (ps->compcv != PL_compcv) {
496 PL_compcv = ps->compcv;
497 PAD_SET_CUR_NOSAVE(CvPADLIST(PL_compcv), 1);
718a7425 498 }
1654d593 499 op_free(ps->val.opval);
0539ab63 500 }
8c63ea58 501 SvREFCNT_dec(ps->compcv);
0de566d7
DM
502 YYPOPSTACK;
503 }
504 YYABORT;
505 }
506
5912531f
DM
507 YYDSYMPRINTF ("Error: discarding", yytoken, &parser->yylval);
508 parser->yychar = YYEMPTY;
0de566d7 509
93a17b20 510 }
0de566d7
DM
511
512 /* Else will try to reuse lookahead token after shifting the error
513 token. */
514 goto yyerrlab1;
515
516
517 /*----------------------------------------------------.
518 | yyerrlab1 -- error raised explicitly by an action. |
519 `----------------------------------------------------*/
520 yyerrlab1:
5912531f 521 parser->yyerrstatus = 3; /* Each real token shifted decrements this. */
0de566d7
DM
522
523 for (;;) {
524 yyn = yypact[yystate];
525 if (yyn != YYPACT_NINF) {
526 yyn += YYTERROR;
527 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) {
528 yyn = yytable[yyn];
529 if (0 < yyn)
530 break;
531 }
532 }
533
534 /* Pop the current state because it cannot handle the error token. */
22735491 535 if (ps == parser->stack)
0de566d7
DM
536 YYABORT;
537
1654d593 538 YYDSYMPRINTF ("Error: popping", yystos[ps->state], &ps->val);
503de470 539 LEAVE_SCOPE(ps->savestack_ix);
1654d593 540 if (yy_type_tab[yystos[ps->state]] == toketype_opval && ps->val.opval) {
0539ab63 541 YYDPRINTF ((Perl_debug_log, "(freeing op)\n"));
8c63ea58
GG
542 if (ps->compcv != PL_compcv) {
543 PL_compcv = ps->compcv;
544 PAD_SET_CUR_NOSAVE(CvPADLIST(PL_compcv), 1);
718a7425 545 }
1654d593 546 op_free(ps->val.opval);
0539ab63 547 }
8c63ea58 548 SvREFCNT_dec(ps->compcv);
1654d593
DM
549 YYPOPSTACK;
550 yystate = ps->state;
0de566d7 551
1654d593 552 YY_STACK_PRINT(parser);
93a17b20 553 }
0de566d7
DM
554
555 if (yyn == YYFINAL)
556 YYACCEPT;
557
558 YYDPRINTF ((Perl_debug_log, "Shifting error token, "));
559
1654d593
DM
560 YYPUSHSTACK;
561 ps->state = yyn;
5912531f 562 ps->val = parser->yylval;
ec8ec19f 563 ps->compcv = (CV*)SvREFCNT_inc(PL_compcv);
503de470 564 ps->savestack_ix = PL_savestack_ix;
9388183f 565#ifdef DEBUGGING
1654d593 566 ps->name ="<err>";
9388183f 567#endif
0de566d7 568
0de566d7
DM
569 goto yynewstate;
570
571
572 /*-------------------------------------.
573 | yyacceptlab -- YYACCEPT comes here. |
574 `-------------------------------------*/
575 yyacceptlab:
576 yyresult = 0;
8c63ea58
GG
577 for (ps=parser->ps; ps > parser->stack; ps--) {
578 SvREFCNT_dec(ps->compcv);
579 }
22735491 580 parser->ps = parser->stack; /* disable cleanup */
0de566d7
DM
581 goto yyreturn;
582
583 /*-----------------------------------.
584 | yyabortlab -- YYABORT comes here. |
585 `-----------------------------------*/
586 yyabortlab:
587 yyresult = 1;
588 goto yyreturn;
589
0de566d7 590 yyreturn:
e3abe207 591 LEAVE; /* force parser stack cleanup before we return */
0de566d7 592 return yyresult;
e1f15930 593}
66610fdd
RGS
594
595/*
14d04a33 596 * ex: set ts=8 sts=4 sw=4 et:
37442d52 597 */