parser3/src/main/execute.C - diff

Return to execute.C CVS log

Up to [parser3project] / parser3 / src / main

Diff for /parser3/src/main/execute.C between versions 1.360 and 1.413

version 1.360, 2010/04/19 19:39:54	version 1.413, 2020/12/31 12:08:35
Line 1	Line 1
/** @file	/** @file
Parser: executor part of request class.	Parser: executor part of request class.

Copyright (c) 2001-2009 ArtLebedev Group (http://www.artlebedev.com)	Copyright (c) 2001-2020 Art. Lebedev Studio (http://www.artlebedev.com)
Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
*/	*/

static const char * const IDENT_EXECUTE_C="$Date$";

#include "pa_opcode.h"	#include "pa_opcode.h"
#include "pa_array.h"	#include "pa_array.h"
#include "pa_request.h"	#include "pa_request.h"
Line 23 static const char * const IDENT_EXECUTE_	Line 21 static const char * const IDENT_EXECUTE_
#include "pa_vimage.h"	#include "pa_vimage.h"
#include "pa_wwrapper.h"	#include "pa_wwrapper.h"

	volatile const char * IDENT_EXECUTE_C="$Id$" IDENT_PA_OPCODE_H IDENT_PA_OPERATION_H IDENT_PA_VCODE_FRAME_H IDENT_PA_WWRAPPER_H;

//#define DEBUG_EXECUTE	//#define DEBUG_EXECUTE

#ifdef DEBUG_EXECUTE	#ifdef DEBUG_EXECUTE
char *opcode_name[]={	const char *opcode_name[]={
// literals	// literals
"VALUE", "CURLY_CODE__STORE_PARAM", "EXPR_CODE__STORE_PARAM",	"VALUE", "CURLY_CODE__STORE_PARAM", "EXPR_CODE__STORE_PARAM",
"NESTED_CODE",	"NESTED_CODE",

// actions	// actions
"WITH_ROOT", "WITH_SELF", "WITH_READ", "WITH_WRITE",	"WITH_ROOT", "WITH_SELF", "WITH_READ", "WITH_WRITE",
#ifdef OPTIMIZE_BYTECODE_GET_CLASS	"VALUE__GET_CLASS", "VALUE__GET_BASE_CLASS",
"VALUE__GET_CLASS",
#else
"GET_CLASS",
#endif
"CONSTRUCT_VALUE", "CONSTRUCT_EXPR", "CURLY_CODE__CONSTRUCT",	"CONSTRUCT_VALUE", "CONSTRUCT_EXPR", "CURLY_CODE__CONSTRUCT",
"WRITE_VALUE", "WRITE_EXPR_RESULT", "STRING__WRITE",	"WRITE_VALUE", "WRITE_EXPR_RESULT", "STRING__WRITE",
#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT	#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT
Line 64 char *opcode_name[]={	Line 60 char *opcode_name[]={
"WITH_SELF__VALUE__GET_ELEMENT",	"WITH_SELF__VALUE__GET_ELEMENT",
"WITH_SELF__VALUE__GET_ELEMENT__WRITE",	"WITH_SELF__VALUE__GET_ELEMENT__WRITE",
#endif	#endif

	#ifdef FEATURE_GET_ELEMENT4CALL
	"GET_ELEMENT4CALL",
	#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_ELEMENT
	"GET_OBJECT_ELEMENT4CALL",
	#endif
	#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_VAR_ELEMENT
	"GET_OBJECT_VAR_ELEMENT4CALL",
	#endif
	#endif // FEATURE_GET_ELEMENT4CALL

"OBJECT_POOL", "STRING_POOL",	"OBJECT_POOL", "STRING_POOL",
"PREPARE_TO_CONSTRUCT_OBJECT",	"PREPARE_TO_CONSTRUCT_OBJECT",
"CONSTRUCT_OBJECT",	"CONSTRUCT_OBJECT",
"CONSTRUCT_OBJECT__WRITE",	"CONSTRUCT_OBJECT__WRITE",
"PREPARE_TO_EXPRESSION",
"CALL", "CALL__WRITE",	"CALL", "CALL__WRITE",

#ifdef OPTIMIZE_BYTECODE_CONSTRUCT	#ifdef OPTIMIZE_BYTECODE_CONSTRUCT
Line 80 char *opcode_name[]={	Line 86 char *opcode_name[]={
"WITH_SELF__VALUE__CONSTRUCT_VALUE",	"WITH_SELF__VALUE__CONSTRUCT_VALUE",
#endif	#endif

	#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT__SPECIAL
	"GET_ELEMENT__SPECIAL",
	"GET_ELEMENT__SPECIAL__WRITE",
	#endif
// expression ops: unary	// expression ops: unary
"NEG", "INV", "NOT", "DEF", "IN", "FEXISTS", "DEXISTS",	"NEG", "INV", "NOT", "DEF", "IN", "FEXISTS", "DEXISTS",
// expression ops: binary	// expression ops: binary
Line 99 const char* debug_value_to_cstr(Value& v	Line 109 const char* debug_value_to_cstr(Value& v
return string->cstr();	return string->cstr();
else	else
if(value.is_bool())	if(value.is_bool())
return value.as_bool()?"<true>":"<false>";	return value.as_bool() ? "<true>" : "<false>";
else	else
return "<value>";	return "<value>";
}	}
Line 128 void debug_dump(SAPI_Info& sapi_info, in	Line 138 void debug_dump(SAPI_Info& sapi_info, in
#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_ELEMENT	#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_ELEMENT
\|\| opcode==OP::OP_GET_OBJECT_ELEMENT	\|\| opcode==OP::OP_GET_OBJECT_ELEMENT
\|\| opcode==OP::OP_GET_OBJECT_ELEMENT__WRITE	\|\| opcode==OP::OP_GET_OBJECT_ELEMENT__WRITE
	#ifdef FEATURE_GET_ELEMENT4CALL
	\|\| opcode==OP::OP_GET_OBJECT_ELEMENT4CALL
	#endif
#endif	#endif
#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_VAR_ELEMENT	#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_VAR_ELEMENT
\|\| opcode==OP::OP_GET_OBJECT_VAR_ELEMENT	\|\| opcode==OP::OP_GET_OBJECT_VAR_ELEMENT
\|\| opcode==OP::OP_GET_OBJECT_VAR_ELEMENT__WRITE	\|\| opcode==OP::OP_GET_OBJECT_VAR_ELEMENT__WRITE
	#ifdef FEATURE_GET_ELEMENT4CALL
	\|\| opcode==OP::OP_GET_OBJECT_VAR_ELEMENT4CALL
	#endif
#endif	#endif
){	){
i.next(); // skip origin	i.next(); // skip origin
Value& value1=*i.next().value;	Value& value1=*i.next().value;
i.next(); // skip origin	i.next(); // skip origin
Value& value2=*i.next().value;	Value& value2=*i.next().value;
debug_printf(sapi_info,	debug_printf(sapi_info, "%s%s \"%s\" \"%s\"", level4, "", opcode_name[opcode], debug_value_to_cstr(value1), debug_value_to_cstr(value2));
"%*s%s"
" \"%s\" \"%s\"",
level*4, "", opcode_name[opcode],
debug_value_to_cstr(value1), debug_value_to_cstr(value2));
continue;	continue;
}	}
#endif	#endif
Line 167 void debug_dump(SAPI_Info& sapi_info, in	Line 179 void debug_dump(SAPI_Info& sapi_info, in
if(	if(
opcode==OP::OP_VALUE	opcode==OP::OP_VALUE
\|\| opcode==OP::OP_STRING__WRITE	\|\| opcode==OP::OP_STRING__WRITE
#ifdef OPTIMIZE_BYTECODE_GET_CLASS
\|\| opcode==OP::OP_VALUE__GET_CLASS	\|\| opcode==OP::OP_VALUE__GET_CLASS
#endif	\|\| opcode==OP::OP_VALUE__GET_BASE_CLASS
#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT	#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT
\|\| opcode==OP::OP_VALUE__GET_ELEMENT	\|\| opcode==OP::OP_VALUE__GET_ELEMENT
\|\| opcode==OP::OP_VALUE__GET_ELEMENT__WRITE	\|\| opcode==OP::OP_VALUE__GET_ELEMENT__WRITE
Line 231 void debug_dump(SAPI_Info& sapi_info, in	Line 242 void debug_dump(SAPI_Info& sapi_info, in
#define DEBUG_PRINT_OPS(local_ops)	#define DEBUG_PRINT_OPS(local_ops)
#endif	#endif


// Request	// Request

void Request::execute(ArrayOperation& ops) {	void Request::execute(ArrayOperation& ops) {
Line 263 void Request::execute(ArrayOperation& op	Line 273 void Request::execute(ArrayOperation& op
stack.push(value);	stack.push(value);
break;	break;
}	}

#ifdef OPTIMIZE_BYTECODE_GET_CLASS
case OP::OP_VALUE__GET_CLASS:	case OP::OP_VALUE__GET_CLASS:
{	{
// maybe they do ^class:method[] call, remember the fact
wcontext->set_somebody_entered_some_class();

debug_origin=i.next().origin;	debug_origin=i.next().origin;
Value& value=*i.next().value;	const String& name=*i.next().value->get_string(); debug_name=&name;
const String& name=*value.get_string(); debug_name=&name;

DEBUG_PRINT_STRING(name)	DEBUG_PRINT_STRING(name)

Value* class_value=get_class(name);	stack.push(get_class_ref(name));
if(!class_value)
throw Exception(PARSER_RUNTIME,
&name,
"class is undefined");

stack.push(*class_value);
break;	break;
}	}
#else
case OP::OP_GET_CLASS:	case OP::OP_VALUE__GET_BASE_CLASS:
{	{
// maybe they do ^class:method[] call, remember the fact	// ^class:method[] call
wcontext->set_somebody_entered_some_class();
	debug_origin=i.next().origin;
	const String& name=*i.next().value->get_string(); debug_name=&name;

const String& name=stack.pop().string(); debug_name=&name;	DEBUG_PRINT_STRING(name)
Value* value=get_class(name);
if(!value)
throw Exception(PARSER_RUNTIME,
&name,
"class is undefined");

stack.push(*value);	stack.push(*new VBaseClassWrapper(get_class_ref(name), get_self()));
	break;
	}

	#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT__SPECIAL
	case OP::OP_GET_ELEMENT__SPECIAL:
	case OP::OP_GET_ELEMENT__SPECIAL__WRITE:
	{
	const String& name=stack.pop().string(); debug_name=&name;
	Value& ncontext=stack.pop().value();

	Value* value=0;
	if(VStateless_class* vclass=ncontext.get_class()){
	if(SYMBOLS_EQ(name,CLASS_SYMBOL)){
	value=vclass;
	} else if(SYMBOLS_EQ(name,CLASS_NAME_SYMBOL)){
	value=new VString(*new String(vclass->type()));
	}
	} else {
	// VJunction is without class, returning self
	if(SYMBOLS_EQ(name,CLASS_SYMBOL)){
	value=&ncontext;
	} else if(SYMBOLS_EQ(name,CLASS_NAME_SYMBOL)){
	value=new VString(*new String(ncontext.type()));
	}
	}
	if(opcode==OP::OP_GET_ELEMENT__SPECIAL){
	stack.push(*value);
	} else {
	write(*value);
	}
break;	break;
}	}
#endif	#endif

// OP_WITH	// OP_WITH
case OP::OP_WITH_ROOT:	case OP::OP_WITH_ROOT:
{	{
Line 321 void Request::execute(ArrayOperation& op	Line 347 void Request::execute(ArrayOperation& op
case OP::OP_WITH_WRITE:	case OP::OP_WITH_WRITE:
{	{
if(wcontext==method_frame)	if(wcontext==method_frame)
throw Exception(PARSER_RUNTIME,	throw Exception(PARSER_RUNTIME, 0, "$.name outside of $name[...]");
0,
"$.name outside of $name[...]");

stack.push(*wcontext);	stack.push(*wcontext);
break;	break;
Line 332 void Request::execute(ArrayOperation& op	Line 356 void Request::execute(ArrayOperation& op
// OTHER ACTIONS BUT WITHs	// OTHER ACTIONS BUT WITHs

#ifdef OPTIMIZE_BYTECODE_CONSTRUCT	#ifdef OPTIMIZE_BYTECODE_CONSTRUCT
#define DO_CONSTRUCT(context, vvalue) { \	#define DO_CONSTRUCT(context, vvalue) { \
debug_origin=i.next().origin; \	debug_origin=i.next().origin; \
const String& name=*i.next().value->get_string(); debug_name=&name; \	const String& name=*i.next().value->get_string(); debug_name=&name; \
DEBUG_PRINT_STRING(name) \	DEBUG_PRINT_STRING(name) \
Value& value=stack.pop().value(); \	Value& value=stack.pop().value(); \
put_element( context, name, vvalue ); \	put_element( context, name, vvalue ); \
break; \	goto check_skip; \
}	}
#define DO_CONSTRUCT_VALUE(context) DO_CONSTRUCT(context, &value)	#define DO_CONSTRUCT_VALUE(context) DO_CONSTRUCT(context, &value)
#define DO_CONSTRUCT_EXPR(context) { \	#define DO_CONSTRUCT_EXPR(context) { \
wcontext->set_in_expression(false); \
DO_CONSTRUCT(context, &value.as_expr_result()) \	DO_CONSTRUCT(context, &value.as_expr_result()) \
}	}

Line 382 void Request::execute(ArrayOperation& op	Line 405 void Request::execute(ArrayOperation& op
Value& ncontext=stack.pop().value();	Value& ncontext=stack.pop().value();
#endif	#endif
put_element(ncontext, name, &value);	put_element(ncontext, name, &value);
	goto check_skip;
break;
}	}

case OP::OP_CONSTRUCT_EXPR:	case OP::OP_CONSTRUCT_EXPR:
{	{
// see OP_PREPARE_TO_EXPRESSION
wcontext->set_in_expression(false);

#ifdef OPTIMIZE_BYTECODE_CONSTRUCT	#ifdef OPTIMIZE_BYTECODE_CONSTRUCT
const String& name=stack.pop().string(); debug_name=&name;	const String& name=stack.pop().string(); debug_name=&name;
Value& ncontext=stack.pop().value();	Value& ncontext=stack.pop().value();
Line 402 void Request::execute(ArrayOperation& op	Line 421 void Request::execute(ArrayOperation& op
#endif	#endif
Value& value=expr.as_expr_result();	Value& value=expr.as_expr_result();
put_element(ncontext, name, &value);	put_element(ncontext, name, &value);
break;	goto check_skip;
}	}

case OP::OP_CURLY_CODE__CONSTRUCT:	case OP::OP_CURLY_CODE__CONSTRUCT:
Line 422 void Request::execute(ArrayOperation& op	Line 441 void Request::execute(ArrayOperation& op

const String& name=stack.pop().string(); debug_name=&name;	const String& name=stack.pop().string(); debug_name=&name;
Value& ncontext=stack.pop().value();	Value& ncontext=stack.pop().value();
if(const VJunction* vjunction=ncontext.put_element(name, &value, false))	if(const VJunction* vjunction=ncontext.put_element(name, &value))
if(vjunction!=PUT_ELEMENT_REPLACED_ELEMENT)	throw Exception(PARSER_RUNTIME, 0, "property value can not be code, use [] or () brackets");
throw Exception(PARSER_RUNTIME,
0,
"property value can not be code, use [] or () brackets");

break;	break;
}	}
case OP::OP_NESTED_CODE:	case OP::OP_NESTED_CODE:
Line 442 void Request::execute(ArrayOperation& op	Line 458 void Request::execute(ArrayOperation& op
case OP::OP_WRITE_VALUE:	case OP::OP_WRITE_VALUE:
{	{
Value& value=stack.pop().value();	Value& value=stack.pop().value();
write_assign_lang(value);	write(value);
break;	break;
}	}
case OP::OP_WRITE_EXPR_RESULT:	case OP::OP_WRITE_EXPR_RESULT:
{	{
// see OP_PREPARE_TO_EXPRESSION
wcontext->set_in_expression(false);

Value& value=stack.pop().value();	Value& value=stack.pop().value();
wcontext->write(value.as_expr_result());	wcontext->write(value.as_expr_result());
break;	break;
Line 463 void Request::execute(ArrayOperation& op	Line 476 void Request::execute(ArrayOperation& op

DEBUG_PRINT_STRING(string_value)	DEBUG_PRINT_STRING(string_value)

write_no_lang(string_value);	write(string_value);
break;	break;
}	}

Line 482 void Request::execute(ArrayOperation& op	Line 495 void Request::execute(ArrayOperation& op
}	}
Value& value=get_element(*rcontext, name);	Value& value=get_element(*rcontext, name);
stack.push(value);	stack.push(value);
break;	goto check_skip;
}	}
#else	#else
case OP::OP_GET_ELEMENT_OR_OPERATOR:	case OP::OP_GET_ELEMENT_OR_OPERATOR:
Line 496 void Request::execute(ArrayOperation& op	Line 509 void Request::execute(ArrayOperation& op
}	}
Value& value=get_element(ncontext, name);	Value& value=get_element(ncontext, name);
stack.push(value);	stack.push(value);
break;	goto check_skip;
}	}
#endif	#endif

#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_ELEMENT	#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_ELEMENT
case OP::OP_GET_OBJECT_ELEMENT:
case OP::OP_GET_OBJECT_ELEMENT__WRITE:
{
debug_origin=i.next().origin;
const String& context_name=*i.next().value->get_string(); debug_name=&context_name;

DEBUG_PRINT_STRING(context_name)

Value& object=get_element(*rcontext, context_name);	#define DO_GET_OBJECT_ELEMENT(code) {\
	debug_origin=i.next().origin; \
debug_origin=i.next().origin;	const String& context_name=*i.next().value->get_string(); debug_name=&context_name; \
const String& field_name=*i.next().value->get_string(); debug_name=&field_name;	DEBUG_PRINT_STRING(context_name) \
	Value& object=get_element(*rcontext, context_name); \
DEBUG_PRINT_STRING(field_name)	debug_origin=i.next().origin; \
	const String& field_name=*i.next().value->get_string(); debug_name=&field_name; \
	DEBUG_PRINT_STRING(field_name) \
	code; \
	goto check_skip; \
	}

	case OP::OP_GET_OBJECT_ELEMENT: DO_GET_OBJECT_ELEMENT({
Value& value=get_element(object, field_name);	Value& value=get_element(object, field_name);
	stack.push(value);
if(opcode==OP::OP_GET_OBJECT_ELEMENT){	})
stack.push(value);	case OP::OP_GET_OBJECT_ELEMENT__WRITE: DO_GET_OBJECT_ELEMENT({
} else {	Value& value=get_element(object, field_name);
write_assign_lang(value);	write(value);
}	})
break;	#ifdef FEATURE_GET_ELEMENT4CALL
}	case OP::OP_GET_OBJECT_ELEMENT4CALL: DO_GET_OBJECT_ELEMENT({
	Value& value=get_element4call(object, field_name);
	stack.push(value);
	})
	#endif
#endif	#endif

#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_VAR_ELEMENT	#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_VAR_ELEMENT
case OP::OP_GET_OBJECT_VAR_ELEMENT:
case OP::OP_GET_OBJECT_VAR_ELEMENT__WRITE:
{
debug_origin=i.next().origin;
const String& context_name=*i.next().value->get_string(); debug_name=&context_name;

DEBUG_PRINT_STRING(context_name)

Value& object=get_element(*rcontext, context_name);

debug_origin=i.next().origin;
const String& var_name=*i.next().value->get_string(); debug_name=&var_name;

DEBUG_PRINT_STRING(var_name)

const String* field=&get_element(*rcontext, var_name).as_string();	#define DO_GET_OBJECT_VAR_ELEMENT(code) {\
	debug_origin=i.next().origin; \
	const String& context_name=*i.next().value->get_string(); debug_name=&context_name; \
	DEBUG_PRINT_STRING(context_name) \
	Value& object=get_element(*rcontext, context_name); \
	debug_origin=i.next().origin; \
	const String& var_name=*i.next().value->get_string(); debug_name=&var_name; \
	DEBUG_PRINT_STRING(var_name) \
	const String* field=&get_element(*rcontext, var_name).as_string(); \
	code; \
	goto check_skip; \
	}

	case OP::OP_GET_OBJECT_VAR_ELEMENT: DO_GET_OBJECT_VAR_ELEMENT({
Value& value=get_element(object, *field);	Value& value=get_element(object, *field);
	stack.push(value);
if(opcode==OP::OP_GET_OBJECT_VAR_ELEMENT){	})
stack.push(value);	case OP::OP_GET_OBJECT_VAR_ELEMENT__WRITE: DO_GET_OBJECT_VAR_ELEMENT({
} else {	Value& value=get_element(object, *field);
write_assign_lang(value);	write(value);
}	})
break;	#ifdef FEATURE_GET_ELEMENT4CALL
}	case OP::OP_GET_OBJECT_VAR_ELEMENT4CALL: DO_GET_OBJECT_VAR_ELEMENT({
	Value& value=get_element4call(object, *field);
	stack.push(value);
	})
	#endif
#endif	#endif

case OP::OP_GET_ELEMENT:	case OP::OP_GET_ELEMENT:
Line 562 void Request::execute(ArrayOperation& op	Line 580 void Request::execute(ArrayOperation& op
Value& ncontext=stack.pop().value();	Value& ncontext=stack.pop().value();
Value& value=get_element(ncontext, name);	Value& value=get_element(ncontext, name);
stack.push(value);	stack.push(value);
break;	goto check_skip;
	}

	#ifdef FEATURE_GET_ELEMENT4CALL
	case OP::OP_GET_ELEMENT4CALL:
	{
	const String& name=stack.pop().string(); debug_name=&name;
	Value& ncontext=stack.pop().value();
	Value& value=get_element4call(ncontext, name);
	stack.push(value);
	goto check_skip;
}	}
	#endif

case OP::OP_GET_ELEMENT__WRITE:	case OP::OP_GET_ELEMENT__WRITE:
{	{
const String& name=stack.pop().string(); debug_name=&name;	const String& name=stack.pop().string(); debug_name=&name;
Value& ncontext=stack.pop().value();	Value& ncontext=stack.pop().value();
Value& value=get_element(ncontext, name);	Value& value=get_element(ncontext, name);
write_assign_lang(value);	write(value);
break;	goto check_skip;
}	}

#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT	#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT
Line 584 void Request::execute(ArrayOperation& op	Line 613 void Request::execute(ArrayOperation& op

Value& value=get_element(*rcontext, name);	Value& value=get_element(*rcontext, name);
stack.push(value);	stack.push(value);
break;	goto check_skip;
}	}

case OP::OP_VALUE__GET_ELEMENT__WRITE:	case OP::OP_VALUE__GET_ELEMENT__WRITE:
Line 595 void Request::execute(ArrayOperation& op	Line 624 void Request::execute(ArrayOperation& op
DEBUG_PRINT_STRING(name)	DEBUG_PRINT_STRING(name)

Value& value=get_element(*rcontext, name);	Value& value=get_element(*rcontext, name);
write_assign_lang(value);	write(value);
break;	goto check_skip;
}	}

case OP::OP_WITH_ROOT__VALUE__GET_ELEMENT:	case OP::OP_WITH_ROOT__VALUE__GET_ELEMENT:
Line 608 void Request::execute(ArrayOperation& op	Line 637 void Request::execute(ArrayOperation& op

Value& value=get_element(*method_frame, name);	Value& value=get_element(*method_frame, name);
stack.push(value);	stack.push(value);
break;	goto check_skip;
}	}
#endif	#endif

Line 626 void Request::execute(ArrayOperation& op	Line 655 void Request::execute(ArrayOperation& op
if(opcode==OP::OP_WITH_SELF__VALUE__GET_ELEMENT){	if(opcode==OP::OP_WITH_SELF__VALUE__GET_ELEMENT){
stack.push(value);	stack.push(value);
} else {	} else {
write_assign_lang(value);	write(value);
}	}
break;	goto check_skip;
}	}
#endif	#endif

case OP::OP_OBJECT_POOL:	case OP::OP_OBJECT_POOL:
{	{
	debug_name=0;

ArrayOperation& local_ops=*i.next().ops;	ArrayOperation& local_ops=*i.next().ops;

WContext *saved_wcontext=wcontext;	WContext *saved_wcontext=wcontext;
String::Language saved_lang=flang;
flang=String::L_PASS_APPENDED;
#ifdef OPTIMIZE_SINGLE_STRING_WRITE	#ifdef OPTIMIZE_SINGLE_STRING_WRITE
WObjectPoolWrapper local(wcontext);	WObjectPoolWrapper local(wcontext);
#else	#else
Line 648 void Request::execute(ArrayOperation& op	Line 677 void Request::execute(ArrayOperation& op

execute(local_ops);	execute(local_ops);

stack.push(wcontext->result().as_value());	stack.push((Value&)wcontext->result());
flang=saved_lang;
wcontext=saved_wcontext;	wcontext=saved_wcontext;
break;	goto check_skip;
}	}

case OP::OP_STRING_POOL:	case OP::OP_STRING_POOL:
Line 664 void Request::execute(ArrayOperation& op	Line 693 void Request::execute(ArrayOperation& op

execute(local_ops);	execute(local_ops);

Value* value;
// from "$a $b" part of expression taking only string value,	// from "$a $b" part of expression taking only string value,
// ignoring any other content of wcontext	// ignoring any other content of wcontext
if(const String* string=wcontext->get_string())	const String* string=wcontext->get_string();
value=new VString(*string);	Value* value=string ? new VString(*string) : new VString();
else
value=VVoid::get();
stack.push(*value);	stack.push(*value);

wcontext=saved_wcontext;	wcontext=saved_wcontext;
break;	goto check_skip;
}	}

// CALL	// CALL
Line 708 void Request::execute(ArrayOperation& op	Line 734 void Request::execute(ArrayOperation& op
break;	break;
}	}

case OP::OP_PREPARE_TO_EXPRESSION:	#define METHOD_PARAMS_ACTION(action) \
{	if(local_ops){ \
wcontext->set_in_expression(true);	size_t first = stack.top_index(); \
break;	execute(*local_ops); \
}	if(!fskip){ \
	frame.store_params((Value**)stack.ptr(first), stack.top_index()-first); \
#define METHOD_FRAME_ACTION(action) \	action; \
if(local_ops){ \	} \
size_t first = stack.top_index(); \	stack.set_top_index(first); \
execute(*local_ops); \	} else { \
frame.store_params((Value**)stack.ptr(first), stack.top_index()-first); \	frame.empty_params(); \
action; \	action; \
stack.set_top_index(first); \
} else { \
frame.empty_params(); \
action; \
}	}

case OP::OP_CALL:	case OP::OP_CALL:
Line 738 void Request::execute(ArrayOperation& op	Line 760 void Request::execute(ArrayOperation& op
Junction* junction=value.get_junction();	Junction* junction=value.get_junction();
if(!junction) {	if(!junction) {
if(value.is("void"))	if(value.is("void"))
throw Exception(PARSER_RUNTIME,	throw Exception(PARSER_RUNTIME, 0, "undefined method");
0,
"undefined method");
else	else
throw Exception(PARSER_RUNTIME,	throw Exception(PARSER_RUNTIME, 0, "is '%s', not a method or junction, can not call it", value.type());
0,
"is '%s', not a method or junction, can not call it",
value.type());
}	}

VMethodFrame frame(*junction, method_frame);	Value *result;
METHOD_FRAME_ACTION(op_call(frame, false));	{
stack.push(frame.result().as_value());	EXPRESSION_FRAME_ACTION(*junction->method, method_frame, junction->self, {
	METHOD_PARAMS_ACTION(call(frame));
	result=&frame.result();
	// desctructor deletes junctions in stack params here
	});
	}
	stack.push(*result);

DEBUG_PRINT_STR("<-returned")	DEBUG_PRINT_STR("<-returned")
	goto check_skip;
if(get_skip())
return;
if(get_interrupted()) {
set_interrupted(false);
throw Exception("parser.interrupted",
0,
"execution stopped");
}
break;
}	}

case OP::OP_CALL__WRITE:	case OP::OP_CALL__WRITE:
Line 777 void Request::execute(ArrayOperation& op	Line 791 void Request::execute(ArrayOperation& op
Junction* junction=value.get_junction();	Junction* junction=value.get_junction();
if(!junction) {	if(!junction) {
if(value.is("void"))	if(value.is("void"))
throw Exception(PARSER_RUNTIME,	throw Exception(PARSER_RUNTIME, 0, "undefined method");
0,
"undefined method");
else	else
throw Exception(PARSER_RUNTIME,	throw Exception(PARSER_RUNTIME, 0, "is '%s', not a method or junction, can not call it", value.type());
0,
"is '%s', not a method or junction, can not call it",
value.type());
}	}

#ifdef OPTIMIZE_CALL
const Method& method=*junction->method;	const Method& method=*junction->method;
	#ifdef OPTIMIZE_CALL
if(method.call_optimization==Method::CO_WITHOUT_FRAME){	if(method.call_optimization==Method::CO_WITHOUT_FRAME){
if(local_ops){ // store param code goes here	if(local_ops){ // store param code goes here
size_t first = stack.top_index();	size_t first = stack.top_index();
execute(*local_ops);	execute(*local_ops);

MethodParams method_params;	if(!fskip){
method_params.store_params((Value**)stack.ptr(first), stack.top_index()-first);	MethodParams method_params;
method.check_actual_numbered_params(junction->self, &method_params);	method_params.store_params((Value**)stack.ptr(first), stack.top_index()-first);
method.native_code(*this, method_params); // execute it	method.check_actual_numbered_params(junction->self, &method_params);
	method.native_code(*this, method_params); // execute it
	}

stack.set_top_index(first);	stack.set_top_index(first);
} else {	} else {
Line 806 void Request::execute(ArrayOperation& op	Line 817 void Request::execute(ArrayOperation& op
method.native_code(*this, method_params); // execute it	method.native_code(*this, method_params); // execute it
}	}
} else if(method.call_optimization==Method::CO_WITHOUT_WCONTEXT){	} else if(method.call_optimization==Method::CO_WITHOUT_WCONTEXT){
VMethodFrame frame(*junction, method_frame);	METHOD_FRAME_ACTION(method, method_frame, junction->self, {
METHOD_FRAME_ACTION(op_call_write(frame));	METHOD_PARAMS_ACTION(call_write(frame))
	});
} else	} else
#endif // OPTIMIZE_CALL	#endif // OPTIMIZE_CALL
{	{
VMethodFrame frame(*junction, method_frame);	METHOD_FRAME_ACTION(method, method_frame, junction->self, {
METHOD_FRAME_ACTION(op_call(frame, false));	METHOD_PARAMS_ACTION(call(frame));
write_pass_lang(frame.result());	write(frame.result());
	});
}	}

DEBUG_PRINT_STR("<-returned")	DEBUG_PRINT_STR("<-returned")
	goto check_skip;
if(get_skip())
return;
if(get_interrupted()) {
set_interrupted(false);
throw Exception("parser.interrupted",
0,
"execution stopped");
}
break;
}	}

case OP::OP_CONSTRUCT_OBJECT:	case OP::OP_CONSTRUCT_OBJECT:
Line 838 void Request::execute(ArrayOperation& op	Line 842 void Request::execute(ArrayOperation& op

DEBUG_PRINT_STRING(class_name)	DEBUG_PRINT_STRING(class_name)

Value* class_value=get_class(class_name);	VStateless_class& vclass=get_class_ref(class_name);
if(!class_value)
throw Exception(PARSER_RUNTIME,
&class_name,
"class is undefined");

debug_origin=i.next().origin;	debug_origin=i.next().origin;
Value& vconstructor_name=*i.next().value;	Value& vconstructor_name=*i.next().value;
Line 850 void Request::execute(ArrayOperation& op	Line 850 void Request::execute(ArrayOperation& op

DEBUG_PRINT_STRING(constructor_name)	DEBUG_PRINT_STRING(constructor_name)

Value& constructor_value=get_element(*class_value, constructor_name);	Junction* constructor_junction=get_element(vclass, constructor_name).get_junction();
	if(!constructor_junction)
Junction* junction=constructor_value.get_junction();	throw Exception(PARSER_RUNTIME, &constructor_name, "constructor must be declared in class '%s'", vclass.type());
if(!junction)
throw Exception(PARSER_RUNTIME,
&constructor_name,
"constructor must be declared in class '%s'",
class_value->get_class()->name_cstr());

ArrayOperation* local_ops=i.next().ops;	ArrayOperation* local_ops=i.next().ops;
DEBUG_PRINT_OPS(local_ops)	DEBUG_PRINT_OPS(local_ops)
DEBUG_PRINT_STR("->\n")	DEBUG_PRINT_STR("->\n")

Junction casted=Junction(*class_value, junction->method);	Value *result;
VConstructorFrame frame(casted, method_frame);	{
	Value& object=construct(vclass, *constructor_junction->method);
	CONSTRUCTOR_FRAME_ACTION(*constructor_junction->method, method_frame, object, {
	METHOD_PARAMS_ACTION(call(frame));
	object.enable_default_setter();
	result=&frame.result();
	// desctructor deletes junctions in stack params here
	});
	}

METHOD_FRAME_ACTION(op_call(frame, true /* constructing */));
if(opcode==OP::OP_CONSTRUCT_OBJECT)	if(opcode==OP::OP_CONSTRUCT_OBJECT)
stack.push(frame.result().as_value());	stack.push(*result);
else	else
write_pass_lang(frame.result());	write(*result);

DEBUG_PRINT_STR("<-returned")	DEBUG_PRINT_STR("<-returned")
break;	goto check_skip;
}	}

// expression ops: unary	// expression ops: unary
Line 916 void Request::execute(ArrayOperation& op	Line 918 void Request::execute(ArrayOperation& op
case OP::OP_FEXISTS:	case OP::OP_FEXISTS:
{	{
Value& a=stack.pop().value();	Value& a=stack.pop().value();
Value& value=VBool::get(file_exist(absolute(a.as_string())));	Value& value=VBool::get(file_exist(full_disk_path(a.as_string())));
stack.push(value);	stack.push(value);
break;	break;
}	}
case OP::OP_DEXISTS:	case OP::OP_DEXISTS:
{	{
Value& a=stack.pop().value();	Value& a=stack.pop().value();
Value& value=VBool::get(dir_exists(absolute(a.as_string())));	Value& value=VBool::get(dir_exists(full_disk_path(a.as_string())));
stack.push(value);	stack.push(value);
break;	break;
}	}
Line 959 void Request::execute(ArrayOperation& op	Line 961 void Request::execute(ArrayOperation& op

if(b_double == 0) {	if(b_double == 0) {
//const String* problem_source=b.as_string();	//const String* problem_source=b.as_string();
throw Exception("number.zerodivision",	throw Exception("number.zerodivision", 0, "Division by zero");
0, //problem_source,
"Division by zero");
}	}

Value& value=*new VDouble(a_double / b_double);	Value& value=*new VDouble(a_double / b_double);
Line 977 void Request::execute(ArrayOperation& op	Line 977 void Request::execute(ArrayOperation& op

if(b_double == 0) {	if(b_double == 0) {
//const String* problem_source=b.as_string();	//const String* problem_source=b.as_string();
throw Exception("number.zerodivision",	throw Exception("number.zerodivision", 0, "Modulus by zero");
0, //problem_source,
"Modulus by zero");
}	}

Value& value=*new VDouble(fmod(a_double, b_double));	Value& value=*new VDouble(fmod(a_double, b_double));
Line 995 void Request::execute(ArrayOperation& op	Line 993 void Request::execute(ArrayOperation& op

if(b_int == 0) {	if(b_int == 0) {
//const String* problem_source=b.as_string();	//const String* problem_source=b.as_string();
throw Exception("number.zerodivision",	throw Exception("number.zerodivision", 0, "Division by zero");
0, //problem_source,
"Division by zero");
}	}

Value& value=*new VInt(a_int / b_int);	Value& value=*new VInt(a_int / b_int);
Line 1061 void Request::execute(ArrayOperation& op	Line 1057 void Request::execute(ArrayOperation& op
result=false;	result=false;
Value& value=VBool::get(result);	Value& value=VBool::get(result);
stack.push(value);	stack.push(value);
break;	goto check_skip;
}	}
case OP::OP_LOG_OR:	case OP::OP_LOG_OR:
{	{
Line 1076 void Request::execute(ArrayOperation& op	Line 1072 void Request::execute(ArrayOperation& op
}	}
Value& value=VBool::get(result);	Value& value=VBool::get(result);
stack.push(value);	stack.push(value);
break;	goto check_skip;
}	}
case OP::OP_LOG_XOR:	case OP::OP_LOG_XOR:
{	{
Line 1182 void Request::execute(ArrayOperation& op	Line 1178 void Request::execute(ArrayOperation& op
stack.push(value);	stack.push(value);
break;	break;
}	}

default:	default:
throw Exception(0,	{
0,	throw Exception(0, 0, "invalid opcode %d", opcode);
"invalid opcode %d", opcode);	}
	check_skip:
	{
	if(fskip){
	if(fskip==Request::SKIP_INTERRUPTED){
	set_skip(Request::SKIP_NOTHING);
	throw Exception("parser.interrupted", 0, "execution stopped");
	}
	return;
	}
	break;
	}
}	}
}	}
} catch(const Exception&) {	} catch(const Exception&) {
Line 1198 void Request::execute(ArrayOperation& op	Line 1204 void Request::execute(ArrayOperation& op
}	}

#define SAVE_CONTEXT \	#define SAVE_CONTEXT \
VMethodFrame *saved_method_frame=method_frame; \	VMethodFrame *saved_method_frame=method_frame; \
Value* saved_rcontext=rcontext; \	Value* saved_rcontext=rcontext; \
WContext *saved_wcontext=wcontext;	WContext *saved_wcontext=wcontext;

#define RESTORE_CONTEXT \	#define RESTORE_CONTEXT \
wcontext=saved_wcontext; \	wcontext=saved_wcontext; \
rcontext=saved_rcontext; \	rcontext=saved_rcontext; \
method_frame=saved_method_frame;	method_frame=saved_method_frame;

void Request::op_call(VMethodFrame& frame, bool constructing){	Value& Request::construct(VStateless_class &called_class, const Method &method){
const Junction &junction=frame.junction;
VStateless_class& called_class=*junction.self.get_class();
Value* new_self;

if(constructing) {
if(junction.method->call_type!=Method::CT_STATIC) {
// this is a constructor call
if(new_self=called_class.create_new_value(fpool)) {
// some stateless_class creatable derivates
} else
throw Exception(PARSER_RUNTIME,
0, //&frame.name(),
"is not a constructor, system class '%s' can be constructed only implicitly",
called_class.name().cstr());

frame.write(*new_self);
} else
throw Exception(PARSER_RUNTIME,
0, //&frame.name(),
"method is static and can not be used as constructor");
} else
new_self=&junction.self;

frame.set_self(*new_self);

// see OP_PREPARE_TO_EXPRESSION
frame.set_in_expression(wcontext->get_in_expression());

SAVE_CONTEXT

rcontext=wcontext=&frame;
method_frame=&frame;

const Method& method=*junction.method;	if(method.call_type!=Method::CT_STATIC) {
Method::Call_type call_type=&called_class==new_self ? Method::CT_STATIC : Method::CT_DYNAMIC;	// this is a constructor call
	if(Value* result=called_class.create_new_value(fpool)) {
if(method.call_type==Method::CT_ANY \|\| method.call_type==call_type) { // allowed call type?	// some stateless_class creatable derivates
if(method.native_code) { // native code?	return *result;
method.check_actual_numbered_params(junction.self, frame.numbered_params());	} else
method.native_code(this, frame.numbered_params()); // execute it	throw Exception(PARSER_RUNTIME, method.name,
} else // parser code, execute it	"is not a constructor, system class '%s' can be constructed only implicitly", called_class.type());
recoursion_checked_execute(*method.parser_code);
} else	} else
throw Exception(PARSER_RUNTIME,	throw Exception(PARSER_RUNTIME, method.name, "method of '%s' is static and can not be used as constructor", called_class.type());
0,
"is not allowed to be called %s",
call_type==Method::CT_STATIC?"statically":"dynamically");

RESTORE_CONTEXT
//return &frame;
}

void Request::op_call_write(VMethodFrame& frame){
const Junction &junction=frame.junction;

frame.set_self(junction.self);

VMethodFrame *saved_method_frame=method_frame;
Value* saved_rcontext=rcontext;

rcontext=&frame;
method_frame=&frame;

const Method& method=*junction.method;
Method::Call_type call_type=junction.self.get_class()==&junction.self ? Method::CT_STATIC : Method::CT_DYNAMIC;

if(method.call_type==Method::CT_ANY \|\| method.call_type==call_type) { // allowed call type?
if(method.native_code) { // native code?
method.check_actual_numbered_params(junction.self, frame.numbered_params());
method.native_code(this, frame.numbered_params()); // execute it
} else // parser code, execute it
recoursion_checked_execute(*method.parser_code);
} else
throw Exception(PARSER_RUNTIME,
0,
"is not allowed to be called %s",
call_type==Method::CT_STATIC?"statically":"dynamically");

rcontext=saved_rcontext;
method_frame=saved_method_frame;
}	}

Value& Request::get_element(Value& ncontext, const String& name) {	Value& Request::get_element(Value& ncontext, const String& name) {
if(wcontext->get_somebody_entered_some_class()) // ^class:method
if(VStateless_class *called_class=ncontext.get_class())
if(VStateless_class *read_class=rcontext->get_class())
if(read_class->derived_from(*called_class)){ // current derived from called
Value *value=called_class->get_element(get_self(), name);
return (value ? &process_to_value(value) : VVoid::get());
}

Value* value=ncontext.get_element(name);	Value* value=ncontext.get_element(name);
	return (value ? &process(value) : VVoid::get());
	}

return (value ? &process_to_value(value) : VVoid::get());	#ifdef FEATURE_GET_ELEMENT4CALL
	Value& Request::get_element4call(Value& ncontext, const String& name) {
	Value* value=ncontext.get_element4call(name);
	return (value ? &process(value) : VVoid::get());
}	}
	#endif

void Request::put_element(Value& ncontext, const String& name, Value* value) {	void Request::put_element(Value& ncontext, const String& name, Value* value) {
// put_element can return property-setting-junction	// put_element can return property-setting-junction
if(const VJunction* vjunction=ncontext.put_element(name, value, false))	if(const VJunction* vjunction=ncontext.put_element(name, value)) {
if(vjunction!=PUT_ELEMENT_REPLACED_ELEMENT) {	const Junction& junction = vjunction->junction();
// process it	int param_count=junction.method->params_count;
VMethodFrame frame(vjunction->junction(), method_frame/caller/);
	if(junction.auto_name) {
size_t param_count=frame.method_params_count();	// default setter
	if(param_count!=2)
	throw Exception(PARSER_RUNTIME, 0, "default setter method must have TWO parameters (has %d parameters)", param_count);

	Value* params[2] = { new VString(*junction.auto_name), value };

	CONSTRUCTOR_FRAME_ACTION(junction.method, method_frame /caller*/, junction.self, {
	frame.store_params(params, 2);
	Temp_disable_default_setter temp(junction.self);
	call(frame);
	});
	} else {
	// setter
if(param_count!=1)	if(param_count!=1)
throw Exception(PARSER_RUNTIME,	throw Exception(PARSER_RUNTIME, 0, "setter method must have ONE parameter (has %d parameters)", param_count);
0,
"setter method must have ONE parameter (has %d parameters)", param_count);

frame.store_params(&value, 1);
frame.set_self(frame.junction.self);

SAVE_CONTEXT	CONSTRUCTOR_FRAME_ACTION(junction.method, method_frame /caller*/, junction.self, {
	frame.store_params(&value, 1);
	call(frame);
	});
	}
	}
	}

rcontext=wcontext=&frame;	Value& Request::process_getter(Junction& junction) {
method_frame=&frame;	int param_count=junction.method->params_count;

// prevent non-string writes for better error reporting [setters are not expected to return anything]	if(junction.auto_name){
wcontext->write(*method_frame);	// default getter
	if(param_count>1)
	throw Exception(PARSER_RUNTIME, 0, "default getter method can't have more then 1 parameter (has %d parameters)", param_count);

	Value *param;
	METHOD_FRAME_ACTION(junction.method, method_frame/caller*/, junction.self, {

	if(param_count){
	param=new VString(*junction.auto_name);
	frame.store_params(&param, 1);
	} // no need for else frame.empty_params()

recoursion_checked_execute(*frame.junction.method->parser_code); // parser code, execute it	Temp_disable_default_getter temp(junction.self);
// we don't need it StringOrValue result=wcontext->result();	call(frame);
	return frame.result();
	});
	} else {
	// getter
	if(param_count>0)
	throw Exception(PARSER_RUNTIME, 0, "getter method must have no parameters (has %d parameters)", param_count);

	METHOD_FRAME_ACTION(junction.method, method_frame/caller*/, junction.self, {
	// no need for frame.empty_params()
	call(frame);
	return frame.result();
	});
	}

RESTORE_CONTEXT
}
}	}

/** @param intercept_string	Value& Request::process(Value& input_value) {
- true:
they want result=string value,
possible object result goes to wcontext
- false:
they want any result[string\|object]
nothing goes to wcontext.
used in @c (expression) params evaluation

using the fact it's either string_ or value_ result requested to speed up checkes
*/
StringOrValue Request::process(Value& input_value, bool intercept_string) {
Junction* junction=input_value.get_junction();	Junction* junction=input_value.get_junction();
if(junction) {	if(junction) {
if(junction->is_getter) { // is it a getter-junction?	if(junction->is_getter) { // is it a getter-junction?
VMethodFrame frame(junction, method_frame/caller*/);	return process(process_getter(*junction));
Value *param;

if(size_t param_count=frame.method_params_count()){
if(junction->auto_name){ // default getter
if(param_count==1){
param=new VString(*junction->auto_name);
frame.store_params(&param, 1);
} else
throw Exception(PARSER_RUNTIME,
0,
"default getter method can't have more then 1 parameter (has %d parameters)", param_count);
} else
throw Exception(PARSER_RUNTIME,
0,
"getter method must have no parameters (has %d parameters)", param_count);
} // no need for else frame.empty_params()

frame.set_self(frame.junction.self);

SAVE_CONTEXT

rcontext=wcontext=&frame;
method_frame=&frame;

recoursion_checked_execute(*frame.junction.method->parser_code); // parser code, execute it

RESTORE_CONTEXT

return frame.result();
}	}

if(junction->code) { // is it a code-junction?	if(junction->code) { // is it a code-junction?
// process it	// process it
StringOrValue result;	ValueRef result;

DEBUG_PRINT_STR("ja->\n")	DEBUG_PRINT_STR("ja->\n")

if(!junction->method_frame)	if(!junction->method_frame)
throw Exception(PARSER_RUNTIME,	throw Exception(PARSER_RUNTIME, 0, "junction used outside of context");
0,
"junction used outside of context");

SAVE_CONTEXT	SAVE_CONTEXT

method_frame=junction->method_frame;	method_frame=junction->method_frame;
rcontext=junction->rcontext;	rcontext=junction->rcontext;

// for expression method params	// for code in [] and () wcontext is set 0
// wcontext is set 0	// using the fact in decision "which wrapper to use"
// using the fact in decision "which wwrapper to use"	if(junction->wcontext) {
bool using_code_frame=intercept_string && junction->wcontext;	// {} code wrapper
if(using_code_frame) {
// almost plain wwrapper about junction wcontext

VCodeFrame local(*junction->wcontext);	VCodeFrame local(*junction->wcontext);
wcontext=&local;	wcontext=&local;

// execute it	// execute it
recoursion_checked_execute(*junction->code);	recoursion_checked_execute(*junction->code);

// CodeFrame soul:
result=wcontext->result();	result=wcontext->result();
} else {	} else {
// plain wwrapper	// [] or () code wrapper
WWrapper local(wcontext);	WWrapper local(wcontext);
wcontext=&local;	wcontext=&local;

Line 1441 StringOrValue Request::process(Value& in	Line 1364 StringOrValue Request::process(Value& in
void Request::process_write(Value& input_value) {	void Request::process_write(Value& input_value) {
Junction* junction=input_value.get_junction();	Junction* junction=input_value.get_junction();
if(junction) {	if(junction) {
if(junction->is_getter) { // is it a getter-junction?	// no getter-junction check as process_write is called
VMethodFrame frame(junction, method_frame/caller*/);	// to process method arguments, not from get_element
Value *param;

if(size_t param_count=frame.method_params_count()){
if(junction->auto_name){ // default getter
if(param_count==1){
param=new VString(*junction->auto_name);
frame.store_params(&param, 1);
} else
throw Exception(PARSER_RUNTIME,
0,
"default getter method can't have more then 1 parameter (has %d parameters)", param_count);
} else
throw Exception(PARSER_RUNTIME,
0,
"getter method must have no parameters (has %d parameters)", param_count);
} // no need for else frame.empty_params()

frame.set_self(frame.junction.self);

SAVE_CONTEXT

rcontext=wcontext=&frame;
method_frame=&frame;

recoursion_checked_execute(*frame.junction.method->parser_code); // parser code, execute it

RESTORE_CONTEXT

write_pass_lang(frame.result());
return;
}

if(junction->code) { // is it a code-junction?	if(junction->code) { // is it a code-junction?
// process it	// process it

DEBUG_PRINT_STR("ja->\n")	DEBUG_PRINT_STR("ja->\n")

if(!junction->method_frame)	if(!junction->method_frame)
throw Exception(PARSER_RUNTIME,	throw Exception(PARSER_RUNTIME, 0, "junction used outside of context");
0,
"junction used outside of context");

SAVE_CONTEXT	SAVE_CONTEXT

method_frame=junction->method_frame;	method_frame=junction->method_frame;
rcontext=junction->rcontext;	rcontext=junction->rcontext;

// for expression method params	// for code in [] and () wcontext is set 0
// wcontext is set 0
// using the fact in decision "which wwrapper to use"	// using the fact in decision "which wwrapper to use"
#ifdef OPTIMIZE_CALL	#ifdef OPTIMIZE_CALL
if(wcontext==junction->wcontext){	if(wcontext==junction->wcontext){
Line 1502 void Request::process_write(Value& input	Line 1391 void Request::process_write(Value& input
} else	} else
#endif	#endif
if(junction->wcontext) {	if(junction->wcontext) {
// almost plain wwrapper about junction wcontext	// {} code wrapper
VCodeFrame local(*junction->wcontext);	VCodeFrame local(*junction->wcontext);
wcontext=&local;	wcontext=&local;

// execute it	// execute it
recoursion_checked_execute(*junction->code);	recoursion_checked_execute(*junction->code);
RESTORE_CONTEXT	RESTORE_CONTEXT
write_pass_lang(local.result());	write(local.result());
} else {	} else {
// plain wwrapper	// [] or () code wrapper
WWrapper local(wcontext);	WWrapper local(wcontext);
wcontext=&local;	wcontext=&local;

// execute it	// execute it
recoursion_checked_execute(*junction->code);	recoursion_checked_execute(*junction->code);
RESTORE_CONTEXT	RESTORE_CONTEXT
write_pass_lang(local.result());	write(local.result());
}	}

DEBUG_PRINT_STR("<-ja returned")	DEBUG_PRINT_STR("<-ja returned")
Line 1530 void Request::process_write(Value& input	Line 1419 void Request::process_write(Value& input
// just return it as we do for usual objects	// just return it as we do for usual objects
}	}

write_pass_lang(input_value);	write(input_value);
}	}

StringOrValue Request::execute_method(VMethodFrame& amethod_frame, const Method& method) {	const String* Request::execute_method(VStateless_class& aclass, const String& method_name, Value* optional_param) {
SAVE_CONTEXT	if(const Method *method=aclass.get_method(method_name)){
	METHOD_FRAME_ACTION(method, method_frame/caller*/, aclass, {
// initialize contexts
rcontext=wcontext=method_frame=&amethod_frame;

// execute!
execute(*method.parser_code);

// result
StringOrValue result=wcontext->result();

RESTORE_CONTEXT

// return
return result;
}

const String* Request::execute_method(Value& aself,	if(optional_param && method->params_count>0) {
const Method& method, Value* optional_param,	frame.store_params(&optional_param, 1);
bool do_return_string) {	} else {
	frame.empty_params();
	}

SAVE_CONTEXT	// prevent non-string writes for better error reporting
	frame.write(frame);

	call(frame);

Junction local_junction(aself, &method);	Value &result=frame.result();
VMethodFrame local_frame(local_junction, method_frame/caller/);	if(const String* sresult=result.get_string()){
if(optional_param && local_frame.method_params_count()>0) {	return sresult;
local_frame.store_params(&optional_param, 1);	}
} else {	result.bark("is '%s', it has no string representation", &method_name);
local_frame.empty_params();	});
}	}
local_frame.set_self(aself);	return 0;
rcontext=wcontext=method_frame=&local_frame;	}

// prevent non-string writes for better error reporting	bool Request::execute_method_if_exists(VStateless_class& aclass, const String& method_name, Value* optional_param) {
if(do_return_string)	if(const Method *method=aclass.get_method(method_name)){
local_frame.write(local_frame);	METHOD_FRAME_ACTION(method, method_frame/caller*/, aclass, {

// execute!	if(optional_param && method->params_count>0) {
execute(*method.parser_code);	frame.store_params(&optional_param, 1);
	} else {
// result	frame.empty_params();
const String* result=do_return_string ? local_frame.get_string() : 0;	}

RESTORE_CONTEXT

return result;	call(frame);
	});
	return true;
	}
	return false;
}	}

Request::Execute_nonvirtual_method_result	const String* Request::get_method_filespec(const Method* method){
Request::execute_nonvirtual_method(VStateless_class& aclass,	Operation::Origin origin=get_method_origin(method);
const String& method_name,	return origin.file_no ? get_used_filespec(origin.file_no) : NULL;
VString* optional_param,
bool do_return_string) {
Execute_nonvirtual_method_result result;
result.method=aclass.get_method(method_name);
if(result.method)
result.string=execute_method(aclass, *result.method, optional_param, do_return_string);
return result;
}	}

const String* Request::execute_virtual_method(Value& aself,	const Operation::Origin Request::get_method_origin(const Method* method){
const String& method_name) {	Operation::Origin origin={0, 0, 0};
if(Value* value=aself.get_element(method_name))
if(Junction* junction=value->get_junction())	if(ArrayOperation* code=method->parser_code)
if(const Method *method=junction->method)	if(code){
return execute_method(aself, method, 0/no params*/, true);	Array_iterator<Operation> i(*code);
	while( i.has_next() ){
return 0;	switch( i.next().code ){
	case OP::OP_CURLY_CODE__STORE_PARAM:
	case OP::OP_EXPR_CODE__STORE_PARAM:
	case OP::OP_CURLY_CODE__CONSTRUCT:
	case OP::OP_NESTED_CODE:
	case OP::OP_OBJECT_POOL:
	case OP::OP_STRING_POOL:
	case OP::OP_CALL:
	case OP::OP_CALL__WRITE:
	{
	i.next(); // skip local ops
	i.next(); // skip next opcode
	// continue execution
	}
	case OP::OP_CONSTRUCT_OBJECT:
	case OP::OP_CONSTRUCT_OBJECT__WRITE:
	case OP::OP_VALUE:
	case OP::OP_STRING__WRITE:
	case OP::OP_VALUE__GET_CLASS:
	case OP::OP_VALUE__GET_BASE_CLASS:
	#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_ELEMENT
	case OP::OP_GET_OBJECT_ELEMENT:
	case OP::OP_GET_OBJECT_ELEMENT__WRITE:
	#endif
	#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_VAR_ELEMENT
	case OP::OP_GET_OBJECT_VAR_ELEMENT:
	case OP::OP_GET_OBJECT_VAR_ELEMENT__WRITE:
	#endif
	#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT
	case OP::OP_VALUE__GET_ELEMENT:
	case OP::OP_VALUE__GET_ELEMENT__WRITE:
	case OP::OP_VALUE__GET_ELEMENT_OR_OPERATOR:
	case OP::OP_WITH_ROOT__VALUE__GET_ELEMENT:
	#endif
	#ifdef OPTIMIZE_BYTECODE_GET_SELF_ELEMENT
	case OP::OP_WITH_SELF__VALUE__GET_ELEMENT:
	case OP::OP_WITH_SELF__VALUE__GET_ELEMENT__WRITE:
	#endif

	#ifdef FEATURE_GET_ELEMENT4CALL
	case OP::OP_GET_ELEMENT4CALL:
	#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_ELEMENT
	case OP::OP_GET_OBJECT_ELEMENT4CALL:
	#endif
	#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_VAR_ELEMENT
	case OP::OP_GET_OBJECT_VAR_ELEMENT4CALL:
	#endif
	#endif // FEATURE_GET_ELEMENT4CALL

	#ifdef OPTIMIZE_BYTECODE_CONSTRUCT
	case OP::OP_WITH_ROOT__VALUE__CONSTRUCT_EXPR:
	case OP::OP_WITH_ROOT__VALUE__CONSTRUCT_VALUE:
	case OP::OP_WITH_WRITE__VALUE__CONSTRUCT_EXPR:
	case OP::OP_WITH_WRITE__VALUE__CONSTRUCT_VALUE:
	case OP::OP_WITH_SELF__VALUE__CONSTRUCT_EXPR:
	case OP::OP_WITH_SELF__VALUE__CONSTRUCT_VALUE:
	#endif
	{
	origin=i.next().origin;
	break;
	}
	default: break;
	}
	if(origin.file_no)
	return origin;
	}
	}
	return origin;
}	}

E-mail:

Removed from v.1.360
changed lines
	Added in v.1.413