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