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.
29 /* allow stack size to grow effectively without limit */
30 #define YYMAXDEPTH 10000000
33 #define PERL_IN_PERLY_C
36 typedef unsigned char yytype_uint8;
37 typedef signed char yytype_int8;
38 typedef unsigned short int yytype_uint16;
39 typedef short int yytype_int16;
40 typedef signed char yysigned_char;
48 /* contains all the parser state tables; auto-generated from perly.y */
51 # define YYSIZE_T size_t
53 #define yyerrok (yyerrstatus = 0)
54 #define yyclearin (yychar = YYEMPTY)
58 #define YYACCEPT goto yyacceptlab
59 #define YYABORT goto yyabortlab
60 #define YYERROR goto yyerrlab1
63 /* Like YYERROR except do call yyerror. This remains here temporarily
64 to ease the transition to the new meaning of YYERROR, for GCC.
65 Once GCC version 2 has supplanted version 1, this can go. */
67 #define YYFAIL goto yyerrlab
69 #define YYRECOVERING() (!!yyerrstatus)
71 #define YYBACKUP(Token, Value) \
73 if (yychar == YYEMPTY && yylen == 1) { \
76 yytoken = YYTRANSLATE (yychar); \
81 yyerror ("syntax error: cannot back up"); \
89 /* Enable debugging if requested. */
92 # define yydebug (DEBUG_p_TEST)
94 # define YYFPRINTF PerlIO_printf
96 # define YYDPRINTF(Args) \
102 # define YYDSYMPRINTF(Title, Token, Value) \
105 YYFPRINTF (Perl_debug_log, "%s ", Title); \
106 yysymprint (aTHX_ Perl_debug_log, Token, Value); \
107 YYFPRINTF (Perl_debug_log, "\n"); \
111 /*--------------------------------.
112 | Print this symbol on YYOUTPUT. |
113 `--------------------------------*/
116 yysymprint(pTHX_ PerlIO * const yyoutput, int yytype, const YYSTYPE * const yyvaluep)
118 if (yytype < YYNTOKENS) {
119 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
121 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
123 YYFPRINTF (yyoutput, "0x%"UVxf, (UV)yyvaluep->ival);
127 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
129 YYFPRINTF (yyoutput, ")");
134 * print the top 8 items on the parse stack. The args have the same
135 * meanings as the local vars in yyparse() of the same name */
138 yy_stack_print (pTHX_ const short *yyss, const short *yyssp, const YYSTYPE *yyvs, const char**yyns)
142 int count = (int)(yyssp - yyss);
145 start = count - 8 + 1;
149 PerlIO_printf(Perl_debug_log, "\nindex:");
150 for (i=0; i < count; i++)
151 PerlIO_printf(Perl_debug_log, " %8d", start+i);
152 PerlIO_printf(Perl_debug_log, "\nstate:");
153 for (i=0; i < count; i++)
154 PerlIO_printf(Perl_debug_log, " %8d", yyss[start+i]);
155 PerlIO_printf(Perl_debug_log, "\ntoken:");
156 for (i=0; i < count; i++)
157 PerlIO_printf(Perl_debug_log, " %8.8s", yyns[start+i]);
158 PerlIO_printf(Perl_debug_log, "\nvalue:");
159 for (i=0; i < count; i++) {
160 if (yy_is_opval[yystos[yyss[start+i]]]) {
161 PerlIO_printf(Perl_debug_log, " %8.8s",
163 ? PL_op_name[yyvs[start+i].opval->op_type]
168 PerlIO_printf(Perl_debug_log, " %8"UVxf, (UV)yyvs[start+i].ival);
170 PerlIO_printf(Perl_debug_log, "\n\n");
173 # define YY_STACK_PRINT(yyss, yyssp, yyvs, yyns) \
175 if (yydebug && DEBUG_v_TEST) \
176 yy_stack_print (aTHX_ (yyss), (yyssp), (yyvs), (yyns)); \
180 /*------------------------------------------------.
181 | Report that the YYRULE is going to be reduced. |
182 `------------------------------------------------*/
185 yy_reduce_print (pTHX_ int yyrule)
188 const unsigned int yylineno = yyrline[yyrule];
189 YYFPRINTF (Perl_debug_log, "Reducing stack by rule %d (line %u), ",
190 yyrule - 1, yylineno);
191 /* Print the symbols being reduced, and their result. */
192 for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
193 YYFPRINTF (Perl_debug_log, "%s ", yytname [yyrhs[yyi]]);
194 YYFPRINTF (Perl_debug_log, "-> %s\n", yytname [yyr1[yyrule]]);
197 # define YY_REDUCE_PRINT(Rule) \
200 yy_reduce_print (aTHX_ Rule); \
203 #else /* !DEBUGGING */
204 # define YYDPRINTF(Args)
205 # define YYDSYMPRINTF(Title, Token, Value)
206 # define YY_STACK_PRINT(yyss, yyssp, yyvs, yyns)
207 # define YY_REDUCE_PRINT(Rule)
208 #endif /* !DEBUGGING */
211 /* YYINITDEPTH -- initial size of the parser's stacks. */
213 # define YYINITDEPTH 200
219 # if defined (__GLIBC__) && defined (_STRING_H)
220 # define yystrlen strlen
222 /* Return the length of YYSTR. */
224 yystrlen (const char *yystr)
226 register const char *yys = yystr;
228 while (*yys++ != '\0')
231 return yys - yystr - 1;
237 # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
238 # define yystpcpy stpcpy
240 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
243 yystpcpy (pTHX_ char *yydest, const char *yysrc)
245 register char *yyd = yydest;
246 register const char *yys = yysrc;
248 while ((*yyd++ = *yys++) != '\0')
256 #endif /* !YYERROR_VERBOSE */
263 #ifdef PERL_IN_MADLY_C
270 int yychar; /* The lookahead symbol. */
271 YYSTYPE yylval; /* The semantic value of the lookahead symbol. */
272 int yynerrs; /* Number of syntax errors so far. */
273 register int yystate;
277 /* Number of tokens to shift before error messages enabled. */
279 /* Lookahead token as an internal (translated) token number. */
282 /* two stacks and their tools:
283 yyss: related to states,
284 yyvs: related to semantic values,
286 Refer to the stacks thru separate pointers, to allow yyoverflow
287 to reallocate them elsewhere. */
289 /* The state stack. */
291 register short *yyssp;
293 /* The semantic value stack. */
295 register YYSTYPE *yyvsp;
297 /* for ease of re-allocation and automatic freeing, have two SVs whose
298 * SvPVX points to the stacks */
299 SV *yyss_sv, *yyvs_sv;
302 /* maintain also a stack of token/rule names for debugging with -Dpv */
303 const char **yyns, **yynsp;
305 # define YYPOPSTACK (yyvsp--, yyssp--, yynsp--)
307 # define YYPOPSTACK (yyvsp--, yyssp--)
311 YYSIZE_T yystacksize = YYINITDEPTH;
313 /* The variables used to return semantic value and location from the
318 /* When reducing, the number of symbols on the RHS of the reduced
322 #ifndef PERL_IN_MADLY_C
329 YYDPRINTF ((Perl_debug_log, "Starting parse\n"));
331 ENTER; /* force stack free before we return */
332 SAVEVPTR(PL_yycharp);
333 SAVEVPTR(PL_yylvalp);
334 PL_yycharp = &yychar; /* so PL_yyerror() can access it */
335 PL_yylvalp = &yylval; /* so various functions in toke.c can access it */
337 yyss_sv = newSV(YYINITDEPTH * sizeof(short));
338 yyvs_sv = newSV(YYINITDEPTH * sizeof(YYSTYPE));
341 yyss = (short *) SvPVX(yyss_sv);
342 yyvs = (YYSTYPE *) SvPVX(yyvs_sv);
343 /* note that elements zero of yyvs and yyns are not used */
347 yyns_sv = newSV(YYINITDEPTH * sizeof(char *));
349 /* XXX This seems strange to cast char * to char ** */
350 yyns = (const char **) SvPVX(yyns_sv);
357 yychar = YYEMPTY; /* Cause a token to be read. */
359 YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate));
363 /*------------------------------------------------------------.
364 | yynewstate -- Push a new state, which is found in yystate. |
365 `------------------------------------------------------------*/
367 /* In all cases, when you get here, the value and location stacks
368 have just been pushed. so pushing a state here evens the stacks.
375 if (yyss + yystacksize - 1 <= yyssp) {
376 /* Get the current used size of the three stacks, in elements. */
377 const YYSIZE_T yysize = yyssp - yyss + 1;
379 /* Extend the stack our own way. */
380 if (YYMAXDEPTH <= yystacksize)
383 if (YYMAXDEPTH < yystacksize)
384 yystacksize = YYMAXDEPTH;
386 SvGROW(yyss_sv, yystacksize * sizeof(short));
387 SvGROW(yyvs_sv, yystacksize * sizeof(YYSTYPE));
388 yyss = (short *) SvPVX(yyss_sv);
389 yyvs = (YYSTYPE *) SvPVX(yyvs_sv);
391 SvGROW(yyns_sv, yystacksize * sizeof(char *));
392 /* XXX This seems strange to cast char * to char ** */
393 yyns = (const char **) SvPVX(yyns_sv);
396 yynsp = yyns + yysize - 1;
401 yyssp = yyss + yysize - 1;
402 yyvsp = yyvs + yysize - 1;
405 YYDPRINTF ((Perl_debug_log, "Stack size increased to %lu\n",
406 (unsigned long int) yystacksize));
408 if (yyss + yystacksize - 1 <= yyssp)
419 /* Do appropriate processing given the current state. */
420 /* Read a lookahead token if we need one and don't already have one. */
423 /* First try to decide what to do without reference to lookahead token. */
425 yyn = yypact[yystate];
426 if (yyn == YYPACT_NINF)
429 /* Not known => get a lookahead token if don't already have one. */
431 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
432 if (yychar == YYEMPTY) {
433 YYDPRINTF ((Perl_debug_log, "Reading a token: "));
434 #ifdef PERL_IN_MADLY_C
435 yychar = PL_madskills ? madlex() : yylex();
441 if (yychar >= 0 && yychar < 255) {
442 yychar = NATIVE_TO_ASCII(yychar);
447 if (yychar <= YYEOF) {
448 yychar = yytoken = YYEOF;
449 YYDPRINTF ((Perl_debug_log, "Now at end of input.\n"));
452 yytoken = YYTRANSLATE (yychar);
453 YYDSYMPRINTF ("Next token is", yytoken, &yylval);
456 /* If the proper action on seeing token YYTOKEN is to reduce or to
457 detect an error, take that action. */
459 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
463 if (yyn == 0 || yyn == YYTABLE_NINF)
472 /* Shift the lookahead token. */
473 YYDPRINTF ((Perl_debug_log, "Shifting token %s, ", yytname[yytoken]));
475 /* Discard the token being shifted unless it is eof. */
481 *++yynsp = (const char *)(yytname[yytoken]);
485 /* Count tokens shifted since error; after three, turn off error
491 YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate));
496 /*-----------------------------------------------------------.
497 | yydefault -- do the default action for the current state. |
498 `-----------------------------------------------------------*/
500 yyn = yydefact[yystate];
506 /*-----------------------------.
507 | yyreduce -- Do a reduction. |
508 `-----------------------------*/
510 /* yyn is the number of a rule to reduce with. */
513 /* If YYLEN is nonzero, implement the default value of the action:
516 Otherwise, the following line sets YYVAL to garbage.
517 This behavior is undocumented and Bison
518 users should not rely upon it. Assigning to YYVAL
519 unconditionally makes the parser a bit smaller, and it avoids a
520 GCC warning that YYVAL may be used uninitialized. */
521 yyval = yyvsp[1-yylen];
524 YY_REDUCE_PRINT (yyn);
528 #define dep() deprecate("\"do\" to call subroutines")
530 #ifdef PERL_IN_MADLY_C
531 # define IVAL(i) (i)->tk_lval.ival
532 # define PVAL(p) (p)->tk_lval.pval
533 # define TOKEN_GETMAD(a,b,c) token_getmad((a),(b),(c))
534 # define TOKEN_FREE(a) token_free(a)
535 # define OP_GETMAD(a,b,c) op_getmad((a),(b),(c))
536 # define IF_MAD(a,b) (a)
542 # define TOKEN_GETMAD(a,b,c)
543 # define TOKEN_FREE(a)
544 # define OP_GETMAD(a,b,c)
545 # define IF_MAD(a,b) (b)
550 /* contains all the rule actions; auto-generated from perly.y */
564 *++yynsp = (const char *)(yytname [yyr1[yyn]]);
567 /* Now shift the result of the reduction. Determine what state
568 that goes to, based on the state we popped back to and the rule
569 number reduced by. */
573 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
574 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
575 yystate = yytable[yystate];
577 yystate = yydefgoto[yyn - YYNTOKENS];
579 YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate));
582 /* tmp push yystate for stack print; this is normally pushed later in
586 YY_STACK_PRINT (yyss, yyssp, yyvs, yyns);
593 /*------------------------------------.
594 | yyerrlab -- here on detecting error |
595 `------------------------------------*/
597 /* If not already recovering from an error, report this error. */
601 yyn = yypact[yystate];
603 if (YYPACT_NINF < yyn && yyn < YYLAST) {
605 const int yytype = YYTRANSLATE (yychar);
610 /* Start YYX at -YYN if negative to avoid negative indexes in
612 for (yyx = yyn < 0 ? -yyn : 0;
613 yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
614 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
615 yysize += yystrlen (yytname[yyx]) + 15, yycount++;
616 yysize += yystrlen ("syntax error, unexpected ") + 1;
617 yysize += yystrlen (yytname[yytype]);
618 Newx(yymsg, yysize, char *);
620 const char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
621 yyp = yystpcpy (yyp, yytname[yytype]);
625 for (yyx = yyn < 0 ? -yyn : 0;
626 yyx < (int) (sizeof (yytname) / sizeof (char *));
629 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) {
630 const char *yyq = ! yycount ?
631 ", expecting " : " or ";
632 yyp = yystpcpy (yyp, yyq);
633 yyp = yystpcpy (yyp, yytname[yyx]);
639 YYSTACK_FREE (yymsg);
642 yyerror ("syntax error; also virtual memory exhausted");
645 #endif /* YYERROR_VERBOSE */
646 yyerror ("syntax error");
650 if (yyerrstatus == 3) {
651 /* If just tried and failed to reuse lookahead token after an
652 error, discard it. */
654 /* Return failure if at end of input. */
655 if (yychar == YYEOF) {
656 /* Pop the error token. */
658 /* Pop the rest of the stack. */
659 while (yyss < yyssp) {
660 YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp);
661 if (yy_is_opval[yystos[*yyssp]]) {
662 YYDPRINTF ((Perl_debug_log, "(freeing op)\n"));
663 op_free(yyvsp->opval);
670 YYDSYMPRINTF ("Error: discarding", yytoken, &yylval);
675 /* Else will try to reuse lookahead token after shifting the error
680 /*----------------------------------------------------.
681 | yyerrlab1 -- error raised explicitly by an action. |
682 `----------------------------------------------------*/
684 yyerrstatus = 3; /* Each real token shifted decrements this. */
687 yyn = yypact[yystate];
688 if (yyn != YYPACT_NINF) {
690 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) {
697 /* Pop the current state because it cannot handle the error token. */
701 YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp);
702 if (yy_is_opval[yystos[*yyssp]]) {
703 YYDPRINTF ((Perl_debug_log, "(freeing op)\n"));
704 op_free(yyvsp->opval);
712 YY_STACK_PRINT (yyss, yyssp, yyvs, yyns);
718 YYDPRINTF ((Perl_debug_log, "Shifting error token, "));
726 YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate));
731 /*-------------------------------------.
732 | yyacceptlab -- YYACCEPT comes here. |
733 `-------------------------------------*/
738 /*-----------------------------------.
739 | yyabortlab -- YYABORT comes here. |
740 `-----------------------------------*/
745 /*----------------------------------------------.
746 | yyoverflowlab -- parser overflow comes here. |
747 `----------------------------------------------*/
749 yyerror ("parser stack overflow");
755 LEAVE; /* force stack free before we return */
762 * c-indentation-style: bsd
764 * indent-tabs-mode: t
767 * ex: set ts=8 sts=4 sw=4 noet: