[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.33.2.19.2.16 and 1.37

version 1.33.2.19.2.16, 2003/04/08 12:47:31 version 1.37, 2003/09/25 09:15:03
Line 68  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(const String& aname, const String* afile_spec):   Charset::Charset(Request_charsets* charsets, const String::Body ANAME, const String* afile_spec): 
         fname(aname),          FNAME(ANAME),
         fname_cstr(aname.cstrm()) {          FNAME_CSTR(ANAME.cstrm()) {
   
         for(char *c=fname_cstr; *c; c++)  
                 *c = toupper(*c);  
   
         if(afile_spec) {          if(afile_spec) {
                 fisUTF8=false;                  fisUTF8=false;
                 load_definition(*afile_spec);                  load_definition(*charsets, *afile_spec);
 #ifdef XML  #ifdef XML
                 addEncoding(fname_cstr);                  addEncoding(FNAME_CSTR);
 #endif  #endif
         } else {          } else {
                 fisUTF8=true;                  fisUTF8=true;
Line 88  Charset::Charset(const String& aname, co Line 85  Charset::Charset(const String& aname, co
         }          }
   
 #ifdef XML  #ifdef XML
         initTranscoder(fname, fname_cstr);          initTranscoder(FNAME, FNAME_CSTR);
 #endif  #endif
 }  }
   
 void Charset::load_definition(const String& afile_spec) {  void Charset::load_definition(Request_charsets& charsets, const String& afile_spec) {
         // pcre_tables          // pcre_tables
         // lowcase, flipcase, bits digit+word+whitespace, masks          // lowcase, flipcase, bits digit+word+whitespace, masks
   
Line 110  void Charset::load_definition(const Stri Line 107  void Charset::load_definition(const Stri
         tables.toTableSize++;          tables.toTableSize++;
   
         // loading text          // loading text
         char *data=file_read_text(UTF8_charset, afile_spec);          char *data=file_read_text(charsets, afile_spec);
   
         // ignore header          // ignore header
         getrow(&data);          getrow(&data);
Line 177  void Charset::sort_ToTable() { Line 174  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) {                           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;
     do {          do {
         // Calc the mid point of the low and high offset.                  // 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                  //  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>tables.toTable[midOfs].intCh)                  if(toXlat>tables.toTable[midOfs].intCh)
             lowOfs = midOfs;                          lowOfs = midOfs;
                 else if(toXlat<tables.toTable[midOfs].intCh)                  else if(toXlat<tables.toTable[midOfs].intCh)
                         hiOfs = midOfs;                          hiOfs = midOfs;
                 else                  else
                         return tables.toTable[midOfs].extCh;                          return tables.toTable[midOfs].extCh;
         } while(lowOfs+1<hiOfs);          } while(lowOfs+1<hiOfs);
           
     return not_found;          return not_found;
 }  }
   
 String::C Charset::transcode(const String::C src,  String::C Charset::transcode(const String::C src,
         const Charset& source_charset,           const Charset& source_charset, 
         const Charset& dest_charset) {          const Charset& dest_charset) {
         if(!src.length)          if(!src.length)
                 return String::C(0, 0);                  return String::C("", 0);
   
         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
Line 259  static const XMLByte gFirstByteMark[7] = Line 256  static const XMLByte gFirstByteMark[7] =
     0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC      0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC
 };  };
   
 static int transcodeToUTF8(  static int transcodeToUTF8(const XMLByte* srcData, size_t& srcLen,
                            const XMLByte* srcData, size_t& srcLen,  
                            XMLByte *toFill, size_t& toFillLen,                             XMLByte *toFill, size_t& toFillLen,
                            const Charset::Tables& tables) {                             const Charset::Tables& tables) {
         const XMLByte* srcPtr=srcData;          const XMLByte* srcPtr=srcData;
Line 268  static int transcodeToUTF8( Line 264  static int transcodeToUTF8(
         XMLByte* outPtr=toFill;          XMLByte* outPtr=toFill;
         XMLByte* outEnd=toFill+toFillLen;          XMLByte* outEnd=toFill+toFillLen;
   
     while(srcPtr<srcEnd) {          while(srcPtr<srcEnd) {
         uint curVal = tables.fromTable[*srcPtr];                  uint curVal = tables.fromTable[*srcPtr];
                 if(!curVal) {                  if(!curVal) {
             // use the replacement character                          // use the replacement character
             *outPtr++= '?';                          *outPtr++= '?';
             srcPtr++;                          srcPtr++;
             continue;                          continue;
         }                  }
   
         // 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                  // Figure out how many bytes we need
     toFillLen = outPtr - toFill;                  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;          //return srcPtr==srcEnd?(int)toFillLen:-1;
 /*  /*
 xmlCharEncodingInputFunc  xmlCharEncodingInputFunc
Line 343  of ocetes consumed. Line 339  of ocetes consumed.
         return 0;          return 0;
 }  }
 /// @todo digital entites only when xml/html output [at output in html/xml mode, in html part of a letter]  /// @todo digital entites only when xml/html output [at output in html/xml mode, in html part of a letter]
 static int transcodeFromUTF8(  static int transcodeFromUTF8(const XMLByte* srcData, size_t& srcLen,
                                                                 const XMLByte* srcData, size_t& srcLen,                               XMLByte* toFill, size_t& toFillLen,
                                                                 XMLByte* toFill, size_t& toFillLen,                               const Charset::Tables& tables) {
                                                                 const Charset::Tables& tables) {  
         const XMLByte* srcPtr=srcData;          const XMLByte* srcPtr=srcData;
         const XMLByte* srcEnd=srcData+srcLen;          const XMLByte* srcEnd=srcData+srcLen;
         XMLByte* outPtr=toFill;          XMLByte* outPtr=toFill;
         XMLByte* outEnd=toFill+toFillLen;          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) {
             *outPtr++= firstByte;                          *outPtr++= firstByte;
             srcPtr++;                          srcPtr++;
             continue;                          continue;
         }                  }
                   
         // See how many trailing src bytes this sequence is going to require                  // See how many trailing src bytes this sequence is going to require
         const unsigned int trailingBytes = gUTFBytes[firstByte];                  const unsigned int trailingBytes = gUTFBytes[firstByte];
                   
         //  If there are not enough source bytes to do this one, then we                  //  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.                  //  counting the 1 byte we get no matter what.
         if(srcPtr+trailingBytes>= srcEnd)                  if(srcPtr+trailingBytes>= srcEnd)
             break;                          break;
                   
         // Looks ok, so lets build up the value                  // Looks ok, so lets build up the value
         uint tmpVal=0;                  uint tmpVal=0;
         switch(trailingBytes) {                  switch(trailingBytes) {
             case 5: tmpVal+=*srcPtr++; tmpVal<<=6;                  case 5: tmpVal+=*srcPtr++; tmpVal<<=6;
             case 4: tmpVal+=*srcPtr++; tmpVal<<=6;                  case 4: tmpVal+=*srcPtr++; tmpVal<<=6;
             case 3: tmpVal+=*srcPtr++; tmpVal<<=6;                  case 3: tmpVal+=*srcPtr++; tmpVal<<=6;
             case 2: tmpVal+=*srcPtr++; tmpVal<<=6;                  case 2: tmpVal+=*srcPtr++; tmpVal<<=6;
             case 1: tmpVal+=*srcPtr++; tmpVal<<=6;                  case 1: tmpVal+=*srcPtr++; tmpVal<<=6;
             case 0: tmpVal+=*srcPtr++;                  case 0: tmpVal+=*srcPtr++;
                      break;                          break;
                           
             default:                  default:
                 throw Exception(0,                          throw Exception(0,
                                         0,                                  0,
                                         "transcodeFromUTF8 error: wrong trailingBytes value(%d)", trailingBytes);                                  "transcodeFromUTF8 error: wrong trailingBytes value(%d)", trailingBytes);
         }                  }
         tmpVal-=gUTFOffsets[trailingBytes];                  tmpVal-=gUTFOffsets[trailingBytes];
                   
         //  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)) {
                         if(XMLByte xlat=xlatOneTo(tmpVal, tables, 0))                          if(XMLByte xlat=xlatOneTo(tmpVal, tables, 0))
                                 *outPtr++=xlat;                                  *outPtr++=xlat;
                         else                           else 
                                 outPtr+=sprintf((char *)outPtr, "&#%d;", tmpVal); // &#decimal;                                  outPtr+=sprintf((char *)outPtr, "&#%d;", tmpVal); // &#decimal;
                 } else                  } else
                         throw Exception(0,                          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          // Update the bytes eaten
     srcLen = srcPtr - srcData;          srcLen = srcPtr - srcData;
           
     // Return the characters read          // Return the characters read
     toFillLen = outPtr - toFill;          toFillLen = outPtr - toFill;
   
         //return srcPtr==srcEnd?(int)toFillLen:-1;          //return srcPtr==srcEnd?(int)toFillLen:-1;
 /*  /*
Line 426  of ocetes consumed. Line 421  of ocetes consumed.
 const String::C Charset::transcodeToUTF8(const String::C src) const {  const String::C Charset::transcodeToUTF8(const String::C src) const {
         size_t src_length=src.length;          size_t src_length=src.length;
         size_t dest_length=src.length*6/*so that surly enough, max utf8 seq len=6*/;          size_t dest_length=src.length*6/*so that surly enough, max utf8 seq len=6*/;
   #ifndef NDEBUG
           size_t saved_dest_length=dest_length;
   #endif
         XMLByte *dest_body=new(PointerFreeGC) XMLByte[dest_length+1/*for terminator*/];          XMLByte *dest_body=new(PointerFreeGC) XMLByte[dest_length+1/*for terminator*/];
   
         if(::transcodeToUTF8(          if(::transcodeToUTF8(
Line 436  const String::C Charset::transcodeToUTF8 Line 434  const String::C Charset::transcodeToUTF8
                         0,                          0,
                         "Charset::transcodeToUTF8 buffer overflow");                          "Charset::transcodeToUTF8 buffer overflow");
   
         dest_body[dest_length]=0; // terminator          assert(dest_length<=saved_dest_length); dest_body[dest_length]=0; // terminator
         return String::C((char*)dest_body, dest_length);          return String::C((char*)dest_body, dest_length);
 }  }
 const String::C Charset::transcodeFromUTF8(const String::C src) const {  const String::C Charset::transcodeFromUTF8(const String::C src) const {
         size_t src_length=src.length;          size_t src_length=src.length;
         size_t dest_length=src.length*6/*so that surly enough, "&#255;" has max ratio */;          size_t dest_length=src.length*6/*so that surly enough, "&#255;" has max ratio */;
   #ifndef NDEBUG
           size_t saved_dest_length=dest_length;
   #endif
         XMLByte *dest_body=new(PointerFreeGC) XMLByte[dest_length+1/*for terminator*/];          XMLByte *dest_body=new(PointerFreeGC) XMLByte[dest_length+1/*for terminator*/];
   
         if(::transcodeFromUTF8(          if(::transcodeFromUTF8(
Line 452  const String::C Charset::transcodeFromUT Line 453  const String::C Charset::transcodeFromUT
                         0,                          0,
                         "Charset::transcodeFromUTF8 buffer overflow");                          "Charset::transcodeFromUTF8 buffer overflow");
   
         dest_body[dest_length]=0; // terminator          assert(dest_length<=saved_dest_length); dest_body[dest_length]=0; // terminator
         return String::C((char*)dest_body, dest_length);          return String::C((char*)dest_body, dest_length);
 }  }
   
Line 467  const String::C Charset::transcodeToChar Line 468  const String::C Charset::transcodeToChar
   
                 XMLByte* output=dest_body;                  XMLByte* output=dest_body;
                 const XMLByte* input=(XMLByte *)src.str;                  const XMLByte* input=(XMLByte *)src.str;
                 while(char c=*input++) {                  while(XMLCh c=*input++) {
                         XMLCh curVal = tables.fromTable[c];                          XMLCh curVal = tables.fromTable[c];
                         *output++=curVal?                          *output++=curVal?
                                 xlatOneTo(curVal, dest_charset.tables, '?') // OK                                  xlatOneTo(curVal, dest_charset.tables, '?') // OK
Line 543  void Charset::addEncoding(char *name_cst Line 544  void Charset::addEncoding(char *name_cst
   
 }  }
   
 void Charset::initTranscoder(const String& name, const char* name_cstr) {  void Charset::initTranscoder(const String::Body NAME, const char* name_cstr) {
         ftranscoder=xmlFindCharEncodingHandler(name_cstr);          ftranscoder=xmlFindCharEncodingHandler(name_cstr);
         transcoder(name); // check right way          transcoder(NAME); // check right way
 }  }
   
 xmlCharEncodingHandler& Charset::transcoder(const String& name) {  xmlCharEncodingHandler& Charset::transcoder(const String::Body NAME) {
         if(!ftranscoder)          if(!ftranscoder)
                 throw Exception("parser.runtime",                  throw Exception("parser.runtime",
                         &name,                          new String(NAME, String::L_TAINTED),
                         "unsupported encoding");                          "unsupported encoding");
         return *ftranscoder;          return *ftranscoder;
 }  }
   
 const char* Charset::transcode_cstr(xmlChar* s) {  String::C Charset::transcode_cstr(xmlChar* s) {
         if(!s)          if(!s)
                 return "";                  return String::C("", 0);
   
         int inlen=strlen((const char* )s);          int inlen=strlen((const char*)s);
         int outlen=inlen+1; // max          int outlen=inlen; // max
         char *out=new(PointerFreeGC) char[outlen];  #ifndef NDEBUG
           int saved_outlen=outlen;
   #endif
           char *out=new(PointerFreeGC) char[outlen+1];
                   
         int error;          int error;
         if(xmlCharEncodingOutputFunc output=transcoder(fname).output) {          if(xmlCharEncodingOutputFunc output=transcoder(FNAME).output) {
                 error=output(                  error=output(
                         (unsigned char*)out, &outlen,                          (unsigned char*)out, &outlen,
                         (const unsigned char*)s, &inlen);                          (const unsigned char*)s, &inlen);
Line 578  const char* Charset::transcode_cstr(xmlC Line 582  const char* Charset::transcode_cstr(xmlC
                         0,                          0,
                         "transcode_cstr failed (%d)", error);                          "transcode_cstr failed (%d)", error);
   
         out[outlen/*surely would be less then on input*/]=0;          assert(outlen<=saved_outlen); out[outlen]=0;
         return out;          return String::C(out, outlen);
 }  }
 const String& Charset::transcode(xmlChar* s) {   const String& Charset::transcode(xmlChar* s) { 
         return *new String(transcode_cstr(s), 0/*auto-size*/, true);          String::C cstr=transcode_cstr(s);
           return *new String(cstr.str, cstr.length, true);
 }  }
 const char* Charset::transcode_cstr(GdomeDOMString* s) {   String::C Charset::transcode_cstr(GdomeDOMString* s) { 
         return s?transcode_cstr(BAD_CAST s->str):"";          return s?transcode_cstr(BAD_CAST s->str)
                   :String::C("", 0);
 }  }
 const String& Charset::transcode(GdomeDOMString* s) {   const String& Charset::transcode(GdomeDOMString* s) { 
         return *new String(transcode_cstr(s), 0/*auto-size*/, true);          String::C cstr=transcode_cstr(s);
           return *new String(cstr.str, cstr.length, true);
 }  }
   
 /// @test less memory using -maybe- xmlParserInputBufferCreateMem  /// @test less memory using -maybe- xmlParserInputBufferCreateMem
 void* Charset::transcode_buf2mchar(transcode_buf_malloc_func malloc_func,   xmlChar* Charset::transcode_buf2xchar(const char* buf, size_t buf_size) {
                                    const char* buf, size_t buf_size) {          xmlChar* out;
         unsigned char* out;  
         int outlen;          int outlen;
         int error;          int error;
         if(xmlCharEncodingInputFunc input=transcoder(fname).input) {  #ifndef NDEBUG
           int saved_outlen;
   #endif
           if(xmlCharEncodingInputFunc input=transcoder(FNAME).input) {
                 outlen=buf_size*6/*max*/;                  outlen=buf_size*6/*max*/;
                 out=(unsigned char*)malloc_func(outlen+1);  #ifndef NDEBUG
                   saved_outlen=outlen;
   #endif
                   out=(xmlChar*)xmlMalloc(outlen+1);
                 error=input(                  error=input(
                         out, &outlen,                          out, &outlen,
                         (const unsigned char *)buf,  (int *)&buf_size);                          (const unsigned char*)buf, (int*)&buf_size);
         } else {          } else {
                 outlen=buf_size;                  outlen=buf_size;
                 out=(unsigned char*)malloc_func(outlen+1);  #ifndef NDEBUG
                   saved_outlen=outlen;
   #endif
                   out=(xmlChar*)xmlMalloc(outlen+1);
                 memcpy(out, buf, outlen);                  memcpy(out, buf, outlen);
                 error=0;                  error=0;
         }          }
Line 615  void* Charset::transcode_buf2mchar(trans Line 630  void* Charset::transcode_buf2mchar(trans
                         0,                          0,
                         "transcode_buf failed (%d)", error);                          "transcode_buf failed (%d)", error);
   
         out[outlen/*surely would be less then on input*/]=0;          assert(outlen<=saved_outlen); out[outlen]=0;
         return out;          return out;
 }  }
   
 xmlChar* Charset::transcode_buf2xchar(const char* buf, size_t buf_size) {  
         return static_cast<xmlChar*>(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<gchar*>(transcode_buf2mchar(g_malloc_wrapper, buf, buf_size));  
 }  
 GdomeDOMString_auto_ptr Charset::transcode_buf2dom(const char* buf, size_t buf_size) {   GdomeDOMString_auto_ptr Charset::transcode_buf2dom(const char* buf, size_t buf_size) { 
         return GdomeDOMString_auto_ptr(transcode_buf2gchar(buf, buf_size));          return GdomeDOMString_auto_ptr(transcode_buf2xchar(buf, buf_size));
 }  }
 GdomeDOMString_auto_ptr Charset::transcode(const String& s) {   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));           return transcode_buf2dom(cstr, strlen(cstr)); 
 }  }
 GdomeDOMString_auto_ptr Charset::transcode(const StringBody s) {   GdomeDOMString_auto_ptr Charset::transcode(const String::Body s) { 
         const char* cstr=s.cstr();          const char* cstr=s.cstr();
   
         return transcode_buf2dom(cstr, s.length());           return transcode_buf2dom(cstr, s.length()); 
 }  }
 #endif  #endif
   
   String::Body Charset::transcode(const String::Body src, 
           const Charset& source_transcoder, 
           const Charset& dest_transcoder) {
   
           const char *src_ptr=src.cstr();
           size_t src_size=strlen(src_ptr);
   
           String::C dest=Charset::transcode(String::C(src_ptr, src_size),
                   source_transcoder,
                   dest_transcoder);
   
           return String::Body(dest.str, dest.length);
   }
   
   String& Charset::transcode(const String& src, 
           const Charset& source_transcoder, 
           const Charset& dest_transcoder) {
           if(!src.length())
                   return *new String("", 0, false);
   
           return *new String(transcode((String::Body)src, source_transcoder, dest_transcoder), String::L_CLEAN);
   }
   
   void Charset::transcode(ArrayString& src,
           const Charset& source_transcoder, 
           const Charset& dest_transcoder) {
           for(size_t i=0; i<src.count(); i++)
                   src.put(i, &transcode(*src[i], source_transcoder, dest_transcoder));
   }
   
   #ifndef DOXYGEN
   struct Transcode_pair_info {
           const Charset* source_transcoder;
           const Charset* dest_transcoder;
   };
   #endif
   static void transcode_pair(const String::Body akey, 
                            String::Body& avalue, 
                            Transcode_pair_info* info) {
           avalue=Charset::transcode(avalue,
                   *info->source_transcoder, 
                   *info->dest_transcoder);
   }
   void Charset::transcode(HashStringString& src,
           const Charset& source_transcoder, 
           const Charset& dest_transcoder) {
           Transcode_pair_info info={&source_transcoder, &dest_transcoder};
           src.for_each_ref(transcode_pair, &info);
   }
Removed from v.1.33.2.19.2.16  
changed lines
  Added in v.1.37

E-mail: