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.25 and 1.127.2.22.2.28

version 1.127.2.22.2.25, 2003/04/03 09:18:45	version 1.127.2.22.2.28, 2003/04/03 10:51:51
Line 74 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 101 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 122 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 132 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?	Value& value=params[0];
params->as_no_junction(0, "target must not be code")
	Value& target_self=params.count()>1?
	params.as_no_junction(0, "target must not be code")
:r.get_method_frame()->caller()->self();	: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();	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 155 static void _process(Request& r, MethodP	Line 152 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	if(const String* file_name=params.last().get_string()) { // ^process...[file]
// would be something like "/some/file(4) process"	r.use_file(target_class, r.absolute(file_name), true/ignore_class_path/);
char local_place[MAX_STRING];	} else { // process...{string}
#ifndef NO_STRING_ORIGIN	Value& vjunction=params.as_junction(params.count()-1, "body must be code");
const String_fragment::Origin& source_origin=source->origin();	// evaluate source to process
const String_fragment::Origin& method_origin=method_name->origin();	const String& source=r.process_to_string(vjunction);
size_t place_size;	r.use_buf(*target_class,
if(source_origin.file==method_origin.file)	source.cstr(String::L_UNSPECIFIED, r.connection(false)),
place_size=snprintf(local_place, MAX_STRING, "%s(%d) %s", // same file	pseudo_file_no__process);
source_origin.file?source_origin.file:"unknown_file", 1+source_origin.line,	}
method_name->cstr().get())+1;
else // different files ^process{external__file_text__or__sql}
place_size=snprintf(local_place, MAX_STRING, "%s",
source_origin.file?source_origin.file:"unknown_file")+1;
#else
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(false)),
0); // later! new String("later"), //new String(heap_place, place_size, true /tainted*/),

// main_method	// main_method
main_method=target_class->get_method(main_method_name);	main_method=target_class->get_method(main_method_name);
}	}
Line 195 static void _process(Request& r, MethodP	Line 177 static void _process(Request& r, MethodP
}	}
}	}

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 222 static void _while(Request& r, MethodPar	Line 204 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 256 static void _for(Request& r, MethodParam	Line 238 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 323 public:	Line 305 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 StringBody, 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 339 static void _switch(Request& r, MethodPa	Line 321 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 478 const String* cache_get(Charset& charset	Line 460 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 516 static void _cache(Request& r, MethodPar	Line 498 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 StringBody, 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 581 static void _cache(Request& r, MethodPar	Line 563 static void _cache(Request& r, MethodPar

// also used in pa_request.C to pass param to @unhandled_exception	// also used in pa_request.C to pass param to @unhandled_exception

static void _try_operator(Request& r, MethodParams* params) {	static void _try_operator(Request& r, MethodParams& params) {
Value& body_code=params->as_junction(0, "body_code must be code");	Value& body_code=params.as_junction(0, "body_code must be code");
Value& catch_code=params->as_junction(1, "catch_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 616 static void _try_operator(Request& r, Me	Line 598 static void _try_operator(Request& r, Me
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 638 static void _throw_operator(Request& r,	Line 619 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 648 static void _throw_operator(Request& r,	Line 629 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

E-mail:

Removed from v.1.127.2.22.2.25
changed lines
	Added in v.1.127.2.22.2.28