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.327 and 1.331

version 1.327, 2009/04/24 06:30:58	version 1.331, 2009/05/01 11:41:14
Line 33 char *opcode_name[]={	Line 33 char *opcode_name[]={

// actions	// actions
"WITH_ROOT", "WITH_SELF", "WITH_READ", "WITH_WRITE",	"WITH_ROOT", "WITH_SELF", "WITH_READ", "WITH_WRITE",
	#ifdef OPTIMIZE_BYTECODE_GET_CLASS
	"VALUE__GET_CLASS",
	#else
"GET_CLASS",	"GET_CLASS",
	#endif
"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_OR_OPERATOR", "GET_ELEMENT", "GET_ELEMENT__WRITE",	#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT
	"VALUE__GET_ELEMENT_OR_OPERATOR",
	#else
	"GET_ELEMENT_OR_OPERATOR",
	#endif
	"GET_ELEMENT",
	#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT
	"VALUE__GET_ELEMENT",
	#endif
	"GET_ELEMENT__WRITE",
	#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT
	"VALUE__GET_ELEMENT__WRITE",
	#endif
"OBJECT_POOL", "STRING_POOL",	"OBJECT_POOL", "STRING_POOL",
"STORE_PARAM",
"PREPARE_TO_CONSTRUCT_OBJECT", "PREPARE_TO_EXPRESSION",	"PREPARE_TO_CONSTRUCT_OBJECT", "PREPARE_TO_EXPRESSION",
"CALL", "CALL__WRITE",	"CALL", "CALL__WRITE",

Line 72 void debug_dump(SAPI_Info& sapi_info, in	Line 87 void debug_dump(SAPI_Info& sapi_info, in
while(i.has_next()) {	while(i.has_next()) {
OP::OPCODE opcode=i.next().code;	OP::OPCODE opcode=i.next().code;

if(opcode==OP::OP_VALUE \|\| opcode==OP::OP_STRING__WRITE) {	if(
	opcode==OP::OP_VALUE
	\|\| opcode==OP::OP_STRING__WRITE
	#ifdef OPTIMIZE_BYTECODE_GET_CLASS
	\|\| opcode==OP::OP_VALUE__GET_CLASS
	#endif
	#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT
	\|\| opcode==OP::OP_VALUE__GET_ELEMENT
	\|\| opcode==OP::OP_VALUE__GET_ELEMENT__WRITE
	\|\| opcode==OP::OP_VALUE__GET_ELEMENT_OR_OPERATOR
	#endif
	) {
Operation::Origin origin=i.next().origin;	Operation::Origin origin=i.next().origin;
Value& value=*i.next().value;	Value& value=*i.next().value;
debug_printf(sapi_info,	debug_printf(sapi_info,
Line 131 void Request::execute(ArrayOperation& op	Line 157 void Request::execute(ArrayOperation& op
stack.push(value);	stack.push(value);
break;	break;
}	}

	#ifdef OPTIMIZE_BYTECODE_GET_CLASS
	case OP::OP_VALUE__GET_CLASS:
	{
	// maybe they do ^class:method[] call, remember the fact
	wcontext->set_somebody_entered_some_class();

	debug_origin=i.next().origin;
	Value& value=*i.next().value;
	const String& name=*value.get_string();

	#ifdef DEBUG_EXECUTE
	debug_printf(sapi_info, " \"%s\" ", name.cstr());
	#endif

	Value* class_value=classes().get(name);
	if(!class_value)
	throw Exception(PARSER_RUNTIME,
	&name,
	"class is undefined");

	stack.push(*class_value);
	break;
	}
	#else
case OP::OP_GET_CLASS:	case OP::OP_GET_CLASS:
{	{
// maybe they do ^class:method[] call, remember the fact	// maybe they do ^class:method[] call, remember the fact
Line 146 void Request::execute(ArrayOperation& op	Line 197 void Request::execute(ArrayOperation& op
stack.push(*value);	stack.push(*value);
break;	break;
}	}
	#endif
// OP_WITH	// OP_WITH
case OP::OP_WITH_ROOT:	case OP::OP_WITH_ROOT:
{	{
Line 180 void Request::execute(ArrayOperation& op	Line 231 void Request::execute(ArrayOperation& op
Value& value=stack.pop().value();	Value& value=stack.pop().value();
const String& name=stack.pop().string(); debug_name=&name;	const String& name=stack.pop().string(); debug_name=&name;
Value& ncontext=stack.pop().value();	Value& ncontext=stack.pop().value();
put_element(ncontext, name, value);	put_element(ncontext, name, &value);

break;	break;
}	}
Line 193 void Request::execute(ArrayOperation& op	Line 244 void Request::execute(ArrayOperation& op
const String& name=stack.pop().string(); debug_name=&name;	const String& name=stack.pop().string(); debug_name=&name;
Value& ncontext=stack.pop().value();	Value& ncontext=stack.pop().value();
Value& value=expr.as_expr_result();	Value& value=expr.as_expr_result();
put_element(ncontext, name, value);	put_element(ncontext, name, &value);
break;	break;
}	}
case OP::OP_CURLY_CODE__CONSTRUCT:	case OP::OP_CURLY_CODE__CONSTRUCT:
Line 258 void Request::execute(ArrayOperation& op	Line 309 void Request::execute(ArrayOperation& op
write_no_lang(*value->get_string());	write_no_lang(*value->get_string());
break;	break;
}	}

	#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT
	case OP::OP_VALUE__GET_ELEMENT_OR_OPERATOR:
	{
	debug_origin=i.next().origin;
	const String& name=*i.next().value->get_string(); debug_name=&name;

	#ifdef DEBUG_EXECUTE
	debug_printf(sapi_info, " \"%s\" ", name.cstr());
	#endif
	if(Method* method=main_class.get_method(name)){ // looking operator of that name FIRST
	if(!method->junction_template) method->junction_template=new VJunction(main_class, method);
	stack.push(*method->junction_template);
	break;
	}
	Value& value=get_element(*rcontext, name);
	stack.push(value);
	break;
	}
	#else
case OP::OP_GET_ELEMENT_OR_OPERATOR:	case OP::OP_GET_ELEMENT_OR_OPERATOR:
{	{
const String& name=stack.pop().string(); debug_name=&name;	const String& name=stack.pop().string(); debug_name=&name;
Value& ncontext=stack.pop().value();	Value& ncontext=stack.pop().value();
Value& value=get_element(ncontext, name, true);	if(Method* method=main_class.get_method(name)){ // looking operator of that name FIRST
	if(!method->junction_template) method->junction_template=new VJunction(main_class, method);
	stack.push(*method->junction_template);
	break;
	}
	Value& value=get_element(ncontext, name);
stack.push(value);	stack.push(value);
break;	break;
}	}
	#endif

case OP::OP_GET_ELEMENT:	case OP::OP_GET_ELEMENT:
{	{
const String& name=stack.pop().string(); debug_name=&name;	const String& name=stack.pop().string(); debug_name=&name;
Value& ncontext=stack.pop().value();	Value& ncontext=stack.pop().value();
Value& value=get_element(ncontext, name, false);	Value& value=get_element(ncontext, name);
	stack.push(value);
	break;
	}

	#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT
	case OP::OP_VALUE__GET_ELEMENT:
	{
	debug_origin=i.next().origin;
	const String& name=*i.next().value->get_string(); debug_name=&name;

	#ifdef DEBUG_EXECUTE
	debug_printf(sapi_info, " \"%s\" ", name.cstr());
	#endif

	Value& value=get_element(*rcontext, name);
stack.push(value);	stack.push(value);
break;	break;
}	}
	#endif


case OP::OP_GET_ELEMENT__WRITE:	case OP::OP_GET_ELEMENT__WRITE:
{	{
const String& name=stack.pop().string(); debug_name=&name;	const String& name=stack.pop().string(); debug_name=&name;
Value& ncontext=stack.pop().value();	Value& ncontext=stack.pop().value();
Value& value=get_element(ncontext, name, false);	Value& value=get_element(ncontext, name);
write_assign_lang(value);	write_assign_lang(value);
break;	break;
}	}

	#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT
	case OP::OP_VALUE__GET_ELEMENT__WRITE:
	{
	debug_origin=i.next().origin;
	const String& name=*i.next().value->get_string(); debug_name=&name;

	#ifdef DEBUG_EXECUTE
	debug_printf(sapi_info, " \"%s\" ", name.cstr());
	#endif

	Value& value=get_element(*rcontext, name);
	write_assign_lang(value);
	break;
	}
	#endif

case OP::OP_OBJECT_POOL:	case OP::OP_OBJECT_POOL:
{	{
Line 328 void Request::execute(ArrayOperation& op	Line 437 void Request::execute(ArrayOperation& op
}	}

// CALL	// CALL
case OP::OP_STORE_PARAM:
{
Value& value=stack.pop().value();
VMethodFrame& frame=stack.top_value().method_frame();
// this op is executed from CALL local_ops only, so may skip the check "method_frame_to_fill==0"
frame.store_param(value);
break;
}
case OP::OP_CURLY_CODE__STORE_PARAM:	case OP::OP_CURLY_CODE__STORE_PARAM:
case OP::OP_EXPR_CODE__STORE_PARAM:	case OP::OP_EXPR_CODE__STORE_PARAM:
{	{
// code	// code
ArrayOperation& local_ops=*i.next().ops;	ArrayOperation& local_ops=*i.next().ops;
VMethodFrame& frame=stack.top_value().method_frame();
#ifdef DEBUG_EXECUTE	#ifdef DEBUG_EXECUTE
debug_printf(sapi_info, " (%d)\n", local_ops.count());	debug_printf(sapi_info, " (%d)\n", local_ops.count());
debug_dump(sapi_info, 1, local_ops);	debug_dump(sapi_info, 1, local_ops);
Line 367 void Request::execute(ArrayOperation& op	Line 467 void Request::execute(ArrayOperation& op
wcontext->attach_junction(&value);	wcontext->attach_junction(&value);
// 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);	stack.push(value);
break;	break;
}	}

Line 422 void Request::execute(ArrayOperation& op	Line 522 void Request::execute(ArrayOperation& op
*/	*/

VMethodFrame frame(*junction, method_frame);	VMethodFrame frame(*junction, method_frame);
	WContext* result_wcontext;

if(local_ops){ // store param code goes here	if(local_ops){ // store param code goes here
stack.push(frame); // argument for *STORE_PARAM ops	size_t first = stack.top_index();
execute(*local_ops);	execute(*local_ops);
stack.pop().value();	frame.store_params((Value**)stack.ptr(first), stack.top_index()-first);
	result_wcontext=op_call(frame);
	stack.set_top_index(first);
	} else {
	frame.empty_params();
	result_wcontext=op_call(frame);
}	}
WContext* result_wcontext=op_call(frame);
if(opcode==OP::OP_CALL__WRITE) {	if(opcode==OP::OP_CALL__WRITE) {
write_assign_lang(result_wcontext->result());	write_assign_lang(result_wcontext->result());
} else { // OP_CALL	} else { // OP_CALL
Line 771 void Request::execute(ArrayOperation& op	Line 878 void Request::execute(ArrayOperation& op
}	}
}	}

WContext* Request::op_call(VMethodFrame& frame){	#define SAVE_CONTEXT \
frame.fill_unspecified_params();	VMethodFrame *saved_method_frame=method_frame; \
VMethodFrame *saved_method_frame=method_frame;	Value* saved_rcontext=rcontext; \
Value* saved_rcontext=rcontext;
WContext *saved_wcontext=wcontext;	WContext *saved_wcontext=wcontext;

	#define RESTORE_CONTEXT \
	wcontext=saved_wcontext; \
	rcontext=saved_rcontext; \
	method_frame=saved_method_frame;

	WContext* Request::op_call(VMethodFrame& frame){
	SAVE_CONTEXT

VStateless_class& called_class=*frame.junction.self.get_class();	VStateless_class& called_class=*frame.junction.self.get_class();
Value* new_self;	Value* new_self;
Line 836 WContext* Request::op_call(VMethodFrame&	Line 950 WContext* Request::op_call(VMethodFrame&
WContext *result_wcontext=wcontext;	WContext *result_wcontext=wcontext;
// StringOrValue result=wcontext->result();	// StringOrValue result=wcontext->result();

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

return result_wcontext;	return result_wcontext;
}	}
Line 848 WContext* Request::op_call(VMethodFrame&	Line 960 WContext* Request::op_call(VMethodFrame&
@todo cache\|prepare junctions	@todo cache\|prepare junctions
@bug ^superbase:method would dynamically call ^base:method if there is any	@bug ^superbase:method would dynamically call ^base:method if there is any
*/	*/
Value& Request::get_element(Value& ncontext, const String& name, bool can_call_operator) {	Value& Request::get_element(Value& ncontext, const String& name) {
Value* value=0;	if(!wcontext->get_constructing() // not constructing
if(can_call_operator) {	&& wcontext->get_somebody_entered_some_class() ) // ^class:method
if(Method* method=main_class.get_method(name)){ // looking operator of that name FIRST
if(!method->junction_template)
method->junction_template=new VJunction(main_class, method);
return *method->junction_template;
}
}
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 *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=get_self().base()) { // doing DYNAMIC call	if(Value* base=get_self().base()) { // doing DYNAMIC call
Temp_derived temp_derived(*base, 0); // temporarily prevent go-back-down virtual calls	Temp_derived temp_derived(*base, 0); // temporarily prevent go-back-down virtual calls
value=base->get_element(name, *base, true); // virtual-up lookup starting from parent	Value value=base->get_element(name, base, true); // virtual-up lookup starting from parent
goto value_ready;	return (value ? &process_to_value(value) : VVoid::get());
}	}
}
if(!value)	Value* value=ncontext.get_element(name, ncontext, true);
value=ncontext.get_element(name, ncontext, true);

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

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

return *value;	return (value ? &process_to_value(value) : VVoid::get());
}	}

void Request::put_element(Value& ncontext, const String& name, Value& value) {	void Request::put_element(Value& ncontext, const String& name, Value* value) {
// put_element can return property-setting-junction	// put_element can return property-setting-junction
if(const VJunction* vjunction=ncontext.put_element(ncontext, name, &value, false))	if(const VJunction* vjunction=ncontext.put_element(ncontext, name, value, false))
if(vjunction!=PUT_ELEMENT_REPLACED_ELEMENT) {	if(vjunction!=PUT_ELEMENT_REPLACED_ELEMENT) {
const Junction& junction=vjunction->junction();
// process it	// process it
ArrayString* params_names=junction.method->params_names;	VMethodFrame frame(vjunction->junction(), method_frame/caller/);
int param_count=params_names? params_names->count(): 0;	int param_count=frame.method_params_count();

if(param_count!=1)	if(param_count!=1)
throw Exception(PARSER_RUNTIME,	throw Exception(PARSER_RUNTIME,
0,	0,
"setter method must have ONE parameter (has %d parameters)", param_count);	"setter method must have ONE parameter (has %d parameters)", param_count);

VMethodFrame frame(junction, method_frame/caller/);	frame.store_params(&value, 1);
frame.store_param(value);

frame.set_self(frame.junction.self);	frame.set_self(frame.junction.self);

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

rcontext=wcontext=&frame;	rcontext=wcontext=&frame;
method_frame=&frame;	method_frame=&frame;
Line 921 void Request::put_element(Value& ncontex	Line 1012 void Request::put_element(Value& ncontex
recoursion_checked_execute(*frame.junction.method->parser_code); // parser code, execute it	recoursion_checked_execute(*frame.junction.method->parser_code); // parser code, execute it
// we don't need it StringOrValue result=wcontext->result();	// we don't need it StringOrValue result=wcontext->result();

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

Line 942 StringOrValue Request::process(Value& in	Line 1031 StringOrValue Request::process(Value& in
Junction* junction=input_value.get_junction();	Junction* junction=input_value.get_junction();
if(junction) {	if(junction) {
if(junction->is_getter) { // is it a getter-junction?	if(junction->is_getter) { // is it a getter-junction?
int param_count=junction->method->params_names?junction->method->params_names->count():0;
if(junction->auto_name){ // default getter
if(param_count>1)
throw Exception(PARSER_RUNTIME,
0,
"default getter method can't have more then 1 parameter (has %d parameters)", param_count);
} else if(param_count)
throw Exception(PARSER_RUNTIME,
0,
"getter method must have no parameters (has %d parameters)", param_count);

VMethodFrame frame(junction, method_frame/caller*/);	VMethodFrame frame(junction, method_frame/caller*/);
	int param_count=frame.method_params_count();

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

frame.set_self(frame.junction.self);	frame.set_self(frame.junction.self);

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

rcontext=wcontext=&frame;	rcontext=wcontext=&frame;
method_frame=&frame;	method_frame=&frame;
Line 970 StringOrValue Request::process(Value& in	Line 1059 StringOrValue Request::process(Value& in
recoursion_checked_execute(*frame.junction.method->parser_code); // parser code, execute it	recoursion_checked_execute(*frame.junction.method->parser_code); // parser code, execute it
StringOrValue result=wcontext->result();	StringOrValue result=wcontext->result();

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

return result;	return result;
}	}
Line 989 StringOrValue Request::process(Value& in	Line 1076 StringOrValue Request::process(Value& in
0,	0,
"junction used outside of context");	"junction used outside of context");

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

method_frame=junction->method_frame;	method_frame=junction->method_frame;
rcontext=junction->rcontext;	rcontext=junction->rcontext;
Line 1022 StringOrValue Request::process(Value& in	Line 1107 StringOrValue Request::process(Value& in
result=wcontext->result();	result=wcontext->result();
}	}

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

#ifdef DEBUG_EXECUTE	#ifdef DEBUG_EXECUTE
debug_printf(sapi_info, "<-ja returned");	debug_printf(sapi_info, "<-ja returned");
Line 1040 StringOrValue Request::process(Value& in	Line 1123 StringOrValue Request::process(Value& in
}	}

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

// initialize contexts	// initialize contexts
rcontext=wcontext=method_frame=&amethod_frame;	rcontext=wcontext=method_frame=&amethod_frame;
Line 1053 StringOrValue Request::execute_method(VM	Line 1134 StringOrValue Request::execute_method(VM
// result	// result
StringOrValue result=wcontext->result();	StringOrValue result=wcontext->result();

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

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

const String* Request::execute_method(Value& aself,	const String* Request::execute_method(Value& aself,
const Method& method, VString* optional_param,	const Method& method, Value* optional_param,
bool do_return_string) {	bool do_return_string) {

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

Junction local_junction(aself, &method);	Junction local_junction(aself, &method);
VMethodFrame local_frame(local_junction, method_frame/caller/);	VMethodFrame local_frame(local_junction, method_frame/caller/);
if(optional_param && local_frame.can_store_param()) {	if(optional_param && local_frame.method_params_count()>0) {
local_frame.store_param(*optional_param);	local_frame.store_params(&optional_param, 1);
local_frame.fill_unspecified_params();	} else {
	local_frame.empty_params();
}	}
local_frame.set_self(aself);	local_frame.set_self(aself);
rcontext=wcontext=method_frame=&local_frame;	rcontext=wcontext=method_frame=&local_frame;
Line 1090 const String* Request::execute_method(Va	Line 1168 const String* Request::execute_method(Va
if(do_return_string)	if(do_return_string)
result=&wcontext->result().as_string();	result=&wcontext->result().as_string();

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

return result;	return result;
}	}

Request::Execute_nonvirtual_method_result	Request::Execute_nonvirtual_method_result
Request::execute_nonvirtual_method(VStateless_class& aclass,	Request::execute_nonvirtual_method(VStateless_class& aclass,
const String& method_name,	const String& method_name,
VString* optional_param,	VString* optional_param,
bool do_return_string) {	bool do_return_string) {
Execute_nonvirtual_method_result result;	Execute_nonvirtual_method_result result;
result.method=aclass.get_method(method_name);	result.method=aclass.get_method(method_name);
if(result.method)	if(result.method)
Line 1110 Request::execute_nonvirtual_method(VStat	Line 1186 Request::execute_nonvirtual_method(VStat
}	}

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

E-mail:

Removed from v.1.327
changed lines
	Added in v.1.331