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