[p5sagit/p5-mst-13.2.git] / perly.c

/*    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, YYSTYPE *yyvaluep)
{
    /* Pacify ``unused variable'' warnings.  */
    (void) yyvaluep;

    if (yytype < YYNTOKENS) {
	YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
#   ifdef YYPRINT
	YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
#   else
	YYFPRINTF (yyoutput, "0x%x", yyvaluep->ival);
#   endif
    }
    else
	YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);

    switch (yytype) {
	default:
	    break;
    }
    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_ short *yyss, short *yyssp, YYSTYPE *yyvs, 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, " %8x", 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;
    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 */


/*-----------------------------------------------.
| Release the memory associated to this symbol.  |
`-----------------------------------------------*/

static void
yydestruct (int yytype, YYSTYPE *yyvaluep)
{
    /* Pacify ``unused variable'' warnings.  */
    (void) yyvaluep;

    switch (yytype) {
	default:
	    break;
    }
}


/*----------.
| yyparse.  |
`----------*/

int
Perl_yyparse (pTHX)
{
    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 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,

	  Refer to the stacks thru separate pointers, to allow yyoverflow
	  to reallocate them elsewhere.  */

    /* 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 */
    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.  */
    YYSTYPE yyval;


    /* When reducing, the number of symbols on the RHS of the reduced
	  rule.  */
    int yylen;

    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(73, YYINITDEPTH * sizeof(short));
    yyvs_sv = NEWSV(73, 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(73, YYINITDEPTH * sizeof(char *));
    SAVEFREESV(yyns_sv);
    yyns = (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;

/*------------------------------------------------------------.
| 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.  */
	 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 *));
	 yyns = (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;


	 YYDPRINTF ((Perl_debug_log, "Stack size increased to %lu\n",
				   (unsigned long int) yystacksize));

	 if (yyss + yystacksize - 1 <= yyssp)
	       YYABORT;
    }

    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.  */

    yyn = yypact[yystate];
    if (yyn == YYPACT_NINF)
	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.  */
    if (yychar == YYEMPTY) {
	YYDPRINTF ((Perl_debug_log, "Reading a token: "));
	yychar = yylex();
#  ifdef EBCDIC
	if (yychar >= 0 && yychar < 255) {
	    yychar = NATIVE_TO_ASCII(yychar);
	}
#  endif
    }

    if (yychar <= YYEOF) {
	yychar = yytoken = YYEOF;
	YYDPRINTF ((Perl_debug_log, "Now at end of input.\n"));
    }
    else {
	yytoken = YYTRANSLATE (yychar);
	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.  */
    yyn += yytoken;
    if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
	goto yydefault;
    yyn = yytable[yyn];
    if (yyn <= 0) {
	if (yyn == 0 || yyn == YYTABLE_NINF)
	    goto yyerrlab;
	yyn = -yyn;
	goto yyreduce;
    }

    if (yyn == YYFINAL)
	YYACCEPT;

    /* Shift the lookahead token.  */
    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;
#ifdef DEBUGGING
    *++yynsp = (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));

    goto yynewstate;


  /*-----------------------------------------------------------.
  | yydefault -- do the default action for the current state.  |
  `-----------------------------------------------------------*/
  yydefault:
    yyn = yydefact[yystate];
    if (yyn == 0)
	goto yyerrlab;
    goto yyreduce;


  /*-----------------------------.
  | yyreduce -- Do a reduction.  |
  `-----------------------------*/
  yyreduce:
    /* yyn is the number of a rule to reduce with.  */
    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.  */
    yyval = yyvsp[1-yylen];


    YY_REDUCE_PRINT (yyn);
    switch (yyn) {

/* contains all the rule actions; auto-generated from perly.y */

#define dep() deprecate("\"do\" to call subroutines")
#include "perly.act"

    }

    yyvsp -= yylen;
    yyssp -= yylen;
#ifdef DEBUGGING
    yynsp -= yylen;
#endif


    *++yyvsp = yyval;
#ifdef DEBUGGING
    *++yynsp = (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.  */

    yyn = yyr1[yyn];

    yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
    if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
	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

    goto yynewstate;


  /*------------------------------------.
  | yyerrlab -- here on detecting error |
  `------------------------------------*/
  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;
	    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) {
		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 (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) {
	    /* Pop the error token.  */
	    YYPOPSTACK;
	    /* Pop the rest of the stack.  */
	    while (yyss < yyssp) {
		YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp);
		yydestruct (yystos[*yyssp], yyvsp);
		YYPOPSTACK;
	    }
	    YYABORT;
	}

	YYDSYMPRINTF ("Error: discarding", yytoken, &yylval);
	yydestruct (yytoken, &yylval);
	yychar = YYEMPTY;

    }

    /* Else will try to reuse lookahead token after shifting the error
	  token.  */
    goto yyerrlab1;


  /*----------------------------------------------------.
  | yyerrlab1 -- error raised explicitly by an action.  |
  `----------------------------------------------------*/
  yyerrlab1:
    yyerrstatus = 3;	/* Each real token shifted decrements this.  */

    for (;;) {
	yyn = yypact[yystate];
	if (yyn != YYPACT_NINF) {
	    yyn += YYTERROR;
	    if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) {
		yyn = yytable[yyn];
		if (0 < yyn)
		    break;
	    }
	}

	/* Pop the current state because it cannot handle the error token.  */
	if (yyssp == yyss)
	    YYABORT;

	YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp);
	yydestruct (yystos[yystate], yyvsp);
	yyvsp--;
#ifdef DEBUGGING
	yynsp--;
#endif
	yystate = *--yyssp;

	YY_STACK_PRINT (yyss, yyssp, yyvs, yyns);
    }

    if (yyn == YYFINAL)
	YYACCEPT;

    YYDPRINTF ((Perl_debug_log, "Shifting error token, "));

    *++yyvsp = yylval;
#ifdef DEBUGGING
    *++yynsp ="<err>";
#endif

    yystate = yyn;
    YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate));

    goto yynewstate;


  /*-------------------------------------.
  | yyacceptlab -- YYACCEPT comes here.  |
  `-------------------------------------*/
  yyacceptlab:
    yyresult = 0;
    goto yyreturn;

  /*-----------------------------------.
  | yyabortlab -- YYABORT comes here.  |
  `-----------------------------------*/
  yyabortlab:
    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 */

    return yyresult;
}
Commit	Line	Data
0de566d7	1	/* perly.c
	2	*
	3	* Copyright (c) 2004 Larry Wall
	4	*
	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.
	7	*
	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 #included
	11	* from the files perly.tab and perly.act.
	12	*
	13	* Here is an important copyright statement from the original, generated
	14	* file:
	15	*
	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.
	20	*/
	21
	22
	23	/* allow stack size to grow effectively without limit */
	24	#define YYMAXDEPTH 10000000
	25
79072805	26	#include "EXTERN.h"
864dbfa3	27	#define PERL_IN_PERLY_C
79072805	28	#include "perl.h"
09bef843	29
0de566d7	30	typedef signed char yysigned_char;
	31
	32	#ifdef DEBUGGING
	33	# define YYDEBUG 1
93a17b20	34	#else
0de566d7	35	# define YYDEBUG 0
93a17b20	36	#endif
09bef843	37
0de566d7	38	/* contains all the parser state tables; auto-generated from perly.y */
	39	#include "perly.tab"
	40
	41	# define YYSIZE_T size_t
	42
	43	#define yyerrok (yyerrstatus = 0)
	44	#define yyclearin (yychar = YYEMPTY)
	45	#define YYEMPTY (-2)
	46	#define YYEOF 0
	47
	48	#define YYACCEPT goto yyacceptlab
	49	#define YYABORT goto yyabortlab
	50	#define YYERROR goto yyerrlab1
	51
	52
	53	/* Like YYERROR except do call yyerror. This remains here temporarily
	54	to ease the transition to the new meaning of YYERROR, for GCC.
	55	Once GCC version 2 has supplanted version 1, this can go. */
	56
	57	#define YYFAIL goto yyerrlab
	58
	59	#define YYRECOVERING() (!!yyerrstatus)
	60
	61	#define YYBACKUP(Token, Value) \
	62	do \
	63	if (yychar == YYEMPTY && yylen == 1) { \
	64	yychar = (Token); \
	65	yylval = (Value); \
	66	yytoken = YYTRANSLATE (yychar); \
	67	YYPOPSTACK; \
	68	goto yybackup; \
	69	} \
	70	else { \
	71	yyerror ("syntax error: cannot back up"); \
	72	YYERROR; \
	73	} \
	74	while (0)
	75
	76	#define YYTERROR 1
	77	#define YYERRCODE 256
	78
0de566d7	79	/* Enable debugging if requested. */
9388183f	80	#ifdef DEBUGGING
0de566d7	81
	82	# define yydebug (DEBUG_p_TEST)
	83
	84	# define YYFPRINTF PerlIO_printf
	85
	86	# define YYDPRINTF(Args) \
	87	do { \
	88	if (yydebug) \
	89	YYFPRINTF Args; \
	90	} while (0)
	91
	92	# define YYDSYMPRINT(Args) \
	93	do { \
	94	if (yydebug) \
	95	yysymprint Args; \
	96	} while (0)
	97
9388183f	98	# define YYDSYMPRINTF(Title, Token, Value) \
0de566d7	99	do { \
	100	if (yydebug) { \
	101	YYFPRINTF (Perl_debug_log, "%s ", Title); \
9388183f	102	yysymprint (aTHX_ Perl_debug_log, Token, Value); \
0de566d7	103	YYFPRINTF (Perl_debug_log, "\n"); \
	104	} \
	105	} while (0)
	106
	107	/*--------------------------------.
	108	\| Print this symbol on YYOUTPUT. \|
	109	`--------------------------------*/
	110
	111	static void
	112	yysymprint (pTHX_ PerlIO yyoutput, int yytype, YYSTYPE yyvaluep)
	113	{
	114	/* Pacify ``unused variable'' warnings. */
	115	(void) yyvaluep;
	116
	117	if (yytype < YYNTOKENS) {
	118	YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
	119	# ifdef YYPRINT
	120	YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
9388183f	121	# else
9388183f	122	YYFPRINTF (yyoutput, "0x%x", yyvaluep->ival);
0de566d7	123	# endif
	124	}
	125	else
	126	YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
	127
	128	switch (yytype) {
	129	default:
	130	break;
	131	}
	132	YYFPRINTF (yyoutput, ")");
	133	}
	134
	135
9388183f	136	/* yy_stack_print()
	137	* print the top 8 items on the parse stack. The args have the same
	138	* meanings as the local vars in yyparse() of the same name */
0de566d7	139
0de566d7	140	static void
9388183f	141	yy_stack_print (pTHX_ short yyss, short yyssp, YYSTYPE yyvs, char*yyns)
0de566d7	142	{
9388183f	143	int i;
	144	int start = 1;
	145	int count = (int)(yyssp - yyss);
	146
	147	if (count > 8) {
	148	start = count - 8 + 1;
	149	count = 8;
	150	}
	151
	152	PerlIO_printf(Perl_debug_log, "\nindex:");
	153	for (i=0; i < count; i++)
	154	PerlIO_printf(Perl_debug_log, " %8d", start+i);
	155	PerlIO_printf(Perl_debug_log, "\nstate:");
	156	for (i=0, yyss += start; i < count; i++, yyss++)
	157	PerlIO_printf(Perl_debug_log, " %8d", *yyss);
	158	PerlIO_printf(Perl_debug_log, "\ntoken:");
	159	for (i=0, yyns += start; i < count; i++, yyns++)
	160	PerlIO_printf(Perl_debug_log, " %8.8s", *yyns);
	161	PerlIO_printf(Perl_debug_log, "\nvalue:");
	162	for (i=0, yyvs += start; i < count; i++, yyvs++)
	163	PerlIO_printf(Perl_debug_log, " %8x", yyvs->ival);
	164	PerlIO_printf(Perl_debug_log, "\n\n");
0de566d7	165	}
0de566d7	166
9388183f	167	# define YY_STACK_PRINT(yyss, yyssp, yyvs, yyns) \
0de566d7	168	do { \
9388183f	169	if (yydebug && DEBUG_v_TEST) \
9388183f	170	yy_stack_print (aTHX_ (yyss), (yyssp), (yyvs), (yyns)); \
0de566d7	171	} while (0)
0de566d7	172
09bef843	173
0de566d7	174	/*------------------------------------------------.
	175	\| Report that the YYRULE is going to be reduced. \|
	176	`------------------------------------------------*/
	177
	178	static void
	179	yy_reduce_print (pTHX_ int yyrule)
	180	{
	181	int yyi;
	182	unsigned int yylineno = yyrline[yyrule];
	183	YYFPRINTF (Perl_debug_log, "Reducing stack by rule %d (line %u), ",
	184	yyrule - 1, yylineno);
	185	/* Print the symbols being reduced, and their result. */
	186	for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
	187	YYFPRINTF (Perl_debug_log, "%s ", yytname [yyrhs[yyi]]);
	188	YYFPRINTF (Perl_debug_log, "-> %s\n", yytname [yyr1[yyrule]]);
	189	}
	190
	191	# define YY_REDUCE_PRINT(Rule) \
	192	do { \
	193	if (yydebug) \
	194	yy_reduce_print (aTHX_ Rule); \
	195	} while (0)
	196
	197	#else /* !DEBUGGING */
	198	# define YYDPRINTF(Args)
	199	# define YYDSYMPRINT(Args)
9388183f	200	# define YYDSYMPRINTF(Title, Token, Value)
9388183f	201	# define YY_STACK_PRINT(yyss, yyssp, yyvs, yyns)
0de566d7	202	# define YY_REDUCE_PRINT(Rule)
	203	#endif /* !DEBUGGING */
	204
	205
	206	/* YYINITDEPTH -- initial size of the parser's stacks. */
	207	#ifndef YYINITDEPTH
	208	# define YYINITDEPTH 200
09bef843	209	#endif
09bef843	210
0de566d7	211
	212	#if YYERROR_VERBOSE
	213	# ifndef yystrlen
	214	# if defined (__GLIBC__) && defined (_STRING_H)
	215	# define yystrlen strlen
	216	# else
	217	/* Return the length of YYSTR. */
	218	static YYSIZE_T
	219	yystrlen (const char *yystr)
	220	{
	221	register const char *yys = yystr;
	222
	223	while (*yys++ != '\0')
	224	continue;
	225
	226	return yys - yystr - 1;
	227	}
	228	# endif
	229	# endif
	230
	231	# ifndef yystpcpy
	232	# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
	233	# define yystpcpy stpcpy
	234	# else
	235	/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
	236	YYDEST. */
	237	static char *
	238	yystpcpy (pTHX_ char yydest, const char yysrc)
	239	{
	240	register char *yyd = yydest;
	241	register const char *yys = yysrc;
	242
	243	while ((yyd++ = yys++) != '\0')
	244	continue;
	245
	246	return yyd - 1;
	247	}
	248	# endif
	249	# endif
	250
	251	#endif /* !YYERROR_VERBOSE */
	252
	253
	254	/*-----------------------------------------------.
	255	\| Release the memory associated to this symbol. \|
	256	`-----------------------------------------------*/
	257
	258	static void
	259	yydestruct (int yytype, YYSTYPE *yyvaluep)
	260	{
	261	/* Pacify ``unused variable'' warnings. */
	262	(void) yyvaluep;
	263
	264	switch (yytype) {
	265	default:
	266	break;
	267	}
	268	}
	269
	270
	271
	272
	273	/*----------.
	274	\| yyparse. \|
275	`----------*/
276
79072805	277	int
0de566d7	278	Perl_yyparse (pTHX)
79072805	279	{
0de566d7	280	int yychar; /* The lookahead symbol. */
	281	YYSTYPE yylval; /* The semantic value of the lookahead symbol. */
	282	int yynerrs; /* Number of syntax errors so far. */
	283	register int yystate;
	284	register int yyn;
	285	int yyresult;
	286
	287	/* Number of tokens to shift before error messages enabled. */
	288	int yyerrstatus;
	289	/* Lookahead token as an internal (translated) token number. */
	290	int yytoken = 0;
	291
	292	/* two stacks and their tools:
	293	`yyss': related to states,
	294	`yyvs': related to semantic values,
	295
	296	Refer to the stacks thru separate pointers, to allow yyoverflow
	297	to reallocate them elsewhere. */
	298
	299	/* The state stack. */
	300	short *yyss;
93a17b20	301	register short *yyssp;
0de566d7	302
	303	/* The semantic value stack. */
	304	YYSTYPE *yyvs;
93a17b20	305	register YYSTYPE *yyvsp;
a0d0e21e	306
0de566d7	307	/* for ease of re-allocation and automatic freeing, have two SVs whose
	308	* SvPVX points to the stacks */
	309	SV yyss_sv, yyvs_sv;
	310
9388183f	311	#ifdef DEBUGGING
	312	/* maintain also a stack of token/rule names for debugging with -Dpv */
	313	char yyns, yynsp;
	314	SV *yyns_sv;
	315	# define YYPOPSTACK (yyvsp--, yyssp--, yynsp--)
	316	#else
	317	# define YYPOPSTACK (yyvsp--, yyssp--)
	318	#endif
	319
0de566d7	320
	321	YYSIZE_T yystacksize = YYINITDEPTH;
	322
	323	/* The variables used to return semantic value and location from the
	324	action routines. */
	325	YYSTYPE yyval;
	326
	327
	328	/* When reducing, the number of symbols on the RHS of the reduced
	329	rule. */
	330	int yylen;
	331
	332	YYDPRINTF ((Perl_debug_log, "Starting parse\n"));
	333
0de566d7	334	ENTER; /* force stack free before we return */
12fbd33b	335	SAVEVPTR(PL_yycharp);
	336	SAVEVPTR(PL_yylvalp);
	337	PL_yycharp = &yychar; /* so PL_yyerror() can access it */
	338	PL_yylvalp = &yylval; /* so various functions in toke.c can access it */
	339
9388183f	340	yyss_sv = NEWSV(73, YYINITDEPTH * sizeof(short));
9388183f	341	yyvs_sv = NEWSV(73, YYINITDEPTH * sizeof(YYSTYPE));
0de566d7	342	SAVEFREESV(yyss_sv);
	343	SAVEFREESV(yyvs_sv);
	344	yyss = (short *) SvPVX(yyss_sv);
	345	yyvs = (YYSTYPE *) SvPVX(yyvs_sv);
9388183f	346	/* note that elements zero of yyvs and yyns are not used */
	347	yyssp = yyss;
	348	yyvsp = yyvs;
	349	#ifdef DEBUGGING
	350	yyns_sv = NEWSV(73, YYINITDEPTH * sizeof(char *));
	351	SAVEFREESV(yyns_sv);
	352	yyns = (char **) SvPVX(yyns_sv);
	353	yynsp = yyns;
	354	#endif
79072805	355
0de566d7	356	yystate = 0;
0de566d7	357	yyerrstatus = 0;
93a17b20	358	yynerrs = 0;
0de566d7	359	yychar = YYEMPTY; /* Cause a token to be read. */
0de566d7	360
79072805	361
9388183f	362
9388183f	363	YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate));
0de566d7	364
	365	goto yysetstate;
	366
	367	/*------------------------------------------------------------.
	368	\| yynewstate -- Push a new state, which is found in yystate. \|
	369	`------------------------------------------------------------*/
	370	yynewstate:
	371	/* In all cases, when you get here, the value and location stacks
	372	have just been pushed. so pushing a state here evens the stacks.
	373	*/
	374	yyssp++;
	375
	376	yysetstate:
	377	*yyssp = yystate;
	378
	379	if (yyss + yystacksize - 1 <= yyssp) {
	380	/* Get the current used size of the three stacks, in elements. */
	381	YYSIZE_T yysize = yyssp - yyss + 1;
	382
	383	/* Extend the stack our own way. */
	384	if (YYMAXDEPTH <= yystacksize)
	385	goto yyoverflowlab;
	386	yystacksize *= 2;
	387	if (YYMAXDEPTH < yystacksize)
	388	yystacksize = YYMAXDEPTH;
	389
	390	SvGROW(yyss_sv, yystacksize * sizeof(short));
	391	SvGROW(yyvs_sv, yystacksize * sizeof(YYSTYPE));
	392	yyss = (short *) SvPVX(yyss_sv);
	393	yyvs = (YYSTYPE *) SvPVX(yyvs_sv);
9388183f	394	#ifdef DEBUGGING
	395	SvGROW(yyns_sv, yystacksize * sizeof(char *));
	396	yyns = (char **) SvPVX(yyns_sv);
	397	if (! yyns)
	398	goto yyoverflowlab;
	399	yynsp = yyns + yysize - 1;
	400	#endif
0de566d7	401	if (!yyss \|\| ! yyvs)
	402	goto yyoverflowlab;
	403
	404	yyssp = yyss + yysize - 1;
	405	yyvsp = yyvs + yysize - 1;
	406
	407
	408	YYDPRINTF ((Perl_debug_log, "Stack size increased to %lu\n",
	409	(unsigned long int) yystacksize));
	410
	411	if (yyss + yystacksize - 1 <= yyssp)
	412	YYABORT;
93a17b20	413	}
0de566d7	414
0de566d7	415	goto yybackup;
	416
	417	/*-----------.
	418	\| yybackup. \|
	419	`-----------*/
	420	yybackup:
	421
	422	/* Do appropriate processing given the current state. */
	423	/* Read a lookahead token if we need one and don't already have one. */
	424	/* yyresume: */
	425
	426	/* First try to decide what to do without reference to lookahead token. */
	427
	428	yyn = yypact[yystate];
	429	if (yyn == YYPACT_NINF)
	430	goto yydefault;
	431
	432	/* Not known => get a lookahead token if don't already have one. */
	433
	434	/* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
	435	if (yychar == YYEMPTY) {
	436	YYDPRINTF ((Perl_debug_log, "Reading a token: "));
12fbd33b	437	yychar = yylex();
	438	# ifdef EBCDIC
	439	if (yychar >= 0 && yychar < 255) {
	440	yychar = NATIVE_TO_ASCII(yychar);
	441	}
	442	# endif
0de566d7	443	}
	444
	445	if (yychar <= YYEOF) {
	446	yychar = yytoken = YYEOF;
	447	YYDPRINTF ((Perl_debug_log, "Now at end of input.\n"));
93a17b20	448	}
0de566d7	449	else {
0de566d7	450	yytoken = YYTRANSLATE (yychar);
9388183f	451	YYDSYMPRINTF ("Next token is", yytoken, &yylval);
93a17b20	452	}
771df094	453
0de566d7	454	/* If the proper action on seeing token YYTOKEN is to reduce or to
	455	detect an error, take that action. */
	456	yyn += yytoken;
	457	if (yyn < 0 \|\| YYLAST < yyn \|\| yycheck[yyn] != yytoken)
	458	goto yydefault;
	459	yyn = yytable[yyn];
	460	if (yyn <= 0) {
	461	if (yyn == 0 \|\| yyn == YYTABLE_NINF)
	462	goto yyerrlab;
	463	yyn = -yyn;
	464	goto yyreduce;
	465	}
7b57b0ea	466
0de566d7	467	if (yyn == YYFINAL)
0de566d7	468	YYACCEPT;
771df094	469
0de566d7	470	/* Shift the lookahead token. */
	471	YYDPRINTF ((Perl_debug_log, "Shifting token %s, ", yytname[yytoken]));
	472
	473	/* Discard the token being shifted unless it is eof. */
	474	if (yychar != YYEOF)
	475	yychar = YYEMPTY;
	476
	477	*++yyvsp = yylval;
9388183f	478	#ifdef DEBUGGING
	479	++yynsp = (char )(yytname[yytoken]);
	480	#endif
0de566d7	481
	482
	483	/* Count tokens shifted since error; after three, turn off error
	484	status. */
	485	if (yyerrstatus)
	486	yyerrstatus--;
	487
	488	yystate = yyn;
9388183f	489	YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate));
9388183f	490
0de566d7	491	goto yynewstate;
	492
	493
	494	/*-----------------------------------------------------------.
	495	\| yydefault -- do the default action for the current state. \|
	496	`-----------------------------------------------------------*/
	497	yydefault:
	498	yyn = yydefact[yystate];
	499	if (yyn == 0)
	500	goto yyerrlab;
	501	goto yyreduce;
	502
	503
	504	/*-----------------------------.
	505	\| yyreduce -- Do a reduction. \|
	506	`-----------------------------*/
	507	yyreduce:
	508	/* yyn is the number of a rule to reduce with. */
	509	yylen = yyr2[yyn];
	510
	511	/* If YYLEN is nonzero, implement the default value of the action:
	512	`$$ = $1'.
	513
	514	Otherwise, the following line sets YYVAL to garbage.
	515	This behavior is undocumented and Bison
	516	users should not rely upon it. Assigning to YYVAL
	517	unconditionally makes the parser a bit smaller, and it avoids a
	518	GCC warning that YYVAL may be used uninitialized. */
	519	yyval = yyvsp[1-yylen];
	520
	521
	522	YY_REDUCE_PRINT (yyn);
	523	switch (yyn) {
	524
	525	/* contains all the rule actions; auto-generated from perly.y */
	526
	527	#define dep() deprecate("\"do\" to call subroutines")
	528	#include "perly.act"
7b57b0ea	529
93a17b20	530	}
0de566d7	531
	532	yyvsp -= yylen;
	533	yyssp -= yylen;
9388183f	534	#ifdef DEBUGGING
	535	yynsp -= yylen;
	536	#endif
0de566d7	537
0de566d7	538
0de566d7	539	*++yyvsp = yyval;
9388183f	540	#ifdef DEBUGGING
	541	++yynsp = (char )(yytname [yyr1[yyn]]);
	542	#endif
0de566d7	543
	544	/* Now `shift' the result of the reduction. Determine what state
	545	that goes to, based on the state we popped back to and the rule
	546	number reduced by. */
	547
	548	yyn = yyr1[yyn];
	549
	550	yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
	551	if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
	552	yystate = yytable[yystate];
93a17b20	553	else
0de566d7	554	yystate = yydefgoto[yyn - YYNTOKENS];
0de566d7	555
9388183f	556	YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate));
	557
	558	#ifdef DEBUGGING
	559	/* tmp push yystate for stack print; this is normally pushed later in
	560	* yynewstate */
	561	yyssp++;
	562	*yyssp = yystate;
	563	YY_STACK_PRINT (yyss, yyssp, yyvs, yyns);
	564	yyssp--;
	565	#endif
	566
0de566d7	567	goto yynewstate;
	568
	569
	570	/*------------------------------------.
	571	\| yyerrlab -- here on detecting error \|
	572	`------------------------------------*/
	573	yyerrlab:
	574	/* If not already recovering from an error, report this error. */
	575	if (!yyerrstatus) {
	576	++yynerrs;
	577	#if YYERROR_VERBOSE
	578	yyn = yypact[yystate];
	579
	580	if (YYPACT_NINF < yyn && yyn < YYLAST) {
	581	YYSIZE_T yysize = 0;
	582	int yytype = YYTRANSLATE (yychar);
	583	char *yymsg;
	584	int yyx, yycount;
	585
	586	yycount = 0;
	587	/* Start YYX at -YYN if negative to avoid negative indexes in
	588	YYCHECK. */
	589	for (yyx = yyn < 0 ? -yyn : 0;
	590	yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
	591	if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
	592	yysize += yystrlen (yytname[yyx]) + 15, yycount++;
	593	yysize += yystrlen ("syntax error, unexpected ") + 1;
	594	yysize += yystrlen (yytname[yytype]);
	595	New(yymsg, yysize, char *);
	596	if (yymsg != 0) {
	597	char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
	598	yyp = yystpcpy (yyp, yytname[yytype]);
	599
	600	if (yycount < 5) {
	601	yycount = 0;
	602	for (yyx = yyn < 0 ? -yyn : 0;
	603	yyx < (int) (sizeof (yytname) / sizeof (char *));
	604	yyx++)
	605	{
	606	if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) {
	607	const char *yyq = ! yycount ?
	608	", expecting " : " or ";
	609	yyp = yystpcpy (yyp, yyq);
	610	yyp = yystpcpy (yyp, yytname[yyx]);
	611	yycount++;
	612	}
	613	}
ecb2f335	614	}
0de566d7	615	yyerror (yymsg);
	616	YYSTACK_FREE (yymsg);
	617	}
	618	else
	619	yyerror ("syntax error; also virtual memory exhausted");
	620	}
	621	else
	622	#endif /* YYERROR_VERBOSE */
	623	yyerror ("syntax error");
93a17b20	624	}
0de566d7	625
	626
	627	if (yyerrstatus == 3) {
	628	/* If just tried and failed to reuse lookahead token after an
	629	error, discard it. */
	630
	631	/* Return failure if at end of input. */
	632	if (yychar == YYEOF) {
	633	/* Pop the error token. */
	634	YYPOPSTACK;
	635	/* Pop the rest of the stack. */
	636	while (yyss < yyssp) {
9388183f	637	YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp);
0de566d7	638	yydestruct (yystos[*yyssp], yyvsp);
	639	YYPOPSTACK;
	640	}
	641	YYABORT;
	642	}
	643
9388183f	644	YYDSYMPRINTF ("Error: discarding", yytoken, &yylval);
0de566d7	645	yydestruct (yytoken, &yylval);
	646	yychar = YYEMPTY;
	647
93a17b20	648	}
0de566d7	649
	650	/* Else will try to reuse lookahead token after shifting the error
	651	token. */
	652	goto yyerrlab1;
	653
	654
	655	/*----------------------------------------------------.
	656	\| yyerrlab1 -- error raised explicitly by an action. \|
	657	`----------------------------------------------------*/
	658	yyerrlab1:
	659	yyerrstatus = 3; /* Each real token shifted decrements this. */
	660
	661	for (;;) {
	662	yyn = yypact[yystate];
	663	if (yyn != YYPACT_NINF) {
	664	yyn += YYTERROR;
	665	if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) {
	666	yyn = yytable[yyn];
	667	if (0 < yyn)
	668	break;
	669	}
	670	}
	671
	672	/* Pop the current state because it cannot handle the error token. */
	673	if (yyssp == yyss)
	674	YYABORT;
	675
9388183f	676	YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp);
0de566d7	677	yydestruct (yystos[yystate], yyvsp);
0de566d7	678	yyvsp--;
9388183f	679	#ifdef DEBUGGING
	680	yynsp--;
	681	#endif
0de566d7	682	yystate = *--yyssp;
0de566d7	683
9388183f	684	YY_STACK_PRINT (yyss, yyssp, yyvs, yyns);
93a17b20	685	}
0de566d7	686
	687	if (yyn == YYFINAL)
	688	YYACCEPT;
	689
	690	YYDPRINTF ((Perl_debug_log, "Shifting error token, "));
	691
	692	*++yyvsp = yylval;
9388183f	693	#ifdef DEBUGGING
	694	*++yynsp ="<err>";
	695	#endif
0de566d7	696
0de566d7	697	yystate = yyn;
9388183f	698	YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate));
9388183f	699
0de566d7	700	goto yynewstate;
	701
	702
	703	/*-------------------------------------.
	704	\| yyacceptlab -- YYACCEPT comes here. \|
	705	`-------------------------------------*/
	706	yyacceptlab:
	707	yyresult = 0;
	708	goto yyreturn;
	709
	710	/*-----------------------------------.
	711	\| yyabortlab -- YYABORT comes here. \|
	712	`-----------------------------------*/
	713	yyabortlab:
	714	yyresult = 1;
	715	goto yyreturn;
	716
	717	/*----------------------------------------------.
	718	\| yyoverflowlab -- parser overflow comes here. \|
	719	`----------------------------------------------*/
	720	yyoverflowlab:
	721	yyerror ("parser stack overflow");
	722	yyresult = 2;
	723	/* Fall through. */
	724
	725	yyreturn:
	726
12fbd33b	727	LEAVE; /* force stack free before we return */
e1f15930	728
0de566d7	729	return yyresult;
e1f15930	730	}