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

Diff for /parser3/src/main/pa_globals.C between versions 1.152.2.19.2.18 and 1.160

version 1.152.2.19.2.18, 2003/04/29 13:16:35 version 1.160, 2003/11/20 15:35:31
Line 28  extern "C" { Line 28  extern "C" {
   
 // defines  // defines
   
 #define PA_DEBUG_XML_GC_MEMORY  //#define PA_DEBUG_XML_GC_MEMORY
   
 // globals  // globals
   
Line 81  public: Line 81  public:
                 thread_id=0;                   thread_id=0; 
                 buf[used=0]=0;                  buf[used=0]=0;
         }          }
         const char* getnd_reset() {          const char* get_and_reset() {
                 char* result=new(PointerFreeGC) char[used+1];                  char* result=new(PointerFreeGC) char[used+1];
                 memcpy(result, buf, used+1);                  memcpy(result, buf, used+1);
                 reset();                  reset();
Line 99  XML_Generic_error_info *xml_generic_erro Line 99  XML_Generic_error_info *xml_generic_erro
 }  }
   
 static void  static void
 xmlParserGenericErrorFunc(void *ctx, const char* msg, ...) {   xmlParserGenericErrorFunc(void *  /*ctx*/, const char* msg, ...) { 
     pa_thread_t thread_id=pa_get_thread_id();          //_asm int 3;
           pa_thread_t thread_id=pa_get_thread_id();
   
         // infinitely looking for free slot to fill it          // infinitely looking for free slot to fill it
         while(true) {          while(true) {
Line 110  xmlParserGenericErrorFunc(void *ctx, con Line 111  xmlParserGenericErrorFunc(void *ctx, con
                 XML_Generic_error_info *p=xml_generic_error_info(thread_id);                  XML_Generic_error_info *p=xml_generic_error_info(thread_id);
                 if(!p) { // occupy empty one                  if(!p) { // occupy empty one
                         p=xml_generic_error_info(0);                          p=xml_generic_error_info(0);
                         if(!p) // wait for empty for it to appear                          if(!p) // wait for empty one to appear
                                 continue;                                  continue;
                 }                  }
   
Line 126  xmlParserGenericErrorFunc(void *ctx, con Line 127  xmlParserGenericErrorFunc(void *ctx, con
 }  }
   
 bool xmlHaveGenericErrors() {  bool xmlHaveGenericErrors() {
     pa_thread_t thread_id=pa_get_thread_id();          pa_thread_t thread_id=pa_get_thread_id();
   
         SYNCHRONIZED;  // find blocked          SYNCHRONIZED;  // find blocked
   
Line 134  bool xmlHaveGenericErrors() { Line 135  bool xmlHaveGenericErrors() {
 }  }
   
 const char* xmlGenericErrors() {  const char* xmlGenericErrors() {
     pa_thread_t thread_id=pa_get_thread_id();          pa_thread_t thread_id=pa_get_thread_id();
   
         SYNCHRONIZED;  // find+free blocked          SYNCHRONIZED;  // find+free blocked
   
Line 142  const char* xmlGenericErrors() { Line 143  const char* xmlGenericErrors() {
         if(!p) // no errors for our thread_id registered          if(!p) // no errors for our thread_id registered
                 return 0;                  return 0;
   
         return p->getnd_reset();          return p->get_and_reset();
 }  }
   
 /**  /**
Line 155  const char* xmlGenericErrors() { Line 156  const char* xmlGenericErrors() {
  */   */
 static int  static int
 xmlFileMatchLocalhost(const char* filename) {  xmlFileMatchLocalhost(const char* filename) {
     if (!strncmp(filename, "http://localhost", 16))          if (!strncmp(filename, "http://localhost", 16))
         return(1);                  return(1);
     return(0);          return(0);
 }  }
   
   
Line 174  xmlFileMatchLocalhost(const char* filena Line 175  xmlFileMatchLocalhost(const char* filena
  */   */
 static void *  static void *
 xmlFileOpenLocalhost (const char* filename) {  xmlFileOpenLocalhost (const char* filename) {
     FILE *fd;          //_asm int 3;
     const char* documentRoot;          FILE *fd;
     char path[1000];          const char* documentRoot;
           char path[1000];
           
         path[0]=0;          path[0]=0;
         strcat(path, (documentRoot=getenv("DOCUMENT_ROOT"))?documentRoot:".");          strcat(path, (documentRoot=getenv("DOCUMENT_ROOT"))?documentRoot:".");
         strcat(path, &filename[16]);          strcat(path, &filename[16]);
           
 #ifdef WIN32  #ifdef WIN32
     fd = fopen(path, "rb");          fd = fopen(path, "rb");
 #else  #else
     fd = fopen(path, "r");          fd = fopen(path, "r");
 #endif /* WIN32 */  #endif /* WIN32 */
     return((void *) fd);          return((void *) fd);
 }  }
   
 /**  /**
Line 202  xmlFileOpenLocalhost (const char* filena Line 204  xmlFileOpenLocalhost (const char* filena
  */   */
 static int  static int
 pa_xmlFileRead (void * context, char * buffer, int len) {  pa_xmlFileRead (void * context, char * buffer, int len) {
     return(fread(&buffer[0], 1,  len, (FILE *) context));          return(fread(&buffer[0], 1,  len, (FILE *) context));
 }  }
   
 /**  /**
Line 213  pa_xmlFileRead (void * context, char * b Line 215  pa_xmlFileRead (void * context, char * b
  */   */
 static int  static int
 pa_xmlFileClose (void * context) {  pa_xmlFileClose (void * context) {
     return ( ( fclose((FILE *) context) == EOF ) ? -1 : 0 );          return ( ( fclose((FILE *) context) == EOF ) ? -1 : 0 );
 }  }
   
 #endif  #endif
Line 223  void pa_globals_destroy(void *) { Line 225  void pa_globals_destroy(void *) {
 #ifdef XML  #ifdef XML
                 GdomeException exc;                  GdomeException exc;
                 gdome_di_unref (domimpl, &exc);                  gdome_di_unref (domimpl, &exc);
                   // uncomment SAPI::abort below if adding potential-throw code here
 #endif  #endif
         } catch(const Exception& e) {          } catch(const Exception& e) {
                 SAPI::abort("pa_globals_destroy failed: %s", e.comment());  //              SAPI::abort("pa_globals_destroy failed: %s", e.comment());
         }          }
 }  }
   
Line 238  static char *pa_GC_strdup(const char *s) Line 241  static char *pa_GC_strdup(const char *s)
   
         size_t size=strlen(s)+1;          size_t size=strlen(s)+1;
         char *result=(char *)GC_malloc_atomic(size);          char *result=(char *)GC_malloc_atomic(size);
           if(!result)
                   SAPI::abort("out of memory (while duplicating XML string [size=%d])", size);
   
         memcpy(result, s, size);          memcpy(result, s, size);
         return result;          return result;
 }  }
   
 #ifdef PA_DEBUG_XML_GC_MEMORY  #ifdef PA_DEBUG_XML_GC_MEMORY
 static void *pa_look_for=(void*)0x01db2000;  void *pa_look_for[]={(void*)0x8abe000,(void*)0x0,(void*)0x0,(void*)0x0,
                           (void*)0x0,(void*)0x0,(void*)0x0,(void*)0x0};
   bool pa_looked(void*p) {
           for(int i=0; i<8; i++)
                   if(pa_look_for[i]==p)
                           return true;
           return false;
   }
 static void* pa_gc_malloc_log(size_t size){  static void* pa_gc_malloc_log(size_t size){
         //fprintf(stderr, "pa_gc_free_log(0x%p)\n", p);  
         void *p=pa_gc_malloc(size);          void *p=pa_gc_malloc(size);
         if(p==pa_look_for)          fprintf(stderr, "pa_gc_malloc_log(%d)=0x%p\n", size, p);
                 fprintf(stderr,"catched debug free");  //      if(pa_looked(p))
   //              fprintf(stderr,"catched debug malloc(%d)=0x%p\n", size, p);
         return p;          return p;
                   
 }  }
 static void* pa_gc_malloc_atomic_log(size_t size){  static void* pa_gc_malloc_atomic_log(size_t size){
         //fprintf(stderr, "pa_gc_free_log(0x%p)\n", p);  
         void *p=pa_gc_malloc_atomic(size);          void *p=pa_gc_malloc_atomic(size);
         if(p==pa_look_for)          fprintf(stderr, "pa_gc_malloc_atomic_log(%d)=0x%p\n", size, p);
                 fprintf(stderr,"catched debug free");  //      if(pa_looked(p))
   //              fprintf(stderr,"catched debug malloc atomic(%d)=0x%p\n", size, p);
           return p;
   }
   static void* pa_gc_realloc_log(void *ptr, size_t size){
           void *p=pa_gc_realloc(ptr, size);
           fprintf(stderr, "pa_gc_realloc_log(0x%p, %d)=0x%p\n", ptr, size, p);
   //      if(pa_looked(p))
   //              fprintf(stderr,"catched debug realloc(%d)=0x%p\n", size, p);
         return p;          return p;
 }  }
 //static void pa_gc_free_ignore(void *){}  //static void pa_gc_free_ignore(void *){}
 static void pa_gc_free_log(void *p){  static void pa_gc_free_log(void *p){
         //fprintf(stderr, "pa_gc_free_log(0x%p)\n", p);          fprintf(stderr, "pa_gc_free_log(0x%p)\n", p);
         if(p==pa_look_for)  //      if(pa_looked(p))
                 fprintf(stderr,"catched debug free");  //              fprintf(stderr,"catched debug free(0x%p)\n", p);
         pa_gc_free(p);          pa_gc_free(p);
 }  }
   #else
   
   inline void *check(void *result, const char *where, size_t size) {
           if(!result)
                   SAPI::abort("out of memory (while %s [size=%d])", where, size);
   
           return result;
   }
   static void* pa_gc_malloc_nonull(size_t size) { 
           return check(pa_gc_malloc(size), "allocating XML compsite memory", size);
   }
   static void* pa_gc_malloc_atomic_nonull(size_t size) { 
           return check(pa_gc_malloc_atomic(size), "allocating XML atomic memory", size);
   }
   static void* pa_gc_realloc_nonull(void* ptr, size_t size) { 
           return check(pa_gc_realloc(ptr, size), "reallocating XML memory", size);
   }
   
 #endif  #endif
 #endif  #endif
   
Line 274  void pa_CORD_oom_fn(void) { Line 312  void pa_CORD_oom_fn(void) {
 }  }
   
 /**  /**
         @todo LIBXML_VERSION with xmlGcMemSetup will be 2.5.7  
         @todo gc: libltdl: substitute lt_dlmalloc & co          @todo gc: libltdl: substitute lt_dlmalloc & co
 */  */
 static void gc_substitute_memory_management_functions() {  static void gc_substitute_memory_management_functions() {
Line 287  static void gc_substitute_memory_managem Line 324  static void gc_substitute_memory_managem
                 /*xmlFreeFunc */pa_gc_free_log,                  /*xmlFreeFunc */pa_gc_free_log,
                 /*xmlMallocFunc */pa_gc_malloc_log,                  /*xmlMallocFunc */pa_gc_malloc_log,
                 /*xmlMallocFunc */pa_gc_malloc_atomic_log,                  /*xmlMallocFunc */pa_gc_malloc_atomic_log,
                 /*xmlReallocFunc */pa_gc_realloc,                  /*xmlReallocFunc */pa_gc_realloc_log,
                 /*xmlStrdupFunc */pa_GC_strdup);                  /*xmlStrdupFunc */pa_GC_strdup);
 #else  #else
         xmlGcMemSetup(          xmlGcMemSetup(
                 /*xmlFreeFunc */pa_gc_free,                  /*xmlFreeFunc */pa_gc_free,
                 /*xmlMallocFunc */pa_gc_malloc,                  /*xmlMallocFunc */pa_gc_malloc_nonull,
                 /*xmlMallocFunc */pa_gc_malloc_atomic,                  /*xmlMallocFunc */pa_gc_malloc_atomic_nonull,
                 /*xmlReallocFunc */pa_gc_realloc,                  /*xmlReallocFunc */pa_gc_realloc_nonull,
                 /*xmlStrdupFunc */pa_GC_strdup);                  /*xmlStrdupFunc */pa_GC_strdup);
 #endif  #endif
   
Line 386  void pa_globals_init() { Line 423  void pa_globals_init() {
 #ifdef _MSC_VER  #ifdef _MSC_VER
   
 #ifndef PA_DEBUG_DISABLE_GC  #ifndef PA_DEBUG_DISABLE_GC
 #       define GC_LIB "/parser3project/win32/gc"  #       define GC_LIB "../../../../win32/gc"
 #       ifdef _DEBUG  #       ifdef _DEBUG
 #               pragma comment(lib, GC_LIB "/Debug/gc.lib")  #               pragma comment(lib, GC_LIB "/Debug/gc.lib")
 #       else  #       else
Line 396  void pa_globals_init() { Line 433  void pa_globals_init() {
 #endif  #endif
   
 #ifdef XML  #ifdef XML
 #       define GNOME_LIBS "/parser3project/win32xml/win32/gnome"  #       define GNOME_LIBS "../../../../win32/gnome"
 #       pragma comment(lib, GNOME_LIBS "/glib/lib/libglib-1.3-11.lib")  #       pragma comment(lib, GNOME_LIBS "/glib/lib/libglib-1.3-11.lib")
 #       ifdef _DEBUG  #       ifdef _DEBUG
   
 #               ifdef LIBXML_STATIC  #               ifdef LIBXML_STATIC
 #                       pragma comment(lib, GNOME_LIBS "/gnome-xml/win32/binaries/libxml2_a.lib")  #                       pragma comment(lib, GNOME_LIBS "/gnome-xml/win32/binaries-debug/libxml2_a.lib")
 #               else  #               else
 #                       pragma comment(lib, GNOME_LIBS "/gnome-xml/win32/binaries/libxml2.lib")  #                       pragma comment(lib, GNOME_LIBS "/gnome-xml/win32/binaries-debug/libxml2.lib")
 #               endif  #               endif
   
 #               ifdef LIBXSLT_STATIC  #               ifdef LIBXSLT_STATIC
Line 426  void pa_globals_init() { Line 463  void pa_globals_init() {
 #else  #else
   
 #               ifdef LIBXML_STATIC  #               ifdef LIBXML_STATIC
 #                       pragma comment(lib, GNOME_LIBS "/gnome-xml/win32/dsp/libxml2_ReleaseStatic/libxml2.lib")  #                       pragma comment(lib, GNOME_LIBS "/gnome-xml/win32/binaries-release/libxml2_a.lib")
 #               else  #               else
 #                       pragma comment(lib, GNOME_LIBS "/gnome-xml/win32/dsp/libxml2_ReleaseDynamic/libxml2.lib")  #                       pragma comment(lib, GNOME_LIBS "/gnome-xml/win32/binaries-release/libxml2.lib")
 #               endif  #               endif
   
 #               ifdef LIBXSLT_STATIC  #               ifdef LIBXSLT_STATIC
Removed from v.1.152.2.19.2.18  
changed lines
  Added in v.1.160

E-mail: