--- parser3/src/main/pa_request.C	2010/05/23 01:06:47	1.320
+++ parser3/src/main/pa_request.C	2016/11/27 23:08:28	1.365
@@ -1,12 +1,10 @@
 /** @file
 	Parser: request class main part. @see compile.C and execute.C.
 
-	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_REQUEST_C="$Date: 2010/05/23 01:06:47 $";
-
 #include "pa_sapi.h"
 #include "pa_common.h"
 #include "pa_request.h"
@@ -34,6 +32,8 @@ static const char * const IDENT_REQUEST_
 #include "pa_vconsole.h"
 #include "pa_vdate.h"
 
+volatile const char * IDENT_PA_REQUEST_C="$Id: pa_request.C,v 1.365 2016/11/27 23:08:28 moko Exp $" IDENT_PA_REQUEST_H IDENT_PA_REQUEST_CHARSETS_H IDENT_PA_REQUEST_INFO_H IDENT_PA_VCONSOLE_H;
+
 // consts
 
 #define UNHANDLED_EXCEPTION_METHOD_NAME "unhandled_exception"
@@ -43,65 +43,99 @@ const char* UNHANDLED_EXCEPTION_CONTENT_
 
 /// content type of response when no $MAIN:defaults.content-type defined
 const char* DEFAULT_CONTENT_TYPE="text/html";
-const char* ORIGINS_CONTENT_TYPE="text/plain";
+
+const uint EXECUTE_RECOURSION_LIMIT=1000;
+const uint LOOP_LIMIT=20000;
 
 // defines for globals
 
 #define MAIN_METHOD_NAME "main"
 #define AUTO_METHOD_NAME "auto"
+#define USE_METHOD_NAME "use"
 #define AUTOUSE_METHOD_NAME "autouse"
-#define BODY_NAME "body"
+
 #define EXCEPTION_TYPE_PART_NAME "type"
 #define EXCEPTION_SOURCE_PART_NAME "source"
 #define EXCEPTION_COMMENT_PART_NAME "comment"
 
+#define ORIGIN_KEY "origin"
+
 // globals
 
 const String main_method_name(MAIN_METHOD_NAME);
 const String auto_method_name(AUTO_METHOD_NAME);
-const String autouse_method_name(AUTOUSE_METHOD_NAME);
+static const String use_method_name(USE_METHOD_NAME);
+static const String autouse_method_name(AUTOUSE_METHOD_NAME);
 
-const String body_name(BODY_NAME);
 const String exception_type_part_name(EXCEPTION_TYPE_PART_NAME);
 const String exception_source_part_name(EXCEPTION_SOURCE_PART_NAME);
 const String exception_comment_part_name(EXCEPTION_COMMENT_PART_NAME);
 const String exception_handled_part_name(EXCEPTION_HANDLED_PART_NAME);
 
+static const String origin_key(ORIGIN_KEY);
+
+int pa_execute_recoursion_limit=EXECUTE_RECOURSION_LIMIT;
+int pa_loop_limit=LOOP_LIMIT;
+
 // defines for statics
 
 #define CHARSETS_NAME "CHARSETS"
 #define MIME_TYPES_NAME "MIME-TYPES"
-#define ORIGINS_MODE_NAME "ORIGINS"
+#define STRICT_VARS_NAME "STRICT-VARS"
+#define PROTOTYPE_NAME "OBJECT-PROTOTYPE"
+#define LIMITS_NAME "LIMITS"
+#define RECOURSION_LIMIT_NAME "max_recoursion"
+#define LOOP_LIMIT_NAME "max_loop"
 #define CONF_METHOD_NAME "conf"
 #define POST_PROCESS_METHOD_NAME "postprocess"
-#define DOWNLOAD_NAME "download"
 #define CLASS_PATH_NAME "CLASS_PATH"
 #define RESPONSE_BODY_FILE_NAME "file"
 
+#define DOWNLOAD_NAME_UPPER "DOWNLOAD"
+#define BODY_NAME_UPPER "BODY"
+
 // statics
 
 static const String charsets_name(CHARSETS_NAME);
 static const String main_class_name(MAIN_CLASS_NAME);
 static const String mime_types_name(MIME_TYPES_NAME);
-static const String origins_mode_name(ORIGINS_MODE_NAME);
+static const String strict_vars_name(STRICT_VARS_NAME);
+static const String prototype_name(PROTOTYPE_NAME);
+static const String limits_name(LIMITS_NAME);
+static const String recoursion_limit_name(RECOURSION_LIMIT_NAME);
+static const String loop_limit_name(LOOP_LIMIT_NAME);
+
 static const String conf_method_name(CONF_METHOD_NAME);
 static const String post_process_method_name(POST_PROCESS_METHOD_NAME);
-static const String download_name(DOWNLOAD_NAME);
 static const String class_path_name(CLASS_PATH_NAME);
 static const String response_body_file_name(RESPONSE_BODY_FILE_NAME);
 
+static const String download_name_upper(DOWNLOAD_NAME_UPPER);
+static const String body_name_upper(BODY_NAME_UPPER);
+
+// more static
+
+static const String content_type_name_upper(HTTP_CONTENT_TYPE_UPPER);
+static const String content_disposition_name_upper(CONTENT_DISPOSITION_UPPER);
+static const String content_disposition_inline(CONTENT_DISPOSITION_INLINE);
+static const String content_disposition_attachment(CONTENT_DISPOSITION_ATTACHMENT);
+
 // defines
 
+#define CHARSET_NAME_UPPER "CHARSET"
+#define LAST_MODIFIED_NAME_UPPER "LAST-MODIFIED"
+
 // op.C
 VStateless_class& VClassMAIN_create();
 
 //
 Request::Request(SAPI_Info& asapi_info, Request_info& arequest_info, 
-				 String::Language adefault_lang, bool status_allowed):
+				 String::Language adefault_lang):
 	// private
 	anti_endless_execute_recoursion(0),
 
 	// public
+	allow_class_replace(false),
 	method_frame(0),
 	rcontext(0),
 	wcontext(0),
@@ -112,15 +146,9 @@ Request::Request(SAPI_Info& asapi_info,
 	fin_cycle(0),
 
 	// public
-#ifdef RESOURCES_DEBUG
-	sql_connect_time(0),
-	sql_request_time(0),
-#endif	
-
-	// public
 	request_info(arequest_info),
 	sapi_info(asapi_info),
-	charsets(UTF8_charset, UTF8_charset, UTF8_charset), // default charsets
+	charsets(pa_UTF8_charset, pa_UTF8_charset, pa_UTF8_charset), // default charsets
 
 	main_class(VClassMAIN_create()),
 	form(*new VForm(charsets, arequest_info)),
@@ -140,50 +168,44 @@ Request::Request(SAPI_Info& asapi_info,
 	pa_register_thread_request(*this);
 
 	// file_no=0 => unknown
-	file_list+=String::Body("UNKNOWN");
-	file_list+=String::Body("-body of process-"); // pseudo_file_no__process
+	file_list+="UNKNOWN";
+	file_list+="-body of process-"; // pseudo_file_no__process
 
 	// maybe expire old caches
 	cache_managers->maybe_expire();
 	
 	/// directly used
 	// MAIN class, operators
-	classes().put(main_class.name(), &main_class);
+	put_class(&main_class);
 	// classes:
 	// table, file, random, mail, image, ...
 	methoded_array().register_directly_used(*this);
 
 	/// methodless
+
 	// env class
-	classes().put(String::Body(ENV_CLASS_NAME), new VEnv(asapi_info));
+	put_class(new VEnv(asapi_info));
 	// status class
-	if(status_allowed)
-		classes().put(String::Body(STATUS_CLASS_NAME), new VStatus());
+	put_class(new VStatus());
 	// request class
-	classes().put(String::Body(REQUEST_CLASS_NAME), new VRequest(arequest_info, charsets, form));	
+	put_class(new VRequest(arequest_info, charsets, form, asapi_info));
 	// cookie class
-	classes().put(String::Body(COOKIE_CLASS_NAME), &cookie);
+	put_class(&cookie);
 	// console class
-	classes().put(String::Body(CONSOLE_CLASS_NAME), &console);
+	put_class(&console);
+
 	/// methoded
-	// response class
-	classes().put(response.get_class()->name(), &response);
 
-	/// bases used
+	// response class
+	put_class(&response);
 	// form class
-	classes().put(form.get_class()->base_class()->name(), &form);
+	put_class(&form);
 	// mail class
-	classes().put(mail.get_class()->base_class()->name(), &mail);
+	put_class(&mail);
 	// math class
-	{
-		Value& math=*new VMath;
-		classes().put(math.get_class()->base_class()->name(), &math);
-	}
+	put_class(new VMath);
 	// memory class
-	{
-		Value& memory=*new VMemory;
-		classes().put(memory.get_class()->base_class()->name(), &memory);
-	}
+	put_class(new VMemory);
 }
 
 Request::~Request() {
@@ -191,44 +213,35 @@ Request::~Request() {
 	// if for some strange reason xml generic errors failed to be reported, free them up
 	if(const char* xml_generic_errors=xmlGenericErrors()) {
 		SAPI::log(sapi_info, "warning: unreported xmlGenericErrors: %s", xml_generic_errors);
-		free((void *)xml_generic_errors);
+		pa_free((void *)xml_generic_errors);
 	}
 #endif
 }
 
 Value& Request::get_self() { return method_frame/*always have!*/->self(); }
 
-Value* Request::get_class(const String& name){
-	Value* result=classes().get(name);
+VStateless_class* Request::get_class(const String& name){
+	VStateless_class* result=classes().get(name);
 	if(!result)
-		if(Value* value=main_class.get_element(autouse_method_name))
-			if(Junction* junction=value->get_junction())
-				if(const Method *method=junction->method) {
-					Value *vname=new VString(name);
-					VMethodFrame frame(*junction, 0/*no parent*/);
-
-					frame.set_self(main_class);
-					frame.store_params(&vname, 1);
-					// we don't need the result
-					execute_method(frame, *method);
-
-					result=classes().get(name);
-				}
-
+		if(const Method *method=main_class.get_method(autouse_method_name)){
+			Value *vname=new VString(name);
+			CONSTRUCTOR_FRAME_ACTION(*method, 0 /*no parent*/, main_class, {
+				frame.store_params(&vname, 1);
+				// we don't need the result
+				call(frame);
+			});
+			result=classes().get(name);
+		}
 	return result;
 }
 
-static void load_charset(HashStringValue::key_type akey, 
-			 HashStringValue::value_type avalue, 
-			 Request_charsets* charsets) {
-	const String::Body NAME=String(akey, String::L_CLEAN).change_case(charsets->source(), String::CC_UPPER);
-	::charsets.load_charset(*charsets, NAME, avalue->as_string());
+static void load_charset(HashStringValue::key_type akey, HashStringValue::value_type avalue, Request_charsets* charsets) {
+	pa_charsets.load_charset(*charsets, akey, avalue->as_string());
 }
+
 void Request::configure_admin(VStateless_class& conf_class) {
 	if(configure_admin_done)
-		throw Exception(PARSER_RUNTIME,
-		0,
-		"parser already configured");
+		throw Exception(PARSER_RUNTIME, 0, "parser already configured");
 	configure_admin_done=true;
 	
 	// charsets must only be specified in method_frame config
@@ -240,56 +253,95 @@ void Request::configure_admin(VStateless
 		]
 	*/
 	if(Value* vcharsets=conf_class.get_element(charsets_name)) {
-		if(!vcharsets->is_string())
+		if(!vcharsets->is_string()) {
 			if(HashStringValue* charsets=vcharsets->get_hash())
 				charsets->for_each<Request_charsets*>(load_charset, &this->charsets);
 			else
-				throw Exception(PARSER_RUNTIME,
-					0,
-					"$" MAIN_CLASS_NAME ":" CHARSETS_NAME " must be hash");
+				throw Exception(PARSER_RUNTIME, 0, "$" MAIN_CLASS_NAME ":" CHARSETS_NAME " must be hash");
+		}
+	}
+
+#ifdef STRICT_VARS
+	VVoid::strict_vars=false;
+	if(Value* strict_vars=conf_class.get_element(strict_vars_name)) {
+		if(strict_vars->is_bool())
+			VVoid::strict_vars=strict_vars->as_bool();
+		else
+			throw Exception(PARSER_RUNTIME, 0, "$" MAIN_CLASS_NAME ":" STRICT_VARS_NAME " must be bool");
+	}
+#endif
+
+#ifdef OBJECT_PROTOTYPE
+	VClass::prototype=true;
+	if(Value* prototype=conf_class.get_element(prototype_name)) {
+		if(prototype->is_bool())
+			VClass::prototype=prototype->as_bool();
+		else
+			throw Exception(PARSER_RUNTIME, 0, "$" MAIN_CLASS_NAME ":" PROTOTYPE_NAME " must be bool");
 	}
+#endif
+
+	Value* limits=conf_class.get_element(limits_name);
+
+	pa_loop_limit=LOOP_LIMIT;
+	if(limits)
+		if(Value* loop_limit=limits->get_element(loop_limit_name)) {
+			if(loop_limit->is_evaluated_expr()) {
+				pa_loop_limit=loop_limit->as_int();
+				if(pa_loop_limit==0) pa_loop_limit=INT_MAX;
+			} else
+				throw Exception(PARSER_RUNTIME, 0, "$" MAIN_CLASS_NAME ":" LOOP_LIMIT_NAME " must be int");
+		}
+
+	pa_execute_recoursion_limit=EXECUTE_RECOURSION_LIMIT;
+	if(limits)
+		if(Value* recoursion_limit=limits->get_element(recoursion_limit_name)) {
+			if(recoursion_limit->is_evaluated_expr()) {
+				pa_execute_recoursion_limit=recoursion_limit->as_int();
+				if(pa_execute_recoursion_limit==0) pa_execute_recoursion_limit=INT_MAX;
+			} else
+				throw Exception(PARSER_RUNTIME, 0, "$" MAIN_CLASS_NAME ":" RECOURSION_LIMIT_NAME " must be int");
+		}
 
 	// configure method_frame options
 	//	until someone with less privileges have overriden them
 	methoded_array().configure_admin(*this);
 }
 
-const char* Request::get_exception_cstr(
-										const Exception& e,
-										Request::Exception_details& details) {
+const char* Request::get_exception_cstr(const Exception& e, Request::Exception_details& details) {
+
 #define PA_URI_FORMAT "%s: "
+#define PA_COMMENT_TYPE_FORMAT "%s [%s]"
+
 #define PA_ORIGIN_FILE_POS_FORMAT "%s(%d:%d): "
 #define PA_SOURCE_FORMAT "'%s' "
-#define PA_COMMENT_TYPE_FORMAT "%s [%s]"
+
+#define PA_ORIGIN_FILE_POS_VALUE file_list[details.origin.file_no].cstr(), 1+details.origin.line, 1+details.origin.col,
+#define PA_SOURCE_VALUE details.problem_source->cstr(),
+
+#define EXCEPTION_CSTR(f1,v1,f2,v2) \
+			snprintf(result, MAX_STRING, \
+				PA_URI_FORMAT \
+				f1 f2 \
+				PA_COMMENT_TYPE_FORMAT, \
+				request_info.uri, \
+				v1 v2 \
+				e.comment(), e.type() \
+			);
+
 	char* result=new(PointerFreeGC) char[MAX_STRING];
 
 	if(details.problem_source) { // do we know the guy?
-		if(details.trace) { // do whe know where he came from?
-			Operation::Origin origin=details.trace.origin();
-			snprintf(result, MAX_STRING, 
-				PA_URI_FORMAT 
-				PA_ORIGIN_FILE_POS_FORMAT 
-				PA_SOURCE_FORMAT PA_COMMENT_TYPE_FORMAT,
-				request_info.uri,
-				file_list[origin.file_no].cstr(), 1+origin.line, 1+origin.col,
-				details.problem_source->cstr(),
-				e.comment(), e.type()
-			);
-		} else
-			snprintf(result, MAX_STRING, 
-				PA_URI_FORMAT 
-				PA_SOURCE_FORMAT PA_COMMENT_TYPE_FORMAT,
-				request_info.uri,
-				details.problem_source->cstr(),
-				e.comment(), e.type()
-			);
-	} else
-		snprintf(result, MAX_STRING, 
-			PA_URI_FORMAT 
-			PA_COMMENT_TYPE_FORMAT,
-			request_info.uri,
-			e.comment(), e.type()
-		);
+		if(details.origin.file_no) // do whe know where he came from?
+			EXCEPTION_CSTR(PA_ORIGIN_FILE_POS_FORMAT, PA_ORIGIN_FILE_POS_VALUE, PA_SOURCE_FORMAT, PA_SOURCE_VALUE)
+		else
+			EXCEPTION_CSTR(PA_SOURCE_FORMAT, PA_SOURCE_VALUE,,)
+	} else {
+		if(details.origin.file_no) // do whe know where he came from?
+			EXCEPTION_CSTR(PA_ORIGIN_FILE_POS_FORMAT, PA_ORIGIN_FILE_POS_VALUE,,)
+		else
+			EXCEPTION_CSTR(,,,)
+	}
 
 	return result;
 }
@@ -319,16 +371,7 @@ void Request::configure() {
 
 */
 void Request::core(const char* config_filespec, bool config_fail_on_read_problem, bool header_only) {
-#ifdef RESOURCES_DEBUG
-//measures
-struct timeval mt[10];
-//measure:before all
-gettimeofday(&mt[0],NULL);
-#endif
 	try {
-		// filling mail received
-		mail.fill_received(*this);
-
 		// loading config
 		if(config_filespec) {
 			const String& filespec=*new String(config_filespec);
@@ -338,6 +381,9 @@ gettimeofday(&mt[0],NULL);
 				true /*file must exist if 'fail on read problem' not set*/);
 		}
 
+		// filling mail received
+		mail.fill_received(*this);
+
 		// loading auto.p files from document_root/.. 
 		// to the one beside requested file.
 		// all assigned bases from upper dir
@@ -379,27 +425,18 @@ gettimeofday(&mt[0],NULL);
 			rethrow;
 		}
 
-#ifdef RESOURCES_DEBUG
-//measure:after compile
-gettimeofday(&mt[1],NULL);
-#endif
 		// execute @main[]
 		const String* body_string=execute_virtual_method(main_class, main_method_name);
 		if(!body_string)
 			throw Exception(PARSER_RUNTIME,
 				0,
-				"'"MAIN_METHOD_NAME"' method not found");
-
-#ifdef RESOURCES_DEBUG
-		//measure:after main
-gettimeofday(&mt[2],NULL);
-#endif
+				"'" MAIN_METHOD_NAME "' method not found");
 
 		// extract response body
-		Value* body_value=response.fields().get(download_name); // $response:download?
+		Value* body_value=response.fields().get(download_name_upper); // $response:download?
 		bool as_attachment=body_value!=0;
 		if(!body_value)
-			body_value=response.fields().get(body_name); // $response:body
+			body_value=response.fields().get(body_name_upper); // $response:body
 		if(!body_value)
 			body_value=new VString(*body_string); // just result of ^main[]
 
@@ -409,41 +446,18 @@ gettimeofday(&mt[2],NULL);
 				if(const Method *method=junction->method) {
 					// preparing to pass parameters to 
 					//	@postprocess[data]
-					VMethodFrame frame(/*method->name, */ *junction, 0/*no parent*/);
-					frame.set_self(main_class);
-
-					frame.store_params(&body_value, 1);
-					body_value=&execute_method(frame, *method).as_value();
+					METHOD_FRAME_ACTION(*method, 0 /*no parent*/, main_class, {
+						frame.store_params(&body_value, 1);
+						call(frame);
+						body_value=&frame.result();
+					});
 				}
 
 		VFile* body_file=body_value->as_vfile(flang, &charsets);
 
-#ifdef RESOURCES_DEBUG
-//measure:after postprocess
-gettimeofday(&mt[3],NULL);		
-#endif
-
 		// OK. write out the result
 		output_result(body_file, header_only, as_attachment);
 
-#ifdef RESOURCES_DEBUG
-		//measure:after output_result
-gettimeofday(&mt[9],NULL);		
-t[9]=mt[9].tv_sec+mt[9].tv_usec/1000000.0;
-
-double t[10];
-for(int i=0;i<10;i++)
-    t[i]=mt[i].tv_sec+mt[i].tv_usec/1000000.0;
-//measure:log2 compile,main,postprocess,output
-SAPI::log("rmeasure: %s,%.2f,%.2f,%.2f %.2f,%.2f %.2f", 
-request_info.uri,
-t[1]-t[0],
-t[2]-t[1],
-t[3]-t[2],
-sql_connect_time,sql_request_time,
-t[9]-t[3]
-);
-#endif
 	} catch(const Exception& e) { // request handling problem
 		try {
 		// we're returning not result, but error explanation
@@ -467,8 +481,6 @@ t[9]-t[3]
 				if(const Method *method=junction->method) {
 					// preparing to pass parameters to 
 					//	@unhandled_exception[exception;stack]
-					VMethodFrame frame(/*method->name, */ *junction, 0/*no caller*/);
-					frame.set_self(main_class);
 
 					// $stack[^table::create{name	file	lineno	colno}]
 					Table::columns_type stack_trace_columns(new ArrayString);
@@ -492,13 +504,16 @@ t[9]-t[3]
 							stack_trace+=row;
 						}
 
-					Value *params[]={&details.vhash, new VTable(&stack_trace)};
-					frame.store_params(params, 2);
-
 					// future $response:body=
 					//   execute ^unhandled_exception[exception;stack]
 					exception_trace.clear(); // forget all about previous life, in case there would be error inside of this method, error handled  would not be mislead by old stack contents (see extract_origin)
-					body_string=&execute_method(frame, *method).as_string();
+
+					Value *params[]={&details.vhash, new VTable(&stack_trace)};
+					METHOD_FRAME_ACTION(*method, 0 /*no caller*/, main_class, {
+						frame.store_params(params, 2);
+						call(frame);
+						body_string=&frame.result().as_string();
+					});
 				}
 			}
 		}
@@ -507,7 +522,7 @@ t[9]-t[3]
 			// doing that ugly
 
 			// future $response:content-type
-			response.fields().put(http_content_type, new VString(*new String(UNHANDLED_EXCEPTION_CONTENT_TYPE)));
+			response.fields().put(content_type_name_upper, new VString(*new String(UNHANDLED_EXCEPTION_CONTENT_TYPE)));
 			// future $response:body
 			body_string=new String(exception_cstr);
 		}
@@ -562,18 +577,21 @@ void Request::use_file_directly(VStatele
 }
 
 
-void Request::use_file(VStateless_class& aclass,
-				const String& file_name,
-				const String* use_filespec/*absolute*/) {
+void Request::use_file(VStateless_class& aclass, const String& file_name, const String* use_filespec/*absolute*/) {
+
+	if(file_name.is_empty())
+		throw Exception(PARSER_RUNTIME,
+			0,
+			"usage failed - no filename was specified");
 
 	const String* filespec=0;
 
 	if(file_name.first_char()=='/') //absolute path? [no need to scan MAIN:CLASS_PATH]
 		filespec=&absolute(file_name);
 	else if(use_filespec){ // search in current dir first
-		int afterslash=lastposafter(*use_filespec, 0, "/", 1, true);
-		if(afterslash>0)
-			filespec=file_exist(use_filespec->mid(0, afterslash-1), file_name); // found in current dir?
+		size_t last_slash_pos=use_filespec->strrpbrk("/");
+		if(last_slash_pos!=STRING_NOT_FOUND)
+			filespec=file_exist(use_filespec->mid(0, last_slash_pos), file_name); // found in current dir?
 	}
 
 	if(!filespec){
@@ -607,14 +625,30 @@ void Request::use_file(VStateless_class&
 	use_file_directly(aclass, *filespec);
 }
 
+void Request::use_file(const String& file_name, const String* use_filespec/*absolute*/, Operation::Origin origin) {
+	static String use("USE");
+	try {
+		static VHash* voptions=new VHash();
+		if(const Method *method=main_class.get_method(use_method_name)){
+			Value *params[]={new VString(file_name), voptions};
+			voptions->hash().put(origin_key, new VString(*use_filespec));
+
+			CONSTRUCTOR_FRAME_ACTION(*method, 0 /*no parent*/, main_class, {
+				frame.store_params(params, 2);
+				// we don't need the result
+				call(frame);
+			});
+		}
+	} catch (...) {
+		exception_trace.push(Trace(&use, origin));
+		rethrow;
+	}
+}
 
-void Request::use_buf(VStateless_class& aclass,
-				const char* source, const String* main_alias, 
-				uint file_no,
-				int line_no_offset) {
-	// temporary zero @conf so to maybe-replace it in compiled code
+void Request::use_buf(VStateless_class& aclass, const char* source, const String* main_alias, uint file_no, int line_no_offset) {
+	// temporary zero @conf to avoid it second execution
 	Temp_method temp_method_conf(aclass, conf_method_name, 0);
-	// temporary zero @auto so to maybe-replace it in compiled code
+	// temporary zero @auto to avoid it second execution
 	Temp_method temp_method_auto(aclass, auto_method_name, 0);
 
 	// compile loaded classes
@@ -627,21 +661,19 @@ void Request::use_buf(VStateless_class&
 		VStateless_class& cclass=*cclasses.get(i);
 
 		// locate and execute possible @conf[] static
-		Execute_nonvirtual_method_result executed=execute_nonvirtual_method(cclass, 
-			conf_method_name, vfilespec,
-			false/*no string result needed*/);
+		Execute_nonvirtual_method_result executed=execute_nonvirtual_method(cclass, conf_method_name, vfilespec, false/*no string result needed*/);
 		if(executed.method)
 			configure_admin(cclass/*, executed.method->name*/);
 
 		// locate and execute possible @auto[] static
-		execute_nonvirtual_method(cclass, 
-			auto_method_name, vfilespec,
-			false/*no result needed*/);
+		execute_nonvirtual_method(cclass, auto_method_name, vfilespec, false/*no result needed*/);
+
+		cclass.enable_default_setter();
 	}
 }
 
 const String& Request::relative(const char* apath, const String& relative_name) {
-	char *hpath=strdup(apath);
+	char *hpath=pa_strdup(apath);
 	String& result=*new String;
 	if(rsplit(hpath, '/')) // if something/splitted
 		result << hpath << "/";
@@ -651,7 +683,7 @@ const String& Request::relative(const ch
 
 const String& Request::absolute(const String& relative_name) {
 	if(relative_name.first_char()=='/') {
-		String& result=*new String(strdup(request_info.document_root));
+		String& result=*new String(pa_strdup(request_info.document_root));
 		result << relative_name;
 		return result;
 	} else 
@@ -676,24 +708,19 @@ public:
 	bool add_last_modified;
 };
 #endif
-static void add_header_attribute(
-				 HashStringValue::key_type name, 
-				 HashStringValue::value_type value, 
-				 Add_header_attribute_info* info) {
-	if(name==BODY_NAME
-		|| name==DOWNLOAD_NAME
-		|| name==CHARSET_NAME)
+static void add_header_attribute(HashStringValue::key_type name, HashStringValue::value_type value, Add_header_attribute_info* info) {
+	if(name==BODY_NAME_UPPER || name==DOWNLOAD_NAME_UPPER || name==CHARSET_NAME_UPPER)
 		return;
 	
+	if(name==LAST_MODIFIED_NAME_UPPER)
+		info->add_last_modified=false;
+
 	const char* aname=String(name, String::L_URI).untaint_and_transcode_cstr(String::L_URI, &info->r.charsets);
 
 	SAPI::add_header_attribute(info->r.sapi_info,
-			aname, 
+			aname,
 			attributed_meaning_to_string(*value, String::L_URI, false).untaint_and_transcode_cstr(String::L_URI, &info->r.charsets)
 		);
-
-	if(strcasecmp(aname, "last-modified")==0)
-		info->add_last_modified=false;
 }
 
 static void output_sole_piece(Request& r,
@@ -758,7 +785,7 @@ static void output_pieces(Request& r,
 
 	const size_t BUFSIZE = 10*0x400;
 	char buf[BUFSIZE];
-	const char *range = SAPI::get_env(r.sapi_info, "HTTP_RANGE");
+	const char *range = SAPI::Env::get(r.sapi_info, "HTTP_RANGE");
 	size_t offset=0;
 	size_t part_length=content_length;
 	if(range){
@@ -844,7 +871,7 @@ void Request::output_result(VFile* body_
 				name_cstr=after_slash;
 			if(char *after_slash=rsplit(name_cstr, '/'))
 				name_cstr=after_slash;
-			vfile_name=new VString(*new String(name_cstr));	
+			vfile_name=new VString(*new String(name_cstr));
 		}
 	}
 	if(vfile_name) {
@@ -853,9 +880,9 @@ void Request::output_result(VFile* body_
 			VHash& hash=*new VHash();
 			HashStringValue &h=hash.hash();
 			h.put(value_name, new VString( as_attachment ? content_disposition_attachment : content_disposition_inline ));
-			h.put(content_disposition_filename_name, vfile_name);
+			h.put(content_disposition_filename_name, new VString(*new String(sfile_name, String::L_HTTP_HEADER)));
 
-			response.fields().put(content_disposition, &hash);
+			response.fields().put(content_disposition_name_upper, &hash);
 
 			if(!body_file_content_type)
 				body_file_content_type=new VString(mime_type_of(sfile_name.cstr()));
@@ -865,10 +892,10 @@ void Request::output_result(VFile* body_
 	// set Content-Type
 	if(body_file_content_type) {
 		// body file content type
-		response.fields().put(content_type_name, body_file_content_type);
+		response.fields().put(content_type_name_upper, body_file_content_type);
 	} else {
 		// default content type
-		response.fields().put_dont_replace(content_type_name, new VString(*new String(DEFAULT_CONTENT_TYPE)));
+		response.fields().put_dont_replace(content_type_name_upper, new VString(*new String(DEFAULT_CONTENT_TYPE)));
 	}
 
 	// prepare header: $response:fields without :body, :download and :charset
@@ -892,7 +919,7 @@ void Request::output_result(VFile* body_
 				throw Exception(PARSER_RUNTIME, 0, "mdate must be a date");
 		}
 		if(!vdate)
-			vdate=new VDate(mtime);
+			vdate=new VDate((pa_time_t)mtime);
 
 		output_pieces(*this, header_only, 
 			sresponse_body_file,
@@ -909,86 +936,29 @@ void Request::output_result(VFile* body_
 	}
 }
 
+const String& Request::mime_type_of(const String* file_name) {
+	return mime_type_of(file_name?file_name->taint_cstr(String::L_FILE_SPEC):0);
+}
+
 const String& Request::mime_type_of(const char* user_file_name_cstr) {
 	if(mime_types)
 		if(const char* cext=strrchr(user_file_name_cstr, '.')) {
 			String sext(++cext);
 			Table::Action_options options;
-			if(mime_types->locate(0, sext.change_case(charsets.source(), String::CC_LOWER), options))
+			if(mime_types->locate(0, sext.change_case(charsets.source(), String::CC_LOWER), options)) {
 				if(const String* result=mime_types->item(1))
 					return *result;
 				else
 					throw Exception(PARSER_RUNTIME,
 						0,
 						MIME_TYPES_NAME  " table column elements must not be empty");
+			}
 		}
 
 	return *new String("application/octet-stream");
 }
 
-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
-						}
-					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:
-#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 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;
-						}
-				}
-				if(origin.file_no)
-					return get_used_filename(origin.file_no);
-			}
-		}
-	return 0;
-}
-
-const String* Request::get_used_filename(uint file_no){
+const String* Request::get_used_filespec(uint file_no){
 	if(file_no < file_list.count())
 		return new String(file_list[file_no], String::L_TAINTED);
 	return 0;
@@ -1008,58 +978,61 @@ const String& Request::transcode(const x
 }
 #endif
 
-
-const Request::Trace Request::Exception_trace::extract_origin(const String*& problem_source) {
-	Trace result;
-	if(!is_empty()) {
-		result=bottom_value();
-		if(!problem_source) { // we don't know who trigged the bug?
-			problem_source=result.name(); // consider the stack-top-guy (we usually know source of next-from-throw-point exception) did that
-			fbottom++;
-		} else if(result.name()==problem_source) // it is that same guy?
-			fbottom++; // throw away that trace
-		else {
-			// stack top contains not us, 
-			//	leaving result intact
-			//	it would help ^throw
-		}
-	}
-
-	return result;
-}
-
 Request::Exception_details Request::get_details(const Exception& e) {
 	const String* problem_source=e.problem_source();
-	Trace trace=exception_trace.extract_origin(problem_source);
-	
 	VHash& vhash=*new VHash;  HashStringValue& hash=vhash.hash();
+	Operation::Origin origin={0, 0, 0};
+
+	if(!exception_trace.is_empty()) {
+		Trace bottom=exception_trace.bottom_value();
+		origin=bottom.origin();
+		if(!problem_source) { // we don't know who trigged the bug
+			problem_source=bottom.name(); // we usually know source of next-from-throw-point exception did that
+			exception_trace.set_bottom_index(exception_trace.bottom_index()+1);
+		} else if (bottom.name()==problem_source) { // it is that same guy?
+			exception_trace.set_bottom_index(exception_trace.bottom_index()+1); // throw away that trace
+		} else {
+			// stack top contains not us, leaving intact to help ^throw
+		}
+	}
 
 	// $.type
 	if(const char* type=e.type(true))
 		hash.put(exception_type_part_name, new VString(*new String(type)));
 
 	// $.source
-	if(problem_source) {
-		String& source=*new String(*problem_source, String::L_TAINTED);
-		hash.put(exception_source_part_name, new VString(source));
-	}
+	if(problem_source)
+		hash.put(exception_source_part_name, new VString(*new String(*problem_source, String::L_TAINTED)));
 
-	// $.file lineno colno
-	if(trace) {
-		const Operation::Origin origin=trace.origin();
-		hash.put(String::Body("file"),
-			new VString(*new String(file_list[origin.file_no], String::L_TAINTED)));
-		hash.put(String::Body("lineno"), new VInt(1+origin.line));
-		hash.put(String::Body("colno"), new VInt(1+origin.col));
+	// $.file $.lineno $.colno
+	if(origin.file_no){
+		hash.put("file", new VString(*new String(file_list[origin.file_no], String::L_TAINTED)));
+		hash.put("lineno", new VInt(1+origin.line));
+		hash.put("colno", new VInt(1+origin.col));
 	}
 
 	// $.comment
 	if(const char* comment=e.comment(true))
-		hash.put(exception_comment_part_name, 
-			new VString(*new String(comment, String::L_TAINTED)));
+		hash.put(exception_comment_part_name, new VString(*new String(comment, String::L_TAINTED)));
 
 	// $.handled(0)
 	hash.put(exception_handled_part_name, &VBool::get(false));
 
-	return Request::Exception_details(trace, problem_source, vhash);
+	return Request::Exception_details(origin, problem_source, vhash);
+}
+
+Temp_value_element::Temp_value_element(Request& arequest, Value& awhere, const String& aname, Value* awhat) :
+	frequest(arequest),
+	fwhere(awhere),
+	fname(aname),
+	saved(awhere.get_element(aname))
+{
+	Junction* junction;
+	if(saved && (junction=saved->get_junction()) && junction->is_getter)
+		saved=0;
+	frequest.put_element(fwhere, aname, awhat);
+}
+
+Temp_value_element::~Temp_value_element() {
+	frequest.put_element(fwhere, fname, saved ? saved : VVoid::get());
 }