[LIBXML2] Update to version 2.9.8. CORE-15280
[reactos.git] / sdk / lib / 3rdparty / libxml2 / globals.c
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 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 */
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 * applicaton.
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 undistinguishable
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"