Annotation of embedaddon/libxml2/globals.c, revision 1.1
1.1 ! misho 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)
! 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"
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to globals.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2