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.146 and 1.182.2.1.2.1

version 1.146, 2001/07/26 10:47:02	version 1.182.2.1.2.1, 2001/12/06 20:23:45
Line 2	Line 2
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 ArtLebedev Group (http://www.artlebedev.com)	Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)
	Author: Alexander Petrosyan <paf@design.ru> (http://paf.design.ru)

Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)	$Id$
*/	*/
static const char *RCSId="$Id$";

#include "pa_config_includes.h"	#include "pa_config_includes.h"

#include "pcre.h"
#include "internal.h"
extern "C" unsigned char pcre_default_tables[]; // pcre/chartables.c	extern "C" unsigned char pcre_default_tables[]; // pcre/chartables.c

#include "pa_sapi.h"	#include "pa_sapi.h"
Line 24 extern "C" unsigned char pcre_default_ta	Line 22 extern "C" unsigned char pcre_default_ta
#include "pa_types.h"	#include "pa_types.h"
#include "pa_vtable.h"	#include "pa_vtable.h"
#include "pa_vfile.h"	#include "pa_vfile.h"
	#include "pa_dictionary.h"
	#include "pa_charset_manager.h"
	#include "pa_charset_connection.h"

/// 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";
Line 34 const char *ORIGINS_CONTENT_TYPE="text/p	Line 35 const char *ORIGINS_CONTENT_TYPE="text/p

Methoded *MOP_create(Pool&);	Methoded *MOP_create(Pool&);

	static void load_charset(const Hash::Key& akey, Hash::Val *avalue,
	void *info) {
	Value& value=static_cast<Value >(avalue);
	Hash& CTYPE=static_cast<Hash >(info);

	Charset_connection& connection=
	charset_manager->get_connection(akey, value.as_string());

	// charset->pcre_tables
	CTYPE.put(akey, connection.pcre_tables());
	}

//	//
Request::Request(Pool& apool,	Request::Request(Pool& apool,
Info& ainfo,	Info& ainfo,
String::Untaint_lang adefault_lang) : Pooled(apool),	uchar adefault_lang,
	bool status_allowed) : Pooled(apool),
stack(apool),	stack(apool),
OP(*MOP_create(apool)),	OP(*MOP_create(apool)),
env(apool),	env(apool),
	status(apool),
form(apool),	form(apool),
math(apool),	math(apool),
request(apool, *this),	request(apool, *this),
response(apool),	response(apool),
cookie(apool),	cookie(apool),
fclasses(apool),	fclasses(apool),
	CTYPE(apool),
fdefault_lang(adefault_lang), flang(adefault_lang),	fdefault_lang(adefault_lang), flang(adefault_lang),
info(ainfo),	info(ainfo),
post_data(0), post_size(0),	post_data(0), post_size(0),
Line 55 Request::Request(Pool& apool,	Line 71 Request::Request(Pool& apool,
mime_types(0),	mime_types(0),
main_class(0),	main_class(0),
connection(0),	connection(0),
pcre_tables(0),
classes_conf(apool),	classes_conf(apool),
anti_endless_execute_recoursion(0)	anti_endless_execute_recoursion(0),
	trace(apool)
	#ifdef RESOURCES_DEBUG
	,sql_connect_time(0),sql_request_time(0)
	#endif
{	{
	// maybe expire old caches
	cache_managers->maybe_expire();

/// directly used	/// directly used
// operators	// operators
OP.register_directly_used(*this);	OP.register_directly_used(*this);
Line 69 Request::Request(Pool& apool,	Line 91 Request::Request(Pool& apool,
/// methodless	/// methodless
// env class	// env class
classes().put(*NEW String(pool(), ENV_CLASS_NAME), &env);	classes().put(*NEW String(pool(), ENV_CLASS_NAME), &env);
	// status class
	if(status_allowed)
	classes().put(*NEW String(pool(), STATUS_CLASS_NAME), &status);
// request class	// request class
classes().put(*NEW String(pool(), REQUEST_CLASS_NAME), &request);	classes().put(*NEW String(pool(), REQUEST_CLASS_NAME), &request);
// cookie class	// cookie class
Line 85 Request::Request(Pool& apool,	Line 110 Request::Request(Pool& apool,
classes().put(math.get_class()->base()->name(), &math);	classes().put(math.get_class()->base()->name(), &math);
}	}

static void element2ctypes(unsigned char *tables,
Value& ctype, const String& name,
unsigned char bit,
int group_offset=-1,
bool skip_ws=true) {
Value *value=ctype.get_element(name);
if(!value)
return;

unsigned char *ctypes_table=tables+ctypes_offset;
const unsigned char *cstr=
(const unsigned char *)value->as_string().cstr(String::UL_AS_IS);
for(; *cstr; cstr++) {
unsigned char c=*cstr;
if(skip_ws && (c=='\n' \|\| c=='\t' \|\| c==' '))
continue;
ctypes_table[c]\|=bit;

if(group_offset>=0)
tables[cbits_offset+group_offset+c/8] \|= 1 << (c%8);
}
}
static void cstr2ctypes(unsigned char tables, const unsigned char cstr,
unsigned char bit) {
unsigned char *ctypes_table=tables+ctypes_offset;
ctypes_table[0]=bit;
for(; *cstr; cstr++) {
unsigned char c=*cstr;
ctypes_table[c]\|=bit;
}
}
static void prepare_case_tables(unsigned char *tables) {
unsigned char *lcc_table=tables+lcc_offset;
unsigned char *fcc_table=tables+fcc_offset;
for(int i=0; i<0x100; i++)
lcc_table[i]=fcc_table[i]=i;
}
static void element2case(unsigned char *tables, Value& ctype, const String& name) {
Value *value=ctype.get_element(name);
if(!value)
return;

unsigned char *lcc_table=tables+lcc_offset;
unsigned char *fcc_table=tables+fcc_offset;
const unsigned char *cstr=
(const unsigned char *)value->as_string().cstr(String::UL_AS_IS);
unsigned char from=0;
for(; *cstr; cstr++) {
unsigned char c=*cstr;
if(c=='\n' \|\| c=='\t' \|\| c==' ')
continue;
if(from) {
lcc_table[from]=c;
fcc_table[from]=c; fcc_table[c]=from;
from=0;
} else
from=c;
}
}
/**	/**
load MAIN class, execute @main.	load MAIN class, execute @main.
MAIN class consists of all the auto.p files we'd manage to find	MAIN class consists of all the auto.p files we'd manage to find
Line 151 static void element2case(unsigned char *	Line 117 static void element2case(unsigned char *
the file user requested us to process	the file user requested us to process
all located classes become children of one another,	all located classes become children of one another,
composing class we name 'MAIN'	composing class we name 'MAIN'

	@test log stack trace

*/	*/
void Request::core(const char *root_auto_path, bool root_auto_fail,	void Request::core(
const char *site_auto_path, bool site_auto_fail,	const char *root_config_filespec, bool root_config_fail_on_read_problem,
	const char *site_config_filespec, bool site_config_fail_on_read_problem,
bool header_only) {	bool header_only) {
//_asm { int 3 }
bool need_rethrow=false; Exception rethrow_me;	#ifdef RESOURCES_DEBUG
TRY {	//measures
	struct timeval mt[10];
	//measure:before all
	gettimeofday(&mt[0],NULL);
	#endif
	try {
char auto_filespec=(char )malloc(MAX_STRING);	char auto_filespec=(char )malloc(MAX_STRING);

// loading root auto.p	// loading root config
if(root_auto_path) {	if(root_config_filespec) {
String& filespec=*NEW String(pool());	String& filespec=*NEW String(pool());
filespec.APPEND_CLEAN(root_auto_path, 0, "root_auto", 0);	filespec.APPEND_CLEAN(root_config_filespec, 0, "root_config", 0);
filespec.APPEND_CONST("/" AUTO_FILE_NAME);
main_class=use_file(	main_class=use_file(
filespec, root_auto_fail,	filespec,
	true/ignore class_path/, root_config_fail_on_read_problem,
main_class_name, main_class);	main_class_name, main_class);
}	}

	if(main_class) {
	/* $MAIN:CHARSETS[
	$.charsetname1[/full/path/to/charset/file.cfg]
	...
	]
	*/
	if(Value vcharsets=main_class->get_element(charsets_name)) {
	if(Hash *charsets=vcharsets->get_hash(0))
	charsets->for_each(load_charset, &CTYPE);
	else
	throw Exception(0, 0,
	&vcharsets->name(),
	"must be hash");
	}
	}

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

// loading site auto.p	// loading site config
if(site_auto_path) {	if(site_config_filespec) {
String& filespec=*NEW String(pool());	String& filespec=*NEW String(pool());
filespec.APPEND_CLEAN(site_auto_path, 0, "site_auto", 0);	filespec.APPEND_CLEAN(site_config_filespec, 0, "site_config", 0);
filespec.APPEND_CONST("/" AUTO_FILE_NAME);
main_class=use_file(	main_class=use_file(
filespec, site_auto_fail,	filespec,
	true/ignore class_path/, site_config_fail_on_read_problem,
main_class_name, main_class);	main_class_name, main_class);
}	}

Line 189 void Request::core(const char *root_auto	Line 180 void Request::core(const char *root_auto
// to the one beside requested file.	// to the one beside requested file.
// all assigned bases from upper dir	// all assigned bases from upper dir
{	{
Array ladder(pool());
const char *after=info.path_translated;	const char *after=info.path_translated;
size_t drlen=strlen(info.document_root);	size_t drlen=strlen(info.document_root);
if(memcmp(after, info.document_root, drlen)==0) {	if(memcmp(after, info.document_root, drlen)==0) {
Line 198 void Request::core(const char *root_auto	Line 188 void Request::core(const char *root_auto
--after;	--after;
}	}

	int step=0;
while(const char *before=strchr(after, '/')) {	while(const char *before=strchr(after, '/')) {
String& step=*NEW String(pool());	String& sfile_spec=*NEW String(pool());
if(after!=info.path_translated) {	if(after!=info.path_translated) {
step.APPEND_CLEAN(	sfile_spec.APPEND_CLEAN(
info.path_translated, before+1/* / */-info.path_translated,	info.path_translated, before-info.path_translated,
"path-translated-scanned", ladder.size());	"path-translated-scanned", step++);
step << AUTO_FILE_NAME;	sfile_spec << "/" AUTO_FILE_NAME;
ladder+=&step;
	main_class=use_file(sfile_spec,
	true/ignore class_path/, false/ignore read problem/,
	main_class_name, main_class);
}	}
after=before+1;	after=before+1;
}	}
for(int i=0; i<ladder.size(); i++) {
const String& sfile_spec=*ladder.get_string(i);
main_class=use_file(sfile_spec, false/ignore read problem/,
main_class_name, main_class);
}
}	}

// compile requested file	// compile requested file
String& spath_translated=*NEW String(pool());	String& spath_translated=*NEW String(pool());
spath_translated.APPEND_TAINTED(info.path_translated, 0, "user-request", 0);	spath_translated.APPEND_TAINTED(info.path_translated, 0, "user-request", 0);
main_class=use_file(spath_translated, true/don't ignore read problem/,	main_class=use_file(spath_translated,
	true/ignore class_path/, true/don't ignore read problem/,
main_class_name, main_class);	main_class_name, main_class);

// configure not-root=user options	// configure not-root=user options
Line 231 void Request::core(const char *root_auto	Line 221 void Request::core(const char *root_auto
// value must be allocated on request's pool for that pool used on	// value must be allocated on request's pool for that pool used on
// meaning constructing @see attributed_meaning_to_string	// meaning constructing @see attributed_meaning_to_string
default_content_type=defaults?defaults->get_element(*content_type_name):0;	default_content_type=defaults?defaults->get_element(*content_type_name):0;
if(Value element=main_class->get_element(user_html_name))	// record default charset
if(Table *table=element->get_table())	if(default_content_type)
pool().set_tag(table);	if(Hash *hash=default_content_type->get_hash(0))
	if(Value vcharset=(Value )hash->get(*charset_name))
	pool().set_charset(vcharset->as_string());

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

/*
$MAIN:CTYPE[
$white-space[
^#09^#0A^#0B^#0C^#0D^#20]
$digit[
0123456789]
$hex-digit[
0123456789ABCDEFabcdef]
$letter[
ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz]
$word[
0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz]

$lowercase[
AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz]
]
*/
if(Value ctype=main_class->get_element(ctype_name)) {
// lowcase, flipcase, bits digit+word+whitespace, masks
pcre_tables=(unsigned char *)calloc(tables_length);
prepare_case_tables(pcre_tables);

element2ctypes(pcre_tables, ctype, ctype_white_space_name, ctype_space, cbit_space, false);
element2ctypes(pcre_tables, ctype, ctype_digit_name, ctype_digit, cbit_digit);
element2ctypes(pcre_tables, ctype, ctype_hex_digit_name, ctype_xdigit);
element2ctypes(pcre_tables, ctype, ctype_letter_name, ctype_letter);
element2ctypes(pcre_tables, ctype, ctype_word_name, ctype_word, cbit_word);
cstr2ctypes(pcre_tables, (const unsigned char )"+?{^.$\|()[", ctype_meta);

element2case(pcre_tables, ctype, ctype_lowercase_name);
} else
pcre_tables=pcre_default_tables;

// filling form fields	// filling form fields
form.fill_fields(*this);	form.fill_fields_and_tables(*this);

// filling cookies	// filling cookies
cookie.fill_fields(*this);	cookie.fill_fields(*this);

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

	#ifdef RESOURCES_DEBUG
	//measure:after main
	gettimeofday(&mt[2],NULL);
	#endif

VString body_vstring_before_post_process(*body_string);	VString body_vstring_before_post_process(*body_string);
VString *body_vstring_after_post_process=&body_vstring_before_post_process;	VString *body_vstring_after_post_process=&body_vstring_before_post_process;

// @postprocess	// @postprocess
if(Value value=main_class->get_element(post_process_method_name))	if(Value value=main_class->get_element(post_process_method_name))
if(Junction *junction=value->get_junction())	if(Junction *junction=value->get_junction())
Line 319 void Request::core(const char *root_auto	Line 286 void Request::core(const char *root_auto
response.fields().put(*content_type_name,	response.fields().put(*content_type_name,
NEW VString(*NEW String(pool(), ORIGINS_CONTENT_TYPE)));	NEW VString(*NEW String(pool(), ORIGINS_CONTENT_TYPE)));

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

// OK. write out the result	// OK. write out the result
output_result(*body_file, header_only);	output_result(*body_file, header_only);
}
CATCH(e) { // request handling problem	#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",
	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	// we're returning not result, but error explanation
TRY {	try {
// log the beast	// log the beast
const String *problem_source=e.problem_source();	const String *problem_source=e.problem_source();
if(problem_source && problem_source->size())	if(problem_source && problem_source->size())
SAPI::log(pool(),	SAPI::log(pool(),
#ifndef NO_STRING_ORIGIN	#ifndef NO_STRING_ORIGIN
"%s(%d): "	ORIGIN_FILE_LINE_FORMAT": "
#endif	#endif
"'%s' %s [%s %s]",	"'%s' %s [%s %s]",
#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(String::UL_AS_IS),	problem_source->cstr(),
e.comment(),	e.comment(),
e.type()?e.type()->cstr(String::UL_AS_IS):"-",	e.type()?e.type()->cstr():"-",
e.code()?e.code()->cstr(String::UL_AS_IS):"-"	e.code()?e.code()->cstr():"-"
);	);
else	else
SAPI::log(pool(),	SAPI::log(pool(),
"%s [%s %s]",	"%s [%s %s]",
e.comment(),	e.comment(),
e.type()?e.type()->cstr(String::UL_AS_IS):"-",	e.type()?e.type()->cstr():"-",
e.code()?e.code()->cstr(String::UL_AS_IS):"-"	e.code()?e.code()->cstr():"-"
);	);

// reset language to default	// reset language to default
flang=fdefault_lang;	flang=fdefault_lang;
if(flang==String::UL_USER_HTML)
flang=String::UL_HTML; // no _ & Co conversions in @exception[params]

// reset response	// reset response
response.fields().clear();	response.fields().clear();
Line 367 void Request::core(const char *root_auto	Line 355 void Request::core(const char *root_auto
if(Value value=main_class->get_element(exception_method_name))	if(Value value=main_class->get_element(exception_method_name))
if(Junction *junction=value->get_junction())	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
// @exception[origin;source;comment;type;code]	// @exception[origin;source;comment;type;code;stack]
VMethodFrame frame(pool(), value->name(), *junction);	VMethodFrame frame(pool(), value->name(), *junction);
frame.set_self(*main_class);	frame.set_self(*main_class);

Line 380 void Request::core(const char *root_auto	Line 368 void Request::core(const char *root_auto
const Origin& origin=problem_source->origin();	const Origin& origin=problem_source->origin();
if(origin.file) {	if(origin.file) {
char buf=(char )malloc(MAX_STRING);	char buf=(char )malloc(MAX_STRING);
size_t buf_size=snprintf(buf, MAX_STRING, "%s(%d):",	size_t buf_size=snprintf(buf, MAX_STRING, ORIGIN_FILE_LINE_FORMAT,
origin.file, 1+origin.line);	origin.file, 1+origin.line);
String *origin_file_line=NEW String(pool(),	origin_value=NEW VString(*NEW String(pool(),
buf, buf_size, true);	buf, buf_size, true));
origin_value=NEW VString(*origin_file_line);
}	}
}	}
#endif	#endif
Line 428 void Request::core(const char *root_auto	Line 415 void Request::core(const char *root_auto
code_value=NEW VVoid(pool());	code_value=NEW VVoid(pool());
frame.store_param(method->name, code_value);	frame.store_param(method->name, code_value);

	// $stack[^table::set{name origin}]
	Array& stack_trace_columns=*NEW Array(pool());
	stack_trace_columns+=NEW String(pool(), "name");
	stack_trace_columns+=NEW String(pool(), "origin");
	Table& stack_trace=*NEW Table(pool(), 0, &stack_trace_columns);
	Array_iter tracei(trace);
	while(tracei.has_next()) {
	Array& row=*NEW Array(pool());

	const String name=(const String )tracei.next();
	row+=name; // name column
	#ifndef NO_STRING_ORIGIN
	const Origin& origin=name->origin();
	if(origin.file) {
	char buf=(char )malloc(MAX_STRING);
	size_t buf_size=snprintf(buf, MAX_STRING, ORIGIN_FILE_LINE_FORMAT,
	origin.file, 1+origin.line);
	row+=NEW String(pool(), buf, buf_size, true); // origin column
	}
	#endif
	stack_trace+=&row;
	}
	frame.store_param(method->name,
	NEW VTable(pool(), &stack_trace));

// future $response:body=	// future $response:body=
// execute ^exception[origin;source;comment;type;code]	// execute ^exception[origin;source;comment;type;code;stack]
body_string=execute_method(frame, *method);	body_string=execute_method(frame, *method);
}	}
}	}
Line 445 void Request::core(const char *root_auto	Line 457 void Request::core(const char *root_auto
#ifndef NO_STRING_ORIGIN	#ifndef NO_STRING_ORIGIN
const Origin& origin=problem_source->origin();	const Origin& origin=problem_source->origin();
if(origin.file)	if(origin.file)
printed+=snprintf(buf+printed, MAX_STRING-printed, "%s(%d): ",	printed+=snprintf(buf+printed, MAX_STRING-printed,
origin.file, 1+origin.line);	ORIGIN_FILE_LINE_FORMAT": ",
	origin.file, 1+origin.line
	);
#endif	#endif
printed+=snprintf(buf+printed, MAX_STRING-printed, "'%s' ",	printed+=snprintf(buf+printed, MAX_STRING-printed, "'%s' ",
problem_source->cstr(String::UL_AS_IS));	problem_source->cstr());
}	}
printed+=snprintf(buf+printed, MAX_STRING-printed, "%s",	printed+=snprintf(buf+printed, MAX_STRING-printed, "%s",
e.comment());	e.comment());
const String *type=e.type();	const String *type=e.type();
if(type) {	if(type) {
printed+=snprintf(buf+printed, MAX_STRING-printed, " type: %s",	printed+=snprintf(buf+printed, MAX_STRING-printed, " type: %s",
type->cstr(String::UL_AS_IS));	type->cstr());
const String *code=e.code();	const String *code=e.code();
if(code)	if(code)
printed+=snprintf(buf+printed, MAX_STRING-printed, ", code: %s",	printed+=snprintf(buf+printed, MAX_STRING-printed, ", code: %s",
code->cstr(String::UL_AS_IS));	code->cstr());
}	}

// future $response:content-type	// future $response:content-type
Line 475 void Request::core(const char *root_auto	Line 489 void Request::core(const char *root_auto

// ERROR. write it out	// ERROR. write it out
output_result(*body_file, header_only);	output_result(*body_file, header_only);
	} catch(const Exception& ) {
	/re/throw;
}	}
CATCH(e) {
// exception in request exception handler
// remember to rethrow it
rethrow_me=e; need_rethrow=true;
}
END_CATCH
}	}
END_CATCH // do not use pool() after this point - no exception handler set
// any throw() would try to use zero exception() pointer

if(need_rethrow) // were there an exception for us to rethrow?
THROW(rethrow_me.type(), rethrow_me.code(),
rethrow_me.problem_source(),
rethrow_me.comment());
}	}

VStateless_class *Request::use_file(const String& file_spec, bool fail_on_read_problem,	VStateless_class *Request::use_file(const String& file_name,
	bool ignore_class_path, bool fail_on_read_problem,
const String *name,	const String *name,
VStateless_class *base_class) {	VStateless_class *base_class) {
// cyclic dependence check	// cyclic dependence check
if(used_files.get(file_spec))	if(used_files.get(file_name))
return base_class;	return base_class;
used_files.put(file_spec, (Hash::Val *)true);	used_files.put(file_name, (Hash::Val *)true);

	const String *file_spec;
	if(ignore_class_path) // ignore_class_path?
	file_spec=&file_name;
	else if(file_name.first_char()=='/') //absolute path, no need to scan MAIN:CLASS_PATH?
	file_spec=&absolute(file_name);
	else {
	file_spec=0;
	if(main_class)
	if(Value element=main_class->get_element(class_path_name)) {
	if(element->is_string()) {
	file_spec=file_readable(element->as_string(), file_name); // found at class_path?
	} else if(Table *table=element->get_table()) {
	int size=table->size();
	for(int i=size; i--; ) {
	const String& path=static_cast<Array >(table->get(i))->get_string(0);
	if(file_spec=file_readable(path, file_name))
	break; // found along class_path
	}
	} else
	throw Exception(0, 0,
	&element->name(),
	"must be string or table");
	if(!file_spec)
	throw Exception(0, 0,
	&file_name,
	"not found along " MAIN_CLASS_NAME ":" CLASS_PATH_NAME);
	}
	if(!file_spec)
	throw Exception(0, 0,
	&file_name,
	"usage failed - no " MAIN_CLASS_NAME ":" CLASS_PATH_NAME " were specified");
	}

char *source=file_read_text(pool(), file_spec, fail_on_read_problem);	char source=file_read_text(pool(), file_spec, fail_on_read_problem);
if(!source)	if(!source)
return base_class;	return base_class;

return use_buf(source, file_spec.cstr(), 0/new class/, name, base_class);	return use_buf(source, file_spec->cstr(), 0/new class/, name, base_class);
}	}

VStateless_class Request::use_buf(const char source, const char *file,	VStateless_class Request::use_buf(const char source, const char *file,
Line 542 const String& Request::absolute(const St	Line 578 const String& Request::absolute(const St

static void add_header_attribute(const Hash::Key& aattribute, Hash::Val *ameaning,	static void add_header_attribute(const Hash::Key& aattribute, Hash::Val *ameaning,
void *info) {	void *info) {
String attribute_to_exclude=static_cast<String >(info);	Request& r=static_cast<Request >(info);
if(aattribute==*attribute_to_exclude)	if(aattribute==*body_name)
return;	return;

Value& lmeaning=static_cast<Value >(ameaning);	Value& lmeaning=static_cast<Value >(ameaning);
Pool& pool=lmeaning.pool();	Pool& pool=lmeaning.pool();

SAPI::add_header_attribute(pool,	SAPI::add_header_attribute(pool,
aattribute.cstr(String::UL_AS_IS),	aattribute.cstr(),
attributed_meaning_to_string(lmeaning, String::UL_HTTP_HEADER).cstr());	attributed_meaning_to_string(lmeaning, String::UL_HTTP_HEADER).cstr());
}	}
void Request::output_result(const VFile& body_file, bool header_only) {	void Request::output_result(const VFile& body_file, bool header_only) {
Line 573 void Request::output_result(const VFile&	Line 609 void Request::output_result(const VFile&
if(VString vfile_name=static_cast<VString >(body_file.fields().get(*name_name)))	if(VString vfile_name=static_cast<VString >(body_file.fields().get(*name_name)))
if(vfile_name->string()!=NONAME_DAT) {	if(vfile_name->string()!=NONAME_DAT) {
VHash& vhash=*NEW VHash(pool());	VHash& vhash=*NEW VHash(pool());
vhash.hash().put(*content_disposition_filename_name, vfile_name);	vhash.hash(0).put(*content_disposition_filename_name, vfile_name);
response.fields().put(*content_disposition_name, &vhash);	response.fields().put(*content_disposition_name, &vhash);
}	}

// prepare header: $response:fields without :body	// prepare header: $response:fields without :body
response.fields().for_each(add_header_attribute, /excluding/ body_name);	response.fields().for_each(add_header_attribute, this);

// prepare...	// prepare...
const void *body=body_file.value_ptr();	const void *body=body_file.value_ptr();
Line 607 const String& Request::mime_type_of(cons	Line 643 const String& Request::mime_type_of(cons
if(const String *result=mime_types->item(1))	if(const String *result=mime_types->item(1))
return *result;	return *result;
else	else
THROW(0, 0,	throw Exception(0, 0,
mime_types->origin_string(),	mime_types->origin_string(),
"MIME-TYPE table column elements must not be empty");	"MIME-TYPE table column elements must not be empty");
}	}
return *NEW String(pool(), "application/octet-stream");	return *NEW String(pool(), "application/octet-stream");
}	}

	const unsigned char *Request::pcre_tables() {
	if(unsigned char result=(unsigned char )CTYPE.get(pool().get_charset()))
	return result;

	// this is not for pcre itself,
	// it can do default, it's for string.lower&co
	return pcre_default_tables;
	}

E-mail:

Removed from v.1.146
changed lines
	Added in v.1.182.2.1.2.1