FCL/sf/os/xmlsrv: comparison xml/libxml2libs/src/libxml2/libxml2

equal deleted inserted replaced

--1:000000000000
+:e35f40988205
+/*
+* 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);
+}
+reader->entTab = tmp;
+}
+reader->entTab[reader->entNr] = value;
+reader->ent = value;
+return (reader->entNr++);
+}
+/**
+* xmlTextReaderEntPop:
+* @param reader the xmlTextReaderPtr used
+*
+* Pops the top element entity from the entities stack
+*
+* Returns the entity just removed
+*/
+static xmlNodePtr
+xmlTextReaderEntPop(xmlTextReaderPtr reader)
+{
+xmlNodePtr ret;
+if (reader->entNr <= 0)
+return NULL;
+reader->entNr--;
+if (reader->entNr > 0)
+reader->ent = reader->entTab[reader->entNr - 1];
+else
+reader->ent = NULL;
+ret = reader->entTab[reader->entNr];
+reader->entTab[reader->entNr] = NULL;
+return (ret);
+}
+/**
+* xmlTextReaderStartElement:
+* @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.
+*/
+static void
+xmlTextReaderStartElement(void* ctx, const xmlChar* fullname, const xmlChar** atts)
+{
+xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+xmlTextReaderPtr reader = ctxt->_private;
+#ifdef DEBUG_CALLBACKS
+printf("xmlTextReaderStartElement(%s)\n", fullname);
+#endif
+if ((reader != NULL) && (reader->startElement != NULL)) {
+reader->startElement(ctx, fullname, atts);
+if ((ctxt->node != NULL) && (ctxt->input != NULL) &&
+(ctxt->input->cur != NULL) && (ctxt->input->cur[0] == '/') &&
+(ctxt->input->cur[1] == '>'))
+{
+ctxt->node->extra = NODE_IS_EMPTY;
+}
+}
+if (reader != NULL)
+reader->state = XML_TEXTREADER_ELEMENT;
+}
+/**
+* xmlTextReaderEndElement:
+* @param ctx the user data (XML parser context)
+* @param fullname The element name, including namespace prefix
+*
+* called when an ending tag has been processed.
+*/
+static void
+xmlTextReaderEndElement(void *ctx, const xmlChar *fullname)
+{
+xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+xmlTextReaderPtr reader = ctxt->_private;
+#ifdef DEBUG_CALLBACKS
+printf("xmlTextReaderEndElement(%s)\n", fullname);
+#endif
+if ((reader != NULL) && (reader->endElement != NULL)) {
+reader->endElement(ctx, fullname);
+}
+}
+/**
+* xmlTextReaderStartElementNs:
+* @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
+* nb_defaulted:  the number of defaulted attributes.
+* @param attributes pointer to the array of (localname/prefix/URI/value/end)
+*               attribute values.
+*
+* called when an opening tag has been processed.
+*/
+static void
+xmlTextReaderStartElementNs(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;
+xmlTextReaderPtr reader = ctxt->_private;
+#ifdef DEBUG_CALLBACKS
+printf("xmlTextReaderStartElementNs(%s)\n", localname);
+#endif
+if ((reader != NULL) && (reader->startElementNs != NULL))
+{
+reader->startElementNs(ctx, localname, prefix, URI, nb_namespaces,
+namespaces, nb_attributes, nb_defaulted,
+attributes);
+if ((ctxt->node != NULL) && (ctxt->input != NULL) &&
+(ctxt->input->cur != NULL) && (ctxt->input->cur[0] == '/') &&
+(ctxt->input->cur[1] == '>'))
+{
+ctxt->node->extra = NODE_IS_EMPTY;
+}
+}
+if (reader != NULL)
+reader->state = XML_TEXTREADER_ELEMENT;
+}
+/**
+* xmlTextReaderEndElementNs:
+* @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
+*
+* called when an ending tag has been processed.
+*/
+static void
+xmlTextReaderEndElementNs(void *ctx,
+const xmlChar * localname,
+const xmlChar * prefix,
+const xmlChar * URI)
+{
+xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+xmlTextReaderPtr reader = ctxt->_private;
+#ifdef DEBUG_CALLBACKS
+printf("xmlTextReaderEndElementNs(%s)\n", localname);
+#endif
+if ((reader != NULL) && (reader->endElementNs != NULL)) {
+reader->endElementNs(ctx, localname, prefix, URI);
+}
+}
+/**
+* xmlTextReaderCharacters:
+* @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.
+*/
+static void
+xmlTextReaderCharacters(void *ctx, const xmlChar *ch, int len)
+{
+xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+xmlTextReaderPtr reader = ctxt->_private;
+#ifdef DEBUG_CALLBACKS
+printf("xmlTextReaderCharacters()\n");
+#endif
+if ((reader != NULL) && (reader->characters != NULL)) {
+reader->characters(ctx, ch, len);
+}
+}
+/**
+* xmlTextReaderCDataBlock:
+* @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
+*/
+static void
+xmlTextReaderCDataBlock(void *ctx, const xmlChar *ch, int len)
+{
+xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+xmlTextReaderPtr reader = ctxt->_private;
+#ifdef DEBUG_CALLBACKS
+printf("xmlTextReaderCDataBlock()\n");
+#endif
+if ((reader != NULL) && (reader->cdataBlock != NULL)) {
+reader->cdataBlock(ctx, ch, len);
+}
+}
+/**
+* xmlTextReaderPushData:
+* @param reader the xmlTextReaderPtr used
+*
+* Push data down the progressive parser until a significant callback
+* got raised.
+*
+* Returns -1 in case of failure, 0 otherwise
+*/
+static int
+xmlTextReaderPushData(xmlTextReaderPtr reader) {
+xmlBufferPtr inbuf;
+int val, s;
+xmlTextReaderState oldstate;
+if ((reader->input == NULL) || (reader->input->buffer == NULL))
+return(-1);
+oldstate = reader->state;
+reader->state = XML_TEXTREADER_NONE;
+inbuf = reader->input->buffer;
+while (reader->state == XML_TEXTREADER_NONE)
+{
+if (inbuf->use < reader->cur + CHUNK_SIZE)
+{
+/*
+* Refill the buffer unless we are at the end of the stream
+*/
+if (reader->mode != XML_TEXTREADER_MODE_EOF)
+{
+val = xmlParserInputBufferRead(reader->input, 4096);
+if ((val == 0) &&
+(inbuf->alloc == XML_BUFFER_ALLOC_IMMUTABLE)) {
+if (inbuf->use == reader->cur) {
+reader->mode = XML_TEXTREADER_MODE_EOF;
+reader->state = oldstate;
+}
+} else if (val < 0) {
+reader->mode = XML_TEXTREADER_MODE_EOF;
+reader->state = oldstate;
+if ((oldstate != XML_TEXTREADER_START) ||
+(reader->ctxt->myDoc != NULL))
+return(val);
+} else if (val == 0) {
+/* mark the end of the stream and process the remains */
+reader->mode = XML_TEXTREADER_MODE_EOF;
+break;
+}
+} else
+break;
+}
+/*
+* parse by block of CHUNK_SIZE bytes, various tests show that
+* it's the best tradeoff at least on a 1.2GH Duron
+*/
+if (inbuf->use >= reader->cur + CHUNK_SIZE)
+{
+val = xmlParseChunk(reader->ctxt,
+(const char *) &inbuf->content[reader->cur],
+CHUNK_SIZE, 0);
+reader->cur += CHUNK_SIZE;
+if ((val != 0) || (reader->ctxt->wellFormed == 0))
+return(-1);
+} else {
+s = inbuf->use - reader->cur;
+val = xmlParseChunk(reader->ctxt,
+(const char*) &inbuf->content[reader->cur],
+s, 0);
+reader->cur += s;
+if ((val != 0) || (reader->ctxt->wellFormed == 0))
+return(-1);
+break;
+}
+} // reader->state == XML_TEXTREADER_NONE
+/*
+* Discard the consumed input when needed and possible
+*/
+if (reader->mode == XML_TEXTREADER_MODE_INTERACTIVE)
+{
+if (inbuf->alloc != XML_BUFFER_ALLOC_IMMUTABLE)
+{
+if ((reader->cur >= 4096) &&
+(inbuf->use - reader->cur <= CHUNK_SIZE))
+{
+val = xmlBufferShrink(inbuf, reader->cur);
+if (val >= 0) {
+reader->cur -= val;
+}
+}
+}
+}
+/*
+* At the end of the stream signal that the work is done to the Push
+* parser.
+*/
+else if (reader->mode == XML_TEXTREADER_MODE_EOF)
+{
+if (reader->mode != XML_TEXTREADER_DONE)
+{
+s = inbuf->use - reader->cur;
+val = xmlParseChunk(reader->ctxt,
+(const char *) &inbuf->content[reader->cur],
+s, 1);
+reader->cur = inbuf->use;
+reader->mode = XML_TEXTREADER_DONE;
+if ((val != 0) || (reader->ctxt->wellFormed == 0))
+return(-1);
+}
+}
+reader->state = oldstate;
+return(0);
+}
+#ifdef LIBXML_REGEXP_ENABLED
+/**
+* xmlTextReaderValidatePush:
+* @param reader the xmlTextReaderPtr used
+*
+* Push the current node for validation
+*/
+static void
+xmlTextReaderValidatePush(xmlTextReaderPtr reader ATTRIBUTE_UNUSED) {
+xmlNodePtr node = reader->node;
+#ifdef LIBXML_VALID_ENABLED
+if ((reader->validate == XML_TEXTREADER_VALIDATE_DTD) &&
+(reader->ctxt != NULL) && (reader->ctxt->validate == 1)) {
+if ((node->ns == NULL) || (node->ns->prefix == NULL)) {
+reader->ctxt->valid &= xmlValidatePushElement(&reader->ctxt->vctxt,
+reader->ctxt->myDoc, node, node->name);
+} else {
+xmlChar *qname;
+qname = xmlStrdup(node->ns->prefix);
+qname = xmlStrcat(qname, BAD_CAST ":");
+qname = xmlStrcat(qname, node->name);
+reader->ctxt->valid &= xmlValidatePushElement(&reader->ctxt->vctxt,
+reader->ctxt->myDoc, node, qname);
+if (qname != NULL)
+xmlFree(qname);
+}
+}
+#endif /* LIBXML_VALID_ENABLED */
+#ifdef LIBXML_SCHEMAS_ENABLED
+if ((reader->validate == XML_TEXTREADER_VALIDATE_RNG) &&
+(reader->rngValidCtxt != NULL)) {
+int ret;
+if (reader->rngFullNode != NULL) return;
+ret = xmlRelaxNGValidatePushElement(reader->rngValidCtxt,
+reader->ctxt->myDoc,
+node);
+if (ret == 0) {
+/*
+* this element requires a full tree
+*/
+node = xmlTextReaderExpand(reader);
+if (node == NULL) {
+printf(EMBED_ERRTXT("Expand failed !\n"));
+ret = -1;
+} else {
+ret = xmlRelaxNGValidateFullElement(reader->rngValidCtxt,
+reader->ctxt->myDoc,
+node);
+reader->rngFullNode = node;
+}
+}
+if (ret != 1)
+reader->rngValidErrors++;
+}
+#endif
+}
+/**
+* xmlTextReaderValidateCData:
+* @param reader the xmlTextReaderPtr used
+* @param data pointer to the CData
+* @param len lenght of the CData block in bytes.
+*
+* Push some CData for validation
+*/
+static void
+xmlTextReaderValidateCData(xmlTextReaderPtr reader,
+const xmlChar *data, int len) {
+#ifdef LIBXML_VALID_ENABLED
+if ((reader->validate == XML_TEXTREADER_VALIDATE_DTD) &&
+(reader->ctxt != NULL) && (reader->ctxt->validate == 1)) {
+reader->ctxt->valid &= xmlValidatePushCData(&reader->ctxt->vctxt,
+data, len);
+}
+#endif /* LIBXML_VALID_ENABLED */
+#ifdef LIBXML_SCHEMAS_ENABLED
+if ((reader->validate == XML_TEXTREADER_VALIDATE_RNG) &&
+(reader->rngValidCtxt != NULL)) {
+int ret;
+if (reader->rngFullNode != NULL) return;
+ret = xmlRelaxNGValidatePushCData(reader->rngValidCtxt, data, len);
+if (ret != 1)
+reader->rngValidErrors++;
+}
+#endif
+}
+/**
+* xmlTextReaderValidatePop:
+* @param reader the xmlTextReaderPtr used
+*
+* Pop the current node from validation
+*/
+static void
+xmlTextReaderValidatePop(xmlTextReaderPtr reader) {
+xmlNodePtr node = reader->node;
+#ifdef LIBXML_VALID_ENABLED
+if ((reader->validate == XML_TEXTREADER_VALIDATE_DTD) &&
+(reader->ctxt != NULL) && (reader->ctxt->validate == 1)) {
+if ((node->ns == NULL) || (node->ns->prefix == NULL)) {
+reader->ctxt->valid &= xmlValidatePopElement(&reader->ctxt->vctxt,
+reader->ctxt->myDoc, node, node->name);
+} else {
+xmlChar *qname;
+qname = xmlStrdup(node->ns->prefix);
+qname = xmlStrcat(qname, BAD_CAST ":");
+qname = xmlStrcat(qname, node->name);
+reader->ctxt->valid &= xmlValidatePopElement(&reader->ctxt->vctxt,
+reader->ctxt->myDoc, node, qname);
+if (qname != NULL)
+xmlFree(qname);
+}
+}
+#endif /* LIBXML_VALID_ENABLED */
+#ifdef LIBXML_SCHEMAS_ENABLED
+if ((reader->validate == XML_TEXTREADER_VALIDATE_RNG) &&
+(reader->rngValidCtxt != NULL)) {
+int ret;
+if (reader->rngFullNode != NULL) {
+if (node == reader->rngFullNode)
+reader->rngFullNode = NULL;
+return;
+}
+ret = xmlRelaxNGValidatePopElement(reader->rngValidCtxt,
+reader->ctxt->myDoc,
+node);
+if (ret != 1)
+reader->rngValidErrors++;
+}
+#endif
+}
+/**
+* xmlTextReaderValidateEntity:
+* @param reader the xmlTextReaderPtr used
+*
+* Handle the validation when an entity reference is encountered and
+* entity substitution is not activated. As a result the parser interface
+* must walk through the entity and do the validation calls
+*/
+static void
+xmlTextReaderValidateEntity(xmlTextReaderPtr reader) {
+xmlNodePtr oldnode = reader->node;
+xmlNodePtr node = reader->node;
+xmlParserCtxtPtr ctxt = reader->ctxt;
+do {
+if (node->type == XML_ENTITY_REF_NODE) {
+/*
+* Case where the underlying tree is not availble, lookup the entity
+* and walk it.
+*/
+if ((node->children == NULL) && (ctxt->sax != NULL) &&
+(ctxt->sax->getEntity != NULL)) {
+node->children = (xmlNodePtr)
+ctxt->sax->getEntity(ctxt, node->name);
+}
+if ((node->children != NULL) &&
+(node->children->type == XML_ENTITY_DECL) &&
+(node->children->children != NULL)) {
+xmlTextReaderEntPush(reader, node);
+node = node->children->children;
+continue;
+} else {
+/*
+* The error has probably be raised already.
+*/
+if (node == oldnode)
+break;
+node = node->next;
+}
+#ifdef LIBXML_REGEXP_ENABLED
+} else if (node->type == XML_ELEMENT_NODE) {
+reader->node = node;
+xmlTextReaderValidatePush(reader);
+} else if ((node->type == XML_TEXT_NODE) ||
+(node->type == XML_CDATA_SECTION_NODE)) {
+xmlTextReaderValidateCData(reader, node->content,
+xmlStrlen(node->content));
+#endif
+}
+/*
+* go to next node
+*/
+if (node->children != NULL) {
+node = node->children;
+continue;
+} else if (node->type == XML_ELEMENT_NODE) {
+xmlTextReaderValidatePop(reader);
+}
+if (node->next != NULL) {
+node = node->next;
+continue;
+}
+do {
+node = node->parent;
+if (node->type == XML_ELEMENT_NODE) {
+xmlNodePtr tmp;
+if (reader->entNr == 0) {
+while ((tmp = node->last) != NULL) {
+if ((tmp->extra & NODE_IS_PRESERVED) == 0) {
+xmlUnlinkNode(tmp);
+xmlTextReaderFreeNode(reader, tmp);
+} else
+break;
+}
+}
+reader->node = node;
+xmlTextReaderValidatePop(reader);
+}
+if ((node->type == XML_ENTITY_DECL) &&
+(reader->ent != NULL) && (reader->ent->children == node)) {
+node = xmlTextReaderEntPop(reader);
+}
+if (node == oldnode)
+break;
+if (node->next != NULL) {
+node = node->next;
+break;
+}
+} while ((node != NULL) && (node != oldnode));
+} while ((node != NULL) && (node != oldnode));
+reader->node = oldnode;
+}
+#endif /* LIBXML_REGEXP_ENABLED */
+/**
+* xmlTextReaderGetSuccessor:
+* @param cur the current node
+*
+* Get the successor of a node if available.
+*
+* Returns the successor node or NULL
+*/
+static xmlNodePtr
+xmlTextReaderGetSuccessor(xmlNodePtr cur)
+{
+if (cur == NULL)
+return(NULL) ; /* ERROR */
+if (cur->next != NULL)
+return(cur->next) ;
+do {
+cur = cur->parent;
+if (cur == NULL)
+return(NULL);
+if (cur->next != NULL)
+return(cur->next);
+} while (cur != NULL);
+return(cur);
+}
+/**
+* xmlTextReaderDoExpand:
+* @param reader the xmlTextReaderPtr used
+*
+* Makes sure that the current node is fully read as well as all its
+* descendant. It means the full DOM subtree must be available at the
+* end of the call.
+*
+* Returns 1 if the node was expanded successfully, 0 if there is no more
+*          nodes to read, or -1 in case of error
+*/
+static int
+xmlTextReaderDoExpand(xmlTextReaderPtr reader)
+{
+int val;
+if ((reader == NULL) || (reader->node == NULL) || (reader->ctxt == NULL))
+return(-1);
+do {
+if (reader->ctxt->instate == XML_PARSER_EOF)
+return(1);
+if (xmlTextReaderGetSuccessor(reader->node) != NULL)
+return(1);
+if (reader->ctxt->nodeNr < reader->depth)
+return(1);
+if (reader->mode == XML_TEXTREADER_MODE_EOF)
+return(1);
+val = xmlTextReaderPushData(reader);
+if (val < 0)
+return(-1);
+} while(reader->mode != XML_TEXTREADER_MODE_EOF);
+return(1);
+}
+/**
+* xmlTextReaderCollectSiblings:
+* @param node the first child
+*
+*  Traverse depth-first through all sibling nodes and their children
+*  nodes and concatenate their content. This is an auxiliary function
+*  to xmlTextReaderReadString.
+*
+*  Returns a string containing the content, or NULL in case of error.
+*/
+static xmlChar *
+xmlTextReaderCollectSiblings(xmlNodePtr node)
+{
+xmlBufferPtr buffer;
+xmlChar *ret;
+buffer = xmlBufferCreate();
+if (buffer == NULL)
+return NULL;
+for ( ; node != NULL; node = node->next) {
+switch (node->type) {
+case XML_TEXT_NODE:
+case XML_CDATA_SECTION_NODE:
+xmlBufferCat(buffer, node->content);
+break;
+case XML_ELEMENT_NODE: {
+xmlChar *tmp;
+tmp = xmlTextReaderCollectSiblings(node->children);
+xmlBufferCat(buffer, tmp);
+xmlFree(tmp);
+break;
+}
+default:
+break;
+}
+}
+ret = buffer->content;
+buffer->content = NULL;
+xmlBufferFree(buffer);
+return(ret);
+}
+/**
+* xmlTextReaderRead:
+* @param reader the xmlTextReaderPtr used
+*
+*  Moves the position of the current instance to the next node in
+*  the stream, exposing its properties.
+*
+*  Returns 1 if the node was read successfully, 0 if there is no more
+*          nodes to read, or -1 in case of error
+*/
+XMLPUBFUNEXPORT int
+xmlTextReaderRead(xmlTextReaderPtr reader)
+{
+int val, olddepth = 0;
+xmlTextReaderState oldstate = XML_TEXTREADER_START;
+xmlNodePtr oldnode = NULL;
+if (reader == NULL)
+return(-1);
+reader->curnode = NULL;
+if (reader->doc != NULL)
+return(xmlTextReaderReadTree(reader));
+if (reader->ctxt == NULL)
+return(-1);
+if (reader->ctxt->wellFormed != 1)
+return(-1);
+#ifdef DEBUG_READER
+fprintf(stderr, "\nREAD ");
+DUMP_READER
+#endif
+if (reader->mode == XML_TEXTREADER_MODE_INITIAL)
+{
+reader->mode = XML_TEXTREADER_MODE_INTERACTIVE;
+/*
+* Initial state
+*/
+do {
+val = xmlTextReaderPushData(reader);
+if (val < 0)
+return(-1);
+} while ((reader->ctxt->node == NULL) &&
+((reader->mode != XML_TEXTREADER_MODE_EOF) &&
+(reader->mode != XML_TEXTREADER_DONE)));
+if (reader->ctxt->node == NULL) {
+if (reader->ctxt->myDoc != NULL) {
+reader->node = reader->ctxt->myDoc->children;
+}
+if (reader->node == NULL)
+return(-1);
+reader->state = XML_TEXTREADER_ELEMENT;
+} else {
+if (reader->ctxt->myDoc != NULL) {
+reader->node = reader->ctxt->myDoc->children;
+}
+if (reader->node == NULL)
+reader->node = reader->ctxt->nodeTab[0];
+reader->state = XML_TEXTREADER_ELEMENT;
+}
+reader->depth = 0;
+//reader->ctxt->parseMode = XML_PARSE_READER;
+goto node_found;
+}
+oldstate = reader->state;
+olddepth = reader->ctxt->nodeNr;
+oldnode = reader->node;
+get_next_node:
+if (reader->node == NULL) {
+if (reader->mode == XML_TEXTREADER_DONE)
+return(0);
+else
+return(-1);
+}
+/*
+* If we are not backtracking on ancestors or examined nodes,
+* that the parser didn't finished or that we arent at the end
+* of stream, continue processing.
+*/
+while (
+reader->node
+&&
+!reader->node->next
+&&
+reader->ctxt->nodeNr == olddepth
+&&
+(
+(oldstate == XML_TEXTREADER_BACKTRACK)       ||
+(reader->node->children == NULL)             ||
+(reader->node->type == XML_ENTITY_REF_NODE)
+||
+(
+(reader->node->children != NULL) &&
+(reader->node->children->type == XML_TEXT_NODE) &&
+(reader->node->children->next == NULL)
+)
+||
+(reader->node->type == XML_DTD_NODE) ||
+(reader->node->type == XML_DOCUMENT_NODE) ||
+(reader->node->type == XML_HTML_DOCUMENT_NODE)
+)
+&&
+(
+(reader->ctxt->node == NULL) ||
+(reader->ctxt->node == reader->node) ||
+(reader->ctxt->node == reader->node->parent)
+)
+&&
+(reader->ctxt->instate != XML_PARSER_EOF))
+{
+val = xmlTextReaderPushData(reader);
+if (val < 0)
+return(-1);
+if (reader->node == NULL)
+goto node_end;
+} // while
+if (oldstate != XML_TEXTREADER_BACKTRACK)
+{
+if ((reader->node->children != NULL) &&
+(reader->node->type != XML_ENTITY_REF_NODE) &&
+(reader->node->type != XML_XINCLUDE_START) &&
+(reader->node->type != XML_DTD_NODE))
+{
+reader->node = reader->node->children;
+reader->depth++;
+reader->state = XML_TEXTREADER_ELEMENT;
+goto node_found;
+}
+}
+if (reader->node->next)
+{
+if ((oldstate == XML_TEXTREADER_ELEMENT) &&
+(reader->node->type == XML_ELEMENT_NODE) &&
+(reader->node->children == NULL) &&
+((reader->node->extra & NODE_IS_EMPTY) == 0)
+#ifdef LIBXML_XINCLUDE_ENABLED
+&& (reader->in_xinclude <= 0)
+#endif
+)
+{
+reader->state = XML_TEXTREADER_END;
+goto node_found;
+}
+#ifdef LIBXML_REGEXP_ENABLED
+if ((reader->validate) &&
+(reader->node->type == XML_ELEMENT_NODE))
+{
+xmlTextReaderValidatePop(reader);
+}
+#endif /* LIBXML_REGEXP_ENABLED */
+if ((reader->preserves > 0) &&
+(reader->node->extra & NODE_IS_SPRESERVED))
+{
+reader->preserves--;
+}
+reader->node = reader->node->next;
+reader->state = XML_TEXTREADER_ELEMENT;
+/*
+* Cleanup of the old node
+*/
+if ((reader->preserves == 0) &&
+#ifdef LIBXML_XINCLUDE_ENABLED
+(reader->in_xinclude == 0) &&
+#endif
+(reader->entNr == 0) &&
+(reader->node->prev != NULL) &&
+(reader->node->prev->type != XML_DTD_NODE) &&
+(reader->entNr == 0))
+{
+xmlNodePtr tmp = reader->node->prev;
+if ((tmp->extra & NODE_IS_PRESERVED) == 0)
+{
+xmlUnlinkNode(tmp);
+xmlTextReaderFreeNode(reader, tmp);
+}
+}
+goto node_found;
+} // if (reader->node->next)
+if ((oldstate == XML_TEXTREADER_ELEMENT) &&
+(reader->node->type == XML_ELEMENT_NODE) &&
+(reader->node->children == NULL) &&
+((reader->node->extra & NODE_IS_EMPTY) == 0))
+{
+reader->state = XML_TEXTREADER_END;
+goto node_found;
+}
+#ifdef LIBXML_REGEXP_ENABLED
+if ((reader->validate) && (reader->node->type == XML_ELEMENT_NODE))
+{
+xmlTextReaderValidatePop(reader);
+}
+#endif /* LIBXML_REGEXP_ENABLED */
+if ((reader->preserves > 0) &&
+(reader->node->extra & NODE_IS_SPRESERVED))
+{
+reader->preserves--;
+}
+reader->node = reader->node->parent;
+if ((reader->node == NULL) ||
+(reader->node->type == XML_DOCUMENT_NODE) ||
+#ifdef LIBXML_DOCB_ENABLED
+(reader->node->type == XML_DOCB_DOCUMENT_NODE) ||
+#endif
+(reader->node->type == XML_HTML_DOCUMENT_NODE))
+{
+if (reader->mode != XML_TEXTREADER_DONE)
+{
+val = xmlParseChunk(reader->ctxt, "", 0, 1);
+reader->mode = XML_TEXTREADER_DONE;
+if (val != 0)
+return(-1);
+}
+reader->node = NULL;
+reader->depth = -1;
+/*
+* Cleanup of the old node
+*/
+if ((reader->preserves == 0) &&
+#ifdef LIBXML_XINCLUDE_ENABLED
+(reader->in_xinclude == 0) &&
+#endif
+(reader->entNr == 0) &&
+(oldnode->type != XML_DTD_NODE) &&
+((oldnode->extra & NODE_IS_PRESERVED) == 0) &&
+(reader->entNr == 0))
+{
+xmlUnlinkNode(oldnode);
+xmlTextReaderFreeNode(reader, oldnode);
+}
+goto node_end;
+}
+if ((reader->preserves == 0) &&
+#ifdef LIBXML_XINCLUDE_ENABLED
+(reader->in_xinclude == 0) &&
+#endif
+(reader->entNr == 0) &&
+(reader->node->last != NULL) &&
+((reader->node->last->extra & NODE_IS_PRESERVED) == 0))
+{
+xmlNodePtr tmp = reader->node->last;
+xmlUnlinkNode(tmp);
+xmlTextReaderFreeNode(reader, tmp);
+}
+reader->depth--;
+reader->state = XML_TEXTREADER_BACKTRACK;
+node_found:
+DUMP_READER
+/*
+* If we are in the middle of a piece of CDATA make sure it's finished
+*/
+if ((reader->node != NULL) &&
+(reader->node->next == NULL) &&
+((reader->node->type == XML_TEXT_NODE) ||
+(reader->node->type == XML_CDATA_SECTION_NODE)))
+{
+if (xmlTextReaderExpand(reader) == NULL) return -1;
+}
+#ifdef LIBXML_XINCLUDE_ENABLED
+/*
+* Handle XInclude if asked for
+*/
+if ((reader->xinclude) && (reader->node != NULL) &&
+(reader->node->type == XML_ELEMENT_NODE) &&
+(reader->node->ns != NULL) &&
+((xmlStrEqual(reader->node->ns->href, XINCLUDE_NS)) ||
+(xmlStrEqual(reader->node->ns->href, XINCLUDE_OLD_NS))))
+{
+if (reader->xincctxt == NULL) {
+reader->xincctxt = xmlXIncludeNewContext(reader->ctxt->myDoc);
+xmlXIncludeSetFlags(reader->xincctxt,
+reader->parserFlags);
+//                            reader->parserFlags & (~XML_PARSE_NOXINCNODE));
+}
+/*
+* expand that node and process it
+*/
+if (xmlTextReaderExpand(reader) == NULL)
+return -1;
+xmlXIncludeProcessNode(reader->xincctxt, reader->node);
+}
+if (reader->node->type == XML_XINCLUDE_START) {
+reader->in_xinclude++;
+goto get_next_node;
+}
+if (reader->node->type == XML_XINCLUDE_END) {
+reader->in_xinclude--;
+goto get_next_node;
+}
+#endif
+/*
+* Handle entities enter and exit when in entity replacement mode
+*/
+if ((reader->node != NULL) &&
+(reader->node->type == XML_ENTITY_REF_NODE) &&
+(reader->ctxt != NULL) && (reader->ctxt->replaceEntities == 1))
+{
+/*
+* Case where the underlying tree is not availble, lookup the entity
+* and walk it.
+*/
+if ((reader->node->children == NULL) && (reader->ctxt->sax != NULL) &&
+(reader->ctxt->sax->getEntity != NULL))
+{
+reader->node->children = (xmlNodePtr)
+reader->ctxt->sax->getEntity(reader->ctxt, reader->node->name);
+}
+if ((reader->node->children != NULL) &&
+(reader->node->children->type == XML_ENTITY_DECL) &&
+(reader->node->children->children != NULL))
+{
+xmlTextReaderEntPush(reader, reader->node);
+reader->node = reader->node->children->children;
+}
+}
+#ifdef LIBXML_REGEXP_ENABLED
+else if ((reader->node != NULL) &&
+(reader->node->type == XML_ENTITY_REF_NODE) &&
+(reader->ctxt != NULL) && (reader->validate))
+{
+xmlTextReaderValidateEntity(reader);
+}
+#endif /* LIBXML_REGEXP_ENABLED */
+if ((reader->node != NULL) &&
+(reader->node->type == XML_ENTITY_DECL) &&
+(reader->ent != NULL) && (reader->ent->children == reader->node))
+{
+reader->node = xmlTextReaderEntPop(reader);
+reader->depth++;
+goto get_next_node;
+}
+#ifdef LIBXML_REGEXP_ENABLED
+if ((reader->validate) && (reader->node != NULL))
+{
+xmlNodePtr node = reader->node;
+if ((node->type == XML_ELEMENT_NODE) &&
+((reader->state != XML_TEXTREADER_END) &&
+(reader->state != XML_TEXTREADER_BACKTRACK)))
+{
+xmlTextReaderValidatePush(reader);
+}
+else if ((node->type == XML_TEXT_NODE) ||
+(node->type == XML_CDATA_SECTION_NODE))
+{
+xmlTextReaderValidateCData(reader, node->content, xmlStrlen(node->content));
+}
+}
+#endif /* LIBXML_REGEXP_ENABLED */
+#ifdef LIBXML_PATTERN_ENABLED
+if ((reader->patternNr > 0) && (reader->state != XML_TEXTREADER_END) &&
+(reader->state != XML_TEXTREADER_BACKTRACK))
+{
+int i;
+for (i = 0;i < reader->patternNr;i++)
+{
+if (xmlPatternMatch(reader->patternTab[i], reader->node) == 1)
+{
+xmlTextReaderPreserve(reader);
+break;
+}
+}
+}
+#endif /* LIBXML_PATTERN_ENABLED */
+#ifdef LIBXML_SCHEMAS_ENABLED
+if ((reader->validate == XML_TEXTREADER_VALIDATE_XSD) &&
+(reader->xsdValidErrors == 0) &&
+(reader->xsdValidCtxt != NULL)) {
+reader->xsdValidErrors = !xmlSchemaIsValid(reader->xsdValidCtxt);
+}
+#endif /* LIBXML_PATTERN_ENABLED */
+return(1);
+node_end:
+reader->mode = XML_TEXTREADER_DONE;
+return(0);
+}
+/**
+* xmlTextReaderReadState:
+* @param reader the xmlTextReaderPtr used
+*
+* Gets the read state of the reader.
+*
+* Returns the state value, or -1 in case of error
+*/
+XMLPUBFUNEXPORT int
+xmlTextReaderReadState(xmlTextReaderPtr reader)
+{
+if (reader == NULL)
+return(-1);
+return(reader->mode);
+}
+/**
+* xmlTextReaderExpand:
+* @param reader the xmlTextReaderPtr used
+*
+* Reads the contents of the current node and the full subtree. It then makes
+* the subtree available until the next xmlTextReaderRead() call
+*
+* Returns a node pointer valid until the next xmlTextReaderRead() call
+*         or NULL in case of error.
+*/
+XMLPUBFUNEXPORT xmlNodePtr
+xmlTextReaderExpand(xmlTextReaderPtr reader)
+{
+if ((reader == NULL) || (reader->node == NULL))
+return(NULL);
+if (reader->doc != NULL)
+return(reader->node);
+if (reader->ctxt == NULL)
+return(NULL);
+if (xmlTextReaderDoExpand(reader) < 0)
+return(NULL);
+return(reader->node);
+}
+/**
+* xmlTextReaderNext:
+* @param reader the xmlTextReaderPtr used
+*
+* Skip to the node following the current one in document order while
+* avoiding the subtree if any.
+*
+* Returns 1 if the node was read successfully, 0 if there is no more
+*          nodes to read, or -1 in case of error
+*/
+XMLPUBFUNEXPORT int
+xmlTextReaderNext(xmlTextReaderPtr reader) {
+int ret;
+xmlNodePtr cur;
+if (reader == NULL)
+return(-1);
+if (reader->doc != NULL)
+return(xmlTextReaderNextTree(reader));
+cur = reader->node;
+if ((cur == NULL) || (cur->type != XML_ELEMENT_NODE))
+return(xmlTextReaderRead(reader));
+if (reader->state == XML_TEXTREADER_END || reader->state == XML_TEXTREADER_BACKTRACK)
+return(xmlTextReaderRead(reader));
+if (cur->extra & NODE_IS_EMPTY)
+return(xmlTextReaderRead(reader));
+do {
+ret = xmlTextReaderRead(reader);
+if (ret != 1)
+return(ret);
+} while (reader->node != cur);
+return(xmlTextReaderRead(reader));
+}
+/**
+* xmlTextReaderReadInnerXml:
+* @param reader the xmlTextReaderPtr used
+*
+* Reads the contents of the current node, including child nodes and markup.
+*
+* Returns a string containing the XML content, or NULL if the current node
+*         is neither an element nor attribute, or has no child nodes. The
+*         string must be deallocated by the caller.
+*/
+XMLPUBFUNEXPORT xmlChar*
+xmlTextReaderReadInnerXml(xmlTextReaderPtr reader ATTRIBUTE_UNUSED)
+{
+xmlChar *resbuf;
+xmlNodePtr node, cur_node;
+xmlBufferPtr buff, buff2;
+xmlDocPtr doc;
+if (xmlTextReaderExpand(reader) == NULL) {
+return NULL;
+}
+doc = reader->doc;
+buff = xmlBufferCreate();
+for (cur_node = reader->node->children; cur_node != NULL;
+cur_node = cur_node->next) {
+node = xmlDocCopyNode(cur_node, doc, 1);
+buff2 = xmlBufferCreate();
+if (xmlNodeDump(buff2, doc, node, 0, 0) == -1) {
+xmlFreeNode(node);
+xmlBufferFree(buff2);
+xmlBufferFree(buff);
+return NULL;
+}
+xmlBufferCat(buff, buff2->content);
+xmlFreeNode(node);
+xmlBufferFree(buff2);
+}
+resbuf = buff->content;
+return resbuf;
+}
+/**
+* xmlTextReaderReadOuterXml:
+* @param reader the xmlTextReaderPtr used
+*
+* Reads the contents of the current node, including child nodes and markup.
+*
+* Returns a string containing the XML content, or NULL if the current node
+*         is neither an element nor attribute, or has no child nodes. The
+*         string must be deallocated by the caller.
+*/
+XMLPUBFUNEXPORT xmlChar*
+xmlTextReaderReadOuterXml(xmlTextReaderPtr reader)
+{
+xmlChar *resbuf;
+xmlNodePtr node;
+xmlBufferPtr buff;
+xmlDocPtr doc;
+node = reader->node;
+doc = reader->doc;
+if (xmlTextReaderExpand(reader) == NULL) {
+return NULL;
+}
+node = xmlDocCopyNode(node, doc, 1);
+buff = xmlBufferCreate();
+if (xmlNodeDump(buff, doc, node, 0, 0) == -1) {
+xmlFreeNode(node);
+xmlBufferFree(buff);
+return NULL;
+}
+resbuf = buff->content;
+buff->content = NULL;
+xmlFreeNode(node);
+xmlBufferFree(buff);
+return resbuf;
+}
+/**
+* xmlTextReaderReadString:
+* @param reader the xmlTextReaderPtr used
+*
+* Reads the contents of an element or a text node as a string.
+*
+* Returns a string containing the contents of the Element or Text node,
+*         or NULL if the reader is positioned on any other type of node.
+*         The string must be deallocated by the caller.
+*/
+XMLPUBFUNEXPORT xmlChar*
+xmlTextReaderReadString(xmlTextReaderPtr reader)
+{
+	xmlNodePtr node;
+if ((reader == NULL) || (reader->node == NULL))
+return(NULL);
+node = (reader->curnode != NULL) ? reader->curnode : reader->node;
+switch (node->type) {
+case XML_TEXT_NODE:
+if (node->content != NULL)
+return(xmlStrdup(node->content));
+break;
+case XML_ELEMENT_NODE:
+if (xmlTextReaderDoExpand(reader) != -1) {
+return xmlTextReaderCollectSiblings(node->children);
+}
+case XML_ATTRIBUTE_NODE:
+TODO
+break;
+default:
+break;
+}
+return(NULL);
+}
+#if 0
+/**
+* xmlTextReaderReadBase64:
+* @param reader the xmlTextReaderPtr used
+* @param array a byte array to store the content.
+* @param offset the zero-based index into array where the method should
+*           begin to write.
+* @param len the number of bytes to write.
+*
+* Reads and decodes the Base64 encoded contents of an element and
+* stores the result in a byte buffer.
+*
+* Returns the number of bytes written to array, or zero if the current
+*         instance is not positioned on an element or -1 in case of error.
+*/
+int
+xmlTextReaderReadBase64(xmlTextReaderPtr reader,
+unsigned char *array ATTRIBUTE_UNUSED,
+int offset ATTRIBUTE_UNUSED,
+int len ATTRIBUTE_UNUSED) {
+if ((reader == NULL) || (reader->ctxt == NULL))
+return(-1);
+if (reader->ctxt->wellFormed != 1)
+return(-1);
+if ((reader->node == NULL) || (reader->node->type == XML_ELEMENT_NODE))
+return(0);
+TODO
+return(0);
+}
+/**
+* xmlTextReaderReadBinHex:
+* @param reader the xmlTextReaderPtr used
+* @param array a byte array to store the content.
+* @param offset the zero-based index into array where the method should
+*           begin to write.
+* @param len the number of bytes to write.
+*
+* Reads and decodes the BinHex encoded contents of an element and
+* stores the result in a byte buffer.
+*
+* Returns the number of bytes written to array, or zero if the current
+*         instance is not positioned on an element or -1 in case of error.
+*/
+int
+xmlTextReaderReadBinHex(xmlTextReaderPtr reader,
+unsigned char *array ATTRIBUTE_UNUSED,
+int offset ATTRIBUTE_UNUSED,
+int len ATTRIBUTE_UNUSED) {
+if ((reader == NULL) || (reader->ctxt == NULL))
+return(-1);
+if (reader->ctxt->wellFormed != 1)
+return(-1);
+if ((reader->node == NULL) || (reader->node->type == XML_ELEMENT_NODE))
+return(0);
+TODO
+return(0);
+}
+#endif
+/************************************************************************
+*                                                                      *
+*          Operating on a preparsed tree                               *
+*                                                                      *
+************************************************************************/
+static int
+xmlTextReaderNextTree(xmlTextReaderPtr reader)
+{
+if (reader == NULL)
+return(-1);
+if (reader->state == XML_TEXTREADER_END)
+return(0);
+if (reader->node == NULL)
+{
+if (reader->doc->children == NULL)
+{
+reader->state = XML_TEXTREADER_END;
+return(0);
+}
+reader->node = reader->doc->children;
+reader->state = XML_TEXTREADER_START;
+return(1);
+}
+if (reader->state != XML_TEXTREADER_BACKTRACK)
+{
+if (reader->node->children != 0)
+{
+reader->node = reader->node->children;
+reader->depth++;
+reader->state = XML_TEXTREADER_START;
+return(1);
+}
+if ((reader->node->type == XML_ELEMENT_NODE) ||
+(reader->node->type == XML_ATTRIBUTE_NODE))
+{
+reader->state = XML_TEXTREADER_BACKTRACK;
+return(1);
+}
+}
+if (reader->node->next != 0)
+{
+reader->node = reader->node->next;
+reader->state = XML_TEXTREADER_START;
+return(1);
+}
+if (reader->node->parent != 0)
+{
+if (reader->node->parent->type == XML_DOCUMENT_NODE)
+{
+reader->state = XML_TEXTREADER_END;
+return(0);
+}
+reader->node = reader->node->parent;
+reader->depth--;
+reader->state = XML_TEXTREADER_BACKTRACK;
+return(1);
+}
+reader->state = XML_TEXTREADER_END;
+return(1);
+}
+/**
+* xmlTextReaderReadTree:
+* @param reader the xmlTextReaderPtr used
+*
+*  Moves the position of the current instance to the next node in
+*  the stream, exposing its properties.
+*
+*  Returns 1 if the node was read successfully, 0 if there is no more
+*          nodes to read, or -1 in case of error
+*/
+static int
+xmlTextReaderReadTree(xmlTextReaderPtr reader)
+{
+if (reader->state == XML_TEXTREADER_END)
+return(0);
+next_node:
+if (reader->node == NULL)
+{
+if (reader->doc->children == NULL)
+{
+reader->state = XML_TEXTREADER_END;
+return(0);
+}
+reader->node = reader->doc->children;
+reader->state = XML_TEXTREADER_START;
+goto found_node;
+}
+if ((reader->state != XML_TEXTREADER_BACKTRACK) &&
+(reader->node->type != XML_DTD_NODE) &&
+(reader->node->type != XML_XINCLUDE_START) &&
+(reader->node->type != XML_ENTITY_REF_NODE))
+{
+if (reader->node->children != NULL)
+{
+reader->node = reader->node->children;
+reader->depth++;
+reader->state = XML_TEXTREADER_START;
+goto found_node;
+}
+if (reader->node->type == XML_ATTRIBUTE_NODE)
+{
+reader->state = XML_TEXTREADER_BACKTRACK;
+goto found_node;
+}
+}
+if (reader->node->next != NULL)
+{
+reader->node = reader->node->next;
+reader->state = XML_TEXTREADER_START;
+goto found_node;
+}
+if (reader->node->parent != NULL)
+{
+if ((reader->node->parent->type == XML_DOCUMENT_NODE) ||
+(reader->node->parent->type == XML_HTML_DOCUMENT_NODE))
+{
+reader->state = XML_TEXTREADER_END;
+return(0);
+}
+reader->node = reader->node->parent;
+reader->depth--;
+reader->state = XML_TEXTREADER_BACKTRACK;
+goto found_node;
+}
+reader->state = XML_TEXTREADER_END;
+found_node:
+if ((reader->node->type == XML_XINCLUDE_START) ||
+(reader->node->type == XML_XINCLUDE_END))
+{
+goto next_node;
+}
+return(1);
+}
+/**
+* xmlTextReaderNextSibling:
+* @param reader the xmlTextReaderPtr used
+*
+* Skip to the node following the current one in document order while
+* avoiding the subtree if any.
+* Currently implemented only for Readers built on a document
+*
+* Returns 1 if the node was read successfully, 0 if there is no more
+*          nodes to read, or -1 in case of error
+*/
+XMLPUBFUNEXPORT int
+xmlTextReaderNextSibling(xmlTextReaderPtr reader)
+{
+if (reader == NULL)
+return(-1);
+if (reader->doc == NULL)
+{
+return(-1);
+}
+if (reader->state == XML_TEXTREADER_END)
+return(0);
+if (reader->node == NULL)
+return(xmlTextReaderNextTree(reader));
+if (reader->node->next != NULL)
+{
+reader->node = reader->node->next;
+reader->state = XML_TEXTREADER_START;
+return(1);
+}
+return(0);
+}
+/************************************************************************
+*                                                                      *
+*          Constructor and destructors                                 *
+*                                                                      *
+************************************************************************/
+/**
+* xmlNewTextReader:
+* @param input the xmlParserInputBufferPtr used to read data
+* @param URI the URI information for the source if available
+*
+* Create an xmlTextReader structure fed with input
+*
+* Returns the new xmlTextReaderPtr or NULL in case of error
+*/
+XMLPUBFUNEXPORT xmlTextReaderPtr
+xmlNewTextReader(xmlParserInputBufferPtr input, const char *URI)
+{
+xmlTextReaderPtr ret;
+if (input == NULL)
+return(NULL);
+ret = (xmlTextReaderPtr) xmlMalloc(sizeof(xmlTextReader));
+if (!ret) {
+xmlGenericError(xmlGenericErrorContext,
+EMBED_ERRTXT("xmlNewTextReader : malloc failed\n"));
+return(NULL);
+}
+memset(ret, 0, sizeof(xmlTextReader));
+//ret->doc = NULL; // Here and below: after memset, setting to 0 (NULL) is not needed, so removed
+//ret->entTab = NULL;
+//ret->entMax = 0;
+//ret->entNr = 0;
+ret->input = input;
+ret->buffer = xmlBufferCreateSize(100);
+if (ret->buffer == NULL) {
+xmlFree(ret);
+xmlGenericError(xmlGenericErrorContext,
+"xmlNewTextReader : malloc failed\n");
+return(NULL);
+}
+ret->sax = (xmlSAXHandler *) xmlMalloc(sizeof(xmlSAXHandler));
+if (!ret->sax) {
+xmlBufferFree(ret->buffer);
+xmlFree(ret);
+xmlGenericError(xmlGenericErrorContext,
+EMBED_ERRTXT("xmlNewTextReader : malloc failed\n"));
+return(NULL);
+}
+// Set DOM's default callbacks for SAX stream, and then replace with own Reader's callbacks;
+// DOM's callbacks are stored in this->{saxEvent} field for later use.
+xmlSAXVersion(ret->sax, 2);
+ret->startElement = ret->sax->startElement;
+ret->sax->startElement = xmlTextReaderStartElement;
+ret->endElement = ret->sax->endElement;
+ret->sax->endElement = xmlTextReaderEndElement;
+#ifdef LIBXML_SAX1_ENABLED
+if (ret->sax->initialized == XML_SAX2_MAGIC) {
+#endif /* LIBXML_SAX1_ENABLED */
+ret->startElementNs = ret->sax->startElementNs;
+ret->sax->startElementNs = xmlTextReaderStartElementNs;
+ret->endElementNs = ret->sax->endElementNs;
+ret->sax->endElementNs = xmlTextReaderEndElementNs;
+#ifdef LIBXML_SAX1_ENABLED
+} else {
+ret->startElementNs = NULL;
+ret->endElementNs = NULL;
+}
+#endif /* LIBXML_SAX1_ENABLED */
+ret->characters = ret->sax->characters;
+ret->sax->characters = xmlTextReaderCharacters;
+ret->sax->ignorableWhitespace = xmlTextReaderCharacters;
+ret->cdataBlock = ret->sax->cdataBlock;
+ret->sax->cdataBlock = xmlTextReaderCDataBlock;
+ret->mode = XML_TEXTREADER_MODE_INITIAL;
+//ret->node = NULL;
+//ret->curnode = NULL;
+if (ret->input->buffer->use < 4) {
+xmlParserInputBufferRead(input, 4);
+}
+if (ret->input->buffer->use >= 4) {
+ret->ctxt = xmlCreatePushParserCtxt(ret->sax, NULL,
+(const char *) ret->input->buffer->content, 4, URI);
+//ret->base = 0;
+ret->cur = 4;
+} else {
+ret->ctxt = xmlCreatePushParserCtxt(ret->sax, NULL, NULL, 0, URI);
+//ret->base = 0;
+//ret->cur = 0;
+}
+if (!ret->ctxt) {
+xmlGenericError(xmlGenericErrorContext,
+EMBED_ERRTXT("xmlNewTextReader : malloc failed\n"));
+xmlBufferFree(ret->buffer);
+xmlFree(ret->sax);
+xmlFree(ret);
+return(NULL);
+}
+//ret->ctxt->parseMode = XML_PARSE_READER;
+// "user data" of the XML parser context is pointer to this xmlTextReader
+// the parser context will be provided during calls to each of SAX callbacks.
+ret->ctxt->_private = ret;
+#ifdef LIBXML_ENABLE_NODE_LINEINFO
+ret->ctxt->linenumbers = 1;
+#endif
+// make SAX parser store name strings in dictionary
+ret->ctxt->dictNames = 1;
+ret->allocs = XML_TEXTREADER_CTXT;
+/*
+* use the parser dictionnary to allocate all elements and attributes names
+*/
+ret->ctxt->docdict = 1;
+ret->dict = ret->ctxt->dict;
+#ifdef LIBXML_XINCLUDE_ENABLED
+//ret->xinclude = 0;
+#endif
+#ifdef LIBXML_PATTERN_ENABLED
+//ret->patternMax = 0;
+//ret->patternTab = NULL;
+#endif
+return(ret);
+}
+/**
+* xmlNewTextReaderFilename:
+* @param URI the URI of the resource to process
+*
+* Create an xmlTextReader structure fed with the resource at URI
+*
+* Returns the new xmlTextReaderPtr or NULL in case of error
+*/
+XMLPUBFUNEXPORT xmlTextReaderPtr
+xmlNewTextReaderFilename(const char *URI)
+{
+xmlParserInputBufferPtr input;
+xmlTextReaderPtr ret;
+// Note:  'directory' variable was removed and function body changed (optimized)
+input = xmlParserInputBufferCreateFilename(URI, XML_CHAR_ENCODING_NONE);
+if (!input)
+return(NULL);
+ret = xmlNewTextReader(input, URI);
+if (!ret) {
+xmlFreeParserInputBuffer(input);
+return(NULL);
+}
+ret->allocs |= XML_TEXTREADER_INPUT;
+if (!ret->ctxt->directory)
+ret->ctxt->directory = xmlParserGetDirectory(URI);
+return(ret);
+}
+/**
+* xmlFreeTextReader:
+* @param reader the xmlTextReaderPtr
+*
+* Deallocate all the resources associated to the reader
+*/
+XMLPUBFUNEXPORT void
+xmlFreeTextReader(xmlTextReaderPtr reader)
+{
+if (reader == NULL)
+return;
+#ifdef LIBXML_SCHEMAS_ENABLED
+if (reader->rngSchemas != NULL) {
+xmlRelaxNGFree(reader->rngSchemas);
+reader->rngSchemas = NULL;
+}
+if (reader->rngValidCtxt != NULL) {
+xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
+reader->rngValidCtxt = NULL;
+}
+if (reader->xsdPlug != NULL) {
+xmlSchemaSAXUnplug(reader->xsdPlug);
+reader->xsdPlug = NULL;
+}
+if (reader->xsdValidCtxt != NULL) {
+xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
+reader->xsdValidCtxt = NULL;
+}
+if (reader->xsdSchemas != NULL) {
+xmlSchemaFree(reader->xsdSchemas);
+reader->xsdSchemas = NULL;
+}
+#endif
+#ifdef LIBXML_XINCLUDE_ENABLED
+if (reader->xincctxt != NULL)
+xmlXIncludeFreeContext(reader->xincctxt);
+#endif
+#ifdef LIBXML_PATTERN_ENABLED
+if (reader->patternTab != NULL) {
+int i;
+for (i = 0;i < reader->patternNr;i++) {
+if (reader->patternTab[i] != NULL)
+xmlFreePattern(reader->patternTab[i]);
+}
+xmlFree(reader->patternTab);
+}
+#endif
+if (reader->ctxt != NULL) {
+if (reader->dict == reader->ctxt->dict)
+reader->dict = NULL;
+if (reader->ctxt->myDoc != NULL) {
+if (reader->preserve == 0)
+xmlTextReaderFreeDoc(reader, reader->ctxt->myDoc);
+reader->ctxt->myDoc = NULL;
+}
+if ((reader->ctxt->vctxt.vstateTab != NULL) &&
+(reader->ctxt->vctxt.vstateMax > 0)){
+xmlFree(reader->ctxt->vctxt.vstateTab);
+reader->ctxt->vctxt.vstateTab = NULL;
+reader->ctxt->vctxt.vstateMax = 0;
+}
+if (reader->allocs & XML_TEXTREADER_CTXT)
+xmlFreeParserCtxt(reader->ctxt);
+}
+if (reader->sax != NULL)
+xmlFree(reader->sax);
+if ((reader->input != NULL)  && (reader->allocs & XML_TEXTREADER_INPUT))
+xmlFreeParserInputBuffer(reader->input);
+if (reader->faketext != NULL) {
+xmlFreeNode(reader->faketext);
+}
+if (reader->buffer != NULL)
+xmlBufferFree(reader->buffer);
+if (reader->entTab != NULL)
+xmlFree(reader->entTab);
+if (reader->dict != NULL)
+xmlDictFree(reader->dict);
+xmlFree(reader);
+}
+/************************************************************************
+*                                                                      *
+*          Methods for XmlTextReader                                   *
+*                                                                      *
+************************************************************************/
+/**
+* xmlTextReaderClose:
+* @param reader the xmlTextReaderPtr used
+*
+* This method releases any resources allocated by the current instance
+* changes the state to Closed and close any underlying input.
+*
+* Returns 0 or -1 in case of error
+*/
+XMLPUBFUNEXPORT int
+xmlTextReaderClose(xmlTextReaderPtr reader) {
+if (reader == NULL)
+return(-1);
+reader->node = NULL;
+reader->curnode = NULL;
+reader->mode = XML_TEXTREADER_MODE_CLOSED;
+if (reader->ctxt != NULL) {
+xmlStopParser(reader->ctxt);
+if (reader->ctxt->myDoc != NULL) {
+if (reader->preserve == 0)
+xmlTextReaderFreeDoc(reader, reader->ctxt->myDoc);
+reader->ctxt->myDoc = NULL;
+}
+}
+if ((reader->input != NULL)  && (reader->allocs & XML_TEXTREADER_INPUT)) {
+xmlFreeParserInputBuffer(reader->input);
+reader->allocs -= XML_TEXTREADER_INPUT;
+}
+return(0);
+}
+/**
+* xmlTextReaderGetAttributeNo:
+* @param reader the xmlTextReaderPtr used
+* @param no the zero-based index of the attribute relative to the containing element
+*
+* Provides the value of the attribute with the specified index relative
+* to the containing element.
+*
+* Returns a string containing the value of the specified attribute, or NULL
+*    in case of error. The string must be deallocated by the caller.
+*/
+XMLPUBFUNEXPORT xmlChar *
+xmlTextReaderGetAttributeNo(xmlTextReaderPtr reader, int no) {
+xmlChar *ret;
+int i;
+xmlAttrPtr cur;
+xmlNsPtr ns;
+if (reader == NULL)
+return(NULL);
+if (reader->node == NULL)
+return(NULL);
+if (reader->curnode != NULL)
+return(NULL);
+if (reader->node->type != XML_ELEMENT_NODE)
+return(NULL);
+ns = reader->node->nsDef;
+for (i = 0;(i < no) && (ns != NULL);i++) {
+ns = ns->next;
+}
+if (ns != NULL)
+return(xmlStrdup(ns->href));
+cur = reader->node->properties;
+if (cur == NULL)
+return(NULL);
+for (;i < no;i++) {
+cur = cur->next;
+if (cur == NULL)
+return(NULL);
+}
+ret = xmlNodeListGetString(reader->node->doc, cur->children, 1);
+if (ret == NULL)
+return(xmlStrdup((xmlChar *)""));
+return(ret);
+}
+/**
+* xmlTextReaderGetAttribute:
+* @param reader the xmlTextReaderPtr used
+* @param name the qualified name of the attribute.
+*
+* Provides the value of the attribute with the specified qualified name.
+*
+* Returns a string containing the value of the specified attribute, or NULL
+*    in case of error. The string must be deallocated by the caller.
+*/
+XMLPUBFUNEXPORT xmlChar *
+xmlTextReaderGetAttribute(xmlTextReaderPtr reader, const xmlChar *name) {
+xmlChar *prefix = NULL;
+xmlChar *localname;
+xmlNsPtr ns;
+xmlChar *ret = NULL;
+if ((reader == NULL) || (name == NULL))
+return(NULL);
+if (reader->node == NULL)
+return(NULL);
+if (reader->curnode != NULL)
+return(NULL);
+if (reader->node->type != XML_ELEMENT_NODE)
+return(NULL);
+localname = xmlSplitQName2(name, &prefix);
+if (localname == NULL) {
+/*
+* Namespace default decl
+*/
+if (xmlStrEqual(name, BAD_CAST "xmlns")) {
+ns = reader->node->nsDef;
+while (ns != NULL) {
+if (ns->prefix == NULL) {
+return(xmlStrdup(ns->href));
+}
+ns = ns->next;
+}
+return NULL;
+}
+return(xmlGetNoNsProp(reader->node, name));
+}
+/*
+* Namespace default decl
+*/
+if (xmlStrEqual(prefix, BAD_CAST "xmlns")) {
+ns = reader->node->nsDef;
+while (ns != NULL) {
+if ((ns->prefix != NULL) && (xmlStrEqual(ns->prefix, localname))) {
+ret = xmlStrdup(ns->href);
+break;
+}
+ns = ns->next;
+}
+} else {
+ns = xmlSearchNs(reader->node->doc, reader->node, prefix);
+if (ns != NULL)
+ret = xmlGetNsProp(reader->node, localname, ns->href);
+}
+xmlFree(localname);
+if (prefix != NULL)
+xmlFree(prefix);
+return(ret);
+}
+/**
+* xmlTextReaderGetAttributeNs:
+* @param reader the xmlTextReaderPtr used
+* @param localName the local name of the attribute.
+* @param namespaceURI the namespace URI of the attribute.
+*
+* Provides the value of the specified attribute
+*
+* Returns a string containing the value of the specified attribute, or NULL
+*    in case of error. The string must be deallocated by the caller.
+*/
+XMLPUBFUNEXPORT xmlChar *
+xmlTextReaderGetAttributeNs(xmlTextReaderPtr reader, const xmlChar *localName,
+const xmlChar *namespaceURI) {
+xmlChar *prefix = NULL;
+xmlNsPtr ns;
+if ((reader == NULL) || (localName == NULL))
+return(NULL);
+if (reader->node == NULL)
+return(NULL);
+if (reader->curnode != NULL)
+return(NULL);
+if (reader->node->type != XML_ELEMENT_NODE)
+return(NULL);
+if (xmlStrEqual(namespaceURI, BAD_CAST "http://www.w3.org/2000/xmlns/")) {
+if (! xmlStrEqual(localName, BAD_CAST "xmlns")) {
+prefix = BAD_CAST localName;
+}
+ns = reader->node->nsDef;
+while (ns != NULL) {
+if ((prefix == NULL && ns->prefix == NULL) ||
+((ns->prefix != NULL) && (xmlStrEqual(ns->prefix, localName)))) {
+return xmlStrdup(ns->href);
+}
+ns = ns->next;
+}
+return NULL;
+}
+return(xmlGetNsProp(reader->node, localName, namespaceURI));
+}
+/**
+* xmlTextReaderGetRemainder:
+* @param reader the xmlTextReaderPtr used
+*
+* Method to get the remainder of the buffered XML. this method stops the
+* parser, set its state to End Of File and return the input stream with
+* what is left that the parser did not use.
+*
+* The implementation is not good, the parser certainly progressed past
+* what's left in reader->input, and there is an allocation problem. Best
+* would be to rewrite it differently.
+*
+* Returns the xmlParserInputBufferPtr attached to the XML or NULL
+*    in case of error.
+*/
+XMLPUBFUNEXPORT xmlParserInputBufferPtr
+xmlTextReaderGetRemainder(xmlTextReaderPtr reader) {
+xmlParserInputBufferPtr ret = NULL;
+if (reader == NULL)
+return(NULL);
+if (reader->node == NULL)
+return(NULL);
+reader->node = NULL;
+reader->curnode = NULL;
+reader->mode = XML_TEXTREADER_MODE_EOF;
+if (reader->ctxt != NULL) {
+xmlStopParser(reader->ctxt);
+if (reader->ctxt->myDoc != NULL) {
+if (reader->preserve == 0)
+xmlTextReaderFreeDoc(reader, reader->ctxt->myDoc);
+reader->ctxt->myDoc = NULL;
+}
+}
+if (reader->allocs & XML_TEXTREADER_INPUT) {
+ret = reader->input;
+reader->input = NULL;
+reader->allocs -= XML_TEXTREADER_INPUT;
+} else {
+/*
+* Hum, one may need to duplicate the data structure because
+* without reference counting the input may be freed twice:
+*   - by the layer which allocated it.
+*   - by the layer to which would have been returned to.
+*/
+TODO
+return(NULL);
+}
+return(ret);
+}
+/**
+* xmlTextReaderLookupNamespace:
+* @param reader the xmlTextReaderPtr used
+* @param prefix the prefix whose namespace URI is to be resolved. To return
+*          the default namespace, specify NULL
+*
+* Resolves a namespace prefix in the scope of the current element.
+*
+* Returns a string containing the namespace URI to which the prefix maps
+*    or NULL in case of error. The string must be deallocated by the caller.
+*/
+XMLPUBFUNEXPORT xmlChar *
+xmlTextReaderLookupNamespace(xmlTextReaderPtr reader, const xmlChar *prefix) {
+xmlNsPtr ns;
+if (reader == NULL)
+return(NULL);
+if (reader->node == NULL)
+return(NULL);
+ns = xmlSearchNs(reader->node->doc, reader->node, prefix);
+if (ns == NULL)
+return(NULL);
+return(xmlStrdup(ns->href));
+}
+/**
+* xmlTextReaderMoveToAttributeNo:
+* @param reader the xmlTextReaderPtr used
+* @param no the zero-based index of the attribute relative to the containing
+*      element.
+*
+* Moves the position of the current instance to the attribute with
+* the specified index relative to the containing element.
+*
+* Returns 1 in case of success, -1 in case of error, 0 if not found
+*/
+XMLPUBFUNEXPORT int
+xmlTextReaderMoveToAttributeNo(xmlTextReaderPtr reader, int no) {
+int i;
+xmlAttrPtr cur;
+xmlNsPtr ns;
+if (reader == NULL)
+return(-1);
+if (reader->node == NULL)
+return(-1);
+if (reader->node->type != XML_ELEMENT_NODE)
+return(-1);
+reader->curnode = NULL;
+ns = reader->node->nsDef;
+for (i = 0;(i < no) && (ns != NULL);i++) {
+ns = ns->next;
+}
+if (ns != NULL) {
+reader->curnode = (xmlNodePtr) ns;
+return(1);
+}
+cur = reader->node->properties;
+if (cur == NULL)
+return(0);
+for (;i < no;i++) {
+cur = cur->next;
+if (cur == NULL)
+return(0);
+}
+reader->curnode = (xmlNodePtr) cur;
+return(1);
+}
+/**
+* xmlTextReaderMoveToAttribute:
+* @param reader the xmlTextReaderPtr used
+* @param name the qualified name of the attribute.
+*
+* Moves the position of the current instance to the attribute with
+* the specified qualified name.
+*
+* Returns 1 in case of success, -1 in case of error, 0 if not found
+*/
+XMLPUBFUNEXPORT int
+xmlTextReaderMoveToAttribute(xmlTextReaderPtr reader, const xmlChar* name)
+{
+xmlChar *prefix = NULL;
+xmlChar *localname;
+xmlNsPtr ns;
+xmlAttrPtr prop;
+if ((reader == NULL) || (name == NULL))
+return(-1);
+if (reader->node == NULL)
+return(-1);
+if (reader->node->type != XML_ELEMENT_NODE)
+return(0);
+localname = xmlSplitQName2(name, &prefix);
+if (localname == NULL) {
+/*
+* Namespace default decl
+*/
+if (xmlStrEqual(name, BAD_CAST "xmlns")) {
+ns = reader->node->nsDef;
+while (ns != NULL) {
+if (ns->prefix == NULL) {
+reader->curnode = (xmlNodePtr) ns;
+return(1);
+}
+ns = ns->next;
+}
+return(0);
+}
+prop = reader->node->properties;
+while (prop != NULL) {
+/*
+* One need to have
+*   - same attribute names
+*   - and the attribute carrying that namespace
+*/
+if ((xmlStrEqual(prop->name, name)) &&
+((prop->ns == NULL) || (prop->ns->prefix == NULL))) {
+reader->curnode = (xmlNodePtr) prop;
+return(1);
+}
+prop = prop->next;
+}
+return(0);
+}
+/*
+* Namespace default decl
+*/
+if (xmlStrEqual(prefix, BAD_CAST "xmlns")) {
+ns = reader->node->nsDef;
+while (ns != NULL) {
+if ((ns->prefix != NULL) && (xmlStrEqual(ns->prefix, localname))) {
+reader->curnode = (xmlNodePtr) ns;
+goto found;
+}
+ns = ns->next;
+}
+goto not_found;
+}
+prop = reader->node->properties;
+while (prop != NULL) {
+/*
+* One need to have
+*   - same attribute names
+*   - and the attribute carrying that namespace
+*/
+if ((xmlStrEqual(prop->name, localname)) &&
+(prop->ns != NULL) && (xmlStrEqual(prop->ns->prefix, prefix)))
+	{
+reader->curnode = (xmlNodePtr) prop;
+goto found;
+}
+prop = prop->next;
+}
+not_found:
+if (localname != NULL)
+xmlFree(localname);
+if (prefix != NULL)
+xmlFree(prefix);
+return(0);
+found:
+if (localname != NULL)
+xmlFree(localname);
+if (prefix != NULL)
+xmlFree(prefix);
+return(1);
+}
+/**
+* xmlTextReaderMoveToAttributeNs:
+* @param reader the xmlTextReaderPtr used
+* @param localName the local name of the attribute.
+* @param namespaceURI the namespace URI of the attribute.
+*
+* Moves the position of the current instance to the attribute with the
+* specified local name and namespace URI.
+*
+* Returns 1 in case of success, -1 in case of error, 0 if not found
+*/
+XMLPUBFUNEXPORT int
+xmlTextReaderMoveToAttributeNs(xmlTextReaderPtr reader,
+const xmlChar *localName, const xmlChar *namespaceURI)
+{
+xmlAttrPtr prop;
+xmlNodePtr node;
+xmlNsPtr ns;
+xmlChar *prefix = NULL;
+if ((reader == NULL) || (localName == NULL) || (namespaceURI == NULL))
+return(-1);
+if (reader->node == NULL)
+return(-1);
+if (reader->node->type != XML_ELEMENT_NODE)
+return(0);
+node = reader->node;
+if (xmlStrEqual(namespaceURI, BAD_CAST "http://www.w3.org/2000/xmlns/")) {
+if (! xmlStrEqual(localName, BAD_CAST "xmlns")) {
+prefix = BAD_CAST localName;
+}
+ns = reader->node->nsDef;
+while (ns != NULL) {
+if ((prefix == NULL && ns->prefix == NULL) ||
+((ns->prefix != NULL) && (xmlStrEqual(ns->prefix, localName)))) {
+reader->curnode = (xmlNodePtr) ns;
+return(1);
+}
+ns = ns->next;
+}
+return(0);
+}
+prop = node->properties;
+while (prop != NULL)
+{
+/*
+* One need to have
+*   - same attribute names
+*   - and the attribute carrying that namespace
+*/
+if (xmlStrEqual(prop->name, localName) &&
+((prop->ns != NULL) &&
+(xmlStrEqual(prop->ns->href, namespaceURI))))
+{
+reader->curnode = (xmlNodePtr) prop;
+return(1);
+}
+prop = prop->next;
+}
+return(0);
+}
+/**
+* xmlTextReaderMoveToFirstAttribute:
+* @param reader the xmlTextReaderPtr used
+*
+* Moves the position of the current instance to the first attribute
+* associated with the current node.
+*
+* Returns 1 in case of success, -1 in case of error, 0 if not found
+*/
+XMLPUBFUNEXPORT int
+xmlTextReaderMoveToFirstAttribute(xmlTextReaderPtr reader)
+{
+if (reader == NULL)
+return(-1);
+if (reader->node == NULL)
+return(-1);
+if (reader->node->type != XML_ELEMENT_NODE)
+return(0);
+if (reader->node->nsDef != NULL) {
+reader->curnode = (xmlNodePtr) reader->node->nsDef;
+return(1);
+}
+if (reader->node->properties != NULL) {
+reader->curnode = (xmlNodePtr) reader->node->properties;
+return(1);
+}
+return(0);
+}
+/**
+* xmlTextReaderMoveToNextAttribute:
+* @param reader the xmlTextReaderPtr used
+*
+* Moves the position of the current instance to the next attribute
+* associated with the current node.
+*
+* Returns 1 in case of success, -1 in case of error, 0 if not found
+*/
+XMLPUBFUNEXPORT int
+xmlTextReaderMoveToNextAttribute(xmlTextReaderPtr reader)
+{
+if (reader == NULL)
+return(-1);
+if (reader->node == NULL)
+return(-1);
+if (reader->node->type != XML_ELEMENT_NODE)
+return(0);
+if (reader->curnode == NULL)
+return(xmlTextReaderMoveToFirstAttribute(reader));
+if (reader->curnode->type == XML_NAMESPACE_DECL)
+{
+xmlNsPtr ns = (xmlNsPtr) reader->curnode;
+if (ns->next != NULL) {
+reader->curnode = (xmlNodePtr) ns->next;
+return(1);
+}
+if (reader->node->properties != NULL) {
+reader->curnode = (xmlNodePtr) reader->node->properties;
+return(1);
+}
+//return(0);
+}
+else if ((reader->curnode->type == XML_ATTRIBUTE_NODE) &&
+(reader->curnode->next != NULL))
+{
+reader->curnode = reader->curnode->next;
+return(1);
+}
+return(0);
+}
+/**
+* xmlTextReaderMoveToElement:
+* @param reader the xmlTextReaderPtr used
+*
+* Moves the position of the current instance to the node that
+* contains the current Attribute  node.
+*
+* Returns 1 in case of success, -1 in case of error, 0 if not moved
+*/
+XMLPUBFUNEXPORT int
+xmlTextReaderMoveToElement(xmlTextReaderPtr reader)
+{
+if (reader == NULL)
+return(-1);
+if (reader->node == NULL)
+return(-1);
+if (reader->node->type != XML_ELEMENT_NODE)
+return(0);
+if (reader->curnode != NULL) {
+reader->curnode = NULL;
+return(1);
+}
+return(0);
+}
+/**
+* xmlTextReaderReadAttributeValue:
+* @param reader the xmlTextReaderPtr used
+*
+* Parses an attribute value into one or more Text and EntityReference nodes.
+*
+* Returns 1 in case of success, 0 if the reader was not positionned on an
+*         ttribute node or all the attribute values have been read, or -1
+*         in case of error.
+*/
+XMLPUBFUNEXPORT int
+xmlTextReaderReadAttributeValue(xmlTextReaderPtr reader)
+{
+if (reader == NULL)
+return(-1);
+if (reader->node == NULL)
+return(-1);
+if (reader->curnode == NULL)
+return(0);
+if (reader->curnode->type == XML_ATTRIBUTE_NODE)
+{
+if (reader->curnode->children == NULL)
+return(0);
+reader->curnode = reader->curnode->children;
+}
+else if (reader->curnode->type == XML_NAMESPACE_DECL)
+{
+xmlNsPtr ns = (xmlNsPtr) reader->curnode;
+if (reader->faketext == NULL) {
+reader->faketext = xmlNewDocText(reader->node->doc, ns->href);
+} else {
+if ((reader->faketext->content != NULL) &&
+(reader->faketext->content !=
+(xmlChar*) &(reader->faketext->properties)))
+xmlFree(reader->faketext->content);
+reader->faketext->content = xmlStrdup(ns->href);
+}
+reader->curnode = reader->faketext;
+}
+else
+{
+if (reader->curnode->next == NULL)
+return(0);
+reader->curnode = reader->curnode->next;
+}
+return(1);
+}
+/**
+* xmlTextReaderConstEncoding:
+* @param reader the xmlTextReaderPtr used
+*
+* Determine the encoding of the document being read.
+*
+* Returns a string containing the encoding of the document or NULL in
+* case of error.  The string is deallocated with the reader.
+*/
+XMLPUBFUNEXPORT const xmlChar *
+xmlTextReaderConstEncoding(xmlTextReaderPtr reader) {
+xmlDocPtr doc = NULL;
+if (reader == NULL)
+return(NULL);
+if (reader->doc != NULL)
+doc = reader->doc;
+else if (reader->ctxt != NULL)
+doc = reader->ctxt->myDoc;
+if (doc == NULL)
+return(NULL);
+if (doc->encoding == NULL)
+return(NULL);
+else
+return(CONSTSTR(doc->encoding));
+}
+/************************************************************************
+*                                                                      *
+*          Access API to the current node                              *
+*                                                                      *
+************************************************************************/
+/**
+* xmlTextReaderAttributeCount:
+* @param reader the xmlTextReaderPtr used
+*
+* Provides the number of attributes of the current node
+*
+* Returns 0 i no attributes, -1 in case of error or the attribute count
+*/
+XMLPUBFUNEXPORT int
+xmlTextReaderAttributeCount(xmlTextReaderPtr reader)
+{
+int ret;
+xmlAttrPtr attr;
+xmlNsPtr ns;
+xmlNodePtr node;
+if (reader == NULL)
+return(-1);
+if (reader->node == NULL)
+return(0);
+if (reader->curnode != NULL)
+node = reader->curnode;
+else
+node = reader->node;
+if (node->type != XML_ELEMENT_NODE)
+return(0);
+if ((reader->state == XML_TEXTREADER_END) ||
+(reader->state == XML_TEXTREADER_BACKTRACK))
+{
+return(0);
+}
+ret = 0;
+attr = node->properties;
+while (attr != NULL) {
+ret++;
+attr = attr->next;
+}
+ns = node->nsDef;
+while (ns != NULL) {
+ret++;
+ns = ns->next;
+}
+return(ret);
+}
+/**
+* xmlTextReaderNodeType:
+* @param reader the xmlTextReaderPtr used
+*
+* Get the node type of the current node
+* Reference:
+* http://dotgnu.org/pnetlib-doc/System/Xml/XmlNodeType.html
+*
+* Returns the xmlNodeType of the current node or -1 in case of error
+*/
+XMLPUBFUNEXPORT int
+xmlTextReaderNodeType(xmlTextReaderPtr reader)
+{
+xmlNodePtr node;
+if (reader == NULL)
+return(-1);
+if (reader->node == NULL)
+return(XML_READER_TYPE_NONE);
+if (reader->curnode != NULL)
+node = reader->curnode;
+else
+node = reader->node;
+switch (node->type)
+{
+case XML_ELEMENT_NODE:
+if ((reader->state == XML_TEXTREADER_END) ||
+(reader->state == XML_TEXTREADER_BACKTRACK))
+return(XML_READER_TYPE_END_ELEMENT);
+return(XML_READER_TYPE_ELEMENT);
+case XML_NAMESPACE_DECL:
+case XML_ATTRIBUTE_NODE:
+return(XML_READER_TYPE_ATTRIBUTE);
+case XML_TEXT_NODE:
+if (xmlIsBlankNode(reader->node)) {
+if (xmlNodeGetSpacePreserve(reader->node))
+return(XML_READER_TYPE_SIGNIFICANT_WHITESPACE);
+else
+return(XML_READER_TYPE_WHITESPACE);
+} else {
+return(XML_READER_TYPE_TEXT);
+}
+case XML_CDATA_SECTION_NODE:
+return(XML_READER_TYPE_CDATA);
+case XML_ENTITY_REF_NODE:
+return(XML_READER_TYPE_ENTITY_REFERENCE);
+case XML_ENTITY_NODE:
+return(XML_READER_TYPE_ENTITY);
+case XML_PI_NODE:
+return(XML_READER_TYPE_PROCESSING_INSTRUCTION);
+case XML_COMMENT_NODE:
+return(XML_READER_TYPE_COMMENT);
+case XML_DOCUMENT_NODE:
+case XML_HTML_DOCUMENT_NODE:
+#ifdef LIBXML_DOCB_ENABLED
+case XML_DOCB_DOCUMENT_NODE:
+#endif
+return(XML_READER_TYPE_DOCUMENT);
+case XML_DOCUMENT_FRAG_NODE:
+return(XML_READER_TYPE_DOCUMENT_FRAGMENT);
+case XML_NOTATION_NODE:
+return(XML_READER_TYPE_NOTATION);
+case XML_DOCUMENT_TYPE_NODE:
+case XML_DTD_NODE:
+return(XML_READER_TYPE_DOCUMENT_TYPE);
+case XML_ELEMENT_DECL:
+case XML_ATTRIBUTE_DECL:
+case XML_ENTITY_DECL:
+case XML_XINCLUDE_START:
+case XML_XINCLUDE_END:
+return(XML_READER_TYPE_NONE);
+}
+return(-1);
+}
+/**
+* xmlTextReaderIsEmptyElement:
+* @param reader the xmlTextReaderPtr used
+*
+* Check if the current node is empty
+*
+* Returns 1 if empty, 0 if not and -1 in case of error
+*/
+XMLPUBFUNEXPORT int
+xmlTextReaderIsEmptyElement(xmlTextReaderPtr reader)
+{
+if ((reader == NULL) || (reader->node == NULL))
+return(-1);
+if (reader->node->type != XML_ELEMENT_NODE)
+return(0);
+if (reader->curnode != NULL)
+return(0);
+if (reader->node->children != NULL)
+return(0);
+if (reader->state == XML_TEXTREADER_END)
+return(0);
+if (reader->doc != NULL)
+return(1);
+#ifdef LIBXML_XINCLUDE_ENABLED
+if (reader->in_xinclude > 0)
+return(1);
+#endif
+return((reader->node->extra & NODE_IS_EMPTY) != 0);
+}
+/**
+* xmlTextReaderLocalName:
+* @param reader the xmlTextReaderPtr used
+*
+* The local name of the node.
+*
+* Returns the local name or NULL if not available
+*/
+XMLPUBFUNEXPORT xmlChar*
+xmlTextReaderLocalName(xmlTextReaderPtr reader)
+{
+xmlNodePtr node;
+if ((reader == NULL) || (reader->node == NULL))
+return(NULL);
+if (reader->curnode != NULL)
+node = reader->curnode;
+else
+node = reader->node;
+if (node->type == XML_NAMESPACE_DECL) {
+xmlNsPtr ns = (xmlNsPtr) node;
+if (ns->prefix == NULL)
+return(xmlStrdup(BAD_CAST "xmlns"));
+else
+return(xmlStrdup(ns->prefix));
+}
+if ((node->type != XML_ELEMENT_NODE) &&
+(node->type != XML_ATTRIBUTE_NODE))
+return(xmlTextReaderName(reader));
+return(xmlStrdup(node->name));
+}
+/**
+* xmlTextReaderConstLocalName:
+* @param reader the xmlTextReaderPtr used
+*
+* The local name of the node.
+*
+* Returns the local name or NULL if not available, the
+*         string will be deallocated with the reader.
+*/
+XMLPUBFUNEXPORT const xmlChar*
+xmlTextReaderConstLocalName(xmlTextReaderPtr reader)
+{
+xmlNodePtr node;
+if ((reader == NULL) || (reader->node == NULL))
+return(NULL);
+if (reader->curnode != NULL)
+node = reader->curnode;
+else
+node = reader->node;
+if (node->type == XML_NAMESPACE_DECL) {
+xmlNsPtr ns = (xmlNsPtr) node;
+if (ns->prefix == NULL)
+return(CONSTSTR(BAD_CAST "xmlns"));
+else
+return(ns->prefix);
+}
+if ((node->type != XML_ELEMENT_NODE) &&
+(node->type != XML_ATTRIBUTE_NODE))
+return(xmlTextReaderConstName(reader));
+return(node->name);
+}
+/**
+* xmlTextReaderName:
+* @param reader the xmlTextReaderPtr used
+*
+* The qualified name of the node, equal to Prefix :LocalName.
+*
+* Returns the local name or NULL if not available
+*/
+XMLPUBFUNEXPORT xmlChar*
+xmlTextReaderName(xmlTextReaderPtr reader)
+{
+xmlNodePtr node;
+xmlChar *ret;
+if ((reader == NULL) || (reader->node == NULL))
+return(NULL);
+if (reader->curnode != NULL)
+node = reader->curnode;
+else
+node = reader->node;
+switch (node->type)
+{
+case XML_ELEMENT_NODE:
+case XML_ATTRIBUTE_NODE:
+if ((node->ns == NULL) ||
+(node->ns->prefix == NULL))
+return(xmlStrdup(node->name));
+ret = xmlStrdup(node->ns->prefix);
+ret = xmlStrcat(ret, BAD_CAST ":");
+ret = xmlStrcat(ret, node->name);
+return(ret);
+case XML_TEXT_NODE:
+return(xmlStrdup(BAD_CAST "#text"));
+case XML_CDATA_SECTION_NODE:
+return(xmlStrdup(BAD_CAST "#cdata-section"));
+case XML_ENTITY_NODE:
+case XML_ENTITY_REF_NODE:
+return(xmlStrdup(node->name));
+case XML_PI_NODE:
+return(xmlStrdup(node->name));
+case XML_COMMENT_NODE:
+return(xmlStrdup(BAD_CAST "#comment"));
+case XML_DOCUMENT_NODE:
+case XML_HTML_DOCUMENT_NODE:
+#ifdef LIBXML_DOCB_ENABLED
+case XML_DOCB_DOCUMENT_NODE:
+#endif
+return(xmlStrdup(BAD_CAST "#document"));
+case XML_DOCUMENT_FRAG_NODE:
+return(xmlStrdup(BAD_CAST "#document-fragment"));
+case XML_NOTATION_NODE:
+return(xmlStrdup(node->name));
+case XML_DOCUMENT_TYPE_NODE:
+case XML_DTD_NODE:
+return(xmlStrdup(node->name));
+case XML_NAMESPACE_DECL: {
+xmlNsPtr ns = (xmlNsPtr) node;
+ret = xmlStrdup(BAD_CAST "xmlns");
+if (ns->prefix == NULL)
+return(ret);
+ret = xmlStrcat(ret, BAD_CAST ":");
+ret = xmlStrcat(ret, ns->prefix);
+return(ret);
+}
+case XML_ELEMENT_DECL:
+case XML_ATTRIBUTE_DECL:
+case XML_ENTITY_DECL:
+case XML_XINCLUDE_START:
+case XML_XINCLUDE_END:
+return(NULL);
+}
+return(NULL);
+}
+/**
+* xmlTextReaderConstName:
+* @param reader the xmlTextReaderPtr used
+*
+* The qualified name of the node, equal to Prefix :LocalName.
+*
+* Returns the local name or NULL if not available, the string is
+*         deallocated with the reader.
+*/
+XMLPUBFUNEXPORT const xmlChar*
+xmlTextReaderConstName(xmlTextReaderPtr reader)
+{
+xmlNodePtr node;
+if ((reader == NULL) || (reader->node == NULL))
+return(NULL);
+if (reader->curnode != NULL)
+node = reader->curnode;
+else
+node = reader->node;
+switch (node->type)
+{
+case XML_ELEMENT_NODE:
+case XML_ATTRIBUTE_NODE:
+if ((node->ns == NULL) ||
+(node->ns->prefix == NULL))
+return(node->name);
+return(CONSTQSTR(node->ns->prefix, node->name));
+case XML_TEXT_NODE:
+return(CONSTSTR(BAD_CAST "#text"));
+case XML_CDATA_SECTION_NODE:
+return(CONSTSTR(BAD_CAST "#cdata-section"));
+case XML_ENTITY_NODE:
+case XML_ENTITY_REF_NODE:
+return(CONSTSTR(node->name));
+case XML_PI_NODE:
+return(CONSTSTR(node->name));
+case XML_COMMENT_NODE:
+return(CONSTSTR(BAD_CAST "#comment"));
+case XML_DOCUMENT_NODE:
+case XML_HTML_DOCUMENT_NODE:
+#ifdef LIBXML_DOCB_ENABLED
+case XML_DOCB_DOCUMENT_NODE:
+#endif
+return(CONSTSTR(BAD_CAST "#document"));
+case XML_DOCUMENT_FRAG_NODE:
+return(CONSTSTR(BAD_CAST "#document-fragment"));
+case XML_NOTATION_NODE:
+return(CONSTSTR(node->name));
+case XML_DOCUMENT_TYPE_NODE:
+case XML_DTD_NODE:
+return(CONSTSTR(node->name));
+case XML_NAMESPACE_DECL: {
+xmlNsPtr ns = (xmlNsPtr) node;
+if (ns->prefix == NULL)
+return(CONSTSTR(BAD_CAST "xmlns"));
+return(CONSTQSTR(BAD_CAST "xmlns", ns->prefix));
+}
+case XML_ELEMENT_DECL:
+case XML_ATTRIBUTE_DECL:
+case XML_ENTITY_DECL:
+case XML_XINCLUDE_START:
+case XML_XINCLUDE_END:
+return(NULL);
+}
+return(NULL);
+}
+/**
+* xmlTextReaderPrefix:
+* @param reader the xmlTextReaderPtr used
+*
+* A shorthand reference to the namespace associated with the node.
+*
+* Returns the prefix or NULL if not available
+*/
+XMLPUBFUNEXPORT xmlChar *
+xmlTextReaderPrefix(xmlTextReaderPtr reader)
+{
+xmlNodePtr node;
+if ((reader == NULL) || (reader->node == NULL))
+return(NULL);
+if (reader->curnode != NULL)
+node = reader->curnode;
+else
+node = reader->node;
+if (node->type == XML_NAMESPACE_DECL) {
+xmlNsPtr ns = (xmlNsPtr) node;
+if (ns->prefix == NULL)
+return(NULL);
+return(xmlStrdup(BAD_CAST "xmlns"));
+}
+if ((node->type != XML_ELEMENT_NODE) &&
+(node->type != XML_ATTRIBUTE_NODE))
+return(NULL);
+if ((node->ns != NULL) && (node->ns->prefix != NULL))
+return(xmlStrdup(node->ns->prefix));
+return(NULL);
+}
+/**
+* xmlTextReaderConstPrefix:
+* @param reader the xmlTextReaderPtr used
+*
+* A shorthand reference to the namespace associated with the node.
+*
+* Returns the prefix or NULL if not available, the string is deallocated
+*         with the reader.
+*/
+XMLPUBFUNEXPORT const xmlChar*
+xmlTextReaderConstPrefix(xmlTextReaderPtr reader)
+{
+xmlNodePtr node;
+if ((reader == NULL) || (reader->node == NULL))
+return(NULL);
+if (reader->curnode != NULL)
+node = reader->curnode;
+else
+node = reader->node;
+if (node->type == XML_NAMESPACE_DECL) {
+xmlNsPtr ns = (xmlNsPtr) node;
+if (ns->prefix == NULL)
+return(NULL);
+return(CONSTSTR(BAD_CAST "xmlns"));
+}
+if ((node->type != XML_ELEMENT_NODE) &&
+(node->type != XML_ATTRIBUTE_NODE))
+return(NULL);
+if ((node->ns != NULL) && (node->ns->prefix != NULL))
+return(CONSTSTR(node->ns->prefix));
+return(NULL);
+}
+/**
+* xmlTextReaderNamespaceUri:
+* @param reader the xmlTextReaderPtr used
+*
+* The URI defining the namespace associated with the node.
+*
+* Returns the namespace URI or NULL if not available
+*/
+XMLPUBFUNEXPORT xmlChar*
+xmlTextReaderNamespaceUri(xmlTextReaderPtr reader)
+{
+xmlNodePtr node;
+if ((reader == NULL) || (reader->node == NULL))
+return(NULL);
+if (reader->curnode != NULL)
+node = reader->curnode;
+else
+node = reader->node;
+if (node->type == XML_NAMESPACE_DECL)
+return(xmlStrdup(BAD_CAST "http://www.w3.org/2000/xmlns/"));
+if ((node->type != XML_ELEMENT_NODE) &&
+(node->type != XML_ATTRIBUTE_NODE))
+return(NULL);
+if (node->ns != NULL)
+return(xmlStrdup(node->ns->href));
+return(NULL);
+}
+/**
+* xmlTextReaderConstNamespaceUri:
+* @param reader the xmlTextReaderPtr used
+*
+* The URI defining the namespace associated with the node.
+*
+* Returns the namespace URI or NULL if not available, the string
+*         will be deallocated with the reader
+*/
+XMLPUBFUNEXPORT const xmlChar*
+xmlTextReaderConstNamespaceUri(xmlTextReaderPtr reader)
+{
+xmlNodePtr node;
+if ((reader == NULL) || (reader->node == NULL))
+return(NULL);
+if (reader->curnode != NULL)
+node = reader->curnode;
+else
+node = reader->node;
+if (node->type == XML_NAMESPACE_DECL)
+return(CONSTSTR(BAD_CAST "http://www.w3.org/2000/xmlns/"));
+if ((node->type != XML_ELEMENT_NODE) &&
+(node->type != XML_ATTRIBUTE_NODE))
+return(NULL);
+if (node->ns != NULL)
+return(CONSTSTR(node->ns->href));
+return(NULL);
+}
+/**
+* xmlTextReaderBaseUri:
+* @param reader the xmlTextReaderPtr used
+*
+* The base URI of the node.
+*
+* Returns the base URI or NULL if not available
+*/
+XMLPUBFUNEXPORT xmlChar*
+xmlTextReaderBaseUri(xmlTextReaderPtr reader)
+{
+if ((reader == NULL) || (reader->node == NULL))
+return(NULL);
+return(xmlNodeGetBase(NULL, reader->node));
+}
+/**
+* xmlTextReaderConstBaseUri:
+* @param reader the xmlTextReaderPtr used
+*
+* The base URI of the node.
+*
+* Returns the base URI or NULL if not available, the string
+*         will be deallocated with the reader
+*/
+XMLPUBFUNEXPORT const xmlChar*
+xmlTextReaderConstBaseUri(xmlTextReaderPtr reader)
+{
+xmlChar* tmp;
+const xmlChar *ret;
+if ((reader == NULL) || (reader->node == NULL))
+return(NULL);
+tmp = xmlNodeGetBase(NULL, reader->node);
+if (tmp == NULL)
+return(NULL);
+ret = CONSTSTR(tmp);
+xmlFree(tmp);
+return(ret);
+}
+/**
+* xmlTextReaderDepth:
+* @param reader the xmlTextReaderPtr used
+*
+* The depth of the node in the tree.
+*
+* Returns the depth or -1 in case of error
+*/
+XMLPUBFUNEXPORT int
+xmlTextReaderDepth(xmlTextReaderPtr reader)
+{
+if (reader == NULL)
+return(-1);
+if (reader->node == NULL)
+return(0);
+if (reader->curnode != NULL) {
+if ((reader->curnode->type == XML_ATTRIBUTE_NODE) ||
+(reader->curnode->type == XML_NAMESPACE_DECL))
+return(reader->depth + 1);
+return(reader->depth + 2);
+}
+return(reader->depth);
+}
+/**
+* xmlTextReaderHasAttributes:
+* @param reader the xmlTextReaderPtr used
+*
+* Whether the node has attributes.
+*
+* Returns 1 if true, 0 if false, and -1 in case or error
+*/
+XMLPUBFUNEXPORT int
+xmlTextReaderHasAttributes(xmlTextReaderPtr reader) {
+xmlNodePtr node;
+if (reader == NULL)
+return(-1);
+if (reader->node == NULL)
+return(0);
+if (reader->curnode != NULL)
+node = reader->curnode;
+else
+node = reader->node;
+if ((node->type == XML_ELEMENT_NODE) &&
+(node->properties || node->nsDef))
+return(1);
+return(0);
+}
+/**
+* xmlTextReaderHasValue:
+* @param reader the xmlTextReaderPtr used
+*
+* Whether the node can have a text value.
+*
+* Returns 1 if true, 0 if false, and -1 in case or error
+*/
+XMLPUBFUNEXPORT int
+xmlTextReaderHasValue(xmlTextReaderPtr reader)
+{
+xmlNodePtr node;
+if (reader == NULL)
+return(-1);
+if (reader->node == NULL)
+return(0);
+if (reader->curnode != NULL)
+node = reader->curnode;
+else
+node = reader->node;
+switch (node->type) {
+case XML_ATTRIBUTE_NODE:
+case XML_TEXT_NODE:
+case XML_CDATA_SECTION_NODE:
+case XML_PI_NODE:
+case XML_COMMENT_NODE:
+case XML_NAMESPACE_DECL:
+return(1);
+default:
+break;
+}
+return(0);
+}
+/**
+* xmlTextReaderValue:
+* @param reader the xmlTextReaderPtr used
+*
+* Provides the text value of the node if present
+*
+* Returns the string or NULL if not available. The result must be deallocated
+*     with xmlFree()
+*/
+XMLPUBFUNEXPORT xmlChar*
+xmlTextReaderValue(xmlTextReaderPtr reader)
+{
+xmlNodePtr node;
+if (reader == NULL)
+return(NULL);
+if (reader->node == NULL)
+return(NULL);
+if (reader->curnode != NULL)
+node = reader->curnode;
+else
+node = reader->node;
+switch (node->type)
+{
+case XML_NAMESPACE_DECL:
+return(xmlStrdup(((xmlNsPtr) node)->href));
+case XML_ATTRIBUTE_NODE:{
+xmlAttrPtr attr = (xmlAttrPtr) node;
+if (attr->parent != NULL)
+	 return (xmlNodeListGetString(attr->parent->doc, attr->children, 1));
+else
+return (xmlNodeListGetString(NULL, attr->children, 1));
+}
+case XML_TEXT_NODE:
+case XML_CDATA_SECTION_NODE:
+case XML_PI_NODE:
+case XML_COMMENT_NODE:
+if (node->content != NULL)
+return (xmlStrdup(node->content));
+default:
+break;
+}
+return(NULL);
+}
+/**
+* xmlTextReaderConstValue:
+* @param reader the xmlTextReaderPtr used
+*
+* Provides the text value of the node if present
+*
+* Returns the string or NULL if not available. The result will be
+*     deallocated on the next Read() operation.
+*/
+XMLPUBFUNEXPORT const xmlChar*
+xmlTextReaderConstValue(xmlTextReaderPtr reader)
+{
+xmlNodePtr node;
+if (reader == NULL)
+return(NULL);
+if (reader->node == NULL)
+return(NULL);
+if (reader->curnode != NULL)
+node = reader->curnode;
+else
+node = reader->node;
+switch (node->type) {
+case XML_NAMESPACE_DECL:
+return(((xmlNsPtr) node)->href);
+case XML_ATTRIBUTE_NODE:{
+xmlAttrPtr attr = (xmlAttrPtr) node;
+if (attr->children &&
+(attr->children->type == XML_TEXT_NODE) &&
+!attr->children->next)
+{
+return(attr->children->content);
+} else {
+if (reader->buffer == NULL)
+reader->buffer = xmlBufferCreateSize(100);
+if (reader->buffer == NULL) {
+xmlGenericError(xmlGenericErrorContext,
+"xmlTextReaderSetup : malloc failed\n");
+return (NULL);
+}
+reader->buffer->use = 0;
+xmlNodeBufGetContent(reader->buffer, node);
+return(reader->buffer->content);
+}
+}
+case XML_TEXT_NODE:
+case XML_CDATA_SECTION_NODE:
+case XML_PI_NODE:
+case XML_COMMENT_NODE:
+return(node->content);
+default:
+break;
+}
+return(NULL);
+}
+/**
+* xmlTextReaderIsDefault:
+* @param reader the xmlTextReaderPtr used
+*
+* Whether an Attribute  node was generated from the default value
+* defined in the DTD or schema.
+*
+* Returns 0 if not defaulted, 1 if defaulted, and -1 in case of error
+*/
+XMLPUBFUNEXPORT int
+xmlTextReaderIsDefault(xmlTextReaderPtr reader)
+{
+if (reader == NULL)
+return(-1);
+return(0);
+}
+/**
+* xmlTextReaderQuoteChar:
+* @param reader the xmlTextReaderPtr used
+*
+* The quotation mark character used to enclose the value of an attribute.
+*
+* Returns " or ' and -1 in case of error
+*/
+XMLPUBFUNEXPORT int
+xmlTextReaderQuoteChar(xmlTextReaderPtr reader)
+{
+if (reader == NULL)
+return(-1);
+return((int) '"');
+}
+/**
+* xmlTextReaderXmlLang:
+* @param reader the xmlTextReaderPtr used
+*
+* The xml:lang scope within which the node resides.
+*
+* Returns the xml:lang value or NULL if none exists.
+*/
+XMLPUBFUNEXPORT xmlChar*
+xmlTextReaderXmlLang(xmlTextReaderPtr reader)
+{
+if (reader == NULL)
+return(NULL);
+if (reader->node == NULL)
+return(NULL);
+return(xmlNodeGetLang(reader->node));
+}
+/**
+* xmlTextReaderConstXmlLang:
+* @param reader the xmlTextReaderPtr used
+*
+* The xml:lang scope within which the node resides.
+*
+* Returns the xml:lang value or NULL if none exists.
+*/
+XMLPUBFUNEXPORT const xmlChar*
+xmlTextReaderConstXmlLang(xmlTextReaderPtr reader)
+{
+xmlChar *tmp;
+const xmlChar *ret;
+if (reader == NULL)
+return(NULL);
+if (reader->node == NULL)
+return(NULL);
+tmp = xmlNodeGetLang(reader->node);
+if (tmp == NULL)
+return(NULL);
+ret = CONSTSTR(tmp);
+xmlFree(tmp);
+return(ret);
+}
+/**
+* xmlTextReaderConstString:
+* @param reader the xmlTextReaderPtr used
+* @param str the string to intern.
+*
+* Get an interned string from the reader, allows for example to
+* speedup string name comparisons
+*
+* Returns an interned copy of the string or NULL in case of error. The
+*         string will be deallocated with the reader.
+*/
+XMLPUBFUNEXPORT const xmlChar*
+xmlTextReaderConstString(xmlTextReaderPtr reader, const xmlChar *str)
+{
+if (reader == NULL)
+return(NULL);
+return(CONSTSTR(str));
+}
+/**
+* xmlTextReaderNormalization:
+* @param reader the xmlTextReaderPtr used
+*
+* The value indicating whether to normalize white space and attribute values.
+* Since attribute value and end of line normalizations are a MUST in the XML
+* specification only the value true is accepted. The broken bahaviour of
+* accepting out of range character entities like &#0; is of course not
+* supported either.
+*
+* Returns 1 or -1 in case of error.
+*/
+XMLPUBFUNEXPORT int
+xmlTextReaderNormalization(xmlTextReaderPtr reader)
+{
+if (reader == NULL)
+return(-1);
+return(1);
+}
+/************************************************************************
+*                                                                      *
+*          Extensions to the base APIs                                 *
+*                                                                      *
+************************************************************************/
+/**
+* xmlTextReaderSetParserProp:
+* @param reader the xmlTextReaderPtr used
+* @param prop the xmlParserProperties to set
+* @param value usually 0 or 1 to (de)activate it
+*
+* Change the parser processing behaviour by changing some of its internal
+* properties. Note that some properties can only be changed before any
+* read has been done.
+*
+* Returns 0 if the call was successful, or -1 in case of error
+*/
+XMLPUBFUNEXPORT int
+xmlTextReaderSetParserProp(xmlTextReaderPtr reader, int prop, int value)
+{
+xmlParserProperties p = (xmlParserProperties) prop;
+xmlParserCtxtPtr ctxt;
+if ((reader == NULL) || (reader->ctxt == NULL))
+return(-1);
+ctxt = reader->ctxt;
+switch (p)
+{
+case XML_PARSER_LOADDTD:
+if (value != 0) {
+if (ctxt->loadsubset == 0) {
+if (reader->mode != XML_TEXTREADER_MODE_INITIAL)
+return(-1);
+ctxt->loadsubset = XML_DETECT_IDS;
+}
+} else {
+ctxt->loadsubset = 0;
+}
+return(0);
+case XML_PARSER_DEFAULTATTRS:
+if (value != 0) {
+ctxt->loadsubset |= XML_COMPLETE_ATTRS;
+} else {
+if (ctxt->loadsubset & XML_COMPLETE_ATTRS)
+ctxt->loadsubset -= XML_COMPLETE_ATTRS;
+}
+return(0);
+case XML_PARSER_VALIDATE:
+if (value != 0) {
+ctxt->validate = 1;
+reader->validate = XML_TEXTREADER_VALIDATE_DTD;
+} else {
+ctxt->validate = 0;
+}
+return(0);
+case XML_PARSER_SUBST_ENTITIES:
+if (value != 0) {
+ctxt->replaceEntities = 1;
+} else {
+ctxt->replaceEntities = 0;
+}
+return(0);
+}
+return(-1);
+}
+/**
+* xmlTextReaderGetParserProp:
+* @param reader the xmlTextReaderPtr used
+* @param prop the xmlParserProperties to get
+*
+* Read the parser internal property.
+*
+* Returns the value, usually 0 or 1, or -1 in case of error.
+*/
+XMLPUBFUNEXPORT int
+xmlTextReaderGetParserProp(xmlTextReaderPtr reader, int prop)
+{
+xmlParserProperties p = (xmlParserProperties) prop;
+xmlParserCtxtPtr ctxt;
+if ((reader == NULL) || (reader->ctxt == NULL))
+return(-1);
+ctxt = reader->ctxt;
+switch (p)
+{
+case XML_PARSER_LOADDTD:
+if ((ctxt->loadsubset != 0) || (ctxt->validate != 0))
+return(1);
+return(0);
+case XML_PARSER_DEFAULTATTRS:
+if (ctxt->loadsubset & XML_COMPLETE_ATTRS)
+return(1);
+return(0);
+case XML_PARSER_VALIDATE:
+return(reader->validate);
+case XML_PARSER_SUBST_ENTITIES:
+return(ctxt->replaceEntities);
+}
+return(-1);
+}
+/**
+* xmlTextReaderGetParserLineNumber:
+* @param reader the user data (XML reader context)
+*
+* Provide the line number of the current parsing point.
+*
+* Returns an int or 0 if not available
+*/
+XMLPUBFUNEXPORT int
+xmlTextReaderGetParserLineNumber(xmlTextReaderPtr reader)
+{
+if ((reader == NULL) || (reader->ctxt == NULL) ||
+(reader->ctxt->input == NULL)) {
+return (0);
+}
+return (reader->ctxt->input->line);
+}
+/**
+* xmlTextReaderGetParserColumnNumber:
+* @param reader the user data (XML reader context)
+*
+* Provide the column number of the current parsing point.
+*
+* Returns an int or 0 if not available
+*/
+XMLPUBFUNEXPORT int
+xmlTextReaderGetParserColumnNumber(xmlTextReaderPtr reader)
+{
+if ((reader == NULL) || (reader->ctxt == NULL) ||
+(reader->ctxt->input == NULL)) {
+return (0);
+}
+return (reader->ctxt->input->col);
+}
+/**
+* xmlTextReaderCurrentNode:
+* @param reader the xmlTextReaderPtr used
+*
+* Hacking interface allowing to get the xmlNodePtr correponding to the
+* current node being accessed by the xmlTextReader. This is dangerous
+* because the underlying node may be destroyed on the next Reads.
+*
+* Returns the xmlNodePtr or NULL in case of error.
+*/
+XMLPUBFUNEXPORT xmlNodePtr
+xmlTextReaderCurrentNode(xmlTextReaderPtr reader)
+{
+if (reader == NULL)
+return(NULL);
+if (reader->curnode != NULL)
+return(reader->curnode);
+return(reader->node);
+}
+/**
+* xmlTextReaderPreserve:
+* @param reader the xmlTextReaderPtr used
+*
+* This tells the XML Reader to preserve the current node.
+* The caller must also use xmlTextReaderCurrentDoc() to
+* keep an handle on the resulting document once parsing has finished
+*
+* Returns the xmlNodePtr or NULL in case of error.
+*/
+XMLPUBFUNEXPORT xmlNodePtr
+xmlTextReaderPreserve(xmlTextReaderPtr reader)
+{
+xmlNodePtr cur, parent;
+if (reader == NULL)
+return(NULL);
+if (reader->curnode != NULL)
+cur = reader->curnode;
+else
+cur = reader->node;
+if (cur == NULL)
+return(NULL);
+if ((cur->type != XML_DOCUMENT_NODE) && (cur->type != XML_DTD_NODE)) {
+cur->extra |= NODE_IS_PRESERVED;
+cur->extra |= NODE_IS_SPRESERVED;
+}
+reader->preserves++;
+parent = cur->parent;
+while (parent != NULL) {
+if (parent->type == XML_ELEMENT_NODE)
+parent->extra |= NODE_IS_PRESERVED;
+parent = parent->parent;
+}
+return(cur);
+}
+#ifdef LIBXML_PATTERN_ENABLED
+/**
+* xmlTextReaderPreservePattern:
+* @param reader the xmlTextReaderPtr used
+* @param pattern an XPath subset pattern
+* @param namespaces the prefix definitions, array of [URI, prefix] or NULL
+*
+* This tells the XML Reader to preserve all nodes matched by the
+* pattern. The caller must also use xmlTextReaderCurrentDoc() to
+* keep an handle on the resulting document once parsing has finished
+*
+* Returns a positive number in case of success and -1 in case of error
+*/
+int
+xmlTextReaderPreservePattern(xmlTextReaderPtr reader, const xmlChar *pattern,
+const xmlChar **namespaces)
+{
+xmlPatternPtr comp;
+if ((reader == NULL) || (pattern == NULL))
+return(-1);
+comp = xmlPatterncompile(pattern, reader->dict, 0, namespaces);
+if (comp == NULL)
+return(-1);
+if (reader->patternMax <= 0) {
+reader->patternMax = 4;
+reader->patternTab = (xmlPatternPtr *) xmlMalloc(reader->patternMax *
+sizeof(reader->patternTab[0]));
+if (reader->patternTab == NULL) {
+xmlGenericError(xmlGenericErrorContext, EMBED_ERRTXT("xmlMalloc failed !\n"));
+return (-1);
+}
+}
+if (reader->patternNr >= reader->patternMax) {
+xmlPatternPtr *tmp;
+reader->patternMax *= 2;
+tmp = (xmlPatternPtr *) xmlRealloc(reader->patternTab,
+reader->patternMax *
+sizeof(reader->patternTab[0]));
+if (tmp == NULL) {
+xmlGenericError(xmlGenericErrorContext, EMBED_ERRTXT("xmlRealloc failed !\n"));
+reader->patternMax /= 2;
+return (-1);
+}
+reader->patternTab = tmp;
+}
+reader->patternTab[reader->patternNr] = comp;
+return(reader->patternNr++);
+}
+#endif
+/**
+* xmlTextReaderCurrentDoc:
+* @param reader the xmlTextReaderPtr used
+*
+* Hacking interface allowing to get the xmlDocPtr correponding to the
+* current document being accessed by the xmlTextReader.
+* NOTE: as a result of this call, the reader will not destroy the
+*       associated XML document and calling xmlFreeDoc() on the result
+*       is needed once the reader parsing has finished.
+*
+* Returns the xmlDocPtr or NULL in case of error.
+*/
+XMLPUBFUNEXPORT xmlDocPtr
+xmlTextReaderCurrentDoc(xmlTextReaderPtr reader)
+{
+if (reader == NULL)
+return(NULL);
+if (reader->doc != NULL)
+return(reader->doc);
+if ((reader == NULL) || (reader->ctxt == NULL) ||
+(reader->ctxt->myDoc == NULL))
+return(NULL);
+reader->preserve = 1;
+return(reader->ctxt->myDoc);
+}
+#ifdef LIBXML_SCHEMAS_ENABLED
+static char *
+xmlTextReaderBuildMessage(const char *msg, va_list ap);
+static void XMLCDECL
+xmlTextReaderValidityError(void *ctxt, const char *msg, ...);
+static void XMLCDECL
+xmlTextReaderValidityWarning(void *ctxt, const char *msg, ...);
+static void XMLCDECL xmlTextReaderValidityErrorRelay(void *ctx, const char *msg, ...)
+{
+xmlTextReaderPtr reader = (xmlTextReaderPtr) ctx;
+char * str;
+va_list ap;
+va_start(ap,msg);
+str = xmlTextReaderBuildMessage(msg,ap);
+if (!reader->errorFunc) {
+xmlTextReaderValidityError(ctx, "%s", str);
+} else {
+reader->errorFunc(reader->errorFuncArg, str, XML_PARSER_SEVERITY_VALIDITY_ERROR, NULL /* locator */);
+}
+if (str != NULL)
+xmlFree(str);
+va_end(ap);
+}
+static void XMLCDECL xmlTextReaderValidityWarningRelay(void *ctx, const char *msg, ...)
+{
+xmlTextReaderPtr reader = (xmlTextReaderPtr) ctx;
+char * str;
+va_list ap;
+va_start(ap,msg);
+str = xmlTextReaderBuildMessage(msg,ap);
+if (!reader->errorFunc) {
+xmlTextReaderValidityWarning(ctx, "%s", str);
+} else {
+reader->errorFunc(reader->errorFuncArg, str, XML_PARSER_SEVERITY_VALIDITY_WARNING, NULL /* locator */);
+}
+if (str != NULL)
+xmlFree(str);
+va_end(ap);
+}
+static void
+xmlTextReaderStructuredError(void *ctxt, xmlErrorPtr error);
+static void xmlTextReaderValidityStructuredRelay(void * userData, xmlErrorPtr error)
+{
+xmlTextReaderPtr reader = (xmlTextReaderPtr) userData;
+if (reader->sErrorFunc) {
+reader->sErrorFunc(reader->errorFuncArg, error);
+} else {
+xmlTextReaderStructuredError(reader, error);
+}
+}
+/**
+* xmlTextReaderRelaxNGSetSchema:
+* @param reader the xmlTextReaderPtr used
+* @param schema a precompiled RelaxNG schema
+*
+* Use RelaxNG to validate the document as it is processed.
+* Activation is only possible before the first Read().
+* if schema is NULL, then RelaxNG validation is desactivated.
+* The schema should not be freed until the reader is deallocated
+* or its use has been deactivated.
+*
+* Returns 0 in case the RelaxNG validation could be (des)activated and
+*         -1 in case of error.
+*/
+int
+xmlTextReaderRelaxNGSetSchema(xmlTextReaderPtr reader, xmlRelaxNGPtr schema) {
+if (reader == NULL)
+return(-1);
+if (schema == NULL) {
+if (reader->rngSchemas != NULL) {
+xmlRelaxNGFree(reader->rngSchemas);
+reader->rngSchemas = NULL;
+}
+if (reader->rngValidCtxt != NULL) {
+xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
+reader->rngValidCtxt = NULL;
+}
+return(0);
+}
+if (reader->mode != XML_TEXTREADER_MODE_INITIAL)
+return(-1);
+if (reader->rngSchemas != NULL) {
+xmlRelaxNGFree(reader->rngSchemas);
+reader->rngSchemas = NULL;
+}
+if (reader->rngValidCtxt != NULL) {
+xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
+reader->rngValidCtxt = NULL;
+}
+reader->rngValidCtxt = xmlRelaxNGNewValidCtxt(schema);
+if (reader->rngValidCtxt == NULL)
+return(-1);
+if (reader->errorFunc != NULL) {
+xmlRelaxNGSetValidErrors(reader->rngValidCtxt,
+xmlTextReaderValidityErrorRelay,
+xmlTextReaderValidityWarningRelay,
+reader);
+}
+if (reader->sErrorFunc != NULL) {
+xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt,
+xmlTextReaderValidityStructuredRelay,
+reader);
+}
+reader->rngValidErrors = 0;
+reader->rngFullNode = NULL;
+reader->validate = XML_TEXTREADER_VALIDATE_RNG;
+return(0);
+}
+/**
+* xmlTextReaderSetSchema:
+* @param reader the xmlTextReaderPtr used
+* @param schema a precompiled Schema schema
+*
+* Use XSD Schema to validate the document as it is processed.
+* Activation is only possible before the first Read().
+* if schema is NULL, then Schema validation is desactivated.
+* The schema should not be freed until the reader is deallocated
+* or its use has been deactivated.
+*
+* Returns 0 in case the Schema validation could be (des)activated and
+*         -1 in case of error.
+*/
+int
+xmlTextReaderSetSchema(xmlTextReaderPtr reader, xmlSchemaPtr schema) {
+if (reader == NULL)
+return(-1);
+if (schema == NULL) {
+if (reader->xsdPlug != NULL) {
+xmlSchemaSAXUnplug(reader->xsdPlug);
+reader->xsdPlug = NULL;
+}
+if (reader->xsdValidCtxt != NULL) {
+xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
+reader->xsdValidCtxt = NULL;
+}
+if (reader->xsdSchemas != NULL) {
+xmlSchemaFree(reader->xsdSchemas);
+reader->xsdSchemas = NULL;
+}
+return(0);
+}
+if (reader->mode != XML_TEXTREADER_MODE_INITIAL)
+return(-1);
+if (reader->xsdPlug != NULL) {
+xmlSchemaSAXUnplug(reader->xsdPlug);
+reader->xsdPlug = NULL;
+}
+if (reader->xsdValidCtxt != NULL) {
+xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
+reader->xsdValidCtxt = NULL;
+}
+if (reader->xsdSchemas != NULL) {
+xmlSchemaFree(reader->xsdSchemas);
+reader->xsdSchemas = NULL;
+}
+reader->xsdValidCtxt = xmlSchemaNewValidCtxt(schema);
+if (reader->xsdValidCtxt == NULL) {
+xmlSchemaFree(reader->xsdSchemas);
+reader->xsdSchemas = NULL;
+return(-1);
+}
+reader->xsdPlug = xmlSchemaSAXPlug(reader->xsdValidCtxt,
+&(reader->ctxt->sax),
+&(reader->ctxt->userData));
+if (reader->xsdPlug == NULL) {
+xmlSchemaFree(reader->xsdSchemas);
+reader->xsdSchemas = NULL;
+xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
+reader->xsdValidCtxt = NULL;
+return(-1);
+}
+if (reader->errorFunc != NULL) {
+xmlSchemaSetValidErrors(reader->xsdValidCtxt,
+xmlTextReaderValidityErrorRelay,
+xmlTextReaderValidityWarningRelay,
+reader);
+}
+if (reader->sErrorFunc != NULL) {
+xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt,
+xmlTextReaderValidityStructuredRelay,
+reader);
+}
+reader->xsdValidErrors = 0;
+reader->validate = XML_TEXTREADER_VALIDATE_XSD;
+return(0);
+}
+/**
+* xmlTextReaderRelaxNGValidate:
+* @param reader the xmlTextReaderPtr used
+* @param rng the path to a RelaxNG schema or NULL
+*
+* Use RelaxNG to validate the document as it is processed.
+* Activation is only possible before the first Read().
+* if rng is NULL, then RelaxNG validation is desactivated.
+*
+* Returns 0 in case the RelaxNG validation could be (des)activated and
+*         -1 in case of error.
+*/
+int
+xmlTextReaderRelaxNGValidate(xmlTextReaderPtr reader, const char *rng)
+{
+xmlRelaxNGParserCtxtPtr ctxt;
+if (reader == NULL)
+return(-1);
+if (rng == NULL) {
+if (reader->rngValidCtxt != NULL) {
+xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
+reader->rngValidCtxt = NULL;
+}
+if (reader->rngSchemas != NULL) {
+xmlRelaxNGFree(reader->rngSchemas);
+reader->rngSchemas = NULL;
+}
+return(0);
+}
+if (reader->mode != XML_TEXTREADER_MODE_INITIAL)
+return(-1);
+if (reader->rngSchemas != NULL) {
+xmlRelaxNGFree(reader->rngSchemas);
+reader->rngSchemas = NULL;
+}
+if (reader->rngValidCtxt != NULL) {
+xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
+reader->rngValidCtxt = NULL;
+}
+ctxt = xmlRelaxNGNewParserCtxt(rng);
+if (reader->errorFunc != NULL) {
+xmlRelaxNGSetParserErrors(ctxt,
+xmlTextReaderValidityErrorRelay,
+xmlTextReaderValidityWarningRelay,
+reader);
+}
+if (reader->sErrorFunc != NULL) {
+xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt,
+xmlTextReaderValidityStructuredRelay,
+reader);
+}
+reader->rngSchemas = xmlRelaxNGParse(ctxt);
+xmlRelaxNGFreeParserCtxt(ctxt);
+if (reader->rngSchemas == NULL)
+return(-1);
+reader->rngValidCtxt = xmlRelaxNGNewValidCtxt(reader->rngSchemas);
+if (reader->rngValidCtxt == NULL) {
+xmlRelaxNGFree(reader->rngSchemas);
+reader->rngSchemas = NULL;
+return(-1);
+}
+if (reader->errorFunc != NULL) {
+xmlRelaxNGSetValidErrors(reader->rngValidCtxt,
+xmlTextReaderValidityErrorRelay,
+xmlTextReaderValidityWarningRelay,
+reader);
+}
+if (reader->sErrorFunc != NULL) {
+xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt,
+xmlTextReaderValidityStructuredRelay,
+reader);
+}
+reader->rngValidErrors = 0;
+reader->rngFullNode = NULL;
+reader->validate = XML_TEXTREADER_VALIDATE_RNG;
+return(0);
+}
+/**
+* xmlTextReaderSchemaValidate:
+* @param reader the xmlTextReaderPtr used
+* @param xsd the path to a W3C XSD schema or NULL
+*
+* Use W3C XSD schema to validate the document as it is processed.
+* Activation is only possible before the first Read().
+* if xsd is NULL, then RelaxNG validation is desactivated.
+*
+* Returns 0 in case the schemas validation could be (des)activated and
+*         -1 in case of error.
+*/
+int
+xmlTextReaderSchemaValidate(xmlTextReaderPtr reader, const char *xsd) {
+xmlSchemaParserCtxtPtr ctxt;
+if (reader == NULL)
+return(-1);
+if (xsd == NULL) {
+if (reader->xsdPlug != NULL) {
+xmlSchemaSAXUnplug(reader->xsdPlug);
+reader->xsdPlug = NULL;
+}
+if (reader->xsdSchemas != NULL) {
+xmlSchemaFree(reader->xsdSchemas);
+reader->xsdSchemas = NULL;
+}
+if (reader->xsdValidCtxt != NULL) {
+xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
+reader->xsdValidCtxt = NULL;
+}
+return(0);
+}
+if ((reader->mode != XML_TEXTREADER_MODE_INITIAL) ||
+(reader->ctxt == NULL))
+return(-1);
+if (reader->xsdPlug != NULL) {
+xmlSchemaSAXUnplug(reader->xsdPlug);
+reader->xsdPlug = NULL;
+}
+if (reader->xsdValidCtxt != NULL) {
+xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
+reader->xsdValidCtxt = NULL;
+}
+if (reader->xsdSchemas != NULL) {
+xmlSchemaFree(reader->xsdSchemas);
+reader->xsdSchemas = NULL;
+}
+ctxt = xmlSchemaNewParserCtxt(xsd);
+if (reader->errorFunc != NULL) {
+xmlSchemaSetParserErrors(ctxt,
+xmlTextReaderValidityErrorRelay,
+xmlTextReaderValidityWarningRelay,
+reader);
+}
+reader->xsdSchemas = xmlSchemaParse(ctxt);
+xmlSchemaFreeParserCtxt(ctxt);
+if (reader->xsdSchemas == NULL)
+return(-1);
+reader->xsdValidCtxt = xmlSchemaNewValidCtxt(reader->xsdSchemas);
+if (reader->xsdValidCtxt == NULL) {
+xmlSchemaFree(reader->xsdSchemas);
+reader->xsdSchemas = NULL;
+return(-1);
+}
+reader->xsdPlug = xmlSchemaSAXPlug(reader->xsdValidCtxt,
+&(reader->ctxt->sax),
+&(reader->ctxt->userData));
+if (reader->xsdPlug == NULL) {
+xmlSchemaFree(reader->xsdSchemas);
+reader->xsdSchemas = NULL;
+xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
+reader->xsdValidCtxt = NULL;
+return(-1);
+}
+if (reader->errorFunc != NULL) {
+xmlSchemaSetValidErrors(reader->xsdValidCtxt,
+xmlTextReaderValidityErrorRelay,
+xmlTextReaderValidityWarningRelay,
+reader);
+}
+if (reader->sErrorFunc != NULL) {
+xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt,
+xmlTextReaderValidityStructuredRelay,
+reader);
+}
+reader->xsdValidErrors = 0;
+reader->validate = XML_TEXTREADER_VALIDATE_XSD;
+return(0);
+}
+#endif
+/**
+* xmlTextReaderIsNamespaceDecl:
+* @param reader the xmlTextReaderPtr used
+*
+* Determine whether the current node is a namespace declaration
+* rather than a regular attribute.
+*
+* Returns 1 if the current node is a namespace declaration, 0 if it
+* is a regular attribute or other type of node, or -1 in case of
+* error.
+*/
+XMLPUBFUNEXPORT int
+xmlTextReaderIsNamespaceDecl(xmlTextReaderPtr reader) {
+xmlNodePtr node;
+if (reader == NULL)
+return(-1);
+if (reader->node == NULL)
+return(-1);
+if (reader->curnode != NULL)
+node = reader->curnode;
+else
+node = reader->node;
+if (XML_NAMESPACE_DECL == node->type)
+return(1);
+else
+return(0);
+}
+/**
+* xmlTextReaderConstXmlVersion:
+* @param reader the xmlTextReaderPtr used
+*
+* Determine the XML version of the document being read.
+*
+* Returns a string containing the XML version of the document or NULL
+* in case of error.  The string is deallocated with the reader.
+*/
+XMLPUBFUNEXPORT const xmlChar *
+xmlTextReaderConstXmlVersion(xmlTextReaderPtr reader) {
+xmlDocPtr doc = NULL;
+if (reader == NULL)
+return(NULL);
+if (reader->doc != NULL)
+doc = reader->doc;
+else if (reader->ctxt != NULL)
+doc = reader->ctxt->myDoc;
+if (doc == NULL)
+return(NULL);
+if (doc->version == NULL)
+return(NULL);
+else
+return(CONSTSTR(doc->version));
+}
+/**
+* xmlTextReaderStandalone:
+* @param reader the xmlTextReaderPtr used
+*
+* Determine the standalone status of the document being read.
+*
+* Returns 1 if the document was declared to be standalone, 0 if it
+* was declared to be not standalone, or -1 if the document did not
+* specify its standalone status or in case of error.
+*/
+XMLPUBFUNEXPORT int
+xmlTextReaderStandalone(xmlTextReaderPtr reader) {
+xmlDocPtr doc = NULL;
+if (reader == NULL)
+return(-1);
+if (reader->doc != NULL)
+doc = reader->doc;
+else if (reader->ctxt != NULL)
+doc = reader->ctxt->myDoc;
+if (doc == NULL)
+return(-1);
+return(doc->standalone);
+}
+/************************************************************************
+*                                                                      *
+*          Error Handling Extensions                                   *
+*                                                                      *
+************************************************************************/
+/* helper to build a xmlMalloc'ed string from a format and va_list */
+static char*
+xmlTextReaderBuildMessage(const char *msg, va_list ap)
+{
+int size;
+int chars;
+char* larger;
+char* str;
+str = (char*) xmlMallocAtomic(150);
+if (str == NULL) {
+xmlGenericError(xmlGenericErrorContext, EMBED_ERRTXT("xmlMalloc failed !\n"));
+return NULL;
+}
+size = 150;
+while (1)
+{
+chars = vsnprintf(str, size, msg, ap);
+if ((chars > -1) && (chars < size))
+break;
+if (chars > -1)
+size += chars + 1;
+else
+size += 100;
+if ((larger = (char *) xmlRealloc(str, size)) == NULL) {
+xmlGenericError(xmlGenericErrorContext, EMBED_ERRTXT("xmlRealloc failed !\n"));
+xmlFree(str);
+return NULL;
+}
+str = larger;
+}
+return str;
+}
+#ifdef LIBXML_ENABLE_NODE_LINEINFO
+/**
+* xmlTextReaderLocatorLineNumber:
+* @param locator the xmlTextReaderLocatorPtr used
+*
+* Obtain the line number for the given locator.
+*
+* Returns the line number or -1 in case of error.
+*/
+int
+xmlTextReaderLocatorLineNumber(xmlTextReaderLocatorPtr locator)
+{
+/* we know that locator is a xmlParserCtxtPtr */
+xmlParserCtxtPtr ctx = (xmlParserCtxtPtr)locator;
+int ret = -1;
+if (locator == NULL)
+return(-1);
+if (ctx->node != NULL) {
+ret = xmlGetLineNo(ctx->node);
+}
+else {
+/* inspired from error.c */
+xmlParserInputPtr input;
+input = ctx->input;
+if ((input->filename == NULL) && (ctx->inputNr > 1))
+input = ctx->inputTab[ctx->inputNr - 2];
+if (input != NULL) {
+ret = input->line;
+}
+else {
+ret = -1;
+}
+}
+return ret;
+}
+#endif /* LIBXML_ENABLE_NODE_LINEINFO */
+/**
+* xmlTextReaderLocatorBaseURI:
+* @param locator the xmlTextReaderLocatorPtr used
+*
+* Obtain the base URI for the given locator.
+*
+* Returns the base URI or NULL in case of error.
+*/
+XMLPUBFUNEXPORT xmlChar *
+xmlTextReaderLocatorBaseURI(xmlTextReaderLocatorPtr locator)
+{
+/* we know that locator is a xmlParserCtxtPtr */
+xmlParserCtxtPtr ctx = (xmlParserCtxtPtr)locator;
+xmlChar *ret = NULL;
+if (locator == NULL)
+return(NULL);
+if (ctx->node != NULL) {
+ret = xmlNodeGetBase(NULL,ctx->node);
+}
+else
+{
+/* inspired from error.c */
+xmlParserInputPtr input;
+input = ctx->input;
+if ((input->filename == NULL) && (ctx->inputNr > 1))
+input = ctx->inputTab[ctx->inputNr - 2];
+if (input != NULL) {
+ret = xmlStrdup(BAD_CAST input->filename);
+}
+else {
+ret = NULL;
+}
+}
+return ret;
+}
+static void
+xmlTextReaderGenericError(void *ctxt, xmlParserSeverities severity, char *str)
+{
+xmlParserCtxtPtr ctx = (xmlParserCtxtPtr)ctxt;
+xmlTextReaderPtr reader = (xmlTextReaderPtr)ctx->_private;
+if (str != NULL) {
+if (reader->errorFunc)
+reader->errorFunc(reader->errorFuncArg,
+str,
+severity,
+(xmlTextReaderLocatorPtr)ctx);
+if (str != NULL) { // NOTE: no this check in the latest open-source version
+xmlFree(str);
+}
+}
+}
+static void
+xmlTextReaderStructuredError(void *ctxt, xmlErrorPtr error)
+{
+xmlParserCtxtPtr ctx = (xmlParserCtxtPtr) ctxt;
+xmlTextReaderPtr reader = (xmlTextReaderPtr) ctx->_private;
+if (error && reader->sErrorFunc) {
+reader->sErrorFunc(reader->errorFuncArg,
+(xmlErrorPtr) error);
+}
+}
+static void /* XMLCDECL */
+xmlTextReaderError(void *ctxt, const char *msg, ...)
+{
+va_list ap;
+va_start(ap,msg);
+xmlTextReaderGenericError(ctxt,
+XML_PARSER_SEVERITY_ERROR,
+xmlTextReaderBuildMessage(msg,ap));
+va_end(ap);
+}
+static void /* XMLCDECL */
+xmlTextReaderWarning(void *ctxt, const char *msg, ...)
+{
+va_list ap;
+va_start(ap,msg);
+xmlTextReaderGenericError(ctxt,
+XML_PARSER_SEVERITY_WARNING,
+xmlTextReaderBuildMessage(msg,ap));
+va_end(ap);
+}
+static void /* XMLCDECL */
+xmlTextReaderValidityError(void *ctxt, const char *msg, ...)
+{
+va_list ap;
+int len = xmlStrlen((const xmlChar *) msg);
+if ((len > 1) && (msg[len - 2] != ':'))
+{
+/*
+* some callbacks only report locator information:
+* skip them (mimicking behaviour in error.c)
+*/
+va_start(ap,msg);
+xmlTextReaderGenericError(ctxt,
+XML_PARSER_SEVERITY_VALIDITY_ERROR,
+xmlTextReaderBuildMessage(msg,ap));
+va_end(ap);
+}
+}
+static void /* XMLCDECL */
+xmlTextReaderValidityWarning(void *ctxt, const char *msg, ...)
+{
+va_list ap;
+int len = xmlStrlen((const xmlChar *) msg);
+if ((len != 0) && (msg[len - 1] != ':'))
+{
+/*
+* some callbacks only report locator information:
+* skip them (mimicking behaviour in error.c)
+*/
+va_start(ap,msg);
+xmlTextReaderGenericError(ctxt,
+XML_PARSER_SEVERITY_VALIDITY_WARNING,
+xmlTextReaderBuildMessage(msg,ap));
+va_end(ap);
+}
+}
+/**
+* xmlTextReaderSetErrorHandler:
+* @param reader the xmlTextReaderPtr used
+* @param f the callback function to call on error and warnings
+* @param arg a user argument to pass to the callback function
+*
+* Register a callback function that will be called on error and warnings.
+*
+* If f is NULL, the default error and warning handlers are restored.
+*/
+XMLPUBFUNEXPORT void
+xmlTextReaderSetErrorHandler(xmlTextReaderPtr reader,
+xmlTextReaderErrorFunc f,
+void *arg)
+{
+if (f != NULL)
+{
+reader->ctxt->sax->error = xmlTextReaderError;
+reader->ctxt->sax->serror = NULL;
+reader->ctxt->vctxt.error = xmlTextReaderValidityError;
+reader->ctxt->sax->warning = xmlTextReaderWarning;
+reader->ctxt->vctxt.warning = xmlTextReaderValidityWarning;
+reader->errorFunc = f;
+reader->sErrorFunc = NULL;
+reader->errorFuncArg = arg;
+#ifdef LIBXML_SCHEMAS_ENABLED
+if (reader->rngValidCtxt) {
+xmlRelaxNGSetValidErrors(reader->rngValidCtxt,
+xmlTextReaderValidityErrorRelay,
+xmlTextReaderValidityWarningRelay,
+reader);
+xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt, NULL, reader);
+}
+if (reader->xsdValidCtxt) {
+xmlSchemaSetValidErrors(reader->xsdValidCtxt,
+xmlTextReaderValidityErrorRelay,
+xmlTextReaderValidityWarningRelay,
+reader);
+xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt, NULL, reader);
+}
+#endif
+}
+else {
+/* restore defaults */
+reader->ctxt->sax->error = xmlParserError;
+reader->ctxt->vctxt.error = xmlParserValidityError;
+reader->ctxt->sax->warning = xmlParserWarning;
+reader->ctxt->vctxt.warning = xmlParserValidityWarning;
+reader->errorFunc = NULL;
+reader->sErrorFunc = NULL;
+reader->errorFuncArg = NULL;
+#ifdef LIBXML_SCHEMAS_ENABLED
+if (reader->rngValidCtxt) {
+xmlRelaxNGSetValidErrors(reader->rngValidCtxt, NULL, NULL, reader);
+xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt, NULL, reader);
+}
+if (reader->xsdValidCtxt) {
+xmlSchemaSetValidErrors(reader->xsdValidCtxt, NULL, NULL, reader);
+xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt, NULL, reader);
+}
+#endif
+}
+}
+/**
+* xmlTextReaderSetStructuredErrorHandler:
+* @param reader the xmlTextReaderPtr used
+* @param f the callback function to call on error and warnings
+* @param arg a user argument to pass to the callback function
+*
+* Register a callback function that will be called on error and warnings.
+*
+* If f is NULL, the default error and warning handlers are restored.
+*/
+XMLPUBFUNEXPORT void
+xmlTextReaderSetStructuredErrorHandler(xmlTextReaderPtr reader,
+xmlStructuredErrorFunc f,
+void *arg)
+{
+if (f != NULL) {
+reader->ctxt->sax->error = NULL;
+reader->ctxt->sax->serror = xmlTextReaderStructuredError;
+reader->ctxt->vctxt.error = xmlTextReaderValidityError;
+reader->ctxt->sax->warning = xmlTextReaderWarning;
+reader->ctxt->vctxt.warning = xmlTextReaderValidityWarning;
+reader->sErrorFunc = f;
+reader->errorFunc = NULL;
+reader->errorFuncArg = arg;
+#ifdef LIBXML_SCHEMAS_ENABLED
+if (reader->rngValidCtxt) {
+xmlRelaxNGSetValidErrors(reader->rngValidCtxt, NULL, NULL, reader);
+xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt,
+xmlTextReaderValidityStructuredRelay,
+reader);
+}
+if (reader->xsdValidCtxt) {
+xmlSchemaSetValidErrors(reader->xsdValidCtxt, NULL, NULL, reader);
+xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt,
+xmlTextReaderValidityStructuredRelay,
+reader);
+}
+#endif
+}
+else {
+/* restore defaults */
+reader->ctxt->sax->error = xmlParserError;
+reader->ctxt->sax->serror = NULL;
+reader->ctxt->vctxt.error = xmlParserValidityError;
+reader->ctxt->sax->warning = xmlParserWarning;
+reader->ctxt->vctxt.warning = xmlParserValidityWarning;
+reader->errorFunc = NULL;
+reader->sErrorFunc = NULL;
+reader->errorFuncArg = NULL;
+#ifdef LIBXML_SCHEMAS_ENABLED
+if (reader->rngValidCtxt) {
+xmlRelaxNGSetValidErrors(reader->rngValidCtxt, NULL, NULL, reader);
+xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt, NULL, reader);
+}
+if (reader->xsdValidCtxt) {
+xmlSchemaSetValidErrors(reader->xsdValidCtxt, NULL, NULL, reader);
+xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt, NULL, reader);
+}
+#endif
+}
+}
+/**
+* xmlTextReaderIsValid:
+* @param reader the xmlTextReaderPtr used
+*
+* Retrieve the validity status from the parser context
+*
+* Returns the flag value 1 if valid, 0 if no, and -1 in case of error
+*/
+XMLPUBFUNEXPORT int
+xmlTextReaderIsValid(xmlTextReaderPtr reader)
+{
+if (reader == NULL) return(-1);
+#ifdef LIBXML_SCHEMAS_ENABLED
+if (reader->validate == XML_TEXTREADER_VALIDATE_RNG)
+return(reader->rngValidErrors == 0);
+if (reader->validate == XML_TEXTREADER_VALIDATE_XSD)
+return(reader->xsdValidErrors == 0);
+#endif
+if ((reader->ctxt != NULL) && (reader->ctxt->validate == 1))
+return(reader->ctxt->valid);
+return(0);
+}
+/**
+* xmlTextReaderGetErrorHandler:
+* @param reader the xmlTextReaderPtr used
+* @param f the callback function or NULL is no callback has been registered
+* @param arg a user argument
+*
+* Retrieve the error callback function and user argument.
+*/
+XMLPUBFUNEXPORT void
+xmlTextReaderGetErrorHandler(xmlTextReaderPtr reader,
+xmlTextReaderErrorFunc *f,
+void **arg)
+{
+if (f != NULL) *f = reader->errorFunc;
+if (arg != NULL) *arg = reader->errorFuncArg;
+}
+/************************************************************************
+*                                                                      *
+*  New set (2.6.0) of simpler and more flexible APIs                   *
+*                                                                      *
+************************************************************************/
+/**
+* xmlTextReaderSetup:
+* @param reader an XML reader
+* @param URL the base URL to use for the document
+* @param encoding the document encoding, or NULL
+* @param options a combination of xmlParserOption
+* @param reuse keep the context for reuse
+*
+* Setup an XML reader with new options
+*
+* Returns 0 in case of success and -1 in case of error.
+*/
+static int
+xmlTextReaderSetup(xmlTextReaderPtr reader,
+xmlParserInputBufferPtr input, const char *URL,
+const char *encoding, int options)
+{
+if (reader == NULL)
+return (-1);
+/*
+* we force the generation of compact text nodes on the reader
+* since usr applications should never modify the tree
+*/
+// XMLENGINE:  Enable when whole libxml2 is updated from open-source
+//options |= XML_PARSE_COMPACT;
+reader->doc = NULL;
+reader->entNr = 0;
+reader->parserFlags = options;
+reader->validate = XML_TEXTREADER_NOT_VALIDATE;
+if ((input != NULL) && (reader->input != NULL) &&
+(reader->allocs & XML_TEXTREADER_INPUT))
+{
+xmlFreeParserInputBuffer(reader->input);
+reader->input = NULL;
+reader->allocs -= XML_TEXTREADER_INPUT;
+}
+if (input != NULL) {
+reader->input = input;
+reader->allocs |= XML_TEXTREADER_INPUT;
+}
+if (reader->buffer == NULL)
+reader->buffer = xmlBufferCreateSize(100);
+if (reader->buffer == NULL) {
+xmlGenericError(xmlGenericErrorContext,
+EMBED_ERRTXT("xmlTextReaderSetup : malloc failed\n"));
+return (-1);
+}
+if (reader->sax == NULL)
+reader->sax = (xmlSAXHandler *) xmlMalloc(sizeof(xmlSAXHandler));
+if (reader->sax == NULL) {
+xmlGenericError(xmlGenericErrorContext,
+EMBED_ERRTXT("xmlTextReaderSetup : malloc failed\n"));
+return (-1);
+}
+xmlSAXVersion(reader->sax, 2);
+reader->startElement = reader->sax->startElement;
+reader->sax->startElement = xmlTextReaderStartElement;
+reader->endElement = reader->sax->endElement;
+reader->sax->endElement = xmlTextReaderEndElement;
+#ifdef LIBXML_SAX1_ENABLED
+if (reader->sax->initialized == XML_SAX2_MAGIC) {
+#endif /* LIBXML_SAX1_ENABLED */
+reader->startElementNs = reader->sax->startElementNs;
+reader->sax->startElementNs = xmlTextReaderStartElementNs;
+reader->endElementNs = reader->sax->endElementNs;
+reader->sax->endElementNs = xmlTextReaderEndElementNs;
+#ifdef LIBXML_SAX1_ENABLED
+} else {
+reader->startElementNs = NULL;
+reader->endElementNs = NULL;
+}
+#endif /* LIBXML_SAX1_ENABLED */
+reader->characters = reader->sax->characters;
+reader->sax->characters = xmlTextReaderCharacters;
+reader->sax->ignorableWhitespace = xmlTextReaderCharacters;
+reader->cdataBlock = reader->sax->cdataBlock;
+reader->sax->cdataBlock = xmlTextReaderCDataBlock;
+reader->mode = XML_TEXTREADER_MODE_INITIAL;
+reader->node = NULL;
+reader->curnode = NULL;
+if (input)
+{
+if (reader->input->buffer->use < 4) {
+xmlParserInputBufferRead(input, 4);
+}
+if (reader->ctxt == NULL) {
+if (reader->input->buffer->use >= 4) {
+reader->ctxt = xmlCreatePushParserCtxt(reader->sax, NULL,
+(const char*) reader->input->buffer->content,
+4, URL);
+reader->base = 0;
+reader->cur = 4;
+} else {
+reader->ctxt = xmlCreatePushParserCtxt(reader->sax, NULL, NULL, 0, URL);
+reader->base = 0;
+reader->cur = 0;
+}
+} else {
+xmlParserInputPtr inputStream;
+xmlParserInputBufferPtr buf;
+xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
+xmlCtxtReset(reader->ctxt);
+buf = xmlAllocParserInputBuffer(enc);
+if (buf == NULL)
+return(-1);
+inputStream = xmlNewInputStream(reader->ctxt);
+if (inputStream == NULL) {
+xmlFreeParserInputBuffer(buf);
+return(-1);
+}
+if (URL == NULL)
+inputStream->filename = NULL;
+else
+inputStream->filename = (char*)
+xmlCanonicPath((const xmlChar*) URL);
+inputStream->buf = buf;
+inputStream->base = inputStream->buf->buffer->content;
+inputStream->cur = inputStream->buf->buffer->content;
+inputStream->end = &inputStream->buf->buffer->content[inputStream->buf->buffer->use];
+inputPush(reader->ctxt, inputStream);
+reader->cur = 0;
+}
+if (reader->ctxt == NULL) {
+xmlGenericError(xmlGenericErrorContext,
+EMBED_ERRTXT("xmlTextReaderSetup : malloc failed\n"));
+return (-1);
+}
+} // end if (input)
+if (reader->dict != NULL) {
+if (reader->ctxt->dict != NULL) {
+if (reader->dict != reader->ctxt->dict) {
+xmlDictFree(reader->dict);
+reader->dict = reader->ctxt->dict;
+}
+} else {
+reader->ctxt->dict = reader->dict;
+}
+} else {
+if (reader->ctxt->dict == NULL)
+reader->ctxt->dict = xmlDictCreate();
+reader->dict = reader->ctxt->dict;
+}
+reader->ctxt->_private = reader;
+#ifdef LIBXML_ENABLE_NODE_LINEINFO
+reader->ctxt->linenumbers = 1;
+#endif
+reader->ctxt->dictNames = 1;
+/*
+* use the parser dictionnary to allocate all elements and attributes names
+*/
+reader->ctxt->docdict = 1;
+//reader->ctxt->parseMode = XML_PARSE_READER;
+#ifdef LIBXML_XINCLUDE_ENABLED
+if (reader->xincctxt != NULL) {
+xmlXIncludeFreeContext(reader->xincctxt);
+reader->xincctxt = NULL;
+}
+if (options & XML_PARSE_XINCLUDE) {
+reader->xinclude = 1;
+reader->xinclude_name = xmlDictLookup(reader->dict, XINCLUDE_NODE, -1);
+options -= XML_PARSE_XINCLUDE;
+} else {
+reader->xinclude = 0;
+}
+reader->in_xinclude = 0;
+#endif
+#ifdef LIBXML_PATTERN_ENABLED
+if (reader->patternTab == NULL) {
+reader->patternNr = 0;
+reader->patternMax = 0;
+}
+while (reader->patternNr > 0) {
+reader->patternNr--;
+if (reader->patternTab[reader->patternNr] != NULL) {
+xmlFreePattern(reader->patternTab[reader->patternNr]);
+reader->patternTab[reader->patternNr] = NULL;
+}
+}
+#endif
+if (options & XML_PARSE_DTDVALID)
+reader->validate = XML_TEXTREADER_VALIDATE_DTD;
+xmlCtxtUseOptions(reader->ctxt, options);
+if (encoding != NULL) {
+xmlCharEncodingHandlerPtr hdlr;
+hdlr = xmlFindCharEncodingHandler(encoding);
+if (hdlr != NULL)
+xmlSwitchToEncoding(reader->ctxt, hdlr);
+}
+if ((URL != NULL) && (reader->ctxt->input != NULL) &&
+(reader->ctxt->input->filename == NULL))
+{
+reader->ctxt->input->filename = (char*)xmlStrdup((const xmlChar*) URL);
+}
+reader->doc = NULL;
+return (0);
+}
+/**
+* xmlTextReaderByteConsumed:
+* @param reader an XML reader
+*
+* This function provides the current index of the parser used
+* by the reader, relative to the start of the current entity.
+* This function actually just wraps a call to xmlBytesConsumed()
+* for the parser context associated with the reader.
+* See xmlBytesConsumed() for more information.
+*
+* Returns the index in bytes from the beginning of the entity or -1
+*         in case the index could not be computed.
+*/
+XMLPUBFUNEXPORT long
+xmlTextReaderByteConsumed(xmlTextReaderPtr reader) {
+if ((reader == NULL) || (reader->ctxt == NULL))
+return(-1);
+//return(xmlByteConsumed(reader->ctxt));
+return 0;
+}
+/**
+* xmlReaderWalker:
+* @param doc a preparsed document
+*
+* Create an xmltextReader for a preparsed document.
+*
+* Returns the new reader or NULL in case of error.
+*/
+XMLPUBFUNEXPORT xmlTextReaderPtr
+xmlReaderWalker(xmlDocPtr doc)
+{
+xmlTextReaderPtr ret;
+if (doc == NULL)
+return(NULL);
+ret = xmlMalloc(sizeof(xmlTextReader));
+if (ret == NULL) {
+xmlGenericError(xmlGenericErrorContext,
+EMBED_ERRTXT("xmlNewTextReader : malloc failed\n"));
+return(NULL);
+}
+memset(ret, 0, sizeof(xmlTextReader));
+//ret->entNr = 0;
+//ret->input = NULL;
+ret->mode = XML_TEXTREADER_MODE_INITIAL;
+//ret->node = NULL;
+//ret->curnode = NULL;
+//ret->base = 0;
+//ret->cur = 0;
+ret->allocs = XML_TEXTREADER_CTXT;
+ret->doc = doc;
+ret->state = XML_TEXTREADER_START;
+ret->dict = xmlDictCreate();
+return(ret);
+}
+/**
+* xmlReaderForDoc:
+* @param cur a pointer to a zero terminated string
+* @param URL the base URL to use for the document
+* @param encoding the document encoding, or NULL
+* @param options a combination of xmlParserOption
+*
+* Create an xmltextReader for an XML in-memory document.
+* The parsing flags options are a combination of xmlParserOption.
+*
+* Returns the new reader or NULL in case of error.
+*/
+XMLPUBFUNEXPORT xmlTextReaderPtr
+xmlReaderForDoc(const xmlChar* cur, const char* URL, const char* encoding, int options)
+{
+int len;
+if (cur == NULL)
+return (NULL);
+len = xmlStrlen(cur);
+return xmlReaderForMemory((const char*) cur, len, URL, encoding, options);
+}
+/**
+* xmlReaderForFile:
+* @param filename a file or URL
+* @param encoding the document encoding, or NULL
+* @param options a combination of xmlParserOption
+*
+* parse an XML file from the filesystem or the network.
+* The parsing flags options are a combination of xmlParserOption.
+*
+* Returns the new reader or NULL in case of error.
+*/
+XMLPUBFUNEXPORT xmlTextReaderPtr
+xmlReaderForFile(const char *filename, const char *encoding, int options)
+{
+xmlTextReaderPtr reader;
+reader = xmlNewTextReaderFilename(filename);
+if (reader == NULL)
+return (NULL);
+xmlTextReaderSetup(reader, NULL, NULL, encoding, options);
+return (reader);
+}
+/**
+* xmlReaderForMemory:
+* @param buffer a pointer to a char array
+* @param size the size of the array
+* @param URL the base URL to use for the document
+* @param encoding the document encoding, or NULL
+* @param options a combination of xmlParserOption
+*
+* Create an xmltextReader for an XML in-memory document.
+* The parsing flags options are a combination of xmlParserOption.
+*
+* Returns the new reader or NULL in case of error.
+*/
+XMLPUBFUNEXPORT xmlTextReaderPtr
+xmlReaderForMemory(const char *buffer, int size, const char *URL,
+const char *encoding, int options)
+{
+xmlTextReaderPtr reader;
+xmlParserInputBufferPtr buf;
+buf = xmlParserInputBufferCreateStatic(buffer, size, XML_CHAR_ENCODING_NONE);
+if (buf == NULL) {
+return (NULL);
+}
+reader = xmlNewTextReader(buf, URL);
+if (reader == NULL) {
+xmlFreeParserInputBuffer(buf);
+return (NULL);
+}
+reader->allocs |= XML_TEXTREADER_INPUT;
+xmlTextReaderSetup(reader, NULL, URL, encoding, options);
+return (reader);
+}
+/**
+* xmlReaderForFd:
+* @param fd an open file descriptor
+* @param URL the base URL to use for the document
+* @param encoding the document encoding, or NULL
+* @param options a combination of xmlParserOption
+*
+* Create an xmltextReader for an XML from a file descriptor.
+* The parsing flags options are a combination of xmlParserOption.
+* NOTE that the file descriptor will not be closed when the
+*      reader is closed or reset.
+*
+* Returns the new reader or NULL in case of error.
+*/
+XMLPUBFUNEXPORT xmlTextReaderPtr
+xmlReaderForFd(int fd, const char *URL, const char *encoding, int options)
+{
+xmlTextReaderPtr reader;
+xmlParserInputBufferPtr input;
+if (fd < 0)
+return (NULL);
+input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE);
+if (input == NULL)
+return (NULL);
+input->closecallback = NULL;
+reader = xmlNewTextReader(input, URL);
+if (reader == NULL) {
+xmlFreeParserInputBuffer(input);
+return (NULL);
+}
+reader->allocs |= XML_TEXTREADER_INPUT;
+xmlTextReaderSetup(reader, NULL, URL, encoding, options);
+return (reader);
+}
+/**
+* xmlReaderForIO:
+* @param ioread an I/O read function
+* @param ioclose an I/O close function
+* @param ioctx an I/O handler
+* @param URL the base URL to use for the document
+* @param encoding the document encoding, or NULL
+* @param options a combination of xmlParserOption
+*
+* Create an xmltextReader for an XML document from I/O functions and source.
+* The parsing flags options are a combination of xmlParserOption.
+*
+* Returns the new reader or NULL in case of error.
+*/
+XMLPUBFUNEXPORT xmlTextReaderPtr
+xmlReaderForIO(xmlInputReadCallback ioread, xmlInputCloseCallback ioclose,
+void *ioctx, const char *URL, const char *encoding,
+int options)
+{
+xmlTextReaderPtr reader;
+xmlParserInputBufferPtr input;
+if (ioread == NULL)
+return (NULL);
+input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx,
+XML_CHAR_ENCODING_NONE);
+if (input == NULL)
+return (NULL);
+reader = xmlNewTextReader(input, URL);
+if (reader == NULL) {
+xmlFreeParserInputBuffer(input);
+return (NULL);
+}
+reader->allocs |= XML_TEXTREADER_INPUT;
+xmlTextReaderSetup(reader, NULL, URL, encoding, options);
+return (reader);
+}
+/**
+* xmlReaderNewWalker:
+* @param reader an XML reader
+* @param doc a preparsed document
+*
+* Setup an xmltextReader to parse a preparsed XML document.
+* This reuses the existing reader xmlTextReader.
+*
+* Returns 0 in case of success and -1 in case of error
+*/
+XMLPUBFUNEXPORT int
+xmlReaderNewWalker(xmlTextReaderPtr reader, xmlDocPtr doc)
+{
+if (doc == NULL)
+return (-1);
+if (reader == NULL)
+return (-1);
+if (reader->input != NULL) {
+xmlFreeParserInputBuffer(reader->input);
+}
+if (reader->ctxt != NULL) {
+xmlCtxtReset(reader->ctxt);
+}
+reader->entNr = 0;
+reader->input = NULL;
+reader->mode = XML_TEXTREADER_MODE_INITIAL;
+reader->node = NULL;
+reader->curnode = NULL;
+reader->base = 0;
+reader->cur = 0;
+reader->allocs = XML_TEXTREADER_CTXT;
+reader->doc = doc;
+reader->state = XML_TEXTREADER_START;
+if (reader->dict == NULL) {
+if ((reader->ctxt != NULL) && (reader->ctxt->dict != NULL))
+reader->dict = reader->ctxt->dict;
+else
+reader->dict = xmlDictCreate();
+}
+return(0);
+}
+/**
+* xmlReaderNewDoc:
+* @param reader an XML reader
+* @param cur a pointer to a zero terminated string
+* @param URL the base URL to use for the document
+* @param encoding the document encoding, or NULL
+* @param options a combination of xmlParserOption
+*
+* Setup an xmltextReader to parse an XML in-memory document.
+* The parsing flags options are a combination of xmlParserOption.
+* This reuses the existing reader xmlTextReader.
+*
+* Returns 0 in case of success and -1 in case of error
+*/
+XMLPUBFUNEXPORT int
+xmlReaderNewDoc(xmlTextReaderPtr reader, const xmlChar * cur,
+const char *URL, const char *encoding, int options)
+{
+int len;
+if (cur == NULL)
+return (-1);
+if (reader == NULL)
+return (-1);
+len = xmlStrlen(cur);
+return (xmlReaderNewMemory(reader, (const char *)cur, len,
+URL, encoding, options));
+}
+/**
+* xmlReaderNewFile:
+* @param reader an XML reader
+* @param filename a file or URL
+* @param encoding the document encoding, or NULL
+* @param options a combination of xmlParserOption
+*
+* parse an XML file from the filesystem or the network.
+* The parsing flags options are a combination of xmlParserOption.
+* This reuses the existing reader xmlTextReader.
+*
+* Returns 0 in case of success and -1 in case of error
+*/
+XMLPUBFUNEXPORT int
+xmlReaderNewFile(xmlTextReaderPtr reader, const char *filename,
+const char *encoding, int options)
+{
+xmlParserInputBufferPtr input;
+if (filename == NULL)
+return (-1);
+if (reader == NULL)
+return (-1);
+input = xmlParserInputBufferCreateFilename(filename, XML_CHAR_ENCODING_NONE);
+if (input == NULL)
+return (-1);
+return (xmlTextReaderSetup(reader, input, filename, encoding, options));
+}
+/**
+* xmlReaderNewMemory:
+* @param reader an XML reader
+* @param buffer a pointer to a char array
+* @param size the size of the array
+* @param URL the base URL to use for the document
+* @param encoding the document encoding, or NULL
+* @param options a combination of xmlParserOption
+*
+* Setup an xmltextReader to parse an XML in-memory document.
+* The parsing flags options are a combination of xmlParserOption.
+* This reuses the existing reader xmlTextReader.
+*
+* Returns 0 in case of success and -1 in case of error
+*/
+XMLPUBFUNEXPORT int
+xmlReaderNewMemory(xmlTextReaderPtr reader, const char *buffer, int size,
+const char *URL, const char *encoding, int options)
+{
+xmlParserInputBufferPtr input;
+if (reader == NULL)
+return (-1);
+if (buffer == NULL)
+return (-1);
+input = xmlParserInputBufferCreateStatic(buffer, size, XML_CHAR_ENCODING_NONE);
+if (input == NULL) {
+return (-1);
+}
+return (xmlTextReaderSetup(reader, input, URL, encoding, options));
+}
+/**
+* xmlReaderNewFd:
+* @param reader an XML reader
+* @param fd an open file descriptor
+* @param URL the base URL to use for the document
+* @param encoding the document encoding, or NULL
+* @param options a combination of xmlParserOption
+*
+* Setup an xmltextReader to parse an XML from a file descriptor.
+* NOTE that the file descriptor will not be closed when the
+*      reader is closed or reset.
+* The parsing flags options are a combination of xmlParserOption.
+* This reuses the existing reader xmlTextReader.
+*
+* Returns 0 in case of success and -1 in case of error
+*/
+XMLPUBFUNEXPORT int
+xmlReaderNewFd(xmlTextReaderPtr reader, int fd,
+const char *URL, const char *encoding, int options)
+{
+xmlParserInputBufferPtr input;
+if (fd < 0)
+return (-1);
+if (reader == NULL)
+return (-1);
+input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE);
+if (input == NULL)
+return (-1);
+input->closecallback = NULL;
+return (xmlTextReaderSetup(reader, input, URL, encoding, options));
+}
+/**
+* xmlReaderNewIO:
+* @param reader an XML reader
+* @param ioread an I/O read function
+* @param ioclose an I/O close function
+* @param ioctx an I/O handler
+* @param URL the base URL to use for the document
+* @param encoding the document encoding, or NULL
+* @param options a combination of xmlParserOption
+*
+* Setup an xmltextReader to parse an XML document from I/O functions
+* and source.
+* The parsing flags options are a combination of xmlParserOption.
+* This reuses the existing reader xmlTextReader.
+*
+* Returns 0 in case of success and -1 in case of error
+*/
+XMLPUBFUNEXPORT int
+xmlReaderNewIO(xmlTextReaderPtr reader, xmlInputReadCallback ioread,
+xmlInputCloseCallback ioclose, void *ioctx,
+const char *URL, const char *encoding, int options)
+{
+xmlParserInputBufferPtr input;
+if (ioread == NULL)
+return (-1);
+if (reader == NULL)
+return (-1);
+input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx,
+XML_CHAR_ENCODING_NONE);
+if (input == NULL)
+return (-1);
+return (xmlTextReaderSetup(reader, input, URL, encoding, options));
+}
+/************************************************************************
+*                                                                      *
+*          Utilities                                                   *
+*                                                                      *
+************************************************************************/
+#ifdef NOT_USED_YET
+/**
+* xmlBase64Decode:
+* @param in the input buffer
+* @param inlen the size of the input (in), the size read from it (out)
+* @param to the output buffer
+* @param tolen the size of the output (in), the size written to (out)
+*
+* Base64 decoder, reads from in and save in to
+*
+*
+* Returns 0 if all the input was consumer, 1 if the Base64 end was reached,
+*         2 if there wasn't enough space on the output or -1 in case of error.
+*/
+static int
+xmlBase64Decode(const unsigned char *in, unsigned long *inlen,
+unsigned char *to, unsigned long *tolen) {
+unsigned long incur;                /* current index in in[] */
+unsigned long inblk;                /* last block index in in[] */
+unsigned long outcur;               /* current index in out[] */
+unsigned long inmax;                /* size of in[] */
+unsigned long outmax;               /* size of out[] */
+unsigned char cur;                  /* the current value read from in[] */
+unsigned char intmp[4], outtmp[4];  /* temporary buffers for the convert */
+int nbintmp;                        /* number of byte in intmp[] */
+int is_ignore;                      /* cur should be ignored */
+int is_end = 0;                     /* the end of the base64 was found */
+int retval = 1;
+int i;
+if ((in == NULL) || (inlen == NULL) || (to == NULL) || (tolen == NULL))
+return(-1);
+incur = 0;
+inblk = 0;
+outcur = 0;
+inmax = *inlen;
+outmax = *tolen;
+nbintmp = 0;
+while (1) {
+if (incur >= inmax)
+break;
+cur = in[incur++];
+is_ignore = 0;
+if ((cur >= 'A') && (cur <= 'Z'))
+cur = cur - 'A';
+else if ((cur >= 'a') && (cur <= 'z'))
+cur = cur - 'a' + 26;
+else if ((cur >= '0') && (cur <= '9'))
+cur = cur - '0' + 52;
+else if (cur == '+')
+cur = 62;
+else if (cur == '/')
+cur = 63;
+else if (cur == '.')
+cur = 0;
+else if (cur == '=') /*no op , end of the base64 stream */
+is_end = 1;
+else {
+is_ignore = 1;
+if (nbintmp == 0)
+inblk = incur;
+}
+if (!is_ignore) {
+int nbouttmp = 3;
+int is_break = 0;
+if (is_end) {
+if (nbintmp == 0)
+break;
+if ((nbintmp == 1) || (nbintmp == 2))
+nbouttmp = 1;
+else
+nbouttmp = 2;
+nbintmp = 3;
+is_break = 1;
+}
+intmp[nbintmp++] = cur;
+/*
+* if intmp is full, push the 4byte sequence as a 3 byte
+* sequence out
+*/
+if (nbintmp == 4) {
+nbintmp = 0;
+outtmp[0] = (intmp[0] << 2) | ((intmp[1] & 0x30) >> 4);
+outtmp[1] =
+((intmp[1] & 0x0F) << 4) | ((intmp[2] & 0x3C) >> 2);
+outtmp[2] = ((intmp[2] & 0x03) << 6) | (intmp[3] & 0x3F);
+if (outcur + 3 >= outmax) {
+retval = 2;
+break;
+}
+for (i = 0; i < nbouttmp; i++)
+to[outcur++] = outtmp[i];
+inblk = incur;
+}
+if (is_break) {
+retval = 0;
+break;
+}
+}
+}
+*tolen = outcur;
+*inlen = inblk;
+return (retval);
+}
+/*
+* Test routine for the xmlBase64Decode function
+*/
+#if 0
+int main(int argc, char **argv) {
+char *input = "  VW4 gcGV0        \n      aXQgdGVzdCAuCg== ";
+char output[100];
+char output2[100];
+char output3[100];
+unsigned long inlen = strlen(input);
+unsigned long outlen = 100;
+int ret;
+unsigned long cons, tmp, tmp2, prod;
+/*
+* Direct
+*/
+ret = xmlBase64Decode(input, &inlen, output, &outlen);
+output[outlen] = 0;
+printf("ret: %d, inlen: %ld , outlen: %ld, output: '%s'\n", ret, inlen, outlen, output);
+/*
+* output chunking
+*/
+cons = 0;
+prod = 0;
+while (cons < inlen) {
+tmp = 5;
+tmp2 = inlen - cons;
+printf("%ld %ld\n", cons, prod);
+ret = xmlBase64Decode(&input[cons], &tmp2, &output2[prod], &tmp);
+cons += tmp2;
+prod += tmp;
+printf("%ld %ld\n", cons, prod);
+}
+output2[outlen] = 0;
+printf("ret: %d, cons: %ld , prod: %ld, output: '%s'\n", ret, cons, prod, output2);
+/*
+* input chunking
+*/
+cons = 0;
+prod = 0;
+while (cons < inlen) {
+tmp = 100 - prod;
+tmp2 = inlen - cons;
+if (tmp2 > 5)
+tmp2 = 5;
+printf("%ld %ld\n", cons, prod);
+ret = xmlBase64Decode(&input[cons], &tmp2, &output3[prod], &tmp);
+cons += tmp2;
+prod += tmp;
+printf("%ld %ld\n", cons, prod);
+}
+output3[outlen] = 0;
+printf("ret: %d, cons: %ld , prod: %ld, output: '%s'\n", ret, cons, prod, output3);
+return(0);
+}
+#endif
+#endif /* NOT_USED_YET */
+//#define bottom_xmlreader
+//#include "elfgcchack.h"
+#endif /* LIBXML_READER_ENABLED */