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.273 and 1.288

version 1.273, 2002/09/17 17:14:32	version 1.288, 2002/10/31 10:27:57
Line 54 char *opcode_name[]={	Line 54 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 166 void Request::execute(const Array& ops)	Line 167 void Request::execute(const Array& ops)
}	}
case OP_WITH_SELF:	case OP_WITH_SELF:
{	{
PUSH(self);	PUSH(get_self());
break;	break;
}	}
case OP_WITH_READ:	case OP_WITH_READ:
Line 176 void Request::execute(const Array& ops)	Line 177 void Request::execute(const Array& ops)
}	}
case OP_WITH_WRITE:	case OP_WITH_WRITE:
{	{
	if(wcontext==method_frame)
	throw Exception("parser.runtime",
	0,
	"$.name outside of $name[...]");

PUSH(wcontext);	PUSH(wcontext);
break;	break;
}	}
Line 208 void Request::execute(const Array& ops)	Line 214 void Request::execute(const Array& ops)
debug_dump(pool(), 1, *local_ops);	debug_dump(pool(), 1, *local_ops);
#endif	#endif
Junction& j=*NEW Junction(pool(),	Junction& j=*NEW Junction(pool(),
*self, 0,	*get_self(), 0,
method_frame,	method_frame,
rcontext,	rcontext,
wcontext,	wcontext,
Line 258 void Request::execute(const Array& ops)	Line 264 void Request::execute(const Array& ops)

case OP_GET_ELEMENT_OR_OPERATOR:	case OP_GET_ELEMENT_OR_OPERATOR:
{	{
//_asm int 3;
value=get_element(last_get_element_name, true);	value=get_element(last_get_element_name, true);
PUSH(value);	PUSH(value);
break;	break;
}	}
case OP_GET_ELEMENT:	case OP_GET_ELEMENT:
{	{
//_asm int 3;
value=get_element(last_get_element_name, false);	value=get_element(last_get_element_name, false);
PUSH(value);	PUSH(value);
break;	break;
Line 348 void Request::execute(const Array& ops)	Line 352 void Request::execute(const Array& ops)
// 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(),	Junction& j=*NEW Junction(pool(),
*self, 0,	*get_self(), 0,
method_frame,	method_frame,
rcontext,	rcontext,
op.code==OP_EXPR_CODE__STORE_PARAM?0:wcontext,	op.code==OP_EXPR_CODE__STORE_PARAM?0:wcontext,
Line 386 void Request::execute(const Array& ops)	Line 390 void Request::execute(const Array& ops)
#endif	#endif
value=POP();	value=POP();

// 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 Exception("parser.runtime",	throw Exception("parser.runtime",
last_get_element_name,	last_get_element_name,
"(%s) not a method or junction, can not call it",	"(%s) not a method or junction, can not call it",
value->type());	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",
	last_get_element_name,
	"(%s) is code junction, can not call it",
	value->type());
	*/

VMethodFrame frame(pool(), last_get_element_name, junction);	VMethodFrame frame(pool(), last_get_element_name, 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	PUSH(&frame); // argument for *STORE_PARAM ops
execute(*local_ops);	execute(*local_ops);
POP();	POP();
}	}
frame.fill_unspecified_params();	frame.fill_unspecified_params();
Value *saved_self=self;
VMethodFrame *saved_method_frame=method_frame;	VMethodFrame *saved_method_frame=method_frame;
Value *saved_rcontext=rcontext;	Value *saved_rcontext=rcontext;
WContext *saved_wcontext=wcontext;	WContext *saved_wcontext=wcontext;

VStateless_class *called_class=frame.junction.self.get_class();	VStateless_class *called_class=frame.junction.self.get_class();
	Value *new_self=get_self();
if(wcontext->get_constructing()) {	if(wcontext->get_constructing()) {
wcontext->set_constructing(false);	wcontext->set_constructing(false);
if(frame.junction.method->call_type!=Method::CT_STATIC) {	if(frame.junction.method->call_type!=Method::CT_STATIC) {
Line 416 void Request::execute(const Array& ops)	Line 429 void Request::execute(const Array& ops)

if(Value *value=called_class->create_new_value(pool())) {	if(Value *value=called_class->create_new_value(pool())) {
// 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(),	&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::UL_CLEAN // not used, always an object, not string
);	);
} else	} else
Line 431 void Request::execute(const Array& ops)	Line 444 void Request::execute(const Array& ops)
&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
self=&frame.junction.self;	new_self=&frame.junction.self;

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());
Line 442 void Request::execute(const Array& ops)	Line 455 void Request::execute(const Array& ops)
{	{
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 {	try {
	method_frame=&frame;
if(method.native_code) { // native code?	if(method.native_code) { // native code?
// method_frame 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.name(), frame.numbered_params()); // execute it	frame.name(), frame.numbered_params()); // execute it
} else { // parser code	} else // parser code, execute it
method_frame=&frame;
// execute it
recoursion_checked_execute(&frame.name(), *method.parser_code);	recoursion_checked_execute(&frame.name(), *method.parser_code);
}
} catch(...) {	} catch(...) {
// record it to stack trace	// record it to stack trace
exception_trace.push((void *)&frame.name());	exception_trace.push((void *)&frame.name());
Line 477 void Request::execute(const Array& ops)	Line 487 void Request::execute(const Array& ops)
wcontext=saved_wcontext;	wcontext=saved_wcontext;
rcontext=saved_rcontext;	rcontext=saved_rcontext;
method_frame=saved_method_frame;	method_frame=saved_method_frame;
self=saved_self;

#ifdef DEBUG_STRING_APPENDS_VS_EXPANDS	#ifdef DEBUG_STRING_APPENDS_VS_EXPANDS
if(const String *s=value->get_string())	if(const String *s=value->get_string())
Line 628 void Request::execute(const Array& ops)	Line 637 void Request::execute(const Array& ops)
PUSH(value);	PUSH(value);
break;	break;
}	}
	case OP_BIN_SL:
	{
	b=POP(); a=POP();
	value=NEW VInt(pool(),
	a->as_int() <<
	b->as_int());
	PUSH(value);
	break;
	}
	case OP_BIN_SR:
	{
	b=POP(); a=POP();
	value=NEW VInt(pool(),
	a->as_int() >>
	b->as_int());
	PUSH(value);
	break;
	}
case OP_BIN_AND:	case OP_BIN_AND:
{	{
b=POP(); a=POP();	b=POP(); a=POP();
value=NEW VDouble(pool(),	value=NEW VInt(pool(),
a->as_int() &	a->as_int() &
b->as_int());	b->as_int());
PUSH(value);	PUSH(value);
Line 640 void Request::execute(const Array& ops)	Line 667 void Request::execute(const Array& ops)
case OP_BIN_OR:	case OP_BIN_OR:
{	{
b=POP(); a=POP();	b=POP(); a=POP();
value=NEW VDouble(pool(),	value=NEW VInt(pool(),
a->as_int() \|	a->as_int() \|
b->as_int());	b->as_int());
PUSH(value);	PUSH(value);
Line 649 void Request::execute(const Array& ops)	Line 676 void Request::execute(const Array& ops)
case OP_BIN_XOR:	case OP_BIN_XOR:
{	{
b=POP(); a=POP();	b=POP(); a=POP();
value=NEW VDouble(pool(),	value=NEW VInt(pool(),
a->as_int() ^	a->as_int() ^
b->as_int());	b->as_int());
PUSH(value);	PUSH(value);
Line 797 void Request::execute(const Array& ops)	Line 824 void Request::execute(const Array& ops)
}	}
}	}

/// @test cache\|prepare junctions	/// @todo cache\|prepare junctions
Value Request::get_element(const String & remember_name, bool can_call_operator) {	Value Request::get_element(const String & remember_name, bool can_call_operator) {
const String& name=POP_NAME(); remember_name=&name;	const String& name=POP_NAME(); remember_name=&name;
Value *ncontext=POP();	Value *ncontext=POP();
Value *value=0;	Value *value=0;
if(can_call_operator) {	if(can_call_operator) {
if(Method* method=OP.get_method(name)) { // looking operator of that name FIRST	if(Method* method=main_class.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(),
*method_frame, method, 0,0,0,0);	main_class, method, 0,0,0,0);
value=NEW VJunction(junction);	value=NEW VJunction(junction);
}	}
}	}
Line 816 Value *Request::get_element(const String	Line 843 Value *Request::get_element(const String
if(VStateless_class *called_class=ncontext->get_class())	if(VStateless_class *called_class=ncontext->get_class())
if(VStateless_class *read_class=rcontext->get_class())	if(VStateless_class *read_class=rcontext->get_class())
if(read_class->derived_from(*called_class)) // current derived from called	if(read_class->derived_from(*called_class)) // current derived from called
if(Value *base_object=self->base_object()) { // doing DYNAMIC call	if(Value *base_object=get_self()->base_object()) { // doing DYNAMIC call
Temp_derived temp_derived(*base_object, 0); // temporarily prevent go-back-down virtual calls	Temp_derived temp_derived(*base_object, 0); // temporarily prevent go-back-down virtual calls
value=base_object->get_element(name, base_object, false); // virtual-up lookup starting from parent	value=base_object->get_element(name, base_object, false); // virtual-up lookup starting from parent
goto _void;	goto _void;
Line 827 Value *Request::get_element(const String	Line 854 Value *Request::get_element(const String

_void:	_void:
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(pool());

Line 859 StringOrValue Request::process(Value& in	Line 886 StringOrValue Request::process(Value& in
0,	0,
"junction used outside of context");	"junction used outside of context");

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

self=&junction->self;
method_frame=junction->method_frame;	method_frame=junction->method_frame;
rcontext=junction->rcontext;	rcontext=junction->rcontext;

Line 899 StringOrValue Request::process(Value& in	Line 924 StringOrValue Request::process(Value& in
wcontext=saved_wcontext;	wcontext=saved_wcontext;
rcontext=saved_rcontext;	rcontext=saved_rcontext;
method_frame=saved_method_frame;	method_frame=saved_method_frame;
self=saved_self;

#ifdef DEBUG_EXECUTE	#ifdef DEBUG_EXECUTE
debug_printf(pool(), "<-ja returned");	debug_printf(pool(), "<-ja returned");
Line 911 StringOrValue Request::process(Value& in	Line 935 StringOrValue Request::process(Value& in
}	}

const String& Request::execute_method(VMethodFrame& amethod_frame, const Method& method) {	const String& Request::execute_method(VMethodFrame& amethod_frame, const Method& method) {
Value *saved_self=self;
VMethodFrame *saved_method_frame=method_frame;	VMethodFrame *saved_method_frame=method_frame;
Value *saved_rcontext=rcontext;	Value *saved_rcontext=rcontext;
WContext *saved_wcontext=wcontext;	WContext *saved_wcontext=wcontext;

// initialize contexts	// initialize contexts
self=rcontext=wcontext=method_frame=&amethod_frame;	rcontext=wcontext=method_frame=&amethod_frame;

// execute!	// execute!
execute(*method.parser_code);	execute(*method.parser_code);
Line 928 const String& Request::execute_method(VM	Line 951 const String& Request::execute_method(VM
wcontext=saved_wcontext;	wcontext=saved_wcontext;
rcontext=saved_rcontext;	rcontext=saved_rcontext;
method_frame=saved_method_frame;	method_frame=saved_method_frame;
self=saved_self;

// return	// return
return result;	return result;
Line 937 const String& Request::execute_method(VM	Line 959 const String& Request::execute_method(VM
void Request::execute_method(Value& aself,	void Request::execute_method(Value& aself,
const Method& method, VString *optional_param,	const Method& method, VString *optional_param,
const String **return_string) {	const String **return_string) {
Value *saved_self=self;
VMethodFrame *saved_method_frame=method_frame;	VMethodFrame *saved_method_frame=method_frame;
Value *saved_rcontext=rcontext;	Value *saved_rcontext=rcontext;
WContext *saved_wcontext=wcontext;	WContext *saved_wcontext=wcontext;

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

// prevent non-string writes for better error reporting	// prevent non-string writes for better error reporting
Line 971 void Request::execute_method(Value& asel	Line 987 void Request::execute_method(Value& asel
wcontext=saved_wcontext;	wcontext=saved_wcontext;
rcontext=saved_rcontext;	rcontext=saved_rcontext;
method_frame=saved_method_frame;	method_frame=saved_method_frame;
self=saved_self;
}	}

void Request::execute_nonvirtual_method(VStateless_class& aclass,	void Request::execute_nonvirtual_method(VStateless_class& aclass,

E-mail:

Removed from v.1.273
changed lines
	Added in v.1.288