parser3/src/main/pa_globals.C - diff

Return to pa_globals.C CVS log

Up to [parser3project] / parser3 / src / main

Diff for /parser3/src/main/pa_globals.C between versions 1.181 and 1.189

version 1.181, 2005/12/19 14:22:01	version 1.189, 2013/07/21 14:22:54
Line 1	Line 1
/** @file	/** @file
Parser: globals.	Parser: globals.

Copyright (c) 2001-2005 ArtLebedev Group (http://www.artlebedev.com)	Copyright (c) 2001-2012 Art. Lebedev Studio (http://www.artlebedev.com)
Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
*/	*/

static const char * const IDENT_GLOBALS_C="$Date$";

#include "pa_config_includes.h"	#include "pa_config_includes.h"

#ifdef XML	#ifdef XML
Line 18 extern "C" {	Line 16 extern "C" {
};	};
#endif	#endif

#include "pcre.h"

#include "pa_globals.h"	#include "pa_globals.h"
#include "pa_string.h"	#include "pa_string.h"
#include "pa_sapi.h"	#include "pa_sapi.h"
Line 29 extern "C" {	Line 25 extern "C" {

#include "pa_cache_managers.h"	#include "pa_cache_managers.h"

	#include "ltdl.h"
	#include "pcre.h"

	volatile const char * IDENT_PA_GLOBALS_C="$Id$" IDENT_PA_GLOBALS_H IDENT_PA_SAPI_H;

// defines	// defines

//#define PA_DEBUG_XML_GC_MEMORY	//#define PA_DEBUG_XML_GC_MEMORY
Line 69 static void setup_hex_value() {	Line 70 static void setup_hex_value() {
hex_value['f'] = 15;	hex_value['f'] = 15;
}	}

	THREAD_LOCAL Request* thread_request=NULL;

Hash<pa_thread_t, Request*> thread_request;
void pa_register_thread_request(Request& r) {	void pa_register_thread_request(Request& r) {
thread_request.put(pa_get_thread_id(), &r);	thread_request=&r;
}	}
/// retrives request set by pa_set_request function, useful in contextless places [slow]	/// retrives request set by pa_set_request function, useful in contextless places [slow]
Request& pa_thread_request() {	Request& pa_thread_request() {
return *thread_request.get(pa_get_thread_id());	return *thread_request;
}

#ifdef PA_RELEASE_ASSERTS
void pa_release_assert(const char* str, const char* file, int line) {
SAPI::die("%s at %s:%d", str, file, line);
}	}
#endif


#ifdef XML	#ifdef XML
Line 101 public:	Line 96 public:
}	}
};	};

static Hash<pa_thread_t, XML_Generic_error_info*> xml_generic_error_infos;	THREAD_LOCAL XML_Generic_error_info* xml_generic_error_info = NULL;

static void xmlParserGenericErrorFunc(void * /ctx/, const char* msg, ...) {	static void xmlParserGenericErrorFunc(void * /ctx/, const char* msg, ...) {
//_asm int 3;
pa_thread_t thread_id=pa_get_thread_id();

XML_Generic_error_info* p;	XML_Generic_error_info* p;
{
SYNCHRONIZED; // find+fill blocked	if(!(p=xml_generic_error_info)) // occupy empty one
	p=xml_generic_error_info=new(PointerFreeGC) XML_Generic_error_info;
// first try to get existing for this thread_id
p=xml_generic_error_infos.get(thread_id);
if(!p) // occupy empty one
xml_generic_error_infos.put(thread_id, (p=new(PointerFreeGC) XML_Generic_error_info));
}

va_list args;	va_list args;
va_start(args, msg);	va_start(args, msg);
Line 124 static void xmlParserGenericErrorFunc(vo	Line 111 static void xmlParserGenericErrorFunc(vo
}	}

bool xmlHaveGenericErrors() {	bool xmlHaveGenericErrors() {
pa_thread_t thread_id=pa_get_thread_id();	return xml_generic_error_info!=0;

SYNCHRONIZED; // find blocked

return xml_generic_error_infos.get(thread_id)!=0;
}	}

const char* xmlGenericErrors() {	const char* xmlGenericErrors() {
pa_thread_t thread_id=pa_get_thread_id();	if(XML_Generic_error_info *p=xml_generic_error_info) {
	xml_generic_error_info=0;
SYNCHRONIZED; // find+free blocked

if(XML_Generic_error_info *p=xml_generic_error_infos.get(thread_id)) {
xml_generic_error_infos.remove(thread_id);
return p->get();	return p->get();
}	}

Line 146 const char* xmlGenericErrors() {	Line 125 const char* xmlGenericErrors() {

#endif	#endif

void pa_globals_destroy(void *) {
/*
try {
#ifdef XML
#endif
} catch(.../const Exception& e /) {
// SAPI::abort("pa_globals_destroy failed: %s", e.comment());
}
*/
}


#ifdef XML	#ifdef XML

static char pa_GC_strdup(const char s) {	static char pa_GC_strdup(const char s) {
Line 167 static char pa_GC_strdup(const char s)	Line 134 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)	if(!result)
SAPI::abort("out of memory (while duplicating XML string [size=%d])", size);	pa_fail_alloc("duplicate XML string",size);

memcpy(result, s, size);	memcpy(result, s, size);
#ifdef PA_DEBUG_XML_GC_MEMORY	#ifdef PA_DEBUG_XML_GC_MEMORY
Line 234 static void pa_gc_free_log(void *p){	Line 201 static void pa_gc_free_log(void *p){

inline void check(void result, const char *where, size_t size) {	inline void check(void result, const char *where, size_t size) {
if(!result)	if(!result)
SAPI::abort("out of memory (while %s [size=%d])", where, size);	pa_fail_alloc(where, size);

return result;	return result;
}	}
static void* pa_gc_malloc_nonull(size_t size) {	static void* pa_gc_malloc_nonull(size_t size) {
return check(pa_gc_malloc(size), "allocating XML compsite memory", size);	return check(pa_gc_malloc(size), "allocate XML compsite memory", size);
}	}
static void* pa_gc_malloc_atomic_nonull(size_t size) {	static void* pa_gc_malloc_atomic_nonull(size_t size) {
#ifdef PA_WORKAROUND_BUGGY_MALLOCATOMIC_IN_LIBXML_GC_MEMORY	#ifdef PA_WORKAROUND_BUGGY_MALLOCATOMIC_IN_LIBXML_GC_MEMORY
return check(pa_gc_malloc(size), "allocating XML composite memory (asked atomic)", size);	return check(pa_gc_malloc(size), "allocate XML composite memory (asked atomic)", size);
#else	#else
return check(pa_gc_malloc_atomic(size), "allocating XML atomic memory", size);	return check(pa_gc_malloc_atomic(size), "allocate XML atomic memory", size);
#endif	#endif
}	}
static void* pa_gc_realloc_nonull(void* ptr, size_t size) {	static void* pa_gc_realloc_nonull(void* ptr, size_t size) {
return check(pa_gc_realloc(ptr, size), "reallocating XML memory", size);	return check(pa_gc_realloc(ptr, size), "reallocate XML memory", size);
}	}

static void pa_gc_free_maybeignore(	static void pa_gc_free_maybeignore(
Line 267 static void pa_gc_free_maybeignore(	Line 234 static void pa_gc_free_maybeignore(
#endif	#endif

void pa_CORD_oom_fn(void) {	void pa_CORD_oom_fn(void) {
SAPI::abort("out of memory (while expanding string)");	pa_fail_alloc("expand string", 0);
}	}

/**	/**
Line 378 void pa_globals_init() {	Line 345 void pa_globals_init() {
#endif	#endif
}	}

	static bool is_dlinited=false;

void pa_globals_done() {	void pa_globals_done() {
delete cache_managers; cache_managers=0;	delete cache_managers; cache_managers=0;
	if(is_dlinited)
	lt_dlexit();
	}

	void pa_dlinit() {
	if(!is_dlinited){
	if(lt_dlinit())
	throw Exception(0,0,"prepare to dynamic libary loading failed, %s", lt_dlerror());
	is_dlinited=true;
	}
}	}

#ifdef _MSC_VER	#ifdef _MSC_VER

E-mail:

Removed from v.1.181
changed lines
	Added in v.1.189