/*

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