--- parser3/src/main/pa_charset.C 2003/03/24 13:43:41 1.33.2.19.2.6 +++ parser3/src/main/pa_charset.C 2003/04/10 08:58:21 1.33.2.19.2.22 @@ -5,7 +5,7 @@ Author: Alexander Petrosyan(http://paf.design.ru) */ -static const char* IDENT_CHARSET_C="$Date: 2003/03/24 13:43:41 $"; +static const char* IDENT_CHARSET_C="$Date: 2003/04/10 08:58:21 $"; #include "pa_charset.h" #include "pa_charsets.h" @@ -68,18 +68,15 @@ static void element2case(unsigned char f // methods extern "C" unsigned char pcre_default_tables[]; // pcre/chartables.c -Charset::Charset(const String& aname, const String* afile_spec): - fname(aname), - fname_cstr(aname.cstrm()) { - - for(char *c=fname_cstr; *c; c++) - *c = toupper(*c); +Charset::Charset(Request_charsets* charsets, const StringBody ANAME, const String* afile_spec): + FNAME(ANAME), + FNAME_CSTR(ANAME.cstrm()) { if(afile_spec) { fisUTF8=false; - load_definition(*afile_spec); + load_definition(*charsets, *afile_spec); #ifdef XML - addEncoding(fname_cstr); + addEncoding(FNAME_CSTR); #endif } else { fisUTF8=true; @@ -88,18 +85,11 @@ Charset::Charset(const String& aname, co } #ifdef XML - initTranscoder(fname, fname_cstr); -#endif -} - -Charset::~Charset() { - // @todonow unregister encodings -#ifdef XML - // not deleting transcoder, that's not our business + initTranscoder(FNAME, FNAME_CSTR); #endif } -void Charset::load_definition(const String& afile_spec) { +void Charset::load_definition(Request_charsets& charsets, const String& afile_spec) { // pcre_tables // lowcase, flipcase, bits digit+word+whitespace, masks @@ -117,7 +107,7 @@ void Charset::load_definition(const Stri tables.toTableSize++; // loading text - char *data=file_read_text(UTF8_charset, afile_spec); + char *data=file_read_text(charsets, afile_spec); // ignore header getrow(&data); @@ -184,59 +174,44 @@ 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 { - // 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; + const Charset::Tables& tables, + XMLByte not_found) { + unsigned int lowOfs = 0; + 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; + + // 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(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; - 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 @@ -445,135 +420,155 @@ of ocetes consumed. } /// @todo not so memory-hungry with prescan -void Charset::transcodeToUTF8( - 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, max utf8 seq len=6*/; - XMLByte *dest_body=new XMLByte[dest_content_length]; +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*/; + XMLByte *dest_body=new(PointerFreeGC) XMLByte[dest_length+1/*for terminator*/]; if(::transcodeToUTF8( - (XMLByte *)source_body, source_content_length, - dest_body, dest_content_length, + (XMLByte *)src.str, src_length, + dest_body, dest_length, tables)<0) throw(0, 0, 0, "Charset::transcodeToUTF8 buffer overflow"); - // return - adest_body=dest_body; + dest_body[dest_length]=0; // terminator + return String::C((char*)dest_body, dest_length); } -void Charset::transcodeFromUTF8( - 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, "ÿ" has max ratio */; - XMLByte *dest_body=new XMLByte[dest_content_length]; +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 */; + XMLByte *dest_body=new(PointerFreeGC) XMLByte[dest_length+1/*for terminator*/]; if(::transcodeFromUTF8( - (XMLByte *)source_body, source_content_length, - dest_body, dest_content_length, + (XMLByte *)src.str, src_length, + dest_body, dest_length, tables)<0) throw(0, 0, 0, - "Charset::transcodeToUTF8 buffer overflow"); + "Charset::transcodeFromUTF8 buffer overflow"); - // return - adest_body=dest_body; + dest_body[dest_length]=0; // terminator + return String::C((char*)dest_body, dest_length); } /// transcode using both charsets -void Charset::transcodeToCharset( - 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; - } else { - size_t dest_content_length=source_content_length; - unsigned char *dest_body=new unsigned char[dest_content_length]; - - const XMLByte* srcPtr=(XMLByte *)source_body; - const XMLByte* srcEnd=(XMLByte *)source_body+source_content_length; - - for(XMLByte* outPtr=dest_body; srcPtrname=name_cstr; - handler->input=xml256CharEncodingInputFunc; handler->inputInfo=&tables; - handler->output=xml256CharEncodingOutputFunc; handler->outputInfo=&tables; + xmlCharEncodingHandler* handler=new(PointerFreeGC) 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* source, const char* name_cstr) { +void Charset::initTranscoder(const StringBody NAME, const char* name_cstr) { ftranscoder=xmlFindCharEncodingHandler(name_cstr); - transcoder(source); // check right way + transcoder(NAME); // check right way } -xmlCharEncodingHandler& Charset::transcoder(const String* source) { +xmlCharEncodingHandler& Charset::transcoder(const StringBody NAME) { if(!ftranscoder) throw Exception("parser.runtime", - source, + new String(NAME, String::L_TAINTED), "unsupported encoding"); return *ftranscoder; } -const char* Charset::transcode_cstrxmlChar* s) { +const char* Charset::transcode_cstr(xmlChar* s) { if(!s) return ""; - 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(0).output) { + if(xmlCharEncodingOutputFunc output=transcoder(FNAME).output) { error=output( (unsigned char*)out, &outlen, - (const unsigned char*)s, &inlen, - transcoder(0).outputInfo); + (const unsigned char*)s, &inlen); } else { memcpy(out, s, outlen=inlen); error=0; @@ -583,48 +578,42 @@ const char* Charset::transcode_cstrxmlCh 0, "transcode_cstr failed (%d)", error); - out[outlen/*surely would be less then on input*/]=0; + assert(outlen<=saved_outlen); out[outlen]=0; return out; } -const String& Charset::transcodexmlChar* s -#ifndef NO_STRING_ORIGIN - , const String& origin -#endif - ) { - const String& result(new String()); - result->APPEND_CLEAN( - transcode_cstr(s), 0/*auto-size*/, - origin->origin().file, origin->origin().line); - return result; +const String& Charset::transcode(xmlChar* s) { + return *new String(transcode_cstr(s), 0/*auto-size*/, true); } -const char* Charset::transcode_cstrGdomeDOMString* s) { +const char* Charset::transcode_cstr(GdomeDOMString* s) { return s?transcode_cstr(BAD_CAST s->str):""; } -const String& Charset::transcodeGdomeDOMString* s -#ifndef NO_STRING_ORIGIN - , const String& origin -#endif - ) { - const String& result(new String()); - result->APPEND_CLEAN(transcode_cstr(s), 0/*auto-size*/, origin->origin().file, origin->origin().line); - return result; +const String& Charset::transcode(GdomeDOMString* s) { + return *new String(transcode_cstr(s), 0/*auto-size*/, true); } /// @test less memory using -maybe- xmlParserInputBufferCreateMem void* Charset::transcode_buf2mchar(transcode_buf_malloc_func malloc_func, - const char* buf, size_t buf_size) { + const char* buf, size_t buf_size) { unsigned char* out; int outlen; int error; - if(xmlCharEncodingInputFunc input=transcoder(0).input) { +#ifndef NDEBUG + int saved_outlen; +#endif + if(xmlCharEncodingInputFunc input=transcoder(FNAME).input) { outlen=buf_size*6/*max*/; +#ifndef NDEBUG + saved_outlen=outlen; +#endif out=(unsigned char*)malloc_func(outlen+1); error=input( out, &outlen, - (const unsigned char *)buf, (int *)&buf_size, - transcoder(0).inputInfo); + (const unsigned char*)buf, (int*)&buf_size); } else { outlen=buf_size; +#ifndef NDEBUG + saved_outlen=outlen; +#endif out=(unsigned char*)malloc_func(outlen+1); memcpy(out, buf, outlen); error=0; @@ -635,7 +624,7 @@ 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; } @@ -643,7 +632,10 @@ xmlChar* Charset::transcode_buf2xchar(co return static_cast(transcode_buf2mchar(xmlMalloc, buf, buf_size)); } static void* g_malloc_wrapper(size_t size) { - return g_malloc(size); + if(void* out=g_malloc(size)) + return out; + + return pa_fail_alloc("g_malloc_wrapper", size); } gchar* Charset::transcode_buf2gchar(const char* buf, size_t buf_size) { return static_cast(transcode_buf2mchar(g_malloc_wrapper, buf, buf_size)); @@ -652,8 +644,13 @@ GdomeDOMString_auto_ptr Charset::transco return GdomeDOMString_auto_ptr(transcode_buf2gchar(buf, buf_size)); } GdomeDOMString_auto_ptr Charset::transcode(const String& s) { - const char* cstr=s->cstr(String::L_UNSPECIFIED); + const char* cstr=s.cstr(String::L_UNSPECIFIED); return transcode_buf2dom(cstr, strlen(cstr)); } +GdomeDOMString_auto_ptr Charset::transcode(const StringBody s) { + const char* cstr=s.cstr(); + + return transcode_buf2dom(cstr, s.length()); +} #endif