third_party/libxml/src/globals.c

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