VirtualBox

source: vbox/trunk/src/libs/libxml2-2.9.4/globals.c@ 76686

Last change on this file since 76686 was 65950, checked in by vboxsync, 8 years ago

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