--- parser3/src/main/pa_charset.C 2009/05/13 07:35:41 1.73 +++ parser3/src/main/pa_charset.C 2010/08/27 02:53:24 1.85 @@ -5,7 +5,7 @@ Author: Alexander Petrosyan(http://paf.design.ru) */ -static const char * const IDENT_CHARSET_C="$Date: 2009/05/13 07:35:41 $"; +static const char * const IDENT_CHARSET_C="$Date: 2010/08/27 02:53:24 $"; #include "pa_charset.h" #include "pa_charsets.h" @@ -193,8 +193,8 @@ void Charset::sort_ToTable() { 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; @@ -263,11 +263,11 @@ 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, int& srcLen, @@ -433,7 +433,7 @@ of ocetes consumed. return 0; } -static bool isEscaped(XMLByte c){ +static bool need_escape(XMLByte c){ return !( (c<=127) @@ -492,7 +492,7 @@ static unsigned int skipUTF8Char(const X return trailingBytes; } -// read non-UTF8 char, and return number of bytes needed for store this char in UTF8 +// 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; @@ -518,138 +518,254 @@ static unsigned int readChar(const XMLBy return 1; } -static int escapeUTF8(const XMLByte* srcData, size_t& srcLen, - XMLByte* toFill, size_t& toFillLen) { - const XMLByte* srcPtr=srcData; - const XMLByte* srcEnd=srcData+srcLen; - XMLByte* outPtr=toFill; - XMLByte* outEnd=toFill+toFillLen; - XMLByte firstByte; - XMLCh UTF8Char; - uint charSize; - - // loop until we either run out of input data, or room to store - while((outPtr < outEnd) && (charSize=readUTF8Char(srcPtr, srcEnd, firstByte, UTF8Char))){ - if(charSize==1){ - if(isEscaped(firstByte)) // %XX - outPtr+=sprintf((char*)outPtr, "%%%02X", firstByte); - else - *outPtr++=firstByte; - } else - outPtr+=sprintf((char*)outPtr, "%%u%04X", UTF8Char); // %uXXXX +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 } - - // Update the bytes eaten - srcLen=srcPtr-srcData; - - // Return the characters read - toFillLen=outPtr-toFill; - return 0; + return dest_length; } -static int escape(const XMLByte* srcData, size_t& srcLen, - XMLByte *toFill, size_t& toFillLen, - const Charset::Tables& tables) { - const XMLByte* srcPtr=srcData; - const XMLByte* srcEnd=srcData+srcLen; - XMLByte* outPtr=toFill; - XMLByte firstByte; - XMLCh UTF8Char; - uint charSize; - - while(charSize=readChar(srcPtr, srcEnd, firstByte, UTF8Char, tables)){ - if(charSize==1){ - if(firstByte){ - if(isEscaped(firstByte)) // %XX - outPtr+=sprintf((char*)outPtr, "%%%02X", firstByte); - else - *outPtr++=firstByte; - } else // add replacement char '?' - *outPtr++='?'; - } else - outPtr+=sprintf((char*)outPtr, "%%u%04X", UTF8Char); // %uXXXX +size_t Charset::calc_escaped_length(XMLByte* src, size_t src_length, const Charset::Tables& tables){ + size_t dest_length=0; + + const XMLByte* src_ptr=src; + const XMLByte* src_end=src_ptr+src_length; + XMLByte first_byte; + XMLCh UTF8_char; + while(uint char_size=readChar(src_ptr, 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 } - // Update the bytes eaten - srcLen = srcPtr - srcData; - - // Return the characters read - toFillLen = outPtr - toFill; + return dest_length; +} + +size_t Charset::calc_escaped_length(const String::C src, const Charset& source_charset){ + size_t src_length=src.length; + 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 0; + return dest_ptr - dest; } +size_t Charset::escape(const XMLByte* src, size_t src_length, XMLByte* dest, const Charset::Tables& tables) { + const XMLByte* src_ptr=src; + 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_ptr, 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){ size_t src_length=src.length; if(!src_length) return String::C("", 0); -#ifdef PRECALCULATE_DEST_LENGTH + 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) { + const char *src_ptr=src.cstr(); + size_t src_size=src.length(); + + String::C dest=Charset::escape(String::C(src_ptr, src_size), 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; - const XMLByte* srcPtr=(XMLByte*)src.str; - const XMLByte* srcEnd=srcPtr+src_length; - XMLByte firstByte; - XMLCh UTF8Char; - if(source_charset.isUTF8()){ - while(uint charSize=readUTF8Char(srcPtr, srcEnd, firstByte, UTF8Char)){ - if(charSize==1) - dest_length+=!isEscaped(firstByte)?1:3/*%XX*/; - else - dest_length+=6; // '%uXXXX' - } - } else { - while(uint charSize=readChar(srcPtr, srcEnd, firstByte, UTF8Char, source_charset.tables)){ - if(charSize==1) - dest_length+=(!firstByte/*replacement char '?'*/ || !isEscaped(firstByte))?1:3/*'%XX'*/; - else - dest_length+=6; // '%uXXXX' - } + 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(XMLByte* src, size_t src_length, const Charset::Tables& tables){ + const XMLByte* src_ptr=src; + const XMLByte* src_end=src_ptr+src_length; + XMLByte first_byte; + XMLCh UTF8_char; + size_t dest_length=0; + + while(uint char_size=readChar(src_ptr, 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){ + size_t src_length=src.length; + 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 - size_t dest_length=src_length*6; // enough for %uXXXX but too memory-hungry + return src_length*6; // enough for \uXXXX but too memory-hungry #endif +} - //throw Exception(0,0,"%u",dest_length); +#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_ptr=src; + const XMLByte* src_end=src+src_length; + XMLByte* dest_ptr=dest; + + XMLByte first_byte; + XMLCh UTF8_char; + uint char_size; -#ifndef NDEBUG - size_t saved_dest_length=dest_length; -#endif - XMLByte *dest_body=new(PointerFreeGC) XMLByte[dest_length+1/*for terminator*/]; + while(char_size=readChar(src_ptr, src_end, first_byte, UTF8_char, tables)) + escape_char_JSON(dest_ptr, char_size, first_byte, UTF8_char) - int status; - if(source_charset.isUTF8()){ - status=::escapeUTF8((XMLByte *)src.str, src_length, dest_body, dest_length); - } else { - status=::escape((XMLByte *)src.str, src_length, dest_body, dest_length, source_charset.tables); - } + return dest_ptr - dest; +} - if(status<0) - throw Exception(0, - 0, - "Charset::escape buffer overflow"); +String::C Charset::escape_JSON(const String::C src, const Charset& source_charset){ + size_t src_length=src.length; + 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"); - assert(dest_length<=saved_dest_length); 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::Body Charset::escape_JSON(const String::Body src, const Charset& source_charset) { const char *src_ptr=src.cstr(); - size_t src_size=strlen(src_ptr); + size_t src_size=src.length(); - String::C dest=Charset::escape(String::C(src_ptr, src_size), source_charset); + String::C dest=Charset::escape_JSON(String::C(src_ptr, src_size), source_charset); - return String::Body(dest.str); + return String::Body(dest.length ? dest.str:0); } -String& Charset::escape(const String& src, const Charset& source_charset) { +String& Charset::escape_JSON(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); + return *new String(escape_JSON((String::Body)src, source_charset), String::L_CLEAN); } const String::C Charset::transcodeToUTF8(const String::C src) const { @@ -664,11 +780,9 @@ const String::C Charset::transcodeToUTF8 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-hyngry + int dest_length=src_length*6; // so that surly enough (max utf8 seq len=6) but too memory-hungry #endif - //throw Exception(0,0,"%u",dest_length); - #ifndef NDEBUG int saved_dest_length=dest_length; #endif @@ -688,8 +802,8 @@ const String::C Charset::transcodeToUTF8 } 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; @@ -829,22 +943,17 @@ static size_t getDecNumLength(XMLCh UTF8 const String::C Charset::transcodeFromUTF8(const String::C src) const { 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=readUTF8Char(srcPtr, srcEnd, firstByte, UTF8Char)){ - if(charSize==1) + for(UTF8_string_iterator i((XMLByte *)src.str, src_length); i.has_next(); ){ + if(i.getCharSize()==1) dest_length++; else - dest_length+=(UTF8Char & 0xFFFF0000) - ?charSize*3 // '%XX' for each byte - :(xlatOneTo(UTF8Char, tables, 0)!=0) + dest_length+=(i.next() & 0xFFFF0000) + ?i.getCharSize()*3 // '%XX' for each byte + :(xlatOneTo(i.next(), tables, 0)!=0) ?1 // can convert it to single char - :getDecNumLength(UTF8Char)+3; // &#XX; - &#XXXXX; + :getDecNumLength(i.next())+3; // &#XX; - &#XXXXX; } #else // so that surly enough, "&#XXX;" has max ratio (huh? 8 bytes needed for '&#XXXXX;') @@ -871,7 +980,7 @@ const String::C Charset::transcodeFromUT /// 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 { @@ -1035,7 +1144,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, true); + return *new String(cstr.str, String::L_TAINTED); } /// @test less memory using -maybe- xmlParserInputBufferCreateMem @@ -1077,15 +1186,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 @@ -1094,13 +1202,11 @@ 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); + return String::Body(dest.length ? dest.str:0); } String& Charset::transcode(const String& src, @@ -1125,7 +1231,7 @@ 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, @@ -1170,3 +1276,12 @@ size_t lengthUTF8(const XMLByte* srcBegi 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; +}