[BACK]Return to pa_charset.C CVS log [TXT] [DIR] Up to [parser3project] / parser3 / src / main

Diff for /parser3/src/main/pa_charset.C between versions 1.10 and 1.33.2.19.2.9

version 1.10, 2001/12/28 18:12:30 version 1.33.2.19.2.9, 2003/03/25 10:25:25
Line 1 Line 1
 /** @file  /** @file
         Parser: Charset connection implementation.          Parser: Charset connection implementation.
   
         Copyright(c) 2001 ArtLebedev Group(http://www.artlebedev.com)          Copyright(c) 2001-2003 ArtLebedev Group (http://www.artlebedev.com)
         Author: Alexander Petrosyan<paf@design.ru>(http://paf.design.ru)          Author: Alexander Petrosyan<paf@design.ru>(http://paf.design.ru)
   
         $Id$  
 */  */
   
   static const char* IDENT_CHARSET_C="$Date$";
   
 #include "pa_charset.h"  #include "pa_charset.h"
   #include "pa_charsets.h"
   
 #ifdef XML  #ifdef XML
 #include "libxml/encoding.h"  #include "libxml/encoding.h"
 #endif  #endif
   
 // globals  
   
   
 // consts  
   
 #define MAX_CHARSET_UNI_CODES 500  
   
 // helpers  // helpers
   
 inline void prepare_case_tables(unsigned char *tables) {  inline void prepare_case_tables(unsigned char *tables) {
Line 37  inline void cstr2ctypes(unsigned char *t Line 31  inline void cstr2ctypes(unsigned char *t
                 ctypes_table[c]|=bit;                  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)          if(!cstr || !*cstr)
                 return 0;                  return 0;
         if(cstr[1]==0)          if(cstr[1]==0)
Line 46  inline unsigned int to_wchar_code(const Line 40  inline unsigned int to_wchar_code(const
         char *error_pos;          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) {  inline bool to_bool(const char* cstr) {
         return cstr && *cstr!=0;          return cstr && *cstr!=0;
 }  }
 static void element2ctypes(unsigned char c, bool belongs,  static void element2ctypes(unsigned char c, bool belongs,
Line 74  static void element2case(unsigned char f Line 68  static void element2case(unsigned char f
 // methods  // methods
   
 extern "C" unsigned char pcre_default_tables[]; // pcre/chartables.c  extern "C" unsigned char pcre_default_tables[]; // pcre/chartables.c
 Charset::Charset(Pool& apool, const String& aname, const String *request_file_spec): Pooled(apool),  Charset::Charset(const String& aname, const String* afile_spec): 
         fname(aname) {          fname(aname),
           fname_cstr(aname.cstrm()) {
   
         char *name_cstr=fname.cstr();          for(char *c=fname_cstr; *c; c++)
     for(char *c=name_cstr; *c; c++)                  *c = toupper(*c);
         *c = toupper(*c);  
   
         if(request_file_spec) {          if(afile_spec) {
                 fisUTF8=false;                  fisUTF8=false;
                 loadDefinition(*request_file_spec);                  load_definition(*afile_spec);
 #ifdef XML  #ifdef XML
                 addEncoding(name_cstr);                  addEncoding(fname_cstr);
 #endif  #endif
         } else {          } else {
                 fisUTF8=true;                  fisUTF8=true;
Line 94  Charset::Charset(Pool& apool, const Stri Line 88  Charset::Charset(Pool& apool, const Stri
         }          }
   
 #ifdef XML  #ifdef XML
         initTranscoder(&aname, name_cstr);          initTranscoder(fname, fname_cstr);
 #endif  #endif
 }  }
   
 Charset::~Charset() {  Charset::~Charset() {
           // @todonow unregister encodings
 #ifdef XML  #ifdef XML
         // not deleting transcoder, that's not our business          // not deleting transcoder, that's not our business
 #endif  #endif
 }  }
   
 void Charset::loadDefinition(const String& request_file_spec) {  void Charset::load_definition(const String& afile_spec) {
         // pcre_tables          // pcre_tables
         // lowcase, flipcase, bits digit+word+whitespace, masks          // lowcase, flipcase, bits digit+word+whitespace, masks
   
Line 115  void Charset::loadDefinition(const Strin Line 110  void Charset::loadDefinition(const Strin
         cstr2ctypes(pcre_tables,(const unsigned char *)"*+?{^.$|()[", ctype_meta);          cstr2ctypes(pcre_tables,(const unsigned char *)"*+?{^.$|()[", ctype_meta);
   
         // charset          // charset
         memset(tables.fromTable, 0, sizeof(tables.fromTable));          memset(&tables, 0, sizeof(tables));
         tables.toTable=(Charset_TransRec *)calloc(sizeof(Charset_TransRec)*MAX_CHARSET_UNI_CODES);  
         tables.toTableSize=0;  
         // strangly vital          // strangly vital
         tables.toTable[tables.toTableSize].intCh=0;          tables.toTable[tables.toTableSize].intCh=0;
         tables.toTable[tables.toTableSize].extCh=(XMLByte)0;          tables.toTable[tables.toTableSize].extCh=(XMLByte)0;
         tables.toTableSize++;          tables.toTableSize++;
   
         // loading text          // loading text
         char *data=file_read_text(pool(), request_file_spec);          char *data=file_read_text(UTF8_charset, afile_spec);
   
         // ignore header          // ignore header
         getrow(&data);          getrow(&data);
Line 153  void Charset::loadDefinition(const Strin Line 146  void Charset::loadDefinition(const Strin
                         case 8:                          case 8:
                                 // charset                                  // charset
                                 if(tables.toTableSize>MAX_CHARSET_UNI_CODES)                                  if(tables.toTableSize>MAX_CHARSET_UNI_CODES)
                                         throw Exception(0, 0,                                          throw Exception("parser.runtime",
                                                 &request_file_spec,                                                  &afile_spec,
                                                 "charset must contain not more then %d unicode values", MAX_CHARSET_UNI_CODES);                                                  "charset must contain not more then %d unicode values", MAX_CHARSET_UNI_CODES);
   
                                 XMLCh unicode=(XMLCh)to_wchar_code(cell);                                  XMLCh unicode=(XMLCh)to_wchar_code(cell);
Line 191  void Charset::sort_ToTable() { Line 184  void Charset::sort_ToTable() {
 }  }
   
 static XMLByte xlatOneTo(const XMLCh toXlat,  static XMLByte xlatOneTo(const XMLCh toXlat,
                                                  const Charset::Tables& tables) {                                                   const Charset::Tables& tables,
                                                    XMLByte not_found) {
     unsigned int    lowOfs = 0;      unsigned int    lowOfs = 0;
     unsigned int    hiOfs = tables.toTableSize - 1;      unsigned int    hiOfs = tables.toTableSize - 1;
     XMLByte         curByte = 0;      XMLByte         curByte = 0;
Line 210  static XMLByte xlatOneTo(const XMLCh toX Line 204  static XMLByte xlatOneTo(const XMLCh toX
                         return tables.toTable[midOfs].extCh;                          return tables.toTable[midOfs].extCh;
         } while(lowOfs+1<hiOfs);          } while(lowOfs+1<hiOfs);
   
     return '?';      return not_found;
 }  }
   
 void Charset::transcode(Pool& pool,  void Charset::transcode(
         const Charset& source_charset, const void *source_body, size_t source_content_length,          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          const Charset& dest_charset, const void *& dest_body, size_t& dest_content_length
         ) {          ) {
         if(!source_content_length) {          if(!source_content_length) {
Line 225  void Charset::transcode(Pool& pool, Line 219  void Charset::transcode(Pool& pool,
   
         switch((source_charset.isUTF8()?0x10:0x00)|(dest_charset.isUTF8()?0x01:0x00)) {          switch((source_charset.isUTF8()?0x10:0x00)|(dest_charset.isUTF8()?0x01:0x00)) {
                 default: // 0x00                  default: // 0x00
                         source_charset.transcodeToCharset(pool, dest_charset,                          source_charset.transcodeToCharset(dest_charset,
                                 source_body, source_content_length,                                  source_body, source_content_length,
                                 dest_body, dest_content_length);                                  dest_body, dest_content_length);
                         break;                          break;
                 case 0x01:                  case 0x01:
                         source_charset.transcodeToUTF8(pool,                          source_charset.transcodeToUTF8(
                                 source_body, source_content_length,                                  source_body, source_content_length,
                                 dest_body, dest_content_length);                                  dest_body, dest_content_length);
                         break;                          break;
                 case 0x10:                  case 0x10:
                         dest_charset.transcodeFromUTF8(pool,                          dest_charset.transcodeFromUTF8(
                                 source_body, source_content_length,                                  source_body, source_content_length,
                                 dest_body, dest_content_length);                                  dest_body, dest_content_length);
                         break;                          break;
Line 287  static const XMLByte gFirstByteMark[7] = Line 281  static const XMLByte gFirstByteMark[7] =
     0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC      0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC
 };  };
   
 static size_t transcodeToUTF8(  static int transcodeToUTF8(
                                                         const void *source_body, size_t source_content_length,                                                          const XMLByte* srcData, size_t& srcLen,
                                                         XMLByte *dest_body, size_t dest_buf_length,                                                          XMLByte *toFill, size_t& toFillLen,
                                                         const Charset::Tables& tables) {                                                          const Charset::Tables& tables) {
         const XMLByte* srcPtr=(const XMLByte*)source_body;          const XMLByte* srcPtr=srcData;
         const XMLByte* srcEnd=(const XMLByte*)source_body+source_content_length;          const XMLByte* srcEnd=srcData+srcLen;
         XMLByte* outPtr=dest_body;          XMLByte* outPtr=toFill;
         XMLByte* outEnd=dest_body+dest_buf_length;          XMLByte* outEnd=toFill+toFillLen;
   
     while(srcPtr<srcEnd) {      while(srcPtr<srcEnd) {
         uint curVal = tables.fromTable[*srcPtr];          uint curVal = tables.fromTable[*srcPtr];
Line 354  static size_t transcodeToUTF8( Line 348  static size_t transcodeToUTF8(
         outPtr+= encodedBytes;          outPtr+= encodedBytes;
     }      }
   
         // eaten      // Update the bytes eaten
         return outPtr-dest_body;      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;
 }  }
 static size_t transcodeFromUTF8(  /// @todo digital entites only when xml/html output [at output in html/xml mode, in html part of a letter]
                                                                    const void *source_body, size_t source_content_length,  static int transcodeFromUTF8(
                                                                    XMLByte* dest_body, size_t dest_buf_length,                                                                  const XMLByte* srcData, size_t& srcLen,
                                                                         const Charset::Tables& tables) {                                                                  XMLByte* toFill, size_t& toFillLen,
         const XMLByte* srcPtr=(const XMLByte*)source_body;                                                                  const Charset::Tables& tables) {
         const XMLByte* srcEnd=(const XMLByte*)source_body+source_content_length;          const XMLByte* srcPtr=srcData;
         XMLByte* outPtr=dest_body;          const XMLByte* srcEnd=srcData+srcLen;
         XMLByte* outEnd=dest_body+dest_buf_length;          XMLByte* outPtr=toFill;
           XMLByte* outEnd=toFill+toFillLen;
   
     //  We now loop until we either run out of input data, or room to store      //  We now loop until we either run out of input data, or room to store
     while ((srcPtr < srcEnd) && (outPtr < outEnd)) {      while ((srcPtr < srcEnd) && (outPtr < outEnd)) {
         // Get the next leading byte out          // 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          // Special-case ASCII, which is a leading byte value of<= 127
         if(firstByte<= 127) {          if(firstByte<= 127) {
Line 399  static size_t transcodeFromUTF8( Line 407  static size_t transcodeFromUTF8(
                      break;                       break;
   
             default:              default:
                 throw Exception(0, 0,                  throw Exception(0,
                                         0,                                          0,
                                         "transcodeFromUTF8 error: wrong trailingBytes value(%d)", trailingBytes);                                          "transcodeFromUTF8 error: wrong trailingBytes value(%d)", trailingBytes);
         }          }
Line 408  static size_t transcodeFromUTF8( Line 416  static size_t transcodeFromUTF8(
         //  If it will fit into a single char, then put it in. Otherwise          //  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          //  fail [*encode it as a surrogate pair. If its not valid, use the
         //  replacement char.*]          //  replacement char.*]
         if(!(tmpVal & 0xFFFF0000))          if(!(tmpVal & 0xFFFF0000)) {
             *outPtr++= xlatOneTo(tmpVal, tables);                          if(XMLByte xlat=xlatOneTo(tmpVal, tables, 0))
                 else                                  *outPtr++=xlat;
                         throw Exception(0, 0,                          else 
                                   outPtr+=sprintf((char *)outPtr, "&#%d;", tmpVal); // &#decimal;
                   } else
                           throw Exception(0,
                                 0,                                  0,
                                 "transcodeFromUTF8 error: too big tmpVal(0x%08X)", tmpVal);                                  "transcodeFromUTF8 error: too big tmpVal(0x%08X)", tmpVal);
         }          }
   
         // eaten      // Update the bytes eaten
         return outPtr-dest_body;      srcLen = srcPtr - srcData;
   
       // Return the characters read
       toFillLen = outPtr - toFill;
   
           //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;
 }  }
   
 /// @todo not so memory-hungry with prescan  /// @todo not so memory-hungry with prescan
 /// @test buf overflow  void Charset::transcodeToUTF8(
 void Charset::transcodeToUTF8(Pool& pool,                                                                   const void* source_body, size_t source_content_length,
                                                                  const void *source_body, size_t source_content_length,                                                                   const void *& adest_body, size_t& dest_content_length) const {
                                                                  const void *& adest_body, size_t& adest_content_length) const {          dest_content_length=source_content_length*6/*so that surly enough, max utf8 seq len=6*/;
         size_t dest_buf_length=source_content_length*6/*so that surly enough*/;          XMLByte *dest_body=new XMLByte[dest_content_length];
         XMLByte *dest_body=(XMLByte*)pool.malloc(dest_buf_length);  
           if(::transcodeToUTF8(
         size_t dest_content_length=::transcodeToUTF8(                  (XMLByte *)source_body, source_content_length,
                 source_body, source_content_length,                  dest_body, dest_content_length,
                 dest_body, dest_buf_length,                  tables)<0)
                 tables);  
         /*if(dest_content_length<dest_buf_length)  
                 throw(0, 0,                  throw(0, 0,
                         0,                          0,
                         "Charset::transcodeToUTF8 error");*/                          "Charset::transcodeToUTF8 buffer overflow");
   
         // return          // return
         adest_body=dest_body;          adest_body=dest_body;
         adest_content_length=dest_content_length;  
 }  }
 /// @test buf overflow  void Charset::transcodeFromUTF8(
 void Charset::transcodeFromUTF8(Pool& pool,                                                                     const void* source_body, size_t source_content_length,
                                                                    const void *source_body, size_t source_content_length,                                                                     const void *& adest_body, size_t& dest_content_length) const {
                                                                    const void *& adest_body, size_t& adest_content_length) const {          dest_content_length=source_content_length*6/*so that surly enough, "&#255;" has max ratio */;
         size_t dest_buf_length=source_content_length/*surly enough*/;          XMLByte *dest_body=new XMLByte[dest_content_length];
         XMLByte *dest_body=(XMLByte*)pool.malloc(dest_buf_length);  
           if(::transcodeFromUTF8(
         size_t dest_content_length=::transcodeFromUTF8(                  (XMLByte *)source_body, source_content_length,
                 source_body, source_content_length,                  dest_body, dest_content_length,
                 dest_body, dest_buf_length,                  tables)<0)
                 tables);  
 /*      if(dest_content_length!=dest_buf_length)  
                 throw(0, 0,                  throw(0, 0,
                         0,                          0,
                         "Charset::transcodeToUTF8 error");*/                          "Charset::transcodeToUTF8 buffer overflow");
   
   
         // return          // return
         adest_body=dest_body;          adest_body=dest_body;
         adest_content_length=dest_content_length;  
 }  }
   
 /// transcode using both charsets  /// transcode using both charsets
 void Charset::transcodeToCharset(Pool& pool,  void Charset::transcodeToCharset(
                                                                            const Charset& dest_charset,                                                                             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 {                                                                             const void *& adest_body, size_t& adest_content_length) const {
         if(&dest_charset==this) {          if(&dest_charset==this) {
                 adest_body=source_body;                  adest_body=source_body;
                 adest_content_length=source_content_length;                  adest_content_length=source_content_length;
         } else {          } else {
                 size_t dest_content_length=source_content_length;                  size_t dest_content_length=source_content_length;
                 unsigned char *dest_body=(unsigned char *)pool.malloc(dest_content_length);                  unsigned char *dest_body=new unsigned char[dest_content_length];
   
                 const XMLByte* srcPtr=(const XMLByte*)source_body;                  const XMLByte* srcPtr=(XMLByte *)source_body;
                 const XMLByte* srcEnd=(const XMLByte*)source_body+source_content_length;                  const XMLByte* srcEnd=(XMLByte *)source_body+source_content_length;
   
                 for(XMLByte* outPtr=dest_body; srcPtr<srcEnd; srcPtr++) {                  for(XMLByte* outPtr=dest_body; srcPtr<srcEnd; srcPtr++) {
                         XMLCh curVal = tables.fromTable[*srcPtr];                          XMLCh curVal = tables.fromTable[*srcPtr];
                         if(curVal)                           if(curVal) 
                                 *outPtr++=xlatOneTo(curVal, dest_charset.tables);                                  *outPtr++=xlatOneTo(curVal, dest_charset.tables, '?');
                         else {                          else {
                                 // use the replacement character                                  // use the replacement character
                                 *outPtr++= '?';                                  *outPtr++= '?';
Line 501  static int         xml256CharEncodingInp Line 518  static int         xml256CharEncodingInp
                                                                                                         int *inlen,                                                                                                           int *inlen, 
                                                                                                         void *info) {                                                                                                          void *info) {
         return transcodeToUTF8(          return transcodeToUTF8(
                                                         in, *inlen,                  in, *(size_t*)inlen,
                                                         out, *(unsigned int*)outlen,                  out, *(size_t*)outlen,
                                                         *(const Charset::Tables *)info);                  *(const Charset::Tables *)info);
 }  }
   
 static int         xml256CharEncodingOutputFunc    (  static int         xml256CharEncodingOutputFunc    (
Line 513  static int         xml256CharEncodingOut Line 530  static int         xml256CharEncodingOut
                                                                                                         int *inlen,                                                                                                           int *inlen, 
                                                                                                         void *info) {                                                                                                          void *info) {
         return transcodeFromUTF8(          return transcodeFromUTF8(
                                                         in, *inlen,                  in, *(size_t*)inlen,
                                                         out, *outlen,                  out, *(size_t*)outlen,
                                                         *(const Charset::Tables *)info);                  *(const Charset::Tables *)info);
 }  }
   
   
 void Charset::addEncoding(char *name_cstr) {  void Charset::addEncoding(char *name_cstr) {
         xmlCharEncodingHandler *handler=          xmlCharEncodingHandler* handler=new(PointerFreeGC) xmlCharEncodingHandler;
                 (xmlCharEncodingHandler *)malloc(sizeof(xmlCharEncodingHandler));  
         handler->name=name_cstr;          handler->name=name_cstr;
         handler->input=xml256CharEncodingInputFunc; handler->inputInfo=&tables;          handler->input=xml256CharEncodingInputFunc; handler->inputInfo=&tables;
         handler->output=xml256CharEncodingOutputFunc; handler->outputInfo=&tables;          handler->output=xml256CharEncodingOutputFunc; handler->outputInfo=&tables;
Line 529  void Charset::addEncoding(char *name_cst Line 545  void Charset::addEncoding(char *name_cst
         xmlRegisterCharEncodingHandler(handler);          xmlRegisterCharEncodingHandler(handler);
 }  }
   
 void Charset::initTranscoder(const String *source, const char *name_cstr) {  void Charset::initTranscoder(const String& name, const char* name_cstr) {
         transcoder=xmlFindCharEncodingHandler(name_cstr);          ftranscoder=xmlFindCharEncodingHandler(name_cstr);
         if(!transcoder)          transcoder(name); // check right way
                 throw Exception(0, 0,  }
                         source,  
   xmlCharEncodingHandler& Charset::transcoder(const String& name) {
           if(!ftranscoder)
                   throw Exception("parser.runtime",
                           &name,
                         "unsupported encoding");                          "unsupported encoding");
           return *ftranscoder;
 }  }
   
 const char *Charset::transcode_cstr(GdomeDOMString *s) {   const char* Charset::transcode_cstr(xmlChar* s) {
         if(!transcoder)          if(!s)
                 throw Exception(0, 0,                  return "";
                         0,  
                         "transcode_cstr no transcoder");  
   
         int inlen=gdome_str_length(s);          int inlen=strlen((const char* )s);
         int outlen=inlen+1; // max          int outlen=inlen+1; // max
         char *out=(char *)malloc(outlen*sizeof(char));          char *out=new(PointerFreeGC) char[outlen];
                   
         int size=transcoder->output(          int error;
                 (unsigned char*)out, &outlen,          if(xmlCharEncodingOutputFunc output=transcoder(fname).output) {
                 (const unsigned char*)s->str, &inlen,                  error=output(
                 transcoder->outputInfo);                          (unsigned char*)out, &outlen,
         if(size<0)                          (const unsigned char*)s, &inlen,
                 throw Exception(0, 0,                          transcoder(fname).outputInfo);
           } else {
                   memcpy(out, s, outlen=inlen);
                   error=0;
           }
           if(error<0)
                   throw Exception(0,
                         0,                          0,
                         "transcode_cstr failed (%d)", size);                          "transcode_cstr failed (%d)", error);
   
         out[size]=0;          out[outlen/*surely would be less then on input*/]=0;
         return out;          return out;
 }  }
 String& Charset::transcode(GdomeDOMString *s) {   const String& Charset::transcode(xmlChar* s) { 
         return *NEW String(pool(), transcode_cstr(s));           return *new String(transcode_cstr(s), 0/*auto-size*/, String::L_CLEAN); 
   }
   const char* Charset::transcode_cstr(GdomeDOMString* s) { 
           return s?transcode_cstr(BAD_CAST s->str):"";
   }
   const String& Charset::transcode(GdomeDOMString* s) { 
           return *new String(transcode_cstr(s), 0/*auto-size*/, String::L_CLEAN); 
 }  }
   
 /// @test less memory using -maybe- xmlParserInputBufferCreateMem  /// @test less memory using -maybe- xmlParserInputBufferCreateMem
 GdomeDOMString *Charset::transcode_buf(const char *buf, size_t buf_size) {   void* Charset::transcode_buf2mchar(transcode_buf_malloc_func malloc_func, 
         if(!transcoder)                                     const char* buf, size_t buf_size) {
                 throw Exception(0, 0,          unsigned char* out;
           int outlen;
           int error;
           if(xmlCharEncodingInputFunc input=transcoder(fname).input) {
                   outlen=buf_size*6/*max*/;
                   out=(unsigned char*)malloc_func(outlen+1);
                   error=input(
                           out, &outlen,
                           (const unsigned char *)buf,  (int *)&buf_size,
                           transcoder(fname).inputInfo);
           } else {
                   outlen=buf_size;
                   out=(unsigned char*)malloc_func(outlen+1);
                   memcpy(out, buf, outlen);
                   error=0;
           }
           
           if(error<0)
                   throw Exception(0,
                         0,                          0,
                         "transcode_buf no transcoder");                          "transcode_buf failed (%d)", error);
   
         int outlen=buf_size*6/*max*/+1;          out[outlen/*surely would be less then on input*/]=0;
         unsigned char *out=(unsigned char*)malloc(outlen*sizeof(unsigned char));          return out;
         int size=transcoder->input(  }
                 out, &outlen,  
                 (const unsigned char *)buf,  (int *)&buf_size,  xmlChar* Charset::transcode_buf2xchar(const char* buf, size_t buf_size) {
                 transcoder->inputInfo);          return static_cast<xmlChar*>(transcode_buf2mchar(xmlMalloc, buf, buf_size));
         if(size<0)  }
                 throw Exception(0, 0,  static void* g_malloc_wrapper(size_t size) {
                         0,          return g_malloc(size);
                         "transcode_buf failed (%d)", size);  }
   gchar* Charset::transcode_buf2gchar(const char* buf, size_t buf_size) {
           return static_cast<gchar*>(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));
   }
   GdomeDOMString_auto_ptr Charset::transcode(const String& s) { 
           const char* cstr=s.cstr(String::L_UNSPECIFIED);
   
         out[size]=0;          return transcode_buf2dom(cstr, strlen(cstr)); 
         return gdome_str_mkref_own((gchar*)out);  
 }  }
 GdomeDOMString *Charset::transcode(const String& s) {   GdomeDOMString_auto_ptr Charset::transcode(const StringBody s) { 
         const char *cstr=s.cstr(String::UL_UNSPECIFIED);          const char* cstr=s.cstr();
   
         return transcode_buf(cstr, strlen(cstr));           return transcode_buf2dom(cstr, s.length()); 
 }  }
 #endif  #endif
Removed from v.1.10  
changed lines
  Added in v.1.33.2.19.2.9

E-mail: