/*

 * libxml2_xmlreader.c: implements the xmlTextReader streaming node API

 *

 * NOTE:

 *   XmlTextReader.Normalization Property won't be supported, since

 *     it makes the parser non compliant to the XML recommendation

 *

 * See Copyright for the status of this software.

 *

 * daniel@veillard.com

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

 */

/*

 * TODOs:

 *   - XML Schemas validation

 *   - setting(s) for NoBlanks

 *   - performances and tuning ...

 */

#define IN_LIBXML

#include "xmlenglibxml.h"

#ifdef LIBXML_READER_ENABLED

#include <string.h> /* for memset() only ! */

#include <stdarg.h>

#ifdef HAVE_CTYPE_H

#include <ctype.h>

#endif

#ifdef HAVE_STDLIB_H

#include <stdlib.h>

#endif

#include <stdapis/libxml2/libxml2_globals.h>

#include "libxml2_xmlreader.h"

#include <stdapis/libxml2/libxml2_parserinternals.h>

#include <stdapis/libxml2/libxml2_uri.h>

/* #define DEBUG_CALLBACKS */

/* #define DEBUG_READER */

/**

 * 

 *

 * macro to flag unimplemented blocks

 */

#define TODO                                                            \

     xmlGenericError(xmlGenericErrorContext,                             \

             EMBED_ERRTXT("Unimplemented block at %s:%d\n"),                             \

             __FILE__, __LINE__);

#ifdef DEBUG_READER

#define DUMP_READER xmlTextReaderDebug(reader);

#else

#define DUMP_READER

#endif

#define CHUNK_SIZE 512

/************************************************************************

 *                                                                      *

 *  The parser: maps the Text Reader API on top of the existing         *

 *      parsing routines building a tree                                *

 *                                                                      *

 ************************************************************************/

#define XML_TEXTREADER_INPUT    1

#define XML_TEXTREADER_CTXT     2

// struct _xmlTextReader was moved to header file

#define NODE_IS_EMPTY       0x1

#define NODE_IS_PRESERVED   0x2

#define NODE_IS_SPRESERVED  0x4

/**

 * CONSTSTR:

 *

 * Macro used to return an interned string

 */

#define CONSTSTR(str) xmlDictLookup(reader->dict, (str), -1)

#define CONSTQSTR(p, str) xmlDictQLookup(reader->dict, (p), (str))

static int xmlTextReaderReadTree(xmlTextReaderPtr reader);

static int xmlTextReaderNextTree(xmlTextReaderPtr reader);

/************************************************************************

 *                                                                      *

 *  Our own version of the freeing routines as we recycle nodes         *

 *                                                                      *

 ************************************************************************/

/**

 * DICT_FREE:

 * @param str a string

 *

 * Free a string if it is not owned by the "dict" dictionnary in the

 * current scope

 */

#define DICT_FREE(str)                                      \

    if ((str) && ((!dict) ||                                \

        (xmlDictOwns(dict, (const xmlChar *)(str)) == 0)))  \

        xmlFree((char *)(str));

static void xmlTextReaderFreeNode(xmlTextReaderPtr reader, xmlNodePtr cur);

static void xmlTextReaderFreeNodeList(xmlTextReaderPtr reader, xmlNodePtr cur);

/**

 * xmlFreeID:

 * @param not A id

 *

 * Deallocate the memory used by an id definition

 */

static void

xmlFreeID(xmlIDPtr id) {

    xmlDictPtr dict = NULL;

    if (id == NULL) return;

    if (id->doc != NULL)

        dict = id->doc->dict;

    if (id->value != NULL)

        DICT_FREE(id->value)

    xmlFree(id);

}

/**

 * xmlTextReaderRemoveID:

 * @param doc the document

 * @param attr the attribute

 *

 * Remove the given attribute from the ID table maintained internally.

 *

 * Returns -1 if the lookup failed and 0 otherwise

 */

static int

xmlTextReaderRemoveID(xmlDocPtr doc, xmlAttrPtr attr) {

    xmlIDTablePtr table;

    xmlIDPtr id;

    xmlChar *ID;

    if (!doc || !attr)

        return(-1);

    table = (xmlIDTablePtr) doc->ids;

    if (table == NULL)

        return(-1);

    if (attr == NULL)

        return(-1);

    ID = xmlNodeListGetString(doc, attr->children, 1);

    if (ID == NULL)

        return(-1);

    id = xmlHashLookup(table, ID);

    xmlFree(ID);

    if (id == NULL || id->attr != attr) {

        return(-1);

    }

    id->name = attr->name;

    id->attr = NULL;

    return(0);

}

/**

 * xmlTextReaderFreeProp:

 * @param reader the xmlTextReaderPtr used

 * @param cur the node

 *

 * Free a node.

 */

static void

xmlTextReaderFreeProp(xmlTextReaderPtr reader, xmlAttrPtr cur) {

    xmlDictPtr dict;

    LOAD_GS_SAFE_ATTR(cur)

    dict = reader->ctxt->dict;

    if (cur == NULL) return;

    if ((__xmlRegisterCallbacks) && (xmlDeregisterNodeDefaultValue))

        xmlDeregisterNodeDefaultValue((xmlNodePtr) cur);

    /* Check for ID removal -> leading to invalid references ! */

    if ((cur->parent != NULL) && (cur->parent->doc != NULL) &&

        ((cur->parent->doc->intSubset != NULL) ||

         (cur->parent->doc->extSubset != NULL))) {

        if (xmlIsID(cur->parent->doc, cur->parent, cur))

            xmlTextReaderRemoveID(cur->parent->doc, cur);

    }

    if (cur->children != NULL)

        xmlTextReaderFreeNodeList(reader, cur->children);

    DICT_FREE(cur->name);

    if ((reader != NULL) && (reader->ctxt != NULL) &&

        (reader->ctxt->freeAttrsNr < 100))

    {

        cur->next = reader->ctxt->freeAttrs;

        reader->ctxt->freeAttrs = cur;

        reader->ctxt->freeAttrsNr++;

    } else {

        xmlFree(cur);

    }

}

/**

 * xmlTextReaderFreePropList:

 * @param reader the xmlTextReaderPtr used

 * @param cur the first property in the list

 *

 * Free a property and all its siblings, all the children are freed too.

 */

static void

xmlTextReaderFreePropList(xmlTextReaderPtr reader, xmlAttrPtr cur) {

    xmlAttrPtr next;

    //if (cur == NULL) return;

    while (cur) {

        next = cur->next;

        xmlTextReaderFreeProp(reader, cur);

        cur = next;

    }

}

/**

 * xmlTextReaderFreeNodeList:

 * @param reader the xmlTextReaderPtr used

 * @param cur the first node in the list

 *

 * Free a node and all its siblings, this is a recursive behaviour, all

 * the children are freed too.

 */

static void

xmlTextReaderFreeNodeList(xmlTextReaderPtr reader, xmlNodePtr cur) {

    xmlNodePtr next;

    xmlDictPtr dict;

    LOAD_GS_SAFE_NODE(cur)

    dict = reader->ctxt->dict;

    if (cur == NULL)

        return;

    if (cur->type == XML_NAMESPACE_DECL) {

        xmlFreeNsList((xmlNsPtr) cur);

        return;

    }

    if ((cur->type == XML_DOCUMENT_NODE) ||

        (cur->type == XML_HTML_DOCUMENT_NODE))

    {

        xmlFreeDoc((xmlDocPtr) cur);

        return;

    }

    while (cur)

    {

        next = cur->next;

        /* unroll to speed up freeing the document */

        if (cur->type != XML_DTD_NODE)

        {

            if ((cur->children != NULL) &&

               (cur->type != XML_ENTITY_REF_NODE))

            {

                if (cur->children->parent == cur)

                    xmlTextReaderFreeNodeList(reader, cur->children);

                cur->children = NULL;

            }

            if ((__xmlRegisterCallbacks) && (xmlDeregisterNodeDefaultValue))

                xmlDeregisterNodeDefaultValue(cur);

            if (((cur->type == XML_ELEMENT_NODE) ||

                (cur->type == XML_XINCLUDE_START) ||

                (cur->type == XML_XINCLUDE_END)) &&

                (cur->properties != NULL))

            {

                xmlTextReaderFreePropList(reader, cur->properties);

            }

            if ((cur->type != XML_ELEMENT_NODE) &&

                (cur->type != XML_XINCLUDE_START) &&

                (cur->type != XML_XINCLUDE_END) &&

                (cur->type != XML_ENTITY_REF_NODE))

            {

                DICT_FREE(cur->content);

            }

            if (((cur->type == XML_ELEMENT_NODE)  ||

                (cur->type == XML_XINCLUDE_START) ||

                (cur->type == XML_XINCLUDE_END)) &&

                (cur->nsDef != NULL))

            {

                xmlFreeNsList(cur->nsDef);

            }

            /*

             * we don't free element names here they are interned now

             */

            if ((cur->type != XML_TEXT_NODE) &&

                (cur->type != XML_COMMENT_NODE))

            {

                DICT_FREE(cur->name);

            }

            if (((cur->type == XML_ELEMENT_NODE) ||

                (cur->type == XML_TEXT_NODE)) &&

                (reader != NULL) && (reader->ctxt != NULL) &&

                (reader->ctxt->freeElemsNr < 100))

            {

                cur->next = reader->ctxt->freeElems;

                reader->ctxt->freeElems = cur;

                reader->ctxt->freeElemsNr++;

            }

            else

            {

                xmlFree(cur);

            }

        } // if (cur->type != XML_DTD_NODE)

        cur = next;

    } // while (cur)

}

/**

 * xmlTextReaderFreeNode:

 * @param reader the xmlTextReaderPtr used

 * @param cur the node

 *

 * Free a node, this is a recursive behaviour, all the children are freed too.

 * This doesn't unlink the child from the list, use xmlUnlinkNode() first.

 */

static void

xmlTextReaderFreeNode(xmlTextReaderPtr reader, xmlNodePtr cur) {

    xmlDictPtr dict;

    LOAD_GS_SAFE_NODE(cur)

    dict = reader->ctxt->dict;

    if (cur->type == XML_DTD_NODE) {

        xmlFreeDtd((xmlDtdPtr) cur);

        return;

    }

    if (cur->type == XML_NAMESPACE_DECL) {

        xmlFreeNs((xmlNsPtr) cur);

        return;

    }

    if (cur->type == XML_ATTRIBUTE_NODE) {

        xmlTextReaderFreeProp(reader, (xmlAttrPtr) cur);

        return;

    }

    if (cur->children && cur->type != XML_ENTITY_REF_NODE) {

        if (cur->children->parent == cur)

            xmlTextReaderFreeNodeList(reader, cur->children);

        cur->children = NULL;

    }

    if ((__xmlRegisterCallbacks) && (xmlDeregisterNodeDefaultValue))

        xmlDeregisterNodeDefaultValue(cur);

    if (((cur->type == XML_ELEMENT_NODE) ||

        (cur->type == XML_XINCLUDE_START) ||

        (cur->type == XML_XINCLUDE_END)) &&

        (cur->properties != NULL))

    {

        xmlTextReaderFreePropList(reader, cur->properties);

    }

    if ((cur->content != (xmlChar *) &(cur->properties)) &&

        (cur->type != XML_ELEMENT_NODE)                  &&

        (cur->type != XML_XINCLUDE_START)                &&

        (cur->type != XML_XINCLUDE_END)                  &&

        (cur->type != XML_ENTITY_REF_NODE))

    {

        DICT_FREE(cur->content);

    }

    if (((cur->type == XML_ELEMENT_NODE)   ||

         (cur->type == XML_XINCLUDE_START) ||

         (cur->type == XML_XINCLUDE_END))

        &&

        (cur->nsDef != NULL))

    {

        xmlFreeNsList(cur->nsDef);

    }

    /*

     * we don't free names here they are interned now

     */

    if ((cur->type != XML_TEXT_NODE) &&

        (cur->type != XML_COMMENT_NODE))

    {

        DICT_FREE(cur->name);

    }

    if (((cur->type == XML_ELEMENT_NODE) ||

        (cur->type == XML_TEXT_NODE)) &&

        (reader != NULL) && (reader->ctxt != NULL) &&

        (reader->ctxt->freeElemsNr < 100))

    {

        cur->next = reader->ctxt->freeElems;

        reader->ctxt->freeElems = cur;

        reader->ctxt->freeElemsNr++;

    }

    else

    {

        xmlFree(cur);

    }

}

/**

 * xmlTextReaderFreeIDTable:

 * @param table An id table

 *

 * Deallocate the memory used by an ID hash table.

 */

static void

xmlTextReaderFreeIDTable(xmlIDTablePtr table) {

    xmlHashFree(table, (xmlHashDeallocator) xmlFreeID);

}

/**

 * xmlTextReaderFreeDoc:

 * @param reader the xmlTextReaderPtr used

 * @param cur pointer to the document

 *

 * Free up all the structures used by a document, tree included.

 */

static void

xmlTextReaderFreeDoc(xmlTextReaderPtr reader, xmlDocPtr cur) {

    xmlDtdPtr extSubset, intSubset;

    LOAD_GS_SAFE_DOC(cur)

    if (cur == NULL) return;

    if ((__xmlRegisterCallbacks) && (xmlDeregisterNodeDefaultValue))

        xmlDeregisterNodeDefaultValue((xmlNodePtr) cur);

    /*

     * Do this before freeing the children list to avoid ID lookups

     */

    if (cur->ids != NULL)

        xmlTextReaderFreeIDTable((xmlIDTablePtr) cur->ids);

    cur->ids = NULL;

    if (cur->refs != NULL)

        xmlFreeRefTable((xmlRefTablePtr) cur->refs);

    cur->refs = NULL;

    extSubset = cur->extSubset;

    intSubset = cur->intSubset;

    if (intSubset == extSubset)

        extSubset = NULL;

    if (extSubset != NULL) {

        xmlUnlinkNode((xmlNodePtr) cur->extSubset);

        cur->extSubset = NULL;

        xmlFreeDtd(extSubset);

    }

    if (intSubset != NULL) {

        xmlUnlinkNode((xmlNodePtr) cur->intSubset);

        cur->intSubset = NULL;

        xmlFreeDtd(intSubset);

    }

    if (cur->children != NULL)

        xmlTextReaderFreeNodeList(reader, cur->children);

    if (cur->version != NULL)

        xmlFree((char *) cur->version);

    if (cur->name != NULL)

        xmlFree((char *) cur->name);

    if (cur->encoding != NULL)

        xmlFree((char *) cur->encoding);

    if (cur->oldNs != NULL)

        xmlFreeNsList(cur->oldNs);

    if (cur->URL != NULL)

        xmlFree((char *) cur->URL);

    if (cur->dict != NULL)

        xmlDictFree(cur->dict);

    xmlFree(cur);

}

/************************************************************************

 *                                                                      *

 *          The reader core parser                                      *

 *                                                                      *

 ************************************************************************/

#ifdef DEBUG_READER

static void

xmlTextReaderDebug(xmlTextReaderPtr reader) {

    if ((reader == NULL) || (reader->ctxt == NULL)) {

        fprintf(stderr, "xmlTextReader NULL\n");

        return;

    }

    fprintf(stderr, "xmlTextReader: state %d depth %d ",

            reader->state, reader->depth);

    if (reader->node == NULL) {

        fprintf(stderr, "node = NULL\n");

    } else {

        fprintf(stderr, "node %s\n", reader->node->name);

    }

    fprintf(stderr, "  input: base %d, cur %d, depth %d: ",

            reader->base, reader->cur, reader->ctxt->nodeNr);

    if (reader->input->buffer == NULL) {

        fprintf(stderr, "buffer is NULL\n");

    } else {

#ifdef LIBXML_DEBUG_ENABLED

        xmlDebugDumpString(stderr,

                &reader->input->buffer->content[reader->cur]);

#endif

        fprintf(stderr, "\n");

    }

}

#endif

/**

 * xmlTextReaderEntPush:

 * @param reader the xmlTextReaderPtr used

 * @param value the entity reference node

 *

 * Pushes a new entity reference node on top of the entities stack

 *

 * Returns 0 in case of error, the index in the stack otherwise

 */

static int

xmlTextReaderEntPush(xmlTextReaderPtr reader, xmlNodePtr value)

{

    if (reader->entMax <= 0) {

        int size = 10;

        reader->entMax = 0;

        reader->entTab = (xmlNodePtr*) xmlMalloc(size * sizeof(reader->entTab[0]));

        if (!reader->entTab)

            goto OOM_exit;

        reader->entMax = size;

    }

    if (reader->entNr >= reader->entMax) {

        xmlNodePtr* tmp;

        reader->entMax *= 2;

        tmp = (xmlNodePtr*)xmlRealloc(reader->entTab, // DONE: Fix xmlRealloc

                                      reader->entMax * sizeof(reader->entTab[0]));

        if (!tmp) {

            reader->entMax /= 2;

OOM_exit:

            xmlGenericError(xmlGenericErrorContext, EMBED_ERRTXT("Memory (re)allocation failed !\n"));

            return (0);