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.172.2.21.2.6 and 1.172.2.21.2.11

version 1.172.2.21.2.6, 2003/03/20 09:41:47	version 1.172.2.21.2.11, 2003/03/20 15:05:58
Line 1	Line 1
/** @file	/** @file
Parser: string class. @see untasize_t.C.	Parser: string class. @see untalength_t.C.

Copyright (c) 2001-2003 ArtLebedev Group (http://www.artlebedev.com)	Copyright (c) 2001-2003 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 39 Table string_match_table_template(new St	Line 39 Table string_match_table_template(new St
// String::ArrayFragment methods	// String::ArrayFragment methods

String::ArrayFragment& String::ArrayFragment::append(const ArrayFragment& src,	String::ArrayFragment& String::ArrayFragment::append(const ArrayFragment& src,
size_t substr_start, size_t substr_end) {	size_t substr_begin, size_t substr_end) {
if(substr_start==substr_end)	if(substr_begin==substr_end)
return *this;	return *this;

size_t fragment_start=0;	size_t fragment_begin=0;
size_t fragment_end;	size_t fragment_end;
for(Array_iterator<element_type> i(src); ; fragment_start=fragment_end) {	for(Array_iterator<element_type> i(src); ; fragment_begin=fragment_end) {
const element_type& fragment=i.next();	const element_type& fragment=i.next();
fragment_end=fragment_start+fragment.size;	fragment_end=fragment_begin+fragment.length;

if(substr_start<fragment_start) // not reached fragments which may include 'substr'?	if(fragment_begin<substr_begin) // not reached fragments which may include 'substr'?
continue;	continue;

// found first fragment including piece of 'substr'	// found first fragment including piece of 'substr'
size_t piece_end=min(substr_end, fragment_end);	size_t piece_end=min(substr_end, fragment_end);
*this+=Fragment(fragment.lang, piece_end-substr_start);	*this+=Fragment(fragment.lang, piece_end-substr_begin);

while(substr_end>fragment_end) { // are there more fragments including pieces of 'substr'?	while(substr_end>fragment_end) { // are there more fragments including pieces of 'substr'?
	fragment_begin=fragment_end;

const element_type& fragment=i.next();	const element_type& fragment=i.next();
fragment_end=fragment_start+fragment.size;	fragment_end=fragment_begin+fragment.length;

if(substr_end>fragment_end) // are there still more?	if(substr_end>fragment_end) // are there still more?
simple_append(Fragment(fragment.lang, fragment.size)); // appending whole fragment	simple_append(Fragment(fragment.lang, fragment.length)); // appending whole fragment
else { // no, it was last	else { // no, it was last
simple_append(Fragment(fragment.lang, substr_end-fragment_start));	simple_append(Fragment(fragment.lang, substr_end-fragment_begin));
goto break2;	goto break2;
}	}
}	}
Line 75 break2:	Line 77 break2:
return *this;	return *this;
}	}
/*	/*
void String::ArrayFragment::mid(ArrayFragment& result, size_t substr_start, size_t substr_end) {	void String::ArrayFragment::mid(ArrayFragment& result, size_t substr_begin, size_t substr_end) {
}	}
*/	*/

// String methods	// String methods

String::String(const char* src, size_t src_size, bool tainted): body(CORD_EMPTY) {	String::String(const char* cstr, size_t helper_length, bool tainted): body(CORD_EMPTY) {
if(src)	append_cstr(cstr, helper_length, tainted?UL_TAINTED:UL_CLEAN);
if(tainted)
APPEND_TAINTED(src, src_size, 0, 0);
else
APPEND_CLEAN(src, src_size, 0, 0);
}	}

String::String(const String& src): body(src.body), fragments(src.fragments) {}	String::String(const String& src): body(src.body), fragments(src.fragments) {}

String& String::real_append(STRING_APPEND_PARAMS) {	String& String::append_cstr(const char* heap_variable, size_t helper_length, Untaint_lang lang) {
if(!src)	if(!heap_variable)
return *this;	return *this;
if(!size)	size_t use_length;
size=strlen(src);	if(helper_length) {
if(!size)	#ifdef _DEBUG
	size_t real_length=strlen(heap_variable);
	if(helper_length!=real_length)
	throw Exception(0,
	this,
	"bad String::String(real=%d, helper%d",
	real_length, helper_length);
	#endif
	use_length=helper_length;
	} else
	use_length=strlen(heap_variable);
	size_t length=helper_length?helper_length:strlen(heap_variable);
	if(!length)
return *this;	return *this;

body=CORD_cat_char_star(body, src, size);	body=CORD_cat_char_star(body, heap_variable, length);
fragments+=Fragment(lang, size);	fragments+=Fragment(lang, length);

	return *this;
	}

	String& String::append_copy(const char* auto_variable, size_t helper_length, Untaint_lang lang) {
	if(!auto_variable)
	return *this;
	size_t use_length=helper_length?helper_length:strlen(auto_variable);
	if(!use_length)
	return *this;

	body=pa_strdup(auto_variable, use_length);
	fragments+=Fragment(lang, use_length);

return *this;	return *this;
}	}
Line 116 uint String::hash_code() const {	Line 139 uint String::hash_code() const {
return result;	return result;
}	}

const String& String::mid(size_t substr_start, size_t substr_end) const {	/// @todo check in doc: whether it documents NOW bad situation "abc".mid(-1, 3) =were?="ab"
	const String& String::mid(size_t substr_begin, size_t substr_end) const {
String& result=*new String;	String& result=*new String;

substr_start=min(substr_start, size());	size_t self_length=length();
substr_end=max(substr_start, substr_end);	substr_begin=max(min(substr_begin, self_length), (size_t)0);
if(substr_start==substr_end)	substr_end=min(max(substr_end, substr_begin), self_length);
	if(substr_begin==substr_end)
return result;	return result;

// first: letters themselves	// first: letters themselves
result.body=CORD_substr(body, substr_start, substr_end-substr_start);	result.body=CORD_substr(body, substr_begin, substr_end-substr_begin);

// next: their langs	// next: their langs
result.fragments.append(fragments, substr_start, substr_end);	result.fragments.append(fragments, substr_begin, substr_end);

// SAPI::log(pool(), "piece of '%s' from %d to %d is '%s'",	// SAPI::log(pool(), "piece of '%s' from %d to %d is '%s'",
//cstr(), substr_start, substr_end, result.cstr());	//cstr(), substr_begin, substr_end, result.cstr());
return result;	return result;
}	}

size_t String::pos(CORD substr,	size_t String::pos(CORD substr,
size_t this_offset, Untaint_lang lang) const {	size_t this_offset, Untaint_lang lang) const {
// first: letters themselves	// first: letters themselves
size_t substr_start=CORD_str(body, this_offset, substr);	size_t substr_begin=CORD_str(body, this_offset, substr);
if(substr_start==CORD_NOT_FOUND)	if(substr_begin==CORD_NOT_FOUND)
return STRING_NOT_FOUND;	return STRING_NOT_FOUND;

// next: check the lang when specified	// next: check the lang when specified

if(lang==UL_UNSPECIFIED) // ignore lang?	if(lang==UL_UNSPECIFIED) // ignore lang?
return substr_start;	return substr_begin;

// substr must be in one fragment, and fragments' lang must = lang	// substr must be in one fragment, and fragments' lang must = lang
size_t substr_end=substr_start+CORD_len(substr);	size_t substr_end=substr_begin+CORD_len(substr);
size_t fragment_start=0;	size_t fragment_begin=0;
size_t fragment_end;	size_t fragment_end;
for(Array_iterator<ArrayFragment::element_type> i(fragments); i.has_next(); fragment_start=fragment_end) {	for(Array_iterator<ArrayFragment::element_type> i(fragments); i.has_next(); fragment_begin=fragment_end) {
const Fragment& fragment=i.next();	const Fragment& fragment=i.next();
fragment_end=fragment_start+fragment.size;	fragment_end=fragment_begin+fragment.length;

if(substr_start<fragment_start) // not reached fragments which may include 'result'?	if(substr_begin<fragment_begin) // not reached fragments which may include 'result'?
continue;	continue;

if(substr_end>fragment_end) // end of substr OUT of current fragment?	if(substr_end>fragment_end) // end of substr OUT of current fragment?
Line 176 void String::split(ArrayString& result,	Line 201 void String::split(ArrayString& result,
size_t& pos_after,	size_t& pos_after,
const char* delim,	const char* delim,
Untaint_lang lang, int limit) {	Untaint_lang lang, int limit) {
size_t self_size=size();	size_t self_length=length();
if(size_t delim_size=strlen(delim)) {	if(size_t delim_length=strlen(delim)) {
int pos_before;	int pos_before;
// while we have 'delim'...	// while we have 'delim'...
for(; (pos_before=pos(delim, pos_after, lang))>=0 && limit; limit--) {	for(; (pos_before=pos(delim, pos_after, lang))>=0 && limit; limit--) {
result+=&mid(pos_after, pos_before);	result+=&mid(pos_after, pos_before);
pos_after=pos_before+delim_size;	pos_after=pos_before+delim_length;
}	}
// last piece	// last piece
if(pos_after<self_size && limit) {	if(pos_after<self_length && limit) {
result+=&mid(pos_after, self_size);	result+=&mid(pos_after, self_length);
pos_after=self_size;	pos_after=self_length;
}	}
} else { // empty delim	} else { // empty delim
result+=this;	result+=this;
pos_after+=self_size;	pos_after+=self_length;
}	}
}	}

Line 204 void String::split(ArrayString& result,	Line 229 void String::split(ArrayString& result,
// while we have 'delim'...	// while we have 'delim'...
for(; (pos_before=pos(delim, pos_after, lang))>=0 && limit; limit--) {	for(; (pos_before=pos(delim, pos_after, lang))>=0 && limit; limit--) {
result+=&mid(pos_after, pos_before);	result+=&mid(pos_after, pos_before);
pos_after=pos_before+delim.size();	pos_after=pos_before+delim.length();
}	}
// last piece	// last piece
if(pos_after<size() && limit) {	if(pos_after<length() && limit) {
result+=&mid(pos_after, size());	result+=&mid(pos_after, length());
pos_after=size();	pos_after=length();
}	}
} else { // empty delim	} else { // empty delim
result+=this;	result+=this;
pos_after+=size();	pos_after+=length();
}	}
}	}

Line 271 Table* String::match(Charset& source_cha	Line 296 Table* String::match(Charset& source_cha

if(!code)	if(!code)
throw Exception(0,	throw Exception(0,
&regexp.mid(erroffset, regexp.size()),	&regexp.mid(erroffset, regexp.length()),
"regular expression syntax error - %s", errptr);	"regular expression syntax error - %s", errptr);

int subpatterns=pcre_info(code, 0, 0);	int subpatterns=pcre_info(code, 0, 0);
Line 284 Table* String::match(Charset& source_cha	Line 309 Table* String::match(Charset& source_cha
}	}

const char* subject=cstr();	const char* subject=cstr();
size_t subject_size=strlen(subject);	size_t subject_length=strlen(subject);
const int ovecsize=(1/match/+MAX_MATCH_GROUPS)*3;	const int oveclength=(1/match/+MAX_MATCH_GROUPS)*3;
int ovector[ovecsize];	int ovector[oveclength];

// create table	// create table
Table* table=new Table(string_match_table_template);	Table* table=new Table(string_match_table_template);
Line 294 Table* String::match(Charset& source_cha	Line 319 Table* String::match(Charset& source_cha
int exec_option_bits=0;	int exec_option_bits=0;
int prestart=0;	int prestart=0;
int poststart=0;	int poststart=0;
int postfinish=size();	int postfinish=length();
while(true) {	while(true) {
int exec_substrings=pcre_exec(code, 0,	int exec_substrings=pcre_exec(code, 0,
subject, subject_size, prestart,	subject, subject_length, prestart,
exec_option_bits, ovector, ovecsize);	exec_option_bits, ovector, oveclength);

if(exec_substrings==PCRE_ERROR_NOMATCH) {	if(exec_substrings==PCRE_ERROR_NOMATCH) {
pcre_free(code);	pcre_free(code);
Line 396 String& String::change_case(Charset& sou	Line 421 String& String::change_case(Charset& sou
const String& String::replace(const Dictionary& dict) const {	const String& String::replace(const Dictionary& dict) const {
String& result=*new String();	String& result=*new String();
const char* old_cstr=cstr();	const char* old_cstr=cstr();
const char* prematch_start=old_cstr;	const char* prematch_begin=old_cstr;

for(const char* current=old_cstr; *current; ) {	for(const char* current=old_cstr; *current; ) {
if(Table::element_type row=dict.first_that_starts(current)) {	if(Table::element_type row=dict.first_that_begins(current)) {
// prematch	// prematch
if(size_t prematch_size=current-prematch_start) {	if(size_t prematch_length=current-prematch_begin) {
result.body=CORD_cat_char_star(result.body, prematch_start, prematch_size);	result.body=CORD_cat_char_star(result.body, prematch_begin, prematch_length);
result.fragments.append(fragments, prematch_start-old_cstr, prematch_size);	result.fragments.append(fragments, prematch_begin-old_cstr, prematch_length);
}	}

// match	// match

const String* a=row->get(0);	const String* a=row->get(0);
// skip 'a' in 'current'; move prematch_start	// skip 'a' in 'current'; move prematch_begin
current+=a->size(); prematch_start=current;	current+=a->length(); prematch_begin=current;

if(row->count()>1) { // are there any b?	if(row->count()>1) { // are there any b?
const String* b=row->get(1);	const String* b=row->get(1);
if(size_t b_size=b->size()) {	if(size_t b_length=b->length()) {
result.body=CORD_cat(result.body, b->cstr_to_cord());	result.body=CORD_cat(result.body, b->cstr_to_cord());
result.fragments.append(b->fragments, 0, b->fragments.count());	result.fragments.append(b->fragments, 0, b->fragments.count());
}	}
Line 424 const String& String::replace(const Dict	Line 449 const String& String::replace(const Dict
}	}

// postmatch	// postmatch
if(size_t prematch_size=current-prematch_start) {	if(size_t prematch_length=current-prematch_begin) {
result.body=CORD_cat_char_star(result.body, prematch_start, prematch_size);	result.body=CORD_cat_char_star(result.body, prematch_begin, prematch_length);
result.fragments.append(fragments, prematch_start-old_cstr, prematch_size);	result.fragments.append(fragments, prematch_begin-old_cstr, prematch_length);
}	}

return result;	return result;
Line 434 const String& String::replace(const Dict	Line 459 const String& String::replace(const Dict

double String::as_double() const {	double String::as_double() const {
double result;	double result;
char buf[MAX_STRING];	const char *str=cstr();
if(size()>MAX_STRING-1)
throw Exception("number.format",	while(str && isspace(str))
this,	str++;
"invalid number too long a string (%u>%u)", size(), MAX_STRING-1);	if(!*str)
char eol=store_to(buf, String::UL_AS_IS); eol=0;
const char* cstr=buf;

while(cstr && isspace(cstr))
cstr++;
if(!*cstr)
return 0;	return 0;

char *error_pos;	char *error_pos;
// 0xABC	// 0xABC
if(cstr[0]=='0')	if(str[0]=='0')
if(cstr[1]=='x' \|\| cstr[1]=='X')	if(str[1]=='x' \|\| str[1]=='X')
result=(double)(unsigned long)strtol(cstr, &error_pos, 0);	result=(double)(unsigned long)strtol(str, &error_pos, 0);
else	else
result=(double)strtod(cstr+1/skip leading 0/, &error_pos);	result=(double)strtod(str+1/skip leading 0/, &error_pos);
else	else
result=(double)strtod(cstr, &error_pos);	result=(double)strtod(str, &error_pos);

while(char c=*error_pos++)	while(char c=*error_pos++)
if(!isspace(c))	if(!isspace(c))
Line 467 double String::as_double() const {	Line 486 double String::as_double() const {
}	}
int String::as_int() const {	int String::as_int() const {
int result;	int result;
char buf[MAX_STRING];	const char *str=cstr();
if(size()>MAX_STRING-1)
throw Exception("number.format",	while(str && isspace(str))
this,	str++;
"invalid number too long a string (%u>%u)", size(), MAX_STRING-1);	if(!*str)
char eol=store_to(buf, String::UL_AS_IS); eol=0;
const char* cstr=buf;

while(cstr && isspace(cstr))
cstr++;
if(!*cstr)
return 0;	return 0;

char *error_pos;	char *error_pos;
// 0xABC	// 0xABC
if(cstr[0]=='0')	if(str[0]=='0')
if(cstr[1]=='x' \|\| cstr[1]=='X')	if(str[1]=='x' \|\| str[1]=='X')
result=(int)(unsigned long)strtol(cstr, &error_pos, 0);	result=(int)(unsigned long)strtol(str, &error_pos, 0);
else	else
result=(int)strtol(cstr+1/skip leading 0/, &error_pos, 0);	result=(int)strtol(str+1/skip leading 0/, &error_pos, 0);
else	else
result=(int)strtol(cstr, &error_pos, 0);	result=(int)strtol(str, &error_pos, 0);

while(char c=*error_pos++)	while(char c=*error_pos++)
if(!isspace(c))	if(!isspace(c))
Line 515 inline uint uchars2uint(uchar *bytes) {	Line 528 inline uint uchars2uint(uchar *bytes) {
static int CORD_batched_iter_fn_append(const char* s, void* client_data) {	static int CORD_batched_iter_fn_append(const char* s, void* client_data) {
char& cur=static_cast<char**>(client_data);	char& cur=static_cast<char**>(client_data);

size_t size=strlen(s);	size_t length=strlen(s);
memcpy(cur, s, size); cur+=size;	memcpy(cur, s, length); cur+=length;
return 0;	return 0;
};	};
String::C String::serialize(size_t prolog_size) const {	String::C String::serialize(size_t prolog_length) const {
size_t buf_size=	size_t buf_length=
prolog_size	prolog_length
+fragments.count()*(sizeof(Untaint_lang)+sizeof(size_t))	+fragments.count()*(sizeof(Untaint_lang)+sizeof(size_t))
+size();	+length();
C result(new(PointerFreeGC) char[buf_size], buf_size);	C result(new(PointerFreeGC) char[buf_length], buf_length);

// 1: prolog	// 1: prolog
char *cur=result.str+prolog_size;	char *cur=result.str+prolog_length;


// 2: fragments.count	// 2: fragments.count
Line 539 String::C String::serialize(size_t prolo	Line 552 String::C String::serialize(size_t prolo
const Fragment& fragment=i.next();	const Fragment& fragment=i.next();
// lang	// lang
memcpy(cur, &fragment.lang, sizeof(fragment.lang)); cur+=sizeof(fragment.lang);	memcpy(cur, &fragment.lang, sizeof(fragment.lang)); cur+=sizeof(fragment.lang);
// size	// length
memcpy(cur, &fragment.size, sizeof(fragment.size)); cur+=sizeof(fragment.size);	memcpy(cur, &fragment.length, sizeof(fragment.length)); cur+=sizeof(fragment.length);
}	}

// 4: letters	// 4: letters
Line 548 String::C String::serialize(size_t prolo	Line 561 String::C String::serialize(size_t prolo

return result;	return result;
}	}
bool String::deserialize(size_t prolog_size, void buf, size_t buf_size, const char file) {	bool String::deserialize(size_t prolog_length, void buf, size_t buf_length, const char file) {
if(buf_size<=prolog_size)	if(buf_length<=prolog_length)
return false;	return false;
buf_size-=prolog_size;	buf_length-=prolog_length;

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

// 2: fragments.count	// 2: fragments.count
if(buf_size<sizeof(size_t)) // fragments.count don't fit?	if(buf_length<sizeof(size_t)) // fragments.count don't fit?
return false;	return false;
size_t fragments_count=reinterpret_cast<const size_t>(cur); cur+=sizeof(size_t);	size_t fragments_count=reinterpret_cast<const size_t>(cur); cur+=sizeof(size_t);
buf_size-=sizeof(size_t);	buf_length-=sizeof(size_t);

// 3: lang info	// 3: lang info
size_t total_size=0;	size_t total_length=0;
for(size_t f=0; f<fragments_count; f++) {	for(size_t f=0; f<fragments_count; f++) {
size_t piece_size=sizeof(Untaint_lang)+sizeof(size_t);	size_t piece_length=sizeof(Untaint_lang)+sizeof(size_t);
if(buf_size<piece_size) // lang+size	if(buf_length<piece_length) // lang+length
return false;	return false;

Untaint_lang lang=reinterpret_cast<const Untaint_lang >(cur); cur+=sizeof(Untaint_lang);	Untaint_lang lang=reinterpret_cast<const Untaint_lang >(cur); cur+=sizeof(Untaint_lang);
size_t fragment_size=reinterpret_cast<const size_t>(cur); cur+=sizeof(size_t);	size_t fragment_length=reinterpret_cast<const size_t>(cur); cur+=sizeof(size_t);
fragments+=Fragment(lang, fragment_size);	fragments+=Fragment(lang, fragment_length);
total_size+=fragment_size;	total_length+=fragment_length;

buf_size-=piece_size;	buf_length-=piece_length;
}	}

// 4: letters	// 4: letters
if(buf_size!=total_size)	if(buf_length!=total_length)
return false;	return false;

body=CORD_cat_char_star(CORD_EMPTY, cur, buf_size);	body=CORD_cat_char_star(CORD_EMPTY, cur, buf_length);

return true;	return true;
}	}

E-mail:

Removed from v.1.172.2.21.2.6
changed lines
	Added in v.1.172.2.21.2.11