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.127.2.22.2.15 and 1.130

version 1.127.2.22.2.15, 2003/03/24 13:43:40	version 1.130, 2003/09/25 09:15:02
Line 31 static const char* IDENT_OP_C="$Date$";	Line 31 static const char* IDENT_OP_C="$Date$";
class VClassMAIN: public VClass {	class VClassMAIN: public VClass {
public:	public:
VClassMAIN();	VClassMAIN();
override ~VClassMAIN() {}
};	};

// defines for statics	// defines for statics
Line 39 public:	Line 38 public:
#define SWITCH_DATA_NAME "SWITCH-DATA"	#define SWITCH_DATA_NAME "SWITCH-DATA"
#define CACHE_DATA_NAME "CACHE-DATA"	#define CACHE_DATA_NAME "CACHE-DATA"
#define EXCEPTION_VAR_NAME "exception"	#define EXCEPTION_VAR_NAME "exception"
#define EXCEPTION_TYPE_PART_NAME "type"
#define EXCEPTION_SOURCE_PART_NAME "source"
#define EXCEPTION_COMMENT_PART_NAME "comment"
#define EXCEPTION_HANDLED_PART_NAME "handled"

// statics	// statics

Line 52 static const String switch_data_name(SWI	Line 47 static const String switch_data_name(SWI
static const String cache_data_name(CACHE_DATA_NAME);	static const String cache_data_name(CACHE_DATA_NAME);

static const String exception_var_name(EXCEPTION_VAR_NAME);	static const String exception_var_name(EXCEPTION_VAR_NAME);
static const String exception_type_part_name(EXCEPTION_TYPE_PART_NAME);
static const String exception_source_part_name(EXCEPTION_SOURCE_PART_NAME);
static const String exception_comment_part_name(EXCEPTION_COMMENT_PART_NAME);
static const String exception_handled_part_name(EXCEPTION_HANDLED_PART_NAME);

// helpers	// helpers

class Untaint_lang_name2enum: public Hash<const StringBody&, String::Language> {	class Untaint_lang_name2enum: public Hash<const String::Body, String::Language> {
public:	public:
Untaint_lang_name2enum() {	Untaint_lang_name2enum() {
#define ULN(name, LANG) \	#define ULN(name, LANG) \
put(StringBody(name), (value_type)(String::L_##LANG));	put(String::Body(name), (value_type)(String::L_##LANG));
ULN("as-is", AS_IS);	ULN("as-is", AS_IS);
ULN("optimized-as-is", AS_IS\|String::L_OPTIMIZE_BIT);	ULN("optimized-as-is", AS_IS\|String::L_OPTIMIZE_BIT);
ULN("file-spec", FILE_SPEC);	ULN("file-spec", FILE_SPEC);
Line 83 public:	Line 74 public:

// methods	// methods

static void _if(Request& r, MethodParams* params) {	static void _if(Request& r, 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_to_value(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")));
else if(params->count()>2)	else if(params.count()>2)
r.write_pass_lang(r.process(params->as_junction(2, "'else' parameter must be code")));	r.write_pass_lang(r.process(params.as_junction(2, "'else' parameter must be code")));
}	}

static void _untaint(Request& r, MethodParams* params) {	static void _untaint(Request& r, MethodParams& params) {

String::Language lang;	String::Language lang;
if(params->count()==1)	if(params.count()==1)
lang=String::L_AS_IS; // mark as simply 'tainted'. useful in html from sql	lang=String::L_AS_IS; // mark as simply 'tainted'. useful in html from sql
else {	else {
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(lang_name);	lang=untaint_lang_name2enum.get(lang_name);
if(!lang)	if(!lang)
throw Exception(0,	throw Exception(0,
Line 110 static void _untaint(Request& r, MethodP	Line 101 static void _untaint(Request& r, MethodP
}	}

{	{
Value& vbody=params->as_junction(params->count()-1, "body must be code");	Value& vbody=params.as_junction(params.count()-1, "body must be code");

Temp_lang temp_lang(r, lang); // set temporarily specified ^untaint[language;	Temp_lang temp_lang(r, lang); // set temporarily specified ^untaint[language;
r.write_pass_lang(r.process(vbody)); // process marking tainted with that lang	r.write_pass_lang(r.process(vbody)); // process marking tainted with that lang
}	}
}	}

static void _taint(Request& r, MethodParams* params) {	static void _taint(Request& r, MethodParams& params) {
String::Language lang;	String::Language lang;
if(params->count()==1)	if(params.count()==1)
lang=String::L_TAINTED; // mark as simply 'tainted'. useful in table:set	lang=String::L_TAINTED; // mark as simply 'tainted'. useful in table:set
else {	else {
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(lang_name);	lang=untaint_lang_name2enum.get(lang_name);
if(!lang)	if(!lang)
throw Exception(0,	throw Exception(0,
Line 131 static void _taint(Request& r, MethodPar	Line 122 static void _taint(Request& r, MethodPar
}	}

{	{
Value& vbody=params->as_no_junction(params->count()-1, "body must not be code");	Value& vbody=params.as_no_junction(params.count()-1, "body must not be code");

String result;	String result;
result.append(	result.append(
Line 141 static void _taint(Request& r, MethodPar	Line 132 static void _taint(Request& r, MethodPar
}	}
}	}

static void _process(Request& r, MethodParams* params) {	static void _process(Request& r, MethodParams& params) {
Method* main_method;	Method* main_method;
Value& target_self=params->count()>1?
params->as_no_junction(0, "target must not be code")
:r.get_method_frame()->caller()->self();
{
Value& vjunction=params->as_junction(params->count()-1, "body must be code");

VStateless_class *target_class=target_self.get_last_derived_class();	size_t index=0;
	Value* target_self;
	Value& maybe_target_self=params[index];
	if(maybe_target_self.get_string() \|\| maybe_target_self.get_junction())
	target_self=&r.get_method_frame()->caller()->self();
	else {
	target_self=&maybe_target_self; index++;
	}

	{
	VStateless_class *target_class=target_self->get_last_derived_class();
if(!target_class)	if(!target_class)
throw Exception("parser.runtime",	throw Exception("parser.runtime",
0,	0,
"no target class");	"no target class");

// evaluate source to process
const String& source=r.process_to_string(vjunction);

// temporary remove language change	// temporary remove language change
Temp_lang temp_lang(r, String::L_PASS_APPENDED);	Temp_lang temp_lang(r, String::L_PASS_APPENDED);
Line 164 static void _process(Request& r, MethodP	Line 157 static void _process(Request& r, MethodP
Temp_method temp_method_main(*target_class, main_method_name, 0);	Temp_method temp_method_main(*target_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(*target_class, auto_method_name, 0);	Temp_method temp_method_auto(*target_class, auto_method_name, 0);
#ifdef LATER
// calculate pseudo file name of processed chars	size_t main_alias_index=index+1;
// would be something like "/some/file(4) process"	const String* main_alias=0;
char local_place[MAX_STRING];	if(main_alias_index<params.count())
#ifndef NO_STRING_ORIGIN	main_alias=&params.as_string(main_alias_index, "main alias must be string");
const String_fragment::Origin& source_origin=source->origin();
const String_fragment::Origin& method_origin=method_name->origin();	if(const String* file_name=params[index].get_string()) { // ^process...[file]
size_t place_size;	r.use_file(target_class, r.absolute(file_name), main_alias, true/ignore_class_path/);
if(source_origin.file==method_origin.file)	} else { // process...{string}
place_size=snprintf(local_place, MAX_STRING, "%s(%d) %s", // same file	Value& vjunction=params.as_junction(index, "body must be code");
source_origin.file?source_origin.file:"unknown_file", 1+source_origin.line,	// evaluate source to process
method_name->cstr().get())+1;	const String& source=r.process_to_string(vjunction);
else // different files ^process{external__file_text__or__sql}	r.use_buf(*target_class,
place_size=snprintf(local_place, MAX_STRING, "%s",	source.cstr(String::L_UNSPECIFIED, r.connection(false)),
source_origin.file?source_origin.file:"unknown_file")+1;	main_alias,
#else	pseudo_file_no__process);
strncpy(local_place, method_name->cstr(), MAX_STRING-1); place[MAX_STRING-1]=0;	}
size_t place_size=strlen(local_place)+1;
#endif
char *heap_place=pool.copy(local_place, place_size);
#endif
// process source code, append processed methods to 'self' class
// maybe-define new @main
r.use_buf(*target_class,
source.cstr(String::L_UNSPECIFIED, r.connection()),
new String("later"), //new String(heap_place, place_size, true /tainted*/),
"later"); //heap_place);

// main_method	// main_method
main_method=target_class->get_method(main_method_name);	main_method=target_class->get_method(main_method_name);
}	}
Line 199 static void _process(Request& r, MethodP	Line 182 static void _process(Request& r, MethodP
// maybe-execute @main[]	// maybe-execute @main[]
if(main_method) {	if(main_method) {
// temporarily set method_frame's self to target_self	// temporarily set method_frame's self to target_self
Temp_method_frame_self tmfs(*r.get_method_frame(), target_self);	Temp_method_frame_self tmfs(r.get_method_frame(), target_self);
// execute!	// execute!
r.execute(*main_method->parser_code);	r.execute(*main_method->parser_code);
}	}
}	}

static void _rem(Request& r, MethodParams* params) {	static void _rem(Request& r, MethodParams& params) {
params->as_junction(0, "body must be code");	params.as_junction(0, "body must be code");
}	}

static void _while(Request& r, MethodParams* params) {	static void _while(Request& r, MethodParams& params) {
Value& vcondition=params->as_junction(0, "condition must be expression");	Value& vcondition=params.as_junction(0, "condition must be expression");
Value& body=params->as_junction(1, "body must be code");	Value& body=params.as_junction(1, "body must be code");

// while...	// while...
int endless_loop_count=0;	int endless_loop_count=0;
Line 232 static void _while(Request& r, MethodPar	Line 215 static void _while(Request& r, MethodPar
}	}
}	}

static void _use(Request& r, MethodParams* params) {	static void _use(Request& r, MethodParams& params) {
Value& vfile=params->as_no_junction(0, "file name must not be code");	Value& vfile=params.as_no_junction(0, "file name must not be code");
r.use_file(r.main_class, vfile.as_string());	r.use_file(r.main_class, vfile.as_string());
}	}

static void _for(Request& r, MethodParams* params) {	static void _for(Request& r, MethodParams& params) {
const String& var_name=params->as_string(0, "var name must be string");	const String& var_name=params.as_string(0, "var name must be string");
int from=params->as_int(1, "from must be int", r);	int from=params.as_int(1, "from must be int", r);
int to=params->as_int(2, "to must be int", r);	int to=params.as_int(2, "to must be int", r);
Value& body_code=params->as_junction(3, "body must be code");	Value& body_code=params.as_junction(3, "body must be code");
Value* delim_maybe_code=params->count()>4?(*params)[4]:0;	Value* delim_maybe_code=params.count()>4?&params[4]:0;

if(to-from>=MAX_LOOPS) // too long loop?	if(to-from>=MAX_LOOPS) // too long loop?
throw Exception("parser.runtime",	throw Exception("parser.runtime",
Line 266 static void _for(Request& r, MethodParam	Line 249 static void _for(Request& r, MethodParam
}	}
}	}

static void _eval(Request& r, MethodParams* params) {	static void _eval(Request& r, MethodParams& params) {
Value& expr=params->as_junction(0, "need expression");	Value& expr=params.as_junction(0, "need expression");
// evaluate expresion	// evaluate expresion
Value& value_result=*r.process_to_value(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->count()>1) {	if(params.count()>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");
r.write_no_lang(String(format(value_result.as_double(), fmt.as_string().cstrm())));	r.write_no_lang(String(format(value_result.as_double(), fmt.as_string().cstrm())));
} else	} else
r.write_no_lang(value_result);	r.write_no_lang(value_result);
}	}

static void _connect(Request& r, MethodParams* params) {	static void _connect(Request& r, MethodParams& params) {
#ifdef RESOURCES_DEBUG	#ifdef RESOURCES_DEBUG
struct timeval mt[2];	struct timeval mt[2];
#endif	#endif
Value& url=params->as_no_junction(0, "url must not be code");	Value& url=params.as_no_junction(0, "url must not be code");
Value& body_code=params->as_junction(1, "body must be code");	Value& body_code=params.as_junction(1, "body must be code");

Table* protocol2driver_and_client=0;	Table* protocol2driver_and_client=0;
if(Value* sql=r.main_class.get_element(String(MAIN_SQL_NAME), r.main_class, false)) {	if(Value* sql=r.main_class.get_element(String(MAIN_SQL_NAME), r.main_class, false)) {
Line 315 r.sql_connect_time+=t[1]-t[0];	Line 298 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));
	connection->commit();
	connection->close();
} catch(...) { // process problem	} catch(...) { // process problem
connection->mark_to_rollback();	connection->rollback();
rethrow;	connection->close();
	rethrow;
}	}
}	}

Line 333 public:	Line 319 public:
r(ar), searching(asearching) {}	r(ar), searching(asearching) {}
};	};
#endif	#endif
static void _switch(Request& r, MethodParams* params) {	static void _switch(Request& r, MethodParams& params) {
Switch_data* data=new Switch_data(r, r.process_to_value((params)[0]));	Switch_data* data=new Switch_data(r, r.process_to_value(params[0]));
Temp_hash_value<const StringBody, PA_Object*>	Temp_hash_value<const String::Body, PA_Object*>
switch_data_setter(r.classes_conf, switch_data_name, data);	switch_data_setter(r.classes_conf, switch_data_name, data);

Value& cases_code=params->as_junction(1, "switch cases must be code");	Value& cases_code=params.as_junction(1, "switch cases must be code");
// execution of found ^case[...]{code} must be in context of ^switch[...]{code}	// execution of found ^case[...]{code} must be in context of ^switch[...]{code}
// because of stacked WWrapper used there as wcontext	// because of stacked WWrapper used there as wcontext
r.process(cases_code, true/intercept_string/);	r.process(cases_code, true/intercept_string/);
Line 349 static void _switch(Request& r, MethodPa	Line 335 static void _switch(Request& r, MethodPa
}	}
}	}

static void _case(Request& r, MethodParams* params) {	static void _case(Request& r, MethodParams& params) {
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("parser.runtime",	throw Exception("parser.runtime",
0,	0,
"without switch");	"without switch");

int count=params->count();	int count=params.count();
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<<}	// killing context for safety, would execute in ^switch[...]{>>context<<}
// reason: context is stacked, and it would become invalid afterwards	// reason: context is stacked, and it would become invalid afterwards
//code->get_junction()->change_context(0);	//code->get_junction()->change_context(0);

for(int i=0; i<count; i++) {	for(int i=0; i<count; i++) {
Value& value=r.process_to_value((params)[i]);	Value& value=r.process_to_value(params[i]);

if(value.as_string() == CASE_DEFAULT_VALUE) {	if(value.as_string() == CASE_DEFAULT_VALUE) {
data->_default=&code;	data->_default=&code;
Line 413 class Cache_data: public PA_Object {	Line 399 class Cache_data: public PA_Object {
public:	public:
time_t expires;	time_t expires;
};	};
DECLARE_OBJECT_PTR(Cache_data);
struct Locked_process_and_cache_put_action_info {	struct Locked_process_and_cache_put_action_info {
Request *r;	Request *r;
Cache_data *data;	Cache_data *data;
Line 434 static void locked_process_and_cache_put	Line 419 static void locked_process_and_cache_put
// expiration time not spoiled by ^cache(0) or something?	// expiration time not spoiled by ^cache(0) or something?
if(info.data->expires > time(0)) {	if(info.data->expires > time(0)) {
// string -serialize> buffer	// string -serialize> buffer
String::C serialized=info.evaluated_body->serialize(	String::Cm serialized=info.evaluated_body->serialize(
sizeof(Data_string_serialized_prolog));	sizeof(Data_string_serialized_prolog));
Data_string_serialized_prolog& prolog=	Data_string_serialized_prolog& prolog=
reinterpret_cast<Data_string_serialized_prolog >(serialized.str);	reinterpret_cast<Data_string_serialized_prolog >(serialized.str);
Line 450 const String* locked_process_and_cache_p	Line 435 const String* locked_process_and_cache_p
Value& body_code,	Value& body_code,
Cache_data& data,	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={0};
info.r=&r;	info.r=&r;
info.data=&data;	info.data=&data;
info.body_code=&body_code;	info.body_code=&body_code;
Line 467 const String* locked_process_and_cache_p	Line 452 const String* locked_process_and_cache_p
cache_delete(file_spec);	cache_delete(file_spec);
return result;	return result;
}	}
const String* cache_get(Charset& charset, const String& file_spec, time_t now) {	const String* cache_get(Request_charsets& charsets, const String& file_spec, time_t now) {
File_read_result file=file_read(charset, file_spec,	File_read_result file=file_read(charsets, file_spec,
false/as_text/,	false/as_text/,
0, //no params	0, //no params
false/fail_on_read_problem/);	false/fail_on_read_problem/);
Line 489 const String* cache_get(Charset& charset	Line 474 const String* cache_get(Charset& charset

return 0;	return 0;
}	}
static time_t as_expires(Request& r, MethodParams* params,	static time_t as_expires(Request& r, MethodParams& params,
int index, time_t now) {	int index, time_t now) {
time_t result;	time_t result;
if(Value* vdate=(*params)[index]->as(VDATE_TYPE, false))	if(Value* vdate=params[index].as(VDATE_TYPE, false))
result=static_cast<VDate*>(vdate)->get_time();	result=static_cast<VDate*>(vdate)->get_time();
else	else
result=now+(time_t)params->as_double(index, "lifespan must be date or number", r);	result=now+(time_t)params.as_double(index, "lifespan must be date or number", r);

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

// ^cache[filename] ^cache(seconds) ^cache[expires date]	// ^cache[filename] ^cache(seconds) ^cache[expires date]
if(params->count()==1) {	if(params.count()==1) {
if((*params)[0]->is_string()) { // filename?	if(params[0].is_string()) { // filename?
cache_delete(as_file_spec(r, params, 0));	cache_delete(as_file_spec(r, params, 0));
return;	return;
}	}
Line 527 static void _cache(Request& r, MethodPar	Line 512 static void _cache(Request& r, MethodPar
}	}

// 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"));

Cache_data* data=new Cache_data;	Cache_data* data=new Cache_data;
Temp_hash_value<const StringBody, PA_Object*>	Temp_hash_value<const String::Body, PA_Object*>
cache_data_setter(r.classes_conf, cache_data_name, data);	cache_data_setter(r.classes_conf, cache_data_name, data);
data->expires=as_expires(r, params, 1, now);	data->expires=as_expires(r, 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(data->expires>now) { // valid 'expires' specified? try cached copy...	if(data->expires>now) { // valid 'expires' specified? try cached copy...
// hence we don't hope to have unary create/lockEX	// hence we don't hope to have unary create/lockEX
Line 553 static void _cache(Request& r, MethodPar	Line 538 static void _cache(Request& r, MethodPar
// \|lockSH succeeds; ...	// \|lockSH succeeds; ...

for(int retry=0; retry<2; retry++) {	for(int retry=0; retry<2; retry++) {
if(const String* cached_body=cache_get(r.charsets.source(), file_spec, now)) { // have cached copy?	if(const String* cached_body=cache_get(r.charsets, file_spec, now)) { // have cached copy?
// write it out	// write it out
r.write_assign_lang(*cached_body);	r.write_assign_lang(*cached_body);
// happy with it	// happy with it
Line 588 static void _cache(Request& r, MethodPar	Line 573 static void _cache(Request& r, MethodPar
// never reached	// never reached
}	}

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

hash.put(exception_source_part_name, new VString(source));
}
if(const char* comment=e.comment(true))
hash.put(exception_comment_part_name,
new VString(new String(comment, 0, true/tainted*/)));
hash.put(exception_handled_part_name, new VBool(false));

return result;
}

static void _try_operator(Request& r, MethodParams* params) {	// also used in pa_request.C to pass param to @unhandled_exception
Value& body_code=params->as_junction(0, "body_code must be code");
Value& catch_code=params->as_junction(1, "catch_code must be code");	static void _try_operator(Request& r, MethodParams& params) {
	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;	StringOrValue result;
// taking snapshot of try-context	// taking snapshot of try-context
Line 618 static void _try_operator(Request& r, Me	Line 587 static void _try_operator(Request& r, Me
try {	try {
result=r.process(body_code);	result=r.process(body_code);
} catch(const Exception& e) {	} catch(const Exception& e) {
	Request::Exception_details details=r.get_details(e);

Request_context_saver throw_context(r); // taking snapshot of throw-context [stack trace contains error]	Request_context_saver throw_context(r); // taking snapshot of throw-context [stack trace contains error]
try_context.restore(); // restoring try-context to perform catch-code	try_context.restore(); // restoring try-context to perform catch-code

VHash& vhash=exception2vhash(e);

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

if(!handled) {	if(!handled) {
throw_context.restore(); // restoring throw-context [exception were not handled]	throw_context.restore(); // restoring throw-context [exception were not handled]
throw(e); // rethrow	rethrow;
}	}
}	}
// write out result	// write out result
r.write_pass_lang(result);	r.write_pass_lang(result);
}	}

static void _throw_operator(Request& r, MethodParams* params) {	static void _throw_operator(Request& r, MethodParams& params) {
if(params->count()==1) {	if(params.count()==1) {
Value* param0=(*params)[0];	if(HashStringValue *hash=params[0].get_hash()) {
if(HashStringValue *hash=param0->get_hash()) {
const char* type=0;	const char* type=0;
if(Value* value=hash->get(exception_type_part_name))	if(Value* value=hash->get(exception_type_part_name))
type=value->as_string().cstr();	type=value->as_string().cstr();
Line 665 static void _throw_operator(Request& r,	Line 633 static void _throw_operator(Request& r,
0,	0,
"one-param version has hash param");	"one-param version has hash param");
} else {	} else {
const char* type=params->as_string(0, "type must be string").cstr();	const char* type=params.as_string(0, "type must be string").cstr();
const String& source=params->as_string(1, "source must be string");	const String& source=params.as_string(1, "source must be string");
const char* comment=params->count()>2? params->as_string(2, "comment must be string").cstr()	const char* comment=params.count()>2? params.as_string(2, "comment must be string").cstr()
:0;	:0;
throw Exception(type, &source, "%s", comment?comment:"");	throw Exception(type, &source, "%s", comment?comment:"");
}	}
Line 675 static void _throw_operator(Request& r,	Line 643 static void _throw_operator(Request& r,

#if defined(WIN32) && defined(_DEBUG)	#if defined(WIN32) && defined(_DEBUG)
# define PA_BPT	# define PA_BPT
static void _bpt(Request& r, MethodParams* params) {	static void _bpt(Request& r, MethodParams& params) {
_asm int 3;	_asm int 3;
}	}
#endif	#endif
Line 748 VClassMAIN::VClassMAIN(): VClass() {	Line 716 VClassMAIN::VClassMAIN(): VClass() {
// constructor & configurator	// constructor & configurator

VStateless_class& VClassMAIN_create() {	VStateless_class& VClassMAIN_create() {

return *new VClassMAIN;	return *new VClassMAIN;
}	}

E-mail:

Removed from v.1.127.2.22.2.15
changed lines
	Added in v.1.130