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.239 and 1.309.2.2

version 1.239, 2002/04/22 10:15:12	version 1.309.2.2, 2005/07/27 09:18:33
Line 1	Line 1
/** @file	/** @file
Parser: executor part of request class.	Parser: executor part of request class.

Copyright (c) 2001, 2002 ArtLebedev Group (http://www.artlebedev.com)	Copyright (c) 2001-2004 ArtLebedev Group (http://www.artlebedev.com)
Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)

$Id$
*/	*/

	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 24	Line 24
#include "pa_wwrapper.h"	#include "pa_wwrapper.h"

//#define DEBUG_EXECUTE	//#define DEBUG_EXECUTE
//#define DEBUG_STRING_APPENDS_VS_EXPANDS


#ifdef DEBUG_STRING_APPENDS_VS_EXPANDS
ulong wcontext_result_size=0;
#endif



#ifdef DEBUG_EXECUTE	#ifdef DEBUG_EXECUTE
char *opcode_name[]={	char *opcode_name[]={
Line 54 char *opcode_name[]={	Line 46 char *opcode_name[]={
"NEG", "INV", "NOT", "DEF", "IN", "FEXISTS", "DEXISTS",	"NEG", "INV", "NOT", "DEF", "IN", "FEXISTS", "DEXISTS",
// expression ops: binary	// expression ops: binary
"SUB", "ADD", "MUL", "DIV", "MOD", "INTDIV",	"SUB", "ADD", "MUL", "DIV", "MOD", "INTDIV",
	"BIN_SL", "BIN_SR",
"BIN_AND", "BIN_OR", "BIN_XOR",	"BIN_AND", "BIN_OR", "BIN_XOR",
"LOG_AND", "LOG_OR", "LOG_XOR",	"LOG_AND", "LOG_OR", "LOG_XOR",
"NUM_LT", "NUM_GT", "NUM_LE", "NUM_GE", "NUM_EQ", "NUM_NE",	"NUM_LT", "NUM_GT", "NUM_LE", "NUM_GE", "NUM_EQ", "NUM_NE",
Line 61 char *opcode_name[]={	Line 54 char *opcode_name[]={
"IS"	"IS"
};	};

void va_debug_printf(Pool& pool, const char *fmt,va_list args) {	void va_debug_printf(SAPI_Info& sapi_info, const char* fmt,va_list args) {
char buf[MAX_STRING];	char buf[MAX_STRING];
vsnprintf(buf, MAX_STRING, fmt, args);	vsnprintf(buf, MAX_STRING, fmt, args);
SAPI::log(pool, "%s", buf);	SAPI::log(sapi_info, "%s", buf);
}	}

void debug_printf(Pool& pool, const char *fmt, ...) {	void debug_printf(SAPI_Info& sapi_info, const char* fmt, ...) {
va_list args;	va_list args;
va_start(args,fmt);	va_start(args, fmt);
va_debug_printf(pool,fmt,args);	va_debug_printf(sapi_info, fmt, args);
va_end(args);	va_end(args);
}	}

void debug_dump(Pool& pool, int level, const Array& ops) {	void debug_dump(SAPI_Info& sapi_info, int level, ArrayOperation& ops) {
Array_iter i(ops);	Array_iterator<Operation> i(ops);
while(i.has_next()) {	while(i.has_next()) {
Operation op;	OPCODE opcode=i.next().code;
op.cast=i.next();

if(op.code==OP_VALUE \|\| op.code==OP_STRING__WRITE) {	if(opcode==OP_VALUE \|\| opcode==OP_STRING__WRITE) {
Value value=static_cast<Value >(i.next());	Operation::Origin origin=i.next().origin;
debug_printf(pool,	Value& value=*i.next().value;
	debug_printf(sapi_info,
"%*s%s"	"%*s%s"
" \"%s\" %s",	" \"%s\" %s",
level*4, "", opcode_name[op.code],	level*4, "", opcode_name[opcode],
value->get_string()->cstr(), value->type());	value.get_string()->cstr(), value.type());
continue;	continue;
}	}
debug_printf(pool, "%s%s", level4, "", opcode_name[op.code]);	debug_printf(sapi_info, "%s%s", level4, "", opcode_name[opcode]);

switch(op.code) {	switch(opcode) {
case OP_CURLY_CODE__STORE_PARAM:	case OP_CURLY_CODE__STORE_PARAM:
case OP_EXPR_CODE__STORE_PARAM:	case OP_EXPR_CODE__STORE_PARAM:
case OP_CURLY_CODE__CONSTRUCT:	case OP_CURLY_CODE__CONSTRUCT:
Line 99 void debug_dump(Pool& pool, int level, c	Line 92 void debug_dump(Pool& pool, int level, c
case OP_OBJECT_POOL:	case OP_OBJECT_POOL:
case OP_STRING_POOL:	case OP_STRING_POOL:
case OP_CALL:	case OP_CALL:
const Array local_ops=reinterpret_cast<const Array >(i.next());	case OP_CALL__WRITE:
debug_dump(pool, level+1, *local_ops);	if(ArrayOperation* local_ops=i.next().ops)
	debug_dump(sapi_info, level+1, *local_ops);
}	}
}	}
}	}
#endif	#endif

#define PUSH(value) stack.push(value)	// Request
#define POP() static_cast<Value *>(stack.pop())
#define POP_NAME() static_cast<Value *>(stack.pop())->as_string()
#define POP_CODE() static_cast<Array *>(stack.pop())

void Request::execute(const Array& ops) {
// _asm int 3;
#ifdef DEBUG_EXECUTE
debug_printf(pool(), "source----------------------------\n");
debug_dump(pool(), 0, ops);
debug_printf(pool(), "execution-------------------------\n");
#endif

const String *last_get_element_name=0;	void Request::execute(ArrayOperation& ops) {
	register Stack<StackItem>& stack=this->stack; // helps a lot on MSVC: 'esi'

Array_iter i(ops);	const String* debug_name=0; Operation::Origin debug_origin={0, 0, 0};
while(i.has_next()) {	try{
Operation op;
op.cast=i.next();
#ifdef DEBUG_EXECUTE	#ifdef DEBUG_EXECUTE
debug_printf(pool(), "%d:%s", stack.top_index()+1, opcode_name[op.code]);	debug_printf(sapi_info, "source----------------------------\n");
	debug_dump(sapi_info, 0, ops);
	debug_printf(sapi_info, "execution-------------------------\n");
#endif	#endif
	for(Array_iterator<Operation> i(ops); i.has_next(); ) {
	if(get_interrupted()) {
	set_interrupted(false);
	throw Exception("parser.interrupted",
	0,
	"execution stopped");
	}
	OPCODE opcode=i.next().code;

Value *value;	#ifdef DEBUG_EXECUTE
Value a; Value b;	debug_printf(sapi_info, "%d:%s", stack.top_index()+1, opcode_name[opcode]);
Array *b_code;	#endif
switch(op.code) {
	switch(opcode) {
// param in next instruction	// param in next instruction
case OP_VALUE:	case OP_VALUE:
{	{
value=static_cast<Value *>(i.next());	debug_origin=i.next().origin;
	Value& value=*i.next().value;
#ifdef DEBUG_EXECUTE	#ifdef DEBUG_EXECUTE
debug_printf(pool(), " \"%s\" %s", value->get_string()->cstr(), value->type());	debug_printf(sapi_info, " \"%s\" %s", value.get_string()->cstr(), value.type());
#endif	#endif
PUSH(value);	stack.push(value);
break;	break;
}	}
case OP_GET_CLASS:	case OP_GET_CLASS:
Line 148 void Request::execute(const Array& ops)	Line 142 void Request::execute(const Array& ops)
// maybe they do ^class:method[] call, remember the fact	// maybe they do ^class:method[] call, remember the fact
wcontext->set_somebody_entered_some_class();	wcontext->set_somebody_entered_some_class();

const String& name=POP_NAME();	const String& name=stack.pop().string();
value=static_cast<Value *>(classes().get(name));	Value* value=classes().get(name);
if(!value)	if(!value)
throw Exception("parser.runtime",	throw Exception("parser.runtime",
&name,	&name,
"class is undefined");	"class is undefined");

PUSH(value);	stack.push(*value);
break;	break;
}	}

// OP_WITH	// OP_WITH
case OP_WITH_ROOT:	case OP_WITH_ROOT:
{	{
PUSH(root);	stack.push(*method_frame);
break;	break;
}	}
case OP_WITH_SELF:	case OP_WITH_SELF:
{	{
PUSH(self);	stack.push(get_self());
break;	break;
}	}
case OP_WITH_READ:	case OP_WITH_READ:
{	{
PUSH(rcontext);	stack.push(*rcontext);
break;	break;
}	}
case OP_WITH_WRITE:	case OP_WITH_WRITE:
{	{
PUSH(wcontext);	if(wcontext==method_frame)
	throw Exception("parser.runtime",
	0,
	"$.name outside of $name[...]");

	stack.push(*wcontext);
break;	break;
}	}

// OTHER ACTIONS BUT WITHs	// OTHER ACTIONS BUT WITHs
case OP_CONSTRUCT_VALUE:	case OP_CONSTRUCT_VALUE:
{	{
value=POP();	Value& value=stack.pop().value();
const String& name=POP_NAME();	const String& name=stack.pop().string(); debug_name=&name;
Value *ncontext=POP();	Value& ncontext=stack.pop().value();
ncontext->put_element(name, value);	put_element(ncontext, name, value);

break;	break;
}	}
case OP_CONSTRUCT_EXPR:	case OP_CONSTRUCT_EXPR:
Line 195 void Request::execute(const Array& ops)	Line 195 void Request::execute(const Array& ops)
// see OP_PREPARE_TO_EXPRESSION	// see OP_PREPARE_TO_EXPRESSION
wcontext->set_in_expression(false);	wcontext->set_in_expression(false);

value=POP();	Value& expr=stack.pop().value();
const String& name=POP_NAME();	const String& name=stack.pop().string(); debug_name=&name;
Value *ncontext=POP();	Value& ncontext=stack.pop().value();
ncontext->put_element(name, value->as_expr_result());	Value& value=expr.as_expr_result();
	put_element(ncontext, name, value);
break;	break;
}	}
case OP_CURLY_CODE__CONSTRUCT:	case OP_CURLY_CODE__CONSTRUCT:
{	{
const Array local_ops=reinterpret_cast<const Array >(i.next());	ArrayOperation& local_ops=*i.next().ops;
#ifdef DEBUG_EXECUTE	#ifdef DEBUG_EXECUTE
debug_printf(pool(), " (%d)\n", local_ops->size());	debug_printf(sapi_info, " (%d)\n", local_ops.count());
debug_dump(pool(), 1, *local_ops);	debug_dump(sapi_info, 1, local_ops);
#endif	#endif
Junction& j=*NEW Junction(pool(),	Value& value=*new VJunction(new Junction(
*self, 0, 0,	get_self(), 0,
0,	method_frame,
0,	rcontext,
0,	wcontext,
local_ops);	&local_ops));

value=NEW VJunction(j);	const String& name=stack.pop().string(); debug_name=&name;
const String& name=POP_NAME();	Value& ncontext=stack.pop().value();
Value *ncontext=POP();	if(const Junction* junction=ncontext.put_element(ncontext, name, &value, false))
ncontext->put_element(name, value);	if(junction!=PUT_ELEMENT_REPLACED_ELEMENT)
	throw Exception("parser.runtime",
	0,
	"property value can not be code, use [] or () brackets");

break;	break;
}	}
case OP_NESTED_CODE:	case OP_NESTED_CODE:
{	{
Array local_ops=static_cast<Array >(i.next());	ArrayOperation& local_ops=*i.next().ops;
#ifdef DEBUG_EXECUTE	#ifdef DEBUG_EXECUTE
debug_printf(pool(), " (%d)\n", local_ops->size());	debug_printf(sapi_info, " (%d)\n", local_ops.count());
debug_dump(pool(), 1, *local_ops);	debug_dump(sapi_info, 1, local_ops);
#endif	#endif
PUSH(local_ops);	stack.push(local_ops);
break;	break;
}	}
case OP_WRITE_VALUE:	case OP_WRITE_VALUE:
{	{
value=POP();	Value& value=stack.pop().value();
write_assign_lang(*value, last_get_element_name);	write_assign_lang(value);
break;	break;
}	}
case OP_WRITE_EXPR_RESULT:	case OP_WRITE_EXPR_RESULT:
{	{
value=POP();	Value& value=stack.pop().value();
write_no_lang(*value->as_expr_result());	write_no_lang(value.as_expr_result());

// must be after write(result) and	// must be after write(result) and
// see OP_PREPARE_TO_EXPRESSION	// see OP_PREPARE_TO_EXPRESSION
Line 249 void Request::execute(const Array& ops)	Line 254 void Request::execute(const Array& ops)
}	}
case OP_STRING__WRITE:	case OP_STRING__WRITE:
{	{
VString vstring=static_cast<VString >(i.next());	i.next(); // ignore origin
	Value* value=i.next().value;
#ifdef DEBUG_EXECUTE	#ifdef DEBUG_EXECUTE
debug_printf(pool(), " \"%s\"", vstring->string().cstr());	debug_printf(sapi_info, " \"%s\"", value->get_string()->cstr());
#endif	#endif
write_no_lang(vstring->string());	write_no_lang(*value->get_string());
break;	break;
}	}

case OP_GET_ELEMENT_OR_OPERATOR:	case OP_GET_ELEMENT_OR_OPERATOR:
{	{
// maybe they do ^object.method[] call, remember the fact	const String& name=stack.pop().string(); debug_name=&name;
wcontext->set_somebody_entered_some_object(true);	Value& ncontext=stack.pop().value();
	Value& value=get_element(ncontext, name, true);
//_asm int 3;	stack.push(value);
value=get_element(last_get_element_name, true);
PUSH(value);
break;	break;
}	}
case OP_GET_ELEMENT:	case OP_GET_ELEMENT:
{	{
// maybe they do ^object.method[] call, remember the fact	const String& name=stack.pop().string(); debug_name=&name;
wcontext->set_somebody_entered_some_object(true);	Value& ncontext=stack.pop().value();
	Value& value=get_element(ncontext, name, false);
//_asm int 3;	stack.push(value);
value=get_element(last_get_element_name, false);
PUSH(value);
break;	break;
}	}

case OP_GET_ELEMENT__WRITE:	case OP_GET_ELEMENT__WRITE:
{	{
value=get_element(last_get_element_name/not followed by call, not needed really/, false);	const String& name=stack.pop().string(); debug_name=&name;
write_assign_lang(*value, last_get_element_name);	Value& ncontext=stack.pop().value();
	Value& value=get_element(ncontext, name, false);
	write_assign_lang(value);
break;	break;
}	}


case OP_OBJECT_POOL:	case OP_OBJECT_POOL:
{	{
const Array local_ops=reinterpret_cast<const Array >(i.next());	ArrayOperation& local_ops=*i.next().ops;

PUSH(wcontext);	WContext *saved_wcontext=wcontext;
PUSH((void *)flang);	String::Language saved_lang=flang;
flang=String::UL_PASS_APPENDED;	flang=String::L_PASS_APPENDED;
WWrapper local(pool(), 0 /empty/);	WWrapper local(0/empty/, wcontext);
wcontext=&local;	wcontext=&local;

execute(*local_ops);	execute(local_ops);

value=&wcontext->result().as_value();	stack.push(wcontext->result().as_value());
flang=static_cast<String::Untaint_lang>(reinterpret_cast<int>(POP()));	flang=saved_lang;
wcontext=static_cast<WContext *>(POP());	wcontext=saved_wcontext;
PUSH(value);
break;	break;
}	}

case OP_STRING_POOL:	case OP_STRING_POOL:
{	{
const Array local_ops=reinterpret_cast<const Array >(i.next());	ArrayOperation& local_ops=*i.next().ops;

PUSH(wcontext);	WContext *saved_wcontext=wcontext;
WWrapper local(pool(), 0 /empty/);	WWrapper local(0 /empty/, wcontext);
wcontext=&local;	wcontext=&local;

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
const String *string=wcontext->get_string();	if(const String* string=wcontext->get_string())
Value *value;	value=new VString(*string);
if(string)
value=NEW VString(*string);
else	else
NEW VVoid(pool());	value=new VVoid;
wcontext=static_cast<WContext *>(POP());	stack.push(*value);
PUSH(value);
	wcontext=saved_wcontext;
break;	break;
}	}

// CALL	// CALL
case OP_STORE_PARAM:	case OP_STORE_PARAM:
{	{
value=POP();	Value& value=stack.pop().value();
VMethodFrame frame=static_cast<VMethodFrame >(stack.top_value());	VMethodFrame& frame=stack.top_value().method_frame();
// this op is executed from CALL local_ops only, so can not check method_frame_to_fill==0	// this op is executed from CALL local_ops only, so may skip the check "method_frame_to_fill==0"
frame->store_param(value);	frame.store_param(value);
break;	break;
}	}
case OP_CURLY_CODE__STORE_PARAM:	case OP_CURLY_CODE__STORE_PARAM:
case OP_EXPR_CODE__STORE_PARAM:	case OP_EXPR_CODE__STORE_PARAM:
{	{
// code	// code
const Array local_ops=reinterpret_cast<const Array >(i.next());	ArrayOperation& local_ops=*i.next().ops;
VMethodFrame frame=static_cast<VMethodFrame >(stack.top_value());	VMethodFrame& frame=stack.top_value().method_frame();
#ifdef DEBUG_EXECUTE	#ifdef DEBUG_EXECUTE
debug_printf(pool(), " (%d)\n", local_ops->size());	debug_printf(sapi_info, " (%d)\n", local_ops.count());
debug_dump(pool(), 1, *local_ops);	debug_dump(sapi_info, 1, local_ops);
#endif	#endif
// when they evaluate expression parameter,	// when they evaluate expression parameter,
// the object expression result	// the object expression result
Line 354 void Request::execute(const Array& ops)	Line 357 void Request::execute(const Array& ops)
// hence, we zero junction.wcontext here, and later	// hence, we zero junction.wcontext here, and later
// in .process we would test that field	// in .process we would test that field
// in decision "which wwrapper to use"	// in decision "which wwrapper to use"
Junction& j=*NEW Junction(pool(),	Value& value=*new VJunction(new Junction(
*self, 0, 0,	get_self(), 0,
root,	method_frame,
rcontext,	rcontext,
op.code==OP_EXPR_CODE__STORE_PARAM?0:wcontext,	opcode==OP_EXPR_CODE__STORE_PARAM?0:wcontext,
local_ops);	&local_ops));

value=NEW VJunction(j);

// store param	// store param
// this op is executed from CALL local_ops only, so can not check method_frame_to_fill==0	// this op is executed from CALL local_ops only, so can not check method_frame_to_fill==0
frame->store_param(value);	frame.store_param(value);
break;	break;
}	}

Line 384 void Request::execute(const Array& ops)	Line 384 void Request::execute(const Array& ops)
case OP_CALL:	case OP_CALL:
case OP_CALL__WRITE:	case OP_CALL__WRITE:
{	{
Array local_ops=static_cast<Array >(i.next());	//is_debug_junction=true;
	ArrayOperation* local_ops=i.next().ops;
#ifdef DEBUG_EXECUTE	#ifdef DEBUG_EXECUTE
debug_printf(pool(), " (%d)\n", local_ops->size());	debug_printf(sapi_info, " (%d)\n", local_ops?local_ops->count():0);
debug_dump(pool(), 1, *local_ops);	if(local_ops)
	debug_dump(sapi_info, 1, *local_ops);

debug_printf(pool(), "->\n");	debug_printf(sapi_info, "->\n");
#endif	#endif
value=POP();	Value& value=stack.pop().value();

// info:	Junction* junction=value.get_junction();
// code compiled so that this one's always method-junction,	if(!junction) {
// not a code-junction	if(value.is("void"))
Junction *junction=value->get_junction();	throw Exception("parser.runtime",
if(!junction)	0,
	"undefined method");
	else
	throw Exception("parser.runtime",
	0,
	"is '%s', not a method or junction, can not call it",
	value.type());
	}
	/* no check needed, code compiled the way that that's impossible
	// check:
	// that this is method-junction, not a code-junction
	// [disabling these contstructions:]
	// $junction{code}
	// ^junction[]
	if(!junction->method)
throw Exception("parser.runtime",	throw Exception("parser.runtime",
last_get_element_name,
"(%s) not a method or junction, can not call it",	"is '%s', it is code junction, can not call it",
value->type());	value.type());
	*/

VMethodFrame frame(pool(), last_get_element_name, junction);	VMethodFrame frame(junction, method_frame/caller*/);
if(local_ops){ // store param code goes here	if(local_ops){ // store param code goes here
PUSH(&frame); // argument for *STORE_PARAM ops	stack.push(frame); // argument for *STORE_PARAM ops
execute(*local_ops);	execute(*local_ops);
POP();	stack.pop().value();
}	}
frame.fill_unspecified_params();	frame.fill_unspecified_params();
PUSH(self);	VMethodFrame *saved_method_frame=method_frame;
PUSH(root);	Value* saved_rcontext=rcontext;
PUSH(rcontext);	WContext *saved_wcontext=wcontext;
PUSH(wcontext);

VStateless_class *called_class=frame.junction.self.get_class();	VStateless_class& called_class=*frame.junction.self.get_class();
	Value* new_self;
if(wcontext->get_constructing()) {	if(wcontext->get_constructing()) {
wcontext->set_constructing(false);	wcontext->set_constructing(false);
	new_self=&get_self();
if(frame.junction.method->call_type!=Method::CT_STATIC) {	if(frame.junction.method->call_type!=Method::CT_STATIC) {
// this is a constructor call	// this is a constructor call

if(Value *value=called_class->create_new_value(pool())) {	HashStringValue& new_object_fields=*new HashStringValue();
	if(Value* value=called_class.create_new_value(fpool, new_object_fields)) {
// some stateless_class creatable derivates	// some stateless_class creatable derivates
self=value;	new_self=value;
} else	} else
throw Exception("parser.runtime",	throw Exception("parser.runtime",
&frame.name(),	0, //&frame.name(),
"is not a constructor, system class '%s' can be constructed only implicitly",	"is not a constructor, system class '%s' can be constructed only implicitly",
called_class->name().cstr());	called_class.name().cstr());

frame.write(*self,	frame.write(*new_self,
String::UL_CLEAN // not used, always an object, not string	String::L_CLEAN // not used, always an object, not string
);	);
} else	} else
throw Exception("parser.runtime",	throw Exception("parser.runtime",
&frame.name(),	0, //&frame.name(),
"method is static and can not be used as constructor");	"method is static and can not be used as constructor");
} else {	} else
// this is not constructor call	new_self=&frame.junction.self;

// not ^name.method call, name:method call; and
// is context object or class & is it my class or my parent's class and?
VStateless_class *read_class=rcontext->get_class();
if(
!(wcontext->get_somebody_entered_some_object() &&
!wcontext->get_somebody_entered_some_class()) &&
read_class && read_class->is_or_derived_from(*called_class)) // yes
self=rcontext; // dynamic call
else // no, not me or relative of mine (=total stranger)
self=&frame.junction.self; // static call
}

frame.set_self(*self);	frame.set_self(*new_self);

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

rcontext=wcontext=&frame;	rcontext=wcontext=&frame;
{	{
// take object or class from any wrappers
// and substitute class alias to the class they are called AS
Temp_alias temp_alias(self->get_aliased(), frame.junction.vclass);

const Method& method=*frame.junction.method;	const Method& method=*frame.junction.method;
Method::Call_type call_type=	Method::Call_type call_type=
called_class==self ? Method::CT_STATIC : Method::CT_DYNAMIC;	&called_class==new_self ? Method::CT_STATIC : Method::CT_DYNAMIC;
if(	if(
method.call_type==Method::CT_ANY \|\|	method.call_type==Method::CT_ANY \|\|
method.call_type==call_type) { // allowed call type?	method.call_type==call_type) { // allowed call type?
try {	method_frame=&frame;
if(method.native_code) { // native code?	if(method.native_code) { // native code?
// root unchanged, so that ^for ^foreach & co may write to locals	method.check_actual_numbered_params(
method.check_actual_numbered_params(	frame.junction.self,
frame.junction.self,	/frame.name(), /frame.numbered_params());
frame.name(), frame.numbered_params());	method.native_code(
method.native_code(	*this,
*this,	*frame.numbered_params()); // execute it
frame.name(), frame.numbered_params()); // execute it	} else // parser code, execute it
} else { // parser code	recoursion_checked_execute(*method.parser_code);
root=&frame;
// execute it
recoursion_checked_execute(&frame.name(), *method.parser_code);
}
} catch(...) {
// record it to stack trace
exception_trace.push((void *)&frame.name());
/re/throw;
}
} else	} else
throw Exception("parser.runtime",	throw Exception("parser.runtime",
&frame.name(),	0, //&frame.name(),
"is not allowed to be called %s",	"is not allowed to be called %s",
call_type==Method::CT_STATIC?"statically":"dynamically");	call_type==Method::CT_STATIC?"statically":"dynamically");

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

wcontext=static_cast<WContext *>(POP());	wcontext=saved_wcontext;
rcontext=POP();	rcontext=saved_rcontext;
root=POP();	method_frame=saved_method_frame;
self=static_cast<VAliased *>(POP());

#ifdef DEBUG_STRING_APPENDS_VS_EXPANDS
if(const String *s=value->get_string())
wcontext_result_size+=s->used_rows()*sizeof(String::Chunk::Row);
#endif

if(op.code==OP_CALL__WRITE) {	if(opcode==OP_CALL__WRITE) {
write_assign_lang(result, last_get_element_name);	write_assign_lang(result);
// forget the fact they've entered some ^object.method[].
// see OP_GET_ELEMENT
wcontext->set_somebody_entered_some_object(false);
} else { // OP_CALL	} else { // OP_CALL
PUSH(&result.as_value());	stack.push(result.as_value());
}	}

#ifdef DEBUG_EXECUTE	#ifdef DEBUG_EXECUTE
debug_printf(pool(), "<-returned");	debug_printf(sapi_info, "<-returned");
#endif	#endif
	//is_debug_junction=false;
break;	break;
}	}

// expression ops: unary	// expression ops: unary
case OP_NEG:	case OP_NEG:
{	{
Value *operand=POP();	Value& a=stack.pop().value();
value=NEW VDouble(pool(), -operand->as_double());	Value& value=*new VDouble(-a.as_double());
PUSH(value);	stack.push(value);
break;	break;
}	}
case OP_INV:	case OP_INV:
{	{
Value *operand=POP();	Value& a=stack.pop().value();
value=NEW VDouble(pool(), ~operand->as_int());	Value& value=*new VDouble(~a.as_int());
PUSH(value);	stack.push(value);
break;	break;
}	}
case OP_NOT:	case OP_NOT:
{	{
Value *operand=POP();	Value& a=stack.pop().value();
value=NEW VBool(pool(), !operand->as_bool());	Value& value=*new VBool(!a.as_bool());
PUSH(value);	stack.push(value);
break;	break;
}	}
case OP_DEF:	case OP_DEF:
{	{
Value *operand=POP();	Value& a=stack.pop().value();
value=NEW VBool(pool(), operand->is_defined());	Value& value=*new VBool(a.is_defined());
PUSH(value);	stack.push(value);
break;	break;
}	}
case OP_IN:	case OP_IN:
{	{
/// @test String::cmp	Value& a=stack.pop().value();
Value *operand=POP();	const String& path=a.as_string();
const char *path=operand->as_string().cstr();	Value& value=new VBool(request_info.uri && request_info.uri && path.this_starts(request_info.uri));
value=NEW VBool(pool(),	stack.push(value);
info.uri && strncmp(path, info.uri, strlen(path))==0);
PUSH(value);
break;	break;
}	}
case OP_FEXISTS:	case OP_FEXISTS:
{	{
Value *operand=POP();	Value& a=stack.pop().value();
value=NEW VBool(pool(),	Value& value=*new VBool(file_readable(absolute(a.as_string())));
file_readable(absolute(operand->as_string())));	stack.push(value);
PUSH(value);
break;	break;
}	}
case OP_DEXISTS:	case OP_DEXISTS:
{	{
Value *operand=POP();	Value& a=stack.pop().value();
value=NEW VBool(pool(),	Value& value=*new VBool(dir_readable(absolute(a.as_string())));
dir_readable(absolute(operand->as_string())));	stack.push(value);
PUSH(value);
break;	break;
}	}

// expression ops: binary	// expression ops: binary
case OP_SUB:	case OP_SUB:
{	{
b=POP(); a=POP();	Value& b=stack.pop().value(); Value& a=stack.pop().value();
value=NEW VDouble(pool(), a->as_double() - b->as_double());	Value& value=*new VDouble(a.as_double() - b.as_double());
PUSH(value);	stack.push(value);
break;	break;
}	}
case OP_ADD:	case OP_ADD:
{	{
b=POP(); a=POP();	Value& b=stack.pop().value(); Value& a=stack.pop().value();
value=NEW VDouble(pool(), a->as_double() + b->as_double());	Value& value=*new VDouble(a.as_double() + b.as_double());
PUSH(value);	stack.push(value);
break;	break;
}	}
case OP_MUL:	case OP_MUL:
{	{
b=POP(); a=POP();	Value& b=stack.pop().value(); Value& a=stack.pop().value();
value=NEW VDouble(pool(), a->as_double() * b->as_double());	Value& value=new VDouble(a.as_double() b.as_double());
PUSH(value);	stack.push(value);
break;	break;
}	}
case OP_DIV:	case OP_DIV:
{	{
b=POP(); a=POP();	Value& b=stack.pop().value(); Value& a=stack.pop().value();

double a_double=a->as_double();	double a_double=a.as_double();
double b_double=b->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",
problem_source,	0, //problem_source,
"Division by zero");	"Division by zero");
}	}

value=NEW VDouble(pool(), a_double / b_double);	Value& value=*new VDouble(a_double / b_double);
PUSH(value);	stack.push(value);
break;	break;
}	}
case OP_MOD:	case OP_MOD:
{	{
b=POP(); a=POP();	Value& b=stack.pop().value(); Value& a=stack.pop().value();

double a_double=a->as_double();	double a_double=a.as_double();
double b_double=b->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",
problem_source,	0, //problem_source,
"Modulus by zero");	"Modulus by zero");
}	}

value=NEW VDouble(pool(), fmod(a_double, b_double));	Value& value=*new VDouble(fmod(a_double, b_double));
PUSH(value);	stack.push(value);
break;	break;
}	}
case OP_INTDIV:	case OP_INTDIV:
{	{
b=POP(); a=POP();	Value& b=stack.pop().value(); Value& a=stack.pop().value();

int a_int=a->as_int();	int a_int=a.as_int();
int b_int=b->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",
problem_source,	0, //problem_source,
"Division by zero");	"Division by zero");
}	}

value=NEW VInt(pool(), a_int / b_int);	Value& value=*new VInt(a_int / b_int);
PUSH(value);	stack.push(value);
	break;
	}
	case OP_BIN_SL:
	{
	Value& b=stack.pop().value(); Value& a=stack.pop().value();
	Value& value=*new VInt(
	a.as_int() <<
	b.as_int());
	stack.push(value);
	break;
	}
	case OP_BIN_SR:
	{
	Value& b=stack.pop().value(); Value& a=stack.pop().value();
	Value& value=*new VInt(
	a.as_int() >>
	b.as_int());
	stack.push(value);
break;	break;
}	}
case OP_BIN_AND:	case OP_BIN_AND:
{	{
b=POP(); a=POP();	Value& b=stack.pop().value(); Value& a=stack.pop().value();
value=NEW VDouble(pool(),	Value& value=*new VInt(
a->as_int() &	a.as_int() &
b->as_int());	b.as_int());
PUSH(value);	stack.push(value);
break;	break;
}	}
case OP_BIN_OR:	case OP_BIN_OR:
{	{
b=POP(); a=POP();	Value& b=stack.pop().value(); Value& a=stack.pop().value();
value=NEW VDouble(pool(),	Value& value=*new VInt(
a->as_int() \|	a.as_int() \|
b->as_int());	b.as_int());
PUSH(value);	stack.push(value);
break;	break;
}	}
case OP_BIN_XOR:	case OP_BIN_XOR:
{	{
b=POP(); a=POP();	Value& b=stack.pop().value(); Value& a=stack.pop().value();
value=NEW VDouble(pool(),	Value& value=*new VInt(
a->as_int() ^	a.as_int() ^
b->as_int());	b.as_int());
PUSH(value);	stack.push(value);
break;	break;
}	}
case OP_LOG_AND:	case OP_LOG_AND:
{	{
b_code=POP_CODE(); a=POP();	ArrayOperation& local_ops=stack.pop().ops(); Value& a=stack.pop().value();
bool result;	bool result;
if(a->as_bool()) {	if(a.as_bool()) {
execute(*b_code);	execute(local_ops);
b=POP();	Value& b=stack.pop().value();
result=b->as_bool();	result=b.as_bool();
} else	} else
result=false;	result=false;
value=NEW VBool(pool(), result);	Value& value=*new VBool(result);
PUSH(value);	stack.push(value);
break;	break;
}	}
case OP_LOG_OR:	case OP_LOG_OR:
{	{
b_code=POP_CODE(); a=POP();	ArrayOperation& local_ops=stack.pop().ops(); Value& a=stack.pop().value();
bool result;	bool result;
if(a->as_bool())	if(a.as_bool())
result=true;	result=true;
else {	else {
execute(*b_code);	execute(local_ops);
b=POP();	Value& b=stack.pop().value();
result=b->as_bool();	result=b.as_bool();
}	}
value=NEW VBool(pool(), result);	Value& value=*new VBool(result);
PUSH(value);	stack.push(value);
break;	break;
}	}
case OP_LOG_XOR:	case OP_LOG_XOR:
{	{
b=POP(); a=POP();	Value& b=stack.pop().value(); Value& a=stack.pop().value();
value=NEW VBool(pool(), a->as_bool() ^ b->as_bool());	Value& value=*new VBool(a.as_bool() ^ b.as_bool());
PUSH(value);	stack.push(value);
break;	break;
}	}
case OP_NUM_LT:	case OP_NUM_LT:
{	{
b=POP(); a=POP();	volatile double b_double=stack.pop().value().as_double();
value=NEW VBool(pool(), a->as_double() < b->as_double());	volatile double a_double=stack.pop().value().as_double();
PUSH(value);	Value& value=*new VBool(a_double<b_double);
	stack.push(value);
break;	break;
}	}
case OP_NUM_GT:	case OP_NUM_GT:
{	{
b=POP(); a=POP();	volatile double b_double=stack.pop().value().as_double();
value=NEW VBool(pool(), a->as_double() > b->as_double());	volatile double a_double=stack.pop().value().as_double();
PUSH(value);	Value& value=*new VBool(a_double>b_double);
	stack.push(value);
break;	break;
}	}
case OP_NUM_LE:	case OP_NUM_LE:
{	{
b=POP(); a=POP();	volatile double b_double=stack.pop().value().as_double();
value=NEW VBool(pool(), a->as_double() <= b->as_double());	volatile double a_double=stack.pop().value().as_double();
PUSH(value);	Value& value=*new VBool(a_double<=b_double);
	stack.push(value);
break;	break;
}	}
case OP_NUM_GE:	case OP_NUM_GE:
{	{
b=POP(); a=POP();	volatile double b_double=stack.pop().value().as_double();
value=NEW VBool(pool(), a->as_double() >= b->as_double());	volatile double a_double=stack.pop().value().as_double();
PUSH(value);	Value& value=*new VBool(a_double>=b_double);
	stack.push(value);
break;	break;
}	}
case OP_NUM_EQ:	case OP_NUM_EQ:
{	{
b=POP(); a=POP();	volatile double b_double=stack.pop().value().as_double();
value=NEW VBool(pool(), a->as_double() == b->as_double());	volatile double a_double=stack.pop().value().as_double();
PUSH(value);	Value& value=*new VBool(a_double==b_double);
	stack.push(value);
break;	break;
}	}
case OP_NUM_NE:	case OP_NUM_NE:
{	{
b=POP(); a=POP();	volatile double b_double=stack.pop().value().as_double();
value=NEW VBool(pool(), a->as_double() != b->as_double());	volatile double a_double=stack.pop().value().as_double();
PUSH(value);	Value& value=*new VBool(a_double!=b_double);
	stack.push(value);
break;	break;
}	}
case OP_STR_LT:	case OP_STR_LT:
{	{
b=POP(); a=POP();	Value& b=stack.pop().value(); Value& a=stack.pop().value();
value=NEW VBool(pool(), a->as_string() < b->as_string());	Value& value=*new VBool(a.as_string() < b.as_string());
PUSH(value);	stack.push(value);
break;	break;
}	}
case OP_STR_GT:	case OP_STR_GT:
{	{
b=POP(); a=POP();	Value& b=stack.pop().value(); Value& a=stack.pop().value();
value=NEW VBool(pool(), a->as_string() > b->as_string());	Value& value=*new VBool(a.as_string() > b.as_string());
PUSH(value);	stack.push(value);
break;	break;
}	}
case OP_STR_LE:	case OP_STR_LE:
{	{
b=POP(); a=POP();	Value& b=stack.pop().value(); Value& a=stack.pop().value();
value=NEW VBool(pool(), a->as_string() <= b->as_string());	Value& value=*new VBool(a.as_string() <= b.as_string());
PUSH(value);	stack.push(value);
break;	break;
}	}
case OP_STR_GE:	case OP_STR_GE:
{	{
b=POP(); a=POP();	Value& b=stack.pop().value(); Value& a=stack.pop().value();
value=NEW VBool(pool(), a->as_string() >= b->as_string());	Value& value=*new VBool(a.as_string() >= b.as_string());
PUSH(value);	stack.push(value);
break;	break;
}	}
case OP_STR_EQ:	case OP_STR_EQ:
{	{
b=POP(); a=POP();	Value& b=stack.pop().value(); Value& a=stack.pop().value();
value=NEW VBool(pool(), a->as_string() == b->as_string());	Value& value=*new VBool(a.as_string() == b.as_string());
PUSH(value);	stack.push(value);
break;	break;
}	}
case OP_STR_NE:	case OP_STR_NE:
{	{
b=POP(); a=POP();	Value& b=stack.pop().value(); Value& a=stack.pop().value();
value=NEW VBool(pool(), a->as_string() != b->as_string());	Value& value=*new VBool(a.as_string() != b.as_string());
PUSH(value);	stack.push(value);
break;	break;
}	}
case OP_IS:	case OP_IS:
{	{
//_asm int 3;	Value& b=stack.pop().value(); Value& a=stack.pop().value();
b=POP(); a=POP();	Value& value=*new VBool(a.is(b.as_string().cstr()));
value=NEW VBool(pool(), b->as_string() == a->type());	stack.push(value);
PUSH(value);
break;	break;
}	}

default:	default:
throw Exception(0,	throw Exception(0,
0,	0,
"invalid opcode %d", op.code);	"invalid opcode %d", opcode);
}	}
}	}
	} catch(const Exception&) {
	// record it to stack trace
	if(debug_name)
	exception_trace.push(Trace(debug_name, debug_origin));
	rethrow;
	}
}	}

/// @test cache\|prepare junctions	/**
Value Request::get_element(const String & remember_name, bool can_call_operator) {	@todo cache\|prepare junctions
const String& name=POP_NAME(); remember_name=&name;	@bug ^superbase:method would dynamically call ^base:method if there is any
Value *ncontext=POP();	*/
Value *value=0;	Value& Request::get_element(Value& ncontext, const String& name, bool can_call_operator) {
if(can_call_operator)	Value* value=0;
if(Method* method=OP.get_method(name)) { // looking operator of that name FIRST	if(can_call_operator) {
// as if that method were in self and we have normal dynamic method here	if(Method* method=main_class.get_method(name)) // looking operator of that name FIRST
Junction& junction=*NEW Junction(pool(),	value=new VJunction(new Junction(main_class, method));
*root, self->get_class(), method, 0,0,0,0);	}
value=NEW VJunction(junction);	if(!value) {
}	if(!wcontext->get_constructing() // not constructing
	&& 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
	if(Value* base=get_self().base()) { // doing DYNAMIC call
	Temp_derived temp_derived(*base, 0); // temporarily prevent go-back-down virtual calls
	value=base->get_element(name, *base, false); // virtual-up lookup starting from parent
	goto value_ready;
	}
	}
if(!value)	if(!value)
value=ncontext->get_element(name);	value=ncontext.get_element(name, ncontext, false);

	if(value && wcontext->get_constructing())
	if(Junction* junction=value->get_junction()) {
	if(junction->self.get_class()!=&ncontext)
	throw Exception("parser.runtime",
	&name,
	"constructor must be declared in class '%s'",
	ncontext.get_class()->name_cstr());
	}

	value_ready:
if(value)	if(value)
value=&process_to_value(*value); // process possible code-junction	value=&process_to_value(*value); // process possible code-junction
else	else
value=NEW VVoid(pool());	value=new VVoid;

return value;	return *value;
	}

	void Request::put_element(Value& ncontext, const String& name, Value& value) {
	// put_element can return property-setting-junction
	if(const Junction* junction=ncontext.put_element(ncontext, name, &value, false))
	if(junction!=PUT_ELEMENT_REPLACED_ELEMENT) {
	// process it
	ArrayString* params_names=junction->method->params_names;
	int param_count=params_names? params_names->count(): 0;
	if(param_count!=1)
	throw Exception("parser.runtime",
	0,
	"setter method must have ONE parameter (has %d parameters)", param_count);

	VMethodFrame frame(junction, method_frame/caller*/);
	frame.store_param(value);

	frame.set_self(frame.junction.self);

	VMethodFrame *saved_method_frame=method_frame;
	Value* saved_rcontext=rcontext;
	WContext *saved_wcontext=wcontext;

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

	// prevent non-string writes for better error reporting
	wcontext->write(*method_frame);

	recoursion_checked_execute(*frame.junction.method->parser_code); // parser code, execute it
	// we don't need it StringOrValue result=wcontext->result();

	method_frame=saved_method_frame;
	wcontext=saved_wcontext;
	rcontext=saved_rcontext;
	}
}	}

/** @param intercept_string	/** @param intercept_string
Line 852 Value *Request::get_element(const String	Line 920 Value *Request::get_element(const String
using the fact it's either string_ or value_ result requested to speed up checkes	using the fact it's either string_ or value_ result requested to speed up checkes
*/	*/
StringOrValue Request::process(Value& input_value, bool intercept_string) {	StringOrValue Request::process(Value& input_value, bool intercept_string) {
StringOrValue result;	Junction* junction=input_value.get_junction();
Junction *junction=input_value.get_junction();	if(junction) {
if(junction && junction->code) { // is it a code-junction?	if(junction->is_getter) { // is it a getter-junction?
// process it	// process it

	VMethodFrame frame(junction, method_frame/caller*/);
	if(junction->method->params_names)
	throw Exception("parser.runtime",
	0,
	"getter method must have no parameters");

	frame.set_self(frame.junction.self);

	VMethodFrame *saved_method_frame=method_frame;
	Value* saved_rcontext=rcontext;
	WContext *saved_wcontext=wcontext;

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

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

	method_frame=saved_method_frame;
	wcontext=saved_wcontext;
	rcontext=saved_rcontext;

	return result;
	}

	if(junction->code) { // is it a code-junction?
	// process it
	StringOrValue result;
#ifdef DEBUG_EXECUTE	#ifdef DEBUG_EXECUTE
debug_printf(pool(), "ja->\n");	debug_printf(sapi_info, "ja->\n");
#endif	#endif

PUSH(self);	if(!junction->method_frame)
PUSH(root);	throw Exception("parser.runtime",
PUSH(rcontext);	0,
PUSH(wcontext);	"junction used outside of context");

WContext *jwcontext;	VMethodFrame *saved_method_frame=method_frame;
self=&junction->self;	Value* saved_rcontext=rcontext;
if(junction->root) {	WContext *saved_wcontext=wcontext;
root=junction->root;
	method_frame=junction->method_frame;
rcontext=junction->rcontext;	rcontext=junction->rcontext;
jwcontext=junction->wcontext;
} else
jwcontext=wcontext;

// for expression method params
// wcontext is set 0
// using the fact in decision "which wwrapper to use"
bool using_code_frame=intercept_string && jwcontext;
if(using_code_frame) {
// almost plain wwrapper about junction wcontext,
// BUT intercepts string writes
VCodeFrame local(pool(), *jwcontext);
wcontext=&local;

// execute it	// for expression method params
recoursion_checked_execute(0/result_name/, *junction->code);	// wcontext is set 0
	// using the fact in decision "which wwrapper to use"
// CodeFrame soul:	bool using_code_frame=intercept_string && junction->wcontext;
// string writes were intercepted	if(using_code_frame) {
// returning them as the result of getting code-junction	// almost plain wwrapper about junction wcontext,
result.set_string(*wcontext->get_string());	// BUT intercepts string writes
} else {	VCodeFrame local(*junction->wcontext, junction->wcontext);
// plain wwrapper	wcontext=&local;
WWrapper local(pool(), 0/empty/);
wcontext=&local;	// execute it
	recoursion_checked_execute(*junction->code);
// execute it
recoursion_checked_execute(0/result_name/, *junction->code);	// CodeFrame soul:
	// string writes were intercepted
result=wcontext->result();	// returning them as the result of getting code-junction
}	result.set_string(*wcontext->get_string());
	} else {
wcontext=static_cast<WContext *>(POP());	// plain wwrapper
rcontext=POP();	WWrapper local(0/empty/, wcontext);
root=POP();	wcontext=&local;
self=static_cast<VAliased *>(POP());
	// execute it
	recoursion_checked_execute(*junction->code);

	result=wcontext->result();
	}

	wcontext=saved_wcontext;
	rcontext=saved_rcontext;
	method_frame=saved_method_frame;

#ifdef DEBUG_EXECUTE	#ifdef DEBUG_EXECUTE
debug_printf(pool(), "<-ja returned");	debug_printf(sapi_info, "<-ja returned");
#endif	#endif
} else {	return result;
result.set_value(input_value);	}
}
return result;	// it is then method-junction, do not explode it
	// just return it as we do for usual objects
	}

	return input_value;
}	}

const String *Request::execute_method(Value& aself, const Method& method,	StringOrValue Request::execute_method(VMethodFrame& amethod_frame, const Method& method) {
bool return_cstr) {	VMethodFrame *saved_method_frame=method_frame;
PUSH(self);	Value* saved_rcontext=rcontext;
PUSH(root);	WContext *saved_wcontext=wcontext;
PUSH(rcontext);
PUSH(wcontext);

// initialize contexts	// initialize contexts
root=rcontext=self=&aself;	rcontext=wcontext=method_frame=&amethod_frame;
WWrapper local(pool(), &aself);
wcontext=&local;

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

// result	// result
const String *result=0;	StringOrValue result=wcontext->result();
if(return_cstr) {
if(Value result_var_value=wcontext->get_element(result_var_name))
result=&result_var_value->as_string();
else
result=&wcontext->as_string();
}

wcontext=static_cast<WContext *>(POP());	wcontext=saved_wcontext;
rcontext=POP();	rcontext=saved_rcontext;
root=POP();	method_frame=saved_method_frame;
self=static_cast<VAliased *>(POP());

// return	// return
return result;	return result;
}	}

const String& Request::execute_method(VMethodFrame& amethodFrame, const Method& method) {	const String* Request::execute_method(Value& aself,
PUSH(self);	const Method& method, VString* optional_param,
PUSH(root);	bool do_return_string) {
PUSH(rcontext);	VMethodFrame *saved_method_frame=method_frame;
PUSH(wcontext);	Value* saved_rcontext=rcontext;
	WContext *saved_wcontext=wcontext;

// initialize contexts	Junction local_junction(aself, &method);
root=rcontext=self=&amethodFrame;	VMethodFrame local_frame(local_junction, method_frame/caller/);
wcontext=&amethodFrame;	if(optional_param && local_frame.can_store_param()) {
	local_frame.store_param(*optional_param);
	local_frame.fill_unspecified_params();
	}
	local_frame.set_self(aself);
	rcontext=wcontext=method_frame=&local_frame;

	// prevent non-string writes for better error reporting
	if(do_return_string)
	wcontext->write(local_frame);

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

// result	// result
const String& result=wcontext->result().as_string();	const String* result=0;
	if(do_return_string)
wcontext=static_cast<WContext *>(POP());	result=&wcontext->result().as_string();
rcontext=POP();
root=POP();
self=static_cast<VAliased *>(POP());

// return	wcontext=saved_wcontext;
	rcontext=saved_rcontext;
	method_frame=saved_method_frame;

return result;	return result;
}	}

const String *Request::execute_virtual_method(Value& aself,	Request::Execute_nonvirtual_method_result
const String& method_name) {	Request::execute_nonvirtual_method(VStateless_class& aclass,
if(Value *value=aself.get_element(method_name))	const String& method_name, VString* optional_param,
if(Junction *junction=value->get_junction())	bool do_return_string) {
if(const Method *method=junction->method)	Execute_nonvirtual_method_result result;
return execute_method(aself, method, true /return_cstr*/);	result.method=aclass.get_method(method_name);
	if(result.method)
return 0;	result.string=execute_method(aclass, *result.method, optional_param,
	do_return_string);
	return result;
}	}

const String *Request::execute_nonvirtual_method(VStateless_class& aclass,	const String* Request::execute_virtual_method(Value& aself,
const String& method_name,	const String& method_name) {
bool return_cstr) {	if(Value* value=aself.get_element(method_name, aself, false))
if(const Method *method=aclass.get_method(method_name))	if(Junction* junction=value->get_junction())
return execute_method(aclass, *method, return_cstr);	if(const Method *method=junction->method)
	return execute_method(aself, method, 0/no params*/, true);

return 0;	return 0;
}	}

E-mail:

Removed from v.1.239
changed lines
	Added in v.1.309.2.2