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) && 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" 1115