[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.35.2.1 and 1.38.2.1

version 1.35.2.1, 2003/07/24 15:10:42 version 1.38.2.1, 2003/11/05 13:53:30
Line 14  static const char* IDENT_CHARSET_C="$Dat Line 14  static const char* IDENT_CHARSET_C="$Dat
 #include "libxml/encoding.h"  #include "libxml/encoding.h"
 #endif  #endif
   
   // globals
   
   Charset::UTF8CaseTable::Rec UTF8CaseToUpperRecords[]={
   #include "utf8-to-upper.inc"
   };
   Charset::UTF8CaseTable UTF8CaseToUpper={
           sizeof(UTF8CaseToUpperRecords)/sizeof(Charset::UTF8CaseTable::Rec),
           UTF8CaseToUpperRecords};
   
   Charset::UTF8CaseTable::Rec UTF8CaseToLowerRecords[]={
   #include "utf8-to-lower.inc"
   };
   Charset::UTF8CaseTable UTF8CaseToLower={
           sizeof(UTF8CaseToLowerRecords)/sizeof(Charset::UTF8CaseTable::Rec),
           UTF8CaseToLowerRecords};
   
 // helpers  // helpers
   
 inline void prepare_case_tables(unsigned char *tables) {  inline void prepare_case_tables(unsigned char *tables) {
Line 68  static void element2case(unsigned char f Line 84  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(Request_charsets* charsets, const StringBody 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()) {
   
Line 101  void Charset::load_definition(Request_ch Line 117  void Charset::load_definition(Request_ch
   
         // charset          // charset
         memset(&tables, 0, sizeof(tables));          memset(&tables, 0, sizeof(tables));
         // strangly vital  
         tables.toTable[tables.toTableSize].intCh=0;  
         tables.toTable[tables.toTableSize].extCh=(XMLByte)0;  
         tables.toTableSize++;  
   
         // loading text          // loading text
         char *data=file_read_text(charsets, afile_spec);          char *data=file_read_text(charsets, afile_spec);
Line 161  void Charset::load_definition(Request_ch Line 173  void Charset::load_definition(Request_ch
   
 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::Tables::Rec *>(a)->intCh-
                 static_cast<const Charset_TransRec *>(b)->intCh;                  static_cast<const Charset::Tables::Rec *>(b)->intCh;
 }  }
   
 void Charset::sort_ToTable() {  void Charset::sort_ToTable() {
Line 176  void Charset::sort_ToTable() { Line 188  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;          int    lo = 0;
         unsigned int    hiOfs = tables.toTableSize - 1;          int    hi = tables.toTableSize - 1;
         XMLByte         curByte = 0;          while(lo<=hi) {
         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 i = (lo + hi) / 2;
                   
                 //  If our test char is greater than the mid point char, then                  XMLCh cur=tables.toTable[i].intCh;
                 //  we move up to the upper half. Else we move to the lower                  if(toXlat==cur)
                 //  half. If its equal, then its our guy.                          return tables.toTable[i].extCh;
                 if(toXlat>tables.toTable[midOfs].intCh)                  if(toXlat>cur)
                         lowOfs = midOfs;                          lo = i+1;
                 else if(toXlat<tables.toTable[midOfs].intCh)  
                         hiOfs = midOfs;  
                 else                  else
                         return tables.toTable[midOfs].extCh;                          hi = i-1;
         } while(lowOfs+1<hiOfs);          }
                   
         return not_found;          return not_found;
 }  }
Line 437  const String::C Charset::transcodeToUTF8 Line 446  const String::C Charset::transcodeToUTF8
         assert(dest_length<=saved_dest_length); 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);
 }  }
   
   static XMLCh change_case_UTF8(const XMLCh src, const Charset::UTF8CaseTable& table) {
           int    lo = 0;
           int    hi = table.size - 1;
           while(lo<=hi) {
                   // Calc the mid point of the low and high offset.
                   const unsigned int i = (lo + hi) / 2;
   
                   XMLCh cur=table.records[i].from;
                   if(src==cur)
                           return table.records[i].to;
                   if(src>cur)
                           lo = i+1;
                   else
                           hi = i-1;
           }
   
           // not found
           return src;
   }
   
   static void store_UTF8(XMLCh src, XMLByte*& outPtr ) {
           if(!src) {
                   // use the replacement character
                   *outPtr++= '?';
                   return;
           }
   
           // Figure out how many bytes we need
           unsigned int encodedBytes;
           if(src<0x80)
                   encodedBytes = 1;
           else if(src<0x800)
                   encodedBytes = 2;
           else if(src<0x10000)
                   encodedBytes = 3;
           else if(src<0x200000)
                   encodedBytes = 4;
           else if(src<0x4000000)
                   encodedBytes = 5;
           else if(src<= 0x7FFFFFFF)
                   encodedBytes = 6;
           else {
                   // use the replacement character
                   *outPtr++= '?';
                   return;
           }
   
           //  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((src | 0x80UL) & 0xBFUL);
                   src>>= 6;
           case 5: *--outPtr = XMLByte((src | 0x80UL) & 0xBFUL);
                   src>>= 6;
           case 4: *--outPtr = XMLByte((src | 0x80UL) & 0xBFUL);
                   src>>= 6;
           case 3: *--outPtr = XMLByte((src | 0x80UL) & 0xBFUL);
                   src>>= 6;
           case 2: *--outPtr = XMLByte((src | 0x80UL) & 0xBFUL);
                   src>>= 6;
           case 1: *--outPtr = XMLByte(src | gFirstByteMark[encodedBytes]);
           }
           
           // Add the encoded bytes back in again to indicate we've eaten them
           outPtr+= encodedBytes;
   }
   
   static void change_case_UTF8(XMLCh src, XMLByte*& outPtr, 
                                                   const Charset::UTF8CaseTable& table) {
           store_UTF8(change_case_UTF8(src, table), outPtr);
   };
   void change_case_UTF8(const XMLByte* srcData, XMLByte* toFill, 
                                                           const Charset::UTF8CaseTable& table) {
           const XMLByte* srcPtr=srcData;
           XMLByte* outPtr=toFill;
   
           // Get the next leading byte out
           while (const XMLByte firstByte = *srcPtr) {
                   if(firstByte<= 127) {
                           change_case_UTF8(firstByte, outPtr, table);
                           srcPtr++;
                           continue;
                   }
                   
                   // See how many trailing src bytes this sequence is going to require
                   const unsigned int trailingBytes = gUTFBytes[firstByte];
                   
                   // Looks ok, so lets build up the value
                   uint tmpVal=0;
                   switch(trailingBytes) {
                   case 5: tmpVal+=*srcPtr++; tmpVal<<=6;
                   case 4: tmpVal+=*srcPtr++; tmpVal<<=6;
                   case 3: tmpVal+=*srcPtr++; tmpVal<<=6;
                   case 2: tmpVal+=*srcPtr++; tmpVal<<=6;
                   case 1: tmpVal+=*srcPtr++; tmpVal<<=6;
                   case 0: tmpVal+=*srcPtr++;
                           break;
                           
                   default:
                           throw Exception(0,
                                   0,
                                   "change_case_UTF8 error: wrong trailingBytes value(%d)", trailingBytes);
                   }
                   tmpVal-=gUTFOffsets[trailingBytes];
                   
                   //  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
                   //  replacement char.*]
                   if(!(tmpVal & 0xFFFF0000))
                           change_case_UTF8(tmpVal, outPtr, table);
                   else
                           throw Exception(0,
                                   0,
                                   "change_case_UTF8 error: too big tmpVal(0x%08X)", tmpVal);
           }
           
           if(srcPtr!=outPtr)
                   throw Exception(0,  
                           0,
                           "change_case_UTF8 error: end pointers do not match");
   }
   
   
 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 */;
Line 544  void Charset::addEncoding(char *name_cst Line 678  void Charset::addEncoding(char *name_cst
   
 }  }
   
 void Charset::initTranscoder(const StringBody 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 StringBody NAME) {  xmlCharEncodingHandler& Charset::transcoder(const String::Body NAME) {
         if(!ftranscoder)          if(!ftranscoder)
                 throw Exception("parser.runtime",                  throw Exception("parser.runtime",
                         new String(NAME, String::L_TAINTED),                          new String(NAME, String::L_TAINTED),
Line 641  GdomeDOMString_auto_ptr Charset::transco Line 775  GdomeDOMString_auto_ptr Charset::transco
   
         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
   
 StringBody Charset::transcode(const StringBody src,   String::Body Charset::transcode(const String::Body src, 
         const Charset& source_transcoder,           const Charset& source_transcoder, 
         const Charset& dest_transcoder) {          const Charset& dest_transcoder) {
   
Line 659  StringBody Charset::transcode(const Stri Line 793  StringBody Charset::transcode(const Stri
                 source_transcoder,                  source_transcoder,
                 dest_transcoder);                  dest_transcoder);
   
         return StringBody(dest.str, dest.length);          return String::Body(dest.str, dest.length);
 }  }
   
 String& Charset::transcode(const String& src,   String& Charset::transcode(const String& src, 
Line 668  String& Charset::transcode(const String& Line 802  String& Charset::transcode(const String&
         if(!src.length())          if(!src.length())
                 return *new String("", 0, false);                  return *new String("", 0, false);
   
         return *new String(transcode((StringBody)src, source_transcoder, dest_transcoder), String::L_CLEAN);          return *new String(transcode((String::Body)src, source_transcoder, dest_transcoder), String::L_CLEAN);
 }  }
   
 void Charset::transcode(ArrayString& src,  void Charset::transcode(ArrayString& src,
Line 684  struct Transcode_pair_info { Line 818  struct Transcode_pair_info {
         const Charset* dest_transcoder;          const Charset* dest_transcoder;
 };  };
 #endif  #endif
 static void transcode_pair(const StringBody akey,   static void transcode_pair(const String::Body akey, 
                          StringBody& avalue,                            String::Body& avalue, 
                          Transcode_pair_info* info) {                           Transcode_pair_info* info) {
         avalue=Charset::transcode(avalue,          avalue=Charset::transcode(avalue,
                 *info->source_transcoder,                   *info->source_transcoder, 
Removed from v.1.35.2.1  
changed lines
  Added in v.1.38.2.1

E-mail: