--- parser3/src/main/pa_request.C	2003/03/21 14:27:52	1.245.2.37.2.6
+++ parser3/src/main/pa_request.C	2004/02/26 14:37:30	1.266
@@ -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-2004 ArtLebedev Group (http://www.artlebedev.com)
 	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
 */
 
-static const char* IDENT_REQUEST_C="$Date: 2003/03/21 14:27:52 $";
+static const char * const IDENT_REQUEST_C="$Date: 2004/02/26 14:37:30 $";
 
 #include "pa_sapi.h"
 #include "pa_common.h"
@@ -30,6 +30,8 @@ static const char* IDENT_REQUEST_C="$Dat
 #include "pa_vform.h"
 #include "pa_vcookie.h"
 #include "pa_vresponse.h"
+#include "pa_vmemory.h"
+#include "pa_vconsole.h"
 
 // consts
 
@@ -47,15 +49,22 @@ const char* ORIGINS_CONTENT_TYPE="text/p
 #define MAIN_METHOD_NAME "main"
 #define AUTO_METHOD_NAME "auto"
 #define BODY_NAME "body"
+#define EXCEPTION_TYPE_PART_NAME "type"
+#define EXCEPTION_SOURCE_PART_NAME "source"
+#define EXCEPTION_COMMENT_PART_NAME "comment"
 
 // globals
 
-const String& main_method_name(new String(MAIN_METHOD_NAME));
-const String& auto_method_name(new String(AUTO_METHOD_NAME));
-const String& content_disposition_name(new String(CONTENT_DISPOSITION_NAME));
-const String& content_disposition_value(new String(CONTENT_DISPOSITION_VALUE));
-const String& content_disposition_filename_name(new String(CONTENT_DISPOSITION_FILENAME_NAME));
-const String& body_name(new String(BODY_NAME));
+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);
+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);
 
 // defines for statics
 
@@ -69,27 +78,24 @@ const String& body_name(new String(BODY_
 
 // statics
 
-static const String& charsets_name(new String(CHARSETS_NAME));
-static const String& main_class_name(new String(MAIN_CLASS_NAME));
-static const String& mime_types_name(new String(MIME_TYPES_NAME));
-static const String& origins_mode_name(new String(ORIGINS_MODE_NAME));
-static const String& conf_method_name(new String(CONF_METHOD_NAME));
-static const String& post_process_method_name(new String(POST_PROCESS_METHOD_NAME));
-static const String& download_name(new String(DOWNLOAD_NAME));
-static const String& class_path_name(new String(CLASS_PATH_NAME));
+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
 
 // op.C
-VStateless_class* VClassMAIN_create();
-// op.C
-VHash* exception2vhashconst Exception& e);
+VStateless_class& VClassMAIN_create();
 
 //
 Request::Request(SAPI_Info& asapi_info, Request_info& arequest_info, 
-				 Language adefault_lang, bool status_allowed):
+				 String::Language adefault_lang, bool status_allowed):
 	// private
-	f
 	anti_endless_execute_recoursion(0),
 
 	// public
@@ -107,15 +113,15 @@ Request::Request(SAPI_Info& asapi_info,
 #endif	
 
 	// public
-	sapi_info(asapi_info),
 	request_info(arequest_info),
-	charsets(*UTF8_charset, *UTF8_charset, *UTF8_charset), // default charsets
+	sapi_info(asapi_info),
+	charsets(UTF8_charset, UTF8_charset, UTF8_charset), // default charsets
 
 	main_class(VClassMAIN_create()),
-	form(new VForm),
-	mail(new VMail),
-	response(new VResponse(farequest_info, charsets)),
-	cookie(new VCookie),
+	form(*new VForm(charsets, arequest_info)),
+	mail(*new VMail),
+	response(*new VResponse(arequest_info, charsets)),
+	cookie(*new VCookie),
 
 	// private
 	configure_admin_done(false),
@@ -125,43 +131,53 @@ Request::Request(SAPI_Info& asapi_info,
 	// private mime types
 	mime_types(0)
 {
+	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
+
 	// 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().put(main_class.name(), &main_class);
 	// classes:
 	// table, file, random, mail, image, ...
 	methoded_array().register_directly_used(*this);
 
 	/// methodless
 	// env class
-	classes().put(String* (new String(ENV_CLASS_NAME)), 
-			Value*(new VEnv(asapi_info)));
+	classes().put(String::Body(ENV_CLASS_NAME), new VEnv(asapi_info));
 	// status class
 	if(status_allowed)
-		classes().put(String* (new String(STATUS_CLASS_NAME)), 
-			Value*(new VStatus()));
+		classes().put(String::Body(STATUS_CLASS_NAME), new VStatus());
 	// request class
-	classes().put(String* (new String(REQUEST_CLASS_NAME)), 
-		Value*(new VRequest(arequest_info, charsets)));	
+	classes().put(String::Body(REQUEST_CLASS_NAME), new VRequest(arequest_info, charsets));	
 	// cookie class
-	classes().put(String* (new String(COOKIE_CLASS_NAME)), cookie);
+	classes().put(String::Body(COOKIE_CLASS_NAME), &cookie);
+	// console class
+	classes().put(String::Body(CONSOLE_CLASS_NAME), new VConsole());
 
 	/// 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);	
+		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);
 	}
 }
 
@@ -175,15 +191,18 @@ Request::~Request() {
 #endif
 }
 
-Value* Request::get_self() { return method_frame?method_frame->get_self():0; }
+Value& Request::get_self() { return method_frame/*always have!*/->self(); }
 
-static void load_charset(HashStringValue::key_type akey, HashStringValue::value_type avalue, int) {
-	::charsets.load_charset(akey, avalue->as_string(0));
+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());
 }
-void Request::configure_admin(VStateless_class& conf_class, const String* source) {
+void Request::configure_admin(VStateless_class& conf_class) {
 	if(configure_admin_done)
 		throw Exception("parser.runtime",
-		source,
+		0,
 		"parser already configured");
 	configure_admin_done=true;
 	
@@ -197,8 +216,8 @@ void Request::configure_admin(VStateless
 	*/
 	if(Value* vcharsets=conf_class.get_element(charsets_name, conf_class, false)) {
 		if(!vcharsets->is_string())
-			if(HashStringValue* charsets=vcharsets->get_hash(0))
-				charsets->for_each(load_charset, 0);
+			if(HashStringValue* charsets=vcharsets->get_hash())
+				charsets->for_each(load_charset, &this->charsets);
 			else
 				throw Exception("parser.runtime",
 					0,
@@ -221,9 +240,7 @@ 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
@@ -234,11 +251,12 @@ gettimeofday(&mt[0],NULL);
 	try {
 		// loading config
 		if(config_filespec) {
-			const String& filespec(new String);
-			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 */);
+			const String& filespec=*new String(config_filespec);
+			use_file(main_class,
+				filespec, 0 /*main_alias*/, 
+				true /*ignore class_path*/, 
+				config_fail_on_read_problem, 
+				true /*file must exist if 'fail on read problem' not set*/);
 		}
 
 		// loading auto.p files from document_root/.. 
@@ -253,57 +271,57 @@ gettimeofday(&mt[0],NULL);
 					--after;
 			}
 			
-			int step=0;
 			while(const char* before=strchr(after, '/')) {
-				const String& sfile_spec(new String);
+				String& sfile_spec=*new String;
 				if(after!=request_info.path_translated) {
-					sfile_spec->APPEND_CLEAN(
+					sfile_spec.append_strdup(
 						request_info.path_translated, before-request_info.path_translated,
-						"path-translated-scanned", step++);
-					*sfile_spec << "/" AUTO_FILE_NAME;
+						String::L_CLEAN);
+					sfile_spec << "/" AUTO_FILE_NAME;
 
-					use_file(*main_class,
-						sfile_spec, true/* ignore class_path */, 
-						true/* fail on read problem */, false/* but ignore absence, sole user */);
+					use_file(main_class,
+						sfile_spec, 
+						0 /*main_alias*/,
+						true /*ignore class_path*/, 
+						true /*fail on read problem*/, 
+						false /*but ignore absence, sole user*/);
 				}
 				after=before+1;
 			}
 		}
 
 		// compile requested file
-		const String& spath_translated(new String);
-		spath_translated->APPEND_TAINTED(request_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 */);
+		String& spath_translated=*new String;
+		spath_translated.append_help_length(request_info.path_translated, 0, String::L_TAINTED);
+		use_file(main_class,
+			spath_translated, 
+			0 /*main_alias*/,
+			true /*ignore class_path*/);
 
 		// configure method_frame options if not configured yet
 		if(!configure_admin_done)
-			configure_admin(*main_class, 0);
+			configure_admin(main_class);
 
 		// configure not-method_frame=user options
 		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);
-
 		// filling cookies
-		cookie->fill_fields(request_info);
+		cookie.fill_fields(request_info);
 
 		// filling mail received
-		mail->fill_received(*this);
+		mail.fill_received(*this);
 
 #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);
+		const String* body_string=execute_virtual_method(main_class, main_method_name);
 		if(!body_string)
 			throw Exception("parser.runtime",
 				0,
@@ -314,33 +332,29 @@ gettimeofday(&mt[1],NULL);
 gettimeofday(&mt[2],NULL);
 #endif
 
-		const VString& body_vstring_before_post_process(new VString(body_string));
-		const VString& body_vstring_after_post_process(body_vstring_before_post_process);
+		// extract response body
+		Value* body_value=response.fields().get(download_name); // $response:download?
+		bool as_attachment=body_value!=0;
+		if(!body_value)
+			body_value=response.fields().get(body_name); // $response:body
+		if(!body_value)
+			body_value=new VString(*body_string); // just result of ^main[]
+
 		// @postprocess
-		if(Value* value=main_class->get_element(post_process_method_name, *main_class, false))
+		if(Value* value=main_class.get_element(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*/); frame.ref();
+					VMethodFrame frame(/*method->name, */ *junction, 0/*no parent*/);
 					frame.set_self(main_class);
 
-					frame.store_param(body_vstring_before_post_process);
-					body_vstring_after_post_process=
-						VString* (new VString(execute_method(frame, *method)));
+					frame.store_param(*body_value);
+					body_value=&execute_method(frame, *method).as_value();
 				}
 
-		VFile* body_file=body_vstring_after_post_process->as_vfile(
-			String::L_UNSPECIFIED);
-
-		// extract response body
-		Value* body_value=response->fields().get(download_name);
-		bool as_attachment=body_value!=0;
-		if(!body_value)
-			body_value=response->fields().get(body_name);
-
-		if(body_value) // there is some $response:body
-			body_file=body_value->as_vfile();
+		VFile* body_file=body_value->as_vfile(
+			String::L_UNSPECIFIED, &charsets);
 
 #ifdef RESOURCES_DEBUG
 //measure:after postprocess
@@ -370,152 +384,154 @@ t[9]-t[3]
 #endif
 	} catch(const Exception& e) { // request handling problem
 		// we're returning not result, but error explanation
-		try {
-			// log the beast
-			if(const String* problem_source=e.problem_source())
+#define PA_URI_FORMAT "%s: "
+#define PA_ORIGIN_FILE_POS_FORMAT "%s(%d:%d): "
+#define PA_SOURCE_FORMAT "'%s' "
+#define PA_COMMENT_TYPE_FORMAT "%s [%s]"
+		// log the beast
+		Request::Exception_details details=get_details(e);
+
+		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();
 				SAPI::log(sapi_info,
-					"%s: "
-#ifndef NO_STRING_ORIGIN
-					ORIGIN_FILE_LINE_FORMAT": "
-#endif
-					"'%s' %s [%s]",
+					PA_URI_FORMAT 
+					PA_ORIGIN_FILE_POS_FORMAT 
+					PA_SOURCE_FORMAT PA_COMMENT_TYPE_FORMAT,
 					request_info.uri,
-#ifndef NO_STRING_ORIGIN
-					problem_source->origin().file?problem_source->origin().file:"global",
-					problem_source->origin().line,
-#endif
-					problem_source->cstr().get(),
-					e.comment(),
-					e.type()
+					file_list[origin.file_no].cstr(), 1+origin.line, 1+origin.col,
+					details.problem_source->cstr(),
+					e.comment(), e.type()
 				);
-			else
+			} else
 				SAPI::log(sapi_info,
-					"%s: "
-					"%s [%s]",
+					PA_URI_FORMAT 
+					PA_SOURCE_FORMAT PA_COMMENT_TYPE_FORMAT,
 					request_info.uri,
+					details.problem_source->cstr(),
 					e.comment(), e.type()
 				);
+		} else
+			SAPI::log(sapi_info,
+				PA_URI_FORMAT 
+				PA_COMMENT_TYPE_FORMAT,
+				request_info.uri,
+				e.comment(), e.type()
+			);
+
+		// reset language to default
+		flang=fdefault_lang;
+		
+		// reset response
+		response.fields().clear();
+
+		// this is what we'd return in $response:body
+		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), 
+				main_class,
+				false)) {
+			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*/);
+frame.set_self(main_class);
+
+// $exception
+frame.store_param(details.vhash);
+// $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);
+if(!exception_trace.is_empty()/*signed!*/) 
+for(size_t i=exception_trace.bottom_index(); i<exception_trace.top_index(); i++) {
+	Trace trace=exception_trace.get(i);
+	Table::element_type row(new ArrayString);
+
+	*row+=trace.name(); // name column
+	Operation::Origin origin=trace.origin();
+	if(origin.file_no) {
+		*row+=new String(file_list[origin.file_no], String::L_TAINTED); // 'file' column
+		*row+=new String(String::Body::Format(1+origin.line), String::L_CLEAN); // 'lineno' column
+		*row+=new String(String::Body::Format(1+origin.col), String::L_CLEAN); // 'colno' column
+	}
+	stack_trace+=row;
+}
+frame.store_param(*new VTable(&stack_trace));
 
-			// reset language to default
-			flang=fdefault_lang;
-			
-			// reset response
-			response->fields().clear();
-
-			// this is what we'd return in $response:body
-			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(
-					String* (new String(UNHANDLED_EXCEPTION_METHOD_NAME)), 
-					*main_class,
-					false)) {
-				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*/); frame.ref();
-						frame.set_self(main_class);
-
-						// $exception
-						frame.store_param(exception2vhash(e));
-						// $stack[^table::set{name	origin}]
-						Table::columns_type stack_trace_columns(new ArrayString);
-						*stack_trace_columns+=String* (new String("name"));
-						*stack_trace_columns+=String* (new String("file"));
-						*stack_trace_columns+=String* (new String("lineno"));
-						Table* stack_trace(new Table(0, stack_trace_columns));
-						Array_iterator<String*> tracei(exception_trace);
-						while(tracei.has_next()) {
-							Table::element_type row(new ArrayString);
-
-							const String& name=tracei.next();
-							*row+=name; // name column
-#ifndef NO_STRING_ORIGIN
-							const String_fragment::Origin& origin=name->origin();
-							if(origin.file) {
-								*row+=String* (new String(origin.file, 0, true)); // file column
-								*row+=String* (new String(
-									pool().format_integer(1+origin.line), 
-									0, true)); // line column
-							}
-#endif
-							*stack_trace+=row;
-						}
-						frame.store_param(Value*(new VTable(stack_trace)));
-
-						// future $response:body=
-						//   execute ^unhandled_exception[exception;stack]
-						body_string=execute_method(frame, *method);
-					}
-				}
-			}
-			
-			if(!body_string) {  // couldn't report an error beautifully?
-				// doing that ugly
-
-				// make up result: $origin $source $comment $type $code
-				char *buf=new char[MAX_STRING];
-				size_t printed=0;
-				if(const String* problem_source=e.problem_source()) {
-#ifndef NO_STRING_ORIGIN
-					const String_fragment::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());
+// future $response:body=
+//   execute ^unhandled_exception[exception;stack]
+body_string=&execute_method(frame, *method).as_string();
 				}
-				if(const char* comment=e.comment(true))
-					printed+=snprintf(buf+printed, MAX_STRING-printed, "%s", comment);
-				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, 
-					Value*(new VString(String* (new String(UNHANDLED_EXCEPTION_CONTENT_TYPE)))));
-				// future $response:body
-				body_string=String* (new String(buf));
 			}
+		}
+		
+		if(!body_string) {  // couldn't report an error beautifully?
+			// doing that ugly
+
+			// make up result: $origin $source $comment $type $code
+			char *buf=new(PointerFreeGC) char[MAX_STRING];
+			size_t printed=0;
+			if(const String* problem_source=e.problem_source())
+				printed+=snprintf(buf+printed, MAX_STRING-printed, "'%s' ", 
+					problem_source->cstr());
+			if(const char* comment=e.comment(true))
+				printed+=snprintf(buf+printed, MAX_STRING-printed, "%s", comment);
+			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)));
+			// future $response:body
+			body_string=new String(buf);
+		}
 
-			VString body_vstring(body_string);
-			VFile* body_file=body_vstring.as_vfile();
+		VString body_vstring(*body_string);
+		VFile* body_file=body_vstring.as_vfile(String::L_UNSPECIFIED, &charsets);
 
-			// ERROR. write it out
-			output_result(body_file, header_only, false);
-		} catch(const Exception& ) {
-			rethrow;
-		}
+		// ERROR. write it out
+		output_result(body_file, header_only, false);
 	}
 }
 
+uint Request::register_file(String::Body file_spec) {
+	file_list+=file_spec;
+	return file_list.count()-1;
+}
+
 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) {
+		       const String& file_name, const String* main_alias, 
+		       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);
 
-	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);
+		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?
+				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();
 				for(int i=size; i--; ) {
-					const String& path=(*table->get(i))[0];
-					if(file_spec=file_readable(*absolute(path), *file_name))
+					const String& path=*(*table->get(i))[0];
+					if((file_spec=file_readable(absolute(path), file_name)))
 						break; // found along class_path
 				}
 			} else
@@ -524,42 +540,44 @@ void Request::use_file(VStateless_class&
 					"$" CLASS_PATH_NAME " must be string or table");
 			if(!file_spec)
 				throw Exception("parser.runtime",
-					file_name,
+					&file_name,
 					"not found along " MAIN_CLASS_NAME ":" CLASS_PATH_NAME);
 		}
 		if(!file_spec)
 			throw Exception("parser.runtime",
-				file_name,
+				&file_name,
 				"usage failed - no $" MAIN_CLASS_NAME  ":" CLASS_PATH_NAME " were specified");
 	}
 
 	if(fail_on_read_problem && !fail_on_file_absence) // ignore file absence if asked for
-		if(!entry_exists(file_spec))
+		if(!entry_exists(*file_spec))
 			return;
 
-	if(const char* source=file_read_text(charsets.source(), file_spec, fail_on_read_problem))
-		use_buf(aclass, source, file_spec, file_spec->cstr());
+	if(const char* source=file_read_text(charsets, *file_spec, fail_on_read_problem))
+		use_buf(aclass, source, main_alias, register_file(*file_spec));
 }
 
 
 void Request::use_buf(VStateless_class& aclass,
-								   const char* source, 
-								   const String& filespec, const char* filespec_cstr) {
+		      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
-	Temp_method temp_method_conf(aclass, conf_method_name, Method*(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, Method*(0));
+	Temp_method temp_method_auto(aclass, auto_method_name, 0);
 
 	// compile loaded class
-	VStateless_class& cclass=COMPILE(&aclass, source, filespec_cstr);
+	VStateless_class& cclass=compile(&aclass, source, main_alias, file_no, line_no_offset);
 
 	// locate and execute possible @conf[] static
-	const VString& vfilespec(new VString(filespec));
+	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);
+		configure_admin(cclass/*, executed.method->name*/);
 
 	// locate and execute possible @auto[] static
 	execute_nonvirtual_method(cclass, 
@@ -568,86 +586,88 @@ void Request::use_buf(VStateless_class&
 }
 
 const String& Request::relative(const char* apath, const String& relative_name) {
-    char *hpath=pool().copy(apath);
-	const String& result(new String);
-    if(rsplit(hpath, '/')) // if something/splitted
-		*result << hpath << "/";
-    *result << relative_name;
-    return result;
+	char *hpath=strdup(apath);
+	String& result=*new String;
+	if(rsplit(hpath, '/')) // if something/splitted
+		result << hpath << "/";
+	result << relative_name;
+	return result;
 }
 
 const String& Request::absolute(const String& relative_name) {
-	if(relative_name->first_char()=='/') {
-		const String& result=String* (new String(request_info.document_root));
-		*result << relative_name;
+	if(relative_name.first_char()=='/') {
+		String& result=*new String(strdup(request_info.document_root));
+		result << relative_name;
 		return result;
 	} else 
-		return relative_name->pos("://")<0? relative(request_info.path_translated, relative_name)
-			:relative_name; // something like "http://xxx"
+		if(relative_name.pos("://")!=STRING_NOT_FOUND // 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(request_info.path_translated, relative_name);
 }
 
 static void add_header_attribute(
-								 HashStringValue::key_type aattribute, 
-								 HashStringValue::value_type ameaning, 
-								 Request *r) {
-	if(*aattribute==BODY_NAME
-		|| *aattribute==DOWNLOAD_NAME
-		|| *aattribute==CHARSET_NAME)
+				 HashStringValue::key_type aattribute, 
+				 HashStringValue::value_type ameaning, 
+				 Request *r) {
+	if(aattribute==BODY_NAME
+		|| aattribute==DOWNLOAD_NAME
+		|| aattribute==CHARSET_NAME)
 		return;
 
 	SAPI::add_header_attribute(r->sapi_info,
-		aattribute->cstr(), 
-		attributed_meaning_to_string(r->ameaning, String::L_HTTP_HEADER, false)->
+		aattribute.cstr(), 
+		attributed_meaning_to_string(*ameaning, String::L_HTTP_HEADER, false).
 			cstr(String::L_UNSPECIFIED));
 }
 void Request::output_result(VFile* body_file, bool header_only, bool as_attachment) {
 	// header: cookies
-	cookie->output_result(sapi_info);
+	cookie.output_result(sapi_info);
 	
 	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=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, 
-			Value*(new VString(String* (new String(DEFAULT_CONTENT_TYPE)))));
+		response.fields().put_dont_replace(content_type_name, 
+			new VString(*new String(DEFAULT_CONTENT_TYPE)));
 	}
 
 	// content-disposition
 	if(Value* vfile_name=body_file->fields().get(name_name))
-		if(*vfile_name->get_string(&fpool)!=NONAME_DAT) {
-			VHash* hash(new VHash);
-			HashStringValue &h=hash->hash(0);
+		if(*vfile_name->get_string()!=NONAME_DAT) {
+			VHash& hash=*new VHash();
+			HashStringValue &h=hash.hash();
 			if(as_attachment)
-				h.put(value_name, Value*(new VString(content_disposition_value)));
+				h.put(value_name, new VString(content_disposition_value));
 			h.put(content_disposition_filename_name, vfile_name);
-			response->fields().put(content_disposition_name, hash);
+			response.fields().put(content_disposition_name, &hash);
 		}
 
 	// prepare header: $response:fields without :body
-	response->fields().for_each(add_header_attribute, this);
+	response.fields().for_each(add_header_attribute, this);
 
-	const void *client_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(0))
+		if(HashStringValue *hash=body_file_content_type->get_hash())
 			body_file_content_type=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
-		);
-	} else {
-		client_body=body_file->value_ptr();
-		client_content_length=body_file->value_size();
-	}
+	String::C output(body_file->value_ptr(), body_file->value_size());
+	if(!body_file_content_type/*vstring.as_vfile*/ || body_file_content_type->as_string().pos("text/")==0)
+		output=Charset::transcode(output, 
+			charsets.source(), 
+			charsets.client());
 
 	// prepare header: content-length
 	char content_length_cstr[MAX_NUMBER];
-	snprintf(content_length_cstr, MAX_NUMBER, "%u", client_content_length);
+	snprintf(content_length_cstr, MAX_NUMBER, "%u", output.length);
 	SAPI::add_header_attribute(sapi_info, "content-length", content_length_cstr);
 
 	// send header
@@ -655,52 +675,96 @@ void Request::output_result(VFile* body_
 	
 	// send body
 	if(!header_only)
-		SAPI::send_body(sapi_info, client_body, client_content_length);
+		SAPI::send_body(sapi_info, output.str, output.length);
 }
 
 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;
+			Table::Action_options 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",
-						mime_types->origin_string(),
+						0,
 						MIME_TYPES_NAME  " table column elements must not be empty");
 		}
 
-	return String* (new String("application/octet-stream"));
+	return *new String("application/octet-stream");
 }
 
 #ifdef XML
-
 GdomeDOMString_auto_ptr Request::transcode(const String& s) {
 	return charsets.source().transcode(s);
 }
 
-const String& Request::transcode(GdomeDOMString* s
-#ifndef NO_STRING_ORIGIN
-	, const String& origin
-#endif
-	) {
-	return charsets.source().transcode(s
-#ifndef NO_STRING_ORIGIN
-		, origin
-#endif
-		);
+GdomeDOMString_auto_ptr Request::transcode(const String::Body s) {
+	return charsets.source().transcode(s);
 }
 
-const String& Request::transcode(xmlChar* s
-#ifndef NO_STRING_ORIGIN
-	, const String& origin
-#endif
-	) {
-	return charsets.source().transcode(s
-#ifndef NO_STRING_ORIGIN
-		, origin
-#endif
-		);
+const String& Request::transcode(GdomeDOMString* s) {
+	return charsets.source().transcode(s);
+}
+
+const String& Request::transcode(xmlChar* s) {
+	return charsets.source().transcode(s);
 }
 #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 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();
+
+	// $.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; 
+		source.append(*problem_source, String::L_TAINTED, true/*forced*/);
+
+		hash.put(exception_source_part_name, new VString(source));
+	}
+
+	// $.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));
+	}
+
+	// $.comment
+	if(const char* comment=e.comment(true))
+		hash.put(exception_comment_part_name, 
+			new VString(*new String(comment, 0, true/*tainted*/)));
+
+	// $.handled(0)
+	hash.put(exception_handled_part_name, new VBool(false));
+
+	return Request::Exception_details(trace, problem_source, vhash);
+}