• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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   */
xmlInitGlobals(void)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   */
xmlCleanupGlobals(void)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 = (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   */
104  xmlMallocFunc 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   */
115  xmlMallocFunc 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   */
125  xmlReallocFunc 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   */
134  xmlStrdupFunc 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   */
175  const 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   */
183  xmlBufferAllocationScheme xmlBufferAllocScheme = XML_BUFFER_ALLOC_EXACT;
184  static xmlBufferAllocationScheme xmlBufferAllocSchemeThrDef = XML_BUFFER_ALLOC_EXACT;
185  /**
186   * xmlDefaultBufferSize:
187   *
188   * Global setting, default buffer size. Default value is BASE_BUFFER_SIZE
189   */
190  int xmlDefaultBufferSize = BASE_BUFFER_SIZE;
191  static int xmlDefaultBufferSizeThrDef = BASE_BUFFER_SIZE;
192  
193  /*
194   * Parser defaults
195   */
196  
197  /**
198   * oldXMLWDcompatibility:
199   *
200   * Global setting, DEPRECATED.
201   */
202  int 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   */
210  int xmlParserDebugEntities = 0;
211  static int xmlParserDebugEntitiesThrDef = 0;
212  /**
213   * xmlDoValidityCheckingDefaultValue:
214   *
215   * Global setting, indicate that the parser should work in validating mode.
216   * Disabled by default.
217   */
218  int xmlDoValidityCheckingDefaultValue = 0;
219  static int xmlDoValidityCheckingDefaultValueThrDef = 0;
220  /**
221   * xmlGetWarningsDefaultValue:
222   *
223   * Global setting, indicate that the parser should provide warnings.
224   * Activated by default.
225   */
226  int xmlGetWarningsDefaultValue = 1;
227  static 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   */
235  int xmlLoadExtDtdDefaultValue = 0;
236  static int xmlLoadExtDtdDefaultValueThrDef = 0;
237  /**
238   * xmlPedanticParserDefaultValue:
239   *
240   * Global setting, indicate that the parser be pedantic
241   * Disabled by default.
242   */
243  int xmlPedanticParserDefaultValue = 0;
244  static 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   */
253  int xmlLineNumbersDefaultValue = 0;
254  static 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   */
264  int xmlKeepBlanksDefaultValue = 1;
265  static 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   */
275  int xmlSubstituteEntitiesDefaultValue = 0;
276  static int xmlSubstituteEntitiesDefaultValueThrDef = 0;
277  
278  xmlRegisterNodeFunc xmlRegisterNodeDefaultValue = NULL;
279  static xmlRegisterNodeFunc xmlRegisterNodeDefaultValueThrDef = NULL;
280  xmlDeregisterNodeFunc xmlDeregisterNodeDefaultValue = NULL;
281  static xmlDeregisterNodeFunc xmlDeregisterNodeDefaultValueThrDef = NULL;
282  
283  xmlParserInputBufferCreateFilenameFunc xmlParserInputBufferCreateFilenameValue = NULL;
284  static xmlParserInputBufferCreateFilenameFunc xmlParserInputBufferCreateFilenameValueThrDef = NULL;
285  
286  xmlOutputBufferCreateFilenameFunc xmlOutputBufferCreateFilenameValue = NULL;
287  static xmlOutputBufferCreateFilenameFunc xmlOutputBufferCreateFilenameValueThrDef = NULL;
288  
289  /*
290   * Error handling
291   */
292  
293  /* xmlGenericErrorFunc xmlGenericError = xmlGenericErrorDefaultFunc; */
294  /* Must initialize xmlGenericError in xmlInitParser */
295  void 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   */
303  xmlGenericErrorFunc xmlGenericError = xmlGenericErrorDefaultFunc;
304  static xmlGenericErrorFunc xmlGenericErrorThrDef = xmlGenericErrorDefaultFunc;
305  /**
306   * xmlStructuredError:
307   *
308   * Global setting: function used for structured error callbacks
309   */
310  xmlStructuredErrorFunc xmlStructuredError = NULL;
311  static xmlStructuredErrorFunc xmlStructuredErrorThrDef = NULL;
312  /**
313   * xmlGenericErrorContext:
314   *
315   * Global setting passed to generic error callbacks
316   */
317  void *xmlGenericErrorContext = NULL;
318  static void *xmlGenericErrorContextThrDef = NULL;
319  /**
320   * xmlStructuredErrorContext:
321   *
322   * Global setting passed to structured error callbacks
323   */
324  void *xmlStructuredErrorContext = NULL;
325  static void *xmlStructuredErrorContextThrDef = NULL;
326  xmlError 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   */
337  int xmlIndentTreeOutput = 1;
338  static 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   */
345  const char *xmlTreeIndentString = "  ";
346  static 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   */
356  int xmlSaveNoEmptyTags = 0;
357  static 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   */
365  xmlSAXHandlerV1 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   */
403  xmlSAXLocator 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   */
416  xmlSAXHandlerV1 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   */
454  xmlSAXHandlerV1 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   */
493  void
xmlInitializeGlobalState(xmlGlobalStatePtr gs)494  xmlInitializeGlobalState(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   */
572  void
xmlThrDefSetGenericErrorFunc(void * ctx,xmlGenericErrorFunc handler)573  xmlThrDefSetGenericErrorFunc(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  
583  void
xmlThrDefSetStructuredErrorFunc(void * ctx,xmlStructuredErrorFunc handler)584  xmlThrDefSetStructuredErrorFunc(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   */
599  xmlRegisterNodeFunc
xmlRegisterNodeDefault(xmlRegisterNodeFunc func)600  xmlRegisterNodeDefault(xmlRegisterNodeFunc func)
601  {
602      xmlRegisterNodeFunc old = xmlRegisterNodeDefaultValue;
603  
604      __xmlRegisterCallbacks = 1;
605      xmlRegisterNodeDefaultValue = func;
606      return(old);
607  }
608  
609  xmlRegisterNodeFunc
xmlThrDefRegisterNodeDefault(xmlRegisterNodeFunc func)610  xmlThrDefRegisterNodeDefault(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   */
632  xmlDeregisterNodeFunc
xmlDeregisterNodeDefault(xmlDeregisterNodeFunc func)633  xmlDeregisterNodeDefault(xmlDeregisterNodeFunc func)
634  {
635      xmlDeregisterNodeFunc old = xmlDeregisterNodeDefaultValue;
636  
637      __xmlRegisterCallbacks = 1;
638      xmlDeregisterNodeDefaultValue = func;
639      return(old);
640  }
641  
642  xmlDeregisterNodeFunc
xmlThrDefDeregisterNodeDefault(xmlDeregisterNodeFunc func)643  xmlThrDefDeregisterNodeDefault(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  
657  xmlParserInputBufferCreateFilenameFunc
xmlThrDefParserInputBufferCreateFilenameDefault(xmlParserInputBufferCreateFilenameFunc func)658  xmlThrDefParserInputBufferCreateFilenameDefault(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  
674  xmlOutputBufferCreateFilenameFunc
xmlThrDefOutputBufferCreateFilenameDefault(xmlOutputBufferCreateFilenameFunc func)675  xmlThrDefOutputBufferCreateFilenameDefault(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
694  xmlSAXHandlerV1 *
__docbDefaultSAXHandler(void)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
705  xmlSAXHandlerV1 *
__htmlDefaultSAXHandler(void)706  __htmlDefaultSAXHandler(void) {
707      if (IS_MAIN_THREAD)
708  	return (&htmlDefaultSAXHandler);
709      else
710  	return (&xmlGetGlobalState()->htmlDefaultSAXHandler);
711  }
712  #endif
713  
714  #undef xmlLastError
715  xmlError *
__xmlLastError(void)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
730  xmlMallocFunc *
__xmlMalloc(void)731  __xmlMalloc(void){
732      if (IS_MAIN_THREAD)
733          return (&xmlMalloc);
734      else
735  	return (&xmlGetGlobalState()->xmlMalloc);
736  }
737  
738  #undef xmlMallocAtomic
739  xmlMallocFunc *
__xmlMallocAtomic(void)740  __xmlMallocAtomic(void){
741      if (IS_MAIN_THREAD)
742          return (&xmlMallocAtomic);
743      else
744          return (&xmlGetGlobalState()->xmlMallocAtomic);
745  }
746  
747  #undef xmlRealloc
748  xmlReallocFunc *
__xmlRealloc(void)749  __xmlRealloc(void){
750      if (IS_MAIN_THREAD)
751          return (&xmlRealloc);
752      else
753          return (&xmlGetGlobalState()->xmlRealloc);
754  }
755  
756  #undef xmlFree
757  xmlFreeFunc *
__xmlFree(void)758  __xmlFree(void){
759      if (IS_MAIN_THREAD)
760          return (&xmlFree);
761      else
762          return (&xmlGetGlobalState()->xmlFree);
763  }
764  
765  xmlStrdupFunc *
__xmlMemStrdup(void)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
783  int *
__oldXMLWDcompatibility(void)784  __oldXMLWDcompatibility(void) {
785      if (IS_MAIN_THREAD)
786  	return (&oldXMLWDcompatibility);
787      else
788  	return (&xmlGetGlobalState()->oldXMLWDcompatibility);
789  }
790  
791  #undef	xmlBufferAllocScheme
792  xmlBufferAllocationScheme *
__xmlBufferAllocScheme(void)793  __xmlBufferAllocScheme(void) {
794      if (IS_MAIN_THREAD)
795  	return (&xmlBufferAllocScheme);
796      else
797  	return (&xmlGetGlobalState()->xmlBufferAllocScheme);
798  }
xmlThrDefBufferAllocScheme(xmlBufferAllocationScheme v)799  xmlBufferAllocationScheme 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
809  int *
__xmlDefaultBufferSize(void)810  __xmlDefaultBufferSize(void) {
811      if (IS_MAIN_THREAD)
812  	return (&xmlDefaultBufferSize);
813      else
814  	return (&xmlGetGlobalState()->xmlDefaultBufferSize);
815  }
xmlThrDefDefaultBufferSize(int v)816  int 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
827  xmlSAXHandlerV1 *
__xmlDefaultSAXHandler(void)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
837  xmlSAXLocator *
__xmlDefaultSAXLocator(void)838  __xmlDefaultSAXLocator(void) {
839      if (IS_MAIN_THREAD)
840  	return (&xmlDefaultSAXLocator);
841      else
842  	return (&xmlGetGlobalState()->xmlDefaultSAXLocator);
843  }
844  
845  #undef	xmlDoValidityCheckingDefaultValue
846  int *
__xmlDoValidityCheckingDefaultValue(void)847  __xmlDoValidityCheckingDefaultValue(void) {
848      if (IS_MAIN_THREAD)
849  	return (&xmlDoValidityCheckingDefaultValue);
850      else
851  	return (&xmlGetGlobalState()->xmlDoValidityCheckingDefaultValue);
852  }
xmlThrDefDoValidityCheckingDefaultValue(int v)853  int 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
863  xmlGenericErrorFunc *
__xmlGenericError(void)864  __xmlGenericError(void) {
865      if (IS_MAIN_THREAD)
866  	return (&xmlGenericError);
867      else
868  	return (&xmlGetGlobalState()->xmlGenericError);
869  }
870  
871  #undef	xmlStructuredError
872  xmlStructuredErrorFunc *
__xmlStructuredError(void)873  __xmlStructuredError(void) {
874      if (IS_MAIN_THREAD)
875  	return (&xmlStructuredError);
876      else
877  	return (&xmlGetGlobalState()->xmlStructuredError);
878  }
879  
880  #undef	xmlGenericErrorContext
881  void * *
__xmlGenericErrorContext(void)882  __xmlGenericErrorContext(void) {
883      if (IS_MAIN_THREAD)
884  	return (&xmlGenericErrorContext);
885      else
886  	return (&xmlGetGlobalState()->xmlGenericErrorContext);
887  }
888  
889  #undef	xmlStructuredErrorContext
890  void * *
__xmlStructuredErrorContext(void)891  __xmlStructuredErrorContext(void) {
892      if (IS_MAIN_THREAD)
893  	return (&xmlStructuredErrorContext);
894      else
895  	return (&xmlGetGlobalState()->xmlStructuredErrorContext);
896  }
897  
898  #undef	xmlGetWarningsDefaultValue
899  int *
__xmlGetWarningsDefaultValue(void)900  __xmlGetWarningsDefaultValue(void) {
901      if (IS_MAIN_THREAD)
902  	return (&xmlGetWarningsDefaultValue);
903      else
904  	return (&xmlGetGlobalState()->xmlGetWarningsDefaultValue);
905  }
xmlThrDefGetWarningsDefaultValue(int v)906  int 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
916  int *
__xmlIndentTreeOutput(void)917  __xmlIndentTreeOutput(void) {
918      if (IS_MAIN_THREAD)
919  	return (&xmlIndentTreeOutput);
920      else
921  	return (&xmlGetGlobalState()->xmlIndentTreeOutput);
922  }
xmlThrDefIndentTreeOutput(int v)923  int 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
933  const char * *
__xmlTreeIndentString(void)934  __xmlTreeIndentString(void) {
935      if (IS_MAIN_THREAD)
936  	return (&xmlTreeIndentString);
937      else
938  	return (&xmlGetGlobalState()->xmlTreeIndentString);
939  }
xmlThrDefTreeIndentString(const char * v)940  const 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
950  int *
__xmlKeepBlanksDefaultValue(void)951  __xmlKeepBlanksDefaultValue(void) {
952      if (IS_MAIN_THREAD)
953  	return (&xmlKeepBlanksDefaultValue);
954      else
955  	return (&xmlGetGlobalState()->xmlKeepBlanksDefaultValue);
956  }
xmlThrDefKeepBlanksDefaultValue(int v)957  int 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
967  int *
__xmlLineNumbersDefaultValue(void)968  __xmlLineNumbersDefaultValue(void) {
969      if (IS_MAIN_THREAD)
970  	return (&xmlLineNumbersDefaultValue);
971      else
972  	return (&xmlGetGlobalState()->xmlLineNumbersDefaultValue);
973  }
xmlThrDefLineNumbersDefaultValue(int v)974  int 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
984  int *
__xmlLoadExtDtdDefaultValue(void)985  __xmlLoadExtDtdDefaultValue(void) {
986      if (IS_MAIN_THREAD)
987  	return (&xmlLoadExtDtdDefaultValue);
988      else
989  	return (&xmlGetGlobalState()->xmlLoadExtDtdDefaultValue);
990  }
xmlThrDefLoadExtDtdDefaultValue(int v)991  int 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
1001  int *
__xmlParserDebugEntities(void)1002  __xmlParserDebugEntities(void) {
1003      if (IS_MAIN_THREAD)
1004  	return (&xmlParserDebugEntities);
1005      else
1006  	return (&xmlGetGlobalState()->xmlParserDebugEntities);
1007  }
xmlThrDefParserDebugEntities(int v)1008  int 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
1018  const char * *
__xmlParserVersion(void)1019  __xmlParserVersion(void) {
1020      if (IS_MAIN_THREAD)
1021  	return (&xmlParserVersion);
1022      else
1023  	return (&xmlGetGlobalState()->xmlParserVersion);
1024  }
1025  
1026  #undef	xmlPedanticParserDefaultValue
1027  int *
__xmlPedanticParserDefaultValue(void)1028  __xmlPedanticParserDefaultValue(void) {
1029      if (IS_MAIN_THREAD)
1030  	return (&xmlPedanticParserDefaultValue);
1031      else
1032  	return (&xmlGetGlobalState()->xmlPedanticParserDefaultValue);
1033  }
xmlThrDefPedanticParserDefaultValue(int v)1034  int 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
1044  int *
__xmlSaveNoEmptyTags(void)1045  __xmlSaveNoEmptyTags(void) {
1046      if (IS_MAIN_THREAD)
1047  	return (&xmlSaveNoEmptyTags);
1048      else
1049  	return (&xmlGetGlobalState()->xmlSaveNoEmptyTags);
1050  }
xmlThrDefSaveNoEmptyTags(int v)1051  int 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
1061  int *
__xmlSubstituteEntitiesDefaultValue(void)1062  __xmlSubstituteEntitiesDefaultValue(void) {
1063      if (IS_MAIN_THREAD)
1064  	return (&xmlSubstituteEntitiesDefaultValue);
1065      else
1066  	return (&xmlGetGlobalState()->xmlSubstituteEntitiesDefaultValue);
1067  }
xmlThrDefSubstituteEntitiesDefaultValue(int v)1068  int 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
1078  xmlRegisterNodeFunc *
__xmlRegisterNodeDefaultValue(void)1079  __xmlRegisterNodeDefaultValue(void) {
1080      if (IS_MAIN_THREAD)
1081  	return (&xmlRegisterNodeDefaultValue);
1082      else
1083  	return (&xmlGetGlobalState()->xmlRegisterNodeDefaultValue);
1084  }
1085  
1086  #undef	xmlDeregisterNodeDefaultValue
1087  xmlDeregisterNodeFunc *
__xmlDeregisterNodeDefaultValue(void)1088  __xmlDeregisterNodeDefaultValue(void) {
1089      if (IS_MAIN_THREAD)
1090  	return (&xmlDeregisterNodeDefaultValue);
1091      else
1092  	return (&xmlGetGlobalState()->xmlDeregisterNodeDefaultValue);
1093  }
1094  
1095  #undef	xmlParserInputBufferCreateFilenameValue
1096  xmlParserInputBufferCreateFilenameFunc *
__xmlParserInputBufferCreateFilenameValue(void)1097  __xmlParserInputBufferCreateFilenameValue(void) {
1098      if (IS_MAIN_THREAD)
1099  	return (&xmlParserInputBufferCreateFilenameValue);
1100      else
1101  	return (&xmlGetGlobalState()->xmlParserInputBufferCreateFilenameValue);
1102  }
1103  
1104  #undef	xmlOutputBufferCreateFilenameValue
1105  xmlOutputBufferCreateFilenameFunc *
__xmlOutputBufferCreateFilenameValue(void)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"
1115