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