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  * 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) && defined(LIBXML_SAX1_ENABLED)
 513     inithtmlDefaultSAXHandler(&gs->htmlDefaultSAXHandler);
 514 #endif
 515
 516     gs->oldXMLWDcompatibility = 0;
 517     gs->xmlBufferAllocScheme = xmlBufferAllocSchemeThrDef;
 518     gs->xmlDefaultBufferSize = xmlDefaultBufferSizeThrDef;
 519 #if defined(LIBXML_SAX1_ENABLED) && defined(LIBXML_LEGACY_ENABLED)
 520     initxmlDefaultSAXHandler(&gs->xmlDefaultSAXHandler, 1);
 521 #endif /* LIBXML_SAX1_ENABLED */
 522     gs->xmlDefaultSAXLocator.getPublicId = xmlSAX2GetPublicId;
 523     gs->xmlDefaultSAXLocator.getSystemId = xmlSAX2GetSystemId;
 524     gs->xmlDefaultSAXLocator.getLineNumber = xmlSAX2GetLineNumber;
 525     gs->xmlDefaultSAXLocator.getColumnNumber = xmlSAX2GetColumnNumber;
 526     gs->xmlDoValidityCheckingDefaultValue =
 527          xmlDoValidityCheckingDefaultValueThrDef;
 528 #if defined(DEBUG_MEMORY_LOCATION) | defined(DEBUG_MEMORY)
 529     gs->xmlFree = (xmlFreeFunc) xmlMemFree;
 530     gs->xmlMalloc = (xmlMallocFunc) xmlMemMalloc;
 531     gs->xmlMallocAtomic = (xmlMallocFunc) xmlMemMalloc;
 532     gs->xmlRealloc = (xmlReallocFunc) xmlMemRealloc;
 533     gs->xmlMemStrdup = (xmlStrdupFunc) xmlMemoryStrdup;
 534 #else
 535     gs->xmlFree = (xmlFreeFunc) free;
 536     gs->xmlMalloc = (xmlMallocFunc) malloc;
 537     gs->xmlMallocAtomic = (xmlMallocFunc) malloc;
 538     gs->xmlRealloc = (xmlReallocFunc) realloc;
 539     gs->xmlMemStrdup = (xmlStrdupFunc) xmlStrdup;
 540 #endif
 541     gs->xmlGetWarningsDefaultValue = xmlGetWarningsDefaultValueThrDef;
 542     gs->xmlIndentTreeOutput = xmlIndentTreeOutputThrDef;
 543     gs->xmlTreeIndentString = xmlTreeIndentStringThrDef;
 544     gs->xmlKeepBlanksDefaultValue = xmlKeepBlanksDefaultValueThrDef;
 545     gs->xmlLineNumbersDefaultValue = xmlLineNumbersDefaultValueThrDef;
 546     gs->xmlLoadExtDtdDefaultValue = xmlLoadExtDtdDefaultValueThrDef;
 547     gs->xmlParserDebugEntities = xmlParserDebugEntitiesThrDef;
 548     gs->xmlParserVersion = LIBXML_VERSION_STRING;
 549     gs->xmlPedanticParserDefaultValue = xmlPedanticParserDefaultValueThrDef;
 550     gs->xmlSaveNoEmptyTags = xmlSaveNoEmptyTagsThrDef;
 551     gs->xmlSubstituteEntitiesDefaultValue =
 552         xmlSubstituteEntitiesDefaultValueThrDef;
 553
 554     gs->xmlGenericError = xmlGenericErrorThrDef;
 555     gs->xmlStructuredError = xmlStructuredErrorThrDef;
 556     gs->xmlGenericErrorContext = xmlGenericErrorContextThrDef;
 557     gs->xmlStructuredErrorContext = xmlStructuredErrorContextThrDef;
 558     gs->xmlRegisterNodeDefaultValue = xmlRegisterNodeDefaultValueThrDef;
 559     gs->xmlDeregisterNodeDefaultValue = xmlDeregisterNodeDefaultValueThrDef;
 560
 561         gs->xmlParserInputBufferCreateFilenameValue = xmlParserInputBufferCreateFilenameValueThrDef;
 562         gs->xmlOutputBufferCreateFilenameValue = xmlOutputBufferCreateFilenameValueThrDef;
 563     memset(&gs->xmlLastError, 0, sizeof(xmlError));
 564
 565     xmlMutexUnlock(xmlThrDefMutex);
 566 }
 567
 568 /**
 569  * DOC_DISABLE : we ignore missing doc for the xmlThrDef functions,
 570  *               those are really internal work
 571  */
 572 void
 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"