--- parser3/src/main/pa_request.C	2003/04/02 16:05:20	1.245.2.37.2.21
+++ parser3/src/main/pa_request.C	2003/04/21 06:03:30	1.247
@@ -1,11 +1,11 @@
 /** @file
 	Parser: request class main part. @see compile.C and execute.C.
 
-	Copyright (c) 2001-2003 ArtLebedev Group (http://www.artlebedev.com)
+	Copyright (c) 2001, 2003 ArtLebedev Group (http://www.artlebedev.com)
 	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
 */
 
-static const char* IDENT_REQUEST_C="$Date: 2003/04/02 16:05:20 $";
+static const char* IDENT_REQUEST_C="$Date: 2003/04/21 06:03:30 $";
 
 #include "pa_sapi.h"
 #include "pa_common.h"
@@ -16,179 +16,118 @@ static const char* IDENT_REQUEST_C="$Dat
 #include "pa_vint.h"
 #include "pa_vmethod_frame.h"
 #include "pa_types.h"
-#include "pa_venv.h"
-#include "pa_vmath.h"
-#include "pa_vstatus.h"
-#include "pa_vrequest.h"
 #include "pa_vtable.h"
 #include "pa_vfile.h"
 #include "pa_dictionary.h"
 #include "pa_charset.h"
 #include "pa_charsets.h"
-#include "pa_cache_managers.h"
-#include "pa_vmail.h"
-#include "pa_vform.h"
-#include "pa_vcookie.h"
-#include "pa_vresponse.h"
-#include "pa_vmemory.h"
 
-// consts
-
-const char* UNHANDLED_EXCEPTION_METHOD_NAME="unhandled_exception";
+const char *POST_PROCESS_METHOD_NAME="postprocess";
+const char *UNHANDLED_EXCEPTION_METHOD_NAME="unhandled_exception";
 
 /// content type of exception response, when no @MAIN:exception handler defined
-const char* UNHANDLED_EXCEPTION_CONTENT_TYPE="text/plain";
+const char *UNHANDLED_EXCEPTION_CONTENT_TYPE="text/plain";
 
 /// 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";
-
-// defines for globals
-
-#define MAIN_METHOD_NAME "main"
-#define AUTO_METHOD_NAME "auto"
-#define BODY_NAME "body"
-
-// globals
-
-const String main_method_name(MAIN_METHOD_NAME);
-const String auto_method_name(AUTO_METHOD_NAME);
-const String content_disposition_name(CONTENT_DISPOSITION_NAME);
-const String content_disposition_value(CONTENT_DISPOSITION_VALUE);
-const String content_disposition_filename_name(CONTENT_DISPOSITION_FILENAME_NAME);
-const String body_name(BODY_NAME);
-
-// defines for statics
-
-#define CHARSETS_NAME "CHARSETS"
-#define MIME_TYPES_NAME "MIME-TYPES"
-#define ORIGINS_MODE_NAME "ORIGINS"
-#define CONF_METHOD_NAME "conf"
-#define POST_PROCESS_METHOD_NAME "postprocess"
-#define DOWNLOAD_NAME "download"
-#define CLASS_PATH_NAME "CLASS_PATH"
-
-// 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 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);
-
-// defines
+const char *DEFAULT_CONTENT_TYPE="text/html";
+const char *ORIGINS_CONTENT_TYPE="text/plain";
 
 // op.C
-VStateless_class& VClassMAIN_create();
+VClass& VClassMAIN_create(Pool& pool);
 // op.C
-VHash& exception2vhash(const Exception& e);
+VHash& exception2vhash(Pool& pool, const Exception& e);
 
 //
-Request::Request(SAPI_Info& asapi_info, Request_info& arequest_info, 
-		 String::Language adefault_lang, bool status_allowed):
-	// private
-	anti_endless_execute_recoursion(0),
-
-	// public
-	method_frame(0),
-	rcontext(0),
-	wcontext(0),
-	flang(adefault_lang),
+Request::Request(Pool& apool,
+				 Info& ainfo,
+				 uchar adefault_lang,
+				 bool status_allowed) : Pooled(apool),
+	main_method_name(apool, MAIN_METHOD_NAME),
+	stack(apool),
+	main_class(VClassMAIN_create(apool)),
+	env(apool),
+	status(apool),
+	form(apool),
+	mail(apool),
+	math(apool),
+	request(apool, *this),
+	response(apool),
+	cookie(apool),
+	fclasses(apool),
+	fdefault_lang(adefault_lang), flang(adefault_lang),
+	info(ainfo),
+	post_data(0), post_size(0),
+	used_files(apool),
+	configure_admin_done(false),
+	default_content_type(0),
+	mime_types(0),
 	fconnection(0),
-	finterrupted(false),
-
-	// public
+	classes_conf(apool),
+	anti_endless_execute_recoursion(0),
+	exception_trace(apool)
 #ifdef RESOURCES_DEBUG
-	sql_connect_time(0),
-	sql_request_time(0),
-#endif	
-
-	// public
-	sapi_info(asapi_info),
-	request_info(arequest_info),
-	charsets(UTF8_charset, UTF8_charset, UTF8_charset), // default charsets
-
-	main_class(VClassMAIN_create()),
-	form(*new VForm),
-	mail(*new VMail),
-	response(*new VResponse(arequest_info, charsets)),
-	cookie(*new VCookie),
-
-	// private
-	configure_admin_done(false),
-
-	// private defaults
-	fdefault_lang(adefault_lang), 
-	// private mime types
-	mime_types(0)
+	, sql_connect_time(0),sql_request_time(0)
+#endif
+	, method_frame(0), rcontext(0), wcontext(0),
+	finterrupted(false)
 {
-	// file_no=0 => unknown
-	file_list+=StringBody("UNKNOWN");
+	// default charsets
+	pool().set_source_charset(*utf8_charset);
+	pool().set_client_charset(*utf8_charset);
 
 	// maybe expire old caches
-	cache_managers.maybe_expire();
+	cache_managers->maybe_expire();
 	
 	/// directly used
 	// MAIN class, operators
 	classes().put(main_class.name(), &main_class);
 	// classes:
 	// table, file, random, mail, image, ...
-	methoded_array().register_directly_used(*this);
+	methoded_array->register_directly_used(*this);
 
 	/// methodless
 	// env class
-	classes().put(StringBody(ENV_CLASS_NAME), new VEnv(asapi_info));
+	classes().put(*NEW String(pool(), ENV_CLASS_NAME), &env);
 	// status class
 	if(status_allowed)
-		classes().put(StringBody(STATUS_CLASS_NAME), new VStatus());
+		classes().put(*NEW String(pool(), STATUS_CLASS_NAME), &status);
 	// request class
-	classes().put(StringBody(REQUEST_CLASS_NAME), new VRequest(arequest_info, charsets));	
+	classes().put(*NEW String(pool(), REQUEST_CLASS_NAME), &request);	
 	// cookie class
-	classes().put(StringBody(COOKIE_CLASS_NAME), &cookie);
+	classes().put(*NEW String(pool(), COOKIE_CLASS_NAME), &cookie);
 
 	/// methoded
 	// response class
-	classes().put(response.get_class()->name(), &response);
+	classes().put(response.get_class()->name(), &response);	
 
 	/// bases used
 	// form class
-	classes().put(form.get_class()->base_class()->name(), &form);
+	classes().put(form.get_class()->base_class()->name(), &form);	
 	// mail class
-	classes().put(mail.get_class()->base_class()->name(), &mail);
+	classes().put(mail.get_class()->base_class()->name(), &mail);	
 	// math class
-	{
-		Value& math=*new VMath;
-		classes().put(math.get_class()->base_class()->name(), &math);
-	}
-	// memory class
-	{
-		Value& memory=*new VMemory;
-		classes().put(memory.get_class()->base_class()->name(), &memory);
-	}
+	classes().put(math.get_class()->base_class()->name(), &math);	
 }
 
 Request::~Request() {
 #ifdef XML
 	// 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);
+	if(const char *xml_generic_errors=xmlGenericErrors()) {
+		SAPI::log(pool(), "warning: unreported xmlGenericErrors: %s", xml_generic_errors);
 		free((void *)xml_generic_errors);
 	}
 #endif
 }
 
-Value& Request::get_self() { return method_frame/*always have!*/->self(); }
+Value *Request::get_self() { return method_frame?&method_frame->self():0; }
 
-static void load_charset(HashStringValue::key_type akey, HashStringValue::value_type avalue, int) {
-	::charsets.load_charset(*new String(akey, String::L_CLEAN), avalue->as_string());
+static void load_charset(const Hash::Key& akey, Hash::Val *avalue, void *) {
+	charsets->load_charset(akey, static_cast<Value *>(avalue)->as_string());
 }
-void Request::configure_admin(VStateless_class& conf_class) {
+void Request::configure_admin(VStateless_class& conf_class, const String *source) {
 	if(configure_admin_done)
 		throw Exception("parser.runtime",
-		0,
+		source,
 		"parser already configured");
 	configure_admin_done=true;
 	
@@ -200,10 +139,10 @@ void Request::configure_admin(VStateless
 			...
 		]
 	*/
-	if(Value* vcharsets=conf_class.get_element(charsets_name, conf_class, false)) {
+	if(Value *vcharsets=conf_class.get_element(*charsets_name, conf_class, false)) {
 		if(!vcharsets->is_string())
-			if(HashStringValue* charsets=vcharsets->get_hash())
-				charsets->for_each(load_charset, 0);
+			if(Hash *charsets=vcharsets->get_hash(0))
+				charsets->for_each(load_charset);
 			else
 				throw Exception("parser.runtime",
 					0,
@@ -212,7 +151,7 @@ void Request::configure_admin(VStateless
 
 	// configure method_frame options
 	//	until someone with less privileges have overriden them
-	methoded_array().configure_admin(*this);
+	methoded_array->configure_admin(*this);
 }
 
 /**
@@ -226,7 +165,9 @@ void Request::configure_admin(VStateless
 	@test log stack trace
 
 */
-void Request::core(const char* config_filespec, bool config_fail_on_read_problem, bool header_only) {
+void Request::core(
+				   const char *config_filespec, bool config_fail_on_read_problem,
+				   bool header_only) {
 
 #ifdef RESOURCES_DEBUG
 //measures
@@ -235,9 +176,12 @@ struct timeval mt[10];
 gettimeofday(&mt[0],NULL);
 #endif
 	try {
+		char *auto_filespec=(char *)malloc(MAX_STRING);
+		
 		// loading config
 		if(config_filespec) {
-			const String& filespec=*new String(config_filespec);
+			String& filespec=*NEW String(pool());
+			filespec.APPEND_CLEAN(config_filespec, 0, "config", 0);
 			use_file(main_class,
 				filespec, true/* ignore class_path */, 
 				config_fail_on_read_problem, true/* file must exist if 'fail on read problem' not set */);
@@ -247,21 +191,21 @@ gettimeofday(&mt[0],NULL);
 		// to the one beside requested file.
 		// all assigned bases from upper dir
 		{
-			const char* after=request_info.path_translated;
-			size_t drlen=strlen(request_info.document_root);
-			if(memcmp(after, request_info.document_root, drlen)==0) {
+			const char *after=info.path_translated;
+			size_t drlen=strlen(info.document_root);
+			if(memcmp(after, info.document_root, drlen)==0) {
 				after+=drlen;
 				if(after[-1]=='/') 
 					--after;
 			}
 			
 			int step=0;
-			while(const char* before=strchr(after, '/')) {
-				String& sfile_spec=*new String;
-				if(after!=request_info.path_translated) {
-					sfile_spec.append_strdup(
-						request_info.path_translated, before-request_info.path_translated,
-						String::L_CLEAN);
+			while(const char *before=strchr(after, '/')) {
+				String& sfile_spec=*NEW String(pool());
+				if(after!=info.path_translated) {
+					sfile_spec.APPEND_CLEAN(
+						info.path_translated, before-info.path_translated,
+						"path-translated-scanned", step++);
 					sfile_spec << "/" AUTO_FILE_NAME;
 
 					use_file(main_class,
@@ -273,29 +217,29 @@ gettimeofday(&mt[0],NULL);
 		}
 
 		// compile requested file
-		String& spath_translated=*new String;
-		spath_translated.append_help_length(request_info.path_translated, 0, String::L_TAINTED);
+		String& spath_translated=*NEW String(pool());
+		spath_translated.APPEND_TAINTED(info.path_translated, 0, "user-request", 0);
 		use_file(main_class,
 			spath_translated, true/* ignore class_path */, 
 			true/* fail on read problem*/, true/* fail on abscence */);
 
 		// configure method_frame options if not configured yet
 		if(!configure_admin_done)
-			configure_admin(main_class);
+			configure_admin(main_class, 0);
 
 		// configure not-method_frame=user options
-		methoded_array().configure_user(*this);
+		methoded_array->configure_user(*this);
 
 		// $MAIN:MIME-TYPES
-		if(Value* element=main_class.get_element(mime_types_name, main_class, false))
+		if(Value *element=main_class.get_element(*mime_types_name, main_class, false))
 			if(Table *table=element->get_table())
 				mime_types=table;			
 
 		// filling form fields
-		form.fill_fields_and_tables(charsets, request_info);
+		form.fill_fields_and_tables(*this);
 
 		// filling cookies
-		cookie.fill_fields(request_info);
+		cookie.fill_fields(*this);
 
 		// filling mail received
 		mail.fill_received(*this);
@@ -305,10 +249,10 @@ gettimeofday(&mt[0],NULL);
 gettimeofday(&mt[1],NULL);
 #endif
 		// execute @main[]
-		const String* body_string=execute_virtual_method(main_class, main_method_name);
+		const String *body_string=execute_virtual_method(main_class, main_method_name);
 		if(!body_string)
 			throw Exception("parser.runtime",
-				0,
+				0, 
 				"'"MAIN_METHOD_NAME"' method not found");
 
 #ifdef RESOURCES_DEBUG
@@ -316,33 +260,43 @@ gettimeofday(&mt[1],NULL);
 gettimeofday(&mt[2],NULL);
 #endif
 
-		VString& body_vstring_before_post_process=*new VString(*body_string);
-		VString* body_vstring_after_post_process=&body_vstring_before_post_process;
+		VString body_vstring_before_post_process(*body_string);
+		VString *body_vstring_after_post_process=&body_vstring_before_post_process;
 		// @postprocess
-		if(Value* value=main_class.get_element(post_process_method_name, main_class, false))
-			if(Junction* junction=value->get_junction())
+		if(Value *value=main_class.get_element(
+				*NEW String(pool(), POST_PROCESS_METHOD_NAME), 
+				main_class, 
+				false))
+			if(Junction *junction=value->get_junction())
 				if(const Method *method=junction->method) {
 					// preparing to pass parameters to 
 					//	@postprocess[data]
-					VMethodFrame frame(/*method->name, */ *junction, 0/*no parent*/);
+					VMethodFrame frame(pool(), method->name, *junction, 0/*no parent*/);
 					frame.set_self(main_class);
 
-					frame.store_param(body_vstring_before_post_process);
+					frame.store_param(&body_vstring_before_post_process);
 					body_vstring_after_post_process=
-						new VString(execute_method(frame, *method));
+						NEW VString(execute_method(frame, *method));
 				}
 
-		VFile* body_file=body_vstring_after_post_process->as_vfile(
-			String::L_UNSPECIFIED, &charsets);
+		bool lorigins_mode=origins_mode();
+
+		const VFile *body_file=body_vstring_after_post_process->as_vfile(
+			String::UL_UNSPECIFIED, lorigins_mode);
 
 		// extract response body
-		Value* body_value=response.fields().get(download_name);
+		Value *body_value=static_cast<Value *>(
+			response.fields().get(*download_name));
 		bool as_attachment=body_value!=0;
 		if(!body_value)
-			body_value=response.fields().get(body_name);
+			body_value=static_cast<Value *>(
+				response.fields().get(*body_name));
 
 		if(body_value) // there is some $response:body
-			body_file=body_value->as_vfile(String::L_UNSPECIFIED, &charsets);
+			body_file=body_value->as_vfile();
+		else if(lorigins_mode)
+			response.fields().put(*content_type_name, 
+				NEW VString(*NEW String(pool(), ORIGINS_CONTENT_TYPE)));
 
 #ifdef RESOURCES_DEBUG
 //measure:after postprocess
@@ -350,7 +304,7 @@ gettimeofday(&mt[3],NULL);
 #endif
 
 		// OK. write out the result
-		output_result(body_file, header_only, as_attachment);
+		output_result(*body_file, header_only, as_attachment);
 
 #ifdef RESOURCES_DEBUG
 		//measure:after output_result
@@ -361,8 +315,8 @@ 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,
+SAPI::log(pool(), "rmeasure: %s,%.2f,%.2f,%.2f %.2f,%.2f %.2f", 
+info.uri,
 t[1]-t[0],
 t[2]-t[1],
 t[3]-t[2],
@@ -374,20 +328,27 @@ t[9]-t[3]
 		// we're returning not result, but error explanation
 		try {
 			// log the beast
-			if(const String* problem_source=e.problem_source())
-				SAPI::log(sapi_info,
+			if(const String *problem_source=e.problem_source())
+				SAPI::log(pool(),
 					"%s: "
+#ifndef NO_STRING_ORIGIN
+					ORIGIN_FILE_LINE_FORMAT": "
+#endif
 					"'%s' %s [%s]",
-					request_info.uri,
+					info.uri,
+#ifndef NO_STRING_ORIGIN
+					problem_source->origin().file?problem_source->origin().file:"global",
+					problem_source->origin().line,
+#endif
 					problem_source->cstr(),
 					e.comment(),
 					e.type()
 				);
 			else
-				SAPI::log(sapi_info,
+				SAPI::log(pool(),
 					"%s: "
 					"%s [%s]",
-					request_info.uri,
+					info.uri,
 					e.comment(), e.type()
 				);
 
@@ -398,44 +359,47 @@ t[9]-t[3]
 			response.fields().clear();
 
 			// this is what we'd return in $response:body
-			const String* body_string=0;
+			const String *body_string=0;
 
 			// maybe we'd be lucky enough as to report an error
 			// in a gracefull way...
-			if(Value* value=main_class.get_element(
-					*new String(UNHANDLED_EXCEPTION_METHOD_NAME), 
+			if(Value *value=main_class.get_element(
+					*NEW String(pool(), UNHANDLED_EXCEPTION_METHOD_NAME), 
 					main_class,
 					false)) {
-				if(Junction* junction=value->get_junction()) {
+				if(Junction *junction=value->get_junction()) {
 					if(const Method *method=junction->method) {
 		 				// preparing to pass parameters to 
 						//	@unhandled_exception[exception;stack]
-						VMethodFrame frame(/*method->name, */ *junction, 0/*no caller*/);
+						VMethodFrame frame(pool(), method->name, *junction, 0/*no caller*/);
 						frame.set_self(main_class);
 
 						// $exception
-						frame.store_param(exception2vhash(e));
+						frame.store_param(&exception2vhash(pool(), e));
 						// $stack[^table::set{name	origin}]
-						Table::columns_type stack_trace_columns(new ArrayString);
-						*stack_trace_columns+=new String("name");
-						*stack_trace_columns+=new String("file");
-						*stack_trace_columns+=new String("lineno");
-						*stack_trace_columns+=new String("colno");
-						Table& stack_trace=*new Table(stack_trace_columns);
-						for(Array_iterator<Trace> i(exception_trace); i.has_next(); ) {
-							Trace trace=i.next();
-							Table::element_type row(new ArrayString);
-
-							*row+=trace.name(); // name column
-							Operation::Info origin=trace.origin();
-							if(origin.file_no) {
-								*row+=new String(file_list[origin.file_no], String::L_TAINTED); // 'file' column
-								*row+=new String(StringBody::Format(1+origin.line), String::L_CLEAN); // 'lineno' column
-								*row+=new String(StringBody::Format(1+origin.col), String::L_CLEAN); // 'colno' column
+						Array& stack_trace_columns=*NEW Array(pool());
+						stack_trace_columns+=NEW String(pool(), "name");
+						stack_trace_columns+=NEW String(pool(), "file");
+						stack_trace_columns+=NEW String(pool(), "lineno");
+						Table& stack_trace=*NEW Table(pool(), 0, &stack_trace_columns);
+						Array_iter tracei(exception_trace);
+						while(tracei.has_next()) {
+							Array& row=*NEW Array(pool());
+
+							const String *name=(const String *)tracei.next();
+							row+=name; // name column
+#ifndef NO_STRING_ORIGIN
+							const Origin& origin=name->origin();
+							if(origin.file) {
+								row+=NEW String(pool(), origin.file, 0, true); // file column
+								char *buf=(char *)malloc(MAX_NUMBER);
+								size_t buf_size=snprintf(buf, MAX_NUMBER, "%d", 1+origin.line);
+								row+=NEW String(pool(), buf, buf_size, true); // line column
 							}
-							stack_trace+=row;
+#endif
+							stack_trace+=&row;
 						}
-						frame.store_param(*new VTable(&stack_trace));
+						frame.store_param(NEW VTable(pool(), &stack_trace));
 
 						// future $response:body=
 						//   execute ^unhandled_exception[exception;stack]
@@ -448,65 +412,65 @@ t[9]-t[3]
 				// doing that ugly
 
 				// make up result: $origin $source $comment $type $code
-				char *buf=new(PointerFreeGC) char[MAX_STRING];
+				char *buf=(char *)malloc(MAX_STRING);
 				size_t printed=0;
-				if(const String* problem_source=e.problem_source()) {
-					/*const String_fragment::Origin& origin=problem_source->origin();
+				if(const String *problem_source=e.problem_source()) {
+#ifndef NO_STRING_ORIGIN
+					const Origin& origin=problem_source->origin();
 					if(origin.file)
 						printed+=snprintf(buf+printed, MAX_STRING-printed, 
 							ORIGIN_FILE_LINE_FORMAT": ", 
 							origin.file, 1+origin.line
 						);
+#endif
 					printed+=snprintf(buf+printed, MAX_STRING-printed, "'%s' ", 
-						problem_source->cstr().get());
-						*/
+						problem_source->cstr());
 				}
-				if(const char* comment=e.comment(true))
+				if(const char *comment=e.comment(true))
 					printed+=snprintf(buf+printed, MAX_STRING-printed, "%s", comment);
-				if(const char* type=e.type(true)) 
+				if(const char *type=e.type(true)) 
 					printed+=snprintf(buf+printed, MAX_STRING-printed, "  type: %s",  type);
 
 				// future $response:content-type
-				response.fields().put(content_type_name, 
-					new VString(*new String(UNHANDLED_EXCEPTION_CONTENT_TYPE)));
+				response.fields().put(*content_type_name, 
+					NEW VString(*NEW String(pool(), UNHANDLED_EXCEPTION_CONTENT_TYPE)));
 				// future $response:body
-				body_string=new String(buf);
+				body_string=NEW String(pool(), buf);
 			}
 
 			VString body_vstring(*body_string);
-			VFile* body_file=body_vstring.as_vfile(String::L_UNSPECIFIED, &charsets);
+			const VFile *body_file=body_vstring.as_vfile();
 
 			// ERROR. write it out
-			output_result(body_file, header_only, false);
+			output_result(*body_file, header_only, false);
 		} catch(const Exception& ) {
-			rethrow;
+			/*re*/throw;
 		}
 	}
 }
 
-void Request::use_file(VStateless_class& aclass,
-		       const String& file_name, bool ignore_class_path, 
-		       bool fail_on_read_problem, bool fail_on_file_absence) {
+VStateless_class *Request::use_file(VStateless_class& aclass,
+									const String& file_name, bool ignore_class_path, 
+									bool fail_on_read_problem, bool fail_on_file_absence) {
 	// cyclic dependence check
 	if(used_files.get(file_name))
-		return;
-	used_files.put(file_name, true);
+		return 0;
+	used_files.put(file_name, (Hash::Val *)true);
 
-
-	const String* file_spec;
+	const String *file_spec;
 	if(ignore_class_path) // ignore_class_path?
 		file_spec=&file_name;
 	else if(file_name.first_char()=='/') //absolute path, no need to scan MAIN:CLASS_PATH?
 		file_spec=&absolute(file_name);
 	else {
 		file_spec=0;
-		if(Value* element=main_class.get_element(class_path_name, main_class, false)) {
+		if(Value *element=main_class.get_element(*class_path_name, main_class, false)) {
 			if(element->is_string()) {
 				file_spec=file_readable(absolute(element->as_string()), file_name); // found at class_path?
 			} else if(Table *table=element->get_table()) {
-				int size=table->count();
+				int size=table->size();
 				for(int i=size; i--; ) {
-					const String& path=*(*table->get(i))[0];
+					const String& path=*static_cast<Array *>(table->get(i))->get_string(0);
 					if(file_spec=file_readable(absolute(path), file_name))
 						break; // found along class_path
 				}
@@ -527,98 +491,114 @@ void Request::use_file(VStateless_class&
 
 	if(fail_on_read_problem && !fail_on_file_absence) // ignore file absence if asked for
 		if(!entry_exists(*file_spec))
-			return;
+			return 0;
+
+	char *source=file_read_text(pool(), *file_spec, fail_on_read_problem);
+	if(!source)
+		return 0;
 
-	file_list+=file_name;
-	if(const char* source=file_read_text(charsets.source(), *file_spec, fail_on_read_problem))
-		use_buf(aclass, source, file_list.count()-1);
+	return use_buf(aclass, source, *file_spec, file_spec->cstr());
 }
 
 
-void Request::use_buf(VStateless_class& aclass,
-		      const char* source, 
-		      uint file_no) {
+VStateless_class *Request::use_buf(VStateless_class& aclass,
+								   const char *source, 
+								   const String& filespec, const char *filespec_cstr) {
 	// temporary zero @conf so to maybe-replace it in compiled code
-	Temp_method temp_method_conf(aclass, conf_method_name, 0);
+	Temp_method temp_method_conf(aclass, *conf_method_name, 0);
 	// temporary zero @auto so to maybe-replace it in compiled code
-	Temp_method temp_method_auto(aclass, auto_method_name, 0);
+	Temp_method temp_method_auto(aclass, *auto_method_name, 0);
 
 	// compile loaded class
-	VStateless_class& cclass=compile(&aclass, source, file_no);
+	VStateless_class& cclass=COMPILE(aclass, source, filespec_cstr);
 
 	// locate and execute possible @conf[] static
-	VString* vfilespec=
-		new VString(*new String(file_list[file_no], String::L_TAINTED));
-	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*/);
+	VString *vfilespec=NEW VString(filespec);
+	const Method *method_called;
+	execute_nonvirtual_method(cclass, 
+		*conf_method_name, vfilespec,
+		0/*no result needed*/, &method_called);
+	if(method_called)
+		configure_admin(cclass, &method_called->name);
 
 	// locate and execute possible @auto[] static
 	execute_nonvirtual_method(cclass, 
-		auto_method_name, vfilespec,
-		false/*no result needed*/);
+		*auto_method_name, vfilespec,
+		0/*no result needed*/);
+	return &cclass;
 }
 
-const String& Request::relative(const char* apath, const String& relative_name) {
-	char *hpath=strdup(apath);
-	String& result=*new String;
-	if(rsplit(hpath, '/')) // if something/splitted
+const String& Request::relative(const char *apath, const String& relative_name) {
+	int hpath_buf_size=strlen(apath)+1;
+    char *hpath=(char *)malloc(hpath_buf_size);
+	memcpy(hpath, apath, hpath_buf_size);
+	String& result=*NEW String(pool());
+    if(rsplit(hpath, '/')) // if something/splitted
 		result << hpath << "/";
-	result << relative_name;
-	return result;
+    result << relative_name;
+    return result;
 }
 
 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(pool(), info.document_root);
 		result << relative_name;
 		return result;
 	} else 
-		return relative_name.pos("://")==STRING_NOT_FOUND?
-			relative(request_info.path_translated, relative_name)
-			:relative_name; // something like "http://xxx"
+		if(relative_name.pos("://")>0 // something like "http://xxx"
+#ifdef WIN32
+			|| relative_name.pos(":")==1  // DRIVE:
+			|| relative_name.starts_with("\\\\") // UNC1
+			|| relative_name.starts_with("//") // UNC2
+#endif
+			)
+			return relative_name;
+		else
+			return relative(info.path_translated, relative_name);
 }
 
-static void add_header_attribute(
-				 HashStringValue::key_type aattribute, 
-				 HashStringValue::value_type ameaning, 
-				 Request *r) {
+static void add_header_attribute(const Hash::Key& aattribute, Hash::Val *ameaning, 
+								 void *info) {
+	Request& r=*static_cast<Request *>(info);
 	if(aattribute==BODY_NAME
 		|| aattribute==DOWNLOAD_NAME
 		|| aattribute==CHARSET_NAME)
 		return;
 
-	SAPI::add_header_attribute(r->sapi_info,
+	Value& lmeaning=*static_cast<Value *>(ameaning);
+	Pool& pool=lmeaning.pool();
+
+	SAPI::add_header_attribute(pool,
 		aattribute.cstr(), 
-		attributed_meaning_to_string(*ameaning, String::L_HTTP_HEADER, false).
-			cstr(String::L_UNSPECIFIED));
+		attributed_meaning_to_string(lmeaning, String::UL_HTTP_HEADER, false)
+			.cstr(String::UL_UNSPECIFIED));
 }
-void Request::output_result(VFile* body_file, bool header_only, bool as_attachment) {
+void Request::output_result(const VFile& body_file, bool header_only, bool as_attachment) {
 	// header: cookies
-	cookie.output_result(sapi_info);
+	cookie.output_result();
 	
-	Value* body_file_content_type;
+	Value *body_file_content_type;
 	// set content-type
-	if(body_file_content_type=body_file->fields().get(content_type_name)) {
+	if(body_file_content_type=static_cast<Value *>(
+		body_file.fields().get(*content_type_name))) {
 		// body file content type
-		response.fields().put(content_type_name, body_file_content_type);
+		response.fields().put(*content_type_name, 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, 
+			default_content_type?default_content_type
+			:NEW VString(*NEW String(pool(), DEFAULT_CONTENT_TYPE)));
 	}
 
 	// content-disposition
-	if(Value* vfile_name=body_file->fields().get(name_name))
-		if(*vfile_name->get_string()!=NONAME_DAT) {
-			VHash& hash=*new VHash();
-			HashStringValue &h=hash.hash();
+	if(VString *vfile_name=static_cast<VString *>(body_file.fields().get(*name_name)))
+		if(vfile_name->string()!=NONAME_DAT) {
+			VHash& vhash=*NEW VHash(pool());
+			Hash& hash=vhash.hash(0);
 			if(as_attachment)
-				h.put(value_name, new VString(content_disposition_value));
-			h.put(content_disposition_filename_name, vfile_name);
-			response.fields().put(content_disposition_name, &hash);
+				hash.put(*value_name, NEW VString(*content_disposition_value));
+			hash.put(*content_disposition_filename_name, vfile_name);
+			response.fields().put(*content_disposition_name, &vhash);
 		}
 
 	// prepare header: $response:fields without :body
@@ -628,61 +608,47 @@ void Request::output_result(VFile* body_
 	size_t client_content_length;
 	// transcode text body when "text/*" or simple result
 	if(body_file_content_type)
-		if(HashStringValue *hash=body_file_content_type->get_hash())
-			body_file_content_type=hash->get(value_name);
+		if(Hash *hash=body_file_content_type->get_hash(0))
+			body_file_content_type=static_cast<Value *>(hash->get(*value_name));
 	if(!body_file_content_type/*vstring.as_vfile*/ || body_file_content_type->as_string().pos("text/")==0) {
-		Charset::transcode(
-			charsets.source(), body_file->value_ptr(), body_file->value_size(),
-			charsets.client(), client_body, client_content_length
+		Charset::transcode(pool(),
+			pool().get_source_charset(), body_file.value_ptr(), body_file.value_size(),
+			pool().get_client_charset(), client_body, client_content_length
 		);
 	} else {
-		client_body=body_file->value_ptr();
-		client_content_length=body_file->value_size();
+		client_body=body_file.value_ptr();
+		client_content_length=body_file.value_size();
 	}
 
 	// prepare header: content-length
 	char content_length_cstr[MAX_NUMBER];
 	snprintf(content_length_cstr, MAX_NUMBER, "%u", client_content_length);
-	SAPI::add_header_attribute(sapi_info, "content-length", content_length_cstr);
+	SAPI::add_header_attribute(pool(), "content-length", content_length_cstr);
 
 	// send header
-	SAPI::send_header(sapi_info);
+	SAPI::send_header(pool());
 	
 	// send body
 	if(!header_only)
-		SAPI::send_body(sapi_info, client_body, client_content_length);
+		SAPI::send_body(pool(), client_body, client_content_length);
 }
 
-const String& Request::mime_type_of(const char* user_file_name_cstr) {
+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);
-			if(mime_types->locate(0, sext.change_case(charsets.source(), String::CC_LOWER)))
-					if(const String* result=mime_types->item(1))
-						return *result;
+		if(const char *cext=strrchr(user_file_name_cstr, '.')) {
+			String sext(pool(), ++cext);
+			Table::Action_options options;
+			if(mime_types->locate(0, sext.change_case(pool(), String::CC_LOWER), options))
+				if(const String *result=mime_types->item(1))
+					return *result;
 				else
 					throw Exception("parser.runtime",
-						0,
+						mime_types->origin_string(),
 						MIME_TYPES_NAME  " table column elements must not be empty");
 		}
-
-	return *new String("application/octet-stream");
+	return *NEW String(pool(), "application/octet-stream");
 }
 
-#ifdef XML
-GdomeDOMString_auto_ptr Request::transcode(const String& s) {
-	return charsets.source().transcode(s);
-}
-
-GdomeDOMString_auto_ptr Request::transcode(const StringBody s) {
-	return charsets.source().transcode(s);
-}
-
-const String& Request::transcode(GdomeDOMString* s) {
-	return charsets.source().transcode(s);
-}
-
-const String& Request::transcode(xmlChar* s) {
-	return charsets.source().transcode(s);
+bool Request::origins_mode() {
+	return main_class.get_element(*origins_mode_name, main_class, false)!=0;  // $ORIGINS mode
 }
-#endif