[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.1 and 1.20.2.18.2.12

version 1.1, 2001/12/15 21:51:43 version 1.20.2.18.2.12, 2003/04/11 09:58:54
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-2003 ArtLebedev Group (http://www.artlebedev.com)
         Author: Alexander Petrosyan <paf@design.ru> (http://paf.design.ru)          Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
   
         $Id$  
 */  */
   
 #ifndef PA_CHARSET_H  #ifndef PA_CHARSET_H
 #define PA_CHARSET_H  #define PA_CHARSET_H
   
 #include "pa_pool.h"  static const char* IDENT_CHARSET_H="$Date$";
   
   
 #include "pa_exception.h"  #include "pa_exception.h"
 #include "pa_common.h"  #include "pa_common.h"
   
Line 20  namespace PCRE { Line 20  namespace PCRE {
 #       include "internal.h"  #       include "internal.h"
 };  };
   
   #ifdef XML
   #include "libxml/encoding.h"
   #endif
   
 // defines  // defines
   
 #ifdef XML  #define MAX_CHARSETS 10
 #       include <util/XercesDefs.hpp>  
 #       include <util/TransService.hpp>  #define MAX_CHARSET_UNI_CODES 500
 #       define Charset_TransRec XMLTransService::TransRec  
 #else  
 #       ifndef XMLCh   #       ifndef XMLCh 
 #               define XMLCh unsigned int                  typedef unsigned int XMLCh;
 #       endif  #       endif
 #       ifndef XMLByte  #       ifndef XMLByte
 #               define XMLByte unsigned char                  typedef unsigned char XMLByte;
 #       endif  #       endif
   
         struct Charset_TransRec {  // forwards
                 XMLCh intCh;  
                 XMLByte extCh;  class GdomeDOMString_auto_ptr;
         };  
 #endif  // helpers
   
   struct Charset_TransRec {
           XMLCh intCh;
           XMLByte extCh;
   };
   
 /**     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& request_name, const String *file_spec);          Charset(Request_charsets* charsets, const StringBody ANAME, const String* afile_spec);
         Charset::~Charset();  
                   
         const String& name() const { return fname; }          const StringBody NAME() const { return FNAME; }
   
         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_transcoder, const void *source_body, size_t source_content_length,                  const Charset& source_transcoder, 
                 const Charset& dest_transcoder, const void *& dest_body, size_t& dest_content_length                  const Charset& dest_transcoder
         );          );
   
   #ifdef XML
           xmlCharEncodingHandler& transcoder(const StringBody NAME);
   #endif
   
 public:  public:
   
         unsigned char pcre_tables[tables_length];          unsigned char pcre_tables[tables_length];
   
 private:  private:
   
         void loadDefinition(const String& file_spec);          void load_definition(Request_charsets& charsets, const String& afile_spec);
         void sort_ToTable();          void sort_ToTable();
   
         XMLByte xlatOneTo(const XMLCh toXlat) const;          const String::C transcodeToUTF8(const String::C src) const;
         void transcodeToUTF8(Pool& pool,          const String::C transcodeFromUTF8(const String::C src) const;
                                                                          const void *source_body, size_t source_content_length,          
                                                                          const void *& dest_body, size_t& dest_content_length) const;          const String::C transcodeToCharset(const String::C src,
         void transcodeFromUTF8(Pool& pool,                  const Charset& dest_transcoder) const;
                                                                            const void *source_body, size_t source_content_length,  
                                                                            const void *& dest_body, size_t& dest_content_length) const;  public:
         void transcodeToCharset(Pool& pool,  
                                                                                    const Charset& dest_transcoder,          struct Tables {
                                                                                    const void *source_body, size_t source_content_length,                  XMLCh fromTable[0x100];
                                                                                    const void *& dest_body, size_t& dest_content_length) const;                  Charset_TransRec toTable[MAX_CHARSET_UNI_CODES];
                   uint toTableSize;
           };
   
 private:  private:
   
         String fname;          const StringBody FNAME;
           char* FNAME_CSTR;
         bool fisUTF8;          bool fisUTF8;
         XMLCh fromTable[0x100];          Tables tables;
         Charset_TransRec *toTable;  
         uint toTableSize;  
   
 #ifdef XML  #ifdef XML
   
 private:  private:
         void addEncoding(const char *name_cstr);          void addEncoding(char* name_cstr);
         void initTranscoder(const String *source, const char *name_cstr);          void initTranscoder(const StringBody name, const char* name_cstr);
           
 public:  public:
         /// converts Xalan string to char *          /// converts GdomeDOMString string to char* 
         const char *transcode_cstr(const XalanDOMString& s);          String::C transcode_cstr(GdomeDOMString* s);
         /// converts Xalan string to parser String          /// converts GdomeDOMString string to parser String
         String& transcode(const XalanDOMString& s);          const String& transcode(GdomeDOMString* s);
         /// converts char * to Xalan string          /// converts xmlChar* null-terminated string to char* 
         std::auto_ptr<XalanDOMString> transcode_buf(const char *buf, size_t buf_size);          String::C transcode_cstr(xmlChar* s);
         /// converts parser String to Xalan string          /// converts xmlChar* null-terminated string to parser String
         std::auto_ptr<XalanDOMString> transcode(const String& s);          const String& transcode(xmlChar* s);
   
           /** converts sized char*  to xmlChar*
                   @returns xmlChar*  WHICH CALLER SHOULD FREE
           */
           xmlChar* transcode_buf2xchar(const char* buf, size_t buf_size);
           /// converts char*  to GdomeDOMString
           GdomeDOMString_auto_ptr transcode_buf2dom(const char* buf, size_t buf_size);
           /// converts parser String to GdomeDOMString
           GdomeDOMString_auto_ptr transcode(const String& s);
           /// converts parser StringBody to GdomeDOMString
           GdomeDOMString_auto_ptr transcode(const StringBody s);
   
 private:  private:
   
         XMLTranscoder *transcoder;          xmlCharEncodingHandler* ftranscoder;
   
 #endif  #endif
   
 };  };
   
   #ifdef XML
   /// Auto-object used to track GdomeDOMString usage
   class GdomeDOMString_auto_ptr {
           GdomeDOMString* fstring;
   public:
           /// frees astring afterwards!!!
           explicit GdomeDOMString_auto_ptr(xmlChar* astring) : fstring(gdome_str_mkref_xml(astring)) {}
           explicit GdomeDOMString_auto_ptr(GdomeDOMString* astring=0) : fstring(astring) {
                   // not ref-ing, owning
           }
           ~GdomeDOMString_auto_ptr() {
                   if(fstring)
                           gdome_str_unref(fstring);
           }
   /*      GdomeDOMString* get() {
                   return fstring;
           }*/
           GdomeDOMString* use() {
                   if(fstring)
                           gdome_str_ref(fstring);
                   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;
   
                   if(fstring)
                           gdome_str_unref(fstring);
                   fstring=src.fstring;
                   if(fstring)
                           gdome_str_ref(fstring);
   
                   return* this;
           }
   };
   #endif
   
 #endif  #endif
Removed from v.1.1  
changed lines
  Added in v.1.20.2.18.2.12

E-mail: