--- parser3/src/main/execute.C	2008/05/30 12:27:05	1.319
+++ parser3/src/main/execute.C	2009/05/01 11:41:14	1.331
@@ -1,11 +1,11 @@
 /** @file
 	Parser: executor part of request class.
 
-	Copyright (c) 2001-2005 ArtLebedev Group (http://www.artlebedev.com)
+	Copyright (c) 2001-2009 ArtLebedev Group (http://www.artlebedev.com)
 	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
 */
 
-static const char * const IDENT_EXECUTE_C="$Date: 2008/05/30 12:27:05 $";
+static const char * const IDENT_EXECUTE_C="$Date: 2009/05/01 11:41:14 $";
 
 #include "pa_opcode.h"
 #include "pa_array.h" 
@@ -14,8 +14,7 @@ static const char * const IDENT_EXECUTE_
 #include "pa_vhash.h"
 #include "pa_vvoid.h"
 #include "pa_vcode_frame.h"
-#include "pa_vmethod_frame_local.h"
-#include "pa_vmethod_frame_global.h"
+#include "pa_vmethod_frame.h"
 #include "pa_vobject.h"
 #include "pa_vdouble.h"
 #include "pa_vbool.h"
@@ -34,12 +33,27 @@ char *opcode_name[]={
 
 	// actions
 	"WITH_ROOT",	"WITH_SELF",	"WITH_READ",	"WITH_WRITE",
+#ifdef OPTIMIZE_BYTECODE_GET_CLASS
+	"VALUE__GET_CLASS",
+#else
 	"GET_CLASS",
+#endif
 	"CONSTRUCT_VALUE", "CONSTRUCT_EXPR", "CURLY_CODE__CONSTRUCT",
 	"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",
-	"STORE_PARAM",
 	"PREPARE_TO_CONSTRUCT_OBJECT",	"PREPARE_TO_EXPRESSION", 
 	"CALL", "CALL__WRITE",
 
@@ -71,9 +85,20 @@ void debug_printf(SAPI_Info& sapi_info,
 void debug_dump(SAPI_Info& sapi_info, int level, ArrayOperation& ops) {
 	Array_iterator<Operation> i(ops);
 	while(i.has_next()) {
-		OPCODE opcode=i.next().code;
+		OP::OPCODE opcode=i.next().code;
 
-		if(opcode==OP_VALUE || opcode==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;
 			Value& value=*i.next().value;
 			debug_printf(sapi_info, 
@@ -86,14 +111,14 @@ void debug_dump(SAPI_Info& sapi_info, in
 		debug_printf(sapi_info, "%*s%s", level*4, "", opcode_name[opcode]);
 
 		switch(opcode) {
-		case OP_CURLY_CODE__STORE_PARAM: 
-		case OP_EXPR_CODE__STORE_PARAM:
-		case OP_CURLY_CODE__CONSTRUCT:
-		case OP_NESTED_CODE:
-		case OP_OBJECT_POOL:  
-		case OP_STRING_POOL:
-		case OP_CALL:
-		case OP_CALL__WRITE:
+		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:
 			if(ArrayOperation* local_ops=i.next().ops)
 				debug_dump(sapi_info, level+1, *local_ops);
 		}
@@ -114,15 +139,7 @@ void Request::execute(ArrayOperation& op
 	debug_printf(sapi_info, "execution-------------------------\n");
 #endif
 	for(Array_iterator<Operation> i(ops); i.has_next(); ) {
-		if(get_skip())
-			return;
-		if(get_interrupted()) {
-			set_interrupted(false);
-			throw Exception("parser.interrupted",
-				0,
-				"execution stopped");
-		}
-		OPCODE opcode=i.next().code;
+		OP::OPCODE opcode=i.next().code;
 
 #ifdef DEBUG_EXECUTE
 		debug_printf(sapi_info, "%d:%s", stack.top_index()+1, opcode_name[opcode]);
@@ -130,7 +147,7 @@ void Request::execute(ArrayOperation& op
 
 		switch(opcode) {
 		// param in next instruction
-		case OP_VALUE:
+		case OP::OP_VALUE:
 			{
 				debug_origin=i.next().origin;
 				Value& value=*i.next().value;
@@ -140,7 +157,32 @@ void Request::execute(ArrayOperation& op
 				stack.push(value);
 				break;
 			}
-		case OP_GET_CLASS:
+
+#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:
 			{
 				// maybe they do ^class:method[] call, remember the fact
 				wcontext->set_somebody_entered_some_class();
@@ -155,24 +197,24 @@ void Request::execute(ArrayOperation& op
 				stack.push(*value);
 				break;
 			}
-			
+#endif
 		// OP_WITH
-		case OP_WITH_ROOT:
+		case OP::OP_WITH_ROOT:
 			{
 				stack.push(*method_frame);
 				break;
 			}
-		case OP_WITH_SELF: 
+		case OP::OP_WITH_SELF: 
 			{
 				stack.push(get_self());
 				break;
 			}
-		case OP_WITH_READ: 
+		case OP::OP_WITH_READ: 
 			{
 				stack.push(*rcontext);
 				break;
 			}
-		case OP_WITH_WRITE: 
+		case OP::OP_WITH_WRITE: 
 			{
 				if(wcontext==method_frame)
 					throw Exception(PARSER_RUNTIME,
@@ -184,16 +226,16 @@ void Request::execute(ArrayOperation& op
 			}
 			
 		// OTHER ACTIONS BUT WITHs
-		case OP_CONSTRUCT_VALUE:
+		case OP::OP_CONSTRUCT_VALUE:
 			{
 				Value& value=stack.pop().value();
 				const String& name=stack.pop().string();  debug_name=&name;
 				Value& ncontext=stack.pop().value();
-				put_element(ncontext, name, value);
+				put_element(ncontext, name, &value);
 
 				break;
 			}
-		case OP_CONSTRUCT_EXPR:
+		case OP::OP_CONSTRUCT_EXPR:
 			{
 				// see OP_PREPARE_TO_EXPRESSION
 				wcontext->set_in_expression(false);
@@ -202,23 +244,25 @@ void Request::execute(ArrayOperation& op
 				const String& name=stack.pop().string();  debug_name=&name;
 				Value& ncontext=stack.pop().value();
 				Value& value=expr.as_expr_result();
-				put_element(ncontext, name, value);
+				put_element(ncontext, name, &value);
 				break;
 			}
-		case OP_CURLY_CODE__CONSTRUCT:
+		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				
-				Value& value=*new VJunction(
+#endif
+				VJunction& value=*new VJunction(
 					get_self(), 0,
 					method_frame, 
 					rcontext, 
 					wcontext, 
 					&local_ops);
 
+				wcontext->attach_junction(&value);
+
 				const String& name=stack.pop().string();  debug_name=&name;
 				Value& ncontext=stack.pop().value();
 				if(const VJunction* vjunction=ncontext.put_element(ncontext, name, &value, false))
@@ -229,7 +273,7 @@ void Request::execute(ArrayOperation& op
 					
 				break;
 			}
-		case OP_NESTED_CODE:
+		case OP::OP_NESTED_CODE:
 			{
 				ArrayOperation& local_ops=*i.next().ops;
 #ifdef DEBUG_EXECUTE
@@ -239,13 +283,13 @@ void Request::execute(ArrayOperation& op
 				stack.push(local_ops);
 				break;
 			}
-		case OP_WRITE_VALUE:
+		case OP::OP_WRITE_VALUE:
 			{
 				Value& value=stack.pop().value();
 				write_assign_lang(value);
 				break;
 			}
-		case OP_WRITE_EXPR_RESULT:
+		case OP::OP_WRITE_EXPR_RESULT:
 			{
 				Value& value=stack.pop().value();
 				write_no_lang(value.as_expr_result());
@@ -255,7 +299,7 @@ void Request::execute(ArrayOperation& op
 				wcontext->set_in_expression(false);
 				break;
 			}
-		case OP_STRING__WRITE:
+		case OP::OP_STRING__WRITE:
 			{
 				i.next(); // ignore origin
 				Value* value=i.next().value;
@@ -265,35 +309,93 @@ void Request::execute(ArrayOperation& op
 				write_no_lang(*value->get_string());
 				break;
 			}
-			
-		case OP_GET_ELEMENT_OR_OPERATOR:
+
+#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:
 			{
 				const String& name=stack.pop().string();  debug_name=&name;
 				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);
 				break;
 			}
-		case OP_GET_ELEMENT:
+#endif
+
+		case OP::OP_GET_ELEMENT:
 			{
 				const String& name=stack.pop().string();  debug_name=&name;
 				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);
 				break;
 			}
+#endif
+
 
-		case OP_GET_ELEMENT__WRITE:
+		case OP::OP_GET_ELEMENT__WRITE:
 			{
 				const String& name=stack.pop().string();  debug_name=&name;
 				Value& ncontext=stack.pop().value();
-				Value& value=get_element(ncontext, name, false);
+				Value& value=get_element(ncontext, name);
 				write_assign_lang(value);
 				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_OBJECT_POOL:
+		case OP::OP_OBJECT_POOL:
 			{
 				ArrayOperation& local_ops=*i.next().ops;
 				
@@ -311,7 +413,7 @@ void Request::execute(ArrayOperation& op
 				break;
 			}
 			
-		case OP_STRING_POOL:
+		case OP::OP_STRING_POOL:
 			{
 				ArrayOperation& local_ops=*i.next().ops;
 
@@ -327,7 +429,7 @@ void Request::execute(ArrayOperation& op
 				if(const String* string=wcontext->get_string())
 					value=new VString(*string);
 				else
-					value=new VVoid;
+					value=VVoid::get();
 				stack.push(*value);
 
 				wcontext=saved_wcontext;
@@ -335,20 +437,11 @@ void Request::execute(ArrayOperation& op
 			}
 
 		// CALL
-		case 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_CURLY_CODE__STORE_PARAM:
-		case OP_EXPR_CODE__STORE_PARAM:
+		case OP::OP_CURLY_CODE__STORE_PARAM:
+		case OP::OP_EXPR_CODE__STORE_PARAM:
 			{
 				// code
 				ArrayOperation& local_ops=*i.next().ops;
-				VMethodFrame& frame=stack.top_value().method_frame();
 #ifdef DEBUG_EXECUTE
 				debug_printf(sapi_info, " (%d)\n", local_ops.count());
 				debug_dump(sapi_info, 1, local_ops);
@@ -360,32 +453,38 @@ void Request::execute(ArrayOperation& op
 				// hence, we zero junction.wcontext here, and later
 				// in .process we would test that field 
 				// in decision "which wwrapper to use"
-				Value& value=*new VJunction(
+				VJunction& value=*new VJunction(
 					get_self(), 0,
 					method_frame, 
 					rcontext, 
-					opcode==OP_EXPR_CODE__STORE_PARAM?0:wcontext, 
+					opcode==OP::OP_EXPR_CODE__STORE_PARAM?0:wcontext, 
 					&local_ops);
+#ifdef USE_DESTRUCTORS
+				value.set_temporal(true);
+#else
+				if (opcode!=OP::OP_EXPR_CODE__STORE_PARAM)
+#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
-				frame.store_param(value);
+				stack.push(value);
 				break;
 			}
 
-		case OP_PREPARE_TO_CONSTRUCT_OBJECT:
+		case OP::OP_PREPARE_TO_CONSTRUCT_OBJECT:
 			{
 				wcontext->set_constructing(true);
 				break;
 			}
 
-		case OP_PREPARE_TO_EXPRESSION:
+		case OP::OP_PREPARE_TO_EXPRESSION:
 			{
 				wcontext->set_in_expression(true);
 				break;
 			}
 
-		case OP_CALL:
-		case OP_CALL__WRITE:
+		case OP::OP_CALL:
+		case OP::OP_CALL__WRITE:
 			{
 				//is_debug_junction=true;
 				ArrayOperation* local_ops=i.next().ops;
@@ -422,116 +521,117 @@ void Request::execute(ArrayOperation& op
 							value.type());
 				*/
 
-				if(junction->method->all_vars_local){
-					VMethodFrameLocal frame(*junction, method_frame);
-					if(local_ops){ // store param code goes here
-						stack.push(frame); // argument for *STORE_PARAM ops
-						execute(*local_ops);
-						stack.pop().value();
-					}
-					WContext* result_wcontext=op_call(frame);
-					if(opcode==OP_CALL__WRITE) {
-						write_assign_lang(result_wcontext->result());
-					} else { // OP_CALL
-						stack.push(result_wcontext->result().as_value());
-					}
+				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);
+					stack.set_top_index(first);
 				} else {
-					VMethodFrameGlobal frame(*junction, method_frame);
-					if(local_ops){ // store param code goes here
-						stack.push(frame); // argument for *STORE_PARAM ops
-						execute(*local_ops);
-						stack.pop().value();
-					}
-					WContext* result_wcontext=op_call(frame);
-					if(opcode==OP_CALL__WRITE) {
-						write_assign_lang(result_wcontext->result());
-					} else { // OP_CALL
-						stack.push(result_wcontext->result().as_value());
-					}
+					frame.empty_params();
+					result_wcontext=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());
 				}
 
 #ifdef DEBUG_EXECUTE
 				debug_printf(sapi_info, "<-returned");
 #endif
 				//is_debug_junction=false;
+
+				if(get_skip())
+					return;
+				if(get_interrupted()) {
+					set_interrupted(false);
+					throw Exception("parser.interrupted",
+						0,
+						"execution stopped");
+				}
 				break;
 			}
 
 		// expression ops: unary
-		case OP_NEG:
+		case OP::OP_NEG:
 			{
 				Value& a=stack.pop().value();
 				Value& value=*new VDouble(-a.as_double());
 				stack.push(value);
 				break;
 			}
-		case OP_INV:
+		case OP::OP_INV:
 			{
 				Value& a=stack.pop().value();
 				Value& value=*new VDouble(~a.as_int());
 				stack.push(value);
 				break;
 			}
-		case OP_NOT:
+		case OP::OP_NOT:
 			{
 				Value& a=stack.pop().value();
-				Value& value=*new VBool(!a.as_bool());
+				Value& value=VBool::get(!a.as_bool());
 				stack.push(value);
 				break;
 			}
-		case OP_DEF:
+		case OP::OP_DEF:
 			{
 				Value& a=stack.pop().value();
-				Value& value=*new VBool(a.is_defined());
+				Value& value=VBool::get(a.is_defined());
 				stack.push(value);
 				break;
 			}
-		case OP_IN:
+		case OP::OP_IN:
 			{
 				Value& a=stack.pop().value();
 				const String& path=a.as_string();
-				Value& value=*new VBool(request_info.uri && *request_info.uri && path.this_starts(request_info.uri));
+				Value& value=VBool::get(request_info.uri && *request_info.uri && path.this_starts(request_info.uri));
 				stack.push(value);
 				break;
 			}
-		case OP_FEXISTS:
+		case OP::OP_FEXISTS:
 			{
 				Value& a=stack.pop().value();
-				Value& value=*new VBool(file_exist(absolute(a.as_string())));
+				Value& value=VBool::get(file_exist(absolute(a.as_string())));
 				stack.push(value);
 				break;
 			}
-		case OP_DEXISTS:
+		case OP::OP_DEXISTS:
 			{
 				Value& a=stack.pop().value();
-				Value& value=*new VBool(dir_exists(absolute(a.as_string())));
+				Value& value=VBool::get(dir_exists(absolute(a.as_string())));
 				stack.push(value);
 				break;
 			}
 
 		// expression ops: binary
-		case OP_SUB: 
+		case OP::OP_SUB: 
 			{
 				Value& b=stack.pop().value();  Value& a=stack.pop().value();
 				Value& value=*new VDouble(a.as_double() - b.as_double());
 				stack.push(value);
 				break;
 			}
-		case OP_ADD: 
+		case OP::OP_ADD: 
 			{
 				Value& b=stack.pop().value();  Value& a=stack.pop().value();
 				Value& value=*new VDouble(a.as_double() + b.as_double());
 				stack.push(value);
 				break;
 			}
-		case OP_MUL: 
+		case OP::OP_MUL: 
 			{
 				Value& b=stack.pop().value();  Value& a=stack.pop().value();
 				Value& value=*new VDouble(a.as_double() * b.as_double());
 				stack.push(value);
 				break;
 			}
-		case OP_DIV: 
+		case OP::OP_DIV: 
 			{
 				Value& b=stack.pop().value();  Value& a=stack.pop().value();
 
@@ -549,7 +649,7 @@ void Request::execute(ArrayOperation& op
 				stack.push(value);
 				break;
 			}
-		case OP_MOD: 
+		case OP::OP_MOD: 
 			{
 				Value& b=stack.pop().value();  Value& a=stack.pop().value();
 
@@ -567,7 +667,7 @@ void Request::execute(ArrayOperation& op
 				stack.push(value);
 				break;
 			}
-		case OP_INTDIV:
+		case OP::OP_INTDIV:
 			{
 				Value& b=stack.pop().value();  Value& a=stack.pop().value();
 
@@ -585,7 +685,7 @@ void Request::execute(ArrayOperation& op
 				stack.push(value);
 				break;
 			}
-		case OP_BIN_SL:
+		case OP::OP_BIN_SL:
 			{
 				Value& b=stack.pop().value();  Value& a=stack.pop().value();
 				Value& value=*new VInt(
@@ -594,7 +694,7 @@ void Request::execute(ArrayOperation& op
 				stack.push(value);
 				break;
 			}
-		case OP_BIN_SR:
+		case OP::OP_BIN_SR:
 			{
 				Value& b=stack.pop().value();  Value& a=stack.pop().value();
 				Value& value=*new VInt(
@@ -603,7 +703,7 @@ void Request::execute(ArrayOperation& op
 				stack.push(value);
 				break;
 			}
-		case OP_BIN_AND:
+		case OP::OP_BIN_AND:
 			{
 				Value& b=stack.pop().value();  Value& a=stack.pop().value();
 				Value& value=*new VInt(
@@ -612,7 +712,7 @@ void Request::execute(ArrayOperation& op
 				stack.push(value);
 				break;
 			}
-		case OP_BIN_OR:
+		case OP::OP_BIN_OR:
 			{
 				Value& b=stack.pop().value();  Value& a=stack.pop().value();
 				Value& value=*new VInt(
@@ -621,7 +721,7 @@ void Request::execute(ArrayOperation& op
 				stack.push(value);
 				break;
 			}
-		case OP_BIN_XOR:
+		case OP::OP_BIN_XOR:
 			{
 				Value& b=stack.pop().value();  Value& a=stack.pop().value();
 				Value& value=*new VInt(
@@ -630,7 +730,7 @@ void Request::execute(ArrayOperation& op
 				stack.push(value);
 				break;
 			}
-		case OP_LOG_AND:
+		case OP::OP_LOG_AND:
 			{
 				ArrayOperation& local_ops=stack.pop().ops();  Value& a=stack.pop().value();
 				bool result;
@@ -640,11 +740,11 @@ void Request::execute(ArrayOperation& op
 					result=b.as_bool();
 				} else
 					result=false;
-				Value& value=*new VBool(result);
+				Value& value=VBool::get(result);
 				stack.push(value);
 				break;
 			}
-		case OP_LOG_OR:
+		case OP::OP_LOG_OR:
 			{
 				ArrayOperation& local_ops=stack.pop().ops();  Value& a=stack.pop().value();
 				bool result;
@@ -655,111 +755,111 @@ void Request::execute(ArrayOperation& op
 					Value& b=stack.pop().value();
 					result=b.as_bool();
 				}
-				Value& value=*new VBool(result);
+				Value& value=VBool::get(result);
 				stack.push(value);
 				break;
 			}
-		case OP_LOG_XOR:
+		case OP::OP_LOG_XOR:
 			{
 				Value& b=stack.pop().value();  Value& a=stack.pop().value();
-				Value& value=*new VBool(a.as_bool() ^ b.as_bool());
+				Value& value=VBool::get(a.as_bool() ^ b.as_bool());
 				stack.push(value);
 				break;
 			}
-		case OP_NUM_LT: 
+		case OP::OP_NUM_LT: 
 			{
 				volatile double b_double=stack.pop().value().as_double();
 				volatile double a_double=stack.pop().value().as_double();
-				Value& value=*new VBool(a_double<b_double);
+				Value& value=VBool::get(a_double<b_double);
 				stack.push(value);
 				break;
 			}
-		case OP_NUM_GT: 
+		case OP::OP_NUM_GT: 
 			{
 				volatile double b_double=stack.pop().value().as_double();
 				volatile double a_double=stack.pop().value().as_double();
-				Value& value=*new VBool(a_double>b_double);
+				Value& value=VBool::get(a_double>b_double);
 				stack.push(value);
 				break;
 			}
-		case OP_NUM_LE: 
+		case OP::OP_NUM_LE: 
 			{
 				volatile double b_double=stack.pop().value().as_double();
 				volatile double a_double=stack.pop().value().as_double();
-				Value& value=*new VBool(a_double<=b_double);
+				Value& value=VBool::get(a_double<=b_double);
 				stack.push(value);
 				break;
 			}
-		case OP_NUM_GE: 
+		case OP::OP_NUM_GE: 
 			{
 				volatile double b_double=stack.pop().value().as_double();
 				volatile double a_double=stack.pop().value().as_double();
-				Value& value=*new VBool(a_double>=b_double);
+				Value& value=VBool::get(a_double>=b_double);
 				stack.push(value);
 				break;
 			}
-		case OP_NUM_EQ: 
+		case OP::OP_NUM_EQ: 
 			{
 				volatile double b_double=stack.pop().value().as_double();
 				volatile double a_double=stack.pop().value().as_double();
-				Value& value=*new VBool(a_double==b_double);
+				Value& value=VBool::get(a_double==b_double);
 				stack.push(value);
 				break;
 			}
-		case OP_NUM_NE: 
+		case OP::OP_NUM_NE: 
 			{
 				volatile double b_double=stack.pop().value().as_double();
 				volatile double a_double=stack.pop().value().as_double();
-				Value& value=*new VBool(a_double!=b_double);
+				Value& value=VBool::get(a_double!=b_double);
 				stack.push(value);
 				break;
 			}
-		case OP_STR_LT: 
+		case OP::OP_STR_LT: 
 			{
 				Value& b=stack.pop().value();  Value& a=stack.pop().value();
-				Value& value=*new VBool(a.as_string() < b.as_string());
+				Value& value=VBool::get(a.as_string() < b.as_string());
 				stack.push(value);
 				break;
 			}
-		case OP_STR_GT: 
+		case OP::OP_STR_GT: 
 			{
 				Value& b=stack.pop().value();  Value& a=stack.pop().value();
-				Value& value=*new VBool(a.as_string() > b.as_string());
+				Value& value=VBool::get(a.as_string() > b.as_string());
 				stack.push(value);
 				break;
 			}
-		case OP_STR_LE: 
+		case OP::OP_STR_LE: 
 			{
 				Value& b=stack.pop().value();  Value& a=stack.pop().value();
-				Value& value=*new VBool(a.as_string() <= b.as_string());
+				Value& value=VBool::get(a.as_string() <= b.as_string());
 				stack.push(value);
 				break;
 			}
-		case OP_STR_GE: 
+		case OP::OP_STR_GE: 
 			{
 				Value& b=stack.pop().value();  Value& a=stack.pop().value();
-				Value& value=*new VBool(a.as_string() >= b.as_string());
+				Value& value=VBool::get(a.as_string() >= b.as_string());
 				stack.push(value);
 				break;
 			}
-		case OP_STR_EQ: 
+		case OP::OP_STR_EQ: 
 			{
 				Value& b=stack.pop().value();  Value& a=stack.pop().value();
-				Value& value=*new VBool(a.as_string() == b.as_string());
+				Value& value=VBool::get(a.as_string() == b.as_string());
 				stack.push(value);
 				break;
 			}
-		case OP_STR_NE: 
+		case OP::OP_STR_NE: 
 			{
 				Value& b=stack.pop().value();  Value& a=stack.pop().value();
-				Value& value=*new VBool(a.as_string() != b.as_string());
+				Value& value=VBool::get(a.as_string() != b.as_string());
 				stack.push(value);
 				break;
 			}
-		case OP_IS:
+		case OP::OP_IS:
 			{
 				Value& b=stack.pop().value();  Value& a=stack.pop().value();
-				Value& value=*new VBool(a.is(b.as_string().cstr()));
+				Value& value=VBool::get(a.is(b.as_string().cstr()));
 				stack.push(value);
 				break;
 			}
@@ -778,11 +878,18 @@ void Request::execute(ArrayOperation& op
 	}
 }
 
-WContext* Request::op_call(VMethodFrame& frame){
-	frame.fill_unspecified_params();
-	VMethodFrame *saved_method_frame=method_frame;
-	Value* saved_rcontext=rcontext;
+#define SAVE_CONTEXT								\
+	VMethodFrame *saved_method_frame=method_frame;	\
+	Value* saved_rcontext=rcontext;					\
 	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();
 	Value* new_self;
@@ -843,9 +950,7 @@ WContext* Request::op_call(VMethodFrame&
 	WContext *result_wcontext=wcontext;
 	// StringOrValue result=wcontext->result();
 
-	wcontext=saved_wcontext;
-	rcontext=saved_rcontext;
-	method_frame=saved_method_frame;
+	RESTORE_CONTEXT
 
 	return result_wcontext;
 }
@@ -855,66 +960,48 @@ WContext* Request::op_call(VMethodFrame&
 	@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, bool can_call_operator) {
-	Value* value=0;
-	if(can_call_operator) {
-		if(Method* method=main_class.get_method(name)) // looking operator of that name FIRST
-			value=new VJunction(main_class, method);
-	}
-	if(!value) {
-		if(!wcontext->get_constructing() // not constructing
-			&& wcontext->get_somebody_entered_some_class() ) // ^class:method
+Value& Request::get_element(Value& ncontext, const String& name) {
+	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 *read_class=rcontext->get_class())
 					if(read_class->derived_from(*called_class)) // current derived from called
 						if(Value* base=get_self().base()) { // doing DYNAMIC call
-							Temp_derived temp_derived(*base, 0); // temporarily prevent go-back-down virtual calls
-							value=base->get_element(name, *base, false); // virtual-up lookup starting from parent
-							goto value_ready;
+							Temp_derived temp_derived(*base, 0); // temporarily prevent go-back-down virtual calls 
+							Value *value=base->get_element(name, *base, true); // virtual-up lookup starting from parent
+							return *(value ? &process_to_value(*value) : VVoid::get());
 						}
-	}
-	if(!value)
-		value=ncontext.get_element(name, ncontext, false);
+
+	Value* value=ncontext.get_element(name, ncontext, true);
 
 	if(value && wcontext->get_constructing())
-		if(Junction* junction=value->get_junction()) {
+		if(Junction* junction=value->get_junction())
 			if(junction->self.get_class()!=&ncontext)
 				throw Exception(PARSER_RUNTIME,
 					&name,
 					"constructor must be declared in class '%s'", 
 						ncontext.get_class()->name_cstr());
-		}
 
-value_ready:
-	if(value)
-		value=&process_to_value(*value); // process possible code-junction
-	else
-		value=new VVoid;
-
-	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
-	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) {
-			const Junction& junction=vjunction->junction();
 			// process it
-			ArrayString* params_names=junction.method->params_names;
-			int param_count=params_names? params_names->count(): 0;
+			VMethodFrame frame(vjunction->junction(), method_frame/*caller*/);
+			int 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);
 
-			VMethodFrameGlobal frame(junction, method_frame/*caller*/);
-			frame.store_param(value);
-
+			frame.store_params(&value, 1);
 			frame.set_self(frame.junction.self);
 
-			VMethodFrame *saved_method_frame=method_frame;
-			Value* saved_rcontext=rcontext;
-			WContext *saved_wcontext=wcontext;
+			SAVE_CONTEXT
 
 			rcontext=wcontext=&frame;
 			method_frame=&frame;
@@ -925,9 +1012,7 @@ void Request::put_element(Value& ncontex
 			recoursion_checked_execute(*frame.junction.method->parser_code); // parser code, execute it
 			// we don't need it StringOrValue result=wcontext->result();
 
-			method_frame=saved_method_frame;
-			wcontext=saved_wcontext;
-			rcontext=saved_rcontext;
+			RESTORE_CONTEXT
 		}
 }
 
@@ -946,20 +1031,27 @@ StringOrValue Request::process(Value& in
 	Junction* junction=input_value.get_junction();
 	if(junction) {
 		if(junction->is_getter) { // is it a getter-junction?
-			// process it
-
-			if(junction->method->params_names)
-				throw Exception(PARSER_RUNTIME,
-					0,
-					"getter method must have no parameters");
+			VMethodFrame frame(*junction, method_frame/*caller*/);
+			int param_count=frame.method_params_count();
 
-			VMethodFrameGlobal frame(*junction, method_frame/*caller*/);
+			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);
 
-			VMethodFrame *saved_method_frame=method_frame;
-			Value* saved_rcontext=rcontext;
-			WContext *saved_wcontext=wcontext;
+			SAVE_CONTEXT
 
 			rcontext=wcontext=&frame;
 			method_frame=&frame;
@@ -967,9 +1059,7 @@ StringOrValue Request::process(Value& in
 			recoursion_checked_execute(*frame.junction.method->parser_code); // parser code, execute it
 			StringOrValue result=wcontext->result();
 
-			method_frame=saved_method_frame;
-			wcontext=saved_wcontext;
-			rcontext=saved_rcontext;
+			RESTORE_CONTEXT
 
 			return result;
 		}
@@ -986,9 +1076,7 @@ StringOrValue Request::process(Value& in
 				0,
 				"junction used outside of context");
 
-			VMethodFrame *saved_method_frame=method_frame;  
-			Value* saved_rcontext=rcontext;  
-			WContext *saved_wcontext=wcontext;
+			SAVE_CONTEXT
 
 			method_frame=junction->method_frame;
 			rcontext=junction->rcontext;
@@ -1019,9 +1107,7 @@ StringOrValue Request::process(Value& in
 				result=wcontext->result();
 			}
 
-			wcontext=saved_wcontext;
-			rcontext=saved_rcontext;
-			method_frame=saved_method_frame;
+			RESTORE_CONTEXT
 
 #ifdef DEBUG_EXECUTE
 			debug_printf(sapi_info, "<-ja returned");
@@ -1037,9 +1123,7 @@ StringOrValue Request::process(Value& in
 }
 
 StringOrValue Request::execute_method(VMethodFrame& amethod_frame, const Method& method) {
-	VMethodFrame *saved_method_frame=method_frame;  
-	Value* saved_rcontext=rcontext;  
-	WContext *saved_wcontext=wcontext;
+	SAVE_CONTEXT
 	
 	// initialize contexts
 	rcontext=wcontext=method_frame=&amethod_frame;
@@ -1050,27 +1134,24 @@ StringOrValue Request::execute_method(VM
 	// result
 	StringOrValue result=wcontext->result();
 	
-	wcontext=saved_wcontext;
-	rcontext=saved_rcontext;
-	method_frame=saved_method_frame;
+	RESTORE_CONTEXT
 	
 	// return
 	return result;
 }
 
 const String* Request::execute_method(Value& aself, 
-				      const Method& method, VString* optional_param,
-				      bool do_return_string) {
+					const Method& method, Value* optional_param,
+					bool do_return_string) {
 
-	VMethodFrame *saved_method_frame=method_frame;  
-	Value* saved_rcontext=rcontext;  
-	WContext *saved_wcontext=wcontext;
+	SAVE_CONTEXT
 	
 	Junction local_junction(aself, &method);
-	VMethodFrameGlobal local_frame(local_junction, method_frame/*caller*/);
-	if(optional_param && local_frame.can_store_param()) {
-		local_frame.store_param(*optional_param);
-		local_frame.fill_unspecified_params();
+	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; 
@@ -1087,18 +1168,16 @@ const String* Request::execute_method(Va
 	if(do_return_string)
 		result=&wcontext->result().as_string();
 	
-	wcontext=saved_wcontext;
-	rcontext=saved_rcontext;
-	method_frame=saved_method_frame;
+	RESTORE_CONTEXT
 
 	return result;
 }
 
 Request::Execute_nonvirtual_method_result 
 Request::execute_nonvirtual_method(VStateless_class& aclass, 
-				   const String& method_name,
-				   VString* optional_param,
-				   bool do_return_string) {
+					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)
@@ -1107,7 +1186,7 @@ Request::execute_nonvirtual_method(VStat
 }
 
 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(Junction* junction=value->get_junction())
 			if(const Method *method=junction->method)