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.195 and 1.215

version 1.195, 2016/05/24 11:01:19	version 1.215, 2024/11/04 03:53:25
Line 1	Line 1
/** @file	/** @file
Parser: globals.	Parser: globals.

Copyright (c) 2001-2015 Art. Lebedev Studio (http://www.artlebedev.com)	Copyright (c) 2001-2024 Art. Lebedev Studio (http://www.artlebedev.com)
Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)	Authors: Konstantin Morshnev <moko@design.ru>, Alexandr Petrosian <paf@design.ru>
*/	*/

#include "pa_config_includes.h"	#include "pa_config_includes.h"
Line 17 extern "C" {	Line 17 extern "C" {
#endif	#endif

#include "pa_globals.h"	#include "pa_globals.h"
	#include "pa_socks.h"
#include "pa_sapi.h"	#include "pa_sapi.h"
#include "pa_threads.h"
#include "pa_xml_io.h"	#include "pa_xml_io.h"
#include "pa_common.h"	#include "pa_common.h"
	#include "pa_symbols.h"

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

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

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

Line 35 volatile const char * IDENT_PA_GLOBALS_C	Line 36 volatile const char * IDENT_PA_GLOBALS_C

// globals	// globals

short hex_value[0x100]={0};	short hex_value[0x100] = {
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
static void setup_hex_value() {	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
hex_value['0'] = 0;	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
hex_value['1'] = 1;	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0,
hex_value['2'] = 2;	0, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0,
hex_value['3'] = 3;	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
hex_value['4'] = 4;	0, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0,
hex_value['5'] = 5;	};
hex_value['6'] = 6;
hex_value['7'] = 7;
hex_value['8'] = 8;
hex_value['9'] = 9;
hex_value['A'] = 10;
hex_value['B'] = 11;
hex_value['C'] = 12;
hex_value['D'] = 13;
hex_value['E'] = 14;
hex_value['F'] = 15;
hex_value['a'] = 10;
hex_value['b'] = 11;
hex_value['c'] = 12;
hex_value['d'] = 13;
hex_value['e'] = 14;
hex_value['f'] = 15;
}

THREAD_LOCAL Request* thread_request=NULL;	THREAD_LOCAL Request* thread_request=NULL; // every TLS should be referenced elsewhere, or GC will collect it

void pa_register_thread_request(Request& r) {	void pa_register_thread_request(Request& r) {
thread_request=&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() {
	if(!thread_request)
	throw Exception(0, 0, "request is not initialized");
return *thread_request;	return *thread_request;
}	}

Line 124 static char pa_GC_strdup(const char s)	Line 111 static char pa_GC_strdup(const char s)
return 0;	return 0;

size_t size=strlen(s)+1;	size_t size=strlen(s)+1;
char result=(char )pa_gc_malloc_atomic(size);	char result=(char )GC_MALLOC_ATOMIC(size);

if(!result)	if(!result)
pa_fail_alloc("duplicate XML string",size);	pa_fail_alloc("duplicate XML string",size);
Line 139 static char pa_GC_strdup(const char s)	Line 126 static char pa_GC_strdup(const char s)
#ifdef PA_DEBUG_XML_GC_MEMORY	#ifdef PA_DEBUG_XML_GC_MEMORY

static void* pa_gc_malloc_log(size_t size){	static void* pa_gc_malloc_log(size_t size){
void *p=pa_gc_malloc(size);	void *p=GC_MALLOC(size);
fprintf(stderr, "pa_gc_malloc_log(%d)=0x%p\n", size, p);	fprintf(stderr, "pa_gc_malloc_log(%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){
void *p=pa_gc_malloc_atomic(size);	void *p=GC_MALLOC_ATOMIC(size);
fprintf(stderr, "pa_gc_malloc_atomic_log(%d)=0x%p\n", size, p);	fprintf(stderr, "pa_gc_malloc_atomic_log(%d)=0x%p\n", size, p);
return p;	return p;
}	}

static void* pa_gc_realloc_log(void *ptr, size_t size){	static void* pa_gc_realloc_log(void *ptr, size_t size){
void *p=pa_gc_realloc(ptr, size);	void *p=GC_REALLOC(ptr, size);
fprintf(stderr, "pa_gc_realloc_log(0x%p, %d)=0x%p\n", ptr, size, p);	fprintf(stderr, "pa_gc_realloc_log(0x%p, %d)=0x%p\n", ptr, size, p);
return p;	return p;
}	}

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);
pa_gc_free(p);	GC_FREE(p);
}	}

#else	#else
Line 171 inline void check(void result, const c	Line 158 inline void check(void result, const c
}	}

static void* pa_gc_malloc_nonull(size_t size) {	static void* pa_gc_malloc_nonull(size_t size) {
return check(pa_gc_malloc(size), "allocate XML compsite memory", size);	return check(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) {
return check(pa_gc_malloc_atomic(size), "allocate XML atomic memory", size);	return check(GC_MALLOC_ATOMIC(size), "allocate XML atomic memory", size);
}	}

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), "reallocate XML memory", size);	return check(GC_REALLOC(ptr, size), "reallocate XML memory", size);
}	}

static void pa_gc_free_maybeignore(void* ptr) {	static void pa_gc_free_maybeignore(void* ptr) {
pa_gc_free(ptr);	GC_FREE(ptr);
}	}

#endif	#endif

#endif // XML	#endif // XML

	#ifdef HAVE_PCRE2
	pcre2_general_context* VRegex::fgen_ctxt;

	static void* pa_pcre_malloc(size_t size, void *ptr){
	return pa_malloc(size);
	}

	static void pa_pcre_free(void ptr, void tag){
	pa_free(ptr);
	}
	#endif


void pa_CORD_oom_fn(void) {	void pa_CORD_oom_fn(void) {
pa_fail_alloc("expand string", 0);	pa_fail_alloc("expand string", 0);
}	}
Line 220 static void gc_substitute_memory_managem	Line 220 static void gc_substitute_memory_managem
#endif	#endif

// pcre	// pcre
pcre_malloc=pa_gc_malloc;	#ifdef HAVE_PCRE2
pcre_free=pa_gc_free;	VRegex::fgen_ctxt=pcre2_general_context_create(pa_pcre_malloc, pa_pcre_free, NULL);
	#else
	pcre_malloc=pa_malloc;
	pcre_free=pa_free;
	#endif

// cord	// cord
CORD_oom_fn=pa_CORD_oom_fn;	CORD_oom_fn=pa_CORD_oom_fn;
Line 231 static void gc_substitute_memory_managem	Line 235 static void gc_substitute_memory_managem
@test hint on one should call this for each thread xmlSubstituteEntitiesDefault(1);	@test hint on one should call this for each thread xmlSubstituteEntitiesDefault(1);
*/	*/
void pa_globals_init() {	void pa_globals_init() {
// global variables
cache_managers=new Cache_managers;

	#ifndef PA_DEBUG_DISABLE_GC
	// Dont collect unless explicitly requested. This is quicker (~30% ),
	// but less memory-efficient(~8%), so deciding for speed.
	GC_disable();
	// as we log allocation errors, we don't need default gc warnings (without timestamp and URI)
	GC_set_warn_proc(GC_ignore_warn_proc);
	#endif

	// init socks
	pa_socks_init();

	// global variables
	cache_managers=new Cache_managers;

// in various libraries	// in various libraries
gc_substitute_memory_management_functions();	gc_substitute_memory_management_functions();

// hex value	#ifdef SYMBOLS_CACHING
setup_hex_value();	// symbols cache
	Symbols::init();
	#endif

#ifdef XML	#ifdef XML
// initializing xml libs	// initializing xml libs
Line 295 void pa_globals_done() {	Line 312 void pa_globals_done() {

if(is_dlinited)	if(is_dlinited)
lt_dlexit();	lt_dlexit();

	pa_socks_done();
}	}

void pa_dlinit() {	void pa_dlinit() {
Line 307 void pa_dlinit() {	Line 326 void pa_dlinit() {

#ifdef _MSC_VER	#ifdef _MSC_VER

#ifndef PA_DEBUG_DISABLE_GC	#define PREFIX "../../../../win32/"

#define GC_LIB "../../../../win32/gc"
#ifdef _DEBUG	#ifdef _DEBUG
#pragma comment(lib, GC_LIB "/Debug/gc.lib")	#define CONFIGURATION "Debug"
#else	#else
#pragma comment(lib, GC_LIB "/Release/gc.lib")	#define CONFIGURATION "Release"
#endif	#endif

	#ifdef _WIN64
	#define PLATFORM_64 "x64/"
	#define PLATFORM_32 ""
	#else
	#define PLATFORM_64 ""
	#define PLATFORM_32 "win32/"
	#endif

	#pragma comment(lib, PREFIX "pcre/" PLATFORM_64 CONFIGURATION "/pcre.lib")

	#ifndef PA_DEBUG_DISABLE_GC

	#pragma comment(lib, PREFIX "gc/" PLATFORM_64 CONFIGURATION "/gc.lib")

#endif // PA_DEBUG_DISABLE_GC	#endif // PA_DEBUG_DISABLE_GC


#ifdef XML	#ifdef XML

#define GNOME_LIBS "../../../../win32/gnome"	#define GNOME_LIBS PREFIX "gnome"

#ifdef _DEBUG	#define LIB_XML PREFIX "gnome/libxml2-x.x.x/" PLATFORM_64 PLATFORM_32 CONFIGURATION "/lib/"
#define LIB_XML GNOME_LIBS "/libxml2-x.x.x/win32/debug/lib/"	#define LIB_XSLT PREFIX "gnome/libxslt-x.x.x/" PLATFORM_64 PLATFORM_32 CONFIGURATION "/lib/"
#define LIB_XSLT GNOME_LIBS "/libxslt-x.x.x/win32/debug/lib/"
#else
#define LIB_XML GNOME_LIBS "/libxml2-x.x.x/win32/release/lib/"
#define LIB_XSLT GNOME_LIBS "/libxslt-x.x.x/win32/release/lib/"
#endif

#ifdef LIBXML_STATIC	#ifdef XML_STATIC
#pragma comment(lib, LIB_XML "libxml2_a.lib")	#pragma comment(lib, LIB_XML "libxml2_a.lib")
#else
#pragma comment(lib, LIB_XML "libxml2.lib")
#endif

#ifdef LIBXSLT_STATIC
#pragma comment(lib, LIB_XSLT "libxslt_a.lib")	#pragma comment(lib, LIB_XSLT "libxslt_a.lib")
#else
#pragma comment(lib, LIB_XSLT "libxslt.lib")
#endif

#ifdef LIBEXSLT_STATIC
#pragma comment(lib, LIB_XSLT "libexslt_a.lib")	#pragma comment(lib, LIB_XSLT "libexslt_a.lib")
#else	#else
	#pragma comment(lib, LIB_XML "libxml2.lib")
	#pragma comment(lib, LIB_XSLT "libxslt.lib")
#pragma comment(lib, LIB_XSLT "libexslt.lib")	#pragma comment(lib, LIB_XSLT "libexslt.lib")
#endif	#endif

#endif // XML	#endif // XML

	// defines for VS2015 to link with gc/xml libs compiled in the previous VS versions
	#if _MSC_VER >= 1900
	#pragma comment(lib,"legacy_stdio_definitions.lib")
	#endif

#endif // _MSC_VER	#endif // _MSC_VER

E-mail:

Removed from v.1.195
changed lines
	Added in v.1.215