--- parser3/src/classes/string.C	2004/06/22 14:12:57	1.141
+++ parser3/src/classes/string.C	2007/04/20 10:19:24	1.152
@@ -1,11 +1,11 @@
 /** @file
 	Parser: @b string parser class.
 
-	Copyright (c) 2001-2004 ArtLebedev Group (http://www.artlebedev.com)
+	Copyright (c) 2001-2005 ArtLebedev Group (http://www.artlebedev.com)
 	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
 */
 
-static const char * const IDENT_STRING_C="$Date: 2004/06/22 14:12:57 $";
+static const char * const IDENT_STRING_C="$Date: 2007/04/20 10:19:24 $";
 
 #include "classes.h"
 #include "pa_vmethod_frame.h"
@@ -54,8 +54,6 @@ static void _length(Request& r, MethodPa
 static void _int(Request& r, MethodParams& params) {
 	const String& self_string=GET_SELF(r, VString).string();
 	int converted;
-	Value* default_code=params.count()>0?&params.as_junction(0, "default must be int")
-		:0; // (default)
 	try {
 		if(self_string.is_empty())
 			throw Exception("parser.runtime",
@@ -63,8 +61,8 @@ static void _int(Request& r, MethodParam
 				"parameter is empty string, error converting");
 		converted=self_string.as_int();
 	} catch(...) { // convert problem
-		if(default_code)
-			converted=r.process_to_value(*default_code).as_int();
+		if(params.count()>0)
+			converted=params.as_int(0, "default must be int", r); // (default)
 		else
 			rethrow; // we have a problem when no default			
 	}
@@ -74,8 +72,6 @@ static void _int(Request& r, MethodParam
 static void _double(Request& r, MethodParams& params) {
 	const String& self_string=GET_SELF(r, VString).string();
 	double converted;
-	Value* default_code=params.count()>0?&params.as_junction(0, "default must be double")
-		:0; // (default)
 	try {
 		if(self_string.is_empty())
 			throw Exception("parser.runtime",
@@ -83,8 +79,8 @@ static void _double(Request& r, MethodPa
 				"parameter is empty string, error converting");
 		converted=self_string.as_double();
 	} catch(...) { // convert problem
-		if(default_code)
-			converted=r.process_to_value(*default_code).as_double();
+		if(params.count()>0)
+			converted=params.as_double(0, "default must be double", r); // (default)
 		else
 			rethrow; // we have a problem when no default
 	}
@@ -92,6 +88,25 @@ static void _double(Request& r, MethodPa
 	r.write_no_lang(*new VDouble(converted));
 }
 
+static void _bool(Request& r, MethodParams& params) {
+	const String& self_string=GET_SELF(r, VString).string();
+	bool converted;
+	try {
+		if(self_string.is_empty())
+			throw Exception("parser.runtime",
+				0,
+				"parameter is empty string, error converting");
+		converted=self_string.as_bool();
+	} catch(...) { // convert problem
+		if(params.count()>0)
+			converted=params.as_bool(0, "default must be bool", r); // (default)
+		else
+			rethrow; // we have a problem when no default
+	}
+
+	r.write_no_lang(*new VBool(converted));
+}
+
 /*not static*/void _string_format(Request& r, MethodParams& params) {
 
 	Value& fmt_maybe_code=params[0];
@@ -321,18 +336,19 @@ static void _match(Request& r, MethodPar
 
 	Temp_lang temp_lang(r, String::L_PASS_APPENDED);
 	const String& src=GET_SELF(r, VString).string();
-	bool just_matched;
+	int matches_count=0;
 	if(params.count()<3) { // search
 		Table* table=src.match(r.charsets.source(),
 			regexp.as_string(), options,
 			search_action, 0,
-			just_matched);
-		Value* result;
-		if(table) 
-			result=new VTable(table); // table of pre/match/post+substrings
-		else 
-			result=new VBool(just_matched);
-		r.write_assign_lang(*result);
+			matches_count);
+		// r.write_assign_lang(*new VTable(table));
+		if(table){
+		r.write_assign_lang(*new VTable(table));
+		} else {
+			r.write_assign_lang(*new VInt(matches_count));
+		}
+
 	} else { // replace
 		Value& replacement_code=params.as_junction(2, "replacement param must be code");
 
@@ -351,7 +367,7 @@ static void _match(Request& r, MethodPar
 		src.match(r.charsets.source(),
 			r.process_to_string(regexp), options,
 			replace_action, &info,
-			just_matched);
+			matches_count);
 		r.write_assign_lang(result);
 	}
 }
@@ -433,7 +449,7 @@ const String* sql_result_string(Request&
 	default_code=0;
 	if(params.count()>1) {
 		Value& voptions=params.as_no_junction(1, "options must be hash, not code");
-		if(!voptions.is_string())
+		if(voptions.is_defined() && !voptions.is_string())
 			if((options=voptions.get_hash())) {
 				int valid_options=0;
 				if(Value* vbind=options->get(sql_bind_name)) {
@@ -450,10 +466,6 @@ const String* sql_result_string(Request&
 				}
 				if((default_code=options->get(sql_default_name))) {
 					valid_options++;
-					if(!default_code->get_junction())
-						throw Exception("parser.runtime",
-							0,
-							"default option must be code");
 				}
 				if(valid_options!=options->count())
 					throw Exception("parser.runtime",
@@ -478,7 +490,7 @@ const String* sql_result_string(Request&
 	String_sql_event_handlers handlers(statement_string, statement_cstr);
 	r.connection()->query(
 		statement_cstr, 
-		0, 0,
+		placeholders_count, placeholders,
 		offset, limit, 
 		handlers,
 		statement_string);
@@ -591,6 +603,24 @@ static void _append(Request& r, MethodPa
 	va.set_string(c);
 }
 
+static void _base64(Request& r, MethodParams& params) {
+	if(params.count()) {
+		// decode
+		const char* cstr=params.as_string(0, "parameter must be string").cstr();
+		char* decoded_cstr=0;
+		size_t decoded_size=0;
+		pa_base64_decode(cstr, strlen(cstr), decoded_cstr, decoded_size);
+		if(decoded_cstr && decoded_size)
+			r.write_assign_lang(*new String(decoded_cstr, decoded_size, true));
+	} else {
+		// encode 
+		VString& self=GET_SELF(r, VString);
+		const char* cstr=self.string().cstr();
+		const char* encoded=pa_base64_encode(cstr, strlen(cstr));
+		r.write_assign_lang(*new String(encoded, 0, true/*once ?param=base64(something) was needed*/));
+	}
+}
+
 // constructor
 
 MString::MString(): Methoded("string") {
@@ -603,6 +633,9 @@ MString::MString(): Methoded("string") {
 	// ^string.double[]
 	// ^string.double(default)
 	add_native_method("double", Method::CT_DYNAMIC, _double, 0, 1);
+	// ^void.bool[]
+	// ^void.bool(default)
+	add_native_method("bool", Method::CT_DYNAMIC, _bool, 0, 1);
 
 	// ^string.format{format}
 	add_native_method("format", Method::CT_DYNAMIC, _string_format, 1, 1);
@@ -653,4 +686,8 @@ MString::MString(): Methoded("string") {
 
 	// ^string.append[string]
 	add_native_method("append", Method::CT_DYNAMIC, _append, 1, 1);
+
+	// ^string.base64[] << encode
+	// ^string:base64[encoded string] << decode	
+	add_native_method("base64", Method::CT_ANY, _base64, 0, 1);
 }