parser3/src/main/compile.y - diff

Return to compile.y CVS log

Up to [parser3project] / parser3 / src / main

Diff for /parser3/src/main/compile.y between versions 1.95 and 1.203

version 1.95, 2001/03/13 14:28:51	version 1.203, 2002/10/22 09:27:10
Line 1	Line 1
/*	%{
Parser	/** @file
	Parser: compiler(lexical parser and grammar).

Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)	Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)
Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)	Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)

$Id$	$Id$
*/	*/

/*	/**
TODO.parser4:	@todo parser4:
cache compiled code from request to request. to do that...	- cache compiled code from request to request. to do that...
1: make method definitions, @CLASS, @BASE, @USE instructions,	-#: make method definitions, @CLASS, @BASE, @USE instructions,
which would be executed afterwards, and actions	which would be executed afterwards, and actions
now performed at compile time would be delayed to run time.	now performed at compile time would be delayed to run time.
2: make cache expiration on time and on disk-change of class source	-#: make cache expiration on time and on disk-change of class source
3: in apache use subpools for compiled class storage	-#: in apache use subpools for compiled class storage
4: in iis make up specialized Pool object for that	-#: in iis make up specialized Pool object for that
*/	*/

%{
#define YYSTYPE Array/<Operation>/ *	#define YYSTYPE Array/<Operation>/ *
#define YYPARSE_PARAM pc	#define YYPARSE_PARAM pc
#define YYLEX_PARAM pc	#define YYLEX_PARAM pc
#define YYDEBUG 1	#define YYDEBUG 1
#define YYERROR_VERBOSE	#define YYERROR_VERBOSE 1
#define yyerror(msg) real_yyerror((parse_control *)pc, msg)	#define yyerror(msg) real_yyerror((parse_control *)pc, msg)
#define YYPRINT(file, type, value) yyprint(file, type, value)	#define YYPRINT(file, type, value) yyprint(file, type, value)

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include "compile_tools.h"	#include "compile_tools.h"
#include "pa_value.h"	#include "pa_value.h"
#include "pa_request.h"	#include "pa_request.h"
#include "pa_vobject.h"	#include "pa_vobject.h"
#include "pa_vdouble.h"	#include "pa_vdouble.h"
#include "core.h"	#include "pa_globals.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"

int real_yyerror(parse_control pc, char s);	static int real_yyerror(parse_control pc, char s);
static void yyprint(FILE *file, int type, YYSTYPE value);	static void yyprint(FILE *file, int type, YYSTYPE value);
int yylex(YYSTYPE lvalp, void pc);	static int yylex(YYSTYPE lvalp, void pc);


// local convinient inplace typecast & var	// local convinient inplace typecast & var
#define PC ((parse_control *)pc)	#define PC ((parse_control )pc)
#define POOL *PC->pool	#define POOL (*PC.pool)
#undef NEW	#undef NEW
#define NEW new(POOL)	#define NEW new(POOL)
	#ifndef DOXYGEN
%}	%}

%pure_parser	%pure_parser
Line 59 int yylex(YYSTYPE lvalp, void pc);	Line 58 int yylex(YYSTYPE lvalp, void pc);
%token BOGUS	%token BOGUS

%token BAD_STRING_COMPARISON_OPERATOR	%token BAD_STRING_COMPARISON_OPERATOR
	%token BAD_HEX_LITERAL
	%token BAD_METHOD_DECL_START
	%token BAD_METHOD_PARAMETER_NAME_CHARACTER
	%token BAD_MATH_OPERATOR_CHARACTER

%token LAND "&&"	%token LAND "&&"
%token LOR "\|\|"	%token LOR "\|\|"
%token LXOR "##"	%token LXOR "!\|\|"
	%token NXOR "!\|"

%token NLE "<="	%token NLE "<="
%token NGE ">="	%token NGE ">="
%token NEQ "=="	%token NEQ "=="
%token NNE "!="	%token NNE "!="
	%token NSL "<<"
	%token NSR ">>"

%token SLT "lt"	%token SLT "lt"
%token SGT "gt"	%token SGT "gt"
Line 79 int yylex(YYSTYPE lvalp, void pc);	Line 85 int yylex(YYSTYPE lvalp, void pc);
%token DEF "def"	%token DEF "def"
%token IN "in"	%token IN "in"
%token FEXISTS "-f"	%token FEXISTS "-f"
	%token DEXISTS "-d"
%token IS "is"	%token IS "is"

/* logical */	/* logical */
%left "is"	%left "!\|\|"
%left "lt" "gt" "le" "ge"
%left "eq" "ne"
%left '<' '>' "<=" ">=" "##"
%left "==" "!="
%left "\|\|"	%left "\|\|"
%left "&&"	%left "&&"
%left "def" "in" "-f"	%left '<' '>' "<=" ">=" "lt" "gt" "le" "ge"
%left '!'	%left "==" "!=" "eq" "ne"
	%left "is" "def" "in" "-f" "-d"

/* bitwise */	/* bitwise */
%left '#'	%left "!\|"
%left '&' '\|'	%left '\|'
%left '~'	%left '&'
	%left "<<" ">>"

/* numerical */	/* numerical */
%left '-' '+'	%left '+' '-'
%left '*' '/' '%'	%left '*' '/' '\\' '%'
%left NEG /* negation: unary - */	%left NUNARY /* unary - + */

	/* out-of-group */
	%left '~' /* bitwise */
	%left '!' /* logical */

%%	%%
all:	all:
one_big_piece {	one_big_piece {
Method& method=*NEW Method(POOL,	Method& method=*NEW Method(POOL,
*main_method_name,	PC.request->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/,	0/param_names/, 0/local_names/,
$1/parser_code/, 0/native_code/);	$1/parser_code/, 0/native_code/);
PC->cclass->add_method(*main_method_name, method);	PC.cclass->add_method(PC.request->main_method_name, method);
}	}
\| methods;	\| methods;

Line 120 one_big_piece: maybe_codes;	Line 130 one_big_piece: maybe_codes;
method: control_method \| code_method;	method: control_method \| code_method;

control_method: '@' STRING '\n'	control_method: '@' STRING '\n'
control_strings {	maybe_control_strings {
const String& command=*SLA2S($2);	const String& command=*LA2S($2);
YYSTYPE strings_code=$4;	YYSTYPE strings_code=$4;
if(strings_code->size()<1*2) {	if(strings_code->size()<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!=&PC->request->root_class) { // 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->size()==1*2) {
// new class' name	// new class' name
const String *name=SLA2S(strings_code);	const String *name=LA2S(strings_code);
// creating the class	// creating the class
PC->cclass=NEW VClass(POOL);	PC.cclass=NEW VClass(POOL);
PC->cclass->set_name(*name);	PC.cclass->set_name(*name);
// defaulting base. may change with @BASE
PC->cclass->set_base(PC->request->root_class);
// append to request's classes	// append to request's classes
PC->request->classes_array()+=PC->cclass;	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 {	} else if(command==USE_CONTROL_METHOD_NAME) {
if(command==USE_CONTROL_METHOD_NAME) {	for(int i=0; i<strings_code->size(); i+=2)
for(int i=0; i<strings_code->size(); i+=2) {	PC.request->use_file(PC.request->main_class, *LA2S(strings_code, i));
String file(*SLA2S(strings_code, i));	} else if(command==BASE_NAME) {
file.APPEND_CONST(".p");	if(PC.cclass->base_class()) { // already changed from default?
PC->request->use_file(file.cstr());	strcpy(PC.error, "class already have a base '");
}	strncat(PC.error, PC.cclass->base_class()->name().cstr(), 100);
} else if(command==BASE_NAME) {	strcat(PC.error, "'");
if(PC->cclass->base()!=&PC->request->root_class) { // already changed from default?	YYERROR;
strcpy(PC->error, "class already have a base '");	}
strncat(PC->error, PC->cclass->base()->name().cstr(), 100);	if(strings_code->size()==1*2) {
strcat(PC->error, "'");	const String& base_name=*LA2S(strings_code);
	Value vbase_class=static_cast<VClass >(
	PC.request->classes().get(base_name));
	VStateless_class *base_class=vbase_class?vbase_class->get_class():0;
	if(!base_class) {
	strcpy(PC.error, base_name.cstr());
	strcat(PC.error, ": undefined class in @"BASE_NAME);
YYERROR;	YYERROR;
}	}
if(strings_code->size()==1*2) {	// @CLASS == @BASE sanity check
// TODO: �� self � �� base	if(PC.cclass==base_class) {
const String& base_name=*SLA2S(strings_code);	strcpy(PC.error, "@"CLASS_NAME" equals @"BASE_NAME);
VClass base=static_cast<VClass >(
PC->request->classes().get(base_name));
if(!base) {
strcpy(PC->error, base_name.cstr());
strcat(PC->error, ": undefined class in @"BASE_NAME);
YYERROR;
}
PC->cclass->set_base(*base);
} else {
strcpy(PC->error, "@"BASE_NAME" must contain sole name");
YYERROR;	YYERROR;
}	}
	PC.cclass->set_base(base_class);
} else {	} else {
strcpy(PC->error, "'");	strcpy(PC.error, "@"BASE_NAME" must contain sole name");
strncat(PC->error, command.cstr(), MAX_STRING/2);
strcat(PC->error, "' invalid special name. valid names are "
"'"CLASS_NAME"', '"USE_CONTROL_METHOD_NAME"' and '"BASE_NAME"'");
YYERROR;	YYERROR;
}	}
	} else {
	strcpy(PC.error, "'");
	strncat(PC.error, command.cstr(), MAX_STRING/2);
	strcat(PC.error, "' invalid special name. valid names are "
	"'"CLASS_NAME"', '"USE_CONTROL_METHOD_NAME"' and '"BASE_NAME"'");
	YYERROR;
}	}
};	};
	maybe_control_strings: empty \| control_strings;
control_strings: control_string \| control_strings control_string { $$=$1; P($$, $2) };	control_strings: control_string \| control_strings control_string { $$=$1; P($$, $2) };
control_string: maybe_string '\n';	control_string: maybe_string '\n';
maybe_string: empty \| STRING;	maybe_string: empty \| STRING;

code_method: '@' STRING bracketed_maybe_strings maybe_bracketed_strings maybe_comment '\n'	code_method: '@' STRING bracketed_maybe_strings maybe_bracketed_strings maybe_comment '\n'
maybe_codes {	maybe_codes {
const String *name=SLA2S($2);	const String *name=LA2S($2);

YYSTYPE params_names_code=$3;	YYSTYPE params_names_code=$3;
Array *params_names=0;	Array *params_names=0;
if(int size=params_names_code->size()) {	if(int size=params_names_code->size()) {
params_names=NEW Array(POOL);	params_names=NEW Array(POOL);
for(int i=0; i<size; i+=2)	for(int i=0; i<size; i+=2)
*params_names+=SLA2S(params_names_code, i);	*params_names+=LA2S(params_names_code, i);
}	}

YYSTYPE locals_names_code=$4;	YYSTYPE locals_names_code=$4;
Line 210 code_method: '@' STRING bracketed_maybe_	Line 218 code_method: '@' STRING bracketed_maybe_
if(int size=locals_names_code->size()) {	if(int size=locals_names_code->size()) {
locals_names=NEW Array(POOL);	locals_names=NEW Array(POOL);
for(int i=0; i<size; i+=2)	for(int i=0; i<size; i+=2)
*locals_names+=SLA2S(locals_names_code, i);	*locals_names+=LA2S(locals_names_code, i);
}	}

Method& method=*NEW Method(POOL,	Method& method=*NEW Method(POOL,
*name,	*name,
	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,
$7, 0);	$7, 0);
PC->cclass->add_method(*name, method);	PC.cclass->add_method(*name, method);
};	};

maybe_bracketed_strings: empty \| bracketed_maybe_strings;	maybe_bracketed_strings: empty \| bracketed_maybe_strings;
Line 234 maybe_codes: empty \| codes;	Line 243 maybe_codes: empty \| codes;

codes: code \| codes code { $$=$1; P($$, $2) };	codes: code \| codes code { $$=$1; P($$, $2) };
code: write_string \| action;	code: write_string \| action;
action: get \| put \| with \| call;	action: get \| put \| call;

/* get */	/* get */

get: get_value {	get: get_value {
$$=$1; /* stack: resulting value */	$$=$1; /* stack: resulting value */
O($$, OP_WRITE); /* value=pop; wcontext.write(value) */	changetail_or_append($$,
	OP_GET_ELEMENT, false, /->/OP_GET_ELEMENT__WRITE,
	/or /OP_WRITE_VALUE
	); /* value=pop; wcontext.write(value) */
};	};
get_value: '$' get_name_value { $$=$2 }	get_value: '$' get_name_value { $$=$2 };
get_name_value: name_without_curly_rdive EON \| name_in_curly_rdive;	get_name_value: name_without_curly_rdive EON \| name_in_curly_rdive;
name_in_curly_rdive: '{' name_without_curly_rdive '}' { $$=$2 };	name_in_curly_rdive: '{' name_without_curly_rdive '}' { $$=$2 };
name_without_curly_rdive:	name_without_curly_rdive:
name_without_curly_rdive_read	name_without_curly_rdive_read
\| name_without_curly_rdive_root
\| name_without_curly_rdive_class;	\| name_without_curly_rdive_class;
name_without_curly_rdive_read: name_without_curly_rdive_code {	name_without_curly_rdive_read: name_without_curly_rdive_code {
$$=N(POOL);	$$=N(POOL);
Array *diving_code=$1;	Array *diving_code=$1;
const String *first_name=SLA2S(diving_code);	const String *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($$, OP_WITH_SELF); /* stack: starting context */	O($$, OP_WITH_SELF); /* stack: starting context */
P($$, diving_code,	P($$, diving_code,
/* skip over... */	/* skip over... */
diving_code->size()>2?3/OP_+string+get_element/:2/OP_+string/);	diving_code->size()>=3?3/OP_VALUE+string+OP_GET_ELEMENTx/:2/OP_+string/);
} else {	} else {
O($$, OP_WITH_READ); /* stack: starting context */	O($$, OP_WITH_READ); /* stack: starting context */

	// ^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->size()==3)
	diving_code->put_int(2, OP_GET_ELEMENT_OR_OPERATOR);
P($$, diving_code);	P($$, diving_code);
}	}
/* diving code; stack: current context */	/* diving code; stack: current context */
};	};
name_without_curly_rdive_root: ':' name_without_curly_rdive_code {
$$=N(POOL);
O($$, OP_WITH_ROOT); /* stack: starting context */
P($$, $2); /* diving code; stack: current context */
};
name_without_curly_rdive_class: class_prefix name_without_curly_rdive_code { $$=$1; P($$, $2) };	name_without_curly_rdive_class: class_prefix name_without_curly_rdive_code { $$=$1; P($$, $2) };
name_without_curly_rdive_code: name_advance2 \| name_path name_advance2 { $$=$1; P($$, $2) };	name_without_curly_rdive_code: name_advance2 \| name_path name_advance2 { $$=$1; P($$, $2) };

Line 279 put: '$' name_expr_wdive construct {	Line 292 put: '$' name_expr_wdive construct {
P($$, $3); /* stack: context,name,constructor_value */	P($$, $3); /* stack: context,name,constructor_value */
};	};
name_expr_wdive:	name_expr_wdive:
name_expr_wdive_write	name_expr_wdive_root
\| name_expr_wdive_root	\| name_expr_wdive_write
\| name_expr_wdive_class;	\| name_expr_wdive_class;
name_expr_wdive_write: name_expr_dive_code {	name_expr_wdive_root: name_expr_dive_code {
$$=N(POOL);	$$=N(POOL);
Array *diving_code=$1;	Array *diving_code=$1;
const String *first_name=SLA2S(diving_code);	const String *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($$, OP_WITH_SELF); /* stack: starting context */	O($$, OP_WITH_SELF); /* stack: starting context */
P($$, diving_code,	P($$, diving_code,
/* skip over... */	/* skip over... */
diving_code->size()>2?3/OP_+string+get_element/:2/OP_+string/);	diving_code->size()>=3?3/OP_VALUE+string+OP_GET_ELEMENTx/:2/OP_+string/);
} else {	} else {
O($$, OP_WITH_WRITE); /* stack: starting context */	O($$, OP_WITH_ROOT); /* stack: starting context */
P($$, diving_code);	P($$, diving_code);
}	}
/* diving code; stack: current context */	/* diving code; stack: current context */
};	};
name_expr_wdive_root: ':' name_expr_dive_code {	name_expr_wdive_write: '.' name_expr_dive_code {
$$=N(POOL);	$$=N(POOL);
O($$, OP_WITH_ROOT); /* stack: starting context */	O($$, OP_WITH_WRITE); /* stack: starting context */
P($$, $2); /* diving code; stack: context,name */	P($$, $2); /* diving code; stack: context,name */
};	};
name_expr_wdive_class: class_prefix name_expr_dive_code { $$=$1; P($$, $2) };	name_expr_wdive_class: class_prefix name_expr_dive_code { $$=$1; P($$, $2) };

construct: construct_by_code \| construct_by_expr;	construct:
construct_by_code: '[' any_constructor_code_value ']' {	construct_square
$$=$2; /* stack: context, name, value */	\| construct_round
	\| construct_curly
	;
	construct_square: '[' any_constructor_code_value ']' {
	// stack: context, name
	$$=$2; // stack: context, name, value
O($$, OP_CONSTRUCT_VALUE); /* value=pop; name=pop; context=pop; construct(context,name,value) */	O($$, OP_CONSTRUCT_VALUE); /* value=pop; name=pop; context=pop; construct(context,name,value) */
}	}
;	;
construct_by_expr: '(' expr_value ')' {	construct_round: '(' expr_value ')' {
$$=$2; /* stack: context, name, value */	$$=N(POOL);
O($$, OP_CONSTRUCT_EXPR); /* value=pop; name=pop; context=pop; construct(context,name,value) */	O($$, OP_PREPARE_TO_EXPRESSION);
	// stack: context, name
	P($$, $2); // stack: context, name, value
	O($$, OP_CONSTRUCT_EXPR); /* value=pop->as_expr_result; name=pop; context=pop; construct(context,name,value) */
}	}
;	;
	construct_curly: '{' maybe_codes '}' {
	// stack: context, name
	$$=N(POOL);
	OA($$, OP_CURLY_CODE__CONSTRUCT, $2); /* code=pop; name=pop; context=pop; construct(context,name,junction(code)) */
	};

any_constructor_code_value:	any_constructor_code_value:
empty_string_value /* optimized $var[] case */	void_value /* optimized $var[] case */
\| STRING /* optimized $var[STRING] case */	\| STRING /* optimized $var[STRING] case */
\| constructor_code_value /* $var[something complex] */	\| constructor_code_value /* $var[something complex] */
;	;
constructor_code_value: constructor_code {	constructor_code_value: constructor_code {
$$=N(POOL);	$$=N(POOL);
O($$, OP_CREATE_EWPOOL); /* stack: empty write context */	OA($$, OP_OBJECT_POOL, $1); /* stack: empty write context */
P($$, $1); /* some code that writes to that context */	/* some code that writes to that context */
O($$, OP_REDUCE_EWPOOL); /* context=pop; stack: context.value() */	/* context=pop; stack: context.value() */
};	};
constructor_code: codes__excluding_sole_str_literal;	constructor_code: codes__excluding_sole_str_literal;
codes__excluding_sole_str_literal: action \| code codes { $$=$1; P($$, $2) };	codes__excluding_sole_str_literal: action \| code codes { $$=$1; P($$, $2) };
Line 333 codes__excluding_sole_str_literal: actio	Line 362 codes__excluding_sole_str_literal: actio

call: call_value {	call: call_value {
$$=$1; /* stack: value */	$$=$1; /* stack: value */
O($$, OP_WRITE); /* value=pop; wcontext.write(value) */	changetail_or_append($$,
	OP_CALL, true, /->/ OP_CALL__WRITE,
	/or /OP_WRITE_VALUE); /* value=pop; wcontext.write(value) */
};	};
call_value: '^' call_name store_params EON { /* ^field.$method{vasya} */	call_value: '^' {
$$=$2; /* with_xxx,diving code; stack: context,method_junction */	PC.in_call_value=true;
O($$, OP_GET_METHOD_FRAME); /* stack: context,method_frame */	}
P($$, $3); /* filling method_frame.store_params */	call_name {
O($$, OP_CALL); /* method_frame=pop; ncontext=pop; call(ncontext,method_frame) stack: value */	PC.in_call_value=false;
	}
	store_params EON { /* ^field.$method{vasya} */
	$$=$3; /* with_xxx,diving code; stack: context,method_junction */

	YYSTYPE params_code=$5;
	if(params_code->size()==3) { // probably [] case. [OP_VALUE + Void + STORE_PARAM]
	if(Value *value=LA2V(params_code)) // it is OP_VALUE + value?
	if(!value->is_defined()) // value is VVoid?
	params_code=0; // ^zzz[] case. don't append lone empty param.
	}
	/* stack: context, method_junction */
	OA($$, OP_CALL, params_code); // method_frame=make frame(pop junction); ncontext=pop; call(ncontext,method_frame) stack: value
};	};

call_name: name_without_curly_rdive;	call_name: name_without_curly_rdive;
Line 365 store_curly_param_parts:	Line 408 store_curly_param_parts:
store_curly_param_part	store_curly_param_part
\| store_curly_param_parts ';' store_curly_param_part { $$=$1; P($$, $3) }	\| store_curly_param_parts ';' store_curly_param_part { $$=$1; P($$, $3) }
;	;
store_code_param_part:	store_code_param_part: code_param_value {
empty /* optimized [] case */
\| STRING { /* optimized [STRING] case */
$$=$1;
O($$, OP_STORE_PARAM);
}
\| constructor_code_value { /* [something complex] */
$$=$1;	$$=$1;
O($$, OP_STORE_PARAM);	O($$, OP_STORE_PARAM);
}	};
;
store_expr_param_part: write_expr_value {	store_expr_param_part: write_expr_value {
$$=N(POOL);	$$=N(POOL);
PCA($$, $1);	OA($$, OP_EXPR_CODE__STORE_PARAM, $1);
};	};
store_curly_param_part: maybe_codes {	store_curly_param_part: maybe_codes {
$$=N(POOL);	$$=N(POOL);
PCA($$, $1);	OA($$, OP_CURLY_CODE__STORE_PARAM, $1);
};	};
	code_param_value:
	void_value /* optimized [;...] case */
	\| STRING /* optimized [STRING] case */
	\| constructor_code_value /* [something complex] */
	;
write_expr_value: expr_value {	write_expr_value: expr_value {
$$=$1;	$$=N(POOL);
O($$, OP_WRITE);	O($$, OP_PREPARE_TO_EXPRESSION);
	P($$, $1);
	O($$, OP_WRITE_EXPR_RESULT);
};	};

/* name */	/* name */
Line 396 name_expr_dive_code: name_expr_value \| n	Line 439 name_expr_dive_code: name_expr_value \| n
name_path: name_step \| name_path name_step { $$=$1; P($$, $2) };	name_path: name_step \| name_path name_step { $$=$1; P($$, $2) };
name_step: name_advance1 '.';	name_step: name_advance1 '.';
name_advance1: name_expr_value {	name_advance1: name_expr_value {
	// 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 */
$$=$1; /* stack: context,name */	$$=$1; /* stack: context,name */
O($$, OP_GET_ELEMENT); /* name=pop; context=pop; stack: context.get_element(name) */	O($$, OP_GET_ELEMENT); /* name=pop; context=pop; stack: context.get_element(name) */
Line 410 name_advance2: name_expr_value {	Line 456 name_advance2: name_expr_value {
name_expr_value:	name_expr_value:
STRING /* subname_is_const */	STRING /* subname_is_const */
\| name_expr_subvar_value /* $subname_is_var_value */	\| name_expr_subvar_value /* $subname_is_var_value */
\| name_expr_with_subvar_value /* xxx$part_of_subname_is_var_value[$...] */	\| name_expr_with_subvar_value /* xxx$part_of_subname_is_var_value */
	\| name_square_code_value /* [codes] */
;	;
name_expr_subvar_value: '$' subvar_ref_name_rdive {	name_expr_subvar_value: '$' subvar_ref_name_rdive {
$$=$2;	$$=$2;
O($$, OP_GET_ELEMENT);	O($$, OP_GET_ELEMENT);
};	};
name_expr_with_subvar_value: STRING subvar_get_writes {	name_expr_with_subvar_value: STRING subvar_get_writes {
	Array *code;
	{
	change_string_literal_to_write_string_literal(code=$1);
	P(code, $2);
	}
$$=N(POOL);	$$=N(POOL);
O($$, OP_CREATE_EWPOOL);	OA($$, OP_STRING_POOL, code);
P($$, $1);
O($$, OP_WRITE);
P($$, $2);
O($$, OP_REDUCE_EWPOOL);
};	};
subvar_ref_name_rdive: subvar_ref_name_rdive_read \| subvar_ref_name_rdive_root;	name_square_code_value: '[' codes ']' {
subvar_ref_name_rdive_read: STRING {
$$=N(POOL);	$$=N(POOL);
O($$, OP_WITH_READ);	OA($$, OP_OBJECT_POOL, $2); /* stack: empty write context */
P($$, $1);	/* some code that writes to that context */
	/* context=pop; stack: context.value() */
};	};
subvar_ref_name_rdive_root: ':' STRING {	subvar_ref_name_rdive: STRING {
$$=N(POOL);	$$=N(POOL);
O($$, OP_WITH_ROOT);	O($$, OP_WITH_READ);
P($$, $2);	P($$, $1);
};	};
subvar_get_writes: subvar__get_write \| subvar_get_writes subvar__get_write { $$=$1; P($$, $2) };	subvar_get_writes: subvar__get_write \| subvar_get_writes subvar__get_write { $$=$1; P($$, $2) };
subvar__get_write: '$' subvar_ref_name_rdive {	subvar__get_write: '$' subvar_ref_name_rdive {
Line 441 subvar__get_write: '$' subvar_ref_name_r	Line 489 subvar__get_write: '$' subvar_ref_name_r
O($$, OP_GET_ELEMENT__WRITE);	O($$, OP_GET_ELEMENT__WRITE);
};	};

class_prefix: STRING ':' {	class_prefix:
	class_static_prefix
	\| class_constructor_prefix
	;
	class_static_prefix: STRING ':' {
$$=$1; // stack: class name string	$$=$1; // stack: class name string
	if(*LA2S($$) == BASE_NAME) { // pseude BASE class
	if(VStateless_class *base=PC.cclass->base_class()) {
	change_string_literal_value($$, base->name());
	} else {
	strcpy(PC.error, "no base class declared");
	YYERROR;
	}
	}
O($$, OP_GET_CLASS);	O($$, OP_GET_CLASS);
};	};
	class_constructor_prefix: class_static_prefix ':' {
	$$=$1;
/* with */	if(!PC.in_call_value) {
	strcpy(PC.error, ":: not allowed here");
with: '$' name_without_curly_rdive '{' codes '}' {	YYERROR;
$$=$2;	}
O($$, OP_CREATE_RWPOOL);	O($$, OP_PREPARE_TO_CONSTRUCT_OBJECT);
P($$, $4);
O($$, OP_REDUCE_RWPOOL);
O($$, OP_WRITE);
};	};


/* expr */	/* expr */

expr_value: expr {	expr_value: expr {
	// see OP_PREPARE_TO_EXPRESSION!!
if(($$=$1)->size()==2) // only one string literal in there?	if(($$=$1)->size()==2) // only one string literal in there?
change_string_literal_to_double_literal($$); // make that string literal Double	change_string_literal_to_double_literal($$); // make that string literal Double
};	};
Line 468 expr:	Line 527 expr:
\| get_value	\| get_value
\| call_value	\| call_value
\| '"' string_inside_quotes_value '"' { $$ = $2; }	\| '"' string_inside_quotes_value '"' { $$ = $2; }
	\| '\'' string_inside_quotes_value '\'' { $$ = $2; }
\| '(' expr ')' { $$ = $2; }	\| '(' expr ')' { $$ = $2; }
/* stack: operand // stack: @operand */	/* stack: operand // stack: @operand */
\| '-' expr %prec NEG { $$=$2; O($$, OP_NEG) }	\| '-' expr %prec NUNARY { $$=$2; O($$, OP_NEG) }
	\| '+' expr %prec NUNARY { $$=$2 }
\| '~' expr { $$=$2; O($$, OP_INV) }	\| '~' expr { $$=$2; O($$, OP_INV) }
\| '!' expr { $$=$2; O($$, OP_NOT) }	\| '!' expr { $$=$2; O($$, OP_NOT) }
\| "def" expr { $$=$2; O($$, OP_DEF) }	\| "def" expr { $$=$2; O($$, OP_DEF) }
\| "in" expr { $$=$2; O($$, OP_IN) }	\| "in" expr { $$=$2; O($$, OP_IN) }
\| "-f" expr { $$=$2; O($$, OP_FEXISTS) }	\| "-f" expr { $$=$2; O($$, OP_FEXISTS) }
	\| "-d" expr { $$=$2; O($$, OP_DEXISTS) }
/* stack: a,b // stack: a@b */	/* stack: a,b // stack: a@b */
\| expr '-' expr { $$=$1; P($$, $3); O($$, OP_SUB) }	\| expr '-' expr { $$=$1; P($$, $3); O($$, OP_SUB) }
\| expr '+' expr { $$=$1; P($$, $3); O($$, OP_ADD) }	\| expr '+' expr { $$=$1; P($$, $3); O($$, OP_ADD) }
\| expr '*' expr { $$=$1; P($$, $3); O($$, OP_MUL) }	\| expr '*' expr { $$=$1; P($$, $3); O($$, OP_MUL) }
\| expr '/' expr { $$=$1; P($$, $3); O($$, OP_DIV) }	\| expr '/' expr { $$=$1; P($$, $3); O($$, OP_DIV) }
\| expr '%' expr { $$=$1; P($$, $3); O($$, OP_MOD) }	\| expr '%' expr { $$=$1; P($$, $3); O($$, OP_MOD) }
	\| expr '\\' expr { $$=$1; P($$, $3); O($$, OP_INTDIV) }
	\| expr "<<" expr { $$=$1; P($$, $3); O($$, OP_BIN_SL) }
	\| expr ">>" expr { $$=$1; P($$, $3); O($$, OP_BIN_SR) }
\| expr '&' expr { $$=$1; P($$, $3); O($$, OP_BIN_AND) }	\| expr '&' expr { $$=$1; P($$, $3); O($$, OP_BIN_AND) }
\| expr '\|' expr { $$=$1; P($$, $3); O($$, OP_BIN_OR) }	\| expr '\|' expr { $$=$1; P($$, $3); O($$, OP_BIN_OR) }
\| expr '#' expr { $$=$1; P($$, $3); O($$, OP_BIN_XOR) }	\| expr "!\|" expr { $$=$1; P($$, $3); O($$, OP_BIN_XOR) }
\| expr "&&" expr { $$=$1; P($$, $3); O($$, OP_LOG_AND) }	\| expr "&&" expr { $$=$1; OA($$, OP_NESTED_CODE, $3); O($$, OP_LOG_AND) }
\| expr "\|\|" expr { $$=$1; P($$, $3); O($$, OP_LOG_OR) }	\| expr "\|\|" expr { $$=$1; OA($$, OP_NESTED_CODE, $3); O($$, OP_LOG_OR) }
\| expr "##" expr { $$=$1; P($$, $3); O($$, OP_LOG_XOR) }	\| expr "!\|\|" expr { $$=$1; P($$, $3); O($$, OP_LOG_XOR) }
\| expr '<' expr { $$=$1; P($$, $3); O($$, OP_NUM_LT) }	\| expr '<' expr { $$=$1; P($$, $3); O($$, OP_NUM_LT) }
\| expr '>' expr { $$=$1; P($$, $3); O($$, OP_NUM_GT) }	\| expr '>' expr { $$=$1; P($$, $3); O($$, OP_NUM_GT) }
\| expr "<=" expr { $$=$1; P($$, $3); O($$, OP_NUM_LE) }	\| expr "<=" expr { $$=$1; P($$, $3); O($$, OP_NUM_LE) }
Line 505 expr:	Line 570 expr:

string_inside_quotes_value: maybe_codes {	string_inside_quotes_value: maybe_codes {
$$=N(POOL);	$$=N(POOL);
O($$, OP_CREATE_SWPOOL); /* stack: empty write context */	OA($$, OP_STRING_POOL, $1); /* stack: empty write context */
P($$, $1); /* some code that writes to that context */	/* some code that writes to that context */
O($$, OP_REDUCE_SWPOOL); /* context=pop; stack: context.get_string() */	/* context=pop; stack: context.get_string() */
};	};

/* basics */	/* basics */

write_string: STRING {	write_string: STRING {
// optimized from OP_STRING+OP_WRITE to OP_STRING__WRITE	// optimized from OP_STRING+OP_WRITE_VALUE to OP_STRING__WRITE
change_string_literal_to_write_string_literal($$=$1)	change_string_literal_to_write_string_literal($$=$1)
};	};

empty_string_value: /* empty */ { $$=VL(NEW VString(POOL)) };	void_value: /* empty */ { $$=VL(NEW VVoid(POOL)) };
empty: /* empty */ { $$=N(POOL) };	empty: /* empty */ { $$=N(POOL) };

%%	%%
	#endif

/*	/*
000$111(2222)00	000$111(2222)00
Line 538 empty: /* empty */ { $$=N(POOL) };	Line 604 empty: /* empty */ { $$=N(POOL) };
4:[^({]=pop	4:[^({]=pop
*/	*/

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;
int result;	int result;

if(PC->pending_state) {	if(PC.pending_state) {
result=PC->pending_state;	result=PC.pending_state;
PC->pending_state=0;	PC.pending_state=0;
return result;	return result;
}	}

const char *begin=PC->source;	const char *begin=PC.source;
const char *end;	const char *end;
int begin_line=PC->line;	int begin_line=PC.line;
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++;
PC->col=0;	PC.col=0;
} else	} else
PC->col++;	PC.col++;

// todo: # in 0+1 column comment

// escaping: ^^ ^$ ^; ^) ^} ^( ^{ ^"	if(c=='@' && PC.col==0+1) {
if(c=='^')	if(PC.ls==LS_DEF_SPECIAL_BODY) {
switch(*PC->source) {	// @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) {
	// ^escaping some punctuators
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(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;

	// converting ^#HH into char(hex(HH))
	case '#':
	if(end!=begin) {
	// append piece till ^
	PC.string->APPEND_CLEAN(begin, end-begin, PC.file, begin_line);
	}
	// #HH ?
	if(PC.source[0]=='#' && PC.source[1] && PC.source[2]) {
	char hex=(char )POOL.malloc(1);
	hex[0]=
	hex_value[(unsigned char)PC.source[1]]*0x10+
	hex_value[(unsigned char)PC.source[2]];
	if(hex[0]==0) {
	result=BAD_HEX_LITERAL;
	goto break2; // wrong hex value[no ^#00 chars allowed]: bail out
	}
	// append char(hex(HH))
	PC.string->APPEND_CLEAN(hex, 1, PC.file, begin_line);
	// skip over ^#HH
	PC.source+=3;
	PC.col+=3;
	// reset piece 'begin' position & line
	begin=PC.source; // ->after ^#HH
	begin_line=PC.line;
	// skip analysis = forced literal
	continue;
	}
	break;
	}
	break;
	}
	}
	// #comment start skipping
	if(c=='#' && PC.col==1) {
	if(end!=begin) {
	// append piece till #
	PC.string->APPEND_CLEAN(begin, end-begin, PC.file, begin_line);
}	}
switch(PC->ls) {	// fall into COMMENT lexical state [wait for \n]
	push_LS(PC, LS_USER_COMMENT);
	continue;
	}
	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)
	switch(c) {
	case '\n': case ' ': case '\t':
	begin=PC.source;
	begin_line=PC.line;
	continue; // skip it
	default:
	PC.trim_bof=false;
	}
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.[co<[>de]
	if(PC.ls==LS_NAME_SQUARE_PART)
	lexical_brackets_nestage++;
	break;
	}
	break;

	// #COMMENT
	case LS_USER_COMMENT:
	if(c=='\n') {
	// skip comment
	begin=PC.source;
	begin_line=PC.line;

	pop_LS(PC);
	continue;
}	}
break;	break;

// STRING IN EXPRESSION	// STRING IN EXPRESSION
case LS_EXPRESSION_STRING:	case LS_EXPRESSION_STRING_QUOTED:
	case LS_EXPRESSION_STRING_APOSTROFED:
switch(c) {	switch(c) {
case '"':	case '"':
pop_LS(PC); //"abc".	case '\'':
RC;	if(
	PC.ls == LS_EXPRESSION_STRING_QUOTED && c=='"' \|\|
	PC.ls == LS_EXPRESSION_STRING_APOSTROFED && c=='\'') {
	pop_LS(PC); //"abc". \| 'abc'.
	RC;
	}
	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 624 int yylex(YYSTYPE lvalp, void pc) {	Line 798 int yylex(YYSTYPE lvalp, void pc) {
case LS_DEF_NAME:	case LS_DEF_NAME:
switch(c) {	switch(c) {
case '[':	case '[':
PC->ls=LS_DEF_PARAMS;	PC.ls=LS_DEF_PARAMS;
RC;	RC;
case '\n':	case '\n':
PC->ls=LS_DEF_SPECIAL_BODY;	PC.ls=LS_DEF_SPECIAL_BODY;
RC;	RC;
}	}
break;	break;

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 ']':
PC->ls=*PC->source=='['?LS_DEF_LOCALS:LS_DEF_COMMENT;	PC.ls=*PC.source=='['?LS_DEF_LOCALS:LS_DEF_COMMENT;
RC;	RC;
case '\n': // wrong. bailing out	case '\n': // wrong. bailing out
pop_LS(PC);	pop_LS(PC);
Line 651 int yylex(YYSTYPE lvalp, void pc) {	Line 828 int yylex(YYSTYPE lvalp, void pc) {
case ';':	case ';':
RC;	RC;
case ']':	case ']':
PC->ls=LS_DEF_COMMENT;	PC.ls=LS_DEF_COMMENT;
RC;	RC;
case '\n': // wrong. bailing out	case '\n': // wrong. bailing out
pop_LS(PC);	pop_LS(PC);
Line 667 int yylex(YYSTYPE lvalp, void pc) {	Line 844 int yylex(YYSTYPE lvalp, void pc) {
break;	break;

case LS_DEF_SPECIAL_BODY:	case LS_DEF_SPECIAL_BODY:
if(c=='\n') {	if(c=='\n')
switch(*PC->source) {
case '@': case 0: // end of special_code
pop_LS(PC);
break;
}
RC;	RC;
}
break;	break;

// (EXPRESSION)	// (EXPRESSION)
Line 683 int yylex(YYSTYPE lvalp, void pc) {	Line 854 int yylex(YYSTYPE lvalp, void pc) {
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
	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 698 int yylex(YYSTYPE lvalp, void pc) {	Line 878 int yylex(YYSTYPE lvalp, void pc) {
lexical_brackets_nestage++;	lexical_brackets_nestage++;
RC;	RC;
case '-':	case '-':
if(*PC->source=='f') { // -f	switch(*PC.source) {
	case 'f': // -f
skip_analized=1;	skip_analized=1;
result=FEXISTS;	result=FEXISTS;
} else	goto break2;
	case 'd': // -d
	skip_analized=1;
	result=DEXISTS;
	goto break2;
	default: // minus
result=c;	result=c;
	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;
	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;	goto break2;

case '"':	case '"':
push_LS(PC, LS_EXPRESSION_STRING);	push_LS(PC, LS_EXPRESSION_STRING_QUOTED);
	RC;
	case '\'':
	push_LS(PC, LS_EXPRESSION_STRING_APOSTROFED);
RC;	RC;
case 'l': case 'g': case 'e': case 'n':	case 'l': case 'g': case 'e': case 'n':
if(end==begin) // right after whitespace	if(end==begin) // right after whitespace
switch(*PC->source) {	if(isspace(PC.source[1])) {
// case '?': // ok [and bad cases, yacc would bark at them]	switch(*PC.source) {
case 't': // lt gt [et nt]	// case '?': // ok [and bad cases, yacc would bark at them]
result=c=='l'?SLT:c=='g'?SGT:BAD_STRING_COMPARISON_OPERATOR;	case 't': // lt gt [et nt]
skip_analized=1;	result=c=='l'?SLT:c=='g'?SGT:BAD_STRING_COMPARISON_OPERATOR;
goto break2;	skip_analized=1;
case 'e': // le ge ne [ee]	goto break2;
result=c=='l'?SLE:c=='g'?SGE:c=='n'?SNE:BAD_STRING_COMPARISON_OPERATOR;	case 'e': // le ge ne [ee]
skip_analized=1;	result=c=='l'?SLE:c=='g'?SGE:c=='n'?SNE:BAD_STRING_COMPARISON_OPERATOR;
goto break2;	skip_analized=1;
case 'q': // eq [lq gq nq]	goto break2;
result=c=='e'?SEQ:BAD_STRING_COMPARISON_OPERATOR;	case 'q': // eq [lq gq nq]
skip_analized=1;	result=c=='e'?SEQ:BAD_STRING_COMPARISON_OPERATOR;
goto break2;	skip_analized=1;
	goto break2;
	}
}	}
break;	break;
case 'i':	case 'i':
if(end==begin) // right after whitespace	if(end==begin) // right after whitespace
switch(PC->source[0]) {	if(isspace(PC.source[1])) {
case 'n':	switch(PC.source[0]) {
{ // in	case 'n': // in
skip_analized=1;	skip_analized=1;
result=IN;	result=IN;
goto break2;	goto break2;
}	case 's': // is
case 's':
{ // is
skip_analized=1;	skip_analized=1;
result=IS;	result=IS;
goto break2;	goto break2;
Line 767 int yylex(YYSTYPE lvalp, void pc) {	Line 992 int yylex(YYSTYPE lvalp, void pc) {
break;	break;
case 'd':	case 'd':
if(end==begin) // right after whitespace	if(end==begin) // right after whitespace
if(PC->source[0]=='e' && PC->source[1]=='f') { // def	if(PC.source[0]=='e' && PC.source[1]=='f') { // def
skip_analized=2;	skip_analized=2;
result=DEF;	result=DEF;
goto break2;	goto break2;
Line 781 int yylex(YYSTYPE lvalp, void pc) {	Line 1006 int yylex(YYSTYPE lvalp, void pc) {
// that's a leading\|traling space or after-operator-space	// that's a leading\|traling space or after-operator-space
// ignoring it	// ignoring it
// reset piece 'begin' position & line	// reset piece 'begin' position & line
begin=PC->source; // after whitespace char	begin=PC.source; // after whitespace char
begin_line=PC->line;	begin_line=PC.line;
	continue;
	}
	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;	continue;
}	}
break;	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:
if(PC->ls==LS_EXPRESSION_VAR_NAME) {	case LS_EXPRESSION_VAR_NAME_WITH_COLON:
// name in expr ends also before binary operators	case LS_EXPRESSION_VAR_NAME_WITHOUT_COLON:
	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;
	goto break2;
	}
	}
	if(
	PC.ls==LS_VAR_NAME_SIMPLE_WITHOUT_COLON \|\|
	PC.ls==LS_EXPRESSION_VAR_NAME_WITHOUT_COLON) {
	// name already has ':', stop before next
	switch(c) {
	case ':':
	pop_LS(PC);
	PC.source--; if(--PC.col<0) { PC.line--; PC.col=-1; }
result=EON;	result=EON;
goto break2;	goto break2;
}	}
Line 804 int yylex(YYSTYPE lvalp, void pc) {	Line 1066 int yylex(YYSTYPE lvalp, void pc) {
case 0:	case 0:
case ' ': case '\t': case '\n':	case ' ': case '\t': case '\n':
case ';':	case ';':
case ']': case '}': case ')': case '"':	case ']': case '}': case ')':
case '<': case '>': // these stand for HTML brackets and expression binary ops	case '"': case '\'':
	case '<': case '>': // these stand for HTML brackets AND expression binary ops
case '+': case '*': case '/': case '%':	case '+': case '*': case '/': case '%':
case '&': case '\|':	case '&': case '\|':
case '=': case '!':	case '=': case '!':
	// common delimiters
	case ',': case '?': case '#':
	// before call
	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;
case '[':	case '[':
PC->ls=LS_VAR_SQUARE;	// $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;
lexical_brackets_nestage=1;	lexical_brackets_nestage=1;
RC;	RC;
case '{':	case '{':
if(begin==end) { // ${name}, no need of EON, switching LS	if(begin==end) { // ${name}, no need of EON, switching LS
PC->ls=LS_VAR_NAME_CURLY;	PC.ls=LS_VAR_NAME_CURLY;
} else {	} else {
PC->ls=LS_VAR_CURLY;	PC.ls=LS_VAR_CURLY;
lexical_brackets_nestage=1;	lexical_brackets_nestage=1;
}	}

RC;	RC;
case '(':	case '(':
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 ':': // ':name' or 'class:name'	case ':': // class<:>name
	// 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 '[':
	// ${name.<[>code]}
	push_LS(PC, LS_NAME_SQUARE_PART);
	lexical_brackets_nestage=1;
	RC;
case '}': // ${name} finished, restoring LS	case '}': // ${name} finished, restoring LS
pop_LS(PC);	pop_LS(PC);
RC;	RC;
Line 852 int yylex(YYSTYPE lvalp, void pc) {	Line 1140 int yylex(YYSTYPE lvalp, void pc) {
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 874 int yylex(YYSTYPE lvalp, void pc) {	Line 1162 int yylex(YYSTYPE lvalp, void pc) {
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 895 int yylex(YYSTYPE lvalp, void pc) {	Line 1183 int yylex(YYSTYPE lvalp, void pc) {
case LS_METHOD_NAME:	case LS_METHOD_NAME:
switch(c) {	switch(c) {
case '[':	case '[':
PC->ls=LS_METHOD_SQUARE;	// ^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;
lexical_brackets_nestage=1;	lexical_brackets_nestage=1;
RC;	RC;
case '{':	case '{':
PC->ls=LS_METHOD_CURLY;	PC.ls=LS_METHOD_CURLY;
lexical_brackets_nestage=1;	lexical_brackets_nestage=1;
RC;	RC;
case '(':	case '(':
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 916 int yylex(YYSTYPE lvalp, void pc) {	Line 1216 int yylex(YYSTYPE lvalp, void pc) {
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 925 int yylex(YYSTYPE lvalp, void pc) {	Line 1225 int yylex(YYSTYPE lvalp, void pc) {
RC;	RC;
case ']':	case ']':
if(--lexical_brackets_nestage==0) {	if(--lexical_brackets_nestage==0) {
PC->ls=LS_METHOD_AFTER;	PC.ls=LS_METHOD_AFTER;
RC;	RC;
}	}
break;	break;
Line 938 int yylex(YYSTYPE lvalp, void pc) {	Line 1238 int yylex(YYSTYPE lvalp, void pc) {
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 947 int yylex(YYSTYPE lvalp, void pc) {	Line 1247 int yylex(YYSTYPE lvalp, void pc) {
RC;	RC;
case '}':	case '}':
if(--lexical_brackets_nestage==0) {	if(--lexical_brackets_nestage==0) {
PC->ls=LS_METHOD_AFTER;	PC.ls=LS_METHOD_AFTER;
RC;	RC;
}	}
break;	break;
Line 959 int yylex(YYSTYPE lvalp, void pc) {	Line 1259 int yylex(YYSTYPE lvalp, void pc) {

case LS_METHOD_AFTER:	case LS_METHOD_AFTER:
if(c=='[') {/* ][ }[ )[ */	if(c=='[') {/* ][ }[ )[ */
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->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;
}	}
Line 989 break2:	Line 1289 break2:
if((c=='@' \|\| c==0) && end[-1]=='\n') { // we are before LS_DEF_NAME or EOF?	if((c=='@' \|\| c==0) && end[-1]=='\n') { // we are before LS_DEF_NAME or EOF?
// strip last \n	// strip last \n
end--;	end--;
	if(end!=begin && end[-1]=='\n') // allow one empty line before LS_DEF_NAME
	end--;
}	}
if(end!=begin) { // last piece still alive?	if(end!=begin && PC.ls!=LS_USER_COMMENT) { // last piece still alive and not comment?
// append it	// append it
PC->string->APPEND(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(NEW VString(PC.string));
// new pieces storage	// new pieces storage
PC->string=NEW String(POOL);	PC.string=NEW String(POOL);
// 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;
}	}
if(skip_analized) {	if(skip_analized) {
PC->source+=skip_analized; PC->col+=skip_analized;	PC.source+=skip_analized; PC.col+=skip_analized;
}	}
return result;	return result;
}	}

int real_yyerror(parse_control pc, char s) /* Called by yyparse on error */	static int real_yyerror(parse_control pc, char s) { // Called by yyparse on error
{	strncpy(PC.error, s, MAX_STRING);
//fprintf(stderr, "[%s]\n", s);

strncpy(pc->error, s, MAX_STRING); // TODO: ��
return 1;	return 1;
}	}

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

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

E-mail:

Removed from v.1.95
changed lines
	Added in v.1.203