--- parser3/src/main/pa_charset.C 2007/04/23 10:30:31 1.56 +++ parser3/src/main/pa_charset.C 2012/05/28 10:33:18 1.91 @@ -1,21 +1,24 @@ /** @file Parser: Charset connection implementation. - Copyright(c) 2001-2005 ArtLebedev Group (http://www.artlebedev.com) + Copyright (c) 2001-2012 Art. Lebedev Studio (http://www.artlebedev.com) Author: Alexander Petrosyan(http://paf.design.ru) */ -static const char * const IDENT_CHARSET_C="$Date: 2007/04/23 10:30:31 $"; - #include "pa_charset.h" #include "pa_charsets.h" +volatile const char * IDENT_PA_CHARSET_C="$Id: pa_charset.C,v 1.91 2012/05/28 10:33:18 moko Exp $" IDENT_PA_CHARSET_H; + #ifdef XML #include "libxml/encoding.h" #endif //#define PA_PATCHED_LIBXML_BACKWARD +// reduce memory usage by pre-calculation utf-8 string length +#define PRECALCULATE_DEST_LENGTH + // globals Charset::UTF8CaseTable::Rec UTF8CaseToUpperRecords[]={ @@ -55,8 +58,7 @@ inline unsigned int to_wchar_code(const if(cstr[1]==0) return(unsigned int)(unsigned char)cstr[0]; - char *error_pos; - return(unsigned int)strtol(cstr, &error_pos, 0); + return pa_atoui(cstr,0); } inline bool to_bool(const char* cstr) { return cstr && *cstr!=0; @@ -85,7 +87,6 @@ static void element2case(unsigned char f // methods -extern "C" unsigned char pcre_default_tables[]; // pcre/chartables.c Charset::Charset(Request_charsets* charsets, const String::Body ANAME, const String* afile_spec): FNAME(ANAME), FNAME_CSTR(ANAME.cstrm()) { @@ -99,7 +100,7 @@ Charset::Charset(Request_charsets* chars } else { fisUTF8=true; // grab default onces [for UTF-8 so to be able to make a-z =>A-Z - memcpy(pcre_tables, pcre_default_tables, sizeof(pcre_tables)); + memcpy(pcre_tables, _pcre_default_tables, sizeof(pcre_tables)); } #ifdef XML @@ -169,6 +170,15 @@ void Charset::load_definition(Request_ch } }; + // parser charset tables declare only white-space before 0x20, thus adding the missing chars + for(uint i=0; i<0x20; i++) + if(!tables.fromTable[i]){ + tables.fromTable[i]=i; + tables.toTable[tables.toTableSize].intCh=i; + tables.toTable[tables.toTableSize].extCh=(XMLByte)i; + tables.toTableSize++; + } + // sort by the Unicode code point sort_ToTable(); } @@ -187,11 +197,12 @@ void Charset::sort_ToTable() { //fclose(f); } +// @todo: precache for spedup searching static XMLByte xlatOneTo(const XMLCh toXlat, const Charset::Tables& tables, XMLByte not_found) { - int lo = 0; - int hi = tables.toTableSize - 1; + int lo = 0; + int hi = tables.toTableSize - 1; while(lo<=hi) { // Calc the mid point of the low and high offset. const unsigned int i = (lo + hi) / 2; @@ -260,16 +271,16 @@ static const XMLByte gUTFBytes[0x100] = }; static const uint gUTFOffsets[6] = { - 0, 0x3080, 0xE2080, 0x3C82080, 0xFA082080, 0x82082080 + 0, 0x3080, 0xE2080, 0x3C82080, 0xFA082080, 0x82082080 }; static const XMLByte gFirstByteMark[7] = { - 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC + 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC }; -static int transcodeToUTF8(const XMLByte* srcData, size_t& srcLen, - XMLByte *toFill, size_t& toFillLen, - const Charset::Tables& tables) { +static int transcodeToUTF8(const XMLByte* srcData, int& srcLen, + XMLByte *toFill, int& toFillLen, + const Charset::Tables& tables) { const XMLByte* srcPtr=srcData; const XMLByte* srcEnd=srcData+srcLen; XMLByte* outPtr=toFill; @@ -316,17 +327,17 @@ static int transcodeToUTF8(const XMLByte // here, so bump up the output pointer and work down as we go. outPtr+= encodedBytes; switch(encodedBytes) { - case 6: *--outPtr = XMLByte((curVal | 0x80UL) & 0xBFUL); - curVal>>= 6; - case 5: *--outPtr = XMLByte((curVal | 0x80UL) & 0xBFUL); - curVal>>= 6; - case 4: *--outPtr = XMLByte((curVal | 0x80UL) & 0xBFUL); - curVal>>= 6; - case 3: *--outPtr = XMLByte((curVal | 0x80UL) & 0xBFUL); - curVal>>= 6; - case 2: *--outPtr = XMLByte((curVal | 0x80UL) & 0xBFUL); - curVal>>= 6; - case 1: *--outPtr = XMLByte(curVal | gFirstByteMark[encodedBytes]); + case 6: *--outPtr = XMLByte((curVal | 0x80UL) & 0xBFUL); + curVal>>= 6; + case 5: *--outPtr = XMLByte((curVal | 0x80UL) & 0xBFUL); + curVal>>= 6; + case 4: *--outPtr = XMLByte((curVal | 0x80UL) & 0xBFUL); + curVal>>= 6; + case 3: *--outPtr = XMLByte((curVal | 0x80UL) & 0xBFUL); + curVal>>= 6; + case 2: *--outPtr = XMLByte((curVal | 0x80UL) & 0xBFUL); + curVal>>= 6; + case 1: *--outPtr = XMLByte(curVal | gFirstByteMark[encodedBytes]); } // Add the encoded bytes back in again to indicate we've eaten them @@ -350,9 +361,9 @@ of ocetes consumed. return 0; } /// @todo digital entites only when xml/html output [at output in html/xml mode, in html part of a letter] -static int transcodeFromUTF8(const XMLByte* srcData, size_t& srcLen, - XMLByte* toFill, size_t& toFillLen, - const Charset::Tables& tables) { +static int transcodeFromUTF8(const XMLByte* srcData, int& srcLen, + XMLByte* toFill, int& toFillLen, + const Charset::Tables& tables) { const XMLByte* srcPtr=srcData; const XMLByte* srcEnd=srcData+srcLen; XMLByte* outPtr=toFill; @@ -364,7 +375,7 @@ static int transcodeFromUTF8(const XMLBy const XMLByte firstByte =* srcPtr; // Special-case ASCII, which is a leading byte value of<= 127 - if(firstByte<= 127) { + if(firstByte<=127) { *outPtr++= firstByte; srcPtr++; continue; @@ -430,12 +441,339 @@ of ocetes consumed. return 0; } -/// @todo not so memory-hungry with prescan +static bool need_escape(XMLByte c){ + return + !( + (c<=127) + && ( + pa_isalnum((unsigned char)c) + || strchr("*@-_+./", c)!=0 + ) + ); +} + +// read one UTF8 char and return length of this char (in bytes) +static unsigned int readUTF8Char(const XMLByte*& srcPtr, const XMLByte* srcEnd, XMLByte& firstByte, XMLCh& UTF8Char){ + if(!srcPtr || !*srcPtr || srcPtr>=srcEnd) + return 0; + + firstByte=*srcPtr; + + if(firstByte<=127){ + UTF8Char=firstByte; + srcPtr++; + return 1; + } + + unsigned int trailingBytes=gUTFBytes[firstByte]; + + if(srcPtr+trailingBytes>=srcEnd){ + return 0; // not enough bytes in source string for reading + } + + uint tmpVal=0; + switch(trailingBytes){ + case 5: tmpVal+=*srcPtr++; tmpVal<<=6; + case 4: tmpVal+=*srcPtr++; tmpVal<<=6; + case 3: tmpVal+=*srcPtr++; tmpVal<<=6; + case 2: tmpVal+=*srcPtr++; tmpVal<<=6; + case 1: tmpVal+=*srcPtr++; tmpVal<<=6; + case 0: tmpVal+=*srcPtr++; + } + + tmpVal-=gUTFOffsets[trailingBytes]; + UTF8Char=tmpVal; + + return trailingBytes+1; +} + +// skip UTF8 char and return length of this char (in bytes) +static unsigned int skipUTF8Char(const XMLByte*& srcPtr, const XMLByte* srcEnd){ + if(!srcPtr || !*srcPtr || srcPtr>=srcEnd) + return 0; + + unsigned int trailingBytes=gUTFBytes[*srcPtr]+1; + srcPtr+=trailingBytes; + + return trailingBytes; +} + +// read non-UTF8 char, and return number of bytes needed for storing this char in UTF8 +static unsigned int readChar(const XMLByte*& srcPtr, const XMLByte* srcEnd, XMLByte& firstByte, XMLCh& UTF8Char, const Charset::Tables& tables){ + if(!srcPtr || !*srcPtr || srcPtr>=srcEnd) + return 0; + + firstByte=*srcPtr++; + UTF8Char=tables.fromTable[firstByte]; + + if(UTF8Char<0x80) + return 1; + else if(UTF8Char<0x800) + return 2; + else if(UTF8Char<0x10000) + return 3; + else if(UTF8Char<0x200000) + return 4; + else if(UTF8Char<0x4000000) + return 5; + else if(UTF8Char<= 0x7FFFFFFF) + return 6; + + // will use the replacement character '?' + firstByte=0; + return 1; +} + +size_t Charset::calc_escaped_length_UTF8(XMLByte* src, size_t src_length){ + size_t dest_length=0; + + for(UTF8_string_iterator i(src, src_length); i.has_next(); ){ + if(i.getCharSize()==1) + dest_length+=!need_escape(i.getFirstByte())?1/*as-is*/:3/*%XX*/; + else + dest_length+=6; // %uXXXX + } + + return dest_length; +} + +size_t Charset::calc_escaped_length(const XMLByte* src, size_t src_length, const Charset::Tables& tables){ + const XMLByte* src_end=src+src_length; + XMLByte first_byte; + XMLCh UTF8_char; + size_t dest_length=0; + + while(uint char_size=readChar(src, src_end, first_byte, UTF8_char, tables)){ + if(char_size==1) + dest_length+=(!first_byte/*replacement char '?'*/ || !need_escape(first_byte))?1:3/*'%XX'*/; + else + dest_length+=6; // %uXXXX + } + + return dest_length; +} + +size_t Charset::calc_escaped_length(const String::C src, const Charset& source_charset){ + if(!src.length) + return 0; + +#ifdef PRECALCULATE_DEST_LENGTH + if(source_charset.isUTF8()) + return calc_escaped_length_UTF8((XMLByte *)src.str, src.length); + else + return calc_escaped_length((XMLByte *)src.str, src.length, source_charset.tables); +#else + return src_length*6; // enough for %uXXXX but too memory-hungry +#endif +} + +#define escape_char(dest_ptr, char_size, first_byte, UTF8_char) \ + if(char_size==1) \ + if(first_byte){ \ + if(need_escape(first_byte)) \ + dest_ptr+=sprintf((char*)dest_ptr, "%%%02X", first_byte); /* %XX */ \ + else \ + *dest_ptr++=first_byte; /*as is*/ \ + } else \ + *dest_ptr++='?'; /* replacement char '?' */ \ + else \ + dest_ptr+=sprintf((char*)dest_ptr, "%%u%04X", UTF8_char); // %uXXXX + + +size_t Charset::escape_UTF8(const XMLByte* src, size_t src_length, XMLByte* dest) { + XMLByte* dest_ptr=dest; + + // loop until we either run out of input data + for(UTF8_string_iterator i((XMLByte *)src, src_length); i.has_next(); ) + escape_char(dest_ptr, i.getCharSize(), i.getFirstByte(), i.next()) + + return dest_ptr - dest; +} + +size_t Charset::escape(const XMLByte* src, size_t src_length, XMLByte* dest, const Charset::Tables& tables) { + const XMLByte* src_end=src+src_length; + XMLByte* dest_ptr=dest; + + XMLByte first_byte; + XMLCh UTF8_char; + uint char_size; + + while(char_size=readChar(src, src_end, first_byte, UTF8_char, tables)) + escape_char(dest_ptr, char_size, first_byte, UTF8_char) + + return dest_ptr - dest; +} + +String::C Charset::escape(const String::C src, const Charset& source_charset){ + if(!src.length) + return String::C("", 0); + + size_t dest_calculated_length=calc_escaped_length(src, source_charset); + XMLByte *dest_body=new(PointerFreeGC) XMLByte[dest_calculated_length+1/*terminator*/]; + + size_t dest_length; + if(source_charset.isUTF8()) + dest_length=escape_UTF8((XMLByte *)src.str, src.length, dest_body); + else + dest_length=escape((XMLByte *)src.str, src.length, dest_body, source_charset.tables); + + if(dest_length>dest_calculated_length) + throw Exception(0, 0, "Charset::escape buffer overflow"); + + dest_body[dest_length]=0; // terminator + return String::C((char*)dest_body, dest_length); +} + +String::Body Charset::escape(const String::Body src, const Charset& source_charset) { + String::C dest=Charset::escape(String::C(src.cstr(), src.length()), source_charset); + return String::Body(dest.length ? dest.str:0); +} + +String& Charset::escape(const String& src, const Charset& source_charset) { + if(src.is_empty()) + return *new String(); + + return *new String(escape((String::Body)src, source_charset), String::L_CLEAN); +} + +inline bool need_json_escape(unsigned char c){ + return strchr("\n\"\\/\t\r\b\f", c)!=0; +} + +size_t Charset::calc_JSON_escaped_length_UTF8(XMLByte* src, size_t src_length){ + size_t dest_length=0; + + for(UTF8_string_iterator i(src, src_length); i.has_next(); ){ + if(i.getCharSize()==1) + dest_length+=need_json_escape(i.getFirstByte()) ? 2 : 1; + else + dest_length+=6; // \uXXXX + } + + return dest_length; +} + +size_t Charset::calc_JSON_escaped_length(const XMLByte* src, size_t src_length, const Charset::Tables& tables){ + const XMLByte* src_end=src+src_length; + XMLByte first_byte; + XMLCh UTF8_char; + size_t dest_length=0; + + while(uint char_size=readChar(src, src_end, first_byte, UTF8_char, tables)){ + if(char_size==1) + dest_length+=(!first_byte/*replacement char '?'*/ || !need_json_escape(first_byte))? 1 : 2; + else + dest_length+=6; // \uXXXX + } + + return dest_length; +} + +size_t Charset::calc_JSON_escaped_length(const String::C src, const Charset& source_charset){ + if(!src.length) + return 0; + +#ifdef PRECALCULATE_DEST_LENGTH + if(source_charset.isUTF8()) + return calc_JSON_escaped_length_UTF8((XMLByte *)src.str, src.length); + else + return calc_JSON_escaped_length((XMLByte *)src.str, src.length, source_charset.tables); +#else + return src_length*6; // enough for \uXXXX but too memory-hungry +#endif +} + +#define escape_char_JSON(dest_ptr, char_size, first_byte, UTF8_char) \ + if(char_size==1) \ + switch(first_byte){ \ + case '\n': *dest_ptr++='\\'; *dest_ptr++='n'; break; \ + case '"' : *dest_ptr++='\\'; *dest_ptr++='"'; break; \ + case '\\': *dest_ptr++='\\'; *dest_ptr++='\\'; break; \ + case '/' : *dest_ptr++='\\'; *dest_ptr++='/'; break; \ + case '\t': *dest_ptr++='\\'; *dest_ptr++='t'; break; \ + case '\r': *dest_ptr++='\\'; *dest_ptr++='r'; break; \ + case '\b': *dest_ptr++='\\'; *dest_ptr++='b'; break; \ + case '\f': *dest_ptr++='\\'; *dest_ptr++='f'; break; \ + case 0 : *dest_ptr++='?'; break; /*replacement char*/ \ + default : *dest_ptr++=first_byte; \ + } \ + else \ + dest_ptr+=sprintf((char*)dest_ptr, "\\u%04X", UTF8_char); // \uXXXX + + +size_t Charset::escape_JSON_UTF8(const XMLByte* src, size_t src_length, XMLByte* dest) { + XMLByte* dest_ptr=dest; + + // loop until we either run out of input data + for(UTF8_string_iterator i((XMLByte *)src, src_length); i.has_next(); ) + escape_char_JSON(dest_ptr, i.getCharSize(), i.getFirstByte(), i.next()) + + return dest_ptr - dest; +} + +size_t Charset::escape_JSON(const XMLByte* src, size_t src_length, XMLByte* dest, const Charset::Tables& tables) { + const XMLByte* src_end=src+src_length; + XMLByte* dest_ptr=dest; + + XMLByte first_byte; + XMLCh UTF8_char; + uint char_size; + + while(char_size=readChar(src, src_end, first_byte, UTF8_char, tables)) + escape_char_JSON(dest_ptr, char_size, first_byte, UTF8_char) + + return dest_ptr - dest; +} + +String::C Charset::escape_JSON(const String::C src, const Charset& source_charset){ + if(!src.length) + return String::C("", 0); + + size_t dest_calculated_length=calc_JSON_escaped_length(src, source_charset); + XMLByte *dest_body=new(PointerFreeGC) XMLByte[dest_calculated_length+1/*terminator*/]; + + size_t dest_length; + if(source_charset.isUTF8()) + dest_length=escape_JSON_UTF8((XMLByte *)src.str, src.length, dest_body); + else + dest_length=escape_JSON((XMLByte *)src.str, src.length, dest_body, source_charset.tables); + + if(dest_length>dest_calculated_length) + throw Exception(0, 0, "Charset::escape_JSON buffer overflow"); + + dest_body[dest_length]=0; // terminator + return String::C((char*)dest_body, dest_length); +} + +String::Body Charset::escape_JSON(const String::Body src, const Charset& source_charset) { + String::C dest=Charset::escape_JSON(String::C(src.cstr(), src.length()), source_charset); + return String::Body(dest.length ? dest.str:0); +} + +String& Charset::escape_JSON(const String& src, const Charset& source_charset) { + if(src.is_empty()) + return *new String(); + + return *new String(escape_JSON((String::Body)src, source_charset), String::L_CLEAN); +} + const String::C Charset::transcodeToUTF8(const String::C src) const { - size_t src_length=src.length; - size_t dest_length=src.length*6/*so that surly enough, max utf8 seq len=6*/; + int src_length=src.length; + +#ifdef PRECALCULATE_DEST_LENGTH + int dest_length=0; + const XMLByte* srcPtr=(XMLByte*)src.str; + const XMLByte* srcEnd=srcPtr+src_length; + XMLByte firstByte; + XMLCh UTF8Char; + while(uint charSize=readChar(srcPtr, srcEnd, firstByte, UTF8Char, tables)) + dest_length+=charSize; +#else + int dest_length=src_length*6; // so that surly enough (max utf8 seq len=6) but too memory-hungry +#endif + #ifndef NDEBUG - size_t saved_dest_length=dest_length; + int saved_dest_length=dest_length; #endif XMLByte *dest_body=new(PointerFreeGC) XMLByte[dest_length+1/*for terminator*/]; @@ -447,13 +785,14 @@ const String::C Charset::transcodeToUTF8 0, "Charset::transcodeToUTF8 buffer overflow"); - assert(dest_length<=saved_dest_length); dest_body[dest_length]=0; // terminator + assert(dest_length<=saved_dest_length); + dest_body[dest_length]=0; // terminator return String::C((char*)dest_body, dest_length); } static XMLCh change_case_UTF8(const XMLCh src, const Charset::UTF8CaseTable& table) { - int lo = 0; - int hi = table.size - 1; + int lo = 0; + int hi = table.size - 1; while(lo<=hi) { // Calc the mid point of the low and high offset. const unsigned int i = (lo + hi) / 2; @@ -471,7 +810,7 @@ static XMLCh change_case_UTF8(const XMLC return src; } -static void store_UTF8(XMLCh src, XMLByte*& outPtr ) { +static void store_UTF8(XMLCh src, XMLByte*& outPtr){ if(!src) { // use the replacement character *outPtr++= '?'; @@ -536,7 +875,7 @@ void change_case_UTF8(const XMLByte* src // Get the next leading byte out const XMLByte firstByte =* srcPtr; - if(firstByte<= 127) { + if(firstByte<=127) { change_case_UTF8(firstByte, outPtr, table); srcPtr++; continue; @@ -580,12 +919,35 @@ void change_case_UTF8(const XMLByte* src "change_case_UTF8 error: end pointers do not match"); } +static size_t getDecNumLength(XMLCh UTF8Char){ + return + (UTF8Char < 100) + ?2 + :(UTF8Char < 1000) + ?3 + :(UTF8Char < 10000) + ?4 + :5; +} const String::C Charset::transcodeFromUTF8(const String::C src) const { - size_t src_length=src.length; - size_t dest_length=src.length*6/*so that surly enough, "ÿ" has max ratio */; + int src_length=src.length; +#ifdef PRECALCULATE_DEST_LENGTH + int dest_length=0; + for(UTF8_string_iterator i((XMLByte *)src.str, src_length); i.has_next(); ){ + dest_length += ( i.next() & 0xFFFF0000 ) + ? 3*i.getCharSize() // %XX for each byte + : ( xlatOneTo(i.next(), tables, 0) != 0 ) + ? 1 // can convert it to a single char + : 3+getDecNumLength( i.next() ); // print char as &#XX;, &#XXX;, &#XXXX; or &#XXXXX; + } +#else + // so that surly enough, "&#XXX;" has max ratio (huh? 8 bytes needed for '&#XXXXX;') + int dest_length=src_length*6; +#endif + #ifndef NDEBUG - size_t saved_dest_length=dest_length; + int saved_dest_length=dest_length; #endif XMLByte *dest_body=new(PointerFreeGC) XMLByte[dest_length+1/*for terminator*/]; @@ -597,13 +959,14 @@ const String::C Charset::transcodeFromUT 0, "Charset::transcodeFromUTF8 buffer overflow"); - assert(dest_length<=saved_dest_length); dest_body[dest_length]=0; // terminator + assert(dest_length<=saved_dest_length); + dest_body[dest_length]=0; // terminator return String::C((char*)dest_body, dest_length); } /// transcode using both charsets const String::C Charset::transcodeToCharset(const String::C src, - const Charset& dest_charset) const { + const Charset& dest_charset) const { if(&dest_charset==this) return src; else { @@ -624,6 +987,13 @@ const String::C Charset::transcodeToChar } } +void Charset::store_Char(XMLByte*& outPtr, XMLCh src, XMLByte not_found){ + if(isUTF8()) + store_UTF8(src, outPtr); + else if(char ch=xlatOneTo(src, tables, not_found)) + *outPtr++=ch; +} + #ifdef XML static const Charset::Tables* tables[MAX_CHARSETS]; @@ -635,16 +1005,16 @@ static const Charset::Tables* tables[MAX unsigned char *out, int *outlen, \ const unsigned char *in, int *inlen, void*) { \ return transcodeToUTF8( \ - in, *(size_t*)inlen, \ - out, *(size_t*)outlen, \ + in, *inlen, \ + out, *outlen, \ *tables[i]); \ } \ static int xml256CharEncodingOutputFunc##i( \ unsigned char *out, int *outlen, \ const unsigned char *in, int *inlen, void*) { \ return transcodeFromUTF8( \ - in, *(size_t*)inlen, \ - out, *(size_t*)outlen, \ + in, *inlen, \ + out, *outlen, \ *tables[i]); \ } @@ -655,16 +1025,16 @@ static const Charset::Tables* tables[MAX unsigned char *out, int *outlen, \ const unsigned char *in, int *inlen) { \ return transcodeToUTF8( \ - in, *(size_t*)inlen, \ - out, *(size_t*)outlen, \ + in, *inlen, \ + out, *outlen, \ *tables[i]); \ } \ static int xml256CharEncodingOutputFunc##i( \ unsigned char *out, int *outlen, \ const unsigned char *in, int *inlen) { \ return transcodeFromUTF8( \ - in, *(size_t*)inlen, \ - out, *(size_t*)outlen, \ + in, *inlen, \ + out, *outlen, \ *tables[i]); \ } @@ -760,7 +1130,7 @@ String::C Charset::transcode_cstr(const } const String& Charset::transcode(const xmlChar* s) { String::C cstr=transcode_cstr(s); - return *new String(cstr.str, cstr.length, true); + return *new String(cstr.str, String::L_TAINTED); } /// @test less memory using -maybe- xmlParserInputBufferCreateMem @@ -802,15 +1172,14 @@ xmlChar* Charset::transcode_buf2xchar(co assert(outlen<=saved_outlen); out[outlen]=0; return out; } -xmlChar* Charset::transcode(const String& s) { - const char* cstr=s.cstr(String::L_UNSPECIFIED); - return transcode_buf2xchar(cstr, strlen(cstr)); +xmlChar* Charset::transcode(const String& s) { + String::Body sbody=s.cstr_to_string_body_untaint(String::L_AS_IS); + return transcode_buf2xchar(sbody.cstr(), sbody.length()); } -xmlChar* Charset::transcode(const String::Body s) { - const char* cstr=s.cstr(); - return transcode_buf2xchar(cstr, s.length()); +xmlChar* Charset::transcode(const String::Body s) { + return transcode_buf2xchar(s.cstr(), s.length()); } #endif @@ -819,20 +1188,18 @@ String::Body Charset::transcode(const St const Charset& dest_transcoder) { const char *src_ptr=src.cstr(); - size_t src_size=strlen(src_ptr); + size_t src_size=src.length(); - String::C dest=Charset::transcode(String::C(src_ptr, src_size), - source_transcoder, - dest_transcoder); + String::C dest=Charset::transcode(String::C(src_ptr, src_size), source_transcoder, dest_transcoder); - return String::Body(dest.str, dest.length); + return String::Body(dest.length ? dest.str:0); } String& Charset::transcode(const String& src, const Charset& source_transcoder, const Charset& dest_transcoder) { - if(!src.length()) - return *new String("", 0, false); + if(src.is_empty()) + return *new String(); return *new String(transcode((String::Body)src, source_transcoder, dest_transcoder), String::L_CLEAN); } @@ -850,16 +1217,57 @@ struct Transcode_pair_info { const Charset* dest_transcoder; }; #endif -static void transcode_pair(const String::Body /*akey*/, +static void transcode_pair(HashStringValue::key_type /*akey*/, String::Body& avalue, Transcode_pair_info* info) { avalue=Charset::transcode(avalue, *info->source_transcoder, *info->dest_transcoder); } + void Charset::transcode(HashStringString& src, const Charset& source_transcoder, const Charset& dest_transcoder) { Transcode_pair_info info={&source_transcoder, &dest_transcoder}; src.for_each_ref(transcode_pair, &info); } + +size_t getUTF8BytePos(const XMLByte* srcBegin, const XMLByte* srcEnd, size_t charPos){ + const XMLByte* ptr=srcBegin; + while(charPos-- && skipUTF8Char(ptr, srcEnd)); + + return ptr-srcBegin; +} + +size_t getUTF8CharPos(const XMLByte* srcBegin, const XMLByte* srcEnd, size_t bytePos){ + size_t charPos=0; + const XMLByte* ptr=srcBegin; + const XMLByte* ptrEnd=srcBegin+bytePos; + while(skipUTF8Char(ptr, srcEnd)){ + if(ptr>ptrEnd) + return charPos; + charPos++; + } + + // scan till end but position in bytes still too low + throw Exception(0, + 0, + "Error convertion byte pos to char pos"); +} + +size_t lengthUTF8(const XMLByte* srcBegin, const XMLByte* srcEnd){ + size_t size=0; + while(skipUTF8Char(srcBegin, srcEnd)) + size++; + + return size; +} + +unsigned int lengthUTF8Char(const XMLByte c){ + return gUTFBytes[c]+1; +} + +bool UTF8_string_iterator::has_next(){ + fcharSize=readUTF8Char(fsrcPtr, fsrcEnd, ffirstByte, fUTF8Char); + return fcharSize!=0; +}