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.10 and 1.172.2.21.2.15

version 1.172.2.21.2.10, 2003/03/20 14:34:01	version 1.172.2.21.2.15, 2003/03/21 13:42:32
Line 38 Table string_match_table_template(new St	Line 38 Table string_match_table_template(new St

// String::ArrayFragment methods	// String::ArrayFragment methods

String::ArrayFragment& String::ArrayFragment::append(const ArrayFragment& src,	void String::ArrayFragment::append_positions(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;

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.length;	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.length;	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.length)); // appending whole fragment	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));	append(Fragment(fragment.lang, substr_end-fragment_begin));
goto break2;	return;
}	}
}	}

break;	break;
}	}
break2:

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) {
}	}
*/	*/

	// StringSimple methods


	static int CORD_batched_iter_fn_generic_hash_code(const char* s, void * client_data) {
	uint& result=static_cast<uint>(client_data);
	generic_hash_code(result, s);
	return 0;
	};
	uint StringSimple::hash_code() const {
	uint result=0;
	CORD_iter5(body, 0, 0, CORD_batched_iter_fn_generic_hash_code, &result);
	return result;
	}

// String methods	// String methods

String::String(const char* cstr, size_t helper_length, bool tainted): body(CORD_EMPTY) {	String::String(const char* cstr, size_t helper_length, bool tainted): body(CORD_EMPTY) {
append_cstr(cstr, helper_length, tainted?UL_TAINTED:UL_CLEAN);	append(cstr, helper_length, tainted?L_TAINTED:L_CLEAN);
}	}

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

String& String::append_cstr(const char* heap_variable, size_t helper_length, Untaint_lang lang) {	String& String::append(const char* str, size_t helper_length, Language lang) {
if(!heap_variable)	if(!str)
return *this;
size_t use_length;
if(helper_length) {
#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;

body=CORD_cat_char_star(body, heap_variable, length);
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;	return *this;
size_t use_length=helper_length?helper_length:strlen(auto_variable);	size_t use_length=helper_length?helper_length:strlen(str);
if(!use_length)	if(!use_length)
return *this;	return *this;

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

return *this;	return *this;
}	}

static int CORD_batched_iter_fn_generic_hash_code(const char* s, void * client_data) {	/// @todo check in doc: whether it documents NOW bad situation "abc".mid(-1, 3) =were?="ab"
uint& result=static_cast<uint>(client_data);	const String& String::mid(size_t substr_begin, size_t substr_end) const {
generic_hash_code(result, s);
return 0;
};
uint String::hash_code() const {
uint result=0;
CORD_iter5(body, 0, 0, CORD_batched_iter_fn_generic_hash_code, &result);
return result;
}

const String& String::mid(size_t substr_start, size_t substr_end) const {
String& result=*new String;	String& result=*new String;

substr_start=min(substr_start, length());	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_positions(fragments, substr_begin, substr_end);

// SAPI::log(pool(), "piece of '%s' from %d to %d is '%s'",	// SAPI::log("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, Language 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==L_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.length;	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;
	if(substr_begin>=fragment_end) // begin of substr OUT of current fragment?
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?
break;	throw Exception(0, // (*) see below
	this,
	"searching for '%s' starting from %ud problem: found begin in one fragment, but end in another",
	CORD_to_const_char_star(substr), this_offset);

return fragment.lang==lang?substr_end:STRING_NOT_FOUND;	if(fragment.lang==lang)
	return substr_begin;
	else { // bad lang...
	/// WARNING: this possibly skips assert (*), but it's fast
	substr_begin=CORD_str(body, fragment_end/...search AFTER for more/, substr);
	if(substr_begin==CORD_NOT_FOUND)
	return STRING_NOT_FOUND;

	size_t substr_end=substr_begin+CORD_len(substr);
	// and continuing with next fragment
	}
}	}

return STRING_NOT_FOUND;	return STRING_NOT_FOUND;
}	}

size_t String::pos(const String& substr,	size_t String::pos(const String& substr,
size_t this_offset, Untaint_lang lang) const {	size_t this_offset, Language lang) const {
return pos(substr.body, this_offset, lang);	return pos(substr.body, this_offset, lang);
}	}

void String::split(ArrayString& result,	void String::split(ArrayString& result,
size_t& pos_after,	size_t& pos_after,
const char* delim,	const char* delim,
Untaint_lang lang, int limit) {	Language lang, int limit) {
size_t self_length=length();	size_t self_length=length();
if(size_t delim_length=strlen(delim)) {	if(size_t delim_length=strlen(delim)) {
int pos_before;	int pos_before;
Line 218 void String::split(ArrayString& result,	Line 211 void String::split(ArrayString& result,

void String::split(ArrayString& result,	void String::split(ArrayString& result,
size_t& pos_after,	size_t& pos_after,
const String& delim, Untaint_lang lang,	const String& delim, Language lang,
int limit) const {	int limit) const {
if(delim) {	if(!delim.is_empty()) {
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--) {
Line 257 static void regex_options(const String&	Line 250 static void regex_options(const String&
result[0]=PCRE_EXTRA \| PCRE_DOTALL \| PCRE_DOLLAR_ENDONLY;	result[0]=PCRE_EXTRA \| PCRE_DOTALL \| PCRE_DOLLAR_ENDONLY;
result[1]=0;	result[1]=0;

if(options)	if(!options.is_empty())
for(Regex_option *o=regex_option; o->keyL; o++)	for(Regex_option *o=regex_option; o->keyL; o++)
if(options.pos(o->keyL)>=0	if(options.pos(o->keyL)>=0
\|\| (o->keyU && options.pos(o->keyU)>=0)) {	\|\| (o->keyU && options.pos(o->keyU)>=0)) {
Line 275 Table* String::match(Charset& source_cha	Line 268 Table* String::match(Charset& source_cha
const String& options,	const String& options,
Row_action row_action, void *info,	Row_action row_action, void *info,
bool& just_matched) const {	bool& just_matched) const {
if(!regexp)	if(regexp.is_empty())
throw Exception(0,	throw Exception(0,
0,	0,
"regexp is empty");	"regexp is empty");
Line 409 String& String::change_case(Charset& sou	Line 402 String& String::change_case(Charset& sou
*dest++=(char)c;	*dest++=(char)c;
}	}
result.body=new_cstr;	result.body=new_cstr;
result.fragments.append(fragments, 0, fragments.count());	result.fragments.append(fragments);

return result;	return result;
}	}
Line 417 String& String::change_case(Charset& sou	Line 410 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_length=current-prematch_start) {	if(size_t prematch_length=current-prematch_begin) {
result.body=CORD_cat_char_star(result.body, prematch_start, prematch_length);	result.body=CORD_cat_char_star(result.body, prematch_begin, prematch_length);
result.fragments.append(fragments, prematch_start-old_cstr, prematch_length);	result.fragments.append_positions(fragments, prematch_begin-old_cstr, current-old_cstr);
}	}

// 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->length(); 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_length=b->length()) {	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);
}	}
}	}
} else // simply advance	} else // simply advance
Line 445 const String& String::replace(const Dict	Line 438 const String& String::replace(const Dict
}	}

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

return result;	return result;
Line 531 static int CORD_batched_iter_fn_append(c	Line 524 static int CORD_batched_iter_fn_append(c
String::C String::serialize(size_t prolog_length) const {	String::C String::serialize(size_t prolog_length) const {
size_t buf_length=	size_t buf_length=
prolog_length	prolog_length
+fragments.count()*(sizeof(Untaint_lang)+sizeof(size_t))	+fragments.count()*(sizeof(Language)+sizeof(size_t))
+length();	+length();
C result(new(PointerFreeGC) char[buf_length], buf_length);	C result(new(PointerFreeGC) char[buf_length], buf_length);

Line 574 bool String::deserialize(size_t prolog_l	Line 567 bool String::deserialize(size_t prolog_l
// 3: lang info	// 3: 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++) {
size_t piece_length=sizeof(Untaint_lang)+sizeof(size_t);	size_t piece_length=sizeof(Language)+sizeof(size_t);
if(buf_length<piece_length) // lang+length	if(buf_length<piece_length) // lang+length
return false;	return false;

Untaint_lang lang=reinterpret_cast<const Untaint_lang >(cur); cur+=sizeof(Untaint_lang);	Language lang=reinterpret_cast<const Language >(cur); cur+=sizeof(Language);
size_t fragment_length=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_length);	fragments+=Fragment(lang, fragment_length);
total_length+=fragment_length;	total_length+=fragment_length;

E-mail:

Removed from v.1.172.2.21.2.10
changed lines
	Added in v.1.172.2.21.2.15