--- parser3/src/main/pa_string.C 2003/03/20 15:39:03 1.172.2.21.2.12 +++ parser3/src/main/pa_string.C 2004/05/26 08:25:55 1.198 @@ -1,11 +1,11 @@ /** @file Parser: string class. @see untalength_t.C. - Copyright (c) 2001-2003 ArtLebedev Group (http://www.artlebedev.com) + Copyright (c) 2001-2004 ArtLebedev Group (http://www.artlebedev.com) Author: Alexandr Petrosian (http://paf.design.ru) */ -static const char* IDENT_STRING_C="$Date: 2003/03/20 15:39:03 $"; +static const char * const IDENT_STRING_C="$Date: 2004/05/26 08:25:55 $"; #include "pcre.h" @@ -15,6 +15,108 @@ static const char* IDENT_STRING_C="$Date #include "pa_dictionary.h" #include "pa_charset.h" +const String String::Empty; + +int pa_atoi(const char* str, const String* problem_source) { + if(!str) + return 0; + + while(*str && isspace(*str)) + str++; + if(!*str) + return 0; + + int result; + char *error_pos; + // 0xABC + if(str[0]=='0') + if(str[1]=='x' || str[1]=='X') + result=(int)(unsigned long)strtol(str, &error_pos, 0); + else { + // skip leading 0000, to disable octal interpretation + do str++; while(*str=='0'); + result=(int)strtol(str, &error_pos, 0); + } + else + result=(int)strtol(str, &error_pos, 0); + + while(char c=*error_pos++) + if(!isspace(c)) + throw Exception("number.format", + problem_source, + problem_source?"invalid number (int)": "'%s' is invalid number (int)", str); + + return result; +} + +double pa_atod(const char* str, const String* problem_source) { + if(!str) + return 0; + + while(*str && isspace(*str)) + str++; + if(!*str) + return 0; + + double result; + char *error_pos; + // 0xABC + if(str[0]=='0') + if(str[1]=='x' || str[1]=='X') + result=(double)(unsigned long)strtol(str, &error_pos, 0); + else + result=(double)strtod(str+1/*skip leading 0*/, &error_pos); + else + result=(double)strtod(str, &error_pos); + + while(char c=*error_pos++) + if(!isspace(c)) + throw Exception("number.format", + problem_source, + problem_source?"invalid number (double)": "'%s' is invalid number (double)", str); + + return result; +} + +// cord lib extension + +#ifndef DOXYGEN +typedef struct { + ssize_t countdown; + char target; /* Character we're looking for */ +} chr_data; +#endif +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; + + if (d -> countdown<=0) return(2); + d -> countdown -= size; + if (c > d -> target) return(1); + return(0); +} +int CORD_range_contains_chr_greater_then(CORD x, size_t i, size_t n, int c) +{ + chr_data d; + + d.countdown = n; + d.target = c; + 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 /// String::match uses this as replace & global search table columns @@ -28,199 +130,185 @@ public: *this+=new String("match"); *this+=new String("postmatch"); for(int i=0; i i(src); ; fragment_begin=fragment_end) { - const element_type& fragment=i.next(); - fragment_end=fragment_begin+fragment.length; - - if(fragment_beginfragment_end) { // are there more fragments including pieces of 'substr'? - fragment_begin=fragment_end; + size_t start=0; + size_t end=our_length; + // from left... + if(kind!=TRIM_END) { + CORD_pos pos; set_pos(pos, 0); + while(true) { + char c=CORD_pos_fetch(pos); + if(strchr(chars, c)) { + if(++start==our_length) + return 0; // all chars are empty, just return empty string + } else + break; - const element_type& fragment=i.next(); - fragment_end=fragment_begin+fragment.length; + CORD_next(pos); + } + } + // from right.. + if(kind!=TRIM_START) { + CORD_pos pos; set_pos(pos, end-1); + while(true) { + char c=CORD_pos_fetch(pos); + if(strchr(chars, c)) { + if(--end==0) // optimization: NO need to check for 'end>=start', that's(<) impossible + return 0; // all chars are empty, just return empty string + } else + break; - if(substr_end>fragment_end) // are there still more? - simple_append(Fragment(fragment.lang, fragment.length)); // appending whole fragment - else { // no, it was last - simple_append(Fragment(fragment.lang, substr_end-fragment_begin)); - goto break2; - } + CORD_prev(pos); } + } - break; - } -break2: - - return *this; + if(start==0 && end==our_length) // nobody moved a thing + return *this; + + if(out_start) + *out_start=start; + size_t new_length=end-start; + if(out_length) + *out_length=new_length; + + return mid(start, new_length); } -/* -void String::ArrayFragment::mid(ArrayFragment& result, size_t substr_begin, size_t substr_end) { + +static int CORD_batched_iter_fn_generic_hash_code(char c, void * client_data) { + uint& result=*static_cast(client_data); + generic_hash_code(result, c); + return 0; +} +static int CORD_batched_iter_fn_generic_hash_code(const char* s, void * client_data) { + uint& result=*static_cast(client_data); + generic_hash_code(result, s); + return 0; +}; +uint String::Body::hash_code() const { + uint result=0; + CORD_iter5(body, 0, + CORD_batched_iter_fn_generic_hash_code, + CORD_batched_iter_fn_generic_hash_code, &result); + return result; } -*/ // String methods 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_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::append_cstr(const char* heap_variable, size_t helper_length, Untaint_lang lang) { - if(!heap_variable) - 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) +String& String::append_know_length(const char* str, size_t known_length, Language lang) { + if(!known_length) return *this; - body=CORD_cat_char_star(body, heap_variable, length); - fragments+=Fragment(lang, length); + // first: langs + langs.append(body, lang, known_length); + // next: letters themselves + body.append_know_length(str, known_length); + ASSERT_STRING_INVARIANT(*this); return *this; } - -String& String::append_copy(const char* auto_variable, size_t helper_length, Untaint_lang lang) { - if(!auto_variable) +String& String::append_help_length(const char* str, size_t helper_length, Language lang) { + if(!str) return *this; - size_t use_length=helper_length?helper_length:strlen(auto_variable); - if(!use_length) + size_t known_length=helper_length?helper_length:strlen(str); + if(!known_length) return *this; - body=pa_strdup(auto_variable, use_length); - fragments+=Fragment(lang, use_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; -static int CORD_batched_iter_fn_generic_hash_code(const char* s, void * client_data) { - uint& result=*static_cast(client_data); - 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; + // first: langs + langs.append(body, lang, known_length); + // next: letters themselves + body.append_strdup_know_length(str, known_length); + + ASSERT_STRING_INVARIANT(*this); + return *this; } /// @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& String::mid(size_t substr_begin, size_t substr_end) const { String& result=*new String; 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); - if(substr_begin==substr_end) + size_t substr_length=substr_end-substr_begin; + if(!substr_length) return result; - // first: letters themselves - result.body=CORD_substr(body, substr_begin, substr_end-substr_begin); + // first: their langs + result.langs.append(result.body, langs, substr_begin, substr_length); + // next: letters themselves + result.body=body.mid(substr_begin, substr_length); - // next: their langs - result.fragments.append(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_begin, substr_end, result.cstr()); + ASSERT_STRING_INVARIANT(result); return result; } -size_t String::pos(CORD substr, - size_t this_offset, Untaint_lang lang) const { - // first: letters themselves - size_t substr_begin=CORD_str(body, this_offset, substr); - if(substr_begin==CORD_NOT_FOUND) - return STRING_NOT_FOUND; - - // next: check the lang when specified - - if(lang==UL_UNSPECIFIED) // ignore lang? - return substr_begin; - - // substr must be in one fragment, and fragments' lang must = lang - size_t substr_end=substr_begin+CORD_len(substr); - size_t fragment_begin=0; - size_t fragment_end; - for(Array_iterator i(fragments); i.has_next(); fragment_begin=fragment_end) { - const Fragment& fragment=i.next(); - fragment_end=fragment_begin+fragment.length; - - if(substr_begin=fragment_end) // begin of substr OUT of current fragment? - continue; +size_t String::pos(const String::Body substr, size_t this_offset, Language lang) const { + size_t substr_length=substr.length(); + while(true) { + size_t substr_begin=body.pos(substr, this_offset); - if(substr_end>fragment_end) // end of substr OUT of current fragment? - 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); + if(substr_begin==CORD_NOT_FOUND) + return STRING_NOT_FOUND; - if(fragment.lang==lang) + if(langs.check_lang(lang, substr_begin, substr_length)) 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; + this_offset=substr_begin+substr_length; + } } 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); } void String::split(ArrayString& result, - size_t& pos_after, - const char* delim, - Untaint_lang lang, int limit) { + size_t& pos_after, + const char* delim, + Language lang, int limit) const { size_t self_length=length(); if(size_t delim_length=strlen(delim)) { - int pos_before; + size_t pos_before; // 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); pos_after=pos_before+delim_length; } @@ -236,13 +324,13 @@ void String::split(ArrayString& result, } void String::split(ArrayString& result, - size_t& pos_after, - const String& delim, Untaint_lang lang, - int limit) const { - if(delim) { - int pos_before; + size_t& pos_after, + const String& delim, Language lang, + int limit) const { + if(!delim.is_empty()) { + size_t pos_before; // 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); pos_after=pos_before+delim.length(); } @@ -257,7 +345,7 @@ void String::split(ArrayString& result, } } -static void regex_options(const String& options, int *result, bool& need_pre_post_match){ +static void regex_options(const String* options, int *result, bool& need_pre_post_match){ struct Regex_option { const char* keyL; const char* keyU; @@ -265,21 +353,21 @@ static void regex_options(const String& int *result; bool *flag; } regex_option[]={ - {"i", "I", 0, PCRE_CASELESS, result}, // a=A - {"s", "S", 0, PCRE_DOTALL, result}, // \n\n$ [default] - {"x", "U", 0, PCRE_EXTENDED, result}, // whitespace in regex ignored - {"m", "M", PCRE_DOTALL, PCRE_MULTILINE, result}, // ^aaa\n$^bbb\n$ - {"g", "G", 0, true, result+1}, // many rows + {"i", "I", 0, PCRE_CASELESS, result, 0}, // a=A + {"s", "S", 0, PCRE_DOTALL, result, 0}, // \n\n$ [default] + {"x", "U", 0, PCRE_EXTENDED, result, 0}, // whitespace in regex ignored + {"m", "M", PCRE_DOTALL, PCRE_MULTILINE, result, 0}, // ^aaa\n$^bbb\n$ + {"g", "G", 0, 1, result+1, 0}, // many rows {"'", 0, 0, 0, 0, &need_pre_post_match}, - {0} + {0, 0, 0, 0, 0, 0} }; result[0]=PCRE_EXTRA | PCRE_DOTALL | PCRE_DOLLAR_ENDONLY; result[1]=0; - if(options) + if(options && !options->is_empty()) for(Regex_option *o=regex_option; o->keyL; o++) - if(options.pos(o->keyL)>=0 - || (o->keyU && options.pos(o->keyU)>=0)) { + if(options->pos(o->keyL)!=STRING_NOT_FOUND + || (o->keyU && options->pos(o->keyU)!=STRING_NOT_FOUND)) { if(o->flag) *o->flag=true; else { // result @@ -290,11 +378,11 @@ static void regex_options(const String& } Table* String::match(Charset& source_charset, - const String& regexp, - const String& options, - Row_action row_action, void *info, - bool& just_matched) const { - if(!regexp) + const String& regexp, + const String* options, + Row_action row_action, void *info, + bool& just_matched) const { + if(regexp.is_empty()) throw Exception(0, 0, "regexp is empty"); @@ -303,7 +391,7 @@ Table* String::match(Charset& source_cha const char* errptr; int erroffset; 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; pcre *code=pcre_compile(pattern, option_bits[0], &errptr, &erroffset, @@ -329,7 +417,8 @@ Table* String::match(Charset& source_cha int ovector[oveclength]; // 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 prestart=0; @@ -344,7 +433,7 @@ Table* String::match(Charset& source_cha pcre_free(code); row_action(table, 0/*last time, no raw*/, 0, 0, poststart, postfinish, info); if(global || subpatterns) - return table; // global or with subpatterns=true+result + return &table; // global or with subpatterns=true+result else { just_matched=false; return 0; // not global=no result } @@ -366,9 +455,9 @@ Table* String::match(Charset& source_cha *row+=&mid(prefinish, poststart); // .match *row+=&mid(poststart, postfinish); // .postmatch } else { - *row+=0; // .prematch column value - *row+=0; // .match - *row+=0; // .postmatch + *row+=&Empty; // .prematch column value + *row+=&Empty; // .match + *row+=&Empty; // .postmatch } for(int i=1; i(kind)); // never - a=b=0; // calm, compiler - break; // never - } + if(is_empty()) + return result; char* new_cstr=cstrm(); - char *dest=new_cstr; - unsigned char index; - for(const char* current=new_cstr; index=(unsigned char)*current; current++) { - unsigned char c=a[index]; - if(b) - c=b[c]; + size_t new_cstr_len=length(); + if(source_charset.isUTF8()) { + switch(kind) { + case CC_UPPER: + change_case_UTF8((const XMLByte*)new_cstr, new_cstr_len, (XMLByte*)new_cstr, new_cstr_len, UTF8CaseToUpper); + break; + case CC_LOWER: + change_case_UTF8((const XMLByte*)new_cstr, new_cstr_len, (XMLByte*)new_cstr, new_cstr_len, UTF8CaseToLower); + break; + default: + assert(!"unknown change case kind"); + break; // never + } + + } else { + const unsigned char *tables=source_charset.pcre_tables; - *dest++=(char)c; + 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 + } + + char *dest=new_cstr; + 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; + } } + result.langs=langs; result.body=new_cstr; - result.fragments.append(fragments, 0, fragments.count()); return result; } @@ -438,178 +542,170 @@ const String& String::replace(const Dict const char* old_cstr=cstr(); const char* prematch_begin=old_cstr; - for(const char* current=old_cstr; *current; ) { - if(Table::element_type row=dict.first_that_begins(current)) { + const char* current=old_cstr; + while(*current) { + if(Dictionary::Subst subst=dict.first_that_begins(current)) { // prematch if(size_t prematch_length=current-prematch_begin) { - result.body=CORD_cat_char_star(result.body, prematch_begin, prematch_length); - result.fragments.append(fragments, prematch_begin-old_cstr, prematch_length); + result.langs.append(result.body, langs, prematch_begin-old_cstr, prematch_length); + result.body.append_strdup_know_length(prematch_begin, prematch_length); } // match - - const String* a=row->get(0); // skip 'a' in 'current'; move prematch_begin - current+=a->length(); prematch_begin=current; + current+=subst.from_length; prematch_begin=current; - if(row->count()>1) { // are there any b? - const String* b=row->get(1); - if(size_t b_length=b->length()) { - result.body=CORD_cat(result.body, b->cstr_to_cord()); - result.fragments.append(b->fragments, 0, b->fragments.count()); - } - } + if(const String* b=subst.to) // are there any b? + result<<*b; } else // simply advance current++; } // postmatch - if(size_t prematch_length=current-prematch_begin) { - result.body=CORD_cat_char_star(result.body, prematch_begin, prematch_length); - result.fragments.append(fragments, prematch_begin-old_cstr, prematch_length); + if(size_t postmatch_length=current-prematch_begin) { + result.langs.append(result.body, langs, prematch_begin-old_cstr, postmatch_length); + result.body.append_strdup_know_length(prematch_begin, postmatch_length); } + ASSERT_STRING_INVARIANT(result); return result; } -double String::as_double() const { - double result; - const char *str=cstr(); - - while(*str && isspace(*str)) - str++; - if(!*str) - return 0; - - char *error_pos; - // 0xABC - if(str[0]=='0') - if(str[1]=='x' || str[1]=='X') - result=(double)(unsigned long)strtol(str, &error_pos, 0); - else - result=(double)strtod(str+1/*skip leading 0*/, &error_pos); - else - result=(double)strtod(str, &error_pos); - - while(char c=*error_pos++) - if(!isspace(c)) - throw Exception("number.format", - this, - "invalid number (double)"); - - return result; -} -int String::as_int() const { - int result; - const char *str=cstr(); - - while(*str && isspace(*str)) - str++; - if(!*str) - return 0; - - char *error_pos; - // 0xABC - if(str[0]=='0') - if(str[1]=='x' || str[1]=='X') - result=(int)(unsigned long)strtol(str, &error_pos, 0); - else - result=(int)strtol(str+1/*skip leading 0*/, &error_pos, 0); - else - result=(int)strtol(str, &error_pos, 0); - - while(char c=*error_pos++) - if(!isspace(c)) - throw Exception("number.format", - this, - "invalid number (int)"); - - return result; -} - -inline void uint2uchars(uint word, uchar *bytes) { - bytes[0]=word&0xFF; - bytes[1]=(word>>8)&0xFF; - 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 CORD_batched_iter_fn_append(const char* s, void* client_data) { - char*& cur=*static_cast(client_data); - +static int serialize_body_char(char c, char** cur) { + *((*cur)++)=c; + return 0; // 0=continue +}; +static int serialize_body_piece(const char* s, char** cur) { size_t length=strlen(s); - memcpy(cur, s, length); cur+=length; - return 0; + memcpy(*cur, s, length); *cur+=length; + return 0; // 0=continue }; -String::C String::serialize(size_t prolog_length) const { +static int serialize_lang_piece(char alang, size_t asize, char** cur) { + // lang + **cur=alang; (*cur)++; + // length [WARNING: not cast, addresses must be %4=0 on sparc] + memcpy(*cur, &asize, sizeof(asize)); *cur+=sizeof(asize); + + return 0; // 0=continue +} +String::Cm String::serialize(size_t prolog_length) const { + size_t fragments_count=langs.count(); size_t buf_length= - prolog_length - +fragments.count()*(sizeof(Untaint_lang)+sizeof(size_t)) - +length(); - C result(new(PointerFreeGC) char[buf_length], buf_length); + prolog_length //1 + +sizeof(size_t) //2 + +fragments_count*(sizeof(char)+sizeof(size_t)) //3 + +body.length() //4 + +1; // for zero terminator used in deserialize + String::Cm result(new(PointerFreeGC) char[buf_length], buf_length); // 1: prolog char *cur=result.str+prolog_length; - - - // 2: fragments.count - size_t fragments_count=fragments.count(); + // 2: langs.count [WARNING: not cast, addresses must be %4=0 on sparc] memcpy(cur, &fragments_count, sizeof(fragments_count)); cur+=sizeof(fragments_count); - // 3: lang info - for(Array_iterator i(fragments); i.has_next(); ) { - 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); - } - + langs.for_each(body, serialize_lang_piece, &cur); // 4: letters - CORD_iter5(body, 0, 0, CORD_batched_iter_fn_append, &cur); + body.for_each(serialize_body_char, serialize_body_piece, &cur); + // 5: zero terminator + *cur=0; return result; } -bool String::deserialize(size_t prolog_length, void *buf, size_t buf_length, const char* file) { +bool String::deserialize(size_t prolog_length, void *buf, size_t buf_length) { if(buf_length<=prolog_length) return false; buf_length-=prolog_length; + buf_length-=1; // 5: zero terminator // 1: prolog const char* cur=(const char* )buf+prolog_length; - // 2: fragments.count - if(buf_length(cur); cur+=sizeof(size_t); - buf_length-=sizeof(size_t); + // [WARNING: not cast, addresses must be %4=0 on sparc] + memcpy(&fragments_count, cur, sizeof(fragments_count)); cur+=sizeof(fragments_count); + buf_length-=sizeof(fragments_count); + + if(fragments_count) { + // 3: lang info + size_t total_length=0; + for(size_t f=0; f(cur); cur+=sizeof(Untaint_lang); - size_t fragment_length=*reinterpret_cast(cur); cur+=sizeof(size_t); - fragments+=Fragment(lang, fragment_length); - total_length+=fragment_length; + // 4: letters + if(buf_length!=total_length) + return false; - buf_length-=piece_length; + // serialize wrote extra zero byte there, we can rely on that + body=String::Body(cur, buf_length); } - // 4: letters - if(buf_length!=total_length) - return false; + ASSERT_STRING_INVARIANT(*this); + return true; +} + +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 { + const uint 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 + ); - body=CORD_cat_char_star(CORD_EMPTY, cur, buf_length); + return buf; +} - return true; +const String& String::trim(String::Trim_kind kind, const char* chars) const { + if(!length()) + return *this; + + size_t substr_begin, substr_length; + Body new_body=body.trim(kind, chars, &substr_begin, &substr_length); + if(new_body==body) // we received unchanged pointer, do likewise + return *this; + // new_body differs from body, adjust langs along + + String& result=*new String; + if(!new_body) // body.trim produced empty result + return result; + // body.trim produced nonempty result + + // first: their langs + result.langs.append(result.body, langs, substr_begin, substr_length); + // next: letters themselves + result.body=new_body; + + ASSERT_STRING_INVARIANT(result); + return result; }