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.25 and 1.172.2.21.2.40

version 1.172.2.21.2.25, 2003/03/24 15:56:59	version 1.172.2.21.2.40, 2003/04/11 16:05:43
Line 28 public:	Line 28 public:
*this+=new String("match");	*this+=new String("match");
*this+=new String("postmatch");	*this+=new String("postmatch");
for(int i=0; i<MAX_MATCH_GROUPS; i++) {	for(int i=0; i<MAX_MATCH_GROUPS; i++) {
char cname=new(PointerFreeGC) char[3/strlen("100")/+1/terminating 0*/];	*this+=new String(StringBody::Format(1+i), String::L_CLEAN);
*this+=new String(cname, sprintf(cname, "%d", 1+i));
}	}
}	}
};	};
Line 43 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'?
	if(!(substr_begin>=fragment_begin && substr_begin<=fragment_end))
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);
/*
void String::ArrayFragment::mid(ArrayFragment& result, size_t substr_begin, size_t substr_end) {
}	}
*/

// StringSimple methods	// StringBody methods

	StringBody StringBody::Format(int value) {
	char local[MAX_NUMBER];
	size_t length=snprintf(local, MAX_NUMBER, "%d", value);
	return StringBody(pa_strdup(local, length), 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);
Line 102 uint StringBody::hash_code() const {	Line 109 uint StringBody::hash_code() const {
// 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, helper_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), fragments(src.fragments) {}	String::String(const String& src): body(src.body) {
	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 \|\| !*str)
	return *this;

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

String& String::append(const char* str, size_t length, Language lang) {	ASSERT_STRING_INVARIANT(*this);
	return *this;
	}
	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=length?length:strlen(str);	size_t known_length=helper_length?helper_length:strlen(str);
if(!use_length)	if(!known_length)
	return *this;

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

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

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

Line 125 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 138 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 158 size_t String::pos(const StringBody subs	Line 190 size_t String::pos(const StringBody subs
size_t fragment_begin=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_begin=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_begin+fragment.length;	fragment_end=fragment_begin+fragment.length;

if(substr_begin<fragment_begin) // not reached fragments which may include 'result'?	if(substr_begin<fragment_begin) // not reached fragments which may include 'result'?
Line 194 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;
Line 217 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'...
Line 271 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 284 Table* String::match(Charset& source_cha	Line 316 Table* String::match(Charset& source_cha
const char* errptr;	const char* errptr;
int erroffset;	int erroffset;
bool need_pre_post_match=false;	bool need_pre_post_match=false;
int option_bits[2]; regex_options(options, option_bits, need_pre_post_match);	int option_bits[2]={0}; regex_options(options, option_bits, need_pre_post_match);
bool global=option_bits[1]!=0;	bool global=option_bits[1]!=0;
pcre *code=pcre_compile(pattern, option_bits[0],	pcre *code=pcre_compile(pattern, option_bits[0],
&errptr, &erroffset,	&errptr, &erroffset,
Line 310 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 375 Table* String::match(Charset& source_cha	Line 408 Table* String::match(Charset& source_cha

String& String::change_case(Charset& source_charset, Change_case_kind kind) const {	String& String::change_case(Charset& source_charset, Change_case_kind kind) const {
String& result=*new String();	String& result=*new String();
	if(is_empty())
	return result;

const unsigned char *tables=source_charset.pcre_tables;	const unsigned char *tables=source_charset.pcre_tables;

Line 419 const String& String::replace(const Dict	Line 454 const String& String::replace(const Dict
const char* old_cstr=cstr();	const char* old_cstr=cstr();
const char* prematch_begin=old_cstr;	const char* prematch_begin=old_cstr;

for(const char* current=old_cstr; *current; ) {	const char* current=old_cstr;
	while(*current) {
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(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 435 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.append(b->cstr_to_string_body());
result.fragments.append(b->fragments);
}
}	}
} else // simply advance	} else // simply advance
current++;	current++;
Line 446 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(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 526 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 543 String::C String::serialize(size_t prolo	Line 577 String::C String::serialize(size_t prolo

// 3: lang info	// 3: lang info
for(Array_iterator<ArrayFragment::element_type> i(fragments); i.has_next(); ) {	for(Array_iterator<ArrayFragment::element_type> i(fragments); i.has_next(); ) {
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);
// length	// length
Line 568 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.25
changed lines
	Added in v.1.172.2.21.2.40