globals.c@ 49962

Last change on this file since 49962 was 39915, checked in by vboxsync, 13 years ago
libxml-2.6.31 unmodified
Property svn:eol-style set to `native`
File size: 28.4 KB

Line
1	/*
2	* globals.c: definition and handling of the set of global variables
3	* of the library
4	*
5	* The bottom of this file is automatically generated by build_glob.py
6	* based on the description file global.data
7	*
8	* See Copyright for the status of this software.
9	*
10	* Gary Pennington <[email protected]>
11	* [email protected]
12	*/
13
14	#define IN_LIBXML
15	#include "libxml.h"
16
17	#ifdef HAVE_STDLIB_H
18	#include <stdlib.h>
19	#endif
20	#include <string.h>
21
22	#include <libxml/globals.h>
23	#include <libxml/xmlmemory.h>
24	#include <libxml/threads.h>
25
26	/* #define DEBUG_GLOBALS */
27
28	/*
29	* Helpful Macro
30	*/
31	#ifdef LIBXML_THREAD_ENABLED
32	#define IS_MAIN_THREAD (xmlIsMainThread())
33	#else
34	#define IS_MAIN_THREAD 1
35	#endif
36
37	/*
38	* Mutex to protect "ForNewThreads" variables
39	*/
40	static xmlMutexPtr xmlThrDefMutex = NULL;
41
42	/**
43	* xmlInitGlobals:
44	*
45	* Additional initialisation for multi-threading
46	*/
47	void xmlInitGlobals(void)
48	{
49	xmlThrDefMutex = xmlNewMutex();
50	}
51
52	/**
53	* xmlCleanupGlobals:
54	*
55	* Additional cleanup for multi-threading
56	*/
57	void xmlCleanupGlobals(void)
58	{
59	if (xmlThrDefMutex != NULL) {
60	xmlFreeMutex(xmlThrDefMutex);
61	xmlThrDefMutex = NULL;
62	}
63	__xmlGlobalInitMutexDestroy();
64	}
65
66	/************************************************************************
67	* *
68	* All the user accessible global variables of the library *
69	* *
70	************************************************************************/
71
72	/*
73	* Memory allocation routines
74	*/
75	#undef xmlFree
76	#undef xmlMalloc
77	#undef xmlMallocAtomic
78	#undef xmlMemStrdup
79	#undef xmlRealloc
80
81	#if defined(DEBUG_MEMORY_LOCATION) \|\| defined(DEBUG_MEMORY)
82	xmlFreeFunc xmlFree = (xmlFreeFunc) xmlMemFree;
83	xmlMallocFunc xmlMalloc = (xmlMallocFunc) xmlMemMalloc;
84	xmlMallocFunc xmlMallocAtomic = (xmlMallocFunc) xmlMemMalloc;
85	xmlReallocFunc xmlRealloc = (xmlReallocFunc) xmlMemRealloc;
86	xmlStrdupFunc xmlMemStrdup = (xmlStrdupFunc) xmlMemoryStrdup;
87	#else
88	/**
89	* xmlFree:
90	* @mem: an already allocated block of memory
91	*
92	* The variable holding the libxml free() implementation
93	*/
94	xmlFreeFunc xmlFree = (xmlFreeFunc) free;
95	/**
96	* xmlMalloc:
97	* @size: the size requested in bytes
98	*
99	* The variable holding the libxml malloc() implementation
100	*
101	* Returns a pointer to the newly allocated block or NULL in case of error
102	*/
103	xmlMallocFunc xmlMalloc = (xmlMallocFunc) malloc;
104	/**
105	* xmlMallocAtomic:
106	* @size: the size requested in bytes
107	*
108	* The variable holding the libxml malloc() implementation for atomic
109	* data (i.e. blocks not containings pointers), useful when using a
110	* garbage collecting allocator.
111	*
112	* Returns a pointer to the newly allocated block or NULL in case of error
113	*/
114	xmlMallocFunc xmlMallocAtomic = (xmlMallocFunc) malloc;
115	/**
116	* xmlRealloc:
117	* @mem: an already allocated block of memory
118	* @size: the new size requested in bytes
119	*
120	* The variable holding the libxml realloc() implementation
121	*
122	* Returns a pointer to the newly reallocated block or NULL in case of error
123	*/
124	xmlReallocFunc xmlRealloc = (xmlReallocFunc) realloc;
125	/**
126	* xmlMemStrdup:
127	* @str: a zero terminated string
128	*
129	* The variable holding the libxml strdup() implementation
130	*
131	* Returns the copy of the string or NULL in case of error
132	*/
133	xmlStrdupFunc xmlMemStrdup = (xmlStrdupFunc) xmlStrdup;
134	#endif /* DEBUG_MEMORY_LOCATION \|\| DEBUG_MEMORY */
135
136	#include <libxml/threads.h>
137	#include <libxml/globals.h>
138	#include <libxml/SAX.h>
139
140	#undef docbDefaultSAXHandler
141	#undef htmlDefaultSAXHandler
142	#undef oldXMLWDcompatibility
143	#undef xmlBufferAllocScheme
144	#undef xmlDefaultBufferSize
145	#undef xmlDefaultSAXHandler
146	#undef xmlDefaultSAXLocator
147	#undef xmlDoValidityCheckingDefaultValue
148	#undef xmlGenericError
149	#undef xmlStructuredError
150	#undef xmlGenericErrorContext
151	#undef xmlGetWarningsDefaultValue
152	#undef xmlIndentTreeOutput
153	#undef xmlTreeIndentString
154	#undef xmlKeepBlanksDefaultValue
155	#undef xmlLineNumbersDefaultValue
156	#undef xmlLoadExtDtdDefaultValue
157	#undef xmlParserDebugEntities
158	#undef xmlParserVersion
159	#undef xmlPedanticParserDefaultValue
160	#undef xmlSaveNoEmptyTags
161	#undef xmlSubstituteEntitiesDefaultValue
162	#undef xmlRegisterNodeDefaultValue
163	#undef xmlDeregisterNodeDefaultValue
164	#undef xmlLastError
165
166	#undef xmlParserInputBufferCreateFilenameValue
167	#undef xmlOutputBufferCreateFilenameValue
168	/**
169	* xmlParserVersion:
170	*
171	* Constant string describing the internal version of the library
172	*/
173	const char *xmlParserVersion = LIBXML_VERSION_STRING LIBXML_VERSION_EXTRA;
174
175	/**
176	* xmlBufferAllocScheme:
177	*
178	* Global setting, default allocation policy for buffers, default is
179	* XML_BUFFER_ALLOC_EXACT
180	*/
181	xmlBufferAllocationScheme xmlBufferAllocScheme = XML_BUFFER_ALLOC_EXACT;
182	static xmlBufferAllocationScheme xmlBufferAllocSchemeThrDef = XML_BUFFER_ALLOC_EXACT;
183	/**
184	* xmlDefaultBufferSize:
185	*
186	* Global setting, default buffer size. Default value is BASE_BUFFER_SIZE
187	*/
188	int xmlDefaultBufferSize = BASE_BUFFER_SIZE;
189	static int xmlDefaultBufferSizeThrDef = BASE_BUFFER_SIZE;
190
191	/*
192	* Parser defaults
193	*/
194
195	/**
196	* oldXMLWDcompatibility:
197	*
198	* Global setting, DEPRECATED.
199	*/
200	int oldXMLWDcompatibility = 0; /* DEPRECATED */
201	/**
202	* xmlParserDebugEntities:
203	*
204	* Global setting, asking the parser to print out debugging informations.
205	* while handling entities.
206	* Disabled by default
207	*/
208	int xmlParserDebugEntities = 0;
209	static int xmlParserDebugEntitiesThrDef = 0;
210	/**
211	* xmlDoValidityCheckingDefaultValue:
212	*
213	* Global setting, indicate that the parser should work in validating mode.
214	* Disabled by default.
215	*/
216	int xmlDoValidityCheckingDefaultValue = 0;
217	static int xmlDoValidityCheckingDefaultValueThrDef = 0;
218	/**
219	* xmlGetWarningsDefaultValue:
220	*
221	* Global setting, indicate that the parser should provide warnings.
222	* Activated by default.
223	*/
224	int xmlGetWarningsDefaultValue = 1;
225	static int xmlGetWarningsDefaultValueThrDef = 1;
226	/**
227	* xmlLoadExtDtdDefaultValue:
228	*
229	* Global setting, indicate that the parser should load DTD while not
230	* validating.
231	* Disabled by default.
232	*/
233	int xmlLoadExtDtdDefaultValue = 0;
234	static int xmlLoadExtDtdDefaultValueThrDef = 0;
235	/**
236	* xmlPedanticParserDefaultValue:
237	*
238	* Global setting, indicate that the parser be pedantic
239	* Disabled by default.
240	*/
241	int xmlPedanticParserDefaultValue = 0;
242	static int xmlPedanticParserDefaultValueThrDef = 0;
243	/**
244	* xmlLineNumbersDefaultValue:
245	*
246	* Global setting, indicate that the parser should store the line number
247	* in the content field of elements in the DOM tree.
248	* Disabled by default since this may not be safe for old classes of
249	* applicaton.
250	*/
251	int xmlLineNumbersDefaultValue = 0;
252	static int xmlLineNumbersDefaultValueThrDef = 0;
253	/**
254	* xmlKeepBlanksDefaultValue:
255	*
256	* Global setting, indicate that the parser should keep all blanks
257	* nodes found in the content
258	* Activated by default, this is actually needed to have the parser
259	* conformant to the XML Recommendation, however the option is kept
260	* for some applications since this was libxml1 default behaviour.
261	*/
262	int xmlKeepBlanksDefaultValue = 1;
263	static int xmlKeepBlanksDefaultValueThrDef = 1;
264	/**
265	* xmlSubstituteEntitiesDefaultValue:
266	*
267	* Global setting, indicate that the parser should not generate entity
268	* references but replace them with the actual content of the entity
269	* Disabled by default, this should be activated when using XPath since
270	* the XPath data model requires entities replacement and the XPath
271	* engine does not handle entities references transparently.
272	*/
273	int xmlSubstituteEntitiesDefaultValue = 0;
274	static int xmlSubstituteEntitiesDefaultValueThrDef = 0;
275
276	xmlRegisterNodeFunc xmlRegisterNodeDefaultValue = NULL;
277	static xmlRegisterNodeFunc xmlRegisterNodeDefaultValueThrDef = NULL;
278	xmlDeregisterNodeFunc xmlDeregisterNodeDefaultValue = NULL;
279	static xmlDeregisterNodeFunc xmlDeregisterNodeDefaultValueThrDef = NULL;
280
281	xmlParserInputBufferCreateFilenameFunc xmlParserInputBufferCreateFilenameValue = NULL;
282	static xmlParserInputBufferCreateFilenameFunc xmlParserInputBufferCreateFilenameValueThrDef = NULL;
283
284	xmlOutputBufferCreateFilenameFunc xmlOutputBufferCreateFilenameValue = NULL;
285	static xmlOutputBufferCreateFilenameFunc xmlOutputBufferCreateFilenameValueThrDef = NULL;
286
287	/*
288	* Error handling
289	*/
290
291	/* xmlGenericErrorFunc xmlGenericError = xmlGenericErrorDefaultFunc; */
292	/* Must initialize xmlGenericError in xmlInitParser */
293	void XMLCDECL xmlGenericErrorDefaultFunc (void *ctx ATTRIBUTE_UNUSED,
294	const char *msg,
295	...);
296	/**
297	* xmlGenericError:
298	*
299	* Global setting: function used for generic error callbacks
300	*/
301	xmlGenericErrorFunc xmlGenericError = xmlGenericErrorDefaultFunc;
302	static xmlGenericErrorFunc xmlGenericErrorThrDef = xmlGenericErrorDefaultFunc;
303	/**
304	* xmlStructuredError:
305	*
306	* Global setting: function used for structured error callbacks
307	*/
308	xmlStructuredErrorFunc xmlStructuredError = NULL;
309	static xmlStructuredErrorFunc xmlStructuredErrorThrDef = NULL;
310	/**
311	* xmlGenericErrorContext:
312	*
313	* Global setting passed to generic error callbacks
314	*/
315	void *xmlGenericErrorContext = NULL;
316	static void *xmlGenericErrorContextThrDef = NULL;
317	xmlError xmlLastError;
318
319	/*
320	* output defaults
321	*/
322	/**
323	* xmlIndentTreeOutput:
324	*
325	* Global setting, asking the serializer to indent the output tree by default
326	* Enabled by default
327	*/
328	int xmlIndentTreeOutput = 1;
329	static int xmlIndentTreeOutputThrDef = 1;
330
331	/**
332	* xmlTreeIndentString:
333	*
334	* The string used to do one-level indent. By default is equal to " " (two spaces)
335	*/
336	const char *xmlTreeIndentString = " ";
337	static const char *xmlTreeIndentStringThrDef = " ";
338
339	/**
340	* xmlSaveNoEmptyTags:
341	*
342	* Global setting, asking the serializer to not output empty tags
343	* as <empty/> but <empty></empty>. those two forms are undistinguishable
344	* once parsed.
345	* Disabled by default
346	*/
347	int xmlSaveNoEmptyTags = 0;
348	static int xmlSaveNoEmptyTagsThrDef = 0;
349
350	#ifdef LIBXML_SAX1_ENABLED
351	/**
352	* xmlDefaultSAXHandler:
353	*
354	* Default SAX version1 handler for XML, builds the DOM tree
355	*/
356	xmlSAXHandlerV1 xmlDefaultSAXHandler = {
357	xmlSAX2InternalSubset,
358	xmlSAX2IsStandalone,
359	xmlSAX2HasInternalSubset,
360	xmlSAX2HasExternalSubset,
361	xmlSAX2ResolveEntity,
362	xmlSAX2GetEntity,
363	xmlSAX2EntityDecl,
364	xmlSAX2NotationDecl,
365	xmlSAX2AttributeDecl,
366	xmlSAX2ElementDecl,
367	xmlSAX2UnparsedEntityDecl,
368	xmlSAX2SetDocumentLocator,
369	xmlSAX2StartDocument,
370	xmlSAX2EndDocument,
371	xmlSAX2StartElement,
372	xmlSAX2EndElement,
373	xmlSAX2Reference,
374	xmlSAX2Characters,
375	xmlSAX2Characters,
376	xmlSAX2ProcessingInstruction,
377	xmlSAX2Comment,
378	xmlParserWarning,
379	xmlParserError,
380	xmlParserError,
381	xmlSAX2GetParameterEntity,
382	xmlSAX2CDataBlock,
383	xmlSAX2ExternalSubset,
384	0,
385	};
386	#endif /* LIBXML_SAX1_ENABLED */
387
388	/**
389	* xmlDefaultSAXLocator:
390	*
391	* The default SAX Locator
392	* { getPublicId, getSystemId, getLineNumber, getColumnNumber}
393	*/
394	xmlSAXLocator xmlDefaultSAXLocator = {
395	xmlSAX2GetPublicId,
396	xmlSAX2GetSystemId,
397	xmlSAX2GetLineNumber,
398	xmlSAX2GetColumnNumber
399	};
400
401	#ifdef LIBXML_HTML_ENABLED
402	/**
403	* htmlDefaultSAXHandler:
404	*
405	* Default old SAX v1 handler for HTML, builds the DOM tree
406	*/
407	xmlSAXHandlerV1 htmlDefaultSAXHandler = {
408	xmlSAX2InternalSubset,
409	NULL,
410	NULL,
411	NULL,
412	NULL,
413	xmlSAX2GetEntity,
414	NULL,
415	NULL,
416	NULL,
417	NULL,
418	NULL,
419	xmlSAX2SetDocumentLocator,
420	xmlSAX2StartDocument,
421	xmlSAX2EndDocument,
422	xmlSAX2StartElement,
423	xmlSAX2EndElement,
424	NULL,
425	xmlSAX2Characters,
426	xmlSAX2IgnorableWhitespace,
427	xmlSAX2ProcessingInstruction,
428	xmlSAX2Comment,
429	xmlParserWarning,
430	xmlParserError,
431	xmlParserError,
432	xmlSAX2GetParameterEntity,
433	xmlSAX2CDataBlock,
434	NULL,
435	0,
436	};
437	#endif /* LIBXML_HTML_ENABLED */
438
439	#ifdef LIBXML_DOCB_ENABLED
440	/**
441	* docbDefaultSAXHandler:
442	*
443	* Default old SAX v1 handler for SGML DocBook, builds the DOM tree
444	*/
445	xmlSAXHandlerV1 docbDefaultSAXHandler = {
446	xmlSAX2InternalSubset,
447	xmlSAX2IsStandalone,
448	xmlSAX2HasInternalSubset,
449	xmlSAX2HasExternalSubset,
450	xmlSAX2ResolveEntity,
451	xmlSAX2GetEntity,
452	xmlSAX2EntityDecl,
453	NULL,
454	NULL,
455	NULL,
456	NULL,
457	xmlSAX2SetDocumentLocator,
458	xmlSAX2StartDocument,
459	xmlSAX2EndDocument,
460	xmlSAX2StartElement,
461	xmlSAX2EndElement,
462	xmlSAX2Reference,
463	xmlSAX2Characters,
464	xmlSAX2IgnorableWhitespace,
465	NULL,
466	xmlSAX2Comment,
467	xmlParserWarning,
468	xmlParserError,
469	xmlParserError,
470	xmlSAX2GetParameterEntity,
471	NULL,
472	NULL,
473	0,
474	};
475	#endif /* LIBXML_DOCB_ENABLED */
476
477	/**
478	* xmlInitializeGlobalState:
479	* @gs: a pointer to a newly allocated global state
480	*
481	* xmlInitializeGlobalState() initialize a global state with all the
482	* default values of the library.
483	*/
484	void
485	xmlInitializeGlobalState(xmlGlobalStatePtr gs)
486	{
487	#ifdef DEBUG_GLOBALS
488	fprintf(stderr, "Initializing globals at %lu for thread %d\n",
489	(unsigned long) gs, xmlGetThreadId());
490	#endif
491
492	/*
493	* Perform initialization as required by libxml
494	*/
495	if (xmlThrDefMutex == NULL)
496	xmlInitGlobals();
497
498	xmlMutexLock(xmlThrDefMutex);
499
500	#if defined(LIBXML_DOCB_ENABLED) && defined(LIBXML_LEGACY_ENABLED) && defined(LIBXML_SAX1_ENABLED)
501	initdocbDefaultSAXHandler(&gs->docbDefaultSAXHandler);
502	#endif
503	#if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_LEGACY_ENABLED)
504	inithtmlDefaultSAXHandler(&gs->htmlDefaultSAXHandler);
505	#endif
506
507	gs->oldXMLWDcompatibility = 0;
508	gs->xmlBufferAllocScheme = xmlBufferAllocSchemeThrDef;
509	gs->xmlDefaultBufferSize = xmlDefaultBufferSizeThrDef;
510	#if defined(LIBXML_SAX1_ENABLED) && defined(LIBXML_LEGACY_ENABLED)
511	initxmlDefaultSAXHandler(&gs->xmlDefaultSAXHandler, 1);
512	#endif /* LIBXML_SAX1_ENABLED */
513	gs->xmlDefaultSAXLocator.getPublicId = xmlSAX2GetPublicId;
514	gs->xmlDefaultSAXLocator.getSystemId = xmlSAX2GetSystemId;
515	gs->xmlDefaultSAXLocator.getLineNumber = xmlSAX2GetLineNumber;
516	gs->xmlDefaultSAXLocator.getColumnNumber = xmlSAX2GetColumnNumber;
517	gs->xmlDoValidityCheckingDefaultValue =
518	xmlDoValidityCheckingDefaultValueThrDef;
519	#if defined(DEBUG_MEMORY_LOCATION) \| defined(DEBUG_MEMORY)
520	gs->xmlFree = (xmlFreeFunc) xmlMemFree;
521	gs->xmlMalloc = (xmlMallocFunc) xmlMemMalloc;
522	gs->xmlMallocAtomic = (xmlMallocFunc) xmlMemMalloc;
523	gs->xmlRealloc = (xmlReallocFunc) xmlMemRealloc;
524	gs->xmlMemStrdup = (xmlStrdupFunc) xmlMemoryStrdup;
525	#else
526	gs->xmlFree = (xmlFreeFunc) free;
527	gs->xmlMalloc = (xmlMallocFunc) malloc;
528	gs->xmlMallocAtomic = (xmlMallocFunc) malloc;
529	gs->xmlRealloc = (xmlReallocFunc) realloc;
530	gs->xmlMemStrdup = (xmlStrdupFunc) xmlStrdup;
531	#endif
532	gs->xmlGetWarningsDefaultValue = xmlGetWarningsDefaultValueThrDef;
533	gs->xmlIndentTreeOutput = xmlIndentTreeOutputThrDef;
534	gs->xmlTreeIndentString = xmlTreeIndentStringThrDef;
535	gs->xmlKeepBlanksDefaultValue = xmlKeepBlanksDefaultValueThrDef;
536	gs->xmlLineNumbersDefaultValue = xmlLineNumbersDefaultValueThrDef;
537	gs->xmlLoadExtDtdDefaultValue = xmlLoadExtDtdDefaultValueThrDef;
538	gs->xmlParserDebugEntities = xmlParserDebugEntitiesThrDef;
539	gs->xmlParserVersion = LIBXML_VERSION_STRING;
540	gs->xmlPedanticParserDefaultValue = xmlPedanticParserDefaultValueThrDef;
541	gs->xmlSaveNoEmptyTags = xmlSaveNoEmptyTagsThrDef;
542	gs->xmlSubstituteEntitiesDefaultValue =
543	xmlSubstituteEntitiesDefaultValueThrDef;
544
545	gs->xmlGenericError = xmlGenericErrorThrDef;
546	gs->xmlStructuredError = xmlStructuredErrorThrDef;
547	gs->xmlGenericErrorContext = xmlGenericErrorContextThrDef;
548	gs->xmlRegisterNodeDefaultValue = xmlRegisterNodeDefaultValueThrDef;
549	gs->xmlDeregisterNodeDefaultValue = xmlDeregisterNodeDefaultValueThrDef;
550
551	gs->xmlParserInputBufferCreateFilenameValue = xmlParserInputBufferCreateFilenameValueThrDef;
552	gs->xmlOutputBufferCreateFilenameValue = xmlOutputBufferCreateFilenameValueThrDef;
553	memset(&gs->xmlLastError, 0, sizeof(xmlError));
554
555	xmlMutexUnlock(xmlThrDefMutex);
556	}
557
558	/**
559	* DOC_DISABLE : we ignore missing doc for the xmlThrDef functions,
560	* those are really internal work
561	*/
562	void
563	xmlThrDefSetGenericErrorFunc(void *ctx, xmlGenericErrorFunc handler) {
564	xmlMutexLock(xmlThrDefMutex);
565	xmlGenericErrorContextThrDef = ctx;
566	if (handler != NULL)
567	xmlGenericErrorThrDef = handler;
568	else
569	xmlGenericErrorThrDef = xmlGenericErrorDefaultFunc;
570	xmlMutexUnlock(xmlThrDefMutex);
571	}
572
573	void
574	xmlThrDefSetStructuredErrorFunc(void *ctx, xmlStructuredErrorFunc handler) {
575	xmlMutexLock(xmlThrDefMutex);
576	xmlGenericErrorContextThrDef = ctx;
577	xmlStructuredErrorThrDef = handler;
578	xmlMutexUnlock(xmlThrDefMutex);
579	}
580
581	/**
582	* xmlRegisterNodeDefault:
583	* @func: function pointer to the new RegisterNodeFunc
584	*
585	* Registers a callback for node creation
586	*
587	* Returns the old value of the registration function
588	*/
589	xmlRegisterNodeFunc
590	xmlRegisterNodeDefault(xmlRegisterNodeFunc func)
591	{
592	xmlRegisterNodeFunc old = xmlRegisterNodeDefaultValue;
593
594	__xmlRegisterCallbacks = 1;
595	xmlRegisterNodeDefaultValue = func;
596	return(old);
597	}
598
599	xmlRegisterNodeFunc
600	xmlThrDefRegisterNodeDefault(xmlRegisterNodeFunc func)
601	{
602	xmlRegisterNodeFunc old;
603
604	xmlMutexLock(xmlThrDefMutex);
605	old = xmlRegisterNodeDefaultValueThrDef;
606
607	__xmlRegisterCallbacks = 1;
608	xmlRegisterNodeDefaultValueThrDef = func;
609	xmlMutexUnlock(xmlThrDefMutex);
610
611	return(old);
612	}
613
614	/**
615	* xmlDeregisterNodeDefault:
616	* @func: function pointer to the new DeregisterNodeFunc
617	*
618	* Registers a callback for node destruction
619	*
620	* Returns the previous value of the deregistration function
621	*/
622	xmlDeregisterNodeFunc
623	xmlDeregisterNodeDefault(xmlDeregisterNodeFunc func)
624	{
625	xmlDeregisterNodeFunc old = xmlDeregisterNodeDefaultValue;
626
627	__xmlRegisterCallbacks = 1;
628	xmlDeregisterNodeDefaultValue = func;
629	return(old);
630	}
631
632	xmlDeregisterNodeFunc
633	xmlThrDefDeregisterNodeDefault(xmlDeregisterNodeFunc func)
634	{
635	xmlDeregisterNodeFunc old;
636
637	xmlMutexLock(xmlThrDefMutex);
638	old = xmlDeregisterNodeDefaultValueThrDef;
639
640	__xmlRegisterCallbacks = 1;
641	xmlDeregisterNodeDefaultValueThrDef = func;
642	xmlMutexUnlock(xmlThrDefMutex);
643
644	return(old);
645	}
646
647	xmlParserInputBufferCreateFilenameFunc
648	xmlThrDefParserInputBufferCreateFilenameDefault(xmlParserInputBufferCreateFilenameFunc func)
649	{
650	xmlParserInputBufferCreateFilenameFunc old;
651
652	xmlMutexLock(xmlThrDefMutex);
653	old = xmlParserInputBufferCreateFilenameValueThrDef;
654	if (old == NULL) {
655	old = __xmlParserInputBufferCreateFilename;
656	}
657
658	xmlParserInputBufferCreateFilenameValueThrDef = func;
659	xmlMutexUnlock(xmlThrDefMutex);
660
661	return(old);
662	}
663
664	xmlOutputBufferCreateFilenameFunc
665	xmlThrDefOutputBufferCreateFilenameDefault(xmlOutputBufferCreateFilenameFunc func)
666	{
667	xmlOutputBufferCreateFilenameFunc old;
668
669	xmlMutexLock(xmlThrDefMutex);
670	old = xmlOutputBufferCreateFilenameValueThrDef;
671	#ifdef LIBXML_OUTPUT_ENABLED
672	if (old == NULL) {
673	old = __xmlOutputBufferCreateFilename;
674	}
675	#endif
676	xmlOutputBufferCreateFilenameValueThrDef = func;
677	xmlMutexUnlock(xmlThrDefMutex);
678
679	return(old);
680	}
681
682	#ifdef LIBXML_DOCB_ENABLED
683	#undef docbDefaultSAXHandler
684	xmlSAXHandlerV1 *
685	__docbDefaultSAXHandler(void) {
686	if (IS_MAIN_THREAD)
687	return (&docbDefaultSAXHandler);
688	else
689	return (&xmlGetGlobalState()->docbDefaultSAXHandler);
690	}
691	#endif
692
693	#ifdef LIBXML_HTML_ENABLED
694	#undef htmlDefaultSAXHandler
695	xmlSAXHandlerV1 *
696	__htmlDefaultSAXHandler(void) {
697	if (IS_MAIN_THREAD)
698	return (&htmlDefaultSAXHandler);
699	else
700	return (&xmlGetGlobalState()->htmlDefaultSAXHandler);
701	}
702	#endif
703
704	#undef xmlLastError
705	xmlError *
706	__xmlLastError(void) {
707	if (IS_MAIN_THREAD)
708	return (&xmlLastError);
709	else
710	return (&xmlGetGlobalState()->xmlLastError);
711	}
712
713	/*
714	* The following memory routines were apparently lost at some point,
715	* and were re-inserted at this point on June 10, 2004. Hope it's
716	* the right place for them :-)
717	*/
718	#if defined(LIBXML_THREAD_ALLOC_ENABLED) && defined(LIBXML_THREAD_ENABLED)
719	#undef xmlMalloc
720	xmlMallocFunc *
721	__xmlMalloc(void){
722	if (IS_MAIN_THREAD)
723	return (&xmlMalloc);
724	else
725	return (&xmlGetGlobalState()->xmlMalloc);
726	}
727
728	#undef xmlMallocAtomic
729	xmlMallocFunc *
730	__xmlMallocAtomic(void){
731	if (IS_MAIN_THREAD)
732	return (&xmlMallocAtomic);
733	else
734	return (&xmlGetGlobalState()->xmlMallocAtomic);
735	}
736
737	#undef xmlRealloc
738	xmlReallocFunc *
739	__xmlRealloc(void){
740	if (IS_MAIN_THREAD)
741	return (&xmlRealloc);
742	else
743	return (&xmlGetGlobalState()->xmlRealloc);
744	}
745
746	#undef xmlFree
747	xmlFreeFunc *
748	__xmlFree(void){
749	if (IS_MAIN_THREAD)
750	return (&xmlFree);
751	else
752	return (&xmlGetGlobalState()->xmlFree);
753	}
754
755	xmlStrdupFunc *
756	__xmlMemStrdup(void){
757	if (IS_MAIN_THREAD)
758	return (&xmlMemStrdup);
759	else
760	return (&xmlGetGlobalState()->xmlMemStrdup);
761	}
762
763	#endif
764
765	/*
766	* Everything starting from the line below is
767	* Automatically generated by build_glob.py.
768	* Do not modify the previous line.
769	*/
770
771
772	#undef oldXMLWDcompatibility
773	int *
774	__oldXMLWDcompatibility(void) {
775	if (IS_MAIN_THREAD)
776	return (&oldXMLWDcompatibility);
777	else
778	return (&xmlGetGlobalState()->oldXMLWDcompatibility);
779	}
780
781	#undef xmlBufferAllocScheme
782	xmlBufferAllocationScheme *
783	__xmlBufferAllocScheme(void) {
784	if (IS_MAIN_THREAD)
785	return (&xmlBufferAllocScheme);
786	else
787	return (&xmlGetGlobalState()->xmlBufferAllocScheme);
788	}
789	xmlBufferAllocationScheme xmlThrDefBufferAllocScheme(xmlBufferAllocationScheme v) {
790	xmlBufferAllocationScheme ret;
791	xmlMutexLock(xmlThrDefMutex);
792	ret = xmlBufferAllocSchemeThrDef;
793	xmlBufferAllocSchemeThrDef = v;
794	xmlMutexUnlock(xmlThrDefMutex);
795	return ret;
796	}
797
798	#undef xmlDefaultBufferSize
799	int *
800	__xmlDefaultBufferSize(void) {
801	if (IS_MAIN_THREAD)
802	return (&xmlDefaultBufferSize);
803	else
804	return (&xmlGetGlobalState()->xmlDefaultBufferSize);
805	}
806	int xmlThrDefDefaultBufferSize(int v) {
807	int ret;
808	xmlMutexLock(xmlThrDefMutex);
809	ret = xmlDefaultBufferSizeThrDef;
810	xmlDefaultBufferSizeThrDef = v;
811	xmlMutexUnlock(xmlThrDefMutex);
812	return ret;
813	}
814
815	#ifdef LIBXML_SAX1_ENABLED
816	#undef xmlDefaultSAXHandler
817	xmlSAXHandlerV1 *
818	__xmlDefaultSAXHandler(void) {
819	if (IS_MAIN_THREAD)
820	return (&xmlDefaultSAXHandler);
821	else
822	return (&xmlGetGlobalState()->xmlDefaultSAXHandler);
823	}
824	#endif /* LIBXML_SAX1_ENABLED */
825
826	#undef xmlDefaultSAXLocator
827	xmlSAXLocator *
828	__xmlDefaultSAXLocator(void) {
829	if (IS_MAIN_THREAD)
830	return (&xmlDefaultSAXLocator);
831	else
832	return (&xmlGetGlobalState()->xmlDefaultSAXLocator);
833	}
834
835	#undef xmlDoValidityCheckingDefaultValue
836	int *
837	__xmlDoValidityCheckingDefaultValue(void) {
838	if (IS_MAIN_THREAD)
839	return (&xmlDoValidityCheckingDefaultValue);
840	else
841	return (&xmlGetGlobalState()->xmlDoValidityCheckingDefaultValue);
842	}
843	int xmlThrDefDoValidityCheckingDefaultValue(int v) {
844	int ret;
845	xmlMutexLock(xmlThrDefMutex);
846	ret = xmlDoValidityCheckingDefaultValueThrDef;
847	xmlDoValidityCheckingDefaultValueThrDef = v;
848	xmlMutexUnlock(xmlThrDefMutex);
849	return ret;
850	}
851
852	#undef xmlGenericError
853	xmlGenericErrorFunc *
854	__xmlGenericError(void) {
855	if (IS_MAIN_THREAD)
856	return (&xmlGenericError);
857	else
858	return (&xmlGetGlobalState()->xmlGenericError);
859	}
860
861	#undef xmlStructuredError
862	xmlStructuredErrorFunc *
863	__xmlStructuredError(void) {
864	if (IS_MAIN_THREAD)
865	return (&xmlStructuredError);
866	else
867	return (&xmlGetGlobalState()->xmlStructuredError);
868	}
869
870	#undef xmlGenericErrorContext
871	void * *
872	__xmlGenericErrorContext(void) {
873	if (IS_MAIN_THREAD)
874	return (&xmlGenericErrorContext);
875	else
876	return (&xmlGetGlobalState()->xmlGenericErrorContext);
877	}
878
879	#undef xmlGetWarningsDefaultValue
880	int *
881	__xmlGetWarningsDefaultValue(void) {
882	if (IS_MAIN_THREAD)
883	return (&xmlGetWarningsDefaultValue);
884	else
885	return (&xmlGetGlobalState()->xmlGetWarningsDefaultValue);
886	}
887	int xmlThrDefGetWarningsDefaultValue(int v) {
888	int ret;
889	xmlMutexLock(xmlThrDefMutex);
890	ret = xmlGetWarningsDefaultValueThrDef;
891	xmlGetWarningsDefaultValueThrDef = v;
892	xmlMutexUnlock(xmlThrDefMutex);
893	return ret;
894	}
895
896	#undef xmlIndentTreeOutput
897	int *
898	__xmlIndentTreeOutput(void) {
899	if (IS_MAIN_THREAD)
900	return (&xmlIndentTreeOutput);
901	else
902	return (&xmlGetGlobalState()->xmlIndentTreeOutput);
903	}
904	int xmlThrDefIndentTreeOutput(int v) {
905	int ret;
906	xmlMutexLock(xmlThrDefMutex);
907	ret = xmlIndentTreeOutputThrDef;
908	xmlIndentTreeOutputThrDef = v;
909	xmlMutexUnlock(xmlThrDefMutex);
910	return ret;
911	}
912
913	#undef xmlTreeIndentString
914	const char * *
915	__xmlTreeIndentString(void) {
916	if (IS_MAIN_THREAD)
917	return (&xmlTreeIndentString);
918	else
919	return (&xmlGetGlobalState()->xmlTreeIndentString);
920	}
921	const char * xmlThrDefTreeIndentString(const char * v) {
922	const char * ret;
923	xmlMutexLock(xmlThrDefMutex);
924	ret = xmlTreeIndentStringThrDef;
925	xmlTreeIndentStringThrDef = v;
926	xmlMutexUnlock(xmlThrDefMutex);
927	return ret;
928	}
929
930	#undef xmlKeepBlanksDefaultValue
931	int *
932	__xmlKeepBlanksDefaultValue(void) {
933	if (IS_MAIN_THREAD)
934	return (&xmlKeepBlanksDefaultValue);
935	else
936	return (&xmlGetGlobalState()->xmlKeepBlanksDefaultValue);
937	}
938	int xmlThrDefKeepBlanksDefaultValue(int v) {
939	int ret;
940	xmlMutexLock(xmlThrDefMutex);
941	ret = xmlKeepBlanksDefaultValueThrDef;
942	xmlKeepBlanksDefaultValueThrDef = v;
943	xmlMutexUnlock(xmlThrDefMutex);
944	return ret;
945	}
946
947	#undef xmlLineNumbersDefaultValue
948	int *
949	__xmlLineNumbersDefaultValue(void) {
950	if (IS_MAIN_THREAD)
951	return (&xmlLineNumbersDefaultValue);
952	else
953	return (&xmlGetGlobalState()->xmlLineNumbersDefaultValue);
954	}
955	int xmlThrDefLineNumbersDefaultValue(int v) {
956	int ret;
957	xmlMutexLock(xmlThrDefMutex);
958	ret = xmlLineNumbersDefaultValueThrDef;
959	xmlLineNumbersDefaultValueThrDef = v;
960	xmlMutexUnlock(xmlThrDefMutex);
961	return ret;
962	}
963
964	#undef xmlLoadExtDtdDefaultValue
965	int *
966	__xmlLoadExtDtdDefaultValue(void) {
967	if (IS_MAIN_THREAD)
968	return (&xmlLoadExtDtdDefaultValue);
969	else
970	return (&xmlGetGlobalState()->xmlLoadExtDtdDefaultValue);
971	}
972	int xmlThrDefLoadExtDtdDefaultValue(int v) {
973	int ret;
974	xmlMutexLock(xmlThrDefMutex);
975	ret = xmlLoadExtDtdDefaultValueThrDef;
976	xmlLoadExtDtdDefaultValueThrDef = v;
977	xmlMutexUnlock(xmlThrDefMutex);
978	return ret;
979	}
980
981	#undef xmlParserDebugEntities
982	int *
983	__xmlParserDebugEntities(void) {
984	if (IS_MAIN_THREAD)
985	return (&xmlParserDebugEntities);
986	else
987	return (&xmlGetGlobalState()->xmlParserDebugEntities);
988	}
989	int xmlThrDefParserDebugEntities(int v) {
990	int ret;
991	xmlMutexLock(xmlThrDefMutex);
992	ret = xmlParserDebugEntitiesThrDef;
993	xmlParserDebugEntitiesThrDef = v;
994	xmlMutexUnlock(xmlThrDefMutex);
995	return ret;
996	}
997
998	#undef xmlParserVersion
999	const char * *
1000	__xmlParserVersion(void) {
1001	if (IS_MAIN_THREAD)
1002	return (&xmlParserVersion);
1003	else
1004	return (&xmlGetGlobalState()->xmlParserVersion);
1005	}
1006
1007	#undef xmlPedanticParserDefaultValue
1008	int *
1009	__xmlPedanticParserDefaultValue(void) {
1010	if (IS_MAIN_THREAD)
1011	return (&xmlPedanticParserDefaultValue);
1012	else
1013	return (&xmlGetGlobalState()->xmlPedanticParserDefaultValue);
1014	}
1015	int xmlThrDefPedanticParserDefaultValue(int v) {
1016	int ret;
1017	xmlMutexLock(xmlThrDefMutex);
1018	ret = xmlPedanticParserDefaultValueThrDef;
1019	xmlPedanticParserDefaultValueThrDef = v;
1020	xmlMutexUnlock(xmlThrDefMutex);
1021	return ret;
1022	}
1023
1024	#undef xmlSaveNoEmptyTags
1025	int *
1026	__xmlSaveNoEmptyTags(void) {
1027	if (IS_MAIN_THREAD)
1028	return (&xmlSaveNoEmptyTags);
1029	else
1030	return (&xmlGetGlobalState()->xmlSaveNoEmptyTags);
1031	}
1032	int xmlThrDefSaveNoEmptyTags(int v) {
1033	int ret;
1034	xmlMutexLock(xmlThrDefMutex);
1035	ret = xmlSaveNoEmptyTagsThrDef;
1036	xmlSaveNoEmptyTagsThrDef = v;
1037	xmlMutexUnlock(xmlThrDefMutex);
1038	return ret;
1039	}
1040
1041	#undef xmlSubstituteEntitiesDefaultValue
1042	int *
1043	__xmlSubstituteEntitiesDefaultValue(void) {
1044	if (IS_MAIN_THREAD)
1045	return (&xmlSubstituteEntitiesDefaultValue);
1046	else
1047	return (&xmlGetGlobalState()->xmlSubstituteEntitiesDefaultValue);
1048	}
1049	int xmlThrDefSubstituteEntitiesDefaultValue(int v) {
1050	int ret;
1051	xmlMutexLock(xmlThrDefMutex);
1052	ret = xmlSubstituteEntitiesDefaultValueThrDef;
1053	xmlSubstituteEntitiesDefaultValueThrDef = v;
1054	xmlMutexUnlock(xmlThrDefMutex);
1055	return ret;
1056	}
1057
1058	#undef xmlRegisterNodeDefaultValue
1059	xmlRegisterNodeFunc *
1060	__xmlRegisterNodeDefaultValue(void) {
1061	if (IS_MAIN_THREAD)
1062	return (&xmlRegisterNodeDefaultValue);
1063	else
1064	return (&xmlGetGlobalState()->xmlRegisterNodeDefaultValue);
1065	}
1066
1067	#undef xmlDeregisterNodeDefaultValue
1068	xmlDeregisterNodeFunc *
1069	__xmlDeregisterNodeDefaultValue(void) {
1070	if (IS_MAIN_THREAD)
1071	return (&xmlDeregisterNodeDefaultValue);
1072	else
1073	return (&xmlGetGlobalState()->xmlDeregisterNodeDefaultValue);
1074	}
1075
1076	#undef xmlParserInputBufferCreateFilenameValue
1077	xmlParserInputBufferCreateFilenameFunc *
1078	__xmlParserInputBufferCreateFilenameValue(void) {
1079	if (IS_MAIN_THREAD)
1080	return (&xmlParserInputBufferCreateFilenameValue);
1081	else
1082	return (&xmlGetGlobalState()->xmlParserInputBufferCreateFilenameValue);
1083	}
1084
1085	#undef xmlOutputBufferCreateFilenameValue
1086	xmlOutputBufferCreateFilenameFunc *
1087	__xmlOutputBufferCreateFilenameValue(void) {
1088	if (IS_MAIN_THREAD)
1089	return (&xmlOutputBufferCreateFilenameValue);
1090	else
1091	return (&xmlGetGlobalState()->xmlOutputBufferCreateFilenameValue);
1092	}
1093
1094	#define bottom_globals
1095	#include "elfgcchack.h"

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/libs/libxml2-2.6.31/globals.c@ 49962

Download in other formats: