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