--- parser3/src/main/pa_charset.C 2001/12/19 16:41:02 1.6 +++ parser3/src/main/pa_charset.C 2008/07/15 12:53:10 1.60 @@ -1,30 +1,37 @@ /** @file Parser: Charset connection implementation. - Copyright(c) 2001 ArtLebedev Group(http://www.artlebedev.com) + Copyright(c) 2001-2005 ArtLebedev Group (http://www.artlebedev.com) Author: Alexander Petrosyan(http://paf.design.ru) - - $Id: pa_charset.C,v 1.6 2001/12/19 16:41:02 paf Exp $ */ +static const char * const IDENT_CHARSET_C="$Date: 2008/07/15 12:53:10 $"; + #include "pa_charset.h" -//#include "pa_exception.h" -//#include "pa_common.h" -//#include "pa_threads.h" +#include "pa_charsets.h" #ifdef XML -# include -# include -# include -# include +#include "libxml/encoding.h" #endif -// globals +//#define PA_PATCHED_LIBXML_BACKWARD +#define PRECALCULATE_DEST_LENGTH +// globals -// consts +Charset::UTF8CaseTable::Rec UTF8CaseToUpperRecords[]={ +#include "utf8-to-upper.inc" +}; +Charset::UTF8CaseTable UTF8CaseToUpper={ + sizeof(UTF8CaseToUpperRecords)/sizeof(Charset::UTF8CaseTable::Rec), + UTF8CaseToUpperRecords}; -#define MAX_CHARSET_UNI_CODES 500 +Charset::UTF8CaseTable::Rec UTF8CaseToLowerRecords[]={ +#include "utf8-to-lower.inc" +}; +Charset::UTF8CaseTable UTF8CaseToLower={ + sizeof(UTF8CaseToLowerRecords)/sizeof(Charset::UTF8CaseTable::Rec), + UTF8CaseToLowerRecords}; // helpers @@ -32,7 +39,7 @@ inline void prepare_case_tables(unsigned 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) { @@ -43,7 +50,7 @@ inline void cstr2ctypes(unsigned char *t ctypes_table[c]|=bit; } } -inline unsigned int to_wchar_code(const char *cstr) { +inline unsigned int to_wchar_code(const char* cstr) { if(!cstr || !*cstr) return 0; if(cstr[1]==0) @@ -52,7 +59,7 @@ inline unsigned int to_wchar_code(const char *error_pos; return(unsigned int)strtol(cstr, &error_pos, 0); } -inline bool to_bool(const char *cstr) { +inline bool to_bool(const char* cstr) { return cstr && *cstr!=0; } static void element2ctypes(unsigned char c, bool belongs, @@ -77,78 +84,18 @@ static void element2case(unsigned char f fcc_table[from]=to; fcc_table[to]=from; } -#ifdef XML -template class ENameMapFor2 : public ENameMap { -public: - // ----------------------------------------------------------------------- - // Constructors and Destructor - // ----------------------------------------------------------------------- - ENameMapFor2( - const XMLCh* const encodingName - , const XMLCh* const fromTable - , const XMLTransService::TransRec* const toTable - , const unsigned int toTableSize - ): ENameMap(encodingName), - ffromTable(fromTable), - ftoTable(toTable), - ftoTableSize(toTableSize) {} - - // ----------------------------------------------------------------------- - // Implementation of virtual factory method - // ----------------------------------------------------------------------- - virtual XMLTranscoder* makeNew(const unsigned int blockSize) const { - return new TType( - getKey(), - blockSize, - ffromTable, - ftoTable, ftoTableSize); - } -private: - const XMLCh* const ffromTable; - const XMLTransService::TransRec* const ftoTable; - const unsigned int ftoTableSize; - -private: - // ----------------------------------------------------------------------- - // Unimplemented constructors and operators - // ----------------------------------------------------------------------- - ENameMapFor2(); - ENameMapFor2(const ENameMapFor2&); - void operator=(const ENameMapFor2&); -}; - -class XML256TableTranscoder2 : public XML256TableTranscoder { -public : - XML256TableTranscoder2( - const XMLCh* const encodingName - , const unsigned int blockSize - , const XMLCh* const fromTable - , const XMLTransService::TransRec* const toTable - , const unsigned int toTableSize - ) : XML256TableTranscoder(encodingName, blockSize, fromTable, toTable, toTableSize) {} - -private: - XML256TableTranscoder2(); - XML256TableTranscoder2(const XML256TableTranscoder2&); - void operator=(const XML256TableTranscoder2&); -}; -#endif - // methods extern "C" unsigned char pcre_default_tables[]; // pcre/chartables.c -Charset::Charset(Pool& apool, const String& aname, const String *file_spec): Pooled(apool), - fname(apool) { - // fname - char *name_cstr=(char *)malloc(aname.size()+1); - memcpy(name_cstr, aname.cstr(String::UL_AS_IS), aname.size()+1); - fname.APPEND_CLEAN(name_cstr, aname.size(), 0, 0); +Charset::Charset(Request_charsets* charsets, const String::Body ANAME, const String* afile_spec): + FNAME(ANAME), + FNAME_CSTR(ANAME.cstrm()) { - if(file_spec) { + if(afile_spec) { fisUTF8=false; - loadDefinition(*file_spec); + load_definition(*charsets, *afile_spec); #ifdef XML - addEncoding(name_cstr); + addEncoding(FNAME_CSTR); #endif } else { fisUTF8=true; @@ -157,17 +104,11 @@ Charset::Charset(Pool& apool, const Stri } #ifdef XML - initTranscoder(&aname, name_cstr); -#endif -} - -Charset::~Charset() { -#ifdef XML - delete transcoder; + initTranscoder(FNAME, FNAME_CSTR); #endif } -void Charset::loadDefinition(const String& file_spec) { +void Charset::load_definition(Request_charsets& charsets, const String& afile_spec) { // pcre_tables // lowcase, flipcase, bits digit+word+whitespace, masks @@ -178,57 +119,51 @@ void Charset::loadDefinition(const Strin cstr2ctypes(pcre_tables,(const unsigned char *)"*+?{^.$|()[", ctype_meta); // charset - memset(fromTable, 0, sizeof(fromTable)); - toTable=(Charset_TransRec *)calloc(sizeof(Charset_TransRec)*MAX_CHARSET_UNI_CODES); - toTableSize=0; - // strangly vital - toTable[toTableSize].intCh=0; - toTable[toTableSize].extCh=(XMLByte)0; - toTableSize++; + memset(&tables, 0, sizeof(tables)); // loading text - char *data=file_read_text(pool(), file_spec); + char *data=file_read_text(charsets, afile_spec); // ignore header getrow(&data); // 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(toTableSize>MAX_CHARSET_UNI_CODES) - throw Exception(0, 0, - &file_spec, + 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); XMLCh unicode=(XMLCh)to_wchar_code(cell); if(!unicode && column==7/*unicode1 column*/) unicode=(XMLCh)c; if(unicode) { - if(!fromTable[c]) - fromTable[c]=unicode; - toTable[toTableSize].intCh=unicode; - toTable[toTableSize].extCh=(XMLByte)c; - toTableSize++; + if(!tables.fromTable[c]) + tables.fromTable[c]=unicode; + tables.toTable[tables.toTableSize].intCh=unicode; + tables.toTable[tables.toTableSize].extCh=(XMLByte)c; + tables.toTableSize++; } break; } @@ -239,102 +174,57 @@ void Charset::loadDefinition(const Strin sort_ToTable(); } -#ifdef XML -void Charset::addEncoding(const char *name_cstr) { - // addEncoding - XalanDOMString sencoding(name_cstr); - const XMLCh* const auto_encoding_cstr=sencoding.c_str(); - int size=sizeof(XMLCh)*(sencoding.size()+1); - XMLCh* pool_encoding_cstr=(XMLCh*)malloc(size); - memcpy(pool_encoding_cstr, auto_encoding_cstr, size); - XMLString::upperCase(pool_encoding_cstr); - - XMLPlatformUtils::fgTransService->addEncoding( - pool_encoding_cstr, - new ENameMapFor2( - pool_encoding_cstr - , fromTable - , toTable - , toTableSize - )); -} - -void Charset::initTranscoder(const String *source, const char *name_cstr) { - XMLTransService::Codes resValue; - transcoder=XMLPlatformUtils::fgTransService->makeNewTranscoderFor(name_cstr, resValue, 60); - if(!transcoder) - throw Exception(0, 0, - source, - "unsupported encoding"); -} -#endif - 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() { - _qsort(toTable, toTableSize, sizeof(*toTable), + _qsort(tables.toTable, tables.toTableSize, sizeof(*tables.toTable), sort_cmp_Trans_rec_intCh); //FILE *f=fopen("c:\\temp\\a", "wb"); - //fwrite(toTable, toTableSize, sizeof(*toTable), f); + //fwrite(tables.toTable, tables.toTableSize, sizeof(*tables.toTable), f); //fclose(f); } -XMLByte Charset::xlatOneTo(const XMLCh toXlat) const { - unsigned int lowOfs = 0; - unsigned int hiOfs = toTableSize - 1; - XMLByte curByte = 0; - do { - // 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>toTable[midOfs].intCh) - lowOfs = midOfs; - else if(toXlatcur) + lo = i+1; else - return toTable[midOfs].extCh; - } while(lowOfs+1>= 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 - outPtr+= encodedBytes; - } - - // return - adest_body=dest_body; - adest_content_length=outPtr-dest_body; -} -void Charset::transcodeFromUTF8(Pool& pool, - const void *source_body, size_t source_content_length, - const void *& adest_body, size_t& adest_content_length) const { - size_t dest_content_length=0; - XMLByte *dest_body=(XMLByte*)pool.malloc(source_content_length/*surly enough*/); - - const XMLByte* srcPtr=(const XMLByte*)source_body; - const XMLByte* srcEnd=(const XMLByte*)source_body+source_content_length; - XMLByte* outPtr=dest_body; - - // We now loop until we either run out of input data - while(srcPtr= here because we are implicitly - // counting the 1 byte we get no matter what. - if(srcPtr+trailingBytes>= srcEnd) - break; - - // 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, - 0, - "transcodeFromUTF8 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)) - *outPtr++= xlatOneTo(tmpVal); - else - throw Exception(0, 0, + // use the replacement character + *outPtr++= '?'; + srcPtr++; + continue; + } + + // Figure out how many bytes we need + unsigned int encodedBytes; + if(curVal<0x80) + encodedBytes = 1; + else if(curVal<0x800) + encodedBytes = 2; + else if(curVal<0x10000) + encodedBytes = 3; + else if(curVal<0x200000) + encodedBytes = 4; + else if(curVal<0x4000000) + encodedBytes = 5; + else if(curVal<= 0x7FFFFFFF) + encodedBytes = 6; + else { + // use the replacement character + *outPtr++= '?'; + srcPtr++; + continue; + } + + // If we cannot fully get this char into the output buffer + if (outPtr + encodedBytes > outEnd) + break; + + // We can do it, so update the source index + srcPtr++; + + // 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((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 + outPtr+= encodedBytes; + } + + // Update the bytes eaten + srcLen = srcPtr - srcData; + + // Return the characters read + toFillLen = outPtr - toFill; + + //return srcPtr==srcEnd?(int)toFillLen:-1; +/* +xmlCharEncodingInputFunc +Returns : +the number of byte written, or -1 by lack of space, or -2 if the transcoding failed. The value of inlen after return is the +number of octets consumed as the return value is positive, else unpredictiable. The value of outlen after return is the number +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) { + 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; + + // Special-case ASCII, which is a leading byte value of<= 127 + if(firstByte<=127) { + *outPtr++= firstByte; + srcPtr++; + continue; + } + + // See how many trailing src bytes this sequence is going to require + const unsigned int trailingBytes = gUTFBytes[firstByte]; + + // If there are not enough source bytes to do this one, then we + // are done. Note that we done>= here because we are implicitly + // counting the 1 byte we get no matter what. + if(srcPtr+trailingBytes>= srcEnd) + break; + + // 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, - "transcodeFromUTF8 error: too big tmpVal(0x%08X)", tmpVal); + "transcodeFromUTF8 error: wrong trailingBytes value(%d)", trailingBytes); // never + } + 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)) { + if(XMLByte xlat=xlatOneTo(tmpVal, tables, 0)) + *outPtr++=xlat; + else { + outPtr+=sprintf((char *)outPtr, "&#%u;", tmpVal); // &#decimal; + } + } else { + const XMLByte* recoverPtr=srcPtr-trailingBytes-1; + for(uint i=0; i<=trailingBytes; i++) + outPtr+=sprintf((char*)outPtr, "%%%02X", *recoverPtr++); + } } + + // Update the bytes eaten + srcLen = srcPtr - srcData; + + // Return the characters read + toFillLen = outPtr - toFill; - // return - adest_body=dest_body; - adest_content_length=outPtr-dest_body; + //return srcPtr==srcEnd?(int)toFillLen:-1; +/* +xmlCharEncodingOutputFunc +Returns : +the number of byte written, or -1 by lack of space, or -2 if the transcoding failed. The value of inlen after return is the +number of octets consumed as the return value is positive, else unpredictiable. The value of outlen after return is the number +of ocetes consumed. +*/ + return 0; } -/// transcode using both charsets -void Charset::transcodeToCharset(Pool& pool, - const Charset& dest_charset, - const void *source_body, size_t source_content_length, - const void *& adest_body, size_t& adest_content_length) const { - if(&dest_charset==this) { - adest_body=source_body; - adest_content_length=source_content_length; +static bool is_escaped(char c){ + return + !(c<=127 + && ( + ((c>='0') && (c<='9')) + || ((c>='A') && (c<='Z')) + || ((c>='a') && (c<='z')) + || 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){ + 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; +} + +// read char, return number of bytes needed for store it as 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; +} + +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 + } + + // Update the bytes eaten + srcLen=srcPtr-srcData; + + // Return the characters read + toFillLen=outPtr-toFill; + + return 0; +} + +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 + } + + // Update the bytes eaten + srcLen = srcPtr - srcData; + + // Return the characters read + toFillLen = outPtr - toFill; + + return 0; +} + + +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_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 { - size_t dest_content_length=source_content_length; - unsigned char *dest_body=(unsigned char *)pool.malloc(dest_content_length); + 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' + } + } +#else + size_t dest_length=src_length*6; // enough for %uXXXX but too memory-hungry +#endif - const XMLByte* srcPtr=(const XMLByte*)source_body; - const XMLByte* srcEnd=(const XMLByte*)source_body+source_content_length; + //throw Exception(0,0,"%u",dest_length); - for(XMLByte* outPtr=dest_body; srcPtrcur) + 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"); +} + +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; + +#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; + } +#else + // so that surly enough, "&#XXX;" has max ratio (huh? 8 bytes needed for '&#XXXXX;') + size_t dest_length=src_length*6; +#endif + + //throw Exception(0,0,"%u",dest_length); - adest_body=dest_body; - adest_content_length=dest_content_length; +#ifndef NDEBUG + size_t saved_dest_length=dest_length; +#endif + XMLByte *dest_body=new(PointerFreeGC) XMLByte[dest_length+1/*for terminator*/]; + + if(::transcodeFromUTF8( + (XMLByte *)src.str, src_length, + dest_body, dest_length, + tables)<0) + throw Exception(0, + 0, + "Charset::transcodeFromUTF8 buffer overflow"); + + 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 { + if(&dest_charset==this) + return src; + else { + size_t dest_length=src.length; + XMLByte* dest_body=new(PointerFreeGC) XMLByte[dest_length+1/*for terminator*/]; + + XMLByte* output=dest_body; + const XMLByte* input=(XMLByte *)src.str; + while(XMLCh c=*input++) { + XMLCh curVal = tables.fromTable[c]; + *output++=curVal? + xlatOneTo(curVal, dest_charset.tables, '?') // OK + :'?'; // use the replacement character + } + + dest_body[dest_length]=0; // terminator + return String::C((char*)dest_body, dest_length); } } +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 -const char *Charset::transcode_cstr(const XalanDOMString& s) { - const unsigned int len=s.size()*2; - XMLByte* dest=(XMLByte *)malloc((len+1)*sizeof(XMLByte)); - bool error=true; - try { - if(transcoder) { - unsigned int charsEaten; - unsigned int size=transcoder->transcodeTo( - s.c_str(), s.length(), - dest, len, - charsEaten, - XMLTranscoder::UnRep_RepChar //UnRep_Throw - ); - dest[size]=0; - error=false; - } - } catch(XMLException& e) { - Exception::provide_source(pool(), 0, e); + +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, \ + *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, \ + *tables[i]); \ } - return(const char *)dest; + +#endif + + +declareXml256ioFuncs(0) declareXml256ioFuncs(1) +declareXml256ioFuncs(2) declareXml256ioFuncs(3) +declareXml256ioFuncs(4) declareXml256ioFuncs(5) +declareXml256ioFuncs(6) declareXml256ioFuncs(7) +declareXml256ioFuncs(8) declareXml256ioFuncs(9) + +static xmlCharEncodingInputFunc inputFuncs[MAX_CHARSETS]={ + xml256CharEncodingInputFunc0, xml256CharEncodingInputFunc1, + xml256CharEncodingInputFunc2, xml256CharEncodingInputFunc3, + xml256CharEncodingInputFunc4, xml256CharEncodingInputFunc5, + xml256CharEncodingInputFunc6, xml256CharEncodingInputFunc7, + xml256CharEncodingInputFunc8, xml256CharEncodingInputFunc9 +}; +static xmlCharEncodingOutputFunc outputFuncs[MAX_CHARSETS]={ + xml256CharEncodingOutputFunc0, xml256CharEncodingOutputFunc1, + xml256CharEncodingOutputFunc2, xml256CharEncodingOutputFunc3, + xml256CharEncodingOutputFunc4, xml256CharEncodingOutputFunc5, + xml256CharEncodingOutputFunc6, xml256CharEncodingOutputFunc7, + xml256CharEncodingOutputFunc8, xml256CharEncodingOutputFunc9 +}; +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 +} + +xmlCharEncodingHandler& Charset::transcoder(const String::Body NAME) { + if(!ftranscoder) + throw Exception(PARSER_RUNTIME, + new String(NAME, String::L_TAINTED), + "unsupported encoding"); + return *ftranscoder; } -String& Charset::transcode(const XalanDOMString& s) { - return *NEW String(pool(), transcode_cstr(s)); -} - -std::auto_ptrCharset::transcode_buf(const char *buf, size_t buf_size) { - unsigned int dest_size=0; - XMLCh* dest=(XMLCh *)malloc((buf_size+1)*sizeof(XMLCh)); - unsigned char *charSizes=(unsigned char *)malloc(buf_size*sizeof(unsigned char)); - XalanDOMString *result; - try { - if(transcoder) { - unsigned int bytesEaten; - unsigned int dest_size=transcoder->transcodeFrom( - (unsigned char *)buf, - (const unsigned int)buf_size, - dest,(const unsigned int)buf_size, - bytesEaten, - charSizes + +String::C Charset::transcode_cstr(const xmlChar* s) { + if(!s) + return String::C("", 0); + + int inlen=strlen((const char*)s); + int outlen=inlen*6/*strlen("ÿ")*/; // max +#ifndef NDEBUG + int saved_outlen=outlen; +#endif + 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 ); - result=new XalanDOMString(dest, dest_size); - } - } catch(XMLException& e) { - Exception::provide_source(pool(), 0, e); - result=0; //calm, compiler + } else { + memcpy(out, s, outlen=inlen); + error=0; + } + if(error<0) + 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); +} + +/// @test less memory using -maybe- xmlParserInputBufferCreateMem +xmlChar* Charset::transcode_buf2xchar(const char* buf, size_t buf_size) { + xmlChar* out; + int outlen; + int error; +#ifndef NDEBUG + int saved_outlen; +#endif + if(xmlCharEncodingInputFunc input=transcoder(FNAME).input) { + 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 + ); + } else { + outlen=buf_size; +#ifndef NDEBUG + saved_outlen=outlen; +#endif + out=(xmlChar*)xmlMalloc(outlen+1); + memcpy(out, buf, outlen); + error=0; } - return std::auto_ptr(result); + if(error<0) + 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)); } -std::auto_ptrCharset::transcode(const String& s) { - const char *cstr=s.cstr(String::UL_UNSPECIFIED); +xmlChar* Charset::transcode(const String::Body s) { + const char* cstr=s.cstr(); - return transcode_buf(cstr, strlen(cstr)); + return transcode_buf2xchar(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& Charset::transcode(const String& src, + const Charset& source_transcoder, + const Charset& dest_transcoder) { + if(!src.length()) + return *new String("", 0, false); + + 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) { + for(size_t i=0; isource_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); +}