--- parser3/src/main/pa_string.C	2003/12/10 14:17:45	1.192
+++ parser3/src/main/pa_string.C	2005/12/09 07:39:19	1.205
@@ -1,11 +1,11 @@
 /** @file
 	Parser: string class. @see untalength_t.C.
 
-	Copyright (c) 2001-2003 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: 2003/12/10 14:17:45 $";
+static const char * const IDENT_STRING_C="$Date: 2005/12/09 07:39:19 $";
 
 #include "pcre.h"
 
@@ -17,12 +17,94 @@ static const char * const IDENT_STRING_C
 
 const String String::Empty;
 
+int pa_atoi(const char* str, const String* problem_source) {
+	if(!str)
+		return 0;
+
+	while(*str && isspace((unsigned char)*str))
+		str++;
+	if(!*str)
+		return 0;
+
+	int result;
+	char *error_pos;
+	bool negative=false;
+	if(str[0]=='-') {
+		negative=true;
+		str++;
+	} else if(str[0]=='+') {
+		str++;
+	}
+	// 0xABC
+	if(str[0]=='0')
+		if(str[1]=='x' || str[1]=='X')
+			result=(int)(unsigned long)strtol(str, &error_pos, 0);
+		else {
+			 // skip leading 0000, to disable octal interpretation
+			do str++; while(*str=='0');				
+			result=(int)strtol(str, &error_pos, 0);
+		}
+	else
+		result=(int)strtol(str, &error_pos, 0);
+	if(negative)
+		result=-result;
+
+	while(char c=*error_pos++)
+		if(!isspace((unsigned char)c))
+			throw Exception("number.format",
+				problem_source,
+				problem_source?"invalid number (int)": "'%s' is invalid number (int)", str);
+
+	return result;
+}
+
+double pa_atod(const char* str, const String* problem_source) {
+	if(!str)
+		return 0;
+
+	while(*str && isspace((unsigned char)*str))
+		str++;
+	if(!*str)
+		return 0;
+
+	double result;
+	char *error_pos;
+	bool negative=false;
+	if(str[0]=='-') {
+		negative=true;
+		str++;
+	} else if(str[0]=='+') {
+		str++;
+	}
+	// 0xABC
+	if(str[0]=='0')
+		if(str[1]=='x' || str[1]=='X')
+			result=(double)(unsigned long)strtol(str, &error_pos, 0);
+		else {
+			 // skip leading 0000, to disable octal interpretation
+			do str++; while(*str=='0');				
+			result=(double)strtod(str, &error_pos);
+		}
+	else
+		result=(double)strtod(str, &error_pos);
+	if(negative)
+		result=-result;
+
+	while(char c=*error_pos++)
+		if(!isspace((unsigned char)c))
+			throw Exception("number.format",
+				problem_source,
+				problem_source?"invalid number (double)": "'%s' is invalid number (double)", str);
+
+	return result;
+}
+
 // cord lib extension
 
 #ifndef DOXYGEN
 typedef struct {
     ssize_t countdown;
-    char target;	/* Character we're looking for	*/
+    int target;	/* Character we're looking for	*/
 } chr_data;
 #endif
 static int CORD_range_contains_chr_greater_then_proc(char c, size_t size, void* client_data)
@@ -84,6 +166,57 @@ String::Body String::Body::Format(int va
 	return String::Body(pa_strdup(local, length), length);
 }
 
+String::Body String::Body::trim(String::Trim_kind kind, const char* chars, 
+								size_t* out_start, size_t* out_length) const {
+	size_t our_length=length();
+	if(!our_length)
+		return *this;
+	if(!chars)
+		chars=" \t\n"; // white space
+
+	size_t start=0;
+	size_t end=our_length;
+	// from left...
+	if(kind!=TRIM_END) {
+		CORD_pos pos; set_pos(pos, 0);
+		while(true) {
+			char c=CORD_pos_fetch(pos);
+			if(strchr(chars, c)) {
+				if(++start==our_length)
+					return 0; // all chars are empty, just return empty string
+			} else
+				break;			
+
+			CORD_next(pos);
+		}
+	}
+	// from right..
+	if(kind!=TRIM_START) {
+		CORD_pos pos; set_pos(pos, end-1);
+		while(true) {
+			char c=CORD_pos_fetch(pos);
+			if(strchr(chars, c)) {
+				if(--end==0) // optimization: NO need to check for 'end>=start', that's(<) impossible
+					return 0; // all chars are empty, just return empty string
+			} else
+				break;			
+
+			CORD_prev(pos);
+		}
+	}
+
+	if(start==0 && end==our_length) // nobody moved a thing
+		return *this;
+
+	if(out_start)
+		*out_start=start;
+	size_t new_length=end-start;
+	if(out_length)
+		*out_length=new_length;
+
+	return mid(start, new_length);
+}
+
 static int CORD_batched_iter_fn_generic_hash_code(char c, void * client_data) {
 	uint& result=*static_cast<uint*>(client_data);
 	generic_hash_code(result, c);
@@ -162,8 +295,6 @@ String& String::mid(size_t substr_begin,
 	// next: letters themselves
 	result.body=body.mid(substr_begin, substr_length);
 
-//	SAPI::log("piece of '%s' from %d to %d is '%s'",
-		//cstr(), substr_begin, substr_end, result.cstr());
 	ASSERT_STRING_INVARIANT(result);
 	return result;
 }
@@ -275,7 +406,7 @@ Table* String::match(Charset& source_cha
 			0,
 			"regexp is empty");
 
-	const char* pattern=regexp.cstr();
+	const char* pattern=regexp.cstr(String::L_UNSPECIFIED); // fix any tainted with L_REGEX
 	const char* errptr;
 	int erroffset;
 	bool need_pre_post_match=false;
@@ -459,61 +590,6 @@ const String& String::replace(const Dict
 	return result;
 }
 
-double String::as_double() const { 
-	double result;
-	const char *str=cstr();
-
-	while(*str && isspace(*str))
-		str++;
-	if(!*str)
-		return 0;
-
-	char *error_pos;
-	// 0xABC
-	if(str[0]=='0')
-		if(str[1]=='x' || str[1]=='X')
-			result=(double)(unsigned long)strtol(str, &error_pos, 0);
-		else
-			result=(double)strtod(str+1/*skip leading 0*/, &error_pos);
-	else
-		result=(double)strtod(str, &error_pos);
-
-	while(char c=*error_pos++)
-		if(!isspace(c))
-			throw Exception("number.format",
-				this,
-				"invalid number (double)");
-
-	return result;
-}
-int String::as_int() const { 
-	int result;
-	const char *str=cstr();
-
-	while(*str && isspace(*str))
-		str++;
-	if(!*str)
-		return 0;
-
-	char *error_pos;
-	// 0xABC
-	if(str[0]=='0')
-		if(str[1]=='x' || str[1]=='X')
-			result=(int)(unsigned long)strtol(str, &error_pos, 0);
-		else
-			result=(int)strtol(str+1/*skip leading 0*/, &error_pos, 0);
-	else
-		result=(int)strtol(str, &error_pos, 0);
-
-	while(char c=*error_pos++)
-		if(!isspace(c))
-			throw Exception("number.format",
-				this,
-				"invalid number (int)");
-
-	return result;
-}
-
 static int serialize_body_char(char c, char** cur) {
 	*((*cur)++)=c;
 	return 0; // 0=continue
@@ -533,52 +609,75 @@ static int serialize_lang_piece(char ala
 }
 String::Cm String::serialize(size_t prolog_length) const {
 	size_t fragments_count=langs.count();
+	size_t body_length=body.length();
 	size_t buf_length=
 		prolog_length //1
 		+sizeof(size_t) //2
-		+fragments_count*(sizeof(char)+sizeof(size_t)) //3
-		+body.length() //4
-		+1; // for zero terminator used in deserialize
+		+body_length //3
+		+1 // 4 for zero terminator used in deserialize
+		+sizeof(size_t) //5
+		+fragments_count*(sizeof(char)+sizeof(size_t)); //6
+
 	String::Cm result(new(PointerFreeGC) char[buf_length], buf_length);
 
 	// 1: prolog
 	char *cur=result.str+prolog_length;
-	// 2: langs.count [WARNING: not cast, addresses must be %4=0 on sparc]
+	// 2: chars.count [WARNING: not cast, addresses must be %4=0 on sparc]
+	memcpy(cur, &body_length, sizeof(body_length));  cur+=sizeof(body_length);
+	// 3: letters
+	body.for_each(serialize_body_char, serialize_body_piece, &cur);
+	// 4: zero terminator
+	*cur++=0;
+	// 5: langs.count [WARNING: not cast, addresses must be %4=0 on sparc]
 	memcpy(cur, &fragments_count, sizeof(fragments_count));  cur+=sizeof(fragments_count);
-	// 3: lang info
+	// 6: lang info
 	langs.for_each(body, serialize_lang_piece, &cur);
-	// 4: letters
-	body.for_each(serialize_body_char, serialize_body_piece, &cur);
-	// 5: zero terminator
-	*cur=0;
 
 	return result;
 }
-bool String::deserialize(size_t prolog_length, void *buf, size_t buf_length) {
-	if(buf_length<=prolog_length)
+bool String::deserialize(size_t prolog_size, void *buf, size_t buf_size) {
+	size_t in_buf=buf_size;
+	if(in_buf<=prolog_size)
 		return false;
-	buf_length-=prolog_length;
-	buf_length-=1; // 5: zero terminator
+	in_buf-=prolog_size;
 
 	// 1: prolog
-	const char* cur=(const char* )buf+prolog_length;
+	const char* cur=(const char* )buf+prolog_size;
 
 	// 2: langs.count
+	size_t body_length;
+	if(in_buf<sizeof(body_length)) // body.length don't fit?
+		return false;
+	// [WARNING: not cast, addresses must be %4=0 on sparc]
+	memcpy(&body_length, cur, sizeof(body_length));  cur+=sizeof(body_length);
+	in_buf-=sizeof(body_length);
+
+	if(in_buf<body_length+1) // letters+terminator don't fit?
+		return false;
+	// 4: zero terminator
+	if(cur[body_length] != 0) // in place?
+		return false;
+	// 3: letters
+	body=String::Body(cur, body_length);  
+	cur+=body_length+1;
+	in_buf-=body_length+1;
+
+	// 5: langs.count
 	size_t fragments_count;
-	if(buf_length<sizeof(fragments_count)) // langs.count don't fit?
+	if(in_buf<sizeof(fragments_count)) // langs.count don't fit?
 		return false;
 	// [WARNING: not cast, addresses must be %4=0 on sparc]
 	memcpy(&fragments_count, cur, sizeof(fragments_count));  cur+=sizeof(fragments_count);
-	buf_length-=sizeof(fragments_count);
+	in_buf-=sizeof(fragments_count);
 	
 	if(fragments_count) {
-		// 3: lang info
+		// 6: lang info
 		size_t total_length=0;
 		for(size_t f=0; f<fragments_count; f++) {
 			char lang;
 			size_t fragment_length;
 			size_t piece_length=sizeof(lang)+sizeof(fragment_length);
-			if(buf_length<piece_length) // lang+length
+			if(in_buf<piece_length) // lang+length
 				return false;
 
 			// lang
@@ -589,17 +688,14 @@ bool String::deserialize(size_t prolog_l
 			// uchar needed to prevent propagating 0x80 bit to upper bytes
 			langs.append(total_length, (String::Language)(uchar)lang, fragment_length);
 			total_length+=fragment_length;
-
-			buf_length-=piece_length;
+			in_buf-=piece_length;
 		}
 
-		// 4: letters
-		if(buf_length!=total_length)
+		if(total_length!=body_length) // length(all language fragments) vs length(letters)
 			return false;
-
-		// serialize wrote extra zero byte there, we can rely on that
-		body=String::Body(cur, buf_length);
 	}
+	if(in_buf!=0) // some strange extra bytes
+		return false;
 
 	ASSERT_STRING_INVARIANT(*this);
 	return true;
@@ -608,14 +704,24 @@ bool String::deserialize(size_t prolog_l
 const char* String::Body::v() const {
 	return CORD_to_const_char_star(body);
 }
+void String::Body::dump() const {
+	CORD_dump(body);
+}
+
 const char* String::Languages::v() const {
 	if(opt.is_not_just_lang)
 		return CORD_to_const_char_star(langs);
 	else
 		return (const char*)&langs;
 }
+void String::Languages::dump() const {
+	if(opt.is_not_just_lang)
+		CORD_dump(langs);
+	else
+		puts((const char*)&langs);
+}
 const char* String::v() const {
-#define LIMIT_VIEW 20
+	const uint LIMIT_VIEW=20;
 	char* buf=(char*)malloc(MAX_STRING);
 	const char*body_view=body.v();
 	const char*langs_view=langs.v();
@@ -627,5 +733,31 @@ const char* String::v() const {
 	);
 
 	return buf;
-#undef LIMIT_VIEW
+}
+void String::dump() const {
+	body.dump();
+	langs.dump();
+}
+const String& String::trim(String::Trim_kind kind, const char* chars) const {
+	if(!length())
+		return *this;
+
+	size_t substr_begin, substr_length;
+	Body new_body=body.trim(kind, chars, &substr_begin, &substr_length);
+	if(new_body==body) // we received unchanged pointer, do likewise
+		return *this;
+	// new_body differs from body, adjust langs along
+
+	String& result=*new String;
+	if(!new_body) // body.trim produced empty result
+		return result;
+	// body.trim produced nonempty result
+
+	// first: their langs
+	result.langs.append(result.body, langs, substr_begin, substr_length);
+	// next: letters themselves
+	result.body=new_body;
+
+	ASSERT_STRING_INVARIANT(result);
+	return result;
 }