--- parser3/src/classes/op.C	2007/06/06 14:21:19	1.169
+++ parser3/src/classes/op.C	2008/07/08 13:37:30	1.181
@@ -5,7 +5,7 @@
 	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
 */
 
-static const char * const IDENT_OP_C="$Date: 2007/06/06 14:21:19 $";
+static const char * const IDENT_OP_C="$Date: 2008/07/08 13:37:30 $";
 
 #include "classes.h"
 #include "pa_vmethod_frame.h"
@@ -102,19 +102,22 @@ static void _if(Request& r, MethodParams
 		r.write_pass_lang(r.process(*params.get(2)));
 }
 
-static void _untaint(Request& r, MethodParams& params) {
+static String::Language get_untaint_lang(MethodParams& params, int index){
+	const String& lang_name=params.as_string(index, "lang must be string");
+	String::Language lang=untaint_lang_name2enum.get(lang_name);
+	if(!lang)
+		throw Exception(0,
+			&lang_name,
+			"invalid taint language");
+	return lang;
+}
 
+static void _untaint(Request& r, MethodParams& params) {
 	String::Language lang;
 	if(params.count()==1)
-		lang=String::L_AS_IS; // mark as simply 'tainted'. useful in html from sql 
-	else {
-		const String& lang_name=params.as_string(0, "lang must be string");
-		lang=untaint_lang_name2enum.get(lang_name);
-		if(!lang)
-			throw Exception(0,
-				&lang_name,
-				"invalid taint language");
-	}
+		lang=String::L_AS_IS; // mark as simply 'as-is'. useful in html from sql 
+	else
+		lang=get_untaint_lang(params, 0);
 
 	{
 		Value& vbody=params.as_junction(params.count()-1, "body must be code");
@@ -127,15 +130,9 @@ static void _untaint(Request& r, MethodP
 static void _taint(Request& r, MethodParams& params) {
 	String::Language lang;
 	if(params.count()==1)
-		lang=String::L_TAINTED; // mark as simply 'tainted'. useful in table:set
-	else {
-		const String& lang_name=params.as_string(0, "lang must be string");
-		lang=untaint_lang_name2enum.get(lang_name);
-		if(!lang)
-			throw Exception(0,
-				&lang_name,
-				"invalid taint language");
-	}
+		lang=String::L_TAINTED; // mark as simply 'tainted'. useful in table:create
+	else
+		lang=get_untaint_lang(params, 0);
 
 	{
 		Value& vbody=params.as_no_junction(params.count()-1, "body must not be code");
@@ -243,7 +240,8 @@ static void _while(Request& r, MethodPar
 	Temp_hash_value<const String::Body, void*> 
 		cycle_data_setter(r.classes_conf, cycle_data_name, /*any not null flag*/&r);
 
-	Value& vcondition=params[0].is_evaluated_expr()?params[0]:params.as_junction(0, "condition must be bool or expression");
+	Value& vcondition=params.as_expression(0, "condition must be number, bool or expression");
+
 	Value& body_code=params.as_junction(1, "body must be code");
 	Value* delim_maybe_code=params.count()>2?&params[2]:0;
 
@@ -267,7 +265,8 @@ static void _while(Request& r, MethodPar
 		if(delim_maybe_code && s_processed && s_processed->length()) { // delimiter set and we have body
 			if(need_delim) // need delim & iteration produced string?
 				r.write_pass_lang(r.process(*delim_maybe_code));
-			need_delim=true;
+			else
+				need_delim=true;
 		}
 		r.write_pass_lang(sv_processed);
 
@@ -277,7 +276,7 @@ static void _while(Request& r, MethodPar
 }
 
 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());
 }
 
@@ -328,7 +327,8 @@ static void _for(Request& r, MethodParam
 		if(delim_maybe_code && s_processed && s_processed->length()) { // delimiter set and we have body
 			if(need_delim) // need delim & iteration produced string?
 				r.write_pass_lang(r.process(*delim_maybe_code));
-			need_delim=true;
+			else
+				need_delim=true;
 		}
 		r.write_pass_lang(sv_processed);
 
@@ -343,8 +343,12 @@ static void _eval(Request& r, MethodPara
 	Value& value_result=r.process_to_value(expr, 
 		false/*don't intercept string*/).as_expr_result();
 	if(params.count()>1) {
-		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())));
+		const String& fmt=params.as_string(1, "fmt must be string").trim();
+		if(fmt.is_empty()){
+			r.write_no_lang(value_result);
+		} else {
+			r.write_no_lang(String(format(value_result.as_double(), fmt.cstrm())));
+		}
 	} else
 		r.write_no_lang(value_result);
 }
@@ -370,7 +374,8 @@ gettimeofday(&mt[0],NULL);
 	// connect
 	SQL_Connection* connection=SQL_driver_manager->get_connection(url.as_string(), 
 		protocol2driver_and_client,
-		r.charsets.source().NAME().cstr());
+		r.charsets.source().NAME().cstr(),
+		r.request_info.document_root);
 
 #ifdef RESOURCES_DEBUG
 //measure:after connect
@@ -399,12 +404,22 @@ r.sql_connect_time+=t[1]-t[0];
 class Switch_data: public PA_Object {
 public:
 	Request& r;
-	Value& searching;
+	const String* searching_string;
+	double searching_double;
 	Value* found;
 	Value* _default;
 public:
 	Switch_data(Request& ar, Value& asearching): 
-	  r(ar), searching(asearching) {}
+		r(ar)
+	{
+		if(asearching.is_string() || asearching.is_void()){
+			searching_string=&asearching.as_string();
+			searching_double=0;
+		} else {
+			searching_string=0;
+			searching_double=asearching.as_double();
+		}
+	}
 };
 #endif
 static void _switch(Request& r, MethodParams& params) {
@@ -427,31 +442,27 @@ static void _case(Request& r, MethodPara
 			0,
 			"without switch");
 
+	if(data->found) // matches already was found
+		return;
+
 	int count=params.count();
 	Value& code=params.as_junction(--count, "case result must be code");
 	
-	Value& searching=data->searching;
-	bool we_are_searching_string_or_void=searching.is_string() || searching.is_void();
-	for(int i=0; i<count; i++) {
+	for(int i=0; i<count; i++){
 		Value& value=r.process_to_value(params[i]);
 
-		if(value.is_string() && value.as_string() == CASE_DEFAULT_VALUE) {
+		if(value.is_string() && value.as_string() == CASE_DEFAULT_VALUE){
 			data->_default=&code;
-			break;
+			continue;
 		}
 
 		bool matches;
-		if(we_are_searching_string_or_void)
-			matches=searching.as_string() == value.as_string();
+		if(data->searching_string)
+			matches=(*data->searching_string) == value.as_string();
 		else
-			matches=searching.as_double() == value.as_double();
-
-		if(matches) {
-			if(data->found)
-				throw Exception(PARSER_RUNTIME,
-					0,
-					"duplicate found");
+			matches=data->searching_double == value.as_double();
 
+		if(matches){
 			data->found=&code;
 			break;
 		}
@@ -470,9 +481,11 @@ struct Try_catch_result {
 template<class I>
 static Try_catch_result try_catch(Request& r, 
 		  StringOrValue body_code(Request&, I), I info, 
-		  Value* catch_code, bool could_be_handled_by_caller=false) 
+		  Value* catch_code,
+		  bool could_be_handled_by_caller=false) 
 {
 	Try_catch_result result;
+
 	if(!catch_code) {
 		result.processed_code=body_code(r, info);
 		return result;
@@ -492,6 +505,7 @@ static Try_catch_result try_catch(Reques
 		Value* saved_exception_var_value=method_frame->get_element(exception_var_name, *method_frame, false);
 		VMethodFrame& frame=*junction->method_frame;
 		frame.put_element(frame, exception_var_name, &details.vhash, false);
+
 		result.processed_code=r.process(*catch_code);
 		
 		// retriving $exception.handled, restoring $exception var
@@ -508,7 +522,7 @@ static Try_catch_result try_catch(Reques
 				
 				bhandled=false;
 			} else
-				bhandled=vhandled->as_bool();		
+				bhandled=vhandled->as_bool();
 		}
 
 		if(!bhandled) {
@@ -516,6 +530,7 @@ static Try_catch_result try_catch(Reques
 			rethrow;
 		}
 	}
+
 	return result;
 }
 
@@ -615,7 +630,8 @@ const String* locked_process_and_cache_p
 		&info,
 		false/*as_text*/,
 		false/*do_append*/,
-		false/*block == don't wait till other thread release lock*/) ? info.processed_code: 0;
+		false/*block == don't wait till other thread release lock*/,
+		false/*dun throw exception if lock failed*/) ? info.processed_code: 0;
 
 	time_t now=time(0);
 	if(scope.expires<=now)
@@ -668,9 +684,8 @@ static const String& as_file_spec(Reques
 	return r.absolute(params.as_string(index, "filespec must be string"));
 }
 static void _cache(Request& r, MethodParams& params) {
-	if(params.count()==0)
-	{
-		// return current expiration time
+	if(params.count()==0) {
+		// ^cache[] -- return current expiration time
 		Cache_scope* scope=static_cast<Cache_scope*>(r.classes_conf.get(cache_data_name));
 		if(!scope)
 			throw Exception(PARSER_RUNTIME,
@@ -682,8 +697,8 @@ static void _cache(Request& r, MethodPar
 
 	time_t now=time(0);
 
-	// ^cache[filename] ^cache(seconds) ^cache[expires date]
 	if(params.count()==1) {
+		// ^cache[filename] ^cache(seconds) ^cache[expires date]
 		if(params[0].is_string()) { // filename?
 			cache_delete(as_file_spec(r, params, 0));
 			return;
@@ -707,7 +722,7 @@ static void _cache(Request& r, MethodPar
 			"invalid number of parameters"); 
 	
 	// file_spec, expires, body code
-	const String& file_spec=r.absolute(params.as_string(0, "filespec must be string"));
+	const String& file_spec=as_file_spec(r, params, 0);
 
 	Cache_scope scope={as_expires(r, params, 1, now), 0};
 
@@ -722,10 +737,10 @@ static void _cache(Request& r, MethodPar
 		Cache_get_result cached=cache_get(r.charsets, file_spec, now);
 
 		if(cached.body) { // have cached copy
-		if(cached.expired) {
-			scope.body_from_disk=cached.body; // storing for user to retrive it with ^cache[]
-		} else {
-			// and it's not expired yet write it out 
+			if(cached.expired) {
+				scope.body_from_disk=cached.body; // storing for user to retrive it with ^cache[]
+			} else {
+				// and it's not expired yet write it out 
    				r.write_assign_lang(*cached.body);
    				// happy with it
    				return;
@@ -733,17 +748,17 @@ static void _cache(Request& r, MethodPar
 		}
 
 		// no cached info or it's already expired
-		try {
-			// try to process and store in file
-   			const String* processed_body=locked_process_and_cache_put(r, body_code, catch_code, scope, file_spec);
-   			// write it out 
-   			r.write_assign_lang(*processed_body);
-   			// happy with it
-   			return;
-		} catch(...) {
-			// we fail during get exclusive lock
-			// nvm we just process it a bit later 
-   		}
+
+		// trying to process it under lock and store result in file
+		const String* processed_body=locked_process_and_cache_put(r, body_code, catch_code, scope, file_spec);
+		if(processed_body){
+			// write it out 
+			r.write_assign_lang(*processed_body);
+			// happy with it
+			return;
+		} else {
+			// we fail while get exclusive lock. nvm, we just execute body_code a bit later
+		}
 	} else { 
 		// instructed not to cache; forget cached copy
 		cache_delete(file_spec);
@@ -761,22 +776,37 @@ static StringOrValue process_try_body_co
 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");
+	Value* finally_code=(params.count()==3) ? &params.as_junction(2, "finally_code must be code") : 0;
 
-	Try_catch_result result=try_catch(r, 
-		process_try_body_code, &body_code,
-		&catch_code);
-	
-	if(result.exception_should_be_handled)
-		throw Exception(PARSER_RUNTIME,
-			result.exception_should_be_handled,
-			"catch block must set $exception.handled to some boolean value, not string");
+	Try_catch_result result;
+	StringOrValue finally_result;
+	try{
+		result=try_catch(r, 
+			process_try_body_code, &body_code,
+			&catch_code);
+		if(result.exception_should_be_handled)
+			throw Exception(PARSER_RUNTIME,
+				result.exception_should_be_handled,
+				"catch block must set $exception.handled to some boolean value, not string");
+	} catch(...){
+		if(finally_code)
+			finally_result=r.process(*finally_code);
+		rethrow;
+	}
+
+	if(finally_code)
+		finally_result=r.process(*finally_code);
 
 	// write out processed body_code or catch_code
 	r.write_pass_lang(result.processed_code);
+
+	// write out processed finally code
+	if(finally_code)
+		r.write_pass_lang(finally_result);
 }
 
 static void _throw_operator(Request&, MethodParams& params) {
-	if(params.count()==1) {
+	if(params.count()==1 && !params[0].is_string()) {
 		if(HashStringValue *hash=params[0].get_hash()) {
 			const char* type=0;
 			if(Value* value=hash->get(exception_type_part_name))
@@ -794,13 +824,12 @@ static void _throw_operator(Request&, Me
 		} else
 			throw Exception(PARSER_RUNTIME,
 				0,
-				"one-param version has hash param");
+				"one-param version has hash or string 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.count()>2? params.as_string(2, "comment must be string").cstr()
-			:0;
-		throw Exception(type, &source, "%s", comment?comment:"");
+		const String* source=params.count()>1? &params.as_string(1, "source must be string"):0;
+		const char* comment=params.count()>2? params.as_string(2, "comment must be string").cstr():0;
+		throw Exception(type, source, "%s", comment?comment:"");
 	}
  }
 
@@ -879,7 +908,7 @@ VClassMAIN::VClassMAIN(): VClass() {
 	// try-catch
 
 	// ^try{code}{catch code}
-	add_native_method("try", Method::CT_ANY, _try_operator, 2, 2);
+	add_native_method("try", Method::CT_ANY, _try_operator, 2, 3);
 	// ^throw[$exception hash]
 	// ^throw[type;source;comment]
 	add_native_method("throw", Method::CT_ANY, _throw_operator, 1, 3);