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 = (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
    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)
    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
    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
    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
    600 xmlRegisterNodeDefault(xmlRegisterNodeFunc func)
    601 {
    602     xmlRegisterNodeFunc old = xmlRegisterNodeDefaultValue;
    603 
    604     __xmlRegisterCallbacks = 1;
    605     xmlRegisterNodeDefaultValue = func;
    606     return(old);
    607 }
    608 
    609 xmlRegisterNodeFunc
    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
    633 xmlDeregisterNodeDefault(xmlDeregisterNodeFunc func)
    634 {
    635     xmlDeregisterNodeFunc old = xmlDeregisterNodeDefaultValue;
    636 
    637     __xmlRegisterCallbacks = 1;
    638     xmlDeregisterNodeDefaultValue = func;
    639     return(old);
    640 }
    641 
    642 xmlDeregisterNodeFunc
    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
    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
    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 *
    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 *
    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 *
    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 *
    731 __xmlMalloc(void){
    732     if (IS_MAIN_THREAD)
    733         return (&xmlMalloc);
    734     else
    735     	return (&xmlGetGlobalState()->xmlMalloc);
    736 }
    737 
    738 #undef xmlMallocAtomic
    739 xmlMallocFunc *
    740 __xmlMallocAtomic(void){
    741     if (IS_MAIN_THREAD)
    742         return (&xmlMallocAtomic);
    743     else
    744         return (&xmlGetGlobalState()->xmlMallocAtomic);
    745 }
    746 
    747 #undef xmlRealloc
    748 xmlReallocFunc *
    749 __xmlRealloc(void){
    750     if (IS_MAIN_THREAD)
    751         return (&xmlRealloc);
    752     else
    753         return (&xmlGetGlobalState()->xmlRealloc);
    754 }
    755 
    756 #undef xmlFree
    757 xmlFreeFunc *
    758 __xmlFree(void){
    759     if (IS_MAIN_THREAD)
    760         return (&xmlFree);
    761     else
    762         return (&xmlGetGlobalState()->xmlFree);
    763 }
    764 
    765 xmlStrdupFunc *
    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 *
    784 __oldXMLWDcompatibility(void) {
    785     if (IS_MAIN_THREAD)
    786 	return (&oldXMLWDcompatibility);
    787     else
    788 	return (&xmlGetGlobalState()->oldXMLWDcompatibility);
    789 }
    790 
    791 #undef	xmlBufferAllocScheme
    792 xmlBufferAllocationScheme *
    793 __xmlBufferAllocScheme(void) {
    794     if (IS_MAIN_THREAD)
    795 	return (&xmlBufferAllocScheme);
    796     else
    797 	return (&xmlGetGlobalState()->xmlBufferAllocScheme);
    798 }
    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 *
    810 __xmlDefaultBufferSize(void) {
    811     if (IS_MAIN_THREAD)
    812 	return (&xmlDefaultBufferSize);
    813     else
    814 	return (&xmlGetGlobalState()->xmlDefaultBufferSize);
    815 }
    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 *
    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 *
    838 __xmlDefaultSAXLocator(void) {
    839     if (IS_MAIN_THREAD)
    840 	return (&xmlDefaultSAXLocator);
    841     else
    842 	return (&xmlGetGlobalState()->xmlDefaultSAXLocator);
    843 }
    844 
    845 #undef	xmlDoValidityCheckingDefaultValue
    846 int *
    847 __xmlDoValidityCheckingDefaultValue(void) {
    848     if (IS_MAIN_THREAD)
    849 	return (&xmlDoValidityCheckingDefaultValue);
    850     else
    851 	return (&xmlGetGlobalState()->xmlDoValidityCheckingDefaultValue);
    852 }
    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 *
    864 __xmlGenericError(void) {
    865     if (IS_MAIN_THREAD)
    866 	return (&xmlGenericError);
    867     else
    868 	return (&xmlGetGlobalState()->xmlGenericError);
    869 }
    870 
    871 #undef	xmlStructuredError
    872 xmlStructuredErrorFunc *
    873 __xmlStructuredError(void) {
    874     if (IS_MAIN_THREAD)
    875 	return (&xmlStructuredError);
    876     else
    877 	return (&xmlGetGlobalState()->xmlStructuredError);
    878 }
    879 
    880 #undef	xmlGenericErrorContext
    881 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 * *
    891 __xmlStructuredErrorContext(void) {
    892     if (IS_MAIN_THREAD)
    893 	return (&xmlStructuredErrorContext);
    894     else
    895 	return (&xmlGetGlobalState()->xmlStructuredErrorContext);
    896 }
    897 
    898 #undef	xmlGetWarningsDefaultValue
    899 int *
    900 __xmlGetWarningsDefaultValue(void) {
    901     if (IS_MAIN_THREAD)
    902 	return (&xmlGetWarningsDefaultValue);
    903     else
    904 	return (&xmlGetGlobalState()->xmlGetWarningsDefaultValue);
    905 }
    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 *
    917 __xmlIndentTreeOutput(void) {
    918     if (IS_MAIN_THREAD)
    919 	return (&xmlIndentTreeOutput);
    920     else
    921 	return (&xmlGetGlobalState()->xmlIndentTreeOutput);
    922 }
    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 * *
    934 __xmlTreeIndentString(void) {
    935     if (IS_MAIN_THREAD)
    936 	return (&xmlTreeIndentString);
    937     else
    938 	return (&xmlGetGlobalState()->xmlTreeIndentString);
    939 }
    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 *
    951 __xmlKeepBlanksDefaultValue(void) {
    952     if (IS_MAIN_THREAD)
    953 	return (&xmlKeepBlanksDefaultValue);
    954     else
    955 	return (&xmlGetGlobalState()->xmlKeepBlanksDefaultValue);
    956 }
    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 *
    968 __xmlLineNumbersDefaultValue(void) {
    969     if (IS_MAIN_THREAD)
    970 	return (&xmlLineNumbersDefaultValue);
    971     else
    972 	return (&xmlGetGlobalState()->xmlLineNumbersDefaultValue);
    973 }
    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 *
    985 __xmlLoadExtDtdDefaultValue(void) {
    986     if (IS_MAIN_THREAD)
    987 	return (&xmlLoadExtDtdDefaultValue);
    988     else
    989 	return (&xmlGetGlobalState()->xmlLoadExtDtdDefaultValue);
    990 }
    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 *
   1002 __xmlParserDebugEntities(void) {
   1003     if (IS_MAIN_THREAD)
   1004 	return (&xmlParserDebugEntities);
   1005     else
   1006 	return (&xmlGetGlobalState()->xmlParserDebugEntities);
   1007 }
   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 * *
   1019 __xmlParserVersion(void) {
   1020     if (IS_MAIN_THREAD)
   1021 	return (&xmlParserVersion);
   1022     else
   1023 	return (&xmlGetGlobalState()->xmlParserVersion);
   1024 }
   1025 
   1026 #undef	xmlPedanticParserDefaultValue
   1027 int *
   1028 __xmlPedanticParserDefaultValue(void) {
   1029     if (IS_MAIN_THREAD)
   1030 	return (&xmlPedanticParserDefaultValue);
   1031     else
   1032 	return (&xmlGetGlobalState()->xmlPedanticParserDefaultValue);
   1033 }
   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 *
   1045 __xmlSaveNoEmptyTags(void) {
   1046     if (IS_MAIN_THREAD)
   1047 	return (&xmlSaveNoEmptyTags);
   1048     else
   1049 	return (&xmlGetGlobalState()->xmlSaveNoEmptyTags);
   1050 }
   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 *
   1062 __xmlSubstituteEntitiesDefaultValue(void) {
   1063     if (IS_MAIN_THREAD)
   1064 	return (&xmlSubstituteEntitiesDefaultValue);
   1065     else
   1066 	return (&xmlGetGlobalState()->xmlSubstituteEntitiesDefaultValue);
   1067 }
   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 *
   1079 __xmlRegisterNodeDefaultValue(void) {
   1080     if (IS_MAIN_THREAD)
   1081 	return (&xmlRegisterNodeDefaultValue);
   1082     else
   1083 	return (&xmlGetGlobalState()->xmlRegisterNodeDefaultValue);
   1084 }
   1085 
   1086 #undef	xmlDeregisterNodeDefaultValue
   1087 xmlDeregisterNodeFunc *
   1088 __xmlDeregisterNodeDefaultValue(void) {
   1089     if (IS_MAIN_THREAD)
   1090 	return (&xmlDeregisterNodeDefaultValue);
   1091     else
   1092 	return (&xmlGetGlobalState()->xmlDeregisterNodeDefaultValue);
   1093 }
   1094 
   1095 #undef	xmlParserInputBufferCreateFilenameValue
   1096 xmlParserInputBufferCreateFilenameFunc *
   1097 __xmlParserInputBufferCreateFilenameValue(void) {
   1098     if (IS_MAIN_THREAD)
   1099 	return (&xmlParserInputBufferCreateFilenameValue);
   1100     else
   1101 	return (&xmlGetGlobalState()->xmlParserInputBufferCreateFilenameValue);
   1102 }
   1103 
   1104 #undef	xmlOutputBufferCreateFilenameValue
   1105 xmlOutputBufferCreateFilenameFunc *
   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