--- parser3/src/main/pa_string.C 2003/03/19 12:22:36 1.172.2.21.2.3 +++ parser3/src/main/pa_string.C 2003/03/20 15:05:58 1.172.2.21.2.11 @@ -1,11 +1,11 @@ /** @file - Parser: string class. @see untasize_t.C. + Parser: string class. @see untalength_t.C. Copyright (c) 2001-2003 ArtLebedev Group (http://www.artlebedev.com) Author: Alexandr Petrosian (http://paf.design.ru) */ -static const char* IDENT_STRING_C="$Date: 2003/03/19 12:22:36 $"; +static const char* IDENT_STRING_C="$Date: 2003/03/20 15:05:58 $"; #include "pcre.h" @@ -28,7 +28,7 @@ public: *this+=new String("match"); *this+=new String("postmatch"); for(int i=0; i i(src); ; fragment_start=fragment_end) { + for(Array_iterator i(src); ; fragment_begin=fragment_end) { const element_type& fragment=i.next(); - fragment_end=fragment_start+fragment.size; + fragment_end=fragment_begin+fragment.length; - if(substr_startfragment_end) { // are there more fragments including pieces of 'substr'? + fragment_begin=fragment_end; + const element_type& fragment=i.next(); - fragment_end=fragment_start+fragment.size; + fragment_end=fragment_begin+fragment.length; if(substr_end>fragment_end) // are there still more? - simple_append(Fragment(fragment.lang, fragment.size)); // appending whole fragment + simple_append(Fragment(fragment.lang, fragment.length)); // appending whole fragment else { // no, it was last - simple_append(Fragment(fragment.lang, substr_end-fragment_start)); + simple_append(Fragment(fragment.lang, substr_end-fragment_begin)); goto break2; } } @@ -75,39 +77,61 @@ 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) { } */ // String methods -String::String(const char* src, size_t src_size, bool tainted): body(CORD_EMPTY) { - if(src) - if(tainted) - APPEND_TAINTED(src, src_size, 0, 0); - else - APPEND_CLEAN(src, src_size, 0, 0); +String::String(const char* cstr, size_t helper_length, bool tainted): body(CORD_EMPTY) { + append_cstr(cstr, helper_length, tainted?UL_TAINTED:UL_CLEAN); } String::String(const String& src): body(src.body), fragments(src.fragments) {} -String& String::real_append(STRING_APPEND_PARAMS) { - if(!src) +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) + 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; - if(!size) - size=strlen(src); - if(!size) + size_t use_length=helper_length?helper_length:strlen(auto_variable); + if(!use_length) return *this; - body=CORD_cat_char_star(body, src, size); - fragments+=Fragment(lang, size); + body=pa_strdup(auto_variable, use_length); + fragments+=Fragment(lang, use_length); return *this; } -static int CORD_batched_iter_fn_generic_hash_code(const char * s, void * client_data) { +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; @@ -115,55 +139,57 @@ uint String::hash_code() const { return result; } -const String& String::mid(size_t substr_start, size_t substr_end) const { +/// @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& result=*new String; - substr_start=min(substr_start, size()); - substr_end=max(substr_start, substr_end); - if(substr_start==substr_end) + size_t self_length=length(); + substr_begin=max(min(substr_begin, self_length), (size_t)0); + substr_end=min(max(substr_end, substr_begin), self_length); + if(substr_begin==substr_end) return result; // 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 - result.fragments.append(fragments, substr_start, substr_end); + result.fragments.append(fragments, substr_begin, substr_end); // SAPI::log(pool(), "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; } size_t String::pos(CORD substr, size_t this_offset, Untaint_lang lang) const { // first: letters themselves - size_t substr_start=CORD_str(body, this_offset, substr); - if(substr_start==CORD_NOT_FOUND) - return NOT_FOUND; + 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_start; + return substr_begin; // substr must be in one fragment, and fragments' lang must = lang - size_t substr_end=substr_start+CORD_len(substr); - size_t fragment_start=0; + 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_start=fragment_end) { + for(Array_iterator i(fragments); i.has_next(); fragment_begin=fragment_end) { const Fragment& fragment=i.next(); - fragment_end=fragment_start+fragment.size; + fragment_end=fragment_begin+fragment.length; - if(substr_startfragment_end) // end of substr OUT of current fragment? break; - return fragment.lang==lang?substr_end:NOT_FOUND; + return fragment.lang==lang?substr_end:STRING_NOT_FOUND; } - return NOT_FOUND; + return STRING_NOT_FOUND; } size_t String::pos(const String& substr, @@ -175,22 +201,22 @@ void String::split(ArrayString& result, size_t& pos_after, const char* delim, Untaint_lang lang, int limit) { - size_t self_size=size(); - if(size_t delim_size=strlen(delim)) { + size_t self_length=length(); + if(size_t delim_length=strlen(delim)) { int pos_before; // while we have 'delim'... for(; (pos_before=pos(delim, pos_after, lang))>=0 && limit; limit--) { result+=&mid(pos_after, pos_before); - pos_after=pos_before+delim_size; + pos_after=pos_before+delim_length; } // last piece - if(pos_after=0 && limit; limit--) { result+=&mid(pos_after, pos_before); - pos_after=pos_before+delim.size(); + pos_after=pos_before+delim.length(); } // last piece - if(pos_after(kind)); // never @@ -375,11 +402,11 @@ String& String::change_case(Charset& sou break; // never } - C new_cstr=cstr(); - const char *end=new_cstr+new_cstr.size; + char* new_cstr=cstrm(); char *dest=new_cstr; - for(const char* current=new_cstr; currentget(0); size_t a_size=a->size(); - // skip 'a' in 'current', in fragment lang index && reduce work size - current+=a_size; old_pos+=a_size; remaining_size-=a_size; + // match - if(row->count()>1) { // are there any b? - const String* b=row->get(1); size_t b_size=b->size(); - if(b_size) { - // write 'b' to 'dest' && skip 'b' in 'dest' - b->store_to(dest, String::UL_AS_IS); dest+=b_size; + const String* a=row->get(0); + // skip 'a' in 'current'; move prematch_begin + current+=a->length(); prematch_begin=current; - // append match fragments + 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()); } } - } else { - // write a char to b && reduce work size - *dest++=*current++; remaining_size--; - } - } while(remaining_size); + } else // simply advance + current++; + } - { // postmatch - size_t now_pos=current-old_cstr; - if(now_pos!=old_pos) // have something at end? - result.fragments.append(fragments, old_pos, now_pos-old_pos); + // 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); } - result.body=new_cstr; return result; } -double String::as_double() { +double String::as_double() const { double result; - char buf[MAX_STRING]; - if(size()>MAX_STRING-1) - throw Exception("number.format", - this, - "invalid number too long a string (%u>%u)", size(), MAX_STRING-1); - char *eol=store_to(buf, String::UL_AS_IS); *eol=0; - const char* cstr=buf; - - while(*cstr && isspace(*cstr)) - cstr++; - if(!*cstr) + const char *str=cstr(); + + while(*str && isspace(*str)) + str++; + if(!*str) return 0; char *error_pos; // 0xABC - if(cstr[0]=='0') - if(cstr[1]=='x' || cstr[1]=='X') - result=(double)(unsigned long)strtol(cstr, &error_pos, 0); + if(str[0]=='0') + if(str[1]=='x' || str[1]=='X') + result=(double)(unsigned long)strtol(str, &error_pos, 0); else - result=(double)strtod(cstr+1/*skip leading 0*/, &error_pos); + result=(double)strtod(str+1/*skip leading 0*/, &error_pos); else - result=(double)strtod(cstr, &error_pos); + result=(double)strtod(str, &error_pos); while(char c=*error_pos++) if(!isspace(c)) @@ -473,30 +484,24 @@ double String::as_double() { return result; } -int String::as_int() { +int String::as_int() const { int result; - char buf[MAX_STRING]; - if(size()>MAX_STRING-1) - throw Exception("number.format", - this, - "invalid number too long a string (%u>%u)", size(), MAX_STRING-1); - char *eol=store_to(buf, String::UL_AS_IS); *eol=0; - const char* cstr=buf; - - while(*cstr && isspace(*cstr)) - cstr++; - if(!*cstr) + const char *str=cstr(); + + while(*str && isspace(*str)) + str++; + if(!*str) return 0; char *error_pos; // 0xABC - if(cstr[0]=='0') - if(cstr[1]=='x' || cstr[1]=='X') - result=(int)(unsigned long)strtol(cstr, &error_pos, 0); + if(str[0]=='0') + if(str[1]=='x' || str[1]=='X') + result=(int)(unsigned long)strtol(str, &error_pos, 0); else - result=(int)strtol(cstr+1/*skip leading 0*/, &error_pos, 0); + result=(int)strtol(str+1/*skip leading 0*/, &error_pos, 0); else - result=(int)strtol(cstr, &error_pos, 0); + result=(int)strtol(str, &error_pos, 0); while(char c=*error_pos++) if(!isspace(c)) @@ -520,52 +525,76 @@ inline uint uchars2uint(uchar *bytes) { | bytes[0]; } -void String::serializesize_t prolog_size, char *& buf, size_t& buf_size) const { - buf_size= - prolog_size - +fused*(sizeof(String_UL)+sizeof(size_t)) - +size(); - buf=new char[buf_size]; - char *cur=buf+prolog_size; +static int CORD_batched_iter_fn_append(const char* s, void* client_data) { + char*& cur=*static_cast(client_data); - STRING_FOREACH_FRAGMENT( + size_t length=strlen(s); + memcpy(cur, s, length); cur+=length; + return 0; +}; +String::C String::serialize(size_t prolog_length) const { + size_t buf_length= + prolog_length + +fragments.count()*(sizeof(Untaint_lang)+sizeof(size_t)) + +length(); + C 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(); + 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); - // size - // bug on some sparc platform [you can't work with integers on odd pointers] - // forces us to use byte array instead - uchar bytes[4]; - uint2uchars(fragment->size, bytes); - memcpy(cur, &bytes, sizeof(bytes)); cur+=sizeof(bytes); - // bytes - memcpy(cur, fragment->ptr, fragment->size); - cur+=fragment->size; - ); + 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 + CORD_iter5(body, 0, 0, CORD_batched_iter_fn_append, &cur); + + return result; } -bool String::deserialize(size_t prolog_size, void *buf, size_t buf_size, const char* file) { - if(buf_size<=prolog_size) +bool String::deserialize(size_t prolog_length, void *buf, size_t buf_length, const char* file) { + if(buf_length<=prolog_length) return false; + buf_length-=prolog_length; - char *cur=(char *)buf+prolog_size; - buf_size-=prolog_size; + // 1: prolog + const char* cur=(const char* )buf+prolog_length; - while(buf_size) { - if(sizeof(String_UL)+sizeof(size_t)>buf_size) // lang+size - return false; - - String_UL lang=*(String_UL *)(cur); - size_t size=uchars2uint((uchar *)cur); + // 2: fragments.count + if(buf_length(cur); cur+=sizeof(size_t); + buf_length-=sizeof(size_t); - size_t piece_size=sizeof(String_UL)+sizeof(size_t)+size; - if(piece_size>buf_size) // buffer overrun, can be on incomplete cache files + // 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; - cur+=piece_size; - buf_size-=piece_size; + buf_length-=piece_length; } + + // 4: letters + if(buf_length!=total_length) + return false; + + body=CORD_cat_char_star(CORD_EMPTY, cur, buf_length); + return true; }