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
52 #define YYACCEPT goto yyacceptlab
53 #define YYABORT goto yyabortlab
54 #define YYERROR goto yyerrlab1
56 /* Enable debugging if requested. */
59 # define yydebug (DEBUG_p_TEST)
61 # define YYFPRINTF PerlIO_printf
63 # define YYDPRINTF(Args) \
69 # define YYDSYMPRINTF(Title, Token, Value) \
72 YYFPRINTF (Perl_debug_log, "%s ", Title); \
73 yysymprint (aTHX_ Perl_debug_log, Token, Value); \
74 YYFPRINTF (Perl_debug_log, "\n"); \
78 /*--------------------------------.
79 | Print this symbol on YYOUTPUT. |
80 `--------------------------------*/
83 yysymprint(pTHX_ PerlIO * const yyoutput, int yytype, const YYSTYPE * const yyvaluep)
85 if (yytype < YYNTOKENS) {
86 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
88 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
90 YYFPRINTF (yyoutput, "0x%"UVxf, (UV)yyvaluep->ival);
94 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
96 YYFPRINTF (yyoutput, ")");
101 * print the top 8 items on the parse stack.
105 yy_stack_print (pTHX_ const yy_parser *parser)
107 const yy_stack_frame *ps, *min;
109 min = parser->ps - 8;
110 if (min <= &parser->stack[0])
111 min = &parser->stack[0] + 1;
113 PerlIO_printf(Perl_debug_log, "\nindex:");
114 for (ps = min; ps <= parser->ps; ps++)
115 PerlIO_printf(Perl_debug_log, " %8d", ps - &parser->stack[0]);
117 PerlIO_printf(Perl_debug_log, "\nstate:");
118 for (ps = min; ps <= parser->ps; ps++)
119 PerlIO_printf(Perl_debug_log, " %8d", ps->state);
121 PerlIO_printf(Perl_debug_log, "\ntoken:");
122 for (ps = min; ps <= parser->ps; ps++)
123 PerlIO_printf(Perl_debug_log, " %8.8s", ps->name);
125 PerlIO_printf(Perl_debug_log, "\nvalue:");
126 for (ps = min; ps <= parser->ps; ps++) {
127 switch (yy_type_tab[yystos[ps->state]]) {
129 PerlIO_printf(Perl_debug_log, " %8.8s",
131 ? PL_op_name[ps->val.opval->op_type]
135 #ifndef PERL_IN_MADLY_C
136 case toketype_p_tkval:
137 PerlIO_printf(Perl_debug_log, " %8.8s",
138 ps->val.pval ? ps->val.pval : "(NULL)");
141 case toketype_i_tkval:
144 PerlIO_printf(Perl_debug_log, " %8"IVdf, (IV)ps->val.ival);
147 PerlIO_printf(Perl_debug_log, " %8"UVxf, (UV)ps->val.ival);
150 PerlIO_printf(Perl_debug_log, "\n\n");
153 # define YY_STACK_PRINT(parser) \
155 if (yydebug && DEBUG_v_TEST) \
156 yy_stack_print (aTHX_ parser); \
160 /*------------------------------------------------.
161 | Report that the YYRULE is going to be reduced. |
162 `------------------------------------------------*/
165 yy_reduce_print (pTHX_ int yyrule)
168 const unsigned int yylineno = yyrline[yyrule];
169 YYFPRINTF (Perl_debug_log, "Reducing stack by rule %d (line %u), ",
170 yyrule - 1, yylineno);
171 /* Print the symbols being reduced, and their result. */
172 for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
173 YYFPRINTF (Perl_debug_log, "%s ", yytname [yyrhs[yyi]]);
174 YYFPRINTF (Perl_debug_log, "-> %s\n", yytname [yyr1[yyrule]]);
177 # define YY_REDUCE_PRINT(Rule) \
180 yy_reduce_print (aTHX_ Rule); \
183 #else /* !DEBUGGING */
184 # define YYDPRINTF(Args)
185 # define YYDSYMPRINTF(Title, Token, Value)
186 # define YY_STACK_PRINT(parser)
187 # define YY_REDUCE_PRINT(Rule)
188 #endif /* !DEBUGGING */
191 /* YYINITDEPTH -- initial size of the parser's stacks. */
192 #define YYINITDEPTH 200
194 /* called during cleanup (via SAVEDESTRUCTOR_X) to free any items on the
195 * parse stack, thus avoiding leaks if we die */
198 S_clear_yystack(pTHX_ const void *p)
200 yy_parser *parser = (yy_parser*) SvPVX((SV*)p);
201 yy_stack_frame *ps = parser->ps;
204 if (ps == &parser->stack[0])
207 YYDPRINTF ((Perl_debug_log, "clearing the parse stack\n"));
209 /* Freeing ops on the stack, and the op_latefree/op_latefreed flags:
211 * When we pop tokens off the stack during error recovery, or when
212 * we pop all the tokens off the stack after a die during a shift or
213 * reduce (ie Perl_croak somewhere in yylex(), or in one of the
214 * newFOO() functions, then its possible that some of these tokens are
215 * of type opval, pointing to an OP. All these ops are orphans; each is
216 * its own miniature subtree that has not yet been attached to a
217 * larger tree. In this case, we shoould clearly free the op (making
218 * sure, for each op we free thyat we have PL_comppad pointing to the
219 * right place for freeing any SVs attached to the op in threaded
222 * However, there is a particular problem if we die in newFOO called
223 * by a reducing action; e.g.
226 * { $$ = newFOO($1,$2,$3) }
229 * OP *newFOO { .... croak .... }
231 * In this case, when we come to clean bar baz and boz off the stack,
232 * we don't know whether newFOO() has already:
235 * * attached them to part of a larger tree
237 * To get round this problem, we set the flag op_latefree on every op
238 * that gets pushed onto the parser stack. If op_free() sees this
239 * flag, it clears the op and frees any children,, but *doesn't* free
240 * the op itself; instead it sets the op_latefreed flag. This means
241 * that we can safely call op_free() multiple times on each stack op.
242 * So, when clearing the stack, we first, for each op that was being
243 * reduced, call op_free with op_latefree=1. This ensures that all ops
244 * hanging off these op are freed, but the reducing ops themselces are
245 * just undefed. Then we set op_latefreed=0 on *all* ops on the stack
246 * and free them. A little though should convince you that this
247 * two-part approach to the reducing ops should handle all three cases
251 /* free any reducing ops (1st pass) */
253 for (i=0; i< parser->yylen; i++) {
254 if (yy_type_tab[yystos[ps[-i].state]] == toketype_opval
255 && ps[-i].val.opval) {
256 if (ps[-i].comppad != PL_comppad) {
257 PAD_RESTORE_LOCAL(ps[-i].comppad);
259 op_free(ps[-i].val.opval);
263 /* now free whole the stack, including the just-reduced ops */
265 while (ps > &parser->stack[0]) {
266 if (yy_type_tab[yystos[ps->state]] == toketype_opval
269 if (ps->comppad != PL_comppad) {
270 PAD_RESTORE_LOCAL(ps->comppad);
272 YYDPRINTF ((Perl_debug_log, "(freeing op)\n"));
273 ps->val.opval->op_latefree = 0;
274 op_free(ps->val.opval);
287 #ifdef PERL_IN_MADLY_C
294 register int yystate;
298 /* Lookahead token as an internal (translated) token number. */
301 SV *parser_sv; /* SV whose PVX holds the parser object */
302 register yy_parser *parser; /* the parser object */
303 register yy_stack_frame *ps; /* current parser stack frame */
305 #define YYPOPSTACK parser->ps = --ps
306 #define YYPUSHSTACK parser->ps = ++ps
308 /* The variables used to return semantic value and location from the
309 action routines: ie $$. */
312 #ifndef PERL_IN_MADLY_C
319 YYDPRINTF ((Perl_debug_log, "Starting parse\n"));
321 ENTER; /* force stack free before we return */
324 parser_sv = newSV(sizeof(yy_parser)
325 + (YYINITDEPTH-1) * sizeof(yy_stack_frame));
326 SAVEFREESV(parser_sv);
327 PL_parser = parser = (yy_parser*) SvPVX(parser_sv);
328 ps = (yy_stack_frame*) &parser->stack[0];
331 parser->stack_size = YYINITDEPTH;
333 /* cleanup the parse stack on premature exit */
334 SAVEDESTRUCTOR_X(S_clear_yystack, (void*) parser_sv);
338 parser->yyerrstatus = 0;
339 parser->yychar = YYEMPTY; /* Cause a token to be read. */
341 /*------------------------------------------------------------.
342 | yynewstate -- Push a new state, which is found in yystate. |
343 `------------------------------------------------------------*/
348 YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate));
350 if (yy_type_tab[yystos[yystate]] == toketype_opval && ps->val.opval) {
351 ps->val.opval->op_latefree = 1;
352 ps->val.opval->op_latefreed = 0;
358 size_t size = ps - &parser->stack[0] + 1;
360 /* grow the stack? We always leave 1 spare slot,
361 * in case of a '' -> 'foo' reduction */
363 if (size >= parser->stack_size - 1) {
364 /* this will croak on insufficient memory */
365 parser->stack_size *= 2;
367 (yy_parser*) SvGROW(parser_sv, sizeof(yy_parser)
368 + (parser->stack_size-1) * sizeof(yy_stack_frame));
370 /* readdress any pointers into realloced parser object */
371 ps = parser->ps = &parser->stack[0] + size -1;
373 YYDPRINTF((Perl_debug_log,
374 "parser stack size increased to %lu frames\n",
375 (unsigned long int)parser->stack_size));
379 /* Do appropriate processing given the current state. */
380 /* Read a lookahead token if we need one and don't already have one. */
382 /* First try to decide what to do without reference to lookahead token. */
384 yyn = yypact[yystate];
385 if (yyn == YYPACT_NINF)
388 /* Not known => get a lookahead token if don't already have one. */
390 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
391 if (parser->yychar == YYEMPTY) {
392 YYDPRINTF ((Perl_debug_log, "Reading a token: "));
393 #ifdef PERL_IN_MADLY_C
394 parser->yychar = PL_madskills ? madlex() : yylex();
396 parser->yychar = yylex();
400 if (parser->yychar >= 0 && parser->yychar < 255) {
401 parser->yychar = NATIVE_TO_ASCII(parser->yychar);
406 if (parser->yychar <= YYEOF) {
407 parser->yychar = yytoken = YYEOF;
408 YYDPRINTF ((Perl_debug_log, "Now at end of input.\n"));
411 yytoken = YYTRANSLATE (parser->yychar);
412 YYDSYMPRINTF ("Next token is", yytoken, &parser->yylval);
415 /* If the proper action on seeing token YYTOKEN is to reduce or to
416 detect an error, take that action. */
418 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
422 if (yyn == 0 || yyn == YYTABLE_NINF)
431 /* Shift the lookahead token. */
432 YYDPRINTF ((Perl_debug_log, "Shifting token %s, ", yytname[yytoken]));
434 /* Discard the token being shifted unless it is eof. */
435 if (parser->yychar != YYEOF)
436 parser->yychar = YYEMPTY;
440 ps->val = parser->yylval;
441 ps->comppad = PL_comppad;
443 ps->name = (const char *)(yytname[yytoken]);
446 /* Count tokens shifted since error; after three, turn off error
448 if (parser->yyerrstatus)
449 parser->yyerrstatus--;
454 /*-----------------------------------------------------------.
455 | yydefault -- do the default action for the current state. |
456 `-----------------------------------------------------------*/
458 yyn = yydefact[yystate];
464 /*-----------------------------.
465 | yyreduce -- Do a reduction. |
466 `-----------------------------*/
468 /* yyn is the number of a rule to reduce with. */
469 parser->yylen = yyr2[yyn];
471 /* If YYLEN is nonzero, implement the default value of the action:
474 Otherwise, the following line sets YYVAL to garbage.
475 This behavior is undocumented and Bison
476 users should not rely upon it. Assigning to YYVAL
477 unconditionally makes the parser a bit smaller, and it avoids a
478 GCC warning that YYVAL may be used uninitialized. */
479 yyval = ps[1-parser->yylen].val;
481 YY_STACK_PRINT(parser);
482 YY_REDUCE_PRINT (yyn);
487 #define dep() deprecate("\"do\" to call subroutines")
489 #ifdef PERL_IN_MADLY_C
490 # define IVAL(i) (i)->tk_lval.ival
491 # define PVAL(p) (p)->tk_lval.pval
492 # define TOKEN_GETMAD(a,b,c) token_getmad((a),(b),(c))
493 # define TOKEN_FREE(a) token_free(a)
494 # define OP_GETMAD(a,b,c) op_getmad((a),(b),(c))
495 # define IF_MAD(a,b) (a)
501 # define TOKEN_GETMAD(a,b,c)
502 # define TOKEN_FREE(a)
503 # define OP_GETMAD(a,b,c)
504 # define IF_MAD(a,b) (b)
509 /* contains all the rule actions; auto-generated from perly.y */
514 /* any just-reduced ops with the op_latefreed flag cleared need to be
515 * freed; the rest need the flag resetting */
518 for (i=0; i< parser->yylen; i++) {
519 if (yy_type_tab[yystos[ps[-i].state]] == toketype_opval
522 ps[-i].val.opval->op_latefree = 0;
523 if (ps[-i].val.opval->op_latefreed)
524 op_free(ps[-i].val.opval);
529 parser->ps = ps -= (parser->yylen-1);
531 /* Now shift the result of the reduction. Determine what state
532 that goes to, based on the state we popped back to and the rule
533 number reduced by. */
536 ps->comppad = PL_comppad;
538 ps->name = (const char *)(yytname [yyr1[yyn]]);
543 yystate = yypgoto[yyn - YYNTOKENS] + ps[-1].state;
544 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == ps[-1].state)
545 yystate = yytable[yystate];
547 yystate = yydefgoto[yyn - YYNTOKENS];
553 /*------------------------------------.
554 | yyerrlab -- here on detecting error |
555 `------------------------------------*/
557 /* If not already recovering from an error, report this error. */
558 if (!parser->yyerrstatus) {
559 yyerror ("syntax error");
563 if (parser->yyerrstatus == 3) {
564 /* If just tried and failed to reuse lookahead token after an
565 error, discard it. */
567 /* Return failure if at end of input. */
568 if (parser->yychar == YYEOF) {
569 /* Pop the error token. */
571 /* Pop the rest of the stack. */
572 while (ps > &parser->stack[0]) {
573 YYDSYMPRINTF ("Error: popping", yystos[ps->state], &ps->val);
574 if (yy_type_tab[yystos[ps->state]] == toketype_opval
577 YYDPRINTF ((Perl_debug_log, "(freeing op)\n"));
578 if (ps->comppad != PL_comppad) {
579 PAD_RESTORE_LOCAL(ps->comppad);
581 ps->val.opval->op_latefree = 0;
582 op_free(ps->val.opval);
589 YYDSYMPRINTF ("Error: discarding", yytoken, &parser->yylval);
590 parser->yychar = YYEMPTY;
594 /* Else will try to reuse lookahead token after shifting the error
599 /*----------------------------------------------------.
600 | yyerrlab1 -- error raised explicitly by an action. |
601 `----------------------------------------------------*/
603 parser->yyerrstatus = 3; /* Each real token shifted decrements this. */
606 yyn = yypact[yystate];
607 if (yyn != YYPACT_NINF) {
609 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) {
616 /* Pop the current state because it cannot handle the error token. */
617 if (ps == &parser->stack[0])
620 YYDSYMPRINTF ("Error: popping", yystos[ps->state], &ps->val);
621 if (yy_type_tab[yystos[ps->state]] == toketype_opval && ps->val.opval) {
622 YYDPRINTF ((Perl_debug_log, "(freeing op)\n"));
623 if (ps->comppad != PL_comppad) {
624 PAD_RESTORE_LOCAL(ps->comppad);
626 ps->val.opval->op_latefree = 0;
627 op_free(ps->val.opval);
632 YY_STACK_PRINT(parser);
638 YYDPRINTF ((Perl_debug_log, "Shifting error token, "));
642 ps->val = parser->yylval;
643 ps->comppad = PL_comppad;
651 /*-------------------------------------.
652 | yyacceptlab -- YYACCEPT comes here. |
653 `-------------------------------------*/
656 parser->ps = &parser->stack[0]; /* disable cleanup */
659 /*-----------------------------------.
660 | yyabortlab -- YYABORT comes here. |
661 `-----------------------------------*/
667 LEAVE; /* force stack free before we return */
673 * c-indentation-style: bsd
675 * indent-tabs-mode: t
678 * ex: set ts=8 sts=4 sw=4 noet: