--- parser3/src/main/execute.C	2009/05/01 11:41:14	1.331
+++ parser3/src/main/execute.C	2009/05/23 05:55:04	1.339
@@ -5,7 +5,7 @@
 	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
 */
 
-static const char * const IDENT_EXECUTE_C="$Date: 2009/05/01 11:41:14 $";
+static const char * const IDENT_EXECUTE_C="$Date: 2009/05/23 05:55:04 $";
 
 #include "pa_opcode.h"
 #include "pa_array.h" 
@@ -46,6 +46,14 @@ char *opcode_name[]={
 	"GET_ELEMENT_OR_OPERATOR",
 #endif
 	"GET_ELEMENT",
+#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_ELEMENT
+	"GET_OBJECT_ELEMENT",
+	"GET_OBJECT_ELEMENT__WRITE",
+#endif
+#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_VAR_ELEMENT
+	"GET_OBJECT_VAR_ELEMENT",
+	"GET_OBJECT_VAR_ELEMENT__WRITE",
+#endif
 #ifdef OPTIMIZE_BYTECODE_GET_ELEMENT
 	"VALUE__GET_ELEMENT",
 #endif
@@ -57,6 +65,27 @@ char *opcode_name[]={
 	"PREPARE_TO_CONSTRUCT_OBJECT",	"PREPARE_TO_EXPRESSION", 
 	"CALL", "CALL__WRITE",
 
+#ifdef OPTIMIZE_BYTECODE_CONSTRUCT
+	"ROOT_CONSTRUCT_EXPR",
+	"ROOT_ELEMENT_CONSTRUCT_EXPR",
+	"ROOT_CALL_CONSTRUCT_EXPR",
+
+
+	"ROOT_CONSTRUCT_VALUE",
+	"ROOT_ELEMENT_CONSTRUCT_VALUE",
+	"ROOT_CALL_CONSTRUCT_VALUE",
+
+
+	"WRITE_CONSTRUCT_EXPR",
+	"WRITE_ELEMENT_CONSTRUCT_EXPR",
+	"WRITE_CALL_CONSTRUCT_EXPR",
+
+
+	"WRITE_CONSTRUCT_VALUE",
+	"WRITE_ELEMENT_CONSTRUCT_VALUE",
+	"WRITE_CALL_CONSTRUCT_VALUE",
+#endif
+
 	// expression ops: unary
 	"NEG", "INV", "NOT", "DEF", "IN", "FEXISTS", "DEXISTS",
 	// expression ops: binary
@@ -76,10 +105,10 @@ void va_debug_printf(SAPI_Info& sapi_inf
 }
 
 void debug_printf(SAPI_Info& sapi_info, const char* fmt, ...) {
-    va_list args;
-    va_start(args, fmt);
-    va_debug_printf(sapi_info, fmt, args);
-    va_end(args);
+	va_list args;
+	va_start(args, fmt);
+	va_debug_printf(sapi_info, fmt, args);
+	va_end(args);
 }
 
 void debug_dump(SAPI_Info& sapi_info, int level, ArrayOperation& ops) {
@@ -87,6 +116,47 @@ void debug_dump(SAPI_Info& sapi_info, in
 	while(i.has_next()) {
 		OP::OPCODE opcode=i.next().code;
 
+#if defined(OPTIMIZE_BYTECODE_GET_OBJECT_ELEMENT) || defined(OPTIMIZE_BYTECODE_GET_OBJECT_VAR_ELEMENT)
+		if(
+			1==0
+#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_ELEMENT
+			|| opcode==OP::OP_GET_OBJECT_ELEMENT
+			|| opcode==OP::OP_GET_OBJECT_ELEMENT__WRITE
+#endif
+#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_VAR_ELEMENT
+			|| opcode==OP::OP_GET_OBJECT_VAR_ELEMENT
+			|| opcode==OP::OP_GET_OBJECT_VAR_ELEMENT__WRITE
+#endif
+#ifdef OPTIMIZE_BYTECODE_CONSTRUCT
+			|| opcode==OP::OP_ROOT_CONSTRUCT_EXPR
+			|| opcode==OP::OP_ROOT_ELEMENT_CONSTRUCT_EXPR
+			|| opcode==OP::OP_ROOT_CALL_CONSTRUCT_EXPR
+
+			|| opcode==OP::OP_ROOT_CONSTRUCT_VALUE
+			|| opcode==OP::OP_ROOT_ELEMENT_CONSTRUCT_VALUE
+			|| opcode==OP::OP_ROOT_CALL_CONSTRUCT_VALUE
+
+			|| opcode==OP::OP_WRITE_CONSTRUCT_EXPR
+			|| opcode==OP::OP_WRITE_ELEMENT_CONSTRUCT_EXPR
+			|| opcode==OP::OP_WRITE_CALL_CONSTRUCT_EXPR
+
+			|| opcode==OP::OP_WRITE_CONSTRUCT_VALUE
+			|| opcode==OP::OP_WRITE_ELEMENT_CONSTRUCT_VALUE
+			|| opcode==OP::OP_WRITE_CALL_CONSTRUCT_VALUE
+#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],
+				value1.get_string()->cstr(), value2.get_string()->cstr());
+			continue;
+		}
+#endif
 		if(
 			opcode==OP::OP_VALUE
 			|| opcode==OP::OP_STRING__WRITE
@@ -124,8 +194,20 @@ void debug_dump(SAPI_Info& sapi_info, in
 		}
 	}
 }
+#define DEBUG_PRINT_STR(str) debug_printf(sapi_info, str);
+#define DEBUG_PRINT_STRING(value) debug_printf(sapi_info, " \"%s\" ", value.cstr());
+#define DEBUG_PRINT_OPS(local_ops) \
+					debug_printf(sapi_info, \
+					" (%d)\n", local_ops?local_ops->count():0); \
+					if(local_ops) debug_dump(sapi_info, 1, *local_ops);
+
+#else
+#define DEBUG_PRINT_STR(str)
+#define DEBUG_PRINT_STRING(value)
+#define DEBUG_PRINT_OPS(local_ops)
 #endif
 
+
 // Request
 
 void Request::execute(ArrayOperation& ops) {
@@ -141,6 +223,8 @@ void Request::execute(ArrayOperation& op
 	for(Array_iterator<Operation> i(ops); i.has_next(); ) {
 		OP::OPCODE opcode=i.next().code;
 
+		bool with_root=true;
+
 #ifdef DEBUG_EXECUTE
 		debug_printf(sapi_info, "%d:%s", stack.top_index()+1, opcode_name[opcode]);
 #endif
@@ -168,9 +252,7 @@ void Request::execute(ArrayOperation& op
 				Value& value=*i.next().value;
 				const String& name=*value.get_string();
 
-#ifdef DEBUG_EXECUTE
-				debug_printf(sapi_info, " \"%s\" ", name.cstr());
-#endif
+				DEBUG_PRINT_STRING(name)
 
 				Value* class_value=classes().get(name);
 				if(!class_value)
@@ -204,17 +286,17 @@ void Request::execute(ArrayOperation& op
 				stack.push(*method_frame);
 				break;
 			}
-		case OP::OP_WITH_SELF: 
+		case OP::OP_WITH_SELF:
 			{
 				stack.push(get_self());
 				break;
 			}
-		case OP::OP_WITH_READ: 
+		case OP::OP_WITH_READ:
 			{
 				stack.push(*rcontext);
 				break;
 			}
-		case OP::OP_WITH_WRITE: 
+		case OP::OP_WITH_WRITE:
 			{
 				if(wcontext==method_frame)
 					throw Exception(PARSER_RUNTIME,
@@ -235,6 +317,173 @@ void Request::execute(ArrayOperation& op
 
 				break;
 			}
+
+#ifdef OPTIMIZE_BYTECODE_CONSTRUCT
+		case OP::OP_WRITE_CONSTRUCT_EXPR:
+		case OP::OP_WRITE_CONSTRUCT_VALUE:
+			{
+				if(wcontext==method_frame)
+					throw Exception(PARSER_RUNTIME,
+						0,
+						"$.name outside of $name[...]");
+				with_root=false;
+				// don't stop here. continue in the next block
+			}
+
+		case OP::OP_ROOT_CONSTRUCT_EXPR:
+		case OP::OP_ROOT_CONSTRUCT_VALUE:
+			{
+				debug_origin=i.next().origin;
+				const String& name=*i.next().value->get_string();  debug_name=&name;
+
+				DEBUG_PRINT_STRING(name)
+
+				debug_origin=i.next().origin;
+				Value& value=*i.next().value;
+
+				if(
+					   opcode == OP::OP_WRITE_CONSTRUCT_EXPR
+					|| opcode == OP::OP_ROOT_CONSTRUCT_EXPR
+				){
+					wcontext->set_in_expression(true);
+					put_element( (with_root)?*method_frame:*wcontext, name, &value.as_expr_result());
+				} else {
+					put_element( (with_root)?*method_frame:*wcontext, name, value.is_void()?new VString():&value);
+				}
+				break;
+			}
+
+		case OP::OP_WRITE_ELEMENT_CONSTRUCT_EXPR:
+		case OP::OP_WRITE_ELEMENT_CONSTRUCT_VALUE:
+			{
+				if(wcontext==method_frame)
+					throw Exception(PARSER_RUNTIME,
+						0,
+						"$.name outside of $name[...]");
+				with_root=false;
+				// don't stop here. continue in the next block
+			}
+
+		case OP::OP_ROOT_ELEMENT_CONSTRUCT_EXPR:
+		case OP::OP_ROOT_ELEMENT_CONSTRUCT_VALUE:
+			{
+				debug_origin=i.next().origin;
+				const String& name=*i.next().value->get_string();  debug_name=&name;
+
+				DEBUG_PRINT_STRING(name)
+
+				debug_origin=i.next().origin;
+				const String& source_var_name=*i.next().value->get_string();  debug_name=&source_var_name;
+
+				DEBUG_PRINT_STRING(source_var_name)
+
+				Value& value=get_element(*rcontext, source_var_name);
+
+				if(
+					   opcode == OP::OP_WRITE_ELEMENT_CONSTRUCT_EXPR
+					|| opcode == OP::OP_ROOT_ELEMENT_CONSTRUCT_EXPR
+				){
+					wcontext->set_in_expression(true);
+					put_element( (with_root)?*method_frame:*wcontext, name, &value.as_expr_result());
+				} else {
+					put_element( (with_root)?*method_frame:*wcontext, name, value.is_void()?new VString():&value);
+				}
+				break;
+			}
+
+		case OP::OP_WRITE_CALL_CONSTRUCT_EXPR:
+		case OP::OP_WRITE_CALL_CONSTRUCT_VALUE:
+			{
+				if(wcontext==method_frame)
+					throw Exception(PARSER_RUNTIME,
+						0,
+						"$.name outside of $name[...]");
+				with_root=false;
+				// don't stop here. continue in the next block
+			}
+
+		case OP::OP_ROOT_CALL_CONSTRUCT_EXPR:
+		case OP::OP_ROOT_CALL_CONSTRUCT_VALUE:
+			{
+				debug_origin=i.next().origin;
+				const String& name=*i.next().value->get_string();  debug_name=&name;
+
+				DEBUG_PRINT_STRING(name)
+
+				debug_origin=i.next().origin;
+				const String& method_name=*i.next().value->get_string();  debug_name=&method_name;
+
+				DEBUG_PRINT_STRING(method_name)
+
+				Value* vjunction;
+				if(Method* method=main_class.get_method(method_name)){ // looking operator of that name FIRST
+					if(!method->junction_template)
+						method->junction_template=new VJunction(main_class, method);
+					vjunction=method->junction_template;
+				} else {
+					vjunction=&get_element(*rcontext, method_name);
+				}
+
+				// CALL
+				i.next(); // ignore OP_CALL|OP_CALL__WRITE, they are redundant...
+				ArrayOperation* local_ops=i.next().ops;
+
+				DEBUG_PRINT_OPS(local_ops)
+				DEBUG_PRINT_STR("->\n")
+
+				Junction* junction=vjunction->get_junction();
+				if(!junction) {
+					if(vjunction->is("void"))
+						throw Exception(PARSER_RUNTIME,
+							0,
+							"undefined method");
+					else
+						throw Exception(PARSER_RUNTIME,
+							0,
+							"is '%s', not a method or junction, can not call it",
+								vjunction->type());
+				}
+
+				VMethodFrame frame(*junction, method_frame);
+
+				if(local_ops){ // store param code goes here
+					size_t first = stack.top_index();
+					execute(*local_ops);
+					frame.store_params((Value**)stack.ptr(first), stack.top_index()-first);
+					op_call(frame);
+					stack.set_top_index(first);
+				} else {
+					frame.empty_params();
+					op_call(frame);
+				}
+
+				Value& value=frame.result().as_value();
+
+				DEBUG_PRINT_STR("<-returned")
+
+				if(
+					   opcode == OP::OP_WRITE_CALL_CONSTRUCT_EXPR
+					|| opcode == OP::OP_ROOT_CALL_CONSTRUCT_EXPR
+				){
+					wcontext->set_in_expression(true);
+					put_element( (with_root)?*method_frame:*wcontext, name, &value.as_expr_result());
+				} else {
+					put_element( (with_root)?*method_frame:*wcontext, name, &value);
+				}
+
+				if(get_skip())
+					return;
+				if(get_interrupted()) {
+					set_interrupted(false);
+					throw Exception("parser.interrupted",
+						0,
+						"execution stopped");
+				}
+
+				break;
+			}
+#endif // OPTIMIZE_BYTECODE_CONSTRUCT
+
 		case OP::OP_CONSTRUCT_EXPR:
 			{
 				// see OP_PREPARE_TO_EXPRESSION
@@ -247,13 +496,13 @@ void Request::execute(ArrayOperation& op
 				put_element(ncontext, name, &value);
 				break;
 			}
+
 		case OP::OP_CURLY_CODE__CONSTRUCT:
 			{
 				ArrayOperation& local_ops=*i.next().ops;
-#ifdef DEBUG_EXECUTE
-				debug_printf(sapi_info, " (%d)\n", local_ops.count());
-				debug_dump(sapi_info, 1, local_ops);
-#endif
+
+				DEBUG_PRINT_OPS((&local_ops))
+
 				VJunction& value=*new VJunction(
 					get_self(), 0,
 					method_frame, 
@@ -276,10 +525,9 @@ void Request::execute(ArrayOperation& op
 		case OP::OP_NESTED_CODE:
 			{
 				ArrayOperation& local_ops=*i.next().ops;
-#ifdef DEBUG_EXECUTE
-				debug_printf(sapi_info, " (%d)\n", local_ops.count());
-				debug_dump(sapi_info, 1, local_ops);
-#endif				
+
+				DEBUG_PRINT_OPS((&local_ops))
+
 				stack.push(local_ops);
 				break;
 			}
@@ -303,10 +551,12 @@ void Request::execute(ArrayOperation& op
 			{
 				i.next(); // ignore origin
 				Value* value=i.next().value;
-#ifdef DEBUG_EXECUTE
-				debug_printf(sapi_info, " \"%s\"", value->get_string()->cstr());
-#endif
-				write_no_lang(*value->get_string());
+
+				const String& string_value=*value->get_string();
+
+				DEBUG_PRINT_STRING(string_value)
+
+				write_no_lang(string_value);
 				break;
 			}
 
@@ -316,9 +566,8 @@ void Request::execute(ArrayOperation& op
 				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
+				DEBUG_PRINT_STRING(name)
+
 				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);
@@ -344,6 +593,66 @@ 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)
+
+				Value& value=get_element(object, field_name);
+
+				i.next(); // skip last OP_GET_ELEMENT
+
+				if(opcode==OP::OP_GET_OBJECT_ELEMENT){
+					stack.push(value);
+				} else {
+					write_assign_lang(value);
+				}
+				break;
+			}
+#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();
+
+				Value& value=get_element(object, *field);
+
+				i.next(); // skip last OP_GET_ELEMENT
+
+				if(opcode==OP::OP_GET_OBJECT_VAR_ELEMENT){
+					stack.push(value);
+				} else {
+					write_assign_lang(value);
+				}
+				break;
+			}
+#endif
+
 		case OP::OP_GET_ELEMENT:
 			{
 				const String& name=stack.pop().string();  debug_name=&name;
@@ -359,9 +668,7 @@ void Request::execute(ArrayOperation& op
 				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
+				DEBUG_PRINT_STRING(name)
 
 				Value& value=get_element(*rcontext, name);
 				stack.push(value);
@@ -385,9 +692,7 @@ void Request::execute(ArrayOperation& op
 				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
+				DEBUG_PRINT_STRING(name)
 
 				Value& value=get_element(*rcontext, name);
 				write_assign_lang(value);
@@ -442,10 +747,9 @@ void Request::execute(ArrayOperation& op
 			{
 				// code
 				ArrayOperation& local_ops=*i.next().ops;
-#ifdef DEBUG_EXECUTE
-				debug_printf(sapi_info, " (%d)\n", local_ops.count());
-				debug_dump(sapi_info, 1, local_ops);
-#endif				
+
+				DEBUG_PRINT_OPS((&local_ops))
+
 				// when they evaluate expression parameter,
 				// the object expression result
 				// does not need to be written into calling frame
@@ -466,7 +770,6 @@ void Request::execute(ArrayOperation& op
 #endif
 				wcontext->attach_junction(&value);
 				// store param
-				// this op is executed from CALL local_ops only, so can not check method_frame_to_fill==0
 				stack.push(value);
 				break;
 			}
@@ -484,17 +787,12 @@ void Request::execute(ArrayOperation& op
 			}
 
 		case OP::OP_CALL:
-		case OP::OP_CALL__WRITE:
 			{
-				//is_debug_junction=true;
 				ArrayOperation* local_ops=i.next().ops;
-#ifdef DEBUG_EXECUTE
-				debug_printf(sapi_info, " (%d)\n", local_ops?local_ops->count():0);
-				if(local_ops)
-					debug_dump(sapi_info, 1, *local_ops);
 
-				debug_printf(sapi_info, "->\n");
-#endif
+				DEBUG_PRINT_OPS(local_ops)
+				DEBUG_PRINT_STR("->\n")
+
 				Value& value=stack.pop().value();
 
 				Junction* junction=value.get_junction();
@@ -509,42 +807,109 @@ void Request::execute(ArrayOperation& op
 							"is '%s', not a method or junction, can not call it",
 								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,
-						"is '%s', it is code junction, can not call it",
-							value.type());
-				*/
 
 				VMethodFrame frame(*junction, method_frame);
-				WContext* result_wcontext;
 
 				if(local_ops){ // store param code goes here
 					size_t first = stack.top_index();
 					execute(*local_ops);
 					frame.store_params((Value**)stack.ptr(first), stack.top_index()-first);
-					result_wcontext=op_call(frame);
+					op_call(frame);
 					stack.set_top_index(first);
 				} else {
 					frame.empty_params();
-					result_wcontext=op_call(frame);
+					op_call(frame);
 				}
 
-				if(opcode==OP::OP_CALL__WRITE) {
-					write_assign_lang(result_wcontext->result());
-				} else { // OP_CALL
-					stack.push(result_wcontext->result().as_value());
+				stack.push(frame.result().as_value());
+
+				DEBUG_PRINT_STR("<-returned")
+
+				if(get_skip())
+					return;
+				if(get_interrupted()) {
+					set_interrupted(false);
+					throw Exception("parser.interrupted",
+						0,
+						"execution stopped");
 				}
+				break;
+			}
 
-#ifdef DEBUG_EXECUTE
-				debug_printf(sapi_info, "<-returned");
-#endif
-				//is_debug_junction=false;
+		case OP::OP_CALL__WRITE:
+			{
+				ArrayOperation* local_ops=i.next().ops;
+
+				DEBUG_PRINT_OPS(local_ops)
+				DEBUG_PRINT_STR("->\n")
+
+				Value& value=stack.pop().value();
+
+				Junction* junction=value.get_junction();
+				if(!junction) {
+					if(value.is("void"))
+						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());
+				}
+
+#ifdef OPTIMIZE_CALL
+				const Method& method=*junction->method;
+				if (!wcontext->get_constructing() && method.call_optimization==Method::CO_WITHOUT_FRAME){
+					if(local_ops){ // store param code goes here
+						size_t first = stack.top_index();
+						execute(*local_ops);
+
+						MethodParams method_params;
+						method_params.store_params((Value**)stack.ptr(first), stack.top_index()-first);
+						method.check_actual_numbered_params(junction->self, &method_params);
+						method.native_code(*this, method_params); // execute it
+
+						stack.set_top_index(first);
+					} else {
+						MethodParams method_params;
+						method.check_actual_numbered_params(junction->self, &method_params);
+						method.native_code(*this, method_params); // execute it
+					}
+				} else if (!wcontext->get_constructing() && method.call_optimization==Method::CO_WITHOUT_WCONTEXT){
+					VMethodFrame frame(*junction, method_frame);
+					if(local_ops){ // store param code goes here
+						size_t first = stack.top_index();
+						execute(*local_ops);
+
+						frame.store_params((Value**)stack.ptr(first), stack.top_index()-first);
+						op_call_write(frame);
+
+						stack.set_top_index(first);
+					} else {
+						frame.empty_params();
+						op_call_write(frame);
+					}
+				} else 
+#endif // OPTIMIZE_CALL
+				{
+					VMethodFrame frame(*junction, method_frame);
+					if(local_ops){ // store param code goes here
+						size_t first = stack.top_index();
+						execute(*local_ops);
+
+						frame.store_params((Value**)stack.ptr(first), stack.top_index()-first);
+						op_call(frame);
+
+						stack.set_top_index(first);
+					} else {
+						frame.empty_params();
+						op_call(frame);
+					}
+					write_assign_lang(frame.result());
+				}
+
+				DEBUG_PRINT_STR("<-returned")
 
 				if(get_skip())
 					return;
@@ -888,20 +1253,18 @@ void Request::execute(ArrayOperation& op
 	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();
+void Request::op_call(VMethodFrame& frame){
+	const Junction &junction=frame.junction;
+	VStateless_class& called_class=*junction.self.get_class();
 	Value* new_self;
+
 	if(wcontext->get_constructing()) {
 		wcontext->set_constructing(false);
-		new_self=&get_self();
-		if(frame.junction.method->call_type!=Method::CT_STATIC) {
+		if(junction.method->call_type!=Method::CT_STATIC) {
 			// this is a constructor call
 			HashStringValue& new_object_fields=*new HashStringValue();
-			if(Value* value=called_class.create_new_value(fpool, new_object_fields)) {
+			if(new_self=called_class.create_new_value(fpool, new_object_fields)) {
 				// some stateless_class creatable derivates
-				new_self=value;
 			} else 
 				throw Exception(PARSER_RUNTIME,
 					0, //&frame.name(),
@@ -915,49 +1278,69 @@ WContext* Request::op_call(VMethodFrame&
 			throw Exception(PARSER_RUNTIME,
 				0, //&frame.name(),
 				"method is static and can not be used as constructor");
-	} else
-		new_self=&frame.junction.self;
+	} else 
+		new_self=&junction.self;
 
 	frame.set_self(*new_self);
 
 	// see OP_PREPARE_TO_EXPRESSION
 	frame.set_in_expression(wcontext->get_in_expression());
 				
+	SAVE_CONTEXT
+
 	rcontext=wcontext=&frame;
-	{
-		const Method& method=*frame.junction.method;
-		Method::Call_type call_type=&called_class==new_self ? Method::CT_STATIC : Method::CT_DYNAMIC;
-		if(
-			method.call_type==Method::CT_ANY ||
-			method.call_type==call_type) { // allowed call type?
-			method_frame=&frame;
-			if(method.native_code) { // native code?
-				method.check_actual_numbered_params(
-					frame.junction.self, 
-					/*frame.name(), */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, //&frame.name(),
-				"is not allowed to be called %s", 
-					call_type==Method::CT_STATIC?"statically":"dynamically");
-	}
+	method_frame=&frame;
 
-	WContext *result_wcontext=wcontext;
-	// StringOrValue result=wcontext->result();
+	const Method& method=*junction.method;
+	Method::Call_type call_type=&called_class==new_self ? Method::CT_STATIC : Method::CT_DYNAMIC;
 
-	RESTORE_CONTEXT
+	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.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");
 
-	return result_wcontext;
+	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;
+
+	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.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");
+	
+	rcontext=saved_rcontext;
+	method_frame=saved_method_frame;
+}
 
 /**
-	@todo cache|prepare junctions
 	@bug ^superbase:method would dynamically call ^base:method if there is any
 */
 Value& Request::get_element(Value& ncontext, const String& name) {
@@ -1025,7 +1408,7 @@ void Request::put_element(Value& ncontex
 		nothing goes to wcontext.
 		used in @c (expression) params evaluation
 
-    using the fact it's either string_ or value_ result requested to speed up checkes
+	using the fact it's either string_ or value_ result requested to speed up checkes
 */
 StringOrValue Request::process(Value& input_value, bool intercept_string) {
 	Junction* junction=input_value.get_junction();
@@ -1067,9 +1450,8 @@ StringOrValue Request::process(Value& in
 		if(junction->code) { // is it a code-junction?
 			// process it
 			StringOrValue result;
-#ifdef DEBUG_EXECUTE
-			debug_printf(sapi_info, "ja->\n");
-#endif
+
+			DEBUG_PRINT_STR("ja->\n")
 
 			if(!junction->method_frame)
 				throw Exception(PARSER_RUNTIME,
@@ -1109,9 +1491,8 @@ StringOrValue Request::process(Value& in
 
 			RESTORE_CONTEXT
 
-#ifdef DEBUG_EXECUTE
-			debug_printf(sapi_info, "<-ja returned");
-#endif
+			DEBUG_PRINT_STR("<-ja returned")
+
 			return result;
 		}
 
@@ -1122,6 +1503,101 @@ StringOrValue Request::process(Value& in
 	return input_value;
 }
 
+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*/);
+			int param_count=frame.method_params_count();
+
+			if(param_count){
+				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);
+
+			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;
+		}
+
+		if(junction->code) { // is it a code-junction?
+							// process it
+
+			DEBUG_PRINT_STR("ja->\n")
+
+			if(!junction->method_frame)
+				throw Exception(PARSER_RUNTIME,
+					0,
+					"junction used outside of context");
+
+			SAVE_CONTEXT
+
+			method_frame=junction->method_frame;
+			rcontext=junction->rcontext;
+
+			// for expression method params
+			// wcontext is set 0
+			// using the fact in decision "which wwrapper to use"
+#ifdef OPTIMIZE_CALL
+			if(wcontext==junction->wcontext){
+				// no wrappers for wcontext
+				recoursion_checked_execute(*junction->code);
+				RESTORE_CONTEXT
+
+			} else
+#endif
+			if(junction->wcontext) {
+				// almost plain wwrapper about junction wcontext 
+				VCodeFrame local(*junction->wcontext);
+				wcontext=&local;
+
+				// execute it
+				recoursion_checked_execute(*junction->code);
+				RESTORE_CONTEXT
+				write_pass_lang(local.result());
+			} else {
+				// plain wwrapper
+				WWrapper local(0/*empty*/, wcontext);
+				wcontext=&local;
+
+				// execute it
+				recoursion_checked_execute(*junction->code);
+				RESTORE_CONTEXT
+				write_pass_lang(local.result());
+			}
+
+			DEBUG_PRINT_STR("<-ja returned")
+
+			return;
+		}
+
+		// it is then method-junction, do not explode it
+		// just return it as we do for usual objects
+	}
+
+	write_pass_lang(input_value);
+}
+
 StringOrValue Request::execute_method(VMethodFrame& amethod_frame, const Method& method) {
 	SAVE_CONTEXT