3 * Copyright (c) 2004, 2005, 2006 Larry Wall and others
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.
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.
13 * Here is an important copyright statement from the original, generated
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.
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.
28 #define PERL_IN_PERLY_C
31 typedef unsigned char yytype_uint8;
32 typedef signed char yytype_int8;
33 typedef unsigned short int yytype_uint16;
34 typedef short int yytype_int16;
35 typedef signed char yysigned_char;
43 /* contains all the parser state tables; auto-generated from perly.y */
46 # define YYSIZE_T size_t
51 #define YYACCEPT goto yyacceptlab
52 #define YYABORT goto yyabortlab
53 #define YYERROR goto yyerrlab1
55 /* Enable debugging if requested. */
58 # define yydebug (DEBUG_p_TEST)
60 # define YYFPRINTF PerlIO_printf
62 # define YYDPRINTF(Args) \
68 # define YYDSYMPRINTF(Title, Token, Value) \
71 YYFPRINTF (Perl_debug_log, "%s ", Title); \
72 yysymprint (aTHX_ Perl_debug_log, Token, Value); \
73 YYFPRINTF (Perl_debug_log, "\n"); \
77 /*--------------------------------.
78 | Print this symbol on YYOUTPUT. |
79 `--------------------------------*/
82 yysymprint(pTHX_ PerlIO * const yyoutput, int yytype, const YYSTYPE * const yyvaluep)
84 if (yytype < YYNTOKENS) {
85 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
87 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
89 YYFPRINTF (yyoutput, "0x%"UVxf, (UV)yyvaluep->ival);
93 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
95 YYFPRINTF (yyoutput, ")");
100 * print the top 8 items on the parse stack.
104 yy_stack_print (pTHX_ const yy_parser *parser)
106 const yy_stack_frame *ps, *min;
108 min = parser->ps - 8 + 1;
109 if (min <= parser->stack)
110 min = parser->stack + 1;
112 PerlIO_printf(Perl_debug_log, "\nindex:");
113 for (ps = min; ps <= parser->ps; ps++)
114 PerlIO_printf(Perl_debug_log, " %8d", ps - parser->stack);
116 PerlIO_printf(Perl_debug_log, "\nstate:");
117 for (ps = min; ps <= parser->ps; ps++)
118 PerlIO_printf(Perl_debug_log, " %8d", ps->state);
120 PerlIO_printf(Perl_debug_log, "\ntoken:");
121 for (ps = min; ps <= parser->ps; ps++)
122 PerlIO_printf(Perl_debug_log, " %8.8s", ps->name);
124 PerlIO_printf(Perl_debug_log, "\nvalue:");
125 for (ps = min; ps <= parser->ps; ps++) {
126 switch (yy_type_tab[yystos[ps->state]]) {
128 PerlIO_printf(Perl_debug_log, " %8.8s",
130 ? PL_op_name[ps->val.opval->op_type]
134 #ifndef PERL_IN_MADLY_C
135 case toketype_p_tkval:
136 PerlIO_printf(Perl_debug_log, " %8.8s",
137 ps->val.pval ? ps->val.pval : "(NULL)");
140 case toketype_i_tkval:
143 PerlIO_printf(Perl_debug_log, " %8"IVdf, (IV)ps->val.ival);
146 PerlIO_printf(Perl_debug_log, " %8"UVxf, (UV)ps->val.ival);
149 PerlIO_printf(Perl_debug_log, "\n\n");
152 # define YY_STACK_PRINT(parser) \
154 if (yydebug && DEBUG_v_TEST) \
155 yy_stack_print (aTHX_ parser); \
159 /*------------------------------------------------.
160 | Report that the YYRULE is going to be reduced. |
161 `------------------------------------------------*/
164 yy_reduce_print (pTHX_ int yyrule)
167 const unsigned int yylineno = yyrline[yyrule];
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]]);
176 # define YY_REDUCE_PRINT(Rule) \
179 yy_reduce_print (aTHX_ Rule); \
182 #else /* !DEBUGGING */
183 # define YYDPRINTF(Args)
184 # define YYDSYMPRINTF(Title, Token, Value)
185 # define YY_STACK_PRINT(parser)
186 # define YY_REDUCE_PRINT(Rule)
187 #endif /* !DEBUGGING */
189 /* called during cleanup (via SAVEDESTRUCTOR_X) to free any items on the
190 * parse stack, thus avoiding leaks if we die */
193 S_clear_yystack(pTHX_ const yy_parser *parser)
195 yy_stack_frame *ps = parser->ps;
198 if (!parser->stack || ps == parser->stack)
201 YYDPRINTF ((Perl_debug_log, "clearing the parse stack\n"));
203 /* Freeing ops on the stack, and the op_latefree / op_latefreed /
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
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
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
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
214 * right place for freeing any SVs attached to the op in threaded
217 * However, there is a particular problem if we die in newFOO() called
218 * by a reducing action; e.g.
221 * { $$ = newFOO($1,$2,$3) }
224 * OP *newFOO { ....; if (...) croak; .... }
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:
230 * * attached them to part of a larger tree
231 * * attached them to PL_compcv
232 * * attached them to PL_compcv then freed it (as in BEGIN {die } )
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
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.
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.
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:
259 * but this would involve reworking all code (core and external) that
260 * manipulate op trees.
263 /* clear any reducing ops (1st pass) */
265 for (i=0; i< parser->yylen; i++) {
266 if (yy_type_tab[yystos[ps[-i].state]] == toketype_opval
267 && ps[-i].val.opval) {
268 if ( ! (ps[-i].val.opval->op_attached
269 && !ps[-i].val.opval->op_latefreed))
271 if (ps[-i].comppad != PL_comppad) {
272 PAD_RESTORE_LOCAL(ps[-i].comppad);
274 op_free(ps[-i].val.opval);
279 /* now free whole the stack, including the just-reduced ops */
281 while (ps > parser->stack) {
282 if (yy_type_tab[yystos[ps->state]] == toketype_opval
285 if (ps->comppad != PL_comppad) {
286 PAD_RESTORE_LOCAL(ps->comppad);
288 YYDPRINTF ((Perl_debug_log, "(freeing op)\n"));
289 ps->val.opval->op_latefree = 0;
290 if (!(ps->val.opval->op_attached && !ps->val.opval->op_latefreed))
291 op_free(ps->val.opval);
297 /* delete a parser object */
300 Perl_parser_free(pTHX_ const yy_parser *parser)
302 S_clear_yystack(aTHX_ parser);
303 Safefree(parser->stack);
304 PL_parser = parser->old_parser;
313 #ifdef PERL_IN_MADLY_C
320 register int yystate;
324 /* Lookahead token as an internal (translated) token number. */
327 register yy_parser *parser; /* the parser object */
328 register yy_stack_frame *ps; /* current parser stack frame */
330 #define YYPOPSTACK parser->ps = --ps
331 #define YYPUSHSTACK parser->ps = ++ps
333 /* The variable used to return semantic value and location from the
334 action routines: ie $$. */
337 #ifndef PERL_IN_MADLY_C
344 YYDPRINTF ((Perl_debug_log, "Starting parse\n"));
349 ENTER; /* force parser free before we return */
350 SAVEDESTRUCTOR_X(Perl_parser_free, (void*) parser);
352 /*------------------------------------------------------------.
353 | yynewstate -- Push a new state, which is found in yystate. |
354 `------------------------------------------------------------*/
359 YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate));
361 if (yy_type_tab[yystos[yystate]] == toketype_opval && ps->val.opval) {
362 ps->val.opval->op_latefree = 1;
363 ps->val.opval->op_latefreed = 0;
369 size_t size = ps - parser->stack + 1;
371 /* grow the stack? We always leave 1 spare slot,
372 * in case of a '' -> 'foo' reduction */
374 if (size >= parser->stack_size - 1) {
375 /* this will croak on insufficient memory */
376 parser->stack_size *= 2;
377 Renew(parser->stack, parser->stack_size, yy_stack_frame);
378 ps = parser->ps = parser->stack + size -1;
380 YYDPRINTF((Perl_debug_log,
381 "parser stack size increased to %lu frames\n",
382 (unsigned long int)parser->stack_size));
386 /* Do appropriate processing given the current state. */
387 /* Read a lookahead token if we need one and don't already have one. */
389 /* First try to decide what to do without reference to lookahead token. */
391 yyn = yypact[yystate];
392 if (yyn == YYPACT_NINF)
395 /* Not known => get a lookahead token if don't already have one. */
397 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
398 if (parser->yychar == YYEMPTY) {
399 YYDPRINTF ((Perl_debug_log, "Reading a token: "));
400 #ifdef PERL_IN_MADLY_C
401 parser->yychar = PL_madskills ? madlex() : yylex();
403 parser->yychar = yylex();
407 if (parser->yychar >= 0 && parser->yychar < 255) {
408 parser->yychar = NATIVE_TO_ASCII(parser->yychar);
413 if (parser->yychar <= YYEOF) {
414 parser->yychar = yytoken = YYEOF;
415 YYDPRINTF ((Perl_debug_log, "Now at end of input.\n"));
418 yytoken = YYTRANSLATE (parser->yychar);
419 YYDSYMPRINTF ("Next token is", yytoken, &parser->yylval);
422 /* If the proper action on seeing token YYTOKEN is to reduce or to
423 detect an error, take that action. */
425 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
429 if (yyn == 0 || yyn == YYTABLE_NINF)
438 /* Shift the lookahead token. */
439 YYDPRINTF ((Perl_debug_log, "Shifting token %s, ", yytname[yytoken]));
441 /* Discard the token being shifted unless it is eof. */
442 if (parser->yychar != YYEOF)
443 parser->yychar = YYEMPTY;
447 ps->val = parser->yylval;
448 ps->comppad = PL_comppad;
450 ps->name = (const char *)(yytname[yytoken]);
453 /* Count tokens shifted since error; after three, turn off error
455 if (parser->yyerrstatus)
456 parser->yyerrstatus--;
461 /*-----------------------------------------------------------.
462 | yydefault -- do the default action for the current state. |
463 `-----------------------------------------------------------*/
465 yyn = yydefact[yystate];
471 /*-----------------------------.
472 | yyreduce -- Do a reduction. |
473 `-----------------------------*/
475 /* yyn is the number of a rule to reduce with. */
476 parser->yylen = yyr2[yyn];
478 /* If YYLEN is nonzero, implement the default value of the action:
481 Otherwise, the following line sets YYVAL to garbage.
482 This behavior is undocumented and Bison
483 users should not rely upon it. Assigning to YYVAL
484 unconditionally makes the parser a bit smaller, and it avoids a
485 GCC warning that YYVAL may be used uninitialized. */
486 yyval = ps[1-parser->yylen].val;
488 YY_STACK_PRINT(parser);
489 YY_REDUCE_PRINT (yyn);
494 #define dep() deprecate("\"do\" to call subroutines")
496 #ifdef PERL_IN_MADLY_C
497 # define IVAL(i) (i)->tk_lval.ival
498 # define PVAL(p) (p)->tk_lval.pval
499 # define TOKEN_GETMAD(a,b,c) token_getmad((a),(b),(c))
500 # define TOKEN_FREE(a) token_free(a)
501 # define OP_GETMAD(a,b,c) op_getmad((a),(b),(c))
502 # define IF_MAD(a,b) (a)
508 # define TOKEN_GETMAD(a,b,c)
509 # define TOKEN_FREE(a)
510 # define OP_GETMAD(a,b,c)
511 # define IF_MAD(a,b) (b)
516 /* contains all the rule actions; auto-generated from perly.y */
521 /* any just-reduced ops with the op_latefreed flag cleared need to be
522 * freed; the rest need the flag resetting */
525 for (i=0; i< parser->yylen; i++) {
526 if (yy_type_tab[yystos[ps[-i].state]] == toketype_opval
529 ps[-i].val.opval->op_latefree = 0;
530 if (ps[-i].val.opval->op_latefreed)
531 op_free(ps[-i].val.opval);
536 parser->ps = ps -= (parser->yylen-1);
538 /* Now shift the result of the reduction. Determine what state
539 that goes to, based on the state we popped back to and the rule
540 number reduced by. */
543 ps->comppad = PL_comppad;
545 ps->name = (const char *)(yytname [yyr1[yyn]]);
550 yystate = yypgoto[yyn - YYNTOKENS] + ps[-1].state;
551 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == ps[-1].state)
552 yystate = yytable[yystate];
554 yystate = yydefgoto[yyn - YYNTOKENS];
560 /*------------------------------------.
561 | yyerrlab -- here on detecting error |
562 `------------------------------------*/
564 /* If not already recovering from an error, report this error. */
565 if (!parser->yyerrstatus) {
566 yyerror ("syntax error");
570 if (parser->yyerrstatus == 3) {
571 /* If just tried and failed to reuse lookahead token after an
572 error, discard it. */
574 /* Return failure if at end of input. */
575 if (parser->yychar == YYEOF) {
576 /* Pop the error token. */
578 /* Pop the rest of the stack. */
579 while (ps > parser->stack) {
580 YYDSYMPRINTF ("Error: popping", yystos[ps->state], &ps->val);
581 if (yy_type_tab[yystos[ps->state]] == toketype_opval
584 YYDPRINTF ((Perl_debug_log, "(freeing op)\n"));
585 if (ps->comppad != PL_comppad) {
586 PAD_RESTORE_LOCAL(ps->comppad);
588 ps->val.opval->op_latefree = 0;
589 op_free(ps->val.opval);
596 YYDSYMPRINTF ("Error: discarding", yytoken, &parser->yylval);
597 parser->yychar = YYEMPTY;
601 /* Else will try to reuse lookahead token after shifting the error
606 /*----------------------------------------------------.
607 | yyerrlab1 -- error raised explicitly by an action. |
608 `----------------------------------------------------*/
610 parser->yyerrstatus = 3; /* Each real token shifted decrements this. */
613 yyn = yypact[yystate];
614 if (yyn != YYPACT_NINF) {
616 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) {
623 /* Pop the current state because it cannot handle the error token. */
624 if (ps == parser->stack)
627 YYDSYMPRINTF ("Error: popping", yystos[ps->state], &ps->val);
628 if (yy_type_tab[yystos[ps->state]] == toketype_opval && ps->val.opval) {
629 YYDPRINTF ((Perl_debug_log, "(freeing op)\n"));
630 if (ps->comppad != PL_comppad) {
631 PAD_RESTORE_LOCAL(ps->comppad);
633 ps->val.opval->op_latefree = 0;
634 op_free(ps->val.opval);
639 YY_STACK_PRINT(parser);
645 YYDPRINTF ((Perl_debug_log, "Shifting error token, "));
649 ps->val = parser->yylval;
650 ps->comppad = PL_comppad;
658 /*-------------------------------------.
659 | yyacceptlab -- YYACCEPT comes here. |
660 `-------------------------------------*/
663 parser->ps = parser->stack; /* disable cleanup */
666 /*-----------------------------------.
667 | yyabortlab -- YYABORT comes here. |
668 `-----------------------------------*/
674 LEAVE; /* force parser free before we return */
680 * c-indentation-style: bsd
682 * indent-tabs-mode: t
685 * ex: set ts=8 sts=4 sw=4 noet: