/*
 * libxml2_sax2.c : Default SAX2 handler to build a tree.
 *
 * See Copyright for the status of this software.
 *
 * Daniel Veillard <daniel@veillard.com>
 * Portion Copyright © 2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved. 
 */

#define IN_LIBXML

#include "xmlenglibxml.h"

#include <stdlib.h>
#include <string.h>
#include <stdapis/libxml2/libxml2_parserinternals.h>
#include "libxml2_xmlerror2.h"

#ifdef LIBXML_DEBUG_ENABLED
#include "libxml2_debugxml.h"
#endif

#include <stdapis/libxml2/libxml2_uri.h>
#include <stdapis/libxml2/libxml2_globals.h>

#ifdef LIBXML_HTML_ENABLED
#include "libxml2_htmltree.h"
#endif

/* #define DEBUG_SAX2 */
/* #define DEBUG_SAX2_TREE */

/**
 * 
 *
 * macro to flag unimplemented blocks
 * XML_CATALOG_PREFER user env to select between system/public prefered
 * option. C.f. Richard Tobin <richard@cogsci.ed.ac.uk>
 *> Just FYI, I am using an environment variable XML_CATALOG_PREFER with
 *> values "system" and "public".  I have made the default be "system" to
 *> match yours.
 */
#define _TODO_                              \
    xmlGenericError(xmlGenericErrorContext,             \
        EMBED_ERRTXT("Unimplemented block at %s:%d\n"),             \
            __FILE__, __LINE__);

/**
 * xmlValidError:
 * @param ctxt an XML validation parser context
 * @param error the error number
 * @param msg the error message
 * @param str1 extra data
 * @param str2 extra data
 *
 * Handle a validation error
 */
static void
xmlErrValid(xmlParserCtxtPtr ctxt, xmlParserErrors error,
            const char *msg, const char *str1, const char *str2)
{
    xmlStructuredErrorFunc schannel = NULL;

    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
        (ctxt->instate == XML_PARSER_EOF))
    return;
    ctxt->errNo = error;
    if ((ctxt->sax != NULL) && (ctxt->sax->initialized == XML_SAX2_MAGIC))
        schannel = ctxt->sax->serror;
    __xmlRaiseError(schannel,
                    ctxt->vctxt.error, ctxt->vctxt.userData,
                    ctxt, NULL, XML_FROM_DTD, error,
                    XML_ERR_ERROR, NULL, 0, (const char *) str1,
            (const char *) str2, NULL, 0, 0,
            msg, (const char *) str1, (const char *) str2);
    ctxt->valid = 0;
}

/**
 * xmlSAX2GetPublicId:
 * @param ctx the user data (XML parser context)
 *
 * Provides the public ID e.g. "-//SGMLSOURCE//DTD DEMO//EN"
 *
 * Returns a xmlChar *
 */
XMLPUBFUNEXPORT const xmlChar *
xmlSAX2GetPublicId(void *ctx ATTRIBUTE_UNUSED)
{
    /* xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; */
    if(ctx)
        return NULL; // just to use ctx
    return(NULL);
}

/**
 * xmlSAX2GetSystemId:
 * @param ctx the user data (XML parser context)
 *
 * Provides the system ID, basically URL or filename e.g.
 * http://www.sgmlsource.com/dtds/memo.dtd
 *
 * Returns a xmlChar *
 */
XMLPUBFUNEXPORT const xmlChar *
xmlSAX2GetSystemId(void *ctx)
{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    return((const xmlChar *) ctxt->input->filename);
}

/**
 * xmlSAX2GetLineNumber:
 * @param ctx the user data (XML parser context)
 *
 * Provide the line number of the current parsing point.
 *
 * Returns an int
 */
XMLPUBFUNEXPORT int
xmlSAX2GetLineNumber(void *ctx)
{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    return(ctxt->input->line);
}

/**
 * xmlSAX2GetColumnNumber:
 * @param ctx the user data (XML parser context)
 *
 * Provide the column number of the current parsing point.
 *
 * Returns an int
 */
XMLPUBFUNEXPORT int
xmlSAX2GetColumnNumber(void *ctx)
{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    return(ctxt->input->col);
}

/**
 * xmlSAX2IsStandalone:
 * @param ctx the user data (XML parser context)
 *
 * Is this document tagged standalone ?
 *
 * Returns 1 if true
 */
XMLPUBFUNEXPORT int
xmlSAX2IsStandalone(void *ctx)
{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    return(ctxt->myDoc->standalone == 1);
}

/**
 * xmlSAX2HasInternalSubset:
 * @param ctx the user data (XML parser context)
 *
 * Does this document has an internal subset
 *
 * Returns 1 if true
 */
XMLPUBFUNEXPORT int
xmlSAX2HasInternalSubset(void *ctx)
{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    return(ctxt->myDoc->intSubset != NULL);
}

/**
 * xmlSAX2HasExternalSubset:
 * @param ctx the user data (XML parser context)
 *
 * Does this document has an external subset
 *
 * Returns 1 if true
 */
XMLPUBFUNEXPORT int
xmlSAX2HasExternalSubset(void *ctx)
{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    return(ctxt->myDoc->extSubset != NULL);
}

/**
 * xmlSAX2InternalSubset:
 * @param ctx the user data (XML parser context)
 * @param name the root element name
 * @param ExternalID the external ID
 * @param SystemID the SYSTEM ID (e.g. filename or URL)
 *
 * Callback on internal subset declaration.
 */
XMLPUBFUNEXPORT void
xmlSAX2InternalSubset(void *ctx, const xmlChar *name,
           const xmlChar *ExternalID, const xmlChar *SystemID)
{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    xmlDtdPtr dtd;
#ifdef DEBUG_SAX
    xmlGenericError(xmlGenericErrorContext,
        "SAX.xmlSAX2InternalSubset(%s, %s, %s)\n",
            name, ExternalID, SystemID);
#endif

    if (ctxt->myDoc == NULL)
        return;
    dtd = xmlGetIntSubset(ctxt->myDoc);
    if (dtd != NULL) {
        if (ctxt->html)
            return;
        xmlUnlinkNode((xmlNodePtr) dtd);
        xmlFreeDtd(dtd);
        ctxt->myDoc->intSubset = NULL;
    }
    ctxt->myDoc->intSubset = xmlCreateIntSubset(ctxt->myDoc, name, ExternalID, SystemID);
}

/**
 * xmlSAX2ExternalSubset:
 * @param ctx the user data (XML parser context)
 * @param name the root element name
 * @param ExternalID the external ID
 * @param SystemID the SYSTEM ID (e.g. filename or URL)
 *
 * Callback on external subset declaration.
 */
XMLPUBFUNEXPORT void
xmlSAX2ExternalSubset(void *ctx, const xmlChar *name,
           const xmlChar *ExternalID, const xmlChar *SystemID)
{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
#ifdef DEBUG_SAX
    xmlGenericError(xmlGenericErrorContext,
        "SAX.xmlSAX2ExternalSubset(%s, %s, %s)\n",
            name, ExternalID, SystemID);
#endif
    if (((ExternalID != NULL) || (SystemID != NULL)) &&
        (((ctxt->validate) || (ctxt->loadsubset != 0)) &&
     (ctxt->wellFormed && ctxt->myDoc))) {
    /*
     * Try to fetch and parse the external subset.
     */
    xmlParserInputPtr oldinput;
    int oldinputNr;
    int oldinputMax;
    xmlParserInputPtr *oldinputTab;
    xmlParserInputPtr input = NULL;
    xmlCharEncoding enc;
    int oldcharset;

    /*
     * Ask the Entity resolver to load the damn thing
     */
    if ((ctxt->sax != NULL) && (ctxt->sax->resolveEntity != NULL))
        input = ctxt->sax->resolveEntity(ctxt->userData, ExternalID,
                                            SystemID);
    if (input == NULL) {
        return;
    }

    xmlNewDtd(ctxt->myDoc, name, ExternalID, SystemID);

    /*
     * make sure we won't destroy the main document context
     */
     
    oldinput = ctxt->input;
    oldinputNr = ctxt->inputNr;
    oldinputMax = ctxt->inputMax;
    oldinputTab = ctxt->inputTab;
    oldcharset = ctxt->charset;

    ctxt->inputTab = (xmlParserInputPtr *)
                     xmlMalloc(5 * sizeof(xmlParserInputPtr));
    if (ctxt->inputTab == NULL) {
        ctxt->errNo = XML_ERR_NO_MEMORY;
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
        ctxt->sax->error(ctxt->userData,
             EMBED_ERRTXT("xmlSAX2ExternalSubset: out of memory\n"));
        ctxt->errNo = XML_ERR_NO_MEMORY;
        ctxt->instate = XML_PARSER_EOF;
        ctxt->disableSAX = 1;
        ctxt->input = oldinput;
        ctxt->inputNr = oldinputNr;
        ctxt->inputMax = oldinputMax;
        ctxt->inputTab = oldinputTab;
        ctxt->charset = oldcharset;
        return;
    }
    ctxt->inputNr = 0;
    ctxt->inputMax = 5;
    ctxt->input = NULL;
    xmlPushInput(ctxt, input);

    /*
     * On the fly encoding conversion if needed
     */
    if (ctxt->input->length >= 4) {
        enc = xmlDetectCharEncoding(ctxt->input->cur, 4);
        xmlSwitchEncoding(ctxt, enc);
    }

    if (input->filename == NULL)
        input->filename = (char *) xmlCanonicPath(SystemID);
    input->line = 1;
    input->col = 1;
    input->base = ctxt->input->cur;
    input->cur = ctxt->input->cur;
    input->free = NULL;

    /*
     * let's parse that entity knowing it's an external subset.
     */
    xmlParseExternalSubset(ctxt, ExternalID, SystemID);

    /*
     * Free up the external entities
     */

    while (ctxt->inputNr > 1)
        xmlPopInput(ctxt);
    xmlFreeInputStream(ctxt->input);
    xmlFree(ctxt->inputTab);

    /*
     * Restore the parsing context of the main entity
     */
    ctxt->input = oldinput;
    ctxt->inputNr = oldinputNr;
    ctxt->inputMax = oldinputMax;
    ctxt->inputTab = oldinputTab;
    ctxt->charset = oldcharset;
    /* ctxt->wellFormed = oldwellFormed; */
    }
}

/**
 * xmlSAX2ResolveEntity:
 * @param ctx the user data (XML parser context)
 * @param publicId The public ID of the entity
 * @param systemId The system ID of the entity
 *
 * The entity loader, to control the loading of external entities,
 * the application can either:
 *    - override this xmlSAX2ResolveEntity() callback in the SAX block
 *    - or better use the xmlSetExternalEntityLoader() function to
 *      set up it's own entity resolution routine
 *
 * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
 */
XMLPUBFUNEXPORT xmlParserInputPtr
xmlSAX2ResolveEntity(void *ctx, const xmlChar *publicId, const xmlChar *systemId)
{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    xmlParserInputPtr ret;
    xmlChar*     URI;
    const char*  base = NULL;

    if (ctxt->input)
        base = ctxt->input->filename;
    if (!base)
        base = ctxt->directory;

    URI = xmlBuildURI(systemId, (const xmlChar *) base);

#ifdef DEBUG_SAX
    xmlGenericError(xmlGenericErrorContext,
        "SAX.xmlSAX2ResolveEntity(%s, %s)\n", publicId, systemId);
#endif

    ret = xmlLoadExternalEntity((const char *) URI,
                (const char *) publicId, ctxt);
    if (URI)
        xmlFree(URI);
    return(ret);
}

/**
 * xmlSAX2GetEntity:
 * @param ctx the user data (XML parser context)
 * @param name The entity name
 *
 * Get an entity by name
 *
 * Returns the xmlEntityPtr if found.
 */
XMLPUBFUNEXPORT xmlEntityPtr
xmlSAX2GetEntity(void *ctx, const xmlChar *name)
{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    xmlEntityPtr ret = NULL;

#ifdef DEBUG_SAX
    xmlGenericError(xmlGenericErrorContext, "SAX.xmlSAX2GetEntity(%s)\n", name);
#endif

    if (ctxt->inSubset == 0) {
        ret = xmlGetPredefinedEntity(name);
        if (ret != NULL)
            return(ret);
    }
    if ((ctxt->myDoc != NULL) && (ctxt->myDoc->standalone == 1))
    {
        if (ctxt->inSubset == 2) {
            ctxt->myDoc->standalone = 0;
            ret = xmlGetDocEntity(ctxt->myDoc, name);
            ctxt->myDoc->standalone = 1;
        } else {
            ret = xmlGetDocEntity(ctxt->myDoc, name);
            if (ret == NULL) {
                ctxt->myDoc->standalone = 0;
                ret = xmlGetDocEntity(ctxt->myDoc, name);
                if (ret != NULL) {
                    if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                        ctxt->sax->error(ctxt->userData,
                                     EMBED_ERRTXT("Entity(%s) document marked standalone but requires external subset\n"),
                                     name);
                    ctxt->valid = 0;
                    ctxt->wellFormed = 0;
                }
                ctxt->myDoc->standalone = 1;
            }
        }
    } else {
        ret = xmlGetDocEntity(ctxt->myDoc, name);
    }
    if (ret &&
        ((ctxt->validate) || (ctxt->replaceEntities)) &&
        !ret->children &&
        (ret->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY))
    {
        int val;

    /*
     * for validation purposes we really need to fetch and
     * parse the external entity
     */
    xmlNodePtr children;

        val = xmlParseCtxtExternalEntity(ctxt, ret->URI, ret->ExternalID, &children);

        if (val == 0) {
            xmlAddChildList((xmlNodePtr) ret, children);
        } else {
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData,
                                 EMBED_ERRTXT("Failure to process entity %s\n"), name);
            ctxt->wellFormed = 0;
            ctxt->valid = 0;
            ctxt->validate = 0;
            return(NULL);
        }
        ret->owner = 1;
    }
    return(ret);
}

/**
 * xmlSAX2GetParameterEntity:
 * @param ctx the user data (XML parser context)
 * @param name The entity name
 *
 * Get a parameter entity by name
 *
 * Returns the xmlEntityPtr if found.
 */
XMLPUBFUNEXPORT xmlEntityPtr
xmlSAX2GetParameterEntity(void *ctx, const xmlChar *name)
{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    xmlEntityPtr ret;

#ifdef DEBUG_SAX
    xmlGenericError(xmlGenericErrorContext,
        "SAX.xmlSAX2GetParameterEntity(%s)\n", name);
#endif

    ret = xmlGetParameterEntity(ctxt->myDoc, name);
    return(ret);
}


/**
 * xmlSAX2EntityDecl:
 * @param ctx the user data (XML parser context)
 * @param name the entity name
 * @param type the entity type
 * @param publicId The public ID of the entity
 * @param systemId The system ID of the entity
 * @param content the entity value (without processing).
 *
 * An entity definition has been parsed
 */
XMLPUBFUNEXPORT void
xmlSAX2EntityDecl(void *ctx, const xmlChar *name, int type,
          const xmlChar *publicId, const xmlChar *systemId, xmlChar *content)
{
    xmlEntityPtr ent;
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;

#ifdef DEBUG_SAX
    xmlGenericError(xmlGenericErrorContext,
        "SAX.xmlSAX2EntityDecl(%s, %d, %s, %s, %s)\n",
            name, type, publicId, systemId, content);
#endif
    if (ctxt->inSubset == 1)
    {
        ent = xmlAddDocEntity(ctxt->myDoc, name, type, publicId,
                          systemId, content);
        if (!ent &&
            ctxt->pedantic &&
            ctxt->sax && ctxt->sax->warning)
        {
            ctxt->sax->warning(ctxt->userData,
                                EMBED_ERRTXT("Entity(%s) already defined in the internal subset\n"), name);
        }
        if (ent && !ent->URI && systemId)
        {
            xmlChar *URI;
            const char *base = NULL;

            if (ctxt->input)
                base = ctxt->input->filename;
            if (!base)
                base = ctxt->directory;

            URI = xmlBuildURI(systemId, (const xmlChar *) base);
            ent->URI = URI;
        }
    }
    else if (ctxt->inSubset == 2)
    {
        ent = xmlAddDtdEntity(ctxt->myDoc, name, type, publicId,
                              systemId, content);
        if (!ent &&
            ctxt->pedantic &&
            ctxt->sax &&
            ctxt->sax->warning)
        {
            ctxt->sax->warning(ctxt->userData,
                                EMBED_ERRTXT("Entity(%s) already defined in the external subset\n"), name);
        }
        if (ent && !ent->URI && systemId)
        {
            xmlChar *URI;
            const char* base = NULL;

            if (ctxt->input != NULL)
                base = ctxt->input->filename;
            if (!base)
                base = ctxt->directory;

            URI = xmlBuildURI(systemId, (const xmlChar*) base);
            ent->URI = URI;
        }
    }
    else if (ctxt->sax && ctxt->sax->error)
    {
        ctxt->sax->error(ctxt->userData,
             EMBED_ERRTXT("SAX.xmlSAX2EntityDecl(%s) called while not in subset\n"),
             name);
    }
}

/**
 * xmlSAX2AttributeDecl:
 * @param ctx the user data (XML parser context)
 * @param elem the name of the element
 * @param fullname the attribute name
 * @param type the attribute type
 * @param def the type of default value
 * @param defaultValue the attribute default value
 * @param tree the tree of enumerated value set
 *
 * An attribute definition has been parsed
 */
XMLPUBFUNEXPORT void
xmlSAX2AttributeDecl(void *ctx, const xmlChar *elem, const xmlChar *fullname,
              int type, int def, const xmlChar *defaultValue,
          xmlEnumerationPtr tree)
{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
#ifdef LIBXML_VALID_ENABLED
    xmlAttributePtr attr;
#endif
    xmlChar *name = NULL, *prefix = NULL;

#ifdef DEBUG_SAX
    xmlGenericError(xmlGenericErrorContext,
        "SAX.xmlSAX2AttributeDecl(%s, %s, %d, %d, %s, ...)\n",
            elem, fullname, type, def, defaultValue);
#endif
    if ((xmlStrEqual(fullname, BAD_CAST "xml:id")) &&
        (type != XML_ATTRIBUTE_ID)) {
    /*
     * Raise the error but keep the validity flag
     */
    int tmp = ctxt->valid;
    xmlErrValid(ctxt, XML_DTD_XMLID_TYPE,
          EMBED_ERRTXT("xml:id : attribute type should be ID\n"), NULL, NULL);
    ctxt->valid = tmp;
    }
    
    name = xmlSplitQName(ctxt, fullname, &prefix);
    ctxt->vctxt.valid = 1;
    if (ctxt->inSubset == 1)
    {
#ifdef LIBXML_VALID_ENABLED
        attr =
#endif
        xmlAddAttributeDecl(&ctxt->vctxt, ctxt->myDoc->intSubset, elem,
           name, prefix, (xmlAttributeType) type,
           (xmlAttributeDefault) def, defaultValue, tree);
    }
    else if (ctxt->inSubset == 2)
    {
#ifdef LIBXML_VALID_ENABLED
        attr =
#endif
        xmlAddAttributeDecl(&ctxt->vctxt, ctxt->myDoc->extSubset, elem,
            name, prefix, (xmlAttributeType) type,
            (xmlAttributeDefault) def, defaultValue, tree);
    }
    else
    {
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData,
                EMBED_ERRTXT("SAX.xmlSAX2AttributeDecl(%s) called while not in subset\n"), name);
                xmlFreeEnumeration(tree);
        return;
    }
#ifdef LIBXML_VALID_ENABLED
    if (ctxt->vctxt.valid == 0)
        ctxt->valid = 0;
    if ((attr != NULL) && (ctxt->validate) && (ctxt->wellFormed) &&
        (ctxt->myDoc != NULL) && (ctxt->myDoc->intSubset != NULL))
        ctxt->valid &= xmlValidateAttributeDecl(&ctxt->vctxt, ctxt->myDoc,
                                            attr);
#endif /* LIBXML_VALID_ENABLED */
    if (prefix != NULL)
        xmlFree(prefix);
    if (name != NULL)
        xmlFree(name);
}

/**
 * xmlSAX2ElementDecl:
 * @param ctx the user data (XML parser context)
 * @param name the element name
 * @param type the element type
 * @param content the element value tree
 *
 * An element definition has been parsed
 */
XMLPUBFUNEXPORT void
xmlSAX2ElementDecl(void *ctx, const xmlChar * name, int type,
            xmlElementContentPtr content)
{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
#ifdef LIBXML_VALID_ENABLED
    xmlElementPtr elem = NULL;
#endif

#ifdef DEBUG_SAX
    xmlGenericError(xmlGenericErrorContext,
                    "SAX.xmlSAX2ElementDecl(%s, %d, ...)\n", name, type);
#endif

    if (ctxt->inSubset == 1){
#ifdef LIBXML_VALID_ENABLED
        elem =
#endif
        xmlAddElementDecl(&ctxt->vctxt, ctxt->myDoc->intSubset,
                                 name, (xmlElementTypeVal) type, content);
    }
    else if (ctxt->inSubset == 2)
    {
#ifdef LIBXML_VALID_ENABLED
        elem =
#endif
        xmlAddElementDecl(&ctxt->vctxt, ctxt->myDoc->extSubset,
                                 name, (xmlElementTypeVal) type, content);
    }
    else
    {
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData,
                             EMBED_ERRTXT("SAX.xmlSAX2ElementDecl(%s) called while not in subset\n"),
                             name);
        return;
    }
#ifdef LIBXML_VALID_ENABLED
    if (elem == NULL)
        ctxt->valid = 0;
    if (ctxt->validate && ctxt->wellFormed &&
        ctxt->myDoc && ctxt->myDoc->intSubset)
        ctxt->valid &=
            xmlValidateElementDecl(&ctxt->vctxt, ctxt->myDoc, elem);
#endif /* LIBXML_VALID_ENABLED */
}

/**
 * xmlSAX2NotationDecl:
 * @param ctx the user data (XML parser context)
 * @param name The name of the notation
 * @param publicId The public ID of the entity
 * @param systemId The system ID of the entity
 *
 * What to do when a notation declaration has been parsed.
 */
XMLPUBFUNEXPORT void
xmlSAX2NotationDecl(void *ctx, const xmlChar *name,
         const xmlChar *publicId, const xmlChar *systemId)
{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
#ifdef LIBXML_VALID_ENABLED
    xmlNotationPtr nota = NULL;
#endif

#ifdef DEBUG_SAX
    xmlGenericError(xmlGenericErrorContext,
        "SAX.xmlSAX2NotationDecl(%s, %s, %s)\n", name, publicId, systemId);
#endif

    if ((publicId == NULL) && (systemId == NULL)) {
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData,
                EMBED_ERRTXT("SAX.xmlSAX2NotationDecl(%s) externalID or PublicID missing\n"), name);
        ctxt->valid = 0;
        ctxt->wellFormed = 0;
        return;
    }
    else if (ctxt->inSubset == 1)
    {
#ifdef LIBXML_VALID_ENABLED
        nota =
#endif
        xmlAddNotationDecl(&ctxt->vctxt, ctxt->myDoc->intSubset, name,
                              publicId, systemId);
    }
    else if (ctxt->inSubset == 2)
    {
#ifdef LIBXML_VALID_ENABLED
        nota =
#endif
        xmlAddNotationDecl(&ctxt->vctxt, ctxt->myDoc->extSubset, name,
                              publicId, systemId);
    }
    else
    {
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData,
                EMBED_ERRTXT("SAX.xmlSAX2NotationDecl(%s) called while not in subset\n"), name);
        return;
    }
#ifdef LIBXML_VALID_ENABLED
    if (nota == NULL)
        ctxt->valid = 0;
    if (ctxt->validate && ctxt->wellFormed &&
        ctxt->myDoc && ctxt->myDoc->intSubset)
    ctxt->valid &= xmlValidateNotationDecl(&ctxt->vctxt, ctxt->myDoc,
                                           nota);
#endif /* LIBXML_VALID_ENABLED */
}

/**
 * xmlSAX2UnparsedEntityDecl:
 * @param ctx the user data (XML parser context)
 * @param name The name of the entity
 * @param publicId The public ID of the entity
 * @param systemId The system ID of the entity
 * @param notationName the name of the notation
 *
 * What to do when an unparsed entity declaration is parsed
 */
XMLPUBFUNEXPORT void
xmlSAX2UnparsedEntityDecl(void *ctx, const xmlChar *name,
           const xmlChar *publicId, const xmlChar *systemId,
           const xmlChar *notationName)
{
    xmlEntityPtr ent;
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
#ifdef DEBUG_SAX
    xmlGenericError(xmlGenericErrorContext,
        "SAX.xmlSAX2UnparsedEntityDecl(%s, %s, %s, %s)\n",
            name, publicId, systemId, notationName);
#endif
    if (ctxt->inSubset == 1)
    {
        ent = xmlAddDocEntity(ctxt->myDoc, name,
                            XML_EXTERNAL_GENERAL_UNPARSED_ENTITY,
                            publicId, systemId, notationName);
        if (!ent && ctxt->pedantic &&
            ctxt->sax && ctxt->sax->warning)
        {
            ctxt->sax->warning(ctxt->userData,
                EMBED_ERRTXT("Entity(%s) already defined in the internal subset\n"), name);
        }
        if (ent && !ent->URI && systemId)
        {
            xmlChar *URI;
            const char* base = NULL;

            if (ctxt->input)
                base = ctxt->input->filename;
            if (!base)
                base = ctxt->directory;

            URI = xmlBuildURI(systemId, (const xmlChar *) base);
            ent->URI = URI;
        }
    }
    else if (ctxt->inSubset == 2)
    {
        ent = xmlAddDtdEntity(ctxt->myDoc, name,
                            XML_EXTERNAL_GENERAL_UNPARSED_ENTITY,
                            publicId, systemId, notationName);
        if (!ent && ctxt->pedantic &&
            ctxt->sax && ctxt->sax->warning)
        {
            ctxt->sax->warning(ctxt->userData,
             EMBED_ERRTXT("Entity(%s) already defined in the external subset\n"), name);
        }
        if (ent && !ent->URI && systemId)
        {
            xmlChar *URI;
            const char* base = NULL;

            if (ctxt->input)
                base = ctxt->input->filename;
            if (!base)
                base = ctxt->directory;

            URI = xmlBuildURI(systemId, (const xmlChar*) base);
            ent->URI = URI;
        }
    }
    else if (ctxt->sax && ctxt->sax->error)
    {
        ctxt->sax->error(ctxt->userData,
                EMBED_ERRTXT("SAX.xmlSAX2UnparsedEntityDecl(%s) called while not in subset\n"), name);
    }
}

/**
 * xmlSAX2SetDocumentLocator:
 * @param ctx the user data (XML parser context)
 * @param loc A SAX Locator
 *
 * Receive the document locator at startup, actually xmlDefaultSAXLocator
 * Everything is available on the context, so this is useless in our case.
 */
XMLPUBFUNEXPORT void
xmlSAX2SetDocumentLocator(void *ctx ATTRIBUTE_UNUSED, xmlSAXLocatorPtr loc ATTRIBUTE_UNUSED)
{
    /* xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; */
#ifdef DEBUG_SAX
    xmlGenericError(xmlGenericErrorContext,  "SAX.xmlSAX2SetDocumentLocator()\n");
#endif
    if(ctx) return; // just to use ctx
}

/**
 * xmlSAX2StartDocument:
 * @param ctx the user data (XML parser context)
 *
 * called when the document start being processed.
 *
 * OOM: possible --> check OOM flag
 */
XMLPUBFUNEXPORT void xmlSAX2StartDocument(void *ctx)
{
	xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    xmlDocPtr doc = NULL;

#ifdef DEBUG_SAX
    xmlGenericError(xmlGenericErrorContext, "SAX.xmlSAX2StartDocument()\n");
#endif
    if (ctxt->html) {

#ifdef LIBXML_HTML_ENABLED
        if (ctxt->myDoc == NULL)
            doc = ctxt->myDoc = htmlNewDocNoDtD(NULL, NULL); 
        if (!ctxt->myDoc)
            goto OOM;
#else
        xmlGenericError(xmlGenericErrorContext, EMBED_ERRTXT("libxml2 built without HTML support\n"));
        ctxt->errNo = XML_ERR_INTERNAL_ERROR;
        goto ERR;
#endif
    } else { // not HTML
        doc = ctxt->myDoc = xmlNewDoc(ctxt->version);
        if (!doc)
            goto OOM;

        if (ctxt->encoding != NULL){
            doc->encoding = xmlStrdup(ctxt->encoding); 
            if(! doc->encoding)
                goto OOM;
        }
        //else
        //    doc->encoding = NULL; // it is NULL after xmlNewDoc
        doc->standalone = ctxt->standalone;
        if (ctxt->dictNames && doc) {
            doc->dict = ctxt->dict;
            xmlDictReference(doc->dict);
        }
    }
    if ( /* (ctxt->myDoc != NULL) && : it's NOT NULL here */
        !doc->URL       &&
        ctxt->input     &&
        ctxt->input->filename)
    {
        doc->URL = xmlCanonicPath((const xmlChar *) ctxt->input->filename); 
        if (!doc->URL)
            doc->URL = xmlStrdup((const xmlChar *) ctxt->input->filename); 
    }
    return;
//----------------------------
OOM:
    if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
        ctxt->sax->error(ctxt->userData, EMBED_ERRTXT("SAX.xmlSAX2StartDocument(): out of memory\n"));
    ctxt->errNo = XML_ERR_NO_MEMORY;
ERR:
    ctxt->instate = XML_PARSER_EOF;
    ctxt->disableSAX = 1;
    return;
}

/**
 * xmlSAX2EndDocument:
 * @param ctx the user data (XML parser context)
 *
 * called when the document end has been detected.
 */
XMLPUBFUNEXPORT void
xmlSAX2EndDocument(void *ctx)
{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
#ifdef DEBUG_SAX
    xmlGenericError(xmlGenericErrorContext, "SAX.xmlSAX2EndDocument()\n");
#endif
#ifdef LIBXML_VALID_ENABLED
    if (ctxt->validate && ctxt->wellFormed &&  ctxt->myDoc && ctxt->myDoc->intSubset)
        ctxt->valid &= xmlValidateDocumentFinal(&ctxt->vctxt, ctxt->myDoc);
#endif /* LIBXML_VALID_ENABLED */

    /*
     * Grab the encoding if it was added on-the-fly
     */
    if (ctxt->encoding &&
        ctxt->myDoc    &&
        !ctxt->myDoc->encoding)
    {
        ctxt->myDoc->encoding = ctxt->encoding;
        ctxt->encoding = NULL;
    }
    if (ctxt->inputTab[0]->encoding &&
        ctxt->myDoc                 &&
        !ctxt->myDoc->encoding)
    {
        ctxt->myDoc->encoding = xmlStrdup(ctxt->inputTab[0]->encoding);
    }
    if ((ctxt->charset != XML_CHAR_ENCODING_NONE) &&
        ctxt->myDoc  &&
        (ctxt->myDoc->charset == XML_CHAR_ENCODING_NONE))
    {
        ctxt->myDoc->charset = ctxt->charset;
    }
}

// Note: old (SAX1) handlers -- name is misleading
#if defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED)
/**
 * xmlSAX2AttributeInternal:
 * @param ctx the user data (XML parser context)
 * @param fullname The attribute name, including namespace prefix
 * @param value The attribute value
 * @param prefix the prefix on the element node
 *
 * Handle an attribute that has been read by the parser.
 * The default handling is to convert the attribute into an
 * DOM subtree and past it in a new xmlAttr element added to
 * the element.
 */
static void
xmlSAX2AttributeInternal(void *ctx, const xmlChar *fullname,
             const xmlChar *value, const xmlChar *prefix ATTRIBUTE_UNUSED)
{
    // DONE: Find and refactor all "namespace" variables to not match C++ keyword
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    xmlAttrPtr ret;
    xmlChar *name;
    xmlChar *ns;
    xmlChar *nval;
    xmlNsPtr nameSpace;

    /*
     * Split the full name into a namespace prefix and the tag name
     */
    name = xmlSplitQName(ctxt, fullname, &ns);
    if ((name != NULL) && (name[0] == 0)) {
        if (xmlStrEqual(ns, BAD_CAST "xmlns")) {
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData,
                 EMBED_ERRTXT("invalid namespace declaration '%s'\n"), fullname);
        } else {
            if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
            ctxt->sax->warning(ctxt->userData,
                 EMBED_ERRTXT("Avoid attribute ending with ':' like '%s'\n"), fullname);
        }
        if (ns != NULL)
            xmlFree(ns);
        ns = NULL;
        xmlFree(name);
        name = xmlStrdup(fullname);
    }
    if (name == NULL) {
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData,EMBED_ERRTXT("SAX.xmlSAX2StartElement(): out of memory\n"));
        ctxt->errNo = XML_ERR_NO_MEMORY;
        ctxt->instate = XML_PARSER_EOF;
        ctxt->disableSAX = 1;
        if (ns != NULL)
            xmlFree(ns);
        return;
    }

#ifdef LIBXML_VALID_ENABLED
    /*
     * Do the last stage of the attribute normalization
     * Needed for HTML too:
     *   http://www.w3.org/TR/html4/types.html#h-6.2
     */
    ctxt->vctxt.valid = 1;
    nval = xmlValidCtxtNormalizeAttributeValue(&ctxt->vctxt,
                                       ctxt->myDoc, ctxt->node,
                       fullname, value);
    if (ctxt->vctxt.valid != 1) {
    ctxt->valid = 0;
    }
    if (nval != NULL)
    value = nval;
#else
    nval = NULL;
#endif /* LIBXML_VALID_ENABLED */

    /*
     * Check whether it's a namespace definition
     */
    if ((!ctxt->html) && (ns == NULL) &&
        (name[0] == 'x') && (name[1] == 'm') && (name[2] == 'l') &&
        (name[3] == 'n') && (name[4] == 's') && (name[5] == 0))
    {
        xmlNsPtr nsret;
        xmlChar *val;

        if (!ctxt->replaceEntities) {
            ctxt->depth++;
            val = xmlStringDecodeEntities(ctxt, value, XML_SUBSTITUTE_REF,0,0,0);
            ctxt->depth--;
        } else {
            val = (xmlChar *) value;
        }

        if (val[0] != 0) {
            xmlURIPtr uri;

            uri = xmlParseURI((const char *)val);
            if (uri == NULL) {
                if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
                    ctxt->sax->warning(ctxt->userData,
                     EMBED_ERRTXT("xmlns: %s not a valid URI\n"), val);
                } else {
                if (uri->scheme == NULL) {
                    if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
                    ctxt->sax->warning(ctxt->userData,
                         EMBED_ERRTXT("xmlns: URI %s is not absolute\n"), val);
                }
                xmlFreeURI(uri);
            }
        }

        /* a default namespace definition */
        nsret = xmlNewNs(ctxt->node, val, NULL);

#ifdef LIBXML_VALID_ENABLED
        /*
         * Validate also for namespace decls, they are attributes from
         * an XML-1.0 perspective
         */
        if (nsret != NULL   &&
            ctxt->validate  &&
            ctxt->wellFormed &&
            ctxt->myDoc && ctxt->myDoc->intSubset)
        {
            ctxt->valid &= xmlValidateOneNamespace(&ctxt->vctxt, ctxt->myDoc,
                           ctxt->node, prefix, nsret, val);
        }
#endif /* LIBXML_VALID_ENABLED */
        if (name != NULL)
            xmlFree(name);
        if (nval != NULL)
            xmlFree(nval);
        if (val != value)
            xmlFree(val);
        return;
    }

    if ((!ctxt->html) &&
        (ns != NULL) &&
        (ns[0] == 'x') && (ns[1] == 'm') && (ns[2] == 'l') &&
        (ns[3] == 'n') && (ns[4] == 's') && (ns[5] == 0))
    {
        xmlNsPtr nsret;
        xmlChar *val;

        if (!ctxt->replaceEntities) {
            ctxt->depth++;
            val = xmlStringDecodeEntities(ctxt, value, XML_SUBSTITUTE_REF,
                                      0,0,0);
            ctxt->depth--;
            if (val == NULL) {
                if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                    ctxt->sax->error(ctxt->userData, EMBED_ERRTXT("SAX.xmlSAX2StartElement(): out of memory\n"));
                ctxt->errNo = XML_ERR_NO_MEMORY;
                ctxt->instate = XML_PARSER_EOF;
                ctxt->disableSAX = 1;
                xmlFree(ns);
                if (name != NULL)
                    xmlFree(name);
                return;
            }
    } else {
        val = (xmlChar *) value;
    }

    if (val[0] == 0) {
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData, EMBED_ERRTXT("Empty namespace name for prefix %s\n"), name);
    }
    if ((ctxt->pedantic != 0) && (val[0] != 0)) {
        xmlURIPtr uri;

        uri = xmlParseURI((const char *)val);
        if (uri == NULL) {
        if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
            ctxt->sax->warning(ctxt->userData,
             EMBED_ERRTXT("xmlns:%s: %s not a valid URI\n"), name, value);
        } else {
        if (uri->scheme == NULL) {
            if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
            ctxt->sax->warning(ctxt->userData,
               EMBED_ERRTXT("xmlns:%s: URI %s is not absolute\n"), name, value);
        }
        xmlFreeURI(uri);
        }
    }

    /* a standard namespace definition */
    nsret = xmlNewNs(ctxt->node, val, name);
    xmlFree(ns);
#ifdef LIBXML_VALID_ENABLED
    /*
     * Validate also for namespace decls, they are attributes from
     * an XML-1.0 perspective
     */
        if (nsret != NULL && ctxt->validate && ctxt->wellFormed &&
        ctxt->myDoc && ctxt->myDoc->intSubset)
        ctxt->valid &= xmlValidateOneNamespace(&ctxt->vctxt, ctxt->myDoc,
                       ctxt->node, prefix, nsret, value);
#endif /* LIBXML_VALID_ENABLED */
    if (name != NULL)
        xmlFree(name);
    if (nval != NULL)
        xmlFree(nval);
    if (val != value)
        xmlFree(val);
    return;
    }

    if (ns != NULL) {
    xmlAttrPtr prop;
    nameSpace = xmlSearchNs(ctxt->myDoc, ctxt->node, ns);
    if (nameSpace == NULL) {
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
        ctxt->sax->error(ctxt->userData,
            EMBED_ERRTXT("Namespace prefix %s of attribute %s is not defined\n"),
                     ns, name);
    }

    prop = ctxt->node->properties;
    while (prop != NULL) {
        if (prop->ns != NULL) {
        if ((xmlStrEqual(name, prop->name)) &&
            ((nameSpace == prop->ns) ||
             (xmlStrEqual(nameSpace->href, prop->ns->href)))) {
            ctxt->errNo = XML_ERR_ATTRIBUTE_REDEFINED;
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData,
                    EMBED_ERRTXT("Attribute %s in %s redefined\n"),
                             name, nameSpace->href);
            ctxt->wellFormed = 0;
            if (ctxt->recovery == 0) ctxt->disableSAX = 1;
            goto error;
        }
        }
        prop = prop->next;
    }
    } else {
    nameSpace = NULL;
    }

    /* !!!!!! <a toto:arg="" xmlns:toto="http://toto.com"> */
    ret = xmlNewNsPropEatName(ctxt->node, nameSpace, name, NULL);

    if (ret != NULL) {
        if ((ctxt->replaceEntities == 0) && (!ctxt->html)) {
            xmlNodePtr tmp;

            ret->children = xmlStringGetNodeList(ctxt->myDoc, value);
            tmp = ret->children;
            while (tmp != NULL) {
            tmp->parent = (xmlNodePtr) ret;
            if (tmp->next == NULL)
                ret->last = tmp;
            tmp = tmp->next;
        }
    } else if (value != NULL) {
            ret->children = xmlNewDocText(ctxt->myDoc, value);
            ret->last = ret->children;
            if (ret->children != NULL)
                ret->children->parent = (xmlNodePtr) ret;
        }
    }

#ifdef LIBXML_VALID_ENABLED
    if ((!ctxt->html) && ctxt->validate && ctxt->wellFormed &&
        ctxt->myDoc && ctxt->myDoc->intSubset)
    {
        /*
         * If we don't substitute entities, the validation should be
         * done on a value with replaced entities anyway.
         */
        if (!ctxt->replaceEntities) {
            xmlChar *val;

            ctxt->depth++;
            val = xmlStringDecodeEntities(ctxt, value, XML_SUBSTITUTE_REF,0,0,0);
            ctxt->depth--;

            if (val == NULL)
                ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt, ctxt->myDoc, ctxt->node, ret, value);
            else {
                xmlChar *nvalnorm;

                /*
                 * Do the last stage of the attribute normalization
                 * It need to be done twice ... it's an extra burden related
                 * to the ability to keep xmlSAX2References in attributes
                 */
                nvalnorm = xmlValidNormalizeAttributeValue(ctxt->myDoc, ctxt->node, fullname, val);
                if (nvalnorm != NULL) {
                    xmlFree(val);
                    val = nvalnorm;
                }

                ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt, ctxt->myDoc, ctxt->node, ret, val);
                xmlFree(val);
            }
        } else {
            ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt, ctxt->myDoc, ctxt->node, ret, value);
        }
    } else
#endif /* LIBXML_VALID_ENABLED */
           if (((ctxt->loadsubset & XML_SKIP_IDS) == 0) &&
           (((ctxt->replaceEntities == 0) && (ctxt->external != 2)) ||
            ((ctxt->replaceEntities != 0) && (ctxt->inSubset == 0)))) {
     /*
     * when validating, the ID registration is done at the attribute
     * validation level. Otherwise we have to do specific handling here.
     */
    if (xmlIsID(ctxt->myDoc, ctxt->node, ret))
        xmlAddID(&ctxt->vctxt, ctxt->myDoc, value, ret);
    else if (xmlIsRef(ctxt->myDoc, ctxt->node, ret))
        xmlAddRef(&ctxt->vctxt, ctxt->myDoc, value, ret);
    else if (xmlStrEqual(fullname, BAD_CAST "xml:id")) {
        /*
         * Add the xml:id value
         *
         * Open issue: normalization of the value.
         */
        if (xmlValidateNCName(value, 1) != 0) {
            xmlErrValid(ctxt, XML_DTD_XMLID_VALUE,
                        EMBED_ERRTXT("xml:id : attribute value %s is not an NCName\n"),
                        (const char *) value, NULL);
        }
        xmlAddID(&ctxt->vctxt, ctxt->myDoc, value, ret);
    }
    }

error:
    if (nval != NULL)
        xmlFree(nval);
    if (ns != NULL)
        xmlFree(ns);
}

/*
 * xmlCheckDefaultedAttributes:
 *
 * Check defaulted attributes from the DTD
 */
static void
xmlCheckDefaultedAttributes(xmlParserCtxtPtr ctxt, const xmlChar *name,
    const xmlChar *prefix, const xmlChar **atts) {
    xmlElementPtr elemDecl;
    const xmlChar *att;
    int internal = 1;
    int i;

    elemDecl = xmlGetDtdQElementDesc(ctxt->myDoc->intSubset, name, prefix);
    if (elemDecl == NULL) {
        elemDecl = xmlGetDtdQElementDesc(ctxt->myDoc->extSubset, name, prefix);
        internal = 0;
    }

process_external_subset:

    if (elemDecl != NULL) {
    xmlAttributePtr attr = elemDecl->attributes;
    /*
     * Check against defaulted attributes from the external subset
     * if the document is stamped as standalone
     */
    if ((ctxt->myDoc->standalone == 1) &&
        (ctxt->myDoc->extSubset != NULL) &&
        (ctxt->validate)) {
        while (attr != NULL) {
        if ((attr->defaultValue != NULL) &&
            (xmlGetDtdQAttrDesc(ctxt->myDoc->extSubset,
                    attr->elem, attr->name,
                    attr->prefix) == attr) &&
            (xmlGetDtdQAttrDesc(ctxt->myDoc->intSubset,
                    attr->elem, attr->name,
                    attr->prefix) == NULL)) {
            xmlChar *fulln;

            if (attr->prefix != NULL) {
            fulln = xmlStrdup(attr->prefix);
            fulln = xmlStrcat(fulln, BAD_CAST ":");
            fulln = xmlStrcat(fulln, attr->name);
            } else {
            fulln = xmlStrdup(attr->name);
            }

            /*
             * Check that the attribute is not declared in the
             * serialization
             */
            att = NULL;
            if (atts != NULL) {
            i = 0;
            att = atts[i];
            while (att != NULL) {
                if (xmlStrEqual(att, fulln))
                break;
                i += 2;
                att = atts[i];
            }
            }
            if (att == NULL) {
                xmlErrValid(ctxt, XML_DTD_STANDALONE_DEFAULTED,
      EMBED_ERRTXT("standalone: attribute %s on %s defaulted from external subset\n"),
                    (const char *)fulln,
                    (const char *)attr->elem);
            }
        }
        attr = attr->nexth;
        }
    }

    /*
     * Actually insert defaulted values when needed
     */
    attr = elemDecl->attributes;
    while (attr != NULL) {
        /*
         * Make sure that attributes redefinition occuring in the
         * internal subset are not overriden by definitions in the
         * external subset.
         */
        if (attr->defaultValue != NULL) {
        /*
         * the element should be instantiated in the tree if:
         *  - this is a namespace prefix
         *  - the user required for completion in the tree
         *    like XSLT
         *  - there isn't already an attribute definition
         *    in the internal subset overriding it.
         */
        if (((attr->prefix != NULL) &&
             (xmlStrEqual(attr->prefix, BAD_CAST "xmlns"))) ||
            ((attr->prefix == NULL) &&
             (xmlStrEqual(attr->name, BAD_CAST "xmlns"))) ||
            (ctxt->loadsubset & XML_COMPLETE_ATTRS)) {
            xmlAttributePtr tst;

            tst = xmlGetDtdQAttrDesc(ctxt->myDoc->intSubset,
                         attr->elem, attr->name,
                         attr->prefix);
            if ((tst == attr) || (tst == NULL)) {
                xmlChar fn[50];
            xmlChar *fulln;

                        fulln = xmlBuildQName(attr->name, attr->prefix, fn, 50);
            if (fulln == NULL) {
                if ((ctxt->sax != NULL) &&
                    (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData,
                     EMBED_ERRTXT("SAX.xmlSAX2StartElement(): out of memory\n"));
                ctxt->errNo = XML_ERR_NO_MEMORY;
                ctxt->instate = XML_PARSER_EOF;
                ctxt->disableSAX = 1;
                return;
            }

            /*
             * Check that the attribute is not declared in the
             * serialization
             */
            att = NULL;
            if (atts != NULL) {
                i = 0;
                att = atts[i];
                while (att != NULL) {
                if (xmlStrEqual(att, fulln))
                    break;
                i += 2;
                att = atts[i];
                }
            }
            if (att == NULL) {
                xmlSAX2AttributeInternal(ctxt, fulln,
                         attr->defaultValue, prefix);
            }
            if ((fulln != fn) && (fulln != attr->name))
                xmlFree(fulln);
            }
        }
        }
        attr = attr->nexth;
    }
    if (internal == 1) {
        elemDecl = xmlGetDtdQElementDesc(ctxt->myDoc->extSubset,
                                     name, prefix);
        internal = 0;
        goto process_external_subset;
    }
    }
}

/**
 * xmlSAX2StartElement:
 * @param ctx the user data (XML parser context)
 * @param fullname The element name, including namespace prefix
 * @param atts An array of name/value attributes pairs, NULL terminated
 *
 * called when an opening tag has been processed.
 */
XMLPUBFUNEXPORT void
xmlSAX2StartElement(void *ctx, const xmlChar *fullname, const xmlChar **atts)
{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    xmlNodePtr ret;
    xmlNodePtr parent = ctxt->node;
    xmlNsPtr ns;
    xmlChar *name;
    xmlChar *prefix;
    const xmlChar *att;
    const xmlChar *value;
    int i;

#ifdef DEBUG_SAX
    xmlGenericError(xmlGenericErrorContext,
        "SAX.xmlSAX2StartElement(%s)\n", fullname);
#endif

    /*
     * First check on validity:
     */
    if (ctxt->validate && (ctxt->myDoc->extSubset == NULL) &&
        ((ctxt->myDoc->intSubset == NULL) ||
     ((ctxt->myDoc->intSubset->notations == NULL) &&
      (ctxt->myDoc->intSubset->elements == NULL) &&
      (ctxt->myDoc->intSubset->attributes == NULL) &&
      (ctxt->myDoc->intSubset->entities == NULL)))) {
    xmlErrValid(ctxt, XML_ERR_NO_DTD,
      EMBED_ERRTXT("Validation failed: no DTD found !"), NULL, NULL);
    ctxt->validate = 0;
    }


    /*
     * Split the full name into a namespace prefix and the tag name
     */
    name = xmlSplitQName(ctxt, fullname, &prefix);


    /*
     * Note : the namespace resolution is deferred until the end of the
     *        attributes parsing, since local namespace can be defined as
     *        an attribute at this level.
     */
    ret = xmlNewDocNodeEatName(ctxt->myDoc, NULL, name, NULL);
    if (ret == NULL) {
        if (prefix != NULL)
            xmlFree(prefix);
        ctxt->errNo = XML_ERR_NO_MEMORY;
        ctxt->instate = XML_PARSER_EOF;
        ctxt->disableSAX = 1;
        return;
    }
    if (ctxt->myDoc->children == NULL) {
#ifdef DEBUG_SAX_TREE
        xmlGenericError(xmlGenericErrorContext, "Setting %s as root\n", name);
#endif
        xmlAddChild((xmlNodePtr) ctxt->myDoc, (xmlNodePtr) ret);
    } else if (parent == NULL) {
        parent = ctxt->myDoc->children;
    }
    ctxt->nodemem = -1;

#ifdef LIBXML_ENABLE_NODE_LINEINFO
    if (ctxt->linenumbers) {
        if (ctxt->input != NULL) {
            if (ctxt->input->line < 65535)
                ret->line = (short) ctxt->input->line;
            else
                ret->line = 65535;
        }
    }
#endif
    /*
     * We are parsing a new node.
     */
#ifdef DEBUG_SAX_TREE
    xmlGenericError(xmlGenericErrorContext, "pushing(%s)\n", name);
#endif
    nodePush(ctxt, ret);

    /*
     * Link the child element
     */
    if (parent != NULL) {
        if (parent->type == XML_ELEMENT_NODE) {
#ifdef DEBUG_SAX_TREE
        xmlGenericError(xmlGenericErrorContext,"adding child %s to %s\n", name, parent->name);
#endif
            xmlAddChild(parent, ret);
        } else {
#ifdef DEBUG_SAX_TREE
            xmlGenericError(xmlGenericErrorContext,"adding sibling %s to ", name);
            xmlDebugDumpOneNode(stderr, parent, 0);
#endif
            xmlAddSibling(parent, ret);
        }
    }

    /*
     * Insert all the defaulted attributes from the DTD especially namespaces
     */
    
    if ((!ctxt->html) &&
        ((ctxt->myDoc->intSubset != NULL) || (ctxt->myDoc->extSubset != NULL)))
    {
        xmlCheckDefaultedAttributes(ctxt, name, prefix, atts);
    }

    /*
     * process all the attributes whose name start with "xmlns"
     */
    if (atts != NULL) {
        i = 0;
        att = atts[i++];
        value = atts[i++];
        if (!ctxt->html) {
            while ((att != NULL) && (value != NULL)) {
                if ((att[0] == 'x') && (att[1] == 'm') && (att[2] == 'l') &&
                    (att[3] == 'n') && (att[4] == 's'))
                    xmlSAX2AttributeInternal(ctxt, att, value, prefix);

                att = atts[i++];
                value = atts[i++];
            }
        }
    }

    /*
     * Search the namespace, note that since the attributes have been
     * processed, the local namespaces are available.
     */
    ns = xmlSearchNs(ctxt->myDoc, ret, prefix);
    if ((ns == NULL) && (parent != NULL))
        ns = xmlSearchNs(ctxt->myDoc, parent, prefix);
    
    if ((prefix != NULL) && (ns == NULL)) {
        ns = xmlNewNs(ret, NULL, prefix);
        if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
            ctxt->sax->warning(ctxt->userData,EMBED_ERRTXT("Namespace prefix %s is not defined\n"), prefix);
    }

    /*
     * set the namespace node, making sure that if the default namspace
     * is unbound on a parent we simply kee it NULL
     */
    if ((ns != NULL) && (ns->href != NULL) &&
        ((ns->href[0] != 0) || (ns->prefix != NULL)))
        xmlSetNs(ret, ns);

    /*
     * process all the other attributes
     */
    if (atts != NULL) {
        i = 0;
        att = atts[i++];
        value = atts[i++];
        if (ctxt->html) {
            while (att != NULL) {
                xmlSAX2AttributeInternal(ctxt, att, value, NULL);
                att = atts[i++];
                value = atts[i++];
            }
        } else {
            while ((att != NULL) && (value != NULL)) {
                if ((att[0] != 'x') || (att[1] != 'm') || (att[2] != 'l') ||
                    (att[3] != 'n') || (att[4] != 's'))
                    xmlSAX2AttributeInternal(ctxt, att, value, NULL);

                /*
                 * Next ones
                 */
                att = atts[i++];
                value = atts[i++];
            }
        }
    }

#ifdef LIBXML_VALID_ENABLED
    /*
     * If it's the Document root, finish the DTD validation and
     * check the document root element for validity
     */
    if ((ctxt->validate) && (ctxt->vctxt.finishDtd == 0)) {
    int chk;

    chk = xmlValidateDtdFinal(&ctxt->vctxt, ctxt->myDoc);
    if (chk <= 0)
        ctxt->valid = 0;
    if (chk < 0)
        ctxt->wellFormed = 0;
    ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
    ctxt->vctxt.finishDtd = 1;
    }
#endif /* LIBXML_VALID_ENABLED */

    if (prefix != NULL)
    xmlFree(prefix);

}

/**
 * xmlSAX2EndElement:
 * @param ctx the user data (XML parser context)
 * @param name The element name
 *
 * called when the end of an element has been detected.
 */
XMLPUBFUNEXPORT void
xmlSAX2EndElement(void *ctx, const xmlChar *name ATTRIBUTE_UNUSED)
{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    //xmlParserNodeInfo node_info;
    xmlNodePtr cur = ctxt->node;

#ifdef DEBUG_SAX
    if (name == NULL)
        xmlGenericError(xmlGenericErrorContext, "SAX.xmlSAX2EndElement(NULL)\n");
    else
    xmlGenericError(xmlGenericErrorContext, "SAX.xmlSAX2EndElement(%s)\n", name);
#endif

#ifdef XMLENGINE_ENABLE_PARSER_RECORD_INFO
    /* Capture end position and add node */
    if (cur != NULL && ctxt->record_info) {
      node_info.end_pos = ctxt->input->cur - ctxt->input->base;
      node_info.end_line = ctxt->input->line;
      node_info.node = cur;
      xmlParserAddNodeInfo(ctxt, &node_info);
    }
#endif // XMLENGINE_ENABLE_PARSER_RECORD_INFO

    ctxt->nodemem = -1;

#ifdef LIBXML_VALID_ENABLED
    if (ctxt->validate && ctxt->wellFormed &&
        ctxt->myDoc && ctxt->myDoc->intSubset)
        ctxt->valid &= xmlValidateOneElement(&ctxt->vctxt, ctxt->myDoc,
                         cur);
#endif /* LIBXML_VALID_ENABLED */


    /*
     * end of parsing of this node.
     */
#ifdef DEBUG_SAX_TREE
    xmlGenericError(xmlGenericErrorContext, "popping(%s)\n", cur->name);
#endif
    nodePop(ctxt);
}
#endif /* LIBXML_SAX1_ENABLED || LIBXML_HTML_ENABLE */

/*
 * xmlSAX2TextNode:
 * @param ctxt the parser context
 * @param str the input string
 * @param len the string length
 *
 * Remove the entities from an attribute value
 *
 * Returns the newly allocated string or NULL if not needed or error
 */
static xmlNodePtr
xmlSAX2TextNode(xmlParserCtxtPtr ctxt, const xmlChar *str, int len) {
	LOAD_GS(ctxt)
    xmlNodePtr ret;
    const xmlChar *intern = NULL;

    /*
     * Allocate
     */
    if (ctxt->freeElems != NULL) {
        ret = ctxt->freeElems;
        ctxt->freeElems = ret->next;
        ctxt->freeElemsNr--;
    } else {
        ret = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
    }
    if (ret == NULL) {
OOM:
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData, EMBED_ERRTXT("SAX.xmlSAX2Characters(): out of memory\n"));
        ctxt->errNo = XML_ERR_NO_MEMORY;
        ctxt->instate = XML_PARSER_EOF;
        ctxt->disableSAX = 1;
        return(NULL);
    }
    /*
     * intern the formatting blanks found between tags, or the
     * very short strings
     */
    if (ctxt->dictNames) {
        xmlChar cur = str[len];

        if ((len <= 3) && ((cur == '"') || (cur == '\'') ||
            ((cur == '<') && (str[len + 1] != '!'))))
        {
            intern = xmlDictLookup(ctxt->dict, str, len);
        }
        else if (IS_BLANK_CH(*str) && (len < 60) && (cur == '<') &&
                   (str[len + 1] != '!'))
           {
                int i;

                for (i = 1;i < len;i++) {
                    if (!IS_BLANK_CH(str[i])) goto skip;
                }
                intern = xmlDictLookup(ctxt->dict, str, len);
            }
    }
skip:
    memset(ret, 0, sizeof(xmlNode));
    ret->type = XML_TEXT_NODE;

    ret->name = xmlStringText;
    if (intern == NULL)
    	{
    	ret->content = xmlStrndup(str, len);
    		{
    		if(OOM_FLAG)
    			{
			    if (ctxt->freeElems != NULL) 
			    	{ 
			    	ctxt->freeElemsNr++;   			
			        ret->next = ctxt->freeElems;
			        ctxt->freeElems = ret;
			    	}
			    else
			    	{
			    	xmlFreeNode(ret);
			    	}
			    goto OOM;
    			}
    		}
    	}
    else
        ret->content = (xmlChar *) intern;

    if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
        xmlRegisterNodeDefaultValue(ret);
    return(ret);
}

#ifdef LIBXML_VALID_ENABLED
/*
 * xmlSAX2DecodeAttrEntities:
 * @param ctxt the parser context
 * @param str the input string
 * @param len the string length
 *
 * Remove the entities from an attribute value
 *
 * Returns the newly allocated string or NULL if not needed or error
 */
static xmlChar *
xmlSAX2DecodeAttrEntities(xmlParserCtxtPtr ctxt, const xmlChar *str,
                          const xmlChar *end) {
    const xmlChar *in;
    xmlChar *ret;

    in = str;
    while (in < end)
        if (*in++ == '&')
        goto decode;
    return(NULL);
decode:
    ctxt->depth++;
    ret = xmlStringLenDecodeEntities(ctxt, str, end - str,
                     XML_SUBSTITUTE_REF, 0,0,0);
    ctxt->depth--;
    return(ret);
}
#endif /* LIBXML_VALID_ENABLED */


/**
 * xmlSAX2AttributeNs:
 * @param ctx the user data (XML parser context)
 * @param localname the local name of the attribute
 * @param prefix the attribute namespace prefix if available
 * @param URI the attribute namespace name if available
 * @param value Start of the attribute value
 * @param valueend end of the attribute value
 *
 * Handle an attribute that has been read by the parser.
 * The default handling is to convert the attribute into an
 * DOM subtree and past it in a new xmlAttr element added to
 * the element.
 */
static void
xmlSAX2AttributeNs(xmlParserCtxtPtr ctxt,
                   const xmlChar* localname,
                   const xmlChar* prefix,
                   const xmlChar* value,
                   const xmlChar* valueend)
{
	LOAD_GS(ctxt)
    xmlAttrPtr ret;
    xmlNsPtr nameSpace = NULL;
    xmlChar *dup = NULL;

    /*
     * Note: if prefix == NULL, the attribute is not in the default namespace
     */
    if (prefix != NULL)
        nameSpace = xmlSearchNs(ctxt->myDoc, ctxt->node, prefix);

    /*
     * allocate the node
     */
    if (ctxt->freeAttrs != NULL)
    {
        ret = ctxt->freeAttrs;
        ctxt->freeAttrs = ret->next;
        ctxt->freeAttrsNr--;
        memset(ret, 0, sizeof(xmlAttr));
        ret->type = XML_ATTRIBUTE_NODE;

        ret->parent = ctxt->node;
        ret->doc = ctxt->myDoc;
        ret->ns = nameSpace;

        if (ctxt->dictNames)
            ret->name = localname;
        else
            ret->name = xmlStrdup(localname);

            
        if (ctxt->node->properties == NULL) {
            ctxt->node->properties = ret;
        } else {
            xmlAttrPtr prev = ctxt->node->properties;

            while (prev->next != NULL) prev = prev->next;
            prev->next = ret;
            ret->prev = prev;
        }

        if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
            xmlRegisterNodeDefaultValue((xmlNodePtr)ret);
    } else {
        if (ctxt->dictNames)
            ret = xmlNewNsPropEatName(ctxt->node, nameSpace,
                                      (xmlChar *) localname, NULL);
        else
            ret = xmlNewNsProp(ctxt->node, nameSpace, localname, NULL);
        if (ret == NULL) {
            ctxt->errNo = XML_ERR_NO_MEMORY;
            ctxt->instate = XML_PARSER_EOF;
            ctxt->disableSAX = 1;
            return;
        }
    }

    if ((ctxt->replaceEntities == 0) && (!ctxt->html))
    {
        xmlNodePtr tmp;

        /*
         * We know that if there is an entity reference, then
         * the string has been dup'ed and terminates with 0
         * otherwise with ' or "
         */
        if (*valueend != 0) {
            tmp = xmlSAX2TextNode(ctxt, value, valueend - value);
		    if(OOM_FLAG) 
		    	{
		    	xmlFree(dup);
		    	return;
		    	}
            ret->children = tmp;
            ret->last = tmp;
            if (tmp != NULL) {
            tmp->doc = ret->doc;
            tmp->parent = (xmlNodePtr) ret;
            }
        } else {
            ret->children = xmlStringLenGetNodeList(ctxt->myDoc, value, valueend - value);
            
            tmp = ret->children;
            while (tmp != NULL) {
            tmp->parent = (xmlNodePtr) ret;
            if (tmp->next == NULL)
                ret->last = tmp;
            tmp = tmp->next;
            }
        }
    } else if (value != NULL) {
        xmlNodePtr tmp;

        tmp = xmlSAX2TextNode(ctxt, value, valueend - value);
        ret->children = tmp;
        ret->last = tmp;
        if (tmp != NULL) {
            tmp->doc = ret->doc;
            tmp->parent = (xmlNodePtr) ret;
        }
    }

#ifdef LIBXML_VALID_ENABLED
    if ((!ctxt->html) && ctxt->validate && ctxt->wellFormed &&
        ctxt->myDoc && ctxt->myDoc->intSubset) {
    /*
     * If we don't substitute entities, the validation should be
     * done on a value with replaced entities anyway.
     */
        if (!ctxt->replaceEntities) {
        dup = xmlSAX2DecodeAttrEntities(ctxt, value, valueend);
        if (dup == NULL) {
            if (*valueend == 0) {
            ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
                    ctxt->myDoc, ctxt->node, ret, value);
        } else {
            /*
             * That should already be normalized.
             * cheaper to finally allocate here than duplicate
             * entry points in the full validation code
             */
            dup = xmlStrndup(value, valueend - value);

            ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
                    ctxt->myDoc, ctxt->node, ret, dup);
        }
        } else {
            /*
         * dup now contains a string of the flattened attribute
         * content with entities substitued. Check if we need to
         * apply an extra layer of normalization.
         * It need to be done twice ... it's an extra burden related
         * to the ability to keep references in attributes
         */
        if (ctxt->attsSpecial != NULL) {
            xmlChar *nvalnorm;
            xmlChar fn[50];
            xmlChar *fullname;

            fullname = xmlBuildQName(localname, prefix, fn, 50);
            if (fullname != NULL) {
            ctxt->vctxt.valid = 1;
                nvalnorm = xmlValidCtxtNormalizeAttributeValue(
                             &ctxt->vctxt, ctxt->myDoc,
                     ctxt->node, fullname, dup);
            if (ctxt->vctxt.valid != 1)
                ctxt->valid = 0;

            if ((fullname != fn) && (fullname != localname))
                xmlFree(fullname);
            if (nvalnorm != NULL) {
                xmlFree(dup);
                dup = nvalnorm;
            }
            }
        }

        ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
                    ctxt->myDoc, ctxt->node, ret, dup);
        }
    } else {
        /*
         * if entities already have been substitued, then
         * the attribute as passed is already normalized
         */
        dup = xmlStrndup(value, valueend - value);

        ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
                                 ctxt->myDoc, ctxt->node, ret, dup);
    }
    } else
#endif /* LIBXML_VALID_ENABLED */
           if (((ctxt->loadsubset & XML_SKIP_IDS) == 0) &&
           (((ctxt->replaceEntities == 0) && (ctxt->external != 2)) ||
            ((ctxt->replaceEntities != 0) && (ctxt->inSubset == 0)))) {
        /*
     * when validating, the ID registration is done at the attribute
     * validation level. Otherwise we have to do specific handling here.
     */
    if (xmlIsID(ctxt->myDoc, ctxt->node, ret)) {
        /* might be worth duplicate entry points and not copy */
        if (dup == NULL)
            dup = xmlStrndup(value, valueend - value);
        xmlAddID(&ctxt->vctxt, ctxt->myDoc, dup, ret);
    } else if (xmlIsRef(ctxt->myDoc, ctxt->node, ret)) {
        if (dup == NULL)
            dup = xmlStrndup(value, valueend - value);
        xmlAddRef(&ctxt->vctxt, ctxt->myDoc, dup, ret);
        } else if ((prefix == ctxt->str_xml) &&
               (localname[0] == 'i') && (localname[1] == 'd') &&
           (localname[2] == 0)) {
        /*
         * Add the xml:id value
         *
         * Open issue: normalization of the value.
         */
        if (dup == NULL)
            dup = xmlStrndup(value, valueend - value);
        if (xmlValidateNCName(dup, 1) != 0) {
            xmlErrValid(ctxt, XML_DTD_XMLID_VALUE,
              EMBED_ERRTXT("xml:id : attribute value %s is not an NCName\n"),
                (const char *) dup, NULL);
        }
        xmlAddID(&ctxt->vctxt, ctxt->myDoc, dup, ret);
    }
    }
    if (dup != NULL)
    xmlFree(dup);
}

/**
 * xmlSAX2StartElementNs:
 * @param ctx the user data (XML parser context)
 * @param localname the local name of the element
 * @param prefix the element namespace prefix if available
 * @param URI the element namespace name if available
 * @param nb_namespaces number of namespace definitions on that node
 * @param namespaces pointer to the array of prefix/URI pairs namespace definitions
 * @param nb_attributes the number of attributes on that node
 * @param nb_defaulted the number of defaulted attributes.
 * @param attributes pointer to the array of (localname/prefix/URI/value/end)
 *               attribute values.
 *
 * SAX2 callback when an element start has been detected by the parser.
 * It provides the namespace informations for the element, as well as
 * the new namespace declarations on the element.
 */
XMLPUBFUNEXPORT void
xmlSAX2StartElementNs(void* ctx,
                      const xmlChar *localname,
                      const xmlChar *prefix,
                      const xmlChar *URI,
                      int nb_namespaces,
                      const xmlChar **namespaces,
                      int nb_attributes,
                      int nb_defaulted,
                      const xmlChar **attributes)
{
	xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    xmlNodePtr ret;
    xmlNodePtr parent = ctxt->node;
    xmlNsPtr last = NULL, ns;
    const xmlChar *uri, *pref;
    int i, j;
	LOAD_GS_SAFE_CTXT(ctxt)
	
    
    /*
     * First check on validity:
     */
    if (ctxt->validate &&
            (ctxt->myDoc->extSubset == NULL) &&
               ((ctxt->myDoc->intSubset == NULL)
                    ||
                ((ctxt->myDoc->intSubset->notations == NULL) &&
                 (ctxt->myDoc->intSubset->elements  == NULL) &&
                 (ctxt->myDoc->intSubset->attributes == NULL)&&
                 (ctxt->myDoc->intSubset->entities  == NULL)
                 )
             )
        )
    {
        xmlErrValid(ctxt, XML_ERR_NO_DTD, EMBED_ERRTXT("Validation failed: no DTD found !"), NULL, NULL);
        ctxt->validate = 0;
    }

    /*
     * allocate the node
     */
    if (ctxt->freeElems != NULL) {
        ret = ctxt->freeElems;
        ctxt->freeElems = ret->next;
        ctxt->freeElemsNr--;
        memset(ret, 0, sizeof(xmlNode));
        ret->type = XML_ELEMENT_NODE;

        if (ctxt->dictNames)
            ret->name = localname;
        else
            ret->name = xmlStrdup(localname); 

        if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
            xmlRegisterNodeDefaultValue(ret);
    } else {
        if (ctxt->dictNames)
            ret = xmlNewDocNodeEatName(ctxt->myDoc, NULL,
                                       (xmlChar *) localname, NULL);
        else
            ret = xmlNewDocNode(ctxt->myDoc, NULL, localname, NULL);

        if (ret == NULL) {
            ctxt->errNo = XML_ERR_NO_MEMORY;
            ctxt->instate = XML_PARSER_EOF;
            ctxt->disableSAX = 1;
            return;
        }
    }
#ifdef LIBXML_ENABLE_NODE_LINEINFO
    if (ctxt->linenumbers) {
        if (ctxt->input != NULL) {
            if (ctxt->input->line < 65535)
                ret->line = (short) ctxt->input->line;
            else
                ret->line = 65535;
        }
    }
#endif

    if (ctxt->myDoc->children == NULL) {
        xmlAddChild((xmlNodePtr) ctxt->myDoc, (xmlNodePtr) ret);
    } else if (parent == NULL) {
        parent = ctxt->myDoc->children;
    }
    /*
     * Build the namespace list
     */
    for (i = 0,j = 0;j < nb_namespaces;j++)
    {
        pref = namespaces[i++];
        uri = namespaces[i++];
        // NULL passed in order to avoid uniqueness check in xmlNewNs(),
        ns = xmlNewNs(NULL, uri, pref);
        // ... but then we need to link new Ns node manually
        if (ns != NULL) {
            if (last == NULL) {
                ret->nsDef = last = ns;
            } else {
                last->next = ns;
                last = ns;
            }
            if ((URI != NULL) && (prefix == pref))
                ret->ns = ns;
        } else {
            ctxt->errNo = XML_ERR_NO_MEMORY;
            ctxt->instate = XML_PARSER_EOF;
            ctxt->disableSAX = 1;
            //DONE: OOM: cleanup:
            if(ctxt->myDoc->children != ret)
                xmlFreeNode(ret); // it was not yet inserted in myDoc
            return;
        }
#ifdef LIBXML_VALID_ENABLED
        if (ctxt->validate && (!ctxt->html) && ctxt->wellFormed &&
            ctxt->myDoc && ctxt->myDoc->intSubset)
        {
            ctxt->valid &= xmlValidateOneNamespace(&ctxt->vctxt, ctxt->myDoc,
                                                   ret, prefix, ns, uri);
        }
#endif /* LIBXML_VALID_ENABLED */
    } // for (i = 0,j = 0;j < nb_namespaces;j++)

    ctxt->nodemem = -1;

    /*
     * We are parsing a new node.
     */
    nodePush(ctxt, ret); 

    /*
     * Link the child element
     */
    if (parent != NULL) {
        if (parent->type == XML_ELEMENT_NODE) {
            xmlAddChild(parent, ret);
        } else {
            xmlAddSibling(parent, ret);
        }
    }

    /*
     * Insert the defaulted attributes from the DTD only if requested:
     */
    if ((nb_defaulted != 0) &&
        ((ctxt->loadsubset & XML_COMPLETE_ATTRS) == 0))
    {
        nb_attributes -= nb_defaulted;
    }

    /*
     * Search the namespace if it wasn't already found
     */
    if ((URI != NULL) && (ret->ns == NULL)) {
        ret->ns = xmlSearchNs(ctxt->myDoc, parent, prefix);
        if (ret->ns == NULL) {
            ns = xmlNewNs(ret, NULL, prefix);
            if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
            ctxt->sax->warning(ctxt->userData,
                 EMBED_ERRTXT("Namespace prefix %s was not found\n"), prefix);
        }
    }

    /*
     * process all the other attributes
     */
        if (nb_attributes > 0) {
            for (j = 0,i = 0;i < nb_attributes;i++,j+=5) {
            
            xmlSAX2AttributeNs(ctxt, attributes[j], attributes[j+1],
                               attributes[j+3], attributes[j+4]);  
		    if(OOM_FLAG) 
		    	{
		    	return;
		    	}                               
        }
    }

#ifdef LIBXML_VALID_ENABLED
    /*
     * If it's the Document root, finish the DTD validation and
     * check the document root element for validity
     */
    if ((ctxt->validate) && (ctxt->vctxt.finishDtd == 0)) {
    int chk;

    chk = xmlValidateDtdFinal(&ctxt->vctxt, ctxt->myDoc);
    if (chk <= 0)
        ctxt->valid = 0;
    if (chk < 0)
        ctxt->wellFormed = 0;
    ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
    ctxt->vctxt.finishDtd = 1;
    }
#endif /* LIBXML_VALID_ENABLED */
}

/**
 * xmlSAX2EndElementNs:
 * @param ctx the user data (XML parser context)
 * @param localname the local name of the element
 * @param prefix the element namespace prefix if available
 * @param URI the element namespace name if available
 *
 * SAX2 callback when an element end has been detected by the parser.
 * It provides the namespace informations for the element.
 */

XMLPUBFUNEXPORT void
xmlSAX2EndElementNs(void *ctx,
                    const xmlChar * localname ATTRIBUTE_UNUSED,
                    const xmlChar * prefix ATTRIBUTE_UNUSED,
            const xmlChar * URI ATTRIBUTE_UNUSED)
{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
#if defined(LIBXML_VALID_ENABLED) || defined(XMLENGINE_ENABLE_PARSER_RECORD_INFO)
    xmlNodePtr cur = ctxt->node;
#endif

#ifdef XMLENGINE_ENABLE_PARSER_RECORD_INFO
    {
    xmlParserNodeInfo node_info;

    /* Capture end position and add node */
    if ((ctxt->record_info) && (cur != NULL)) {
        node_info.end_pos = ctxt->input->cur - ctxt->input->base;
        node_info.end_line = ctxt->input->line;
        node_info.node = cur;
        xmlParserAddNodeInfo(ctxt, &node_info);
    }
    }
#endif

    ctxt->nodemem = -1;

#ifdef LIBXML_VALID_ENABLED
    if (ctxt->validate && ctxt->wellFormed &&
        ctxt->myDoc && ctxt->myDoc->intSubset)
        ctxt->valid &= xmlValidateOneElement(&ctxt->vctxt, ctxt->myDoc, cur);
#endif /* LIBXML_VALID_ENABLED */

    /*
     * end of parsing of this node.
     */
    nodePop(ctxt);
}

/**
 * xmlSAX2Reference:
 * @param ctx the user data (XML parser context)
 * @param name The entity name
 *
 * called when an entity xmlSAX2Reference is detected.
 */
XMLPUBFUNEXPORT void
xmlSAX2Reference(void *ctx, const xmlChar *name)
{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    xmlNodePtr ret;

#ifdef DEBUG_SAX
    xmlGenericError(xmlGenericErrorContext,
        "SAX.xmlSAX2Reference(%s)\n", name);
#endif
    if (name[0] == '#')
        ret = xmlNewCharRef(ctxt->myDoc, name);
    else
        ret = xmlNewReference(ctxt->myDoc, name);
#ifdef DEBUG_SAX_TREE
    xmlGenericError(xmlGenericErrorContext,
        "add xmlSAX2Reference %s to %s \n", name, ctxt->node->name);
#endif
    xmlAddChild(ctxt->node, ret);
}

/**
 * xmlSAX2Characters:
 * @param ctx the user data (XML parser context)
 * @param ch a xmlChar string
 * @param len the number of xmlChar
 *
 * receiving some chars from the parser.
 */
XMLPUBFUNEXPORT void
xmlSAX2Characters(void *ctx, const xmlChar *ch, int len)
{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    xmlNodePtr lastChild;

	/*
	 *   SYMBIAN DEF130695 FIX : Ensuring that CTX(xml buffer context) is valid or not. The CTX is being considered 
     *                           here while receiving parsed characters using SAX parsing mechanism.	       
	 */
	if(ctx == NULL)
		return;


#ifdef DEBUG_SAX
    xmlGenericError(xmlGenericErrorContext, "SAX.xmlSAX2Characters(%.30s, %d)\n", ch, len);
#endif
    /*
     * Handle the data if any. If there is no child
     * add it as content, otherwise if the last child is text,
     * concatenate it, else create a new node of type text.
     */

    if (ctxt->node == NULL) {
#ifdef DEBUG_SAX_TREE
        xmlGenericError(xmlGenericErrorContext, "add chars: ctxt->node == NULL !\n");
#endif
        return;
    }
    lastChild = ctxt->node->last;
#ifdef DEBUG_SAX_TREE
    xmlGenericError(xmlGenericErrorContext, "add chars to %s \n", ctxt->node->name);
#endif

    /*
     * Here we needed an accelerator mechanism in case of very large
     * elements. Use an attribute in the structure !!!
     */
    if (lastChild == NULL) {
        lastChild = xmlSAX2TextNode(ctxt, ch, len);
        
        if (lastChild != NULL) {
            ctxt->node->children = lastChild;
            ctxt->node->last = lastChild;
            lastChild->parent = ctxt->node;
            lastChild->doc = ctxt->node->doc;
            ctxt->nodelen = len;
            ctxt->nodemem = len + 1;
        }
    } else {
    int coalesceText = (lastChild != NULL) &&
        (lastChild->type == XML_TEXT_NODE) &&
        (lastChild->name == xmlStringText);
    if ((coalesceText) && (ctxt->nodemem != 0)) {
        /*
         * The whole point of maintaining nodelen and nodemem,
         * xmlTextConcat is too costly, i.e. compute length,
         * reallocate a new buffer, move data, append ch. Here
         * We try to minimaze realloc() uses and avoid copying
         * and recomputing length over and over.
         */
        if ((ctxt->nodemem == ctxt->nodelen + 1) &&
            (xmlDictOwns(ctxt->dict, lastChild->content)))
        {
            lastChild->content = xmlStrdup(lastChild->content);
        }
        if (ctxt->nodelen + len >= ctxt->nodemem) {
            xmlChar *newbuf;
            int size;

            size = ctxt->nodemem + len;
            size *= 2;
            newbuf = (xmlChar *) xmlRealloc(lastChild->content,size);
            if (newbuf == NULL) {
                if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                    ctxt->sax->error(ctxt->userData, EMBED_ERRTXT("SAX.xmlSAX2Characters(): out of memory\n"));
                ctxt->errNo = XML_ERR_NO_MEMORY;
                ctxt->instate = XML_PARSER_EOF;
                ctxt->disableSAX = 1;
                return;
            }
            ctxt->nodemem = size;
            lastChild->content = newbuf;
        }
        memcpy(&lastChild->content[ctxt->nodelen], ch, len);
        ctxt->nodelen += len;
        lastChild->content[ctxt->nodelen] = 0;
    } else if (coalesceText) {
        if (xmlTextConcat(lastChild, ch, len)) {
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData, EMBED_ERRTXT("SAX.xmlSAX2Characters(): out of memory\n"));
            ctxt->errNo = XML_ERR_NO_MEMORY;
            ctxt->instate = XML_PARSER_EOF;
            ctxt->disableSAX = 1;
        }
        if (ctxt->node->children != NULL) {
            ctxt->nodelen = xmlStrlen(lastChild->content);
            ctxt->nodemem = ctxt->nodelen + 1;
        }
    } else {
        /* Mixed content, first time */
        lastChild = xmlSAX2TextNode(ctxt, ch, len);
        if (lastChild != NULL) {
            xmlAddChild(ctxt->node, lastChild);
            if (ctxt->node->children != NULL) {
                ctxt->nodelen = len;
                ctxt->nodemem = len + 1;
            }
        }
    }
    }
}

/**
 * xmlSAX2IgnorableWhitespace:
 * @param ctx the user data (XML parser context)
 * @param ch a xmlChar string
 * @param len the number of xmlChar
 *
 * receiving some ignorable whitespaces from the parser.
 * UNUSED: by default the DOM building will use xmlSAX2Characters
 */
XMLPUBFUNEXPORT void
xmlSAX2IgnorableWhitespace(void *ctx ATTRIBUTE_UNUSED, const xmlChar *ch ATTRIBUTE_UNUSED, int len ATTRIBUTE_UNUSED)
{
    /* xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; */
#ifdef DEBUG_SAX
    xmlGenericError(xmlGenericErrorContext, "SAX.xmlSAX2IgnorableWhitespace(%.30s, %d)\n", ch, len);
#endif
    if(ctx) return; // just to use ctx
}

/**
 * xmlSAX2ProcessingInstruction:
 * @param ctx the user data (XML parser context)
 * @param target the target name
 * @param data the PI data's
 *
 * A processing instruction has been parsed.
 */
XMLPUBFUNEXPORT void
xmlSAX2ProcessingInstruction(void *ctx,
                             const xmlChar *target,
                             const xmlChar *data)
{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    xmlNodePtr ret;
    xmlNodePtr parent = ctxt->node;

#ifdef DEBUG_SAX
    xmlGenericError(xmlGenericErrorContext,
        "SAX.xmlSAX2ProcessingInstruction(%s, %s)\n", target, data);
#endif

    ret = xmlNewPI(target, data);
    if (!ret)
        return;
    parent = ctxt->node;

    if (ctxt->inSubset == 1) {
        xmlAddChild((xmlNodePtr) ctxt->myDoc->intSubset, ret);
        return;
    } else
    if (ctxt->inSubset == 2) {
        xmlAddChild((xmlNodePtr) ctxt->myDoc->extSubset, ret);
        return;
    }
    if ((ctxt->myDoc->children == NULL) || (parent == NULL)) {
#ifdef DEBUG_SAX_TREE
        xmlGenericError(xmlGenericErrorContext,"Setting PI %s as root\n", target);
#endif
        xmlAddChild((xmlNodePtr) ctxt->myDoc, (xmlNodePtr) ret);
        return;
    }
    if (parent->type == XML_ELEMENT_NODE) {
#ifdef DEBUG_SAX_TREE
        xmlGenericError(xmlGenericErrorContext,
            "adding PI %s child to %s\n", target, parent->name);
#endif
        xmlAddChild(parent, ret);
    } else {
#ifdef DEBUG_SAX_TREE
        xmlGenericError(xmlGenericErrorContext, "adding PI %s sibling to ", target);
        xmlDebugDumpOneNode(stderr, parent, 0);
#endif
        xmlAddSibling(parent, ret);
    }
}

/**
 * xmlSAX2Comment:
 * @param ctx the user data (XML parser context)
 * @param value the xmlSAX2Comment content
 *
 * A xmlSAX2Comment has been parsed.
 */
XMLPUBFUNEXPORT void
xmlSAX2Comment(void *ctx, const xmlChar *value)
{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    xmlNodePtr ret;
    xmlNodePtr parent = ctxt->node;

#ifdef DEBUG_SAX
    xmlGenericError(xmlGenericErrorContext, "SAX.xmlSAX2Comment(%s)\n", value);
#endif
    ret = xmlNewDocComment(ctxt->myDoc, value);
    if (ret == NULL) return;

    
    if (ctxt->inSubset == 1) {
        xmlAddChild((xmlNodePtr) ctxt->myDoc->intSubset, ret);
        return;
    } else if (ctxt->inSubset == 2) {
        xmlAddChild((xmlNodePtr) ctxt->myDoc->extSubset, ret);
        return;
    }
    if ((ctxt->myDoc->children == NULL) || (parent == NULL)) {
#ifdef DEBUG_SAX_TREE
        xmlGenericError(xmlGenericErrorContext,
            "Setting xmlSAX2Comment as root\n");
#endif
        xmlAddChild((xmlNodePtr) ctxt->myDoc, (xmlNodePtr) ret);
        return;
    }
    if (parent->type == XML_ELEMENT_NODE) {
#ifdef DEBUG_SAX_TREE
        xmlGenericError(xmlGenericErrorContext,
            "adding xmlSAX2Comment child to %s\n", parent->name);
#endif
        xmlAddChild(parent, ret);
    } else {
#ifdef DEBUG_SAX_TREE
        xmlGenericError(xmlGenericErrorContext,
            "adding xmlSAX2Comment sibling to ");
        xmlDebugDumpOneNode(stderr, parent, 0);
#endif
        xmlAddSibling(parent, ret);
    }
}

/**
 * xmlSAX2CDataBlock:
 * @param ctx the user data (XML parser context)
 * @param value The pcdata content
 * @param len the block length
 *
 * called when a pcdata block has been parsed
 */
XMLPUBFUNEXPORT void
xmlSAX2CDataBlock(void *ctx, const xmlChar *value, int len)
{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    xmlNodePtr ret, lastChild;

#ifdef DEBUG_SAX
    xmlGenericError(xmlGenericErrorContext,"SAX.pcdata(%.10s, %d)\n", value, len);
#endif
    lastChild = xmlGetLastChild(ctxt->node);
#ifdef DEBUG_SAX_TREE
    xmlGenericError(xmlGenericErrorContext,"add chars to %s \n", ctxt->node->name);
#endif
    if ((lastChild != NULL) &&
        (lastChild->type == XML_CDATA_SECTION_NODE))
    {
        xmlTextConcat(lastChild, value, len);
    } else {
        ret = xmlNewCDataBlock(ctxt->myDoc, value, len);
        xmlAddChild(ctxt->node, ret);
    }
}

#ifdef LIBXML_SAX1_ENABLED
/**
 * xmlSAXDefaultVersion:
 * @param version the version, 1 or 2
 *
 * Set the default version of SAX used globally by the library.
 * Note that this may not be a good thing to do from a library
 * it is better to use xmlSAXVersion() to set up specifically the
 * version for a given parsing context.
 *
 * Returns the previous value in case of success and -1 in case of error.
 */
XMLPUBFUNEXPORT int
xmlSAXDefaultVersion(int version)
{
	LOAD_GS_DIRECT
    int ret = xmlSAX2DefaultVersionValue;

    if ((version != 1) && (version != 2))
        return(-1);
    xmlSAX2DefaultVersionValue = version;
    return(ret);
}
#endif /* LIBXML_SAX1_ENABLED */

/**
 * xmlSAXVersion:
 * @param hdlr the SAX handler
 * @param version the version, 1 or 2
 *
 * Initialize the default XML SAX handler according to the version
 *
 * Returns 0 in case of success and -1 in case of error.
 *
 * OOM: never
 */
XMLPUBFUNEXPORT int
xmlSAXVersion(xmlSAXHandler *hdlr, int version)
{
    if (hdlr == NULL) return(-1);
    if (version == 2) {
        hdlr->startElement = NULL;
        hdlr->endElement = NULL;
        hdlr->startElementNs = xmlSAX2StartElementNs;
        hdlr->endElementNs = xmlSAX2EndElementNs;
        hdlr->serror = NULL;
        hdlr->initialized = XML_SAX2_MAGIC;
#ifdef LIBXML_SAX1_ENABLED
    } else if (version == 1) {
        hdlr->startElement = xmlSAX2StartElement;
        hdlr->endElement = xmlSAX2EndElement;
        hdlr->initialized = 1;
#endif /* LIBXML_SAX1_ENABLED */
    } else
        return(-1);
    hdlr->internalSubset = xmlSAX2InternalSubset;
    hdlr->externalSubset = xmlSAX2ExternalSubset;
    hdlr->isStandalone = xmlSAX2IsStandalone;
    hdlr->hasInternalSubset = xmlSAX2HasInternalSubset;
    hdlr->hasExternalSubset = xmlSAX2HasExternalSubset;
    hdlr->resolveEntity = xmlSAX2ResolveEntity;
    hdlr->getEntity = xmlSAX2GetEntity;
    hdlr->getParameterEntity = xmlSAX2GetParameterEntity;
    hdlr->entityDecl = xmlSAX2EntityDecl;
    hdlr->attributeDecl = xmlSAX2AttributeDecl;
    hdlr->elementDecl = xmlSAX2ElementDecl;
    hdlr->notationDecl = xmlSAX2NotationDecl;
    hdlr->unparsedEntityDecl = xmlSAX2UnparsedEntityDecl;
    hdlr->setDocumentLocator = xmlSAX2SetDocumentLocator;
    hdlr->startDocument = xmlSAX2StartDocument;
    hdlr->endDocument = xmlSAX2EndDocument;
    hdlr->reference = xmlSAX2Reference;
    hdlr->characters = xmlSAX2Characters;
    hdlr->cdataBlock = xmlSAX2CDataBlock;
    hdlr->ignorableWhitespace = xmlSAX2Characters;
    hdlr->processingInstruction = xmlSAX2ProcessingInstruction;
    hdlr->comment = xmlSAX2Comment;
// XMLENGINE: MODIFIED CODE
// preprocessor directive is used for managing error callbacks
#ifdef _DEBUG_LIBXML
    hdlr->warning = xmlParserWarning;
    hdlr->error = xmlParserError;
    hdlr->fatalError = xmlParserError;
#else
    hdlr->warning = NULL;
    hdlr->error = NULL;
    hdlr->fatalError = NULL;
#endif
// XMLENGINE: BEGINE NEW CODE
    // These should be nullified for DOMParser
    hdlr->startPrefixMapping = NULL;
    hdlr->endPrefixMapping = NULL;
// XMLENGINE: END NEW CODE

    return(0);
}

#ifdef LIBXML_HTML_ENABLED
/**
 * xmlSAX2InitHtmlDefaultSAXHandler:
 * @param hdlr the SAX handler
 *
 * Initialize the default HTML SAX2 handler
 */
void
xmlSAX2InitHtmlDefaultSAXHandler(xmlSAXHandler *hdlr)
{
    if(hdlr->initialized != 0)
    return;

    hdlr->internalSubset = xmlSAX2InternalSubset;
    hdlr->externalSubset = NULL;
    hdlr->isStandalone = NULL;
    hdlr->hasInternalSubset = NULL;
    hdlr->hasExternalSubset = NULL;
    hdlr->resolveEntity = NULL;
    hdlr->getEntity = xmlSAX2GetEntity;
    hdlr->getParameterEntity = NULL;
    hdlr->entityDecl = NULL;
    hdlr->attributeDecl = NULL;
    hdlr->elementDecl = NULL;
    hdlr->notationDecl = NULL;
    hdlr->unparsedEntityDecl = NULL;
    hdlr->setDocumentLocator = xmlSAX2SetDocumentLocator;
    hdlr->startDocument = xmlSAX2StartDocument;
    hdlr->endDocument = xmlSAX2EndDocument;
    hdlr->startElement = xmlSAX2StartElement;
    hdlr->endElement = xmlSAX2EndElement;
    hdlr->reference = NULL;
    hdlr->characters = xmlSAX2Characters;
    hdlr->cdataBlock = xmlSAX2CDataBlock;
    hdlr->ignorableWhitespace = xmlSAX2IgnorableWhitespace;
    hdlr->processingInstruction = NULL;
    hdlr->comment = xmlSAX2Comment;
    hdlr->warning = xmlParserWarning;
    hdlr->error = xmlParserError;
    hdlr->fatalError = xmlParserError;

    hdlr->initialized = 1;
}


/**
 * htmlDefaultSAXHandlerInit:
 *
 * Initialize the default SAX handler
 */
void
htmlDefaultSAXHandlerInit(void)
{
// XMLENGINE: disabled: HTML is never parsed
//    xmlSAX2InitHtmlDefaultSAXHandler((xmlSAXHandlerPtr) &htmlDefaultSAXHandler);
}
#endif


/**
 * xmlSAX2InitDefaultSAXHandler:
 * @param hdlr the SAX handler
 * @param warning flag if non-zero sets the handler warning procedure
 *
 * Initialize the default XML SAX2 handler
 */
XMLPUBFUNEXPORT void
xmlSAX2InitDefaultSAXHandler(xmlSAXHandler* hdlr, int warning)
{
	LOAD_GS_DIRECT
    if ((hdlr == NULL) || (hdlr->initialized != 0))
        return;

    xmlSAXVersion(hdlr, xmlSAX2DefaultVersionValue);
    // Note: hdlr->warning is NULL after previous line
   if(warning)
    hdlr->warning = xmlParserWarning;
}

/**
 * xmlDefaultSAXHandlerInit:
 *
 * Initialize the default SAX2 handler
 *
 * OOM: never
 */
XMLPUBFUNEXPORT void
xmlDefaultSAXHandlerInit(void)
{
#ifdef XMLENGINE_SAX1
#ifdef LIBXML_SAX1_ENABLED
    xmlSAXVersion((xmlSAXHandlerPtr) &xmlDefaultSAXHandler, 1);
#endif /* LIBXML_SAX1_ENABLED */
#endif
}


#ifdef LIBXML_DOCB_ENABLED

/**
 * xmlSAX2InitDocbDefaultSAXHandler:
 * @param hdlr the SAX handler
 *
 * Initialize the default DocBook SAX2 handler
 */
void
xmlSAX2InitDocbDefaultSAXHandler(xmlSAXHandler *hdlr)
{
    if(hdlr->initialized != 0)
    return;

    hdlr->internalSubset = xmlSAX2InternalSubset;
    hdlr->externalSubset = NULL;
    hdlr->isStandalone = xmlSAX2IsStandalone;
    hdlr->hasInternalSubset = xmlSAX2HasInternalSubset;
    hdlr->hasExternalSubset = xmlSAX2HasExternalSubset;
    hdlr->resolveEntity = xmlSAX2ResolveEntity;
    hdlr->getEntity = xmlSAX2GetEntity;
    hdlr->getParameterEntity = NULL;
    hdlr->entityDecl = xmlSAX2EntityDecl;
    hdlr->attributeDecl = NULL;
    hdlr->elementDecl = NULL;
    hdlr->notationDecl = NULL;
    hdlr->unparsedEntityDecl = NULL;
    hdlr->setDocumentLocator = xmlSAX2SetDocumentLocator;
    hdlr->startDocument = xmlSAX2StartDocument;
    hdlr->endDocument = xmlSAX2EndDocument;
    hdlr->startElement = xmlSAX2StartElement;
    hdlr->endElement = xmlSAX2EndElement;
    hdlr->reference = xmlSAX2Reference;
    hdlr->characters = xmlSAX2Characters;
    hdlr->cdataBlock = NULL;
    hdlr->ignorableWhitespace = xmlSAX2IgnorableWhitespace;
    hdlr->processingInstruction = NULL;
    hdlr->comment = xmlSAX2Comment;
    hdlr->warning = xmlParserWarning;
    hdlr->error = xmlParserError;
    hdlr->fatalError = xmlParserError;

    hdlr->initialized = 1;
}

/**
 * docbDefaultSAXHandlerInit:
 *
 * Initialize the default SAX handler
 */
void
docbDefaultSAXHandlerInit(void)
{
    xmlSAX2InitDocbDefaultSAXHandler((xmlSAXHandlerPtr) &docbDefaultSAXHandler);
}

#endif /* LIBXML_DOCB_ENABLED */

