parser3/src/main/pa_string.C - diff

Return to pa_string.C CVS log

Up to [parser3project] / parser3 / src / main

Diff for /parser3/src/main/pa_string.C between versions 1.194 and 1.207

version 1.194, 2004/02/11 15:33:16	version 1.207, 2006/04/09 13:38:47
Line 1	Line 1
/** @file	/** @file
Parser: string class. @see untalength_t.C.	Parser: string class. @see untalength_t.C.

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)	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
*/	*/

Line 21 int pa_atoi(const char* str, const Strin	Line 21 int pa_atoi(const char* str, const Strin
if(!str)	if(!str)
return 0;	return 0;

while(str && isspace(str))	while(str && isspace((unsigned char)str))
str++;	str++;
if(!*str)	if(!*str)
return 0;	return 0;

int result;	int result;
char *error_pos;	char *error_pos;
	bool negative=false;
	if(str[0]=='-') {
	negative=true;
	str++;
	} else if(str[0]=='+') {
	str++;
	}
// 0xABC	// 0xABC
if(str[0]=='0')	if(str[0]=='0')
if(str[1]=='x' \|\| str[1]=='X')	if(str[1]=='x' \|\| str[1]=='X')
result=(int)(unsigned long)strtol(str, &error_pos, 0);	result=(int)(unsigned long)strtol(str, &error_pos, 0);
else	else {
result=(int)strtol(str+1/skip leading 0/, &error_pos, 0);	// skip leading 0000, to disable octal interpretation
	do str++; while(*str=='0');
	result=(int)strtol(str, &error_pos, 0);
	}
else	else
result=(int)strtol(str, &error_pos, 0);	result=(int)strtol(str, &error_pos, 0);
	if(negative)
	result=-result;

while(char c=*error_pos++)	while(char c=*error_pos++)
if(!isspace(c))	if(!isspace((unsigned char)c))
throw Exception("number.format",	throw Exception("number.format",
problem_source,	problem_source,
problem_source?"invalid number (int)": "'%s' is invalid number (int)", str);	problem_source?"invalid number (int)": "'%s' is invalid number (int)", str);
Line 50 double pa_atod(const char* str, const St	Line 62 double pa_atod(const char* str, const St
if(!str)	if(!str)
return 0;	return 0;

while(str && isspace(str))	while(str && isspace((unsigned char)str))
str++;	str++;
if(!*str)	if(!*str)
return 0;	return 0;

double result;	double result;
char *error_pos;	char *error_pos;
	bool negative=false;
	if(str[0]=='-') {
	negative=true;
	str++;
	} else if(str[0]=='+') {
	str++;
	}
// 0xABC	// 0xABC
if(str[0]=='0')	if(str[0]=='0')
if(str[1]=='x' \|\| str[1]=='X')	if(str[1]=='x' \|\| str[1]=='X')
result=(double)(unsigned long)strtol(str, &error_pos, 0);	result=(double)(unsigned long)strtol(str, &error_pos, 0);
else	else {
result=(double)strtod(str+1/skip leading 0/, &error_pos);	// skip leading 0000, to disable octal interpretation
	do str++; while(*str=='0');
	result=(double)strtod(str, &error_pos);
	}
else	else
result=(double)strtod(str, &error_pos);	result=(double)strtod(str, &error_pos);
	if(negative)
	result=-result;

while(char c=*error_pos++)	while(char c=*error_pos++)
if(!isspace(c))	if(!isspace((unsigned char)c))
throw Exception("number.format",	throw Exception("number.format",
problem_source,	problem_source,
problem_source?"invalid number (double)": "'%s' is invalid number (double)", str);	problem_source?"invalid number (double)": "'%s' is invalid number (double)", str);
Line 80 double pa_atod(const char* str, const St	Line 104 double pa_atod(const char* str, const St
#ifndef DOXYGEN	#ifndef DOXYGEN
typedef struct {	typedef struct {
ssize_t countdown;	ssize_t countdown;
char target; /* Character we're looking for */	int target; /* Character we're looking for */
} chr_data;	} chr_data;
#endif	#endif
static int CORD_range_contains_chr_greater_then_proc(char c, size_t size, void* client_data)	static int CORD_range_contains_chr_greater_then_proc(char c, size_t size, void* client_data)
Line 142 String::Body String::Body::Format(int va	Line 166 String::Body String::Body::Format(int va
return String::Body(pa_strdup(local, length), length);	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) {	static int CORD_batched_iter_fn_generic_hash_code(char c, void * client_data) {
uint& result=static_cast<uint>(client_data);	uint& result=static_cast<uint>(client_data);
generic_hash_code(result, c);	generic_hash_code(result, c);
Line 220 String& String::mid(size_t substr_begin,	Line 295 String& String::mid(size_t substr_begin,
// next: letters themselves	// next: letters themselves
result.body=body.mid(substr_begin, substr_length);	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);	ASSERT_STRING_INVARIANT(result);
return result;	return result;
}	}
Line 333 Table* String::match(Charset& source_cha	Line 406 Table* String::match(Charset& source_cha
0,	0,
"regexp is empty");	"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;	const char* errptr;
int erroffset;	int erroffset;
bool need_pre_post_match=false;	bool need_pre_post_match=false;
Line 536 static int serialize_lang_piece(char ala	Line 609 static int serialize_lang_piece(char ala
}	}
String::Cm String::serialize(size_t prolog_length) const {	String::Cm String::serialize(size_t prolog_length) const {
size_t fragments_count=langs.count();	size_t fragments_count=langs.count();
	size_t body_length=body.length();
size_t buf_length=	size_t buf_length=
prolog_length //1	prolog_length //1
+sizeof(size_t) //2	+sizeof(size_t) //2
+fragments_count*(sizeof(char)+sizeof(size_t)) //3	+body_length //3
+body.length() //4	+1 // 4 for zero terminator used in deserialize
+1; // 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);	String::Cm result(new(PointerFreeGC) char[buf_length], buf_length);

// 1: prolog	// 1: prolog
char *cur=result.str+prolog_length;	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);	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);	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;	return result;
}	}
bool String::deserialize(size_t prolog_length, void *buf, size_t buf_length) {	bool String::deserialize(size_t prolog_size, void *buf, size_t buf_size) {
if(buf_length<=prolog_length)	size_t in_buf=buf_size;
	if(in_buf<=prolog_size)
return false;	return false;
buf_length-=prolog_length;	in_buf-=prolog_size;
buf_length-=1; // 5: zero terminator

// 1: prolog	// 1: prolog
const char* cur=(const char* )buf+prolog_length;	const char* cur=(const char* )buf+prolog_size;

	// 2: chars.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;

// 2: langs.count	// 5: langs.count
size_t fragments_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;	return false;
// [WARNING: not cast, addresses must be %4=0 on sparc]	// [WARNING: not cast, addresses must be %4=0 on sparc]
memcpy(&fragments_count, cur, sizeof(fragments_count)); cur+=sizeof(fragments_count);	memcpy(&fragments_count, cur, sizeof(fragments_count)); cur+=sizeof(fragments_count);
buf_length-=sizeof(fragments_count);	in_buf-=sizeof(fragments_count);

if(fragments_count) {	if(fragments_count) {
// 3: lang info	// 6: lang info
size_t total_length=0;	size_t total_length=0;
for(size_t f=0; f<fragments_count; f++) {	for(size_t f=0; f<fragments_count; f++) {
char lang;	char lang;
size_t fragment_length;	size_t fragment_length;
size_t piece_length=sizeof(lang)+sizeof(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;	return false;

// lang	// lang
Line 589 bool String::deserialize(size_t prolog_l	Line 685 bool String::deserialize(size_t prolog_l
// length [WARNING: not cast, addresses must be %4=0 on sparc]	// length [WARNING: not cast, addresses must be %4=0 on sparc]
memcpy(&fragment_length, cur, sizeof(fragment_length)); cur+=sizeof(fragment_length);	memcpy(&fragment_length, cur, sizeof(fragment_length)); cur+=sizeof(fragment_length);

	size_t combined_length=total_length+fragment_length;
	if(combined_length>body_length)
	return false; // file curruption
// uchar needed to prevent propagating 0x80 bit to upper bytes	// uchar needed to prevent propagating 0x80 bit to upper bytes
langs.append(total_length, (String::Language)(uchar)lang, fragment_length);	langs.append(total_length, (String::Language)(uchar)lang, fragment_length);
total_length+=fragment_length;	total_length=combined_length;
	in_buf-=piece_length;
buf_length-=piece_length;
}	}

// 4: letters	if(total_length!=body_length) // length(all language fragments) vs length(letters)
if(buf_length!=total_length)
return false;	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);	ASSERT_STRING_INVARIANT(*this);
return true;	return true;
Line 611 bool String::deserialize(size_t prolog_l	Line 707 bool String::deserialize(size_t prolog_l
const char* String::Body::v() const {	const char* String::Body::v() const {
return CORD_to_const_char_star(body);	return CORD_to_const_char_star(body);
}	}
	void String::Body::dump() const {
	CORD_dump(body);
	}

const char* String::Languages::v() const {	const char* String::Languages::v() const {
if(opt.is_not_just_lang)	if(opt.is_not_just_lang)
return CORD_to_const_char_star(langs);	return CORD_to_const_char_star(langs);
else	else
return (const char*)&langs;	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 {	const char* String::v() const {
#define LIMIT_VIEW 20	const uint LIMIT_VIEW=20;
char* buf=(char*)malloc(MAX_STRING);	char* buf=(char*)malloc(MAX_STRING);
const char*body_view=body.v();	const char*body_view=body.v();
const char*langs_view=langs.v();	const char*langs_view=langs.v();
Line 630 const char* String::v() const {	Line 736 const char* String::v() const {
);	);

return buf;	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;
}	}

E-mail:

Removed from v.1.194
changed lines
	Added in v.1.207