VirtualBox

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

Last change on this file since 49482 was 39915, checked in by vboxsync, 13 years ago

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette