--- parser3/src/main/pa_request.C	2001/03/10 14:05:36	1.4
+++ parser3/src/main/pa_request.C	2003/02/03 11:55:33	1.245.2.12
@@ -1,102 +1,668 @@
-/*
-$Id: pa_request.C,v 1.4 2001/03/10 14:05:36 paf Exp $
+/** @file
+	Parser: request class main part. @see compile.C and execute.C.
+
+	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/02/03 11:55:33 $";
+
+#include "pa_sapi.h"
+#include "pa_common.h"
 #include "pa_request.h"
 #include "pa_wwrapper.h"
-#include "pa_common.h"
 #include "pa_vclass.h"
-#include "classes/_root.h"
-#include "classes/_env.h"
-
-#include <stdio.h>
+#include "pa_globals.h"
+#include "pa_vint.h"
+#include "pa_vmethod_frame.h"
+#include "pa_types.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"
+
+// consts
+
+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";
+
+/// 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"
+
+// globals
+
+StringPtr main_method_name(new String(MAIN_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));
+
+// defines for statics
+
+#define CHARSETS_NAME "CHARSETS"
+#define MAIN_CLASS_NAME "MAIN"
+#define MIME_TYPES_NAME "MIME-TYPES"
+#define ORIGINS_MODE_NAME "ORIGINS"
+#define AUTO_FILE_NAME "auto.p"
+#define CONF_METHOD_NAME "conf"
+#define AUTO_METHOD_NAME "auto"
+#define POST_PROCESS_METHOD_NAME "postprocess"
+#define BODY_NAME "body"
+#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 auto_method_name(new String(AUTO_METHOD_NAME));
+static StringPtr post_process_method_name(new String(POST_PROCESS_METHOD_NAME));
+static StringPtr body_name(new String(BODY_NAME));
+static StringPtr download_name(new String(DOWNLOAD_NAME));
+static StringPtr class_path_name(new String(CLASS_PATH_NAME));
+
+// defines
+
+// op.C
+VStateless_classPtr VClassMAIN_create();
+// op.C
+VHashPtr exception2vhash(const Exception& e);
+
+void lock_system_class(HashStringValue::key_type key, HashStringValue::value_type value, int) {
+	if(VStateless_class *value_class=value->get_class())
+		value_class->lock();
+}
 
-Request::Request(Pool& apool) : Pooled(apool),
-	stack(apool),
-	root_class(apool),
-	env_class(apool),
-	fclasses(apool),
-	fclasses_array(apool),
-	lang(String::Untaint_lang::HTML_TYPO)
+//
+Request::Request(SAPI_Info& asapi_info, Request_info& arequest_info, 
+				 uchar adefault_lang, bool status_allowed):
+	sapi_info(asapi_info),
+	request_info(arequest_info),
+	fdefault_lang(adefault_lang), flang(adefault_lang),
+
+	main_class(VClassMAIN_create()),
+	charsets(pool(), *UTF8_charset, *UTF8_charset, *UTF8_charset), // default charsets
+
+	response(new VResponse(fpool, arequest_info, charsets)),
+	form(new VForm),
+	mail(new VMail),
+	cookie(new VCookie)
 {
-	// root class
-	initialize_root_class(pool(), root_class);
-	// adding root superclass, 
-	//   parent of all classes, 
-	//   operators holder
-	String ROOT(pool()); ROOT.APPEND_CONST(ROOT_NAME);
-	classes().put(ROOT, &root_class);
+	// maybe expire old caches
+	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);
 
+	/// methodless
 	// env class
-	initialize_env_class(pool(), env_class);
-	String ENV(pool()); ENV.APPEND_CONST(ENV_NAME);
-	classes().put(ENV, &env_class);
-}
-
-void Request::core() {
-	TRY {
-		char *file="Y:\\parser3\\src\\test.p";
-		String RUN(pool()); RUN.APPEND_CONST(RUN_NAME);
-		use(file, &RUN);
-
-		char *result=execute_MAIN();
-		printf("result-----------------\n%sEOF----------------\n", result);
-	} 
-	CATCH(e) {
-		printf("\nERROR: ");
-		const String *problem_source=e.problem_source();
-		if(problem_source) {
-			const Origin& origin=problem_source->origin();
-			if(origin.file)
-				printf("%s(%d): ",
-				origin.file, 1+origin.line);
-			printf("'%s' ", 
-				problem_source->cstr());
-		}
-		printf("%s", e.comment());
-		const String *type=e.type();
-		if(type) {
-			printf("  type: %s", type->cstr());
-			const String *code=e.code();
-			if(code)
-				printf(", code: %s", code->cstr());
-		}
-		printf("\n");
-	}
-	END_CATCH
-}
-
-void Request::use(char *file, String *name) {
-	// TODO: обнаружить|решить cyclic dependences
-	char *source=file_read(pool(), file);
-	if(!source)
-		THROW(0,0,
-			0,
-			"use: can not read '%s' file", file);
-
-	VClass& vclass=COMPILE(source, name, file);
-
-	// locate and execute possible @auto[] static method
-	String name_auto(pool());
-	name_auto.APPEND_CONST(AUTO_METHOD_NAME);
-	execute_static(vclass, name_auto, false);
-}
-
-char *Request::execute_MAIN() {
-	// locate class with @main & it's code
-	String name_main(pool());
-	name_main.APPEND_CONST(MAIN_METHOD_NAME);
-
-	// looking for latest known @main
-	for(int i=classes_array().size(); --i>=0;) {
-		VClass *vclass=static_cast<VClass *>(classes_array().get(i));
-		char *result=execute_static(*vclass, name_main, true);
-		if(result)
-			return result;
+	classes().put(StringPtr(new String(ENV_CLASS_NAME)), 
+			ValuePtr(new VEnv(asapi_info)));
+	// status class
+	if(status_allowed)
+		classes().put(StringPtr(new String(STATUS_CLASS_NAME)), 
+			ValuePtr(new VStatus(pool())));
+	// request class
+	classes().put(StringPtr(new String(REQUEST_CLASS_NAME)), 
+		ValuePtr(new VRequest(arequest_info, charsets)));	
+	// cookie class
+	classes().put(StringPtr(new String(COOKIE_CLASS_NAME)), cookie);
+
+	/// methoded
+	// response class
+	classes().put(response->get_class()->name(), response);
+
+	/// bases used
+	// form class
+	classes().put(form->get_class()->base_class()->name(), form);	
+	// mail class
+	classes().put(mail->get_class()->base_class()->name(), mail);	
+	// math class
+	{
+		ValuePtr math(new VMail);
+		classes().put(math->get_class()->base_class()->name(), math);	
+	}
+
+	// prevent system classes from modification [calling add_method]
+	// ^process[$string:CLASS]{@method} prohibited from now on...
+	classes().for_each(lock_system_class, 0);
+}
+
+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(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); }
+
+static void load_charset(HashStringValue::key_type akey, HashStringValue::value_type avalue, int) {
+	::charsets.load_charset(akey, avalue->as_string(0));
+}
+void Request::configure_admin(VStateless_class& conf_class, StringPtr source) {
+	if(configure_admin_done)
+		throw Exception("parser.runtime",
+		source,
+		"parser already configured");
+	configure_admin_done=true;
+	
+	// charsets must only be specified in method_frame config
+	// so that users would not interfere
+
+	/* $MAIN:CHARSETS[
+			$.charsetname1[/full/path/to/charset/file.cfg]
+			...
+		]
+	*/
+	if(ValuePtr 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);
+			else
+				throw Exception("parser.runtime",
+					Exception::undefined_source,
+					"$" 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);
+}
+
+/**
+	load MAIN class, execute @main.
+	MAIN class consists of all the auto.p files we'd manage to find
+	plus
+	the file user requested us to process
+	all located classes become children of one another,
+	composing class we name 'MAIN'
+
+	@test log stack trace
+
+*/
+void Request::core(
+				   const char* config_filespec, bool config_fail_on_read_problem,
+				   bool header_only) {
+
+#ifdef RESOURCES_DEBUG
+//measures
+struct timeval mt[10];
+//measure:before all
+gettimeofday(&mt[0],NULL);
+#endif
+	try {
+		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,
+				filespec, 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/.. 
+		// 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) {
+				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,
+						"path-translated-scanned", step++);
+					*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 */);
+				}
+				after=before+1;
+			}
+		}
+
+		// compile requested file
+		StringPtr 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 */);
+
+		// configure method_frame options if not configured yet
+		if(!configure_admin_done)
+			configure_admin(*main_class, StringPtr(0));
+
+		// configure not-method_frame=user options
+		methoded_array.configure_user(*this);
+
+		// $MAIN:MIME-TYPES
+		if(ValuePtr 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);
+
+		// filling cookies
+		cookie->fill_fields(pool(), request_info);
+
+		// filling mail received
+		mail->fill_received(pool(), request_info);
+
+#ifdef RESOURCES_DEBUG
+//measure:after compile
+gettimeofday(&mt[1],NULL);
+#endif
+		// execute @main[]
+		StringPtr body_string=execute_virtual_method(main_class, main_method_name);
+		if(!body_string)
+			throw Exception("parser.runtime",
+				Exception::undefined_source,
+				"'"MAIN_METHOD_NAME"' method not found");
+
+#ifdef RESOURCES_DEBUG
+		//measure:after main
+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);
+		// @postprocess
+		if(ValuePtr value=main_class->get_element(post_process_method_name, *main_class, false))
+			if(JunctionPtr 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.set_self(main_class);
+
+					frame.store_param(body_vstring_before_post_process);
+					body_vstring_after_post_process=
+						VStringPtr(new VString(execute_method(frame, *method)));
+				}
+
+		bool lorigins_mode=origins_mode();
+
+		VFilePtr 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);
+		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(pool());
+		else if(lorigins_mode)
+			response->fields().put(content_type_name, 
+				ValuePtr(new VString(StringPtr(new String(ORIGINS_CONTENT_TYPE)))));
+
+#ifdef RESOURCES_DEBUG
+//measure:after postprocess
+gettimeofday(&mt[3],NULL);		
+#endif
+
+		// OK. write out the result
+		output_result(body_file, header_only, as_attachment);
+
+#ifdef RESOURCES_DEBUG
+		//measure:after output_result
+gettimeofday(&mt[9],NULL);		
+t[9]=mt[9].tv_sec+mt[9].tv_usec/1000000.0;
+
+double t[10];
+for(int i=0;i<10;i++)
+    t[i]=mt[i].tv_sec+mt[i].tv_usec/1000000.0;
+//measure:log2 compile,main,postprocess,output
+SAPI::log(pool(), "rmeasure: %s,%.2f,%.2f,%.2f %.2f,%.2f %.2f", 
+request_info.uri,
+t[1]-t[0],
+t[2]-t[1],
+t[3]-t[2],
+sql_connect_time,sql_request_time,
+t[9]-t[3]
+);
+#endif
+	} catch(const Exception& e) { // request handling problem
+		// we're returning not result, but error explanation
+		try {
+			// log the beast
+			if(StringPtr problem_source=e.problem_source())
+				SAPI::log(sapi_info,
+					"%s: "
+#ifndef NO_STRING_ORIGIN
+					ORIGIN_FILE_LINE_FORMAT": "
+#endif
+					"'%s' %s [%s]",
+					request_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,
+					"%s: "
+					"%s [%s]",
+					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
+			StringPtr 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,
+					false)) {
+				if(JunctionPtr 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.set_self(main_class);
+
+						// $exception
+						frame.store_param(exception2vhash(e));
+						// $stack[^table::set{name	origin}]
+						Table::columns_type stack_trace_columns;
+						*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);
+						while(tracei.has_next()) {
+							Table::element_type row;
+
+							StringPtr name=tracei.next();
+							*row+=name; // name column
+#ifndef NO_STRING_ORIGIN
+							const String_fragment::Origin& origin=name->origin();
+							if(origin.file) {
+								*row+=StringPtr(new String(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+=StringPtr(new String(buf, buf_size, true)); // line column
+							}
+#endif
+							*stack_trace+=row;
+						}
+						frame.store_param(ValuePtr(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=(char *)malloc(MAX_STRING);
+				size_t printed=0;
+				if(StringPtr 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());
+				}
+				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, 
+					ValuePtr(new VString(StringPtr(new String(UNHANDLED_EXCEPTION_CONTENT_TYPE)))));
+				// future $response:body
+				body_string=StringPtr(new String(buf));
+			}
+
+			VString body_vstring(body_string);
+			VFilePtr body_file=body_vstring.as_vfile();
+
+			// ERROR. write it out
+			output_result(body_file, header_only, false);
+		} catch(const Exception& ) {
+			rethrow;
+		}
 	}
+}
+
+VStateless_classPtr Request::use_file(VStateless_class& aclass,
+									StringPtr 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 0;
+	used_files.put(file_name, true);
+
+	StringPtr 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=StringPtr(0);
+		if(ValuePtr 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?
+			} else if(Table *table=element->get_table()) {
+				int size=table->count();
+				for(int i=size; i--; ) {
+					StringPtr path=(*table->get(i))[0];
+					if(file_spec=file_readable(absolute(path), file_name))
+						break; // found along class_path
+				}
+			} else
+				throw Exception("parser.runtime",
+					Exception::undefined_source,
+					"$" CLASS_PATH_NAME " must be string or table");
+			if(!file_spec)
+				throw Exception("parser.runtime",
+					file_name,
+					"not found along " MAIN_CLASS_NAME ":" CLASS_PATH_NAME);
+		}
+		if(!file_spec)
+			throw Exception("parser.runtime",
+				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 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 0;
+}
+
+
+VStateless_classPtr Request::use_buf(VStateless_class& aclass,
+								   const char* source, 
+								   StringPtr 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));
+	// temporary zero @auto so to maybe-replace it in compiled code
+	Temp_method temp_method_auto(aclass, auto_method_name, MethodPtr(0));
+
+	// compile loaded class
+	VStateless_class& cclass=COMPILE(&aclass, source, filespec_cstr);
+
+	// locate and execute possible @conf[] static
+	VStringPtr vfilespec(new VString(filespec));
+	const Method *method_called;
+	execute_nonvirtual_method(cclass, 
+		conf_method_name, vfilespec,
+		false/*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,
+		0/*no result needed*/);
+	return &cclass;
+}
+
+StringPtr Request::relative(const char* apath, StringPtr relative_name) {
+    char *hpath=pool().copy(apath);
+	StringPtr result(new String);
+    if(rsplit(hpath, '/')) // if something/splitted
+		*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;
+		return result;
+	} else 
+		return relative_name->pos("://")<0? relative(request_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)
+		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));
+}
+void Request::output_result(VFilePtr body_file, bool header_only, bool as_attachment) {
+	// header: cookies
+	cookie->output_result(pool(), sapi_info);
 	
-	THROW(0,0,
-		0, 
-		"'"MAIN_METHOD_NAME"' method not found");
-	return 0;
+	ValuePtr body_file_content_type;
+	// set content-type
+	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);
+	} else {
+		// default content type
+		response->fields().put_dont_replace(content_type_name, 
+			ValuePtr(new VString(StringPtr(new String(DEFAULT_CONTENT_TYPE)))));
+	}
+
+	// content-disposition
+	if(ValuePtr vfile_name=body_file->fields().get(name_name))
+		if(*vfile_name->get_string(&Pool())!=NONAME_DAT) {
+			VHashPtr hash(new VHash);
+			HashStringValue &h=hash->hash(Exception::undefined_source);
+			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);
+		}
+
+	// prepare header: $response:fields without :body
+	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) {
+		Charset::transcode(pool(),
+			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();
+	}
+
+	// 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);
+
+	// send header
+	SAPI::send_header(sapi_info);
+	
+	// send body
+	if(!header_only)
+		SAPI::send_body(sapi_info, client_body, client_content_length);
+}
+
+StringPtr 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;
+				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"));
+}
+
+bool Request::origins_mode() {
+	return main_class->get_element(origins_mode_name, *main_class, false)!=0;  // $ORIGINS mode
 }