[BACK]Return to pa_charset.h CVS log [TXT] [DIR] Up to [parser3project] / parser3 / src / include

Diff for /parser3/src/include/pa_charset.h between versions 1.9 and 1.59

version 1.9, 2002/01/15 13:18:43 version 1.59, 2024/11/04 03:53:25
Line 1 Line 1
 /** @file  /** @file
         Parser: Charset connection decl.          Parser: Charset connection decl.
   
         Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)          Copyright (c) 2001-2024 Art. Lebedev Studio (http://www.artlebedev.com)
         Author: Alexander Petrosyan <paf@design.ru> (http://paf.design.ru)          Authors: Konstantin Morshnev <moko@design.ru>, Alexandr Petrosian <paf@design.ru>
   
         $Id$  
 */  */
   
 #ifndef PA_CHARSET_H  #ifndef PA_CHARSET_H
 #define PA_CHARSET_H  #define PA_CHARSET_H
   
 #include "pa_pool.h"  #define IDENT_PA_CHARSET_H "$Id$"
   
   
 #include "pa_exception.h"  #include "pa_exception.h"
 #include "pa_common.h"  #include "pa_common.h"
   #include "pa_hash.h"
   #include "pa_array.h"
   
 // hiding into namespace so to avoid stupid conflict  #ifdef HAVE_PCRE2
 namespace PCRE {  #include <pcre2.h>
 #include "pcre.h"  #else
 #       include "internal.h"  #include <pcre.h>
 };  #endif
   // we are using some pcre_internal.h stuff as well
   #include "../lib/pcre/pa_pcre_internal.h"
   
 #ifdef XML  #ifdef XML
 #include "libxml/encoding.h"  #include "libxml/encoding.h"
Line 26  namespace PCRE { Line 30  namespace PCRE {
   
 // defines  // defines
   
 #ifdef XML  #define MAX_CHARSETS 10
 /*#     include <util/XercesDefs.hpp>  
 #       include <util/TransService.hpp>  
 #       define Charset_TransRec XMLTransService::TransRec  
 */  
   
 #       ifndef XMLCh   #define MAX_CHARSET_UNI_CODES 500
 #               define XMLCh unsigned int  
 #       endif  
 #       ifndef XMLByte  
 #               define XMLByte unsigned char  
 #       endif  
   
         struct Charset_TransRec {  
                 XMLCh intCh;  
                 XMLByte extCh;  
         };  
   
 #else  #ifndef XMLCh 
 #       ifndef XMLCh           typedef unsigned int XMLCh;
 #               define XMLCh unsigned int  #endif
 #       endif  #ifndef XMLByte
 #       ifndef XMLByte          typedef unsigned char XMLByte;
 #               define XMLByte unsigned char  
 #       endif  
   
         struct Charset_TransRec {  
                 XMLCh intCh;  
                 XMLByte extCh;  
         };  
 #endif  #endif
   
   // helpers
   
   typedef HashString<String::Body> HashStringString;
   
 /**     charset holds name & transcode tables   /**     charset holds name & transcode tables 
         registers Xerces transcoders          registers libxml transcoders
 */  */
 class Charset : public Pooled {  class Charset: public PA_Object {
 public:  public:
   
         Charset(Pool& apool, const String& aname, const String *request_file_spec);          Charset(Request_charsets* charsets, const String::Body ANAME, const String* afile_spec);
         Charset::~Charset();  
                   
         const String& name() const { return fname; }          const String::Body NAME() const { return FNAME; }
           const char* NAME_CSTR() const { return FNAME_CSTR; }
   
         bool isUTF8() const { return fisUTF8; }          bool isUTF8() const { return fisUTF8; }
   
         static void transcode(Pool& pool,          static String::C transcode(const String::C src, const Charset& source_charset, const Charset& dest_charset);
                 const Charset& source_transcoder, const void *source_body, size_t source_content_length,          static String::Body transcode(const String::Body src, const Charset& source_transcoder, const Charset& dest_transcoder);
                 const Charset& dest_transcoder, const void *& dest_body, size_t& dest_content_length          static String& transcode(const String& src, const Charset& source_transcoder, const Charset& dest_transcoder);
         );          static void transcode(ArrayString& src, const Charset& source_transcoder, const Charset& dest_transcoder);
           static void transcode(HashStringString& src, const Charset& source_transcoder, const Charset& dest_transcoder);
   
           static String::C escape(const String::C src, const Charset& source_charset);
           static String::Body escape(const String::Body src, const Charset& source_charset);
           static String& escape(const String& src, const Charset& source_charset);
   
           static String::C escape_JSON(const String::C src, const Charset& source_charset);
           static String::Body escape_JSON(const String::Body src, const Charset& source_charset);
           static String& escape_JSON(const String& src, const Charset& source_charset);
   
           void store_Char(XMLByte*& outPtr, XMLCh src, XMLByte not_found);
   
 #ifdef XML  #ifdef XML
         xmlCharEncodingHandler *transcoder(const String *source);          xmlCharEncodingHandler& transcoder(const String::Body NAME);
 #endif  #endif
   
 public:  public:
Line 86  public: Line 84  public:
   
 private:  private:
   
         void loadDefinition(const String& request_file_spec);          void load_definition(Request_charsets& charsets, const String& afile_spec);
         void sort_ToTable();          void sort_ToTable();
   
         void transcodeToUTF8(Pool& pool,          const String::C transcodeToUTF8(const String::C src) const;
                                                                          const void *source_body, size_t source_content_length,          const String::C transcodeFromUTF8(const String::C src) const;
                                                                          const void *& dest_body, size_t& dest_content_length) const;          
         void transcodeFromUTF8(Pool& pool,          const String::C transcodeToCharset(const String::C src,
                                                                            const void *source_body, size_t source_content_length,                  const Charset& dest_transcoder) const;
                                                                            const void *& dest_body, size_t& dest_content_length) const;  
         void transcodeToCharset(Pool& pool,  
                                                                                    const Charset& dest_transcoder,  
                                                                                    const void *source_body, size_t source_content_length,  
                                                                                    const void *& dest_body, size_t& dest_content_length) const;  
   
 public:  public:
   
         struct Tables {          struct Tables {
                   struct Rec {
                           XMLCh intCh;
                           XMLByte extCh;
                   };
   
                 XMLCh fromTable[0x100];                  XMLCh fromTable[0x100];
                 Charset_TransRec *toTable;                  Rec toTable[MAX_CHARSET_UNI_CODES];
                 uint toTableSize;                  uint toTableSize;
         };          };
   
           struct UTF8CaseTable {
                   struct Rec {
                           XMLCh from, to;
                   };
   
                   uint size;
                   Rec* records;
           };
   
 private:  private:
   
         const String& fname;          const String::Body FNAME;
           char* FNAME_CSTR;
         bool fisUTF8;          bool fisUTF8;
         Tables tables;          Tables tables;
   
           static size_t calc_escaped_length_UTF8(XMLByte* src, size_t src_length);
           static size_t calc_escaped_length(const XMLByte* src, size_t src_length, const Charset::Tables& tables);
           static size_t calc_escaped_length(const String::C src, const Charset& source_charset);
           static size_t escape_UTF8(const XMLByte* src, size_t src_length, XMLByte* dest);
           static size_t escape(const XMLByte* src, size_t src_length, XMLByte* dest, const Charset::Tables& tables);
   
           static size_t calc_JSON_escaped_length_UTF8(XMLByte* src, size_t src_length);
           static size_t calc_JSON_escaped_length(const XMLByte* src, size_t src_length, const Charset::Tables& tables);
           static size_t calc_JSON_escaped_length(const String::C src, const Charset& source_charset);
           static size_t escape_JSON_UTF8(const XMLByte* src, size_t src_length, XMLByte* dest);
           static size_t escape_JSON(const XMLByte* src, size_t src_length, XMLByte* dest, const Charset::Tables& tables);
   
 #ifdef XML  #ifdef XML
   
 private:  private:
         void addEncoding(char *name_cstr);          void addEncoding(char* name_cstr);
         void initTranscoder(const String *source, const char *name_cstr);          void initTranscoder(const String::Body name, const char* name_cstr);
           
 public:  public:
         /// converts GdomeDOMString string to char *          /// converts xmlChar* null-terminated string to char* 
         const char *transcode_cstr(GdomeDOMString *s);          String::C transcode_cstr(const xmlChar* s);
         /// converts GdomeDOMString string to parser String  
         String& transcode(GdomeDOMString *s);  
         /// converts xmlChar* null-terminated string to char *  
         const char *transcode_cstr(xmlChar *s);  
         /// converts xmlChar* null-terminated string to parser String          /// converts xmlChar* null-terminated string to parser String
         String& transcode(xmlChar *s);          const String& transcode(const xmlChar* s);
         /// converts char * to GdomeDOMString  
         GdomeDOMString_auto_ptr transcode_buf(const char *buf, size_t buf_size);          /** converts sized char*  to xmlChar*
         /// converts parser String to GdomeDOMString                  @returns xmlChar*  WHICH CALLER SHOULD FREE
         GdomeDOMString_auto_ptr transcode(const String& s);          */
           xmlChar* transcode_buf2xchar(const char* buf, size_t buf_size);
           /// converts parser String to xmlChar*
           xmlChar* transcode(const String& s);
           /// converts parser String::Body to xmlChar*
           xmlChar* transcode(const String::Body s);
   
 private:  private:
   
         xmlCharEncodingHandler *ftranscoder;          xmlCharEncodingHandler* ftranscoder;
   
 #endif  #endif
   
 };  };
   
 /// Auto-object used to track GdomeDOMString usage  
 class GdomeDOMString_auto_ptr {  
         GdomeDOMString *fstring;  
 public:  
         explicit GdomeDOMString_auto_ptr(gchar *astring) : fstring(gdome_str_mkref(astring)) {}  
         explicit GdomeDOMString_auto_ptr(GdomeDOMString *astring) : fstring(astring) {  
                 // not ref-ing, owning  
         }  
         ~GdomeDOMString_auto_ptr() {  
                 gdome_str_unref(fstring);  
         }  
         GdomeDOMString* get() {  
                 return fstring;  
         }  
         GdomeDOMString* operator->() {  
                 return fstring;  
         }  
         GdomeDOMString& operator*() {  
                 return *fstring;  
         }  
   
         // copying  
         GdomeDOMString_auto_ptr(const GdomeDOMString_auto_ptr& src) : fstring(src.fstring) {  
                 gdome_str_ref(fstring);  
         }  
         GdomeDOMString_auto_ptr& operator =(const GdomeDOMString_auto_ptr& src) {  
                 if(this == &src)  
                         return *this;  
   
                 gdome_str_unref(fstring);  
                 fstring=src.fstring;  
                 gdome_str_ref(fstring);  
   
                 return *this;  // externs
         }  
   extern Charset::UTF8CaseTable UTF8CaseToUpper;
   extern Charset::UTF8CaseTable UTF8CaseToLower;
   void change_case_UTF8(const XMLByte* srcData, size_t srcLen,
                                           XMLByte* toFill, size_t toFillLen,
                                           const Charset::UTF8CaseTable& table);
   size_t getUTF8BytePos(const XMLByte* srcBegin, const XMLByte* srcEnd, size_t charPos/*position in characters*/);
   size_t getUTF8CharPos(const XMLByte* srcBegin, const XMLByte* srcEnd, size_t bytePos/*position in bytes*/);
   size_t lengthUTF8(const XMLByte* srcBegin, const XMLByte* srcEnd);
   unsigned int lengthUTF8Char(const XMLByte c);
   
   const char *fixUTF8(const char *src);
   
   class UTF8_string_iterator {
           public:
                   UTF8_string_iterator(const String& astring): fsrcPtr((XMLByte*)astring.cstr()), fsrcEnd(fsrcPtr + astring.length()) {}
                   UTF8_string_iterator(XMLByte* asrcPtr, size_t length): fsrcPtr(asrcPtr), fsrcEnd(fsrcPtr + length) {}
   
                   bool has_next();
                   XMLCh next() { return fUTF8Char; }
                   XMLByte getFirstByte(){ return ffirstByte; }
                   size_t getCharSize(){ return fcharSize; }
           private:
                   const XMLByte* fsrcPtr;
                   const XMLByte* fsrcEnd;
                   size_t fcharSize;
                   XMLByte ffirstByte;
                   XMLCh fUTF8Char;
 };  };
   
 #endif  #endif
Removed from v.1.9  
changed lines
  Added in v.1.59

E-mail: