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

Diff for /parser3/src/main/pa_pool.C between versions 1.32 and 1.64

version 1.32, 2001/10/18 13:09:37 version 1.64, 2015/10/26 01:21:59
Line 1 Line 1
 /** @file  /** @file
         Parser: pool class.          Parser: pool class.
   
         Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)          Copyright (c) 2000-2015 Art. Lebedev Studio (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$  
 */  */
   
 #include "pa_pool.h"  #include "pa_pool.h"
 #include "pa_exception.h"  #include "pa_exception.h"
 #include "pa_common.h"  #include "pa_common.h"
   #include "pa_sapi.h"
   #include "pa_charset.h"
   
 #ifdef XML  volatile const char * IDENT_PA_POOL_C="$Id$" IDENT_PA_POOL_H;
 #include <util/PlatformUtils.hpp>  
 #endif  // Pool
   
 Pool::Pool(void *astorage) :   Pool::Pool(){}
         fstorage(astorage), fcontext(0), ftag(0), fexception(0)  
 #ifdef XML  
         , transcoder(0)   
 #endif  
         {  
 #ifdef XML  
         charset=new(*this) String(*this, "UTF-8");  
 #else  
         charset=new(*this) String(*this, "");  
 #endif  
 }  
   
   static void cleanup(Pool::Cleanup item, int) {
           if(item.cleanup)
                   item.cleanup(item.data);
   }
 Pool::~Pool() {  Pool::~Pool() {
 #ifdef XML          //__asm__("int3");
         delete transcoder;          //_asm int 3;
 #endif          //fprintf(stderr, "cleanups: %d\n", cleanups.size());
 }          // cleanups first, because they use some object's memory pointers
           cleanups.for_each(cleanup, 0);
 void Pool::fail_alloc(size_t size) const {  }
         fexception->_throw(0, 0,  
                 0,  void Pool::register_cleanup(void (*cleanup) (void *), void *data) {
                 "failed to allocate %u bytes", size);          cleanups+=Cleanup(cleanup, data);
 }  
   
 void Pool::fail_register_cleanup() const {  
         fexception->_throw(0, 0,  
                 0,  
                 "failed to register cleanup");  
 }  
   
 void Pool::set_charset(const String &new_charset) {  
         if(new_charset!=*charset) {  
 #ifdef XML  
                 delete transcoder;  transcoder=0; // flag "we need new transcoder"  
 #endif  
                 charset=&new_charset; // for this charset  
         }  
 }  
   
 #ifdef XML  
 void Pool::update_transcoder() {  
         if(transcoder)  
                 return;  
   
         XMLTransService::Codes resValue;  
         transcoder=XMLPlatformUtils::fgTransService->makeNewTranscoderFor(charset->cstr(), resValue, 60);  
         if(!transcoder)  
                 THROW(0, 0,  
                         charset,  
                         "unsupported encoding");  
 }  
   
 const char *Pool::transcode_cstr(const XalanDOMString& s) {   
         update_transcoder();  
   
         const unsigned int len=s.size()*2;  
         XMLByte* dest=(XMLByte *)malloc((len+1)*sizeof(XMLByte));  
         bool error=true;  
         try {  
                 if(transcoder) {  
                         unsigned int charsEaten;  
                         unsigned int size=transcoder->transcodeTo(  
                                 s.c_str(), s.length(),  
                                 dest, len,  
                                 charsEaten,  
                                 XMLTranscoder::UnRep_RepChar //UnRep_Throw  
                         );  
                         dest[size]=0;  
                         error=false;  
                 }  
         } catch(XMLException& e) {  
                 exception()._throw(*this, 0, e);  
         }  
         return (const char *)dest;  
 }  
 String& Pool::transcode(const XalanDOMString& s) {   
         return *new(*this) String(*this, transcode_cstr(s));   
 }  
   
 /// @test who would free up result?  
 XalanDOMString& Pool::transcode_buf(const char *buf, size_t buf_size) {   
         update_transcoder();  
   
         unsigned int dest_size=0;  
         XMLCh* dest=(XMLCh *)malloc((buf_size+1)*sizeof(XMLCh));  
         unsigned char *charSizes=(unsigned char *)malloc(buf_size*sizeof(unsigned char));  
         XalanDOMString *result;  
         try {  
                 if(transcoder) {  
                         unsigned int bytesEaten;  
                         unsigned int dest_size=transcoder->transcodeFrom(  
                                 (unsigned char *)buf,  
                                 (const unsigned int)buf_size,  
                                 dest, (const unsigned int)buf_size,  
                                 bytesEaten,  
                                 charSizes  
                         );  
                         result=new XalanDOMString(dest, dest_size);  
                 }  
         } catch(XMLException& e) {  
                 exception()._throw(*this, 0, e);  
         }  
         free(charSizes);  
           
         return *result;  
 }  }
 XalanDOMString& Pool::transcode(const String& s) {   
         const char *cstr=s.cstr(String::UL_XML);  
   
         return transcode_buf(cstr, strlen(cstr));   static void unregister_cleanup(Pool::Cleanup& item, void* cleanup_data) {
           if(item.data==cleanup_data)
                   item.cleanup=0;
   }
   void Pool::unregister_cleanup(void *cleanup_data) {
           cleanups.for_each_ref(::unregister_cleanup, cleanup_data);
   }
   
   // Pooled
   
   static void cleanup(void *data) {
           static_cast<Pooled*>(data)->~Pooled();
 }  }
   
 #endif  Pooled::Pooled(Pool& apool): fpool(apool) {
           fpool.register_cleanup(cleanup, this);
   }
   
   /// Sole: this got called automatically from Pool::~Pool()
   Pooled::~Pooled() {
           fpool.unregister_cleanup(this);
   }
Removed from v.1.32  
changed lines
  Added in v.1.64

E-mail: