--- parser3/src/classes/string.C	2008/07/18 09:12:17	1.166
+++ parser3/src/classes/string.C	2009/04/22 04:38:36	1.174
@@ -1,11 +1,11 @@
 /** @file
 	Parser: @b string parser class.
 
-	Copyright (c) 2001-2005 ArtLebedev Group (http://www.artlebedev.com)
+	Copyright (c) 2001-2009 ArtLebedev Group (http://www.artlebedev.com)
 	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
 */
 
-static const char * const IDENT_STRING_C="$Date: 2008/07/18 09:12:17 $";
+static const char * const IDENT_STRING_C="$Date: 2009/04/22 04:38:36 $";
 
 #include "classes.h"
 #include "pa_vmethod_frame.h"
@@ -19,6 +19,7 @@ static const char * const IDENT_STRING_C
 #include "pa_sql_connection.h"
 #include "pa_dictionary.h"
 #include "pa_vmethod_frame.h"
+#include "pa_vregex.h"
 
 // class
 
@@ -116,7 +117,7 @@ static void _bool(Request& r, MethodPara
 			rethrow; // we have a problem when no default
 	}
 
-	r.write_no_lang(*new VBool(converted));
+	r.write_no_lang(VBool::get(converted));
 }
 
 /*not static*/void _string_format(Request& r, MethodParams& params) {
@@ -360,27 +361,42 @@ static void replace_action(Table& table,
 		*ai.dest << ai.src->mid(poststart, postfinish);
 }
 
-/// @todo use pcre:study somehow
 static void _match(Request& r, MethodParams& params) {
+	size_t params_count=params.count();
+
 	Value& regexp=params.as_no_junction(0, "regexp must not be code");
+	Value* options=(params_count>1)?&params.as_no_junction(1, "options must not be code"):0;
+
+	VRegex* vregex;
+	VRegexCleaner vrcleaner;
 
-	const String* options=
-		params.count()>1?
-		&params.as_no_junction(1, "options must not be code").as_string():0;
+	if(Value* value=regexp.as(VREGEX_TYPE, false)){
+		if(options && options->is_defined())
+			throw Exception(PARSER_RUNTIME,
+				0,
+				"you can not specify regex-object and options together"
+			);
+		vregex=static_cast<VRegex*>(value);
+	} else {
+		vregex=new VRegex(r.charsets.source(),
+			&regexp.as_string(),
+			(options)?(&options->as_string()):0);
+		vrcleaner.vregex=vregex;
+	}
 
 	Temp_lang temp_lang(r, String::L_PASS_APPENDED);
 	const String& src=GET_SELF(r, VString).string();
 	int matches_count=0;
-	if(params.count()<3) { // search
-		Table* table=src.match(r.charsets.source(),
-			regexp.as_string(), options,
+
+	if(params_count<3) { // search
+		Table* table=src.match(vregex,
 			search_action, 0,
 			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));
+			r.write_no_lang(*new VInt(matches_count));
 		}
 
 	} else { // replace
@@ -398,10 +414,11 @@ static void _match(Request& r, MethodPar
 		Temp_value_element temp_match_var(
 			*replacement_code.get_junction()->method_frame, 
 			match_var_name, vtable);
-		src.match(r.charsets.source(),
-			r.process_to_string(regexp), options,
+
+		src.match(vregex,
 			replace_action, &info,
 			matches_count);
+
 		r.write_assign_lang(result);
 	}
 }
@@ -639,22 +656,42 @@ static void _append(Request& r, MethodPa
 
 static void _base64(Request& r, MethodParams& params) {
 	if(params.count()) {
-		// decode
+		// decode: ^string:base64[encoded]
 		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));
+		char* decoded=0;
+		size_t length=0;
+		pa_base64_decode(cstr, strlen(cstr), decoded, length);
+		if(decoded && length){
+			if(memchr((const char*)decoded, 0, length))
+				throw Exception(PARSER_RUNTIME,
+					0,
+					"Invalid \\x00 character found while decode to string. Decode it to file instead.");
+
+			fix_line_breaks(decoded, length);
+			if(length){
+				r.write_assign_lang(*new String(decoded, length, true/*tainted*/));
+			}
+		}
 	} else {
-		// encode 
+		// encode: ^str.base64[]
 		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*/));
+		r.write_assign_lang(*new String(encoded, 0, true/*tainted. once ?param=base64(something) was needed*/));
 	}
 }
 
+static void _escape(Request& r, MethodParams&){
+	const String& src=GET_SELF(r, VString).string();
+	r.write_assign_lang(src.escape(r.charsets.source()));
+}
+
+static void _unescape(Request& r, MethodParams& params){
+	const String& src=params.as_string(0, PARAMETER_MUST_BE_STRING);
+	if(const char* result=unescape_chars(src.cstr(), src.length(), &r.charsets.source(), true/* don't unescape '+' char */))
+		r.write_assign_lang(*new String(result));
+}
+
 // constructor
 
 MString::MString(): Methoded("string") {
@@ -727,4 +764,9 @@ MString::MString(): Methoded("string") {
 	// ^string.base64[] << encode
 	// ^string:base64[encoded string] << decode	
 	add_native_method("base64", Method::CT_ANY, _base64, 0, 1);
+
+	// ^string.js-escape[]
+	// ^string:js-unescape[escaped%uXXXXstring]
+	add_native_method("js-escape", Method::CT_ANY, _escape, 0, 0);
+	add_native_method("js-unescape", Method::CT_STATIC, _unescape, 1, 1);
 }