--- parser3/src/main/pa_charset.C 2003/06/27 08:36:59 1.33.2.19.2.26 +++ parser3/src/main/pa_charset.C 2008/05/22 16:18:03 1.57 @@ -1,11 +1,11 @@ /** @file Parser: Charset connection implementation. - Copyright(c) 2001-2003 ArtLebedev Group (http://www.artlebedev.com) + Copyright(c) 2001-2005 ArtLebedev Group (http://www.artlebedev.com) Author: Alexander Petrosyan(http://paf.design.ru) */ -static const char* IDENT_CHARSET_C="$Date: 2003/06/27 08:36:59 $"; +static const char * const IDENT_CHARSET_C="$Date: 2008/05/22 16:18:03 $"; #include "pa_charset.h" #include "pa_charsets.h" @@ -14,13 +14,31 @@ static const char* IDENT_CHARSET_C="$Dat #include "libxml/encoding.h" #endif +//#define PA_PATCHED_LIBXML_BACKWARD + +// globals + +Charset::UTF8CaseTable::Rec UTF8CaseToUpperRecords[]={ +#include "utf8-to-upper.inc" +}; +Charset::UTF8CaseTable UTF8CaseToUpper={ + sizeof(UTF8CaseToUpperRecords)/sizeof(Charset::UTF8CaseTable::Rec), + UTF8CaseToUpperRecords}; + +Charset::UTF8CaseTable::Rec UTF8CaseToLowerRecords[]={ +#include "utf8-to-lower.inc" +}; +Charset::UTF8CaseTable UTF8CaseToLower={ + sizeof(UTF8CaseToLowerRecords)/sizeof(Charset::UTF8CaseTable::Rec), + UTF8CaseToLowerRecords}; + // helpers inline void prepare_case_tables(unsigned char *tables) { unsigned char *lcc_table=tables+lcc_offset; unsigned char *fcc_table=tables+fcc_offset; for(int i=0; i<0x100; i++) - lcc_table[i]=fcc_table[i]=i; + lcc_table[i]=fcc_table[i]=(unsigned char)i; } inline void cstr2ctypes(unsigned char *tables, const unsigned char *cstr, unsigned char bit) { @@ -68,7 +86,7 @@ static void element2case(unsigned char f // methods extern "C" unsigned char pcre_default_tables[]; // pcre/chartables.c -Charset::Charset(Request_charsets* charsets, const StringBody ANAME, const String* afile_spec): +Charset::Charset(Request_charsets* charsets, const String::Body ANAME, const String* afile_spec): FNAME(ANAME), FNAME_CSTR(ANAME.cstrm()) { @@ -101,10 +119,6 @@ void Charset::load_definition(Request_ch // charset memset(&tables, 0, sizeof(tables)); - // strangly vital - tables.toTable[tables.toTableSize].intCh=0; - tables.toTable[tables.toTableSize].extCh=(XMLByte)0; - tables.toTableSize++; // loading text char *data=file_read_text(charsets, afile_spec); @@ -114,29 +128,29 @@ void Charset::load_definition(Request_ch // parse cells char *row; - while(row=getrow(&data)) { + while((row=getrow(&data))) { // remove empty&comment lines if(!*row || *row=='#') continue; // char white-space digit hex-digit letter word lowercase unicode1 unicode2 - unsigned int c=0; + unsigned char c=0; char *cell; - for(int column=0; cell=lsplit(&row, '\t'); column++) { + for(int column=0; (cell=lsplit(&row, '\t')); column++) { switch(column) { - case 0: c=to_wchar_code(cell); break; + case 0: c=(unsigned char)to_wchar_code(cell); break; // pcre_tables case 1: element2ctypes(c, to_bool(cell), pcre_tables, ctype_space, cbit_space); break; case 2: element2ctypes(c, to_bool(cell), pcre_tables, ctype_digit, cbit_digit); break; case 3: element2ctypes(c, to_bool(cell), pcre_tables, ctype_xdigit); break; case 4: element2ctypes(c, to_bool(cell), pcre_tables, ctype_letter); break; case 5: element2ctypes(c, to_bool(cell), pcre_tables, ctype_word, cbit_word); break; - case 6: element2case(c, to_wchar_code(cell), pcre_tables); break; + case 6: element2case(c, (unsigned char)to_wchar_code(cell), pcre_tables); break; case 7: case 8: // charset if(tables.toTableSize>MAX_CHARSET_UNI_CODES) - throw Exception("parser.runtime", + throw Exception(PARSER_RUNTIME, &afile_spec, "charset must contain not more then %d unicode values", MAX_CHARSET_UNI_CODES); @@ -161,8 +175,8 @@ void Charset::load_definition(Request_ch static int sort_cmp_Trans_rec_intCh(const void *a, const void *b) { return - static_cast(a)->intCh- - static_cast(b)->intCh; + static_cast(a)->intCh- + static_cast(b)->intCh; } void Charset::sort_ToTable() { @@ -176,23 +190,20 @@ void Charset::sort_ToTable() { static XMLByte xlatOneTo(const XMLCh toXlat, const Charset::Tables& tables, XMLByte not_found) { - unsigned int lowOfs = 0; - unsigned int hiOfs = tables.toTableSize - 1; - XMLByte curByte = 0; - do { + int lo = 0; + int hi = tables.toTableSize - 1; + while(lo<=hi) { // Calc the mid point of the low and high offset. - const unsigned int midOfs =((hiOfs - lowOfs) / 2)+lowOfs; - - // If our test char is greater than the mid point char, then - // we move up to the upper half. Else we move to the lower - // half. If its equal, then its our guy. - if(toXlat>tables.toTable[midOfs].intCh) - lowOfs = midOfs; - else if(toXlatcur) + lo = i+1; else - return tables.toTable[midOfs].extCh; - } while(lowOfs+1cur) + lo = i+1; + else + hi = i-1; + } + + // not found + return src; +} + +static void store_UTF8(XMLCh src, XMLByte*& outPtr ) { + if(!src) { + // use the replacement character + *outPtr++= '?'; + return; + } + + // Figure out how many bytes we need + unsigned int encodedBytes; + if(src<0x80) + encodedBytes = 1; + else if(src<0x800) + encodedBytes = 2; + else if(src<0x10000) + encodedBytes = 3; + else if(src<0x200000) + encodedBytes = 4; + else if(src<0x4000000) + encodedBytes = 5; + else if(src<= 0x7FFFFFFF) + encodedBytes = 6; + else { + // use the replacement character + *outPtr++= '?'; + return; + } + + // And spit out the bytes. We spit them out in reverse order + // here, so bump up the output pointer and work down as we go. + outPtr+= encodedBytes; + switch(encodedBytes) { + case 6: *--outPtr = XMLByte((src | 0x80UL) & 0xBFUL); + src>>= 6; + case 5: *--outPtr = XMLByte((src | 0x80UL) & 0xBFUL); + src>>= 6; + case 4: *--outPtr = XMLByte((src | 0x80UL) & 0xBFUL); + src>>= 6; + case 3: *--outPtr = XMLByte((src | 0x80UL) & 0xBFUL); + src>>= 6; + case 2: *--outPtr = XMLByte((src | 0x80UL) & 0xBFUL); + src>>= 6; + case 1: *--outPtr = XMLByte(src | gFirstByteMark[encodedBytes]); + } + + // Add the encoded bytes back in again to indicate we've eaten them + outPtr+= encodedBytes; +} + +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) { + const XMLByte* srcPtr=srcData; + const XMLByte* srcEnd=srcData+srcLen; + XMLByte* outPtr=toFill; + XMLByte* outEnd=toFill+toFillLen; + + // We now loop until we either run out of input data, or room to store + while ((srcPtr < srcEnd) && (outPtr < outEnd)) { + // Get the next leading byte out + const XMLByte firstByte =* srcPtr; + + if(firstByte<= 127) { + change_case_UTF8(firstByte, outPtr, table); + srcPtr++; + continue; + } + + // See how many trailing src bytes this sequence is going to require + const unsigned int trailingBytes = gUTFBytes[firstByte]; + + // Looks ok, so lets build up the value + 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++; + break; + + default: + throw Exception(0, + 0, + "change_case_UTF8 error: wrong trailingBytes value(%d)", trailingBytes); + } + tmpVal-=gUTFOffsets[trailingBytes]; + + // If it will fit into a single char, then put it in. Otherwise + // fail [*encode it as a surrogate pair. If its not valid, use the + // replacement char.*] + if(!(tmpVal & 0xFFFF0000)) + change_case_UTF8(tmpVal, outPtr, table); + else + 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"); +} + + 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 */; @@ -449,7 +593,7 @@ const String::C Charset::transcodeFromUT (XMLByte *)src.str, src_length, dest_body, dest_length, tables)<0) - throw(0, 0, + throw Exception(0, 0, "Charset::transcodeFromUTF8 buffer overflow"); @@ -480,10 +624,37 @@ const String::C Charset::transcodeToChar } } +XMLByte Charset::transcodeCharFromUTF8(XMLCh utf8code, XMLByte not_found){ + return xlatOneTo(utf8code, tables, not_found); +} + + #ifdef XML 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, \ @@ -502,6 +673,9 @@ static const Charset::Tables* tables[MAX *tables[i]); \ } +#endif + + declareXml256ioFuncs(0) declareXml256ioFuncs(1) declareXml256ioFuncs(2) declareXml256ioFuncs(3) declareXml256ioFuncs(4) declareXml256ioFuncs(5) @@ -531,7 +705,7 @@ void Charset::addEncoding(char *name_cst "already allocated %d handlers, no space for new encoding '%s'", MAX_CHARSETS, name_cstr); - xmlCharEncodingHandler* handler=new(PointerFreeGC) xmlCharEncodingHandler; + xmlCharEncodingHandler* handler=new(UseGC) xmlCharEncodingHandler; { handler->name=name_cstr; handler->input=inputFuncs[handlers_count]; @@ -544,25 +718,25 @@ void Charset::addEncoding(char *name_cst } -void Charset::initTranscoder(const StringBody NAME, const char* name_cstr) { +void Charset::initTranscoder(const String::Body NAME, const char* name_cstr) { ftranscoder=xmlFindCharEncodingHandler(name_cstr); transcoder(NAME); // check right way } -xmlCharEncodingHandler& Charset::transcoder(const StringBody NAME) { +xmlCharEncodingHandler& Charset::transcoder(const String::Body NAME) { if(!ftranscoder) - throw Exception("parser.runtime", + throw Exception(PARSER_RUNTIME, new String(NAME, String::L_TAINTED), "unsupported encoding"); return *ftranscoder; } -String::C Charset::transcode_cstr(xmlChar* s) { +String::C Charset::transcode_cstr(const xmlChar* s) { if(!s) return String::C("", 0); int inlen=strlen((const char*)s); - int outlen=inlen; // max + int outlen=inlen*6/*strlen("ÿ")*/; // max #ifndef NDEBUG int saved_outlen=outlen; #endif @@ -572,7 +746,11 @@ String::C Charset::transcode_cstr(xmlCha if(xmlCharEncodingOutputFunc output=transcoder(FNAME).output) { error=output( (unsigned char*)out, &outlen, - (const unsigned char*)s, &inlen); + (const unsigned char*)s, &inlen +#ifdef PA_PATCHED_LIBXML_BACKWARD + ,0 +#endif + ); } else { memcpy(out, s, outlen=inlen); error=0; @@ -585,15 +763,7 @@ String::C Charset::transcode_cstr(xmlCha assert(outlen<=saved_outlen); out[outlen]=0; return String::C(out, outlen); } -const String& Charset::transcode(xmlChar* s) { - String::C cstr=transcode_cstr(s); - return *new String(cstr.str, cstr.length, true); -} -String::C Charset::transcode_cstr(GdomeDOMString* s) { - return s?transcode_cstr(BAD_CAST s->str) - :String::C("", 0); -} -const String& Charset::transcode(GdomeDOMString* s) { +const String& Charset::transcode(const xmlChar* s) { String::C cstr=transcode_cstr(s); return *new String(cstr.str, cstr.length, true); } @@ -607,14 +777,18 @@ xmlChar* Charset::transcode_buf2xchar(co int saved_outlen; #endif if(xmlCharEncodingInputFunc input=transcoder(FNAME).input) { - outlen=buf_size*6/*max*/; + 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); + (const unsigned char*)buf, (int*)&buf_size +#ifdef PA_PATCHED_LIBXML_BACKWARD + ,0 +#endif + ); } else { outlen=buf_size; #ifndef NDEBUG @@ -633,21 +807,19 @@ xmlChar* Charset::transcode_buf2xchar(co assert(outlen<=saved_outlen); out[outlen]=0; return out; } -GdomeDOMString_auto_ptr Charset::transcode_buf2dom(const char* buf, size_t buf_size) { - return GdomeDOMString_auto_ptr(transcode_buf2xchar(buf, buf_size)); -} -GdomeDOMString_auto_ptr Charset::transcode(const String& s) { +xmlChar* Charset::transcode(const String& s) { const char* cstr=s.cstr(String::L_UNSPECIFIED); - return transcode_buf2dom(cstr, strlen(cstr)); + return transcode_buf2xchar(cstr, strlen(cstr)); } -GdomeDOMString_auto_ptr Charset::transcode(const StringBody s) { +xmlChar* Charset::transcode(const String::Body s) { const char* cstr=s.cstr(); - return transcode_buf2dom(cstr, s.length()); + return transcode_buf2xchar(cstr, s.length()); } +#endif -StringBody Charset::transcode(const StringBody src, +String::Body Charset::transcode(const String::Body src, const Charset& source_transcoder, const Charset& dest_transcoder) { @@ -658,7 +830,7 @@ StringBody Charset::transcode(const Stri source_transcoder, dest_transcoder); - return StringBody(dest.str, dest.length); + return String::Body(dest.str, dest.length); } String& Charset::transcode(const String& src, @@ -667,7 +839,7 @@ String& Charset::transcode(const String& if(!src.length()) return *new String("", 0, false); - return *new String(transcode((StringBody)src, source_transcoder, dest_transcoder), String::L_CLEAN); + return *new String(transcode((String::Body)src, source_transcoder, dest_transcoder), String::L_CLEAN); } void Charset::transcode(ArrayString& src, @@ -683,8 +855,8 @@ struct Transcode_pair_info { const Charset* dest_transcoder; }; #endif -static void transcode_pair(const StringBody akey, - StringBody& avalue, +static void transcode_pair(const String::Body /*akey*/, + String::Body& avalue, Transcode_pair_info* info) { avalue=Charset::transcode(avalue, *info->source_transcoder, @@ -694,6 +866,5 @@ void Charset::transcode(HashStringString const Charset& source_transcoder, const Charset& dest_transcoder) { Transcode_pair_info info={&source_transcoder, &dest_transcoder}; - src.for_each_ref(transcode_pair, &info); + src.for_each_ref(transcode_pair, &info); } -#endif