parser3/src/main/compile.tab.C - diff

Return to compile.tab.C CVS log

Up to [parser3project] / parser3 / src / main

Diff for /parser3/src/main/compile.tab.C between versions 1.160 and 1.177

version 1.160, 2015/04/02 22:18:25	version 1.177, 2016/11/27 23:10:06
Line 1	Line 1
/* A Bison parser, made by GNU Bison 2.5. */	/* A Bison parser, made by GNU Bison 3.0.2. */

/* Bison implementation for Yacc-like parsers in C	/* Bison implementation for Yacc-like parsers in C

Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.	Copyright (C) 1984, 1989-1990, 2000-2013 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 3 of the License, or
(at your option) any later version.	(at your option) 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, see <http://www.gnu.org/licenses/>. */

Line 26	Line 26
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 44	Line 44
#define YYBISON 1	#define YYBISON 1

/* Bison version. */	/* Bison version. */
#define YYBISON_VERSION "2.5"	#define YYBISON_VERSION "3.0.2"

/* Skeleton name. */	/* Skeleton name. */
#define YYSKELETON_NAME "yacc.c"	#define YYSKELETON_NAME "yacc.c"
Line 58	Line 58
/* Pull parsers. */	/* Pull parsers. */
#define YYPULL 1	#define YYPULL 1

/* Using locations. */
#define YYLSP_NEEDED 0



/* Copy the first part of user declarations. */	/* Copy the first part of user declarations. */
	#line 1 "compile.y" /* yacc.c:339 */
/* Line 268 of yacc.c */
#line 1 "compile.y"

/** @file	/** @file
Parser: compiler(lexical parser and grammar).	Parser: compiler(lexical parser and grammar).

Copyright (c) 2001-2012 Art. Lebedev Studio (http://www.artlebedev.com)	Copyright (c) 2001-2015 Art. Lebedev Studio (http://www.artlebedev.com)
Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)	Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)


Line 91 volatile const char * IDENT_COMPILE_Y =	Line 87 volatile const char * IDENT_COMPILE_Y =
*/	*/

#define YYSTYPE ArrayOperation*	#define YYSTYPE ArrayOperation*
#define YYPARSE_PARAM pc
#define YYLEX_PARAM pc
#define YYDEBUG 1	#define YYDEBUG 1
#define YYERROR_VERBOSE 1	#define YYERROR_VERBOSE 1
#define yyerror(msg) real_yyerror((Parse_control *)pc, msg)	#define yyerror(pc, msg) real_yyerror(pc, msg)
#define YYPRINT(file, type, value) yyprint(file, type, value)	#define YYPRINT(file, type, value) yyprint(file, type, value)
	#define YYMALLOC pa_malloc
	#define YYFREE pa_free

// includes	// includes

Line 110 volatile const char * IDENT_COMPILE_Y =	Line 106 volatile const char * IDENT_COMPILE_Y =

// defines	// defines

	#define CLASS_NAME "CLASS"
#define USE_CONTROL_METHOD_NAME "USE"	#define USE_CONTROL_METHOD_NAME "USE"
#define OPTIONS_CONTROL_METHOD_NAME "OPTIONS"	#define OPTIONS_CONTROL_METHOD_NAME "OPTIONS"
#define OPTION_ALL_VARS_LOCAL_NAME "locals"
#define OPTION_PARTIAL_CLASS "partial"
#define REM_OPERATOR_NAME "rem"

// forwards	// forwards

Line 128 static const VString vempty;	Line 122 static const VString vempty;

// local convinient inplace typecast & var	// local convinient inplace typecast & var
#undef PC	#undef PC
#define PC ((Parse_control )pc)	#define PC (*pc)
#undef POOL	#undef POOL
#define POOL (*PC.pool)	#define POOL (*PC.pool)
#ifndef DOXYGEN	#ifndef DOXYGEN

#define CLASS_ADD if(PC.class_add()){ \	#define CLASS_ADD if(PC.class_add()){ \
strncpy(PC.error, PC.cclass->name().cstr(), MAX_STRING/2); \	strncpy(PC.error, PC.cclass->type(), MAX_STRING/2); \
strcat(PC.error, " - class is already defined"); \	strcat(PC.error, " - class is already defined"); \
YYERROR; \	YYERROR; \
}	}

	#define PC_ERROR(header, value, footer){ \
	strcpy(PC.error, header); \
	strncat(PC.error, value, MAX_STRING/2); \
	strcat(PC.error, footer); \
	}


/* Line 268 of yacc.c */	#line 144 "compile.tab.C" /* yacc.c:339 */
#line 146 "compile.tab.C"

/* Enabling traces. */	# ifndef YY_NULLPTR
#ifndef YYDEBUG	# if defined __cplusplus && 201103L <= __cplusplus
# define YYDEBUG 0	# define YY_NULLPTR nullptr
#endif	# else
	# define YY_NULLPTR 0
	# endif
	# endif

/* Enabling verbose error messages. */	/* Enabling verbose error messages. */
#ifdef YYERROR_VERBOSE	#ifdef YYERROR_VERBOSE
Line 157 static const VString vempty;	Line 158 static const VString vempty;
# define YYERROR_VERBOSE 0	# define YYERROR_VERBOSE 0
#endif	#endif

/* Enabling the token table. */
#ifndef YYTOKEN_TABLE
# define YYTOKEN_TABLE 0
#endif

	/* Debug traces. */
	#ifndef YYDEBUG
	# define YYDEBUG 0
	#endif
	#if YYDEBUG
	extern int yydebug;
	#endif

/* Tokens. */	/* Token type. */
#ifndef YYTOKENTYPE	#ifndef YYTOKENTYPE
# define YYTOKENTYPE	# define YYTOKENTYPE
/* Put the tokens into the symbol table, so that GDB and other debuggers	enum yytokentype
know about them. */	{
enum yytokentype {	EON = 258,
EON = 258,	STRING = 259,
STRING = 259,	BOGUS = 260,
BOGUS = 260,	BAD_STRING_COMPARISON_OPERATOR = 261,
BAD_STRING_COMPARISON_OPERATOR = 261,	BAD_HEX_LITERAL = 262,
BAD_HEX_LITERAL = 262,	BAD_METHOD_DECL_START = 263,
BAD_METHOD_DECL_START = 263,	BAD_METHOD_PARAMETER_NAME_CHARACTER = 264,
BAD_METHOD_PARAMETER_NAME_CHARACTER = 264,	LAND = 265,
BAD_NONWHITESPACE_CHARACTER_IN_EXPLICIT_RESULT_MODE = 265,	LOR = 266,
LAND = 266,	LXOR = 267,
LOR = 267,	NXOR = 268,
LXOR = 268,	NLE = 269,
NXOR = 269,	NGE = 270,
NLE = 270,	NEQ = 271,
NGE = 271,	NNE = 272,
NEQ = 272,	NSL = 273,
NNE = 273,	NSR = 274,
NSL = 274,	SLT = 275,
NSR = 275,	SGT = 276,
SLT = 276,	SLE = 277,
SGT = 277,	SGE = 278,
SLE = 278,	SEQ = 279,
SGE = 279,	SNE = 280,
SEQ = 280,	DEF = 281,
SNE = 281,	IN = 282,
DEF = 282,	FEXISTS = 283,
IN = 283,	DEXISTS = 284,
FEXISTS = 284,	IS = 285,
DEXISTS = 285,	LITERAL_TRUE = 286,
IS = 286,	LITERAL_FALSE = 287,
LITERAL_TRUE = 287,	NUNARY = 288
LITERAL_FALSE = 288,	};
NUNARY = 289
};
#endif	#endif

	/* Value type. */

#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_IS_TRIVIAL 1
# define yystype YYSTYPE /* obsolescent; will be withdrawn */
# define YYSTYPE_IS_DECLARED 1	# define YYSTYPE_IS_DECLARED 1
#endif	#endif


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

	int yyparse (Parse_control* pc);

/* Line 343 of yacc.c */
#line 222 "compile.tab.C"
	/* Copy the second part of user declarations. */

	#line 225 "compile.tab.C" /* yacc.c:358 */

#ifdef short	#ifdef short
# undef short	# undef short
Line 232 typedef unsigned char yytype_uint8;	Line 235 typedef unsigned char yytype_uint8;

#ifdef YYTYPE_INT8	#ifdef YYTYPE_INT8
typedef YYTYPE_INT8 yytype_int8;	typedef YYTYPE_INT8 yytype_int8;
#elif (defined __STDC__ \|\| defined __C99__FUNC__ \
\|\| defined __cplusplus \|\| defined _MSC_VER)
typedef signed char yytype_int8;
#else	#else
typedef short int yytype_int8;	typedef signed char yytype_int8;
#endif	#endif

#ifdef YYTYPE_UINT16	#ifdef YYTYPE_UINT16
Line 256 typedef short int yytype_int16;	Line 256 typedef short int yytype_int16;
# define YYSIZE_T __SIZE_TYPE__	# define YYSIZE_T __SIZE_TYPE__
# elif defined size_t	# elif defined size_t
# define YYSIZE_T size_t	# define YYSIZE_T size_t
# elif ! defined YYSIZE_T && (defined __STDC__ \|\| defined __C99__FUNC__ \	# elif ! defined YYSIZE_T
\|\| defined __cplusplus \|\| defined _MSC_VER)
# include <stddef.h> /* INFRINGES ON USER NAME SPACE */	# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
# define YYSIZE_T size_t	# define YYSIZE_T size_t
# else	# else
Line 271 typedef short int yytype_int16;	Line 270 typedef short int yytype_int16;
# if defined YYENABLE_NLS && 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)
# endif	# endif
# endif	# endif
# ifndef YY_	# ifndef YY_
# define YY_(msgid) msgid	# define YY_(Msgid) Msgid
	# endif
	#endif

	#ifndef YY_ATTRIBUTE
	# if (defined __GNUC__ \
	&& (2 < __GNUC__ \|\| (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \
	\|\| defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
	# define YY_ATTRIBUTE(Spec) __attribute__(Spec)
	# else
	# define YY_ATTRIBUTE(Spec) /* empty */
	# endif
	#endif

	#ifndef YY_ATTRIBUTE_PURE
	# define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__))
	#endif

	#ifndef YY_ATTRIBUTE_UNUSED
	# define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
	#endif

	#if !defined _Noreturn \
	&& (!defined __STDC_VERSION__ \|\| __STDC_VERSION__ < 201112)
	# if defined _MSC_VER && 1200 <= _MSC_VER
	# define _Noreturn __declspec (noreturn)
	# else
	# define _Noreturn YY_ATTRIBUTE ((__noreturn__))
# endif	# endif
#endif	#endif

/* Suppress unused-variable warnings by "using" E. */	/* Suppress unused-variable warnings by "using" E. */
#if ! defined lint \|\| defined __GNUC__	#if ! defined lint \|\| defined __GNUC__
# define YYUSE(e) ((void) (e))	# define YYUSE(E) ((void) (E))
#else	#else
# define YYUSE(e) /* empty */	# define YYUSE(E) /* empty */
#endif	#endif

/* Identity function, used to suppress warnings about constant conditions. */	#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
#ifndef lint	/* Suppress an incorrect diagnostic about yylval being uninitialized. */
# define YYID(n) (n)	# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
	_Pragma ("GCC diagnostic push") \
	_Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
	_Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
	# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
	_Pragma ("GCC diagnostic pop")
#else	#else
#if (defined __STDC__ \|\| defined __C99__FUNC__ \	# define YY_INITIAL_VALUE(Value) Value
\|\| defined __cplusplus \|\| defined _MSC_VER)
static int
YYID (int yyi)
#else
static int
YYID (yyi)
int yyi;
#endif	#endif
{	#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
return yyi;	# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
}	# define YY_IGNORE_MAYBE_UNINITIALIZED_END
#endif	#endif
	#ifndef YY_INITIAL_VALUE
	# define YY_INITIAL_VALUE(Value) /* Nothing. */
	#endif


#if ! defined yyoverflow \|\| YYERROR_VERBOSE	#if ! defined yyoverflow \|\| YYERROR_VERBOSE

Line 321 YYID (yyi)	Line 349 YYID (yyi)
# define alloca _alloca	# define alloca _alloca
# else	# else
# define YYSTACK_ALLOC alloca	# define YYSTACK_ALLOC alloca
# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ \|\| defined __C99__FUNC__ \	# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
\|\| defined __cplusplus \|\| defined _MSC_VER)
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */	# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
	/* Use EXIT_SUCCESS as a witness for stdlib.h. */
# ifndef EXIT_SUCCESS	# ifndef EXIT_SUCCESS
# define EXIT_SUCCESS 0	# define EXIT_SUCCESS 0
# endif	# endif
Line 333 YYID (yyi)	Line 361 YYID (yyi)
# endif	# endif

# ifdef YYSTACK_ALLOC	# ifdef YYSTACK_ALLOC
/* Pacify GCC's `empty if-body' warning. */	/* Pacify GCC's 'empty if-body' warning. */
# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))	# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
# ifndef YYSTACK_ALLOC_MAXIMUM	# ifndef YYSTACK_ALLOC_MAXIMUM
/* The OS might guarantee only one guard page at the bottom of the stack,	/* The OS might guarantee only one guard page at the bottom of the stack,
and a page size can be as small as 4096 bytes. So we cannot safely	and a page size can be as small as 4096 bytes. So we cannot safely
Line 350 YYID (yyi)	Line 378 YYID (yyi)
# endif	# endif
# if (defined __cplusplus && ! defined EXIT_SUCCESS \	# if (defined __cplusplus && ! defined EXIT_SUCCESS \
&& ! ((defined YYMALLOC \|\| defined malloc) \	&& ! ((defined YYMALLOC \|\| defined malloc) \
&& (defined YYFREE \|\| defined free)))	&& (defined YYFREE \|\| defined free)))
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */	# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
# ifndef EXIT_SUCCESS	# ifndef EXIT_SUCCESS
# define EXIT_SUCCESS 0	# define EXIT_SUCCESS 0
Line 358 YYID (yyi)	Line 386 YYID (yyi)
# endif	# endif
# ifndef YYMALLOC	# ifndef YYMALLOC
# define YYMALLOC malloc	# define YYMALLOC malloc
# if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ \|\| defined __C99__FUNC__ \	# if ! defined malloc && ! defined EXIT_SUCCESS
\|\| defined __cplusplus \|\| defined _MSC_VER)
void malloc (YYSIZE_T); / INFRINGES ON USER NAME SPACE */	void malloc (YYSIZE_T); / INFRINGES ON USER NAME SPACE */
# endif	# endif
# endif	# endif
# ifndef YYFREE	# ifndef YYFREE
# define YYFREE free	# define YYFREE free
# if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ \|\| defined __C99__FUNC__ \	# if ! defined free && ! defined EXIT_SUCCESS
\|\| defined __cplusplus \|\| defined _MSC_VER)
void free (void ); / INFRINGES ON USER NAME SPACE */	void free (void ); / INFRINGES ON USER NAME SPACE */
# endif	# endif
# endif	# endif
Line 376 void free (void ); / INFRINGES ON USER	Line 402 void free (void ); / INFRINGES ON USER

#if (! defined yyoverflow \	#if (! defined yyoverflow \
&& (! defined __cplusplus \	&& (! defined __cplusplus \
\|\| (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))	\|\| (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))

/* A type that is properly aligned for any stack member. */	/* A type that is properly aligned for any stack member. */
union yyalloc	union yyalloc
Line 401 union yyalloc	Line 427 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_alloc, Stack) \
do \	do \
{ \	{ \
YYSIZE_T yynewbytes; \	YYSIZE_T yynewbytes; \
YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \	YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
Stack = &yyptr->Stack_alloc; \	Stack = &yyptr->Stack_alloc; \
yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
yyptr += yynewbytes / sizeof (*yyptr); \	yyptr += yynewbytes / sizeof (*yyptr); \
} \	} \
while (YYID (0))	while (0)

#endif	#endif

#if defined YYCOPY_NEEDED && YYCOPY_NEEDED	#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
/* Copy COUNT objects from FROM to TO. The source and destination do	/* Copy COUNT objects from SRC to DST. The source and destination do
not overlap. */	not overlap. */
# ifndef YYCOPY	# ifndef YYCOPY
# if defined __GNUC__ && 1 < __GNUC__	# if defined __GNUC__ && 1 < __GNUC__
# define YYCOPY(To, From, Count) \	# define YYCOPY(Dst, Src, Count) \
__builtin_memcpy (To, From, (Count) * sizeof (*(From)))	__builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
# else	# else
# define YYCOPY(To, From, Count) \	# define YYCOPY(Dst, Src, Count) \
do \	do \
{ \	{ \
YYSIZE_T yyi; \	YYSIZE_T yyi; \
for (yyi = 0; yyi < (Count); yyi++) \	for (yyi = 0; yyi < (Count); yyi++) \
(To)[yyi] = (From)[yyi]; \	(Dst)[yyi] = (Src)[yyi]; \
} \	} \
while (YYID (0))	while (0)
# endif	# endif
# endif	# endif
#endif /* !YYCOPY_NEEDED */	#endif /* !YYCOPY_NEEDED */
Line 437 union yyalloc	Line 463 union yyalloc
/* YYFINAL -- State number of the termination state. */	/* YYFINAL -- State number of the termination state. */
#define YYFINAL 51	#define YYFINAL 51
/* YYLAST -- Last index in YYTABLE. */	/* YYLAST -- Last index in YYTABLE. */
#define YYLAST 470	#define YYLAST 473

/* YYNTOKENS -- Number of terminals. */	/* YYNTOKENS -- Number of terminals. */
#define YYNTOKENS 62	#define YYNTOKENS 61
/* YYNNTS -- Number of nonterminals. */	/* YYNNTS -- Number of nonterminals. */
#define YYNNTS 89	#define YYNNTS 89
/* YYNRULES -- Number of rules. */	/* YYNRULES -- Number of rules. */
#define YYNRULES 172	#define YYNRULES 172
/* YYNRULES -- Number of states. */	/* YYNSTATES -- Number of states. */
#define YYNSTATES 263	#define YYNSTATES 263

/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */	/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
	by yylex, with out-of-bounds checking. */
#define YYUNDEFTOK 2	#define YYUNDEFTOK 2
#define YYMAXUTOK 289	#define YYMAXUTOK 288

#define YYTRANSLATE(YYX) \	#define YYTRANSLATE(YYX) \
((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)	((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)

/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */	/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
	as returned by yylex, without out-of-bounds checking. */
static const yytype_uint8 yytranslate[] =	static const yytype_uint8 yytranslate[] =
{	{
0, 2, 2, 2, 2, 2, 2, 2, 2, 2,	0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
48, 2, 2, 2, 2, 2, 2, 2, 2, 2,	47, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 46, 60, 2, 52, 43, 37, 61,	2, 2, 2, 45, 59, 2, 51, 42, 36, 60,
56, 57, 40, 38, 2, 39, 55, 41, 2, 2,	55, 56, 39, 37, 2, 38, 54, 40, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 59, 51,	2, 2, 2, 2, 2, 2, 2, 2, 58, 50,
34, 2, 35, 2, 47, 2, 2, 2, 2, 2,	33, 2, 34, 2, 46, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 49, 42, 50, 58, 2, 2, 2, 2, 2,	2, 48, 41, 49, 57, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 53, 36, 54, 45, 2, 2, 2,	2, 2, 2, 52, 35, 53, 44, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
Line 486 static const yytype_uint8 yytranslate[]	Line 514 static const yytype_uint8 yytranslate[]
2, 2, 2, 2, 2, 2, 1, 2, 3, 4,	2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
5, 6, 7, 8, 9, 10, 11, 12, 13, 14,	5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22, 23, 24,	15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 33, 44	25, 26, 27, 28, 29, 30, 31, 32, 43
};	};

#if YYDEBUG	#if YYDEBUG
/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in	/* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
YYRHS. */
static const yytype_uint16 yyprhs[] =
{
0, 0, 3, 5, 7, 9, 12, 14, 16, 18,
23, 25, 27, 29, 32, 35, 37, 39, 40, 49,
51, 53, 57, 59, 61, 63, 67, 69, 71, 73,
75, 77, 80, 82, 84, 86, 88, 90, 92, 95,
98, 100, 104, 106, 108, 110, 113, 115, 118, 122,
124, 126, 128, 130, 133, 136, 138, 140, 142, 143,
144, 150, 154, 158, 160, 162, 164, 166, 168, 170,
173, 175, 176, 177, 184, 186, 188, 191, 193, 195,
197, 198, 199, 205, 209, 213, 215, 219, 221, 225,
227, 231, 233, 235, 237, 239, 241, 243, 245, 248,
250, 253, 256, 258, 260, 263, 265, 267, 269, 271,
274, 277, 278, 279, 285, 287, 289, 292, 295, 297,
299, 302, 305, 307, 309, 311, 313, 315, 317, 321,
325, 329, 332, 335, 338, 341, 344, 347, 350, 353,
357, 361, 365, 369, 373, 377, 381, 385, 389, 393,
397, 401, 405, 409, 413, 417, 421, 425, 429, 433,
437, 441, 445, 449, 453, 457, 461, 463, 465, 467,
468, 470, 472
};

/* YYRHS -- A `-1'-separated list of the rules' RHS. */
static const yytype_int16 yyrhs[] =
{
63, 0, -1, 65, -1, 64, -1, 66, -1, 64,
66, -1, 79, -1, 67, -1, 72, -1, 47, 4,
48, 68, -1, 150, -1, 69, -1, 70, -1, 69,
70, -1, 71, 48, -1, 150, -1, 4, -1, -1,
47, 4, 75, 74, 78, 48, 73, 79, -1, 150,
-1, 75, -1, 49, 76, 50, -1, 150, -1, 77,
-1, 4, -1, 77, 51, 4, -1, 150, -1, 4,
-1, 150, -1, 80, -1, 81, -1, 80, 81, -1,
146, -1, 82, -1, 83, -1, 91, -1, 106, -1,
84, -1, 52, 85, -1, 87, 3, -1, 86, -1,
53, 87, 54, -1, 88, -1, 89, -1, 90, -1,
139, 90, -1, 129, -1, 126, 129, -1, 52, 92,
96, -1, 93, -1, 94, -1, 95, -1, 125, -1,
55, 125, -1, 139, 125, -1, 97, -1, 100, -1,
101, -1, -1, -1, 49, 98, 102, 99, 50, -1,
56, 142, 57, -1, 53, 79, 54, -1, 147, -1,
4, -1, 103, -1, 104, -1, 105, -1, 82, -1,
81, 80, -1, 107, -1, -1, -1, 58, 108, 110,
109, 111, 3, -1, 87, -1, 112, -1, 111, 112,
-1, 113, -1, 116, -1, 117, -1, -1, -1, 49,
114, 118, 115, 50, -1, 56, 119, 57, -1, 53,
120, 54, -1, 121, -1, 118, 51, 121, -1, 122,
-1, 119, 51, 122, -1, 123, -1, 120, 51, 123,
-1, 124, -1, 142, -1, 79, -1, 147, -1, 4,
-1, 103, -1, 130, -1, 126, 130, -1, 127, -1,
126, 127, -1, 128, 55, -1, 130, -1, 130, -1,
4, 5, -1, 4, -1, 131, -1, 132, -1, 133,
-1, 52, 136, -1, 4, 137, -1, -1, -1, 49,
134, 80, 135, 50, -1, 4, -1, 138, -1, 137,
138, -1, 52, 136, -1, 140, -1, 141, -1, 4,
59, -1, 140, 59, -1, 143, -1, 144, -1, 148,
-1, 149, -1, 84, -1, 107, -1, 60, 145, 60,
-1, 61, 145, 61, -1, 56, 143, 57, -1, 39,
143, -1, 38, 143, -1, 45, 143, -1, 46, 143,
-1, 27, 143, -1, 28, 143, -1, 29, 143, -1,
30, 143, -1, 143, 39, 143, -1, 143, 38, 143,
-1, 143, 40, 143, -1, 143, 41, 143, -1, 143,
43, 143, -1, 143, 42, 143, -1, 143, 19, 143,
-1, 143, 20, 143, -1, 143, 37, 143, -1, 143,
36, 143, -1, 143, 14, 143, -1, 143, 11, 143,
-1, 143, 12, 143, -1, 143, 13, 143, -1, 143,
34, 143, -1, 143, 35, 143, -1, 143, 15, 143,
-1, 143, 16, 143, -1, 143, 17, 143, -1, 143,
18, 143, -1, 143, 21, 143, -1, 143, 22, 143,
-1, 143, 23, 143, -1, 143, 24, 143, -1, 143,
25, 143, -1, 143, 26, 143, -1, 143, 31, 143,
-1, 4, -1, 79, -1, 4, -1, -1, 32, -1,
33, -1, -1
};

/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
static const yytype_uint16 yyrline[] =	static const yytype_uint16 yyrline[] =
{	{
0, 140, 140, 147, 149, 149, 150, 152, 152, 154,	0, 145, 145, 149, 151, 151, 152, 154, 154, 156,
264, 264, 265, 265, 266, 267, 267, 269, 269, 317,	243, 243, 244, 244, 245, 246, 246, 248, 248, 295,
317, 318, 319, 319, 320, 320, 322, 322, 326, 326,	295, 296, 297, 297, 298, 298, 300, 300, 304, 304,
328, 328, 329, 329, 330, 330, 330, 334, 382, 383,	306, 306, 307, 307, 308, 308, 308, 312, 343, 344,
383, 384, 386, 387, 388, 441, 442, 442, 446, 459,	344, 345, 347, 348, 349, 398, 399, 399, 403, 416,
460, 461, 462, 488, 493, 496, 497, 498, 500, 503,	417, 418, 419, 441, 446, 449, 450, 451, 453, 456,
500, 511, 519, 526, 527, 528, 530, 536, 537, 537,	453, 464, 471, 478, 479, 480, 482, 488, 489, 489,
541, 554, 557, 554, 602, 604, 604, 606, 607, 608,	493, 504, 507, 504, 556, 572, 572, 574, 575, 576,
610, 613, 610, 616, 617, 619, 620, 623, 624, 627,	578, 581, 578, 584, 585, 587, 588, 591, 592, 595,
628, 630, 633, 647, 652, 653, 654, 659, 659, 661,	596, 598, 601, 614, 619, 620, 621, 626, 626, 628,
661, 662, 663, 675, 684, 687, 688, 689, 690, 692,	628, 629, 630, 642, 651, 654, 655, 656, 657, 659,
696, 705, 708, 705, 721, 726, 726, 727, 733, 734,	663, 672, 675, 672, 688, 693, 693, 694, 700, 701,
736, 749, 761, 763, 764, 765, 766, 767, 768, 769,	703, 723, 735, 737, 738, 739, 740, 741, 742, 743,
770, 772, 773, 774, 775, 776, 777, 778, 779, 781,	744, 746, 747, 748, 749, 750, 751, 752, 753, 755,
782, 783, 784, 785, 786, 787, 788, 789, 790, 791,	756, 757, 758, 759, 760, 761, 762, 763, 764, 765,
792, 793, 794, 795, 796, 797, 798, 799, 800, 801,	766, 767, 768, 769, 770, 771, 772, 773, 774, 775,
802, 803, 804, 805, 806, 807, 810, 815, 836, 841,	776, 777, 778, 779, 780, 781, 784, 789, 810, 815,
842, 843, 845	816, 817, 819
};	};
#endif	#endif

#if YYDEBUG \|\| YYERROR_VERBOSE \|\| YYTOKEN_TABLE	#if YYDEBUG \|\| YYERROR_VERBOSE \|\| 0
/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.	/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
First, the terminals, then, starting at YYNTOKENS, nonterminals. */	First, the terminals, then, starting at YYNTOKENS, nonterminals. */
static const char *const yytname[] =	static const char *const yytname[] =
{	{
"$end", "error", "$undefined", "EON", "STRING", "BOGUS",	"$end", "error", "$undefined", "EON", "STRING", "BOGUS",
"BAD_STRING_COMPARISON_OPERATOR", "BAD_HEX_LITERAL",	"BAD_STRING_COMPARISON_OPERATOR", "BAD_HEX_LITERAL",
"BAD_METHOD_DECL_START", "BAD_METHOD_PARAMETER_NAME_CHARACTER",	"BAD_METHOD_DECL_START", "BAD_METHOD_PARAMETER_NAME_CHARACTER", "\"&&\"",
"BAD_NONWHITESPACE_CHARACTER_IN_EXPLICIT_RESULT_MODE", "\"&&\"",
"\"\|\|\"", "\"!\|\|\"", "\"!\|\"", "\"<=\"", "\">=\"", "\"==\"", "\"!=\"",	"\"\|\|\"", "\"!\|\|\"", "\"!\|\"", "\"<=\"", "\">=\"", "\"==\"", "\"!=\"",
"\"<<\"", "\">>\"", "\"lt\"", "\"gt\"", "\"le\"", "\"ge\"", "\"eq\"",	"\"<<\"", "\">>\"", "\"lt\"", "\"gt\"", "\"le\"", "\"ge\"", "\"eq\"",
"\"ne\"", "\"def\"", "\"in\"", "\"-f\"", "\"-d\"", "\"is\"", "\"true\"",	"\"ne\"", "\"def\"", "\"in\"", "\"-f\"", "\"-d\"", "\"is\"", "\"true\"",
Line 630 static const char *const yytname[] =	Line 580 static const char *const yytname[] =
"subvar_ref_name_rdive", "subvar_get_writes", "subvar__get_write",	"subvar_ref_name_rdive", "subvar_get_writes", "subvar__get_write",
"class_prefix", "class_static_prefix", "class_constructor_prefix",	"class_prefix", "class_static_prefix", "class_constructor_prefix",
"expr_value", "expr", "double_or_STRING", "string_inside_quotes_value",	"expr_value", "expr", "double_or_STRING", "string_inside_quotes_value",
"write_string", "empty_value", "true_value", "false_value", "empty", 0	"write_string", "empty_value", "true_value", "false_value", "empty", YY_NULLPTR
};	};
#endif	#endif

# ifdef YYPRINT	# ifdef YYPRINT
/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to	/* YYTOKNUM[NUM] -- (External) token number corresponding to the
token YYLEX-NUM. */	(internal) symbol number NUM (which must be that of a token). */
static const yytype_uint16 yytoknum[] =	static const yytype_uint16 yytoknum[] =
{	{
0, 256, 257, 258, 259, 260, 261, 262, 263, 264,	0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
265, 266, 267, 268, 269, 270, 271, 272, 273, 274,	265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
275, 276, 277, 278, 279, 280, 281, 282, 283, 284,	275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
285, 286, 287, 288, 60, 62, 124, 38, 43, 45,	285, 286, 287, 60, 62, 124, 38, 43, 45, 42,
42, 47, 92, 37, 289, 126, 33, 64, 10, 91,	47, 92, 37, 288, 126, 33, 64, 10, 91, 93,
93, 59, 36, 123, 125, 46, 40, 41, 94, 58,	59, 36, 123, 125, 46, 40, 41, 94, 58, 34,
34, 39	39
};	};
# endif	# endif

/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */	#define YYPACT_NINF -107
static const yytype_uint8 yyr1[] =
{
0, 62, 63, 63, 64, 64, 65, 66, 66, 67,
68, 68, 69, 69, 70, 71, 71, 73, 72, 74,
74, 75, 76, 76, 77, 77, 78, 78, 79, 79,
80, 80, 81, 81, 82, 82, 82, 83, 84, 85,
85, 86, 87, 87, 88, 89, 90, 90, 91, 92,
92, 92, 93, 94, 95, 96, 96, 96, 98, 99,
97, 100, 101, 102, 102, 102, 103, 104, 105, 105,
106, 108, 109, 107, 110, 111, 111, 112, 112, 112,
114, 115, 113, 116, 117, 118, 118, 119, 119, 120,
120, 121, 122, 123, 124, 124, 124, 125, 125, 126,
126, 127, 128, 129, 129, 130, 130, 130, 130, 131,
132, 134, 135, 133, 136, 137, 137, 138, 139, 139,
140, 141, 142, 143, 143, 143, 143, 143, 143, 143,
143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
143, 143, 143, 143, 143, 143, 144, 145, 146, 147,
148, 149, 150
};

/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */	#define yypact_value_is_default(Yystate) \
static const yytype_uint8 yyr2[] =	(!!((Yystate) == (-107)))

	#define YYTABLE_NINF -173

	#define yytable_value_is_error(Yytable_value) \
	0

	/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
	STATE-NUM. */
	static const yytype_int16 yypact[] =
{	{
0, 2, 1, 1, 1, 2, 1, 1, 1, 4,	12, -107, 9, 41, -107, 23, -21, -107, -107, -107,
1, 1, 1, 2, 2, 1, 1, 0, 8, 1,	-107, -107, 27, -107, -107, -107, -107, -107, -107, -107,
1, 3, 1, 1, 1, 3, 1, 1, 1, 1,	-107, -107, 34, 10, -107, 37, 106, 108, -107, -107,
1, 2, 1, 1, 1, 1, 1, 1, 2, 2,	24, -107, -107, -107, -31, -107, -107, -107, -107, 110,
1, 3, 1, 1, 1, 2, 1, 2, 3, 1,	-107, -6, -107, 16, -107, -107, -107, 110, 42, -107,
1, 1, 1, 2, 2, 1, 1, 1, 0, 0,	106, -107, -107, -107, 63, 103, 65, -107, 37, -107,
5, 3, 3, 1, 1, 1, 1, 1, 1, 2,	77, -107, 27, -107, -107, 88, 110, 76, 110, 77,
1, 0, 0, 6, 1, 1, 2, 1, 1, 1,	-107, 108, 76, -107, -107, 27, 28, -107, -107, -107,
0, 0, 5, 3, 3, 1, 3, 1, 3, 1,	-107, 29, -107, -107, 16, -107, -107, -107, -107, -107,
3, 1, 1, 1, 1, 1, 1, 1, 2, 1,	-107, -107, -107, 4, -107, 96, 100, -107, 104, 102,
2, 2, 1, 1, 2, 1, 1, 1, 1, 2,	-107, 141, -107, -107, -107, -107, 27, -107, 76, 39,
2, 0, 0, 5, 1, 1, 2, 2, 1, 1,	109, -107, 28, 28, 28, 28, -107, -107, 28, 28,
2, 2, 1, 1, 1, 1, 1, 1, 3, 3,	28, 28, 67, 28, 27, 27, -107, -107, 120, 324,
3, 2, 2, 2, 2, 2, 2, 2, 2, 3,	-107, -107, -107, -26, -107, -107, -107, -107, 151, -107,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,	130, -107, 129, 132, 27, 82, -107, -107, -107, -107,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,	-107, -107, 425, 425, 425, 425, -107, -107, -107, -107,
3, 3, 3, 3, 3, 3, 1, 1, 1, 0,	277, -107, 123, 119, -107, 28, 28, 28, 28, 28,
1, 1, 0	28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
	28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
	28, 28, -107, 27, 28, 46, -107, -107, -107, -107,
	-107, -107, -107, 27, 148, -107, -107, -107, 387, 150,
	357, 98, 417, 417, 290, 290, 192, 192, 417, 417,
	417, 417, 290, 290, 425, 417, 417, 183, 431, 81,
	81, -107, -107, -107, -107, 40, -107, -14, -107, -10,
	-107, -107, -107, -107, 27, -107, 99, -107, 149, -107,
	-107, -107, 27, -107, 28, -107, -107, 40, 155, -107,
	-107, -107, -107
};	};

/* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.	/* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
Performed when YYTABLE doesn't specify something else to do. Zero	Performed when YYTABLE does not specify something else to do. Zero
means the default is an error. */	means the default is an error. */
static const yytype_uint8 yydefact[] =	static const yytype_uint8 yydefact[] =
{	{
172, 168, 0, 0, 71, 0, 3, 2, 4, 7,	172, 168, 0, 0, 71, 0, 3, 2, 4, 7,
Line 729 static const yytype_uint8 yydefact[] =	Line 676 static const yytype_uint8 yydefact[] =
88, 86, 82	88, 86, 82
};	};

/* YYDEFGOTO[NTERM-NUM]. */	/* YYPGOTO[NTERM-NUM]. */
	static const yytype_int16 yypgoto[] =
	{
	-107, -107, -107, -107, 194, -107, -107, -107, 105, -107,
	-107, -107, -107, 156, -107, -107, -107, 1, -58, -7,
	-106, -107, 0, -107, -107, -15, -107, -107, -40, -107,
	-107, -107, -107, -107, -107, -107, -107, -107, -107, -107,
	-107, 97, -107, -107, -107, 2, -107, -107, -107, -107,
	22, -107, -107, -107, -107, -107, -107, -107, -107, -46,
	-28, -25, -107, -9, 6, -19, -107, -29, 3, -107,
	-107, -107, -107, -107, 178, -107, 179, 235, -107, -107,
	164, 95, -107, 116, -107, 133, -107, -107, 49
	};

	/* YYDEFGOTO[NTERM-NUM]. */
static const yytype_int16 yydefgoto[] =	static const yytype_int16 yydefgoto[] =
{	{
-1, 5, 6, 7, 8, 9, 92, 93, 94, 95,	-1, 5, 6, 7, 8, 9, 92, 93, 94, 95,
Line 743 static const yytype_int16 yydefgoto[] =	Line 704 static const yytype_int16 yydefgoto[] =
241, 129, 130, 162, 20, 251, 131, 132, 21	241, 129, 130, 162, 20, 251, 131, 132, 21
};	};

/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing	/* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
STATE-NUM. */	positive, shift that token. If negative, reduce the rule whose
#define YYPACT_NINF -107	number is the opposite. If YYTABLE_NINF, syntax error. */
static const yytype_int16 yypact[] =
{
14, -107, 13, 45, -107, 28, -15, -107, -107, -107,
-107, -107, 21, -107, -107, -107, -107, -107, -107, -107,
-107, -107, 73, 19, -107, 50, 6, 44, -107, -107,
87, -107, -107, -107, -34, -107, -107, -107, -107, 65,
-107, 48, -107, 5, -107, -107, -107, 65, 24, -107,
6, -107, -107, -107, 88, 109, 74, -107, 50, -107,
76, -107, 21, -107, -107, 86, 65, 101, 65, 76,
-107, 44, 101, -107, -107, 21, 7, -107, -107, -107,
-107, 18, -107, -107, 5, -107, -107, -107, -107, -107,
-107, -107, -107, 9, -107, 94, 99, -107, 93, 112,
-107, 146, -107, -107, -107, -107, 21, -107, 101, 29,
110, -107, 7, 7, 7, 7, -107, -107, 7, 7,
7, 7, 52, 7, 21, 21, -107, -107, 113, 323,
-107, -107, -107, 92, -107, -107, -107, -107, 165, -107,
144, -107, 147, 149, 21, 80, -107, -107, -107, -107,
-107, -107, 96, 96, 96, 96, -107, -107, -107, -107,
276, -107, 138, 139, -107, 7, 7, 7, 7, 7,
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
7, 7, -107, 21, 7, 35, -107, -107, -107, -107,
-107, -107, -107, 21, 154, -107, -107, -107, 419, 389,
356, 284, 135, 135, 148, 148, 191, 191, 135, 135,
135, 135, 148, 148, 96, 135, 135, 182, 427, 140,
140, -107, -107, -107, -107, 37, -107, 31, -107, -30,
-107, -107, -107, -107, 21, -107, 108, -107, 155, -107,
-107, -107, 21, -107, 7, -107, -107, 37, 161, -107,
-107, -107, -107
};

/* YYPGOTO[NTERM-NUM]. */
static const yytype_int16 yypgoto[] =
{
-107, -107, -107, -107, 206, -107, -107, -107, 124, -107,
-107, -107, -107, 170, -107, -107, -107, 1, -58, -7,
-106, -107, 0, -107, -107, -6, -107, -107, -21, -107,
-107, -107, -107, -107, -107, -107, -107, -107, -107, -107,
-107, 118, -107, -107, -107, 2, -107, -107, -107, -107,
43, -107, -107, -107, -107, -107, -107, -107, -107, -17,
-13, -16, -107, -18, 4, 41, -107, -23, 3, -107,
-107, -107, -107, -107, 181, -107, 183, 239, -107, -107,
171, 95, -107, 123, -107, 142, -107, -107, 64
};

/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
positive, shift that token. If negative, reduce the rule which
number is the opposite. If YYTABLE_NINF, syntax error. */
#define YYTABLE_NINF -173
static const yytype_int16 yytable[] =	static const yytype_int16 yytable[] =
{	{
16, 11, 19, 145, 106, 53, 43, 39, -103, 70,	16, 11, 19, 145, 106, 53, 43, 86, 91, 39,
23, 111, 16, 91, 19, 74, 83, 22, 1, 75,	83, 65, 16, 22, 19, 57, 1, 74, 70, -103,
65, 254, 76, 57, 57, 1, 86, 255, 51, 87,	82, 75, 192, 51, 76, 2, 193, 73, 86, 194,
72, 71, 2, 143, 112, 113, 114, 115, 242, 116,	72, 1, 111, 71, 57, 89, 252, 83, 87, 253,
117, 246, 84, 83, 89, 118, 119, 86, 69, 23,	254, 63, 84, 143, 246, 23, 255, 82, 85, 242,
43, 39, 120, 121, 63, 24, 23, -172, 25, 122,	43, -172, 82, 39, 112, 113, 114, 115, 2, 116,
-102, 2, 16, 123, 19, 4, 3, 124, 125, 81,	117, 58, 16, 3, 19, 118, 119, 91, 59, 4,
58, 58, 4, 3, 108, 16, 110, 19, 59, 4,	-102, 23, 120, 121, 108, 16, 110, 19, 3, 122,
82, 3, 252, 88, 192, 253, 203, 4, 193, 3,	58, 54, 55, 123, 4, 4, 203, 124, 125, 24,
73, 194, 91, 24, 24, 4, 25, 25, 26, 53,	3, 3, 25, 26, 192, 27, 4, 4, 193, 53,
27, 24, 144, 85, 25, 26, 16, 82, 19, 16,	88, 194, 144, 96, 100, 103, 16, 97, 19, 16,
168, 19, 82, 97, 24, 173, 174, 25, 96, 100,	23, 19, 69, 55, 81, 24, 173, 174, 25, 26,
103, 54, 55, 55, 16, 16, 19, 19, 58, 145,	188, 189, 190, 191, 16, 16, 19, 19, 58, 145,
-68, -68, 184, 185, 186, 187, 188, 189, 190, 191,	-102, -68, -68, 184, 185, 186, 187, 188, 189, 190,
107, 192, 136, 137, 16, 193, 19, -15, 194, 168,	191, 107, 135, 136, 16, 139, 19, -15, -95, -95,
139, 145, 171, 172, 173, 174, -102, 135, -95, -95,	141, 145, 138, 137, 24, 200, 24, 25, 24, 25,
179, 180, 168, 138, 151, 141, 181, 173, 174, 200,	165, 25, 151, 168, 169, 170, 171, 172, 173, 174,
164, 184, 185, 186, 187, 188, 189, 190, 191, 181,	175, 176, 177, 178, 179, 180, 164, 201, 202, 207,
188, 189, 190, 191, 184, 185, 186, 187, 188, 189,	181, -64, 206, 182, 183, 184, 185, 186, 187, 188,
190, 191, 201, 16, 236, 19, 53, 202, 206, -64,	189, 190, 191, 16, 236, 19, 53, 245, 134, 257,
207, 173, 174, 16, 245, 19, 257, 152, 153, 154,	52, 173, 174, 16, 262, 19, 147, 152, 153, 154,
155, 262, 52, 156, 157, 158, 159, 134, 160, 185,	155, 261, 102, 156, 157, 158, 159, 243, 160, 185,
186, 187, 188, 189, 190, 191, 102, 147, 144, 186,	186, 187, 188, 189, 190, 191, 260, 259, 144, 186,
187, 188, 189, 190, 191, 16, 259, 19, 243, 104,	187, 188, 189, 190, 191, 16, 104, 19, 47, 105,
261, 260, 47, 105, 16, 256, 19, 128, 163, 0,	128, 163, 150, 0, 16, 256, 19, 0, 0, 0,
144, 150, 16, 236, 19, 0, 0, 16, 0, 19,	144, 0, 16, 236, 19, 0, 0, 16, 0, 19,
208, 209, 210, 211, 212, 213, 214, 215, 216, 217,	208, 209, 210, 211, 212, 213, 214, 215, 216, 217,
218, 219, 220, 221, 222, 223, 224, 225, 226, 227,	218, 219, 220, 221, 222, 223, 224, 225, 226, 227,
228, 229, 230, 231, 232, 233, 234, 165, 166, 167,	228, 229, 230, 231, 232, 233, 234, 165, 166, 167,
168, 169, 170, 171, 172, 173, 174, 175, 176, 177,	168, 169, 170, 171, 172, 173, 174, 175, 176, 177,
178, 179, 180, 173, 174, 0, 0, 181, 0, 0,	178, 179, 180, 168, 0, 0, 0, 181, 173, 174,
182, 183, 184, 185, 186, 187, 188, 189, 190, 191,	182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
184, 185, 186, 187, 188, 189, 190, 191, 0, 0,	181, 0, 0, 0, 0, 184, 185, 186, 187, 188,
0, 0, 0, 205, 165, 166, 167, 168, 169, 170,	189, 190, 191, 205, 165, 166, 167, 168, 169, 170,
171, 172, 173, 174, 175, 176, 177, 178, 179, 180,	171, 172, 173, 174, 175, 176, 177, 178, 179, 180,
0, 0, 0, 0, 181, 0, 0, 182, 183, 184,	0, 0, 0, 0, 181, 0, 0, 182, 183, 184,
185, 186, 187, 188, 189, 190, 191, 165, 166, 0,	185, 186, 187, 188, 189, 190, 191, 165, 166, 0,
168, 169, 170, 171, 172, 173, 174, 175, 176, 177,	168, 169, 170, 171, 172, 173, 174, 175, 176, 177,
178, 179, 180, 0, 0, 0, 0, 181, 0, 0,	178, 179, 180, 0, 0, 0, 0, 181, 0, 0,
182, 183, 184, 185, 186, 187, 188, 189, 190, 191,	182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
165, 0, 0, 168, 169, 170, 171, 172, 173, 174,	168, 169, 170, 171, 172, 173, 174, 175, 176, 177,
175, 176, 177, 178, 179, 180, 0, 0, 0, 0,	178, 179, 180, 0, 0, 0, 0, 181, 0, 0,
181, 0, 0, 182, 183, 184, 185, 186, 187, 188,	182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
189, 190, 191, 168, 169, 170, 171, 172, 173, 174,	168, 0, 0, 171, 172, 173, 174, 0, 168, 0,
175, 176, 177, 178, 179, 180, 173, 174, 0, 0,	0, 179, 180, 173, 174, 0, 0, 181, 0, 173,
181, 0, 0, 182, 183, 184, 185, 186, 187, 188,	174, 0, 184, 185, 186, 187, 188, 189, 190, 191,
189, 190, 191, 0, 0, 186, 187, 188, 189, 190,	184, 185, 186, 187, 188, 189, 190, 191, 186, 187,
191	188, 189, 190, 191
};	};

#define yypact_value_is_default(yystate) \
((yystate) == (-107))

#define yytable_value_is_error(yytable_value) \
YYID (0)

static const yytype_int16 yycheck[] =	static const yytype_int16 yycheck[] =
{	{
0, 0, 0, 109, 62, 12, 3, 3, 3, 27,	0, 0, 0, 109, 62, 12, 3, 47, 4, 3,
4, 4, 12, 4, 12, 49, 39, 4, 4, 53,	39, 26, 12, 4, 12, 5, 4, 48, 27, 3,
26, 51, 56, 5, 5, 4, 47, 57, 0, 47,	39, 52, 48, 0, 55, 46, 52, 3, 68, 55,
27, 27, 47, 4, 27, 28, 29, 30, 3, 32,	27, 4, 4, 27, 5, 50, 50, 66, 47, 53,
33, 4, 39, 66, 50, 38, 39, 68, 4, 4,	50, 4, 39, 4, 4, 4, 56, 66, 54, 3,
47, 47, 45, 46, 4, 49, 4, 48, 52, 52,	47, 47, 71, 47, 26, 27, 28, 29, 46, 31,
55, 47, 62, 56, 62, 58, 52, 60, 61, 4,	32, 51, 62, 51, 62, 37, 38, 4, 58, 57,
52, 52, 58, 52, 71, 75, 75, 75, 59, 58,	54, 4, 44, 45, 71, 75, 75, 75, 51, 51,
39, 52, 51, 59, 49, 54, 144, 58, 53, 52,	51, 47, 48, 55, 57, 57, 144, 59, 60, 48,
3, 56, 4, 49, 49, 58, 52, 52, 53, 106,	51, 51, 51, 52, 48, 54, 57, 57, 52, 106,
55, 49, 109, 55, 52, 53, 106, 66, 106, 109,	58, 55, 109, 54, 55, 56, 106, 4, 106, 109,
14, 109, 71, 4, 49, 19, 20, 52, 54, 55,	4, 109, 4, 48, 4, 48, 18, 19, 51, 52,
56, 48, 49, 49, 124, 125, 124, 125, 52, 235,	39, 40, 41, 42, 124, 125, 124, 125, 51, 235,
50, 51, 36, 37, 38, 39, 40, 41, 42, 43,	54, 49, 50, 35, 36, 37, 38, 39, 40, 41,
54, 49, 48, 50, 144, 53, 144, 48, 56, 14,	42, 53, 93, 47, 144, 4, 144, 47, 49, 50,
4, 257, 17, 18, 19, 20, 55, 93, 50, 51,	101, 257, 50, 49, 48, 4, 48, 51, 48, 51,
25, 26, 14, 51, 54, 101, 31, 19, 20, 4,	10, 51, 53, 13, 14, 15, 16, 17, 18, 19,
57, 36, 37, 38, 39, 40, 41, 42, 43, 31,	20, 21, 22, 23, 24, 25, 56, 47, 49, 60,
40, 41, 42, 43, 36, 37, 38, 39, 40, 41,	30, 49, 59, 33, 34, 35, 36, 37, 38, 39,
42, 43, 48, 193, 193, 193, 203, 50, 60, 50,	40, 41, 42, 193, 193, 193, 203, 49, 93, 50,
61, 19, 20, 203, 50, 203, 51, 112, 113, 114,	6, 18, 19, 203, 49, 203, 109, 112, 113, 114,
115, 50, 6, 118, 119, 120, 121, 93, 123, 37,	115, 257, 56, 118, 119, 120, 121, 195, 123, 36,
38, 39, 40, 41, 42, 43, 56, 109, 235, 38,	37, 38, 39, 40, 41, 42, 254, 252, 235, 37,
39, 40, 41, 42, 43, 235, 252, 235, 195, 58,	38, 39, 40, 41, 42, 235, 58, 235, 3, 60,
257, 254, 3, 60, 244, 244, 244, 76, 125, -1,	76, 125, 109, -1, 244, 244, 244, -1, -1, -1,
257, 109, 252, 252, 252, -1, -1, 257, -1, 257,	257, -1, 252, 252, 252, -1, -1, 257, -1, 257,
165, 166, 167, 168, 169, 170, 171, 172, 173, 174,	165, 166, 167, 168, 169, 170, 171, 172, 173, 174,
175, 176, 177, 178, 179, 180, 181, 182, 183, 184,	175, 176, 177, 178, 179, 180, 181, 182, 183, 184,
185, 186, 187, 188, 189, 190, 191, 11, 12, 13,	185, 186, 187, 188, 189, 190, 191, 10, 11, 12,
14, 15, 16, 17, 18, 19, 20, 21, 22, 23,	13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
24, 25, 26, 19, 20, -1, -1, 31, -1, -1,	23, 24, 25, 13, -1, -1, -1, 30, 18, 19,
34, 35, 36, 37, 38, 39, 40, 41, 42, 43,	33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
36, 37, 38, 39, 40, 41, 42, 43, -1, -1,	30, -1, -1, -1, -1, 35, 36, 37, 38, 39,
-1, -1, -1, 57, 11, 12, 13, 14, 15, 16,	40, 41, 42, 56, 10, 11, 12, 13, 14, 15,
17, 18, 19, 20, 21, 22, 23, 24, 25, 26,	16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
-1, -1, -1, -1, 31, -1, -1, 34, 35, 36,	-1, -1, -1, -1, 30, -1, -1, 33, 34, 35,
37, 38, 39, 40, 41, 42, 43, 11, 12, -1,	36, 37, 38, 39, 40, 41, 42, 10, 11, -1,
14, 15, 16, 17, 18, 19, 20, 21, 22, 23,	13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
24, 25, 26, -1, -1, -1, -1, 31, -1, -1,	23, 24, 25, -1, -1, -1, -1, 30, -1, -1,
34, 35, 36, 37, 38, 39, 40, 41, 42, 43,	33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
11, -1, -1, 14, 15, 16, 17, 18, 19, 20,	13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
21, 22, 23, 24, 25, 26, -1, -1, -1, -1,	23, 24, 25, -1, -1, -1, -1, 30, -1, -1,
31, -1, -1, 34, 35, 36, 37, 38, 39, 40,	33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
41, 42, 43, 14, 15, 16, 17, 18, 19, 20,	13, -1, -1, 16, 17, 18, 19, -1, 13, -1,
21, 22, 23, 24, 25, 26, 19, 20, -1, -1,	-1, 24, 25, 18, 19, -1, -1, 30, -1, 18,
31, -1, -1, 34, 35, 36, 37, 38, 39, 40,	19, -1, 35, 36, 37, 38, 39, 40, 41, 42,
41, 42, 43, -1, -1, 38, 39, 40, 41, 42,	35, 36, 37, 38, 39, 40, 41, 42, 37, 38,
43	39, 40, 41, 42
};	};

/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing	/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
symbol of state STATE-NUM. */	symbol of state STATE-NUM. */
static const yytype_uint8 yystos[] =	static const yytype_uint8 yystos[] =
{	{
0, 4, 47, 52, 58, 63, 64, 65, 66, 67,	0, 4, 46, 51, 57, 62, 63, 64, 65, 66,
72, 79, 80, 81, 82, 83, 84, 91, 106, 107,	71, 78, 79, 80, 81, 82, 83, 90, 105, 106,
146, 150, 4, 4, 49, 52, 53, 55, 85, 86,	145, 149, 4, 4, 48, 51, 52, 54, 84, 85,
87, 88, 89, 90, 92, 93, 94, 95, 125, 126,	86, 87, 88, 89, 91, 92, 93, 94, 124, 125,
127, 128, 129, 130, 131, 132, 133, 139, 140, 141,	126, 127, 128, 129, 130, 131, 132, 138, 139, 140,
108, 0, 66, 81, 48, 49, 75, 5, 52, 59,	107, 0, 65, 80, 47, 48, 74, 5, 51, 58,
137, 138, 134, 4, 136, 87, 126, 130, 139, 4,	136, 137, 133, 4, 135, 86, 125, 129, 138, 4,
125, 126, 130, 3, 49, 53, 56, 96, 97, 100,	124, 125, 129, 3, 48, 52, 55, 95, 96, 99,
101, 4, 127, 129, 130, 55, 90, 125, 59, 87,	100, 4, 126, 128, 129, 54, 89, 124, 58, 86,
110, 4, 68, 69, 70, 71, 150, 4, 76, 77,	109, 4, 67, 68, 69, 70, 149, 4, 75, 76,
150, 74, 75, 150, 136, 138, 80, 54, 130, 98,	149, 73, 74, 149, 135, 137, 79, 53, 129, 97,
79, 4, 27, 28, 29, 30, 32, 33, 38, 39,	78, 4, 26, 27, 28, 29, 31, 32, 37, 38,
45, 46, 52, 56, 60, 61, 84, 107, 142, 143,	44, 45, 51, 55, 59, 60, 83, 106, 141, 142,
144, 148, 149, 109, 70, 150, 48, 50, 51, 4,	143, 147, 148, 108, 69, 149, 47, 49, 50, 4,
78, 150, 135, 4, 81, 82, 102, 103, 104, 105,	77, 149, 134, 4, 80, 81, 101, 102, 103, 104,
147, 54, 143, 143, 143, 143, 143, 143, 143, 143,	146, 53, 142, 142, 142, 142, 142, 142, 142, 142,
143, 79, 145, 145, 57, 11, 12, 13, 14, 15,	142, 78, 144, 144, 56, 10, 11, 12, 13, 14,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25,	15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
26, 31, 34, 35, 36, 37, 38, 39, 40, 41,	25, 30, 33, 34, 35, 36, 37, 38, 39, 40,
42, 43, 49, 53, 56, 111, 112, 113, 116, 117,	41, 42, 48, 52, 55, 110, 111, 112, 115, 116,
4, 48, 50, 80, 99, 57, 60, 61, 143, 143,	4, 47, 49, 79, 98, 56, 59, 60, 142, 142,
143, 143, 143, 143, 143, 143, 143, 143, 143, 143,	142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
143, 143, 143, 143, 143, 143, 143, 143, 143, 143,	142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
143, 143, 143, 143, 143, 114, 79, 120, 123, 119,	142, 142, 142, 142, 142, 113, 78, 119, 122, 118,
122, 142, 3, 112, 73, 50, 4, 103, 118, 121,	121, 141, 3, 111, 72, 49, 4, 102, 117, 120,
124, 147, 51, 54, 51, 57, 79, 51, 115, 123,	123, 146, 50, 53, 50, 56, 78, 50, 114, 122,
122, 121, 50	121, 120, 49
};	};

#define yyerrok (yyerrstatus = 0)	/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
#define yyclearin (yychar = YYEMPTY)	static const yytype_uint8 yyr1[] =
#define YYEMPTY (-2)	{
#define YYEOF 0	0, 61, 62, 62, 63, 63, 64, 65, 65, 66,
	67, 67, 68, 68, 69, 70, 70, 72, 71, 73,
#define YYACCEPT goto yyacceptlab	73, 74, 75, 75, 76, 76, 77, 77, 78, 78,
#define YYABORT goto yyabortlab	79, 79, 80, 80, 81, 81, 81, 82, 83, 84,
#define YYERROR goto yyerrorlab	84, 85, 86, 86, 87, 88, 89, 89, 90, 91,
	91, 91, 92, 93, 94, 95, 95, 95, 97, 98,
	96, 99, 100, 101, 101, 101, 102, 103, 104, 104,
/* Like YYERROR except do call yyerror. This remains here temporarily	105, 107, 108, 106, 109, 110, 110, 111, 111, 111,
to ease the transition to the new meaning of YYERROR, for GCC.	113, 114, 112, 115, 116, 117, 117, 118, 118, 119,
Once GCC version 2 has supplanted version 1, this can go. However,	119, 120, 121, 122, 123, 123, 123, 124, 124, 125,
YYFAIL appears to be in use. Nevertheless, it is formally deprecated	125, 126, 127, 128, 128, 129, 129, 129, 129, 130,
in Bison 2.4.2's NEWS entry, where a plan to phase it out is	131, 133, 134, 132, 135, 136, 136, 137, 138, 138,
discussed. */	139, 140, 141, 142, 142, 142, 142, 142, 142, 142,
	142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
#define YYFAIL goto yyerrlab	142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
#if defined YYFAIL	142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
/* This is here to suppress warnings from the GCC cpp's	142, 142, 142, 142, 142, 142, 143, 144, 145, 146,
-Wunused-macros. Normally we don't worry about that warning, but	147, 148, 149
some users do, and we want to make it easy for users to remove	};
YYFAIL uses, which will produce warnings from Bison 2.5. */
#endif

#define YYRECOVERING() (!!yyerrstatus)	/* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
	static const yytype_uint8 yyr2[] =
	{
	0, 2, 1, 1, 1, 2, 1, 1, 1, 4,
	1, 1, 1, 2, 2, 1, 1, 0, 8, 1,
	1, 3, 1, 1, 1, 3, 1, 1, 1, 1,
	1, 2, 1, 1, 1, 1, 1, 1, 2, 2,
	1, 3, 1, 1, 1, 2, 1, 2, 3, 1,
	1, 1, 1, 2, 2, 1, 1, 1, 0, 0,
	5, 3, 3, 1, 1, 1, 1, 1, 1, 2,
	1, 0, 0, 6, 1, 1, 2, 1, 1, 1,
	0, 0, 5, 3, 3, 1, 3, 1, 3, 1,
	3, 1, 1, 1, 1, 1, 1, 1, 2, 1,
	2, 2, 1, 1, 2, 1, 1, 1, 1, 2,
	2, 0, 0, 5, 1, 1, 2, 2, 1, 1,
	2, 2, 1, 1, 1, 1, 1, 1, 3, 3,
	3, 2, 2, 2, 2, 2, 2, 2, 2, 3,
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
	3, 3, 3, 3, 3, 3, 1, 1, 1, 0,
	1, 1, 0
	};

#define YYBACKUP(Token, Value) \
do \
if (yychar == YYEMPTY && yylen == 1) \
{ \
yychar = (Token); \
yylval = (Value); \
YYPOPSTACK (1); \
goto yybackup; \
} \
else \
{ \
yyerror (YY_("syntax error: cannot back up")); \
YYERROR; \
} \
while (YYID (0))


#define YYTERROR 1
#define YYERRCODE 256


/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
If N is 0, then set CURRENT to the empty location which ends
the previous symbol: RHS[0] (always defined). */

#define YYRHSLOC(Rhs, K) ((Rhs)[K])
#ifndef YYLLOC_DEFAULT
# define YYLLOC_DEFAULT(Current, Rhs, N) \
do \
if (YYID (N)) \
{ \
(Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
(Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
(Current).last_line = YYRHSLOC (Rhs, N).last_line; \
(Current).last_column = YYRHSLOC (Rhs, N).last_column; \
} \
else \
{ \
(Current).first_line = (Current).last_line = \
YYRHSLOC (Rhs, 0).last_line; \
(Current).first_column = (Current).last_column = \
YYRHSLOC (Rhs, 0).last_column; \
} \
while (YYID (0))
#endif

	#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 yyerrorlab

/* This macro is provided for backward compatibility. */

#ifndef YY_LOCATION_PRINT	#define YYRECOVERING() (!!yyerrstatus)
# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
#endif

	#define YYBACKUP(Token, Value) \
	do \
	if (yychar == YYEMPTY) \
	{ \
	yychar = (Token); \
	yylval = (Value); \
	YYPOPSTACK (yylen); \
	yystate = *yyssp; \
	goto yybackup; \
	} \
	else \
	{ \
	yyerror (pc, YY_("syntax error: cannot back up")); \
	YYERROR; \
	} \
	while (0)

	/* Error token number */
	#define YYTERROR 1
	#define YYERRCODE 256

/* YYLEX -- calling `yylex' with the right arguments. */

#ifdef YYLEX_PARAM
# define YYLEX yylex (&yylval, YYLEX_PARAM)
#else
# define YYLEX yylex (&yylval)
#endif

/* Enable debugging if requested. */	/* Enable debugging if requested. */
#if YYDEBUG	#if YYDEBUG
Line 1035 while (YYID (0))	Line 934 while (YYID (0))
# define YYFPRINTF fprintf	# define YYFPRINTF fprintf
# endif	# endif

# define YYDPRINTF(Args) \	# define YYDPRINTF(Args) \
do { \	do { \
if (yydebug) \	if (yydebug) \
YYFPRINTF Args; \	YYFPRINTF Args; \
} while (YYID (0))	} while (0)

# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
do { \
if (yydebug) \
{ \
YYFPRINTF (stderr, "%s ", Title); \
yy_symbol_print (stderr, \
Type, Value); \
YYFPRINTF (stderr, "\n"); \
} \
} while (YYID (0))

	/* This macro is provided for backward compatibility. */
	#ifndef YY_LOCATION_PRINT
	# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
	#endif

/*--------------------------------.
\| Print this symbol on YYOUTPUT. \|
`--------------------------------*/

/ARGSUSED/	# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
#if (defined __STDC__ \|\| defined __C99__FUNC__ \	do { \
\|\| defined __cplusplus \|\| defined _MSC_VER)	if (yydebug) \
static void	{ \
yy_symbol_value_print (FILE yyoutput, int yytype, YYSTYPE const const yyvaluep)	YYFPRINTF (stderr, "%s ", Title); \
#else	yy_symbol_print (stderr, \
	Type, Value, pc); \
	YYFPRINTF (stderr, "\n"); \
	} \
	} while (0)


	/*----------------------------------------.
	\| Print this symbol's value on YYOUTPUT. \|
	`----------------------------------------*/

static void	static void
yy_symbol_value_print (yyoutput, yytype, yyvaluep)	yy_symbol_value_print (FILE yyoutput, int yytype, YYSTYPE const const yyvaluep, Parse_control* pc)
FILE *yyoutput;
int yytype;
YYSTYPE const * const yyvaluep;
#endif
{	{
	FILE *yyo = yyoutput;
	YYUSE (yyo);
	YYUSE (pc);
if (!yyvaluep)	if (!yyvaluep)
return;	return;
# ifdef YYPRINT	# ifdef YYPRINT
if (yytype < YYNTOKENS)	if (yytype < YYNTOKENS)
YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);	YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
# else
YYUSE (yyoutput);
# endif	# endif
switch (yytype)	YYUSE (yytype);
{
default:
break;
}
}	}


Line 1090 yy_symbol_value_print (yyoutput, yytype,	Line 982 yy_symbol_value_print (yyoutput, yytype,
\| Print this symbol on YYOUTPUT. \|	\| Print this symbol on YYOUTPUT. \|
`--------------------------------*/	`--------------------------------*/

#if (defined __STDC__ \|\| defined __C99__FUNC__ \
\|\| defined __cplusplus \|\| defined _MSC_VER)
static void	static void
yy_symbol_print (FILE yyoutput, int yytype, YYSTYPE const const yyvaluep)	yy_symbol_print (FILE yyoutput, int yytype, YYSTYPE const const yyvaluep, Parse_control* pc)
#else
static void
yy_symbol_print (yyoutput, yytype, yyvaluep)
FILE *yyoutput;
int yytype;
YYSTYPE const * const yyvaluep;
#endif
{	{
if (yytype < YYNTOKENS)	YYFPRINTF (yyoutput, "%s %s (",
YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);	yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
else
YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);

yy_symbol_value_print (yyoutput, yytype, yyvaluep);	yy_symbol_value_print (yyoutput, yytype, yyvaluep, pc);
YYFPRINTF (yyoutput, ")");	YYFPRINTF (yyoutput, ")");
}	}

Line 1116 yy_symbol_print (yyoutput, yytype, yyval	Line 997 yy_symbol_print (yyoutput, yytype, yyval
\| TOP (included). \|	\| TOP (included). \|
`------------------------------------------------------------------*/	`------------------------------------------------------------------*/

#if (defined __STDC__ \|\| defined __C99__FUNC__ \
\|\| defined __cplusplus \|\| defined _MSC_VER)
static void	static void
yy_stack_print (yytype_int16 yybottom, yytype_int16 yytop)	yy_stack_print (yytype_int16 yybottom, yytype_int16 yytop)
#else
static void
yy_stack_print (yybottom, yytop)
yytype_int16 *yybottom;
yytype_int16 *yytop;
#endif
{	{
YYFPRINTF (stderr, "Stack now");	YYFPRINTF (stderr, "Stack now");
for (; yybottom <= yytop; yybottom++)	for (; yybottom <= yytop; yybottom++)
Line 1136 yy_stack_print (yybottom, yytop)	Line 1009 yy_stack_print (yybottom, yytop)
YYFPRINTF (stderr, "\n");	YYFPRINTF (stderr, "\n");
}	}

# define YY_STACK_PRINT(Bottom, Top) \	# define YY_STACK_PRINT(Bottom, Top) \
do { \	do { \
if (yydebug) \	if (yydebug) \
yy_stack_print ((Bottom), (Top)); \	yy_stack_print ((Bottom), (Top)); \
} while (YYID (0))	} while (0)


/*------------------------------------------------.	/*------------------------------------------------.
\| Report that the YYRULE is going to be reduced. \|	\| Report that the YYRULE is going to be reduced. \|
`------------------------------------------------*/	`------------------------------------------------*/

#if (defined __STDC__ \|\| defined __C99__FUNC__ \
\|\| defined __cplusplus \|\| defined _MSC_VER)
static void	static void
yy_reduce_print (YYSTYPE *yyvsp, int yyrule)	yy_reduce_print (yytype_int16 yyssp, YYSTYPE yyvsp, int yyrule, Parse_control* pc)
#else
static void
yy_reduce_print (yyvsp, yyrule)
YYSTYPE *yyvsp;
int yyrule;
#endif
{	{
	unsigned long int yylno = yyrline[yyrule];
int yynrhs = yyr2[yyrule];	int yynrhs = yyr2[yyrule];
int yyi;	int yyi;
unsigned long int yylno = yyrline[yyrule];
YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",	YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
yyrule - 1, yylno);	yyrule - 1, yylno);
/* 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);	YYFPRINTF (stderr, " $%d = ", yyi + 1);
yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],	yy_symbol_print (stderr,
&(yyvsp[(yyi + 1) - (yynrhs)])	yystos[yyssp[yyi + 1 - yynrhs]],
);	&(yyvsp[(yyi + 1) - (yynrhs)])
	, pc);
YYFPRINTF (stderr, "\n");	YYFPRINTF (stderr, "\n");
}	}
}	}

# define YY_REDUCE_PRINT(Rule) \	# define YY_REDUCE_PRINT(Rule) \
do { \	do { \
if (yydebug) \	if (yydebug) \
yy_reduce_print (yyvsp, Rule); \	yy_reduce_print (yyssp, yyvsp, Rule, pc); \
} while (YYID (0))	} while (0)

/* Nonzero means print parse trace. It is left uninitialized so that	/* Nonzero means print parse trace. It is left uninitialized so that
multiple parsers can coexist. */	multiple parsers can coexist. */
Line 1192 int yydebug;	Line 1058 int yydebug;


/* YYINITDEPTH -- initial size of the parser's stacks. */	/* YYINITDEPTH -- initial size of the parser's stacks. */
#ifndef YYINITDEPTH	#ifndef YYINITDEPTH
# define YYINITDEPTH 200	# define YYINITDEPTH 200
#endif	#endif

Line 1215 int yydebug;	Line 1081 int yydebug;
# define yystrlen strlen	# define yystrlen strlen
# else	# else
/* Return the length of YYSTR. */	/* Return the length of YYSTR. */
#if (defined __STDC__ \|\| defined __C99__FUNC__ \
\|\| defined __cplusplus \|\| defined _MSC_VER)
static YYSIZE_T	static YYSIZE_T
yystrlen (const char *yystr)	yystrlen (const char *yystr)
#else
static YYSIZE_T
yystrlen (yystr)
const char *yystr;
#endif
{	{
YYSIZE_T yylen;	YYSIZE_T yylen;
for (yylen = 0; yystr[yylen]; yylen++)	for (yylen = 0; yystr[yylen]; yylen++)
Line 1239 yystrlen (yystr)	Line 1098 yystrlen (yystr)
# else	# else
/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in	/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
YYDEST. */	YYDEST. */
#if (defined __STDC__ \|\| defined __C99__FUNC__ \
\|\| defined __cplusplus \|\| defined _MSC_VER)
static char *	static char *
yystpcpy (char yydest, const char yysrc)	yystpcpy (char yydest, const char yysrc)
#else
static char *
yystpcpy (yydest, yysrc)
char *yydest;
const char *yysrc;
#endif
{	{
char *yyd = yydest;	char *yyd = yydest;
const char *yys = yysrc;	const char *yys = yysrc;
Line 1278 yytnamerr (char yyres, const char yyst	Line 1129 yytnamerr (char yyres, const char yyst
char const *yyp = yystr;	char const *yyp = yystr;

for (;;)	for (;;)
switch (*++yyp)	switch (*++yyp)
{	{
case '\'':	case '\'':
case ',':	case ',':
goto do_not_strip_quotes;	goto do_not_strip_quotes;

case '\\':	case '\\':
if (*++yyp != '\\')	if (*++yyp != '\\')
goto do_not_strip_quotes;	goto do_not_strip_quotes;
/* Fall through. */	/* Fall through. */
default:	default:
if (yyres)	if (yyres)
yyres[yyn] = *yyp;	yyres[yyn] = *yyp;
yyn++;	yyn++;
break;	break;

case '"':	case '"':
if (yyres)	if (yyres)
yyres[yyn] = '\0';	yyres[yyn] = '\0';
return yyn;	return yyn;
}	}
do_not_strip_quotes: ;	do_not_strip_quotes: ;
}	}

Line 1321 static int	Line 1172 static int
yysyntax_error (YYSIZE_T yymsg_alloc, char *yymsg,	yysyntax_error (YYSIZE_T yymsg_alloc, char *yymsg,
yytype_int16 *yyssp, int yytoken)	yytype_int16 *yyssp, int yytoken)
{	{
YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);	YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
YYSIZE_T yysize = yysize0;	YYSIZE_T yysize = yysize0;
YYSIZE_T yysize1;
enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };	enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
/* Internationalized format string. */	/* Internationalized format string. */
const char *yyformat = 0;	const char *yyformat = YY_NULLPTR;
/* Arguments of yyformat. */	/* Arguments of yyformat. */
char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];	char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
/* Number of reported tokens (one for the "unexpected", one per	/* Number of reported tokens (one for the "unexpected", one per
Line 1334 yysyntax_error (YYSIZE_T *yymsg_alloc, c	Line 1184 yysyntax_error (YYSIZE_T *yymsg_alloc, c
int yycount = 0;	int yycount = 0;

/* There are many possibilities here to consider:	/* There are many possibilities here to consider:
- Assume YYFAIL is not used. It's too flawed to consider. See
<http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
for details. YYERROR is fine as it does not invoke this
function.
- If this state is a consistent state with a default action, then	- If this state is a consistent state with a default action, then
the only way this function was invoked is if the default action	the only way this function was invoked is if the default action
is an error action. In that case, don't check for expected	is an error action. In that case, don't check for expected
Line 1386 yysyntax_error (YYSIZE_T *yymsg_alloc, c	Line 1232 yysyntax_error (YYSIZE_T *yymsg_alloc, c
break;	break;
}	}
yyarg[yycount++] = yytname[yyx];	yyarg[yycount++] = yytname[yyx];
yysize1 = yysize + yytnamerr (0, yytname[yyx]);	{
if (! (yysize <= yysize1	YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
&& yysize1 <= YYSTACK_ALLOC_MAXIMUM))	if (! (yysize <= yysize1
return 2;	&& yysize1 <= YYSTACK_ALLOC_MAXIMUM))
yysize = yysize1;	return 2;
	yysize = yysize1;
	}
}	}
}	}
}	}
Line 1410 yysyntax_error (YYSIZE_T *yymsg_alloc, c	Line 1258 yysyntax_error (YYSIZE_T *yymsg_alloc, c
# undef YYCASE_	# undef YYCASE_
}	}

yysize1 = yysize + yystrlen (yyformat);	{
if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))	YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
return 2;	if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
yysize = yysize1;	return 2;
	yysize = yysize1;
	}

if (*yymsg_alloc < yysize)	if (*yymsg_alloc < yysize)
{	{
Line 1450 yysyntax_error (YYSIZE_T *yymsg_alloc, c	Line 1300 yysyntax_error (YYSIZE_T *yymsg_alloc, c
\| Release the memory associated to this symbol. \|	\| Release the memory associated to this symbol. \|
`-----------------------------------------------*/	`-----------------------------------------------*/

/ARGSUSED/
#if (defined __STDC__ \|\| defined __C99__FUNC__ \
\|\| defined __cplusplus \|\| defined _MSC_VER)
static void	static void
yydestruct (const char yymsg, int yytype, YYSTYPE yyvaluep)	yydestruct (const char yymsg, int yytype, YYSTYPE yyvaluep, Parse_control* pc)
#else
static void
yydestruct (yymsg, yytype, yyvaluep)
const char *yymsg;
int yytype;
YYSTYPE *yyvaluep;
#endif
{	{
YYUSE (yyvaluep);	YYUSE (yyvaluep);
	YYUSE (pc);
if (!yymsg)	if (!yymsg)
yymsg = "Deleting";	yymsg = "Deleting";
YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);	YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);

switch (yytype)	YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
{	YYUSE (yytype);
	YY_IGNORE_MAYBE_UNINITIALIZED_END
default:
break;
}
}	}


/* Prevent warnings from -Wmissing-prototypes. */
#ifdef YYPARSE_PARAM
#if defined __STDC__ \|\| defined __cplusplus
int yyparse (void *YYPARSE_PARAM);
#else
int yyparse ();
#endif
#else /* ! YYPARSE_PARAM */
#if defined __STDC__ \|\| defined __cplusplus
int yyparse (void);
#else
int yyparse ();
#endif
#endif /* ! YYPARSE_PARAM */


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

#ifdef YYPARSE_PARAM
#if (defined __STDC__ \|\| defined __C99__FUNC__ \
\|\| defined __cplusplus \|\| defined _MSC_VER)
int	int
yyparse (void *YYPARSE_PARAM)	yyparse (Parse_control* pc)
#else
int
yyparse (YYPARSE_PARAM)
void *YYPARSE_PARAM;
#endif
#else /* ! YYPARSE_PARAM */
#if (defined __STDC__ \|\| defined __C99__FUNC__ \
\|\| defined __cplusplus \|\| defined _MSC_VER)
int
yyparse (void)
#else
int
yyparse ()

#endif
#endif
{	{
/* The lookahead symbol. */	/* The lookahead symbol. */
int yychar;	int yychar;


/* The semantic value of the lookahead symbol. */	/* The semantic value of the lookahead symbol. */
YYSTYPE yylval;	/* Default value used for initialization, for pacifying older GCCs
	or non-GCC compilers. */
	YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
	YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);

/* Number of syntax errors so far. */	/* Number of syntax errors so far. */
int yynerrs;	int yynerrs;
Line 1534 YYSTYPE yylval;	Line 1342 YYSTYPE yylval;
int yyerrstatus;	int yyerrstatus;

/* The stacks and their tools:	/* The stacks and their tools:
`yyss': related to states.	'yyss': related to states.
`yyvs': related to semantic values.	'yyvs': related to semantic values.

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

/* The state stack. */	/* The state stack. */
Line 1555 YYSTYPE yylval;	Line 1363 YYSTYPE yylval;
int yyn;	int yyn;
int yyresult;	int yyresult;
/* Lookahead token as an internal (translated) token number. */	/* Lookahead token as an internal (translated) token number. */
int yytoken;	int yytoken = 0;
/* The variables used to return semantic value and location from the	/* The variables used to return semantic value and location from the
action routines. */	action routines. */
YYSTYPE yyval;	YYSTYPE yyval;
Line 1573 YYSTYPE yylval;	Line 1381 YYSTYPE yylval;
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;	yyssp = yyss = yyssa;
yyss = yyssa;	yyvsp = yyvs = yyvsa;
yyvs = yyvsa;
yystacksize = YYINITDEPTH;	yystacksize = YYINITDEPTH;

YYDPRINTF ((stderr, "Starting parse\n"));	YYDPRINTF ((stderr, "Starting parse\n"));
Line 1584 YYSTYPE yylval;	Line 1391 YYSTYPE yylval;
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.
Waste one element of value and location stack
so that they stay on the same level as the state stack.
The wasted elements are never initialized. */
yyssp = yyss;
yyvsp = yyvs;

goto yysetstate;	goto yysetstate;

/*------------------------------------------------------------.	/*------------------------------------------------------------.
Line 1612 YYSTYPE yylval;	Line 1411 YYSTYPE yylval;

#ifdef yyoverflow	#ifdef yyoverflow
{	{
/* Give user a chance to reallocate the stack. Use copies of	/* Give user a chance to reallocate the stack. Use copies of
these so that the &'s don't force the real ones into	these so that the &'s don't force the real ones into
memory. */	memory. */
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
be undefined if yyoverflow is a macro. */	be undefined if yyoverflow is a macro. */
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;
yyvs = yyvs1;	yyvs = yyvs1;
}	}
#else /* no yyoverflow */	#else /* no yyoverflow */
# ifndef YYSTACK_RELOCATE	# ifndef YYSTACK_RELOCATE
Line 1636 YYSTYPE yylval;	Line 1435 YYSTYPE yylval;
# else	# else
/* Extend the stack our own way. */	/* Extend the stack our own way. */
if (YYMAXDEPTH <= yystacksize)	if (YYMAXDEPTH <= yystacksize)
goto yyexhaustedlab;	goto yyexhaustedlab;
yystacksize *= 2;	yystacksize *= 2;
if (YYMAXDEPTH < yystacksize)	if (YYMAXDEPTH < yystacksize)
yystacksize = YYMAXDEPTH;	yystacksize = YYMAXDEPTH;

{	{
yytype_int16 *yyss1 = yyss;	yytype_int16 *yyss1 = yyss;
union yyalloc *yyptr =	union yyalloc *yyptr =
(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_alloc, yyss);
YYSTACK_RELOCATE (yyvs_alloc, yyvs);	YYSTACK_RELOCATE (yyvs_alloc, yyvs);
# undef YYSTACK_RELOCATE	# undef YYSTACK_RELOCATE
if (yyss1 != yyssa)	if (yyss1 != yyssa)
YYSTACK_FREE (yyss1);	YYSTACK_FREE (yyss1);
}	}
# endif	# endif
#endif /* no yyoverflow */	#endif /* no yyoverflow */
Line 1660 YYSTYPE yylval;	Line 1459 YYSTYPE yylval;
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));

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

YYDPRINTF ((stderr, "Entering state %d\n", yystate));	YYDPRINTF ((stderr, "Entering state %d\n", yystate));
Line 1692 yybackup:	Line 1491 yybackup:
if (yychar == YYEMPTY)	if (yychar == YYEMPTY)
{	{
YYDPRINTF ((stderr, "Reading a token: "));	YYDPRINTF ((stderr, "Reading a token: "));
yychar = YYLEX;	yychar = yylex (&yylval, pc);
}	}

if (yychar <= YYEOF)	if (yychar <= YYEOF)
Line 1732 yybackup:	Line 1531 yybackup:
yychar = YYEMPTY;	yychar = YYEMPTY;

yystate = yyn;	yystate = yyn;
	YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
*++yyvsp = yylval;	*++yyvsp = yylval;
	YY_IGNORE_MAYBE_UNINITIALIZED_END

goto yynewstate;	goto yynewstate;

Line 1755 yyreduce:	Line 1556 yyreduce:
yylen = yyr2[yyn];	yylen = yyr2[yyn];

/* If YYLEN is nonzero, implement the default value of the action:	/* If YYLEN is nonzero, implement the default value of the action:
`$$ = $1'.	'$$ = $1'.

Otherwise, the following line sets YYVAL to garbage.	Otherwise, the following line sets YYVAL to garbage.
This behavior is undocumented and Bison	This behavior is undocumented and Bison
Line 1769 yyreduce:	Line 1570 yyreduce:
switch (yyn)	switch (yyn)
{	{
case 2:	case 2:
	#line 145 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 140 "compile.y"
{	{
Method* method=new Method(Method::CT_ANY,	Method* method=new Method(Method::CT_ANY, 0, 0 /min, max numbered_params_count/, 0 /param_names/, 0 /local_names/, (yyvsp[0]) /parser_code/, 0 /native_code/, PC.cclass->is_vars_local());
0, 0, /min, max numbered_params_count/
0/param_names/, 0/local_names/,
(yyvsp[(1) - (1)])/parser_code/, 0/native_code/);
PC.cclass->set_method(PC.alias_method(main_method_name), method);	PC.cclass->set_method(PC.alias_method(main_method_name), method);
}	}
	#line 1579 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 9:	case 9:
	#line 157 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 155 "compile.y"
{	{
const String& command=LA2S(*(yyvsp[(2) - (4)]))->trim(String::TRIM_END);	const String& command=LA2S(*(yyvsp[-2]))->trim(String::TRIM_END);
YYSTYPE strings_code=(yyvsp[(4) - (4)]);	YYSTYPE strings_code=(yyvsp[0]);
if(strings_code->count()<1*OPERATIONS_PER_OPVALUE) {	if(strings_code->count()<1*OPERATIONS_PER_OPVALUE) {
strcpy(PC.error, "@");	PC_ERROR("@", command.cstr(), " is empty");
strcat(PC.error, command.cstr());
strcat(PC.error, " is empty");
YYERROR;	YYERROR;
}	}
if(command==CLASS_NAME) {	if(command==CLASS_NAME) {
Line 1800 yyreduce:	Line 1593 yyreduce:
// new class' name	// new class' name
const String& name=LA2S(*strings_code)->trim(String::TRIM_END);	const String& name=LA2S(*strings_code)->trim(String::TRIM_END);
// creating the class	// creating the class
VStateless_class* cclass=new VClass;	VStateless_class* cclass=new VClass(name.cstr(), PC.request.get_used_filespec(PC.file_no));
PC.cclass_new=cclass;	PC.cclass_new=cclass;
PC.cclass_new->set_name(name);
PC.append=false;	PC.append=false;
} else {	} else {
strcpy(PC.error, "@" CLASS_NAME " must contain only one line with class name (contains more then one)");	strcpy(PC.error, "@" CLASS_NAME " must contain only one line with class name (contains more then one)");
Line 1810 yyreduce:	Line 1602 yyreduce:
}	}
} else if(command==USE_CONTROL_METHOD_NAME) {	} else if(command==USE_CONTROL_METHOD_NAME) {
CLASS_ADD;	CLASS_ADD;
for(size_t i=0; i<strings_code->count(); i+=OPERATIONS_PER_OPVALUE)	for(size_t i=0; i<strings_code->count(); i+=OPERATIONS_PER_OPVALUE){
PC.request.use_file(PC.request.main_class, LA2S(*strings_code, i)->trim(String::TRIM_END), PC.request.get_used_filename(PC.file_no));	PC.request.use_file(LA2S(*strings_code, i)->trim(String::TRIM_END), PC.request.get_used_filespec(PC.file_no), strings_code->get(i+1).origin);
	}
} else if(command==BASE_NAME) {	} else if(command==BASE_NAME) {
if(PC.append){	if(PC.append){
strcpy(PC.error, "can't set base while appending methods to class '");	PC_ERROR("can't set base while appending methods to class '", PC.cclass->type(), "'");
strncat(PC.error, PC.cclass->name().cstr(), MAX_STRING/2);
strcat(PC.error, "'");
YYERROR;	YYERROR;
}	}
CLASS_ADD;	CLASS_ADD;
if(PC.cclass->base_class()) { // already changed from default?	if(PC.cclass->base_class()) { // already changed from default?
strcpy(PC.error, "class already have a base '");	PC_ERROR("class already have a base '", PC.cclass->base_class()->type(), "'");
strncat(PC.error, PC.cclass->base_class()->name().cstr(), MAX_STRING/2);
strcat(PC.error, "'");
YYERROR;	YYERROR;
}	}
if(strings_code->count()==1*OPERATIONS_PER_OPVALUE) {	if(strings_code->count()==1*OPERATIONS_PER_OPVALUE) {
const String& base_name=LA2S(*strings_code)->trim(String::TRIM_END);	const String& base_name=LA2S(*strings_code)->trim(String::TRIM_END);
if(Value* base_class_value=PC.request.get_class(base_name)) {	if(VStateless_class *base_class=PC.request.get_class(base_name)) {
// @CLASS == @BASE sanity check	// @CLASS == @BASE sanity check
if(VStateless_class *base_class=base_class_value->get_class()) {	if(PC.cclass==base_class) {
if(PC.cclass==base_class) {	strcpy(PC.error, "@" CLASS_NAME " equals @" BASE_NAME);
strcpy(PC.error, "@" CLASS_NAME " equals @" BASE_NAME);
YYERROR;
}
PC.cclass->get_class()->set_base(base_class);
} else { // they asked to derive from a class without methods ['env' & co]
strcpy(PC.error, base_name.cstr());
strcat(PC.error, ": you can not derive from this class in @" BASE_NAME);
YYERROR;	YYERROR;
}	}
	PC.cclass->get_class()->set_base(base_class);
} else {	} else {
strcpy(PC.error, base_name.cstr());	PC_ERROR("'", base_name.cstr(), "': undefined class in @" BASE_NAME);
strcat(PC.error, ": undefined class in @" BASE_NAME);
YYERROR;	YYERROR;
}	}
} else {	} else {
Line 1853 yyreduce:	Line 1635 yyreduce:
} else if(command==OPTIONS_CONTROL_METHOD_NAME) {	} else if(command==OPTIONS_CONTROL_METHOD_NAME) {
for(size_t i=0; i<strings_code->count(); i+=OPERATIONS_PER_OPVALUE) {	for(size_t i=0; i<strings_code->count(); i+=OPERATIONS_PER_OPVALUE) {
const String& option=LA2S(*strings_code, i)->trim(String::TRIM_END);	const String& option=LA2S(*strings_code, i)->trim(String::TRIM_END);
if(option==OPTION_ALL_VARS_LOCAL_NAME){	if(option==Symbols::LOCALS_SYMBOL){
PC.set_all_vars_local();	PC.set_all_vars_local();
} else if(option==OPTION_PARTIAL_CLASS){	} else if(option==Symbols::PARTIAL_SYMBOL){
if(PC.cclass_new){	if(PC.cclass_new){
if(VStateless_class* existed=PC.get_existed_class(PC.cclass_new)){	if(VStateless_class* existed=PC.get_existed_class(PC.cclass_new)){
if(!PC.reuse_existed_class(existed)){	if(!PC.reuse_existed_class(existed)){
strcpy(PC.error, "can't append methods to '");	PC_ERROR("can't append methods to '", PC.cclass_new->type(), "' - the class wasn't marked as partial");
strncat(PC.error, PC.cclass_new->name().cstr(), MAX_STRING/2);
strcat(PC.error, "' - the class wasn't marked as partial");
YYERROR;	YYERROR;
}	}
} else {	} else {
Line 1869 yyreduce:	Line 1649 yyreduce:
PC.cclass_new->set_partial();	PC.cclass_new->set_partial();
}	}
} else {	} else {
strcpy(PC.error, "'" OPTION_PARTIAL_CLASS "' option should be used straight after @" CLASS_NAME);	strcpy(PC.error, "'partial' option should be used straight after @" CLASS_NAME);
YYERROR;	YYERROR;
}	}
} else if(option==method_call_type_static){	} else if(option==Symbols::STATIC_SYMBOL){
PC.set_methods_call_type(Method::CT_STATIC);	PC.set_methods_call_type(Method::CT_STATIC);
} else if(option==method_call_type_dynamic){	} else if(option==Symbols::DYNAMIC_SYMBOL){
PC.set_methods_call_type(Method::CT_DYNAMIC);	PC.set_methods_call_type(Method::CT_DYNAMIC);
} else {	} else {
strcpy(PC.error, "'");	PC_ERROR("'", option.cstr(), "' invalid option. valid options are 'partial', 'locals', 'static' and 'dynamic'");
strncat(PC.error, option.cstr(), MAX_STRING/2);
strcat(PC.error, "' invalid option. valid options are "
"'" OPTION_PARTIAL_CLASS "', '" OPTION_ALL_VARS_LOCAL_NAME "'"
", '" METHOD_CALL_TYPE_STATIC "' and '" METHOD_CALL_TYPE_DYNAMIC "'"
);
YYERROR;	YYERROR;
}	}
}	}
} else {	} else {
strcpy(PC.error, "'");	PC_ERROR("'", command.cstr(), "' invalid special name. valid names are '" CLASS_NAME "', '" USE_CONTROL_METHOD_NAME "', '" BASE_NAME "' and '" OPTIONS_CONTROL_METHOD_NAME "'.");
strncat(PC.error, command.cstr(), MAX_STRING/2);
strcat(PC.error, "' invalid special name. valid names are "
"'" CLASS_NAME "', '" USE_CONTROL_METHOD_NAME "', '" BASE_NAME "' and '" OPTIONS_CONTROL_METHOD_NAME "'.");
YYERROR;	YYERROR;
}	}
}	}
	#line 1670 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 13:	case 13:
	#line 244 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-1]); P((yyval), (yyvsp[0])); }
#line 265 "compile.y"	#line 1676 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (2)]); P((yyval), (yyvsp[(2) - (2)])); }
break;	break;

case 17:	case 17:
	#line 248 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 269 "compile.y"
{	{
CLASS_ADD;	CLASS_ADD;
PC.explicit_result=false;	PC.explicit_result=false;

YYSTYPE params_names_code=(yyvsp[(3) - (6)]);	YYSTYPE params_names_code=(yyvsp[-3]);
ArrayString* params_names=0;	ArrayString* params_names=0;
if(int size=params_names_code->count()) {	if(int size=params_names_code->count()) {
params_names=new ArrayString;	params_names=new ArrayString;
Line 1919 yyreduce:	Line 1689 yyreduce:
params_names+=LA2S(params_names_code, i);	params_names+=LA2S(params_names_code, i);
}	}

YYSTYPE locals_names_code=(yyvsp[(4) - (6)]);	YYSTYPE locals_names_code=(yyvsp[-2]);
ArrayString* locals_names=0;	ArrayString* locals_names=0;
bool all_vars_local=false;	bool all_vars_local=PC.cclass->is_vars_local();

if(int size=locals_names_code->count()) {	if(int size=locals_names_code->count()) {
locals_names=new ArrayString;	locals_names=new ArrayString;
for(int i=0; i<size; i+=OPERATIONS_PER_OPVALUE) {	for(int i=0; i<size; i+=OPERATIONS_PER_OPVALUE) {
const String* local_name=LA2S(*locals_names_code, i);	const String* local_name=LA2S(*locals_names_code, i);
if(*local_name==RESULT_VAR_NAME)	if(SYMBOLS_EQ(*local_name,RESULT_SYMBOL))
PC.explicit_result=true;	PC.explicit_result=true;
else if(*local_name==OPTION_ALL_VARS_LOCAL_NAME)	else if(SYMBOLS_EQ(*local_name,LOCALS_SYMBOL))
all_vars_local=true;	all_vars_local=true;
else	else
*locals_names+=local_name;	*locals_names+=local_name;
}	}
}	}
if(!all_vars_local && PC.cclass && PC.cclass->is_vars_local())
all_vars_local=true;

Method* method=new Method(	Method* method=new Method(
//name,	//name,
GetMethodCallType(PC, *(yyvsp[(2) - (6)])),	GetMethodCallType(PC, *(yyvsp[-4])),
0, 0/min,max numbered_params_count/,	0, 0/min,max numbered_params_count/,
params_names, locals_names,	params_names, locals_names,
0/to be filled later in next {} /, 0, all_vars_local);	0/to be filled later in next {} /, 0, all_vars_local);

reinterpret_cast<Method*>(&(yyval))=method;	reinterpret_cast<Method*>(&(yyval))=method;
}	}
	#line 1719 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 18:	case 18:
	#line 285 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 307 "compile.y"
{	{
Method* method=reinterpret_cast<Method*>((yyvsp[(7) - (8)]));	Method* method=reinterpret_cast<Method*>((yyvsp[-1]));
// fill in the code	// fill in the code
method->parser_code=(yyvsp[(8) - (8)]);	method->parser_code=(yyvsp[0]);

// register in class	// register in class
const String& name=LA2S((yyvsp[(2) - (8)]));	const String& name=LA2S((yyvsp[-6]));
PC.cclass->set_method(PC.alias_method(name), method);	PC.cclass->set_method(PC.alias_method(name), method);
}	}
	#line 1733 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 21:	case 21:
	#line 296 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{(yyval)=(yyvsp[-1]);}
#line 318 "compile.y"	#line 1739 "compile.tab.C" /* yacc.c:1646 */
{(yyval)=(yyvsp[(2) - (3)]);}
break;	break;

case 25:	case 25:
	#line 298 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-2]); P((yyval), (yyvsp[0])); }
#line 320 "compile.y"	#line 1745 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (3)]); P((yyval), (yyvsp[(3) - (3)])); }
break;	break;

case 31:	case 31:
	#line 306 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-1]); P((yyval), (yyvsp[0])); }
#line 328 "compile.y"	#line 1751 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (2)]); P((yyval), (yyvsp[(2) - (2)])); }
break;	break;

case 37:	case 37:
	#line 312 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 334 "compile.y"
{	{
(yyval)=N();	(yyval)=N();
YYSTYPE code=(yyvsp[(1) - (1)]);	YYSTYPE code=(yyvsp[0]);
size_t count=code->count();	size_t count=code->count();

#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT	#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT
if(	if(count!=3 \|\| !change_first(code, OP::OP_VALUE__GET_ELEMENT, /=>*/OP::OP_VALUE__GET_ELEMENT__WRITE) )
count!=3
\|\| !change_first(code, OP::OP_VALUE__GET_ELEMENT, /=>*/OP::OP_VALUE__GET_ELEMENT__WRITE)
)
#endif	#endif

#ifdef OPTIMIZE_BYTECODE_GET_SELF_ELEMENT	#ifdef OPTIMIZE_BYTECODE_GET_SELF_ELEMENT
if(	if(count!=3 \|\| !change_first(code, OP::OP_WITH_SELF__VALUE__GET_ELEMENT, /=>*/OP::OP_WITH_SELF__VALUE__GET_ELEMENT__WRITE) )
count!=3
\|\| !change_first(code, OP::OP_WITH_SELF__VALUE__GET_ELEMENT, /=>*/OP::OP_WITH_SELF__VALUE__GET_ELEMENT__WRITE)
)
#endif	#endif

#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_ELEMENT	#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_ELEMENT
if(	if(count!=5 \|\| !change_first(code, OP::OP_GET_OBJECT_ELEMENT, /=>*/OP::OP_GET_OBJECT_ELEMENT__WRITE) )
count!=5
\|\| !change_first(code, OP::OP_GET_OBJECT_ELEMENT, /=>*/OP::OP_GET_OBJECT_ELEMENT__WRITE)
)
#endif	#endif

#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_VAR_ELEMENT	#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_VAR_ELEMENT
if(	if(count!=5 \|\| !change_first(code, OP::OP_GET_OBJECT_VAR_ELEMENT, /=>*/OP::OP_GET_OBJECT_VAR_ELEMENT__WRITE) )
count!=5
\|\| !change_first(code, OP::OP_GET_OBJECT_VAR_ELEMENT, /=>*/OP::OP_GET_OBJECT_VAR_ELEMENT__WRITE)
)
#endif	#endif

#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT__SPECIAL	#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT__SPECIAL
if(	if(!change(code, count-1/ last /, OP::OP_GET_ELEMENT__SPECIAL, /=>*/OP::OP_GET_ELEMENT__SPECIAL__WRITE) )
!change(code, count-1/ last /, OP::OP_GET_ELEMENT__SPECIAL, /=>*/OP::OP_GET_ELEMENT__SPECIAL__WRITE)
)
#endif	#endif

{	{
change_or_append(code, count-1 / last */,	change_or_append(code, count-1 / last /, OP::OP_GET_ELEMENT, /=>/OP::OP_GET_ELEMENT__WRITE, /or /OP::OP_WRITE_VALUE ); / value=pop; wcontext.write(value) */
OP::OP_GET_ELEMENT, /=>/OP::OP_GET_ELEMENT__WRITE,
/or /OP::OP_WRITE_VALUE
); /* value=pop; wcontext.write(value) */
}	}

P((yyval), code);	P((yyval), code);
}	}
	#line 1787 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 38:	case 38:
	#line 343 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[0]); }
#line 382 "compile.y"	#line 1793 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(2) - (2)]); }
break;	break;

case 41:	case 41:
	#line 345 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-1]); }
#line 384 "compile.y"	#line 1799 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(2) - (3)]); }
break;	break;

case 44:	case 44:
	#line 349 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 388 "compile.y"
{	{
(yyval)=N();	(yyval)=N();
YYSTYPE diving_code=(yyvsp[(1) - (1)]);	YYSTYPE diving_code=(yyvsp[0]);
size_t count=diving_code->count();	size_t count=diving_code->count();

if(maybe_make_self((yyval), diving_code, count)) {	if(maybe_make_self((yyval), diving_code, count)) {
Line 2078 yyreduce:	Line 1822 yyreduce:
#endif	#endif

#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT	#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT
if(	if(count>=4 && (diving_code)[0].code==OP::OP_VALUE && (diving_code)[3].code==OP::OP_GET_ELEMENT ){
count>=4
&& (*diving_code)[0].code==OP::OP_VALUE
&& (*diving_code)[3].code==OP::OP_GET_ELEMENT
){
// optimization	// optimization
O(*(yyval),	O(*(yyval),
(PC.in_call_value && count==4)	(PC.in_call_value && count==4)
Line 2109 yyreduce:	Line 1849 yyreduce:
#endif	#endif
/* diving code; stack: current context */	/* diving code; stack: current context */
}	}
	#line 1853 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 45:	case 45:
	#line 398 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-1]); P((yyval), (yyvsp[0])); }
#line 441 "compile.y"	#line 1859 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (2)]); P((yyval), (yyvsp[(2) - (2)])); }
break;	break;

case 47:	case 47:
	#line 399 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-1]); P((yyval), (yyvsp[0])); }
#line 442 "compile.y"	#line 1865 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (2)]); P((yyval), (yyvsp[(2) - (2)])); }
break;	break;

case 48:	case 48:
	#line 403 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 446 "compile.y"
{	{
(yyval)=N();	(yyval)=N();
#ifdef OPTIMIZE_BYTECODE_CONSTRUCT	#ifdef OPTIMIZE_BYTECODE_CONSTRUCT
if(maybe_optimize_construct((yyval), (yyvsp[(2) - (3)]), *(yyvsp[(3) - (3)]))){	if(maybe_optimize_construct((yyval), (yyvsp[-1]), *(yyvsp[0]))){
// $a(expr), $.a(expr), $a[value], $.a[value], $self.a[value], $self.a(expr)	// $a(expr), $.a(expr), $a[value], $.a[value], $self.a[value], $self.a(expr)
} else	} else
#endif	#endif
{	{
P((yyval), (yyvsp[(2) - (3)])); /* stack: context,name */	P((yyval), (yyvsp[-1])); /* stack: context,name */
P((yyval), (yyvsp[(3) - (3)])); /* stack: context,name,constructor_value */	P((yyval), (yyvsp[0])); /* stack: context,name,constructor_value */
}	}
}	}
	#line 1882 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 52:	case 52:
	#line 419 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 462 "compile.y"
{	{
(yyval)=N();	(yyval)=N();
YYSTYPE diving_code=(yyvsp[(1) - (1)]);	YYSTYPE diving_code=(yyvsp[0]);
size_t count=diving_code->count();	size_t count=diving_code->count();

if(maybe_make_self((yyval), diving_code, count)) {	if(maybe_make_self((yyval), diving_code, count)) {
// $self.	// $self.
} else	} else
#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT	#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT
if(	if(count>=4 && (diving_code)[0].code==OP::OP_VALUE && (diving_code)[3].code==OP::OP_GET_ELEMENT ){
count>=4
&& (*diving_code)[0].code==OP::OP_VALUE
&& (*diving_code)[3].code==OP::OP_GET_ELEMENT
){
O(*(yyval), OP::OP_WITH_ROOT__VALUE__GET_ELEMENT);	O(*(yyval), OP::OP_WITH_ROOT__VALUE__GET_ELEMENT);
P((yyval), diving_code, 1/offset/, 2/limit/); // copy origin+value	P((yyval), diving_code, 1/offset/, 2/limit/); // copy origin+value
if(count>4)	if(count>4)
Line 2173 yyreduce:	Line 1905 yyreduce:
}	}
/* diving code; stack: current context */	/* diving code; stack: current context */
}	}
	#line 1909 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 53:	case 53:
	#line 441 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 488 "compile.y"
{	{
(yyval)=N();	(yyval)=N();
O((yyval), OP::OP_WITH_WRITE); / stack: starting context */	O((yyval), OP::OP_WITH_WRITE); / stack: starting context */
P((yyval), (yyvsp[(2) - (2)])); /* diving code; stack: context,name */	P((yyval), (yyvsp[0])); /* diving code; stack: context,name */
}	}
	#line 1919 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 54:	case 54:
	#line 446 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-1]); P((yyval), (yyvsp[0])); }
#line 493 "compile.y"	#line 1925 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (2)]); P((yyval), (yyvsp[(2) - (2)])); }
break;	break;

case 58:	case 58:
	#line 453 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 500 "compile.y"
{	{
// allow $result_or_other_variable[ letters here any time ]	// allow $result_or_other_variable[ letters here any time ]
reinterpret_cast<bool>(&(yyval))=PC.explicit_result; PC.explicit_result=false;	reinterpret_cast<bool>(&(yyval))=PC.explicit_result; PC.explicit_result=false;
}	}
	#line 1934 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 59:	case 59:
	#line 456 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 503 "compile.y"
{	{
PC.explicit_result=reinterpret_cast<bool>(&(yyvsp[(2) - (3)]));	PC.explicit_result=reinterpret_cast<bool>(&(yyvsp[-1]));
}	}
	#line 1942 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 60:	case 60:
	#line 458 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 505 "compile.y"
{	{
// stack: context, name	// stack: context, name
(yyval)=(yyvsp[(3) - (5)]); // stack: context, name, value	(yyval)=(yyvsp[-2]); // stack: context, name, value
O((yyval), OP::OP_CONSTRUCT_VALUE); / value=pop; name=pop; context=pop; construct(context,name,value) */	O((yyval), OP::OP_CONSTRUCT_VALUE); / value=pop; name=pop; context=pop; construct(context,name,value) */
}	}
	#line 1952 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 61:	case 61:
	#line 464 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 511 "compile.y"
{	{
(yyval)=N();	(yyval)=N();
O(*(yyval), OP::OP_PREPARE_TO_EXPRESSION);
// stack: context, name	// stack: context, name
P((yyval), (yyvsp[(2) - (3)])); // stack: context, name, value	P((yyval), (yyvsp[-1])); // stack: context, name, value
O((yyval), OP::OP_CONSTRUCT_EXPR); / value=pop->as_expr_result; name=pop; context=pop; construct(context,name,value) */	O((yyval), OP::OP_CONSTRUCT_EXPR); / value=pop->as_expr_result; name=pop; context=pop; construct(context,name,value) */
}	}
	#line 1963 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 62:	case 62:
	#line 471 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 519 "compile.y"
{	{
// stack: context, name	// stack: context, name
(yyval)=N();	(yyval)=N();
OA((yyval), OP::OP_CURLY_CODE__CONSTRUCT, (yyvsp[(2) - (3)])); / code=pop; name=pop; context=pop; construct(context,name,junction(code)) */	OA((yyval), OP::OP_CURLY_CODE__CONSTRUCT, (yyvsp[-1])); / code=pop; name=pop; context=pop; construct(context,name,junction(code)) */
}	}
	#line 1973 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 66:	case 66:
	#line 482 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 530 "compile.y"
{	{
(yyval)=N();	(yyval)=N();
OA((yyval), OP::OP_OBJECT_POOL, (yyvsp[(1) - (1)])); / stack: empty write context */	OA((yyval), OP::OP_OBJECT_POOL, (yyvsp[0])); / stack: empty write context */
/* some code that writes to that context */	/* some code that writes to that context */
/* context=pop; stack: context.value() */	/* context=pop; stack: context.value() */
}	}
	#line 1984 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 69:	case 69:
	#line 489 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-1]); P((yyval), (yyvsp[0])); }
#line 537 "compile.y"	#line 1990 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (2)]); P((yyval), (yyvsp[(2) - (2)])); }
break;	break;

case 70:	case 70:
	#line 493 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 541 "compile.y"
{	{
size_t count=(yyvsp[(1) - (1)])->count();	size_t count=(yyvsp[0])->count();
#ifdef OPTIMIZE_BYTECODE_CUT_REM_OPERATOR	#ifdef OPTIMIZE_BYTECODE_CUT_REM_OPERATOR
if(count)	if(count)
#endif	#endif
{	{
(yyval)=(yyvsp[(1) - (1)]); /* stack: value */	(yyval)=(yyvsp[0]); /* stack: value */
if(!change_first((yyval), OP::OP_CONSTRUCT_OBJECT, /=>*/OP::OP_CONSTRUCT_OBJECT__WRITE))	if(!change_first((yyval), OP::OP_CONSTRUCT_OBJECT, /=>*/ OP::OP_CONSTRUCT_OBJECT__WRITE))
change_or_append((yyval), count-2 / second last */,	change_or_append((yyval), count-2 / second last /, OP::OP_CALL, /=>/ OP::OP_CALL__WRITE, /or / OP::OP_WRITE_VALUE); / value=pop; wcontext.write(value) */
OP::OP_CALL, /=>/ OP::OP_CALL__WRITE,
/or /OP::OP_WRITE_VALUE); /* value=pop; wcontext.write(value) */
}	}
}	}
	#line 2006 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 71:	case 71:
	#line 504 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 554 "compile.y"
{	{
PC.in_call_value=true;	PC.in_call_value=true;
}	}
	#line 2014 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 72:	case 72:
	#line 507 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 557 "compile.y"
{	{
PC.in_call_value=false;	PC.in_call_value=false;
}	}
	#line 2022 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 73:	case 73:
	#line 510 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 560 "compile.y"
{ /* ^field.$method{vasya} */	{ /* ^field.$method{vasya} */
#ifdef OPTIMIZE_BYTECODE_CUT_REM_OPERATOR	#ifdef OPTIMIZE_BYTECODE_CUT_REM_OPERATOR
#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT	#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT
const String* operator_name=LA2S(*(yyvsp[(3) - (6)]), 0, OP::OP_VALUE__GET_ELEMENT_OR_OPERATOR);	const String* operator_name=LA2S(*(yyvsp[-3]), 0, OP::OP_VALUE__GET_ELEMENT_OR_OPERATOR);
#else	#else
const String* operator_name=LA2S(*(yyvsp[(3) - (6)]), 1);	const String* operator_name=LA2S(*(yyvsp[-3]), 1);
#endif	#endif
if(operator_name && *operator_name==REM_OPERATOR_NAME){	if(operator_name && SYMBOLS_EQ(*operator_name,REM_SYMBOL)){
(yyval)=N();	(yyval)=N();
} else	} else
#endif	#endif
{	{
YYSTYPE params_code=(yyvsp[(5) - (6)]);	YYSTYPE params_code=(yyvsp[-1]);
if(params_code->count()==3) { // probably [] case. [OP::OP_VALUE+origin+Void]	if(params_code->count()==3) { // probably [] case. [OP::OP_VALUE+origin+Void]
if(Value* value=LA2V(*params_code)) // it is OP_VALUE+origin+value?	if(Value* value=LA2V(*params_code)) // it is OP_VALUE+origin+value?
if(const String * string=value->get_string())	if(const String * string=value->get_string())
Line 2328 yyreduce:	Line 2044 yyreduce:
}	}
/* stack: context, method_junction */	/* stack: context, method_junction */

YYSTYPE var_code=(yyvsp[(3) - (6)]);	YYSTYPE var_code=(yyvsp[-3]);
if(	if(
var_code->count()==8	var_code->count()==8
&& (*var_code)[0].code==OP::OP_VALUE__GET_CLASS	&& ( (var_code)[0].code==OP::OP_VALUE__GET_CLASS \|\| (var_code)[0].code==OP::OP_VALUE__GET_BASE_CLASS )
&& (*var_code)[3].code==OP::OP_PREPARE_TO_CONSTRUCT_OBJECT	&& (*var_code)[3].code==OP::OP_PREPARE_TO_CONSTRUCT_OBJECT
&& (*var_code)[4].code==OP::OP_VALUE	&& (*var_code)[4].code==OP::OP_VALUE
	#ifdef FEATURE_GET_ELEMENT4CALL
	&& (*var_code)[7].code==OP::OP_GET_ELEMENT4CALL
	#else
&& (*var_code)[7].code==OP::OP_GET_ELEMENT	&& (*var_code)[7].code==OP::OP_GET_ELEMENT
	#endif
){	){
(yyval)=N();	(yyval)=N();
O(*(yyval), OP::OP_CONSTRUCT_OBJECT);	O(*(yyval), OP::OP_CONSTRUCT_OBJECT);
Line 2348 yyreduce:	Line 2068 yyreduce:
}	}
}	}
}	}
	#line 2072 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 76:	case 74:
	#line 556 "compile.y" /* yacc.c:1646 */
	{
	#ifdef FEATURE_GET_ELEMENT4CALL
	size_t count=(yyvsp[0])->count();
	if(count){
	(yyval)=(yyvsp[0]);
	#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_ELEMENT
	!(count==5 && change_first(*(yyval), OP::OP_GET_OBJECT_ELEMENT, OP::OP_GET_OBJECT_ELEMENT4CALL)) &&
	#endif
	#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_VAR_ELEMENT
	!(count==5 && change_first(*(yyval), OP::OP_GET_OBJECT_VAR_ELEMENT, OP::OP_GET_OBJECT_VAR_ELEMENT4CALL)) &&
	#endif
	!change(*(yyval), count-1, OP::OP_GET_ELEMENT, OP::OP_GET_ELEMENT4CALL);
	}
	#endif
	}
	#line 2092 "compile.tab.C" /* yacc.c:1646 */
	break;

/* Line 1806 of yacc.c */	case 76:
#line 604 "compile.y"	#line 572 "compile.y" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (2)]); P((yyval), (yyvsp[(2) - (2)])); }	{ (yyval)=(yyvsp[-1]); P((yyval), (yyvsp[0])); }
	#line 2098 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 80:	case 80:
	#line 578 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 610 "compile.y"
{	{
// allow ^call[ letters here any time ]	// allow ^call[ letters here any time ]
reinterpret_cast<bool>(&(yyval))=PC.explicit_result; PC.explicit_result=false;	reinterpret_cast<bool>(&(yyval))=PC.explicit_result; PC.explicit_result=false;
}	}
	#line 2107 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 81:	case 81:
	#line 581 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 613 "compile.y"
{	{
PC.explicit_result=reinterpret_cast<bool>(&(yyvsp[(2) - (3)]));	PC.explicit_result=reinterpret_cast<bool>(&(yyvsp[-1]));
}	}
	#line 2115 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 82:	case 82:
	#line 583 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{(yyval)=(yyvsp[-2]);}
#line 615 "compile.y"	#line 2121 "compile.tab.C" /* yacc.c:1646 */
{(yyval)=(yyvsp[(3) - (5)]);}
break;	break;

case 83:	case 83:
	#line 584 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{(yyval)=(yyvsp[-1]);}
#line 616 "compile.y"	#line 2127 "compile.tab.C" /* yacc.c:1646 */
{(yyval)=(yyvsp[(2) - (3)]);}
break;	break;

case 84:	case 84:
	#line 585 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{(yyval)=(yyvsp[-1]);}
#line 617 "compile.y"	#line 2133 "compile.tab.C" /* yacc.c:1646 */
{(yyval)=(yyvsp[(2) - (3)]);}
break;	break;

case 86:	case 86:
	#line 588 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-2]); P((yyval), (yyvsp[0])); }
#line 620 "compile.y"	#line 2139 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (3)]); P((yyval), (yyvsp[(3) - (3)])); }
break;	break;

case 88:	case 88:
	#line 592 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-2]); P((yyval), (yyvsp[0])); }
#line 624 "compile.y"	#line 2145 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (3)]); P((yyval), (yyvsp[(3) - (3)])); }
break;	break;

case 90:	case 90:
	#line 596 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-2]); P((yyval), (yyvsp[0])); }
#line 628 "compile.y"	#line 2151 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (3)]); P((yyval), (yyvsp[(3) - (3)])); }
break;	break;

case 91:	case 91:
	#line 598 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 630 "compile.y"
{	{
(yyval)=(yyvsp[(1) - (1)]);	(yyval)=(yyvsp[0]);
}	}
	#line 2159 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 92:	case 92:
	#line 601 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 633 "compile.y"
{	{
YYSTYPE expr_code=(yyvsp[(1) - (1)]);	YYSTYPE expr_code=(yyvsp[0]);
if(expr_code->count()==3	if(expr_code->count()==3
&& (*expr_code)[0].code==OP::OP_VALUE) { // optimizing (double/bool/incidently 'string' too) case. [OP::OP_VALUE+origin+Double]. no evaluating	&& (*expr_code)[0].code==OP::OP_VALUE) { // optimizing (double/bool/incidently 'string' too) case. [OP::OP_VALUE+origin+Double]. no evaluating
(yyval)=expr_code;	(yyval)=expr_code;
} else {	} else {
YYSTYPE code=N();	YYSTYPE code=N();
O(*code, OP::OP_PREPARE_TO_EXPRESSION);
P(code, expr_code);	P(code, expr_code);
O(*code, OP::OP_WRITE_EXPR_RESULT);	O(*code, OP::OP_WRITE_EXPR_RESULT);
(yyval)=N();	(yyval)=N();
OA(*(yyval), OP::OP_EXPR_CODE__STORE_PARAM, code);	OA(*(yyval), OP::OP_EXPR_CODE__STORE_PARAM, code);
}	}
}	}
	#line 2177 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 93:	case 93:
	#line 614 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 647 "compile.y"
{	{
(yyval)=N();	(yyval)=N();
OA(*(yyval), OP::OP_CURLY_CODE__STORE_PARAM, (yyvsp[(1) - (1)]));	OA(*(yyval), OP::OP_CURLY_CODE__STORE_PARAM, (yyvsp[0]));
}	}
	#line 2186 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 98:	case 98:
	#line 626 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-1]); P((yyval), (yyvsp[0])); }
#line 659 "compile.y"	#line 2192 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (2)]); P((yyval), (yyvsp[(2) - (2)])); }
break;	break;

case 100:	case 100:
	#line 628 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-1]); P((yyval), (yyvsp[0])); }
#line 661 "compile.y"	#line 2198 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (2)]); P((yyval), (yyvsp[(2) - (2)])); }
break;	break;

case 102:	case 102:
	#line 630 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 663 "compile.y"
{	{
// we know that name_advance1 not called from ^xxx context	// we know that name_advance1 not called from ^xxx context
// so we'll not check for operator call possibility as we do in name_advance2	// so we'll not check for operator call possibility as we do in name_advance2

/* stack: context */	/* stack: context */
(yyval)=(yyvsp[(1) - (1)]); /* stack: context,name */	(yyval)=(yyvsp[0]); /* stack: context,name */
#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT__SPECIAL	#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT__SPECIAL
O((yyval), is_special_element((yyval)) ? OP::OP_GET_ELEMENT__SPECIAL : OP::OP_GET_ELEMENT);	O((yyval), is_special_element((yyval)) ? OP::OP_GET_ELEMENT__SPECIAL : OP::OP_GET_ELEMENT);
#else	#else
O((yyval), OP::OP_GET_ELEMENT); / name=pop; context=pop; stack: context.get_element(name) */	O((yyval), OP::OP_GET_ELEMENT); / name=pop; context=pop; stack: context.get_element(name) */
#endif	#endif
}	}
	#line 2215 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 103:	case 103:
	#line 642 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 675 "compile.y"
{	{
/* stack: context */	/* stack: context */
(yyval)=(yyvsp[(1) - (1)]); /* stack: context,name */	(yyval)=(yyvsp[0]); /* stack: context,name */
#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT__SPECIAL	#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT__SPECIAL
O((yyval), is_special_element((yyval)) ? OP::OP_GET_ELEMENT__SPECIAL : OP::OP_GET_ELEMENT);	O((yyval), is_special_element((yyval)) ? OP::OP_GET_ELEMENT__SPECIAL : OP::OP_GET_ELEMENT);
#else	#else
O((yyval), OP::OP_GET_ELEMENT); / name=pop; context=pop; stack: context.get_element(name) */	O((yyval), OP::OP_GET_ELEMENT); / name=pop; context=pop; stack: context.get_element(name) */
#endif	#endif
}	}
	#line 2229 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 109:	case 109:
	#line 659 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 692 "compile.y"
{	{
(yyval)=(yyvsp[(2) - (2)]);	(yyval)=(yyvsp[0]);
O(*(yyval), OP::OP_GET_ELEMENT);	O(*(yyval), OP::OP_GET_ELEMENT);
}	}
	#line 2238 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 110:	case 110:
	#line 663 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 696 "compile.y"
{	{
YYSTYPE code;	YYSTYPE code;
{	{
change_string_literal_to_write_string_literal(*(code=(yyvsp[(1) - (2)])));	change_string_literal_to_write_string_literal(*(code=(yyvsp[-1])));
P(code, (yyvsp[(2) - (2)]));	P(code, (yyvsp[0]));
}	}
(yyval)=N();	(yyval)=N();
OA(*(yyval), OP::OP_STRING_POOL, code);	OA(*(yyval), OP::OP_STRING_POOL, code);
}	}
	#line 2252 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 111:	case 111:
	#line 672 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 705 "compile.y"
{	{
// allow $result_or_other_variable[ letters here any time ]	// allow $result_or_other_variable[ letters here any time ]
reinterpret_cast<bool>(&(yyval))=PC.explicit_result; PC.explicit_result=false;	reinterpret_cast<bool>(&(yyval))=PC.explicit_result; PC.explicit_result=false;
}	}
	#line 2261 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 112:	case 112:
	#line 675 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 708 "compile.y"
{	{
PC.explicit_result=reinterpret_cast<bool>(&(yyvsp[(2) - (3)]));	PC.explicit_result=reinterpret_cast<bool>(&(yyvsp[-1]));
}	}
	#line 2269 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 113:	case 113:
	#line 677 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 710 "compile.y"
{	{
(yyval)=N();	(yyval)=N();
#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT__SPECIAL	#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT__SPECIAL
if(!maybe_append_simple_diving_code((yyval), (yyvsp[(3) - (5)])))	if(!maybe_append_simple_diving_code((yyval), (yyvsp[-2])))
#endif	#endif
{	{
OA((yyval), OP::OP_OBJECT_POOL, (yyvsp[(3) - (5)])); / stack: empty write context */	OA((yyval), OP::OP_OBJECT_POOL, (yyvsp[-2])); / stack: empty write context */
/* some code that writes to that context */	/* some code that writes to that context */
/* context=pop; stack: context.value() */	/* context=pop; stack: context.value() */
}	}
}	}
	#line 2285 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 114:	case 114:
	#line 688 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 721 "compile.y"
{	{
(yyval)=N();	(yyval)=N();
O(*(yyval), OP::OP_WITH_READ);	O(*(yyval), OP::OP_WITH_READ);
P((yyval), (yyvsp[(1) - (1)]));	P((yyval), (yyvsp[0]));
}	}
	#line 2295 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 116:	case 116:
	#line 693 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-1]); P((yyval), (yyvsp[0])); }
#line 726 "compile.y"	#line 2301 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (2)]); P((yyval), (yyvsp[(2) - (2)])); }
break;	break;

case 117:	case 117:
	#line 694 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 727 "compile.y"
{	{
(yyval)=(yyvsp[(2) - (2)]);	(yyval)=(yyvsp[0]);
O(*(yyval), OP::OP_GET_ELEMENT__WRITE);	O(*(yyval), OP::OP_GET_ELEMENT__WRITE);
}	}
	#line 2310 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 120:	case 120:
	#line 703 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 736 "compile.y"
{	{
(yyval)=(yyvsp[(1) - (2)]); // stack: class name string	(yyval)=(yyvsp[-1]); // stack: class name string
	OP::OPCODE code = OP::OP_VALUE__GET_CLASS;
if(LA2S((yyval)) == BASE_NAME) { // pseudo BASE class	if(LA2S((yyval)) == BASE_NAME) { // pseudo BASE class
if(VStateless_class* base=PC.cclass->base_class()) {	if(VStateless_class* base=PC.cclass->base_class()) {
change_string_literal_value(*(yyval), base->name());	change_string_literal_value((yyval), new String(base->type()));
} else {	} else {
strcpy(PC.error, "no base class declared");	strcpy(PC.error, "no base class declared");
YYERROR;	YYERROR;
}	}
	code = OP::OP_VALUE__GET_BASE_CLASS;
	} else {
	// can't use get_class because it will call @autouse[] if the class wasn't loaded
	VStateless_class* base=PC.request.classes().get(LA2S((yyval)));
	if(base && PC.cclass->derived_from(*base))
	code = OP::OP_VALUE__GET_BASE_CLASS;
}	}
// optimized OP_VALUE+origin+string+OP_GET_CLASS => OP_VALUE__GET_CLASS+origin+string	// optimized OP_VALUE+origin+string+OP_GET_CLASS => OP_VALUE__GET_CLASS+origin+string
change_first(*(yyval), OP::OP_VALUE, OP::OP_VALUE__GET_CLASS);	change_first(*(yyval), OP::OP_VALUE, code);
}	}
	#line 2335 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 121:	case 121:
	#line 723 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 749 "compile.y"
{	{
(yyval)=(yyvsp[(1) - (2)]);	(yyval)=(yyvsp[-1]);
if(!PC.in_call_value) {	if(!PC.in_call_value) {
strcpy(PC.error, ":: not allowed here");	strcpy(PC.error, ":: not allowed here");
YYERROR;	YYERROR;
}	}
O(*(yyval), OP::OP_PREPARE_TO_CONSTRUCT_OBJECT);	O(*(yyval), OP::OP_PREPARE_TO_CONSTRUCT_OBJECT);
}	}
	#line 2348 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 128:	case 128:
	#line 742 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval) = (yyvsp[-1]); }
#line 768 "compile.y"	#line 2354 "compile.tab.C" /* yacc.c:1646 */
{ (yyval) = (yyvsp[(2) - (3)]); }
break;	break;

case 129:	case 129:
	#line 743 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval) = (yyvsp[-1]); }
#line 769 "compile.y"	#line 2360 "compile.tab.C" /* yacc.c:1646 */
{ (yyval) = (yyvsp[(2) - (3)]); }
break;	break;

case 130:	case 130:
	#line 744 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval) = (yyvsp[-1]); }
#line 770 "compile.y"	#line 2366 "compile.tab.C" /* yacc.c:1646 */
{ (yyval) = (yyvsp[(2) - (3)]); }
break;	break;

case 131:	case 131:
	#line 746 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[0]); O(*(yyval), OP::OP_NEG); }
#line 772 "compile.y"	#line 2372 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(2) - (2)]); O(*(yyval), OP::OP_NEG); }
break;	break;

case 132:	case 132:
	#line 747 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[0]); }
#line 773 "compile.y"	#line 2378 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(2) - (2)]); }
break;	break;

case 133:	case 133:
	#line 748 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[0]); O(*(yyval), OP::OP_INV); }
#line 774 "compile.y"	#line 2384 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(2) - (2)]); O(*(yyval), OP::OP_INV); }
break;	break;

case 134:	case 134:
	#line 749 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[0]); O(*(yyval), OP::OP_NOT); }
#line 775 "compile.y"	#line 2390 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(2) - (2)]); O(*(yyval), OP::OP_NOT); }
break;	break;

case 135:	case 135:
	#line 750 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[0]); O(*(yyval), OP::OP_DEF); }
#line 776 "compile.y"	#line 2396 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(2) - (2)]); O(*(yyval), OP::OP_DEF); }
break;	break;

case 136:	case 136:
	#line 751 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[0]); O(*(yyval), OP::OP_IN); }
#line 777 "compile.y"	#line 2402 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(2) - (2)]); O(*(yyval), OP::OP_IN); }
break;	break;

case 137:	case 137:
	#line 752 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[0]); O(*(yyval), OP::OP_FEXISTS); }
#line 778 "compile.y"	#line 2408 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(2) - (2)]); O(*(yyval), OP::OP_FEXISTS); }
break;	break;

case 138:	case 138:
	#line 753 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[0]); O(*(yyval), OP::OP_DEXISTS); }
#line 779 "compile.y"	#line 2414 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(2) - (2)]); O(*(yyval), OP::OP_DEXISTS); }
break;	break;

case 139:	case 139:
	#line 755 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-2]); P((yyval), (yyvsp[0])); O(*(yyval), OP::OP_SUB); }
#line 781 "compile.y"	#line 2420 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (3)]); P((yyval), (yyvsp[(3) - (3)])); O(*(yyval), OP::OP_SUB); }
break;	break;

case 140:	case 140:
	#line 756 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-2]); P((yyval), (yyvsp[0])); O(*(yyval), OP::OP_ADD); }
#line 782 "compile.y"	#line 2426 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (3)]); P((yyval), (yyvsp[(3) - (3)])); O(*(yyval), OP::OP_ADD); }
break;	break;

case 141:	case 141:
	#line 757 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-2]); P((yyval), (yyvsp[0])); O(*(yyval), OP::OP_MUL); }
#line 783 "compile.y"	#line 2432 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (3)]); P((yyval), (yyvsp[(3) - (3)])); O(*(yyval), OP::OP_MUL); }
break;	break;

case 142:	case 142:
	#line 758 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-2]); P((yyval), (yyvsp[0])); O(*(yyval), OP::OP_DIV); }
#line 784 "compile.y"	#line 2438 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (3)]); P((yyval), (yyvsp[(3) - (3)])); O(*(yyval), OP::OP_DIV); }
break;	break;

case 143:	case 143:
	#line 759 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-2]); P((yyval), (yyvsp[0])); O(*(yyval), OP::OP_MOD); }
#line 785 "compile.y"	#line 2444 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (3)]); P((yyval), (yyvsp[(3) - (3)])); O(*(yyval), OP::OP_MOD); }
break;	break;

case 144:	case 144:
	#line 760 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-2]); P((yyval), (yyvsp[0])); O(*(yyval), OP::OP_INTDIV); }
#line 786 "compile.y"	#line 2450 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (3)]); P((yyval), (yyvsp[(3) - (3)])); O(*(yyval), OP::OP_INTDIV); }
break;	break;

case 145:	case 145:
	#line 761 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-2]); P((yyval), (yyvsp[0])); O(*(yyval), OP::OP_BIN_SL); }
#line 787 "compile.y"	#line 2456 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (3)]); P((yyval), (yyvsp[(3) - (3)])); O(*(yyval), OP::OP_BIN_SL); }
break;	break;

case 146:	case 146:
	#line 762 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-2]); P((yyval), (yyvsp[0])); O(*(yyval), OP::OP_BIN_SR); }
#line 788 "compile.y"	#line 2462 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (3)]); P((yyval), (yyvsp[(3) - (3)])); O(*(yyval), OP::OP_BIN_SR); }
break;	break;

case 147:	case 147:
	#line 763 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-2]); P((yyval), (yyvsp[0])); O(*(yyval), OP::OP_BIN_AND); }
#line 789 "compile.y"	#line 2468 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (3)]); P((yyval), (yyvsp[(3) - (3)])); O(*(yyval), OP::OP_BIN_AND); }
break;	break;

case 148:	case 148:
	#line 764 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-2]); P((yyval), (yyvsp[0])); O(*(yyval), OP::OP_BIN_OR); }
#line 790 "compile.y"	#line 2474 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (3)]); P((yyval), (yyvsp[(3) - (3)])); O(*(yyval), OP::OP_BIN_OR); }
break;	break;

case 149:	case 149:
	#line 765 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-2]); P((yyval), (yyvsp[0])); O(*(yyval), OP::OP_BIN_XOR); }
#line 791 "compile.y"	#line 2480 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (3)]); P((yyval), (yyvsp[(3) - (3)])); O(*(yyval), OP::OP_BIN_XOR); }
break;	break;

case 150:	case 150:
	#line 766 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-2]); OA((yyval), OP::OP_NESTED_CODE, (yyvsp[0])); O((yyval), OP::OP_LOG_AND); }
#line 792 "compile.y"	#line 2486 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (3)]); OA((yyval), OP::OP_NESTED_CODE, (yyvsp[(3) - (3)])); O((yyval), OP::OP_LOG_AND); }
break;	break;

case 151:	case 151:
	#line 767 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-2]); OA((yyval), OP::OP_NESTED_CODE, (yyvsp[0])); O((yyval), OP::OP_LOG_OR); }
#line 793 "compile.y"	#line 2492 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (3)]); OA((yyval), OP::OP_NESTED_CODE, (yyvsp[(3) - (3)])); O((yyval), OP::OP_LOG_OR); }
break;	break;

case 152:	case 152:
	#line 768 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-2]); P((yyval), (yyvsp[0])); O(*(yyval), OP::OP_LOG_XOR); }
#line 794 "compile.y"	#line 2498 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (3)]); P((yyval), (yyvsp[(3) - (3)])); O(*(yyval), OP::OP_LOG_XOR); }
break;	break;

case 153:	case 153:
	#line 769 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-2]); P((yyval), (yyvsp[0])); O(*(yyval), OP::OP_NUM_LT); }
#line 795 "compile.y"	#line 2504 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (3)]); P((yyval), (yyvsp[(3) - (3)])); O(*(yyval), OP::OP_NUM_LT); }
break;	break;

case 154:	case 154:
	#line 770 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-2]); P((yyval), (yyvsp[0])); O(*(yyval), OP::OP_NUM_GT); }
#line 796 "compile.y"	#line 2510 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (3)]); P((yyval), (yyvsp[(3) - (3)])); O(*(yyval), OP::OP_NUM_GT); }
break;	break;

case 155:	case 155:
	#line 771 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-2]); P((yyval), (yyvsp[0])); O(*(yyval), OP::OP_NUM_LE); }
#line 797 "compile.y"	#line 2516 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (3)]); P((yyval), (yyvsp[(3) - (3)])); O(*(yyval), OP::OP_NUM_LE); }
break;	break;

case 156:	case 156:
	#line 772 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-2]); P((yyval), (yyvsp[0])); O(*(yyval), OP::OP_NUM_GE); }
#line 798 "compile.y"	#line 2522 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (3)]); P((yyval), (yyvsp[(3) - (3)])); O(*(yyval), OP::OP_NUM_GE); }
break;	break;

case 157:	case 157:
	#line 773 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-2]); P((yyval), (yyvsp[0])); O(*(yyval), OP::OP_NUM_EQ); }
#line 799 "compile.y"	#line 2528 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (3)]); P((yyval), (yyvsp[(3) - (3)])); O(*(yyval), OP::OP_NUM_EQ); }
break;	break;

case 158:	case 158:
	#line 774 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-2]); P((yyval), (yyvsp[0])); O(*(yyval), OP::OP_NUM_NE); }
#line 800 "compile.y"	#line 2534 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (3)]); P((yyval), (yyvsp[(3) - (3)])); O(*(yyval), OP::OP_NUM_NE); }
break;	break;

case 159:	case 159:
	#line 775 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-2]); P((yyval), (yyvsp[0])); O(*(yyval), OP::OP_STR_LT); }
#line 801 "compile.y"	#line 2540 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (3)]); P((yyval), (yyvsp[(3) - (3)])); O(*(yyval), OP::OP_STR_LT); }
break;	break;

case 160:	case 160:
	#line 776 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-2]); P((yyval), (yyvsp[0])); O(*(yyval), OP::OP_STR_GT); }
#line 802 "compile.y"	#line 2546 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (3)]); P((yyval), (yyvsp[(3) - (3)])); O(*(yyval), OP::OP_STR_GT); }
break;	break;

case 161:	case 161:
	#line 777 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-2]); P((yyval), (yyvsp[0])); O(*(yyval), OP::OP_STR_LE); }
#line 803 "compile.y"	#line 2552 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (3)]); P((yyval), (yyvsp[(3) - (3)])); O(*(yyval), OP::OP_STR_LE); }
break;	break;

case 162:	case 162:
	#line 778 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-2]); P((yyval), (yyvsp[0])); O(*(yyval), OP::OP_STR_GE); }
#line 804 "compile.y"	#line 2558 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (3)]); P((yyval), (yyvsp[(3) - (3)])); O(*(yyval), OP::OP_STR_GE); }
break;	break;

case 163:	case 163:
	#line 779 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-2]); P((yyval), (yyvsp[0])); O(*(yyval), OP::OP_STR_EQ); }
#line 805 "compile.y"	#line 2564 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (3)]); P((yyval), (yyvsp[(3) - (3)])); O(*(yyval), OP::OP_STR_EQ); }
break;	break;

case 164:	case 164:
	#line 780 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-2]); P((yyval), (yyvsp[0])); O(*(yyval), OP::OP_STR_NE); }
#line 806 "compile.y"	#line 2570 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (3)]); P((yyval), (yyvsp[(3) - (3)])); O(*(yyval), OP::OP_STR_NE); }
break;	break;

case 165:	case 165:
	#line 781 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */	{ (yyval)=(yyvsp[-2]); P((yyval), (yyvsp[0])); O(*(yyval), OP::OP_IS); }
#line 807 "compile.y"	#line 2576 "compile.tab.C" /* yacc.c:1646 */
{ (yyval)=(yyvsp[(1) - (3)]); P((yyval), (yyvsp[(3) - (3)])); O(*(yyval), OP::OP_IS); }
break;	break;

case 166:	case 166:
	#line 784 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 810 "compile.y"
{	{
// optimized OP_STRING => OP_VALUE for doubles	// optimized OP_STRING => OP_VALUE for doubles
maybe_change_string_literal_to_double_literal(*((yyval)=(yyvsp[(1) - (1)])));	maybe_change_string_literal_to_double_literal(*((yyval)=(yyvsp[0])));
}	}
	#line 2585 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 167:	case 167:
	#line 789 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 815 "compile.y"
{	{
#ifdef OPTIMIZE_BYTECODE_STRING_POOL	#ifdef OPTIMIZE_BYTECODE_STRING_POOL
// it brakes ^if(" 09 "){...}	// it brakes ^if(" 09 "){...}
YYSTYPE code=(yyvsp[(1) - (1)]);	YYSTYPE code=(yyvsp[0]);
(yyval)=N();	(yyval)=N();
if(code->count()==3 && change_first(*code, OP::OP_STRING__WRITE, OP::OP_VALUE)){	if(code->count()==3 && change_first(*code, OP::OP_STRING__WRITE, OP::OP_VALUE)){
// optimized OP_STRING__WRITE+origin+value => OP_VALUE+origin+value without starting OP_STRING_POOL	// optimized OP_STRING__WRITE+origin+value => OP_VALUE+origin+value without starting OP_STRING_POOL
Line 2919 yyreduce:	Line 2599 yyreduce:
}	}
#else	#else
(yyval)=N();	(yyval)=N();
OA((yyval), OP::OP_STRING_POOL, (yyvsp[(1) - (1)])); / stack: empty write context */	OA((yyval), OP::OP_STRING_POOL, (yyvsp[0])); / stack: empty write context */
#endif	#endif
/* some code that writes to that context */	/* some code that writes to that context */
/* context=pop; stack: context.get_string() */	/* context=pop; stack: context.get_string() */
}	}
	#line 2608 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 168:	case 168:
	#line 810 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 836 "compile.y"
{	{
// optimized OP_STRING+OP_WRITE_VALUE => OP_STRING__WRITE	// optimized OP_STRING+OP_WRITE_VALUE => OP_STRING__WRITE
change_string_literal_to_write_string_literal(*((yyval)=(yyvsp[(1) - (1)])));	change_string_literal_to_write_string_literal(*((yyval)=(yyvsp[0])));
}	}
	#line 2617 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 169:	case 169:
	#line 815 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 841 "compile.y"
{ (yyval)=VL(/we know that we will not change it/const_cast<VString*>(&vempty), 0, 0, 0); }	{ (yyval)=VL(/we know that we will not change it/const_cast<VString*>(&vempty), 0, 0, 0); }
	#line 2623 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 170:	case 170:
	#line 816 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 842 "compile.y"
{ (yyval) = VL(/we know that we will not change it/const_cast<VBool*>(&vtrue), 0, 0, 0); }	{ (yyval) = VL(/we know that we will not change it/const_cast<VBool*>(&vtrue), 0, 0, 0); }
	#line 2629 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 171:	case 171:
	#line 817 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 843 "compile.y"
{ (yyval) = VL(/we know that we will not change it/const_cast<VBool*>(&vfalse), 0, 0, 0); }	{ (yyval) = VL(/we know that we will not change it/const_cast<VBool*>(&vfalse), 0, 0, 0); }
	#line 2635 "compile.tab.C" /* yacc.c:1646 */
break;	break;

case 172:	case 172:
	#line 819 "compile.y" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 845 "compile.y"
{ (yyval)=N(); }	{ (yyval)=N(); }
	#line 2641 "compile.tab.C" /* yacc.c:1646 */
break;	break;


	#line 2645 "compile.tab.C" /* yacc.c:1646 */
/* Line 1806 of yacc.c */
#line 2971 "compile.tab.C"
default: break;	default: break;
}	}
/* User semantic actions sometimes alter yychar, and that requires	/* User semantic actions sometimes alter yychar, and that requires
Line 2989 yyreduce:	Line 2663 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 3004 yyreduce:	Line 2678 yyreduce:
goto yynewstate;	goto yynewstate;


/*------------------------------------.	/*--------------------------------------.
\| yyerrlab -- here on detecting error \|	\| yyerrlab -- here on detecting error. \|
`------------------------------------*/	`--------------------------------------*/
yyerrlab:	yyerrlab:
/* Make sure we have latest lookahead translation. See comments at	/* Make sure we have latest lookahead translation. See comments at
user semantic actions for why this is necessary. */	user semantic actions for why this is necessary. */
Line 3017 yyerrlab:	Line 2691 yyerrlab:
{	{
++yynerrs;	++yynerrs;
#if ! YYERROR_VERBOSE	#if ! YYERROR_VERBOSE
yyerror (YY_("syntax error"));	yyerror (pc, YY_("syntax error"));
#else	#else
# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \	# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
yyssp, yytoken)	yyssp, yytoken)
Line 3044 yyerrlab:	Line 2718 yyerrlab:
yymsgp = yymsg;	yymsgp = yymsg;
}	}
}	}
yyerror (yymsgp);	yyerror (pc, yymsgp);
if (yysyntax_error_status == 2)	if (yysyntax_error_status == 2)
goto yyexhaustedlab;	goto yyexhaustedlab;
}	}
Line 3057 yyerrlab:	Line 2731 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 lookahead token after an
error, discard it. */	error, discard it. */

if (yychar <= YYEOF)	if (yychar <= YYEOF)
{	{
/* Return failure if at end of input. */	/* Return failure if at end of input. */
if (yychar == YYEOF)	if (yychar == YYEOF)
YYABORT;	YYABORT;
}	}
else	else
{	{
yydestruct ("Error: discarding",	yydestruct ("Error: discarding",
yytoken, &yylval);	yytoken, &yylval, pc);
yychar = YYEMPTY;	yychar = YYEMPTY;
}	}
}	}

/* Else will try to reuse lookahead token after shifting the error	/* Else will try to reuse lookahead token after shifting the error
Line 3089 yyerrorlab:	Line 2763 yyerrorlab:
if (/CONSTCOND/ 0)	if (/CONSTCOND/ 0)
goto yyerrorlab;	goto yyerrorlab;

/* Do not reclaim the symbols of the rule which action triggered	/* Do not reclaim the symbols of the rule whose action triggered
this YYERROR. */	this YYERROR. */
YYPOPSTACK (yylen);	YYPOPSTACK (yylen);
yylen = 0;	yylen = 0;
Line 3102 yyerrorlab:	Line 2776 yyerrorlab:
\| yyerrlab1 -- common code for both syntax error and YYERROR. \|	\| yyerrlab1 -- common code for both syntax error and YYERROR. \|
`-------------------------------------------------------------*/	`-------------------------------------------------------------*/
yyerrlab1:	yyerrlab1:
yyerrstatus = 3; /* Each real token shifted decrements this. */	yyerrstatus = 3; /* Each real token shifted decrements this. */

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

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


yydestruct ("Error: popping",	yydestruct ("Error: popping",
yystos[yystate], yyvsp);	yystos[yystate], yyvsp, pc);
YYPOPSTACK (1);	YYPOPSTACK (1);
yystate = *yyssp;	yystate = *yyssp;
YY_STACK_PRINT (yyss, yyssp);	YY_STACK_PRINT (yyss, yyssp);
}	}

	YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
*++yyvsp = yylval;	*++yyvsp = yylval;
	YY_IGNORE_MAYBE_UNINITIALIZED_END


/* Shift the error token. */	/* Shift the error token. */
Line 3154 yyabortlab:	Line 2830 yyabortlab:
yyresult = 1;	yyresult = 1;
goto yyreturn;	goto yyreturn;

#if !defined(yyoverflow) \|\| YYERROR_VERBOSE	#if !defined yyoverflow \|\| YYERROR_VERBOSE
/*-------------------------------------------------.	/*-------------------------------------------------.
\| yyexhaustedlab -- memory exhaustion comes here. \|	\| yyexhaustedlab -- memory exhaustion comes here. \|
`-------------------------------------------------*/	`-------------------------------------------------*/
yyexhaustedlab:	yyexhaustedlab:
yyerror (YY_("memory exhausted"));	yyerror (pc, YY_("memory exhausted"));
yyresult = 2;	yyresult = 2;
/* Fall through. */	/* Fall through. */
#endif	#endif
Line 3171 yyreturn:	Line 2847 yyreturn:
user semantic actions for why this is necessary. */	user semantic actions for why this is necessary. */
yytoken = YYTRANSLATE (yychar);	yytoken = YYTRANSLATE (yychar);
yydestruct ("Cleanup: discarding lookahead",	yydestruct ("Cleanup: discarding lookahead",
yytoken, &yylval);	yytoken, &yylval, pc);
}	}
/* Do not reclaim the symbols of the rule which action triggered	/* Do not reclaim the symbols of the rule whose action triggered
this YYABORT or YYACCEPT. */	this YYABORT or YYACCEPT. */
YYPOPSTACK (yylen);	YYPOPSTACK (yylen);
YY_STACK_PRINT (yyss, yyssp);	YY_STACK_PRINT (yyss, yyssp);
while (yyssp != yyss)	while (yyssp != yyss)
{	{
yydestruct ("Cleanup: popping",	yydestruct ("Cleanup: popping",
yystos[*yyssp], yyvsp);	yystos[*yyssp], yyvsp, pc);
YYPOPSTACK (1);	YYPOPSTACK (1);
}	}
#ifndef yyoverflow	#ifndef yyoverflow
Line 3191 yyreturn:	Line 2867 yyreturn:
if (yymsg != yymsgbuf)	if (yymsg != yymsgbuf)
YYSTACK_FREE (yymsg);	YYSTACK_FREE (yymsg);
#endif	#endif
/* Make sure YYID is used. */	return yyresult;
return YYID (yyresult);
}	}
	#line 821 "compile.y" /* yacc.c:1906 */


/* Line 2067 of yacc.c */
#line 847 "compile.y"

#endif	#endif

Line 3397 default:	Line 3068 default:
}	}
if(pc.explicit_result && c)	if(pc.explicit_result && c)
switch(c) {	switch(c) {
	default:
	pc.string.append(c);
case '\n': case ' ': case '\t':	case '\n': case ' ': case '\t':
begin=pc.source;	begin=pc.source;
begin_pos=pc.pos;	begin_pos=pc.pos;
continue; // skip it	continue;
default:
result=BAD_NONWHITESPACE_CHARACTER_IN_EXPLICIT_RESULT_MODE;
goto break2;
}	}
break;	break;

Line 3426 default:	Line 3096 default:
case '"':	case '"':
case '\'':	case '\'':
if(	if(
pc.ls == LS_EXPRESSION_STRING_QUOTED && c=='"' \|\|	(pc.ls == LS_EXPRESSION_STRING_QUOTED && c=='"') \|\|
pc.ls == LS_EXPRESSION_STRING_APOSTROFED && c=='\'') {	(pc.ls == LS_EXPRESSION_STRING_APOSTROFED && c=='\'') ) {
pop_LS(pc); //"abc". \| 'abc'.	pop_LS(pc); //"abc". \| 'abc'.
RC;	RC;
}	}
Line 3500 default:	Line 3170 default:
case LS_METHOD_ROUND:	case LS_METHOD_ROUND:
switch(c) {	switch(c) {
case ')':	case ')':
if(--lexical_brackets_nestage==0)	if(--lexical_brackets_nestage==0) {
if(pc.ls==LS_METHOD_ROUND) // method round param ended	if(pc.ls==LS_METHOD_ROUND) // method round param ended
pc.ls=LS_METHOD_AFTER; // look for method end	pc.ls=LS_METHOD_AFTER; // look for method end
else // pc.ls==LS_VAR_ROUND // variable constructor ended	else // pc.ls==LS_VAR_ROUND // variable constructor ended
pop_LS(pc); // return to normal life	pop_LS(pc); // return to normal life
	}
RC;	RC;
case '#': // comment start skipping	case '#': // comment start skipping
if(end!=begin) {	if(end!=begin) {
Line 3929 default:	Line 3600 default:
}	}
if(pc.explicit_result && c)	if(pc.explicit_result && c)
switch(c) {	switch(c) {
	default:
	pc.string.append(c);
case '\n': case ' ': case '\t':	case '\n': case ' ': case '\t':
begin=pc.source;	begin=pc.source;
begin_pos=pc.pos;	begin_pos=pc.pos;
continue; // skip it	continue;
default:
result=BAD_NONWHITESPACE_CHARACTER_IN_EXPLICIT_RESULT_MODE;
goto break2;
}	}
break;	break;

Line 3944 default:	Line 3614 default:
pc.ls=LS_METHOD_SQUARE;	pc.ls=LS_METHOD_SQUARE;
lexical_brackets_nestage=1;	lexical_brackets_nestage=1;
RC;	RC;
}	}
if(c=='{') {/* ]{ }{ ){ */	if(c=='{') {/* ]{ }{ ){ */
pc.ls=LS_METHOD_CURLY;	pc.ls=LS_METHOD_CURLY;
lexical_brackets_nestage=1;	lexical_brackets_nestage=1;
RC;	RC;
}	}
if(c=='(') {/* ]( }( )( */	if(c=='(') {/* ]( }( )( */
pc.ls=LS_METHOD_ROUND;	pc.ls=LS_METHOD_ROUND;
lexical_brackets_nestage=1;	lexical_brackets_nestage=1;
RC;	RC;
}	}
pop_LS(pc);	pop_LS(pc);
pc.ungetc();	pc.ungetc();
result=EON;	result=EON;
Line 3980 break2:	Line 3650 break2:
}	}
if(!pc.string.is_empty()) { // something accumulated?	if(!pc.string.is_empty()) { // something accumulated?
// create STRING value: array of OP_VALUE+origin+vstring	// create STRING value: array of OP_VALUE+origin+vstring
*lvalp=VL(	#ifdef SYMBOLS_CACHING
new VString(*new String(pc.string, String::L_CLEAN)),	Value *lookup=symbols->get(pc.string);
pc.file_no, pc.string_start.line, pc.string_start.col);	#else
	Value *lookup=0;
	#endif
	lvalp=VL(lookup ? lookup : new VString(new String(pc.string, String::L_CLEAN)), pc.file_no, pc.string_start.line, pc.string_start.col);
// new pieces storage	// new pieces storage
pc.string.clear();	pc.string.clear();
pc.string_start.clear();	pc.string_start.clear();
Line 3996 break2:	Line 3669 break2:
}	}

static int real_yyerror(Parse_control pc, const char s) { // Called by yyparse on error	static int real_yyerror(Parse_control pc, const char s) { // Called by yyparse on error
strncpy(PC.error, s, MAX_STRING);	strncpy(PC.error, s, MAX_STRING);
return 1;	return 1;
}	}

static void yyprint(FILE *file, int type, YYSTYPE value) {	static void yyprint(FILE *file, int type, YYSTYPE value) {
if(type==STRING)	if(type==STRING)
fprintf(file, " \"%s\"", LA2S(*value)->cstr());	fprintf(file, " \"%s\"", LA2S(*value)->cstr());
}	}

E-mail:

Removed from v.1.160
changed lines
	Added in v.1.177