--- parser3/src/main/pa_charset.C 2003/03/21 13:42:31 1.33.2.19.2.4 +++ parser3/src/main/pa_charset.C 2003/03/17 14:48:05 1.33.4.1 @@ -1,19 +1,25 @@ /** @file Parser: Charset connection implementation. - Copyright(c) 2001-2003 ArtLebedev Group (http://www.artlebedev.com) + Copyright(c) 2001, 2003 ArtLebedev Group (http://www.artlebedev.com) Author: Alexander Petrosyan(http://paf.design.ru) */ -static const char* IDENT_CHARSET_C="$Date: 2003/03/21 13:42:31 $"; +static const char* IDENT_CHARSET_C="$Date: 2003/03/17 14:48:05 $"; #include "pa_charset.h" -#include "pa_charsets.h" #ifdef XML #include "libxml/encoding.h" #endif +// globals + + +// consts + +#define MAX_CHARSET_UNI_CODES 500 + // helpers inline void prepare_case_tables(unsigned char *tables) { @@ -31,7 +37,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) @@ -40,7 +46,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, @@ -68,18 +74,18 @@ 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->cstr()) { +Charset::Charset(Pool& apool, const String& aname, const String *request_file_spec): Pooled(apool), + fname(aname) { - for(char *c=fname_cstr; *c; c++) + char *name_cstr=fname.cstr(); + for(char *c=name_cstr; *c; c++) *c = toupper(*c); - if(afile_spec) { + if(request_file_spec) { fisUTF8=false; - load_definition(afile_spec); + loadDefinition(*request_file_spec); #ifdef XML - addEncoding(fname_cstr); + addEncoding(name_cstr); #endif } else { fisUTF8=true; @@ -88,18 +94,17 @@ Charset::Charset(const String& aname, co } #ifdef XML - initTranscoder(fname, fname_cstr); + initTranscoder(&aname, name_cstr); #endif } Charset::~Charset() { - // @todonow unregister encodings #ifdef XML // not deleting transcoder, that's not our business #endif } -void Charset::load_definition(const String& afile_spec) { +void Charset::loadDefinition(const String& request_file_spec) { // pcre_tables // lowcase, flipcase, bits digit+word+whitespace, masks @@ -110,15 +115,16 @@ void Charset::load_definition(const Stri cstr2ctypes(pcre_tables,(const unsigned char *)"*+?{^.$|()[", ctype_meta); // charset - memset(&tables, 0, sizeof(tables)); + memset(tables.fromTable, 0, sizeof(tables.fromTable)); + tables.toTable=(Charset_TransRec *)calloc(sizeof(Charset_TransRec)*MAX_CHARSET_UNI_CODES); + tables.toTableSize=0; // strangly vital tables.toTable[tables.toTableSize].intCh=0; tables.toTable[tables.toTableSize].extCh=(XMLByte)0; tables.toTableSize++; // loading text - Pool pool_for_load_only; - char *data=file_read_text(pool_for_load_only, *UTF8_charset, afile_spec); + char *data=file_read_text(pool(), request_file_spec); // ignore header getrow(&data); @@ -148,7 +154,7 @@ void Charset::load_definition(const Stri // charset if(tables.toTableSize>MAX_CHARSET_UNI_CODES) throw Exception("parser.runtime", - afile_spec, + &request_file_spec, "charset must contain not more then %d unicode values", MAX_CHARSET_UNI_CODES); XMLCh unicode=(XMLCh)to_wchar_code(cell); @@ -208,8 +214,8 @@ static XMLByte xlatOneTo(const XMLCh toX return not_found; } -void Charset::transcode( - const Charset& source_charset, const void* source_body, size_t source_content_length, +void Charset::transcode(Pool& pool, + const Charset& source_charset, const void *source_body, size_t source_content_length, const Charset& dest_charset, const void *& dest_body, size_t& dest_content_length ) { if(!source_content_length) { @@ -220,7 +226,7 @@ void Charset::transcode( switch((source_charset.isUTF8()?0x10:0x00)|(dest_charset.isUTF8()?0x01:0x00)) { default: // 0x00 - source_charset.transcodeToCharset(dest_charset, + source_charset.transcodeToCharset(pool, dest_charset, source_body, source_content_length, dest_body, dest_content_length); break; @@ -235,7 +241,8 @@ void Charset::transcode( dest_body, dest_content_length); break; case 0x11: - dest_body=pool.copy((char*)source_body, dest_content_length=source_content_length); + dest_body=source_body; + dest_content_length=source_content_length; break; } } @@ -366,7 +373,7 @@ of ocetes consumed. } /// @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, + const XMLByte *srcData, size_t& srcLen, XMLByte* toFill, size_t& toFillLen, const Charset::Tables& tables) { const XMLByte* srcPtr=srcData; @@ -377,7 +384,7 @@ static int transcodeFromUTF8( // 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; + const XMLByte firstByte = *srcPtr; // Special-case ASCII, which is a leading byte value of<= 127 if(firstByte<= 127) { @@ -445,11 +452,11 @@ of ocetes consumed. } /// @todo not so memory-hungry with prescan -void Charset::transcodeToUTF8( - const void* source_body, size_t source_content_length, +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, max utf8 seq len=6*/; - XMLByte *dest_body=new XMLByte[dest_content_length]; + XMLByte *dest_body=(XMLByte*)pool.malloc_atomic(dest_content_length); if(::transcodeToUTF8( (XMLByte *)source_body, source_content_length, @@ -462,11 +469,11 @@ void Charset::transcodeToUTF8( // return adest_body=dest_body; } -void Charset::transcodeFromUTF8( - const void* source_body, size_t source_content_length, +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*6/*so that surly enough, "ÿ" has max ratio */; - XMLByte *dest_body=new XMLByte[dest_content_length]; + XMLByte *dest_body=(XMLByte*)pool.malloc_atomic(dest_content_length); if(::transcodeFromUTF8( (XMLByte *)source_body, source_content_length, @@ -481,15 +488,16 @@ void Charset::transcodeFromUTF8( } /// transcode using both charsets -void Charset::transcodeToCharset( +void Charset::transcodeToCharset(Pool& pool, const Charset& dest_charset, - const void* source_body, size_t source_content_length, + 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=pool.copy((char*)source_body, adest_content_length=source_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=new unsigned char[dest_content_length]; + unsigned char *dest_body=(unsigned char *)pool.malloc_atomic(dest_content_length); const XMLByte* srcPtr=(XMLByte *)source_body; const XMLByte* srcEnd=(XMLByte *)source_body+source_content_length; @@ -536,9 +544,8 @@ static int xml256CharEncodingOut void Charset::addEncoding(char *name_cstr) { - xmlCharEncodingHandler* handler=new xmlCharEncodingHandler; - fcreated_handler=xmlCharEncodingHandlerPtr(handler); - + xmlCharEncodingHandler *handler= + (xmlCharEncodingHandler *)malloc(sizeof(xmlCharEncodingHandler)); handler->name=name_cstr; handler->input=xml256CharEncodingInputFunc; handler->inputInfo=&tables; handler->output=xml256CharEncodingOutputFunc; handler->outputInfo=&tables; @@ -546,33 +553,33 @@ void Charset::addEncoding(char *name_cst xmlRegisterCharEncodingHandler(handler); } -void Charset::initTranscoder(const String* source, const char* name_cstr) { +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) { +xmlCharEncodingHandler *Charset::transcoder(const String *source) { if(!ftranscoder) throw Exception("parser.runtime", source, "unsupported encoding"); - return *ftranscoder; + 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 inlen=strlen((const char *)s); int outlen=inlen+1; // max - char *out=new char[outlen]; + char *out=(char *)malloc_atomic(outlen*sizeof(char)); int error; - if(xmlCharEncodingOutputFunc output=transcoder(0).output) { + if(xmlCharEncodingOutputFunc output=transcoder(0)->output) { error=output( (unsigned char*)out, &outlen, (const unsigned char*)s, &inlen, - transcoder(0).outputInfo); + transcoder(0)->outputInfo); } else { memcpy(out, s, outlen=inlen); error=0; @@ -585,46 +592,43 @@ const char* Charset::transcode_cstrxmlCh out[outlen/*surely would be less then on input*/]=0; return out; } -const String& Charset::transcodexmlChar* s +String& Charset::transcode(xmlChar *s #ifndef NO_STRING_ORIGIN - , const 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); + String& result=*NEW String(pool()); + result.APPEND_CLEAN(transcode_cstr(s), 0/*auto-size*/, origin->origin().file, origin->origin().line); return result; } -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 +String& Charset::transcode(GdomeDOMString *s #ifndef NO_STRING_ORIGIN - , const 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); + String& result=*NEW String(pool()); + result.APPEND_CLEAN(transcode_cstr(s), 0/*auto-size*/, origin->origin().file, origin->origin().line); return result; } /// @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) { + unsigned char *out; int outlen; int error; - if(xmlCharEncodingInputFunc input=transcoder(0).input) { + if(xmlCharEncodingInputFunc input=transcoder(0)->input) { outlen=buf_size*6/*max*/; - out=(unsigned char*)malloc_func(outlen+1); + out=(unsigned char*)malloc_atomic((outlen+1)*sizeof(unsigned char)); error=input( out, &outlen, (const unsigned char *)buf, (int *)&buf_size, - transcoder(0).inputInfo); + transcoder(0)->inputInfo); } else { outlen=buf_size; - out=(unsigned char*)malloc_func(outlen+1); + out=(unsigned char*)malloc_atomic((outlen+1)*sizeof(unsigned char)); memcpy(out, buf, outlen); error=0; } @@ -635,23 +639,13 @@ void* Charset::transcode_buf2mchar(trans "transcode_buf failed (%d)", error); out[outlen/*surely would be less then on input*/]=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)); + return (xmlChar *)out; } -GdomeDOMString_auto_ptr Charset::transcode_buf2dom(const char* buf, size_t buf_size) { - return GdomeDOMString_auto_ptr(transcode_buf2gchar(buf, buf_size)); +GdomeDOMString_auto_ptr Charset::transcode_buf2dom(const char *buf, size_t buf_size) { + return GdomeDOMString_auto_ptr((gchar*)transcode_buf2xchar(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::UL_UNSPECIFIED); return transcode_buf2dom(cstr, strlen(cstr)); }