[perl5.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, 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)
{
    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 */
    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.  */
    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 = (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;

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


	 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 = (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));

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

    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;
	    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 */
	    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);
		YYPOPSTACK;
	    }
	    YYABORT;
	}

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