--- parser3/src/main/pa_charset.C 2009/04/15 04:51:40 1.68 +++ parser3/src/main/pa_charset.C 2025/06/28 15:42:00 1.117 @@ -1,21 +1,23 @@ /** @file Parser: Charset connection implementation. - Copyright(c) 2001-2009 ArtLebedev Group (http://www.artlebedev.com) - Author: Alexander Petrosyan(http://paf.design.ru) + Copyright (c) 2001-2024 Art. Lebedev Studio (http://www.artlebedev.com) + Authors: Konstantin Morshnev , Alexandr Petrosian */ -static const char * const IDENT_CHARSET_C="$Date: 2009/04/15 04:51:40 $"; - #include "pa_charset.h" #include "pa_charsets.h" +// we are using some pcre_internal.h stuff as well +#include "../lib/pcre/pa_pcre_internal.h" + +volatile const char * IDENT_PA_CHARSET_C="$Id: pa_charset.C,v 1.117 2025/06/28 15:42:00 moko Exp $" IDENT_PA_CHARSET_H; + #ifdef XML +#include "libxml/xmlmemory.h" #include "libxml/encoding.h" #endif -//#define PA_PATCHED_LIBXML_BACKWARD - // reduce memory usage by pre-calculation utf-8 string length #define PRECALCULATE_DEST_LENGTH @@ -43,8 +45,7 @@ inline void prepare_case_tables(unsigned for(int i=0; i<0x100; i++) lcc_table[i]=fcc_table[i]=(unsigned char)i; } -inline void cstr2ctypes(unsigned char *tables, const unsigned char *cstr, - unsigned char bit) { +inline void cstr2ctypes(unsigned char *tables, const unsigned char *cstr, unsigned char bit) { unsigned char *ctypes_table=tables+ctypes_offset; ctypes_table[0]=bit; for(; *cstr; cstr++) { @@ -58,14 +59,12 @@ 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; } -static void element2ctypes(unsigned char c, bool belongs, - unsigned char *tables, unsigned char bit, int group_offset=-1) { +static void element2ctypes(unsigned char c, bool belongs, unsigned char *tables, unsigned char bit, int group_offset=-1) { if(!belongs) return; @@ -75,8 +74,7 @@ static void element2ctypes(unsigned char if(group_offset>=0) tables[cbits_offset+group_offset+c/8] |= 1<<(c%8); } -static void element2case(unsigned char from, unsigned char to, - unsigned char *tables) { +static void element2case(unsigned char from, unsigned char to, unsigned char *tables) { if(!to) return; @@ -86,30 +84,48 @@ static void element2case(unsigned char f fcc_table[from]=to; fcc_table[to]=from; } +inline XMLByte *append_hex_8(XMLByte *dest, unsigned char c, const char* prefix=0) { + if(prefix) { + strcpy((char *)dest, prefix); + dest+=strlen(prefix); + } + *dest++=hex_digits[c >> 4]; + *dest++=hex_digits[c & 0x0F]; + return dest; +} + +inline XMLByte *append_hex_16(XMLByte *dest, unsigned int c, const char* prefix=0) { + if(prefix) { + strcpy((char *)dest, prefix); + dest+=strlen(prefix); + } + *dest++=hex_digits[(c >> 12) & 0x0F]; + *dest++=hex_digits[(c >> 8) & 0x0F]; + *dest++=hex_digits[(c >> 4) & 0x0F]; + *dest++=hex_digits[(c) & 0x0F]; + return dest; +} + // methods -Charset::Charset(Request_charsets* charsets, const String::Body ANAME, const String* afile_spec): +Charset::Charset(Request_charsets* acharsets, const String::Body ANAME, const String* afile_spec): FNAME(ANAME), FNAME_CSTR(ANAME.cstrm()) { if(afile_spec) { fisUTF8=false; - load_definition(*charsets, *afile_spec); + load_definition(*acharsets, *afile_spec); #ifdef XML addEncoding(FNAME_CSTR); #endif } 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, pa_pcre_default_tables, sizeof(pcre_tables)); } - -#ifdef XML - initTranscoder(FNAME, FNAME_CSTR); -#endif } -void Charset::load_definition(Request_charsets& charsets, const String& afile_spec) { +void Charset::load_definition(Request_charsets& acharsets, const String& afile_spec) { // pcre_tables // lowcase, flipcase, bits digit+word+whitespace, masks @@ -123,7 +139,7 @@ void Charset::load_definition(Request_ch memset(&tables, 0, sizeof(tables)); // loading text - char *data=file_read_text(charsets, afile_spec); + char *data=file_read_text(acharsets, afile_spec); // ignore header getrow(&data); @@ -152,9 +168,7 @@ void Charset::load_definition(Request_ch case 8: // charset if(tables.toTableSize>MAX_CHARSET_UNI_CODES) - throw Exception(PARSER_RUNTIME, - &afile_spec, - "charset must contain not more then %d unicode values", MAX_CHARSET_UNI_CODES); + throw Exception(PARSER_RUNTIME, &afile_spec, "charset must contain not more than %d unicode values", MAX_CHARSET_UNI_CODES); XMLCh unicode=(XMLCh)to_wchar_code(cell); if(!unicode && column==7/*unicode1 column*/) @@ -171,6 +185,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(); } @@ -182,19 +205,13 @@ static int sort_cmp_Trans_rec_intCh(cons } void Charset::sort_ToTable() { - _qsort(tables.toTable, tables.toTableSize, sizeof(*tables.toTable), - sort_cmp_Trans_rec_intCh); - //FILE *f=fopen("c:\\temp\\a", "wb"); - //fwrite(tables.toTable, tables.toTableSize, sizeof(*tables.toTable), f); - //fclose(f); + qsort(tables.toTable, tables.toTableSize, sizeof(*tables.toTable), sort_cmp_Trans_rec_intCh); } // @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; +static XMLByte xlatOneTo(const XMLCh toXlat, const Charset::Tables& tables, XMLByte not_found) { + 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; @@ -211,9 +228,7 @@ static XMLByte xlatOneTo(const XMLCh toX return not_found; } -String::C Charset::transcode(const String::C src, - const Charset& source_charset, - const Charset& dest_charset) { +String::C Charset::transcode(const String::C src, const Charset& source_charset, const Charset& dest_charset) { if(!src.length) return String::C("", 0); @@ -263,16 +278,14 @@ 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; @@ -353,9 +366,7 @@ 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; @@ -394,9 +405,7 @@ static int transcodeFromUTF8(const XMLBy break; default: - throw Exception(0, - 0, - "transcodeFromUTF8 error: wrong trailingBytes value(%d)", trailingBytes); // never + throw Exception(0, 0, "transcodeFromUTF8 error: wrong trailingBytes value(%d)", trailingBytes); // never } tmpVal-=gUTFOffsets[trailingBytes]; @@ -433,21 +442,19 @@ of ocetes consumed. return 0; } -static bool is_escaped(XMLByte c){ +static bool need_escape(XMLByte c){ return !( (c<=127) && ( - ((c>='0') && (c<='9')) - || ((c>='A') && (c<='Z')) - || ((c>='a') && (c<='z')) + pa_isalnum((unsigned char)c) || strchr("*@-_+./", c)!=0 ) ); } -// read one utf8 character, return number of bytes needed for store it -static unsigned int readChar(const XMLByte*& srcPtr, const XMLByte* srcEnd, XMLByte& firstByte, XMLCh& UTF8Char){ +// 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; @@ -481,7 +488,8 @@ static unsigned int readChar(const XMLBy return trailingBytes+1; } -static unsigned int skipChar(const XMLByte*& srcPtr, const XMLByte* srcEnd){ +// 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; @@ -491,7 +499,7 @@ static unsigned int skipChar(const XMLBy return trailingBytes; } -// read char, return number of bytes needed for store it as 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; @@ -517,161 +525,258 @@ static unsigned int readChar(const XMLBy return 1; } -static int escape(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=readChar(srcPtr, srcEnd, firstByte, UTF8Char))){ - if(charSize==1){ - if(is_escaped(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* outEnd=toFill+toFillLen; - XMLByte firstByte; - XMLCh UTF8Char; - uint charSize; - - while(charSize=readChar(srcPtr, srcEnd, firstByte, UTF8Char, tables)){ - if(charSize==1){ - if(firstByte){ - if(is_escaped(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(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 } - // 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){ + 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=append_hex_8(dest_ptr, first_byte, "%"); /* %XX */ \ + else \ + *dest_ptr++=first_byte; /*as is*/ \ + } else \ + *dest_ptr++='?'; /* replacement char '?' */ \ + else \ + dest_ptr=append_hex_16(dest_ptr, UTF8_char, "%u"); /* %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_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){ - size_t src_length=src.length; - if(!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) { + 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; - const XMLByte* srcPtr=(XMLByte*)src.str; - const XMLByte* srcEnd=srcPtr+src_length; - XMLByte firstByte; - XMLCh UTF8Char; - if(source_charset.isUTF8()){ - while(uint charSize=readChar(srcPtr, srcEnd, firstByte, UTF8Char)){ - if(charSize==1) - dest_length+=!is_escaped(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 '?'*/ || !is_escaped(firstByte))?1:3/*'%XX'*/; - else - dest_length+=6; // '%uXXXX' - } + for(UTF8_string_iterator i(src, src_length); i.has_next(); ){ + if(i.getCharSize()==1){ + XMLByte first_byte=i.getFirstByte(); + dest_length+=need_json_escape(first_byte) ? 2 : (first_byte < 0x20 && first_byte /* 0 replacement char is '?' */) ? 6 : 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+=need_json_escape(first_byte) ? 2 : (first_byte < 0x20 && first_byte /* 0 replacement char is '?' */) ? 6 : 1; + 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 - 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 : if(first_byte < 0x20) dest_ptr=append_hex_16(dest_ptr, UTF8_char, "\\u"); \ + else *dest_ptr++=first_byte; \ + } \ + else \ + dest_ptr=append_hex_16(dest_ptr, UTF8_char, "\\u"); // \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; -#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, 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=::escape((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::escapeString buffer overflow"); +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"); - 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) { - const char *src_ptr=src.cstr(); - size_t src_size=strlen(src_ptr); - - String::C dest=Charset::escape(String::C(src_ptr, src_size), - source_charset); - return String::Body(dest.str, 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(const String& src, const Charset& source_charset) { - if(!src.length()) - return *new String("", 0, false); +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 { - size_t src_length=src.length; + int src_length=src.length; #ifdef PRECALCULATE_DEST_LENGTH - size_t dest_length=0; + int dest_length=0; const XMLByte* srcPtr=(XMLByte*)src.str; const XMLByte* srcEnd=srcPtr+src_length; - XMLByte firstByte; - XMLCh UTF8Char; - while(uint charSize=skipChar(srcPtr, srcEnd)) + XMLByte firstByte; + XMLCh UTF8Char; + while(uint charSize=readChar(srcPtr, srcEnd, firstByte, UTF8Char, tables)) dest_length+=charSize; #else - size_t 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 - 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*/]; @@ -679,9 +784,7 @@ const String::C Charset::transcodeToUTF8 (XMLByte *)src.str, src_length, dest_body, dest_length, tables)<0) - throw Exception(0, - 0, - "Charset::transcodeToUTF8 buffer overflow"); + throw Exception(0, 0, "Charset::transcodeToUTF8 buffer overflow"); assert(dest_length<=saved_dest_length); dest_body[dest_length]=0; // terminator @@ -689,8 +792,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; @@ -756,13 +859,11 @@ static void store_UTF8(XMLCh src, XMLByt outPtr+= encodedBytes; } -static void change_case_UTF8(XMLCh src, XMLByte*& outPtr, - const Charset::UTF8CaseTable& table) { +static void change_case_UTF8(XMLCh src, XMLByte*& outPtr, const Charset::UTF8CaseTable& table) { store_UTF8(change_case_UTF8(src, table), outPtr); -}; -void change_case_UTF8(const XMLByte* srcData, size_t srcLen, - XMLByte* toFill, size_t toFillLen, - const Charset::UTF8CaseTable& table) { +} + +void change_case_UTF8(const XMLByte* srcData, size_t srcLen, XMLByte* toFill, size_t toFillLen, const Charset::UTF8CaseTable& table) { const XMLByte* srcPtr=srcData; const XMLByte* srcEnd=srcData+srcLen; XMLByte* outPtr=toFill; @@ -794,9 +895,7 @@ void change_case_UTF8(const XMLByte* src break; default: - throw Exception(0, - 0, - "change_case_UTF8 error: wrong trailingBytes value(%d)", trailingBytes); + throw Exception(0, 0, "change_case_UTF8 error: wrong trailingBytes value(%d)", trailingBytes); } tmpVal-=gUTFOffsets[trailingBytes]; @@ -806,15 +905,11 @@ void change_case_UTF8(const XMLByte* src if(!(tmpVal & 0xFFFF0000)) change_case_UTF8(tmpVal, outPtr, table); else - throw Exception(0, - 0, - "change_case_UTF8 error: too big tmpVal(0x%08X)", tmpVal); + throw Exception(0, 0, "change_case_UTF8 error: too big tmpVal(0x%08X)", tmpVal); } if(srcPtr!=outPtr) - throw Exception(0, - 0, - "change_case_UTF8 error: end pointers do not match"); + throw Exception(0, 0, "change_case_UTF8 error: end pointers do not match"); } static size_t getDecNumLength(XMLCh UTF8Char){ @@ -829,33 +924,23 @@ static size_t getDecNumLength(XMLCh UTF8 } const String::C Charset::transcodeFromUTF8(const String::C src) const { - size_t src_length=src.length; - + int src_length=src.length; #ifdef PRECALCULATE_DEST_LENGTH - size_t 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)){ - if(charSize==1) - dest_length++; - else - dest_length+=(UTF8Char & 0xFFFF0000) - ?charSize*3 // '%XX' for each byte - :(xlatOneTo(UTF8Char, tables, 0)!=0) - ?1 // can convert it to single char - :getDecNumLength(UTF8Char)+3; // &#XX; - &#XXXXX; + 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;') - size_t dest_length=src_length*6; + int dest_length=src_length*6; #endif - //throw Exception(0,0,"%u",dest_length); - #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*/]; @@ -863,9 +948,7 @@ const String::C Charset::transcodeFromUT (XMLByte *)src.str, src_length, dest_body, dest_length, tables)<0) - throw Exception(0, - 0, - "Charset::transcodeFromUTF8 buffer overflow"); + throw Exception(0, 0, "Charset::transcodeFromUTF8 buffer overflow"); assert(dest_length<=saved_dest_length); dest_body[dest_length]=0; // terminator @@ -873,8 +956,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 String::C Charset::transcodeToCharset(const String::C src, const Charset& dest_charset) const { if(&dest_charset==this) return src; else { @@ -906,49 +988,24 @@ void Charset::store_Char(XMLByte*& outPt static const Charset::Tables* tables[MAX_CHARSETS]; -#ifdef PA_PATCHED_LIBXML_BACKWARD - -#define declareXml256ioFuncs(i) \ - static int xml256CharEncodingInputFunc##i( \ - unsigned char *out, int *outlen, \ - const unsigned char *in, int *inlen, void*) { \ - return transcodeToUTF8( \ - in, *(size_t*)inlen, \ - out, *(size_t*)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, \ - *tables[i]); \ - } - -#else - #define declareXml256ioFuncs(i) \ static int xml256CharEncodingInputFunc##i( \ 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]); \ } -#endif - - declareXml256ioFuncs(0) declareXml256ioFuncs(1) declareXml256ioFuncs(2) declareXml256ioFuncs(3) declareXml256ioFuncs(4) declareXml256ioFuncs(5) @@ -973,35 +1030,16 @@ static size_t handlers_count=0; void Charset::addEncoding(char *name_cstr) { if(handlers_count==MAX_CHARSETS) - throw Exception(0, - 0, - "already allocated %d handlers, no space for new encoding '%s'", - MAX_CHARSETS, name_cstr); - - xmlCharEncodingHandler* handler=new(UseGC) xmlCharEncodingHandler; - { - handler->name=name_cstr; - handler->input=inputFuncs[handlers_count]; - handler->output=outputFuncs[handlers_count]; - ::tables[handlers_count]=&tables; - handlers_count++; - } - - xmlRegisterCharEncodingHandler(handler); - -} - -void Charset::initTranscoder(const String::Body NAME, const char* name_cstr) { - ftranscoder=xmlFindCharEncodingHandler(name_cstr); - transcoder(NAME); // check right way -} + throw Exception(0, 0, "already allocated %d handlers, no space for new encoding '%s'", MAX_CHARSETS, name_cstr); -xmlCharEncodingHandler& Charset::transcoder(const String::Body NAME) { - if(!ftranscoder) - throw Exception(PARSER_RUNTIME, - new String(NAME, String::L_TAINTED), - "unsupported encoding"); - return *ftranscoder; + ftranscoder_input=inputFuncs[handlers_count]; + ftranscoder_output=outputFuncs[handlers_count]; + ::tables[handlers_count++]=&tables; + + xmlCharEncodingHandler* handler=xmlNewCharEncodingHandler(name_cstr, ftranscoder_input, ftranscoder_output); + if(!handler) + throw Exception(0, new String(name_cstr, String::L_TAINTED), "unable to register XML encoding handler"); + xmlRegisterCharEncodingHandler(handler); } String::C Charset::transcode_cstr(const xmlChar* s) { @@ -1016,29 +1054,21 @@ String::C Charset::transcode_cstr(const char *out=new(PointerFreeGC) char[outlen+1]; int error; - if(xmlCharEncodingOutputFunc output=transcoder(FNAME).output) { - error=output( - (unsigned char*)out, &outlen, - (const unsigned char*)s, &inlen -#ifdef PA_PATCHED_LIBXML_BACKWARD - ,0 -#endif - ); + if(!fisUTF8) { + error=ftranscoder_output((unsigned char*)out, &outlen, (const unsigned char*)s, &inlen); } else { memcpy(out, s, outlen=inlen); error=0; } if(error<0) - throw Exception(0, - 0, - "transcode_cstr failed (%d)", error); + throw Exception(0, 0, "transcode_cstr failed (%d)", error); assert(outlen<=saved_outlen); out[outlen]=0; return String::C(out, outlen); } 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 @@ -1049,19 +1079,13 @@ xmlChar* Charset::transcode_buf2xchar(co #ifndef NDEBUG int saved_outlen; #endif - if(xmlCharEncodingInputFunc input=transcoder(FNAME).input) { + if(!fisUTF8) { outlen=buf_size*6/*max UTF8 bytes per char*/; #ifndef NDEBUG saved_outlen=outlen; #endif out=(xmlChar*)xmlMalloc(outlen+1); - error=input( - out, &outlen, - (const unsigned char*)buf, (int*)&buf_size -#ifdef PA_PATCHED_LIBXML_BACKWARD - ,0 -#endif - ); + error=ftranscoder_input(out, &outlen, (const unsigned char*)buf, (int*)&buf_size); } else { outlen=buf_size; #ifndef NDEBUG @@ -1073,51 +1097,34 @@ xmlChar* Charset::transcode_buf2xchar(co } if(error<0) - throw Exception(0, - 0, - "transcode_buf failed (%d)", error); + throw Exception(0, 0, "transcode_buf failed (%d)", error); 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 -String::Body Charset::transcode(const String::Body src, - const Charset& source_transcoder, - const Charset& dest_transcoder) { - - const char *src_ptr=src.cstr(); - size_t src_size=strlen(src_ptr); - - String::C dest=Charset::transcode(String::C(src_ptr, src_size), - source_transcoder, - dest_transcoder); - - return String::Body(dest.str, dest.length); +String::Body Charset::transcode(const String::Body src, const Charset& source_transcoder, const Charset& dest_transcoder) { + return String::Body(Charset::transcode(String::C(src.cstr(), src.length()), source_transcoder, dest_transcoder)); } -String& Charset::transcode(const String& src, - const Charset& source_transcoder, - const Charset& dest_transcoder) { - if(!src.length()) - return *new String("", 0, false); +String& Charset::transcode(const String& src, const Charset& source_transcoder, const Charset& dest_transcoder) { + if(src.is_empty()) + return *new String(); return *new String(transcode((String::Body)src, source_transcoder, dest_transcoder), String::L_CLEAN); } -void Charset::transcode(ArrayString& src, - const Charset& source_transcoder, - const Charset& dest_transcoder) { +void Charset::transcode(ArrayString& src, const Charset& source_transcoder, const Charset& dest_transcoder) { for(size_t i=0; isource_transcoder, - *info->dest_transcoder); +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) { +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-- && skipChar(ptr, srcEnd)); + while(charPos-- && skipUTF8Char(ptr, srcEnd)); return ptr-srcBegin; } @@ -1154,22 +1155,68 @@ size_t getUTF8CharPos(const XMLByte* src size_t charPos=0; const XMLByte* ptr=srcBegin; const XMLByte* ptrEnd=srcBegin+bytePos; - while(skipChar(ptr, srcEnd)){ + 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"); + throw Exception(0, 0, "Error conversion byte pos to char pos"); } size_t lengthUTF8(const XMLByte* srcBegin, const XMLByte* srcEnd){ size_t size=0; - while(skipChar(srcBegin, srcEnd)) + while(skipUTF8Char(srcBegin, srcEnd)) size++; return size; } + +unsigned int lengthUTF8Char(const XMLByte c){ + return gUTFBytes[c]+1; +} + +const char *fixUTF8(const char *src){ + if(src && *src){ + size_t length=strlen(src); + + int error_offset; + if(pa_pcre_valid_utf((unsigned char *)src, length, &error_offset)){ + + char *result=(char *)pa_malloc_atomic(length+1); + char *dst=result; + + do { + + if(error_offset){ + memcpy(dst, src, error_offset); + dst+=error_offset; + + src+=error_offset; + length-=error_offset; + + } + + *dst++='?'; + src++; + length--; + + } while (length && pa_pcre_valid_utf((unsigned char *)src, length, &error_offset)); + + if(length){ + strcpy(dst, src); + } else { + *dst='\0'; + } + + return result; + } + } + return src; +} + +bool UTF8_string_iterator::has_next(){ + fcharSize=readUTF8Char(fsrcPtr, fsrcEnd, ffirstByte, fUTF8Char); + return fcharSize!=0; +}