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

Diff for /parser3/src/include/pa_pool.h between versions 1.56 and 1.80.4.1

version 1.56, 2001/09/21 07:30:25 version 1.80.4.1, 2002/06/27 11:56:19
Line 1 Line 1
 /** @file  /** @file
         Parser: pool class decl.          Parser: pool class decl.
   
         Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)          Copyright (c) 2001, 2002 ArtLebedev Group (http://www.artlebedev.com)
   
         Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)          Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
   
         $Id$          $Id$
 */  */
Line 13 Line 13
   
 #include "pa_config_includes.h"  #include "pa_config_includes.h"
   
 #include <XalanDOM/XalanDOMString.hpp>  #ifdef XML
 #include <util/TransService.hpp>  #       include "gdome.h"
 #include <PlatformSupport/XSLException.hpp>  // for xmlChar
   #       include "libxml/tree.h"
   #endif
   
 // forwards  // forwards
   
 class Exception;  class Exception;
 class Temp_exception;  
 class String;  class String;
   class Charset;
   class GdomeDOMString_auto_ptr;
   
 /**   /** 
         Pool mechanizm allows users not to free up allocated memory,          Pool mechanizm allows users not to free up allocated memory,
         leaving that problem to 'pools'.          leaving that problem to 'pools'.
   
         Also holds Exception object, which can be temporary set using   
         Temp_exception auto-object.  
   
         @see Pooled          @see Pooled
 */  */
   
 class Pool {  class Pool {
         friend Temp_exception;  
 public:  public:
   
         Pool(void *astorage);          Pool(void *astorage);
         ~Pool();  
   
         void set_context(void *acontext) { fcontext=acontext; }          //{@ statistics
         void *context() { return fcontext; }          size_t total_allocated() { return ftotal_allocated; }
           unsigned int total_times() { return ftotal_times; }
           //}@
   
         void set_tag(void *atag) { ftag=atag; }          void set_context(void *acontext) { fcontext=acontext; }
         void *tag() { return ftag; }          void *get_context() { return fcontext; }
   
         /// allocates some bytes on pool          /// allocates some bytes on pool
         void *malloc(size_t size/*, int place=0*/) {          void *malloc(size_t size, int place=0) {
                 return check(real_malloc(size/*, place*/), size);                  return check(real_malloc(size, place), size);
         }          }
         /// allocates some bytes clearing them with zeros          /// allocates some bytes clearing them with zeros
         void *calloc(size_t size) {          void *calloc(size_t size) {
Line 62  public: Line 61  public:
                         fail_register_cleanup();                          fail_register_cleanup();
         }          }
   
         /// current exception object of the pool          //{@ source charset
         Exception& exception() const { return *fexception; }          void set_source_charset(Charset& acharset);
           Charset& get_source_charset();
           //}@
   
           //{@ client charset
           void set_client_charset(Charset& charset);
           Charset& get_client_charset();
           //}@
   
   #ifdef XML
   
           /// @see Charset::transcode_cstr(xmlChar *s);
           const char *transcode_cstr(xmlChar *s);
           /// @see Charset::transcode(xmlChar *s);
           String& transcode(xmlChar *s);
           /// @see Charset::transcode_cstr(GdomeDOMString *s);
           const char *transcode_cstr(GdomeDOMString *s);
           /// @see Charset::transcode(GdomeDOMString *s);
           String& transcode(GdomeDOMString *s);
           /// @see Charset::transcode_cstr(const char *buf, size_t buf_size=0);
           xmlChar *transcode_buf2xchar(const char *buf, size_t buf_size=0);
           /// @see Charset::transcode(const String& s)
           GdomeDOMString_auto_ptr transcode(const String& s);
   
         /// resets transcoder if they change charset   #endif
         void set_charset(const String &charset);  
         /// converts Xalan string to char *  
         const char *transcode(const XalanDOMString& s);  
         /// converts XSL exception to parser exception  
         void _throw(const String *source, const XSLException& e);  
   
 private:  
   
         void set_charset(const char *new_scharset);  
         void update_transcoder();  
   
 private:  private:
   
         void *fstorage;          void *fstorage;
         void *fcontext;          void *fcontext;
         void *ftag;          Charset *source_charset;
         const String *scharset; const char *charset;          Charset *client_charset;
         XMLTranscoder *transcoder;  
   
 private:   private: 
                   
         //{          //{
         /// @name implementation defined          /// @name implementation defined
     void *real_malloc(size_t size/*, int place*/);      void *real_malloc(size_t size, int place);
     void *real_calloc(size_t size);      void *real_calloc(size_t size);
         bool real_register_cleanup(void (*cleanup) (void *), void *data);          bool real_register_cleanup(void (*cleanup) (void *), void *data);
         //}          //}
Line 98  private: Line 108  private:
   
         /// checks whether mem allocated OK. throws exception otherwise          /// checks whether mem allocated OK. throws exception otherwise
         void *check(void *ptr, size_t size) {          void *check(void *ptr, size_t size) {
                 if(ptr)                  if(ptr) {
                           ftotal_allocated+=size;
                           ftotal_times++;
                         return ptr;                          return ptr;
                   }
   
                 fail_alloc(size);                  fail_alloc(size);
   
Line 112  private: Line 125  private:
         /// throws register cleanup exception          /// throws register cleanup exception
         void fail_register_cleanup() const;          void fail_register_cleanup() const;
   
 private: // exception handling  private: // statistics
           
         // exception replacement mechanism is 'private'zed from direct usage          size_t ftotal_allocated;
         // Temp_exception object enforces paired set/restore          unsigned int ftotal_times;
         Exception *set_exception(Exception *e){  
                 Exception *r=fexception;  
                 fexception=e;  
                 return r;  
         }  
         void restore_exception(Exception *e) {  
                 fexception=e;  
         }  
   
 private:  
   
         // current request's exception object  
         Exception *fexception;  
   
 private: //disabled  private: //disabled
   
         // Pool(const Pool&) {}          Pool(const Pool&);
         Pool& operator = (const Pool&) { return *this; }          Pool& operator= (const Pool&);
 };  };
   
 /**   /** 
Line 141  private: //disabled Line 141  private: //disabled
   
         Holds Pool object. Contains useful wrappers to it's methods.          Holds Pool object. Contains useful wrappers to it's methods.
   
         @see NEW, Temp_exception          @see NEW
 */  */
   
   // all classes that are members parents of packed class [String] 
   // sould be packed also to avoid sparc odd st/lduh problem
   #include "pa_pragma_pack_begin.h"
 class Pooled {  class Pooled {
         // the pool i'm allocated on          // the pool i'm allocated on
         Pool *fpool;          Pool *fpool;
Line 150  public: Line 154  public:
   
         /// the Pooled-sole: Pooled instances can be allocated in Pool rather then on heap          /// the Pooled-sole: Pooled instances can be allocated in Pool rather then on heap
         static void *operator new(size_t size, Pool& apool) {           static void *operator new(size_t size, Pool& apool) { 
                 return apool.malloc(size/*, 1*/);                  return apool.malloc(size, 1);
         }          }
   
         Pooled(Pool& apool) : fpool(&apool) {}          Pooled(Pool& apool) : fpool(&apool) {}
Line 164  public: Line 168  public:
         */          */
         void set_pool(Pool *apool) { fpool=apool; }          void set_pool(Pool *apool) { fpool=apool; }
   
         /// useful wrapper around pool          //{
         void *malloc(size_t size) const { return fpool->malloc(size); }          /// @name useful wrapper around pool
         /// useful wrapper around pool          void *malloc(size_t size, int place=0) const { return fpool->malloc(size, place); }
         void *calloc(size_t size) const { return fpool->calloc(size); }          void *calloc(size_t size) const { return fpool->calloc(size); }
         /// useful wrapper around pool          void register_cleanup(void (*cleanup) (void *), void *data) { fpool->register_cleanup(cleanup, data); }
         void register_cleanup(void (*cleanup) (void *), void *data) {   #ifdef XML
                 fpool->register_cleanup(cleanup, data);  
         }  
         /// useful wrapper around pool  
         Exception& exception() const { return fpool->exception(); }  
         /// useful wrapper around pool  
         const char *transcode(const XalanDOMString& s) { return fpool->transcode(s); }  
         /// useful wrapper around pool  
         void _throw(const String *source, const XSLException& e) { fpool->_throw(source, e); }  
 };  
 /// useful macro for creating objects on current Pooled object Pooled::pool()  
 #define NEW new(pool())  
   
 /**   
         Auto-object used for temporary changing Pool's exception().  
   
         Use by with these macros:          const char *transcode_cstr(GdomeDOMString *s) { return fpool->transcode_cstr(s); }
         @code          String& transcode(GdomeDOMString *s) { return fpool->transcode(s); }
                 TRY {   
                         // ...   
                         if(?)   
                                 THROW(?);   
                         // ...  
                 } CATCH(e) {   
                         // code, using e fields  
                         // e.comment()   
                 }  
                 END_CATCH  
         @endcode  
   
         @see TRY, THROW  #endif
 */          //}
 class Temp_exception {  
         Pool& fpool;  
         Exception *saved_exception;  
 public:  
         Temp_exception(Pool& apool, Exception& exception) :   
                 fpool(apool),  
                 saved_exception(apool.set_exception(&exception)) {  
         }  
         ~Temp_exception() {   
                 fpool.restore_exception(saved_exception);   
         }  
 };  };
   #include "pa_pragma_pack_end.h"
 #define XTRY(pool) \  /// useful macro for creating objects on current Pooled object Pooled::pool()
         { \  #define NEW new(pool())
                 Exception temp_exception; \  
                 Temp_exception le(pool, temp_exception); \  
                 if(setjmp(temp_exception.mark)==0)  
   
 #define XTHROW(exception) exception._throw  
 #define XCATCH(e) \  
                 else{ \  
                         Exception& e=temp_exception;  
   
 #define XEND_CATCH \  
                 } \  
         }  
   
 //@{  
 /// @see Temp_exception   
 #define TRY XTRY(pool())  
 #define THROW XTHROW(exception())  
 #define CATCH(e) XCATCH(e)  
 #define END_CATCH XEND_CATCH   
   
 #define PTRY XTRY(pool)  
 #define PTHROW XTHROW(pool.exception())  
 #define PCATCH(e) XCATCH(e)  
 #define PEND_CATCH XEND_CATCH   
 //@}  
   
 #endif  #endif
Removed from v.1.56  
changed lines
  Added in v.1.80.4.1

E-mail: