/*

 * libxml2_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

 * Portion Copyright © 2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved. 

 */

#define IN_LIBXML

#define UNDEF_IMPORT_C_IN_DATA

#include <assert.h>

#include <errno.h>

#include <stdlib.h>

#include <string.h>

#include "xmlenglibxml.h"

#include <stdapis/libxml2/libxml2_globals.h>

#include "libxml2_xmlschemastypes.h"

const xeGlobalConstData xeGlobalConsts =

    {

    LIBXML_VERSION_STRING // xmlParserVersion field

    };

const xeGlobalConstData* xeGetGlobalConsts()

{

    return &xeGlobalConsts;

}

/**

 * xmlParserVersion:

 *

 * Constant string describing the internal version of the library

 */

XMLPUBFUNEXPORT const char* const xmlParserVersion = LIBXML_VERSION_STRING;

/*

This function creates and initializes new xmlGlobalState structure

and stores pointer to it into Thread-Local Storage of this DLL.

If TLS is not NULL, then nothing happens and pointer to existing global data is returned

This function is used once prior any use of libxml2 code!

It called from XmlEngine::XmlEngineAttachL() function

and must be called by any other client of libxml2's API if XmlEngineAttachL()

is not used.

*/

XMLPUBFUNEXPORT xmlGlobalStatePtr xmlCreateAndInitializeGlobalState()

{

    xmlGlobalStatePtr gs = xeGetTLS();

    if(gs)

        return gs; // already initialized;

    gs = (xmlGlobalStatePtr) malloc(sizeof(xmlGlobalState));

    if(gs)

    {

        memset(gs, 0, sizeof(xmlGlobalState));

        xeSetTLS(gs);

        xmlInitializeGlobalState(gs);

    }

    return gs;

}

/*

Performs complete cleanup of the resource allocated for Libxml2.

Global state data is destroyed.

On Symbian:

  Thread-Local Storage is set to NULL after the cleanup finished.

 @note XmlEngine::XmlEngineCleanup(TAny*) calls this function

       as part of XML Engine shutdown sequence; but it also adds

       counter for multi-user (within one thread) processing support.

 @note This function should not be directly used by Symbian applications;

       the only exception for this rule is usage of libxml2 by other

       open-source libraries [XmlEngine::XmlEngineCleanup(TAny*) is preferred]

*/

XMLPUBFUNEXPORT void xmlCleanupGlobalData()

{

    DEFINE_GS_PROXY /* NOTE: Initialize GS proxy initialize before using any GS member */

    xmlGlobalStatePtr gs = xeGetTLS();

    if(!gs)

        return;

    SET_GS_PROXY(gs);

    xmlSchemaCleanupTypes();

    xmlResetLastError();

    xmlCleanupCharEncodingHandlers();

    xmlCleanupParser();

    xeXPathCleanup();

    xeCleanupDOMStringConverter();

#ifdef XMLENGINE_XSLT

    if(xsltGlobalsCleanupFunc)

        ((void(*)())xsltGlobalsCleanupFunc)();

#endif

    free(gs); //using xmlFree(gs) is not right:  GS was not initialized with xmlMalloc() !

    xeSetTLS(NULL);

}

XMLPUBFUNEXPORT int xmlOOMFlag()

    {

    LOAD_GS_DIRECT

#ifdef _DEBUG

    int f = OOM_FLAG;

    if(f)

        {

        f |= 0; // SET BREAKPOINT HERE

        }

    return f;

#else

    return OOM_FLAG;

#endif

    }

void XMLCALL xeCheckErrno()

    {

    int err = errno;

    if (err == ENOMEM)

        {

        SET_OOM_FLAG;

        }

#ifdef _DEBUG

    else if (err)

        {

        // some other error!!!

        err ^=err;

        }

#endif

    }

XMLPUBFUNEXPORT void xmlSetOOM()

    {

    DEFINE_GS_PROXY //note: ensure GS proxy initialize before any GS member access

    xmlGlobalStatePtr gs = xeGetTLS();

    SET_GS_PROXY(gs)

    // Should be sure that globals state (contains the OOM flag) is initialized

    if(gs)

        {

        OOM_FLAG = 1;

        }

    }

XMLPUBFUNEXPORT void xmlResetOOM()

    {

    DEFINE_GS_PROXY //note: ensure GS proxy initialize before any GS member access

    xmlGlobalStatePtr gs = xeGetTLS();

    SET_GS_PROXY(gs)

    // We need this in case OOM happened during initialization of the 'global state'

    if (!gs)

        return;

    OOM_FLAG = 0;

    }

#define __lookup_ALLOC_ADDRES_  0

#ifdef XMLENGINE_MEM_DEBUG

void __catchAllocatedAddress()

    {

    // Set breakpoint here

    }

void __catchFreedAddress()

    {

    // Set breakpoint here

    }

#endif

#ifdef XMLENGINE_MEM_DEBUG

//#define XMLENGINE_MEM_DEBUG_SIZE

#endif

/*

 NOTE: XMLENGINE_MEM_DEBUG option is defined only in debug builds

*/

XMLPUBFUNEXPORT void* XMLCALL malloc_impl(size_t size)

{

#ifdef XMLENGINE_MEM_DEBUG

    LOAD_GS_DIRECT

#endif

#ifndef XMLENGINE_MEM_DEBUG_SIZE

    void* mem = malloc(size);

#ifdef XMLENGINE_MEM_DEBUG

    if((int)mem == __lookup_ALLOC_ADDRES_) {

        __catchAllocatedAddress();

    }

#endif

#else

    // when defined XMLENGINE_MEM_DEBUG_SIZE

    //

    // the previous 4 bytes before returned pointer is the size of a block

    void *hdr;

    void *mem;

    hdr = malloc(size + sizeof(size_t));

    if(hdr)

    {

        mem = ((char*)hdr) + sizeof(size_t);

        *((size_t*)hdr) = size;

    }

    else

        mem = NULL;

    if((int)hdr == __lookup_ALLOC_ADDRES_) {

        __catchAllocatedAddress();

    }

#endif

    if(mem)

        {

#ifdef XMLENGINE_MEM_DEBUG

        xmlGlobalStatePtr gs = xeGetTLS();

        if(gs && !xmlOOM) // do not count "after allocations" during error-handling

            {

            gs->allocCount++;

            gs->allocTotal += size;

#ifdef XMLENGINE_MEM_DEBUG_SIZE

            gs->allocMemSize += size;

            if(gs->allocMemSize > gs->allocMemSizeMax)

                gs->allocMemSizeMax = gs->allocMemSize;

#endif

            }

#endif

        return mem;

        }

    else

        {

        SET_OOM_FLAG;

        return NULL; // NULL

        }

}

XMLPUBFUNEXPORT void* XMLCALL realloc_impl(void *ptr, size_t size)

{

#ifdef XMLENGINE_MEM_DEBUG

    LOAD_GS_DIRECT

#endif

#ifndef XMLENGINE_MEM_DEBUG_SIZE

    void* mem = realloc(ptr, size);

#   ifdef XMLENGINE_MEM_DEBUG

    if((int)mem == __lookup_ALLOC_ADDRES_) {

        __catchAllocatedAddress();

    }

#   endif

#else

    // XMLENGINE_MEM_DEBUG_SIZE is defined

    void* hdr;

    void* mem;

    size_t prevSize;

    hdr = (((size_t*)ptr) - 1);

    prevSize = *((size_t*)hdr);

    hdr = realloc(hdr, size + sizeof(size_t));

    if(hdr)

    {

        mem = ((size_t*)hdr) + 1;

        *((size_t*)hdr) = size;

    }

    else

        mem = NULL;

    if((int)hdr == __lookup_ALLOC_ADDRES_) {

        __catchAllocatedAddress();

    }

#endif /* XMLENGINE_MEM_DEBUG_SIZE */

    if(mem)

        {

#ifdef XMLENGINE_MEM_DEBUG

        xmlGlobalStatePtr gs = xeGetTLS();

        if(gs && !xmlOOM) // do not count "after allocations" during error-handling

            {

            gs->reallocCount++;

#ifdef XMLENGINE_MEM_DEBUG_SIZE

            gs->allocMemSize += size - prevSize;

            if(gs->allocMemSize > gs->allocMemSizeMax)

                gs->allocMemSizeMax = gs->allocMemSize;

#endif

            }

#endif

        return mem;

        }

    else

        {

        SET_OOM_FLAG;

        return NULL;

        }

}

//

// NOTE: in release builds  free() is used directly

void free_debug(void* mem)

{

#ifdef XMLENGINE_MEM_DEBUG

    xmlGlobalStatePtr gs;

#ifndef XMLENGINE_MEM_DEBUG_SIZE

    if((int)mem == __lookup_ALLOC_ADDRES_) {

        __catchFreedAddress();

    }

    free(mem);

#else

    void*  hdr;

    size_t size;

    hdr = (((size_t*)mem) - 1);

    if((int)hdr == __lookup_ALLOC_ADDRES_) {

        __catchFreedAddress();

    }

    size = *((size_t*)hdr);

    free(hdr);

#endif /* XMLENGINE_MEM_DEBUG_SIZE */

    gs = xeGetTLS();

    if(gs)

        {

        gs->deallocCount++;

#ifdef XMLENGINE_MEM_DEBUG_SIZE

        gs->allocMemSize -=size;

#endif

        }

#endif /* XMLENGINE_MEM_DEBUG */

}

//

#ifdef XMLENGINE_EXCLUDE_EMBED_MSG

const char* const __embedded_errtxt_replacement = "DISABLED ERROR STRING\n";

#endif

void xeCleanupDOMStringConverter()

{

    DOMStringConverterData* data = &xmlGetGlobalState()->xeStringArgs;

    char** buf;

    int i;

    for(i=0; i<4; i++){

        buf = &data->cleanupItem[i];

        if(*buf){

            xmlFree(*buf);

            *buf = 0;

        }

    }

}

int symbian_vsnprintf(char *str, size_t size, const char *format, va_list ap)

{

    int ret = 0;

    ret = vsprintf(str, format, ap);

    assert((size_t)ret < size);

    return ret;

}

int symbian_snprintf(char *str, size_t size, const char *format, ...)

{

    int ret = 0;

    va_list args;

    va_start(args, format);

    symbian_vsnprintf(str, size, format, args);

    va_end(args);

    assert((size_t)ret < size);

    return ret;

}

#include <stdapis/libxml2/libxml2_sax.h>

/**

 * xmlTreeIndentString:

 *

 * The string used to do one-level indent. By default is equal to "  " (two spaces)

 */

XMLPUBFUNEXPORT const char* const xmlTreeIndentString = "  ";

const char* const xmlTreeIndentStringThrDef = "  ";

XMLPUBFUNEXPORT xmlRegisterNodeFunc

xmlRegisterNodeDefault(xmlRegisterNodeFunc func)

{

	LOAD_GS_DIRECT

    xmlRegisterNodeFunc old = xmlRegisterNodeDefaultValue;

    __xmlRegisterCallbacks = 1;

    xmlRegisterNodeDefaultValue = func;

    return(old);

}

XMLPUBFUNEXPORT xmlDeregisterNodeFunc

xmlDeregisterNodeDefault(xmlDeregisterNodeFunc func)

{

	LOAD_GS_DIRECT

    xmlDeregisterNodeFunc old = xmlDeregisterNodeDefaultValue;

    __xmlRegisterCallbacks = 1;

    xmlDeregisterNodeDefaultValue = func;

    return(old);

}

#define xmlBufferAllocSchemeThrDef XML_BUFFER_ALLOC_EXACT

#define xmlDefaultBufferSizeThrDef BASE_BUFFER_SIZE

#define xmlParserDebugEntitiesThrDef 0

#define xmlDoValidityCheckingDefaultValueThrDef 0

#define xmlGetWarningsDefaultValueThrDef 1

#define xmlLoadExtDtdDefaultValueThrDef 0

#define xmlPedanticParserDefaultValueThrDef 0

#define xmlLineNumbersDefaultValueThrDef 0

#define xmlKeepBlanksDefaultValueThrDef 1

#define xmlSubstituteEntitiesDefaultValueThrDef 0

#define xmlRegisterNodeDefaultValueThrDef NULL

#define xmlDeregisterNodeDefaultValueThrDef NULL

void xmlGenericErrorDefaultFunc (void *ctx ATTRIBUTE_UNUSED, const char *msg, ...);

#define xmlGenericErrorThrDef  xmlGenericErrorDefaultFunc

#define xmlStructuredErrorThrDef  NULL

#define xmlGenericErrorContextThrDef NULL

#define xmlIndentTreeOutputThrDef 1

#define xmlTreeIndentStringThrDef "  "

#define xmlSaveNoEmptyTagsThrDef 0

#undef  docbDefaultSAXHandler

#undef  htmlDefaultSAXHandler

#undef  xmlBufferAllocScheme

#undef  xmlDefaultBufferSize

#undef  xmlDefaultSAXHandler

#undef  xmlDefaultSAXLocator

#undef  xmlDoValidityCheckingDefaultValue

#undef  xmlGenericError

#undef  xmlStructuredError

#undef  xmlGenericErrorContext

#undef  xmlGetWarningsDefaultValue

#undef  xmlIndentTreeOutput

//#undef  xmlTreeIndentString

#undef  xmlKeepBlanksDefaultValue

#undef  xmlLineNumbersDefaultValue

#undef  xmlLoadExtDtdDefaultValue

#undef  xmlParserDebugEntities

#undef  xmlPedanticParserDefaultValue

#undef  xmlSaveNoEmptyTags

#undef  xmlSubstituteEntitiesDefaultValue

#undef  xmlRegisterNodeDefaultValue

#undef  xmlDeregisterNodeDefaultValue

#undef  xmlLastError

#undef  xmlFree

#undef  xmlMalloc

#undef  xmlMallocAtomic

#undef  xmlMemStrdup

#undef  xmlRealloc

/* html */

#undef  htmlStartCloseIndex

#undef  htmlStartCloseIndexinitialized

/* tree */

#undef __xmlRegisterCallbacks

#undef xmlCompressMode

#undef xmlCheckDTD

/* xmlmemory */

#undef xmlMemInitialized

#undef debugMemSize

#undef debugMaxMemSize

#undef xmlMemMutex

#undef g_block

#undef xmlMemStopAtBlock

#undef xmlMemTraceBlockAt

/* catalog */

#undef  xmlDebugCatalogs

#undef  xmlCatalogDefaultAllow

#undef  xmlCatalogDefaultPrefer

#undef  xmlCatalogXMLFiles

#undef  xmlDefaultCatalog

#undef  xmlCatalogMutex

#undef  xmlCatalogInitialized

#undef  xmlInputCallbackTable

#undef  xmlInputCallbackNr

#undef  xmlInputCallbackInitialized

#undef  xmlOutputCallbackTable

#undef  xmlOutputCallbackNr

#undef  xmlOutputCallbackInitialized

#undef xmlCurrentExternalEntityLoader

#undef xmlSAX2DefaultVersionValue

#undef xmlParserMaxDepth

#undef xmlW3CPIs

#undef xmlParserInitialized

#undef xeStackLimit

// Now these are global constants

//#undef xmlEntityLt

//#undef xmlEntityGt

//#undef xmlEntityAmp

//#undef xmlEntityQuot

//#undef xmlEntityApos

#undef xmlUTF16LEHandler

#undef xmlUTF16BEHandler

#undef xmlCharEncodingAliases

#undef xmlCharEncodingAliasesNb

#undef xmlCharEncodingAliasesMax

#undef xmlLittleEndian

#undef handlers