[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, 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)
{
    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 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);
    /* 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;

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


	 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]);
	    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 (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;
}

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