/* perly.c
*
- * Copyright (c) 2004, 2005, 2006 Larry Wall and others
+ * Copyright (c) 2004, 2005, 2006, 2007, 2008,
+ * 2009, 2010, 2011 by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
* restriction. This special exception was added by the Free
* Software Foundation in version 1.24 of Bison.
*
- * Note that this file is also #included in madly.c, to allow compilation
- * of a second parser, Perl_madparse, that is identical to Perl_yyparse,
- * but which includes extra code for dumping the parse tree.
- * This is controlled by the PERL_IN_MADLY_C define.
*/
-
-
-/* allow stack size to grow effectively without limit */
-#define YYMAXDEPTH 10000000
-
#include "EXTERN.h"
#define PERL_IN_PERLY_C
#include "perl.h"
+#include "feature.h"
+#include "keywords.h"
typedef unsigned char yytype_uint8;
typedef signed char yytype_int8;
typedef short int yytype_int16;
typedef signed char yysigned_char;
+/* YYINITDEPTH -- initial size of the parser's stacks. */
+#define YYINITDEPTH 200
+
+#ifdef YYDEBUG
+# undef YYDEBUG
+#endif
#ifdef DEBUGGING
# define YYDEBUG 1
#else
# define YYDEBUG 0
#endif
+#ifndef YY_NULL
+# define YY_NULL 0
+#endif
+
+#ifndef YY_NULLPTR
+# define YY_NULLPTR NULL
+#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 YYTERROR 1
#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
static void
yysymprint(pTHX_ PerlIO * const yyoutput, int yytype, const YYSTYPE * const yyvaluep)
{
+ PERL_UNUSED_CONTEXT;
if (yytype < YYNTOKENS) {
YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
# ifdef YYPRINT
YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
# else
- YYFPRINTF (yyoutput, "0x%"UVxf, (UV)yyvaluep->ival);
+ YYFPRINTF (yyoutput, "0x%" UVxf, (UV)yyvaluep->ival);
# endif
}
else
/* 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 */
+ * print the top 8 items on the parse stack.
+ */
static void
-yy_stack_print (pTHX_ const short *yyss, const short *yyssp, const YYSTYPE *yyvs, const char**yyns)
+yy_stack_print (pTHX_ const yy_parser *parser)
{
- int i;
- int start = 1;
- int count = (int)(yyssp - yyss);
+ const yy_stack_frame *ps, *min;
- if (count > 8) {
- start = count - 8 + 1;
- count = 8;
- }
+ min = parser->ps - 8 + 1;
+ if (min <= parser->stack)
+ min = parser->stack + 1;
PerlIO_printf(Perl_debug_log, "\nindex:");
- for (i=0; i < count; i++)
- PerlIO_printf(Perl_debug_log, " %8d", start+i);
+ for (ps = min; ps <= parser->ps; ps++)
+ PerlIO_printf(Perl_debug_log, " %8d", (int)(ps - parser->stack));
+
PerlIO_printf(Perl_debug_log, "\nstate:");
- for (i=0; i < count; i++)
- PerlIO_printf(Perl_debug_log, " %8d", yyss[start+i]);
+ for (ps = min; ps <= parser->ps; ps++)
+ PerlIO_printf(Perl_debug_log, " %8d", ps->state);
+
PerlIO_printf(Perl_debug_log, "\ntoken:");
- for (i=0; i < count; i++)
- PerlIO_printf(Perl_debug_log, " %8.8s", yyns[start+i]);
+ for (ps = min; ps <= parser->ps; ps++)
+ PerlIO_printf(Perl_debug_log, " %8.8s", ps->name);
+
PerlIO_printf(Perl_debug_log, "\nvalue:");
- for (i=0; i < count; i++) {
- switch (yy_type_tab[yystos[yyss[start+i]]]) {
+ for (ps = min; ps <= parser->ps; ps++) {
+ switch (yy_type_tab[yystos[ps->state]]) {
case toketype_opval:
PerlIO_printf(Perl_debug_log, " %8.8s",
- yyvs[start+i].opval
- ? PL_op_name[yyvs[start+i].opval->op_type]
- : "(NULL)"
+ ps->val.opval
+ ? PL_op_name[ps->val.opval->op_type]
+ : "(Nullop)"
);
break;
-#ifndef PERL_IN_MADLY_C
- case toketype_p_tkval:
- PerlIO_printf(Perl_debug_log, " %8.8s",
- yyvs[start+i].pval ? yyvs[start+i].pval : "(NULL)");
- break;
-
- case toketype_i_tkval:
-#endif
case toketype_ival:
- PerlIO_printf(Perl_debug_log, " %8"IVdf, yyvs[start+i].ival);
+ PerlIO_printf(Perl_debug_log, " %8" IVdf, (IV)ps->val.ival);
break;
default:
- PerlIO_printf(Perl_debug_log, " %8"UVxf, (UV)yyvs[start+i].ival);
+ PerlIO_printf(Perl_debug_log, " %8" UVxf, (UV)ps->val.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)); \
+# define YY_STACK_PRINT(parser) \
+do { \
+ if (yydebug && DEBUG_v_TEST) \
+ yy_stack_print (aTHX_ parser); \
} while (0)
YYFPRINTF (Perl_debug_log, "Reducing stack by rule %d (line %u), ",
yyrule - 1, yylineno);
/* Print the symbols being reduced, and their result. */
+#if PERL_BISON_VERSION >= 30000 /* 3.0+ */
+ for (yyi = 0; yyi < yyr2[yyrule]; yyi++)
+ YYFPRINTF (Perl_debug_log, "%s ",
+ yytname [yystos[(PL_parser->ps)[yyi + 1 - yyr2[yyrule]].state]]);
+#else
for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
YYFPRINTF (Perl_debug_log, "%s ", yytname [yyrhs[yyi]]);
+#endif
YYFPRINTF (Perl_debug_log, "-> %s\n", yytname [yyr1[yyrule]]);
}
#else /* !DEBUGGING */
# define YYDPRINTF(Args)
# define YYDSYMPRINTF(Title, Token, Value)
-# define YY_STACK_PRINT(yyss, yyssp, yyvs, yyns)
+# define YY_STACK_PRINT(parser)
# define YY_REDUCE_PRINT(Rule)
#endif /* !DEBUGGING */
+/* called during cleanup (via SAVEDESTRUCTOR_X) to free any items on the
+ * parse stack, thus avoiding leaks if we die */
-/* 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)
+static void
+S_clear_yystack(pTHX_ const yy_parser *parser)
{
- register const char *yys = yystr;
+ yy_stack_frame *ps = parser->ps;
+ int i = 0;
- while (*yys++ != '\0')
- continue;
+ if (!parser->stack)
+ return;
- 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;
+ YYDPRINTF ((Perl_debug_log, "clearing the parse stack\n"));
- while ((*yyd++ = *yys++) != '\0')
- continue;
+ for (i=0; i< parser->yylen; i++) {
+ SvREFCNT_dec(ps[-i].compcv);
+ }
+ ps -= parser->yylen;
+
+ /* now free whole the stack, including the just-reduced ops */
+
+ while (ps > parser->stack) {
+ LEAVE_SCOPE(ps->savestack_ix);
+ if (yy_type_tab[yystos[ps->state]] == toketype_opval
+ && ps->val.opval)
+ {
+ if (ps->compcv && (ps->compcv != PL_compcv)) {
+ PL_compcv = ps->compcv;
+ PAD_SET_CUR_NOSAVE(CvPADLIST(PL_compcv), 1);
+ PL_comppad_name = PadlistNAMES(CvPADLIST(PL_compcv));
+ }
+ YYDPRINTF ((Perl_debug_log, "(freeing op)\n"));
+ op_free(ps->val.opval);
+ }
+ SvREFCNT_dec(ps->compcv);
+ ps--;
+ }
- return yyd - 1;
+ Safefree(parser->stack);
}
-# endif
-# endif
-#endif /* !YYERROR_VERBOSE */
/*----------.
| yyparse. |
`----------*/
int
-#ifdef PERL_IN_MADLY_C
-Perl_madparse (pTHX)
-#else
-Perl_yyparse (pTHX)
-#endif
+Perl_yyparse (pTHX_ int gramtype)
{
dVAR;
- int yychar; /* The lookahead symbol. */
- YYSTYPE yylval; /* The semantic value of the lookahead symbol. */
- int yynerrs; /* Number of syntax errors so far. */
- register int yystate;
- register int yyn;
+ int yystate;
+ int yyn;
int yyresult;
- /* Number of tokens to shift before error messages enabled. */
- int yyerrstatus;
/* Lookahead token as an internal (translated) token number. */
int yytoken = 0;
- /* two stacks and their tools:
- yyss: related to states,
- yyvs: related to semantic values,
+ yy_parser *parser; /* the parser object */
+ yy_stack_frame *ps; /* current parser stack frame */
- Refer to the stacks thru separate pointers, to allow yyoverflow
- to reallocate them elsewhere. */
+#define YYPOPSTACK parser->ps = --ps
+#define YYPUSHSTACK parser->ps = ++ps
- /* The state stack. */
- short *yyss;
- register short *yyssp;
-
- /* The semantic value stack. */
- YYSTYPE *yyvs;
- register YYSTYPE *yyvsp;
-
- /* for ease of re-allocation and automatic freeing, have two SVs whose
- * SvPVX points to the stacks */
- SV *yyss_sv, *yyvs_sv;
-
-#ifdef DEBUGGING
- /* maintain also a stack of token/rule names for debugging with -Dpv */
- const char **yyns, **yynsp;
- SV *yyns_sv;
-# define YYPOPSTACK (yyvsp--, yyssp--, yynsp--)
-#else
-# define YYPOPSTACK (yyvsp--, yyssp--)
-#endif
-
-
- YYSIZE_T yystacksize = YYINITDEPTH;
-
- /* The variables used to return semantic value and location from the
- action routines. */
+ /* The variable used to return semantic value and location from the
+ action routines: ie $$. */
YYSTYPE yyval;
-
- /* When reducing, the number of symbols on the RHS of the reduced
- rule. */
- int yylen;
-
- /* keep track of which pad ops are currently using */
- AV* comppad = PL_comppad;
-
-#ifndef PERL_IN_MADLY_C
-# ifdef PERL_MAD
- if (PL_madskills)
- return madparse();
-# endif
-#endif
-
YYDPRINTF ((Perl_debug_log, "Starting parse\n"));
- ENTER; /* force stack free before we return */
- SAVEVPTR(PL_yycharp);
- SAVEVPTR(PL_yylvalp);
- PL_yycharp = &yychar; /* so PL_yyerror() can access it */
- PL_yylvalp = &yylval; /* so various functions in toke.c can access it */
-
- yyss_sv = newSV(YYINITDEPTH * sizeof(short));
- yyvs_sv = newSV(YYINITDEPTH * sizeof(YYSTYPE));
- SAVEFREESV(yyss_sv);
- SAVEFREESV(yyvs_sv);
- yyss = (short *) SvPVX(yyss_sv);
- yyvs = (YYSTYPE *) SvPVX(yyvs_sv);
- /* note that elements zero of yyvs and yyns are not used */
- yyssp = yyss;
- yyvsp = yyvs;
-#ifdef DEBUGGING
- yyns_sv = newSV(YYINITDEPTH * sizeof(char *));
- SAVEFREESV(yyns_sv);
- /* XXX This seems strange to cast char * to char ** */
- yyns = (const char **) SvPVX(yyns_sv);
- yynsp = yyns;
-#endif
-
- yystate = 0;
- yyerrstatus = 0;
- yynerrs = 0;
- yychar = YYEMPTY; /* Cause a token to be read. */
-
- YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate));
-
- goto yysetstate;
+ parser = PL_parser;
+
+ ENTER; /* force parser state cleanup/restoration before we return */
+ SAVEPPTR(parser->yylval.pval);
+ SAVEINT(parser->yychar);
+ SAVEINT(parser->yyerrstatus);
+ SAVEINT(parser->yylen);
+ SAVEVPTR(parser->stack);
+ SAVEVPTR(parser->stack_max1);
+ SAVEVPTR(parser->ps);
+
+ /* initialise state for this parse */
+ parser->yychar = gramtype;
+ parser->yyerrstatus = 0;
+ parser->yylen = 0;
+ Newx(parser->stack, YYINITDEPTH, yy_stack_frame);
+ parser->stack_max1 = parser->stack + YYINITDEPTH - 1;
+ ps = parser->ps = parser->stack;
+ ps->state = 0;
+ SAVEDESTRUCTOR_X(S_clear_yystack, parser);
/*------------------------------------------------------------.
| 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.
- */
- yyssp++;
-
- yysetstate:
- *yyssp = yystate;
-
- if (yyss + yystacksize - 1 <= yyssp) {
- /* Get the current used size of the three stacks, in elements. */
- const YYSIZE_T yysize = yyssp - yyss + 1;
-
- /* Extend the stack our own way. */
- if (YYMAXDEPTH <= yystacksize)
- goto yyoverflowlab;
- yystacksize *= 2;
- if (YYMAXDEPTH < yystacksize)
- yystacksize = YYMAXDEPTH;
-
- SvGROW(yyss_sv, yystacksize * sizeof(short));
- SvGROW(yyvs_sv, yystacksize * sizeof(YYSTYPE));
- yyss = (short *) SvPVX(yyss_sv);
- yyvs = (YYSTYPE *) SvPVX(yyvs_sv);
-#ifdef DEBUGGING
- SvGROW(yyns_sv, yystacksize * sizeof(char *));
- /* XXX This seems strange to cast char * to char ** */
- yyns = (const char **) SvPVX(yyns_sv);
- if (! yyns)
- goto yyoverflowlab;
- yynsp = yyns + yysize - 1;
-#endif
- if (!yyss || ! yyvs)
- goto yyoverflowlab;
-
- yyssp = yyss + yysize - 1;
- yyvsp = yyvs + yysize - 1;
+ yystate = ps->state;
- YYDPRINTF ((Perl_debug_log, "Stack size increased to %lu\n",
- (unsigned long int) yystacksize));
+ YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate));
- if (yyss + yystacksize - 1 <= yyssp)
- YYABORT;
+ parser->yylen = 0;
+
+ {
+ /* grow the stack? We always leave 1 spare slot,
+ * in case of a '' -> 'foo' reduction.
+ * Note that stack_max1 points to the (top-1)th allocated stack
+ * element to make this check fast */
+
+ if (ps >= parser->stack_max1) {
+ Size_t pos = ps - parser->stack;
+ Size_t newsize = 2 * (parser->stack_max1 + 2 - parser->stack);
+ /* this will croak on insufficient memory */
+ Renew(parser->stack, newsize, yy_stack_frame);
+ ps = parser->ps = parser->stack + pos;
+ parser->stack_max1 = parser->stack + newsize - 1;
+
+ YYDPRINTF((Perl_debug_log,
+ "parser stack size increased to %lu frames\n",
+ (unsigned long int)newsize));
+ }
}
- 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. */
/* Not known => get a lookahead token if don't already have one. */
/* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
- if (yychar == YYEMPTY) {
- YYDPRINTF ((Perl_debug_log, "Reading a token: "));
-#ifdef PERL_IN_MADLY_C
- yychar = PL_madskills ? madlex() : yylex();
-#else
- yychar = yylex();
-#endif
-
-# ifdef EBCDIC
- if (yychar >= 0 && yychar < 255) {
- yychar = NATIVE_TO_ASCII(yychar);
- }
-# endif
+ if (parser->yychar == YYEMPTY) {
+ YYDPRINTF ((Perl_debug_log, "Reading a token:\n"));
+ parser->yychar = yylex();
}
- if (yychar <= YYEOF) {
- yychar = yytoken = YYEOF;
+ if (parser->yychar <= YYEOF) {
+ parser->yychar = yytoken = YYEOF;
YYDPRINTF ((Perl_debug_log, "Now at end of input.\n"));
}
else {
- yytoken = YYTRANSLATE (yychar);
- YYDSYMPRINTF ("Next token is", yytoken, &yylval);
+ /* perly.tab is shipped based on an ASCII system, so need to index it
+ * with characters translated to ASCII. Although it's not designed for
+ * this purpose, we can use NATIVE_TO_UNI here. It returns its
+ * argument on ASCII platforms, and on EBCDIC translates native to
+ * ascii in the 0-255 range, leaving everything else unchanged. This
+ * jibes with yylex() returning some bare characters in that range, but
+ * all tokens it returns are either 0, or above 255. There could be a
+ * problem if NULs weren't 0, or were ever returned as raw chars by
+ * yylex() */
+ yytoken = YYTRANSLATE (NATIVE_TO_UNI(parser->yychar));
+ YYDSYMPRINTF ("Next token is", yytoken, &parser->yylval);
}
/* If the proper action on seeing token YYTOKEN is to reduce or to
YYDPRINTF ((Perl_debug_log, "Shifting token %s, ", yytname[yytoken]));
/* Discard the token being shifted unless it is eof. */
- if (yychar != YYEOF)
- yychar = YYEMPTY;
-
- *++yyvsp = yylval;
+ if (parser->yychar != YYEOF)
+ parser->yychar = YYEMPTY;
+
+ YYPUSHSTACK;
+ ps->state = yyn;
+ ps->val = parser->yylval;
+ ps->compcv = (CV*)SvREFCNT_inc(PL_compcv);
+ ps->savestack_ix = PL_savestack_ix;
#ifdef DEBUGGING
- *++yynsp = (const char *)(yytname[yytoken]);
+ ps->name = (const char *)(yytname[yytoken]);
#endif
-
/* Count tokens shifted since error; after three, turn off error
status. */
- if (yyerrstatus)
- yyerrstatus--;
-
- yystate = yyn;
- YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate));
+ if (parser->yyerrstatus)
+ parser->yyerrstatus--;
goto yynewstate;
`-----------------------------*/
yyreduce:
/* yyn is the number of a rule to reduce with. */
- yylen = yyr2[yyn];
+ parser->yylen = yyr2[yyn];
/* If YYLEN is nonzero, implement the default value of the action:
"$$ = $1".
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. */
- yyval = yyvsp[1-yylen];
-
+ yyval = ps[1-parser->yylen].val;
+ YY_STACK_PRINT(parser);
YY_REDUCE_PRINT (yyn);
- switch (yyn) {
-
-
-#define dep() deprecate("\"do\" to call subroutines")
-#ifdef PERL_IN_MADLY_C
-# define IVAL(i) (i)->tk_lval.ival
-# define PVAL(p) (p)->tk_lval.pval
-# define TOKEN_GETMAD(a,b,c) token_getmad((a),(b),(c))
-# define TOKEN_FREE(a) token_free(a)
-# define OP_GETMAD(a,b,c) op_getmad((a),(b),(c))
-# define IF_MAD(a,b) (a)
-# define DO_MAD(a) a
-# define MAD
-#else
-# define IVAL(i) (i)
-# define PVAL(p) (p)
-# define TOKEN_GETMAD(a,b,c)
-# define TOKEN_FREE(a)
-# define OP_GETMAD(a,b,c)
-# define IF_MAD(a,b) (b)
-# define DO_MAD(a)
-# undef MAD
-#endif
+ switch (yyn) {
/* contains all the rule actions; auto-generated from perly.y */
#include "perly.act"
}
- yyvsp -= yylen;
- yyssp -= yylen;
-#ifdef DEBUGGING
- yynsp -= yylen;
-#endif
-
-
- *++yyvsp = yyval;
- comppad = PL_comppad;
+ {
+ int i;
+ for (i=0; i< parser->yylen; i++) {
+ SvREFCNT_dec(ps[-i].compcv);
+ }
+ }
-#ifdef DEBUGGING
- *++yynsp = (const char *)(yytname [yyr1[yyn]]);
-#endif
+ parser->ps = ps -= (parser->yylen-1);
/* 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. */
+ ps->val = yyval;
+ ps->compcv = (CV*)SvREFCNT_inc(PL_compcv);
+ ps->savestack_ix = PL_savestack_ix;
+#ifdef DEBUGGING
+ ps->name = (const char *)(yytname [yyr1[yyn]]);
+#endif
+
yyn = yyr1[yyn];
- yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
- if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
+ yystate = yypgoto[yyn - YYNTOKENS] + ps[-1].state;
+ if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == ps[-1].state)
yystate = yytable[yystate];
else
yystate = yydefgoto[yyn - YYNTOKENS];
-
- YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate));
-
-#ifdef DEBUGGING
- /* tmp push yystate for stack print; this is normally pushed later in
- * yynewstate */
- yyssp++;
- *yyssp = yystate;
- YY_STACK_PRINT (yyss, yyssp, yyvs, yyns);
- yyssp--;
-#endif
+ ps->state = yystate;
goto yynewstate;
`------------------------------------*/
yyerrlab:
/* If not already recovering from an error, report this error. */
- if (!yyerrstatus) {
- ++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]);
- Newx(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 */
- yyerror ("syntax error");
+ if (!parser->yyerrstatus) {
+ yyerror ("syntax error");
}
- if (yyerrstatus == 3) {
+ if (parser->yyerrstatus == 3) {
/* If just tried and failed to reuse lookahead token after an
error, discard it. */
/* Return failure if at end of input. */
- if (yychar == YYEOF) {
+ if (parser->yychar == YYEOF) {
/* Pop the error token. */
+ SvREFCNT_dec(ps->compcv);
YYPOPSTACK;
/* Pop the rest of the stack. */
- PAD_RESTORE_LOCAL(comppad);
- while (yyss < yyssp) {
- YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp);
- if (yy_type_tab[yystos[*yyssp]] == toketype_padval) {
- comppad = yyvsp->padval;
- PAD_RESTORE_LOCAL(comppad);
- }
- else if (yy_type_tab[yystos[*yyssp]] == toketype_opval) {
+ while (ps > parser->stack) {
+ YYDSYMPRINTF ("Error: popping", yystos[ps->state], &ps->val);
+ LEAVE_SCOPE(ps->savestack_ix);
+ if (yy_type_tab[yystos[ps->state]] == toketype_opval
+ && ps->val.opval)
+ {
YYDPRINTF ((Perl_debug_log, "(freeing op)\n"));
- op_free(yyvsp->opval);
+ if (ps->compcv != PL_compcv) {
+ PL_compcv = ps->compcv;
+ PAD_SET_CUR_NOSAVE(CvPADLIST(PL_compcv), 1);
+ }
+ op_free(ps->val.opval);
}
+ SvREFCNT_dec(ps->compcv);
YYPOPSTACK;
}
YYABORT;
}
- YYDSYMPRINTF ("Error: discarding", yytoken, &yylval);
- yychar = YYEMPTY;
+ YYDSYMPRINTF ("Error: discarding", yytoken, &parser->yylval);
+ parser->yychar = YYEMPTY;
}
| yyerrlab1 -- error raised explicitly by an action. |
`----------------------------------------------------*/
yyerrlab1:
- yyerrstatus = 3; /* Each real token shifted decrements this. */
+ parser->yyerrstatus = 3; /* Each real token shifted decrements this. */
- PAD_RESTORE_LOCAL(comppad);
for (;;) {
yyn = yypact[yystate];
if (yyn != YYPACT_NINF) {
}
/* Pop the current state because it cannot handle the error token. */
- if (yyssp == yyss)
+ if (ps == parser->stack)
YYABORT;
- YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp);
- if (yy_type_tab[yystos[*yyssp]] == toketype_padval) {
- comppad = yyvsp->padval;
- PAD_RESTORE_LOCAL(comppad);
- }
- else if (yy_type_tab[yystos[*yyssp]] == toketype_opval) {
+ YYDSYMPRINTF ("Error: popping", yystos[ps->state], &ps->val);
+ LEAVE_SCOPE(ps->savestack_ix);
+ if (yy_type_tab[yystos[ps->state]] == toketype_opval && ps->val.opval) {
YYDPRINTF ((Perl_debug_log, "(freeing op)\n"));
- op_free(yyvsp->opval);
+ if (ps->compcv != PL_compcv) {
+ PL_compcv = ps->compcv;
+ PAD_SET_CUR_NOSAVE(CvPADLIST(PL_compcv), 1);
+ }
+ op_free(ps->val.opval);
}
- yyvsp--;
-#ifdef DEBUGGING
- yynsp--;
-#endif
- yystate = *--yyssp;
+ SvREFCNT_dec(ps->compcv);
+ YYPOPSTACK;
+ yystate = ps->state;
- YY_STACK_PRINT (yyss, yyssp, yyvs, yyns);
+ YY_STACK_PRINT(parser);
}
if (yyn == YYFINAL)
YYDPRINTF ((Perl_debug_log, "Shifting error token, "));
- *++yyvsp = yylval;
+ YYPUSHSTACK;
+ ps->state = yyn;
+ ps->val = parser->yylval;
+ ps->compcv = (CV*)SvREFCNT_inc(PL_compcv);
+ ps->savestack_ix = PL_savestack_ix;
#ifdef DEBUGGING
- *++yynsp ="<err>";
+ ps->name ="<err>";
#endif
- yystate = yyn;
- YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate));
-
goto yynewstate;
`-------------------------------------*/
yyacceptlab:
yyresult = 0;
+ for (ps=parser->ps; ps > parser->stack; ps--) {
+ SvREFCNT_dec(ps->compcv);
+ }
+ parser->ps = parser->stack; /* disable cleanup */
goto yyreturn;
/*-----------------------------------.
yyresult = 1;
goto yyreturn;
- /*----------------------------------------------.
- | yyoverflowlab -- parser overflow comes here. |
- `----------------------------------------------*/
- yyoverflowlab:
- yyerror ("parser stack overflow");
- yyresult = 2;
- /* Fall through. */
-
yyreturn:
-
- LEAVE; /* force stack free before we return */
-
+ LEAVE; /* force parser stack cleanup before we return */
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:
+ * ex: set ts=8 sts=4 sw=4 et:
*/
https://perl5.git.perl.org / perl5.git / blobdiff