embedaddon/php/Zend/zend_ini_parser.c - diff

Return to zend_ini_parser.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / Zend

Diff for /embedaddon/php/Zend/zend_ini_parser.c between versions 1.1 and 1.1.1.3

version 1.1, 2012/02/21 23:47:52	version 1.1.1.3, 2013/07/22 01:32:15
Line 1	Line 1
	/* A Bison parser, made by GNU Bison 2.3. */

/* A Bison parser, made by GNU Bison 2.4.1. */

/* Skeleton implementation for Bison's Yacc-like parsers in C	/* Skeleton implementation for Bison's Yacc-like parsers in C

Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006	Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
Free Software Foundation, Inc.	Free Software Foundation, Inc.

This program is free software: you can redistribute it and/or modify	This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by	it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or	the Free Software Foundation; either version 2, or (at your option)
(at your option) any later version.	any later version.

This program is distributed in the hope that it will be useful,	This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of	but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.	GNU General Public License for more details.

You should have received a copy of the GNU General Public License	You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */	along with this program; if not, write to the Free Software
	Foundation, Inc., 51 Franklin Street, Fifth Floor,
	Boston, MA 02110-1301, USA. */

/* As a special exception, you may create a larger work that contains	/* As a special exception, you may create a larger work that contains
part or all of the Bison parser skeleton and distribute that work	part or all of the Bison parser skeleton and distribute that work
Line 28	Line 29
special exception, which will cause the skeleton and the resulting	special exception, which will cause the skeleton and the resulting
Bison output files to be licensed under the GNU General Public	Bison output files to be licensed under the GNU General Public
License without this special exception.	License without this special exception.

This special exception was added by the Free Software Foundation in	This special exception was added by the Free Software Foundation in
version 2.2 of Bison. */	version 2.2 of Bison. */

Line 46	Line 47
#define YYBISON 1	#define YYBISON 1

/* Bison version. */	/* Bison version. */
#define YYBISON_VERSION "2.4.1"	#define YYBISON_VERSION "2.3"

/* Skeleton name. */	/* Skeleton name. */
#define YYSKELETON_NAME "yacc.c"	#define YYSKELETON_NAME "yacc.c"
Line 54	Line 55
/* Pure parsers. */	/* Pure parsers. */
#define YYPURE 1	#define YYPURE 1

/* Push parsers. */
#define YYPUSH 0

/* Pull parsers. */
#define YYPULL 1

/* Using locations. */	/* Using locations. */
#define YYLSP_NEEDED 0	#define YYLSP_NEEDED 0

/* Substitute the variable and function names. */	/* Substitute the variable and function names. */
#define yyparse ini_parse	#define yyparse ini_parse
#define yylex ini_lex	#define yylex ini_lex
#define yyerror ini_error	#define yyerror ini_error
#define yylval ini_lval	#define yylval ini_lval
#define yychar ini_char	#define yychar ini_char
#define yydebug ini_debug	#define yydebug ini_debug
#define yynerrs ini_nerrs	#define yynerrs ini_nerrs


	/* Tokens. */
	#ifndef YYTOKENTYPE
	# define YYTOKENTYPE
	/* Put the tokens into the symbol table, so that GDB and other debuggers
	know about them. */
	enum yytokentype {
	TC_SECTION = 258,
	TC_RAW = 259,
	TC_CONSTANT = 260,
	TC_NUMBER = 261,
	TC_STRING = 262,
	TC_WHITESPACE = 263,
	TC_LABEL = 264,
	TC_OFFSET = 265,
	TC_DOLLAR_CURLY = 266,
	TC_VARNAME = 267,
	TC_QUOTED_STRING = 268,
	BOOL_TRUE = 269,
	BOOL_FALSE = 270,
	END_OF_LINE = 271
	};
	#endif
	/* Tokens. */
	#define TC_SECTION 258
	#define TC_RAW 259
	#define TC_CONSTANT 260
	#define TC_NUMBER 261
	#define TC_STRING 262
	#define TC_WHITESPACE 263
	#define TC_LABEL 264
	#define TC_OFFSET 265
	#define TC_DOLLAR_CURLY 266
	#define TC_VARNAME 267
	#define TC_QUOTED_STRING 268
	#define BOOL_TRUE 269
	#define BOOL_FALSE 270
	#define END_OF_LINE 271




/* Copy the first part of user declarations. */	/* Copy the first part of user declarations. */


Line 80	Line 116
+----------------------------------------------------------------------+	+----------------------------------------------------------------------+
\| Zend Engine \|	\| Zend Engine \|
+----------------------------------------------------------------------+	+----------------------------------------------------------------------+
\| Copyright (c) 1998-2012 Zend Technologies Ltd. (http://www.zend.com) \|	\| Copyright (c) 1998-2013 Zend Technologies Ltd. (http://www.zend.com) \|
+----------------------------------------------------------------------+	+----------------------------------------------------------------------+
\| This source file is subject to version 2.00 of the Zend license, \|	\| This source file is subject to version 2.00 of the Zend license, \|
\| that is bundled with this package in the file LICENSE, and is \|	\| that is bundled with this package in the file LICENSE, and is \|
Line 323 ZEND_API int zend_parse_ini_string(char *str, zend_boo	Line 359 ZEND_API int zend_parse_ini_string(char *str, zend_boo




/* Enabling traces. */	/* Enabling traces. */
#ifndef YYDEBUG	#ifndef YYDEBUG
# define YYDEBUG 0	# define YYDEBUG 0
Line 342 ZEND_API int zend_parse_ini_string(char *str, zend_boo	Line 377 ZEND_API int zend_parse_ini_string(char *str, zend_boo
# define YYTOKEN_TABLE 0	# define YYTOKEN_TABLE 0
#endif	#endif


/* Tokens. */
#ifndef YYTOKENTYPE
# define YYTOKENTYPE
/* Put the tokens into the symbol table, so that GDB and other debuggers
know about them. */
enum yytokentype {
TC_SECTION = 258,
TC_RAW = 259,
TC_CONSTANT = 260,
TC_NUMBER = 261,
TC_STRING = 262,
TC_WHITESPACE = 263,
TC_LABEL = 264,
TC_OFFSET = 265,
TC_DOLLAR_CURLY = 266,
TC_VARNAME = 267,
TC_QUOTED_STRING = 268,
BOOL_TRUE = 269,
BOOL_FALSE = 270,
END_OF_LINE = 271
};
#endif
/* Tokens. */
#define TC_SECTION 258
#define TC_RAW 259
#define TC_CONSTANT 260
#define TC_NUMBER 261
#define TC_STRING 262
#define TC_WHITESPACE 263
#define TC_LABEL 264
#define TC_OFFSET 265
#define TC_DOLLAR_CURLY 266
#define TC_VARNAME 267
#define TC_QUOTED_STRING 268
#define BOOL_TRUE 269
#define BOOL_FALSE 270
#define END_OF_LINE 271




#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED	#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
typedef int YYSTYPE;	typedef int YYSTYPE;
# define YYSTYPE_IS_TRIVIAL 1
# define yystype YYSTYPE /* obsolescent; will be withdrawn */	# define yystype YYSTYPE /* obsolescent; will be withdrawn */
# define YYSTYPE_IS_DECLARED 1	# define YYSTYPE_IS_DECLARED 1
	# define YYSTYPE_IS_TRIVIAL 1
#endif	#endif



/* Copy the second part of user declarations. */	/* Copy the second part of user declarations. */


	/* Line 216 of yacc.c. */


#ifdef short	#ifdef short
# undef short	# undef short
#endif	#endif
Line 444 typedef short int yytype_int16;	Line 440 typedef short int yytype_int16;
#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)	#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)

#ifndef YY_	#ifndef YY_
# if YYENABLE_NLS	# if defined YYENABLE_NLS && YYENABLE_NLS
# if ENABLE_NLS	# if ENABLE_NLS
# include <libintl.h> /* INFRINGES ON USER NAME SPACE */	# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
# define YY_(msgid) dgettext ("bison-runtime", msgid)	# define YY_(msgid) dgettext ("bison-runtime", msgid)
Line 469 typedef short int yytype_int16;	Line 465 typedef short int yytype_int16;
#if (defined __STDC__ \|\| defined __C99__FUNC__ \	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
\|\| defined __cplusplus \|\| defined _MSC_VER)	\|\| defined __cplusplus \|\| defined _MSC_VER)
static int	static int
YYID (int yyi)	YYID (int i)
#else	#else
static int	static int
YYID (yyi)	YYID (i)
int yyi;	int i;
#endif	#endif
{	{
return yyi;	return i;
}	}
#endif	#endif

Line 557 void free (void ); / INFRINGES ON USER NAME SPACE */	Line 553 void free (void ); / INFRINGES ON USER NAME SPACE */
/* A type that is properly aligned for any stack member. */	/* A type that is properly aligned for any stack member. */
union yyalloc	union yyalloc
{	{
yytype_int16 yyss_alloc;	yytype_int16 yyss;
YYSTYPE yyvs_alloc;	YYSTYPE yyvs;
};	};

/* The size of the maximum gap between one aligned stack and the next. */	/* The size of the maximum gap between one aligned stack and the next. */
# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)	# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
Line 593 union yyalloc	Line 589 union yyalloc
elements in the stack, and YYPTR gives the new location of the	elements in the stack, and YYPTR gives the new location of the
stack. Advance YYPTR to a properly aligned location for the next	stack. Advance YYPTR to a properly aligned location for the next
stack. */	stack. */
# define YYSTACK_RELOCATE(Stack_alloc, Stack) \	# define YYSTACK_RELOCATE(Stack) \
do \	do \
{ \	{ \
YYSIZE_T yynewbytes; \	YYSIZE_T yynewbytes; \
YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \	YYCOPY (&yyptr->Stack, Stack, yysize); \
Stack = &yyptr->Stack_alloc; \	Stack = &yyptr->Stack; \
yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
yyptr += yynewbytes / sizeof (*yyptr); \	yyptr += yynewbytes / sizeof (*yyptr); \
} \	} \
Line 709 static const char *const yytname[] =	Line 705 static const char *const yytname[] =
"$end", "error", "$undefined", "TC_SECTION", "TC_RAW", "TC_CONSTANT",	"$end", "error", "$undefined", "TC_SECTION", "TC_RAW", "TC_CONSTANT",
"TC_NUMBER", "TC_STRING", "TC_WHITESPACE", "TC_LABEL", "TC_OFFSET",	"TC_NUMBER", "TC_STRING", "TC_WHITESPACE", "TC_LABEL", "TC_OFFSET",
"TC_DOLLAR_CURLY", "TC_VARNAME", "TC_QUOTED_STRING", "BOOL_TRUE",	"TC_DOLLAR_CURLY", "TC_VARNAME", "TC_QUOTED_STRING", "BOOL_TRUE",
"BOOL_FALSE", "END_OF_LINE", "'='", "':'", "','", "'.'", "'\"'", "'\\''",	"BOOL_FALSE", "END_OF_LINE", "'='", "':'", "','", "'.'", "'\"'", "'''",
"'^'", "'+'", "'-'", "'/'", "'*'", "'%'", "'$'", "'~'", "'<'", "'>'",	"'^'", "'+'", "'-'", "'/'", "'*'", "'%'", "'$'", "'~'", "'<'", "'>'",
"'?'", "'@'", "'{'", "'}'", "'\|'", "'&'", "'!'", "']'", "'('", "')'",	"'?'", "'@'", "'{'", "'}'", "'\|'", "'&'", "'!'", "']'", "'('", "')'",
"$accept", "statement_list", "statement", "section_string_or_value",	"$accept", "statement_list", "statement", "section_string_or_value",
Line 913 while (YYID (0))	Line 909 while (YYID (0))
we won't break user code: when these are the locations we know. */	we won't break user code: when these are the locations we know. */

#ifndef YY_LOCATION_PRINT	#ifndef YY_LOCATION_PRINT
# if YYLTYPE_IS_TRIVIAL	# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
# define YY_LOCATION_PRINT(File, Loc) \	# define YY_LOCATION_PRINT(File, Loc) \
fprintf (File, "%d.%d-%d.%d", \	fprintf (File, "%d.%d-%d.%d", \
(Loc).first_line, (Loc).first_column, \	(Loc).first_line, (Loc).first_column, \
Line 1024 yy_symbol_print (yyoutput, yytype, yyvaluep)	Line 1020 yy_symbol_print (yyoutput, yytype, yyvaluep)
#if (defined __STDC__ \|\| defined __C99__FUNC__ \	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
\|\| defined __cplusplus \|\| defined _MSC_VER)	\|\| defined __cplusplus \|\| defined _MSC_VER)
static void	static void
yy_stack_print (yytype_int16 yybottom, yytype_int16 yytop)	yy_stack_print (yytype_int16 bottom, yytype_int16 top)
#else	#else
static void	static void
yy_stack_print (yybottom, yytop)	yy_stack_print (bottom, top)
yytype_int16 *yybottom;	yytype_int16 *bottom;
yytype_int16 *yytop;	yytype_int16 *top;
#endif	#endif
{	{
YYFPRINTF (stderr, "Stack now");	YYFPRINTF (stderr, "Stack now");
for (; yybottom <= yytop; yybottom++)	for (; bottom <= top; ++bottom)
{	YYFPRINTF (stderr, " %d", *bottom);
int yybot = *yybottom;
YYFPRINTF (stderr, " %d", yybot);
}
YYFPRINTF (stderr, "\n");	YYFPRINTF (stderr, "\n");
}	}

Line 1071 yy_reduce_print (yyvsp, yyrule)	Line 1064 yy_reduce_print (yyvsp, yyrule)
/* The symbols being reduced. */	/* The symbols being reduced. */
for (yyi = 0; yyi < yynrhs; yyi++)	for (yyi = 0; yyi < yynrhs; yyi++)
{	{
YYFPRINTF (stderr, " $%d = ", yyi + 1);	fprintf (stderr, " $%d = ", yyi + 1);
yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],	yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
&(yyvsp[(yyi + 1) - (yynrhs)])	&(yyvsp[(yyi + 1) - (yynrhs)])
);	);
YYFPRINTF (stderr, "\n");	fprintf (stderr, "\n");
}	}
}	}

Line 1355 yydestruct (yymsg, yytype, yyvaluep)	Line 1348 yydestruct (yymsg, yytype, yyvaluep)
break;	break;
}	}
}	}


/* Prevent warnings from -Wmissing-prototypes. */	/* Prevent warnings from -Wmissing-prototypes. */

#ifdef YYPARSE_PARAM	#ifdef YYPARSE_PARAM
#if defined __STDC__ \|\| defined __cplusplus	#if defined __STDC__ \|\| defined __cplusplus
int yyparse (void *YYPARSE_PARAM);	int yyparse (void *YYPARSE_PARAM);
Line 1375 int yyparse ();	Line 1370 int yyparse ();



/*-------------------------.
\| yyparse or yypush_parse. \|
`-------------------------*/

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

#ifdef YYPARSE_PARAM	#ifdef YYPARSE_PARAM
#if (defined __STDC__ \|\| defined __C99__FUNC__ \	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
\|\| defined __cplusplus \|\| defined _MSC_VER)	\|\| defined __cplusplus \|\| defined _MSC_VER)
Line 1401 yyparse ()	Line 1397 yyparse ()
#endif	#endif
#endif	#endif
{	{
/* The lookahead symbol. */	/* The look-ahead symbol. */
int yychar;	int yychar;

/* The semantic value of the lookahead symbol. */	/* The semantic value of the look-ahead symbol. */
YYSTYPE yylval;	YYSTYPE yylval;

/* Number of syntax errors so far. */	/* Number of syntax errors so far. */
int yynerrs;	int yynerrs;

int yystate;	int yystate;
/* Number of tokens to shift before error messages enabled. */
int yyerrstatus;

/* The 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. */
yytype_int16 yyssa[YYINITDEPTH];
yytype_int16 *yyss;
yytype_int16 *yyssp;

/* The semantic value stack. */
YYSTYPE yyvsa[YYINITDEPTH];
YYSTYPE *yyvs;
YYSTYPE *yyvsp;

YYSIZE_T yystacksize;

int yyn;	int yyn;
int yyresult;	int yyresult;
/* Lookahead token as an internal (translated) token number. */	/* Number of tokens to shift before error messages enabled. */
int yytoken;	int yyerrstatus;
/* The variables used to return semantic value and location from the	/* Look-ahead token as an internal (translated) token number. */
action routines. */	int yytoken = 0;
YYSTYPE yyval;

#if YYERROR_VERBOSE	#if YYERROR_VERBOSE
/* Buffer for error messages, and its allocated size. */	/* Buffer for error messages, and its allocated size. */
char yymsgbuf[128];	char yymsgbuf[128];
Line 1448 YYSTYPE yylval;	Line 1420 YYSTYPE yylval;
YYSIZE_T yymsg_alloc = sizeof yymsgbuf;	YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
#endif	#endif

	/* Three stacks and their tools:
	`yyss': related to states,
	`yyvs': related to semantic values,
	`yyls': related to locations.

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

	/* The state stack. */
	yytype_int16 yyssa[YYINITDEPTH];
	yytype_int16 *yyss = yyssa;
	yytype_int16 *yyssp;

	/* The semantic value stack. */
	YYSTYPE yyvsa[YYINITDEPTH];
	YYSTYPE *yyvs = yyvsa;
	YYSTYPE *yyvsp;



#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))	#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))

	YYSIZE_T yystacksize = YYINITDEPTH;

	/* The variables used to return semantic value and location from the
	action routines. */
	YYSTYPE yyval;


/* The number of symbols on the RHS of the reduced rule.	/* The number of symbols on the RHS of the reduced rule.
Keep to zero when no symbol should be popped. */	Keep to zero when no symbol should be popped. */
int yylen = 0;	int yylen = 0;

yytoken = 0;
yyss = yyssa;
yyvs = yyvsa;
yystacksize = YYINITDEPTH;

YYDPRINTF ((stderr, "Starting parse\n"));	YYDPRINTF ((stderr, "Starting parse\n"));

yystate = 0;	yystate = 0;
yyerrstatus = 0;	yyerrstatus = 0;
yynerrs = 0;	yynerrs = 0;
yychar = YYEMPTY; /* Cause a token to be read. */	yychar = YYEMPTY; /* Cause a token to be read. */

/* Initialize stack pointers.	/* Initialize stack pointers.
Waste one element of value and location stack	Waste one element of value and location stack
so that they stay on the same level as the state stack.	so that they stay on the same level as the state stack.
The wasted elements are never initialized. */	The wasted elements are never initialized. */

yyssp = yyss;	yyssp = yyss;
yyvsp = yyvs;	yyvsp = yyvs;

Line 1499 YYSTYPE yylval;	Line 1494 YYSTYPE yylval;
YYSTYPE *yyvs1 = yyvs;	YYSTYPE *yyvs1 = yyvs;
yytype_int16 *yyss1 = yyss;	yytype_int16 *yyss1 = yyss;


/* Each stack pointer address is followed by the size of the	/* Each stack pointer address is followed by the size of the
data in use in that stack, in bytes. This used to be a	data in use in that stack, in bytes. This used to be a
conditional around just the two extra args, but that might	conditional around just the two extra args, but that might
Line 1506 YYSTYPE yylval;	Line 1502 YYSTYPE yylval;
yyoverflow (YY_("memory exhausted"),	yyoverflow (YY_("memory exhausted"),
&yyss1, yysize * sizeof (*yyssp),	&yyss1, yysize * sizeof (*yyssp),
&yyvs1, yysize * sizeof (*yyvsp),	&yyvs1, yysize * sizeof (*yyvsp),

&yystacksize);	&yystacksize);

yyss = yyss1;	yyss = yyss1;
Line 1528 YYSTYPE yylval;	Line 1525 YYSTYPE yylval;
(union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));	(union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
if (! yyptr)	if (! yyptr)
goto yyexhaustedlab;	goto yyexhaustedlab;
YYSTACK_RELOCATE (yyss_alloc, yyss);	YYSTACK_RELOCATE (yyss);
YYSTACK_RELOCATE (yyvs_alloc, yyvs);	YYSTACK_RELOCATE (yyvs);

# undef YYSTACK_RELOCATE	# undef YYSTACK_RELOCATE
if (yyss1 != yyssa)	if (yyss1 != yyssa)
YYSTACK_FREE (yyss1);	YYSTACK_FREE (yyss1);
Line 1540 YYSTYPE yylval;	Line 1538 YYSTYPE yylval;
yyssp = yyss + yysize - 1;	yyssp = yyss + yysize - 1;
yyvsp = yyvs + yysize - 1;	yyvsp = yyvs + yysize - 1;


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

Line 1549 YYSTYPE yylval;	Line 1548 YYSTYPE yylval;

YYDPRINTF ((stderr, "Entering state %d\n", yystate));	YYDPRINTF ((stderr, "Entering state %d\n", yystate));

if (yystate == YYFINAL)
YYACCEPT;

goto yybackup;	goto yybackup;

/*-----------.	/*-----------.
Line 1560 YYSTYPE yylval;	Line 1556 YYSTYPE yylval;
yybackup:	yybackup:

/* Do appropriate processing given the current state. Read a	/* Do appropriate processing given the current state. Read a
lookahead token if we need one and don't already have one. */	look-ahead token if we need one and don't already have one. */

/* First try to decide what to do without reference to lookahead token. */	/* First try to decide what to do without reference to look-ahead token. */
yyn = yypact[yystate];	yyn = yypact[yystate];
if (yyn == YYPACT_NINF)	if (yyn == YYPACT_NINF)
goto yydefault;	goto yydefault;

/* Not known => get a lookahead token if don't already have one. */	/* Not known => get a look-ahead token if don't already have one. */

/* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */	/* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
if (yychar == YYEMPTY)	if (yychar == YYEMPTY)
{	{
YYDPRINTF ((stderr, "Reading a token: "));	YYDPRINTF ((stderr, "Reading a token: "));
Line 1601 yybackup:	Line 1597 yybackup:
goto yyreduce;	goto yyreduce;
}	}

	if (yyn == YYFINAL)
	YYACCEPT;

/* Count tokens shifted since error; after three, turn off error	/* Count tokens shifted since error; after three, turn off error
status. */	status. */
if (yyerrstatus)	if (yyerrstatus)
yyerrstatus--;	yyerrstatus--;

/* Shift the lookahead token. */	/* Shift the look-ahead token. */
YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);	YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);

/* Discard the shifted token. */	/* Discard the shifted token unless it is eof. */
yychar = YYEMPTY;	if (yychar != YYEOF)
	yychar = YYEMPTY;

yystate = yyn;	yystate = yyn;
*++yyvsp = yylval;	*++yyvsp = yylval;
Line 1891 yyreduce:	Line 1891 yyreduce:
break;	break;


	/* Line 1267 of yacc.c. */

default: break;	default: break;
}	}
Line 1902 yyreduce:	Line 1903 yyreduce:

*++yyvsp = yyval;	*++yyvsp = yyval;


/* Now `shift' the result of the reduction. Determine what state	/* Now `shift' the result of the reduction. Determine what state
that goes to, based on the state we popped back to and the rule	that goes to, based on the state we popped back to and the rule
number reduced by. */	number reduced by. */
Line 1966 yyerrlab:	Line 1968 yyerrlab:

if (yyerrstatus == 3)	if (yyerrstatus == 3)
{	{
/* If just tried and failed to reuse lookahead token after an	/* If just tried and failed to reuse look-ahead token after an
error, discard it. */	error, discard it. */

if (yychar <= YYEOF)	if (yychar <= YYEOF)
Line 1983 yyerrlab:	Line 1985 yyerrlab:
}	}
}	}

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

Line 2040 yyerrlab1:	Line 2042 yyerrlab1:
YY_STACK_PRINT (yyss, yyssp);	YY_STACK_PRINT (yyss, yyssp);
}	}

	if (yyn == YYFINAL)
	YYACCEPT;

*++yyvsp = yylval;	*++yyvsp = yylval;


Line 2064 yyabortlab:	Line 2069 yyabortlab:
yyresult = 1;	yyresult = 1;
goto yyreturn;	goto yyreturn;

#if !defined(yyoverflow) \|\| YYERROR_VERBOSE	#ifndef yyoverflow
/*-------------------------------------------------.	/*-------------------------------------------------.
\| yyexhaustedlab -- memory exhaustion comes here. \|	\| yyexhaustedlab -- memory exhaustion comes here. \|
`-------------------------------------------------*/	`-------------------------------------------------*/
Line 2075 yyexhaustedlab:	Line 2080 yyexhaustedlab:
#endif	#endif

yyreturn:	yyreturn:
if (yychar != YYEMPTY)	if (yychar != YYEOF && yychar != YYEMPTY)
yydestruct ("Cleanup: discarding lookahead",	yydestruct ("Cleanup: discarding lookahead",
yytoken, &yylval);	yytoken, &yylval);
/* Do not reclaim the symbols of the rule which action triggered	/* Do not reclaim the symbols of the rule which action triggered

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>

Removed from v.1.1
changed lines
	Added in v.1.1.1.3