Paul Cercueil
/
libxml2
Important changes to repositories hosted on mbed.com
Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.
To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.
It is also possible to export all your personal repositories from the account settings page.
Diff: xmlreader.c
- Revision:
- 0:03b5121a232e
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/xmlreader.c Thu Aug 25 10:05:35 2016 +0000
@@ -0,0 +1,5951 @@
+/*
+ * 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
+ */
+
+/*
+ * TODOs:
+ * - XML Schemas validation
+ */
+#define IN_LIBXML
+#include "libxml.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 <libxml/xmlmemory.h>
+#include <libxml/xmlIO.h>
+#include <libxml/xmlreader.h>
+#include <libxml/parserInternals.h>
+#ifdef LIBXML_SCHEMAS_ENABLED
+#include <libxml/relaxng.h>
+#include <libxml/xmlschemas.h>
+#endif
+#include <libxml/uri.h>
+#ifdef LIBXML_XINCLUDE_ENABLED
+#include <libxml/xinclude.h>
+#endif
+#ifdef LIBXML_PATTERN_ENABLED
+#include <libxml/pattern.h>
+#endif
+
+#include "buf.h"
+
+#define MAX_ERR_MSG_SIZE 64000
+
+/*
+ * The following VA_COPY was coded following an example in
+ * the Samba project. It may not be sufficient for some
+ * esoteric implementations of va_list but (hopefully) will
+ * be sufficient for libxml2.
+ */
+#ifndef VA_COPY
+ #ifdef HAVE_VA_COPY
+ #define VA_COPY(dest, src) va_copy(dest, src)
+ #else
+ #ifdef HAVE___VA_COPY
+ #define VA_COPY(dest,src) __va_copy(dest, src)
+ #else
+ #ifndef VA_LIST_IS_ARRAY
+ #define VA_COPY(dest,src) (dest) = (src)
+ #else
+ #include <string.h>
+ #define VA_COPY(dest,src) memcpy((char *)(dest),(char *)(src),sizeof(va_list))
+ #endif
+ #endif
+ #endif
+#endif
+
+/* #define DEBUG_CALLBACKS */
+/* #define DEBUG_READER */
+
+/**
+ * TODO:
+ *
+ * macro to flag unimplemented blocks
+ */
+#define TODO \
+ xmlGenericError(xmlGenericErrorContext, \
+ "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
+
+typedef enum {
+ XML_TEXTREADER_NONE = -1,
+ XML_TEXTREADER_START= 0,
+ XML_TEXTREADER_ELEMENT= 1,
+ XML_TEXTREADER_END= 2,
+ XML_TEXTREADER_EMPTY= 3,
+ XML_TEXTREADER_BACKTRACK= 4,
+ XML_TEXTREADER_DONE= 5,
+ XML_TEXTREADER_ERROR= 6
+} xmlTextReaderState;
+
+typedef enum {
+ XML_TEXTREADER_NOT_VALIDATE = 0,
+ XML_TEXTREADER_VALIDATE_DTD = 1,
+ XML_TEXTREADER_VALIDATE_RNG = 2,
+ XML_TEXTREADER_VALIDATE_XSD = 4
+} xmlTextReaderValidate;
+
+struct _xmlTextReader {
+ int mode; /* the parsing mode */
+ xmlDocPtr doc; /* when walking an existing doc */
+ xmlTextReaderValidate validate;/* is there any validation */
+ int allocs; /* what structure were deallocated */
+ xmlTextReaderState state;
+ xmlParserCtxtPtr ctxt; /* the parser context */
+ xmlSAXHandlerPtr sax; /* the parser SAX callbacks */
+ xmlParserInputBufferPtr input; /* the input */
+ startElementSAXFunc startElement;/* initial SAX callbacks */
+ endElementSAXFunc endElement; /* idem */
+ startElementNsSAX2Func startElementNs;/* idem */
+ endElementNsSAX2Func endElementNs; /* idem */
+ charactersSAXFunc characters;
+ cdataBlockSAXFunc cdataBlock;
+ unsigned int base; /* base of the segment in the input */
+ unsigned int cur; /* current position in the input */
+ xmlNodePtr node; /* current node */
+ xmlNodePtr curnode;/* current attribute node */
+ int depth; /* depth of the current node */
+ xmlNodePtr faketext;/* fake xmlNs chld */
+ int preserve;/* preserve the resulting document */
+ xmlBufPtr buffer; /* used to return const xmlChar * */
+ xmlDictPtr dict; /* the context dictionnary */
+
+ /* entity stack when traversing entities content */
+ xmlNodePtr ent; /* Current Entity Ref Node */
+ int entNr; /* Depth of the entities stack */
+ int entMax; /* Max depth of the entities stack */
+ xmlNodePtr *entTab; /* array of entities */
+
+ /* error handling */
+ xmlTextReaderErrorFunc errorFunc; /* callback function */
+ void *errorFuncArg; /* callback function user argument */
+
+#ifdef LIBXML_SCHEMAS_ENABLED
+ /* Handling of RelaxNG validation */
+ xmlRelaxNGPtr rngSchemas; /* The Relax NG schemas */
+ xmlRelaxNGValidCtxtPtr rngValidCtxt;/* The Relax NG validation context */
+ int rngPreserveCtxt; /* 1 if the context was provided by the user */
+ int rngValidErrors;/* The number of errors detected */
+ xmlNodePtr rngFullNode; /* the node if RNG not progressive */
+ /* Handling of Schemas validation */
+ xmlSchemaPtr xsdSchemas; /* The Schemas schemas */
+ xmlSchemaValidCtxtPtr xsdValidCtxt;/* The Schemas validation context */
+ int xsdPreserveCtxt; /* 1 if the context was provided by the user */
+ int xsdValidErrors;/* The number of errors detected */
+ xmlSchemaSAXPlugPtr xsdPlug; /* the schemas plug in SAX pipeline */
+#endif
+#ifdef LIBXML_XINCLUDE_ENABLED
+ /* Handling of XInclude processing */
+ int xinclude; /* is xinclude asked for */
+ const xmlChar * xinclude_name; /* the xinclude name from dict */
+ xmlXIncludeCtxtPtr xincctxt; /* the xinclude context */
+ int in_xinclude; /* counts for xinclude */
+#endif
+#ifdef LIBXML_PATTERN_ENABLED
+ int patternNr; /* number of preserve patterns */
+ int patternMax; /* max preserve patterns */
+ xmlPatternPtr *patternTab; /* array of preserve patterns */
+#endif
+ int preserves; /* level of preserves */
+ int parserFlags; /* the set of options set */
+ /* Structured error handling */
+ xmlStructuredErrorFunc sErrorFunc; /* callback function */
+};
+
+#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:
+ * @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:
+ * @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:
+ * @doc: the document
+ * @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 == NULL) return(-1);
+ if (attr == NULL) return(-1);
+ table = (xmlIDTablePtr) doc->ids;
+ if (table == 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:
+ * @reader: the xmlTextReaderPtr used
+ * @cur: the node
+ *
+ * Free a node.
+ */
+static void
+xmlTextReaderFreeProp(xmlTextReaderPtr reader, xmlAttrPtr cur) {
+ xmlDictPtr dict;
+
+ if ((reader != NULL) && (reader->ctxt != NULL))
+ dict = reader->ctxt->dict;
+ else
+ dict = NULL;
+ 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:
+ * @reader: the xmlTextReaderPtr used
+ * @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;
+
+ while (cur != NULL) {
+ next = cur->next;
+ xmlTextReaderFreeProp(reader, cur);
+ cur = next;
+ }
+}
+
+/**
+ * xmlTextReaderFreeNodeList:
+ * @reader: the xmlTextReaderPtr used
+ * @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;
+
+ if ((reader != NULL) && (reader->ctxt != NULL))
+ dict = reader->ctxt->dict;
+ else
+ dict = NULL;
+ 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 != NULL) {
+ 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->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 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);
+ }
+ }
+ cur = next;
+ }
+}
+
+/**
+ * xmlTextReaderFreeNode:
+ * @reader: the xmlTextReaderPtr used
+ * @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;
+
+ if ((reader != NULL) && (reader->ctxt != NULL))
+ dict = reader->ctxt->dict;
+ else
+ dict = NULL;
+ 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 != 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->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:
+ * @table: An id table
+ *
+ * Deallocate the memory used by an ID hash table.
+ */
+static void
+xmlTextReaderFreeIDTable(xmlIDTablePtr table) {
+ xmlHashFree(table, (xmlHashDeallocator) xmlFreeID);
+}
+
+/**
+ * xmlTextReaderFreeDoc:
+ * @reader: the xmlTextReaderPtr used
+ * @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;
+
+ 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:
+ * @reader: the xmlTextReaderPtr used
+ * @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) {
+ reader->entMax = 10;
+ reader->entTab = (xmlNodePtr *) xmlMalloc(reader->entMax *
+ sizeof(reader->entTab[0]));
+ if (reader->entTab == NULL) {
+ xmlGenericError(xmlGenericErrorContext, "xmlMalloc failed !\n");
+ return (0);
+ }
+ }
+ if (reader->entNr >= reader->entMax) {
+ reader->entMax *= 2;
+ reader->entTab =
+ (xmlNodePtr *) xmlRealloc(reader->entTab,
+ reader->entMax *
+ sizeof(reader->entTab[0]));
+ if (reader->entTab == NULL) {
+ xmlGenericError(xmlGenericErrorContext, "xmlRealloc failed !\n");
+ return (0);
+ }
+ }
+ reader->entTab[reader->entNr] = value;
+ reader->ent = value;
+ return (reader->entNr++);
+}
+
+/**
+ * xmlTextReaderEntPop:
+ * @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:
+ * @ctx: the user data (XML parser context)
+ * @fullname: The element name, including namespace prefix
+ * @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:
+ * @ctx: the user data (XML parser context)
+ * @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:
+ * @ctx: the user data (XML parser context)
+ * @localname: the local name of the element
+ * @prefix: the element namespace prefix if available
+ * @URI: the element namespace name if available
+ * @nb_namespaces: number of namespace definitions on that node
+ * @namespaces: pointer to the array of prefix/URI pairs namespace definitions
+ * @nb_attributes: the number of attributes on that node
+ * nb_defaulted: the number of defaulted attributes.
+ * @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:
+ * @ctx: the user data (XML parser context)
+ * @localname: the local name of the element
+ * @prefix: the element namespace prefix if available
+ * @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:
+ * @ctx: the user data (XML parser context)
+ * @ch: a xmlChar string
+ * @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:
+ * @ctx: the user data (XML parser context)
+ * @value: The pcdata content
+ * @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:
+ * @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) {
+ xmlBufPtr inbuf;
+ int val, s;
+ xmlTextReaderState oldstate;
+ int alloc;
+
+ if ((reader->input == NULL) || (reader->input->buffer == NULL))
+ return(-1);
+
+ oldstate = reader->state;
+ reader->state = XML_TEXTREADER_NONE;
+ inbuf = reader->input->buffer;
+ alloc = xmlBufGetAllocationScheme(inbuf);
+
+ while (reader->state == XML_TEXTREADER_NONE) {
+ if (xmlBufUse(inbuf) < 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) &&
+ (alloc == XML_BUFFER_ALLOC_IMMUTABLE)) {
+ if (xmlBufUse(inbuf) == 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 (xmlBufUse(inbuf) >= reader->cur + CHUNK_SIZE) {
+ val = xmlParseChunk(reader->ctxt,
+ (const char *) xmlBufContent(inbuf) + reader->cur,
+ CHUNK_SIZE, 0);
+ reader->cur += CHUNK_SIZE;
+ if (val != 0)
+ reader->ctxt->wellFormed = 0;
+ if (reader->ctxt->wellFormed == 0)
+ break;
+ } else {
+ s = xmlBufUse(inbuf) - reader->cur;
+ val = xmlParseChunk(reader->ctxt,
+ (const char *) xmlBufContent(inbuf) + reader->cur,
+ s, 0);
+ reader->cur += s;
+ if (val != 0)
+ reader->ctxt->wellFormed = 0;
+ break;
+ }
+ }
+
+ /*
+ * Discard the consumed input when needed and possible
+ */
+ if (reader->mode == XML_TEXTREADER_MODE_INTERACTIVE) {
+ if (alloc != XML_BUFFER_ALLOC_IMMUTABLE) {
+ if ((reader->cur >= 4096) &&
+ (xmlBufUse(inbuf) - reader->cur <= CHUNK_SIZE)) {
+ val = xmlBufShrink(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->state != XML_TEXTREADER_DONE) {
+ s = xmlBufUse(inbuf) - reader->cur;
+ val = xmlParseChunk(reader->ctxt,
+ (const char *) xmlBufContent(inbuf) + reader->cur,
+ s, 1);
+ reader->cur = xmlBufUse(inbuf);
+ reader->state = XML_TEXTREADER_DONE;
+ if (val != 0) {
+ if (reader->ctxt->wellFormed)
+ reader->ctxt->wellFormed = 0;
+ else
+ return(-1);
+ }
+ }
+ }
+ reader->state = oldstate;
+ if (reader->ctxt->wellFormed == 0) {
+ reader->mode = XML_TEXTREADER_MODE_EOF;
+ return(-1);
+ }
+
+ return(0);
+}
+
+#ifdef LIBXML_REGEXP_ENABLED
+/**
+ * xmlTextReaderValidatePush:
+ * @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 {
+ /* TODO use the BuildQName interface */
+ 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("Expand failed !\n");
+ ret = -1;
+ } else {
+ ret = xmlRelaxNGValidateFullElement(reader->rngValidCtxt,
+ reader->ctxt->myDoc,
+ node);
+ reader->rngFullNode = node;
+ }
+ }
+ if (ret != 1)
+ reader->rngValidErrors++;
+ }
+#endif
+}
+
+/**
+ * xmlTextReaderValidateCData:
+ * @reader: the xmlTextReaderPtr used
+ * @data: pointer to the CData
+ * @len: length 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:
+ * @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 {
+ /* TODO use the BuildQName interface */
+ 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:
+ * @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:
+ * @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) break;
+ if (cur->next != NULL) return(cur->next);
+ } while (cur != NULL);
+ return(cur);
+}
+
+/**
+ * xmlTextReaderDoExpand:
+ * @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){
+ reader->mode = XML_TEXTREADER_MODE_ERROR;
+ return(-1);
+ }
+ } while(reader->mode != XML_TEXTREADER_MODE_EOF);
+ return(1);
+}
+
+/**
+ * xmlTextReaderCollectSiblings:
+ * @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;
+
+ if ((node == NULL) || (node->type == XML_NAMESPACE_DECL))
+ return(NULL);
+
+ 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:
+ * @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
+ */
+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);
+
+#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){
+ reader->mode = XML_TEXTREADER_MODE_ERROR;
+ reader->state = XML_TEXTREADER_ERROR;
+ return(-1);
+ }
+ } while ((reader->ctxt->node == NULL) &&
+ ((reader->mode != XML_TEXTREADER_MODE_EOF) &&
+ (reader->state != XML_TEXTREADER_DONE)));
+ if (reader->ctxt->node == NULL) {
+ if (reader->ctxt->myDoc != NULL) {
+ reader->node = reader->ctxt->myDoc->children;
+ }
+ if (reader->node == NULL){
+ reader->mode = XML_TEXTREADER_MODE_ERROR;
+ reader->state = XML_TEXTREADER_ERROR;
+ 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_MODE_EOF)
+ 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 != NULL) && (reader->node->next == NULL) &&
+ (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){
+ reader->mode = XML_TEXTREADER_MODE_ERROR;
+ reader->state = XML_TEXTREADER_ERROR;
+ return(-1);
+ }
+ if (reader->node == NULL)
+ goto node_end;
+ }
+ 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 != NULL) {
+ 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)) {
+ xmlNodePtr tmp = reader->node->prev;
+ if ((tmp->extra & NODE_IS_PRESERVED) == 0) {
+ xmlUnlinkNode(tmp);
+ xmlTextReaderFreeNode(reader, tmp);
+ }
+ }
+
+ goto node_found;
+ }
+ 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 != XML_TEXTREADER_NOT_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_MODE_EOF) {
+ val = xmlParseChunk(reader->ctxt, "", 0, 1);
+ reader->state = XML_TEXTREADER_DONE;
+ if (val != 0)
+ return(-1);
+ }
+ reader->node = NULL;
+ reader->depth = -1;
+
+ /*
+ * Cleanup of the old node
+ */
+ if ((oldnode != NULL) && (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)) {
+ 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 & (~XML_PARSE_NOXINCNODE));
+ }
+ /*
+ * expand that node and process it
+ */
+ if (xmlTextReaderExpand(reader) == NULL)
+ return -1;
+ xmlXIncludeProcessNode(reader->xincctxt, reader->node);
+ }
+ if ((reader->node != NULL) && (reader->node->type == XML_XINCLUDE_START)) {
+ reader->in_xinclude++;
+ goto get_next_node;
+ }
+ if ((reader->node != NULL) && (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 != XML_TEXTREADER_NOT_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->state = XML_TEXTREADER_DONE;
+ return(0);
+}
+
+/**
+ * xmlTextReaderReadState:
+ * @reader: the xmlTextReaderPtr used
+ *
+ * Gets the read state of the reader.
+ *
+ * Returns the state value, or -1 in case of error
+ */
+int
+xmlTextReaderReadState(xmlTextReaderPtr reader) {
+ if (reader == NULL)
+ return(-1);
+ return(reader->mode);
+}
+
+/**
+ * xmlTextReaderExpand:
+ * @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.
+ */
+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:
+ * @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
+ */
+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));
+}
+
+#ifdef LIBXML_WRITER_ENABLED
+/**
+ * xmlTextReaderReadInnerXml:
+ * @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.
+ */
+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;
+ buff->content = NULL;
+
+ xmlBufferFree(buff);
+ return resbuf;
+}
+#endif
+
+#ifdef LIBXML_WRITER_ENABLED
+/**
+ * xmlTextReaderReadOuterXml:
+ * @reader: the xmlTextReaderPtr used
+ *
+ * Reads the contents of the current node, including child nodes and markup.
+ *
+ * Returns a string containing the node and any XML content, or NULL if the
+ * current node cannot be serialized. The string must be deallocated
+ * by the caller.
+ */
+xmlChar *
+xmlTextReaderReadOuterXml(xmlTextReaderPtr reader ATTRIBUTE_UNUSED)
+{
+ xmlChar *resbuf;
+ xmlNodePtr node;
+ xmlBufferPtr buff;
+ xmlDocPtr doc;
+
+ node = reader->node;
+ doc = reader->doc;
+ if (xmlTextReaderExpand(reader) == NULL) {
+ return NULL;
+ }
+ if (node->type == XML_DTD_NODE) {
+ node = (xmlNodePtr) xmlCopyDtd((xmlDtdPtr) node);
+ } else {
+ 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;
+}
+#endif
+
+/**
+ * xmlTextReaderReadString:
+ * @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.
+ */
+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);
+ }
+ break;
+ case XML_ATTRIBUTE_NODE:
+ TODO
+ break;
+ default:
+ break;
+ }
+ return(NULL);
+}
+
+#if 0
+/**
+ * xmlTextReaderReadBase64:
+ * @reader: the xmlTextReaderPtr used
+ * @array: a byte array to store the content.
+ * @offset: the zero-based index into array where the method should
+ * begin to write.
+ * @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:
+ * @reader: the xmlTextReaderPtr used
+ * @array: a byte array to store the content.
+ * @offset: the zero-based index into array where the method should
+ * begin to write.
+ * @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) {
+ /* Here removed traversal to child, because we want to skip the subtree,
+ replace with traversal to sibling to skip subtree */
+ if (reader->node->next != 0) {
+ /* Move to sibling if present,skipping sub-tree */
+ reader->node = reader->node->next;
+ reader->state = XML_TEXTREADER_START;
+ return(1);
+ }
+
+ /* if reader->node->next is NULL mean no subtree for current node,
+ so need to move to sibling of parent node if present */
+ if ((reader->node->type == XML_ELEMENT_NODE) ||
+ (reader->node->type == XML_ATTRIBUTE_NODE)) {
+ reader->state = XML_TEXTREADER_BACKTRACK;
+ /* This will move to parent if present */
+ xmlTextReaderRead(reader);
+ }
+ }
+
+ 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;
+ /* Repeat process to move to sibling of parent node if present */
+ xmlTextReaderNextTree(reader);
+ }
+
+ reader->state = XML_TEXTREADER_END;
+
+ return(1);
+}
+
+/**
+ * xmlTextReaderReadTree:
+ * @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:
+ * @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
+ */
+int
+xmlTextReaderNextSibling(xmlTextReaderPtr reader) {
+ if (reader == NULL)
+ return(-1);
+ if (reader->doc == NULL) {
+ /* TODO */
+ 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:
+ * @input: the xmlParserInputBufferPtr used to read data
+ * @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
+ */
+xmlTextReaderPtr
+xmlNewTextReader(xmlParserInputBufferPtr input, const char *URI) {
+ xmlTextReaderPtr ret;
+
+ if (input == NULL)
+ return(NULL);
+ ret = xmlMalloc(sizeof(xmlTextReader));
+ if (ret == NULL) {
+ xmlGenericError(xmlGenericErrorContext,
+ "xmlNewTextReader : malloc failed\n");
+ return(NULL);
+ }
+ memset(ret, 0, sizeof(xmlTextReader));
+ ret->doc = NULL;
+ ret->entTab = NULL;
+ ret->entMax = 0;
+ ret->entNr = 0;
+ ret->input = input;
+ ret->buffer = xmlBufCreateSize(100);
+ if (ret->buffer == NULL) {
+ xmlFree(ret);
+ xmlGenericError(xmlGenericErrorContext,
+ "xmlNewTextReader : malloc failed\n");
+ return(NULL);
+ }
+ /* no operation on a reader should require a huge buffer */
+ xmlBufSetAllocationScheme(ret->buffer,
+ XML_BUFFER_ALLOC_BOUNDED);
+ ret->sax = (xmlSAXHandler *) xmlMalloc(sizeof(xmlSAXHandler));
+ if (ret->sax == NULL) {
+ xmlBufFree(ret->buffer);
+ xmlFree(ret);
+ xmlGenericError(xmlGenericErrorContext,
+ "xmlNewTextReader : malloc failed\n");
+ return(NULL);
+ }
+ 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 (xmlBufUse(ret->input->buffer) < 4) {
+ xmlParserInputBufferRead(input, 4);
+ }
+ if (xmlBufUse(ret->input->buffer) >= 4) {
+ ret->ctxt = xmlCreatePushParserCtxt(ret->sax, NULL,
+ (const char *) xmlBufContent(ret->input->buffer),
+ 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 == NULL) {
+ xmlGenericError(xmlGenericErrorContext,
+ "xmlNewTextReader : malloc failed\n");
+ xmlBufFree(ret->buffer);
+ xmlFree(ret->sax);
+ xmlFree(ret);
+ return(NULL);
+ }
+ ret->ctxt->parseMode = XML_PARSE_READER;
+ ret->ctxt->_private = ret;
+ ret->ctxt->linenumbers = 1;
+ 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:
+ * @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
+ */
+xmlTextReaderPtr
+xmlNewTextReaderFilename(const char *URI) {
+ xmlParserInputBufferPtr input;
+ xmlTextReaderPtr ret;
+ char *directory = NULL;
+
+ input = xmlParserInputBufferCreateFilename(URI, XML_CHAR_ENCODING_NONE);
+ if (input == NULL)
+ return(NULL);
+ ret = xmlNewTextReader(input, URI);
+ if (ret == NULL) {
+ xmlFreeParserInputBuffer(input);
+ return(NULL);
+ }
+ ret->allocs |= XML_TEXTREADER_INPUT;
+ if (ret->ctxt->directory == NULL)
+ directory = xmlParserGetDirectory(URI);
+ if ((ret->ctxt->directory == NULL) && (directory != NULL))
+ ret->ctxt->directory = (char *) xmlStrdup((xmlChar *) directory);
+ if (directory != NULL)
+ xmlFree(directory);
+ return(ret);
+}
+
+/**
+ * xmlFreeTextReader:
+ * @reader: the xmlTextReaderPtr
+ *
+ * Deallocate all the resources associated to the reader
+ */
+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) {
+ if (! reader->rngPreserveCtxt)
+ xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
+ reader->rngValidCtxt = NULL;
+ }
+ if (reader->xsdPlug != NULL) {
+ xmlSchemaSAXUnplug(reader->xsdPlug);
+ reader->xsdPlug = NULL;
+ }
+ if (reader->xsdValidCtxt != NULL) {
+ if (! reader->xsdPreserveCtxt)
+ 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->faketext != NULL) {
+ xmlFreeNode(reader->faketext);
+ }
+ 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->buffer != NULL)
+ xmlBufFree(reader->buffer);
+ if (reader->entTab != NULL)
+ xmlFree(reader->entTab);
+ if (reader->dict != NULL)
+ xmlDictFree(reader->dict);
+ xmlFree(reader);
+}
+
+/************************************************************************
+ * *
+ * Methods for XmlTextReader *
+ * *
+ ************************************************************************/
+/**
+ * xmlTextReaderClose:
+ * @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
+ */
+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:
+ * @reader: the xmlTextReaderPtr used
+ * @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.
+ */
+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);
+ /* TODO: handle the xmlDecl */
+ 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);
+ }
+ /* TODO walk the DTD if present */
+
+ ret = xmlNodeListGetString(reader->node->doc, cur->children, 1);
+ if (ret == NULL) return(xmlStrdup((xmlChar *)""));
+ return(ret);
+}
+
+/**
+ * xmlTextReaderGetAttribute:
+ * @reader: the xmlTextReaderPtr used
+ * @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.
+ */
+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);
+
+ /* TODO: handle the xmlDecl */
+ 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:
+ * @reader: the xmlTextReaderPtr used
+ * @localName: the local name of the attribute.
+ * @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.
+ */
+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);
+
+ /* TODO: handle the xmlDecl */
+ 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:
+ * @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 procgressed 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.
+ */
+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:
+ * @reader: the xmlTextReaderPtr used
+ * @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.
+ */
+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:
+ * @reader: the xmlTextReaderPtr used
+ * @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
+ */
+int
+xmlTextReaderMoveToAttributeNo(xmlTextReaderPtr reader, int no) {
+ int i;
+ xmlAttrPtr cur;
+ xmlNsPtr ns;
+
+ if (reader == NULL)
+ return(-1);
+ if (reader->node == NULL)
+ return(-1);
+ /* TODO: handle the xmlDecl */
+ 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);
+ }
+ /* TODO walk the DTD if present */
+
+ reader->curnode = (xmlNodePtr) cur;
+ return(1);
+}
+
+/**
+ * xmlTextReaderMoveToAttribute:
+ * @reader: the xmlTextReaderPtr used
+ * @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
+ */
+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);
+
+ /* TODO: handle the xmlDecl */
+ 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:
+ * @reader: the xmlTextReaderPtr used
+ * @localName: the local name of the attribute.
+ * @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
+ */
+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:
+ * @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
+ */
+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:
+ * @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
+ */
+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:
+ * @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
+ */
+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:
+ * @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.
+ */
+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:
+ * @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.
+ */
+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));
+}
+
+
+/************************************************************************
+ * *
+ * Acces API to the current node *
+ * *
+ ************************************************************************/
+/**
+ * xmlTextReaderAttributeCount:
+ * @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
+ */
+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:
+ * @reader: the xmlTextReaderPtr used
+ *
+ * Get the node type of the current node
+ * Reference:
+ * http://www.gnu.org/software/dotgnu/pnetlib-doc/System/Xml/XmlNodeType.html
+ *
+ * Returns the xmlNodeType of the current node or -1 in case of error
+ */
+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:
+ * @reader: the xmlTextReaderPtr used
+ *
+ * Check if the current node is empty
+ *
+ * Returns 1 if empty, 0 if not and -1 in case of error
+ */
+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:
+ * @reader: the xmlTextReaderPtr used
+ *
+ * The local name of the node.
+ *
+ * Returns the local name or NULL if not available,
+ * if non NULL it need to be freed by the caller.
+ */
+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:
+ * @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.
+ */
+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:
+ * @reader: the xmlTextReaderPtr used
+ *
+ * The qualified name of the node, equal to Prefix :LocalName.
+ *
+ * Returns the local name or NULL if not available,
+ * if non NULL it need to be freed by the caller.
+ */
+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:
+ * @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.
+ */
+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:
+ * @reader: the xmlTextReaderPtr used
+ *
+ * A shorthand reference to the namespace associated with the node.
+ *
+ * Returns the prefix or NULL if not available,
+ * if non NULL it need to be freed by the caller.
+ */
+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:
+ * @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.
+ */
+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:
+ * @reader: the xmlTextReaderPtr used
+ *
+ * The URI defining the namespace associated with the node.
+ *
+ * Returns the namespace URI or NULL if not available,
+ * if non NULL it need to be freed by the caller.
+ */
+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:
+ * @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
+ */
+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:
+ * @reader: the xmlTextReaderPtr used
+ *
+ * The base URI of the node.
+ *
+ * Returns the base URI or NULL if not available,
+ * if non NULL it need to be freed by the caller.
+ */
+xmlChar *
+xmlTextReaderBaseUri(xmlTextReaderPtr reader) {
+ if ((reader == NULL) || (reader->node == NULL))
+ return(NULL);
+ return(xmlNodeGetBase(NULL, reader->node));
+}
+
+/**
+ * xmlTextReaderConstBaseUri:
+ * @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
+ */
+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:
+ * @reader: the xmlTextReaderPtr used
+ *
+ * The depth of the node in the tree.
+ *
+ * Returns the depth or -1 in case of error
+ */
+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:
+ * @reader: the xmlTextReaderPtr used
+ *
+ * Whether the node has attributes.
+ *
+ * Returns 1 if true, 0 if false, and -1 in case or error
+ */
+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 != NULL) || (node->nsDef != NULL)))
+ return(1);
+ /* TODO: handle the xmlDecl */
+ return(0);
+}
+
+/**
+ * xmlTextReaderHasValue:
+ * @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
+ */
+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:
+ * @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()
+ */
+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));
+ break;
+ }
+ 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:
+ * @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.
+ */
+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;
+ const xmlChar *ret;
+
+ if ((attr->children != NULL) &&
+ (attr->children->type == XML_TEXT_NODE) &&
+ (attr->children->next == NULL))
+ return(attr->children->content);
+ else {
+ if (reader->buffer == NULL) {
+ reader->buffer = xmlBufCreateSize(100);
+ if (reader->buffer == NULL) {
+ xmlGenericError(xmlGenericErrorContext,
+ "xmlTextReaderSetup : malloc failed\n");
+ return (NULL);
+ }
+ xmlBufSetAllocationScheme(reader->buffer,
+ XML_BUFFER_ALLOC_BOUNDED);
+ } else
+ xmlBufEmpty(reader->buffer);
+ xmlBufGetNodeContent(reader->buffer, node);
+ ret = xmlBufContent(reader->buffer);
+ if (ret == NULL) {
+ /* error on the buffer best to reallocate */
+ xmlBufFree(reader->buffer);
+ reader->buffer = xmlBufCreateSize(100);
+ xmlBufSetAllocationScheme(reader->buffer,
+ XML_BUFFER_ALLOC_BOUNDED);
+ ret = BAD_CAST "";
+ }
+ return(ret);
+ }
+ break;
+ }
+ 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:
+ * @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
+ */
+int
+xmlTextReaderIsDefault(xmlTextReaderPtr reader) {
+ if (reader == NULL)
+ return(-1);
+ return(0);
+}
+
+/**
+ * xmlTextReaderQuoteChar:
+ * @reader: the xmlTextReaderPtr used
+ *
+ * The quotation mark character used to enclose the value of an attribute.
+ *
+ * Returns " or ' and -1 in case of error
+ */
+int
+xmlTextReaderQuoteChar(xmlTextReaderPtr reader) {
+ if (reader == NULL)
+ return(-1);
+ /* TODO maybe lookup the attribute value for " first */
+ return((int) '"');
+}
+
+/**
+ * xmlTextReaderXmlLang:
+ * @reader: the xmlTextReaderPtr used
+ *
+ * The xml:lang scope within which the node resides.
+ *
+ * Returns the xml:lang value or NULL if none exists.,
+ * if non NULL it need to be freed by the caller.
+ */
+xmlChar *
+xmlTextReaderXmlLang(xmlTextReaderPtr reader) {
+ if (reader == NULL)
+ return(NULL);
+ if (reader->node == NULL)
+ return(NULL);
+ return(xmlNodeGetLang(reader->node));
+}
+
+/**
+ * xmlTextReaderConstXmlLang:
+ * @reader: the xmlTextReaderPtr used
+ *
+ * The xml:lang scope within which the node resides.
+ *
+ * Returns the xml:lang value or NULL if none exists.
+ */
+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:
+ * @reader: the xmlTextReaderPtr used
+ * @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.
+ */
+const xmlChar *
+xmlTextReaderConstString(xmlTextReaderPtr reader, const xmlChar *str) {
+ if (reader == NULL)
+ return(NULL);
+ return(CONSTSTR(str));
+}
+
+/**
+ * xmlTextReaderNormalization:
+ * @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 � is of course not
+ * supported either.
+ *
+ * Returns 1 or -1 in case of error.
+ */
+int
+xmlTextReaderNormalization(xmlTextReaderPtr reader) {
+ if (reader == NULL)
+ return(-1);
+ return(1);
+}
+
+/************************************************************************
+ * *
+ * Extensions to the base APIs *
+ * *
+ ************************************************************************/
+
+/**
+ * xmlTextReaderSetParserProp:
+ * @reader: the xmlTextReaderPtr used
+ * @prop: the xmlParserProperties to set
+ * @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
+ */
+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:
+ * @reader: the xmlTextReaderPtr used
+ * @prop: the xmlParserProperties to get
+ *
+ * Read the parser internal property.
+ *
+ * Returns the value, usually 0 or 1, or -1 in case of error.
+ */
+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:
+ * @reader: the user data (XML reader context)
+ *
+ * Provide the line number of the current parsing point.
+ *
+ * Returns an int or 0 if not available
+ */
+int
+xmlTextReaderGetParserLineNumber(xmlTextReaderPtr reader)
+{
+ if ((reader == NULL) || (reader->ctxt == NULL) ||
+ (reader->ctxt->input == NULL)) {
+ return (0);
+ }
+ return (reader->ctxt->input->line);
+}
+
+/**
+ * xmlTextReaderGetParserColumnNumber:
+ * @reader: the user data (XML reader context)
+ *
+ * Provide the column number of the current parsing point.
+ *
+ * Returns an int or 0 if not available
+ */
+int
+xmlTextReaderGetParserColumnNumber(xmlTextReaderPtr reader)
+{
+ if ((reader == NULL) || (reader->ctxt == NULL) ||
+ (reader->ctxt->input == NULL)) {
+ return (0);
+ }
+ return (reader->ctxt->input->col);
+}
+
+/**
+ * xmlTextReaderCurrentNode:
+ * @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.
+ */
+xmlNodePtr
+xmlTextReaderCurrentNode(xmlTextReaderPtr reader) {
+ if (reader == NULL)
+ return(NULL);
+
+ if (reader->curnode != NULL)
+ return(reader->curnode);
+ return(reader->node);
+}
+
+/**
+ * xmlTextReaderPreserve:
+ * @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.
+ */
+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:
+ * @reader: the xmlTextReaderPtr used
+ * @pattern: an XPath subset pattern
+ * @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, "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, "xmlRealloc failed !\n");
+ reader->patternMax /= 2;
+ return (-1);
+ }
+ reader->patternTab = tmp;
+ }
+ reader->patternTab[reader->patternNr] = comp;
+ return(reader->patternNr++);
+}
+#endif
+
+/**
+ * xmlTextReaderCurrentDoc:
+ * @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.
+ */
+xmlDocPtr
+xmlTextReaderCurrentDoc(xmlTextReaderPtr reader) {
+ if (reader == NULL)
+ return(NULL);
+ if (reader->doc != NULL)
+ return(reader->doc);
+ if ((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:
+ * @reader: the xmlTextReaderPtr used
+ * @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) {
+ if (! reader->rngPreserveCtxt)
+ xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
+ reader->rngValidCtxt = NULL;
+ }
+ reader->rngPreserveCtxt = 0;
+ 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) {
+ if (! reader->rngPreserveCtxt)
+ xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
+ reader->rngValidCtxt = NULL;
+ }
+ reader->rngPreserveCtxt = 0;
+ 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);
+}
+
+/**
+ * xmlTextReaderLocator:
+ * @ctx: the xmlTextReaderPtr used
+ * @file: returned file information
+ * @line: returned line information
+ *
+ * Internal locator function for the readers
+ *
+ * Returns 0 in case the Schema validation could be (des)activated and
+ * -1 in case of error.
+ */
+static int
+xmlTextReaderLocator(void *ctx, const char **file, unsigned long *line) {
+ xmlTextReaderPtr reader;
+
+ if ((ctx == NULL) || ((file == NULL) && (line == NULL)))
+ return(-1);
+
+ if (file != NULL)
+ *file = NULL;
+ if (line != NULL)
+ *line = 0;
+
+ reader = (xmlTextReaderPtr) ctx;
+ if ((reader->ctxt != NULL) && (reader->ctxt->input != NULL)) {
+ if (file != NULL)
+ *file = reader->ctxt->input->filename;
+ if (line != NULL)
+ *line = reader->ctxt->input->line;
+ return(0);
+ }
+ if (reader->node != NULL) {
+ long res;
+ int ret = 0;
+
+ if (line != NULL) {
+ res = xmlGetLineNo(reader->node);
+ if (res > 0)
+ *line = (unsigned long) res;
+ else
+ ret = -1;
+ }
+ if (file != NULL) {
+ xmlDocPtr doc = reader->node->doc;
+ if ((doc != NULL) && (doc->URL != NULL))
+ *file = (const char *) doc->URL;
+ else
+ ret = -1;
+ }
+ return(ret);
+ }
+ return(-1);
+}
+
+/**
+ * xmlTextReaderSetSchema:
+ * @reader: the xmlTextReaderPtr used
+ * @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) {
+ if (! reader->xsdPreserveCtxt)
+ xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
+ reader->xsdValidCtxt = NULL;
+ }
+ reader->xsdPreserveCtxt = 0;
+ 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) {
+ if (! reader->xsdPreserveCtxt)
+ xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
+ reader->xsdValidCtxt = NULL;
+ }
+ reader->xsdPreserveCtxt = 0;
+ 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);
+ }
+ xmlSchemaValidateSetLocator(reader->xsdValidCtxt,
+ xmlTextReaderLocator,
+ (void *) reader);
+
+ 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);
+}
+
+/**
+ * xmlTextReaderRelaxNGValidateInternal:
+ * @reader: the xmlTextReaderPtr used
+ * @rng: the path to a RelaxNG schema or NULL
+ * @ctxt: the RelaxNG schema validation context or NULL
+ * @options: options (not yet used)
+ *
+ * Use RelaxNG to validate the document as it is processed.
+ * Activation is only possible before the first Read().
+ * If both @rng and @ctxt are NULL, then RelaxNG validation is deactivated.
+ *
+ * Returns 0 in case the RelaxNG validation could be (de)activated and
+ * -1 in case of error.
+ */
+static int
+xmlTextReaderRelaxNGValidateInternal(xmlTextReaderPtr reader,
+ const char *rng,
+ xmlRelaxNGValidCtxtPtr ctxt,
+ int options ATTRIBUTE_UNUSED)
+{
+ if (reader == NULL)
+ return(-1);
+
+ if ((rng != NULL) && (ctxt != NULL))
+ return (-1);
+
+ if (((rng != NULL) || (ctxt != NULL)) &&
+ ((reader->mode != XML_TEXTREADER_MODE_INITIAL) ||
+ (reader->ctxt == NULL)))
+ return(-1);
+
+ /* Cleanup previous validation stuff. */
+ if (reader->rngValidCtxt != NULL) {
+ if ( !reader->rngPreserveCtxt)
+ xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
+ reader->rngValidCtxt = NULL;
+ }
+ reader->rngPreserveCtxt = 0;
+ if (reader->rngSchemas != NULL) {
+ xmlRelaxNGFree(reader->rngSchemas);
+ reader->rngSchemas = NULL;
+ }
+
+ if ((rng == NULL) && (ctxt == NULL)) {
+ /* We just want to deactivate the validation, so get out. */
+ return(0);
+ }
+
+
+ if (rng != NULL) {
+ xmlRelaxNGParserCtxtPtr pctxt;
+ /* Parse the schema and create validation environment. */
+
+ pctxt = xmlRelaxNGNewParserCtxt(rng);
+ if (reader->errorFunc != NULL) {
+ xmlRelaxNGSetParserErrors(pctxt,
+ xmlTextReaderValidityErrorRelay,
+ xmlTextReaderValidityWarningRelay,
+ reader);
+ }
+ if (reader->sErrorFunc != NULL) {
+ xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt,
+ xmlTextReaderValidityStructuredRelay,
+ reader);
+ }
+ reader->rngSchemas = xmlRelaxNGParse(pctxt);
+ xmlRelaxNGFreeParserCtxt(pctxt);
+ if (reader->rngSchemas == NULL)
+ return(-1);
+ reader->rngValidCtxt = xmlRelaxNGNewValidCtxt(reader->rngSchemas);
+ if (reader->rngValidCtxt == NULL) {
+ xmlRelaxNGFree(reader->rngSchemas);
+ reader->rngSchemas = NULL;
+ return(-1);
+ }
+ } else {
+ /* Use the given validation context. */
+ reader->rngValidCtxt = ctxt;
+ reader->rngPreserveCtxt = 1;
+ }
+ /*
+ * Redirect the validation context's error channels to use
+ * the reader channels.
+ * TODO: In case the user provides the validation context we
+ * could make this redirection optional.
+ */
+ 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);
+}
+
+/**
+ * xmlTextReaderSchemaValidateInternal:
+ * @reader: the xmlTextReaderPtr used
+ * @xsd: the path to a W3C XSD schema or NULL
+ * @ctxt: the XML Schema validation context or NULL
+ * @options: options (not used yet)
+ *
+ * Validate the document as it is processed using XML Schema.
+ * Activation is only possible before the first Read().
+ * If both @xsd and @ctxt are NULL then XML Schema validation is deactivated.
+ *
+ * Returns 0 in case the schemas validation could be (de)activated and
+ * -1 in case of error.
+ */
+static int
+xmlTextReaderSchemaValidateInternal(xmlTextReaderPtr reader,
+ const char *xsd,
+ xmlSchemaValidCtxtPtr ctxt,
+ int options ATTRIBUTE_UNUSED)
+{
+ if (reader == NULL)
+ return(-1);
+
+ if ((xsd != NULL) && (ctxt != NULL))
+ return(-1);
+
+ if (((xsd != NULL) || (ctxt != NULL)) &&
+ ((reader->mode != XML_TEXTREADER_MODE_INITIAL) ||
+ (reader->ctxt == NULL)))
+ return(-1);
+
+ /* Cleanup previous validation stuff. */
+ if (reader->xsdPlug != NULL) {
+ xmlSchemaSAXUnplug(reader->xsdPlug);
+ reader->xsdPlug = NULL;
+ }
+ if (reader->xsdValidCtxt != NULL) {
+ if (! reader->xsdPreserveCtxt)
+ xmlSchemaFreeValidCtxt(reader->xsdValidCtxt);
+ reader->xsdValidCtxt = NULL;
+ }
+ reader->xsdPreserveCtxt = 0;
+ if (reader->xsdSchemas != NULL) {
+ xmlSchemaFree(reader->xsdSchemas);
+ reader->xsdSchemas = NULL;
+ }
+
+ if ((xsd == NULL) && (ctxt == NULL)) {
+ /* We just want to deactivate the validation, so get out. */
+ return(0);
+ }
+
+ if (xsd != NULL) {
+ xmlSchemaParserCtxtPtr pctxt;
+ /* Parse the schema and create validation environment. */
+ pctxt = xmlSchemaNewParserCtxt(xsd);
+ if (reader->errorFunc != NULL) {
+ xmlSchemaSetParserErrors(pctxt,
+ xmlTextReaderValidityErrorRelay,
+ xmlTextReaderValidityWarningRelay,
+ reader);
+ }
+ reader->xsdSchemas = xmlSchemaParse(pctxt);
+ xmlSchemaFreeParserCtxt(pctxt);
+ 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);
+ }
+ } else {
+ /* Use the given validation context. */
+ reader->xsdValidCtxt = ctxt;
+ reader->xsdPreserveCtxt = 1;
+ reader->xsdPlug = xmlSchemaSAXPlug(reader->xsdValidCtxt,
+ &(reader->ctxt->sax),
+ &(reader->ctxt->userData));
+ if (reader->xsdPlug == NULL) {
+ reader->xsdValidCtxt = NULL;
+ reader->xsdPreserveCtxt = 0;
+ return(-1);
+ }
+ }
+ xmlSchemaValidateSetLocator(reader->xsdValidCtxt,
+ xmlTextReaderLocator,
+ (void *) reader);
+ /*
+ * Redirect the validation context's error channels to use
+ * the reader channels.
+ * TODO: In case the user provides the validation context we
+ * could make this redirection optional.
+ */
+ 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);
+}
+
+/**
+ * xmlTextReaderSchemaValidateCtxt:
+ * @reader: the xmlTextReaderPtr used
+ * @ctxt: the XML Schema validation context or NULL
+ * @options: options (not used yet)
+ *
+ * Use W3C XSD schema context to validate the document as it is processed.
+ * Activation is only possible before the first Read().
+ * If @ctxt is NULL, then XML Schema validation is deactivated.
+ *
+ * Returns 0 in case the schemas validation could be (de)activated and
+ * -1 in case of error.
+ */
+int
+xmlTextReaderSchemaValidateCtxt(xmlTextReaderPtr reader,
+ xmlSchemaValidCtxtPtr ctxt,
+ int options)
+{
+ return(xmlTextReaderSchemaValidateInternal(reader, NULL, ctxt, options));
+}
+
+/**
+ * xmlTextReaderSchemaValidate:
+ * @reader: the xmlTextReaderPtr used
+ * @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 XML Schema validation is deactivated.
+ *
+ * Returns 0 in case the schemas validation could be (de)activated and
+ * -1 in case of error.
+ */
+int
+xmlTextReaderSchemaValidate(xmlTextReaderPtr reader, const char *xsd)
+{
+ return(xmlTextReaderSchemaValidateInternal(reader, xsd, NULL, 0));
+}
+
+/**
+ * xmlTextReaderRelaxNGValidateCtxt:
+ * @reader: the xmlTextReaderPtr used
+ * @ctxt: the RelaxNG schema validation context or NULL
+ * @options: options (not used yet)
+ *
+ * Use RelaxNG schema context to validate the document as it is processed.
+ * Activation is only possible before the first Read().
+ * If @ctxt is NULL, then RelaxNG schema validation is deactivated.
+ *
+ * Returns 0 in case the schemas validation could be (de)activated and
+ * -1 in case of error.
+ */
+int
+xmlTextReaderRelaxNGValidateCtxt(xmlTextReaderPtr reader,
+ xmlRelaxNGValidCtxtPtr ctxt,
+ int options)
+{
+ return(xmlTextReaderRelaxNGValidateInternal(reader, NULL, ctxt, options));
+}
+
+/**
+ * xmlTextReaderRelaxNGValidate:
+ * @reader: the xmlTextReaderPtr used
+ * @rng: the path to a RelaxNG schema or NULL
+ *
+ * Use RelaxNG schema to validate the document as it is processed.
+ * Activation is only possible before the first Read().
+ * If @rng is NULL, then RelaxNG schema validation is deactivated.
+ *
+ * Returns 0 in case the schemas validation could be (de)activated and
+ * -1 in case of error.
+ */
+int
+xmlTextReaderRelaxNGValidate(xmlTextReaderPtr reader, const char *rng)
+{
+ return(xmlTextReaderRelaxNGValidateInternal(reader, rng, NULL, 0));
+}
+
+#endif
+
+/**
+ * xmlTextReaderIsNamespaceDecl:
+ * @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.
+ */
+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:
+ * @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.
+ */
+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:
+ * @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.
+ */
+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 = 0;
+ int chars;
+ char *larger;
+ char *str = NULL;
+ va_list aq;
+
+ while (1) {
+ VA_COPY(aq, ap);
+ chars = vsnprintf(str, size, msg, aq);
+ va_end(aq);
+ if (chars < 0) {
+ xmlGenericError(xmlGenericErrorContext, "vsnprintf failed !\n");
+ if (str)
+ xmlFree(str);
+ return NULL;
+ }
+ if ((chars < size) || (size == MAX_ERR_MSG_SIZE))
+ break;
+ if (chars < MAX_ERR_MSG_SIZE)
+ size = chars + 1;
+ else
+ size = MAX_ERR_MSG_SIZE;
+ if ((larger = (char *) xmlRealloc(str, size)) == NULL) {
+ xmlGenericError(xmlGenericErrorContext, "xmlRealloc failed !\n");
+ if (str)
+ xmlFree(str);
+ return NULL;
+ }
+ str = larger;
+ }
+
+ return str;
+}
+
+/**
+ * xmlTextReaderLocatorLineNumber:
+ * @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;
+}
+
+/**
+ * xmlTextReaderLocatorBaseURI:
+ * @locator: the xmlTextReaderLocatorPtr used
+ *
+ * Obtain the base URI for the given locator.
+ *
+ * Returns the base URI or NULL in case of error,
+ * if non NULL it need to be freed by the caller.
+ */
+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);
+ 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:
+ * @reader: the xmlTextReaderPtr used
+ * @f: the callback function to call on error and warnings
+ * @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.
+ */
+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:
+ * @reader: the xmlTextReaderPtr used
+ * @f: the callback function to call on error and warnings
+ * @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.
+ */
+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:
+ * @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
+ */
+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:
+ * @reader: the xmlTextReaderPtr used
+ * @f: the callback function or NULL is no callback has been registered
+ * @arg: a user argument
+ *
+ * Retrieve the error callback function and user argument.
+ */
+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:
+ * @reader: an XML reader
+ * @input: xmlParserInputBufferPtr used to feed the reader, will
+ * be destroyed with it.
+ * @URL: the base URL to use for the document
+ * @encoding: the document encoding, or NULL
+ * @options: a combination of xmlParserOption
+ *
+ * Setup an XML reader with new options
+ *
+ * Returns 0 in case of success and -1 in case of error.
+ */
+int
+xmlTextReaderSetup(xmlTextReaderPtr reader,
+ xmlParserInputBufferPtr input, const char *URL,
+ const char *encoding, int options)
+{
+ if (reader == NULL) {
+ if (input != NULL)
+ xmlFreeParserInputBuffer(input);
+ return (-1);
+ }
+
+ /*
+ * we force the generation of compact text nodes on the reader
+ * since usr applications should never modify the tree
+ */
+ 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 = xmlBufCreateSize(100);
+ if (reader->buffer == NULL) {
+ xmlGenericError(xmlGenericErrorContext,
+ "xmlTextReaderSetup : malloc failed\n");
+ return (-1);
+ }
+ /* no operation on a reader should require a huge buffer */
+ xmlBufSetAllocationScheme(reader->buffer,
+ XML_BUFFER_ALLOC_BOUNDED);
+ if (reader->sax == NULL)
+ reader->sax = (xmlSAXHandler *) xmlMalloc(sizeof(xmlSAXHandler));
+ if (reader->sax == NULL) {
+ xmlGenericError(xmlGenericErrorContext,
+ "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 != NULL) {
+ if (xmlBufUse(reader->input->buffer) < 4) {
+ xmlParserInputBufferRead(input, 4);
+ }
+ if (reader->ctxt == NULL) {
+ if (xmlBufUse(reader->input->buffer) >= 4) {
+ reader->ctxt = xmlCreatePushParserCtxt(reader->sax, NULL,
+ (const char *) xmlBufContent(reader->input->buffer),
+ 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;
+ xmlBufResetInput(buf->buffer, inputStream);
+
+ inputPush(reader->ctxt, inputStream);
+ reader->cur = 0;
+ }
+ if (reader->ctxt == NULL) {
+ xmlGenericError(xmlGenericErrorContext,
+ "xmlTextReaderSetup : malloc failed\n");
+ return (-1);
+ }
+ }
+ 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;
+ reader->ctxt->linenumbers = 1;
+ 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:
+ * @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.
+ */
+long
+xmlTextReaderByteConsumed(xmlTextReaderPtr reader) {
+ if ((reader == NULL) || (reader->ctxt == NULL))
+ return(-1);
+ return(xmlByteConsumed(reader->ctxt));
+}
+
+
+/**
+ * xmlReaderWalker:
+ * @doc: a preparsed document
+ *
+ * Create an xmltextReader for a preparsed document.
+ *
+ * Returns the new reader or NULL in case of error.
+ */
+xmlTextReaderPtr
+xmlReaderWalker(xmlDocPtr doc)
+{
+ xmlTextReaderPtr ret;
+
+ if (doc == NULL)
+ return(NULL);
+
+ ret = xmlMalloc(sizeof(xmlTextReader));
+ if (ret == NULL) {
+ xmlGenericError(xmlGenericErrorContext,
+ "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:
+ * @cur: a pointer to a zero terminated string
+ * @URL: the base URL to use for the document
+ * @encoding: the document encoding, or NULL
+ * @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.
+ */
+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:
+ * @filename: a file or URL
+ * @encoding: the document encoding, or NULL
+ * @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.
+ */
+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:
+ * @buffer: a pointer to a char array
+ * @size: the size of the array
+ * @URL: the base URL to use for the document
+ * @encoding: the document encoding, or NULL
+ * @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.
+ */
+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:
+ * @fd: an open file descriptor
+ * @URL: the base URL to use for the document
+ * @encoding: the document encoding, or NULL
+ * @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.
+ */
+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:
+ * @ioread: an I/O read function
+ * @ioclose: an I/O close function
+ * @ioctx: an I/O handler
+ * @URL: the base URL to use for the document
+ * @encoding: the document encoding, or NULL
+ * @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.
+ */
+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) {
+ if (ioclose != NULL)
+ ioclose(ioctx);
+ 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:
+ * @reader: an XML reader
+ * @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
+ */
+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:
+ * @reader: an XML reader
+ * @cur: a pointer to a zero terminated string
+ * @URL: the base URL to use for the document
+ * @encoding: the document encoding, or NULL
+ * @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
+ */
+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:
+ * @reader: an XML reader
+ * @filename: a file or URL
+ * @encoding: the document encoding, or NULL
+ * @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
+ */
+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:
+ * @reader: an XML reader
+ * @buffer: a pointer to a char array
+ * @size: the size of the array
+ * @URL: the base URL to use for the document
+ * @encoding: the document encoding, or NULL
+ * @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
+ */
+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:
+ * @reader: an XML reader
+ * @fd: an open file descriptor
+ * @URL: the base URL to use for the document
+ * @encoding: the document encoding, or NULL
+ * @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
+ */
+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:
+ * @reader: an XML reader
+ * @ioread: an I/O read function
+ * @ioclose: an I/O close function
+ * @ioctx: an I/O handler
+ * @URL: the base URL to use for the document
+ * @encoding: the document encoding, or NULL
+ * @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
+ */
+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) {
+ if (ioclose != NULL)
+ ioclose(ioctx);
+ return (-1);
+ }
+ return (xmlTextReaderSetup(reader, input, URL, encoding, options));
+}
+
+/************************************************************************
+ * *
+ * Utilities *
+ * *
+ ************************************************************************/
+#ifdef NOT_USED_YET
+
+/**
+ * xmlBase64Decode:
+ * @in: the input buffer
+ * @inlen: the size of the input (in), the size read from it (out)
+ * @to: the output buffer
+ * @tolen: the size of the output (in), the size written to (out)
+ *
+ * Base64 decoder, reads from @in and save in @to
+ * TODO: tell jody when this is actually exported
+ *
+ * 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)indent: Standard input:179: Error:Unmatched #endif
+;
+
+ /*
+ * 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 */
+