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.94 and 1.181

version 1.94, 2001/03/12 13:13:21	version 1.181, 2001/07/24 15:43:56
Line 1	Line 1
/*	/** @file
Parser	Parser: executor part of request class.

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

$Id$	Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)
*/	*/
	static const char *RCSId="$Id$";

	#include "pa_opcode.h"
#include "pa_array.h"	#include "pa_array.h"
#include "code.h"
#include "pa_request.h"	#include "pa_request.h"
#include "pa_vstring.h"	#include "pa_vstring.h"
#include "pa_vhash.h"	#include "pa_vhash.h"
#include "pa_vunknown.h"	#include "pa_vvoid.h"
#include "pa_vcframe.h"	#include "pa_vcode_frame.h"
#include "pa_vmframe.h"	#include "pa_vmethod_frame.h"
#include "pa_vobject.h"	#include "pa_vobject.h"
#include "pa_vdouble.h"	#include "pa_vdouble.h"
#include "pa_vbool.h"	#include "pa_vbool.h"
#include "pa_vtable.h"	#include "pa_vtable.h"
	#include "pa_vfile.h"
	#include "pa_vimage.h"

#include <stdio.h>	//#define DEBUG_EXECUTE

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

	const uint ANTI_ENDLESS_EXECUTE_RECOURSION=500;

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

// actions	// actions
"WITH_SELF", "WITH_ROOT", "WITH_READ", "WITH_WRITE",	"WITH_SELF", "WITH_ROOT", "WITH_READ", "WITH_WRITE",
"GET_CLASS",	"GET_CLASS",
"CONSTRUCT_VALUE", "CONSTRUCT_DOUBLE",	"CONSTRUCT_VALUE", "CONSTRUCT_EXPR",
"WRITE", "STRING__WRITE",	"WRITE_VALUE", "WRITE_EXPR_RESULT", "STRING__WRITE",
"GET_ELEMENT", "GET_ELEMENT__WRITE",	"GET_ELEMENT", "GET_ELEMENT__WRITE",
"CREATE_EWPOOL", "REDUCE_EWPOOL",	"CREATE_EWPOOL", "REDUCE_EWPOOL",
"CREATE_RWPOOL", "REDUCE_RWPOOL",	"CREATE_RWPOOL", "REDUCE_RWPOOL",
Line 44 char *opcode_name[]={	Line 45 char *opcode_name[]={
"CALL",	"CALL",

// expression ops: unary	// expression ops: unary
"NEG", "INV", "NOT", "DEF", "IN", "FEXISTS",	"NEG", "INV", "NOT", "DEF", "IN", "FEXISTS", "DEXISTS",
// expression ops: binary	// expression ops: binary
"SUB", "ADD", "MUL", "DIV", "MOD",	"SUB", "ADD", "MUL", "DIV", "MOD",
"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",
"STR_LT", "STR_GT", "STR_LE", "STR_GE", "STR_EQ", "STR_NE"	"STR_LT", "STR_GT", "STR_LE", "STR_GE", "STR_EQ", "STR_NE",
	"IS"
};	};

void dump(int level, const Array& ops) {	void va_debug_printf(Pool& pool, const char *fmt,va_list args) {
if(0){	char buf[MAX_STRING];
int size=ops.size();	vsnprintf(buf, MAX_STRING, fmt, args);
//fprintf(stderr, "size=%d\n", size);	SAPI::log(pool, "%s", buf);
	}

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

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

int size=ops.size();	int size=ops.quick_size();
//fprintf(stderr, "size=%d\n", size);	//debug_printf(pool, "size=%d\n", size);
for(int i=0; i<size; i++) {	for(int i=0; i<size; i++) {
Operation op;	Operation op;
op.cast=ops.quick_get(i);	op.cast=ops.quick_get(i);
fprintf(stderr, "%s%s", level4, "", opcode_name[op.code]);

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 >(ops.quick_get(++i));
fprintf(stderr, " \"%s\" %s", value->get_string()->cstr(), value->type());	debug_printf(pool,
	"%*s%s"
	" \"%s\" %s",
	level*4, "", opcode_name[op.code],
	value->get_string()->cstr(), value->type());
	continue;
}	}
fprintf(stderr, "\n");	debug_printf(pool, "%s%s", level4, "", opcode_name[op.code]);

if(op.code==OP_CODE__STORE_PARAM) {	if(op.code==OP_CURLY_CODE__STORE_PARAM \|\| op.code==OP_EXPR_CODE__STORE_PARAM) {
const Array local_ops=reinterpret_cast<const Array >(ops.quick_get(++i));	const Array local_ops=reinterpret_cast<const Array >(ops.quick_get(++i));
dump(level+1, *local_ops);	debug_dump(pool, level+1, *local_ops);
}	}
}	}
fflush(stderr);
}	}
	#endif

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

void Request::execute(const Array& ops) {	void Request::execute(const Array& ops) {
if(1) {	#ifdef DEBUG_EXECUTE
fputs("source----------------------------\n", stderr);	debug_printf(pool(), "source----------------------------\n");
dump(0, ops);	debug_dump(pool(), 0, ops);
fputs("execution-------------------------\n", stderr);	debug_printf(pool(), "execution-------------------------\n");
}	#endif

int size=ops.size();	int size=ops.quick_size();
//fprintf(stderr, "size=%d\n", size);	//debug_printf(pool(), "size=%d\n", size);
for(int i=0; i<size; i++) {	for(int i=0; i<size; i++) {
Operation op;	Operation op;
op.cast=ops.quick_get(i);	op.cast=ops.quick_get(i);
fprintf(stderr, "%d:%s", stack.top_index()+1, opcode_name[op.code]); fflush(stderr);	#ifdef DEBUG_EXECUTE
	debug_printf(pool(), "%d:%s", stack.top_index()+1, opcode_name[op.code]);
	#endif

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 value=static_cast<Value >(ops.quick_get(++i));
fprintf(stderr, " \"%s\" %s", value->get_string()->cstr(), value->type());	#ifdef DEBUG_EXECUTE
	debug_printf(pool(), " \"%s\" %s", value->get_string()->cstr(), value->type());
	#endif
PUSH(value);	PUSH(value);
break;	break;
}	}
case OP_CODE__STORE_PARAM:	case OP_CURLY_CODE__STORE_PARAM:
	case OP_EXPR_CODE__STORE_PARAM:
{	{
VMethodFrame frame=static_cast<VMethodFrame >(stack.top_value());	VMethodFrame frame=static_cast<VMethodFrame >(stack.top_value());
// code	// code
const Array local_ops=reinterpret_cast<const Array >(ops.quick_get(++i));	const Array local_ops=reinterpret_cast<const Array >(ops.quick_get(++i));
fprintf(stderr, " (%d)\n", local_ops->size());	#ifdef DEBUG_EXECUTE
dump(1, *local_ops);	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(),	Junction& j=*NEW Junction(pool(),
*self, 0, 0,	*self, 0, 0,
root, frame, frame, local_ops);	root,
	rcontext,
	op.code==OP_EXPR_CODE__STORE_PARAM?0:wcontext,
	local_ops);

Value *value=NEW VJunction(j);	Value *value=NEW VJunction(j);

Line 128 void Request::execute(const Array& ops)	Line 167 void Request::execute(const Array& ops)
}	}
case OP_GET_CLASS:	case OP_GET_CLASS:
{	{
	// maybe they do ^class:method[] call, remember the fact
	wcontext->set_somebody_entered_some_class();

const String& name=POP_NAME();	const String& name=POP_NAME();
VClass vclass=static_cast<VClass >(classes().get(name));	Value value=static_cast<Value >(classes().get(name));
if(!vclass)	if(!value)
THROW(0,0,	THROW(0,0,
&name,	&name,
": undefined class");	"class is undefined");

PUSH(vclass);	PUSH(value);
break;	break;
}	}

Line 176 void Request::execute(const Array& ops)	Line 218 void Request::execute(const Array& ops)
Value *value=POP();	Value *value=POP();
const String& name=POP_NAME();	const String& name=POP_NAME();
Value *ncontext=POP();	Value *ncontext=POP();
ncontext->put_element(name, value->get_expr_result());	ncontext->put_element(name, value->as_expr_result());
value->set_name(name);	value->set_name(name);
break;	break;
}	}
case OP_WRITE:	case OP_WRITE_VALUE:
{	{
Value *value=POP();	Value *value=POP();
write_assign_lang(*value);	write_assign_lang(*value);

	// forget the fact they've entered some ^object.method[].
	// see OP_GET_ELEMENT
	wcontext->clear_somebody_entered_some_object();
	break;
	}
	case OP_WRITE_EXPR_RESULT:
	{
	Value *value=POP();
	write_expr_result(*value->as_expr_result());
break;	break;
}	}
case OP_STRING__WRITE:	case OP_STRING__WRITE:
{	{
VString vstring=static_cast<VString >(ops.quick_get(++i));	VString vstring=static_cast<VString >(ops.quick_get(++i));
fprintf(stderr, " \"%s\"", vstring->value().cstr());	#ifdef DEBUG_EXECUTE
write(vstring->value());	debug_printf(pool(), " \"%s\"", vstring->string().cstr());
	#endif
	write_no_lang(vstring->string());
break;	break;
}	}

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

	//_asm int 3;
Value *value=get_element();	Value *value=get_element();
PUSH(value);	PUSH(value);
break;	break;
Line 212 void Request::execute(const Array& ops)	Line 270 void Request::execute(const Array& ops)
case OP_CREATE_EWPOOL:	case OP_CREATE_EWPOOL:
{	{
PUSH(wcontext);	PUSH(wcontext);
wcontext=NEW WWrapper(pool(), 0 /* empty /, true / constructing */);	PUSH((void *)flang);
	flang=String::UL_PASS_APPENDED;
	wcontext=NEW WWrapper(pool(), 0 /empty/, true /constructing/);
break;	break;
}	}
case OP_REDUCE_EWPOOL:	case OP_REDUCE_EWPOOL:
{	{
Value *value=wcontext->result();	Value *value=wcontext->result();
	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;
Line 227 void Request::execute(const Array& ops)	Line 288 void Request::execute(const Array& ops)
{	{
Value *ncontext=POP();	Value *ncontext=POP();
PUSH(rcontext);	PUSH(rcontext);
rcontext=ncontext;
PUSH(wcontext);	PUSH(wcontext);
wcontext=NEW WWrapper(pool(), ncontext, false /* not constructing */);	rcontext=ncontext;
	wcontext=NEW WWrapper(pool(), ncontext, false /not constructing/);
break;	break;
}	}
case OP_REDUCE_RWPOOL:	case OP_REDUCE_RWPOOL:
Line 239 void Request::execute(const Array& ops)	Line 300 void Request::execute(const Array& ops)
if(string)	if(string)
value=NEW VString(*string);	value=NEW VString(*string);
else	else
value=NEW VUnknown(pool());	value=NEW VVoid(pool());
wcontext=static_cast<WContext *>(POP());	wcontext=static_cast<WContext *>(POP());
rcontext=POP();	rcontext=POP();
PUSH(value);	PUSH(value);
Line 248 void Request::execute(const Array& ops)	Line 309 void Request::execute(const Array& ops)
case OP_CREATE_SWPOOL:	case OP_CREATE_SWPOOL:
{	{
PUSH(wcontext);	PUSH(wcontext);
wcontext=NEW WWrapper(pool(), 0 /* empty /, false / not constructing */);	wcontext=NEW WWrapper(pool(), 0 /empty/, false /not constructing/);
break;	break;
}	}
case OP_REDUCE_SWPOOL:	case OP_REDUCE_SWPOOL:
Line 260 void Request::execute(const Array& ops)	Line 321 void Request::execute(const Array& ops)
if(string)	if(string)
value=NEW VString(*string);	value=NEW VString(*string);
else	else
NEW VUnknown(pool());	NEW VVoid(pool());
wcontext=static_cast<WContext *>(POP());	wcontext=static_cast<WContext *>(POP());
PUSH(value);	PUSH(value);
break;	break;
Line 270 void Request::execute(const Array& ops)	Line 331 void Request::execute(const Array& ops)
case OP_GET_METHOD_FRAME:	case OP_GET_METHOD_FRAME:
{	{
Value *value=POP();	Value *value=POP();
// info: this one's always method-junction, not a code-junction
	// info:
	// code compiled so that this one's always method-junction,
	// not a code-junction
Junction *junction=value->get_junction();	Junction *junction=value->get_junction();
if(!junction)	if(!junction)
THROW(0,0,	THROW(0,0,
&value->name(),	&value->name(),
"type is '%s', can not call it (must be method or junction)",	"(%s) not a method or junction, can not call it",
value->type());	value->type());

VMethodFrame frame=NEW VMethodFrame(pool(), junction);	bool is_constructor=
//frame->set_name(junction->self.name());	wcontext->constructing() && // constructing?
frame->set_name(value->name());	wcontext->somebody_entered_some_class(); // ^class:method[..]?
	if(is_constructor)
	wcontext->constructing(false);

	VMethodFrame frame=NEW VMethodFrame(pool(), value->name(), junction, is_constructor);
PUSH(frame);	PUSH(frame);
break;	break;
}	}
Line 294 void Request::execute(const Array& ops)	Line 362 void Request::execute(const Array& ops)

case OP_CALL:	case OP_CALL:
{	{
fprintf(stderr, "->\n");	#ifdef DEBUG_EXECUTE
	debug_printf(pool(), "->\n");
	#endif
VMethodFrame frame=static_cast<VMethodFrame >(POP());	VMethodFrame frame=static_cast<VMethodFrame >(POP());
frame->fill_unspecified_params();	frame->fill_unspecified_params();
PUSH(self);	PUSH(self);
Line 302 void Request::execute(const Array& ops)	Line 372 void Request::execute(const Array& ops)
PUSH(rcontext);	PUSH(rcontext);
PUSH(wcontext);	PUSH(wcontext);

VClass *called_class=frame->junction.self.get_class();	VStateless_class *called_class=frame->junction.self.get_class();
// is context object or class & is it my class or my parent's class?	// not ^name.method call, name:method call; and
VClass *read_class=rcontext->get_class();	// is context object or class & is it my class or my parent's class and?
if(read_class && read_class->is_or_derived_from(*called_class)) // yes	VStateless_class *read_class=rcontext->get_class();
	if(
	!(wcontext->somebody_entered_some_object() &&
	!wcontext->somebody_entered_some_class()) &&
	read_class && read_class->is_or_derived_from(*called_class)) // yes
self=rcontext; // class dynamic call	self=rcontext; // class dynamic call
else // no, not me or relative of mine (total stranger)	else // no, not me or relative of mine (total stranger)
if(wcontext->constructing()) { // constructing?	// were are constructing something and
// yes, constructor call: $some(^class:method(..))	// our constructor is just method call and
if(called_class->name()==TABLE_CLASS_NAME)	// not static-only-method call
self=NEW VTable(pool());	if(frame->is_constructor &&
else	wcontext->somebody_entered_some_object()==1 &&
	frame->junction.method->call_type!=Method::CT_STATIC) {
	// this is a constructor call
	// some stateless_object creatable derivates
	if(Value *value=called_class->create_new_value(pool()))
	self=value;
	else // stateful object
self=NEW VObject(pool(), *called_class);	self=NEW VObject(pool(), *called_class);
frame->write(*self,	frame->write(*self,
String::Untaint_lang::NO // not used, always an object, not string	String::UL_CLEAN // not used, always an object, not string
);	);
} else	} else
self=&frame->junction.self; // no, static or simple dynamic call	self=&frame->junction.self; // no, static or simple dynamic call
Line 324 void Request::execute(const Array& ops)	Line 404 void Request::execute(const Array& ops)
root=rcontext=wcontext=frame;	root=rcontext=wcontext=frame;
{	{
// take object or class from any wrappers	// take object or class from any wrappers
VAliased *aliased=self->get_aliased();	// and substitute class alias to the class they are called AS
// substitute class alias to the class they are called AS	Temp_alias temp_alias(self->get_aliased(), frame->junction.vclass);
Temp_alias temp_alias(aliased, frame->junction.vclass);
	const Method& method=*frame->junction.method;
Method& method=*frame->junction.method;	Method::Call_type call_type=
if(method.native_code) { // native code?	called_class==self ? Method::CT_STATIC : Method::CT_DYNAMIC;
method.check_actual_numbered_params(	if(
frame->name(), frame->numbered_params());	method.call_type==Method::CT_ANY \|\|
(method.native_code)(this,	method.call_type==call_type) // allowed call type?
frame->name(), frame->numbered_params()); // execute it	if(method.native_code) { // native code?
} else // parser code	method.check_actual_numbered_params(pool(),
execute(*method.parser_code); // execute it	frame->junction.self,
	frame->name(), frame->numbered_params());
	method.native_code(
	*this,
	frame->name(), frame->numbered_params()); // execute it
	} else { // parser code
	if(++anti_endless_execute_recoursion==ANTI_ENDLESS_EXECUTE_RECOURSION) {
	anti_endless_execute_recoursion=0; // give @exception a chance
	THROW(0, 0,
	&frame->name(),
	"endless recursion detected");
	}

	execute(*method.parser_code); // execute it
	anti_endless_execute_recoursion--;
	}
	else
	THROW(0, 0,
	&frame->name(),
	"is not allowed to be called %s",
	call_type==Method::CT_STATIC?"statically":"dynamically");

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

Line 345 void Request::execute(const Array& ops)	Line 446 void Request::execute(const Array& ops)
self=static_cast<VAliased *>(POP());	self=static_cast<VAliased *>(POP());

PUSH(value);	PUSH(value);
fprintf(stderr, "<-returned");	#ifdef DEBUG_EXECUTE
	debug_printf(pool(), "<-returned");
	#endif
break;	break;
}	}

Line 353 void Request::execute(const Array& ops)	Line 456 void Request::execute(const Array& ops)
case OP_NEG:	case OP_NEG:
{	{
Value *operand=POP();	Value *operand=POP();
Value *value=NEW VDouble(pool(), -operand->get_double());	Value *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(), ~static_cast<int>(operand->get_double()));	Value *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->get_bool());	Value *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->get_defined());	Value *value=NEW VBool(pool(), operand->is_defined());
PUSH(value);	PUSH(value);
break;	break;
}	}
case OP_IN:	case OP_IN:
{	{
Value *operand=POP();	Value *operand=POP();
Value value=NEW VBool(pool(), true/TODO*/);	const char *path=operand->as_string().cstr();
	Value *value=NEW VBool(pool(),
	info.uri && strncmp(path, info.uri, strlen(path))==0);
PUSH(value);	PUSH(value);
break;	break;
}	}
case OP_FEXISTS:	case OP_FEXISTS:
{	{
Value *operand=POP();	Value *operand=POP();
Value value=NEW VBool(pool(), true/TODO*/);	Value *value=NEW VBool(pool(),
	file_readable(absolute(operand->as_string())));
	PUSH(value);
	break;
	}
	case OP_DEXISTS:
	{
	Value *operand=POP();
	Value *value=NEW VBool(pool(),
	dir_readable(absolute(operand->as_string())));
PUSH(value);	PUSH(value);
break;	break;
}	}
Line 397 void Request::execute(const Array& ops)	Line 511 void Request::execute(const Array& ops)
case OP_SUB:	case OP_SUB:
{	{
Value b=POP(); Value a=POP();	Value b=POP(); Value a=POP();
Value *value=NEW VDouble(pool(), a->get_double() - b->get_double());	Value *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();	Value b=POP(); Value a=POP();
Value *value=NEW VDouble(pool(), a->get_double() + b->get_double());	Value *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();	Value b=POP(); Value a=POP();
Value value=NEW VDouble(pool(), a->get_double() b->get_double());	Value 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();	Value b=POP(); Value a=POP();
Value *value=NEW VDouble(pool(), a->get_double() / b->get_double());
	double a_double=a->as_double();
	double b_double=b->as_double();

	if(b_double == 0) {
	const String *problem_source=&b->as_string();
	#ifndef NO_STRING_ORIGIN
	if(!problem_source->origin().file)
	problem_source=&b->name();
	#endif
	THROW(0, 0,
	problem_source,
	"Division by zero");
	}

	Value *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();	Value b=POP(); Value a=POP();
Value *value=NEW VDouble(pool(),
static_cast<int>(a->get_double()) %	double a_double=a->as_double();
static_cast<int>(b->get_double()));	double b_double=b->as_double();

	if(b_double == 0) {
	const String *problem_source=&b->as_string();
	#ifndef NO_STRING_ORIGIN
	if(!problem_source->origin().file)
	problem_source=&b->name();
	#endif
	THROW(0, 0,
	problem_source,
	"Modulus by zero");
	}

	Value *value=NEW VDouble(pool(), fmod(a_double, b_double));
PUSH(value);	PUSH(value);
break;	break;
}	}
Line 435 void Request::execute(const Array& ops)	Line 577 void Request::execute(const Array& ops)
{	{
Value b=POP(); Value a=POP();	Value b=POP(); Value a=POP();
Value *value=NEW VDouble(pool(),	Value *value=NEW VDouble(pool(),
static_cast<int>(a->get_double()) &	a->as_int() &
static_cast<int>(b->get_double()));	b->as_int());
PUSH(value);	PUSH(value);
break;	break;
}	}
Line 444 void Request::execute(const Array& ops)	Line 586 void Request::execute(const Array& ops)
{	{
Value b=POP(); Value a=POP();	Value b=POP(); Value a=POP();
Value *value=NEW VDouble(pool(),	Value *value=NEW VDouble(pool(),
static_cast<int>(a->get_double()) \|	a->as_int() \|
static_cast<int>(b->get_double()));	b->as_int());
PUSH(value);	PUSH(value);
break;	break;
}	}
Line 453 void Request::execute(const Array& ops)	Line 595 void Request::execute(const Array& ops)
{	{
Value b=POP(); Value a=POP();	Value b=POP(); Value a=POP();
Value *value=NEW VDouble(pool(),	Value *value=NEW VDouble(pool(),
static_cast<int>(a->get_double()) ^	a->as_int() ^
static_cast<int>(b->get_double()));	b->as_int());
PUSH(value);	PUSH(value);
break;	break;
}	}
case OP_LOG_AND:	case OP_LOG_AND:
{	{
Value b=POP(); Value a=POP();	Value b=POP(); Value a=POP();
Value *value=NEW VBool(pool(), a->get_bool() && b->get_bool());	Value *value=NEW VBool(pool(), a->as_bool() && b->as_bool());
PUSH(value);	PUSH(value);
break;	break;
}	}
case OP_LOG_OR:	case OP_LOG_OR:
{	{
Value b=POP(); Value a=POP();	Value b=POP(); Value a=POP();
Value *value=NEW VBool(pool(), a->get_bool() \|\| b->get_bool());	Value *value=NEW VBool(pool(), a->as_bool() \|\| b->as_bool());
PUSH(value);	PUSH(value);
break;	break;
}	}
case OP_LOG_XOR:	case OP_LOG_XOR:
{	{
Value b=POP(); Value a=POP();	Value b=POP(); Value a=POP();
Value *value=NEW VBool(pool(), a->get_bool() ^ b->get_bool());	Value *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();	Value b=POP(); Value a=POP();
Value *value=NEW VBool(pool(), a->get_double() < b->get_double());	Value *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();	Value b=POP(); Value a=POP();
Value *value=NEW VBool(pool(), a->get_double() > b->get_double());	Value *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();	Value b=POP(); Value a=POP();
Value *value=NEW VBool(pool(), a->get_double() <= b->get_double());	Value *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();	Value b=POP(); Value a=POP();
Value *value=NEW VBool(pool(), a->get_double() >= b->get_double());	Value *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();	Value b=POP(); Value a=POP();
Value *value=NEW VBool(pool(), a->get_double() == b->get_double());	Value *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();	Value b=POP(); Value a=POP();
Value *value=NEW VBool(pool(), a->get_double() != b->get_double());	Value *value=NEW VBool(pool(), a->as_double() != b->as_double());
PUSH(value);	PUSH(value);
break;	break;
}	}
Line 563 void Request::execute(const Array& ops)	Line 705 void Request::execute(const Array& ops)
PUSH(value);	PUSH(value);
break;	break;
}	}
	case OP_IS:
	{
	Value b=POP(); Value a=POP();
	Value *value=NEW VBool(pool(), b->as_string() == a->type());
	PUSH(value);
	break;
	}

default:	default:
THROW(0,0,	THROW(0,0,
0,	0,
"unhandled '%s' opcode", opcode_name[op.code]);	"invalid opcode %d", op.code);
}	}
fprintf(stderr, "\n");
}	}
}	}

Line 577 Value *Request::get_element() {	Line 725 Value *Request::get_element() {
const String& name=POP_NAME();	const String& name=POP_NAME();
Value *ncontext=POP();	Value *ncontext=POP();
Value *value=ncontext->get_element(name);	Value *value=ncontext->get_element(name);
	if(!value)
	if(Method* method=OP.get_method(name)) { // maybe operator?
	// as if that method were in self and we have normal dynamic method here
	Junction& junction=*NEW Junction(pool(),
	*self, self->get_class(), method, 0,0,0,0);
	value=NEW VJunction(junction);
	}
if(value)	if(value)
value=&process(*value, &name); // process possible code-junction	value=&process(*value, &name); // process possible code-junction
else {	else {
value=NEW VUnknown(pool());	value=NEW VVoid(pool());
value->set_name(name);	value->set_name(name);
}	}

return value;	return value;
}	}

	/** @param intercept_string
	- 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
	*/
Value& Request::process(Value& value, const String *name, bool intercept_string) {	Value& Request::process(Value& value, const String *name, bool intercept_string) {
// intercept_string:
// 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 (expression) params evaluation

Value *result;	Value *result;
Junction *junction=value.get_junction();	Junction *junction=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
fprintf(stderr, "ja->\n");	#ifdef DEBUG_EXECUTE
	debug_printf(pool(), "ja->\n");
	#endif
PUSH(self);	PUSH(self);
PUSH(root);	PUSH(root);
PUSH(rcontext);	PUSH(rcontext);
PUSH(wcontext);	PUSH(wcontext);

WContext *frame;	WContext *frame;
if(intercept_string) {	// for expression method params
	// wcontext is set 0
	// using the fact in decision "which wwrapper to use"
	bool using_code_frame=intercept_string && junction->wcontext;
	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);	frame=NEW VCodeFrame(pool(), *junction->wcontext);
} else {	} else {
// plain wwrapper	// plain wwrapper
frame=NEW WWrapper(pool(), 0 /* empty /, false /not constructing*/);	frame=NEW WWrapper(pool(), 0/empty/, false/not constructing/);
}	}

wcontext=frame;	wcontext=frame;
Line 623 Value& Request::process(Value& value, co	Line 783 Value& Request::process(Value& value, co
root=junction->root;	root=junction->root;
rcontext=junction->rcontext;	rcontext=junction->rcontext;
execute(*junction->code);	execute(*junction->code);
if(intercept_string) {	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
Line 636 Value& Request::process(Value& value, co	Line 796 Value& Request::process(Value& value, co
root=POP();	root=POP();
self=static_cast<VAliased *>(POP());	self=static_cast<VAliased *>(POP());

fprintf(stderr, "<-ja returned");	#ifdef DEBUG_EXECUTE
	debug_printf(pool(), "<-ja returned");
	#endif
} else	} else
result=&value;	result=&value;

Line 645 Value& Request::process(Value& value, co	Line 807 Value& Request::process(Value& value, co
return *result;	return *result;
}	}

char *Request::execute_static_method(VClass& vclass, String& method_name, bool return_cstr) {	const String *Request::execute_method(Value& aself, const Method& method,
if(const Method *method=vclass.get_method(method_name)) {	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=&vclass;	root=rcontext=self=&aself;
wcontext=NEW WWrapper(pool(), &vclass, false /* not constructing */);	wcontext=NEW WWrapper(pool(), &aself, false /not constructing/);

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

// result	// result
char *result;	const String *result;
if(return_cstr)	if(return_cstr)
result=wcontext->get_string()->cstr(); // chars	result=&wcontext->as_string();
else	else
result=0; // ignore result	result=0; // ignore 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());

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

	const String *Request::execute_virtual_method(Value& aself,
	const String& method_name,
	bool return_cstr) {
	if(Value *value=aself.get_element(method_name))
	if(Junction *junction=value->get_junction())
	if(const Method *method=junction->method)
	return execute_method(aself, *method, return_cstr);

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

E-mail:

Removed from v.1.94
changed lines
	Added in v.1.181