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