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.189 and 1.243

version 1.189, 2001/08/02 08:58:59	version 1.243, 2002/08/01 11:26:49
Line 1	Line 1
/** @file	/** @file
Parser: executor part of request class.	Parser: executor part of request class.

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

#include "pa_opcode.h"	#include "pa_opcode.h"
#include "pa_array.h"	#include "pa_array.h"
Line 21 static const char *RCSId="$Id$";	Line 21 static const char *RCSId="$Id$";
#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_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


const uint ANTI_ENDLESS_EXECUTE_RECOURSION=400;

#ifdef DEBUG_EXECUTE	#ifdef DEBUG_EXECUTE
char *opcode_name[]={	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",

// actions	// actions
"WITH_ROOT", "WITH_SELF", "WITH_READ", "WITH_WRITE",	"WITH_ROOT", "WITH_SELF", "WITH_READ", "WITH_WRITE",
"GET_CLASS",	"GET_CLASS",
"CONSTRUCT_VALUE", "CONSTRUCT_EXPR", "CURLY_CODE__CONSTRUCT",	"CONSTRUCT_VALUE", "CONSTRUCT_EXPR", "CURLY_CODE__CONSTRUCT",
"WRITE_VALUE", "WRITE_EXPR_RESULT", "STRING__WRITE",	"WRITE_VALUE", "WRITE_EXPR_RESULT", "STRING__WRITE",
"GET_ELEMENT", "GET_ELEMENT__WRITE",	"GET_ELEMENT_OR_OPERATOR", "GET_ELEMENT", "GET_ELEMENT__WRITE",
"CREATE_EWPOOL", "REDUCE_EWPOOL",	"OBJECT_POOL", "STRING_POOL",
"CREATE_SWPOOL", "REDUCE_SWPOOL",
"GET_METHOD_FRAME",
"STORE_PARAM",	"STORE_PARAM",
"PREPARE_TO_CONSTRUCT_OBJECT", "CALL",	"PREPARE_TO_CONSTRUCT_OBJECT", "PREPARE_TO_EXPRESSION",
	"CALL", "CALL__WRITE",

// expression ops: unary	// expression ops: unary
"NEG", "INV", "NOT", "DEF", "IN", "FEXISTS", "DEXISTS",	"NEG", "INV", "NOT", "DEF", "IN", "FEXISTS", "DEXISTS",
// expression ops: binary	// expression ops: binary
"SUB", "ADD", "MUL", "DIV", "MOD",	"SUB", "ADD", "MUL", "DIV", "MOD", "INTDIV",
"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 68 void debug_printf(Pool& pool, const char	Line 75 void debug_printf(Pool& pool, const char
}	}

void debug_dump(Pool& pool, int level, const Array& ops) {	void debug_dump(Pool& pool, int level, const Array& ops) {
/* {	Array_iter i(ops);
int size=ops.quick_size();	while(i.has_next()) {
//debug_printf(pool, "size=%d\n", size);
for(int i=0; i<size; i++) {
Operation op;
op.cast=ops.quick_get(i);
debug_printf(pool, "%8X\n", op.cast);
}
}*/

int size=ops.quick_size();
//debug_printf(pool, "size=%d\n", size);
for(int i=0; i<size; i++) {
Operation op;	Operation op;
op.cast=ops.quick_get(i);	op.cast=i.next();

if(op.code==OP_VALUE \|\| op.code==OP_STRING__WRITE) {	if(op.code==OP_VALUE \|\| op.code==OP_STRING__WRITE) {
Value value=static_cast<Value >(ops.quick_get(++i));	Value value=static_cast<Value >(i.next());
debug_printf(pool,	debug_printf(pool,
"%*s%s"	"%*s%s"
" \"%s\" %s",	" \"%s\" %s",
Line 99 void debug_dump(Pool& pool, int level, c	Line 95 void debug_dump(Pool& pool, int level, c
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:
const Array local_ops=reinterpret_cast<const Array >(ops.quick_get(++i));	case OP_NESTED_CODE:
	case OP_OBJECT_POOL:
	case OP_STRING_POOL:
	case OP_CALL:
	const Array local_ops=reinterpret_cast<const Array >(i.next());
debug_dump(pool, level+1, *local_ops);	debug_dump(pool, level+1, *local_ops);
}	}
}	}
Line 109 void debug_dump(Pool& pool, int level, c	Line 109 void debug_dump(Pool& pool, int level, c
#define PUSH(value) stack.push(value)	#define PUSH(value) stack.push(value)
#define POP() static_cast<Value *>(stack.pop())	#define POP() static_cast<Value *>(stack.pop())
#define POP_NAME() static_cast<Value *>(stack.pop())->as_string()	#define POP_NAME() static_cast<Value *>(stack.pop())->as_string()
	#define POP_CODE() static_cast<Array *>(stack.pop())

	/**
	Helps preventing evaluation of junctions in outdated context

	To stop situations like this:
	@code
	@main[]
	^method1[]
	^method2[]

	@method1[]
	$junction{
	some code
	}

	@method2[]
	^junction[]
	@endcode

	All Junctions, generated by OP_CURLY_CODE__CONSTRUCT are registered here,
	and on scope exit got cleaned - there Junction::root becomes 0,
	which later in Request::process triggers exception
	*/
	class Auto_junction_cleaner {
	public:
	Auto_junction_cleaner () : junctions(0) {}
	~Auto_junction_cleaner () {
	if(junctions) {
	Array_iter i(*junctions);
	while(i.has_next())
	static_cast<Junction *>(i.next())->change_context(0);
	// someday free junctions
	}
	}
	void register_junction(Pool& apool, Junction& ajunction) {
	if(!junctions)
	junctions=new(apool) Array(apool);
	if(junctions)
	*junctions+=&ajunction;
	}
	private:
	Array *junctions;
	};

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

//int size=ops.quick_size();	Auto_junction_cleaner junction_cleaner;
//debug_printf(pool(), "size=%d\n", size);	const String *last_get_element_name=0;
for(int i=0; i<ops.size(); i++) {
	Array_iter i(ops);
	while(i.has_next()) {
Operation op;	Operation op;
//op.cast=ops.quick_get(i);	op.cast=i.next();
op.cast=ops.get(i);
#ifdef DEBUG_EXECUTE	#ifdef DEBUG_EXECUTE
debug_printf(pool(), "%d:%s", stack.top_index()+1, opcode_name[op.code]);	debug_printf(pool(), "%d:%s", stack.top_index()+1, opcode_name[op.code]);
#endif	#endif

	Value *value;
	Value a; Value b;
	Array *b_code;
switch(op.code) {	switch(op.code) {
// param in next instruction	// param in next instruction
case OP_VALUE:	case OP_VALUE:
{	{
Value value=static_cast<Value >(ops.quick_get(++i));	value=static_cast<Value *>(i.next());
#ifdef DEBUG_EXECUTE	#ifdef DEBUG_EXECUTE
debug_printf(pool(), " \"%s\" %s", value->get_string()->cstr(), value->type());	debug_printf(pool(), " \"%s\" %s", value->get_string()->cstr(), value->type());
#endif	#endif
PUSH(value);	PUSH(value);
break;	break;
}	}
case OP_CURLY_CODE__STORE_PARAM:
case OP_EXPR_CODE__STORE_PARAM:
{
VMethodFrame frame=static_cast<VMethodFrame >(stack.top_value());
// code
const Array local_ops=reinterpret_cast<const Array >(ops.quick_get(++i));
#ifdef DEBUG_EXECUTE
debug_printf(pool(), " (%d)\n", local_ops->size());
debug_dump(pool(), 1, *local_ops);
#endif
// when they evaluate expression parameter,
// the object expression result
// does not need to be written into calling frame
// it must go into any expressions using that parameter
// hence, we zero junction.wcontext here, and later
// in .process we would test that field
// in decision "which wwrapper to use"
Junction& j=*NEW Junction(pool(),
*self, 0, 0,
root,
rcontext,
op.code==OP_EXPR_CODE__STORE_PARAM?0:wcontext,
local_ops);

Value *value=NEW VJunction(j);

// store param
frame->store_param(frame->name(), value);
break;
}
case OP_GET_CLASS:	case OP_GET_CLASS:
{	{
// 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=POP_NAME();
Value value=static_cast<Value >(classes().get(name));	value=static_cast<Value *>(classes().get(name));
if(!value)	if(!value)
THROW(0,0,	throw Exception("parser.runtime",
&name,	&name,
"class is undefined");	"class is undefined");

Line 209 void Request::execute(const Array& ops)	Line 228 void Request::execute(const Array& ops)
// OTHER ACTIONS BUT WITHs	// OTHER ACTIONS BUT WITHs
case OP_CONSTRUCT_VALUE:	case OP_CONSTRUCT_VALUE:
{	{
Value *value=POP();	value=POP();
const String& name=POP_NAME();	const String& name=POP_NAME();
Value *ncontext=POP();	Value *ncontext=POP();
ncontext->put_element(name, value);	ncontext->put_element(name, value);
value->set_name(name);
break;	break;
}	}
case OP_CONSTRUCT_EXPR:	case OP_CONSTRUCT_EXPR:
{	{
Value *value=POP();	// see OP_PREPARE_TO_EXPRESSION
	wcontext->set_in_expression(false);

	value=POP();
const String& name=POP_NAME();	const String& name=POP_NAME();
Value *ncontext=POP();	Value *ncontext=POP();
ncontext->put_element(name, value->as_expr_result());	ncontext->put_element(name, value->as_expr_result());
value->set_name(name);
break;	break;
}	}
case OP_CURLY_CODE__CONSTRUCT:	case OP_CURLY_CODE__CONSTRUCT:
{	{
const Array local_ops=reinterpret_cast<const Array >(ops.quick_get(++i));	const Array local_ops=reinterpret_cast<const Array >(i.next());
#ifdef DEBUG_EXECUTE	#ifdef DEBUG_EXECUTE
debug_printf(pool(), " (%d)\n", local_ops->size());	debug_printf(pool(), " (%d)\n", local_ops->size());
debug_dump(pool(), 1, *local_ops);	debug_dump(pool(), 1, *local_ops);
Line 238 void Request::execute(const Array& ops)	Line 258 void Request::execute(const Array& ops)
rcontext,	rcontext,
wcontext,	wcontext,
local_ops);	local_ops);
	junction_cleaner.register_junction(pool(), j);
Value *value=NEW VJunction(j);
	value=NEW VJunction(j);
const String& name=POP_NAME();	const String& name=POP_NAME();
Value *ncontext=POP();	Value *ncontext=POP();
ncontext->put_element(name, value);	ncontext->put_element(name, value);
value->set_name(name);	break;
	}
	case OP_NESTED_CODE:
	{
	Array local_ops=static_cast<Array >(i.next());
	#ifdef DEBUG_EXECUTE
	debug_printf(pool(), " (%d)\n", local_ops->size());
	debug_dump(pool(), 1, *local_ops);
	#endif
	PUSH(local_ops);
break;	break;
}	}
case OP_WRITE_VALUE:	case OP_WRITE_VALUE:
{	{
Value *value=POP();	value=POP();
write_assign_lang(*value);	write_assign_lang(*value, last_get_element_name);

// forget the fact they've entered some ^object.method[].
// see OP_GET_ELEMENT
wcontext->clear_somebody_entered_some_object();
break;	break;
}	}
case OP_WRITE_EXPR_RESULT:	case OP_WRITE_EXPR_RESULT:
{	{
Value *value=POP();	value=POP();
write_expr_result(*value->as_expr_result());	write_no_lang(*value->as_expr_result());

	// must be after write(result) and
	// see OP_PREPARE_TO_EXPRESSION
	wcontext->set_in_expression(false);
break;	break;
}	}
case OP_STRING__WRITE:	case OP_STRING__WRITE:
{	{
VString vstring=static_cast<VString >(ops.quick_get(++i));	VString vstring=static_cast<VString >(i.next());
#ifdef DEBUG_EXECUTE	#ifdef DEBUG_EXECUTE
debug_printf(pool(), " \"%s\"", vstring->string().cstr());	debug_printf(pool(), " \"%s\"", vstring->string().cstr());
#endif	#endif
Line 272 void Request::execute(const Array& ops)	Line 302 void Request::execute(const Array& ops)
break;	break;
}	}

	case OP_GET_ELEMENT_OR_OPERATOR:
	{
	// maybe they do ^object.method[] call, remember the fact
	wcontext->set_somebody_entered_some_object(true);

	//_asm int 3;
	value=get_element(last_get_element_name, true);
	PUSH(value);
	break;
	}
case OP_GET_ELEMENT:	case OP_GET_ELEMENT:
{	{
// maybe they do ^object.method[] call, remember the fact	// maybe they do ^object.method[] call, remember the fact
wcontext->inc_somebody_entered_some_object();	wcontext->set_somebody_entered_some_object(true);

//_asm int 3;	//_asm int 3;
Value *value=get_element();	value=get_element(last_get_element_name, false);
PUSH(value);	PUSH(value);
break;	break;
}	}

case OP_GET_ELEMENT__WRITE:	case OP_GET_ELEMENT__WRITE:
{	{
Value *value=get_element();	value=get_element(last_get_element_name/not followed by call, not needed really/, false);
write_assign_lang(*value);	write_assign_lang(*value, last_get_element_name);
break;	break;
}	}


case OP_CREATE_EWPOOL:	case OP_OBJECT_POOL:
{	{
	const Array local_ops=reinterpret_cast<const Array >(i.next());

PUSH(wcontext);	PUSH(wcontext);
PUSH((void *)flang);	PUSH((void *)flang);
flang=String::UL_PASS_APPENDED;	flang=String::UL_PASS_APPENDED;
wcontext=NEW WWrapper(pool(), 0 /empty/);	WWrapper local(pool(), 0 /empty/);
break;	wcontext=&local;
}
case OP_REDUCE_EWPOOL:	execute(*local_ops);
{
Value *value=wcontext->result();	value=&wcontext->result().as_value();
flang=static_cast<String::Untaint_lang>(reinterpret_cast<int>(POP()));	flang=static_cast<String::Untaint_lang>(reinterpret_cast<int>(POP()));
wcontext=static_cast<WContext *>(POP());	wcontext=static_cast<WContext *>(POP());
PUSH(value);	PUSH(value);
break;	break;
}	}

case OP_CREATE_SWPOOL:	case OP_STRING_POOL:
{	{
	const Array local_ops=reinterpret_cast<const Array >(i.next());

PUSH(wcontext);	PUSH(wcontext);
wcontext=NEW WWrapper(pool(), 0 /empty/);	WWrapper local(pool(), 0 /empty/);
break;	wcontext=&local;
}
case OP_REDUCE_SWPOOL:	execute(*local_ops);
{
// 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();	const String *string=wcontext->get_string();
Line 330 void Request::execute(const Array& ops)	Line 374 void Request::execute(const Array& ops)
}	}

// CALL	// CALL
case OP_GET_METHOD_FRAME:	case OP_STORE_PARAM:
{	{
Value *value=POP();	value=POP();
	VMethodFrame frame=static_cast<VMethodFrame >(stack.top_value());
// info:	// this op is executed from CALL local_ops only, so can not check method_frame_to_fill==0
// code compiled so that this one's always method-junction,	frame->store_param(value);
// not a code-junction
Junction *junction=value->get_junction();
if(!junction)
THROW(0, 0,
&value->name(),
"(%s) not a method or junction, can not call it",
value->type());

VMethodFrame frame=NEW VMethodFrame(pool(), value->name(), junction);
PUSH(frame);
break;	break;
}	}
case OP_STORE_PARAM:	case OP_CURLY_CODE__STORE_PARAM:
	case OP_EXPR_CODE__STORE_PARAM:
{	{
Value *value=POP();	// code
	const Array local_ops=reinterpret_cast<const Array >(i.next());
VMethodFrame frame=static_cast<VMethodFrame >(stack.top_value());	VMethodFrame frame=static_cast<VMethodFrame >(stack.top_value());
frame->store_param(frame->name(), value);	#ifdef DEBUG_EXECUTE
	debug_printf(pool(), " (%d)\n", local_ops->size());
	debug_dump(pool(), 1, *local_ops);
	#endif
	// when they evaluate expression parameter,
	// the object expression result
	// does not need to be written into calling frame
	// it must go into any expressions using that parameter
	// hence, we zero junction.wcontext here, and later
	// in .process we would test that field
	// in decision "which wwrapper to use"
	Junction& j=*NEW Junction(pool(),
	*self, 0, 0,
	root,
	rcontext,
	op.code==OP_EXPR_CODE__STORE_PARAM?0:wcontext,
	local_ops);

	value=NEW VJunction(j);

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

case OP_PREPARE_TO_CONSTRUCT_OBJECT:	case OP_PREPARE_TO_CONSTRUCT_OBJECT:
{	{
wcontext->constructing(true);	wcontext->set_constructing(true);
	break;
	}

	case OP_PREPARE_TO_EXPRESSION:
	{
	wcontext->set_in_expression(true);
break;	break;
}	}

case OP_CALL:	case OP_CALL:
	case OP_CALL__WRITE:
{	{
	Array local_ops=static_cast<Array >(i.next());
#ifdef DEBUG_EXECUTE	#ifdef DEBUG_EXECUTE
	debug_printf(pool(), " (%d)\n", local_ops->size());
	debug_dump(pool(), 1, *local_ops);

debug_printf(pool(), "->\n");	debug_printf(pool(), "->\n");
#endif	#endif
VMethodFrame frame=static_cast<VMethodFrame >(POP());	value=POP();
frame->fill_unspecified_params();
	// info:
	// code compiled so that this one's always method-junction,
	// not a code-junction
	Junction *junction=value->get_junction();
	if(!junction)
	throw Exception("parser.runtime",
	last_get_element_name,
	"(%s) not a method or junction, can not call it",
	value->type());

	VMethodFrame frame(pool(), last_get_element_name, junction);
	if(local_ops){ // store param code goes here
	PUSH(&frame); // argument for *STORE_PARAM ops
	execute(*local_ops);
	POP();
	}
	frame.fill_unspecified_params();
PUSH(self);	PUSH(self);
PUSH(root);	PUSH(root);
PUSH(rcontext);	PUSH(rcontext);
PUSH(wcontext);	PUSH(wcontext);

VStateless_class *called_class=frame->junction.self.get_class();	VStateless_class *called_class=frame.junction.self.get_class();
if(wcontext->constructing()) {	if(wcontext->get_constructing()) {
wcontext->constructing(false);	wcontext->set_constructing(false);
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())) {	if(Value *value=called_class->create_new_value(pool())) {
// some stateless_object creatable derivates	// some stateless_class creatable derivates
self=value;	self=value;
} else {	} else
// stateful object	throw Exception("parser.runtime",
self=NEW VObject(pool(), *called_class);	&frame.name(),
}	"is not a constructor, system class '%s' can be constructed only implicitly",
frame->write(*self,	called_class->name().cstr());

	frame.write(*self,
String::UL_CLEAN // not used, always an object, not string	String::UL_CLEAN // not used, always an object, not string
);	);
} else	} else
THROW(0, 0,	throw Exception("parser.runtime",
&frame->name(),	&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	// this is not constructor call
Line 400 void Request::execute(const Array& ops)	Line 489 void Request::execute(const Array& ops)
// is context object or class & is it my class or my parent's class and?	// is context object or class & is it my class or my parent's class and?
VStateless_class *read_class=rcontext->get_class();	VStateless_class *read_class=rcontext->get_class();
if(	if(
!(wcontext->somebody_entered_some_object() &&	!(wcontext->get_somebody_entered_some_object() &&
!wcontext->somebody_entered_some_class()) &&	!wcontext->get_somebody_entered_some_class()) &&
read_class && read_class->is_or_derived_from(*called_class)) // yes	read_class && read_class->is_or_derived_from(*called_class)) // yes
self=rcontext; // dynamic call	self=rcontext; // dynamic call
else // no, not me or relative of mine (=total stranger)	else // no, not me or relative of mine (=total stranger)
self=&frame->junction.self; // static call	self=&frame.junction.self; // static call
}	}

frame->set_self(*self);	frame.set_self(*self);
root=rcontext=wcontext=frame;
	// see OP_PREPARE_TO_EXPRESSION
	frame.set_in_expression(wcontext->get_in_expression());

	rcontext=wcontext=&frame;
{	{
// take object or class from any wrappers	// take object or class from any wrappers
// and substitute class alias to the class they are called AS	// and substitute class alias to the class they are called AS
Temp_alias temp_alias(self->get_aliased(), frame->junction.vclass);	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==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?
if(method.native_code) { // native code?	try {
method.check_actual_numbered_params(pool(),	if(method.native_code) { // native code?
frame->junction.self,	// root unchanged, so that ^for ^foreach & co may write to locals
frame->name(), frame->numbered_params());	method.check_actual_numbered_params(
method.native_code(	frame.junction.self,
*this,	frame.name(), frame.numbered_params());
frame->name(), frame->numbered_params()); // execute it	method.native_code(
} else { // parser code	*this,
if(++anti_endless_execute_recoursion==ANTI_ENDLESS_EXECUTE_RECOURSION) {	frame.name(), frame.numbered_params()); // execute it
anti_endless_execute_recoursion=0; // give @exception a chance	} else { // parser code
THROW(0, 0,	root=&frame;
&frame->name(),	// execute it
"endless recursion detected");	recoursion_checked_execute(&frame.name(), *method.parser_code);
}	}
	} catch(...) {
execute(*method.parser_code); // execute it	// record it to stack trace
anti_endless_execute_recoursion--;	exception_trace.push((void *)&frame.name());
	/re/throw;
}	}
else	} else
THROW(0, 0,	throw Exception("parser.runtime",
&frame->name(),	&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");

}	}
Value *value=wcontext->result();	StringOrValue result=wcontext->result();

wcontext=static_cast<WContext *>(POP());	wcontext=static_cast<WContext *>(POP());
rcontext=POP();	rcontext=POP();
root=POP();	root=POP();
self=static_cast<VAliased *>(POP());	self=static_cast<VAliased *>(POP());

PUSH(value);	#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) {
	write_assign_lang(result, last_get_element_name);
	// forget the fact they've entered some ^object.method[].
	// see OP_GET_ELEMENT
	wcontext->set_somebody_entered_some_object(false);
	} else { // OP_CALL
	PUSH(&result.as_value());
	}

#ifdef DEBUG_EXECUTE	#ifdef DEBUG_EXECUTE
debug_printf(pool(), "<-returned");	debug_printf(pool(), "<-returned");
#endif	#endif
Line 464 void Request::execute(const Array& ops)	Line 571 void Request::execute(const Array& ops)
case OP_NEG:	case OP_NEG:
{	{
Value *operand=POP();	Value *operand=POP();
Value *value=NEW VDouble(pool(), -operand->as_double());	value=NEW VDouble(pool(), -operand->as_double());
PUSH(value);	PUSH(value);
break;	break;
}	}
case OP_INV:	case OP_INV:
{	{
Value *operand=POP();	Value *operand=POP();
Value *value=NEW VDouble(pool(), ~operand->as_int());	value=NEW VDouble(pool(), ~operand->as_int());
PUSH(value);	PUSH(value);
break;	break;
}	}
case OP_NOT:	case OP_NOT:
{	{
Value *operand=POP();	Value *operand=POP();
Value *value=NEW VBool(pool(), !operand->as_bool());	value=NEW VBool(pool(), !operand->as_bool());
PUSH(value);	PUSH(value);
break;	break;
}	}
case OP_DEF:	case OP_DEF:
{	{
Value *operand=POP();	Value *operand=POP();
Value *value=NEW VBool(pool(), operand->is_defined());	value=NEW VBool(pool(), operand->is_defined());
PUSH(value);	PUSH(value);
break;	break;
}	}
case OP_IN:	case OP_IN:
{	{
	/// @test String::cmp
Value *operand=POP();	Value *operand=POP();
const char *path=operand->as_string().cstr();	const char *path=operand->as_string().cstr();
Value *value=NEW VBool(pool(),	value=NEW VBool(pool(),
info.uri && strncmp(path, info.uri, strlen(path))==0);	info.uri && strncmp(path, info.uri, strlen(path))==0);
PUSH(value);	PUSH(value);
break;	break;
Line 501 void Request::execute(const Array& ops)	Line 609 void Request::execute(const Array& ops)
case OP_FEXISTS:	case OP_FEXISTS:
{	{
Value *operand=POP();	Value *operand=POP();
Value *value=NEW VBool(pool(),	value=NEW VBool(pool(),
file_readable(absolute(operand->as_string())));	file_readable(absolute(operand->as_string())));
PUSH(value);	PUSH(value);
break;	break;
Line 509 void Request::execute(const Array& ops)	Line 617 void Request::execute(const Array& ops)
case OP_DEXISTS:	case OP_DEXISTS:
{	{
Value *operand=POP();	Value *operand=POP();
Value *value=NEW VBool(pool(),	value=NEW VBool(pool(),
dir_readable(absolute(operand->as_string())));	dir_readable(absolute(operand->as_string())));
PUSH(value);	PUSH(value);
break;	break;
Line 518 void Request::execute(const Array& ops)	Line 626 void Request::execute(const Array& ops)
// expression ops: binary	// expression ops: binary
case OP_SUB:	case OP_SUB:
{	{
Value b=POP(); Value a=POP();	b=POP(); a=POP();
Value *value=NEW VDouble(pool(), a->as_double() - b->as_double());	value=NEW VDouble(pool(), a->as_double() - b->as_double());
PUSH(value);	PUSH(value);
break;	break;
}	}
case OP_ADD:	case OP_ADD:
{	{
Value b=POP(); Value a=POP();	b=POP(); a=POP();
Value *value=NEW VDouble(pool(), a->as_double() + b->as_double());	value=NEW VDouble(pool(), a->as_double() + b->as_double());
PUSH(value);	PUSH(value);
break;	break;
}	}
case OP_MUL:	case OP_MUL:
{	{
Value b=POP(); Value a=POP();	b=POP(); a=POP();
Value value=NEW VDouble(pool(), a->as_double() b->as_double());	value=NEW VDouble(pool(), a->as_double() * b->as_double());
PUSH(value);	PUSH(value);
break;	break;
}	}
case OP_DIV:	case OP_DIV:
{	{
Value b=POP(); Value a=POP();	b=POP(); a=POP();

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();
#ifndef NO_STRING_ORIGIN	throw Exception("number.zerodivision",
if(!problem_source->origin().file)
problem_source=&b->name();
#endif
THROW(0, 0,
problem_source,	problem_source,
"Division by zero");	"Division by zero");
}	}

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

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();
#ifndef NO_STRING_ORIGIN	throw Exception("number.zerodivision",
if(!problem_source->origin().file)
problem_source=&b->name();
#endif
THROW(0, 0,
problem_source,	problem_source,
"Modulus by zero");	"Modulus by zero");
}	}

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

	int a_int=a->as_int();
	int b_int=b->as_int();

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

	value=NEW VInt(pool(), a_int / b_int);
PUSH(value);	PUSH(value);
break;	break;
}	}
case OP_BIN_AND:	case OP_BIN_AND:
{	{
Value b=POP(); Value a=POP();	b=POP(); a=POP();
Value *value=NEW VDouble(pool(),	value=NEW VDouble(pool(),
a->as_int() &	a->as_int() &
b->as_int());	b->as_int());
PUSH(value);	PUSH(value);
Line 592 void Request::execute(const Array& ops)	Line 710 void Request::execute(const Array& ops)
}	}
case OP_BIN_OR:	case OP_BIN_OR:
{	{
Value b=POP(); Value a=POP();	b=POP(); a=POP();
Value *value=NEW VDouble(pool(),	value=NEW VDouble(pool(),
a->as_int() \|	a->as_int() \|
b->as_int());	b->as_int());
PUSH(value);	PUSH(value);
Line 601 void Request::execute(const Array& ops)	Line 719 void Request::execute(const Array& ops)
}	}
case OP_BIN_XOR:	case OP_BIN_XOR:
{	{
Value b=POP(); Value a=POP();	b=POP(); a=POP();
Value *value=NEW VDouble(pool(),	value=NEW VDouble(pool(),
a->as_int() ^	a->as_int() ^
b->as_int());	b->as_int());
PUSH(value);	PUSH(value);
Line 610 void Request::execute(const Array& ops)	Line 728 void Request::execute(const Array& ops)
}	}
case OP_LOG_AND:	case OP_LOG_AND:
{	{
Value b=POP(); Value a=POP();	b_code=POP_CODE(); a=POP();
Value *value=NEW VBool(pool(), a->as_bool() && b->as_bool());	bool result;
	if(a->as_bool()) {
	execute(*b_code);
	b=POP();
	result=b->as_bool();
	} else
	result=false;
	value=NEW VBool(pool(), result);
PUSH(value);	PUSH(value);
break;	break;
}	}
case OP_LOG_OR:	case OP_LOG_OR:
{	{
Value b=POP(); Value a=POP();	b_code=POP_CODE(); a=POP();
Value *value=NEW VBool(pool(), a->as_bool() \|\| b->as_bool());	bool result;
	if(a->as_bool())
	result=true;
	else {
	execute(*b_code);
	b=POP();
	result=b->as_bool();
	}
	value=NEW VBool(pool(), result);
PUSH(value);	PUSH(value);
break;	break;
}	}
case OP_LOG_XOR:	case OP_LOG_XOR:
{	{
Value b=POP(); Value a=POP();	b=POP(); a=POP();
Value *value=NEW VBool(pool(), a->as_bool() ^ b->as_bool());	value=NEW VBool(pool(), a->as_bool() ^ b->as_bool());
PUSH(value);	PUSH(value);
break;	break;
}	}
case OP_NUM_LT:	case OP_NUM_LT:
{	{
Value b=POP(); Value a=POP();	b=POP(); a=POP();
Value *value=NEW VBool(pool(), a->as_double() < b->as_double());	value=NEW VBool(pool(), a->as_double() < b->as_double());
PUSH(value);	PUSH(value);
break;	break;
}	}
case OP_NUM_GT:	case OP_NUM_GT:
{	{
Value b=POP(); Value a=POP();	b=POP(); a=POP();
Value *value=NEW VBool(pool(), a->as_double() > b->as_double());	value=NEW VBool(pool(), a->as_double() > b->as_double());
PUSH(value);	PUSH(value);
break;	break;
}	}
case OP_NUM_LE:	case OP_NUM_LE:
{	{
Value b=POP(); Value a=POP();	b=POP(); a=POP();
Value *value=NEW VBool(pool(), a->as_double() <= b->as_double());	value=NEW VBool(pool(), a->as_double() <= b->as_double());
PUSH(value);	PUSH(value);
break;	break;
}	}
case OP_NUM_GE:	case OP_NUM_GE:
{	{
Value b=POP(); Value a=POP();	b=POP(); a=POP();
Value *value=NEW VBool(pool(), a->as_double() >= b->as_double());	value=NEW VBool(pool(), a->as_double() >= b->as_double());
PUSH(value);	PUSH(value);
break;	break;
}	}
case OP_NUM_EQ:	case OP_NUM_EQ:
{	{
Value b=POP(); Value a=POP();	b=POP(); a=POP();
Value *value=NEW VBool(pool(), a->as_double() == b->as_double());	value=NEW VBool(pool(), a->as_double() == b->as_double());
PUSH(value);	PUSH(value);
break;	break;
}	}
case OP_NUM_NE:	case OP_NUM_NE:
{	{
Value b=POP(); Value a=POP();	b=POP(); a=POP();
Value *value=NEW VBool(pool(), a->as_double() != b->as_double());	value=NEW VBool(pool(), a->as_double() != b->as_double());
PUSH(value);	PUSH(value);
break;	break;
}	}
case OP_STR_LT:	case OP_STR_LT:
{	{
Value b=POP(); Value a=POP();	b=POP(); a=POP();
Value *value=NEW VBool(pool(), a->as_string() < b->as_string());	value=NEW VBool(pool(), a->as_string() < b->as_string());
PUSH(value);	PUSH(value);
break;	break;
}	}
case OP_STR_GT:	case OP_STR_GT:
{	{
Value b=POP(); Value a=POP();	b=POP(); a=POP();
Value *value=NEW VBool(pool(), a->as_string() > b->as_string());	value=NEW VBool(pool(), a->as_string() > b->as_string());
PUSH(value);	PUSH(value);
break;	break;
}	}
case OP_STR_LE:	case OP_STR_LE:
{	{
Value b=POP(); Value a=POP();	b=POP(); a=POP();
Value *value=NEW VBool(pool(), a->as_string() <= b->as_string());	value=NEW VBool(pool(), a->as_string() <= b->as_string());
PUSH(value);	PUSH(value);
break;	break;
}	}
case OP_STR_GE:	case OP_STR_GE:
{	{
Value b=POP(); Value a=POP();	b=POP(); a=POP();
Value *value=NEW VBool(pool(), a->as_string() >= b->as_string());	value=NEW VBool(pool(), a->as_string() >= b->as_string());
PUSH(value);	PUSH(value);
break;	break;
}	}
case OP_STR_EQ:	case OP_STR_EQ:
{	{
Value b=POP(); Value a=POP();	b=POP(); a=POP();
Value *value=NEW VBool(pool(), a->as_string() == b->as_string());	value=NEW VBool(pool(), a->as_string() == b->as_string());
PUSH(value);	PUSH(value);
break;	break;
}	}
case OP_STR_NE:	case OP_STR_NE:
{	{
Value b=POP(); Value a=POP();	b=POP(); a=POP();
Value *value=NEW VBool(pool(), a->as_string() != b->as_string());	value=NEW VBool(pool(), a->as_string() != b->as_string());
PUSH(value);	PUSH(value);
break;	break;
}	}
case OP_IS:	case OP_IS:
{	{
Value b=POP(); Value a=POP();	//_asm int 3;
Value *value=NEW VBool(pool(), b->as_string() == a->type());	b=POP(); a=POP();
	value=NEW VBool(pool(), b->as_string() == a->type());
PUSH(value);	PUSH(value);
break;	break;
}	}

default:	default:
THROW(0,0,	throw Exception(0,
0,	0,
"invalid opcode %d", op.code);	"invalid opcode %d", op.code);
}	}
}	}
}	}

Value *Request::get_element() {	/// @test cache\|prepare junctions
const String& name=POP_NAME();	Value Request::get_element(const String & remember_name, bool can_call_operator) {
	const String& name=POP_NAME(); remember_name=&name;
Value *ncontext=POP();	Value *ncontext=POP();
Value *value=ncontext->get_element(name);	Value *value=0;
if(!value)	if(can_call_operator)
if(Method* method=OP.get_method(name)) { // maybe operator?	if(Method* method=OP.get_method(name)) { // looking operator of that name FIRST
// as if that method were in self and we have normal dynamic method here	// as if that method were in self and we have normal dynamic method here
Junction& junction=*NEW Junction(pool(),	Junction& junction=*NEW Junction(pool(),
*self, self->get_class(), method, 0,0,0,0);	*root, self->get_class(), method, 0,0,0,0);
value=NEW VJunction(junction);	value=NEW VJunction(junction);
}	}
	if(!value)
	value=ncontext->get_element(name);
if(value)	if(value)
value=&process(*value, &name); // process possible code-junction	value=&process_to_value(*value); // process possible code-junction
else {	else
value=NEW VVoid(pool());	value=NEW VVoid(pool());
value->set_name(name);
}

return value;	return value;
}	}
Line 758 Value *Request::get_element() {	Line 893 Value *Request::get_element() {
they want any result[string\|object]	they want any result[string\|object]
nothing goes to wcontext.	nothing goes to wcontext.
used in @c (expression) params evaluation	used in @c (expression) params evaluation

	using the fact it's either string_ or value_ result requested to speed up checkes
*/	*/
Value& Request::process(Value& value, const String *name, bool intercept_string) {	StringOrValue Request::process(Value& input_value, bool intercept_string) {
Value *result;	StringOrValue result;
Junction *junction=value.get_junction();	Junction *junction=input_value.get_junction();
if(junction && junction->code) { // is it a code-junction?	if(junction && junction->code) { // is it a code-junction?
// process it	// process it
#ifdef DEBUG_EXECUTE	#ifdef DEBUG_EXECUTE
debug_printf(pool(), "ja->\n");	debug_printf(pool(), "ja->\n");
#endif	#endif

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

PUSH(self);	PUSH(self);
PUSH(root);	PUSH(root);
PUSH(rcontext);	PUSH(rcontext);
PUSH(wcontext);	PUSH(wcontext);

WContext *frame;	self=&junction->self;
	root=junction->root;
	rcontext=junction->rcontext;

// for expression method params	// for expression method params
// 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"
Line 780 Value& Request::process(Value& value, co	Line 926 Value& Request::process(Value& value, co
if(using_code_frame) {	if(using_code_frame) {
// almost plain wwrapper about junction wcontext,	// almost plain wwrapper about junction wcontext,
// BUT intercepts string writes	// BUT intercepts string writes
frame=NEW VCodeFrame(pool(), *junction->wcontext);	VCodeFrame local(pool(), *junction->wcontext);
} else {	wcontext=&local;
// plain wwrapper
frame=NEW WWrapper(pool(), 0/empty/);	// execute it
}	recoursion_checked_execute(0/result_name/, *junction->code);

//frame->set_name(value.name());
wcontext=frame;
self=&junction->self;
root=junction->root;
rcontext=junction->rcontext;
execute(*junction->code);
if(using_code_frame) {
// CodeFrame soul:	// CodeFrame soul:
// string writes were intercepted	// string writes were intercepted
// returning them as the result of getting code-junction	// returning them as the result of getting code-junction
result=NEW VString(*frame->get_string());	result.set_string(*wcontext->get_string());
} else	} else {
result=frame->result();	// plain wwrapper
	WWrapper local(pool(), 0/empty/);
	wcontext=&local;

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

	result=wcontext->result();
	}

wcontext=static_cast<WContext *>(POP());	wcontext=static_cast<WContext *>(POP());
rcontext=POP();	rcontext=POP();
Line 808 Value& Request::process(Value& value, co	Line 955 Value& Request::process(Value& value, co
#ifdef DEBUG_EXECUTE	#ifdef DEBUG_EXECUTE
debug_printf(pool(), "<-ja returned");	debug_printf(pool(), "<-ja returned");
#endif	#endif
} else	} else {
result=&value;	result.set_value(input_value);
	}
if(name)	return result;
result->set_name(*name);
return *result;
}	}

const String *Request::execute_method(Value& aself, const Method& method,	const String& Request::execute_method(VMethodFrame& amethodFrame, const Method& method) {
bool return_cstr) {
PUSH(self);	PUSH(self);
PUSH(root);	PUSH(root);
PUSH(rcontext);	PUSH(rcontext);
PUSH(wcontext);	PUSH(wcontext);

// initialize contexts	// initialize contexts
root=rcontext=self=&aself;	root=rcontext=self=&amethodFrame;
wcontext=NEW WWrapper(pool(), &aself);	wcontext=&amethodFrame;

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

// result	// result
const String *result;	const String& result=wcontext->result().as_string();
if(return_cstr)
result=&wcontext->as_string();
else
result=0; // ignore result

wcontext=static_cast<WContext *>(POP());	wcontext=static_cast<WContext *>(POP());
rcontext=POP();	rcontext=POP();
Line 846 const String *Request::execute_method(Va	Line 986 const String *Request::execute_method(Va
return result;	return result;
}	}

	void Request::execute_method(Value& aself,
	const Method& method, VString *optional_param,
	const String **return_string) {
	PUSH(self);
	PUSH(root);
	PUSH(rcontext);
	PUSH(wcontext);

	// initialize contexts
	//root=rcontext=self=&aself;
	self=&aself;
	// WWrapper local(pool(), &aself);
	// wcontext=&local;
	Junction local_junction(pool(), *self, self->get_class(), &method, 0,0,0,0);
	VMethodFrame local_frame(pool(), method.name, local_junction);
	if(optional_param && local_frame.can_store_param()) {
	local_frame.store_param(optional_param);
	local_frame.fill_unspecified_params();
	}
	local_frame.set_self(*self);
	root=rcontext=wcontext=&local_frame;

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

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

	wcontext=static_cast<WContext *>(POP());
	rcontext=POP();
	root=POP();
	self=static_cast<VAliased *>(POP());
	}

	void Request::execute_nonvirtual_method(VStateless_class& aclass,
	const String& method_name, VString *optional_param,
	const String **return_string,
	const Method **return_method) {

	const Method *method=aclass.get_method(method_name);
	if(return_string)
	*return_string=0;
	if(return_method)
	*return_method=method;

	if(method)
	execute_method(aclass, *method, optional_param, return_string);
	}

const String *Request::execute_virtual_method(Value& aself,	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))	if(Value *value=aself.get_element(method_name))
if(Junction *junction=value->get_junction())	if(Junction *junction=value->get_junction())
if(const Method *method=junction->method)	if(const Method *method=junction->method) {
return execute_method(aself, *method, return_cstr);	const String *result;
	execute_method(aself, method, 0/no params*/, &result);
	return result;
	}

return 0;	return 0;
}	}

const String *Request::execute_nonvirtual_method(VStateless_class& aclass,
const String& method_name,
bool return_cstr) {
if(const Method *method=aclass.get_method(method_name))
return execute_method(aclass, *method, return_cstr);

return 0;
}

E-mail:

Removed from v.1.189
changed lines
	Added in v.1.243