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.3 and 1.81.2.2

version 1.3, 2001/08/10 12:36:55	version 1.81.2.2, 2003/01/30 14:59:44
Line 9	Line 9
#define BOGUS 259	#define BOGUS 259
#define BAD_STRING_COMPARISON_OPERATOR 260	#define BAD_STRING_COMPARISON_OPERATOR 260
#define BAD_HEX_LITERAL 261	#define BAD_HEX_LITERAL 261
#define LAND 262	#define BAD_METHOD_DECL_START 262
#define LOR 263	#define BAD_METHOD_PARAMETER_NAME_CHARACTER 263
#define LXOR 264	#define BAD_MATH_OPERATOR_CHARACTER 264
#define NLE 265	#define LAND 265
#define NGE 266	#define LOR 266
#define NEQ 267	#define LXOR 267
#define NNE 268	#define NXOR 268
#define SLT 269	#define NLE 269
#define SGT 270	#define NGE 270
#define SLE 271	#define NEQ 271
#define SGE 272	#define NNE 272
#define SEQ 273	#define NSL 273
#define SNE 274	#define NSR 274
#define DEF 275	#define SLT 275
#define IN 276	#define SGT 276
#define FEXISTS 277	#define SLE 277
#define DEXISTS 278	#define SGE 278
#define IS 279	#define SEQ 279
#define NEG 280	#define SNE 280
	#define DEF 281
	#define IN 282
	#define FEXISTS 283
	#define DEXISTS 284
	#define IS 285
	#define NUNARY 286

	#line 1 "compile.y"

#line 8 "compile.y"	/** @file
	Parser: compiler(lexical parser and grammar).

static char *RCSId="$Id$";	Copyright (c) 2001, 2003 ArtLebedev Group (http://www.artlebedev.com)
	Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)

	$Id$
	*/

/**	/**
@todo parser4:	@todo parser4:
Line 44 static char *RCSId="$Id$";	Line 57 static char *RCSId="$Id$";
-#: in iis make up specialized Pool object for that	-#: in iis make up specialized Pool object for that
*/	*/

#define YYSTYPE Array/<Operation>/ *	#define YYSTYPE ArrayOperationPtr
#define YYPARSE_PARAM pc	#define YYPARSE_PARAM pc
#define YYLEX_PARAM pc	#define YYLEX_PARAM pc
#define YYDEBUG 1	#define YYDEBUG 1
Line 59 static char *RCSId="$Id$";	Line 72 static char *RCSId="$Id$";
#include "pa_vdouble.h"	#include "pa_vdouble.h"
#include "pa_globals.h"	#include "pa_globals.h"
#include "pa_vvoid.h"	#include "pa_vvoid.h"
	#include "pa_vmethod_frame.h"

#define SELF_ELEMENT_NAME "self"
#define USE_CONTROL_METHOD_NAME "USE"	#define USE_CONTROL_METHOD_NAME "USE"

static int real_yyerror(parse_control pc, char s);	static int real_yyerror(parse_control pc, char s);
Line 87 static int yylex(YYSTYPE lvalp, void p	Line 100 static int yylex(YYSTYPE lvalp, void p



#define YYFINAL 244	#define YYFINAL 252
#define YYFLAG -32768	#define YYFLAG -32768
#define YYNTBASE 54	#define YYNTBASE 60

#define YYTRANSLATE(x) ((unsigned)(x) <= 280 ? yytranslate[x] : 133)	#define YYTRANSLATE(x) ((unsigned)(x) <= 286 ? yytranslate[x] : 139)

static const char yytranslate[] = { 0,	static const char yytranslate[] = { 0,
2, 2, 2, 2, 2, 2, 2, 2, 2, 40,	2, 2, 2, 2, 2, 2, 2, 2, 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, 28, 52, 29, 44, 37, 31, 53, 48,	2, 2, 44, 58, 2, 50, 41, 35, 59, 54,
49, 35, 34, 2, 33, 47, 36, 2, 2, 2,	55, 38, 36, 2, 37, 53, 39, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 51, 43, 26,	2, 2, 2, 2, 2, 2, 2, 57, 49, 32,
2, 27, 2, 39, 2, 2, 2, 2, 2, 2,	2, 33, 2, 45, 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,
41, 2, 42, 50, 2, 2, 2, 2, 2, 2,	47, 40, 48, 56, 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, 45, 30, 46, 32, 2, 2, 2, 2,	2, 2, 51, 34, 52, 43, 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, 2,
Line 121 static const char yytranslate[] = {	Line 134 static const char yytranslate[] = {
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, 1, 3, 4, 5, 6,	2, 2, 2, 2, 2, 1, 3, 4, 5, 6,
7, 8, 9, 10, 11, 12, 13, 14, 15, 16,	7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23, 24, 25, 38	17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
	27, 28, 29, 30, 31, 42
};	};

#if YYDEBUG != 0	#if YYDEBUG != 0
Line 138 static const short yyprhs[] = { 0,	Line 152 static const short yyprhs[] = { 0,
230, 232, 234, 237, 239, 242, 245, 247, 249, 252,	230, 232, 234, 237, 239, 242, 245, 247, 249, 252,
254, 256, 258, 260, 263, 266, 270, 272, 274, 277,	254, 256, 258, 260, 263, 266, 270, 272, 274, 277,
280, 282, 284, 287, 290, 292, 294, 296, 298, 302,	280, 282, 284, 287, 290, 292, 294, 296, 298, 302,
306, 310, 313, 316, 319, 322, 325, 328, 331, 335,	306, 310, 313, 316, 319, 322, 325, 328, 331, 334,
339, 343, 347, 351, 355, 359, 363, 367, 371, 375,	338, 342, 346, 350, 354, 358, 362, 366, 370, 374,
379, 383, 387, 391, 395, 399, 403, 407, 411, 415,	378, 382, 386, 390, 394, 398, 402, 406, 410, 414,
419, 423, 427, 429, 431, 432	418, 422, 426, 430, 434, 438, 442, 444, 446, 447
};	};

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

#endif	#endif

#if YYDEBUG != 0	#if YYDEBUG != 0
static const short yyrline[] = { 0,	static const short yyrline[] = { 0,
106, 116, 118, 118, 119, 121, 121, 123, 189, 189,	115, 123, 125, 125, 126, 128, 128, 130, 195, 195,
190, 190, 191, 192, 192, 194, 223, 223, 224, 225,	196, 196, 197, 198, 198, 200, 229, 229, 230, 231,
225, 226, 226, 228, 228, 232, 232, 234, 234, 235,	231, 232, 232, 234, 234, 238, 238, 240, 240, 241,
235, 236, 236, 236, 240, 244, 245, 245, 246, 247,	241, 242, 242, 242, 246, 253, 254, 254, 255, 256,
249, 250, 265, 266, 266, 270, 274, 276, 277, 278,	258, 259, 281, 282, 282, 286, 290, 292, 293, 294,
293, 298, 300, 301, 302, 305, 311, 317, 323, 325,	311, 316, 318, 320, 321, 323, 329, 337, 343, 345,
326, 328, 334, 335, 335, 339, 343, 344, 345, 359,	346, 348, 354, 355, 355, 359, 365, 368, 371, 384,
361, 361, 362, 364, 365, 367, 368, 369, 370, 372,	386, 386, 387, 389, 390, 392, 393, 394, 395, 397,
374, 376, 378, 380, 382, 386, 390, 394, 396, 397,	399, 401, 403, 405, 407, 411, 415, 419, 421, 422,
399, 406, 406, 408, 408, 409, 410, 415, 420, 422,	424, 433, 433, 435, 435, 436, 437, 445, 450, 452,
424, 425, 426, 428, 432, 440, 446, 451, 451, 452,	454, 455, 456, 458, 462, 471, 477, 482, 482, 483,
457, 459, 461, 465, 477, 481, 483, 484, 485, 486,	488, 490, 492, 504, 516, 521, 523, 524, 525, 526,
487, 489, 490, 491, 492, 493, 494, 495, 497, 498,	527, 529, 530, 531, 532, 533, 534, 535, 536, 538,
499, 500, 501, 502, 503, 504, 505, 506, 507, 508,	539, 540, 541, 542, 543, 544, 545, 546, 547, 548,
509, 510, 511, 512, 513, 514, 515, 516, 517, 518,	549, 550, 551, 552, 553, 554, 555, 556, 557, 558,
519, 520, 523, 532, 537, 538	559, 560, 561, 562, 563, 564, 567, 576, 581, 582
};	};
#endif	#endif

Line 218 static const short yyrline[] = { 0,	Line 233 static const short yyrline[] = { 0,
#if YYDEBUG != 0 \|\| defined (YYERROR_VERBOSE)	#if YYDEBUG != 0 \|\| defined (YYERROR_VERBOSE)

static const char * const yytname[] = { "$","error","$undefined.","EON","STRING",	static const char * const yytname[] = { "$","error","$undefined.","EON","STRING",
"BOGUS","BAD_STRING_COMPARISON_OPERATOR","BAD_HEX_LITERAL","\"&&\"","\"\|\|\"",	"BOGUS","BAD_STRING_COMPARISON_OPERATOR","BAD_HEX_LITERAL","BAD_METHOD_DECL_START",
"\"##\"","\"<=\"","\">=\"","\"==\"","\"!=\"","\"lt\"","\"gt\"","\"le\"","\"ge\"",	"BAD_METHOD_PARAMETER_NAME_CHARACTER","BAD_MATH_OPERATOR_CHARACTER","\"&&\"",
"\"eq\"","\"ne\"","\"def\"","\"in\"","\"-f\"","\"-d\"","\"is\"","'<'","'>'",	"\"\|\|\"","\"!\|\|\"","\"!\|\"","\"<=\"","\">=\"","\"==\"","\"!=\"","\"<<\"","\">>\"",
"'!'","'#'","'\|'","'&'","'~'","'-'","'+'","'*'","'/'","'%'","NEG","'@'","'\\n'",	"\"lt\"","\"gt\"","\"le\"","\"ge\"","\"eq\"","\"ne\"","\"def\"","\"in\"","\"-f\"",
"'['","']'","';'","'$'","'{'","'}'","'.'","'('","')'","'^'","':'","'\\\"'","'\\''",	"\"-d\"","\"is\"","'<'","'>'","'\|'","'&'","'+'","'-'","'*'","'/'","'\\\\'","'%'",
"all","methods","one_big_piece","method","control_method","maybe_control_strings",	"NUNARY","'~'","'!'","'@'","'\\n'","'['","']'","';'","'$'","'{'","'}'","'.'",
"control_strings","control_string","maybe_string","code_method","maybe_bracketed_strings",	"'('","')'","'^'","':'","'\\\"'","'\\''","all","methods","one_big_piece","method",
"bracketed_maybe_strings","maybe_strings","strings","maybe_comment","maybe_codes",	"control_method","maybe_control_strings","control_strings","control_string",
"codes","code","action","get","get_value","get_name_value","name_in_curly_rdive",	"maybe_string","code_method","maybe_bracketed_strings","bracketed_maybe_strings",
"name_without_curly_rdive","name_without_curly_rdive_read","name_without_curly_rdive_class",	"maybe_strings","strings","maybe_comment","maybe_codes","codes","code","action",
"name_without_curly_rdive_code","put","name_expr_wdive","name_expr_wdive_root",	"get","get_value","get_name_value","name_in_curly_rdive","name_without_curly_rdive",
"name_expr_wdive_write","name_expr_wdive_class","construct","construct_square",	"name_without_curly_rdive_read","name_without_curly_rdive_class","name_without_curly_rdive_code",
"construct_round","construct_curly","any_constructor_code_value","constructor_code_value",	"put","name_expr_wdive","name_expr_wdive_root","name_expr_wdive_write","name_expr_wdive_class",
"constructor_code","codes__excluding_sole_str_literal","call","call_value","@1",	"construct","construct_square","construct_round","construct_curly","any_constructor_code_value",
"@2","call_name","store_params","store_param","store_square_param","store_round_param",	"constructor_code_value","constructor_code","codes__excluding_sole_str_literal",
"store_curly_param","store_code_param_parts","store_expr_param_parts","store_curly_param_parts",	"call","call_value","@1","@2","call_name","store_params","store_param","store_square_param",
"store_code_param_part","store_expr_param_part","store_curly_param_part","code_param_value",	"store_round_param","store_curly_param","store_code_param_parts","store_expr_param_parts",
"write_expr_value","name_expr_dive_code","name_path","name_step","name_advance1",	"store_curly_param_parts","store_code_param_part","store_expr_param_part","store_curly_param_part",
"name_advance2","name_expr_value","name_expr_subvar_value","name_expr_with_subvar_value",	"code_param_value","write_expr_value","name_expr_dive_code","name_path","name_step",
"name_curly_code_value","subvar_ref_name_rdive","subvar_get_writes","subvar__get_write",	"name_advance1","name_advance2","name_expr_value","name_expr_subvar_value","name_expr_with_subvar_value",
	"name_square_code_value","subvar_ref_name_rdive","subvar_get_writes","subvar__get_write",
"class_prefix","class_static_prefix","class_constructor_prefix","expr_value",	"class_prefix","class_static_prefix","class_constructor_prefix","expr_value",
"expr","string_inside_quotes_value","write_string","void_value","empty", NULL	"expr","string_inside_quotes_value","write_string","void_value","empty", NULL
};	};
#endif	#endif

static const short yyr1[] = { 0,	static const short yyr1[] = { 0,
54, 54, 55, 55, 56, 57, 57, 58, 59, 59,	60, 60, 61, 61, 62, 63, 63, 64, 65, 65,
60, 60, 61, 62, 62, 63, 64, 64, 65, 66,	66, 66, 67, 68, 68, 69, 70, 70, 71, 72,
66, 67, 67, 68, 68, 69, 69, 70, 70, 71,	72, 73, 73, 74, 74, 75, 75, 76, 76, 77,
71, 72, 72, 72, 73, 74, 75, 75, 76, 77,	77, 78, 78, 78, 79, 80, 81, 81, 82, 83,
77, 78, 79, 80, 80, 81, 82, 82, 82, 83,	83, 84, 85, 86, 86, 87, 88, 88, 88, 89,
84, 85, 86, 86, 86, 87, 88, 89, 90, 90,	90, 91, 92, 92, 92, 93, 94, 95, 96, 96,
90, 91, 92, 93, 93, 94, 96, 97, 95, 98,	96, 97, 98, 99, 99, 100, 102, 103, 101, 104,
99, 99, 100, 100, 100, 101, 102, 103, 104, 104,	105, 105, 106, 106, 106, 107, 108, 109, 110, 110,
105, 105, 106, 106, 107, 108, 109, 110, 110, 110,	111, 111, 112, 112, 113, 114, 115, 116, 116, 116,
111, 112, 112, 113, 113, 114, 115, 116, 116, 117,	117, 118, 118, 119, 119, 120, 121, 122, 122, 123,
117, 117, 117, 118, 119, 120, 121, 122, 122, 123,	123, 123, 123, 124, 125, 126, 127, 128, 128, 129,
124, 124, 125, 126, 127, 128, 128, 128, 128, 128,	130, 130, 131, 132, 133, 134, 134, 134, 134, 134,
128, 128, 128, 128, 128, 128, 128, 128, 128, 128,	134, 134, 134, 134, 134, 134, 134, 134, 134, 134,
128, 128, 128, 128, 128, 128, 128, 128, 128, 128,	134, 134, 134, 134, 134, 134, 134, 134, 134, 134,
128, 128, 128, 128, 128, 128, 128, 128, 128, 128,	134, 134, 134, 134, 134, 134, 134, 134, 134, 134,
128, 128, 129, 130, 131, 132	134, 134, 134, 134, 134, 134, 135, 136, 137, 138
};	};

static const short yyr2[] = { 0,	static const short yyr2[] = { 0,
Line 275 static const short yyr2[] = { 0,	Line 291 static const short yyr2[] = { 0,
1, 1, 2, 1, 2, 2, 1, 1, 2, 1,	1, 1, 2, 1, 2, 2, 1, 1, 2, 1,
1, 1, 1, 2, 2, 3, 1, 1, 2, 2,	1, 1, 1, 2, 2, 3, 1, 1, 2, 2,
1, 1, 2, 2, 1, 1, 1, 1, 3, 3,	1, 1, 2, 2, 1, 1, 1, 1, 3, 3,
3, 2, 2, 2, 2, 2, 2, 2, 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, 3, 3, 3, 3,	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 1, 1, 0, 0	3, 3, 3, 3, 3, 3, 1, 1, 0, 0
};	};

static const short yydefact[] = { 156,	static const short yydefact[] = { 160,
154, 0, 0, 67, 2, 1, 3, 6, 7, 5,	158, 0, 0, 67, 2, 1, 3, 6, 7, 5,
27, 28, 31, 32, 35, 33, 34, 66, 30, 26,	27, 28, 31, 32, 35, 33, 34, 66, 30, 26,
0, 100, 0, 0, 0, 0, 36, 38, 0, 40,	0, 100, 0, 0, 0, 0, 36, 38, 0, 40,
41, 42, 0, 47, 48, 49, 50, 0, 94, 0,	41, 42, 0, 47, 48, 49, 50, 0, 94, 0,
44, 92, 101, 102, 103, 0, 111, 112, 0, 4,	44, 92, 101, 102, 103, 0, 111, 112, 0, 4,
29, 156, 156, 156, 99, 0, 113, 105, 108, 107,	29, 160, 160, 160, 99, 0, 113, 105, 108, 0,
104, 0, 0, 98, 0, 100, 51, 0, 92, 0,	107, 104, 0, 0, 98, 0, 100, 51, 0, 92,
37, 155, 156, 0, 46, 53, 54, 55, 100, 95,	37, 159, 160, 0, 46, 53, 54, 55, 100, 95,
45, 93, 96, 43, 52, 114, 70, 68, 15, 8,	45, 93, 96, 43, 52, 114, 70, 68, 15, 8,
10, 11, 0, 9, 22, 0, 21, 20, 156, 18,	10, 11, 0, 9, 22, 0, 21, 20, 160, 18,
17, 110, 109, 39, 93, 106, 154, 0, 31, 0,	17, 110, 109, 106, 39, 93, 158, 0, 31, 0,
61, 62, 63, 59, 0, 116, 0, 0, 0, 0,	61, 62, 63, 59, 0, 116, 0, 0, 0, 0,
0, 0, 0, 0, 0, 156, 156, 117, 118, 0,	0, 0, 0, 0, 0, 0, 160, 160, 117, 118,
115, 0, 12, 14, 13, 19, 0, 25, 0, 24,	0, 115, 0, 12, 14, 13, 19, 0, 25, 0,
65, 56, 58, 125, 126, 127, 128, 124, 123, 122,	24, 65, 56, 58, 126, 127, 128, 129, 123, 122,
0, 153, 0, 0, 57, 0, 0, 0, 0, 0,	124, 125, 0, 157, 0, 0, 57, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 155,	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
156, 0, 0, 71, 73, 74, 75, 23, 156, 121,	0, 0, 0, 0, 159, 160, 0, 0, 71, 73,
119, 120, 137, 138, 139, 142, 143, 144, 145, 146,	74, 75, 23, 160, 121, 119, 120, 141, 142, 143,
147, 148, 149, 150, 151, 152, 140, 141, 136, 135,	140, 146, 147, 148, 149, 136, 137, 150, 151, 152,
134, 129, 130, 131, 132, 133, 154, 90, 0, 79,	153, 154, 155, 156, 144, 145, 139, 138, 131, 130,
85, 88, 87, 0, 83, 0, 81, 86, 91, 69,	132, 133, 135, 134, 158, 90, 0, 79, 85, 88,
72, 16, 76, 155, 156, 78, 0, 77, 80, 84,	87, 0, 83, 0, 81, 86, 91, 69, 72, 16,
82, 0, 0, 0	76, 159, 160, 78, 0, 77, 80, 84, 82, 0,
	0, 0
};	};

static const short yydefgoto[] = { 242,	static const short yydefgoto[] = { 250,
5, 6, 7, 8, 90, 91, 92, 93, 9, 99,	5, 6, 7, 8, 90, 91, 92, 93, 9, 99,
54, 96, 97, 139, 152, 11, 12, 13, 14, 128,	54, 96, 97, 140, 154, 11, 12, 13, 14, 129,
27, 28, 29, 30, 31, 32, 16, 33, 34, 35,	27, 28, 29, 30, 31, 32, 16, 33, 34, 35,
36, 75, 76, 77, 78, 110, 218, 112, 113, 17,	36, 75, 76, 77, 78, 110, 226, 112, 113, 17,
129, 49, 132, 88, 183, 184, 185, 186, 187, 219,	130, 49, 133, 88, 188, 189, 190, 191, 192, 227,
226, 224, 220, 227, 225, 221, 228, 37, 63, 39,	234, 232, 228, 235, 233, 229, 236, 37, 64, 39,
40, 41, 64, 43, 44, 45, 61, 58, 59, 65,	40, 41, 65, 43, 44, 45, 62, 58, 59, 66,
47, 48, 229, 131, 153, 19, 222, 20	47, 48, 237, 132, 155, 19, 230, 20
};	};

static const short yypact[] = { 6,	static const short yypact[] = { 13,
-32768, 14, 57,-32768, -17,-32768,-32768,-32768,-32768,-32768,	-32768, 24, 98,-32768, 36,-32768,-32768,-32768,-32768,-32768,
16,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,	14,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
73, 35, 23, 51, 76, 16,-32768,-32768, 80,-32768,	-26, 39, 14, 44, 45, 100,-32768,-32768, 47,-32768,
-32768,-32768, -24,-32768,-32768,-32768,-32768, 77,-32768, 47,	-32768,-32768, 52,-32768,-32768,-32768,-32768, 118,-32768, 59,
-32768, 22,-32768,-32768,-32768, 77, 46,-32768, 51,-32768,	-32768, 4,-32768,-32768,-32768, 118, -3,-32768, 45,-32768,
-32768, 96, 107, 88,-32768, 23,-32768, 71,-32768,-32768,	-32768, 101, 113, 71,-32768, 44,-32768, 70,-32768, 32,
-32768, 141, 77, 90, 77, 71,-32768, 76, 90, 8,	-32768,-32768, 73, 118, 83, 118, 70,-32768, 100, 83,
-32768, 38, 16, 15,-32768,-32768,-32768,-32768, 9,-32768,	-32768, 27, 14, 57,-32768,-32768,-32768,-32768, 1,-32768,
-32768, 22,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,	-32768, 4,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
94,-32768, 83, 142,-32768, 144, 145,-32768, 186,-32768,	20,-32768, 78, 91,-32768, 90, 94,-32768, 135,-32768,
-32768,-32768,-32768,-32768, 90,-32768, 150, 16, 123, 152,	-32768,-32768,-32768,-32768,-32768, 83, 92, 14, -22, 106,
-32768,-32768,-32768,-32768, 173,-32768, 15, 15, 15, 15,	-32768,-32768,-32768,-32768, 115,-32768, 57, 57, 57, 57,
15, 15, 15, 74, 15, 16, 16,-32768,-32768, 171,	57, 57, 57, 57, 105, 57, 14, 14,-32768,-32768,
274, 91,-32768,-32768,-32768,-32768, 217,-32768, 182,-32768,	114, 281, 72,-32768,-32768,-32768,-32768, 142,-32768, 107,
16,-32768,-32768, 140, 140, 140, 140, 140, 118,-32768,	-32768, 14,-32768,-32768, 440, 440, 440, 440,-32768,-32768,
232,-32768, 180, 170,-32768, 15, 15, 15, 15, 15,	-32768,-32768, 236,-32768, 112, 120,-32768, 57, 57, 57,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15,	57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
15, 15, 15, 15, 15, 15, 15, 15, 15, 40,	57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
16, 15, 48,-32768,-32768,-32768,-32768,-32768, 16,-32768,	57, 57, 57, 57, 41, 14, 57, 5,-32768,-32768,
-32768,-32768, 361, 334, 304, 386, 386, 113, 113, 386,	-32768,-32768,-32768, 14,-32768,-32768,-32768, 371, 343, 312,
386, 386, 386, 113, 113, 140, 386, 386, 194, 239,	244, 399, 399, 412, 412, 136, 136, 399, 399, 399,
118, -4, -4,-32768,-32768,-32768, 125,-32768, 136,-32768,	399, 412, 412, 440, 399, 399, 447, 453, 93, 93,
-32768,-32768,-32768, 60,-32768, -20,-32768,-32768,-32768,-32768,	-32768,-32768,-32768,-32768, -11,-32768, 19,-32768,-32768,-32768,
-32768,-32768,-32768, 40, 16,-32768, 15,-32768,-32768,-32768,	-32768, -10,-32768, -33,-32768,-32768,-32768,-32768,-32768,-32768,
-32768, 233, 236,-32768	-32768, 41, 14,-32768, 57,-32768,-32768,-32768,-32768, 180,
	181,-32768
};	};

static const short yypgoto[] = {-32768,	static const short yypgoto[] = {-32768,
-32768,-32768, 248,-32768,-32768,-32768, 163,-32768,-32768,-32768,	-32768,-32768, 177,-32768,-32768,-32768, 99,-32768,-32768,-32768,
201,-32768,-32768,-32768, 2, -21, -8, -71,-32768, 0,	129,-32768,-32768,-32768, 3, -18, -7, -71,-32768, 0,
-32768,-32768, 67,-32768,-32768, -30,-32768,-32768,-32768,-32768,	-32768,-32768, -6,-32768,-32768, -37,-32768,-32768,-32768,-32768,
-32768,-32768,-32768,-32768,-32768,-32768, 184,-32768,-32768,-32768,	-32768,-32768,-32768,-32768,-32768,-32768, 119,-32768,-32768,-32768,
4,-32768,-32768,-32768,-32768, 81,-32768,-32768,-32768,-32768,	2,-32768,-32768,-32768,-32768, -4,-32768,-32768,-32768,-32768,
-32768,-32768, 26, 34, 42,-32768,-32768, -12, 82, 72,	-32768,-32768, -50, -52, -48,-32768,-32768, -16, 95, -23,
-32768, 54, 3,-32768,-32768,-32768, 222,-32768, 221, 277,	-32768, -24, 9,-32768,-32768,-32768, 169,-32768, 168, 224,
-32768,-32768, 223, 39, 168,-32768, 224, -45	-32768,-32768, 154, 40, 102,-32768, 157, -20
};	};


#define YYLAST 423	#define YYLAST 494


static const short yytable[] = { 15,	static const short yytable[] = { 15,
109, 10, 51, 18, 70, 42, 94, 98, 101, 1,	109, 18, 10, 51, 60, 55, -98, 238, 84, 68,
15, 1, 67, 55, 18, 84, 72, 21, 116, 1,	15, 42, 18, 81, 80, 245, 1, 1, 63, 52,
73, 2, 237, 74, -98, 15, 60, 69, 238, 18,	53, 246, 15, 89, 18, -64, -64, 21, 84, 85,
177, 178, 179, 85, 84, 117, 118, 119, 120, 55,	107, 94, 98, 101, 70, 1, -89, -89, 243, 81,
82, 107, 121, 217, 2, 134, 122, 123, 42, 3,	80, 244, 87, 55, 225, 80, 82, 61, 22, 71,
230, 3, 56, 140, 22, 4, 106, 4, 124, 3,	56, 185, 51, 86, 42, 186, -97, 2, 187, 15,
22, 51, 125, 108, 4, 4, 126, 127, -97, 15,	116, 18, 3, 3, 108, -160, 241, 242, 4, 4,
105, 15, 15, 18, 115, 18, 18, 22, 56, 66,	135, 15, 15, 18, 18, 115, 3, 106, 141, 104,
79, 3, 71, 3, 38, 57, 141, 4, 180, 4,	2, 3, 4, 117, 118, 119, 120, 4, 56, 142,
62, 81, 181, 83, 23, 182, 86, 89, 26, 89,	3, 23, 121, 122, 24, 57, 4, 38, 72, 123,
23, 24, 235, 25, 26, 236, 68, 15, 109, 80,	124, 22, 73, 67, 89, 74, 125, 15, 22, 18,
95, 18, 52, 53, 56, 87, 81, 23, 24, 23,	126, 83, 4, 109, 127, 128, 95, 53, 185, 56,
23, 26, 135, 26, 26, 15, 15, 38, 53, 18,	69, 79, 186, 136, 105, 187, 15, 15, 18, 18,
18, 180, 51, -156, 80, 181, -97, 169, 182, 80,	181, 182, 183, 184, 51, -97, -14, 137, 139, -60,
15, 172, 173, 174, 18, 175, 176, 177, 178, 179,	38, 15, 138, 18, 23, 193, 23, 24, 25, 24,
175, 176, 177, 178, 179, 144, 145, 146, 147, 148,	26, 23, 194, 143, 24, 25, 145, 146, 147, 148,
149, 150, 109, 151, -64, -64, -89, -89, 172, 173,	149, 150, 151, 152, 23, 153, 144, 24, 157, 196,
174, 108, 175, 176, 177, 178, 179, 233, 234, 15,	109, 179, 180, 181, 182, 183, 184, 108, 197, 251,
15, -14, 223, 18, 18, 136, 104, 137, 15, 138,	252, 50, 100, 239, 15, 15, 18, 18, 231, 134,
232, -60, 18, 142, 193, 194, 195, 196, 197, 198,	111, 247, 249, 15, 248, 18, 240, 198, 199, 200,
199, 200, 201, 202, 203, 204, 205, 206, 207, 208,	201, 202, 203, 204, 205, 206, 207, 208, 209, 210,
209, 210, 211, 212, 213, 214, 215, 216, 143, 155,	211, 212, 213, 214, 215, 216, 217, 218, 219, 220,
188, 189, 192, 173, 174, 108, 175, 176, 177, 178,	221, 222, 223, 224, 102, 103, 46, 131, 114, 156,
179, 191, 243, 15, 15, 244, 223, 18, 18, 156,	0, 0, 0, 0, 108, 0, 0, 0, 0, 0,
157, 158, 159, 160, 161, 162, 163, 164, 165, 166,	0, 15, 15, 18, 18, 231, 158, 159, 160, 161,
167, 168, 50, 133, 100, 111, 169, 170, 171, 239,	162, 163, 164, 165, 166, 167, 168, 169, 170, 171,
172, 173, 174, 231, 175, 176, 177, 178, 179, 174,	172, 173, 166, 167, 0, 0, 174, 175, 176, 177,
241, 175, 176, 177, 178, 179, 240, 102, 103, 46,	178, 179, 180, 181, 182, 183, 184, 177, 178, 179,
190, 156, 157, 158, 159, 160, 161, 162, 163, 164,	180, 181, 182, 183, 184, 0, 0, 0, 0, 0,
165, 166, 167, 168, 154, 114, 130, 0, 169, 170,	195, 158, 159, 160, 161, 162, 163, 164, 165, 166,
171, 0, 172, 173, 174, 0, 175, 176, 177, 178,	167, 168, 169, 170, 171, 172, 173, 0, 0, 0,
179, 156, 157, 0, 159, 160, 161, 162, 163, 164,	0, 174, 175, 176, 177, 178, 179, 180, 181, 182,
165, 166, 167, 168, 0, 0, 0, 0, 169, 170,	183, 184, 158, 159, 0, 161, 162, 163, 164, 165,
171, 0, 172, 173, 174, 0, 175, 176, 177, 178,	166, 167, 168, 169, 170, 171, 172, 173, 0, 0,
179, 156, 0, 0, 159, 160, 161, 162, 163, 164,	0, 0, 174, 175, 176, 177, 178, 179, 180, 181,
165, 166, 167, 168, 0, 0, 0, 0, 169, 170,	182, 183, 184, 158, 0, 0, 161, 162, 163, 164,
171, 0, 172, 173, 174, 0, 175, 176, 177, 178,	165, 166, 167, 168, 169, 170, 171, 172, 173, 0,
179, 159, 160, 161, 162, 163, 164, 165, 166, 167,	0, 0, 0, 174, 175, 176, 177, 178, 179, 180,
168, 0, 0, 0, 0, 169, 170, 171, 0, 172,	181, 182, 183, 184, 161, 162, 163, 164, 165, 166,
173, 174, 0, 175, 176, 177, 178, 179, 161, 162,	167, 168, 169, 170, 171, 172, 173, 0, 0, 0,
0, 0, 0, 0, 167, 168, 0, 0, 0, 0,	0, 174, 175, 176, 177, 178, 179, 180, 181, 182,
169, 0, 0, 0, 172, 173, 174, 0, 175, 176,	183, 184, 161, 0, 0, 164, 165, 166, 167, 0,
177, 178, 179	0, 0, 0, 172, 173, 161, 0, 0, 0, 174,
	166, 167, 177, 178, 179, 180, 181, 182, 183, 184,
	0, 0, 174, 0, 0, 177, 178, 179, 180, 181,
	182, 183, 184, 161, 0, 0, 0, 0, 166, 167,
	0, 0, 0, 0, 0, 166, 167, 0, 0, 0,
	0, 166, 167, 177, 178, 179, 180, 181, 182, 183,
	184, 178, 179, 180, 181, 182, 183, 184, 179, 180,
	181, 182, 183, 184
};	};

static const short yycheck[] = { 0,	static const short yycheck[] = { 0,
72, 0, 11, 0, 26, 3, 52, 53, 54, 4,	72, 0, 0, 11, 23, 5, 3, 3, 46, 26,
11, 4, 25, 5, 11, 46, 41, 4, 4, 4,	11, 3, 11, 38, 38, 49, 4, 4, 25, 46,
45, 39, 43, 48, 3, 26, 4, 25, 49, 26,	47, 55, 23, 4, 23, 48, 49, 4, 66, 46,
35, 36, 37, 46, 65, 21, 22, 23, 24, 5,	4, 52, 53, 54, 26, 4, 48, 49, 49, 64,
38, 4, 28, 4, 39, 91, 32, 33, 46, 44,	64, 52, 49, 5, 4, 69, 38, 4, 4, 3,
3, 44, 44, 99, 4, 50, 49, 50, 44, 44,	50, 47, 60, 57, 46, 51, 53, 45, 54, 60,
4, 70, 48, 72, 50, 50, 52, 53, 47, 70,	4, 60, 50, 50, 72, 46, 48, 49, 56, 56,
68, 72, 73, 70, 73, 72, 73, 4, 44, 4,	91, 72, 73, 72, 73, 73, 50, 69, 99, 48,
4, 44, 3, 44, 3, 51, 108, 50, 41, 50,	45, 50, 56, 27, 28, 29, 30, 56, 50, 108,
24, 38, 45, 47, 44, 48, 51, 4, 48, 4,	50, 47, 36, 37, 50, 57, 56, 3, 47, 43,
44, 45, 43, 47, 48, 46, 25, 108, 180, 38,	44, 4, 51, 4, 4, 54, 50, 108, 4, 108,
4, 108, 40, 41, 44, 49, 63, 44, 45, 44,	54, 53, 56, 185, 58, 59, 4, 47, 47, 50,
44, 48, 40, 48, 48, 126, 127, 46, 41, 126,	26, 4, 51, 46, 52, 54, 127, 128, 127, 128,
127, 41, 141, 40, 63, 45, 47, 25, 48, 68,	38, 39, 40, 41, 142, 53, 46, 48, 4, 48,
141, 29, 30, 31, 141, 33, 34, 35, 36, 37,	46, 142, 49, 142, 47, 4, 47, 50, 51, 50,
33, 34, 35, 36, 37, 117, 118, 119, 120, 121,	53, 47, 46, 48, 50, 51, 117, 118, 119, 120,
122, 123, 234, 125, 42, 43, 42, 43, 29, 30,	121, 122, 123, 124, 47, 126, 52, 50, 55, 58,
31, 180, 33, 34, 35, 36, 37, 42, 43, 180,	242, 36, 37, 38, 39, 40, 41, 185, 59, 0,
181, 40, 181, 180, 181, 42, 46, 43, 189, 4,	0, 5, 54, 188, 185, 186, 185, 186, 186, 91,
189, 42, 189, 42, 156, 157, 158, 159, 160, 161,	72, 242, 245, 194, 243, 194, 194, 158, 159, 160,
162, 163, 164, 165, 166, 167, 168, 169, 170, 171,	161, 162, 163, 164, 165, 166, 167, 168, 169, 170,
172, 173, 174, 175, 176, 177, 178, 179, 46, 49,	171, 172, 173, 174, 175, 176, 177, 178, 179, 180,
4, 40, 53, 30, 31, 234, 33, 34, 35, 36,	181, 182, 183, 184, 56, 58, 3, 74, 72, 128,
37, 52, 0, 234, 235, 0, 235, 234, 235, 8,	-1, -1, -1, -1, 242, -1, -1, -1, -1, -1,
9, 10, 11, 12, 13, 14, 15, 16, 17, 18,	-1, 242, 243, 242, 243, 243, 11, 12, 13, 14,
19, 20, 5, 91, 54, 72, 25, 26, 27, 234,	15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
29, 30, 31, 183, 33, 34, 35, 36, 37, 31,	25, 26, 19, 20, -1, -1, 31, 32, 33, 34,
237, 33, 34, 35, 36, 37, 235, 56, 58, 3,	35, 36, 37, 38, 39, 40, 41, 34, 35, 36,
49, 8, 9, 10, 11, 12, 13, 14, 15, 16,	37, 38, 39, 40, 41, -1, -1, -1, -1, -1,
17, 18, 19, 20, 127, 72, 74, -1, 25, 26,	55, 11, 12, 13, 14, 15, 16, 17, 18, 19,
27, -1, 29, 30, 31, -1, 33, 34, 35, 36,	20, 21, 22, 23, 24, 25, 26, -1, -1, -1,
37, 8, 9, -1, 11, 12, 13, 14, 15, 16,	-1, 31, 32, 33, 34, 35, 36, 37, 38, 39,
17, 18, 19, 20, -1, -1, -1, -1, 25, 26,	40, 41, 11, 12, -1, 14, 15, 16, 17, 18,
27, -1, 29, 30, 31, -1, 33, 34, 35, 36,	19, 20, 21, 22, 23, 24, 25, 26, -1, -1,
37, 8, -1, -1, 11, 12, 13, 14, 15, 16,	-1, -1, 31, 32, 33, 34, 35, 36, 37, 38,
17, 18, 19, 20, -1, -1, -1, -1, 25, 26,	39, 40, 41, 11, -1, -1, 14, 15, 16, 17,
27, -1, 29, 30, 31, -1, 33, 34, 35, 36,	18, 19, 20, 21, 22, 23, 24, 25, 26, -1,
37, 11, 12, 13, 14, 15, 16, 17, 18, 19,	-1, -1, -1, 31, 32, 33, 34, 35, 36, 37,
20, -1, -1, -1, -1, 25, 26, 27, -1, 29,	38, 39, 40, 41, 14, 15, 16, 17, 18, 19,
30, 31, -1, 33, 34, 35, 36, 37, 13, 14,	20, 21, 22, 23, 24, 25, 26, -1, -1, -1,
-1, -1, -1, -1, 19, 20, -1, -1, -1, -1,	-1, 31, 32, 33, 34, 35, 36, 37, 38, 39,
25, -1, -1, -1, 29, 30, 31, -1, 33, 34,	40, 41, 14, -1, -1, 17, 18, 19, 20, -1,
35, 36, 37	-1, -1, -1, 25, 26, 14, -1, -1, -1, 31,
	19, 20, 34, 35, 36, 37, 38, 39, 40, 41,
	-1, -1, 31, -1, -1, 34, 35, 36, 37, 38,
	39, 40, 41, 14, -1, -1, -1, -1, 19, 20,
	-1, -1, -1, -1, -1, 19, 20, -1, -1, -1,
	-1, 19, 20, 34, 35, 36, 37, 38, 39, 40,
	41, 35, 36, 37, 38, 39, 40, 41, 36, 37,
	38, 39, 40, 41
};	};
#define YYPURE 1	#define YYPURE 1

/* --C-- Note some compilers choke on comments on `#line' lines. */	/* --C-- Note some compilers choke on comments on `#line' lines. */
#line 3 "D:/cygwin/usr/share/bison.simple"	#line 3 "/usr/share/bison.simple"
/* This file comes from bison-1.28. */	/* This file comes from bison-1.28. */

/* Skeleton output parser for bison,	/* Skeleton output parser for bison,
Line 671 __yy_memcpy (char to, char from, unsig	Line 703 __yy_memcpy (char to, char from, unsig
#endif	#endif
#endif	#endif

#line 217 "D:/cygwin/usr/share/bison.simple"	#line 217 "/usr/share/bison.simple"

/* The user can define YYPARSE_PARAM as the name of an argument to be passed	/* The user can define YYPARSE_PARAM as the name of an argument to be passed
into yyparse. The argument should have type void *.	into yyparse. The argument should have type void *.
Line 1000 yyreduce:	Line 1032 yyreduce:
switch (yyn) {	switch (yyn) {

case 1:	case 1:
#line 107 "compile.y"	#line 116 "compile.y"
{	{
Method& method=*NEW Method(POOL,	MethodPtr method(new Method(main_method_name, Method::CT_ANY,
*main_method_name,
Method::CT_ANY,
0, 0, /min, max numbered_params_count/	0, 0, /min, max numbered_params_count/
0/param_names/, 0/local_names/,	ArrayConstStringPtr(0)/param_names/, ArrayConstStringPtr(0)/local_names/,
yyvsp[0]/parser_code/, 0/native_code/);	yyvsp[0]/parser_code/, 0/native_code/));
PC.cclass->add_method(*main_method_name, method);	PC.cclass->add_method(main_method_name, method);
;	;
break;}	break;}
case 8:	case 8:
#line 124 "compile.y"	#line 131 "compile.y"
{	{
const String& command=*LA2S(yyvsp[-2]);	ConstStringPtr command=LA2S(*yyvsp[-2]);
YYSTYPE strings_code=yyvsp[0];	YYSTYPE strings_code=yyvsp[0];
if(strings_code->size()<1*2) {	if(strings_code->count()<1*2) {
strcpy(PC.error, "@");	strcpy(PC.error, "@");
strcat(PC.error, command.cstr());	strcat(PC.error, command->cstr());
strcat(PC.error, " is empty");	strcat(PC.error, " is empty");
YYERROR;	YYERROR;
}	}
if(command==CLASS_NAME) {	if(*command==CLASS_NAME) {
if(PC.cclass->base()) { // already changed from default?	if(PC.cclass->base_class()) { // already changed from default?
strcpy(PC.error, "class already have a name '");	strcpy(PC.error, "class already have a name '");
strncat(PC.error, PC.cclass->name().cstr(), 100);	strncat(PC.error, PC.cclass->name()->cstr(), 100);
strcat(PC.error, "'");	strcat(PC.error, "'");
YYERROR;	YYERROR;
}	}
if(strings_code->size()==1*2) {	if(strings_code->count()==1*2) {
// new class' name	// new class' name
const String *name=LA2S(strings_code);	ConstStringPtr name=LA2S(*strings_code);
// creating the class	// creating the class
PC.cclass=NEW VClass(POOL);	PC.cclass=VStateless_classPtr(new VClass);
PC.cclass->set_name(*name);	PC.cclass->set_name(name);
// append to request's classes	// append to request's classes
PC.request->classes().put(*name, PC.cclass);	PC.request->classes().put(name, PC.cclass);
} else {	} else {
strcpy(PC.error, "@"CLASS_NAME" must contain sole name");	strcpy(PC.error, "@"CLASS_NAME" must contain sole name");
YYERROR;	YYERROR;
}	}
} else if(command==USE_CONTROL_METHOD_NAME) {	} else if(*command==USE_CONTROL_METHOD_NAME) {
for(int i=0; i<strings_code->size(); i+=2)	for(int i=0; i<strings_code->count(); i+=2)
PC.request->use_file(*LA2S(strings_code, i));	PC.request->use_file(PC.request->main_class, LA2S(*strings_code, i));
} else if(command==BASE_NAME) {	} else if(*command==BASE_NAME) {
if(PC.cclass->base()) { // already changed from default?	if(PC.cclass->base_class()) { // already changed from default?
strcpy(PC.error, "class already have a base '");	strcpy(PC.error, "class already have a base '");
strncat(PC.error, PC.cclass->base()->name().cstr(), 100);	strncat(PC.error, PC.cclass->base_class()->name()->cstr(), 100);
strcat(PC.error, "'");	strcat(PC.error, "'");
YYERROR;	YYERROR;
}	}
if(strings_code->size()==1*2) {	if(strings_code->count()==1*2) {
const String& base_name=*LA2S(strings_code);	ConstStringPtr base_name=LA2S(*strings_code);
VClass base=static_cast<VClass >(	if(VStateless_classPtr base_class=PC.request->classes().get(base_name)) {
PC.request->classes().get(base_name));	// @CLASS == @BASE sanity check
if(!base) {	if(PC.cclass.get()==base_class.get()) {
strcpy(PC.error, base_name.cstr());	strcpy(PC.error, "@"CLASS_NAME" equals @"BASE_NAME);
	YYERROR;
	}
	PC.cclass->set_base(base_class);
	} else {
	strcpy(PC.error, base_name->cstr());
strcat(PC.error, ": undefined class in @"BASE_NAME);	strcat(PC.error, ": undefined class in @"BASE_NAME);
YYERROR;	YYERROR;
}	}
// @CLASS == @BASE sanity check
if(PC.cclass==base) {
strcpy(PC.error, "@"CLASS_NAME" equals @"BASE_NAME);
YYERROR;
}
PC.cclass->set_base(*base);
} else {	} else {
strcpy(PC.error, "@"BASE_NAME" must contain sole name");	strcpy(PC.error, "@"BASE_NAME" must contain sole name");
YYERROR;	YYERROR;
}	}
} else {	} else {
strcpy(PC.error, "'");	strcpy(PC.error, "'");
strncat(PC.error, command.cstr(), MAX_STRING/2);	strncat(PC.error, command->cstr(), MAX_STRING/2);
strcat(PC.error, "' invalid special name. valid names are "	strcat(PC.error, "' invalid special name. valid names are "
"'"CLASS_NAME"', '"USE_CONTROL_METHOD_NAME"' and '"BASE_NAME"'");	"'"CLASS_NAME"', '"USE_CONTROL_METHOD_NAME"' and '"BASE_NAME"'");
YYERROR;	YYERROR;
Line 1080 case 8:	Line 1109 case 8:
;	;
break;}	break;}
case 12:	case 12:
#line 190 "compile.y"	#line 196 "compile.y"
{ yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;	{ yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;
break;}	break;}
case 16:	case 16:
#line 195 "compile.y"	#line 201 "compile.y"
{	{
const String *name=LA2S(yyvsp[-5]);	ConstStringPtr name=LA2S(*yyvsp[-5]);

YYSTYPE params_names_code=yyvsp[-4];	YYSTYPE params_names_code=yyvsp[-4];
Array *params_names=0;	ArrayConstStringPtr params_names;
if(int size=params_names_code->size()) {	if(int size=params_names_code->count()) {
params_names=NEW Array(POOL);	params_names=ArrayConstStringPtr(new ArrayConstString);
for(int i=0; i<size; i+=2)	for(int i=0; i<size; i+=2)
*params_names+=LA2S(params_names_code, i);	params_names+=LA2S(params_names_code, i);
}	}

YYSTYPE locals_names_code=yyvsp[-3];	YYSTYPE locals_names_code=yyvsp[-3];
Array *locals_names=0;	ArrayConstStringPtr locals_names;
if(int size=locals_names_code->size()) {	if(int size=locals_names_code->count()) {
locals_names=NEW Array(POOL);	locals_names=ArrayConstStringPtr(new ArrayConstString);
for(int i=0; i<size; i+=2)	for(int i=0; i<size; i+=2)
*locals_names+=LA2S(locals_names_code, i);	locals_names+=LA2S(locals_names_code, i);
}	}

Method& method=*NEW Method(POOL,	MethodPtr method(new Method(
*name,	name,
Method::CT_ANY,	Method::CT_ANY,
0, 0/min,max numbered_params_count/,	0, 0/min,max numbered_params_count/,
params_names, locals_names,	params_names, locals_names,
yyvsp[0], 0);	yyvsp[0], 0));
PC.cclass->add_method(*name, method);	PC.cclass->add_method(name, method);
;	;
break;}	break;}
case 19:	case 19:
#line 224 "compile.y"	#line 230 "compile.y"
{yyval=yyvsp[-1];	{yyval=yyvsp[-1];
break;}	break;}
case 23:	case 23:
#line 226 "compile.y"	#line 232 "compile.y"
{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]) ;	{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]) ;
break;}	break;}
case 29:	case 29:
#line 234 "compile.y"	#line 240 "compile.y"
{ yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;	{ yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;
break;}	break;}
case 35:	case 35:
#line 240 "compile.y"	#line 246 "compile.y"
{	{
yyval=yyvsp[0]; /* stack: resulting value */	yyval=yyvsp[0]; /* stack: resulting value */
O(yyval, OP_WRITE_VALUE); /* value=pop; wcontext.write(value) */	changetail_or_append(*yyval,
	OP_GET_ELEMENT, false, /->/OP_GET_ELEMENT__WRITE,
	/or /OP_WRITE_VALUE
	); /* value=pop; wcontext.write(value) */
;	;
break;}	break;}
case 36:	case 36:
#line 244 "compile.y"	#line 253 "compile.y"
{ yyval=yyvsp[0] ;	{ yyval=yyvsp[0] ;
break;}	break;}
case 39:	case 39:
#line 246 "compile.y"	#line 255 "compile.y"
{ yyval=yyvsp[-1] ;	{ yyval=yyvsp[-1] ;
break;}	break;}
case 42:	case 42:
#line 250 "compile.y"	#line 259 "compile.y"
{	{
yyval=N(POOL);	yyval=N();
Array *diving_code=yyvsp[0];	ArrayOperationPtr diving_code=yyvsp[0];
const String *first_name=LA2S(diving_code);	ConstStringPtr first_name=LA2S(*diving_code);
	// self.xxx... -> xxx...
	// OP_VALUE+string+OP_GET_ELEMENT+... -> OP_WITH_SELF+...
if(first_name && *first_name==SELF_ELEMENT_NAME) {	if(first_name && *first_name==SELF_ELEMENT_NAME) {
O(yyval, OP_WITH_SELF); /* stack: starting context */	O(yyval, OP_WITH_SELF); / stack: starting context */
P(yyval, diving_code,	P(yyval, diving_code,
/* skip over... */	/* skip over... */
diving_code->size()>2?3/OP_+string+get_element/:2/OP_+string/);	diving_code->count()>=3?3/OP_VALUE+string+OP_GET_ELEMENTx/:2/OP_+string/);
} else {	} else {
O(yyval, OP_WITH_READ); /* stack: starting context */	O(yyval, OP_WITH_READ); / stack: starting context */
P(yyval, diving_code);
	// ^if ELEMENT -> ^if ELEMENT_OR_OPERATOR
	// OP_VALUE+string+OP_GET_ELEMENT. -> OP_VALUE+string+OP_GET_ELEMENT_OR_OPERATOR.
	if(PC.in_call_value && diving_code->count()==3)
	(*diving_code)[2].code=OP_GET_ELEMENT_OR_OPERATOR;
	P(yyval, diving_code);
}	}
/* diving code; stack: current context */	/* diving code; stack: current context */
;	;
break;}	break;}
case 43:	case 43:
#line 265 "compile.y"	#line 281 "compile.y"
{ yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;	{ yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;
break;}	break;}
case 45:	case 45:
#line 266 "compile.y"	#line 282 "compile.y"
{ yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;	{ yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;
break;}	break;}
case 46:	case 46:
#line 270 "compile.y"	#line 286 "compile.y"
{	{
yyval=yyvsp[-1]; /* stack: context,name */	yyval=yyvsp[-1]; /* stack: context,name */
P(yyval, yyvsp[0]); /* stack: context,name,constructor_value */	P(yyval, yyvsp[0]); /* stack: context,name,constructor_value */
;	;
break;}	break;}
case 50:	case 50:
#line 278 "compile.y"	#line 294 "compile.y"
{	{
yyval=N(POOL);	yyval=N();
Array *diving_code=yyvsp[0];	ArrayOperationPtr diving_code=yyvsp[0];
const String *first_name=LA2S(diving_code);	ConstStringPtr first_name=LA2S(*diving_code);
	// $self.xxx... -> $xxx...
	// OP_VALUE+string+OP_GET_ELEMENT+... -> OP_WITH_SELF+...
if(first_name && *first_name==SELF_ELEMENT_NAME) {	if(first_name && *first_name==SELF_ELEMENT_NAME) {
O(yyval, OP_WITH_SELF); /* stack: starting context */	O(yyval, OP_WITH_SELF); / stack: starting context */
P(yyval, diving_code,	P(yyval, diving_code,
/* skip over... */	/* skip over... */
diving_code->size()>2?3/OP_+string+get_element/:2/OP_+string/);	diving_code->count()>=3?3/OP_VALUE+string+OP_GET_ELEMENTx/:2/OP_+string/);
} else {	} else {
O(yyval, OP_WITH_ROOT); /* stack: starting context */	O(yyval, OP_WITH_ROOT); / stack: starting context */
P(yyval, diving_code);	P(yyval, diving_code);
}	}
/* diving code; stack: current context */	/* diving code; stack: current context */
;	;
break;}	break;}
case 51:	case 51:
#line 293 "compile.y"	#line 311 "compile.y"
{	{
yyval=N(POOL);	yyval=N();
O(yyval, OP_WITH_WRITE); /* stack: starting context */	O(yyval, OP_WITH_WRITE); / stack: starting context */
P(yyval, yyvsp[0]); /* diving code; stack: context,name */	P(yyval, yyvsp[0]); /* diving code; stack: context,name */
;	;
break;}	break;}
case 52:	case 52:
#line 298 "compile.y"	#line 316 "compile.y"
{ yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;	{ yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;
break;}	break;}
case 56:	case 56:
#line 305 "compile.y"	#line 323 "compile.y"
{	{
// stack: context, name	// stack: context, name
yyval=yyvsp[-1]; // stack: context, name, value	yyval=yyvsp[-1]; // stack: context, name, value
O(yyval, OP_CONSTRUCT_VALUE); /* value=pop; name=pop; context=pop; construct(context,name,value) */	O(yyval, OP_CONSTRUCT_VALUE); / value=pop; name=pop; context=pop; construct(context,name,value) */
;	;
break;}	break;}
case 57:	case 57:
#line 311 "compile.y"	#line 329 "compile.y"
{	{
	yyval=N();
	O(*yyval, OP_PREPARE_TO_EXPRESSION);
// stack: context, name	// stack: context, name
yyval=yyvsp[-1]; // stack: context, name, value	P(yyval, yyvsp[-1]); // stack: context, name, value
O(yyval, OP_CONSTRUCT_EXPR); /* value=pop; name=pop; context=pop; construct(context,name,value) */	O(yyval, OP_CONSTRUCT_EXPR); / value=pop->as_expr_result; name=pop; context=pop; construct(context,name,value) */
;	;
break;}	break;}
case 58:	case 58:
#line 317 "compile.y"	#line 337 "compile.y"
{	{
// stack: context, name	// stack: context, name
yyval=N(POOL);	yyval=N();
CCA(yyval, yyvsp[-1]); /* code=pop; name=pop; context=pop; construct(context,name,junction(code)) */	OA(yyval, OP_CURLY_CODE__CONSTRUCT, yyvsp[-1]); / code=pop; name=pop; context=pop; construct(context,name,junction(code)) */
;	;
break;}	break;}
case 62:	case 62:
#line 328 "compile.y"	#line 348 "compile.y"
{	{
yyval=N(POOL);	yyval=N();
O(yyval, OP_CREATE_EWPOOL); /* stack: empty write context */	OA(yyval, OP_OBJECT_POOL, yyvsp[0]); / stack: empty write context */
P(yyval, yyvsp[0]); /* some code that writes to that context */	/* some code that writes to that context */
O(yyval, OP_REDUCE_EWPOOL); /* context=pop; stack: context.value() */	/* context=pop; stack: context.value() */
;	;
break;}	break;}
case 65:	case 65:
#line 335 "compile.y"	#line 355 "compile.y"
{ yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;	{ yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;
break;}	break;}
case 66:	case 66:
#line 339 "compile.y"	#line 359 "compile.y"
{	{
yyval=yyvsp[0]; /* stack: value */	yyval=yyvsp[0]; /* stack: value */
O(yyval, OP_WRITE_VALUE); /* value=pop; wcontext.write(value) */	changetail_or_append(*yyval,
	OP_CALL, true, /->/ OP_CALL__WRITE,
	/or /OP_WRITE_VALUE); /* value=pop; wcontext.write(value) */
;	;
break;}	break;}
case 67:	case 67:
#line 343 "compile.y"	#line 365 "compile.y"
{ PC.object_constructor_allowed=true ;	{
	PC.in_call_value=true;
	;
break;}	break;}
case 68:	case 68:
#line 344 "compile.y"	#line 368 "compile.y"
{ PC.object_constructor_allowed=false ;	{
	PC.in_call_value=false;
	;
break;}	break;}
case 69:	case 69:
#line 345 "compile.y"	#line 371 "compile.y"
{ /* ^field.$method{vasya} */	{ /* ^field.$method{vasya} */
yyval=yyvsp[-3]; /* with_xxx,diving code; stack: context,method_junction */	yyval=yyvsp[-3]; /* with_xxx,diving code; stack: context,method_junction */
O(yyval, OP_GET_METHOD_FRAME); /* stack: context,method_frame */

YYSTYPE params_code=yyvsp[-1];	YYSTYPE params_code=yyvsp[-1];
if(params_code->size()==3) // probably [] case. [OP_VALUE + Void + STORE_PARAM]	if(params_code->count()==3) { // probably [] case. [OP_VALUE + Void + STORE_PARAM]
if(Value *value=LA2V(params_code)) // it is OP_VALUE + value?	if(ValuePtr value=LA2V(*params_code)) // it is OP_VALUE + value?
if(!value->is_defined()) // value is VVoid?	if(!value->is_defined()) // value is VVoid?
params_code=0; // ^zzz[] case. don't append lone empty param.	params_code=YYSTYPE(0); // ^zzz[] case. don't append lone empty param.
if(params_code)	}
P(yyval, params_code); // filling method_frame.store_params	/* stack: context, method_junction */
O(yyval, OP_CALL); // method_frame=pop; ncontext=pop; call(ncontext,method_frame) stack: value	OA(*yyval, OP_CALL, params_code); // method_frame=make frame(pop junction); ncontext=pop; call(ncontext,method_frame) stack: value
;	;
break;}	break;}
case 72:	case 72:
#line 361 "compile.y"	#line 386 "compile.y"
{ yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;	{ yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;
break;}	break;}
case 76:	case 76:
#line 367 "compile.y"	#line 392 "compile.y"
{yyval=yyvsp[-1];	{yyval=yyvsp[-1];
break;}	break;}
case 77:	case 77:
#line 368 "compile.y"	#line 393 "compile.y"
{yyval=yyvsp[-1];	{yyval=yyvsp[-1];
break;}	break;}
case 78:	case 78:
#line 369 "compile.y"	#line 394 "compile.y"
{yyval=yyvsp[-1];	{yyval=yyvsp[-1];
break;}	break;}
case 80:	case 80:
#line 372 "compile.y"	#line 397 "compile.y"
{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]) ;	{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]) ;
break;}	break;}
case 82:	case 82:
#line 376 "compile.y"	#line 401 "compile.y"
{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]) ;	{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]) ;
break;}	break;}
case 84:	case 84:
#line 380 "compile.y"	#line 405 "compile.y"
{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]) ;	{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]) ;
break;}	break;}
case 85:	case 85:
#line 382 "compile.y"	#line 407 "compile.y"
{	{
yyval=yyvsp[0];	yyval=yyvsp[0];
O(yyval, OP_STORE_PARAM);	O(*yyval, OP_STORE_PARAM);
;	;
break;}	break;}
case 86:	case 86:
#line 386 "compile.y"	#line 411 "compile.y"
{	{
yyval=N(POOL);	yyval=N();
PEA(yyval, yyvsp[0]);	OA(*yyval, OP_EXPR_CODE__STORE_PARAM, yyvsp[0]);
;	;
break;}	break;}
case 87:	case 87:
#line 390 "compile.y"	#line 415 "compile.y"
{	{
yyval=N(POOL);	yyval=N();
PCA(yyval, yyvsp[0]);	OA(*yyval, OP_CURLY_CODE__STORE_PARAM, yyvsp[0]);
;	;
break;}	break;}
case 91:	case 91:
#line 399 "compile.y"	#line 424 "compile.y"
{	{
yyval=yyvsp[0];	yyval=N();
O(yyval, OP_WRITE_EXPR_RESULT);	O(*yyval, OP_PREPARE_TO_EXPRESSION);
	P(yyval, yyvsp[0]);
	O(*yyval, OP_WRITE_EXPR_RESULT);
;	;
break;}	break;}
case 93:	case 93:
#line 406 "compile.y"	#line 433 "compile.y"
{ yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;	{ yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;
break;}	break;}
case 95:	case 95:
#line 408 "compile.y"	#line 435 "compile.y"
{ yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;	{ yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;
break;}	break;}
case 97:	case 97:
#line 410 "compile.y"	#line 437 "compile.y"
{	{
	// 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

/* stack: context */	/* stack: context */
yyval=yyvsp[0]; /* stack: context,name */	yyval=yyvsp[0]; /* stack: context,name */
O(yyval, OP_GET_ELEMENT); /* name=pop; context=pop; stack: context.get_element(name) */	O(yyval, OP_GET_ELEMENT); / name=pop; context=pop; stack: context.get_element(name) */
;	;
break;}	break;}
case 98:	case 98:
#line 415 "compile.y"	#line 445 "compile.y"
{	{
/* stack: context */	/* stack: context */
yyval=yyvsp[0]; /* stack: context,name */	yyval=yyvsp[0]; /* stack: context,name */
O(yyval, OP_GET_ELEMENT); /* name=pop; context=pop; stack: context.get_element(name) */	O(yyval, OP_GET_ELEMENT); / name=pop; context=pop; stack: context.get_element(name) */
;	;
break;}	break;}
case 104:	case 104:
#line 428 "compile.y"	#line 458 "compile.y"
{	{
yyval=yyvsp[0];	yyval=yyvsp[0];
O(yyval, OP_GET_ELEMENT);	O(*yyval, OP_GET_ELEMENT);
;	;
break;}	break;}
case 105:	case 105:
#line 432 "compile.y"	#line 462 "compile.y"
{	{
yyval=N(POOL);	ArrayOperationPtr code;
O(yyval, OP_CREATE_EWPOOL);	{
P(yyval, yyvsp[-1]);	change_string_literal_to_write_string_literal(*(code=yyvsp[-1]));
O(yyval, OP_WRITE_VALUE);	P(code, yyvsp[0]);
P(yyval, yyvsp[0]);	}
O(yyval, OP_REDUCE_EWPOOL);	yyval=N();
	OA(*yyval, OP_STRING_POOL, code);
;	;
break;}	break;}
case 106:	case 106:
#line 440 "compile.y"	#line 471 "compile.y"
{	{
yyval=N(POOL);	yyval=N();
O(yyval, OP_CREATE_EWPOOL);	OA(yyval, OP_OBJECT_POOL, yyvsp[-1]); / stack: empty write context */
P(yyval, yyvsp[-1]);	/* some code that writes to that context */
O(yyval, OP_REDUCE_EWPOOL);	/* context=pop; stack: context.value() */
;	;
break;}	break;}
case 107:	case 107:
#line 446 "compile.y"	#line 477 "compile.y"
{	{
yyval=N(POOL);	yyval=N();
O(yyval, OP_WITH_READ);	O(*yyval, OP_WITH_READ);
P(yyval, yyvsp[0]);	P(yyval, yyvsp[0]);
;	;
break;}	break;}
case 109:	case 109:
#line 451 "compile.y"	#line 482 "compile.y"
{ yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;	{ yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;
break;}	break;}
case 110:	case 110:
#line 452 "compile.y"	#line 483 "compile.y"
{	{
yyval=yyvsp[0];	yyval=yyvsp[0];
O(yyval, OP_GET_ELEMENT__WRITE);	O(*yyval, OP_GET_ELEMENT__WRITE);
;	;
break;}	break;}
case 113:	case 113:
#line 461 "compile.y"	#line 492 "compile.y"
{	{
yyval=yyvsp[-1]; // stack: class name string	yyval=yyvsp[-1]; // stack: class name string
O(yyval, OP_GET_CLASS);	if(LA2S(yyval) == BASE_NAME) { // pseude BASE class
	if(VStateless_classPtr base=PC.cclass->base_class()) {
	change_string_literal_value(*yyval, base->name());
	} else {
	strcpy(PC.error, "no base class declared");
	YYERROR;
	}
	}
	O(*yyval, OP_GET_CLASS);
;	;
break;}	break;}
case 114:	case 114:
#line 465 "compile.y"	#line 504 "compile.y"
{	{
yyval=yyvsp[-1];	yyval=yyvsp[-1];
if(!PC.object_constructor_allowed) {	if(!PC.in_call_value) {
strcpy(PC.error, ":: not allowed here");	strcpy(PC.error, ":: not allowed here");
YYERROR;	YYERROR;
}	}
O(yyval, OP_PREPARE_TO_CONSTRUCT_OBJECT);	O(*yyval, OP_PREPARE_TO_CONSTRUCT_OBJECT);
;	;
break;}	break;}
case 115:	case 115:
#line 477 "compile.y"	#line 516 "compile.y"
{	{
if((yyval=yyvsp[0])->size()==2) // only one string literal in there?	// see OP_PREPARE_TO_EXPRESSION!!
change_string_literal_to_double_literal(yyval); // make that string literal Double	if((yyval=yyvsp[0])->count()==2) // only one string literal in there?
	change_string_literal_to_double_literal(*yyval); // make that string literal Double
;	;
break;}	break;}
case 119:	case 119:
#line 485 "compile.y"	#line 525 "compile.y"
{ yyval = yyvsp[-1]; ;	{ yyval = yyvsp[-1]; ;
break;}	break;}
case 120:	case 120:
#line 486 "compile.y"	#line 526 "compile.y"
{ yyval = yyvsp[-1]; ;	{ yyval = yyvsp[-1]; ;
break;}	break;}
case 121:	case 121:
#line 487 "compile.y"	#line 527 "compile.y"
{ yyval = yyvsp[-1]; ;	{ yyval = yyvsp[-1]; ;
break;}	break;}
case 122:	case 122:
#line 489 "compile.y"	#line 529 "compile.y"
{ yyval=yyvsp[0]; O(yyval, OP_NEG) ;	{ yyval=yyvsp[0]; O(*yyval, OP_NEG) ;
break;}	break;}
case 123:	case 123:
#line 490 "compile.y"	#line 530 "compile.y"
{ yyval=yyvsp[0]; O(yyval, OP_INV) ;	{ yyval=yyvsp[0] ;
break;}	break;}
case 124:	case 124:
#line 491 "compile.y"	#line 531 "compile.y"
{ yyval=yyvsp[0]; O(yyval, OP_NOT) ;	{ yyval=yyvsp[0]; O(*yyval, OP_INV) ;
break;}	break;}
case 125:	case 125:
#line 492 "compile.y"	#line 532 "compile.y"
{ yyval=yyvsp[0]; O(yyval, OP_DEF) ;	{ yyval=yyvsp[0]; O(*yyval, OP_NOT) ;
break;}	break;}
case 126:	case 126:
#line 493 "compile.y"	#line 533 "compile.y"
{ yyval=yyvsp[0]; O(yyval, OP_IN) ;	{ yyval=yyvsp[0]; O(*yyval, OP_DEF) ;
break;}	break;}
case 127:	case 127:
#line 494 "compile.y"	#line 534 "compile.y"
{ yyval=yyvsp[0]; O(yyval, OP_FEXISTS) ;	{ yyval=yyvsp[0]; O(*yyval, OP_IN) ;
break;}	break;}
case 128:	case 128:
#line 495 "compile.y"	#line 535 "compile.y"
{ yyval=yyvsp[0]; O(yyval, OP_DEXISTS) ;	{ yyval=yyvsp[0]; O(*yyval, OP_FEXISTS) ;
break;}	break;}
case 129:	case 129:
#line 497 "compile.y"	#line 536 "compile.y"
{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_SUB) ;	{ yyval=yyvsp[0]; O(*yyval, OP_DEXISTS) ;
break;}	break;}
case 130:	case 130:
#line 498 "compile.y"	#line 538 "compile.y"
{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_ADD) ;	{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(*yyval, OP_SUB) ;
break;}	break;}
case 131:	case 131:
#line 499 "compile.y"	#line 539 "compile.y"
{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_MUL) ;	{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(*yyval, OP_ADD) ;
break;}	break;}
case 132:	case 132:
#line 500 "compile.y"	#line 540 "compile.y"
{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_DIV) ;	{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(*yyval, OP_MUL) ;
break;}	break;}
case 133:	case 133:
#line 501 "compile.y"	#line 541 "compile.y"
{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_MOD) ;	{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(*yyval, OP_DIV) ;
break;}	break;}
case 134:	case 134:
#line 502 "compile.y"	#line 542 "compile.y"
{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_BIN_AND) ;	{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(*yyval, OP_MOD) ;
break;}	break;}
case 135:	case 135:
#line 503 "compile.y"	#line 543 "compile.y"
{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_BIN_OR) ;	{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(*yyval, OP_INTDIV) ;
break;}	break;}
case 136:	case 136:
#line 504 "compile.y"	#line 544 "compile.y"
{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_BIN_XOR) ;	{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(*yyval, OP_BIN_SL) ;
break;}	break;}
case 137:	case 137:
#line 505 "compile.y"	#line 545 "compile.y"
{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_LOG_AND) ;	{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(*yyval, OP_BIN_SR) ;
break;}	break;}
case 138:	case 138:
#line 506 "compile.y"	#line 546 "compile.y"
{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_LOG_OR) ;	{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(*yyval, OP_BIN_AND) ;
break;}	break;}
case 139:	case 139:
#line 507 "compile.y"	#line 547 "compile.y"
{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_LOG_XOR) ;	{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(*yyval, OP_BIN_OR) ;
break;}	break;}
case 140:	case 140:
#line 508 "compile.y"	#line 548 "compile.y"
{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_NUM_LT) ;	{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(*yyval, OP_BIN_XOR) ;
break;}	break;}
case 141:	case 141:
#line 509 "compile.y"	#line 549 "compile.y"
{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_NUM_GT) ;	{ yyval=yyvsp[-2]; OA(yyval, OP_NESTED_CODE, yyvsp[0]); O(yyval, OP_LOG_AND) ;
break;}	break;}
case 142:	case 142:
#line 510 "compile.y"	#line 550 "compile.y"
{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_NUM_LE) ;	{ yyval=yyvsp[-2]; OA(yyval, OP_NESTED_CODE, yyvsp[0]); O(yyval, OP_LOG_OR) ;
break;}	break;}
case 143:	case 143:
#line 511 "compile.y"	#line 551 "compile.y"
{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_NUM_GE) ;	{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(*yyval, OP_LOG_XOR) ;
break;}	break;}
case 144:	case 144:
#line 512 "compile.y"	#line 552 "compile.y"
{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_NUM_EQ) ;	{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(*yyval, OP_NUM_LT) ;
break;}	break;}
case 145:	case 145:
#line 513 "compile.y"	#line 553 "compile.y"
{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_NUM_NE) ;	{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(*yyval, OP_NUM_GT) ;
break;}	break;}
case 146:	case 146:
#line 514 "compile.y"	#line 554 "compile.y"
{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_STR_LT) ;	{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(*yyval, OP_NUM_LE) ;
break;}	break;}
case 147:	case 147:
#line 515 "compile.y"	#line 555 "compile.y"
{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_STR_GT) ;	{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(*yyval, OP_NUM_GE) ;
break;}	break;}
case 148:	case 148:
#line 516 "compile.y"	#line 556 "compile.y"
{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_STR_LE) ;	{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(*yyval, OP_NUM_EQ) ;
break;}	break;}
case 149:	case 149:
#line 517 "compile.y"	#line 557 "compile.y"
{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_STR_GE) ;	{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(*yyval, OP_NUM_NE) ;
break;}	break;}
case 150:	case 150:
#line 518 "compile.y"	#line 558 "compile.y"
{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_STR_EQ) ;	{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(*yyval, OP_STR_LT) ;
break;}	break;}
case 151:	case 151:
#line 519 "compile.y"	#line 559 "compile.y"
{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_STR_NE) ;	{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(*yyval, OP_STR_GT) ;
break;}	break;}
case 152:	case 152:
#line 520 "compile.y"	#line 560 "compile.y"
{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_IS) ;	{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(*yyval, OP_STR_LE) ;
break;}	break;}
case 153:	case 153:
#line 523 "compile.y"	#line 561 "compile.y"
	{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(*yyval, OP_STR_GE) ;
	break;}
	case 154:
	#line 562 "compile.y"
	{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(*yyval, OP_STR_EQ) ;
	break;}
	case 155:
	#line 563 "compile.y"
	{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(*yyval, OP_STR_NE) ;
	break;}
	case 156:
	#line 564 "compile.y"
	{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(*yyval, OP_IS) ;
	break;}
	case 157:
	#line 567 "compile.y"
{	{
yyval=N(POOL);	yyval=N();
O(yyval, OP_CREATE_SWPOOL); /* stack: empty write context */	OA(yyval, OP_STRING_POOL, yyvsp[0]); / stack: empty write context */
P(yyval, yyvsp[0]); /* some code that writes to that context */	/* some code that writes to that context */
O(yyval, OP_REDUCE_SWPOOL); /* context=pop; stack: context.get_string() */	/* context=pop; stack: context.get_string() */
;	;
break;}	break;}
case 154:	case 158:
#line 532 "compile.y"	#line 576 "compile.y"
{	{
// optimized from OP_STRING+OP_WRITE_VALUE to OP_STRING__WRITE	// optimized from OP_STRING+OP_WRITE_VALUE to OP_STRING__WRITE
change_string_literal_to_write_string_literal(yyval=yyvsp[0])	change_string_literal_to_write_string_literal(*(yyval=yyvsp[0]))
;	;
break;}	break;}
case 155:	case 159:
#line 537 "compile.y"	#line 581 "compile.y"
{ yyval=VL(NEW VVoid(POOL)) ;	{ yyval=VL(ValuePtr(new VVoid())) ;
break;}	break;}
case 156:	case 160:
#line 538 "compile.y"	#line 582 "compile.y"
{ yyval=N(POOL) ;	{ yyval=N() ;
break;}	break;}
}	}
/* the action file gets copied in in place of this dollarsign */	/* the action file gets copied in in place of this dollarsign */
#line 543 "D:/cygwin/usr/share/bison.simple"	#line 543 "/usr/share/bison.simple"

yyvsp -= yylen;	yyvsp -= yylen;
yyssp -= yylen;	yyssp -= yylen;
Line 1804 yyerrhandle:	Line 1883 yyerrhandle:
}	}
return 1;	return 1;
}	}
#line 540 "compile.y"	#line 584 "compile.y"

#endif	#endif

Line 1825 yyerrhandle:	Line 1904 yyerrhandle:
*/	*/

static int yylex(YYSTYPE lvalp, void pc) {	static int yylex(YYSTYPE lvalp, void pc) {
#define lexical_brackets_nestage PC.brackets_nestages[PC.sp]	#define lexical_brackets_nestage PC.brackets_nestages[PC.ls_sp]
#define RC {result=c; goto break2; }	#define RC {result=c; goto break2; }

register int c;	register int c;
Line 1843 static int yylex(YYSTYPE lvalp, void p	Line 1922 static int yylex(YYSTYPE lvalp, void p
int skip_analized=0;	int skip_analized=0;
while(true) {	while(true) {
c=*(end=(PC.source++));	c=*(end=(PC.source++));
	// fprintf(stderr, "\nchar: %c %02X; nestage: %d, sp=%d", c, c, lexical_brackets_nestage, PC.sp);

if(c=='\n') {	if(c=='\n') {
PC.line++;	PC.line++;
Line 1850 static int yylex(YYSTYPE lvalp, void p	Line 1930 static int yylex(YYSTYPE lvalp, void p
} else	} else
PC.col++;	PC.col++;

if(c=='^' && PC.ls!=LS_COMMENT && PC.ls!=LS_DEF_COMMENT)	if(c=='@' && PC.col==0+1) {
	if(PC.ls==LS_DEF_SPECIAL_BODY) {
	// @SPECIAL
	// ...
	// @<here =
	pop_LS(PC); // exiting from LS_DEF_SPECIAL_BODY state
	} // continuing checks
	if(PC.ls==LS_USER) {
	push_LS(PC, LS_DEF_NAME);
	RC;
	} else // @ in first column inside some code [when could that be?]
	result=BAD_METHOD_DECL_START;
	goto break2;
	} else if(c=='^') {
	if(PC.ls==LS_METHOD_AFTER) {
	// handle after-method situation
	pop_LS(PC);
	result=EON;
	skip_analized=-1; // return to punctuation afterwards to assure it's literality
	goto break2;
	}
	switch(PC.ls) {
	case LS_EXPRESSION_VAR_NAME_WITH_COLON:
	case LS_EXPRESSION_VAR_NAME_WITHOUT_COLON:
	case LS_VAR_NAME_SIMPLE_WITH_COLON:
	case LS_VAR_NAME_SIMPLE_WITHOUT_COLON:
	case LS_VAR_NAME_CURLY:
	case LS_METHOD_NAME:
	case LS_USER_COMMENT:
	case LS_DEF_COMMENT:
	// no literals in names, please
	break;
	default:
switch(*PC.source) {	switch(*PC.source) {
// escaping: ^^ & co	// ^escaping some punctuators
case '^': case '$': case ';':	case '^': case '$': case ';':
case '(': case ')':	case '(': case ')':
case '[': case ']':	case '[': case ']':
case '{': case '}':	case '{': case '}':
case '"':	case '"': case ':':
if(end!=begin) {	if(end!=begin) {
// append piece till ^	// append piece till ^
PC.string->APPEND_CLEAN(begin, end-begin, PC.file, begin_line);	PC.string->APPEND_CLEAN(begin, end-begin, PC.file, begin_line);
}	}
// reset piece 'begin' position & line	// reset piece 'begin' position & line
begin=PC.source; // ^	begin=PC.source; // ->punctuation
begin_line=PC.line;	begin_line=PC.line;
// skip over ^ and _	// skip over _ after ^
PC.source++; PC.col++;	PC.source++; PC.col++;
// skip analysis = forced literal	// skip analysis = forced literal
continue;	continue;
Line 1892 static int yylex(YYSTYPE lvalp, void p	Line 2004 static int yylex(YYSTYPE lvalp, void p
PC.source+=3;	PC.source+=3;
PC.col+=3;	PC.col+=3;
// reset piece 'begin' position & line	// reset piece 'begin' position & line
begin=PC.source; // ^	begin=PC.source; // ->after ^#HH
begin_line=PC.line;	begin_line=PC.line;
	// skip analysis = forced literal
continue;	continue;
}	}
break;	break;
}	}
	break;
	}
	}
// #comment start skipping	// #comment start skipping
if(c=='#' && PC.col==1) {	if(c=='#' && PC.col==1) {
if(end!=begin) {	if(end!=begin) {
Line 1905 static int yylex(YYSTYPE lvalp, void p	Line 2021 static int yylex(YYSTYPE lvalp, void p
PC.string->APPEND_CLEAN(begin, end-begin, PC.file, begin_line);	PC.string->APPEND_CLEAN(begin, end-begin, PC.file, begin_line);
}	}
// fall into COMMENT lexical state [wait for \n]	// fall into COMMENT lexical state [wait for \n]
push_LS(PC, LS_COMMENT);	push_LS(PC, LS_USER_COMMENT);
	continue;
}	}
switch(PC.ls) {	switch(PC.ls) {

// USER'S = NOT OURS	// USER'S = NOT OURS
case LS_USER:	case LS_USER:
	case LS_NAME_SQUARE_PART: // name.[here].xxx
if(PC.trim_bof)	if(PC.trim_bof)
switch(c) {	switch(c) {
case '\n': case ' ': case '\t':	case '\n': case ' ': case '\t':
Line 1922 static int yylex(YYSTYPE lvalp, void p	Line 2040 static int yylex(YYSTYPE lvalp, void p
}	}
switch(c) {	switch(c) {
case '$':	case '$':
push_LS(PC, LS_VAR_NAME_SIMPLE);	push_LS(PC, LS_VAR_NAME_SIMPLE_WITH_COLON);
RC;	RC;
case '^':	case '^':
push_LS(PC, LS_METHOD_NAME);	push_LS(PC, LS_METHOD_NAME);
RC;	RC;
case '@':	case ']':
if(PC.col==0+1) {	if(PC.ls==LS_NAME_SQUARE_PART)
push_LS(PC, LS_DEF_NAME);	if(--lexical_brackets_nestage==0) {// $name.[co<]?>de<]?>
RC;	pop_LS(PC); // $name.[co<]>de<]!>
}	RC;
	}
break;	break;
case ')': // $name.(code<)>	case '[': // $name.[co<[>de]
if(--lexical_brackets_nestage==0) {	if(PC.ls==LS_NAME_SQUARE_PART)
pop_LS(PC);	lexical_brackets_nestage++;
RC;
}
break;	break;
}	}
break;	break;

// #COMMENT	// #COMMENT
case LS_COMMENT:	case LS_USER_COMMENT:
if(c=='\n') {	if(c=='\n') {
// skip comment	// skip comment
begin=PC.source;	begin=PC.source;
Line 1968 static int yylex(YYSTYPE lvalp, void p	Line 2085 static int yylex(YYSTYPE lvalp, void p
}	}
break;	break;
case '$':	case '$':
push_LS(PC, LS_VAR_NAME_SIMPLE);	push_LS(PC, LS_VAR_NAME_SIMPLE_WITH_COLON);
RC;	RC;
case '^':	case '^':
push_LS(PC, LS_METHOD_NAME);	push_LS(PC, LS_METHOD_NAME);
Line 1990 static int yylex(YYSTYPE lvalp, void p	Line 2107 static int yylex(YYSTYPE lvalp, void p

case LS_DEF_PARAMS:	case LS_DEF_PARAMS:
switch(c) {	switch(c) {
	case '$': // common error
	result=BAD_METHOD_PARAMETER_NAME_CHARACTER;
	goto break2;
case ';':	case ';':
RC;	RC;
case ']':	case ']':
Line 2023 static int yylex(YYSTYPE lvalp, void p	Line 2143 static int yylex(YYSTYPE lvalp, void p
break;	break;

case LS_DEF_SPECIAL_BODY:	case LS_DEF_SPECIAL_BODY:
// @todo in case	if(c=='\n')
// ################
// @next-method
// we are here with c=='@'
// which is wrong, and need action
if(c=='\n') {
switch(*PC.source) {
case '@': case 0: // end of special_code
pop_LS(PC);
break;
}
RC;	RC;
}
break;	break;

// (EXPRESSION)	// (EXPRESSION)
Line 2049 static int yylex(YYSTYPE lvalp, void p	Line 2158 static int yylex(YYSTYPE lvalp, void p
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
	if(end!=begin) {
	// append piece till #
	PC.string->APPEND_CLEAN(begin, end-begin, PC.file, begin_line);
	}
	// fall into COMMENT lexical state [wait for \n]
	push_LS(PC, LS_EXPRESSION_COMMENT);
	lexical_brackets_nestage=1;
	continue;
case '$':	case '$':
push_LS(PC, LS_EXPRESSION_VAR_NAME);	push_LS(PC, LS_EXPRESSION_VAR_NAME_WITH_COLON);
RC;	RC;
case '^':	case '^':
push_LS(PC, LS_METHOD_NAME);	push_LS(PC, LS_METHOD_NAME);
Line 2068 static int yylex(YYSTYPE lvalp, void p	Line 2186 static int yylex(YYSTYPE lvalp, void p
skip_analized=1;	skip_analized=1;
result=DEXISTS;	result=DEXISTS;
goto break2;	goto break2;
default:	default: // minus
result=c;	result=c;
goto break2;	goto break2;
}	}
goto break2;	goto break2;
case '+': case '*': case '/': case '%':	case '+': case '*': case '/': case '%': case '\\':
case '~':	case '~':
case ';':	case ';':
RC;	RC;
case '&': case '\|': case '#':	case '&': case '\|':
if(*PC.source==c) { // && \|\|	if(*PC.source==c) { // && \|\|
result=c=='#'?LXOR:c=='&'?LAND:LOR;	result=c=='&'?LAND:LOR;
skip_analized=1;	skip_analized=1;
} else	} else
result=c;	result=c;
goto break2;	goto break2;
case '<': case '>': case '=': case '!':	case '!':
if(*PC.source=='=') { // <= >= == !=	switch(PC.source[0]) {
	case '\|': // !\| !\|\|
skip_analized=1;	skip_analized=1;
switch(c) {	if(PC.source[1]=='\|') {
case '<': result=NLE; break;	skip_analized++;
case '>': result=NGE; break;	result=LXOR;
case '=': result=NEQ; break;	} else
case '!': result=NNE; break;	result=NXOR;
}	goto break2;
} else	case '=': // !=
result=c;	skip_analized=1;
	result=NNE;
	goto break2;
	}
	RC;

	case '<': // <<, <=, <
	switch(*PC.source) {
	case '<': // <[<]
	skip_analized=1; result=NSL; break;
	case '=': // <[=]
	skip_analized=1; result=NLE; break;
	default: // <[]
	result=c; break;
	}
goto break2;	goto break2;
	case '>': // >>, >=, >
	switch(*PC.source) {
	case '>': // >[>]
	skip_analized=1; result=NSR; break;
	case '=': // >[=]
	skip_analized=1; result=NGE; break;
	default: // >[]
	result=c; break;
	}
	goto break2;
	case '=': // ==
	switch(*PC.source) {
	case '=': // =[=]
	skip_analized=1; result=NEQ; break;
	default: // =[]
	result=c; break; // not used now
	}
	goto break2;

case '"':	case '"':
push_LS(PC, LS_EXPRESSION_STRING_QUOTED);	push_LS(PC, LS_EXPRESSION_STRING_QUOTED);
RC;	RC;
Line 2158 static int yylex(YYSTYPE lvalp, void p	Line 2310 static int yylex(YYSTYPE lvalp, void p
continue;	continue;
}	}
break;	break;
	case LS_EXPRESSION_COMMENT:
	if(c=='(')
	lexical_brackets_nestage++;

	switch(*PC.source) {
	case '\n': case ')':
	if(*PC.source==')')
	if(--lexical_brackets_nestage!=0)
	continue;

	// skip comment
	begin=PC.source;
	begin_line=PC.line;

	pop_LS(PC);
	continue;
	}
	break;

// VARIABLE GET/PUT/WITH	// VARIABLE GET/PUT/WITH
case LS_VAR_NAME_SIMPLE:	case LS_VAR_NAME_SIMPLE_WITH_COLON:
case LS_EXPRESSION_VAR_NAME:	case LS_VAR_NAME_SIMPLE_WITHOUT_COLON:
case LS_VAR_NAME_NO_COLON:	case LS_EXPRESSION_VAR_NAME_WITH_COLON:
if(PC.ls==LS_EXPRESSION_VAR_NAME) {	case LS_EXPRESSION_VAR_NAME_WITHOUT_COLON:
// name in expr ends also before binary operators	if(
	PC.ls==LS_EXPRESSION_VAR_NAME_WITH_COLON \|\|
	PC.ls==LS_EXPRESSION_VAR_NAME_WITHOUT_COLON) {
	// name in expr ends also before
switch(c) {	switch(c) {
	// expression minus
case '-':	case '-':
	// expression integer division
	case '\\':
pop_LS(PC);	pop_LS(PC);
PC.source--; if(--PC.col<0) { PC.line--; PC.col=-1; }	PC.source--; if(--PC.col<0) { PC.line--; PC.col=-1; }
result=EON;	result=EON;
goto break2;	goto break2;
}	}
}	}
if(PC.ls==LS_VAR_NAME_NO_COLON) {	if(
	PC.ls==LS_VAR_NAME_SIMPLE_WITHOUT_COLON \|\|
	PC.ls==LS_EXPRESSION_VAR_NAME_WITHOUT_COLON) {
// name already has ':', stop before next	// name already has ':', stop before next
switch(c) {	switch(c) {
case ':':	case ':':
Line 2194 static int yylex(YYSTYPE lvalp, void p	Line 2372 static int yylex(YYSTYPE lvalp, void p
case '&': case '\|':	case '&': case '\|':
case '=': case '!':	case '=': case '!':
// common delimiters	// common delimiters
case ',': case '?':	case ',': case '?': case '#':
// before call	// before call
case '^':	case '^':
pop_LS(PC);	pop_LS(PC);
Line 2202 static int yylex(YYSTYPE lvalp, void p	Line 2380 static int yylex(YYSTYPE lvalp, void p
result=EON;	result=EON;
goto break2;	goto break2;
case '[':	case '[':
	// $name.<[>code]
	if(PC.col>1/not first column/ && (
	end[-1]=='$'/was start of get/ \|\|
	end[-1]==':'/was class name delim / \|\|
	end[-1]=='.'/was name delim /
	)) {
	push_LS(PC, LS_NAME_SQUARE_PART);
	lexical_brackets_nestage=1;
	RC;
	}
PC.ls=LS_VAR_SQUARE;	PC.ls=LS_VAR_SQUARE;
lexical_brackets_nestage=1;	lexical_brackets_nestage=1;
RC;	RC;
Line 2215 static int yylex(YYSTYPE lvalp, void p	Line 2403 static int yylex(YYSTYPE lvalp, void p

RC;	RC;
case '(':	case '(':
// $name.<(>code)
if(PC.col>1/not first column/ && end[-1]=='.'/was dot /) {
push_LS(PC, LS_USER);
lexical_brackets_nestage=1;
RC;
}
PC.ls=LS_VAR_ROUND;	PC.ls=LS_VAR_ROUND;
lexical_brackets_nestage=1;	lexical_brackets_nestage=1;
RC;	RC;
case '.': // name part delim	case '.': // name part delim
case '$': // name part subvar	case '$': // name part subvar
case ':': // class<:>name	case ':': // class<:>name
PC.ls=LS_VAR_NAME_NO_COLON; // stop before next ':'	// go to _WITHOUT_COLON state variant...
	if(PC.ls==LS_VAR_NAME_SIMPLE_WITH_COLON)
	PC.ls=LS_VAR_NAME_SIMPLE_WITHOUT_COLON;
	else if(PC.ls==LS_EXPRESSION_VAR_NAME_WITH_COLON)
	PC.ls=LS_EXPRESSION_VAR_NAME_WITHOUT_COLON;
	// ...stop before next ':'
RC;	RC;
}	}
break;	break;

case LS_VAR_NAME_CURLY:	case LS_VAR_NAME_CURLY:
switch(c) {	switch(c) {
case '(':	case '[':
// ${name.<(>code)}	// ${name.<[>code]}
push_LS(PC, LS_USER);	push_LS(PC, LS_NAME_SQUARE_PART);
lexical_brackets_nestage=1;	lexical_brackets_nestage=1;
RC;	RC;
case '}': // ${name} finished, restoring LS	case '}': // ${name} finished, restoring LS
Line 2252 static int yylex(YYSTYPE lvalp, void p	Line 2439 static int yylex(YYSTYPE lvalp, void p
case LS_VAR_SQUARE:	case LS_VAR_SQUARE:
switch(c) {	switch(c) {
case '$':	case '$':
push_LS(PC, LS_VAR_NAME_SIMPLE);	push_LS(PC, LS_VAR_NAME_SIMPLE_WITH_COLON);
RC;	RC;
case '^':	case '^':
push_LS(PC, LS_METHOD_NAME);	push_LS(PC, LS_METHOD_NAME);
Line 2274 static int yylex(YYSTYPE lvalp, void p	Line 2461 static int yylex(YYSTYPE lvalp, void p
case LS_VAR_CURLY:	case LS_VAR_CURLY:
switch(c) {	switch(c) {
case '$':	case '$':
push_LS(PC, LS_VAR_NAME_SIMPLE);	push_LS(PC, LS_VAR_NAME_SIMPLE_WITH_COLON);
RC;	RC;
case '^':	case '^':
push_LS(PC, LS_METHOD_NAME);	push_LS(PC, LS_METHOD_NAME);
Line 2295 static int yylex(YYSTYPE lvalp, void p	Line 2482 static int yylex(YYSTYPE lvalp, void p
case LS_METHOD_NAME:	case LS_METHOD_NAME:
switch(c) {	switch(c) {
case '[':	case '[':
	// ^name.<[>code].xxx
	if(PC.col>1/not first column/ && (
	end[-1]=='^'/was start of call/ \|\| // never, ^[ is literal...
	end[-1]==':'/was class name delim / \|\|
	end[-1]=='.'/was name delim /
	)) {
	push_LS(PC, LS_NAME_SQUARE_PART);
	lexical_brackets_nestage=1;
	RC;
	}
PC.ls=LS_METHOD_SQUARE;	PC.ls=LS_METHOD_SQUARE;
lexical_brackets_nestage=1;	lexical_brackets_nestage=1;
RC;	RC;
Line 2303 static int yylex(YYSTYPE lvalp, void p	Line 2500 static int yylex(YYSTYPE lvalp, void p
lexical_brackets_nestage=1;	lexical_brackets_nestage=1;
RC;	RC;
case '(':	case '(':
// $name.<(>code)
if(PC.col>1/not first column/ && end[-1]=='.'/was dot /) {
push_LS(PC, LS_USER);
lexical_brackets_nestage=1;
RC;
}
PC.ls=LS_METHOD_ROUND;	PC.ls=LS_METHOD_ROUND;
lexical_brackets_nestage=1;	lexical_brackets_nestage=1;
RC;	RC;
case '.': // name part delim	case '.': // name part delim
case '$': // name part subvar	case '$': // name part subvar
case ':': // ':name' or 'class:name'	case ':': // ':name' or 'class:name'
	case '^': // ^abc^xxx wrong. bailing out
	case ']': case '}': case ')': // ^abc]}) wrong. bailing out
RC;	RC;
}	}
break;	break;
Line 2322 static int yylex(YYSTYPE lvalp, void p	Line 2515 static int yylex(YYSTYPE lvalp, void p
case LS_METHOD_SQUARE:	case LS_METHOD_SQUARE:
switch(c) {	switch(c) {
case '$':	case '$':
push_LS(PC, LS_VAR_NAME_SIMPLE);	push_LS(PC, LS_VAR_NAME_SIMPLE_WITH_COLON);
RC;	RC;
case '^':	case '^':
push_LS(PC, LS_METHOD_NAME);	push_LS(PC, LS_METHOD_NAME);
Line 2344 static int yylex(YYSTYPE lvalp, void p	Line 2537 static int yylex(YYSTYPE lvalp, void p
case LS_METHOD_CURLY:	case LS_METHOD_CURLY:
switch(c) {	switch(c) {
case '$':	case '$':
push_LS(PC, LS_VAR_NAME_SIMPLE);	push_LS(PC, LS_VAR_NAME_SIMPLE_WITH_COLON);
RC;	RC;
case '^':	case '^':
push_LS(PC, LS_METHOD_NAME);	push_LS(PC, LS_METHOD_NAME);
Line 2398 break2:	Line 2591 break2:
if(end!=begin && end[-1]=='\n') // allow one empty line before LS_DEF_NAME	if(end!=begin && end[-1]=='\n') // allow one empty line before LS_DEF_NAME
end--;	end--;
}	}
if(end!=begin && PC.ls!=LS_COMMENT) { // last piece still alive and not comment?	if(end!=begin && PC.ls!=LS_USER_COMMENT) { // last piece still alive and not comment?
// append it	// append it
PC.string->APPEND_CLEAN(begin, end-begin, PC.file, begin_line/, start_col/);	PC.string->APPEND_CLEAN(begin, end-begin, PC.file, begin_line/, start_col/);
}	}
}	}
if(PC.string->size()) { // something accumulated?	if(PC.string->size()) { // something accumulated?
// create STRING value: array of OP_VALUE+vstring	// create STRING value: array of OP_VALUE+vstring
lvalp=VL(NEW VString(PC.string));	*lvalp=VL(ValuePtr(new VString(PC.string)));
// new pieces storage	// new pieces storage
PC.string=NEW String(POOL);	PC.string=StringPtr(new String);
// make current result be pending for next call, return STRING for now	// make current result be pending for next call, return STRING for now
PC.pending_state=result; result=STRING;	PC.pending_state=result; result=STRING;
}	}
Line 2424 static int real_yyerror(parse_control *p	Line 2617 static int real_yyerror(parse_control *p

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.3
changed lines
	Added in v.1.81.2.2