--- parser3/src/main/pa_string.C 2003/03/20 13:09:54 1.172.2.21.2.8 +++ parser3/src/main/pa_string.C 2003/07/24 11:31:24 1.174 @@ -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/20 13:09:54 $"; +static const char* IDENT_STRING_C="$Date: 2003/07/24 11:31:24 $"; #include "pcre.h" @@ -28,8 +28,7 @@ public: *this+=new String("match"); *this+=new String("postmatch"); for(int i=0; i i(src); ; fragment_start=fragment_end) { - const element_type& fragment=i.next(); - fragment_end=fragment_start+fragment.size; + for(Array_iterator i(src); ; fragment_begin=fragment_end) { + const Fragment fragment=i.next(); + fragment_end=fragment_begin+fragment.length; + //fprintf(err, "1end=%u\n", fragment_end);fflush(err); - if(substr_start=fragment_begin && substr_beginfragment_end) { // are there more fragments including pieces of 'substr'? - const element_type& fragment=i.next(); - fragment_end=fragment_start+fragment.size; - - if(substr_end>fragment_end) // are there still more? - simple_append(Fragment(fragment.lang, fragment.size)); // appending whole fragment - else { // no, it was last - simple_append(Fragment(fragment.lang, substr_end-fragment_start)); - goto break2; + if(substr_end<=fragment_end) // fits into first fragment? + *this+=Fragment(fragment.lang, substr_end-substr_begin); + else { // spans more then one fragment + *this+=Fragment(fragment.lang, fragment_end-substr_begin); + while(true) { + const Fragment fragment=i.next(); + fragment_end=(fragment_begin=fragment_end)+fragment.length; + //fprintf(err, "2end=%u\n", fragment_end);fflush(err); + + if(substr_end>fragment_end) // are there still more? + append(Fragment(fragment.lang, fragment.length)); // appending whole fragment + else { // no, it was last + append(Fragment(fragment.lang, substr_end-fragment_begin)); + //fclose(err); + return; + } } } break; - } -break2: - - return *this; + } + //fclose(err); } -/* -void String::ArrayFragment::mid(ArrayFragment& result, size_t substr_start, size_t substr_end) { + +// 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) { + 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 StringBody::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* src, size_t src_size, bool tainted): body(CORD_EMPTY) { - if(src) - if(tainted) - APPEND_TAINTED(src, src_size); - else - APPEND_CLEAN(src, src_size); +String::String(const char* cstr, size_t helper_length, bool tainted): body(CORD_EMPTY) { + 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(const char* src, size_t size, Untaint_lang lang) { - if(!src) - return *this; - if(!size) - size=strlen(src); - if(!size) +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, src, size); - fragments+=Fragment(lang, size); + 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) { + if(!str) + return *this; + size_t known_length=helper_length?helper_length:strlen(str); + 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; -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; + body.append_strdup_know_length(str, known_length); + fragments+=Fragment(lang, known_length); + + ASSERT_STRING_INVARIANT(*this); + return *this; } -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" +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=min(substr_begin, self_length); + 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=body.mid(substr_begin, substr_end-substr_begin); // next: their langs - result.fragments.append(fragments, substr_start, substr_end); + result.fragments.append_positions(fragments, substr_begin, substr_end); -// SAPI::log(pool(), "piece of '%s' from %d to %d is '%s'", - //cstr(), substr_start, substr_end, result.cstr()); +// 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 { +size_t String::pos(const StringBody substr, + size_t this_offset, Language lang) const { // first: letters themselves - size_t substr_start=CORD_str(body, this_offset, substr); - if(substr_start==CORD_NOT_FOUND) + size_t substr_begin=body.pos(substr, this_offset); + 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; + if(lang==L_UNSPECIFIED) // ignore lang? + 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+substr.length(); + size_t fragment_begin=0; size_t fragment_end; - for(Array_iterator i(fragments); i.has_next(); fragment_start=fragment_end) { - const Fragment& fragment=i.next(); - fragment_end=fragment_start+fragment.size; + 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_start=fragment_end) // begin of substr OUT of current fragment? continue; if(substr_end>fragment_end) // end of substr OUT of current fragment? - break; + throw Exception(0, // (*) see below + this, + "searching for '%s' starting from %ud problem: found begin in one fragment, but end in another", + substr.cstr(), this_offset); - return fragment.lang==lang?substr_end:STRING_NOT_FOUND; + if(fragment.lang<=lang) + return substr_begin; + else { // bad lang... + /// WARNING: this possibly skips assert (*), but it's fast + substr_begin=body.pos(substr, fragment_end/*...search AFTER for more*/); + if(substr_begin==CORD_NOT_FOUND) + return STRING_NOT_FOUND; + + size_t substr_end=substr_begin+substr.length(); + // and continuing with next fragment + } } return STRING_NOT_FOUND; } 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 self_size=size(); - if(size_t delim_size=strlen(delim)) { + 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; // 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_size; + pos_after=pos_before+delim_length; } // last piece - if(pos_after=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.size(); + pos_after=pos_before+delim.length(); } // last piece - if(pos_afteris_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 @@ -250,11 +303,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"); @@ -263,7 +316,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, @@ -271,7 +324,7 @@ Table* String::match(Charset& source_cha if(!code) throw Exception(0, - ®exp.mid(erroffset, regexp.size()), + ®exp.mid(erroffset, regexp.length()), "regular expression syntax error - %s", errptr); int subpatterns=pcre_info(code, 0, 0); @@ -284,27 +337,28 @@ Table* String::match(Charset& source_cha } const char* subject=cstr(); - size_t subject_size=strlen(subject); - const int ovecsize=(1/*match*/+MAX_MATCH_GROUPS)*3; - int ovector[ovecsize]; + size_t subject_length=strlen(subject); + const int oveclength=(1/*match*/+MAX_MATCH_GROUPS)*3; + 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; int poststart=0; - int postfinish=size(); + int postfinish=length(); while(true) { int exec_substrings=pcre_exec(code, 0, - subject, subject_size, prestart, - exec_option_bits, ovector, ovecsize); + subject, subject_length, prestart, + exec_option_bits, ovector, oveclength); if(exec_substrings==PCRE_ERROR_NOMATCH) { 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 } @@ -341,7 +395,7 @@ Table* String::match(Charset& source_cha if(!global || prestart==poststart) { // not global | going to hang pcre_free(code); row_action(table, 0/*last time, no row*/, 0, 0, poststart, postfinish, info); - return table; + return &table; } prestart=poststart; @@ -352,8 +406,10 @@ Table* String::match(Charset& source_cha } } -String& String::change_case(Charset& source_charset, Change_case_kind kind) { +String& String::change_case(Charset& source_charset, Change_case_kind kind) const { String& result=*new String(); + if(is_empty()) + return result; const unsigned char *tables=source_charset.pcre_tables; @@ -388,7 +444,7 @@ String& String::change_case(Charset& sou *dest++=(char)c; } result.body=new_cstr; - result.fragments.append(fragments, 0, fragments.count()); + result.fragments.append(fragments); return result; } @@ -396,39 +452,38 @@ String& String::change_case(Charset& sou const String& String::replace(const Dictionary& dict) const { String& result=*new String(); const char* old_cstr=cstr(); - const char* prematch_start=old_cstr; + const char* prematch_begin=old_cstr; - for(const char* current=old_cstr; *current; ) { - if(Table::element_type row=dict.first_that_starts(current)) { + const char* current=old_cstr; + while(*current) { + if(Table::element_type row=dict.first_that_begins(current)) { // prematch - if(size_t prematch_size=current-prematch_start) { - result.body=CORD_cat_char_star(result.body, prematch_start, prematch_size); - result.fragments.append(fragments, prematch_start-old_cstr, prematch_size); + if(size_t prematch_length=current-prematch_begin) { + result.body.append_strdup_know_length(prematch_begin, prematch_length); + result.fragments.append_positions(fragments, prematch_begin-old_cstr, current-old_cstr); } // match const String* a=row->get(0); - // skip 'a' in 'current'; move prematch_start - current+=a->size(); prematch_start=current; + // skip 'a' in 'current'; move prematch_begin + current+=a->length(); prematch_begin=current; if(row->count()>1) { // are there any b? const String* b=row->get(1); - if(size_t b_size=b->size()) { - result.body=CORD_cat(result.body, b->cstr_to_cord()); - result.fragments.append(b->fragments, 0, b->fragments.count()); - } + result<<*b; } } else // simply advance current++; } // postmatch - if(size_t prematch_size=current-prematch_start) { - result.body=CORD_cat_char_star(result.body, prematch_start, prematch_size); - result.fragments.append(fragments, prematch_start-old_cstr, prematch_size); + if(size_t postmatch_length=current-prematch_begin) { + result.body.append_strdup_know_length(prematch_begin, postmatch_length); + result.fragments.append_positions(fragments, prematch_begin-old_cstr, current-old_cstr); } + ASSERT_STRING_INVARIANT(result); return result; } @@ -500,22 +555,20 @@ inline uint uchars2uint(uchar *bytes) { | bytes[0]; } -static int CORD_batched_iter_fn_append(const char* s, void* client_data) { - char*& cur=*static_cast(client_data); - - size_t size=strlen(s); - memcpy(cur, s, size); cur+=size; +static int serialize_body_piece(const char* s, char** cur) { + size_t length=strlen(s); + memcpy(*cur, s, length); *cur+=length; return 0; }; -String::C String::serialize(size_t prolog_size) const { - size_t buf_size= - prolog_size - +fragments.count()*(sizeof(Untaint_lang)+sizeof(size_t)) - +size(); - C result(new(PointerFreeGC) char[buf_size], buf_size); +String::Cm String::serialize(size_t prolog_length) const { + size_t buf_length= + prolog_length + +fragments.count()*(sizeof(Language)+sizeof(size_t)) + +length(); + String::Cm result(new(PointerFreeGC) char[buf_length], buf_length); // 1: prolog - char *cur=result.str+prolog_size; + char *cur=result.str+prolog_length; // 2: fragments.count @@ -524,52 +577,55 @@ String::C String::serialize(size_t prolo // 3: lang info for(Array_iterator i(fragments); i.has_next(); ) { - const Fragment& fragment=i.next(); + const Fragment fragment=i.next(); // lang memcpy(cur, &fragment.lang, sizeof(fragment.lang)); cur+=sizeof(fragment.lang); - // size - memcpy(cur, &fragment.size, sizeof(fragment.size)); cur+=sizeof(fragment.size); + // 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); + body.for_each(serialize_body_piece, &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) { + if(buf_length<=prolog_length) return false; - buf_size-=prolog_size; + buf_length-=prolog_length; // 1: prolog - const char* cur=(const char* )buf+prolog_size; + const char* cur=(const char* )buf+prolog_length; // 2: fragments.count - if(buf_size(cur); cur+=sizeof(size_t); - buf_size-=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(cur); cur+=sizeof(Language); + size_t fragment_length=*reinterpret_cast(cur); cur+=sizeof(size_t); + fragments+=Fragment(lang, fragment_length); + total_length+=fragment_length; - // 3: lang info - size_t total_size=0; - for(size_t f=0; f(cur); cur+=sizeof(Untaint_lang); - size_t fragment_size=*reinterpret_cast(cur); cur+=sizeof(size_t); - fragments+=Fragment(lang, fragment_size); - total_size+=fragment_size; + // 4: letters + if(buf_length!=total_length) + return false; - buf_size-=piece_size; + body=StringBody(cur, buf_length); } - // 4: letters - if(buf_size!=total_size) - return false; - - body=CORD_cat_char_star(CORD_EMPTY, cur, buf_size); - + ASSERT_STRING_INVARIANT(*this); return true; }