--- parser3/src/main/pa_charset.C 2003/04/09 08:01:20 1.33.2.19.2.18 +++ parser3/src/main/pa_charset.C 2003/11/06 08:22:49 1.39 @@ -5,7 +5,7 @@ Author: Alexander Petrosyan(http://paf.design.ru) */ -static const char* IDENT_CHARSET_C="$Date: 2003/04/09 08:01:20 $"; +static const char* IDENT_CHARSET_C="$Date: 2003/11/06 08:22:49 $"; #include "pa_charset.h" #include "pa_charsets.h" @@ -14,6 +14,22 @@ static const char* IDENT_CHARSET_C="$Dat #include "libxml/encoding.h" #endif +// 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) { @@ -68,7 +84,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 +117,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); @@ -161,8 +173,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 +188,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+1 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; + // use the replacement character + *outPtr++= '?'; + srcPtr++; + continue; + } - // Return the characters read - toFillLen = outPtr - toFill; + // 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 @@ -340,73 +348,72 @@ 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, 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: 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)) { + // 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: 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)) { if(XMLByte xlat=xlatOneTo(tmpVal, tables, 0)) *outPtr++=xlat; else outPtr+=sprintf((char *)outPtr, "&#%d;", tmpVal); // &#decimal; } else throw Exception(0, - 0, - "transcodeFromUTF8 error: too big tmpVal(0x%08X)", tmpVal); + 0, + "transcodeFromUTF8 error: too big tmpVal(0x%08X)", tmpVal); } - - // Update the bytes eaten - srcLen = srcPtr - srcData; - - // Return the characters read - toFillLen = outPtr - toFill; + + // Update the bytes eaten + srcLen = srcPtr - srcData; + + // Return the characters read + toFillLen = outPtr - toFill; //return srcPtr==srcEnd?(int)toFillLen:-1; /* @@ -423,6 +430,9 @@ of ocetes consumed. const String::C Charset::transcodeToUTF8(const String::C src) const { size_t src_length=src.length; size_t dest_length=src.length*6/*so that surly enough, max utf8 seq len=6*/; +#ifndef NDEBUG + size_t saved_dest_length=dest_length; +#endif XMLByte *dest_body=new(PointerFreeGC) XMLByte[dest_length+1/*for terminator*/]; if(::transcodeToUTF8( @@ -433,12 +443,140 @@ const String::C Charset::transcodeToUTF8 0, "Charset::transcodeToUTF8 buffer overflow"); - dest_body[dest_length]=0; // terminator + assert(dest_length<=saved_dest_length); dest_body[dest_length]=0; // terminator return String::C((char*)dest_body, dest_length); } + +static XMLCh change_case_UTF8(const XMLCh src, const Charset::UTF8CaseTable& table) { + int lo = 0; + int hi = table.size - 1; + while(lo<=hi) { + // Calc the mid point of the low and high offset. + const unsigned int i = (lo + hi) / 2; + + XMLCh cur=table.records[i].from; + if(src==cur) + return table.records[i].to; + if(src>cur) + 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, XMLByte* toFill, + const Charset::UTF8CaseTable& table) { + const XMLByte* srcPtr=srcData; + XMLByte* outPtr=toFill; + + // Get the next leading byte out + while (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 */; +#ifndef NDEBUG + size_t saved_dest_length=dest_length; +#endif XMLByte *dest_body=new(PointerFreeGC) XMLByte[dest_length+1/*for terminator*/]; if(::transcodeFromUTF8( @@ -449,7 +587,7 @@ const String::C Charset::transcodeFromUT 0, "Charset::transcodeFromUTF8 buffer overflow"); - dest_body[dest_length]=0; // terminator + assert(dest_length<=saved_dest_length); dest_body[dest_length]=0; // terminator return String::C((char*)dest_body, dest_length); } @@ -540,12 +678,12 @@ 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", new String(NAME, String::L_TAINTED), @@ -553,13 +691,16 @@ xmlCharEncodingHandler& Charset::transco return *ftranscoder; } -const char* Charset::transcode_cstr(xmlChar* s) { +String::C Charset::transcode_cstr(xmlChar* s) { if(!s) - return ""; + return String::C("", 0); - int inlen=strlen((const char* )s); - int outlen=inlen+1; // max - char *out=new(PointerFreeGC) char[outlen]; + int inlen=strlen((const char*)s); + int outlen=inlen; // max +#ifndef NDEBUG + int saved_outlen=outlen; +#endif + char *out=new(PointerFreeGC) char[outlen+1]; int error; if(xmlCharEncodingOutputFunc output=transcoder(FNAME).output) { @@ -575,34 +716,45 @@ const char* Charset::transcode_cstr(xmlC 0, "transcode_cstr failed (%d)", error); - out[outlen/*surely would be less then on input*/]=0; - return out; + assert(outlen<=saved_outlen); out[outlen]=0; + return String::C(out, outlen); } const String& Charset::transcode(xmlChar* s) { - return *new String(transcode_cstr(s), 0/*auto-size*/, true); + String::C cstr=transcode_cstr(s); + return *new String(cstr.str, cstr.length, true); } -const char* Charset::transcode_cstr(GdomeDOMString* s) { - return s?transcode_cstr(BAD_CAST s->str):""; +String::C Charset::transcode_cstr(GdomeDOMString* s) { + return s?transcode_cstr(BAD_CAST s->str) + :String::C("", 0); } const String& Charset::transcode(GdomeDOMString* s) { - return *new String(transcode_cstr(s), 0/*auto-size*/, true); + String::C cstr=transcode_cstr(s); + return *new String(cstr.str, cstr.length, true); } /// @test less memory using -maybe- xmlParserInputBufferCreateMem -void* Charset::transcode_buf2mchar(transcode_buf_malloc_func malloc_func, - const char* buf, size_t buf_size) { - unsigned char* out; +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*/; - out=(unsigned char*)malloc_func(outlen+1); +#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); } else { outlen=buf_size; - out=(unsigned char*)malloc_func(outlen+1); +#ifndef NDEBUG + saved_outlen=outlen; +#endif + out=(xmlChar*)xmlMalloc(outlen+1); memcpy(out, buf, outlen); error=0; } @@ -612,30 +764,70 @@ void* Charset::transcode_buf2mchar(trans 0, "transcode_buf failed (%d)", error); - out[outlen/*surely would be less then on input*/]=0; + assert(outlen<=saved_outlen); out[outlen]=0; return out; } - -xmlChar* Charset::transcode_buf2xchar(const char* buf, size_t buf_size) { - return static_cast(transcode_buf2mchar(xmlMalloc, buf, buf_size)); -} -static void* g_malloc_wrapper(size_t size) { - return g_malloc(size); -} -gchar* Charset::transcode_buf2gchar(const char* buf, size_t buf_size) { - return static_cast(transcode_buf2mchar(g_malloc_wrapper, buf, buf_size)); -} GdomeDOMString_auto_ptr Charset::transcode_buf2dom(const char* buf, size_t buf_size) { - return GdomeDOMString_auto_ptr(transcode_buf2gchar(buf, buf_size)); + return GdomeDOMString_auto_ptr(transcode_buf2xchar(buf, buf_size)); } GdomeDOMString_auto_ptr Charset::transcode(const String& s) { const char* cstr=s.cstr(String::L_UNSPECIFIED); return transcode_buf2dom(cstr, strlen(cstr)); } -GdomeDOMString_auto_ptr Charset::transcode(const StringBody s) { +GdomeDOMString_auto_ptr Charset::transcode(const String::Body s) { const char* cstr=s.cstr(); return transcode_buf2dom(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); +}