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 * xmlFree:
91 * @mem: an already allocated block of memory
92 *
93 * The variable holding the libxml free() implementation
94 */
95xmlFreeFunc 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 */
104xmlMallocFunc 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 containings 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 */
115xmlMallocFunc 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 */
125xmlReallocFunc 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 */
134static char *
135xmlPosixStrdup(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 */
146xmlStrdupFunc 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 */
187const 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 */
195xmlBufferAllocationScheme xmlBufferAllocScheme = XML_BUFFER_ALLOC_EXACT;
196static xmlBufferAllocationScheme xmlBufferAllocSchemeThrDef = XML_BUFFER_ALLOC_EXACT;
197/**
198 * xmlDefaultBufferSize:
199 *
200 * Global setting, default buffer size. Default value is BASE_BUFFER_SIZE
201 */
202int xmlDefaultBufferSize = BASE_BUFFER_SIZE;
203static int xmlDefaultBufferSizeThrDef = BASE_BUFFER_SIZE;
204
205/*
206 * Parser defaults
207 */
208
209/**
210 * oldXMLWDcompatibility:
211 *
212 * Global setting, DEPRECATED.
213 */
214int 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 */
222int xmlParserDebugEntities = 0;
223static int xmlParserDebugEntitiesThrDef = 0;
224/**
225 * xmlDoValidityCheckingDefaultValue:
226 *
227 * Global setting, indicate that the parser should work in validating mode.
228 * Disabled by default.
229 */
230int xmlDoValidityCheckingDefaultValue = 0;
231static int xmlDoValidityCheckingDefaultValueThrDef = 0;
232/**
233 * xmlGetWarningsDefaultValue:
234 *
235 * Global setting, indicate that the parser should provide warnings.
236 * Activated by default.
237 */
238int xmlGetWarningsDefaultValue = 1;
239static 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 */
247int xmlLoadExtDtdDefaultValue = 0;
248static int xmlLoadExtDtdDefaultValueThrDef = 0;
249/**
250 * xmlPedanticParserDefaultValue:
251 *
252 * Global setting, indicate that the parser be pedantic
253 * Disabled by default.
254 */
255int xmlPedanticParserDefaultValue = 0;
256static 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 * applicaton.
264 */
265int xmlLineNumbersDefaultValue = 0;
266static 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 */
276int xmlKeepBlanksDefaultValue = 1;
277static 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 */
287int xmlSubstituteEntitiesDefaultValue = 0;
288static int xmlSubstituteEntitiesDefaultValueThrDef = 0;
289
290xmlRegisterNodeFunc xmlRegisterNodeDefaultValue = NULL;
291static xmlRegisterNodeFunc xmlRegisterNodeDefaultValueThrDef = NULL;
292xmlDeregisterNodeFunc xmlDeregisterNodeDefaultValue = NULL;
293static xmlDeregisterNodeFunc xmlDeregisterNodeDefaultValueThrDef = NULL;
294
295xmlParserInputBufferCreateFilenameFunc xmlParserInputBufferCreateFilenameValue = NULL;
296static xmlParserInputBufferCreateFilenameFunc xmlParserInputBufferCreateFilenameValueThrDef = NULL;
297
298xmlOutputBufferCreateFilenameFunc xmlOutputBufferCreateFilenameValue = NULL;
299static xmlOutputBufferCreateFilenameFunc xmlOutputBufferCreateFilenameValueThrDef = NULL;
300
301/*
302 * Error handling
303 */
304
305/* xmlGenericErrorFunc xmlGenericError = xmlGenericErrorDefaultFunc; */
306/* Must initialize xmlGenericError in xmlInitParser */
307void 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 */
315xmlGenericErrorFunc xmlGenericError = xmlGenericErrorDefaultFunc;
316static xmlGenericErrorFunc xmlGenericErrorThrDef = xmlGenericErrorDefaultFunc;
317/**
318 * xmlStructuredError:
319 *
320 * Global setting: function used for structured error callbacks
321 */
322xmlStructuredErrorFunc xmlStructuredError = NULL;
323static xmlStructuredErrorFunc xmlStructuredErrorThrDef = NULL;
324/**
325 * xmlGenericErrorContext:
326 *
327 * Global setting passed to generic error callbacks
328 */
329void *xmlGenericErrorContext = NULL;
330static void *xmlGenericErrorContextThrDef = NULL;
331/**
332 * xmlStructuredErrorContext:
333 *
334 * Global setting passed to structured error callbacks
335 */
336void *xmlStructuredErrorContext = NULL;
337static void *xmlStructuredErrorContextThrDef = NULL;
338xmlError 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 */
349int xmlIndentTreeOutput = 1;
350static 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 */
357const char *xmlTreeIndentString = " ";
358static 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 undistinguishable
365 * once parsed.
366 * Disabled by default
367 */
368int xmlSaveNoEmptyTags = 0;
369static 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 */
377xmlSAXHandlerV1 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 */
415xmlSAXLocator 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 */
428xmlSAXHandlerV1 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 */
466xmlSAXHandlerV1 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 */
505void
506xmlInitializeGlobalState(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 */
584void
585xmlThrDefSetGenericErrorFunc(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
595void
596xmlThrDefSetStructuredErrorFunc(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 */
611xmlRegisterNodeFunc
612xmlRegisterNodeDefault(xmlRegisterNodeFunc func)
613{
614 xmlRegisterNodeFunc old = xmlRegisterNodeDefaultValue;
615
616 __xmlRegisterCallbacks = 1;
617 xmlRegisterNodeDefaultValue = func;
618 return(old);
619}
620
621xmlRegisterNodeFunc
622xmlThrDefRegisterNodeDefault(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 */
644xmlDeregisterNodeFunc
645xmlDeregisterNodeDefault(xmlDeregisterNodeFunc func)
646{
647 xmlDeregisterNodeFunc old = xmlDeregisterNodeDefaultValue;
648
649 __xmlRegisterCallbacks = 1;
650 xmlDeregisterNodeDefaultValue = func;
651 return(old);
652}
653
654xmlDeregisterNodeFunc
655xmlThrDefDeregisterNodeDefault(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
669xmlParserInputBufferCreateFilenameFunc
670xmlThrDefParserInputBufferCreateFilenameDefault(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
686xmlOutputBufferCreateFilenameFunc
687xmlThrDefOutputBufferCreateFilenameDefault(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
706xmlSAXHandlerV1 *
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
717xmlSAXHandlerV1 *
718__htmlDefaultSAXHandler(void) {
719 if (IS_MAIN_THREAD)
720 return (&htmlDefaultSAXHandler);
721 else
722 return (&xmlGetGlobalState()->htmlDefaultSAXHandler);
723}
724#endif
725
726#undef xmlLastError
727xmlError *
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
742xmlMallocFunc *
743__xmlMalloc(void){
744 if (IS_MAIN_THREAD)
745 return (&xmlMalloc);
746 else
747 return (&xmlGetGlobalState()->xmlMalloc);
748}
749
750#undef xmlMallocAtomic
751xmlMallocFunc *
752__xmlMallocAtomic(void){
753 if (IS_MAIN_THREAD)
754 return (&xmlMallocAtomic);
755 else
756 return (&xmlGetGlobalState()->xmlMallocAtomic);
757}
758
759#undef xmlRealloc
760xmlReallocFunc *
761__xmlRealloc(void){
762 if (IS_MAIN_THREAD)
763 return (&xmlRealloc);
764 else
765 return (&xmlGetGlobalState()->xmlRealloc);
766}
767
768#undef xmlFree
769xmlFreeFunc *
770__xmlFree(void){
771 if (IS_MAIN_THREAD)
772 return (&xmlFree);
773 else
774 return (&xmlGetGlobalState()->xmlFree);
775}
776
777xmlStrdupFunc *
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
795int *
796__oldXMLWDcompatibility(void) {
797 if (IS_MAIN_THREAD)
798 return (&oldXMLWDcompatibility);
799 else
800 return (&xmlGetGlobalState()->oldXMLWDcompatibility);
801}
802
803#undef xmlBufferAllocScheme
804xmlBufferAllocationScheme *
805__xmlBufferAllocScheme(void) {
806 if (IS_MAIN_THREAD)
807 return (&xmlBufferAllocScheme);
808 else
809 return (&xmlGetGlobalState()->xmlBufferAllocScheme);
810}
811xmlBufferAllocationScheme 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
821int *
822__xmlDefaultBufferSize(void) {
823 if (IS_MAIN_THREAD)
824 return (&xmlDefaultBufferSize);
825 else
826 return (&xmlGetGlobalState()->xmlDefaultBufferSize);
827}
828int 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
839xmlSAXHandlerV1 *
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
849xmlSAXLocator *
850__xmlDefaultSAXLocator(void) {
851 if (IS_MAIN_THREAD)
852 return (&xmlDefaultSAXLocator);
853 else
854 return (&xmlGetGlobalState()->xmlDefaultSAXLocator);
855}
856
857#undef xmlDoValidityCheckingDefaultValue
858int *
859__xmlDoValidityCheckingDefaultValue(void) {
860 if (IS_MAIN_THREAD)
861 return (&xmlDoValidityCheckingDefaultValue);
862 else
863 return (&xmlGetGlobalState()->xmlDoValidityCheckingDefaultValue);
864}
865int 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
875xmlGenericErrorFunc *
876__xmlGenericError(void) {
877 if (IS_MAIN_THREAD)
878 return (&xmlGenericError);
879 else
880 return (&xmlGetGlobalState()->xmlGenericError);
881}
882
883#undef xmlStructuredError
884xmlStructuredErrorFunc *
885__xmlStructuredError(void) {
886 if (IS_MAIN_THREAD)
887 return (&xmlStructuredError);
888 else
889 return (&xmlGetGlobalState()->xmlStructuredError);
890}
891
892#undef xmlGenericErrorContext
893void * *
894__xmlGenericErrorContext(void) {
895 if (IS_MAIN_THREAD)
896 return (&xmlGenericErrorContext);
897 else
898 return (&xmlGetGlobalState()->xmlGenericErrorContext);
899}
900
901#undef xmlStructuredErrorContext
902void * *
903__xmlStructuredErrorContext(void) {
904 if (IS_MAIN_THREAD)
905 return (&xmlStructuredErrorContext);
906 else
907 return (&xmlGetGlobalState()->xmlStructuredErrorContext);
908}
909
910#undef xmlGetWarningsDefaultValue
911int *
912__xmlGetWarningsDefaultValue(void) {
913 if (IS_MAIN_THREAD)
914 return (&xmlGetWarningsDefaultValue);
915 else
916 return (&xmlGetGlobalState()->xmlGetWarningsDefaultValue);
917}
918int 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
928int *
929__xmlIndentTreeOutput(void) {
930 if (IS_MAIN_THREAD)
931 return (&xmlIndentTreeOutput);
932 else
933 return (&xmlGetGlobalState()->xmlIndentTreeOutput);
934}
935int 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
945const char * *
946__xmlTreeIndentString(void) {
947 if (IS_MAIN_THREAD)
948 return (&xmlTreeIndentString);
949 else
950 return (&xmlGetGlobalState()->xmlTreeIndentString);
951}
952const 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
962int *
963__xmlKeepBlanksDefaultValue(void) {
964 if (IS_MAIN_THREAD)
965 return (&xmlKeepBlanksDefaultValue);
966 else
967 return (&xmlGetGlobalState()->xmlKeepBlanksDefaultValue);
968}
969int 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
979int *
980__xmlLineNumbersDefaultValue(void) {
981 if (IS_MAIN_THREAD)
982 return (&xmlLineNumbersDefaultValue);
983 else
984 return (&xmlGetGlobalState()->xmlLineNumbersDefaultValue);
985}
986int 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
996int *
997__xmlLoadExtDtdDefaultValue(void) {
998 if (IS_MAIN_THREAD)
999 return (&xmlLoadExtDtdDefaultValue);
1000 else
1001 return (&xmlGetGlobalState()->xmlLoadExtDtdDefaultValue);
1002}
1003int 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
1013int *
1014__xmlParserDebugEntities(void) {
1015 if (IS_MAIN_THREAD)
1016 return (&xmlParserDebugEntities);
1017 else
1018 return (&xmlGetGlobalState()->xmlParserDebugEntities);
1019}
1020int 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
1030const char * *
1031__xmlParserVersion(void) {
1032 if (IS_MAIN_THREAD)
1033 return (&xmlParserVersion);
1034 else
1035 return (&xmlGetGlobalState()->xmlParserVersion);
1036}
1037
1038#undef xmlPedanticParserDefaultValue
1039int *
1040__xmlPedanticParserDefaultValue(void) {
1041 if (IS_MAIN_THREAD)
1042 return (&xmlPedanticParserDefaultValue);
1043 else
1044 return (&xmlGetGlobalState()->xmlPedanticParserDefaultValue);
1045}
1046int 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
1056int *
1057__xmlSaveNoEmptyTags(void) {
1058 if (IS_MAIN_THREAD)
1059 return (&xmlSaveNoEmptyTags);
1060 else
1061 return (&xmlGetGlobalState()->xmlSaveNoEmptyTags);
1062}
1063int 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
1073int *
1074__xmlSubstituteEntitiesDefaultValue(void) {
1075 if (IS_MAIN_THREAD)
1076 return (&xmlSubstituteEntitiesDefaultValue);
1077 else
1078 return (&xmlGetGlobalState()->xmlSubstituteEntitiesDefaultValue);
1079}
1080int 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
1090xmlRegisterNodeFunc *
1091__xmlRegisterNodeDefaultValue(void) {
1092 if (IS_MAIN_THREAD)
1093 return (&xmlRegisterNodeDefaultValue);
1094 else
1095 return (&xmlGetGlobalState()->xmlRegisterNodeDefaultValue);
1096}
1097
1098#undef xmlDeregisterNodeDefaultValue
1099xmlDeregisterNodeFunc *
1100__xmlDeregisterNodeDefaultValue(void) {
1101 if (IS_MAIN_THREAD)
1102 return (&xmlDeregisterNodeDefaultValue);
1103 else
1104 return (&xmlGetGlobalState()->xmlDeregisterNodeDefaultValue);
1105}
1106
1107#undef xmlParserInputBufferCreateFilenameValue
1108xmlParserInputBufferCreateFilenameFunc *
1109__xmlParserInputBufferCreateFilenameValue(void) {
1110 if (IS_MAIN_THREAD)
1111 return (&xmlParserInputBufferCreateFilenameValue);
1112 else
1113 return (&xmlGetGlobalState()->xmlParserInputBufferCreateFilenameValue);
1114}
1115
1116#undef xmlOutputBufferCreateFilenameValue
1117xmlOutputBufferCreateFilenameFunc *
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