1127 lines
29 KiB
C
1127 lines
29 KiB
C
/*
|
|
* globals.c: definition and handling of the set of global variables
|
|
* of the library
|
|
*
|
|
* The bottom of this file is automatically generated by build_glob.py
|
|
* based on the description file global.data
|
|
*
|
|
* See Copyright for the status of this software.
|
|
*
|
|
* Gary Pennington <Gary.Pennington@uk.sun.com>
|
|
* daniel@veillard.com
|
|
*/
|
|
|
|
#define IN_LIBXML
|
|
#include "libxml.h"
|
|
|
|
#ifdef HAVE_STDLIB_H
|
|
#include <stdlib.h>
|
|
#endif
|
|
#include <string.h>
|
|
|
|
#include <libxml/globals.h>
|
|
#include <libxml/xmlmemory.h>
|
|
#include <libxml/threads.h>
|
|
|
|
/* #define DEBUG_GLOBALS */
|
|
|
|
/*
|
|
* Helpful Macro
|
|
*/
|
|
#ifdef LIBXML_THREAD_ENABLED
|
|
#define IS_MAIN_THREAD (xmlIsMainThread())
|
|
#else
|
|
#define IS_MAIN_THREAD 1
|
|
#endif
|
|
|
|
/*
|
|
* Mutex to protect "ForNewThreads" variables
|
|
*/
|
|
static xmlMutexPtr xmlThrDefMutex = NULL;
|
|
|
|
/**
|
|
* xmlInitGlobals:
|
|
*
|
|
* Additional initialisation for multi-threading
|
|
*/
|
|
void xmlInitGlobals(void)
|
|
{
|
|
if (xmlThrDefMutex == NULL)
|
|
xmlThrDefMutex = xmlNewMutex();
|
|
}
|
|
|
|
/**
|
|
* xmlCleanupGlobals:
|
|
*
|
|
* Additional cleanup for multi-threading
|
|
*/
|
|
void xmlCleanupGlobals(void)
|
|
{
|
|
if (xmlThrDefMutex != NULL) {
|
|
xmlFreeMutex(xmlThrDefMutex);
|
|
xmlThrDefMutex = NULL;
|
|
}
|
|
__xmlGlobalInitMutexDestroy();
|
|
}
|
|
|
|
/************************************************************************
|
|
* *
|
|
* All the user accessible global variables of the library *
|
|
* *
|
|
************************************************************************/
|
|
|
|
/*
|
|
* Memory allocation routines
|
|
*/
|
|
#undef xmlFree
|
|
#undef xmlMalloc
|
|
#undef xmlMallocAtomic
|
|
#undef xmlMemStrdup
|
|
#undef xmlRealloc
|
|
|
|
#if defined(DEBUG_MEMORY_LOCATION) || defined(DEBUG_MEMORY)
|
|
xmlFreeFunc xmlFree = (xmlFreeFunc) xmlMemFree;
|
|
xmlMallocFunc xmlMalloc = (xmlMallocFunc) xmlMemMalloc;
|
|
xmlMallocFunc xmlMallocAtomic = (xmlMallocFunc) xmlMemMalloc;
|
|
xmlReallocFunc xmlRealloc = (xmlReallocFunc) xmlMemRealloc;
|
|
xmlStrdupFunc xmlMemStrdup = (xmlStrdupFunc) xmlMemoryStrdup;
|
|
#else
|
|
/**
|
|
* xmlFree:
|
|
* @mem: an already allocated block of memory
|
|
*
|
|
* The variable holding the libxml free() implementation
|
|
*/
|
|
xmlFreeFunc xmlFree = free;
|
|
/**
|
|
* xmlMalloc:
|
|
* @size: the size requested in bytes
|
|
*
|
|
* The variable holding the libxml malloc() implementation
|
|
*
|
|
* Returns a pointer to the newly allocated block or NULL in case of error
|
|
*/
|
|
xmlMallocFunc xmlMalloc = malloc;
|
|
/**
|
|
* xmlMallocAtomic:
|
|
* @size: the size requested in bytes
|
|
*
|
|
* The variable holding the libxml malloc() implementation for atomic
|
|
* data (i.e. blocks not containing pointers), useful when using a
|
|
* garbage collecting allocator.
|
|
*
|
|
* Returns a pointer to the newly allocated block or NULL in case of error
|
|
*/
|
|
xmlMallocFunc xmlMallocAtomic = malloc;
|
|
/**
|
|
* xmlRealloc:
|
|
* @mem: an already allocated block of memory
|
|
* @size: the new size requested in bytes
|
|
*
|
|
* The variable holding the libxml realloc() implementation
|
|
*
|
|
* Returns a pointer to the newly reallocated block or NULL in case of error
|
|
*/
|
|
xmlReallocFunc xmlRealloc = realloc;
|
|
/**
|
|
* xmlPosixStrdup
|
|
* @cur: the input char *
|
|
*
|
|
* a strdup implementation with a type signature matching POSIX
|
|
*
|
|
* Returns a new xmlChar * or NULL
|
|
*/
|
|
static char *
|
|
xmlPosixStrdup(const char *cur) {
|
|
return((char*) xmlCharStrdup(cur));
|
|
}
|
|
/**
|
|
* xmlMemStrdup:
|
|
* @str: a zero terminated string
|
|
*
|
|
* The variable holding the libxml strdup() implementation
|
|
*
|
|
* Returns the copy of the string or NULL in case of error
|
|
*/
|
|
xmlStrdupFunc xmlMemStrdup = xmlPosixStrdup;
|
|
#endif /* DEBUG_MEMORY_LOCATION || DEBUG_MEMORY */
|
|
|
|
#include <libxml/threads.h>
|
|
#include <libxml/globals.h>
|
|
#include <libxml/SAX.h>
|
|
|
|
#undef docbDefaultSAXHandler
|
|
#undef htmlDefaultSAXHandler
|
|
#undef oldXMLWDcompatibility
|
|
#undef xmlBufferAllocScheme
|
|
#undef xmlDefaultBufferSize
|
|
#undef xmlDefaultSAXHandler
|
|
#undef xmlDefaultSAXLocator
|
|
#undef xmlDoValidityCheckingDefaultValue
|
|
#undef xmlGenericError
|
|
#undef xmlStructuredError
|
|
#undef xmlGenericErrorContext
|
|
#undef xmlStructuredErrorContext
|
|
#undef xmlGetWarningsDefaultValue
|
|
#undef xmlIndentTreeOutput
|
|
#undef xmlTreeIndentString
|
|
#undef xmlKeepBlanksDefaultValue
|
|
#undef xmlLineNumbersDefaultValue
|
|
#undef xmlLoadExtDtdDefaultValue
|
|
#undef xmlParserDebugEntities
|
|
#undef xmlParserVersion
|
|
#undef xmlPedanticParserDefaultValue
|
|
#undef xmlSaveNoEmptyTags
|
|
#undef xmlSubstituteEntitiesDefaultValue
|
|
#undef xmlRegisterNodeDefaultValue
|
|
#undef xmlDeregisterNodeDefaultValue
|
|
#undef xmlLastError
|
|
|
|
#undef xmlParserInputBufferCreateFilenameValue
|
|
#undef xmlOutputBufferCreateFilenameValue
|
|
/**
|
|
* xmlParserVersion:
|
|
*
|
|
* Constant string describing the internal version of the library
|
|
*/
|
|
const char *xmlParserVersion = LIBXML_VERSION_STRING LIBXML_VERSION_EXTRA;
|
|
|
|
/**
|
|
* xmlBufferAllocScheme:
|
|
*
|
|
* Global setting, default allocation policy for buffers, default is
|
|
* XML_BUFFER_ALLOC_EXACT
|
|
*/
|
|
xmlBufferAllocationScheme xmlBufferAllocScheme = XML_BUFFER_ALLOC_EXACT;
|
|
static xmlBufferAllocationScheme xmlBufferAllocSchemeThrDef = XML_BUFFER_ALLOC_EXACT;
|
|
/**
|
|
* xmlDefaultBufferSize:
|
|
*
|
|
* Global setting, default buffer size. Default value is BASE_BUFFER_SIZE
|
|
*/
|
|
int xmlDefaultBufferSize = BASE_BUFFER_SIZE;
|
|
static int xmlDefaultBufferSizeThrDef = BASE_BUFFER_SIZE;
|
|
|
|
/*
|
|
* Parser defaults
|
|
*/
|
|
|
|
/**
|
|
* oldXMLWDcompatibility:
|
|
*
|
|
* Global setting, DEPRECATED.
|
|
*/
|
|
int oldXMLWDcompatibility = 0; /* DEPRECATED */
|
|
/**
|
|
* xmlParserDebugEntities:
|
|
*
|
|
* Global setting, asking the parser to print out debugging information.
|
|
* while handling entities.
|
|
* Disabled by default
|
|
*/
|
|
int xmlParserDebugEntities = 0;
|
|
static int xmlParserDebugEntitiesThrDef = 0;
|
|
/**
|
|
* xmlDoValidityCheckingDefaultValue:
|
|
*
|
|
* Global setting, indicate that the parser should work in validating mode.
|
|
* Disabled by default.
|
|
*/
|
|
int xmlDoValidityCheckingDefaultValue = 0;
|
|
static int xmlDoValidityCheckingDefaultValueThrDef = 0;
|
|
/**
|
|
* xmlGetWarningsDefaultValue:
|
|
*
|
|
* Global setting, indicate that the parser should provide warnings.
|
|
* Activated by default.
|
|
*/
|
|
int xmlGetWarningsDefaultValue = 1;
|
|
static int xmlGetWarningsDefaultValueThrDef = 1;
|
|
/**
|
|
* xmlLoadExtDtdDefaultValue:
|
|
*
|
|
* Global setting, indicate that the parser should load DTD while not
|
|
* validating.
|
|
* Disabled by default.
|
|
*/
|
|
int xmlLoadExtDtdDefaultValue = 0;
|
|
static int xmlLoadExtDtdDefaultValueThrDef = 0;
|
|
/**
|
|
* xmlPedanticParserDefaultValue:
|
|
*
|
|
* Global setting, indicate that the parser be pedantic
|
|
* Disabled by default.
|
|
*/
|
|
int xmlPedanticParserDefaultValue = 0;
|
|
static int xmlPedanticParserDefaultValueThrDef = 0;
|
|
/**
|
|
* xmlLineNumbersDefaultValue:
|
|
*
|
|
* Global setting, indicate that the parser should store the line number
|
|
* in the content field of elements in the DOM tree.
|
|
* Disabled by default since this may not be safe for old classes of
|
|
* application.
|
|
*/
|
|
int xmlLineNumbersDefaultValue = 0;
|
|
static int xmlLineNumbersDefaultValueThrDef = 0;
|
|
/**
|
|
* xmlKeepBlanksDefaultValue:
|
|
*
|
|
* Global setting, indicate that the parser should keep all blanks
|
|
* nodes found in the content
|
|
* Activated by default, this is actually needed to have the parser
|
|
* conformant to the XML Recommendation, however the option is kept
|
|
* for some applications since this was libxml1 default behaviour.
|
|
*/
|
|
int xmlKeepBlanksDefaultValue = 1;
|
|
static int xmlKeepBlanksDefaultValueThrDef = 1;
|
|
/**
|
|
* xmlSubstituteEntitiesDefaultValue:
|
|
*
|
|
* Global setting, indicate that the parser should not generate entity
|
|
* references but replace them with the actual content of the entity
|
|
* Disabled by default, this should be activated when using XPath since
|
|
* the XPath data model requires entities replacement and the XPath
|
|
* engine does not handle entities references transparently.
|
|
*/
|
|
int xmlSubstituteEntitiesDefaultValue = 0;
|
|
static int xmlSubstituteEntitiesDefaultValueThrDef = 0;
|
|
|
|
xmlRegisterNodeFunc xmlRegisterNodeDefaultValue = NULL;
|
|
static xmlRegisterNodeFunc xmlRegisterNodeDefaultValueThrDef = NULL;
|
|
xmlDeregisterNodeFunc xmlDeregisterNodeDefaultValue = NULL;
|
|
static xmlDeregisterNodeFunc xmlDeregisterNodeDefaultValueThrDef = NULL;
|
|
|
|
xmlParserInputBufferCreateFilenameFunc xmlParserInputBufferCreateFilenameValue = NULL;
|
|
static xmlParserInputBufferCreateFilenameFunc xmlParserInputBufferCreateFilenameValueThrDef = NULL;
|
|
|
|
xmlOutputBufferCreateFilenameFunc xmlOutputBufferCreateFilenameValue = NULL;
|
|
static xmlOutputBufferCreateFilenameFunc xmlOutputBufferCreateFilenameValueThrDef = NULL;
|
|
|
|
/*
|
|
* Error handling
|
|
*/
|
|
|
|
/* xmlGenericErrorFunc xmlGenericError = xmlGenericErrorDefaultFunc; */
|
|
/* Must initialize xmlGenericError in xmlInitParser */
|
|
void XMLCDECL xmlGenericErrorDefaultFunc (void *ctx ATTRIBUTE_UNUSED,
|
|
const char *msg,
|
|
...);
|
|
/**
|
|
* xmlGenericError:
|
|
*
|
|
* Global setting: function used for generic error callbacks
|
|
*/
|
|
xmlGenericErrorFunc xmlGenericError = xmlGenericErrorDefaultFunc;
|
|
static xmlGenericErrorFunc xmlGenericErrorThrDef = xmlGenericErrorDefaultFunc;
|
|
/**
|
|
* xmlStructuredError:
|
|
*
|
|
* Global setting: function used for structured error callbacks
|
|
*/
|
|
xmlStructuredErrorFunc xmlStructuredError = NULL;
|
|
static xmlStructuredErrorFunc xmlStructuredErrorThrDef = NULL;
|
|
/**
|
|
* xmlGenericErrorContext:
|
|
*
|
|
* Global setting passed to generic error callbacks
|
|
*/
|
|
void *xmlGenericErrorContext = NULL;
|
|
static void *xmlGenericErrorContextThrDef = NULL;
|
|
/**
|
|
* xmlStructuredErrorContext:
|
|
*
|
|
* Global setting passed to structured error callbacks
|
|
*/
|
|
void *xmlStructuredErrorContext = NULL;
|
|
static void *xmlStructuredErrorContextThrDef = NULL;
|
|
xmlError xmlLastError;
|
|
|
|
/*
|
|
* output defaults
|
|
*/
|
|
/**
|
|
* xmlIndentTreeOutput:
|
|
*
|
|
* Global setting, asking the serializer to indent the output tree by default
|
|
* Enabled by default
|
|
*/
|
|
int xmlIndentTreeOutput = 1;
|
|
static int xmlIndentTreeOutputThrDef = 1;
|
|
|
|
/**
|
|
* xmlTreeIndentString:
|
|
*
|
|
* The string used to do one-level indent. By default is equal to " " (two spaces)
|
|
*/
|
|
const char *xmlTreeIndentString = " ";
|
|
static const char *xmlTreeIndentStringThrDef = " ";
|
|
|
|
/**
|
|
* xmlSaveNoEmptyTags:
|
|
*
|
|
* Global setting, asking the serializer to not output empty tags
|
|
* as <empty/> but <empty></empty>. those two forms are indistinguishable
|
|
* once parsed.
|
|
* Disabled by default
|
|
*/
|
|
int xmlSaveNoEmptyTags = 0;
|
|
static int xmlSaveNoEmptyTagsThrDef = 0;
|
|
|
|
#ifdef LIBXML_SAX1_ENABLED
|
|
/**
|
|
* xmlDefaultSAXHandler:
|
|
*
|
|
* Default SAX version1 handler for XML, builds the DOM tree
|
|
*/
|
|
xmlSAXHandlerV1 xmlDefaultSAXHandler = {
|
|
xmlSAX2InternalSubset,
|
|
xmlSAX2IsStandalone,
|
|
xmlSAX2HasInternalSubset,
|
|
xmlSAX2HasExternalSubset,
|
|
xmlSAX2ResolveEntity,
|
|
xmlSAX2GetEntity,
|
|
xmlSAX2EntityDecl,
|
|
xmlSAX2NotationDecl,
|
|
xmlSAX2AttributeDecl,
|
|
xmlSAX2ElementDecl,
|
|
xmlSAX2UnparsedEntityDecl,
|
|
xmlSAX2SetDocumentLocator,
|
|
xmlSAX2StartDocument,
|
|
xmlSAX2EndDocument,
|
|
xmlSAX2StartElement,
|
|
xmlSAX2EndElement,
|
|
xmlSAX2Reference,
|
|
xmlSAX2Characters,
|
|
xmlSAX2Characters,
|
|
xmlSAX2ProcessingInstruction,
|
|
xmlSAX2Comment,
|
|
xmlParserWarning,
|
|
xmlParserError,
|
|
xmlParserError,
|
|
xmlSAX2GetParameterEntity,
|
|
xmlSAX2CDataBlock,
|
|
xmlSAX2ExternalSubset,
|
|
0,
|
|
};
|
|
#endif /* LIBXML_SAX1_ENABLED */
|
|
|
|
/**
|
|
* xmlDefaultSAXLocator:
|
|
*
|
|
* The default SAX Locator
|
|
* { getPublicId, getSystemId, getLineNumber, getColumnNumber}
|
|
*/
|
|
xmlSAXLocator xmlDefaultSAXLocator = {
|
|
xmlSAX2GetPublicId,
|
|
xmlSAX2GetSystemId,
|
|
xmlSAX2GetLineNumber,
|
|
xmlSAX2GetColumnNumber
|
|
};
|
|
|
|
#ifdef LIBXML_HTML_ENABLED
|
|
/**
|
|
* htmlDefaultSAXHandler:
|
|
*
|
|
* Default old SAX v1 handler for HTML, builds the DOM tree
|
|
*/
|
|
xmlSAXHandlerV1 htmlDefaultSAXHandler = {
|
|
xmlSAX2InternalSubset,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
xmlSAX2GetEntity,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
xmlSAX2SetDocumentLocator,
|
|
xmlSAX2StartDocument,
|
|
xmlSAX2EndDocument,
|
|
xmlSAX2StartElement,
|
|
xmlSAX2EndElement,
|
|
NULL,
|
|
xmlSAX2Characters,
|
|
xmlSAX2IgnorableWhitespace,
|
|
xmlSAX2ProcessingInstruction,
|
|
xmlSAX2Comment,
|
|
xmlParserWarning,
|
|
xmlParserError,
|
|
xmlParserError,
|
|
xmlSAX2GetParameterEntity,
|
|
xmlSAX2CDataBlock,
|
|
NULL,
|
|
0,
|
|
};
|
|
#endif /* LIBXML_HTML_ENABLED */
|
|
|
|
#ifdef LIBXML_DOCB_ENABLED
|
|
/**
|
|
* docbDefaultSAXHandler:
|
|
*
|
|
* Default old SAX v1 handler for SGML DocBook, builds the DOM tree
|
|
*/
|
|
xmlSAXHandlerV1 docbDefaultSAXHandler = {
|
|
xmlSAX2InternalSubset,
|
|
xmlSAX2IsStandalone,
|
|
xmlSAX2HasInternalSubset,
|
|
xmlSAX2HasExternalSubset,
|
|
xmlSAX2ResolveEntity,
|
|
xmlSAX2GetEntity,
|
|
xmlSAX2EntityDecl,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
xmlSAX2SetDocumentLocator,
|
|
xmlSAX2StartDocument,
|
|
xmlSAX2EndDocument,
|
|
xmlSAX2StartElement,
|
|
xmlSAX2EndElement,
|
|
xmlSAX2Reference,
|
|
xmlSAX2Characters,
|
|
xmlSAX2IgnorableWhitespace,
|
|
NULL,
|
|
xmlSAX2Comment,
|
|
xmlParserWarning,
|
|
xmlParserError,
|
|
xmlParserError,
|
|
xmlSAX2GetParameterEntity,
|
|
NULL,
|
|
NULL,
|
|
0,
|
|
};
|
|
#endif /* LIBXML_DOCB_ENABLED */
|
|
|
|
/**
|
|
* xmlInitializeGlobalState:
|
|
* @gs: a pointer to a newly allocated global state
|
|
*
|
|
* xmlInitializeGlobalState() initialize a global state with all the
|
|
* default values of the library.
|
|
*/
|
|
void
|
|
xmlInitializeGlobalState(xmlGlobalStatePtr gs)
|
|
{
|
|
#ifdef DEBUG_GLOBALS
|
|
fprintf(stderr, "Initializing globals at %lu for thread %d\n",
|
|
(unsigned long) gs, xmlGetThreadId());
|
|
#endif
|
|
|
|
/*
|
|
* Perform initialization as required by libxml
|
|
*/
|
|
if (xmlThrDefMutex == NULL)
|
|
xmlInitGlobals();
|
|
|
|
xmlMutexLock(xmlThrDefMutex);
|
|
|
|
#if defined(LIBXML_DOCB_ENABLED) && defined(LIBXML_LEGACY_ENABLED) && defined(LIBXML_SAX1_ENABLED)
|
|
initdocbDefaultSAXHandler(&gs->docbDefaultSAXHandler);
|
|
#endif
|
|
#if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_LEGACY_ENABLED) && defined(LIBXML_SAX1_ENABLED)
|
|
inithtmlDefaultSAXHandler(&gs->htmlDefaultSAXHandler);
|
|
#endif
|
|
|
|
gs->oldXMLWDcompatibility = 0;
|
|
gs->xmlBufferAllocScheme = xmlBufferAllocSchemeThrDef;
|
|
gs->xmlDefaultBufferSize = xmlDefaultBufferSizeThrDef;
|
|
#if defined(LIBXML_SAX1_ENABLED) && defined(LIBXML_LEGACY_ENABLED)
|
|
initxmlDefaultSAXHandler(&gs->xmlDefaultSAXHandler, 1);
|
|
#endif /* LIBXML_SAX1_ENABLED */
|
|
gs->xmlDefaultSAXLocator.getPublicId = xmlSAX2GetPublicId;
|
|
gs->xmlDefaultSAXLocator.getSystemId = xmlSAX2GetSystemId;
|
|
gs->xmlDefaultSAXLocator.getLineNumber = xmlSAX2GetLineNumber;
|
|
gs->xmlDefaultSAXLocator.getColumnNumber = xmlSAX2GetColumnNumber;
|
|
gs->xmlDoValidityCheckingDefaultValue =
|
|
xmlDoValidityCheckingDefaultValueThrDef;
|
|
#if defined(DEBUG_MEMORY_LOCATION) | defined(DEBUG_MEMORY)
|
|
gs->xmlFree = (xmlFreeFunc) xmlMemFree;
|
|
gs->xmlMalloc = (xmlMallocFunc) xmlMemMalloc;
|
|
gs->xmlMallocAtomic = (xmlMallocFunc) xmlMemMalloc;
|
|
gs->xmlRealloc = (xmlReallocFunc) xmlMemRealloc;
|
|
gs->xmlMemStrdup = (xmlStrdupFunc) xmlMemoryStrdup;
|
|
#else
|
|
gs->xmlFree = (xmlFreeFunc) free;
|
|
gs->xmlMalloc = (xmlMallocFunc) malloc;
|
|
gs->xmlMallocAtomic = (xmlMallocFunc) malloc;
|
|
gs->xmlRealloc = (xmlReallocFunc) realloc;
|
|
gs->xmlMemStrdup = (xmlStrdupFunc) xmlStrdup;
|
|
#endif
|
|
gs->xmlGetWarningsDefaultValue = xmlGetWarningsDefaultValueThrDef;
|
|
gs->xmlIndentTreeOutput = xmlIndentTreeOutputThrDef;
|
|
gs->xmlTreeIndentString = xmlTreeIndentStringThrDef;
|
|
gs->xmlKeepBlanksDefaultValue = xmlKeepBlanksDefaultValueThrDef;
|
|
gs->xmlLineNumbersDefaultValue = xmlLineNumbersDefaultValueThrDef;
|
|
gs->xmlLoadExtDtdDefaultValue = xmlLoadExtDtdDefaultValueThrDef;
|
|
gs->xmlParserDebugEntities = xmlParserDebugEntitiesThrDef;
|
|
gs->xmlParserVersion = LIBXML_VERSION_STRING;
|
|
gs->xmlPedanticParserDefaultValue = xmlPedanticParserDefaultValueThrDef;
|
|
gs->xmlSaveNoEmptyTags = xmlSaveNoEmptyTagsThrDef;
|
|
gs->xmlSubstituteEntitiesDefaultValue =
|
|
xmlSubstituteEntitiesDefaultValueThrDef;
|
|
|
|
gs->xmlGenericError = xmlGenericErrorThrDef;
|
|
gs->xmlStructuredError = xmlStructuredErrorThrDef;
|
|
gs->xmlGenericErrorContext = xmlGenericErrorContextThrDef;
|
|
gs->xmlStructuredErrorContext = xmlStructuredErrorContextThrDef;
|
|
gs->xmlRegisterNodeDefaultValue = xmlRegisterNodeDefaultValueThrDef;
|
|
gs->xmlDeregisterNodeDefaultValue = xmlDeregisterNodeDefaultValueThrDef;
|
|
|
|
gs->xmlParserInputBufferCreateFilenameValue = xmlParserInputBufferCreateFilenameValueThrDef;
|
|
gs->xmlOutputBufferCreateFilenameValue = xmlOutputBufferCreateFilenameValueThrDef;
|
|
memset(&gs->xmlLastError, 0, sizeof(xmlError));
|
|
|
|
xmlMutexUnlock(xmlThrDefMutex);
|
|
}
|
|
|
|
/**
|
|
* DOC_DISABLE : we ignore missing doc for the xmlThrDef functions,
|
|
* those are really internal work
|
|
*/
|
|
void
|
|
xmlThrDefSetGenericErrorFunc(void *ctx, xmlGenericErrorFunc handler) {
|
|
xmlMutexLock(xmlThrDefMutex);
|
|
xmlGenericErrorContextThrDef = ctx;
|
|
if (handler != NULL)
|
|
xmlGenericErrorThrDef = handler;
|
|
else
|
|
xmlGenericErrorThrDef = xmlGenericErrorDefaultFunc;
|
|
xmlMutexUnlock(xmlThrDefMutex);
|
|
}
|
|
|
|
void
|
|
xmlThrDefSetStructuredErrorFunc(void *ctx, xmlStructuredErrorFunc handler) {
|
|
xmlMutexLock(xmlThrDefMutex);
|
|
xmlStructuredErrorContextThrDef = ctx;
|
|
xmlStructuredErrorThrDef = handler;
|
|
xmlMutexUnlock(xmlThrDefMutex);
|
|
}
|
|
|
|
/**
|
|
* xmlRegisterNodeDefault:
|
|
* @func: function pointer to the new RegisterNodeFunc
|
|
*
|
|
* Registers a callback for node creation
|
|
*
|
|
* Returns the old value of the registration function
|
|
*/
|
|
xmlRegisterNodeFunc
|
|
xmlRegisterNodeDefault(xmlRegisterNodeFunc func)
|
|
{
|
|
xmlRegisterNodeFunc old = xmlRegisterNodeDefaultValue;
|
|
|
|
__xmlRegisterCallbacks = 1;
|
|
xmlRegisterNodeDefaultValue = func;
|
|
return(old);
|
|
}
|
|
|
|
xmlRegisterNodeFunc
|
|
xmlThrDefRegisterNodeDefault(xmlRegisterNodeFunc func)
|
|
{
|
|
xmlRegisterNodeFunc old;
|
|
|
|
xmlMutexLock(xmlThrDefMutex);
|
|
old = xmlRegisterNodeDefaultValueThrDef;
|
|
|
|
__xmlRegisterCallbacks = 1;
|
|
xmlRegisterNodeDefaultValueThrDef = func;
|
|
xmlMutexUnlock(xmlThrDefMutex);
|
|
|
|
return(old);
|
|
}
|
|
|
|
/**
|
|
* xmlDeregisterNodeDefault:
|
|
* @func: function pointer to the new DeregisterNodeFunc
|
|
*
|
|
* Registers a callback for node destruction
|
|
*
|
|
* Returns the previous value of the deregistration function
|
|
*/
|
|
xmlDeregisterNodeFunc
|
|
xmlDeregisterNodeDefault(xmlDeregisterNodeFunc func)
|
|
{
|
|
xmlDeregisterNodeFunc old = xmlDeregisterNodeDefaultValue;
|
|
|
|
__xmlRegisterCallbacks = 1;
|
|
xmlDeregisterNodeDefaultValue = func;
|
|
return(old);
|
|
}
|
|
|
|
xmlDeregisterNodeFunc
|
|
xmlThrDefDeregisterNodeDefault(xmlDeregisterNodeFunc func)
|
|
{
|
|
xmlDeregisterNodeFunc old;
|
|
|
|
xmlMutexLock(xmlThrDefMutex);
|
|
old = xmlDeregisterNodeDefaultValueThrDef;
|
|
|
|
__xmlRegisterCallbacks = 1;
|
|
xmlDeregisterNodeDefaultValueThrDef = func;
|
|
xmlMutexUnlock(xmlThrDefMutex);
|
|
|
|
return(old);
|
|
}
|
|
|
|
xmlParserInputBufferCreateFilenameFunc
|
|
xmlThrDefParserInputBufferCreateFilenameDefault(xmlParserInputBufferCreateFilenameFunc func)
|
|
{
|
|
xmlParserInputBufferCreateFilenameFunc old;
|
|
|
|
xmlMutexLock(xmlThrDefMutex);
|
|
old = xmlParserInputBufferCreateFilenameValueThrDef;
|
|
if (old == NULL) {
|
|
old = __xmlParserInputBufferCreateFilename;
|
|
}
|
|
|
|
xmlParserInputBufferCreateFilenameValueThrDef = func;
|
|
xmlMutexUnlock(xmlThrDefMutex);
|
|
|
|
return(old);
|
|
}
|
|
|
|
xmlOutputBufferCreateFilenameFunc
|
|
xmlThrDefOutputBufferCreateFilenameDefault(xmlOutputBufferCreateFilenameFunc func)
|
|
{
|
|
xmlOutputBufferCreateFilenameFunc old;
|
|
|
|
xmlMutexLock(xmlThrDefMutex);
|
|
old = xmlOutputBufferCreateFilenameValueThrDef;
|
|
#ifdef LIBXML_OUTPUT_ENABLED
|
|
if (old == NULL) {
|
|
old = __xmlOutputBufferCreateFilename;
|
|
}
|
|
#endif
|
|
xmlOutputBufferCreateFilenameValueThrDef = func;
|
|
xmlMutexUnlock(xmlThrDefMutex);
|
|
|
|
return(old);
|
|
}
|
|
|
|
#ifdef LIBXML_DOCB_ENABLED
|
|
#undef docbDefaultSAXHandler
|
|
xmlSAXHandlerV1 *
|
|
__docbDefaultSAXHandler(void) {
|
|
if (IS_MAIN_THREAD)
|
|
return (&docbDefaultSAXHandler);
|
|
else
|
|
return (&xmlGetGlobalState()->docbDefaultSAXHandler);
|
|
}
|
|
#endif
|
|
|
|
#ifdef LIBXML_HTML_ENABLED
|
|
#undef htmlDefaultSAXHandler
|
|
xmlSAXHandlerV1 *
|
|
__htmlDefaultSAXHandler(void) {
|
|
if (IS_MAIN_THREAD)
|
|
return (&htmlDefaultSAXHandler);
|
|
else
|
|
return (&xmlGetGlobalState()->htmlDefaultSAXHandler);
|
|
}
|
|
#endif
|
|
|
|
#undef xmlLastError
|
|
xmlError *
|
|
__xmlLastError(void) {
|
|
if (IS_MAIN_THREAD)
|
|
return (&xmlLastError);
|
|
else
|
|
return (&xmlGetGlobalState()->xmlLastError);
|
|
}
|
|
|
|
/*
|
|
* The following memory routines were apparently lost at some point,
|
|
* and were re-inserted at this point on June 10, 2004. Hope it's
|
|
* the right place for them :-)
|
|
*/
|
|
#if defined(LIBXML_THREAD_ALLOC_ENABLED) && defined(LIBXML_THREAD_ENABLED)
|
|
#undef xmlMalloc
|
|
xmlMallocFunc *
|
|
__xmlMalloc(void){
|
|
if (IS_MAIN_THREAD)
|
|
return (&xmlMalloc);
|
|
else
|
|
return (&xmlGetGlobalState()->xmlMalloc);
|
|
}
|
|
|
|
#undef xmlMallocAtomic
|
|
xmlMallocFunc *
|
|
__xmlMallocAtomic(void){
|
|
if (IS_MAIN_THREAD)
|
|
return (&xmlMallocAtomic);
|
|
else
|
|
return (&xmlGetGlobalState()->xmlMallocAtomic);
|
|
}
|
|
|
|
#undef xmlRealloc
|
|
xmlReallocFunc *
|
|
__xmlRealloc(void){
|
|
if (IS_MAIN_THREAD)
|
|
return (&xmlRealloc);
|
|
else
|
|
return (&xmlGetGlobalState()->xmlRealloc);
|
|
}
|
|
|
|
#undef xmlFree
|
|
xmlFreeFunc *
|
|
__xmlFree(void){
|
|
if (IS_MAIN_THREAD)
|
|
return (&xmlFree);
|
|
else
|
|
return (&xmlGetGlobalState()->xmlFree);
|
|
}
|
|
|
|
xmlStrdupFunc *
|
|
__xmlMemStrdup(void){
|
|
if (IS_MAIN_THREAD)
|
|
return (&xmlMemStrdup);
|
|
else
|
|
return (&xmlGetGlobalState()->xmlMemStrdup);
|
|
}
|
|
|
|
#endif
|
|
|
|
/*
|
|
* Everything starting from the line below is
|
|
* Automatically generated by build_glob.py.
|
|
* Do not modify the previous line.
|
|
*/
|
|
|
|
|
|
#undef oldXMLWDcompatibility
|
|
int *
|
|
__oldXMLWDcompatibility(void) {
|
|
if (IS_MAIN_THREAD)
|
|
return (&oldXMLWDcompatibility);
|
|
else
|
|
return (&xmlGetGlobalState()->oldXMLWDcompatibility);
|
|
}
|
|
|
|
#undef xmlBufferAllocScheme
|
|
xmlBufferAllocationScheme *
|
|
__xmlBufferAllocScheme(void) {
|
|
if (IS_MAIN_THREAD)
|
|
return (&xmlBufferAllocScheme);
|
|
else
|
|
return (&xmlGetGlobalState()->xmlBufferAllocScheme);
|
|
}
|
|
xmlBufferAllocationScheme xmlThrDefBufferAllocScheme(xmlBufferAllocationScheme v) {
|
|
xmlBufferAllocationScheme ret;
|
|
xmlMutexLock(xmlThrDefMutex);
|
|
ret = xmlBufferAllocSchemeThrDef;
|
|
xmlBufferAllocSchemeThrDef = v;
|
|
xmlMutexUnlock(xmlThrDefMutex);
|
|
return ret;
|
|
}
|
|
|
|
#undef xmlDefaultBufferSize
|
|
int *
|
|
__xmlDefaultBufferSize(void) {
|
|
if (IS_MAIN_THREAD)
|
|
return (&xmlDefaultBufferSize);
|
|
else
|
|
return (&xmlGetGlobalState()->xmlDefaultBufferSize);
|
|
}
|
|
int xmlThrDefDefaultBufferSize(int v) {
|
|
int ret;
|
|
xmlMutexLock(xmlThrDefMutex);
|
|
ret = xmlDefaultBufferSizeThrDef;
|
|
xmlDefaultBufferSizeThrDef = v;
|
|
xmlMutexUnlock(xmlThrDefMutex);
|
|
return ret;
|
|
}
|
|
|
|
#ifdef LIBXML_SAX1_ENABLED
|
|
#undef xmlDefaultSAXHandler
|
|
xmlSAXHandlerV1 *
|
|
__xmlDefaultSAXHandler(void) {
|
|
if (IS_MAIN_THREAD)
|
|
return (&xmlDefaultSAXHandler);
|
|
else
|
|
return (&xmlGetGlobalState()->xmlDefaultSAXHandler);
|
|
}
|
|
#endif /* LIBXML_SAX1_ENABLED */
|
|
|
|
#undef xmlDefaultSAXLocator
|
|
xmlSAXLocator *
|
|
__xmlDefaultSAXLocator(void) {
|
|
if (IS_MAIN_THREAD)
|
|
return (&xmlDefaultSAXLocator);
|
|
else
|
|
return (&xmlGetGlobalState()->xmlDefaultSAXLocator);
|
|
}
|
|
|
|
#undef xmlDoValidityCheckingDefaultValue
|
|
int *
|
|
__xmlDoValidityCheckingDefaultValue(void) {
|
|
if (IS_MAIN_THREAD)
|
|
return (&xmlDoValidityCheckingDefaultValue);
|
|
else
|
|
return (&xmlGetGlobalState()->xmlDoValidityCheckingDefaultValue);
|
|
}
|
|
int xmlThrDefDoValidityCheckingDefaultValue(int v) {
|
|
int ret;
|
|
xmlMutexLock(xmlThrDefMutex);
|
|
ret = xmlDoValidityCheckingDefaultValueThrDef;
|
|
xmlDoValidityCheckingDefaultValueThrDef = v;
|
|
xmlMutexUnlock(xmlThrDefMutex);
|
|
return ret;
|
|
}
|
|
|
|
#undef xmlGenericError
|
|
xmlGenericErrorFunc *
|
|
__xmlGenericError(void) {
|
|
if (IS_MAIN_THREAD)
|
|
return (&xmlGenericError);
|
|
else
|
|
return (&xmlGetGlobalState()->xmlGenericError);
|
|
}
|
|
|
|
#undef xmlStructuredError
|
|
xmlStructuredErrorFunc *
|
|
__xmlStructuredError(void) {
|
|
if (IS_MAIN_THREAD)
|
|
return (&xmlStructuredError);
|
|
else
|
|
return (&xmlGetGlobalState()->xmlStructuredError);
|
|
}
|
|
|
|
#undef xmlGenericErrorContext
|
|
void * *
|
|
__xmlGenericErrorContext(void) {
|
|
if (IS_MAIN_THREAD)
|
|
return (&xmlGenericErrorContext);
|
|
else
|
|
return (&xmlGetGlobalState()->xmlGenericErrorContext);
|
|
}
|
|
|
|
#undef xmlStructuredErrorContext
|
|
void * *
|
|
__xmlStructuredErrorContext(void) {
|
|
if (IS_MAIN_THREAD)
|
|
return (&xmlStructuredErrorContext);
|
|
else
|
|
return (&xmlGetGlobalState()->xmlStructuredErrorContext);
|
|
}
|
|
|
|
#undef xmlGetWarningsDefaultValue
|
|
int *
|
|
__xmlGetWarningsDefaultValue(void) {
|
|
if (IS_MAIN_THREAD)
|
|
return (&xmlGetWarningsDefaultValue);
|
|
else
|
|
return (&xmlGetGlobalState()->xmlGetWarningsDefaultValue);
|
|
}
|
|
int xmlThrDefGetWarningsDefaultValue(int v) {
|
|
int ret;
|
|
xmlMutexLock(xmlThrDefMutex);
|
|
ret = xmlGetWarningsDefaultValueThrDef;
|
|
xmlGetWarningsDefaultValueThrDef = v;
|
|
xmlMutexUnlock(xmlThrDefMutex);
|
|
return ret;
|
|
}
|
|
|
|
#undef xmlIndentTreeOutput
|
|
int *
|
|
__xmlIndentTreeOutput(void) {
|
|
if (IS_MAIN_THREAD)
|
|
return (&xmlIndentTreeOutput);
|
|
else
|
|
return (&xmlGetGlobalState()->xmlIndentTreeOutput);
|
|
}
|
|
int xmlThrDefIndentTreeOutput(int v) {
|
|
int ret;
|
|
xmlMutexLock(xmlThrDefMutex);
|
|
ret = xmlIndentTreeOutputThrDef;
|
|
xmlIndentTreeOutputThrDef = v;
|
|
xmlMutexUnlock(xmlThrDefMutex);
|
|
return ret;
|
|
}
|
|
|
|
#undef xmlTreeIndentString
|
|
const char * *
|
|
__xmlTreeIndentString(void) {
|
|
if (IS_MAIN_THREAD)
|
|
return (&xmlTreeIndentString);
|
|
else
|
|
return (&xmlGetGlobalState()->xmlTreeIndentString);
|
|
}
|
|
const char * xmlThrDefTreeIndentString(const char * v) {
|
|
const char * ret;
|
|
xmlMutexLock(xmlThrDefMutex);
|
|
ret = xmlTreeIndentStringThrDef;
|
|
xmlTreeIndentStringThrDef = v;
|
|
xmlMutexUnlock(xmlThrDefMutex);
|
|
return ret;
|
|
}
|
|
|
|
#undef xmlKeepBlanksDefaultValue
|
|
int *
|
|
__xmlKeepBlanksDefaultValue(void) {
|
|
if (IS_MAIN_THREAD)
|
|
return (&xmlKeepBlanksDefaultValue);
|
|
else
|
|
return (&xmlGetGlobalState()->xmlKeepBlanksDefaultValue);
|
|
}
|
|
int xmlThrDefKeepBlanksDefaultValue(int v) {
|
|
int ret;
|
|
xmlMutexLock(xmlThrDefMutex);
|
|
ret = xmlKeepBlanksDefaultValueThrDef;
|
|
xmlKeepBlanksDefaultValueThrDef = v;
|
|
xmlMutexUnlock(xmlThrDefMutex);
|
|
return ret;
|
|
}
|
|
|
|
#undef xmlLineNumbersDefaultValue
|
|
int *
|
|
__xmlLineNumbersDefaultValue(void) {
|
|
if (IS_MAIN_THREAD)
|
|
return (&xmlLineNumbersDefaultValue);
|
|
else
|
|
return (&xmlGetGlobalState()->xmlLineNumbersDefaultValue);
|
|
}
|
|
int xmlThrDefLineNumbersDefaultValue(int v) {
|
|
int ret;
|
|
xmlMutexLock(xmlThrDefMutex);
|
|
ret = xmlLineNumbersDefaultValueThrDef;
|
|
xmlLineNumbersDefaultValueThrDef = v;
|
|
xmlMutexUnlock(xmlThrDefMutex);
|
|
return ret;
|
|
}
|
|
|
|
#undef xmlLoadExtDtdDefaultValue
|
|
int *
|
|
__xmlLoadExtDtdDefaultValue(void) {
|
|
if (IS_MAIN_THREAD)
|
|
return (&xmlLoadExtDtdDefaultValue);
|
|
else
|
|
return (&xmlGetGlobalState()->xmlLoadExtDtdDefaultValue);
|
|
}
|
|
int xmlThrDefLoadExtDtdDefaultValue(int v) {
|
|
int ret;
|
|
xmlMutexLock(xmlThrDefMutex);
|
|
ret = xmlLoadExtDtdDefaultValueThrDef;
|
|
xmlLoadExtDtdDefaultValueThrDef = v;
|
|
xmlMutexUnlock(xmlThrDefMutex);
|
|
return ret;
|
|
}
|
|
|
|
#undef xmlParserDebugEntities
|
|
int *
|
|
__xmlParserDebugEntities(void) {
|
|
if (IS_MAIN_THREAD)
|
|
return (&xmlParserDebugEntities);
|
|
else
|
|
return (&xmlGetGlobalState()->xmlParserDebugEntities);
|
|
}
|
|
int xmlThrDefParserDebugEntities(int v) {
|
|
int ret;
|
|
xmlMutexLock(xmlThrDefMutex);
|
|
ret = xmlParserDebugEntitiesThrDef;
|
|
xmlParserDebugEntitiesThrDef = v;
|
|
xmlMutexUnlock(xmlThrDefMutex);
|
|
return ret;
|
|
}
|
|
|
|
#undef xmlParserVersion
|
|
const char * *
|
|
__xmlParserVersion(void) {
|
|
if (IS_MAIN_THREAD)
|
|
return (&xmlParserVersion);
|
|
else
|
|
return (&xmlGetGlobalState()->xmlParserVersion);
|
|
}
|
|
|
|
#undef xmlPedanticParserDefaultValue
|
|
int *
|
|
__xmlPedanticParserDefaultValue(void) {
|
|
if (IS_MAIN_THREAD)
|
|
return (&xmlPedanticParserDefaultValue);
|
|
else
|
|
return (&xmlGetGlobalState()->xmlPedanticParserDefaultValue);
|
|
}
|
|
int xmlThrDefPedanticParserDefaultValue(int v) {
|
|
int ret;
|
|
xmlMutexLock(xmlThrDefMutex);
|
|
ret = xmlPedanticParserDefaultValueThrDef;
|
|
xmlPedanticParserDefaultValueThrDef = v;
|
|
xmlMutexUnlock(xmlThrDefMutex);
|
|
return ret;
|
|
}
|
|
|
|
#undef xmlSaveNoEmptyTags
|
|
int *
|
|
__xmlSaveNoEmptyTags(void) {
|
|
if (IS_MAIN_THREAD)
|
|
return (&xmlSaveNoEmptyTags);
|
|
else
|
|
return (&xmlGetGlobalState()->xmlSaveNoEmptyTags);
|
|
}
|
|
int xmlThrDefSaveNoEmptyTags(int v) {
|
|
int ret;
|
|
xmlMutexLock(xmlThrDefMutex);
|
|
ret = xmlSaveNoEmptyTagsThrDef;
|
|
xmlSaveNoEmptyTagsThrDef = v;
|
|
xmlMutexUnlock(xmlThrDefMutex);
|
|
return ret;
|
|
}
|
|
|
|
#undef xmlSubstituteEntitiesDefaultValue
|
|
int *
|
|
__xmlSubstituteEntitiesDefaultValue(void) {
|
|
if (IS_MAIN_THREAD)
|
|
return (&xmlSubstituteEntitiesDefaultValue);
|
|
else
|
|
return (&xmlGetGlobalState()->xmlSubstituteEntitiesDefaultValue);
|
|
}
|
|
int xmlThrDefSubstituteEntitiesDefaultValue(int v) {
|
|
int ret;
|
|
xmlMutexLock(xmlThrDefMutex);
|
|
ret = xmlSubstituteEntitiesDefaultValueThrDef;
|
|
xmlSubstituteEntitiesDefaultValueThrDef = v;
|
|
xmlMutexUnlock(xmlThrDefMutex);
|
|
return ret;
|
|
}
|
|
|
|
#undef xmlRegisterNodeDefaultValue
|
|
xmlRegisterNodeFunc *
|
|
__xmlRegisterNodeDefaultValue(void) {
|
|
if (IS_MAIN_THREAD)
|
|
return (&xmlRegisterNodeDefaultValue);
|
|
else
|
|
return (&xmlGetGlobalState()->xmlRegisterNodeDefaultValue);
|
|
}
|
|
|
|
#undef xmlDeregisterNodeDefaultValue
|
|
xmlDeregisterNodeFunc *
|
|
__xmlDeregisterNodeDefaultValue(void) {
|
|
if (IS_MAIN_THREAD)
|
|
return (&xmlDeregisterNodeDefaultValue);
|
|
else
|
|
return (&xmlGetGlobalState()->xmlDeregisterNodeDefaultValue);
|
|
}
|
|
|
|
#undef xmlParserInputBufferCreateFilenameValue
|
|
xmlParserInputBufferCreateFilenameFunc *
|
|
__xmlParserInputBufferCreateFilenameValue(void) {
|
|
if (IS_MAIN_THREAD)
|
|
return (&xmlParserInputBufferCreateFilenameValue);
|
|
else
|
|
return (&xmlGetGlobalState()->xmlParserInputBufferCreateFilenameValue);
|
|
}
|
|
|
|
#undef xmlOutputBufferCreateFilenameValue
|
|
xmlOutputBufferCreateFilenameFunc *
|
|
__xmlOutputBufferCreateFilenameValue(void) {
|
|
if (IS_MAIN_THREAD)
|
|
return (&xmlOutputBufferCreateFilenameValue);
|
|
else
|
|
return (&xmlGetGlobalState()->xmlOutputBufferCreateFilenameValue);
|
|
}
|
|
|
|
#define bottom_globals
|
|
#include "elfgcchack.h"
|