--- parser3/src/main/pa_request.C	2003/03/08 16:41:30	1.245.2.36
+++ parser3/src/main/pa_request.C	2003/04/11 15:00:05	1.246
@@ -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/03/08 16:41:30 $";
+static const char* IDENT_REQUEST_C="$Date: 2003/04/11 15:00:05 $";
 
 #include "pa_sapi.h"
 #include "pa_common.h"
@@ -16,171 +16,115 @@ 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"
 
-// 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
-
-StringPtr main_method_name(new String(MAIN_METHOD_NAME));
-StringPtr auto_method_name(new String(AUTO_METHOD_NAME));
-StringPtr content_disposition_name(new String(CONTENT_DISPOSITION_NAME));
-StringPtr content_disposition_value(new String(CONTENT_DISPOSITION_VALUE));
-StringPtr content_disposition_filename_name(new String(CONTENT_DISPOSITION_FILENAME_NAME));
-StringPtr body_name(new String(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 StringPtr charsets_name(new String(CHARSETS_NAME));
-static StringPtr main_class_name(new String(MAIN_CLASS_NAME));
-static StringPtr mime_types_name(new String(MIME_TYPES_NAME));
-static StringPtr origins_mode_name(new String(ORIGINS_MODE_NAME));
-static StringPtr conf_method_name(new String(CONF_METHOD_NAME));
-static StringPtr post_process_method_name(new String(POST_PROCESS_METHOD_NAME));
-static StringPtr download_name(new String(DOWNLOAD_NAME));
-static StringPtr class_path_name(new String(CLASS_PATH_NAME));
-
-// defines
+const char *DEFAULT_CONTENT_TYPE="text/html";
+const char *ORIGINS_CONTENT_TYPE="text/plain";
 
 // op.C
-VStateless_classPtr VClassMAIN_create();
+VClass& VClassMAIN_create(Pool& pool);
 // op.C
-VHashPtr exception2vhash(Pool& pool, const Exception& e);
+VHash& exception2vhash(Pool& pool, const Exception& e);
 
 //
-Request::Request(Pool& apool, SAPI_Info& asapi_info, Request_info& arequest_info, 
-				 String_UL adefault_lang, bool status_allowed):
-	// private
-	fpool(apool),
-	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(pool(), *UTF8_charset, *UTF8_charset, *UTF8_charset), // default charsets
-
-	main_class(VClassMAIN_create()),
-	form(new VForm),
-	mail(new VMail),
-	response(new VResponse(fpool, 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)
 {
+	// 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().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(StringPtr(new String(ENV_CLASS_NAME)), 
-			ValuePtr(new VEnv(pool(), asapi_info)));
+	classes().put(*NEW String(pool(), ENV_CLASS_NAME), &env);
 	// status class
 	if(status_allowed)
-		classes().put(StringPtr(new String(STATUS_CLASS_NAME)), 
-			ValuePtr(new VStatus(pool())));
+		classes().put(*NEW String(pool(), STATUS_CLASS_NAME), &status);
 	// request class
-	classes().put(StringPtr(new String(REQUEST_CLASS_NAME)), 
-		ValuePtr(new VRequest(arequest_info, charsets)));	
+	classes().put(*NEW String(pool(), REQUEST_CLASS_NAME), &request);	
 	// cookie class
-	classes().put(StringPtr(new String(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
-	{
-		ValuePtr math(new VMath);
-		classes().put(math->get_class()->base_class()->name(), math);	
-	}
+	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
 }
 
-ValuePtr Request::get_self() { return method_frame?method_frame->get_self():ValuePtr(0); }
+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(akey, avalue->as_string(0));
+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, StringPtr source) {
+void Request::configure_admin(VStateless_class& conf_class, const String *source) {
 	if(configure_admin_done)
 		throw Exception("parser.runtime",
 		source,
@@ -195,19 +139,19 @@ void Request::configure_admin(VStateless
 			...
 		]
 	*/
-	if(ValuePtr 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(StringPtr(0)))
-				charsets->for_each(load_charset, 0);
+			if(Hash *charsets=vcharsets->get_hash(0))
+				charsets->for_each(load_charset);
 			else
 				throw Exception("parser.runtime",
-					Exception::undefined_source,
+					0,
 					"$" MAIN_CLASS_NAME ":" CHARSETS_NAME " must be hash");
 	}
 
 	// configure method_frame options
 	//	until someone with less privileges have overriden them
-	methoded_array().configure_admin(*this);
+	methoded_array->configure_admin(*this);
 }
 
 /**
@@ -222,7 +166,7 @@ void Request::configure_admin(VStateless
 
 */
 void Request::core(
-				   const char* config_filespec, bool config_fail_on_read_problem,
+				   const char *config_filespec, bool config_fail_on_read_problem,
 				   bool header_only) {
 
 #ifdef RESOURCES_DEBUG
@@ -232,11 +176,13 @@ struct timeval mt[10];
 gettimeofday(&mt[0],NULL);
 #endif
 	try {
+		char *auto_filespec=(char *)malloc(MAX_STRING);
+		
 		// loading config
 		if(config_filespec) {
-			StringPtr filespec(new String);
-			filespec->APPEND_CLEAN(config_filespec, 0, "config", 0);
-			use_file(*main_class,
+			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 */);
 		}
@@ -245,24 +191,24 @@ 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, '/')) {
-				StringPtr sfile_spec(new String);
-				if(after!=request_info.path_translated) {
-					sfile_spec->APPEND_CLEAN(
-						request_info.path_translated, before-request_info.path_translated,
+			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;
+					sfile_spec << "/" AUTO_FILE_NAME;
 
-					use_file(*main_class,
+					use_file(main_class,
 						sfile_spec, true/* ignore class_path */, 
 						true/* fail on read problem */, false/* but ignore absence, sole user */);
 				}
@@ -271,42 +217,42 @@ gettimeofday(&mt[0],NULL);
 		}
 
 		// compile requested file
-		StringPtr spath_translated(new String);
-		spath_translated->APPEND_TAINTED(request_info.path_translated, 0, "user-request", 0);
-		use_file(*main_class,
+		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, StringPtr(0));
+			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(ValuePtr 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(pool(), charsets, request_info);
+		form.fill_fields_and_tables(*this);
 
 		// filling cookies
-		cookie->fill_fields(pool(), request_info);
+		cookie.fill_fields(*this);
 
 		// filling mail received
-		mail->fill_received(*this);
+		mail.fill_received(*this);
 
 #ifdef RESOURCES_DEBUG
 //measure:after compile
 gettimeofday(&mt[1],NULL);
 #endif
 		// execute @main[]
-		StringPtr 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",
-				Exception::undefined_source,
+				0, 
 				"'"MAIN_METHOD_NAME"' method not found");
 
 #ifdef RESOURCES_DEBUG
@@ -314,38 +260,43 @@ gettimeofday(&mt[1],NULL);
 gettimeofday(&mt[2],NULL);
 #endif
 
-		VStringPtr body_vstring_before_post_process(new VString(body_string));
-		VStringPtr 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(ValuePtr value=main_class->get_element(post_process_method_name, *main_class, false))
-			if(JunctionPtr 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(pool(), method->name, *junction, 0/*no parent*/); frame.ref();
+					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=
-						VStringPtr(new VString(execute_method(frame, *method)));
+						NEW VString(execute_method(frame, *method));
 				}
 
 		bool lorigins_mode=origins_mode();
 
-		VFilePtr body_file=body_vstring_after_post_process->as_vfile(pool(), 
+		const VFile *body_file=body_vstring_after_post_process->as_vfile(
 			String::UL_UNSPECIFIED, lorigins_mode);
 
 		// extract response body
-		ValuePtr 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(pool());
+			body_file=body_value->as_vfile();
 		else if(lorigins_mode)
-			response->fields().put(content_type_name, 
-				ValuePtr(new VString(StringPtr(new String(ORIGINS_CONTENT_TYPE)))));
+			response.fields().put(*content_type_name, 
+				NEW VString(*NEW String(pool(), ORIGINS_CONTENT_TYPE)));
 
 #ifdef RESOURCES_DEBUG
 //measure:after postprocess
@@ -353,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
@@ -365,7 +316,7 @@ 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(pool(), "rmeasure: %s,%.2f,%.2f,%.2f %.2f,%.2f %.2f", 
-request_info.uri,
+info.uri,
 t[1]-t[0],
 t[2]-t[1],
 t[3]-t[2],
@@ -377,27 +328,27 @@ t[9]-t[3]
 		// we're returning not result, but error explanation
 		try {
 			// log the beast
-			if(StringPtr 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().get(),
+					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()
 				);
 
@@ -405,54 +356,54 @@ t[9]-t[3]
 			flang=fdefault_lang;
 			
 			// reset response
-			response->fields().clear();
+			response.fields().clear();
 
 			// this is what we'd return in $response:body
-			StringPtr body_string(0);
+			const String *body_string=0;
 
 			// maybe we'd be lucky enough as to report an error
 			// in a gracefull way...
-			if(ValuePtr value=main_class->get_element(
-					StringPtr(new String(UNHANDLED_EXCEPTION_METHOD_NAME)), 
-					*main_class,
+			if(Value *value=main_class.get_element(
+					*NEW String(pool(), UNHANDLED_EXCEPTION_METHOD_NAME), 
+					main_class,
 					false)) {
-				if(JunctionPtr 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(pool(), method->name, *junction, 0/*no caller*/); frame.ref();
+						VMethodFrame frame(pool(), method->name, *junction, 0/*no caller*/);
 						frame.set_self(main_class);
 
 						// $exception
-						frame.store_param(exception2vhash(pool(), e));
+						frame.store_param(&exception2vhash(pool(), e));
 						// $stack[^table::set{name	origin}]
-						Table::columns_type stack_trace_columns(new ArrayString);
-						*stack_trace_columns+=StringPtr(new String("name"));
-						*stack_trace_columns+=StringPtr(new String("file"));
-						*stack_trace_columns+=StringPtr(new String("lineno"));
-						TablePtr stack_trace(new Table(Exception::undefined_source, stack_trace_columns));
-						Array_iterator<StringPtr> tracei(exception_trace);
+						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()) {
-							Table::element_type row(new ArrayString);
+							Array& row=*NEW Array(pool());
 
-							StringPtr name=tracei.next();
-							*row+=name; // name column
+							const String *name=(const String *)tracei.next();
+							row+=name; // name column
 #ifndef NO_STRING_ORIGIN
-							const String_fragment::Origin& origin=name->origin();
+							const Origin& origin=name->origin();
 							if(origin.file) {
-								*row+=StringPtr(new String(origin.file, 0, true)); // file column
-								*row+=StringPtr(new String(
-									pool().format_integer(1+origin.line), 
-									0, true)); // line column
+								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
 							}
 #endif
-							*stack_trace+=row;
+							stack_trace+=&row;
 						}
-						frame.store_param(ValuePtr(new VTable(stack_trace)));
+						frame.store_param(NEW VTable(pool(), &stack_trace));
 
 						// future $response:body=
 						//   execute ^unhandled_exception[exception;stack]
-						body_string=execute_method(frame, *method);
+						body_string=&execute_method(frame, *method);
 					}
 				}
 			}
@@ -461,11 +412,11 @@ t[9]-t[3]
 				// doing that ugly
 
 				// make up result: $origin $source $comment $type $code
-				char *buf=new(pool()) char[MAX_STRING];
+				char *buf=(char *)malloc(MAX_STRING);
 				size_t printed=0;
-				if(StringPtr problem_source=e.problem_source()) {
+				if(const String *problem_source=e.problem_source()) {
 #ifndef NO_STRING_ORIGIN
-					const String_fragment::Origin& origin=problem_source->origin();
+					const Origin& origin=problem_source->origin();
 					if(origin.file)
 						printed+=snprintf(buf+printed, MAX_STRING-printed, 
 							ORIGIN_FILE_LINE_FORMAT": ", 
@@ -473,246 +424,223 @@ t[9]-t[3]
 						);
 #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, 
-					ValuePtr(new VString(StringPtr(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=StringPtr(new String(buf));
+				body_string=NEW String(pool(), buf);
 			}
 
-			VString body_vstring(body_string);
-			VFilePtr body_file=body_vstring.as_vfile(pool());
+			VString body_vstring(*body_string);
+			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;
 		}
 	}
 }
 
-VStateless_classPtr Request::use_file(VStateless_class& aclass,
-									StringPtr file_name, bool ignore_class_path, 
+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 VStateless_classPtr(0);
-	used_files.put(file_name, true);
+		return 0;
+	used_files.put(file_name, (Hash::Val *)true);
 
-	StringPtr 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=StringPtr(0);
-		if(ValuePtr element=main_class->get_element(class_path_name, *main_class, false)) {
+		file_spec=0;
+		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(&pool())), *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();
+				int size=table->size();
 				for(int i=size; i--; ) {
-					StringPtr path=(*table->get(i))[0];
-					if(file_spec=file_readable(*absolute(path), *file_name))
+					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
 				}
 			} else
 				throw Exception("parser.runtime",
-					Exception::undefined_source,
+					0,
 					"$" 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))
-			return VStateless_classPtr(0);
+		if(!entry_exists(*file_spec))
+			return 0;
 
-	if(const char *source=file_read_text(pool(), charsets.source(), file_spec, fail_on_read_problem))
-		return use_buf(aclass, source, file_spec, file_spec->cstr(pool()));
-	else
-		return VStateless_classPtr(0);
+	char *source=file_read_text(pool(), *file_spec, fail_on_read_problem);
+	if(!source)
+		return 0;
+
+	return use_buf(aclass, source, *file_spec, file_spec->cstr());
 }
 
 
-VStateless_classPtr Request::use_buf(VStateless_class& aclass,
-								   const char* source, 
-								   StringPtr filespec, const char* filespec_cstr) {
+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, MethodPtr(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, MethodPtr(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, filespec_cstr);
 
 	// locate and execute possible @conf[] static
-	VStringPtr vfilespec(new VString(filespec));
-	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*/);
-	return VStateless_classPtr(&cclass);
+		*auto_method_name, vfilespec,
+		0/*no result needed*/);
+	return &cclass;
 }
 
-StringPtr Request::relative(const char* apath, StringPtr relative_name) {
-    char *hpath=pool().copy(apath);
-	StringPtr result(new String);
+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;
+		result << hpath << "/";
+    result << relative_name;
     return result;
 }
 
-StringPtr Request::absolute(StringPtr relative_name) {
-	if(relative_name->first_char()=='/') {
-		StringPtr result=StringPtr(new String(request_info.document_root));
-		*result << relative_name;
+const String& Request::absolute(const String& relative_name) {
+	if(relative_name.first_char()=='/') {
+		String& result=*NEW String(pool(), info.document_root);
+		result << relative_name;
 		return result;
 	} else 
-		return relative_name->pos("://")<0? relative(request_info.path_translated, relative_name)
+		return relative_name.pos("://")<0? relative(info.path_translated, relative_name)
 			:relative_name; // something like "http://xxx"
 }
 
-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)
+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,
-		aattribute->cstr(), 
-		attributed_meaning_to_string(r->pool(), ameaning, String::UL_HTTP_HEADER, false)->
-			cstr(String::UL_UNSPECIFIED));
+	Value& lmeaning=*static_cast<Value *>(ameaning);
+	Pool& pool=lmeaning.pool();
+
+	SAPI::add_header_attribute(pool,
+		aattribute.cstr(), 
+		attributed_meaning_to_string(lmeaning, String::UL_HTTP_HEADER, false)
+			.cstr(String::UL_UNSPECIFIED));
 }
-void Request::output_result(VFilePtr 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(pool(), sapi_info);
+	cookie.output_result();
 	
-	ValuePtr 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, 
-			ValuePtr(new VString(StringPtr(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(ValuePtr vfile_name=body_file->fields().get(name_name))
-		if(*vfile_name->get_string(&fpool)!=NONAME_DAT) {
-			VHashPtr hash(new VHash);
-			HashStringValue &h=hash->hash(Exception::undefined_source);
+	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, ValuePtr(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
-	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(Exception::undefined_source))
-			body_file_content_type=hash->get(value_name);
-	if(!body_file_content_type/*vstring.as_vfile*/ || body_file_content_type->as_string(&pool())->pos("text/")==0) {
+		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(pool(),
-			charsets.source(), body_file->value_ptr(), body_file->value_size(),
-			charsets.client(), client_body, client_content_length
+			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);
 }
 
-StringPtr 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(pool(), charsets.source(), String::CC_LOWER)))
-				if(StringPtr 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",
 						mime_types->origin_string(),
 						MIME_TYPES_NAME  " table column elements must not be empty");
 		}
-
-	return StringPtr(new String("application/octet-stream"));
+	return *NEW String(pool(), "application/octet-stream");
 }
 
 bool Request::origins_mode() {
-	return main_class->get_element(origins_mode_name, *main_class, false)!=0;  // $ORIGINS mode
+	return main_class.get_element(*origins_mode_name, main_class, false)!=0;  // $ORIGINS mode
 }
-
-#ifdef XML
-
-GdomeDOMString_auto_ptr Request::transcode(StringPtr s) {
-	return charsets.source().transcode(s);
-}
-
-StringPtr Request::transcode(GdomeDOMString* s
-#ifndef NO_STRING_ORIGIN
-	, StringPtr origin
-#endif
-	) {
-	return charsets.source().transcode(pool(), s
-#ifndef NO_STRING_ORIGIN
-		, origin
-#endif
-		);
-}
-
-StringPtr Request::transcode(xmlChar* s
-#ifndef NO_STRING_ORIGIN
-	, StringPtr origin
-#endif
-	) {
-	return charsets.source().transcode(pool(), s
-#ifndef NO_STRING_ORIGIN
-		, origin
-#endif
-		);
-}
-#endif