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.383 and 1.427

version 1.383, 2016/07/19 16:35:36	version 1.427, 2025/10/04 15:50:49
Line 1	Line 1
/** @file	/** @file
Parser: executor part of request class.	Parser: executor part of request class.

Copyright (c) 2001-2015 Art. Lebedev Studio (http://www.artlebedev.com)	Copyright (c) 2001-2024 Art. Lebedev Studio (http://www.artlebedev.com)
Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)	Authors: Konstantin Morshnev <moko@design.ru>, Alexandr Petrosian <paf@design.ru>
*/	*/

#include "pa_opcode.h"	#include "pa_opcode.h"
Line 19	Line 19
#include "pa_vtable.h"	#include "pa_vtable.h"
#include "pa_vfile.h"	#include "pa_vfile.h"
#include "pa_vimage.h"	#include "pa_vimage.h"
	#include "pa_varray.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;	volatile const char * IDENT_EXECUTE_C="$Id$" IDENT_PA_OPCODE_H IDENT_PA_OPERATION_H IDENT_PA_VCODE_FRAME_H IDENT_PA_WWRAPPER_H;
Line 26 volatile const char * IDENT_EXECUTE_C="$	Line 27 volatile const char * IDENT_EXECUTE_C="$
//#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",
"VALUE__GET_CLASS",	"VALUE__GET_CLASS", "VALUE__GET_BASE_CLASS",
"CONSTRUCT_VALUE", "CONSTRUCT_EXPR", "CURLY_CODE__CONSTRUCT",	"CONSTRUCT_VALUE", "CONSTRUCT_EXPR", "CURLY_CODE__CONSTRUCT", "CONSTRUCT_ARRAY",
"WRITE_VALUE", "WRITE_EXPR_RESULT", "STRING__WRITE",	"WRITE_VALUE", "WRITE_EXPR_RESULT", "STRING__WRITE",
#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT	#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT
"VALUE__GET_ELEMENT_OR_OPERATOR",	"VALUE__GET_ELEMENT_OR_OPERATOR",
Line 75 char *opcode_name[]={	Line 76 char *opcode_name[]={
"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 110 const char* debug_value_to_cstr(Value& v	Line 110 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 129 void debug_printf(SAPI_Info& sapi_info,	Line 129 void debug_printf(SAPI_Info& sapi_info,
}	}

void debug_dump(SAPI_Info& sapi_info, int level, ArrayOperation& ops) {	void debug_dump(SAPI_Info& sapi_info, int level, ArrayOperation& ops) {
Array_iterator<Operation> i(ops);	for(Array_iterator<Operation> i(ops); i;) {
while(i.has_next()) {
OP::OPCODE opcode=i.next().code;	OP::OPCODE opcode=i.next().code;

#if defined(OPTIMIZE_BYTECODE_GET_OBJECT_ELEMENT) \|\| defined(OPTIMIZE_BYTECODE_GET_OBJECT_VAR_ELEMENT)	#if defined(OPTIMIZE_BYTECODE_GET_OBJECT_ELEMENT) \|\| defined(OPTIMIZE_BYTECODE_GET_OBJECT_VAR_ELEMENT)
Line 155 void debug_dump(SAPI_Info& sapi_info, in	Line 154 void debug_dump(SAPI_Info& sapi_info, in
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 225 void debug_dump(SAPI_Info& sapi_info, in	Line 220 void debug_dump(SAPI_Info& sapi_info, in
case OP::OP_NESTED_CODE:	case OP::OP_NESTED_CODE:
case OP::OP_OBJECT_POOL:	case OP::OP_OBJECT_POOL:
case OP::OP_STRING_POOL:	case OP::OP_STRING_POOL:
	case OP::OP_CONSTRUCT_ARRAY:
case OP::OP_CALL:	case OP::OP_CALL:
case OP::OP_CALL__WRITE:	case OP::OP_CALL__WRITE:
if(ArrayOperation* local_ops=i.next().ops)	if(ArrayOperation* local_ops=i.next().ops)
Line 247 void debug_dump(SAPI_Info& sapi_info, in	Line 243 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) {
register Stack<StackItem>& stack=this->stack; // helps a lot on MSVC: 'esi'	Stack<StackItem>& stack=this->stack; // helps a lot on MSVC: 'esi'

const String* debug_name=0; Operation::Origin debug_origin={0, 0, 0};	const String* debug_name=0; Operation::Origin debug_origin={0, 0, 0};
try{	try{
Line 260 void Request::execute(ArrayOperation& op	Line 255 void Request::execute(ArrayOperation& op
debug_dump(sapi_info, 0, ops);	debug_dump(sapi_info, 0, ops);
debug_printf(sapi_info, "execution-------------------------\n");	debug_printf(sapi_info, "execution-------------------------\n");
#endif	#endif
for(Array_iterator<Operation> i(ops); i.has_next(); ) {	for(Array_iterator<Operation> i(ops); i; ) {
OP::OPCODE opcode=i.next().code;	OP::OPCODE opcode=i.next().code;

#ifdef DEBUG_EXECUTE	#ifdef DEBUG_EXECUTE
Line 286 void Request::execute(ArrayOperation& op	Line 281 void Request::execute(ArrayOperation& op

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;
}	}

Line 303 void Request::execute(ArrayOperation& op	Line 294 void Request::execute(ArrayOperation& op

DEBUG_PRINT_STRING(name)	DEBUG_PRINT_STRING(name)

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

stack.push(new VBaseClassWrapper(class_value->get_class(), get_self()));
break;	break;
}	}

Line 336 void Request::execute(ArrayOperation& op	Line 323 void Request::execute(ArrayOperation& op
if(opcode==OP::OP_GET_ELEMENT__SPECIAL){	if(opcode==OP::OP_GET_ELEMENT__SPECIAL){
stack.push(*value);	stack.push(*value);
} else {	} else {
write_assign_lang(*value);	write(*value);
}	}
break;	break;
}	}
Line 361 void Request::execute(ArrayOperation& op	Line 348 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 372 void Request::execute(ArrayOperation& op	Line 357 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 422 void Request::execute(ArrayOperation& op	Line 406 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 442 void Request::execute(ArrayOperation& op	Line 422 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 462 void Request::execute(ArrayOperation& op	Line 442 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))	if(ncontext.put_element(name, &value))
if(vjunction!=PUT_ELEMENT_REPLACED_ELEMENT)	throw Exception(PARSER_RUNTIME, 0, "property value cannot be code, use [] or () brackets");
throw Exception(PARSER_RUNTIME,
0,
"property value can not be code, use [] or () brackets");

break;	break;
}	}

	case OP::OP_CONSTRUCT_ARRAY:
	{
	ArrayOperation* local_ops=i.next().ops;

	DEBUG_PRINT_OPS(local_ops)
	DEBUG_PRINT_STR("->\n")

	size_t first = stack.top_index();
	execute(*local_ops);
	Value value=new VArray(stack.top_index()-first, (Value*)stack.ptr(first));
	stack.set_top_index(first);

	#ifdef OPTIMIZE_BYTECODE_CONSTRUCT
	const String& name=stack.pop().string(); debug_name=&name;
	Value& ncontext=stack.pop().value();
	#else
	const String& name=stack.pop().string(); debug_name=&name;
	Value& ncontext=stack.pop().value();
	#endif
	put_element(ncontext, name, value);

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

case OP::OP_NESTED_CODE:	case OP::OP_NESTED_CODE:
{	{
ArrayOperation& local_ops=*i.next().ops;	ArrayOperation& local_ops=*i.next().ops;
Line 482 void Request::execute(ArrayOperation& op	Line 485 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 503 void Request::execute(ArrayOperation& op	Line 503 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 516 void Request::execute(ArrayOperation& op	Line 516 void Request::execute(ArrayOperation& op
DEBUG_PRINT_STRING(name)	DEBUG_PRINT_STRING(name)

if(Method* method=main_class.get_method(name)){ // looking operator of that name FIRST	if(Method* method=main_class.get_method(name)){ // looking operator of that name FIRST
if(!method->junction_template) method->junction_template=new VJunction(main_class, method);	stack.push(*method->get_vjunction(main_class));
stack.push(*method->junction_template);
break;	break;
}	}
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 530 void Request::execute(ArrayOperation& op	Line 529 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(Method* method=main_class.get_method(name)){ // looking operator of that name FIRST	if(Method* method=main_class.get_method(name)){ // looking operator of that name FIRST
if(!method->junction_template) method->junction_template=new VJunction(main_class, method);	stack.push(*method->get_vjunction(main_class));
stack.push(*method->junction_template);
break;	break;
}	}
Value& value=get_element(ncontext, name);	Value& value=get_element(ncontext, name);
stack.push(value);	stack.push(value);
break;	goto check_skip;
}	}
#endif	#endif

Line 551 void Request::execute(ArrayOperation& op	Line 549 void Request::execute(ArrayOperation& op
const String& field_name=*i.next().value->get_string(); debug_name=&field_name; \	const String& field_name=*i.next().value->get_string(); debug_name=&field_name; \
DEBUG_PRINT_STRING(field_name) \	DEBUG_PRINT_STRING(field_name) \
code; \	code; \
break; \	goto check_skip; \
}	}

case OP::OP_GET_OBJECT_ELEMENT: DO_GET_OBJECT_ELEMENT({	case OP::OP_GET_OBJECT_ELEMENT: DO_GET_OBJECT_ELEMENT({
Line 560 void Request::execute(ArrayOperation& op	Line 558 void Request::execute(ArrayOperation& op
})	})
case OP::OP_GET_OBJECT_ELEMENT__WRITE: DO_GET_OBJECT_ELEMENT({	case OP::OP_GET_OBJECT_ELEMENT__WRITE: DO_GET_OBJECT_ELEMENT({
Value& value=get_element(object, field_name);	Value& value=get_element(object, field_name);
write_assign_lang(value);	write(value);
})	})
#ifdef FEATURE_GET_ELEMENT4CALL	#ifdef FEATURE_GET_ELEMENT4CALL
case OP::OP_GET_OBJECT_ELEMENT4CALL: DO_GET_OBJECT_ELEMENT({	case OP::OP_GET_OBJECT_ELEMENT4CALL: DO_GET_OBJECT_ELEMENT({
Line 582 void Request::execute(ArrayOperation& op	Line 580 void Request::execute(ArrayOperation& op
DEBUG_PRINT_STRING(var_name) \	DEBUG_PRINT_STRING(var_name) \
const String* field=&get_element(*rcontext, var_name).as_string(); \	const String* field=&get_element(*rcontext, var_name).as_string(); \
code; \	code; \
break; \	goto check_skip; \
}	}

case OP::OP_GET_OBJECT_VAR_ELEMENT: DO_GET_OBJECT_VAR_ELEMENT({	case OP::OP_GET_OBJECT_VAR_ELEMENT: DO_GET_OBJECT_VAR_ELEMENT({
Line 591 void Request::execute(ArrayOperation& op	Line 589 void Request::execute(ArrayOperation& op
})	})
case OP::OP_GET_OBJECT_VAR_ELEMENT__WRITE: DO_GET_OBJECT_VAR_ELEMENT({	case OP::OP_GET_OBJECT_VAR_ELEMENT__WRITE: DO_GET_OBJECT_VAR_ELEMENT({
Value& value=get_element(object, *field);	Value& value=get_element(object, *field);
write_assign_lang(value);	write(value);
})	})
#ifdef FEATURE_GET_ELEMENT4CALL	#ifdef FEATURE_GET_ELEMENT4CALL
case OP::OP_GET_OBJECT_VAR_ELEMENT4CALL: DO_GET_OBJECT_VAR_ELEMENT({	case OP::OP_GET_OBJECT_VAR_ELEMENT4CALL: DO_GET_OBJECT_VAR_ELEMENT({
Line 607 void Request::execute(ArrayOperation& op	Line 605 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	#ifdef FEATURE_GET_ELEMENT4CALL
Line 617 void Request::execute(ArrayOperation& op	Line 615 void Request::execute(ArrayOperation& op
Value& ncontext=stack.pop().value();	Value& ncontext=stack.pop().value();
Value& value=get_element4call(ncontext, name);	Value& value=get_element4call(ncontext, name);
stack.push(value);	stack.push(value);
break;	goto check_skip;
}	}
#endif	#endif

Line 626 void Request::execute(ArrayOperation& op	Line 624 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();
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 640 void Request::execute(ArrayOperation& op	Line 638 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 651 void Request::execute(ArrayOperation& op	Line 649 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 664 void Request::execute(ArrayOperation& op	Line 662 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 682 void Request::execute(ArrayOperation& op	Line 680 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 704 void Request::execute(ArrayOperation& op	Line 702 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 727 void Request::execute(ArrayOperation& op	Line 725 void Request::execute(ArrayOperation& op
stack.push(*value);	stack.push(*value);

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

// CALL	// CALL
Line 761 void Request::execute(ArrayOperation& op	Line 759 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 790 void Request::execute(ArrayOperation& op	Line 784 void Request::execute(ArrayOperation& op

Junction* junction=value.get_junction();	Junction* junction=value.get_junction();
if(!junction) {	if(!junction) {
if(value.is("void"))	if(dynamic_cast<VVoid*>(&value))
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, cannot call it", value.type());
0,
"is '%s', not a method or junction, can not call it",
value.type());
}	}

Value *result;	Value *result;
{	{
VMethodFrame frame(*junction->method, method_frame, junction->self);	EXPRESSION_FRAME_ACTION(*junction->method, method_frame, junction->self, {
METHOD_FRAME_ACTION(op_call(frame));	METHOD_PARAMS_ACTION(call(frame));
result=&frame.result().as_value();	result=&frame.result();
// VMethodFrame desctructor deletes junctions in stack params here	// desctructor deletes junctions in stack params here
	});
}	}
stack.push(*result);	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 834 void Request::execute(ArrayOperation& op	Line 815 void Request::execute(ArrayOperation& op

Junction* junction=value.get_junction();	Junction* junction=value.get_junction();
if(!junction) {	if(!junction) {
if(value.is("void"))	if(dynamic_cast<VVoid*>(&value))
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, cannot 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 864 void Request::execute(ArrayOperation& op	Line 842 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(method, method_frame, junction->self);	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(method, method_frame, junction->self);	METHOD_FRAME_ACTION(method, method_frame, junction->self, {
METHOD_FRAME_ACTION(op_call(frame));	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 896 void Request::execute(ArrayOperation& op	Line 867 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 908 void Request::execute(ArrayOperation& op	Line 875 void Request::execute(ArrayOperation& op

DEBUG_PRINT_STRING(constructor_name)	DEBUG_PRINT_STRING(constructor_name)

Junction* constructor_junction=get_element(*class_value, constructor_name).get_junction();	// not get_element4call for better error reporting
	Junction* constructor_junction=get_element(vclass, constructor_name).get_junction();
if(!constructor_junction)	if(!constructor_junction)
throw Exception(PARSER_RUNTIME,	throw Exception(PARSER_RUNTIME, &constructor_name, "%s constructor not found", vclass.type());
&constructor_name,
"constructor must be declared in class '%s'",
class_value->type());

ArrayOperation* local_ops=i.next().ops;	ArrayOperation* local_ops=i.next().ops;
DEBUG_PRINT_OPS(local_ops)	DEBUG_PRINT_OPS(local_ops)
Line 921 void Request::execute(ArrayOperation& op	Line 886 void Request::execute(ArrayOperation& op

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

if(opcode==OP::OP_CONSTRUCT_OBJECT)	if(opcode==OP::OP_CONSTRUCT_OBJECT)
stack.push(*result);	stack.push(*result);
else	else
write_pass_lang(*result);	write(*result);

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

// expression ops: unary	// expression ops: unary
Line 978 void Request::execute(ArrayOperation& op	Line 944 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;
}	}

// expression ops: binary	// expression ops: binary
case OP::OP_SUB:	case OP::OP_SUB:
{	{
Value& b=stack.pop().value(); Value& a=stack.pop().value();	volatile double b_double=stack.pop().value().as_double();
Value& value=*new VDouble(a.as_double() - b.as_double());	volatile double a_double=stack.pop().value().as_double();

	Value& value=*new VDouble(a_double - b_double);
stack.push(value);	stack.push(value);
break;	break;
}	}
case OP::OP_ADD:	case OP::OP_ADD:
{	{
Value& b=stack.pop().value(); Value& a=stack.pop().value();	volatile double b_double=stack.pop().value().as_double();
Value& value=*new VDouble(a.as_double() + b.as_double());	volatile double a_double=stack.pop().value().as_double();

	Value& value=*new VDouble(a_double + b_double);
stack.push(value);	stack.push(value);
break;	break;
}	}
case OP::OP_MUL:	case OP::OP_MUL:
{	{
Value& b=stack.pop().value(); Value& a=stack.pop().value();	volatile double b_double=stack.pop().value().as_double();
Value& value=new VDouble(a.as_double() b.as_double());	volatile double a_double=stack.pop().value().as_double();

	Value& value=new VDouble(a_double b_double);
stack.push(value);	stack.push(value);
break;	break;
}	}
case OP::OP_DIV:	case OP::OP_DIV:
{	{
Value& b=stack.pop().value(); Value& a=stack.pop().value();	volatile double b_double=stack.pop().value().as_double();
	volatile double a_double=stack.pop().value().as_double();
double a_double=a.as_double();
double b_double=b.as_double();

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);
stack.push(value);	stack.push(value);
break;	break;
}	}
case OP::OP_MOD:	case OP::OP_MOD:
{	{
Value& b=stack.pop().value(); Value& a=stack.pop().value();	volatile double b_double=stack.pop().value().as_double();
	volatile double a_double=stack.pop().value().as_double();
double a_double=a.as_double();
double b_double=b.as_double();

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 1050 void Request::execute(ArrayOperation& op	Line 1014 void Request::execute(ArrayOperation& op
}	}
case OP::OP_INTDIV:	case OP::OP_INTDIV:
{	{
Value& b=stack.pop().value(); Value& a=stack.pop().value();	int b_int=stack.pop().value().as_int();
	int a_int=stack.pop().value().as_int();
int a_int=a.as_int();
int b_int=b.as_int();

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 1123 void Request::execute(ArrayOperation& op	Line 1083 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 1138 void Request::execute(ArrayOperation& op	Line 1098 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 1244 void Request::execute(ArrayOperation& op	Line 1204 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 1260 void Request::execute(ArrayOperation& op	Line 1230 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;

	Value& Request::construct(VStateless_class &called_class, const Method &method){
Value& Request::construct(Value &class_value, const Method &method){
VStateless_class& called_class=*class_value.get_class();

if(method.call_type!=Method::CT_STATIC) {	if(method.call_type!=Method::CT_STATIC) {
// this is a constructor call	// this is a constructor call
Line 1279 Value& Request::construct(Value &class_v	Line 1247 Value& Request::construct(Value &class_v
// some stateless_class creatable derivates	// some stateless_class creatable derivates
return *result;	return *result;
} else	} else
throw Exception(PARSER_RUNTIME,	throw Exception(PARSER_RUNTIME, method.name,
0, //&frame.name(),	"is not a constructor, system class '%s' can be constructed only implicitly", called_class.type());
"is not a constructor, system class '%s' can be constructed only implicitly",
called_class.type());
} else
throw Exception(PARSER_RUNTIME,
0, //&frame.name(),
"method is static and can not be used as constructor");
}

void Request::op_call(VMethodFrame& frame){
// see OP_PREPARE_TO_EXPRESSION
frame.set_in_expression(wcontext->get_in_expression());

SAVE_CONTEXT

rcontext=wcontext=method_frame=&frame;

Value& self=frame.self();
const Method& method=frame.method;
Method::Call_type call_type=self.get_class()==&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(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	} else
throw Exception(PARSER_RUNTIME,	throw Exception(PARSER_RUNTIME, method.name, "method of '%s' is static and cannot be used as constructor", called_class.type());
0,
"is not allowed to be called %s",
call_type==Method::CT_STATIC?"statically":"dynamically");

RESTORE_CONTEXT
}

void Request::op_call_write(VMethodFrame& frame){
VMethodFrame *saved_method_frame=method_frame;
Value* saved_rcontext=rcontext;

rcontext=&frame;
method_frame=&frame;

Value& self=frame.self();
const Method& method=frame.method;
Method::Call_type call_type=self.get_class()==&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(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) {
Value* value=ncontext.get_element(name);	Value* value=ncontext.get_element(name);
return (value ? &process_to_value(value) : VVoid::get());	return (value ? &process(value) : VVoid::get());
}	}

#ifdef FEATURE_GET_ELEMENT4CALL	#ifdef FEATURE_GET_ELEMENT4CALL
Value& Request::get_element4call(Value& ncontext, const String& name) {	Value& Request::get_element4call(Value& ncontext, const String& name) {
Value* value=ncontext.get_element4call(name);	Value* value=ncontext.get_element4call(name);
return (value ? &process_to_value(value) : VVoid::get());	return (value ? &process(value) : VVoid::get());
}	}
#endif	#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))	if(const VJunction* vjunction=ncontext.put_element(name, value)) {
if(vjunction!=PUT_ELEMENT_REPLACED_ELEMENT) {	const Junction& junction = vjunction->junction();
const Junction& junction = vjunction->junction();	int param_count=junction.method->params_count;
VConstructorFrame frame(junction.method, method_frame /caller*/, junction.self);
	if(junction.auto_name) {
size_t param_count=frame.method_params_count();	// default setter
	if(param_count!=2)
if(junction.auto_name){	throw Exception(PARSER_RUNTIME, 0, "default setter method must have TWO parameters (has %d parameters)", param_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 };	Value* params[2] = { new VString(*junction.auto_name), value };
frame.store_params(params, 2);

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

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

StringOrValue Request::process_getter(Junction& junction) {	Value& Request::process_getter(Junction& junction) {
VMethodFrame frame(junction.method, method_frame/caller*/, junction.self);	int param_count=junction.method->params_count;
size_t param_count=frame.method_params_count();

if(junction.auto_name){	if(junction.auto_name){
// default getter	// default getter
Value *param;	if(param_count>1)
	throw Exception(PARSER_RUNTIME, 0, "default getter method can't have more than 1 parameter (has %d parameters)", param_count);

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

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

	Temp_disable_default_getter temp(junction.self);
	call(frame);
	return frame.result();
	});
} else {	} else {
// getter	// getter
if(param_count!=0)	if(param_count>0)
throw Exception(PARSER_RUNTIME,	throw Exception(PARSER_RUNTIME, 0, "getter method must have no parameters (has %d parameters)", param_count);
0,
"getter method must have no parameters (has %d parameters)", param_count);

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

return frame.result();
}	}

/** @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?
return process(process_getter(*junction).as_value(), intercept_string);	return process(process_getter(*junction));
}	}

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);	recursion_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;

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

result=wcontext->result();	result=wcontext->result();
}	}
Line 1490 StringOrValue Request::process(Value& in	Line 1380 StringOrValue Request::process(Value& in
return result;	return result;
}	}

// it is then method-junction, do not explode it	// then it is a method-junction, do not explode it
// just return it as we do for usual objects	// just return it as we do for usual objects
}	}

Line 1504 void Request::process_write(Value& input	Line 1394 void Request::process_write(Value& input
// to process method arguments, not from get_element	// to process method arguments, not from get_element

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){
// no wrappers for wcontext	// no wrappers for wcontext
recoursion_checked_execute(*junction->code);	recursion_checked_execute(*junction->code);
RESTORE_CONTEXT	RESTORE_CONTEXT

} 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);	recursion_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);	recursion_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 1554 void Request::process_write(Value& input	Line 1441 void Request::process_write(Value& input
return;	return;
}	}

// it is then method-junction, do not explode it	// then it is a method-junction, do not explode it
// 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);
}	}

void Request::execute_method(VMethodFrame& aframe) {	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=&aframe;	if(optional_param && method->params_count>0) {
	frame.store_params(&optional_param, 1);
// execute!	} else {
recoursion_checked_execute(*aframe.method.parser_code);	frame.empty_params();
	}

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

	call(frame);

RESTORE_CONTEXT	Value &result=frame.result();
	if(const String* sresult=result.get_string()){
	return sresult;
	}
	result.bark("is '%s', it has no string representation", &method_name);
	});
	}
	return 0;
}	}

const String* Request::execute_method(Value& aself,	bool Request::execute_method_if_exists(VStateless_class& aclass, const String& method_name, Value* optional_param) {
const Method& method, Value* optional_param,	if(const Method *method=aclass.get_method(method_name)){
bool do_return_string) {	METHOD_FRAME_ACTION(method, method_frame/caller*/, aclass, {

VMethodFrame local_frame(method, method_frame/caller/, aself);	if(optional_param && method->params_count>0) {
	frame.store_params(&optional_param, 1);
	} else {
	frame.empty_params();
	}

if(optional_param && local_frame.method_params_count()>0) {	call(frame);
local_frame.store_params(&optional_param, 1);	});
} else {	return true;
local_frame.empty_params();
}	}
	return false;
// prevent non-string writes for better error reporting
if(do_return_string)
local_frame.write(local_frame);

execute_method(local_frame);

return do_return_string ? local_frame.get_string() : 0;
}	}

Request::Execute_nonvirtual_method_result	bool Request::execute_auto_method_if_exists(VStateless_class& aclass, const String& method_name, Value* optional_param) {
Request::execute_nonvirtual_method(VStateless_class& aclass,	if(const Method *method=aclass.get_method(method_name)){
const String& method_name,	METHOD_FRAME_ACTION(method, method_frame/caller*/, aclass, {
VString* optional_param,	Value* two_params[2];
bool do_return_string) {
Execute_nonvirtual_method_result result;	if (optional_param && method->params_count>1) {
result.method=aclass.get_method(method_name);	two_params[0] = optional_param;
if(result.method)	two_params[1] = new VString(*new String(aclass.type()));
result.string=execute_method(aclass, *result.method, optional_param, do_return_string);	frame.store_params(two_params, 2);
return result;	} else if (optional_param && method->params_count>0) {
	frame.store_params(&optional_param, 1);
	} else {
	frame.empty_params();
	}

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

const String* Request::execute_virtual_method(Value& aself,	const String* Request::get_method_filespec(const Method* method){
const String& method_name) {	Operation::Origin origin=get_method_origin(method);
if(Value* value=aself.get_element(method_name))	return origin.file_no ? get_used_filespec(origin.file_no) : NULL;
if(Junction* junction=value->get_junction())
if(const Method *method=junction->method)
return execute_method(aself, method, 0/no params*/, true);

return 0;
}	}

const String* Request::get_method_filename(const Method* method){	const Operation::Origin Request::get_method_origin(const Method* method){
	Operation::Origin origin={0, 0, 0};

if(ArrayOperation* code=method->parser_code)	if(ArrayOperation* code=method->parser_code)
if(code){	if(code){
Operation::Origin origin={0, 0, 0};	for(Array_iterator<Operation> i(*code); i; ){
Array_iterator<Operation> i(*code);
while( i.has_next() ){
switch( i.next().code ){	switch( i.next().code ){
case OP::OP_CURLY_CODE__STORE_PARAM:	case OP::OP_CURLY_CODE__STORE_PARAM:
case OP::OP_EXPR_CODE__STORE_PARAM:	case OP::OP_EXPR_CODE__STORE_PARAM:
Line 1686 const String* Request::get_method_filena	Line 1587 const String* Request::get_method_filena
default: break;	default: break;
}	}
if(origin.file_no)	if(origin.file_no)
return get_used_filename(origin.file_no);	return origin;
}	}
}	}
return 0;	return origin;
}	}

E-mail:

Removed from v.1.383
changed lines
	Added in v.1.427