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.175.2.1 and 1.181

version 1.175.2.1, 2003/09/23 09:54:28	version 1.181, 2003/09/29 09:42:12
Line 23 typedef struct {	Line 23 typedef struct {
char target; /* Character we're looking for */	char target; /* Character we're looking for */
} chr_data;	} chr_data;
#endif	#endif
static int CORD_nnchr_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)
{	{
register chr_data * d = (chr_data *)client_data;	register chr_data * d = (chr_data *)client_data;

if (d -> countdown<=0) return(2);	if (d -> countdown<=0) return(2);
d -> countdown -= size;	d -> countdown -= size;
if (c != d -> target) return(1);	if (c > d -> target) return(1);
return(0);	return(0);
}	}
int CORD_nnchr(CORD x, size_t i, size_t n, int not_c)	int CORD_range_contains_chr_greater_then(CORD x, size_t i, size_t n, int c)
{	{
chr_data d;	chr_data d;

d.countdown = i+n;	d.countdown = n;
d.target = not_c;	d.target = c;
return(CORD_block_iter(x, i, CORD_nnchr_proc, &d) == 1/alternatives: 0 normally ended, 2=struck 'n'/);	return(CORD_block_iter(x, i, CORD_range_contains_chr_greater_then_proc, &d) == 1/alternatives: 0 normally ended, 2=struck 'n'/);
	}

	static int CORD_block_count_proc(char c, size_t size, void* client_data)
	{
	int* result=(int*)client_data;
	(*result)++;
	return(0); // 0=continue
	}
	size_t CORD_block_count(CORD x)
	{
	size_t result=0;
	CORD_block_iter(x, 0, CORD_block_count_proc, &result);
	return result;
}	}

// helpers	// helpers
Line 54 public:	Line 67 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++) {
*this+=new String(StringBody::Format(1+i), String::L_CLEAN);	*this+=new String(String::Body::Format(1+i), String::L_CLEAN);
}	}
}	}
};	};

Table string_match_table_template(new String_match_table_template_columns);	Table string_match_table_template(new String_match_table_template_columns);

// StringBody methods	// String::Body methods

StringBody StringBody::Format(int value) {	String::Body String::Body::Format(int value) {
char local[MAX_NUMBER];	char local[MAX_NUMBER];
size_t length=snprintf(local, MAX_NUMBER, "%d", value);	size_t length=snprintf(local, MAX_NUMBER, "%d", value);
return StringBody(pa_strdup(local, length), length);	return String::Body(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) {
Line 79 static int CORD_batched_iter_fn_generic_	Line 92 static int CORD_batched_iter_fn_generic_
generic_hash_code(result, s);	generic_hash_code(result, s);
return 0;	return 0;
};	};
uint StringBody::hash_code() const {	uint String::Body::hash_code() const {
uint result=0;	uint result=0;
CORD_iter5(body, 0,	CORD_iter5(body, 0,
CORD_batched_iter_fn_generic_hash_code,	CORD_batched_iter_fn_generic_hash_code,
Line 105 String& String::append_know_length(const	Line 118 String& String::append_know_length(const
// next: letters themselves	// next: letters themselves
body.append_know_length(str, known_length);	body.append_know_length(str, known_length);

	ASSERT_STRING_INVARIANT(*this);
return *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) {
Line 126 String& String::append_strdup(const char	Line 140 String& String::append_strdup(const char
// next: letters themselves	// next: letters themselves
body.append_strdup_know_length(str, known_length);	body.append_strdup_know_length(str, known_length);

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

Line 136 String& String::mid(size_t substr_begin,	Line 151 String& String::mid(size_t substr_begin,
size_t self_length=length();	size_t self_length=length();
substr_begin=min(substr_begin, self_length);	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)	size_t substr_length=substr_end-substr_begin;
	if(!substr_length)
return result;	return result;

// first: their langs	// first: their langs
result.langs.append(result.body, langs, substr_begin, substr_end);	result.langs.append(result.body, langs, substr_begin, substr_length);
// next: letters themselves	// next: letters themselves
result.body=body.mid(substr_begin, substr_end-substr_begin);	result.body=body.mid(substr_begin, substr_length);

// 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;
}	}

size_t String::pos(const StringBody substr, size_t this_offset, Language lang) const {	size_t String::pos(const String::Body substr, size_t this_offset, Language lang) const {
size_t substr_begin=body.pos(substr, this_offset);	size_t substr_begin=body.pos(substr, this_offset);
if(substr_begin==CORD_NOT_FOUND \|\| !langs.check_lang(lang, this_offset, substr.length()))	if(substr_begin==CORD_NOT_FOUND \|\| !langs.check_lang(lang, substr_begin, substr.length()))
return STRING_NOT_FOUND;	return STRING_NOT_FOUND;

return substr_begin;	return substr_begin;
Line 348 String& String::change_case(Charset& sou	Line 365 String& String::change_case(Charset& sou
if(is_empty())	if(is_empty())
return result;	return result;

const unsigned char *tables=source_charset.pcre_tables;

const unsigned char *a;
const unsigned char *b;
switch(kind) {
case CC_UPPER:
a=tables+lcc_offset;
b=tables+fcc_offset;
break;
case CC_LOWER:
a=tables+lcc_offset;
b=0;
break;
default:
throw Exception(0,
this,
"unknown change case kind #%d",
static_cast<int>(kind)); // never
a=b=0; // calm, compiler
break; // never
}

char* new_cstr=cstrm();	char* new_cstr=cstrm();
char *dest=new_cstr;	char *dest=new_cstr;
unsigned char index;	if(source_charset.isUTF8()) {
for(const char* current=new_cstr; index=(unsigned char)*current; current++) {	switch(kind) {
unsigned char c=a[index];	case CC_UPPER:
if(b)	change_case_UTF8((const XMLByte)new_cstr, (XMLByte)new_cstr, UTF8CaseToUpper);
c=b[c];	break;
	case CC_LOWER:
	change_case_UTF8((const XMLByte)new_cstr, (XMLByte)new_cstr, UTF8CaseToLower);
	break;
	default:
	assert(!"unknown change case kind");
	break; // never
	}

	} else {
	const unsigned char *tables=source_charset.pcre_tables;

	const unsigned char *a;
	const unsigned char *b;
	switch(kind) {
	case CC_UPPER:
	a=tables+lcc_offset;
	b=tables+fcc_offset;
	break;
	case CC_LOWER:
	a=tables+lcc_offset;
	b=0;
	break;
	default:
	assert(!"unknown change case kind");
	a=b=0; // calm, compiler
	break; // never
	}

	unsigned char index;
	for(const char* current=new_cstr; index=(unsigned char)*current; current++) {
	unsigned char c=a[index];
	if(b)
	c=b[c];

*dest++=(char)c;	*dest++=(char)c;
	}
}	}
result.langs=langs;	result.langs=langs;
result.body=new_cstr;	result.body=new_cstr;
Line 396 const String& String::replace(const Dict	Line 425 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.langs.append(result.body, langs, prematch_begin-old_cstr, current-old_cstr);	result.langs.append(result.body, langs, prematch_begin-old_cstr, prematch_length);
result.body.append_strdup_know_length(prematch_begin, prematch_length);	result.body.append_strdup_know_length(prematch_begin, prematch_length);
}	}

Line 416 const String& String::replace(const Dict	Line 445 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.langs.append(result.body, langs, prematch_begin-old_cstr, current-old_cstr);	result.langs.append(result.body, langs, prematch_begin-old_cstr, postmatch_length);
result.body.append_strdup_know_length(prematch_begin, postmatch_length);	result.body.append_strdup_know_length(prematch_begin, postmatch_length);
}	}

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

Line 478 int String::as_int() const {	Line 508 int String::as_int() const {
return result;	return result;
}	}

inline void uint2uchars(uint word, uchar *bytes) {	static int serialize_body_char(char c, char** cur) {
bytes[0]=word&0xFF;	((cur)++)=c;
bytes[1]=(word>>8)&0xFF;	return 0; // 0=continue
bytes[2]=(word>>16)&0xFF;	};
bytes[3]=(word>>24)&0xFF;
}
inline uint uchars2uint(uchar *bytes) {
return bytes[3]<<24
\| bytes[2]<<16
\| bytes[1]<<8
\| bytes[0];
}

static int serialize_body_piece(const char* s, char** cur) {	static int serialize_body_piece(const char* s, char** cur) {
size_t length=strlen(s);	size_t length=strlen(s);
memcpy(cur, s, length); cur+=length;	memcpy(cur, s, length); cur+=length;
return 0;	return 0; // 0=continue
};	};
	static int serialize_lang_piece(char alang, size_t asize, char** cur) {
	// lang
	memcpy(cur, &alang, sizeof(alang)); cur+=sizeof(alang);
	// length
	memcpy(cur, &asize, sizeof(asize)); cur+=sizeof(asize);

	return 0; // 0=continue
	}
String::Cm String::serialize(size_t prolog_length) const {	String::Cm String::serialize(size_t prolog_length) const {
#if TODO	size_t fragments_count=langs.count();
//_asm int 3;
size_t buf_length=	size_t buf_length=
prolog_length	prolog_length //1
+sizeof(size_t)	+sizeof(size_t) //2
+langs.count()*(sizeof(Language)+sizeof(size_t))	+fragments_count*(sizeof(char)+sizeof(size_t)) //3
+length();	+body.length() //4
	+1; // for zero terminator used in deserialize
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	// 2: langs.count
size_t fragments_count=langs.count();
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	// 3: lang info
for(Array_iterator<ArrayFragment::element_type> i(langs); i.has_next(); ) {	langs.for_each(body, serialize_lang_piece, &cur);
const Fragment fragment=i.next();
// lang
memcpy(cur, &fragment.lang, sizeof(fragment.lang)); cur+=sizeof(fragment.lang);
// length
memcpy(cur, &fragment.length, sizeof(fragment.length)); cur+=sizeof(fragment.length);
}

// 4: letters	// 4: letters
body.for_each(serialize_body_piece, &cur);	body.for_each(serialize_body_char, serialize_body_piece, &cur);
	// 5: zero terminator already there put by new(PointerFreeGC)

return result;	return result;
#endif
return String::Cm(0, 0);
}	}
bool String::deserialize(size_t prolog_length, void *buf, size_t buf_length) {	bool String::deserialize(size_t prolog_length, void *buf, size_t buf_length) {
#if TODO
if(buf_length<=prolog_length)	if(buf_length<=prolog_length)
return false;	return false;
buf_length-=prolog_length;	buf_length-=prolog_length;
	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_length;
Line 549 bool String::deserialize(size_t prolog_l	Line 566 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(Language)+sizeof(size_t);	size_t piece_length=sizeof(char)+sizeof(size_t);
if(buf_length<piece_length) // lang+length	if(buf_length<piece_length) // lang+length
return false;	return false;

Language lang=reinterpret_cast<const Language >(cur); cur+=sizeof(Language);	Language lang=reinterpret_cast<const Language >(cur); cur+=sizeof(char);
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);
langs+=Fragment(lang, fragment_length);	langs.append(total_length, lang, fragment_length);
total_length+=fragment_length;	total_length+=fragment_length;

buf_length-=piece_length;	buf_length-=piece_length;
Line 565 bool String::deserialize(size_t prolog_l	Line 582 bool String::deserialize(size_t prolog_l
if(buf_length!=total_length)	if(buf_length!=total_length)
return false;	return false;

body=StringBody(cur, buf_length);	// serialize wrote extra zero byte there, we can rely on that
	body=String::Body(cur, buf_length);
}	}

ASSERT_STRING_INVARIANT(*this);	ASSERT_STRING_INVARIANT(*this);
return true;	return true;
#endif	}
return false;
	const char* String::Body::v() const {
	return CORD_to_const_char_star(body);
	}
	const char* String::Languages::v() const {
	if(opt.is_not_just_lang)
	return CORD_to_const_char_star(langs);
	else
	return (const char*)&langs;
	}
	const char* String::v() const {
	#define LIMIT_VIEW 20
	char* buf=(char*)malloc(MAX_STRING);
	const char*body_view=body.v();
	const char*langs_view=langs.v();
	snprintf(buf, MAX_STRING,
	"%d:%.*s%s} "
	"{%d:%s",
	langs.count(), LIMIT_VIEW, langs_view, strlen(langs_view)>LIMIT_VIEW?"...":"",
	strlen(body_view), body_view
	);

	return buf;
	#undef LIMIT_VIEW
}	}

E-mail:

Removed from v.1.175.2.1
changed lines
	Added in v.1.181