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.35 and 1.172.2.21.2.43

version 1.172.2.21.2.35, 2003/04/02 10:10:01	version 1.172.2.21.2.43, 2003/07/22 08:20:24
Line 42 void String::ArrayFragment::append_posit	Line 42 void String::ArrayFragment::append_posit
if(substr_begin==substr_end)	if(substr_begin==substr_end)
return;	return;

	// FILE *err=fopen("append.log", "wt");

size_t fragment_begin=0;	size_t fragment_begin=0;
size_t fragment_end;	size_t fragment_end;
for(Array_iterator<element_type> i(src); ; fragment_begin=fragment_end) {	for(Array_iterator<element_type> i(src); ; fragment_begin=fragment_end) {
const element_type fragment=i.next();	const Fragment fragment=i.next();
fragment_end=fragment_begin+fragment.length;	fragment_end=fragment_begin+fragment.length;
	//fprintf(err, "1end=%u\n", fragment_end);fflush(err);

if(substr_begin<fragment_begin) // not reached fragments which may include 'substr'?	// not reached fragments which may include 'substr'?
continue;	if(!(substr_begin>=fragment_begin && substr_begin<fragment_end))

if(substr_begin>fragment_end) // 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);	if(substr_end<=fragment_end) // fits into first fragment?
*this+=Fragment(fragment.lang, piece_end-substr_begin);	*this+=Fragment(fragment.lang, substr_end-substr_begin);
	else { // spans more then one fragment
while(substr_end>fragment_end) { // are there more fragments including pieces of 'substr'?	*this+=Fragment(fragment.lang, fragment_end-substr_begin);
fragment_begin=fragment_end;	while(true) {
	const Fragment fragment=i.next();
const element_type fragment=i.next();	fragment_end=(fragment_begin=fragment_end)+fragment.length;
fragment_end=fragment_begin+fragment.length;	//fprintf(err, "2end=%u\n", fragment_end);fflush(err);

if(substr_end>fragment_end) // are there still more?	if(substr_end>fragment_end) // are there still more?
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
append(Fragment(fragment.lang, substr_end-fragment_begin));	append(Fragment(fragment.lang, substr_end-fragment_begin));
return;	//fclose(err);
	return;
	}
}	}
}	}

break;	break;
}	}
	//fclose(err);
}	}

// StringBody methods	// StringBody methods
Line 104 uint StringBody::hash_code() const {	Line 108 uint StringBody::hash_code() const {

// String methods	// String methods

String::String(const char* cstr, size_t help_length, bool tainted): body(CORD_EMPTY) {	String::String(const char* cstr, size_t helper_length, bool tainted): body(CORD_EMPTY) {
append_help_length(cstr, help_length, tainted?L_TAINTED:L_CLEAN);	append_help_length(cstr, helper_length, tainted?L_TAINTED:L_CLEAN);
	}
	String::String(const String::C cstr, bool tainted): body(CORD_EMPTY) {
	append_know_length(cstr.str, cstr.length, tainted?L_TAINTED:L_CLEAN);
}	}

String::String(const String& src): body(src.body) {	String::String(const String& src): body(src.body) {
fragments.append(src.fragments);	fragments.append(src.fragments);
	ASSERT_STRING_INVARIANT(*this);
}	}

	String& String::append_know_length(const char* str, size_t known_length, Language lang) {
	if(!known_length)
	return *this;

	body.append_know_length(str, known_length);
	fragments+=Fragment(lang, known_length);

	ASSERT_STRING_INVARIANT(*this);
	return *this;
	}
String& String::append_help_length(const char* str, size_t helper_length, Language lang) {	String& String::append_help_length(const char* str, size_t helper_length, Language lang) {
if(!str)	if(!str)
return *this;	return *this;
size_t use_length=helper_length?helper_length:strlen(str);	size_t known_length=helper_length?helper_length:strlen(str);
if(!use_length)	if(!known_length)
return *this;	return *this;

body.append_help_length(str, use_length);	return append_know_length(str, known_length, lang);
fragments+=Fragment(lang, use_length);

return *this;
}	}
String& String::append_strdup(const char* str, size_t length, Language lang) {	String& String::append_strdup(const char* str, size_t helper_length, Language lang) {
body.append_strdup(str, length);	size_t known_length=helper_length?helper_length:strlen(str);
fragments+=Fragment(lang, length);	if(!known_length)
	return *this;

	body.append_strdup_know_length(str, known_length);
	fragments+=Fragment(lang, known_length);

	ASSERT_STRING_INVARIANT(*this);
return *this;	return *this;
}	}

Line 136 String& String::mid(size_t substr_begin,	Line 156 String& String::mid(size_t substr_begin,
String& result=*new String;	String& result=*new String;

size_t self_length=length();	size_t self_length=length();
substr_begin=max(min(substr_begin, self_length), (size_t)0);	substr_begin=min(substr_begin, self_length);
substr_end=min(max(substr_end, substr_begin), self_length);	substr_end=min(max(substr_end, substr_begin), self_length);
if(substr_begin==substr_end)	if(substr_begin==substr_end)
return result;	return result;
Line 149 String& String::mid(size_t substr_begin,	Line 169 String& String::mid(size_t substr_begin,

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

Line 205 size_t String::pos(const String& substr,	Line 226 size_t String::pos(const String& substr,
}	}

void String::split(ArrayString& result,	void String::split(ArrayString& result,
size_t& pos_after,	size_t& pos_after,
const char* delim,	const char* delim,
Language lang, int limit) const {	Language lang, int limit) const {
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;
// 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))!=STRING_NOT_FOUND && limit; limit--) {
result+=&mid(pos_after, pos_before);	result+=&mid(pos_after, pos_before);
pos_after=pos_before+delim_length;	pos_after=pos_before+delim_length;
}	}
Line 228 void String::split(ArrayString& result,	Line 249 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, Language lang,	const String& delim, Language lang,
int limit) const {	int limit) const {
if(!delim.is_empty()) {	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))!=STRING_NOT_FOUND && limit; limit--) {
result+=&mid(pos_after, pos_before);	result+=&mid(pos_after, pos_before);
pos_after=pos_before+delim.length();	pos_after=pos_before+delim.length();
}	}
Line 270 static void regex_options(const String*	Line 291 static void regex_options(const String*

if(options && !options->is_empty())	if(options && !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)!=STRING_NOT_FOUND
\|\| (o->keyU && options->pos(o->keyU)>=0)) {	\|\| (o->keyU && options->pos(o->keyU)!=STRING_NOT_FOUND)) {
if(o->flag)	if(o->flag)
*o->flag=true;	*o->flag=true;
else { // result	else { // result
Line 282 static void regex_options(const String*	Line 303 static void regex_options(const String*
}	}

Table* String::match(Charset& source_charset,	Table* String::match(Charset& source_charset,
const String& regexp,	const String& regexp,
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.is_empty())	if(regexp.is_empty())
throw Exception(0,	throw Exception(0,
0,	0,
Line 321 Table* String::match(Charset& source_cha	Line 342 Table* String::match(Charset& source_cha
int ovector[oveclength];	int ovector[oveclength];

// create table	// create table
Table& table=*new Table(string_match_table_template);	Table::Action_options table_options;
	Table& table=*new Table(string_match_table_template, table_options);

int exec_option_bits=0;	int exec_option_bits=0;
int prestart=0;	int prestart=0;
Line 437 const String& String::replace(const Dict	Line 459 const String& String::replace(const Dict
if(Table::element_type row=dict.first_that_begins(current)) {	if(Table::element_type row=dict.first_that_begins(current)) {
// prematch	// prematch
if(size_t prematch_length=current-prematch_begin) {	if(size_t prematch_length=current-prematch_begin) {
result.body.append_strdup(prematch_begin, prematch_length);	result.body.append_strdup_know_length(prematch_begin, prematch_length);
result.fragments.append_positions(fragments, prematch_begin-old_cstr, current-old_cstr);	result.fragments.append_positions(fragments, prematch_begin-old_cstr, current-old_cstr);
}	}

Line 449 const String& String::replace(const Dict	Line 471 const String& String::replace(const Dict

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()) {	result<<*b;
result.body<<b->cstr_to_string_body();
result.fragments.append(b->fragments);
}
}	}
} else // simply advance	} else // simply advance
current++;	current++;
Line 460 const String& String::replace(const Dict	Line 479 const String& String::replace(const Dict

// postmatch	// postmatch
if(size_t postmatch_length=current-prematch_begin) {	if(size_t postmatch_length=current-prematch_begin) {
result.body.append_strdup(prematch_begin, postmatch_length);	result.body.append_strdup_know_length(prematch_begin, postmatch_length);
result.fragments.append_positions(fragments, prematch_begin-old_cstr, current-old_cstr);	result.fragments.append_positions(fragments, prematch_begin-old_cstr, current-old_cstr);
}	}

	ASSERT_STRING_INVARIANT(result);
return result;	return result;
}	}

Line 540 static int serialize_body_piece(const ch	Line 560 static int serialize_body_piece(const ch
memcpy(cur, s, length); cur+=length;	memcpy(cur, s, length); cur+=length;
return 0;	return 0;
};	};
String::C String::serialize(size_t prolog_length) const {	String::Cm String::serialize(size_t prolog_length) const {
size_t buf_length=	size_t buf_length=
prolog_length	prolog_length
+fragments.count()*(sizeof(Language)+sizeof(size_t))	+fragments.count()*(sizeof(Language)+sizeof(size_t))
+length();	+length();
C 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;
Line 582 bool String::deserialize(size_t prolog_l	Line 602 bool String::deserialize(size_t prolog_l
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_length-=sizeof(size_t);	buf_length-=sizeof(size_t);

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

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

// 3: lang info	buf_length-=piece_length;
size_t total_length=0;	}
for(size_t f=0; f<fragments_count; f++) {
size_t piece_length=sizeof(Language)+sizeof(size_t);
if(buf_length<piece_length) // lang+length
return false;

Language lang=reinterpret_cast<const Language >(cur); cur+=sizeof(Language);	// 4: letters
size_t fragment_length=reinterpret_cast<const size_t>(cur); cur+=sizeof(size_t);	if(buf_length!=total_length)
fragments+=Fragment(lang, fragment_length);	return false;
total_length+=fragment_length;

buf_length-=piece_length;	body=StringBody(cur, buf_length);
}	}

// 4: letters	ASSERT_STRING_INVARIANT(*this);
if(buf_length!=total_length)
return false;

body=CORD_cat_char_star(CORD_EMPTY, cur, buf_length);

return true;	return true;
}	}

E-mail:

Removed from v.1.172.2.21.2.35
changed lines
	Added in v.1.172.2.21.2.43