[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.19 and 1.33.2.19.2.26

version 1.33.2.19.2.19, 2003/04/10 08:33:05 version 1.33.2.19.2.26, 2003/06/27 08:36:59
Line 201  String::C Charset::transcode(const Strin Line 201  String::C Charset::transcode(const Strin
         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 256  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 340  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 423  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 433  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 449  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 553  xmlCharEncodingHandler& Charset::transco Line 557  xmlCharEncodingHandler& Charset::transco
         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) {
Line 575  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;
   #ifndef NDEBUG
           int saved_outlen;
   #endif
         if(xmlCharEncodingInputFunc input=transcoder(FNAME).input) {          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(
                           out, &outlen,
                           (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 609  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) {  
         if(void* out=g_malloc(size))  
                 return out;  
   
         return pa_fail_alloc("g_malloc_wrapper", size);  
 }  
 gchar* Charset::transcode_buf2gchar(const char* buf, size_t buf_size) {  
         return static_cast<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);
Line 638  GdomeDOMString_auto_ptr Charset::transco Line 646  GdomeDOMString_auto_ptr Charset::transco
   
         return transcode_buf2dom(cstr, s.length());           return transcode_buf2dom(cstr, s.length()); 
 }  }
   
   StringBody Charset::transcode(const StringBody 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 StringBody(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((StringBody)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 StringBody akey, 
                            StringBody& 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);
   }
 #endif  #endif
Removed from v.1.33.2.19.2.19  
changed lines
  Added in v.1.33.2.19.2.26

E-mail: