parser3/src/main/pa_request.C - diff

Return to pa_request.C CVS log

Up to [parser3project] / parser3 / src / main

Diff for /parser3/src/main/pa_request.C between versions 1.243 and 1.245.2.31

version 1.243, 2002/12/02 10:07:39	version 1.245.2.31, 2003/03/07 14:56:59
Line 1	Line 1
/** @file	/** @file
Parser: request class main part. @see compile.C and execute.C.	Parser: request class main part. @see compile.C and execute.C.

Copyright (c) 2001, 2002 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)	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
*/	*/

Line 16 static const char* IDENT_REQUEST_C="$Dat	Line 16 static const char* IDENT_REQUEST_C="$Dat
#include "pa_vint.h"	#include "pa_vint.h"
#include "pa_vmethod_frame.h"	#include "pa_vmethod_frame.h"
#include "pa_types.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_vtable.h"
#include "pa_vfile.h"	#include "pa_vfile.h"
#include "pa_dictionary.h"	#include "pa_dictionary.h"
#include "pa_charset.h"	#include "pa_charset.h"
#include "pa_charsets.h"	#include "pa_charsets.h"
	#include "pa_cache_managers.h"

const char *POST_PROCESS_METHOD_NAME="postprocess";	// consts
const char *UNHANDLED_EXCEPTION_METHOD_NAME="unhandled_exception";
	const char* UNHANDLED_EXCEPTION_METHOD_NAME="unhandled_exception";

/// content type of exception response, when no @MAIN:exception handler defined	/// 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	/// content type of response when no $MAIN:defaults.content-type defined
const char *DEFAULT_CONTENT_TYPE="text/html";	const char* DEFAULT_CONTENT_TYPE="text/html";
const char *ORIGINS_CONTENT_TYPE="text/plain";	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

// op.C	// op.C
VClass& VClassMAIN_create(Pool& pool);	VStateless_classPtr VClassMAIN_create();
// op.C	// op.C
VHash& exception2vhash(Pool& pool, const Exception& e);	VHashPtr exception2vhash(Pool& pool, const Exception& e);

//	//
Request::Request(Pool& apool,	Request::Request(Pool& apool, SAPI_Info& asapi_info, Request_info& arequest_info,
Info& ainfo,	String_UL adefault_lang, bool status_allowed):
uchar adefault_lang,	// private
bool status_allowed) : Pooled(apool),	fpool(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),
classes_conf(apool),
anti_endless_execute_recoursion(0),	anti_endless_execute_recoursion(0),
exception_trace(apool)
	// public
	method_frame(0),
	rcontext(0),
	wcontext(0),
	flang(adefault_lang),
	fconnection(0),
	finterrupted(false),

	// public
#ifdef RESOURCES_DEBUG	#ifdef RESOURCES_DEBUG
, sql_connect_time(0),sql_request_time(0)	sql_connect_time(0),
#endif	sql_request_time(0),
, method_frame(0), rcontext(0), wcontext(0),	#endif
finterrupted(false)
{	// public
// default charsets	sapi_info(asapi_info),
pool().set_source_charset(*utf8_charset);	request_info(arequest_info),
pool().set_client_charset(*utf8_charset);	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)
	{
// maybe expire old caches	// maybe expire old caches
cache_managers->maybe_expire();	cache_managers.maybe_expire();

/// directly used	/// directly used
// MAIN class, operators	// MAIN class, operators
classes().put(main_class.name(), &main_class);	classes().put(main_class->name(), main_class);
// classes:	// classes:
// table, file, random, mail, image, ...	// table, file, random, mail, image, ...
methoded_array->register_directly_used(*this);	methoded_array().register_directly_used(*this);

/// methodless	/// methodless
// env class	// env class
classes().put(*NEW String(pool(), ENV_CLASS_NAME), &env);	classes().put(StringPtr(new String(ENV_CLASS_NAME)),
	ValuePtr(new VEnv(pool(), asapi_info)));
// status class	// status class
if(status_allowed)	if(status_allowed)
classes().put(*NEW String(pool(), STATUS_CLASS_NAME), &status);	classes().put(StringPtr(new String(STATUS_CLASS_NAME)),
	ValuePtr(new VStatus(pool())));
// request class	// request class
classes().put(*NEW String(pool(), REQUEST_CLASS_NAME), &request);	classes().put(StringPtr(new String(REQUEST_CLASS_NAME)),
	ValuePtr(new VRequest(arequest_info, charsets)));
// cookie class	// cookie class
classes().put(*NEW String(pool(), COOKIE_CLASS_NAME), &cookie);	classes().put(StringPtr(new String(COOKIE_CLASS_NAME)), cookie);

/// methoded	/// methoded
// response class	// response class
classes().put(response.get_class()->name(), &response);	classes().put(response->get_class()->name(), response);

/// bases used	/// bases used
// form class	// form class
classes().put(form.get_class()->base_class()->name(), &form);	classes().put(form->get_class()->base_class()->name(), form);
// mail class	// mail class
classes().put(mail.get_class()->base_class()->name(), &mail);	classes().put(mail->get_class()->base_class()->name(), mail);
// math class	// math class
classes().put(math.get_class()->base_class()->name(), &math);	{
	ValuePtr math(new VMath);
	classes().put(math->get_class()->base_class()->name(), math);
	}
}	}

Request::~Request() {	Request::~Request() {
#ifdef XML	#ifdef XML
// if for some strange reason xml generic errors failed to be reported, free them up	// if for some strange reason xml generic errors failed to be reported, free them up
if(const char *xml_generic_errors=xmlGenericErrors()) {	if(const char* xml_generic_errors=xmlGenericErrors()) {
SAPI::log(pool(), "warning: unreported xmlGenericErrors: %s", xml_generic_errors);	SAPI::log(sapi_info, "warning: unreported xmlGenericErrors: %s", xml_generic_errors);
free((void *)xml_generic_errors);	free((void *)xml_generic_errors);
}	}
#endif	#endif
}	}

Value *Request::get_self() { return method_frame?&method_frame->self():0; }	ValuePtr Request::get_self() { return method_frame?method_frame->get_self():ValuePtr(0); }

static void load_charset(const Hash::Key& akey, Hash::Val avalue, void ) {	static void load_charset(HashStringValue::key_type akey, HashStringValue::value_type avalue, int) {
charsets->load_charset(akey, static_cast<Value *>(avalue)->as_string());	::charsets.load_charset(akey, avalue->as_string(0));
}	}
void Request::configure_admin(VStateless_class& conf_class, const String *source) {	void Request::configure_admin(VStateless_class& conf_class, StringPtr source) {
if(configure_admin_done)	if(configure_admin_done)
throw Exception("parser.runtime",	throw Exception("parser.runtime",
source,	source,
Line 139 void Request::configure_admin(VStateless	Line 191 void Request::configure_admin(VStateless
...	...
]	]
*/	*/
if(Value vcharsets=conf_class.get_element(charsets_name, conf_class, false)) {	if(ValuePtr vcharsets=conf_class.get_element(charsets_name, conf_class, false)) {
if(!vcharsets->is_string())	if(!vcharsets->is_string())
if(Hash *charsets=vcharsets->get_hash(0))	if(HashStringValue* charsets=vcharsets->get_hash(StringPtr(0)))
charsets->for_each(load_charset);	charsets->for_each(load_charset, 0);
else	else
throw Exception("parser.runtime",	throw Exception("parser.runtime",
0,	Exception::undefined_source,
"$" MAIN_CLASS_NAME ":" CHARSETS_NAME " must be hash");	"$" MAIN_CLASS_NAME ":" CHARSETS_NAME " must be hash");
}	}

// configure method_frame options	// configure method_frame options
// until someone with less privileges have overriden them	// until someone with less privileges have overriden them
methoded_array->configure_admin(*this);	methoded_array().configure_admin(*this);
}	}

/**	/**
Line 166 void Request::configure_admin(VStateless	Line 218 void Request::configure_admin(VStateless

*/	*/
void Request::core(	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) {	bool header_only) {

#ifdef RESOURCES_DEBUG	#ifdef RESOURCES_DEBUG
Line 176 struct timeval mt[10];	Line 228 struct timeval mt[10];
gettimeofday(&mt[0],NULL);	gettimeofday(&mt[0],NULL);
#endif	#endif
try {	try {
char auto_filespec=(char )malloc(MAX_STRING);

// loading config	// loading config
if(config_filespec) {	if(config_filespec) {
String& filespec=*NEW String(pool());	StringPtr filespec(new String);
filespec.APPEND_CLEAN(config_filespec, 0, "config", 0);	filespec->APPEND_CLEAN(config_filespec, 0, "config", 0);
use_file(main_class,	use_file(*main_class,
filespec, true/* ignore class_path */,	filespec, true/* ignore class_path */,
config_fail_on_read_problem, true/* file must exist if 'fail on read problem' not set */);	config_fail_on_read_problem, true/* file must exist if 'fail on read problem' not set */);
}	}
Line 191 gettimeofday(&mt[0],NULL);	Line 241 gettimeofday(&mt[0],NULL);
// to the one beside requested file.	// to the one beside requested file.
// all assigned bases from upper dir	// all assigned bases from upper dir
{	{
const char *after=info.path_translated;	const char* after=request_info.path_translated;
size_t drlen=strlen(info.document_root);	size_t drlen=strlen(request_info.document_root);
if(memcmp(after, info.document_root, drlen)==0) {	if(memcmp(after, request_info.document_root, drlen)==0) {
after+=drlen;	after+=drlen;
if(after[-1]=='/')	if(after[-1]=='/')
--after;	--after;
}	}

int step=0;	int step=0;
while(const char *before=strchr(after, '/')) {	while(const char* before=strchr(after, '/')) {
String& sfile_spec=*NEW String(pool());	StringPtr sfile_spec(new String);
if(after!=info.path_translated) {	if(after!=request_info.path_translated) {
sfile_spec.APPEND_CLEAN(	sfile_spec->APPEND_CLEAN(
info.path_translated, before-info.path_translated,	request_info.path_translated, before-request_info.path_translated,
"path-translated-scanned", step++);	"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 */,	sfile_spec, true/* ignore class_path */,
true/* fail on read problem /, false/ but ignore absence, sole user */);	true/* fail on read problem /, false/ but ignore absence, sole user */);
}	}
Line 217 gettimeofday(&mt[0],NULL);	Line 267 gettimeofday(&mt[0],NULL);
}	}

// compile requested file	// compile requested file
String& spath_translated=*NEW String(pool());	StringPtr spath_translated(new String);
spath_translated.APPEND_TAINTED(info.path_translated, 0, "user-request", 0);	spath_translated->APPEND_TAINTED(request_info.path_translated, 0, "user-request", 0);
use_file(main_class,	use_file(*main_class,
spath_translated, true/* ignore class_path */,	spath_translated, true/* ignore class_path */,
true/* fail on read problem/, true/ fail on abscence */);	true/* fail on read problem/, true/ fail on abscence */);

// configure method_frame options if not configured yet	// configure method_frame options if not configured yet
if(!configure_admin_done)	if(!configure_admin_done)
configure_admin(main_class, 0);	configure_admin(*main_class, StringPtr(0));

// configure not-method_frame=user options	// configure not-method_frame=user options
methoded_array->configure_user(*this);	methoded_array().configure_user(*this);

// $MAIN:MIME-TYPES	// $MAIN:MIME-TYPES
if(Value element=main_class.get_element(mime_types_name, main_class, false))	if(ValuePtr element=main_class->get_element(mime_types_name, *main_class, false))
if(Table *table=element->get_table())	if(Table *table=element->get_table())
mime_types=table;	mime_types=table;

// filling form fields	// filling form fields
form.fill_fields_and_tables(*this);	form->fill_fields_and_tables(pool(), charsets, request_info);

// filling cookies	// filling cookies
cookie.fill_fields(*this);	cookie->fill_fields(pool(), request_info);

// filling mail received	// filling mail received
mail.fill_received(*this);	mail->fill_received(pool(), request_info);

#ifdef RESOURCES_DEBUG	#ifdef RESOURCES_DEBUG
//measure:after compile	//measure:after compile
gettimeofday(&mt[1],NULL);	gettimeofday(&mt[1],NULL);
#endif	#endif
// execute @main[]	// execute @main[]
const String *body_string=execute_virtual_method(main_class, main_method_name);	StringPtr body_string=execute_virtual_method(main_class, main_method_name);
if(!body_string)	if(!body_string)
throw Exception("parser.runtime",	throw Exception("parser.runtime",
0,	Exception::undefined_source,
"'"MAIN_METHOD_NAME"' method not found");	"'"MAIN_METHOD_NAME"' method not found");

#ifdef RESOURCES_DEBUG	#ifdef RESOURCES_DEBUG
Line 260 gettimeofday(&mt[1],NULL);	Line 310 gettimeofday(&mt[1],NULL);
gettimeofday(&mt[2],NULL);	gettimeofday(&mt[2],NULL);
#endif	#endif

VString body_vstring_before_post_process(*body_string);	VStringPtr body_vstring_before_post_process(new VString(body_string));
VString *body_vstring_after_post_process=&body_vstring_before_post_process;	VStringPtr body_vstring_after_post_process(body_vstring_before_post_process);
// @postprocess	// @postprocess
if(Value *value=main_class.get_element(	if(ValuePtr value=main_class->get_element(post_process_method_name, *main_class, false))
*NEW String(pool(), POST_PROCESS_METHOD_NAME),	if(JunctionPtr junction=value->get_junction())
main_class,
false))
if(Junction *junction=value->get_junction())
if(const Method *method=junction->method) {	if(const Method *method=junction->method) {
// preparing to pass parameters to	// preparing to pass parameters to
// @postprocess[data]	// @postprocess[data]
VMethodFrame frame(pool(), method->name, junction, 0/no parent*/);	VMethodFrame frame(pool(), method->name, junction, 0/no parent*/); frame.ref();
frame.set_self(main_class);	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=	body_vstring_after_post_process=
NEW VString(execute_method(frame, *method));	VStringPtr(new VString(execute_method(frame, *method)));
}	}

bool lorigins_mode=origins_mode();	bool lorigins_mode=origins_mode();

const VFile *body_file=body_vstring_after_post_process->as_vfile(	VFilePtr body_file=body_vstring_after_post_process->as_vfile(pool(),
String::UL_UNSPECIFIED, lorigins_mode);	String::UL_UNSPECIFIED, lorigins_mode);

// extract response body	// extract response body
Value body_value=static_cast<Value >(	ValuePtr body_value=response->fields().get(download_name);
response.fields().get(*body_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	if(body_value) // there is some $response:body
body_file=body_value->as_vfile();	body_file=body_value->as_vfile(pool());
else if(lorigins_mode)	else if(lorigins_mode)
response.fields().put(*content_type_name,	response->fields().put(content_type_name,
NEW VString(*NEW String(pool(), ORIGINS_CONTENT_TYPE)));	ValuePtr(new VString(StringPtr(new String(ORIGINS_CONTENT_TYPE)))));

#ifdef RESOURCES_DEBUG	#ifdef RESOURCES_DEBUG
//measure:after postprocess	//measure:after postprocess
Line 299 gettimeofday(&mt[3],NULL);	Line 349 gettimeofday(&mt[3],NULL);
#endif	#endif

// OK. write out the result	// OK. write out the result
output_result(*body_file, header_only);	output_result(body_file, header_only, as_attachment);

#ifdef RESOURCES_DEBUG	#ifdef RESOURCES_DEBUG
//measure:after output_result	//measure:after output_result
Line 311 for(int i=0;i<10;i++)	Line 361 for(int i=0;i<10;i++)
t[i]=mt[i].tv_sec+mt[i].tv_usec/1000000.0;	t[i]=mt[i].tv_sec+mt[i].tv_usec/1000000.0;
//measure:log2 compile,main,postprocess,output	//measure:log2 compile,main,postprocess,output
SAPI::log(pool(), "rmeasure: %s,%.2f,%.2f,%.2f %.2f,%.2f %.2f",	SAPI::log(pool(), "rmeasure: %s,%.2f,%.2f,%.2f %.2f,%.2f %.2f",
info.uri,	request_info.uri,
t[1]-t[0],	t[1]-t[0],
t[2]-t[1],	t[2]-t[1],
t[3]-t[2],	t[3]-t[2],
Line 323 t[9]-t[3]	Line 373 t[9]-t[3]
// we're returning not result, but error explanation	// we're returning not result, but error explanation
try {	try {
// log the beast	// log the beast
if(const String *problem_source=e.problem_source())	if(StringPtr problem_source=e.problem_source())
SAPI::log(pool(),	SAPI::log(sapi_info,
"%s: "	"%s: "
#ifndef NO_STRING_ORIGIN	#ifndef NO_STRING_ORIGIN
ORIGIN_FILE_LINE_FORMAT": "	ORIGIN_FILE_LINE_FORMAT": "
#endif	#endif
"'%s' %s [%s]",	"'%s' %s [%s]",
info.uri,	request_info.uri,
#ifndef NO_STRING_ORIGIN	#ifndef NO_STRING_ORIGIN
problem_source->origin().file?problem_source->origin().file:"global",	problem_source->origin().file?problem_source->origin().file:"global",
problem_source->origin().line,	problem_source->origin().line,
#endif	#endif
problem_source->cstr(),	problem_source->cstr().get(),
e.comment(),	e.comment(),
e.type()	e.type()
);	);
else	else
SAPI::log(pool(),	SAPI::log(sapi_info,
"%s: "	"%s: "
"%s [%s]",	"%s [%s]",
info.uri,	request_info.uri,
e.comment(), e.type()	e.comment(), e.type()
);	);

Line 351 t[9]-t[3]	Line 401 t[9]-t[3]
flang=fdefault_lang;	flang=fdefault_lang;

// reset response	// reset response
response.fields().clear();	response->fields().clear();

// this is what we'd return in $response:body	// this is what we'd return in $response:body
const String *body_string=0;	StringPtr body_string(0);

// maybe we'd be lucky enough as to report an error	// maybe we'd be lucky enough as to report an error
// in a gracefull way...	// in a gracefull way...
if(Value *value=main_class.get_element(	if(ValuePtr value=main_class->get_element(
*NEW String(pool(), UNHANDLED_EXCEPTION_METHOD_NAME),	StringPtr(new String(UNHANDLED_EXCEPTION_METHOD_NAME)),
main_class,	*main_class,
false)) {	false)) {
if(Junction *junction=value->get_junction()) {	if(JunctionPtr junction=value->get_junction()) {
if(const Method *method=junction->method) {	if(const Method *method=junction->method) {
// preparing to pass parameters to	// preparing to pass parameters to
// @unhandled_exception[exception;stack]	// @unhandled_exception[exception;stack]
VMethodFrame frame(pool(), method->name, junction, 0/no caller*/);	VMethodFrame frame(pool(), method->name, junction, 0/no caller*/); frame.ref();
frame.set_self(main_class);	frame.set_self(main_class);

// $exception	// $exception
frame.store_param(&exception2vhash(pool(), e));	frame.store_param(exception2vhash(pool(), e));
// $stack[^table::set{name origin}]	// $stack[^table::set{name origin}]
Array& stack_trace_columns=*NEW Array(pool());	Table::columns_type stack_trace_columns(new ArrayString);
stack_trace_columns+=NEW String(pool(), "name");	*stack_trace_columns+=StringPtr(new String("name"));
stack_trace_columns+=NEW String(pool(), "file");	*stack_trace_columns+=StringPtr(new String("file"));
stack_trace_columns+=NEW String(pool(), "lineno");	*stack_trace_columns+=StringPtr(new String("lineno"));
Table& stack_trace=*NEW Table(pool(), 0, &stack_trace_columns);	TablePtr stack_trace(new Table(Exception::undefined_source, stack_trace_columns));
Array_iter tracei(exception_trace);	Array_iterator<StringPtr> tracei(exception_trace);
while(tracei.has_next()) {	while(tracei.has_next()) {
Array& row=*NEW Array(pool());	Table::element_type row(new ArrayString);

const String name=(const String )tracei.next();	StringPtr name=tracei.next();
row+=name; // name column	*row+=name; // name column
#ifndef NO_STRING_ORIGIN	#ifndef NO_STRING_ORIGIN
const Origin& origin=name->origin();	const String_fragment::Origin& origin=name->origin();
if(origin.file) {	if(origin.file) {
row+=NEW String(pool(), origin.file, 0, true); // file column	*row+=StringPtr(new String(origin.file, 0, true)); // file column
char buf=(char )malloc(MAX_NUMBER);	*row+=StringPtr(new String(
size_t buf_size=snprintf(buf, MAX_NUMBER, "%d", 1+origin.line);	pool().format_integer(1+origin.line),
row+=NEW String(pool(), buf, buf_size, true); // line column	0, true)); // line column
}	}
#endif	#endif
stack_trace+=&row;	*stack_trace+=row;
}	}
frame.store_param(NEW VTable(pool(), &stack_trace));	frame.store_param(ValuePtr(new VTable(stack_trace)));

// future $response:body=	// future $response:body=
// execute ^unhandled_exception[exception;stack]	// execute ^unhandled_exception[exception;stack]
body_string=&execute_method(frame, *method);	body_string=execute_method(frame, *method);
}	}
}	}
}	}
Line 407 t[9]-t[3]	Line 457 t[9]-t[3]
// doing that ugly	// doing that ugly

// make up result: $origin $source $comment $type $code	// make up result: $origin $source $comment $type $code
char buf=(char )malloc(MAX_STRING);	char *buf=new(pool()) char[MAX_STRING];
size_t printed=0;	size_t printed=0;
if(const String *problem_source=e.problem_source()) {	if(StringPtr problem_source=e.problem_source()) {
#ifndef NO_STRING_ORIGIN	#ifndef NO_STRING_ORIGIN
const Origin& origin=problem_source->origin();	const String_fragment::Origin& origin=problem_source->origin();
if(origin.file)	if(origin.file)
printed+=snprintf(buf+printed, MAX_STRING-printed,	printed+=snprintf(buf+printed, MAX_STRING-printed,
ORIGIN_FILE_LINE_FORMAT": ",	ORIGIN_FILE_LINE_FORMAT": ",
Line 419 t[9]-t[3]	Line 469 t[9]-t[3]
);	);
#endif	#endif
printed+=snprintf(buf+printed, MAX_STRING-printed, "'%s' ",	printed+=snprintf(buf+printed, MAX_STRING-printed, "'%s' ",
problem_source->cstr());	problem_source->cstr().get());
}	}
if(const char *comment=e.comment(true))	if(const char* comment=e.comment(true))
printed+=snprintf(buf+printed, MAX_STRING-printed, "%s", comment);	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);	printed+=snprintf(buf+printed, MAX_STRING-printed, " type: %s", type);

// future $response:content-type	// future $response:content-type
response.fields().put(*content_type_name,	response->fields().put(content_type_name,
NEW VString(*NEW String(pool(), UNHANDLED_EXCEPTION_CONTENT_TYPE)));	ValuePtr(new VString(StringPtr(new String(UNHANDLED_EXCEPTION_CONTENT_TYPE)))));
// future $response:body	// future $response:body
body_string=NEW String(pool(), buf);	body_string=StringPtr(new String(buf));
}	}

VString body_vstring(*body_string);	VString body_vstring(body_string);
const VFile *body_file=body_vstring.as_vfile();	VFilePtr body_file=body_vstring.as_vfile(pool());

// ERROR. write it out	// ERROR. write it out
output_result(*body_file, header_only);	output_result(body_file, header_only, false);
} catch(const Exception& ) {	} catch(const Exception& ) {
/re/throw;	rethrow;
}	}
}	}
}	}

VStateless_class *Request::use_file(VStateless_class& aclass,	VStateless_classPtr Request::use_file(VStateless_class& aclass,
const String& file_name, bool ignore_class_path,	StringPtr file_name, bool ignore_class_path,
bool fail_on_read_problem, bool fail_on_file_absence) {	bool fail_on_read_problem, bool fail_on_file_absence) {
// cyclic dependence check	// cyclic dependence check
if(used_files.get(file_name))	if(used_files.get(file_name))
return 0;	return VStateless_classPtr(0);
used_files.put(file_name, (Hash::Val *)true);	used_files.put(file_name, true);

const String *file_spec;	StringPtr file_spec;
if(ignore_class_path) // ignore_class_path?	if(ignore_class_path) // ignore_class_path?
file_spec=&file_name;	file_spec=file_name;
else if(file_name.first_char()=='/') //absolute path, no need to scan MAIN:CLASS_PATH?	else if(file_name->first_char()=='/') //absolute path, no need to scan MAIN:CLASS_PATH?
file_spec=&absolute(file_name);	file_spec=absolute(file_name);
else {	else {
file_spec=0;	file_spec=StringPtr(0);
if(Value element=main_class.get_element(class_path_name, main_class, false)) {	if(ValuePtr element=main_class->get_element(class_path_name, *main_class, false)) {
if(element->is_string()) {	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(&pool())), file_name); // found at class_path?
} else if(Table *table=element->get_table()) {	} else if(Table *table=element->get_table()) {
int size=table->size();	int size=table->count();
for(int i=size; i--; ) {	for(int i=size; i--; ) {
const String& path=static_cast<Array >(table->get(i))->get_string(0);	StringPtr path=(*table->get(i))[0];
if(file_spec=file_readable(absolute(path), file_name))	if(file_spec=file_readable(absolute(path), file_name))
break; // found along class_path	break; // found along class_path
}	}
} else	} else
throw Exception("parser.runtime",	throw Exception("parser.runtime",
0,	Exception::undefined_source,
"$" CLASS_PATH_NAME " must be string or table");	"$" CLASS_PATH_NAME " must be string or table");
if(!file_spec)	if(!file_spec)
throw Exception("parser.runtime",	throw Exception("parser.runtime",
&file_name,	file_name,
"not found along " MAIN_CLASS_NAME ":" CLASS_PATH_NAME);	"not found along " MAIN_CLASS_NAME ":" CLASS_PATH_NAME);
}	}
if(!file_spec)	if(!file_spec)
throw Exception("parser.runtime",	throw Exception("parser.runtime",
&file_name,	file_name,
"usage failed - no $" MAIN_CLASS_NAME ":" CLASS_PATH_NAME " were specified");	"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(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 0;	return VStateless_classPtr(0);

char source=file_read_text(pool(), file_spec, fail_on_read_problem);	if(const char *source=file_read_text(pool(), charsets.source(), file_spec, fail_on_read_problem))
if(!source)	return use_buf(aclass, source, file_spec, file_spec->cstr(pool()));
return 0;	else
	return VStateless_classPtr(0);
return use_buf(aclass, source, *file_spec, file_spec->cstr());
}	}


VStateless_class *Request::use_buf(VStateless_class& aclass,	VStateless_classPtr Request::use_buf(VStateless_class& aclass,
const char *source,	const char* source,
const String& filespec, const char *filespec_cstr) {	StringPtr filespec, const char* filespec_cstr) {
// temporary zero @conf so to maybe-replace it in compiled code	// temporary zero @conf so to maybe-replace it in compiled code
Temp_method temp_method_conf(aclass, *conf_method_name, 0);	Temp_method temp_method_conf(aclass, conf_method_name, MethodPtr(0));
// temporary zero @auto so to maybe-replace it in compiled code	// temporary zero @auto so to maybe-replace it in compiled code
Temp_method temp_method_auto(aclass, *auto_method_name, 0);	Temp_method temp_method_auto(aclass, auto_method_name, MethodPtr(0));

// compile loaded class	// 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	// locate and execute possible @conf[] static
VString *vfilespec=NEW VString(filespec);	VStringPtr vfilespec(new VString(filespec));
const Method *method_called;	Execute_nonvirtual_method_result executed=execute_nonvirtual_method(cclass,
execute_nonvirtual_method(cclass,	conf_method_name, vfilespec,
*conf_method_name, vfilespec,	false/no string result needed/);
0/no result needed/, &method_called);	if(executed.method)
if(method_called)	configure_admin(cclass, executed.method->name);
configure_admin(cclass, &method_called->name);

// locate and execute possible @auto[] static	// locate and execute possible @auto[] static
execute_nonvirtual_method(cclass,	execute_nonvirtual_method(cclass,
*auto_method_name, vfilespec,	auto_method_name, vfilespec,
0/no result needed/);	false/no result needed/);
return &cclass;	return VStateless_classPtr(&cclass);
}	}

const String& Request::relative(const char *apath, const String& relative_name) {	StringPtr Request::relative(const char* apath, StringPtr relative_name) {
int hpath_buf_size=strlen(apath)+1;	char *hpath=pool().copy(apath);
char hpath=(char )malloc(hpath_buf_size);	StringPtr result(new String);
memcpy(hpath, apath, hpath_buf_size);
String& result=*NEW String(pool());
if(rsplit(hpath, '/')) // if something/splitted	if(rsplit(hpath, '/')) // if something/splitted
result << hpath << "/";	*result << hpath << "/";
result << relative_name;	*result << relative_name;
return result;	return result;
}	}

const String& Request::absolute(const String& relative_name) {	StringPtr Request::absolute(StringPtr relative_name) {
if(relative_name.first_char()=='/') {	if(relative_name->first_char()=='/') {
String& result=*NEW String(pool(), info.document_root);	StringPtr result=StringPtr(new String(request_info.document_root));
result << relative_name;	*result << relative_name;
return result;	return result;
} else	} else
return relative_name.pos("://")<0? relative(info.path_translated, relative_name)	return relative_name->pos("://")<0? relative(request_info.path_translated, relative_name)
:relative_name; // something like "http://xxx"	:relative_name; // something like "http://xxx"
}	}

static void add_header_attribute(const Hash::Key& aattribute, Hash::Val *ameaning,	static void add_header_attribute(
void *info) {	HashStringValue::key_type aattribute,
Request& r=static_cast<Request >(info);	HashStringValue::value_type ameaning,
if(aattribute==BODY_NAME	Request *r) {
\|\| aattribute==CHARSET_NAME)	if(*aattribute==BODY_NAME
	\|\| *aattribute==DOWNLOAD_NAME
	\|\| *aattribute==CHARSET_NAME)
return;	return;

Value& lmeaning=static_cast<Value >(ameaning);	SAPI::add_header_attribute(r->sapi_info,
Pool& pool=lmeaning.pool();	aattribute->cstr(),
	attributed_meaning_to_string(r->pool(), ameaning, String::UL_HTTP_HEADER, false)->
SAPI::add_header_attribute(pool,	cstr(String::UL_UNSPECIFIED));
aattribute.cstr(),
attributed_meaning_to_string(lmeaning, String::UL_HTTP_HEADER, false)
.cstr(String::UL_UNSPECIFIED));
}	}
void Request::output_result(const VFile& body_file, bool header_only) {	void Request::output_result(VFilePtr body_file, bool header_only, bool as_attachment) {
// header: cookies	// header: cookies
cookie.output_result();	cookie->output_result(pool(), sapi_info);

Value *body_file_content_type;	ValuePtr body_file_content_type;
// set content-type	// set content-type
if(body_file_content_type=static_cast<Value *>(	if(body_file_content_type=body_file->fields().get(content_type_name)) {
body_file.fields().get(*content_type_name))) {
// body file content type	// 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 {	} else {
// default content type	// default content type
response.fields().put_dont_replace(*content_type_name,	response->fields().put_dont_replace(content_type_name,
default_content_type?default_content_type	ValuePtr(new VString(StringPtr(new String(DEFAULT_CONTENT_TYPE)))));
:NEW VString(*NEW String(pool(), DEFAULT_CONTENT_TYPE)));
}	}

// content-disposition	// content-disposition
if(VString vfile_name=static_cast<VString >(body_file.fields().get(*name_name)))	if(ValuePtr vfile_name=body_file->fields().get(name_name))
if(vfile_name->string()!=NONAME_DAT) {	if(*vfile_name->get_string(&fpool)!=NONAME_DAT) {
VHash& vhash=*NEW VHash(pool());	VHashPtr hash(new VHash);
Hash& hash=vhash.hash(0);	HashStringValue &h=hash->hash(Exception::undefined_source);
hash.put(value_name, NEW VString(content_disposition_value));	if(as_attachment)
hash.put(*content_disposition_filename_name, vfile_name);	h.put(value_name, ValuePtr(new VString(content_disposition_value)));
response.fields().put(*content_disposition_name, &vhash);	h.put(content_disposition_filename_name, vfile_name);
	response->fields().put(content_disposition_name, hash);
}	}

// prepare header: $response:fields without :body	// 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;	const void *client_body;
size_t client_content_length;	size_t client_content_length;
// transcode text body when "text/*" or simple result	// transcode text body when "text/*" or simple result
if(body_file_content_type)	if(body_file_content_type)
if(Hash *hash=body_file_content_type->get_hash(0))	if(HashStringValue *hash=body_file_content_type->get_hash(Exception::undefined_source))
body_file_content_type=static_cast<Value >(hash->get(value_name));	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) {	if(!body_file_content_type/vstring.as_vfile/ \|\| body_file_content_type->as_string(&pool())->pos("text/")==0) {
Charset::transcode(pool(),	Charset::transcode(pool(),
pool().get_source_charset(), body_file.value_ptr(), body_file.value_size(),	charsets.source(), body_file->value_ptr(), body_file->value_size(),
pool().get_client_charset(), client_body, client_content_length	charsets.client(), client_body, client_content_length
);	);
} else {	} else {
client_body=body_file.value_ptr();	client_body=body_file->value_ptr();
client_content_length=body_file.value_size();	client_content_length=body_file->value_size();
}	}

// prepare header: content-length	// prepare header: content-length
char content_length_cstr[MAX_NUMBER];	char content_length_cstr[MAX_NUMBER];
snprintf(content_length_cstr, MAX_NUMBER, "%u", client_content_length);	snprintf(content_length_cstr, MAX_NUMBER, "%u", client_content_length);
SAPI::add_header_attribute(pool(), "content-length", content_length_cstr);	SAPI::add_header_attribute(sapi_info, "content-length", content_length_cstr);

// send header	// send header
SAPI::send_header(pool());	SAPI::send_header(sapi_info);

// send body	// send body
if(!header_only)	if(!header_only)
SAPI::send_body(pool(), client_body, client_content_length);	SAPI::send_body(sapi_info, client_body, client_content_length);
}	}

const String& Request::mime_type_of(const char *user_file_name_cstr) {	StringPtr Request::mime_type_of(const char* user_file_name_cstr) {
if(mime_types)	if(mime_types)
if(const char *cext=strrchr(user_file_name_cstr, '.')) {	if(const char* cext=strrchr(user_file_name_cstr, '.')) {
String sext(pool(), ++cext);	String sext(++cext);
if(mime_types->locate(0, sext.change_case(pool(), String::CC_LOWER)))	if(mime_types->locate(0, sext.change_case(pool(), charsets.source(), String::CC_LOWER)))
if(const String *result=mime_types->item(1))	if(StringPtr result=mime_types->item(1))
return *result;	return result;
else	else
throw Exception("parser.runtime",	throw Exception("parser.runtime",
mime_types->origin_string(),	mime_types->origin_string(),
MIME_TYPES_NAME " table column elements must not be empty");	MIME_TYPES_NAME " table column elements must not be empty");
}	}
return *NEW String(pool(), "application/octet-stream");
	return StringPtr(new String("application/octet-stream"));
}	}

bool Request::origins_mode() {	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
	}

	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
	);
}	}

E-mail:

Removed from v.1.243
changed lines
	Added in v.1.245.2.31