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 switch (yy_type_tab[yystos[yyss[start+i]]]) {
162 PerlIO_printf(Perl_debug_log, " %8.8s",
164 ? PL_op_name[yyvs[start+i].opval->op_type]
168 #ifndef PERL_IN_MADLY_C
169 case toketype_p_tkval:
170 PerlIO_printf(Perl_debug_log, " %8.8s",
171 yyvs[start+i].pval ? yyvs[start+i].pval : "(NULL)");
174 case toketype_i_tkval:
177 PerlIO_printf(Perl_debug_log, " %8"IVdf, yyvs[start+i].ival);
180 PerlIO_printf(Perl_debug_log, " %8"UVxf, (UV)yyvs[start+i].ival);
183 PerlIO_printf(Perl_debug_log, "\n\n");
186 # define YY_STACK_PRINT(yyss, yyssp, yyvs, yyns) \
188 if (yydebug && DEBUG_v_TEST) \
189 yy_stack_print (aTHX_ (yyss), (yyssp), (yyvs), (yyns)); \
193 /*------------------------------------------------.
194 | Report that the YYRULE is going to be reduced. |
195 `------------------------------------------------*/
198 yy_reduce_print (pTHX_ int yyrule)
201 const unsigned int yylineno = yyrline[yyrule];
202 YYFPRINTF (Perl_debug_log, "Reducing stack by rule %d (line %u), ",
203 yyrule - 1, yylineno);
204 /* Print the symbols being reduced, and their result. */
205 for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
206 YYFPRINTF (Perl_debug_log, "%s ", yytname [yyrhs[yyi]]);
207 YYFPRINTF (Perl_debug_log, "-> %s\n", yytname [yyr1[yyrule]]);
210 # define YY_REDUCE_PRINT(Rule) \
213 yy_reduce_print (aTHX_ Rule); \
216 #else /* !DEBUGGING */
217 # define YYDPRINTF(Args)
218 # define YYDSYMPRINTF(Title, Token, Value)
219 # define YY_STACK_PRINT(yyss, yyssp, yyvs, yyns)
220 # define YY_REDUCE_PRINT(Rule)
221 #endif /* !DEBUGGING */
224 /* YYINITDEPTH -- initial size of the parser's stacks. */
226 # define YYINITDEPTH 200
232 # if defined (__GLIBC__) && defined (_STRING_H)
233 # define yystrlen strlen
235 /* Return the length of YYSTR. */
237 yystrlen (const char *yystr)
239 register const char *yys = yystr;
241 while (*yys++ != '\0')
244 return yys - yystr - 1;
250 # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
251 # define yystpcpy stpcpy
253 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
256 yystpcpy (pTHX_ char *yydest, const char *yysrc)
258 register char *yyd = yydest;
259 register const char *yys = yysrc;
261 while ((*yyd++ = *yys++) != '\0')
269 #endif /* !YYERROR_VERBOSE */
272 /* a snapshot of the current stack position variables for use by
283 /* called during cleanup (via SAVEDESTRUCTOR_X) to free any items on the
284 * parse stack, thus avoiding leaks if we die */
287 S_clear_yystack(pTHX_ const void *p)
289 yystack_positions *y = (yystack_positions*) p;
293 YYDPRINTF ((Perl_debug_log, "clearing the parse stack\n"));
294 y->yyvsp -= y->yylen; /* ignore the tokens that have just been reduced */
295 y->yyssp -= y->yylen;
296 y->yypsp -= y->yylen;
297 while (y->yyssp > y->yyss) {
298 if (yy_type_tab[yystos[*y->yyssp]] == toketype_opval) {
299 if (*y->yypsp != PL_comppad) {
300 PAD_RESTORE_LOCAL(*y->yypsp);
302 YYDPRINTF ((Perl_debug_log, "(freeing op)\n"));
303 op_free(y->yyvsp->opval);
318 #ifdef PERL_IN_MADLY_C
325 int yychar; /* The lookahead symbol. */
326 YYSTYPE yylval; /* The semantic value of the lookahead symbol. */
327 int yynerrs; /* Number of syntax errors so far. */
328 register int yystate;
332 /* Number of tokens to shift before error messages enabled. */
334 /* Lookahead token as an internal (translated) token number. */
337 /* three stacks and their tools:
338 yyss: related to states,
339 yyvs: related to semantic values,
340 yyps: current value of PL_comppad for each state
343 Refer to the stacks thru separate pointers, to allow yyoverflow
344 to reallocate them elsewhere. */
346 /* The state stack. */
348 register short *yyssp;
350 /* The semantic value stack. */
352 register YYSTYPE *yyvsp;
357 /* for ease of re-allocation and automatic freeing, have three SVs whose
358 * SvPVX points to the stacks */
359 SV *yyss_sv, *yyvs_sv, *yyps_sv;
361 yystack_positions *ss_save;
365 /* maintain also a stack of token/rule names for debugging with -Dpv */
366 const char **yyns, **yynsp;
368 # define YYPOPSTACK (yyvsp--, yyssp--, yypsp--, yynsp--)
370 # define YYPOPSTACK (yyvsp--, yyssp--, yypsp--)
374 YYSIZE_T yystacksize = YYINITDEPTH;
376 /* The variables used to return semantic value and location from the
381 /* When reducing, the number of symbols on the RHS of the reduced
385 #ifndef PERL_IN_MADLY_C
392 YYDPRINTF ((Perl_debug_log, "Starting parse\n"));
394 ENTER; /* force stack free before we return */
395 SAVEVPTR(PL_yycharp);
396 SAVEVPTR(PL_yylvalp);
397 PL_yycharp = &yychar; /* so PL_yyerror() can access it */
398 PL_yylvalp = &yylval; /* so various functions in toke.c can access it */
400 yyss_sv = newSV(YYINITDEPTH * sizeof(short));
401 yyvs_sv = newSV(YYINITDEPTH * sizeof(YYSTYPE));
402 yyps_sv = newSV(YYINITDEPTH * sizeof(AV*));
403 ss_save_sv = newSV(sizeof(yystack_positions));
407 SAVEFREESV(ss_save_sv);
408 yyss = (short *) SvPVX(yyss_sv);
409 yyvs = (YYSTYPE *) SvPVX(yyvs_sv);
410 yyps = (AV **) SvPVX(yyps_sv);
411 ss_save = (yystack_positions *) SvPVX(ss_save_sv);
413 ss_save->yyss = NULL; /* disarm stack cleanup */
414 /* cleanup the parse stack on premature exit */
415 SAVEDESTRUCTOR_X(S_clear_yystack, (void*) ss_save);
417 /* note that elements zero of yyvs and yyns are not used */
422 yyns_sv = newSV(YYINITDEPTH * sizeof(char *));
424 /* XXX This seems strange to cast char * to char ** */
425 yyns = (const char **) SvPVX(yyns_sv);
432 yychar = YYEMPTY; /* Cause a token to be read. */
434 YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate));
438 /*------------------------------------------------------------.
439 | yynewstate -- Push a new state, which is found in yystate. |
440 `------------------------------------------------------------*/
442 /* In all cases, when you get here, the value and location stacks
443 have just been pushed. so pushing a state here evens the stacks.
450 if (yyss + yystacksize - 1 <= yyssp) {
451 /* Get the current used size of the three stacks, in elements. */
452 const YYSIZE_T yysize = yyssp - yyss + 1;
454 /* Extend the stack our own way. */
455 if (YYMAXDEPTH <= yystacksize)
458 if (YYMAXDEPTH < yystacksize)
459 yystacksize = YYMAXDEPTH;
461 SvGROW(yyss_sv, yystacksize * sizeof(short));
462 SvGROW(yyvs_sv, yystacksize * sizeof(YYSTYPE));
463 SvGROW(yyps_sv, yystacksize * sizeof(AV*));
464 yyss = (short *) SvPVX(yyss_sv);
465 yyvs = (YYSTYPE *) SvPVX(yyvs_sv);
466 yyps = (AV **) SvPVX(yyps_sv);
468 SvGROW(yyns_sv, yystacksize * sizeof(char *));
469 /* XXX This seems strange to cast char * to char ** */
470 yyns = (const char **) SvPVX(yyns_sv);
473 yynsp = yyns + yysize - 1;
475 if (!yyss || ! yyvs || ! yyps)
478 yyssp = yyss + yysize - 1;
479 yyvsp = yyvs + yysize - 1;
480 yypsp = yyps + yysize - 1;
483 YYDPRINTF ((Perl_debug_log, "Stack size increased to %lu\n",
484 (unsigned long int) yystacksize));
486 if (yyss + yystacksize - 1 <= yyssp)
497 /* Do appropriate processing given the current state. */
498 /* Read a lookahead token if we need one and don't already have one. */
501 /* First try to decide what to do without reference to lookahead token. */
503 yyn = yypact[yystate];
504 if (yyn == YYPACT_NINF)
507 /* Not known => get a lookahead token if don't already have one. */
509 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
510 if (yychar == YYEMPTY) {
511 YYDPRINTF ((Perl_debug_log, "Reading a token: "));
512 #ifdef PERL_IN_MADLY_C
513 yychar = PL_madskills ? madlex() : yylex();
519 if (yychar >= 0 && yychar < 255) {
520 yychar = NATIVE_TO_ASCII(yychar);
525 if (yychar <= YYEOF) {
526 yychar = yytoken = YYEOF;
527 YYDPRINTF ((Perl_debug_log, "Now at end of input.\n"));
530 yytoken = YYTRANSLATE (yychar);
531 YYDSYMPRINTF ("Next token is", yytoken, &yylval);
534 /* If the proper action on seeing token YYTOKEN is to reduce or to
535 detect an error, take that action. */
537 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
541 if (yyn == 0 || yyn == YYTABLE_NINF)
550 /* Shift the lookahead token. */
551 YYDPRINTF ((Perl_debug_log, "Shifting token %s, ", yytname[yytoken]));
553 /* Discard the token being shifted unless it is eof. */
558 *++yypsp = PL_comppad;
560 *++yynsp = (const char *)(yytname[yytoken]);
564 /* Count tokens shifted since error; after three, turn off error
570 YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate));
575 /*-----------------------------------------------------------.
576 | yydefault -- do the default action for the current state. |
577 `-----------------------------------------------------------*/
579 yyn = yydefact[yystate];
585 /*-----------------------------.
586 | yyreduce -- Do a reduction. |
587 `-----------------------------*/
589 /* yyn is the number of a rule to reduce with. */
592 /* If YYLEN is nonzero, implement the default value of the action:
595 Otherwise, the following line sets YYVAL to garbage.
596 This behavior is undocumented and Bison
597 users should not rely upon it. Assigning to YYVAL
598 unconditionally makes the parser a bit smaller, and it avoids a
599 GCC warning that YYVAL may be used uninitialized. */
600 yyval = yyvsp[1-yylen];
603 YY_REDUCE_PRINT (yyn);
605 /* running external code may trigger a die (eg 'use nosuchmodule'):
606 * record the current stack state so that an unwind will
607 * free all the pesky OPs lounging around on the parse stack */
608 ss_save->yyss = yyss;
609 ss_save->yyssp = yyssp;
610 ss_save->yyvsp = yyvsp;
611 ss_save->yypsp = yypsp;
612 ss_save->yylen = yylen;
617 #define dep() deprecate("\"do\" to call subroutines")
619 #ifdef PERL_IN_MADLY_C
620 # define IVAL(i) (i)->tk_lval.ival
621 # define PVAL(p) (p)->tk_lval.pval
622 # define TOKEN_GETMAD(a,b,c) token_getmad((a),(b),(c))
623 # define TOKEN_FREE(a) token_free(a)
624 # define OP_GETMAD(a,b,c) op_getmad((a),(b),(c))
625 # define IF_MAD(a,b) (a)
631 # define TOKEN_GETMAD(a,b,c)
632 # define TOKEN_FREE(a)
633 # define OP_GETMAD(a,b,c)
634 # define IF_MAD(a,b) (b)
639 /* contains all the rule actions; auto-generated from perly.y */
653 *++yypsp = PL_comppad;
656 *++yynsp = (const char *)(yytname [yyr1[yyn]]);
659 /* Now shift the result of the reduction. Determine what state
660 that goes to, based on the state we popped back to and the rule
661 number reduced by. */
665 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
666 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
667 yystate = yytable[yystate];
669 yystate = yydefgoto[yyn - YYNTOKENS];
671 YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate));
674 /* tmp push yystate for stack print; this is normally pushed later in
678 YY_STACK_PRINT (yyss, yyssp, yyvs, yyns);
679 if (yydebug && DEBUG_v_TEST)
684 int count = (int)(yyssp - yyss);
687 start = count - 8 + 1;
691 PerlIO_printf(Perl_debug_log, "cppad:");
692 for (i=0; i < count; i++)
693 PerlIO_printf(Perl_debug_log, " %8p", yyps[start+i]);
694 PerlIO_printf(Perl_debug_log, "\n");
702 /*------------------------------------.
703 | yyerrlab -- here on detecting error |
704 `------------------------------------*/
706 /* If not already recovering from an error, report this error. */
710 yyn = yypact[yystate];
712 if (YYPACT_NINF < yyn && yyn < YYLAST) {
714 const int yytype = YYTRANSLATE (yychar);
719 /* Start YYX at -YYN if negative to avoid negative indexes in
721 for (yyx = yyn < 0 ? -yyn : 0;
722 yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
723 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
724 yysize += yystrlen (yytname[yyx]) + 15, yycount++;
725 yysize += yystrlen ("syntax error, unexpected ") + 1;
726 yysize += yystrlen (yytname[yytype]);
727 Newx(yymsg, yysize, char *);
729 const char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
730 yyp = yystpcpy (yyp, yytname[yytype]);
734 for (yyx = yyn < 0 ? -yyn : 0;
735 yyx < (int) (sizeof (yytname) / sizeof (char *));
738 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) {
739 const char *yyq = ! yycount ?
740 ", expecting " : " or ";
741 yyp = yystpcpy (yyp, yyq);
742 yyp = yystpcpy (yyp, yytname[yyx]);
748 YYSTACK_FREE (yymsg);
751 yyerror ("syntax error; also virtual memory exhausted");
754 #endif /* YYERROR_VERBOSE */
755 yyerror ("syntax error");
759 if (yyerrstatus == 3) {
760 /* If just tried and failed to reuse lookahead token after an
761 error, discard it. */
763 /* Return failure if at end of input. */
764 if (yychar == YYEOF) {
765 /* Pop the error token. */
767 /* Pop the rest of the stack. */
768 while (yyss < yyssp) {
769 YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp);
770 if (yy_type_tab[yystos[*yyssp]] == toketype_opval) {
771 YYDPRINTF ((Perl_debug_log, "(freeing op)\n"));
772 if (*yypsp != PL_comppad) {
773 PAD_RESTORE_LOCAL(*yypsp);
775 op_free(yyvsp->opval);
782 YYDSYMPRINTF ("Error: discarding", yytoken, &yylval);
787 /* Else will try to reuse lookahead token after shifting the error
792 /*----------------------------------------------------.
793 | yyerrlab1 -- error raised explicitly by an action. |
794 `----------------------------------------------------*/
796 yyerrstatus = 3; /* Each real token shifted decrements this. */
799 yyn = yypact[yystate];
800 if (yyn != YYPACT_NINF) {
802 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) {
809 /* Pop the current state because it cannot handle the error token. */
813 YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp);
814 if (yy_type_tab[yystos[*yyssp]] == toketype_opval) {
815 YYDPRINTF ((Perl_debug_log, "(freeing op)\n"));
816 if (*yypsp != PL_comppad) {
817 PAD_RESTORE_LOCAL(*yypsp);
819 op_free(yyvsp->opval);
828 YY_STACK_PRINT (yyss, yyssp, yyvs, yyns);
829 if (yydebug && DEBUG_v_TEST)
834 int count = (int)(yyssp - yyss);
837 start = count - 8 + 1;
841 PerlIO_printf(Perl_debug_log, "cppad:");
842 for (i=0; i < count; i++)
843 PerlIO_printf(Perl_debug_log, " %8p", yyps[start+i]);
844 PerlIO_printf(Perl_debug_log, "\n");
851 YYDPRINTF ((Perl_debug_log, "Shifting error token, "));
854 *++yypsp = PL_comppad;
860 YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate));
865 /*-------------------------------------.
866 | yyacceptlab -- YYACCEPT comes here. |
867 `-------------------------------------*/
872 /*-----------------------------------.
873 | yyabortlab -- YYABORT comes here. |
874 `-----------------------------------*/
879 /*----------------------------------------------.
880 | yyoverflowlab -- parser overflow comes here. |
881 `----------------------------------------------*/
883 yyerror ("parser stack overflow");
889 ss_save->yyss = NULL; /* disarm parse stack cleanup */
890 LEAVE; /* force stack free before we return */
897 * c-indentation-style: bsd
899 * indent-tabs-mode: t
902 * ex: set ts=8 sts=4 sw=4 noet: