/* perly.c * * Copyright (c) 2004 Larry Wall * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * * Note that this file was originally generated as an output from * GNU bison version 1.875, but now the code is statically maintained * and edited; the bits that are dependent on perly.y are now #included * from the files perly.tab and perly.act. * * Here is an important copyright statement from the original, generated * file: * * As a special exception, when this file is copied by Bison into a * Bison output file, you may use that output file without * restriction. This special exception was added by the Free * Software Foundation in version 1.24 of Bison. */ /* allow stack size to grow effectively without limit */ #define YYMAXDEPTH 10000000 #include "EXTERN.h" #define PERL_IN_PERLY_C #include "perl.h" typedef signed char yysigned_char; #ifdef DEBUGGING # define YYDEBUG 1 #else # define YYDEBUG 0 #endif /* contains all the parser state tables; auto-generated from perly.y */ #include "perly.tab" # define YYSIZE_T size_t #define yyerrok (yyerrstatus = 0) #define yyclearin (yychar = YYEMPTY) #define YYEMPTY (-2) #define YYEOF 0 #define YYACCEPT goto yyacceptlab #define YYABORT goto yyabortlab #define YYERROR goto yyerrlab1 /* Like YYERROR except do call yyerror. This remains here temporarily to ease the transition to the new meaning of YYERROR, for GCC. Once GCC version 2 has supplanted version 1, this can go. */ #define YYFAIL goto yyerrlab #define YYRECOVERING() (!!yyerrstatus) #define YYBACKUP(Token, Value) \ do \ if (yychar == YYEMPTY && yylen == 1) { \ yychar = (Token); \ yylval = (Value); \ yytoken = YYTRANSLATE (yychar); \ YYPOPSTACK; \ goto yybackup; \ } \ else { \ yyerror ("syntax error: cannot back up"); \ YYERROR; \ } \ while (0) #define YYTERROR 1 #define YYERRCODE 256 /* Enable debugging if requested. */ #ifdef DEBUGGING # define yydebug (DEBUG_p_TEST) # define YYFPRINTF PerlIO_printf # define YYDPRINTF(Args) \ do { \ if (yydebug) \ YYFPRINTF Args; \ } while (0) # define YYDSYMPRINT(Args) \ do { \ if (yydebug) \ yysymprint Args; \ } while (0) # define YYDSYMPRINTF(Title, Token, Value) \ do { \ if (yydebug) { \ YYFPRINTF (Perl_debug_log, "%s ", Title); \ yysymprint (aTHX_ Perl_debug_log, Token, Value); \ YYFPRINTF (Perl_debug_log, "\n"); \ } \ } while (0) /*--------------------------------. | Print this symbol on YYOUTPUT. | `--------------------------------*/ static void yysymprint (pTHX_ PerlIO *yyoutput, int yytype, const YYSTYPE *yyvaluep) ###### { ###### if (yytype < YYNTOKENS) { ###### YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); # ifdef YYPRINT YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); # else ###### YYFPRINTF (yyoutput, "0x%"UVxf, (UV)yyvaluep->ival); # endif } else ###### YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); ###### YYFPRINTF (yyoutput, ")"); } /* yy_stack_print() * print the top 8 items on the parse stack. The args have the same * meanings as the local vars in yyparse() of the same name */ static void yy_stack_print (pTHX_ const short *yyss, const short *yyssp, const YYSTYPE *yyvs, const char**yyns) ###### { ###### int i; ###### int start = 1; ###### int count = (int)(yyssp - yyss); ###### if (count > 8) { ###### start = count - 8 + 1; ###### count = 8; } ###### PerlIO_printf(Perl_debug_log, "\nindex:"); ###### for (i=0; i < count; i++) ###### PerlIO_printf(Perl_debug_log, " %8d", start+i); ###### PerlIO_printf(Perl_debug_log, "\nstate:"); ###### for (i=0, yyss += start; i < count; i++, yyss++) ###### PerlIO_printf(Perl_debug_log, " %8d", *yyss); ###### PerlIO_printf(Perl_debug_log, "\ntoken:"); ###### for (i=0, yyns += start; i < count; i++, yyns++) ###### PerlIO_printf(Perl_debug_log, " %8.8s", *yyns); ###### PerlIO_printf(Perl_debug_log, "\nvalue:"); ###### for (i=0, yyvs += start; i < count; i++, yyvs++) ###### PerlIO_printf(Perl_debug_log, " %8"UVxf, (UV)yyvs->ival); ###### PerlIO_printf(Perl_debug_log, "\n\n"); } # define YY_STACK_PRINT(yyss, yyssp, yyvs, yyns) \ do { \ if (yydebug && DEBUG_v_TEST) \ yy_stack_print (aTHX_ (yyss), (yyssp), (yyvs), (yyns)); \ } while (0) /*------------------------------------------------. | Report that the YYRULE is going to be reduced. | `------------------------------------------------*/ static void yy_reduce_print (pTHX_ int yyrule) ###### { ###### int yyi; ###### const unsigned int yylineno = yyrline[yyrule]; ###### YYFPRINTF (Perl_debug_log, "Reducing stack by rule %d (line %u), ", yyrule - 1, yylineno); /* Print the symbols being reduced, and their result. */ ###### for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++) ###### YYFPRINTF (Perl_debug_log, "%s ", yytname [yyrhs[yyi]]); ###### YYFPRINTF (Perl_debug_log, "-> %s\n", yytname [yyr1[yyrule]]); } # define YY_REDUCE_PRINT(Rule) \ do { \ if (yydebug) \ yy_reduce_print (aTHX_ Rule); \ } while (0) #else /* !DEBUGGING */ # define YYDPRINTF(Args) # define YYDSYMPRINT(Args) # define YYDSYMPRINTF(Title, Token, Value) # define YY_STACK_PRINT(yyss, yyssp, yyvs, yyns) # define YY_REDUCE_PRINT(Rule) #endif /* !DEBUGGING */ /* YYINITDEPTH -- initial size of the parser's stacks. */ #ifndef YYINITDEPTH # define YYINITDEPTH 200 #endif #if YYERROR_VERBOSE # ifndef yystrlen # if defined (__GLIBC__) && defined (_STRING_H) # define yystrlen strlen # else /* Return the length of YYSTR. */ static YYSIZE_T yystrlen (const char *yystr) { register const char *yys = yystr; while (*yys++ != '\0') continue; return yys - yystr - 1; } # endif # endif # ifndef yystpcpy # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE) # define yystpcpy stpcpy # else /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in YYDEST. */ static char * yystpcpy (pTHX_ char *yydest, const char *yysrc) { register char *yyd = yydest; register const char *yys = yysrc; while ((*yyd++ = *yys++) != '\0') continue; return yyd - 1; } # endif # endif #endif /* !YYERROR_VERBOSE */ /*----------. | yyparse. | `----------*/ int Perl_yyparse (pTHX) 106267 { 106267 int yychar; /* The lookahead symbol. */ 106267 YYSTYPE yylval; /* The semantic value of the lookahead symbol. */ 106267 int yynerrs; /* Number of syntax errors so far. */ 106267 register int yystate; 106267 register int yyn; 106267 int yyresult; /* Number of tokens to shift before error messages enabled. */ 106267 int yyerrstatus; /* Lookahead token as an internal (translated) token number. */ 106267 int yytoken = 0; /* two stacks and their tools: yyss: related to states, yyvs: related to semantic values, Refer to the stacks thru separate pointers, to allow yyoverflow to reallocate them elsewhere. */ /* The state stack. */ 106267 short *yyss; 106267 register short *yyssp; /* The semantic value stack. */ 106267 YYSTYPE *yyvs; 106267 register YYSTYPE *yyvsp; /* for ease of re-allocation and automatic freeing, have two SVs whose * SvPVX points to the stacks */ 106267 SV *yyss_sv, *yyvs_sv; #ifdef DEBUGGING /* maintain also a stack of token/rule names for debugging with -Dpv */ 106267 const char **yyns, **yynsp; 106267 SV *yyns_sv; # define YYPOPSTACK (yyvsp--, yyssp--, yynsp--) #else # define YYPOPSTACK (yyvsp--, yyssp--) #endif 106267 YYSIZE_T yystacksize = YYINITDEPTH; /* The variables used to return semantic value and location from the action routines. */ 106267 YYSTYPE yyval; /* When reducing, the number of symbols on the RHS of the reduced rule. */ 106267 int yylen; 106267 YYDPRINTF ((Perl_debug_log, "Starting parse\n")); 106267 ENTER; /* force stack free before we return */ 106267 SAVEVPTR(PL_yycharp); 106267 SAVEVPTR(PL_yylvalp); 106267 PL_yycharp = &yychar; /* so PL_yyerror() can access it */ 106267 PL_yylvalp = &yylval; /* so various functions in toke.c can access it */ 106267 yyss_sv = NEWSV(73, YYINITDEPTH * sizeof(short)); 106267 yyvs_sv = NEWSV(73, YYINITDEPTH * sizeof(YYSTYPE)); 106267 SAVEFREESV(yyss_sv); 106267 SAVEFREESV(yyvs_sv); 106267 yyss = (short *) SvPVX(yyss_sv); 106267 yyvs = (YYSTYPE *) SvPVX(yyvs_sv); /* note that elements zero of yyvs and yyns are not used */ 106267 yyssp = yyss; 106267 yyvsp = yyvs; #ifdef DEBUGGING 106267 yyns_sv = NEWSV(73, YYINITDEPTH * sizeof(char *)); 106267 SAVEFREESV(yyns_sv); /* XXX This seems strange to cast char * to char ** */ 106267 yyns = (const char **) SvPVX(yyns_sv); 106267 yynsp = yyns; #endif 106267 yystate = 0; 106267 yyerrstatus = 0; 106267 yynerrs = 0; 106267 yychar = YYEMPTY; /* Cause a token to be read. */ 106267 YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate)); ###### goto yysetstate; /*------------------------------------------------------------. | yynewstate -- Push a new state, which is found in yystate. | `------------------------------------------------------------*/ yynewstate: /* In all cases, when you get here, the value and location stacks have just been pushed. so pushing a state here evens the stacks. */ 115110163 yyssp++; yysetstate: 115216430 *yyssp = yystate; 115216430 if (yyss + yystacksize - 1 <= yyssp) { /* Get the current used size of the three stacks, in elements. */ 11 const YYSIZE_T yysize = yyssp - yyss + 1; /* Extend the stack our own way. */ 11 if (YYMAXDEPTH <= yystacksize) ###### goto yyoverflowlab; 11 yystacksize *= 2; 11 if (YYMAXDEPTH < yystacksize) ###### yystacksize = YYMAXDEPTH; 11 SvGROW(yyss_sv, yystacksize * sizeof(short)); 11 SvGROW(yyvs_sv, yystacksize * sizeof(YYSTYPE)); 11 yyss = (short *) SvPVX(yyss_sv); 11 yyvs = (YYSTYPE *) SvPVX(yyvs_sv); #ifdef DEBUGGING 11 SvGROW(yyns_sv, yystacksize * sizeof(char *)); /* XXX This seems strange to cast char * to char ** */ 11 yyns = (const char **) SvPVX(yyns_sv); 11 if (! yyns) ###### goto yyoverflowlab; 11 yynsp = yyns + yysize - 1; #endif 11 if (!yyss || ! yyvs) ###### goto yyoverflowlab; 11 yyssp = yyss + yysize - 1; 11 yyvsp = yyvs + yysize - 1; YYDPRINTF ((Perl_debug_log, "Stack size increased to %lu\n", 11 (unsigned long int) yystacksize)); 11 if (yyss + yystacksize - 1 <= yyssp) ###### YYABORT; } 115216430 goto yybackup; /*-----------. | yybackup. | `-----------*/ yybackup: /* Do appropriate processing given the current state. */ /* Read a lookahead token if we need one and don't already have one. */ /* yyresume: */ /* First try to decide what to do without reference to lookahead token. */ 115216430 yyn = yypact[yystate]; 115216430 if (yyn == YYPACT_NINF) 38346484 goto yydefault; /* Not known => get a lookahead token if don't already have one. */ /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 76869946 if (yychar == YYEMPTY) { 38992828 YYDPRINTF ((Perl_debug_log, "Reading a token: ")); 38992828 yychar = yylex(); # ifdef EBCDIC if (yychar >= 0 && yychar < 255) { yychar = NATIVE_TO_ASCII(yychar); } # endif } 76869879 if (yychar <= YYEOF) { 210962 yychar = yytoken = YYEOF; 210962 YYDPRINTF ((Perl_debug_log, "Now at end of input.\n")); } else { 76658917 yytoken = YYTRANSLATE (yychar); 76658917 YYDSYMPRINTF ("Next token is", yytoken, &yylval); } /* If the proper action on seeing token YYTOKEN is to reduce or to detect an error, take that action. */ 76869879 yyn += yytoken; 76869879 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 39379809 goto yydefault; 39379809 yyn = yytable[yyn]; 39379809 if (yyn <= 0) { 387504 if (yyn == 0 || yyn == YYTABLE_NINF) 387504 goto yyerrlab; 387504 yyn = -yyn; 387504 goto yyreduce; } 38992305 if (yyn == YYFINAL) 105460 YYACCEPT; /* Shift the lookahead token. */ 38886845 YYDPRINTF ((Perl_debug_log, "Shifting token %s, ", yytname[yytoken])); /* Discard the token being shifted unless it is eof. */ 38886845 if (yychar != YYEOF) 38886845 yychar = YYEMPTY; 38886845 *++yyvsp = yylval; #ifdef DEBUGGING 38886845 *++yynsp = (const char *)(yytname[yytoken]); #endif /* Count tokens shifted since error; after three, turn off error status. */ 38886845 if (yyerrstatus) 132 yyerrstatus--; 38886845 yystate = yyn; 38886845 YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate)); ###### goto yynewstate; /*-----------------------------------------------------------. | yydefault -- do the default action for the current state. | `-----------------------------------------------------------*/ yydefault: 75836554 yyn = yydefact[yystate]; 75836554 if (yyn == 0) 256 goto yyerrlab; 76223802 goto yyreduce; /*-----------------------------. | yyreduce -- Do a reduction. | `-----------------------------*/ yyreduce: /* yyn is the number of a rule to reduce with. */ 76223802 yylen = yyr2[yyn]; /* If YYLEN is nonzero, implement the default value of the action: "$$ = $1". Otherwise, the following line sets YYVAL to garbage. This behavior is undocumented and Bison users should not rely upon it. Assigning to YYVAL unconditionally makes the parser a bit smaller, and it avoids a GCC warning that YYVAL may be used uninitialized. */ 76223802 yyval = yyvsp[1-yylen]; 76223802 YY_REDUCE_PRINT (yyn); 76223802 switch (yyn) { /* contains all the rule actions; auto-generated from perly.y */ #define dep() deprecate("\"do\" to call subroutines") #include "perly.act" } 76223070 yyvsp -= yylen; 76223070 yyssp -= yylen; #ifdef DEBUGGING 76223070 yynsp -= yylen; #endif 76223070 *++yyvsp = yyval; #ifdef DEBUGGING 76223070 *++yynsp = (const char *)(yytname [yyr1[yyn]]); #endif /* Now shift the result of the reduction. Determine what state that goes to, based on the state we popped back to and the rule number reduced by. */ 76223070 yyn = yyr1[yyn]; 76223070 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 76223070 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 28419097 yystate = yytable[yystate]; else 47803973 yystate = yydefgoto[yyn - YYNTOKENS]; 76223070 YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate)); #ifdef DEBUGGING /* tmp push yystate for stack print; this is normally pushed later in * yynewstate */ 76223070 yyssp++; 76223070 *yyssp = yystate; 76223070 YY_STACK_PRINT (yyss, yyssp, yyvs, yyns); 76223070 yyssp--; #endif 76223070 goto yynewstate; /*------------------------------------. | yyerrlab -- here on detecting error | `------------------------------------*/ yyerrlab: /* If not already recovering from an error, report this error. */ 256 if (!yyerrstatus) { 87 ++yynerrs; #if YYERROR_VERBOSE yyn = yypact[yystate]; if (YYPACT_NINF < yyn && yyn < YYLAST) { YYSIZE_T yysize = 0; const int yytype = YYTRANSLATE (yychar); char *yymsg; int yyx, yycount; yycount = 0; /* Start YYX at -YYN if negative to avoid negative indexes in YYCHECK. */ for (yyx = yyn < 0 ? -yyn : 0; yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++) if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) yysize += yystrlen (yytname[yyx]) + 15, yycount++; yysize += yystrlen ("syntax error, unexpected ") + 1; yysize += yystrlen (yytname[yytype]); New(yymsg, yysize, char *); if (yymsg != 0) { const char *yyp = yystpcpy (yymsg, "syntax error, unexpected "); yyp = yystpcpy (yyp, yytname[yytype]); if (yycount < 5) { yycount = 0; for (yyx = yyn < 0 ? -yyn : 0; yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++) { if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) { const char *yyq = ! yycount ? ", expecting " : " or "; yyp = yystpcpy (yyp, yyq); yyp = yystpcpy (yyp, yytname[yyx]); yycount++; } } } yyerror (yymsg); YYSTACK_FREE (yymsg); } else yyerror ("syntax error; also virtual memory exhausted"); } else #endif /* YYERROR_VERBOSE */ 87 yyerror ("syntax error"); } 256 if (yyerrstatus == 3) { /* If just tried and failed to reuse lookahead token after an error, discard it. */ /* Return failure if at end of input. */ 165 if (yychar == YYEOF) { /* Pop the error token. */ 4 YYPOPSTACK; /* Pop the rest of the stack. */ 34 while (yyss < yyssp) { 30 YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp); 30 YYPOPSTACK; } 161 YYABORT; } 161 YYDSYMPRINTF ("Error: discarding", yytoken, &yylval); 161 yychar = YYEMPTY; } /* Else will try to reuse lookahead token after shifting the error token. */ 252 goto yyerrlab1; /*----------------------------------------------------. | yyerrlab1 -- error raised explicitly by an action. | `----------------------------------------------------*/ yyerrlab1: 252 yyerrstatus = 3; /* Each real token shifted decrements this. */ 542 for (;;) { 542 yyn = yypact[yystate]; 542 if (yyn != YYPACT_NINF) { 525 yyn += YYTERROR; 525 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) { 248 yyn = yytable[yyn]; 248 if (0 < yyn) 248 break; } } /* Pop the current state because it cannot handle the error token. */ 294 if (yyssp == yyss) 4 YYABORT; 290 YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp); 290 yyvsp--; #ifdef DEBUGGING 290 yynsp--; #endif 290 yystate = *--yyssp; 290 YY_STACK_PRINT (yyss, yyssp, yyvs, yyns); } 248 if (yyn == YYFINAL) ###### YYACCEPT; 248 YYDPRINTF ((Perl_debug_log, "Shifting error token, ")); 248 *++yyvsp = yylval; #ifdef DEBUGGING 248 *++yynsp =""; #endif 248 yystate = yyn; 248 YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate)); ###### goto yynewstate; /*-------------------------------------. | yyacceptlab -- YYACCEPT comes here. | `-------------------------------------*/ yyacceptlab: 105460 yyresult = 0; 105460 goto yyreturn; /*-----------------------------------. | yyabortlab -- YYABORT comes here. | `-----------------------------------*/ yyabortlab: 8 yyresult = 1; 8 goto yyreturn; /*----------------------------------------------. | yyoverflowlab -- parser overflow comes here. | `----------------------------------------------*/ yyoverflowlab: ###### yyerror ("parser stack overflow"); ###### yyresult = 2; /* Fall through. */ yyreturn: 105468 LEAVE; /* force stack free before we return */ 105468 return yyresult; } /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 * indent-tabs-mode: t * End: * * ex: set ts=8 sts=4 sw=4 noet: */