--- parser3/src/main/pa_charset.C 2001/12/15 21:49:18 1.3 +++ parser3/src/main/pa_charset.C 2002/01/21 16:44:48 1.16 @@ -1,22 +1,16 @@ /** @file Parser: Charset connection implementation. - Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com) - Author: Alexander Petrosyan (http://paf.design.ru) + Copyright(c) 2001 ArtLebedev Group(http://www.artlebedev.com) + Author: Alexander Petrosyan(http://paf.design.ru) - $Id: pa_charset.C,v 1.3 2001/12/15 21:49:18 paf Exp $ + $Id: pa_charset.C,v 1.16 2002/01/21 16:44:48 paf Exp $ */ #include "pa_charset.h" -//#include "pa_exception.h" -//#include "pa_common.h" -//#include "pa_threads.h" #ifdef XML -# include -# include -# include -# include +#include "libxml/encoding.h" #endif // globals @@ -47,10 +41,10 @@ inline unsigned int to_wchar_code(const if(!cstr || !*cstr) return 0; if(cstr[1]==0) - return (unsigned int)(unsigned char)cstr[0]; + return(unsigned int)(unsigned char)cstr[0]; char *error_pos; - return (unsigned int)strtol(cstr, &error_pos, 0); + return(unsigned int)strtol(cstr, &error_pos, 0); } inline bool to_bool(const char *cstr) { return cstr && *cstr!=0; @@ -64,7 +58,7 @@ static void element2ctypes(unsigned char ctypes_table[c]|=bit; if(group_offset>=0) - tables[cbits_offset+group_offset+c/8] |= 1 << (c%8); + tables[cbits_offset+group_offset+c/8] |= 1<<(c%8); } static void element2case(unsigned char from, unsigned char to, unsigned char *tables) { @@ -77,82 +71,25 @@ 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(Pool& apool, const String& aname, const String *request_file_spec): Pooled(apool), + fname(aname) { + + char *name_cstr=fname.cstr(); + for(char *c=name_cstr; *c; c++) + *c = toupper(*c); - if(file_spec) { + if(request_file_spec) { fisUTF8=false; - loadDefinition(*file_spec); + loadDefinition(*request_file_spec); #ifdef XML addEncoding(name_cstr); #endif } else { fisUTF8=true; - // grab default onces [for UTF-8 so to be able to make a-z => A-Z + // 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)); } @@ -163,11 +100,11 @@ Charset::Charset(Pool& apool, const Stri Charset::~Charset() { #ifdef XML - delete transcoder; + // not deleting transcoder, that's not our business #endif } -void Charset::loadDefinition(const String& file_spec) { +void Charset::loadDefinition(const String& request_file_spec) { // pcre_tables // lowcase, flipcase, bits digit+word+whitespace, masks @@ -175,20 +112,19 @@ void Charset::loadDefinition(const Strin // don't know the size there memset(pcre_tables, 0, sizeof(pcre_tables)); prepare_case_tables(pcre_tables); - cstr2ctypes(pcre_tables, (const unsigned char *)"*+?{^.$|()[", ctype_meta); + cstr2ctypes(pcre_tables,(const unsigned char *)"*+?{^.$|()[", ctype_meta); // charset - memset(fromTable, 0, sizeof(fromTable)); - toTable=(XMLTransService::TransRec *)calloc( - sizeof(XMLTransService::TransRec)*MAX_CHARSET_UNI_CODES); - toTableSize=0; + memset(tables.fromTable, 0, sizeof(tables.fromTable)); + tables.toTable=(Charset_TransRec *)calloc(sizeof(Charset_TransRec)*MAX_CHARSET_UNI_CODES); + tables.toTableSize=0; // strangly vital - toTable[toTableSize].intCh=0; - toTable[toTableSize].extCh=(XMLByte)0; - toTableSize++; + tables.toTable[tables.toTableSize].intCh=0; + tables.toTable[tables.toTableSize].extCh=(XMLByte)0; + tables.toTableSize++; // loading text - char *data=file_read_text(pool(), file_spec); + char *data=file_read_text(pool(), request_file_spec); // ignore header getrow(&data); @@ -216,20 +152,20 @@ void Charset::loadDefinition(const Strin case 7: case 8: // charset - if(toTableSize>MAX_CHARSET_UNI_CODES) + if(tables.toTableSize>MAX_CHARSET_UNI_CODES) throw Exception(0, 0, - &file_spec, + &request_file_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; } @@ -240,36 +176,6 @@ 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- @@ -277,31 +183,32 @@ static int sort_cmp_Trans_rec_intCh(cons } 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 { +static XMLByte xlatOneTo(const XMLCh toXlat, + const Charset::Tables& tables) { unsigned int lowOfs = 0; - unsigned int hiOfs = toTableSize - 1; + unsigned int hiOfs = tables.toTableSize - 1; XMLByte curByte = 0; do { // Calc the mid point of the low and high offset. - const unsigned int midOfs = ((hiOfs - lowOfs) / 2) + lowOfs; + 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) + if(toXlat>tables.toTable[midOfs].intCh) lowOfs = midOfs; - else if (toXlat < toTable[midOfs].intCh) + else if(toXlat 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; + 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]); + 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; + outPtr+= encodedBytes; } - // return - adest_body=dest_body; - adest_content_length=outPtr-dest_body; + // Update the bytes eaten + srcLen = srcPtr - srcData; + + // Return the characters read + toFillLen = outPtr - toFill; + + return srcPtr==srcEnd?(int)toFillLen:-1; } -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; +static size_t 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 - while (srcPtr < srcEnd) { + // 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; + // Special-case ASCII, which is a leading byte value of<= 127 + if(firstByte<= 127) { + *outPtr++= firstByte; srcPtr++; continue; } @@ -473,9 +387,9 @@ void Charset::transcodeFromUTF8(Pool& po 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 + // are done. Note that we done>= here because we are implicitly // counting the 1 byte we get no matter what. - if (srcPtr + trailingBytes >= srcEnd) + if(srcPtr+trailingBytes>= srcEnd) break; // Looks ok, so lets build up the value @@ -492,99 +406,193 @@ void Charset::transcodeFromUTF8(Pool& po default: throw Exception(0, 0, 0, - "transcodeFromUTF8 error: wrong trailingBytes value (%d)", trailingBytes); + "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); + if(!(tmpVal & 0xFFFF0000)) + *outPtr++= xlatOneTo(tmpVal, tables); else throw Exception(0, 0, 0, - "transcodeFromUTF8 error: too big tmpVal (0x%08X)", tmpVal); + "transcodeFromUTF8 error: too big tmpVal(0x%08X)", tmpVal); } + // Update the bytes eaten + srcLen = srcPtr - srcData; + + // Return the characters read + toFillLen = outPtr - toFill; + + return srcPtr==srcEnd?(int)toFillLen:-1; +} + +/// @todo not so memory-hungry with prescan +void Charset::transcodeToUTF8(Pool& pool, + const void *source_body, size_t source_content_length, + const void *& adest_body, size_t& dest_content_length) const { + dest_content_length=source_content_length*6/*so that surly enough*/; + XMLByte *dest_body=(XMLByte*)pool.malloc(dest_content_length); + + if(::transcodeToUTF8( + (XMLByte *)source_body, source_content_length, + dest_body, dest_content_length, + tables)<0) + throw(0, 0, + 0, + "Charset::transcodeToUTF8 buffer overflow"); + + // return + adest_body=dest_body; +} +/// @test buf overflow +void Charset::transcodeFromUTF8(Pool& pool, + const void *source_body, size_t source_content_length, + const void *& adest_body, size_t& dest_content_length) const { + dest_content_length=source_content_length/*surly enough*/; + XMLByte *dest_body=(XMLByte*)pool.malloc(dest_content_length); + + if(::transcodeFromUTF8( + (XMLByte *)source_body, source_content_length, + dest_body, dest_content_length, + tables)<0) + throw(0, 0, + 0, + "Charset::transcodeToUTF8 buffer overflow"); + // return adest_body=dest_body; - adest_content_length=outPtr-dest_body; } /// transcode using both charsets void Charset::transcodeToCharset(Pool& pool, const Charset& dest_charset, const void *source_body, size_t source_content_length, - const void *& dest_body, size_t& dest_content_length) const { + const void *& adest_body, size_t& adest_content_length) const { if(&dest_charset==this) { - dest_body=source_body; - dest_content_length=source_content_length; - } else - throw Exception(0, 0, - 0, - "transcodeToCharset not supported(yet)"); -/* - void *dest_body; - - dest_body=pool.malloc(dest_content_length=source_content_length); - // dummy - memset(dest_body, '?', dest_content_length); + adest_body=source_body; + adest_content_length=source_content_length; + } else { + size_t dest_content_length=source_content_length; + unsigned char *dest_body=(unsigned char *)pool.malloc(dest_content_length); - adest_body=dest_body;*/ -} + const XMLByte* srcPtr=(XMLByte *)source_body; + const XMLByte* srcEnd=(XMLByte *)source_body+source_content_length; -#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; + for(XMLByte* outPtr=dest_body; srcPtrname=name_cstr; + handler->input=xml256CharEncodingInputFunc; handler->inputInfo=&tables; + handler->output=xml256CharEncodingOutputFunc; handler->outputInfo=&tables; + + xmlRegisterCharEncodingHandler(handler); } -std::auto_ptr Charset::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 - ); - result=new XalanDOMString(dest, dest_size); - } - } catch(XMLException& e) { - Exception::provide_source(pool(), 0, e); - result=0; //calm, compiler - } +void Charset::initTranscoder(const String *source, const char *name_cstr) { + ftranscoder=xmlFindCharEncodingHandler(name_cstr); + transcoder(source); // check right way +} + +xmlCharEncodingHandler *Charset::transcoder(const String *source) { + if(!ftranscoder) + throw Exception(0, 0, + source, + "unsupported encoding"); + return ftranscoder; +} + +const char *Charset::transcode_cstr(xmlChar *s) { + if(!s) + return ""; + + int inlen=strlen((const char *)s); + int outlen=inlen+1; // max + char *out=(char *)malloc(outlen*sizeof(char)); - return std::auto_ptr(result); + int size=transcoder(0)->output( + (unsigned char*)out, &outlen, + (const unsigned char*)s, &inlen, + transcoder(0)->outputInfo); + if(size<0) + throw Exception(0, 0, + 0, + "transcode_cstr failed (%d)", size); + + out[size]=0; + return out; +} +String& Charset::transcode(xmlChar *s) { + return *NEW String(pool(), transcode_cstr(s)); +} +const char *Charset::transcode_cstr(GdomeDOMString *s) { + return s?transcode_cstr(BAD_CAST s->str):""; +} +String& Charset::transcode(GdomeDOMString *s) { + return *NEW String(pool(), transcode_cstr(s)); +} + +/// @test less memory using -maybe- xmlParserInputBufferCreateMem +GdomeDOMString_auto_ptr Charset::transcode_buf(const char *buf, size_t buf_size) { + int outlen=buf_size*6/*max*/+1; + unsigned char *out=(unsigned char*)malloc(outlen*sizeof(unsigned char)); + int size=transcoder(0)->input( + out, &outlen, + (const unsigned char *)buf, (int *)&buf_size, + transcoder(0)->inputInfo); + if(size<0) + throw Exception(0, 0, + 0, + "transcode_buf failed (%d)", size); + + out[size]=0; + return GdomeDOMString_auto_ptr((gchar*)out); } -std::auto_ptr Charset::transcode(const String& s) { +GdomeDOMString_auto_ptr Charset::transcode(const String& s) { const char *cstr=s.cstr(String::UL_UNSPECIFIED); return transcode_buf(cstr, strlen(cstr));