[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.4 and 1.17

version 1.4, 2001/12/17 17:59:51 version 1.17, 2002/01/21 17:17:27
Line 8 Line 8
 */  */
   
 #include "pa_charset.h"  #include "pa_charset.h"
 //#include "pa_exception.h"  
 //#include "pa_common.h"  
 //#include "pa_threads.h"  
   
 #ifdef XML  #ifdef XML
 #       include<util/TransENameMap.hpp>  #include "libxml/encoding.h"
 #       include<util/XML256TableTranscoder.hpp>  
 #       include<util/PlatformUtils.hpp>  
 #       include<PlatformSupport/XalanTranscodingServices.hpp>  
 #endif  #endif
   
 // globals  // globals
Line 77  static void element2case(unsigned char f Line 71  static void element2case(unsigned char f
         fcc_table[from]=to; fcc_table[to]=from;          fcc_table[from]=to; fcc_table[to]=from;
 }  }
   
 #ifdef XML  
 template <class TType> 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<TType>&);  
     void operator=(const ENameMapFor2<TType>&);  
 };  
   
 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  // 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 *file_spec): Pooled(apool),  Charset::Charset(Pool& apool, const String& aname, const String *request_file_spec): Pooled(apool),
         fname(apool) {          fname(aname) {
         // fname  
         char *name_cstr=(char *)malloc(aname.size()+1);          char *name_cstr=fname.cstr();
         memcpy(name_cstr, aname.cstr(String::UL_AS_IS), aname.size()+1);      for(char *c=name_cstr; *c; c++)
         fname.APPEND_CLEAN(name_cstr, aname.size(), 0, 0);          *c = toupper(*c);
   
         if(file_spec) {          if(request_file_spec) {
                 fisUTF8=false;                  fisUTF8=false;
                 loadDefinition(*file_spec);                  loadDefinition(*request_file_spec);
 #ifdef XML  #ifdef XML
                 addEncoding(name_cstr);                  addEncoding(name_cstr);
 #endif  #endif
Line 163  Charset::Charset(Pool& apool, const Stri Line 100  Charset::Charset(Pool& apool, const Stri
   
 Charset::~Charset() {  Charset::~Charset() {
 #ifdef XML  #ifdef XML
         delete transcoder;          // not deleting transcoder, that's not our business
 #endif  #endif
 }  }
   
 void Charset::loadDefinition(const String& file_spec) {  void Charset::loadDefinition(const String& request_file_spec) {
         // pcre_tables          // pcre_tables
         // lowcase, flipcase, bits digit+word+whitespace, masks          // lowcase, flipcase, bits digit+word+whitespace, masks
   
Line 178  void Charset::loadDefinition(const Strin Line 115  void Charset::loadDefinition(const Strin
         cstr2ctypes(pcre_tables,(const unsigned char *)"*+?{^.$|()[", ctype_meta);          cstr2ctypes(pcre_tables,(const unsigned char *)"*+?{^.$|()[", ctype_meta);
   
         // charset          // charset
         memset(fromTable, 0, sizeof(fromTable));          memset(tables.fromTable, 0, sizeof(tables.fromTable));
         toTable=(XMLTransService::TransRec *)calloc(          tables.toTable=(Charset_TransRec *)calloc(sizeof(Charset_TransRec)*MAX_CHARSET_UNI_CODES);
                         sizeof(XMLTransService::TransRec)*MAX_CHARSET_UNI_CODES);          tables.toTableSize=0;
         toTableSize=0;  
         // strangly vital          // strangly vital
         toTable[toTableSize].intCh=0;          tables.toTable[tables.toTableSize].intCh=0;
         toTable[toTableSize].extCh=(XMLByte)0;          tables.toTable[tables.toTableSize].extCh=(XMLByte)0;
         toTableSize++;          tables.toTableSize++;
   
         // loading text          // loading text
         char *data=file_read_text(pool(), file_spec);          char *data=file_read_text(pool(), request_file_spec);
   
         // ignore header          // ignore header
         getrow(&data);          getrow(&data);
Line 216  void Charset::loadDefinition(const Strin Line 152  void Charset::loadDefinition(const Strin
                         case 7:                          case 7:
                         case 8:                          case 8:
                                 // charset                                  // charset
                                 if(toTableSize>MAX_CHARSET_UNI_CODES)                                  if(tables.toTableSize>MAX_CHARSET_UNI_CODES)
                                         throw Exception(0, 0,                                          throw Exception(0, 0,
                                                 &file_spec,                                                  &request_file_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);
                                 if(!unicode && column==7/*unicode1 column*/)                                  if(!unicode && column==7/*unicode1 column*/)
                                         unicode=(XMLCh)c;                                          unicode=(XMLCh)c;
                                 if(unicode) {                                  if(unicode) {
                                         if(!fromTable[c])                                          if(!tables.fromTable[c])
                                                 fromTable[c]=unicode;                                                  tables.fromTable[c]=unicode;
                                         toTable[toTableSize].intCh=unicode;                                          tables.toTable[tables.toTableSize].intCh=unicode;
                                         toTable[toTableSize].extCh=(XMLByte)c;                                          tables.toTable[tables.toTableSize].extCh=(XMLByte)c;
                                         toTableSize++;                                          tables.toTableSize++;
                                 }                                  }
                                 break;                                  break;
                         }                          }
Line 240  void Charset::loadDefinition(const Strin Line 176  void Charset::loadDefinition(const Strin
         sort_ToTable();          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<XML256TableTranscoder2>(  
                         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) {  static int sort_cmp_Trans_rec_intCh(const void *a, const void *b) {
         return           return 
                 static_cast<const Charset_TransRec *>(a)->intCh-                  static_cast<const Charset_TransRec *>(a)->intCh-
Line 277  static int sort_cmp_Trans_rec_intCh(cons Line 183  static int sort_cmp_Trans_rec_intCh(cons
 }  }
   
 void Charset::sort_ToTable() {  void Charset::sort_ToTable() {
         _qsort(toTable, toTableSize, sizeof(*toTable),           _qsort(tables.toTable, tables.toTableSize, sizeof(*tables.toTable), 
                 sort_cmp_Trans_rec_intCh);                  sort_cmp_Trans_rec_intCh);
         //FILE *f=fopen("c:\\temp\\a", "wb");          //FILE *f=fopen("c:\\temp\\a", "wb");
         //fwrite(toTable, toTableSize, sizeof(*toTable), f);          //fwrite(tables.toTable, tables.toTableSize, sizeof(*tables.toTable), f);
         //fclose(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    lowOfs = 0;
     unsigned int    hiOfs = toTableSize - 1;      unsigned int    hiOfs = tables.toTableSize - 1;
     XMLByte         curByte = 0;      XMLByte         curByte = 0;
     do {      do {
         // Calc the mid point of the low and high offset.          // Calc the mid point of the low and high offset.
Line 295  XMLByte Charset::xlatOneTo(const XMLCh t Line 202  XMLByte Charset::xlatOneTo(const XMLCh t
         //  If our test char is greater than the mid point char, then          //  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          //  we move up to the upper half. Else we move to the lower
         //  half. If its equal, then its our guy.          //  half. If its equal, then its our guy.
         if(toXlat>toTable[midOfs].intCh)          if(toXlat>tables.toTable[midOfs].intCh)
             lowOfs = midOfs;              lowOfs = midOfs;
                 else if(toXlat<toTable[midOfs].intCh)                  else if(toXlat<tables.toTable[midOfs].intCh)
                         hiOfs = midOfs;                          hiOfs = midOfs;
                 else                  else
                         return toTable[midOfs].extCh;                          return tables.toTable[midOfs].extCh;
         } while(lowOfs+1<hiOfs);          } while(lowOfs+1<hiOfs);
   
     return '?';      return '?';
Line 380  static const XMLByte gFirstByteMark[7] = Line 287  static const XMLByte gFirstByteMark[7] =
     0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC      0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC
 };  };
   
 /// @todo not so memory-hungry with prescan  static int transcodeToUTF8(
 void Charset::transcodeToUTF8(Pool& pool,                                                          const XMLByte* srcData, size_t& srcLen,
                                                                  const void *source_body, size_t source_content_length,                                                          XMLByte *toFill, size_t& toFillLen,
                                                                  const void *& adest_body, size_t& adest_content_length) const {                                                          const Charset::Tables& tables) {
                   const XMLByte* srcPtr=srcData;
         size_t dest_content_length=0;          const XMLByte* srcEnd=srcData+srcLen;
         XMLByte *dest_body=(XMLByte*)pool.malloc(source_content_length*6/*so that surly enough*/);          XMLByte* outPtr=toFill;
           XMLByte* outEnd=toFill+toFillLen;
         const XMLByte* srcPtr=(const XMLByte*)source_body;  
         const XMLByte* srcEnd=(const XMLByte*)source_body+source_content_length;  
         XMLByte* outPtr=dest_body;  
   
     while(srcPtr<srcEnd) {      while(srcPtr<srcEnd) {
         uint curVal = fromTable[*srcPtr];          uint curVal = tables.fromTable[*srcPtr];
                 if(!curVal) {                  if(!curVal) {
             // use the replacement character              // use the replacement character
             *outPtr++= '?';              *outPtr++= '?';
Line 422  void Charset::transcodeToUTF8(Pool& pool Line 326  void Charset::transcodeToUTF8(Pool& pool
             continue;              continue;
         }          }
   
         //  If we cannot fully get this char into the output buffer,          //  If we cannot fully get this char into the output buffer
                 // never          if (outPtr + encodedBytes > outEnd)
               break;
   
         // We can do it, so update the source index          // We can do it, so update the source index
         srcPtr++;          srcPtr++;
Line 432  void Charset::transcodeToUTF8(Pool& pool Line 337  void Charset::transcodeToUTF8(Pool& pool
         //  here, so bump up the output pointer and work down as we go.          //  here, so bump up the output pointer and work down as we go.
         outPtr+= encodedBytes;          outPtr+= encodedBytes;
         switch(encodedBytes) {          switch(encodedBytes) {
             case 6: *--outPtr = XMLByte((curVal | 0x80UL) & 0xBFUL);              case 6: *--outPtr = (XMLByte)((curVal | 0x80UL) & 0xBFUL);
                      curVal>>= 6;                       curVal>>= 6;
             case 5: *--outPtr = XMLByte((curVal | 0x80UL) & 0xBFUL);              case 5: *--outPtr = (XMLByte)((curVal | 0x80UL) & 0xBFUL);
                      curVal>>= 6;                       curVal>>= 6;
             case 4: *--outPtr = XMLByte((curVal | 0x80UL) & 0xBFUL);              case 4: *--outPtr = (XMLByte)((curVal | 0x80UL) & 0xBFUL);
                      curVal>>= 6;                       curVal>>= 6;
             case 3: *--outPtr = XMLByte((curVal | 0x80UL) & 0xBFUL);              case 3: *--outPtr = (XMLByte)((curVal | 0x80UL) & 0xBFUL);
                      curVal>>= 6;                       curVal>>= 6;
             case 2: *--outPtr = XMLByte((curVal | 0x80UL) & 0xBFUL);              case 2: *--outPtr = (XMLByte)((curVal | 0x80UL) & 0xBFUL);
                      curVal>>= 6;                       curVal>>= 6;
             case 1: *--outPtr = XMLByte(curVal | gFirstByteMark[encodedBytes]);              case 1: *--outPtr = (XMLByte)(curVal | gFirstByteMark[encodedBytes]);
         }          }
   
         // Add the encoded bytes back in again to indicate we've eaten them          // Add the encoded bytes back in again to indicate we've eaten them
         outPtr+= encodedBytes;          outPtr+= encodedBytes;
     }      }
   
         // return      // Update the bytes eaten
         adest_body=dest_body;      srcLen = srcPtr - srcData;
         adest_content_length=outPtr-dest_body;  
       // Return the characters read
       toFillLen = outPtr - toFill;
   
           return srcPtr==srcEnd?(int)toFillLen:-1;
 }  }
 void Charset::transcodeFromUTF8(Pool& pool,  static size_t transcodeFromUTF8(
                                                                    const void *source_body, size_t source_content_length,                                                                  const XMLByte *srcData, size_t& srcLen,
                                                                    const void *& adest_body, size_t& adest_content_length) const {                                                                  XMLByte* toFill, size_t& toFillLen,
         size_t dest_content_length=0;                                                                  const Charset::Tables& tables) {
         XMLByte *dest_body=(XMLByte*)pool.malloc(source_content_length/*surly enough*/);          const XMLByte* srcPtr=srcData;
           const XMLByte* srcEnd=srcData+srcLen;
         const XMLByte* srcPtr=(const XMLByte*)source_body;          XMLByte* outPtr=toFill;
         const XMLByte* srcEnd=(const XMLByte*)source_body+source_content_length;          XMLByte* outEnd=toFill+toFillLen;
         XMLByte* outPtr=dest_body;  
   
     //  We now loop until we either run out of input data      //  We now loop until we either run out of input data, or room to store
     while(srcPtr<srcEnd) {      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;
   
Line 506  void Charset::transcodeFromUTF8(Pool& po Line 414  void Charset::transcodeFromUTF8(Pool& po
         //  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);              *outPtr++= xlatOneTo(tmpVal, tables);
                 else                  else
                         throw Exception(0, 0,                          throw Exception(0, 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          // return
         adest_body=dest_body;          adest_body=dest_body;
         adest_content_length=outPtr-dest_body;  
 }  }
   
 /// transcode using both charsets  /// transcode using both charsets
 void Charset::transcodeToCharset(Pool& pool,  void Charset::transcodeToCharset(Pool& pool,
                                                                            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 *& dest_body, size_t& dest_content_length) const {                                                                             const void *& adest_body, size_t& adest_content_length) const {
         if(&dest_charset==this) {          if(&dest_charset==this) {
                 dest_body=source_body;                  adest_body=source_body;
                 dest_content_length=source_content_length;                  adest_content_length=source_content_length;
         } else          } else {
                 throw Exception(0, 0,                  size_t dest_content_length=source_content_length;
                         0,                  unsigned char *dest_body=(unsigned char *)pool.malloc(dest_content_length);
                         "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=dest_body;*/                  const XMLByte* srcPtr=(XMLByte *)source_body;
 }                                         const XMLByte* srcEnd=(XMLByte *)source_body+source_content_length;
   
 #ifdef XML                  for(XMLByte* outPtr=dest_body; srcPtr<srcEnd; srcPtr++) {
 const char *Charset::transcode_cstr(const XalanDOMString& s) {                           XMLCh curVal = tables.fromTable[*srcPtr];
         const unsigned int len=s.size()*2;                          if(curVal) 
         XMLByte* dest=(XMLByte *)malloc((len+1)*sizeof(XMLByte));                                  *outPtr++=xlatOneTo(curVal, dest_charset.tables);
         bool error=true;                          else {
         try {                                  // use the replacement character
                 if(transcoder) {                                  *outPtr++= '?';
                         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;  
                 }                  }
         } catch(XMLException& e) {  
                 Exception::provide_source(pool(), 0, e);                  adest_body=dest_body;
                   adest_content_length=dest_content_length;
         }          }
         return(const char *)dest;  }                       
   
   #ifdef XML
   static int         xml256CharEncodingInputFunc     (
                                                                                                           unsigned char *out,
                                                                                                           int *outlen,
                                                                                                           const unsigned char *in,
                                                                                                           int *inlen, 
                                                                                                           void *info) {
           return transcodeToUTF8(
                                                           in, *(unsigned int*)inlen,
                                                           out, *(unsigned int*)outlen,
                                                           *(const Charset::Tables *)info);
   }
   
   static int         xml256CharEncodingOutputFunc    (
                                                                                                           unsigned char *out,
                                                                                                           int *outlen,
                                                                                                           const unsigned char *in,
                                                                                                           int *inlen, 
                                                                                                           void *info) {
           return transcodeFromUTF8(
                                                           in, *(unsigned int*)inlen,
                                                           out, *(unsigned int*)outlen,
                                                           *(const Charset::Tables *)info);
 }  }
 String& Charset::transcode(const XalanDOMString& s) {   
   
   void Charset::addEncoding(char *name_cstr) {
           xmlCharEncodingHandler *handler=
                   (xmlCharEncodingHandler *)malloc(sizeof(xmlCharEncodingHandler));
           handler->name=name_cstr;
           handler->input=xml256CharEncodingInputFunc; handler->inputInfo=&tables;
           handler->output=xml256CharEncodingOutputFunc; handler->outputInfo=&tables;
           
           xmlRegisterCharEncodingHandler(handler);
   }
   
   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));
           
           int size;
           if(xmlCharEncodingOutputFunc output=transcoder(0)->output) {
                   size=output(
                           (unsigned char*)out, &outlen,
                           (const unsigned char*)s, &inlen,
                           transcoder(0)->outputInfo);
           } else
                   memcpy(out, s, size=inlen);
           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));           return *NEW String(pool(), transcode_cstr(s)); 
 }  }
   
 std::auto_ptr<XalanDOMString>Charset::transcode_buf(const char *buf, size_t buf_size) {   /// @test less memory using -maybe- xmlParserInputBufferCreateMem
         unsigned int dest_size=0;  GdomeDOMString_auto_ptr Charset::transcode_buf(const char *buf, size_t buf_size) { 
         XMLCh* dest=(XMLCh *)malloc((buf_size+1)*sizeof(XMLCh));          int outlen=buf_size*6/*max*/+1;
         unsigned char *charSizes=(unsigned char *)malloc(buf_size*sizeof(unsigned char));          unsigned char *out=(unsigned char*)malloc(outlen*sizeof(unsigned char));
         XalanDOMString *result;  
         try {          int size;
                 if(transcoder) {          if(xmlCharEncodingInputFunc input=transcoder(0)->input) {
                         unsigned int bytesEaten;                  size=input(
                         unsigned int dest_size=transcoder->transcodeFrom(                          out, &outlen,
                                 (unsigned char *)buf,                          (const unsigned char *)buf,  (int *)&buf_size,
                                 (const unsigned int)buf_size,                          transcoder(0)->inputInfo);
                                 dest,(const unsigned int)buf_size,          } else
                                 bytesEaten,                  memcpy(out, buf, size=buf_size);
                                 charSizes  
                         );  
                         result=new XalanDOMString(dest, dest_size);  
                 }  
         } catch(XMLException& e) {  
                 Exception::provide_source(pool(), 0, e);  
                 result=0; //calm, compiler  
         }  
                   
         return std::auto_ptr<XalanDOMString>(result);          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<XalanDOMString>Charset::transcode(const String& s) {   GdomeDOMString_auto_ptr Charset::transcode(const String& s) { 
         const char *cstr=s.cstr(String::UL_UNSPECIFIED);          const char *cstr=s.cstr(String::UL_UNSPECIFIED);
   
         return transcode_buf(cstr, strlen(cstr));           return transcode_buf(cstr, strlen(cstr)); 
Removed from v.1.4  
changed lines
  Added in v.1.17

E-mail: