[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.68 and 1.76

version 1.68, 2009/04/15 04:51:40 version 1.76, 2009/05/14 11:27:23
Line 270  static const XMLByte gFirstByteMark[7] = Line 270  static const XMLByte gFirstByteMark[7] =
     0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC      0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC
 };  };
   
 static int transcodeToUTF8(const XMLByte* srcData, size_t& srcLen,  static int transcodeToUTF8(const XMLByte* srcData, int& srcLen,
                            XMLByte *toFill, size_t& toFillLen,                                  XMLByte *toFill, int& 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;
Line 353  of ocetes consumed. Line 353  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(const XMLByte* srcData, size_t& srcLen,  static int transcodeFromUTF8(const XMLByte* srcData, int& srcLen,
                              XMLByte* toFill, size_t& toFillLen,                                  XMLByte* toFill, int& 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;
Line 433  of ocetes consumed. Line 433  of ocetes consumed.
         return 0;          return 0;
 }  }
   
 static bool is_escaped(XMLByte c){  static bool isEscaped(XMLByte c){
         return          return
                 !(                  !(
                         (c<=127)                          (c<=127)
Line 446  static bool is_escaped(XMLByte c){ Line 446  static bool is_escaped(XMLByte c){
                 );                  );
 }  }
   
 // read one utf8 character, return number of bytes needed for store it  // read one UTF8 char and return length of this char (in bytes)
 static unsigned int readChar(const XMLByte*& srcPtr, const XMLByte* srcEnd, XMLByte& firstByte, XMLCh& UTF8Char){  static unsigned int readUTF8Char(const XMLByte*& srcPtr, const XMLByte* srcEnd, XMLByte& firstByte, XMLCh& UTF8Char){
         if(!srcPtr || !*srcPtr || srcPtr>=srcEnd)          if(!srcPtr || !*srcPtr || srcPtr>=srcEnd)
                 return 0;                  return 0;
   
Line 481  static unsigned int readChar(const XMLBy Line 481  static unsigned int readChar(const XMLBy
         return trailingBytes+1;          return trailingBytes+1;
 }  }
   
 static unsigned int skipChar(const XMLByte*& srcPtr, const XMLByte* srcEnd){  // skip UTF8 char and return length of this char (in bytes)
   static unsigned int skipUTF8Char(const XMLByte*& srcPtr, const XMLByte* srcEnd){
         if(!srcPtr || !*srcPtr || srcPtr>=srcEnd)          if(!srcPtr || !*srcPtr || srcPtr>=srcEnd)
                 return 0;                  return 0;
   
Line 491  static unsigned int skipChar(const XMLBy Line 492  static unsigned int skipChar(const XMLBy
         return trailingBytes;          return trailingBytes;
 }  }
   
 // read char, return number of bytes needed for store it as UTF8  // read non-UTF8 char, and return number of bytes needed for store this char in UTF8
 static unsigned int readChar(const XMLByte*& srcPtr, const XMLByte* srcEnd, XMLByte& firstByte, XMLCh& UTF8Char, const Charset::Tables& tables){  static unsigned int readChar(const XMLByte*& srcPtr, const XMLByte* srcEnd, XMLByte& firstByte, XMLCh& UTF8Char, const Charset::Tables& tables){
         if(!srcPtr || !*srcPtr || srcPtr>=srcEnd)          if(!srcPtr || !*srcPtr || srcPtr>=srcEnd)
                 return 0;                  return 0;
Line 517  static unsigned int readChar(const XMLBy Line 518  static unsigned int readChar(const XMLBy
         return 1;          return 1;
 }  }
   
 static int escape(const XMLByte* srcData, size_t& srcLen,  static int escapeUTF8(const XMLByte* srcData, size_t& srcLen,
                              XMLByte* toFill, size_t& toFillLen) {                               XMLByte* toFill, size_t& toFillLen) {
         const XMLByte* srcPtr=srcData;          const XMLByte* srcPtr=srcData;
         const XMLByte* srcEnd=srcData+srcLen;          const XMLByte* srcEnd=srcData+srcLen;
Line 528  static int escape(const XMLByte* srcData Line 529  static int escape(const XMLByte* srcData
         uint charSize;          uint charSize;
   
         // loop until we either run out of input data, or room to store          // loop until we either run out of input data, or room to store
         while((outPtr < outEnd) && (charSize=readChar(srcPtr, srcEnd, firstByte, UTF8Char))){          while((outPtr < outEnd) && (charSize=readUTF8Char(srcPtr, srcEnd, firstByte, UTF8Char))){
                 if(charSize==1){                  if(charSize==1){
                         if(is_escaped(firstByte)) // %XX                          if(isEscaped(firstByte)) // %XX
                                 outPtr+=sprintf((char*)outPtr, "%%%02X", firstByte);                                  outPtr+=sprintf((char*)outPtr, "%%%02X", firstByte);
                         else                          else
                                 *outPtr++=firstByte;                                  *outPtr++=firstByte;
Line 553  static int escape(const XMLByte* srcData Line 554  static int escape(const XMLByte* srcData
         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 firstByte;          XMLByte firstByte;
         XMLCh UTF8Char;          XMLCh UTF8Char;
         uint charSize;          uint charSize;
Line 561  static int escape(const XMLByte* srcData Line 561  static int escape(const XMLByte* srcData
         while(charSize=readChar(srcPtr, srcEnd, firstByte, UTF8Char, tables)){          while(charSize=readChar(srcPtr, srcEnd, firstByte, UTF8Char, tables)){
                 if(charSize==1){                  if(charSize==1){
                         if(firstByte){                          if(firstByte){
                                 if(is_escaped(firstByte)) // %XX                                  if(isEscaped(firstByte)) // %XX
                                         outPtr+=sprintf((char*)outPtr, "%%%02X", firstByte);                                          outPtr+=sprintf((char*)outPtr, "%%%02X", firstByte);
                                 else                                  else
                                         *outPtr++=firstByte;                                          *outPtr++=firstByte;
Line 594  String::C Charset::escape(const String:: Line 594  String::C Charset::escape(const String::
         XMLCh UTF8Char;          XMLCh UTF8Char;
   
         if(source_charset.isUTF8()){          if(source_charset.isUTF8()){
                 while(uint charSize=readChar(srcPtr, srcEnd, firstByte, UTF8Char)){                  while(uint charSize=readUTF8Char(srcPtr, srcEnd, firstByte, UTF8Char)){
                         if(charSize==1)                          if(charSize==1)
                                 dest_length+=!is_escaped(firstByte)?1:3/*%XX*/;                                  dest_length+=!isEscaped(firstByte)?1:3/*%XX*/;
                         else                          else
                                 dest_length+=6; // '%uXXXX'                                  dest_length+=6; // '%uXXXX'
                 }                  }
         } else {          } else {
                 while(uint charSize=readChar(srcPtr, srcEnd, firstByte, UTF8Char, source_charset.tables)){                  while(uint charSize=readChar(srcPtr, srcEnd, firstByte, UTF8Char, source_charset.tables)){
                         if(charSize==1)                          if(charSize==1)
                                 dest_length+=(!firstByte/*replacement char '?'*/ || !is_escaped(firstByte))?1:3/*'%XX'*/;                                  dest_length+=(!firstByte/*replacement char '?'*/ || !isEscaped(firstByte))?1:3/*'%XX'*/;
                         else                          else
                                 dest_length+=6; // '%uXXXX'                                  dest_length+=6; // '%uXXXX'
                 }                  }
Line 621  String::C Charset::escape(const String:: Line 621  String::C Charset::escape(const String::
   
         int status;          int status;
         if(source_charset.isUTF8()){          if(source_charset.isUTF8()){
                 status=::escape((XMLByte *)src.str, src_length, dest_body, dest_length);                  status=::escapeUTF8((XMLByte *)src.str, src_length, dest_body, dest_length);
         } else {          } else {
                 status=::escape((XMLByte *)src.str, src_length, dest_body, dest_length, source_charset.tables);                  status=::escape((XMLByte *)src.str, src_length, dest_body, dest_length, source_charset.tables);
         }          }
Line 629  String::C Charset::escape(const String:: Line 629  String::C Charset::escape(const String::
         if(status<0)          if(status<0)
                 throw Exception(0,                  throw Exception(0,
                         0,                          0,
                         "Charset::escapeString buffer overflow");                          "Charset::escape buffer overflow");
   
         assert(dest_length<=saved_dest_length);          assert(dest_length<=saved_dest_length);
         dest_body[dest_length]=0; // terminator          dest_body[dest_length]=0; // terminator
Line 640  String::Body Charset::escape(const Strin Line 640  String::Body Charset::escape(const Strin
         const char *src_ptr=src.cstr();          const char *src_ptr=src.cstr();
         size_t src_size=strlen(src_ptr);          size_t src_size=strlen(src_ptr);
   
         String::C dest=Charset::escape(String::C(src_ptr, src_size),          String::C dest=Charset::escape(String::C(src_ptr, src_size), source_charset);
                 source_charset);  
   
         return String::Body(dest.str, dest.length);          return String::Body(dest.str);
 }  }
   
 String& Charset::escape(const String& src, const Charset& source_charset) {  String& Charset::escape(const String& src, const Charset& source_charset) {
         if(!src.length())          if(src.is_empty())
                 return *new String("", 0, false);                  return *new String();
   
         return *new String(escape((String::Body)src, source_charset), String::L_CLEAN);          return *new String(escape((String::Body)src, source_charset), String::L_CLEAN);
 }  }
   
 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;          int src_length=src.length;
   
 #ifdef PRECALCULATE_DEST_LENGTH  #ifdef PRECALCULATE_DEST_LENGTH
         size_t dest_length=0;          int dest_length=0;
         const XMLByte* srcPtr=(XMLByte*)src.str;          const XMLByte* srcPtr=(XMLByte*)src.str;
         const XMLByte* srcEnd=srcPtr+src_length;          const XMLByte* srcEnd=srcPtr+src_length;
         XMLByte firstByte;          XMLByte firstByte;
         XMLCh UTF8Char;          XMLCh UTF8Char;
         while(uint charSize=skipChar(srcPtr, srcEnd))          while(uint charSize=readChar(srcPtr, srcEnd, firstByte, UTF8Char, tables))
                 dest_length+=charSize;                  dest_length+=charSize;
 #else  #else
         size_t dest_length=src_length*6; // so that surly enough (max utf8 seq len=6) but too memory-hyngry          int dest_length=src_length*6; // so that surly enough (max utf8 seq len=6) but too memory-hyngry
 #endif  #endif
   
         //throw Exception(0,0,"%u",dest_length);          //throw Exception(0,0,"%u",dest_length);
   
 #ifndef NDEBUG  #ifndef NDEBUG
         size_t saved_dest_length=dest_length;          int saved_dest_length=dest_length;
 #endif  #endif
         XMLByte *dest_body=new(PointerFreeGC) XMLByte[dest_length+1/*for terminator*/];          XMLByte *dest_body=new(PointerFreeGC) XMLByte[dest_length+1/*for terminator*/];
   
Line 829  static size_t getDecNumLength(XMLCh UTF8 Line 828  static size_t getDecNumLength(XMLCh UTF8
 }  }
   
 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;          int src_length=src.length;
   
 #ifdef PRECALCULATE_DEST_LENGTH  #ifdef PRECALCULATE_DEST_LENGTH
         size_t dest_length=0;          int dest_length=0;
         const XMLByte* srcPtr=(XMLByte*)src.str;          const XMLByte* srcPtr=(XMLByte*)src.str;
         const XMLByte* srcEnd=srcPtr+src_length;          const XMLByte* srcEnd=srcPtr+src_length;
         XMLByte firstByte;          XMLByte firstByte;
         XMLCh UTF8Char;          XMLCh UTF8Char;
         while(uint charSize=readChar(srcPtr, srcEnd, firstByte, UTF8Char)){          while(uint charSize=readUTF8Char(srcPtr, srcEnd, firstByte, UTF8Char)){
                 if(charSize==1)                  if(charSize==1)
                         dest_length++;                          dest_length++;
                 else                  else
Line 849  const String::C Charset::transcodeFromUT Line 848  const String::C Charset::transcodeFromUT
         }          }
 #else  #else
         // so that surly enough, "&#XXX;" has max ratio (huh? 8 bytes needed for '&#XXXXX;')          // so that surly enough, "&#XXX;" has max ratio (huh? 8 bytes needed for '&#XXXXX;')
         size_t dest_length=src_length*6;          int dest_length=src_length*6;
 #endif  #endif
   
         //throw Exception(0,0,"%u",dest_length);  
   
 #ifndef NDEBUG  #ifndef NDEBUG
         size_t saved_dest_length=dest_length;          int saved_dest_length=dest_length;
 #endif  #endif
         XMLByte *dest_body=new(PointerFreeGC) XMLByte[dest_length+1/*for terminator*/];          XMLByte *dest_body=new(PointerFreeGC) XMLByte[dest_length+1/*for terminator*/];
   
Line 913  static const Charset::Tables* tables[MAX Line 910  static const Charset::Tables* tables[MAX
                 unsigned char *out, int *outlen, \                  unsigned char *out, int *outlen, \
                 const unsigned char *in, int *inlen, void*) { \                  const unsigned char *in, int *inlen, void*) { \
                 return transcodeToUTF8( \                  return transcodeToUTF8( \
                         in, *(size_t*)inlen, \                          in, *inlen, \
                         out, *(size_t*)outlen, \                          out, *outlen, \
                         *tables[i]); \                          *tables[i]); \
         } \          } \
         static int xml256CharEncodingOutputFunc##i( \          static int xml256CharEncodingOutputFunc##i( \
                 unsigned char *out, int *outlen, \                  unsigned char *out, int *outlen, \
                 const unsigned char *in, int *inlen, void*) { \                  const unsigned char *in, int *inlen, void*) { \
                 return transcodeFromUTF8( \                  return transcodeFromUTF8( \
                         in, *(size_t*)inlen, \                          in, *inlen, \
                         out, *(size_t*)outlen, \                          out, *outlen, \
                         *tables[i]); \                          *tables[i]); \
         }          }
   
Line 933  static const Charset::Tables* tables[MAX Line 930  static const Charset::Tables* tables[MAX
                 unsigned char *out, int *outlen, \                  unsigned char *out, int *outlen, \
                 const unsigned char *in, int *inlen) { \                  const unsigned char *in, int *inlen) { \
                 return transcodeToUTF8( \                  return transcodeToUTF8( \
                         in, *(size_t*)inlen, \                          in, *inlen, \
                         out, *(size_t*)outlen, \                          out, *outlen, \
                         *tables[i]); \                          *tables[i]); \
         } \          } \
         static int xml256CharEncodingOutputFunc##i( \          static int xml256CharEncodingOutputFunc##i( \
                 unsigned char *out, int *outlen, \                  unsigned char *out, int *outlen, \
                 const unsigned char *in, int *inlen) { \                  const unsigned char *in, int *inlen) { \
                 return transcodeFromUTF8( \                  return transcodeFromUTF8( \
                         in, *(size_t*)inlen, \                          in, *inlen, \
                         out, *(size_t*)outlen, \                          out, *outlen, \
                         *tables[i]); \                          *tables[i]); \
         }          }
   
Line 1038  String::C Charset::transcode_cstr(const Line 1035  String::C Charset::transcode_cstr(const
 }  }
 const String& Charset::transcode(const xmlChar* s) {   const String& Charset::transcode(const xmlChar* s) { 
         String::C cstr=transcode_cstr(s);          String::C cstr=transcode_cstr(s);
         return *new String(cstr.str, cstr.length, true);          return *new String(cstr.str, String::L_TAINTED);
 }  }
   
 /// @test less memory using -maybe- xmlParserInputBufferCreateMem  /// @test less memory using -maybe- xmlParserInputBufferCreateMem
Line 1103  String::Body Charset::transcode(const St Line 1100  String::Body Charset::transcode(const St
                 source_transcoder,                  source_transcoder,
                 dest_transcoder);                  dest_transcoder);
   
         return String::Body(dest.str, dest.length);          return String::Body(dest.str);
 }  }
   
 String& Charset::transcode(const String& src,   String& Charset::transcode(const String& src, 
         const Charset& source_transcoder,           const Charset& source_transcoder, 
         const Charset& dest_transcoder) {          const Charset& dest_transcoder) {
         if(!src.length())          if(src.is_empty())
                 return *new String("", 0, false);                  return *new String();
   
         return *new String(transcode((String::Body)src, source_transcoder, dest_transcoder), String::L_CLEAN);          return *new String(transcode((String::Body)src, source_transcoder, dest_transcoder), String::L_CLEAN);
 }  }
Line 1128  struct Transcode_pair_info { Line 1125  struct Transcode_pair_info {
         const Charset* dest_transcoder;          const Charset* dest_transcoder;
 };  };
 #endif  #endif
 static void transcode_pair(const String::Body /*akey*/,   static void transcode_pair(HashStringValue::key_type /*akey*/, 
                          String::Body& avalue,                            String::Body& avalue, 
                          Transcode_pair_info* info) {                           Transcode_pair_info* info) {
         avalue=Charset::transcode(avalue,          avalue=Charset::transcode(avalue,
Line 1145  void Charset::transcode(HashStringString Line 1142  void Charset::transcode(HashStringString
   
 size_t getUTF8BytePos(const XMLByte* srcBegin, const XMLByte* srcEnd, size_t charPos){  size_t getUTF8BytePos(const XMLByte* srcBegin, const XMLByte* srcEnd, size_t charPos){
         const XMLByte* ptr=srcBegin;          const XMLByte* ptr=srcBegin;
         while(charPos-- && skipChar(ptr, srcEnd));          while(charPos-- && skipUTF8Char(ptr, srcEnd));
   
         return ptr-srcBegin;          return ptr-srcBegin;
 }  }
Line 1154  size_t getUTF8CharPos(const XMLByte* src Line 1151  size_t getUTF8CharPos(const XMLByte* src
         size_t charPos=0;          size_t charPos=0;
         const XMLByte* ptr=srcBegin;          const XMLByte* ptr=srcBegin;
         const XMLByte* ptrEnd=srcBegin+bytePos;          const XMLByte* ptrEnd=srcBegin+bytePos;
         while(skipChar(ptr, srcEnd)){          while(skipUTF8Char(ptr, srcEnd)){
                 if(ptr>ptrEnd)                  if(ptr>ptrEnd)
                         return charPos;                          return charPos;
                 charPos++;                  charPos++;
Line 1168  size_t getUTF8CharPos(const XMLByte* src Line 1165  size_t getUTF8CharPos(const XMLByte* src
   
 size_t lengthUTF8(const XMLByte* srcBegin, const XMLByte* srcEnd){  size_t lengthUTF8(const XMLByte* srcBegin, const XMLByte* srcEnd){
         size_t size=0;          size_t size=0;
         while(skipChar(srcBegin, srcEnd))          while(skipUTF8Char(srcBegin, srcEnd))
                 size++;                  size++;
   
         return size;          return size;
Removed from v.1.68  
changed lines
  Added in v.1.76

E-mail: