--- parser3/src/main/execute.C	2009/08/14 10:39:57	1.357
+++ parser3/src/main/execute.C	2016/10/04 12:48:59	1.387
@@ -1,12 +1,10 @@
 /** @file
 	Parser: executor part of request class.
 
-	Copyright (c) 2001-2009 ArtLebedev Group (http://www.artlebedev.com)
+	Copyright (c) 2001-2015 Art. Lebedev Studio (http://www.artlebedev.com)
 	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
 */
 
-static const char * const IDENT_EXECUTE_C="$Date: 2009/08/14 10:39:57 $";
-
 #include "pa_opcode.h"
 #include "pa_array.h" 
 #include "pa_request.h"
@@ -23,21 +21,19 @@ static const char * const IDENT_EXECUTE_
 #include "pa_vimage.h"
 #include "pa_wwrapper.h"
 
+volatile const char * IDENT_EXECUTE_C="$Id: execute.C,v 1.387 2016/10/04 12:48:59 moko Exp $" IDENT_PA_OPCODE_H IDENT_PA_OPERATION_H IDENT_PA_VCODE_FRAME_H IDENT_PA_WWRAPPER_H;
+
 //#define DEBUG_EXECUTE
 
 #ifdef DEBUG_EXECUTE
-char *opcode_name[]={
+const char *opcode_name[]={
 	// literals
 	"VALUE",  "CURLY_CODE__STORE_PARAM",  "EXPR_CODE__STORE_PARAM",
 	"NESTED_CODE",
 
 	// actions
 	"WITH_ROOT",	"WITH_SELF",	"WITH_READ",	"WITH_WRITE",
-#ifdef OPTIMIZE_BYTECODE_GET_CLASS
-	"VALUE__GET_CLASS",
-#else
-	"GET_CLASS",
-#endif
+	"VALUE__GET_CLASS", "VALUE__GET_BASE_CLASS",
 	"CONSTRUCT_VALUE", "CONSTRUCT_EXPR", "CURLY_CODE__CONSTRUCT",
 	"WRITE_VALUE",  "WRITE_EXPR_RESULT",  "STRING__WRITE",
 #ifdef OPTIMIZE_BYTECODE_GET_ELEMENT
@@ -64,6 +60,17 @@ char *opcode_name[]={
 	"WITH_SELF__VALUE__GET_ELEMENT",
 	"WITH_SELF__VALUE__GET_ELEMENT__WRITE",
 #endif
+
+#ifdef FEATURE_GET_ELEMENT4CALL
+	"GET_ELEMENT4CALL",
+#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_ELEMENT
+	"GET_OBJECT_ELEMENT4CALL",
+#endif
+#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_VAR_ELEMENT
+	"GET_OBJECT_VAR_ELEMENT4CALL",
+#endif
+#endif // FEATURE_GET_ELEMENT4CALL
+
 	"OBJECT_POOL",	"STRING_POOL",
 	"PREPARE_TO_CONSTRUCT_OBJECT",
 	"CONSTRUCT_OBJECT",
@@ -80,6 +87,10 @@ char *opcode_name[]={
 	"WITH_SELF__VALUE__CONSTRUCT_VALUE",
 #endif
 
+#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT__SPECIAL
+	"GET_ELEMENT__SPECIAL",
+	"GET_ELEMENT__SPECIAL__WRITE",
+#endif
 	// expression ops: unary
 	"NEG", "INV", "NOT", "DEF", "IN", "FEXISTS", "DEXISTS",
 	// expression ops: binary
@@ -99,7 +110,7 @@ const char* debug_value_to_cstr(Value& v
 		return string->cstr();
 	else
 		if(value.is_bool())
-			return value.as_bool()?"<true>":"<false>";
+			return value.as_bool() ? "<true>" : "<false>";
 		else
 			return "<value>";
 }
@@ -128,21 +139,23 @@ void debug_dump(SAPI_Info& sapi_info, in
 #ifdef OPTIMIZE_BYTECODE_GET_OBJECT_ELEMENT
 			|| opcode==OP::OP_GET_OBJECT_ELEMENT
 			|| opcode==OP::OP_GET_OBJECT_ELEMENT__WRITE
+#ifdef FEATURE_GET_ELEMENT4CALL
+			|| opcode==OP::OP_GET_OBJECT_ELEMENT4CALL
+#endif
 #endif
 #ifdef OPTIMIZE_BYTECODE_GET_OBJECT_VAR_ELEMENT
 			|| opcode==OP::OP_GET_OBJECT_VAR_ELEMENT
 			|| opcode==OP::OP_GET_OBJECT_VAR_ELEMENT__WRITE
+#ifdef FEATURE_GET_ELEMENT4CALL
+			|| opcode==OP::OP_GET_OBJECT_VAR_ELEMENT4CALL
+#endif
 #endif
 		){
 			i.next(); // skip origin
 			Value& value1=*i.next().value;
 			i.next(); // skip origin
 			Value& value2=*i.next().value;
-			debug_printf(sapi_info, 
-				"%*s%s"
-				" \"%s\" \"%s\"", 
-				level*4, "", opcode_name[opcode],
-				debug_value_to_cstr(value1), debug_value_to_cstr(value2));
+			debug_printf(sapi_info, "%*s%s \"%s\" \"%s\"", level*4, "", opcode_name[opcode], debug_value_to_cstr(value1), debug_value_to_cstr(value2));
 			continue;
 		}
 #endif
@@ -167,9 +180,8 @@ void debug_dump(SAPI_Info& sapi_info, in
 		if(
 			opcode==OP::OP_VALUE
 			|| opcode==OP::OP_STRING__WRITE
-#ifdef OPTIMIZE_BYTECODE_GET_CLASS
 			|| opcode==OP::OP_VALUE__GET_CLASS
-#endif
+			|| opcode==OP::OP_VALUE__GET_BASE_CLASS
 #ifdef OPTIMIZE_BYTECODE_GET_ELEMENT
 			|| opcode==OP::OP_VALUE__GET_ELEMENT
 			|| opcode==OP::OP_VALUE__GET_ELEMENT__WRITE
@@ -263,45 +275,69 @@ void Request::execute(ArrayOperation& op
 				stack.push(value);
 				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();
+				const String& name=*i.next().value->get_string(); debug_name=&name;
 
 				DEBUG_PRINT_STRING(name)
 
-				Value* class_value=classes().get(name);
-				if(!class_value)
-					throw Exception(PARSER_RUNTIME,
-						&name,
-						"class is undefined"); 
+				VStateless_class* vclass=get_class(name);
+				if(!vclass)
+					throw Exception(PARSER_RUNTIME, &name, "class is undefined"); 
 
-				stack.push(*class_value);
+				stack.push(*vclass);
 				break;
 			}
-#else
-		case OP::OP_GET_CLASS:
+
+		case OP::OP_VALUE__GET_BASE_CLASS:
 			{
-				// maybe they do ^class:method[] call, remember the fact
-				wcontext->set_somebody_entered_some_class();
+				// ^class:method[] call
 
-				const String& name=stack.pop().string();
-				Value* value=classes().get(name);
-				if(!value) 
-					throw Exception(PARSER_RUNTIME,
-						&name,
-						"class is undefined"); 
+				debug_origin=i.next().origin;
+				const String& name=*i.next().value->get_string(); debug_name=&name;
 
-				stack.push(*value);
+				DEBUG_PRINT_STRING(name)
+
+				VStateless_class* vclass=get_class(name);
+				if(!vclass)
+					throw Exception(PARSER_RUNTIME, &name, "class is undefined"); 
+
+				stack.push(*new VBaseClassWrapper(*vclass, get_self()));
+				break;
+			}
+
+#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT__SPECIAL
+		case OP::OP_GET_ELEMENT__SPECIAL:
+		case OP::OP_GET_ELEMENT__SPECIAL__WRITE:
+			{
+				const String& name=stack.pop().string();  debug_name=&name;
+				Value& ncontext=stack.pop().value();
+
+				Value* value=0;
+				if(VStateless_class* vclass=ncontext.get_class()){
+					if(SYMBOLS_EQ(name,CLASS_SYMBOL)){
+						value=vclass;
+					} else if(SYMBOLS_EQ(name,CLASS_NAME_SYMBOL)){
+						value=new VString(*new String(vclass->type()));
+					}
+				} else {
+					// VJunction is without class, returning self
+					if(SYMBOLS_EQ(name,CLASS_SYMBOL)){
+						value=&ncontext;
+					} else if(SYMBOLS_EQ(name,CLASS_NAME_SYMBOL)){
+						value=new VString(*new String(ncontext.type()));
+					}
+				}
+				if(opcode==OP::OP_GET_ELEMENT__SPECIAL){
+					stack.push(*value);
+				} else {
+					write_assign_lang(*value);
+				}
 				break;
 			}
 #endif
+
 		// OP_WITH
 		case OP::OP_WITH_ROOT:
 			{
@@ -321,9 +357,7 @@ void Request::execute(ArrayOperation& op
 		case OP::OP_WITH_WRITE:
 			{
 				if(wcontext==method_frame)
-					throw Exception(PARSER_RUNTIME,
-						0,
-						"$.name outside of $name[...]");
+					throw Exception(PARSER_RUNTIME, 0, "$.name outside of $name[...]");
 
 				stack.push(*wcontext);
 				break;
@@ -422,11 +456,9 @@ void Request::execute(ArrayOperation& op
 
 				const String& name=stack.pop().string();  debug_name=&name;
 				Value& ncontext=stack.pop().value();
-				if(const VJunction* vjunction=ncontext.put_element(name, &value, false))
+				if(const VJunction* vjunction=ncontext.put_element(name, &value))
 					if(vjunction!=PUT_ELEMENT_REPLACED_ELEMENT)
-						throw Exception(PARSER_RUNTIME,
-							0,
-							"property value can not be code, use [] or () brackets");
+						throw Exception(PARSER_RUNTIME, 0, "property value can not be code, use [] or () brackets");
 					
 				break;
 			}
@@ -501,59 +533,64 @@ void Request::execute(ArrayOperation& op
 #endif
 
 #ifdef OPTIMIZE_BYTECODE_GET_OBJECT_ELEMENT
-		case OP::OP_GET_OBJECT_ELEMENT:
-		case OP::OP_GET_OBJECT_ELEMENT__WRITE:
-			{
-				debug_origin=i.next().origin;
-				const String& context_name=*i.next().value->get_string();  debug_name=&context_name;
-
-				DEBUG_PRINT_STRING(context_name)
-
-				Value& object=get_element(*rcontext, context_name);
-
-				debug_origin=i.next().origin;
-				const String& field_name=*i.next().value->get_string();  debug_name=&field_name;
 
-				DEBUG_PRINT_STRING(field_name)
+#define DO_GET_OBJECT_ELEMENT(code) {\
+				debug_origin=i.next().origin;								\
+				const String& context_name=*i.next().value->get_string();  debug_name=&context_name;	\
+				DEBUG_PRINT_STRING(context_name)							\
+				Value& object=get_element(*rcontext, context_name);					\
+				debug_origin=i.next().origin;								\
+				const String& field_name=*i.next().value->get_string();  debug_name=&field_name;	\
+				DEBUG_PRINT_STRING(field_name) 								\
+				code;											\
+				break;											\
+			}
 
+		case OP::OP_GET_OBJECT_ELEMENT: DO_GET_OBJECT_ELEMENT({
 				Value& value=get_element(object, field_name);
-
-				if(opcode==OP::OP_GET_OBJECT_ELEMENT){
-					stack.push(value);
-				} else {
-					write_assign_lang(value);
-				}
-				break;
-			}
+				stack.push(value);
+			})
+		case OP::OP_GET_OBJECT_ELEMENT__WRITE: DO_GET_OBJECT_ELEMENT({
+				Value& value=get_element(object, field_name);
+				write_assign_lang(value);
+			})
+#ifdef FEATURE_GET_ELEMENT4CALL
+		case OP::OP_GET_OBJECT_ELEMENT4CALL: DO_GET_OBJECT_ELEMENT({
+				Value& value=get_element4call(object, field_name);
+				stack.push(value);
+			})
+#endif
 #endif
 
 #ifdef OPTIMIZE_BYTECODE_GET_OBJECT_VAR_ELEMENT
-		case OP::OP_GET_OBJECT_VAR_ELEMENT:
-		case OP::OP_GET_OBJECT_VAR_ELEMENT__WRITE:
-			{
-				debug_origin=i.next().origin;
-				const String& context_name=*i.next().value->get_string();  debug_name=&context_name;
-
-				DEBUG_PRINT_STRING(context_name)
 
-				Value& object=get_element(*rcontext, context_name);
-
-				debug_origin=i.next().origin;
-				const String& var_name=*i.next().value->get_string();  debug_name=&var_name;
-
-				DEBUG_PRINT_STRING(var_name)
-
-				const String* field=get_element(*rcontext, var_name).get_string();
+#define DO_GET_OBJECT_VAR_ELEMENT(code) {\
+				debug_origin=i.next().origin;								\
+				const String& context_name=*i.next().value->get_string();  debug_name=&context_name;	\
+				DEBUG_PRINT_STRING(context_name)							\
+				Value& object=get_element(*rcontext, context_name);					\
+				debug_origin=i.next().origin;								\
+				const String& var_name=*i.next().value->get_string();  debug_name=&var_name;		\
+				DEBUG_PRINT_STRING(var_name)								\
+				const String* field=&get_element(*rcontext, var_name).as_string();			\
+				code;											\
+				break;											\
+			}
 
+		case OP::OP_GET_OBJECT_VAR_ELEMENT: DO_GET_OBJECT_VAR_ELEMENT({
 				Value& value=get_element(object, *field);
-
-				if(opcode==OP::OP_GET_OBJECT_VAR_ELEMENT){
-					stack.push(value);
-				} else {
-					write_assign_lang(value);
-				}
-				break;
-			}
+				stack.push(value);
+			})
+		case OP::OP_GET_OBJECT_VAR_ELEMENT__WRITE: DO_GET_OBJECT_VAR_ELEMENT({
+				Value& value=get_element(object, *field);
+				write_assign_lang(value);
+			})
+#ifdef FEATURE_GET_ELEMENT4CALL
+		case OP::OP_GET_OBJECT_VAR_ELEMENT4CALL: DO_GET_OBJECT_VAR_ELEMENT({
+				Value& value=get_element4call(object, *field);
+				stack.push(value);
+			})
+#endif
 #endif
 
 		case OP::OP_GET_ELEMENT:
@@ -565,6 +602,17 @@ void Request::execute(ArrayOperation& op
 				break;
 			}
 
+#ifdef FEATURE_GET_ELEMENT4CALL
+		case OP::OP_GET_ELEMENT4CALL:
+			{
+				const String& name=stack.pop().string();  debug_name=&name;
+				Value& ncontext=stack.pop().value();
+				Value& value=get_element4call(ncontext, name);
+				stack.push(value);
+				break;
+			}
+#endif
+
 		case OP::OP_GET_ELEMENT__WRITE:
 			{
 				const String& name=stack.pop().string();  debug_name=&name;
@@ -648,7 +696,7 @@ void Request::execute(ArrayOperation& op
 
 				execute(local_ops);
 
-				stack.push(wcontext->result().as_value());
+				stack.push(wcontext->result());
 				flang=saved_lang;
 				wcontext=saved_wcontext;
 				break;
@@ -664,13 +712,10 @@ void Request::execute(ArrayOperation& op
 
 				execute(local_ops);
 
-				Value* value;
 				// from "$a $b" part of expression taking only string value,
 				// ignoring any other content of wcontext
-				if(const String* string=wcontext->get_string())
-					value=new VString(*string);
-				else
-					value=VVoid::get();
+				const String* string=wcontext->get_string();
+				Value* value=string ? new VString(*string) : new VString();
 				stack.push(*value);
 
 				wcontext=saved_wcontext;
@@ -714,16 +759,16 @@ void Request::execute(ArrayOperation& op
 				break;
 			}
 
-#define METHOD_FRAME_ACTION(action)													\
-		if(local_ops){																\
-			size_t first = stack.top_index();										\
-			execute(*local_ops);													\
-			frame.store_params((Value**)stack.ptr(first), stack.top_index()-first);	\
-			action;																	\
-			stack.set_top_index(first);												\
-		} else {																	\
-			frame.empty_params();													\
-			action;																	\
+#define METHOD_FRAME_ACTION(action)											\
+		if(local_ops){												\
+			size_t first = stack.top_index();								\
+			execute(*local_ops);										\
+			frame.store_params((Value**)stack.ptr(first), stack.top_index()-first);				\
+			action;												\
+			stack.set_top_index(first);									\
+		} else {												\
+			frame.empty_params();										\
+			action;												\
 		}
 
 		case OP::OP_CALL:
@@ -738,19 +783,19 @@ void Request::execute(ArrayOperation& op
 				Junction* junction=value.get_junction();
 				if(!junction) {
 					if(value.is("void"))
-						throw Exception(PARSER_RUNTIME,
-							0,
-							"undefined method");
+						throw Exception(PARSER_RUNTIME, 0, "undefined method");
 					else
-						throw Exception(PARSER_RUNTIME,
-							0,
-							"is '%s', not a method or junction, can not call it",
-								value.type());
+						throw Exception(PARSER_RUNTIME, 0, "is '%s', not a method or junction, can not call it", value.type());
 				}
 
-				VMethodFrame frame(*junction, method_frame);
-				METHOD_FRAME_ACTION(op_call(frame, false));
-				stack.push(frame.result().as_value());
+				Value *result;
+				{
+					VMethodFrame frame(*junction->method, method_frame, junction->self);
+					METHOD_FRAME_ACTION(op_call(frame));
+					result=&frame.result();
+					// VMethodFrame desctructor deletes junctions in stack params here
+				}
+				stack.push(*result);
 
 				DEBUG_PRINT_STR("<-returned")
 
@@ -758,9 +803,7 @@ void Request::execute(ArrayOperation& op
 					return;
 				if(get_interrupted()) {
 					set_interrupted(false);
-					throw Exception("parser.interrupted",
-						0,
-						"execution stopped");
+					throw Exception("parser.interrupted", 0, "execution stopped");
 				}
 				break;
 			}
@@ -777,14 +820,9 @@ void Request::execute(ArrayOperation& op
 				Junction* junction=value.get_junction();
 				if(!junction) {
 					if(value.is("void"))
-						throw Exception(PARSER_RUNTIME,
-							0,
-							"undefined method");
+						throw Exception(PARSER_RUNTIME, 0, "undefined method");
 					else
-						throw Exception(PARSER_RUNTIME,
-							0,
-							"is '%s', not a method or junction, can not call it",
-							value.type());
+						throw Exception(PARSER_RUNTIME, 0, "is '%s', not a method or junction, can not call it", value.type());
 				}
 
 #ifdef OPTIMIZE_CALL
@@ -806,13 +844,13 @@ void Request::execute(ArrayOperation& op
 						method.native_code(*this, method_params); // execute it
 					}
 				} else if(method.call_optimization==Method::CO_WITHOUT_WCONTEXT){
-					VMethodFrame frame(*junction, method_frame);
+					VMethodFrame frame(method, method_frame, junction->self);
 					METHOD_FRAME_ACTION(op_call_write(frame));
 				} else 
 #endif // OPTIMIZE_CALL
 				{
-					VMethodFrame frame(*junction, method_frame);
-					METHOD_FRAME_ACTION(op_call(frame, false));
+					VMethodFrame frame(method, method_frame, junction->self);
+					METHOD_FRAME_ACTION(op_call(frame));
 					write_pass_lang(frame.result());
 				}
 
@@ -822,9 +860,7 @@ void Request::execute(ArrayOperation& op
 					return;
 				if(get_interrupted()) {
 					set_interrupted(false);
-					throw Exception("parser.interrupted",
-						0,
-						"execution stopped");
+					throw Exception("parser.interrupted", 0, "execution stopped");
 				}
 				break;
 			}
@@ -834,15 +870,13 @@ void Request::execute(ArrayOperation& op
 			{
 				debug_origin=i.next().origin;
 				Value& vclass_name=*i.next().value;
-				const String& class_name=*vclass_name.get_string();
+				const String& class_name=*vclass_name.get_string(); debug_name=&class_name;
 
 				DEBUG_PRINT_STRING(class_name)
 
-				Value* class_value=classes().get(class_name);
-				if(!class_value)
-					throw Exception(PARSER_RUNTIME,
-						&class_name,
-						"class is undefined"); 
+				VStateless_class* vclass=get_class(class_name);
+				if(!vclass)
+					throw Exception(PARSER_RUNTIME, &class_name, "class is undefined"); 
 
 				debug_origin=i.next().origin;
 				Value& vconstructor_name=*i.next().value;
@@ -850,27 +884,28 @@ void Request::execute(ArrayOperation& op
 
 				DEBUG_PRINT_STRING(constructor_name)
 
-				Value& constructor_value=get_element(*class_value, constructor_name);
-
-				Junction* junction=constructor_value.get_junction();
-				if(!junction)
-					throw Exception(PARSER_RUNTIME,
-						&constructor_name,
-						"constructor must be declared in class '%s'", 
-						class_value->get_class()->name_cstr());
+				Junction* constructor_junction=get_element(*vclass, constructor_name).get_junction();
+				if(!constructor_junction)
+					throw Exception(PARSER_RUNTIME, &constructor_name, "constructor must be declared in class '%s'", vclass->type());
 
 				ArrayOperation* local_ops=i.next().ops;
 				DEBUG_PRINT_OPS(local_ops)
 				DEBUG_PRINT_STR("->\n")
 
-				Junction casted=Junction(*class_value, junction->method);
-				VConstructorFrame frame(casted, method_frame);
+				Value *result;
+				{
+					Value& object=construct(*vclass, *constructor_junction->method);
+					VConstructorFrame frame(*constructor_junction->method, method_frame, object);
+					METHOD_FRAME_ACTION(op_call(frame));
+					object.enable_default_setter();
+					result=&frame.result();
+					// VMethodFrame desctructor deletes junctions in stack params here
+				}
 
-				METHOD_FRAME_ACTION(op_call(frame, true /* constructing */));
 				if(opcode==OP::OP_CONSTRUCT_OBJECT)
-					stack.push(frame.result().as_value());
+					stack.push(*result);
 				else
-					write_pass_lang(frame.result());
+					write_pass_lang(*result);
 
 				DEBUG_PRINT_STR("<-returned")
 				break;
@@ -959,9 +994,7 @@ void Request::execute(ArrayOperation& op
 
 				if(b_double == 0) {
 					//const String* problem_source=b.as_string();
-					throw Exception("number.zerodivision",
-						0, //problem_source,
-						"Division by zero");
+					throw Exception("number.zerodivision", 0, "Division by zero");
 				}
 
 				Value& value=*new VDouble(a_double / b_double);
@@ -977,9 +1010,7 @@ void Request::execute(ArrayOperation& op
 
 				if(b_double == 0) {
 					//const String* problem_source=b.as_string();
-					throw Exception("number.zerodivision",
-						0, //problem_source,
-						"Modulus by zero");
+					throw Exception("number.zerodivision", 0, "Modulus by zero");
 				}
 
 				Value& value=*new VDouble(fmod(a_double, b_double));
@@ -995,9 +1026,7 @@ void Request::execute(ArrayOperation& op
 
 				if(b_int == 0) {
 					//const String* problem_source=b.as_string();
-					throw Exception("number.zerodivision",
-						0, //problem_source,
-						"Division by zero");
+					throw Exception("number.zerodivision", 0, "Division by zero");
 				}
 
 				Value& value=*new VInt(a_int / b_int);
@@ -1184,9 +1213,7 @@ void Request::execute(ArrayOperation& op
 			}
 
 		default:
-			throw Exception(0,
-				0,
-				"invalid opcode %d", opcode); 
+			throw Exception(0, 0, "invalid opcode %d", opcode); 
 		}
 	}
 	} catch(const Exception&) {
@@ -1198,141 +1225,149 @@ void Request::execute(ArrayOperation& op
 }
 
 #define SAVE_CONTEXT								\
-	VMethodFrame *saved_method_frame=method_frame;	\
-	Value* saved_rcontext=rcontext;					\
+	VMethodFrame *saved_method_frame=method_frame;				\
+	Value* saved_rcontext=rcontext;						\
 	WContext *saved_wcontext=wcontext;
 
-#define RESTORE_CONTEXT					\
-	wcontext=saved_wcontext;			\
-	rcontext=saved_rcontext;			\
+#define RESTORE_CONTEXT								\
+	wcontext=saved_wcontext;						\
+	rcontext=saved_rcontext;						\
 	method_frame=saved_method_frame;
 
-void Request::op_call(VMethodFrame& frame, bool constructing){
-	const Junction &junction=frame.junction;
-	VStateless_class& called_class=*junction.self.get_class();
-	Value* new_self;
-
-	if(constructing) {
-		if(junction.method->call_type!=Method::CT_STATIC) {
-			// this is a constructor call
-			if(new_self=called_class.create_new_value(fpool)) {
-				// some stateless_class creatable derivates
-			} else 
-				throw Exception(PARSER_RUNTIME,
-					0, //&frame.name(),
-					"is not a constructor, system class '%s' can be constructed only implicitly", 
-						called_class.name().cstr());
 
-			frame.write(*new_self);
-		} else
+Value& Request::construct(VStateless_class &called_class, const Method &method){
+
+	if(method.call_type!=Method::CT_STATIC) {
+		// this is a constructor call
+		if(Value* result=called_class.create_new_value(fpool)) {
+				// some stateless_class creatable derivates
+				return *result;
+		} else 
 			throw Exception(PARSER_RUNTIME,
 				0, //&frame.name(),
-				"method is static and can not be used as constructor");
-	} else 
-		new_self=&junction.self;
-
-	frame.set_self(*new_self);
+				"is not a constructor, system class '%s' can be constructed only implicitly", 
+					called_class.type());
+	} else
+		throw Exception(PARSER_RUNTIME, 0, "method is static and can not be used as constructor");
+}
 
+void Request::op_call(VMethodFrame& frame){
 	// see OP_PREPARE_TO_EXPRESSION
 	frame.set_in_expression(wcontext->get_in_expression());
 				
 	SAVE_CONTEXT
 
-	rcontext=wcontext=&frame;
-	method_frame=&frame;
+	rcontext=wcontext=method_frame=&frame;
 
-	const Method& method=*junction.method;
-	Method::Call_type call_type=&called_class==new_self ? Method::CT_STATIC : Method::CT_DYNAMIC;
+	Value& self=frame.self();
+	const Method& method=frame.method;
+	Method::Call_type call_type=self.get_class()==&self ? Method::CT_STATIC : Method::CT_DYNAMIC;
 
 	if(method.call_type==Method::CT_ANY || method.call_type==call_type) { // allowed call type?
 		if(method.native_code) { // native code?
-			method.check_actual_numbered_params(junction.self, frame.numbered_params());
+			method.check_actual_numbered_params(self, frame.numbered_params());
 			method.native_code(*this, *frame.numbered_params()); // execute it
 		} else // parser code, execute it
 			recoursion_checked_execute(*method.parser_code);
 	} else
-		throw Exception(PARSER_RUNTIME,
-			0,
-			"is not allowed to be called %s", 
-			call_type==Method::CT_STATIC?"statically":"dynamically");
+		throw Exception(PARSER_RUNTIME, 0, "is not allowed to be called %s", call_type==Method::CT_STATIC ? "statically" : "dynamically");
 
 	RESTORE_CONTEXT
-	//return &frame;
 }
 
 void Request::op_call_write(VMethodFrame& frame){
-	const Junction &junction=frame.junction;
-
-	frame.set_self(junction.self);
-
 	VMethodFrame *saved_method_frame=method_frame;
 	Value* saved_rcontext=rcontext;
 
 	rcontext=&frame;
 	method_frame=&frame;
 
-	const Method& method=*junction.method;
-	Method::Call_type call_type=junction.self.get_class()==&junction.self ? Method::CT_STATIC : Method::CT_DYNAMIC;
+	Value& self=frame.self();
+	const Method& method=frame.method;
+	Method::Call_type call_type=self.get_class()==&self ? Method::CT_STATIC : Method::CT_DYNAMIC;
 
 	if(method.call_type==Method::CT_ANY || method.call_type==call_type) { // allowed call type?
 		if(method.native_code) { // native code?
-			method.check_actual_numbered_params(junction.self, frame.numbered_params());
+			method.check_actual_numbered_params(self, frame.numbered_params());
 			method.native_code(*this, *frame.numbered_params()); // execute it
 		} else // parser code, execute it
 			recoursion_checked_execute(*method.parser_code);
 	} else
-		throw Exception(PARSER_RUNTIME,
-			0,
-			"is not allowed to be called %s", 
-			call_type==Method::CT_STATIC?"statically":"dynamically");
+		throw Exception(PARSER_RUNTIME, 0, "is not allowed to be called %s", call_type==Method::CT_STATIC ? "statically" : "dynamically");
 	
 	rcontext=saved_rcontext;
 	method_frame=saved_method_frame;
 }
 
 Value& Request::get_element(Value& ncontext, const String& name) {
-	if(wcontext->get_somebody_entered_some_class()) // ^class:method
-		if(VStateless_class *called_class=ncontext.get_class())
-			if(VStateless_class *read_class=rcontext->get_class())
-				if(read_class->derived_from(*called_class)){ // current derived from called
-					Value *value=called_class->get_element(get_self(), name);
-					return *(value ? &process_to_value(*value) : VVoid::get());
-				}
-
 	Value* value=ncontext.get_element(name);
+	return *(value ? &process_to_value(*value) : VVoid::get());
+}
 
+#ifdef FEATURE_GET_ELEMENT4CALL
+Value& Request::get_element4call(Value& ncontext, const String& name) {
+	Value* value=ncontext.get_element4call(name);
 	return *(value ? &process_to_value(*value) : VVoid::get());
 }
+#endif
 
 void Request::put_element(Value& ncontext, const String& name, Value* value) {
 	// put_element can return property-setting-junction
-	if(const VJunction* vjunction=ncontext.put_element(name, value, false))
+	if(const VJunction* vjunction=ncontext.put_element(name, value))
 		if(vjunction!=PUT_ELEMENT_REPLACED_ELEMENT) {
-			// process it
-			VMethodFrame frame(vjunction->junction(), method_frame/*caller*/);
+			const Junction& junction = vjunction->junction();
+			VConstructorFrame frame(*junction.method, method_frame /*caller*/, junction.self);
 
 			size_t param_count=frame.method_params_count();
-			if(param_count!=1)
-				throw Exception(PARSER_RUNTIME,
-					0,
-					"setter method must have ONE parameter (has %d parameters)", param_count);
-
-			frame.store_params(&value, 1);
-			frame.set_self(frame.junction.self);
 
-			SAVE_CONTEXT
+ 			if(junction.auto_name){ 
+				// default setter
+ 				if(param_count!=2)
+ 					throw Exception(PARSER_RUNTIME, 0, "default setter method must have TWO parameters (has %d parameters)", param_count);
+
+				Value* params[2] = { new VString(*junction.auto_name), value };
+				frame.store_params(params, 2);
+
+				Temp_disable_default_setter temp(junction.self);
+				execute_method(frame);
+ 			} else {
+				// setter
+ 				if(param_count!=1)
+ 					throw Exception(PARSER_RUNTIME, 0, "setter method must have ONE parameter (has %d parameters)", param_count);
 
-			rcontext=wcontext=&frame;
-			method_frame=&frame;
+				frame.store_params(&value, 1);
+				execute_method(frame);
+			}
+		}
+}
 
-			// prevent non-string writes for better error reporting [setters are not expected to return anything]
-			wcontext->write(*method_frame);
+Value& Request::process_getter(Junction& junction) {
+	VMethodFrame frame(*junction.method, method_frame/*caller*/, junction.self);
+	size_t param_count=frame.method_params_count();
+
+	if(junction.auto_name){ 
+		// default getter
+		Value *param;
+
+		if(param_count){
+			if(param_count>1)
+				throw Exception(PARSER_RUNTIME, 0, "default getter method can't have more then 1 parameter (has %d parameters)", param_count);
+			param=new VString(*junction.auto_name);
+			frame.store_params(&param, 1);
+		} // no need for else frame.empty_params()
 
-			recoursion_checked_execute(*frame.junction.method->parser_code); // parser code, execute it
-			// we don't need it StringOrValue result=wcontext->result();
+		Temp_disable_default_getter temp(junction.self);
+		execute_method(frame);
+	} else {
+		// getter
+		if(param_count!=0)
+			throw Exception(PARSER_RUNTIME, 0, "getter method must have no parameters (has %d parameters)", param_count);
+		
+		// no need for frame.empty_params()
+		execute_method(frame);
+	}
 
-			RESTORE_CONTEXT
-		}
+	return frame.result();
 }
 
 /**	@param intercept_string
@@ -1346,52 +1381,22 @@ void Request::put_element(Value& ncontex
 
 	using the fact it's either string_ or value_ result requested to speed up checkes
 */
-StringOrValue Request::process(Value& input_value, bool intercept_string) {
+
+Value& Request::process(Value& input_value, bool intercept_string) {
 	Junction* junction=input_value.get_junction();
 	if(junction) {
 		if(junction->is_getter) { // is it a getter-junction?
-			VMethodFrame frame(*junction, method_frame/*caller*/);
-			Value *param;
-
-			if(size_t param_count=frame.method_params_count()){
-				if(junction->auto_name){ // default getter
-					if(param_count==1){
-						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);
-
-			SAVE_CONTEXT
-
-			rcontext=wcontext=&frame;
-			method_frame=&frame;
-
-			recoursion_checked_execute(*frame.junction.method->parser_code); // parser code, execute it
-
-			RESTORE_CONTEXT
-
-			return frame.result();
+			return process(process_getter(*junction), intercept_string);
 		}
 
 		if(junction->code) { // is it a code-junction?
 			// process it
-			StringOrValue result;
+			ValueRef result;
 
 			DEBUG_PRINT_STR("ja->\n")
 
 			if(!junction->method_frame)
-				throw Exception(PARSER_RUNTIME,
-					0,
-					"junction used outside of context");
+				throw Exception(PARSER_RUNTIME, 0, "junction used outside of context");
 
 			SAVE_CONTEXT
 
@@ -1441,39 +1446,8 @@ StringOrValue Request::process(Value& in
 void Request::process_write(Value& input_value) {
 	Junction* junction=input_value.get_junction();
 	if(junction) {
-		if(junction->is_getter) { // is it a getter-junction?
-			VMethodFrame frame(*junction, method_frame/*caller*/);
-			Value *param;
-
-			if(size_t param_count=frame.method_params_count()){
-				if(junction->auto_name){ // default getter
-					if(param_count==1){
-						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);
-
-			SAVE_CONTEXT
-
-			rcontext=wcontext=&frame;
-			method_frame=&frame;
-
-			recoursion_checked_execute(*frame.junction.method->parser_code); // parser code, execute it
-
-			RESTORE_CONTEXT
-
-			write_pass_lang(frame.result());
-			return;
-		}
+		// no getter-junction check as process_write is called
+		// to process method arguments, not from get_element
 
 		if(junction->code) { // is it a code-junction?
 							// process it
@@ -1481,9 +1455,7 @@ void Request::process_write(Value& input
 			DEBUG_PRINT_STR("ja->\n")
 
 			if(!junction->method_frame)
-				throw Exception(PARSER_RUNTIME,
-					0,
-					"junction used outside of context");
+				throw Exception(PARSER_RUNTIME, 0, "junction used outside of context");
 
 			SAVE_CONTEXT
 
@@ -1533,60 +1505,39 @@ void Request::process_write(Value& input
 	write_pass_lang(input_value);
 }
 
-StringOrValue Request::execute_method(VMethodFrame& amethod_frame, const Method& method) {
+void Request::execute_method(VMethodFrame& aframe) {
 	SAVE_CONTEXT
 	
 	// initialize contexts
-	rcontext=wcontext=method_frame=&amethod_frame;
-	
-	// execute!	
-	execute(*method.parser_code);
+	rcontext=wcontext=method_frame=&aframe;
 	
-	// result
-	StringOrValue result=wcontext->result();
+	// execute!
+	recoursion_checked_execute(*aframe.method.parser_code);
 	
 	RESTORE_CONTEXT
-	
-	// return
-	return result;
 }
 
-const String* Request::execute_method(Value& aself, 
-					const Method& method, Value* optional_param,
-					bool do_return_string) {
+const String* Request::execute_method(Value& aself, const Method& method, Value* optional_param, bool do_return_string) {
+
+	VMethodFrame local_frame(method, method_frame/*caller*/, aself);
 
-	SAVE_CONTEXT
-	
-	Junction local_junction(aself, &method);
-	VMethodFrame local_frame(local_junction, method_frame/*caller*/);
 	if(optional_param && local_frame.method_params_count()>0) {
 		local_frame.store_params(&optional_param, 1);
 	} else {
 		local_frame.empty_params();
 	}
-	local_frame.set_self(aself);
-	rcontext=wcontext=method_frame=&local_frame; 
 
 	// prevent non-string writes for better error reporting
 	if(do_return_string)
 		local_frame.write(local_frame);
 	
-	// execute!	
-	execute(*method.parser_code);
-	
-	// result
-	const String* result=do_return_string ? local_frame.get_string() : 0;
+	execute_method(local_frame);
 	
-	RESTORE_CONTEXT
-
-	return result;
+	return do_return_string ? local_frame.get_string() : 0;
 }
 
 Request::Execute_nonvirtual_method_result 
-Request::execute_nonvirtual_method(VStateless_class& aclass, 
-					const String& method_name,
-					VString* optional_param,
-					bool do_return_string) {
+Request::execute_nonvirtual_method(VStateless_class& aclass, const String& method_name, VString* optional_param, bool do_return_string) {
 	Execute_nonvirtual_method_result result;
 	result.method=aclass.get_method(method_name);
 	if(result.method)
@@ -1594,8 +1545,7 @@ Request::execute_nonvirtual_method(VStat
 	return result;
 }
 
-const String* Request::execute_virtual_method(Value& aself, 
-					const String& method_name) {
+const String* Request::execute_virtual_method(Value& aself, const String& method_name) {
 	if(Value* value=aself.get_element(method_name))
 		if(Junction* junction=value->get_junction())
 			if(const Method *method=junction->method) 
@@ -1603,3 +1553,80 @@ const String* Request::execute_virtual_m
 			
 	return 0;
 }
+
+const String* Request::get_method_filename(const Method* method){
+	if(ArrayOperation* code=method->parser_code)
+		if(code){
+			Operation::Origin origin={0, 0, 0};
+			Array_iterator<Operation> i(*code);
+			while( i.has_next() ){
+				switch( i.next().code ){
+					case OP::OP_CURLY_CODE__STORE_PARAM: 
+					case OP::OP_EXPR_CODE__STORE_PARAM:
+					case OP::OP_CURLY_CODE__CONSTRUCT:
+					case OP::OP_NESTED_CODE:
+					case OP::OP_OBJECT_POOL:
+					case OP::OP_STRING_POOL:
+					case OP::OP_CALL:
+					case OP::OP_CALL__WRITE:
+						{
+							i.next(); // skip local ops
+							i.next(); // skip next opcode
+							// continue execution
+						}
+					case OP::OP_CONSTRUCT_OBJECT:
+					case OP::OP_CONSTRUCT_OBJECT__WRITE:
+					case OP::OP_VALUE:
+					case OP::OP_STRING__WRITE:
+					case OP::OP_VALUE__GET_CLASS:
+					case OP::OP_VALUE__GET_BASE_CLASS:
+#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_ELEMENT
+					case OP::OP_GET_OBJECT_ELEMENT:
+					case OP::OP_GET_OBJECT_ELEMENT__WRITE:
+#endif
+#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_VAR_ELEMENT
+					case OP::OP_GET_OBJECT_VAR_ELEMENT:
+					case OP::OP_GET_OBJECT_VAR_ELEMENT__WRITE:
+#endif
+#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT
+					case OP::OP_VALUE__GET_ELEMENT:
+					case OP::OP_VALUE__GET_ELEMENT__WRITE:
+					case OP::OP_VALUE__GET_ELEMENT_OR_OPERATOR:
+					case OP::OP_WITH_ROOT__VALUE__GET_ELEMENT:
+#endif
+#ifdef OPTIMIZE_BYTECODE_GET_SELF_ELEMENT
+					case OP::OP_WITH_SELF__VALUE__GET_ELEMENT:
+					case OP::OP_WITH_SELF__VALUE__GET_ELEMENT__WRITE:
+#endif
+
+#ifdef FEATURE_GET_ELEMENT4CALL
+					case OP::OP_GET_ELEMENT4CALL:
+#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_ELEMENT
+					case OP::OP_GET_OBJECT_ELEMENT4CALL:
+#endif
+#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_VAR_ELEMENT
+					case OP::OP_GET_OBJECT_VAR_ELEMENT4CALL:
+#endif
+#endif // FEATURE_GET_ELEMENT4CALL
+
+#ifdef OPTIMIZE_BYTECODE_CONSTRUCT
+					case OP::OP_WITH_ROOT__VALUE__CONSTRUCT_EXPR:
+					case OP::OP_WITH_ROOT__VALUE__CONSTRUCT_VALUE:
+					case OP::OP_WITH_WRITE__VALUE__CONSTRUCT_EXPR:
+					case OP::OP_WITH_WRITE__VALUE__CONSTRUCT_VALUE:
+					case OP::OP_WITH_SELF__VALUE__CONSTRUCT_EXPR:
+					case OP::OP_WITH_SELF__VALUE__CONSTRUCT_VALUE:
+#endif
+						{
+							origin=i.next().origin;
+							break;
+						}
+					default: break;
+				}
+				if(origin.file_no)
+					return get_used_filename(origin.file_no);
+			}
+		}
+	return 0;
+}
+