parser3/src/classes/op.C - diff

Return to op.C CVS log

Up to [parser3project] / parser3 / src / classes

Diff for /parser3/src/classes/op.C between versions 1.70 and 1.91

version 1.70, 2002/02/08 07:27:40	version 1.91, 2002/04/18 10:51:00
Line 2	Line 2
Parser: parser @b operators.	Parser: parser @b operators.

Copyright (c) 2001, 2002 ArtLebedev Group (http://www.artlebedev.com)	Copyright (c) 2001, 2002 ArtLebedev Group (http://www.artlebedev.com)
Author: Alexander Petrosyan <paf@design.ru> (http://paf.design.ru)	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)

$Id$	$Id$
*/	*/
Line 12	Line 12
#include "pa_request.h"	#include "pa_request.h"
#include "pa_vint.h"	#include "pa_vint.h"
#include "pa_sql_connection.h"	#include "pa_sql_connection.h"
	#include "pa_vdate.h"

// limits	// limits

Line 19	Line 20

// defines	// defines

#define OP_CLASS_NAME "OP"	#define CASE_DEFAULT_VALUE "DEFAULT"

// class	// class

Line 40 private:	Line 41 private:
static void _if(Request& r, const String&, MethodParams *params) {	static void _if(Request& r, const String&, MethodParams *params) {
Value& condition_code=params->as_junction(0, "condition must be expression");	Value& condition_code=params->as_junction(0, "condition must be expression");

bool condition=r.process(condition_code,	bool condition=r.process_to_value(condition_code,
0/no name/,	/0/no name* /,*/
false/don't intercept string/).as_bool();	false/don't intercept string/).as_bool();
if(condition)	if(condition)
r.write_pass_lang(r.process(params->as_junction(1, "'then' parameter must be code")));	r.write_pass_lang(r.process(params->as_junction(1, "'then' parameter must be code")));
Line 59 static void _untaint(Request& r, const S	Line 60 static void _untaint(Request& r, const S
const String& lang_name=params->as_string(0, "lang must be string");	const String& lang_name=params->as_string(0, "lang must be string");
lang=untaint_lang_name2enum->get_int(lang_name);	lang=untaint_lang_name2enum->get_int(lang_name);
if(!lang)	if(!lang)
throw Exception(0, 0,	throw Exception(0,
&lang_name,	&lang_name,
"invalid taint language");	"invalid taint language");
}	}
Line 82 static void _taint(Request& r, const Str	Line 83 static void _taint(Request& r, const Str
const String& lang_name=params->as_string(0, "lang must be string");	const String& lang_name=params->as_string(0, "lang must be string");
lang=untaint_lang_name2enum->get_int(lang_name);	lang=untaint_lang_name2enum->get_int(lang_name);
if(!lang)	if(!lang)
throw Exception(0, 0,	throw Exception(0,
&lang_name,	&lang_name,
"invalid taint language");	"invalid taint language");
}	}
Line 90 static void _taint(Request& r, const Str	Line 91 static void _taint(Request& r, const Str
{	{
Value& vbody=params->as_no_junction(params->size()-1, "body must not be code");	Value& vbody=params->as_no_junction(params->size()-1, "body must not be code");

String result(r.pool());	String& result=*new(pool) String(pool);
result.append(	result.append(
vbody.as_string(), // process marking tainted with that lang	vbody.as_string(), // process marking tainted with that lang
lang, true); // force result language to specified	lang, true); // force result language to specified
Line 101 static void _taint(Request& r, const Str	Line 102 static void _taint(Request& r, const Str
static void _process(Request& r, const String& method_name, MethodParams *params) {	static void _process(Request& r, const String& method_name, MethodParams *params) {
// calculate pseudo file name of processed chars	// calculate pseudo file name of processed chars
// would be something like "/some/file(4) process"	// would be something like "/some/file(4) process"
char place[MAX_STRING];	char local_place[MAX_STRING];
#ifndef NO_STRING_ORIGIN	#ifndef NO_STRING_ORIGIN
const Origin& origin=method_name.origin();	const Origin& origin=method_name.origin();
snprintf(place, MAX_STRING, "%s(%d) %s",	size_t place_size=snprintf(local_place, MAX_STRING, "%s(%d) %s",
origin.file, 1+origin.line,	origin.file?origin.file:"unknown_file", 1+origin.line,
method_name.cstr());	method_name.cstr())+1;
#else	#else
strncpy(place, method_name.cstr(), MAX_STRING-1); place[MAX_STRING-1]=0;	strncpy(local_place, method_name.cstr(), MAX_STRING-1); place[MAX_STRING-1]=0;
#endif	size_t place_size=strlen(local_place)+1;
	#endif
	char heap_place=(char )r.malloc(place_size);
	memcpy(heap_place, local_place, place_size);


VStateless_class& self_class=*r.self->get_class();	VStateless_class& self_class=*r.self->get_class();
	const Method *main_method;
{	{
	// temporary remove language change
	Temp_lang temp_lang(r, String::UL_PASS_APPENDED);
// temporary zero @main so to maybe-replace it in processed code	// temporary zero @main so to maybe-replace it in processed code
Temp_method temp_method_main(self_class, *main_method_name, 0);	Temp_method temp_method_main(self_class, *main_method_name, 0);
// temporary zero @auto so it wouldn't be auto-called in Request::use_buf	// temporary zero @auto so it wouldn't be auto-called in Request::use_buf
Temp_method temp_method_auto(self_class, *auto_method_name, 0);	Temp_method temp_method_auto(self_class, *auto_method_name, 0);

// evaluate source to process	// evaluate source to process
const String& source=	const String& source=r.process_to_string(params->as_junction(0, "body must be code"));
r.process(params->as_junction(0, "body must be code")).as_string();

// process source code, append processed methods to 'self' class	// process source code, append processed methods to 'self' class
// maybe-define new @main	// maybe-define new @main
r.use_buf(	r.use_buf(
source.cstr(String::UL_UNSPECIFIED, r.connection(0)),	source.cstr(String::UL_UNSPECIFIED, r.connection(0)),
place,	heap_place,
&self_class);	&self_class);

// maybe-execute @main[]	// main_method
if(const Method method=self_class.get_method(main_method_name)) {	main_method=self_class.get_method(*main_method_name);
// execute!	}
r.execute(*method->parser_code);	// after restoring current-request-lang
}	// maybe-execute @main[]
	if(main_method) {
	// execute!
	r.execute(*main_method->parser_code);
}	}
}	}

Line 151 static void _while(Request& r, const Str	Line 161 static void _while(Request& r, const Str
int endless_loop_count=0;	int endless_loop_count=0;
while(true) {	while(true) {
if(++endless_loop_count>=MAX_LOOPS) // endless loop?	if(++endless_loop_count>=MAX_LOOPS) // endless loop?
throw Exception(0, 0,	throw Exception("parser.runtime",
&method_name,	&method_name,
"endless loop detected");	"endless loop detected");

bool condition=	bool condition=r.process_to_value(vcondition,
r.process(	/0/no name* /,*/
vcondition,
0/no name/,
false/don't intercept string/).as_bool();	false/don't intercept string/).as_bool();
if(!condition) // ...condition is true	if(!condition) // ...condition is true
break;	break;
Line 182 static void _for(Request& r, const Strin	Line 190 static void _for(Request& r, const Strin
Value *delim_maybe_code=params->size()>4?&params->get(4):0;	Value *delim_maybe_code=params->size()>4?&params->get(4):0;

if(to-from>=MAX_LOOPS) // too long loop?	if(to-from>=MAX_LOOPS) // too long loop?
throw Exception(0, 0,	throw Exception("parser.runtime",
&method_name,	&method_name,
"endless loop detected");	"endless loop detected");

Line 192 static void _for(Request& r, const Strin	Line 200 static void _for(Request& r, const Strin
vint->set_int(i);	vint->set_int(i);
r.root->put_element(var_name, vint);	r.root->put_element(var_name, vint);

Value& processed_body=r.process(body_code);	StringOrValue processed_body=r.process(body_code);
if(delim_maybe_code) { // delimiter set?	if(delim_maybe_code) { // delimiter set?
const String *string=processed_body.get_string();	const String *string=processed_body.get_string();
if(need_delim && string && string->size()) // need delim & iteration produced string?	if(need_delim && string && string->size()) // need delim & iteration produced string?
Line 206 static void _for(Request& r, const Strin	Line 214 static void _for(Request& r, const Strin
static void _eval(Request& r, const String& method_name, MethodParams *params) {	static void _eval(Request& r, const String& method_name, MethodParams *params) {
Value& expr=params->as_junction(0, "need expression");	Value& expr=params->as_junction(0, "need expression");
// evaluate expresion	// evaluate expresion
Value *result=r.process(expr,	Value *value_result=r.process_to_value(expr,
0/no name YET/,	/0/no name YET* /,*/
true/don't intercept string/).as_expr_result();	true/don't intercept string/).as_expr_result();
if(params->size()>1) {	if(params->size()>1) {
Value& fmt=params->as_no_junction(1, "fmt must not be code");	Value& fmt=params->as_no_junction(1, "fmt must not be code");

Pool& pool=r.pool();	Pool& pool=r.pool();
String& string=*new(pool) String(pool);	String& string=*new(pool) String(pool);
string.APPEND_CONST(format(pool, result->as_double(), fmt.as_string().cstr()));	string.APPEND_CONST(format(pool, value_result->as_double(), fmt.as_string().cstr()));
result=new(pool) VString(string);	r.write_no_lang(string);
}	} else
result->set_name(method_name);	r.write_no_lang(*value_result);
r.write_no_lang(*result);
}	}

static void _error(Request& r, const String& method_name, MethodParams *params) {
Pool& pool=r.pool();

const String& serror=params->as_string(0, "message must be string");
throw Exception(0, 0,
&method_name,
"%s", serror.cstr());
}


/// @todo rewrite ugly code with try/try to autoobject TempConnection
static void _connect(Request& r, const String& method_name, MethodParams *params) {	static void _connect(Request& r, const String& method_name, MethodParams *params) {
Pool& pool=r.pool();	Pool& pool=r.pool();
#ifdef RESOURCES_DEBUG	#ifdef RESOURCES_DEBUG
Line 265 r.sql_connect_time+=t[1]-t[0];	Line 261 r.sql_connect_time+=t[1]-t[0];
// execute body	// execute body
try {	try {
r.write_assign_lang(r.process(body_code));	r.write_assign_lang(r.process(body_code));
	} catch(...) { // process problem
} catch(...) { // process/commit problem
connection->mark_to_rollback();	connection->mark_to_rollback();
/re/throw;	/re/throw;
}	}
Line 274 r.sql_connect_time+=t[1]-t[0];	Line 269 r.sql_connect_time+=t[1]-t[0];

#ifndef DOXYGEN	#ifndef DOXYGEN
struct Switch_data {	struct Switch_data {
	Request *r;
Value *searching;	Value *searching;
Value *found;	Value *found;
Value *_default;	Value *_default;
};	};
#endif	#endif
static void _switch(Request& r, const String&, MethodParams *params) {	static void _switch(Request& r, const String&, MethodParams *params) {
void backup=r.classes_conf.get(switch_data_name);	Switch_data data={&r, &r.process_to_value(params->get(0))};
Switch_data data={&r.process(params->get(0))};	Temp_hash_value switch_data_setter(r.classes_conf, *switch_data_name, &data);
r.classes_conf.put(*switch_data_name, &data);

r.process(params->as_junction(1, "switch cases must be code")); // and ignore result

r.classes_conf.put(*switch_data_name, backup);	Value& cases_code=params->as_junction(1, "switch cases must be code");
	// execution of found ^case[...]{code} must be in context of ^switch[...]{code}
if(Value *code=data.found ? data.found : data._default)	// because of stacked WWrapper used there as wcontext
r.write_pass_lang(r.process(*code));	r.process(cases_code, true/intercept_string/);
	if(Value *selected_code=data.found ? data.found : data._default) {
	// setting code context, would execute in ^switch[...]{>>context<<}
	selected_code->get_junction()->change_context(cases_code.get_junction());
	r.write_pass_lang(r.process(*selected_code));
	}
}	}

static void _case(Request& r, const String& method_name, MethodParams *params) {	static void _case(Request& r, const String& method_name, MethodParams *params) {
Line 297 static void _case(Request& r, const Stri	Line 295 static void _case(Request& r, const Stri

Switch_data data=static_cast<Switch_data >(r.classes_conf.get(*switch_data_name));	Switch_data data=static_cast<Switch_data >(r.classes_conf.get(*switch_data_name));
if(!data)	if(!data)
throw Exception(0, 0,	throw Exception("parser.runtime",
&method_name,	&method_name,
"without switch");	"without switch");

int count=params->size();	int count=params->size();
Value *code=&params->as_junction(--count, "case result must be code");	Value *code=&params->as_junction(--count, "case result must be code");

	// killing context for safety, would execute in ^switch[...]{>>context<<}
	// reason: context is stacked, and it would become invalid afterwards
	code->get_junction()->change_context(0);

for(int i=0; i<count; i++) {	for(int i=0; i<count; i++) {
Value& value=r.process(params->get(i));	Value& value=r.process_to_value(params->get(i));

if(value.as_string() == *case_default_value) {	if(value.as_string() == CASE_DEFAULT_VALUE) {
data->_default=code;	data->_default=code;
break;	break;
}	}
Line 318 static void _case(Request& r, const Stri	Line 321 static void _case(Request& r, const Stri
matches=data->searching->as_double() == value.as_double();	matches=data->searching->as_double() == value.as_double();

if(matches) {	if(matches) {
	if(data->found)
	throw Exception("parser.runtime",
	&method_name,
	"duplicate found");

data->found=code;	data->found=code;
break;	break;
}	}
Line 328 static void _case(Request& r, const Stri	Line 336 static void _case(Request& r, const Stri

// consts	// consts

const int DATA_STRING_SERIALIZED_VERSION=0x0001;	const int DATA_STRING_SERIALIZED_VERSION=0x0002;

// helper types	// helper types

#ifndef DOXYGEN	#ifndef DOXYGEN
struct Data_string_serialized_prolog {	struct Data_string_serialized_prolog {
int version;	int version;
	time_t expires;
};	};
#endif	#endif

Line 343 void cache_delete(const String& file_spe	Line 352 void cache_delete(const String& file_spe
}	}

#ifndef DOXYGEN	#ifndef DOXYGEN
	struct Cache_data {
	time_t expires;
	};
struct Locked_process_and_cache_put_action_info {	struct Locked_process_and_cache_put_action_info {
Request *r;	Request *r;
Value *body;	Cache_data *data;
	Value body_code; const String evaluated_body;
};	};
#endif	#endif
static void locked_process_and_cache_put_action(int f, void *context) {	static void locked_process_and_cache_put_action(int f, void *context) {
Line 353 static void locked_process_and_cache_put	Line 366 static void locked_process_and_cache_put
static_cast<Locked_process_and_cache_put_action_info >(context);	static_cast<Locked_process_and_cache_put_action_info >(context);

// body->process	// body->process
info.body=&info.r->process(*info.body);	info.evaluated_body=&info.r->process_to_string(*info.body_code);

// result->string
const String& data_string=info.body->as_string();

// string -serialize> buffer	// expiration time not spoiled by ^cache(0) or something?
void *data; size_t data_size;	if(info.data->expires > time(0)) {
data_string.serialize(	// string -serialize> buffer
sizeof(Data_string_serialized_prolog),	void *data; size_t data_size;
data, data_size);	info.evaluated_body->serialize(
Data_string_serialized_prolog& prolog=	sizeof(Data_string_serialized_prolog),
static_cast<Data_string_serialized_prolog >(data);	data, data_size);
prolog.version=DATA_STRING_SERIALIZED_VERSION;	Data_string_serialized_prolog& prolog=
	static_cast<Data_string_serialized_prolog >(data);
// buffer -write> file	prolog.version=DATA_STRING_SERIALIZED_VERSION;
write(f, data, data_size);	prolog.expires=info.data->expires;

	// buffer -write> file
	write(f, data, data_size);
	} else // expired!
	info.data->expires=0; // flag it so that could be easily checked by caller
}	}
Value *locked_process_and_cache_put(Request& r,	const String *locked_process_and_cache_put(Request& r,
Value& body_code,	Value& body_code,
	Cache_data& data,
const String& file_spec) {	const String& file_spec) {
Locked_process_and_cache_put_action_info info={	Locked_process_and_cache_put_action_info info={
&r,	&r,
&body_code,	&data,
	&body_code
};	};

return file_write_action_under_lock(	const String *result=file_write_action_under_lock(
file_spec,	file_spec,
"cache_put", locked_process_and_cache_put_action, &info,	"cache_put", locked_process_and_cache_put_action, &info,
false/as_text/,	false/as_text/,
false/do_append/,	false/do_append/,
false/block/) ? info.body : 0;	false/block/) ? info.evaluated_body: 0;
	if(data.expires==0)
	cache_delete(file_spec);
	return result;
}	}
String *cache_get(Pool& pool, const String& file_spec) {	String *cache_get(Pool& pool, const String& file_spec, time_t now) {
void* data; size_t data_size;	void* data; size_t data_size;
if(!file_read(pool, file_spec,	if(file_read(pool, file_spec,
data, data_size,	data, data_size,
false/as_text/,	false/as_text/,
false/fail_on_read_problem/)	false/fail_on_read_problem/)
\|\| !data_size/* ignore reads which are empty due to	&& data_size/* ignore reads which are empty due to
non-unary open+lockEX conflict with lockSH */)	non-unary open+lockEX conflict with lockSH */) {
return 0;

Data_string_serialized_prolog& prolog=	Data_string_serialized_prolog& prolog=
static_cast<Data_string_serialized_prolog >(data);	static_cast<Data_string_serialized_prolog >(data);

if(data_size<sizeof(Data_string_serialized_prolog))
throw Exception(0, 0,
&file_spec,
"bad cached file (size=%d), too short (minsize=%d)",
data_size, sizeof(Data_string_serialized_prolog));

if(prolog.version!=DATA_STRING_SERIALIZED_VERSION)	String *result=new(pool) String(pool);
throw Exception(0, 0,	if(
&file_spec,	data_size>=sizeof(Data_string_serialized_prolog)
"data string version 0x%04X not equal to 0x%04X, recreate file",	&& prolog.version==DATA_STRING_SERIALIZED_VERSION
prolog.version, DATA_STRING_SERIALIZED_VERSION);	&& prolog.expires > now
	&& result->deserialize(
String& result=*new(pool) String(pool);	sizeof(Data_string_serialized_prolog), data, data_size, file_spec.cstr()))
result.deserialize(	return result;
sizeof(Data_string_serialized_prolog),	}
data, data_size, file_spec.cstr());
return &result;	return 0;
	}
	static time_t as_expires(Request& r, const String& method_name, MethodParams *params,
	int index, time_t now) {
	time_t result;
	Value& vlifespan_or_expires=params->get(index);
	if(strcmp(vlifespan_or_expires.type(), VDATE_TYPE)==0)
	result=static_cast<VDate&>(vlifespan_or_expires).get_time();
	else
	result=now+(time_t)params->as_double(index, "lifespan must be date or number", r);

	return result;
	}
	static const String as_file_spec(Request&r, MethodParams *params, int index) {
	return r.absolute(params->as_string(index, "filespec must be string"));
}	}
static void _cache(Request& r, const String& method_name, MethodParams *params) {	static void _cache(Request& r, const String& method_name, MethodParams *params) {
Pool& pool=r.pool();	Pool& pool=r.pool();
	time_t now=time(0);

	// ^cache[filename] ^cache(seconds) ^cache[expires date]
	if(params->size()==1) {
	if(params->get(0).is_string()) { // filename?
	cache_delete(as_file_spec(r, params, 0));
	return;
	}

	// secods\|expires date
	Cache_data data=static_cast<Cache_data >(r.classes_conf.get(*cache_data_name));
	if(!data)
	throw Exception("parser.runtime",
	&method_name,
	"expire-time reducing instruction without cache");

	time_t expires=as_expires(r, method_name, params, 0, now);
	if(expires < data->expires)
	data->expires=expires;

	return;
	}

// file_spec, expires, body code	// file_spec, expires, body code
const String &file_spec=r.absolute(params->as_string(0, "filespec must be string"));	const String &file_spec=r.absolute(params->as_string(0, "filespec must be string"));
if(params->size()==1) { // delete
cache_delete(file_spec);
return;
}

time_t lifespan=(time_t)params->as_double(1, "lifespan must be number", r);	Cache_data data;
	Temp_hash_value cache_data_setter(r.classes_conf, *cache_data_name, &data);
	data.expires=as_expires(r, method_name, params, 1, now);
Value& body_code=params->as_junction(2, "body must be code");	Value& body_code=params->as_junction(2, "body must be code");

if(lifespan) { // 'lifespan' specified? try cached copy...	if(data.expires>now) { // valid 'expires' specified? try cached copy...
size_t size;
time_t atime, mtime, ctime;

// hence we don't hope to have unary create/lockEX	// hence we don't hope to have unary create/lockEX
// we need some plan to live in a life like that, so...	// we need some plan to live in a life like that, so...
// worst races plan:	// worst races plan:
Line 449 static void _cache(Request& r, const Str	Line 493 static void _cache(Request& r, const Str
// ...	// ...
// \|lockSH succeeds; ...	// \|lockSH succeeds; ...

// {file_spec} modification time
for(int retry=0; retry<2; retry++) {	for(int retry=0; retry<2; retry++) {
if(file_stat(file_spec, size, atime, mtime, ctime, false/no exception on error/)) // exists?	if(String *cached_body=cache_get(pool, file_spec, now)) { // have cached copy?
if(time(0)-mtime > lifespan) // expired	// write it out
cache_delete(file_spec);	r.write_assign_lang(*cached_body);
else // not expired	// happy with it
if(String *cached_body=cache_get(pool, file_spec)) { // have cached copy?	return;
// write it out	}
r.write_assign_lang(*cached_body);
// happy with it
return;
}

// non-blocked lock; process; cache it	// non-blocked lock; process; cache it
if(Value *processed_body=locked_process_and_cache_put(r, body_code, file_spec)) {	if(const String*processed_body=
	locked_process_and_cache_put(r, body_code, data, file_spec)) {
// write it out	// write it out
r.write_assign_lang(*processed_body);	r.write_assign_lang(*processed_body);
// happy with it	// happy with it
Line 473 static void _cache(Request& r, const Str	Line 513 static void _cache(Request& r, const Str
retry=0; // prolonging our wait, than could cache_get it, without processing body_code	retry=0; // prolonging our wait, than could cache_get it, without processing body_code
}	}
}	}
throw Exception(0, 0,	throw Exception(0,
&file_spec,	&file_spec,
"locking problem");	"locking problem");
} else {	} else {
// 'lifespan'=0, forget cached copy	// instructed not to cache; forget cached copy
cache_delete(file_spec);	cache_delete(file_spec);
// process	// process
Value& processed_body=r.process(body_code);	const String& processed_body=r.process_to_string(body_code);
// write it out	// write it out
r.write_assign_lang(processed_body);	r.write_assign_lang(processed_body);
// happy with it	// happy with it
Line 489 static void _cache(Request& r, const Str	Line 529 static void _cache(Request& r, const Str
// never reached	// never reached
}	}

	// also used in pa_request.C to pass param to @unhandled_exception
	VHash& exception2vhash(Pool& pool, const Exception& e) {
	VHash& result=*new(pool) VHash(pool);
	Hash& hash=result.hash(0);
	if(const char *type=e.type())
	hash.put(exception_type_part_name, new(pool) VString(new(pool) String(pool, type)));
	if(const String *asource=e.problem_source()) {
	String& source=*new(pool) String(pool);
	source.append(asource, String::UL_TAINTED, true/forced*/);

	hash.put(*exception_source_part_name, new(pool) VString(source));
	#ifndef NO_STRING_ORIGIN
	const Origin& origin=source.origin();
	hash.put(*new(pool) String(pool, "file", 0, true),
	new(pool) VString(*new(pool) String(pool, origin.file)));
	hash.put(*new(pool) String(pool, "lineno"),
	new(pool) VInt(pool, 1+origin.line));
	#endif
	}
	if(const char *ecomment=e.comment()) {
	int comment_size=strlen(ecomment);
	char pcomment=(char )pool.malloc(comment_size);
	memcpy(pcomment, ecomment, comment_size);
	hash.put(*exception_comment_part_name,
	new(pool) VString(new(pool) String(pool, pcomment, comment_size, true/tainted*/)));
	}
	hash.put(*exception_handled_part_name,
	new(pool) VBool(pool, false));

	return result;
	}

	static void _try_operator(Request& r, const String& method_name, MethodParams *params) {
	Pool& pool=r.pool();

	Value& body_code=params->as_junction(0, "body_code must be code");
	Value& catch_code=params->as_junction(1, "catch_code must be code");

	StringOrValue result;

	// taking snapshot of request processing status
	//int ssexception_trace=r.exception_trace.top_index();
	int sstack=r.stack.top_index();
	Value sself=r.self, sroot=r.root, *srcontext=r.rcontext;
	WContext *swcontext=r.wcontext;
	try {
	result=r.process(body_code);
	} catch(const Exception& e) {
	// restoring request processing status
	//r.exception_trace.top_index(ssexception_trace);
	r.stack.top_index(sstack);
	r.self=sself; r.root=sroot, r.rcontext=srcontext; r.wcontext=swcontext;


	VHash& vhash=exception2vhash(pool, e);

	Junction *junction=catch_code.get_junction();
	Value saved_exception_var_value=junction->root->get_element(exception_var_name);
	junction->root->put_element(*exception_var_name, &vhash);
	result=r.process(catch_code);
	bool handled=false;
	if(Value value=static_cast<Value >(vhash.hash(0).get(*exception_handled_part_name)))
	handled=value->as_bool();
	junction->root->put_element(*exception_var_name, saved_exception_var_value);

	if(!handled)
	throw(e); // rethrow
	}
	// write it out
	r.write_pass_lang(result);
	}

	static void _throw_operator(Request& r, const String& method_name, MethodParams *params) {
	Pool& pool=r.pool();

	if(params->size()==1) {
	Value& param0=params->get(0);
	if(Hash *hash=param0.get_hash(&method_name)) {
	const char *type=0;
	if(Value value=static_cast<Value >(hash->get(*exception_type_part_name)))
	type=value->as_string().cstr();
	const String *source=0;
	if(Value value=static_cast<Value >(hash->get(*exception_source_part_name)))
	source=&value->as_string();
	const char *comment=0;
	if(Value *value=
	static_cast<Value >(hash->get(exception_comment_part_name)))
	comment=value->as_string().cstr();

	throw Exception(type,
	source?source:&method_name,
	comment);
	} else
	throw Exception("parser.runtime",
	&method_name,
	"one-param version has hash param");
	} else {
	const char *type=params->as_string(0, "type must be string").cstr();
	const String& source=params->as_string(1, "source must be string");
	const char *comment=params->as_string(2, "comment must be string").cstr();
	throw Exception(type, &source, comment);
	}
	}

// constructor	// constructor

MOP::MOP(Pool& apool) : Methoded(apool),	MOP::MOP(Pool& apool) : Methoded(apool, "OP"),
main_sql_name(apool, MAIN_SQL_NAME),	main_sql_name(apool, MAIN_SQL_NAME),
main_sql_drivers_name(apool, MAIN_SQL_DRIVERS_NAME)	main_sql_drivers_name(apool, MAIN_SQL_DRIVERS_NAME)
{	{
set_name(*NEW String(pool(), OP_CLASS_NAME));

// ^if(condition){code-when-true}	// ^if(condition){code-when-true}
// ^if(condition){code-when-true}{code-when-false}	// ^if(condition){code-when-true}{code-when-false}
add_native_method("if", Method::CT_ANY, _if, 2, 3);	add_native_method("if", Method::CT_ANY, _if, 2, 3);
Line 526 MOP::MOP(Pool& apool) : Methoded(apool),	Line 668 MOP::MOP(Pool& apool) : Methoded(apool),
// ^eval(expr)[format]	// ^eval(expr)[format]
add_native_method("eval", Method::CT_ANY, _eval, 1, 2);	add_native_method("eval", Method::CT_ANY, _eval, 1, 2);

// ^error[msg]
add_native_method("error", Method::CT_ANY, _error, 1, 1);


// ^connect[protocol://user:pass@host[:port]/database]{code with ^sql-s}	// ^connect[protocol://user:pass@host[:port]/database]{code with ^sql-s}
add_native_method("connect", Method::CT_ANY, _connect, 2, 2);	add_native_method("connect", Method::CT_ANY, _connect, 2, 2);

Line 545 MOP::MOP(Pool& apool) : Methoded(apool),	Line 683 MOP::MOP(Pool& apool) : Methoded(apool),

// ^case[value]{code}	// ^case[value]{code}
add_native_method("case", Method::CT_ANY, _case, 2, 10000);	add_native_method("case", Method::CT_ANY, _case, 2, 10000);

	// try-catch

	// ^try{code}{catch code}
	add_native_method("try", Method::CT_ANY, _try_operator, 2, 2);
	// ^throw[$exception hash]
	// ^throw[type;source;comment]
	add_native_method("throw", Method::CT_ANY, _throw_operator, 1, 3);

}	}

// constructor & configurator	// constructor & configurator

E-mail:

Removed from v.1.70
changed lines
	Added in v.1.91