Restoring authorship annotation for <wawaka@yandex-team.ru>. Commit 2 of 2.

1 files changed, 5879 insertions, 5879 deletions

diff --git a/contrib/libs/libxml/xmlreader.c b/contrib/libs/libxml/xmlreader.c
index b88b62d155..f3891e43af 100644
--- a/contrib/libs/libxml/xmlreader.c
+++ b/contrib/libs/libxml/xmlreader.c
@@ -1,371 +1,371 @@
-/* 
- * 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 * */ 
+/*
+ * 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 dictionary */
- 
-    /* 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 
- * 
+
+    /* 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" dictionary 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) 
+ * 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)
     if (id->name != NULL)
 	DICT_FREE(id->name)
-    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; 
+    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;
     attr->name = NULL;
-    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; 
+    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;
     xmlNodePtr parent;
-    xmlDictPtr dict; 
+    xmlDictPtr dict;
     size_t depth = 0;
- 
-    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; 
-    } 
+
+    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 (1) {
         while ((cur->type != XML_DTD_NODE) &&
                (cur->type != XML_ENTITY_REF_NODE) &&
@@ -375,50 +375,50 @@ xmlTextReaderFreeNodeList(xmlTextReaderPtr reader, xmlNodePtr cur) {
             depth += 1;
         }
 
-        next = cur->next; 
+        next = cur->next;
         parent = cur->parent;
 
-	/* unroll to speed up freeing the document */ 
-	if (cur->type != XML_DTD_NODE) { 
- 
-	    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); 
-	    } 
-	} 
+	/* unroll to speed up freeing the document */
+	if (cur->type != XML_DTD_NODE) {
+
+	    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);
+	    }
+	}
 
         if (next != NULL) {
 	    cur = next;
@@ -429,3240 +429,3240 @@ xmlTextReaderFreeNodeList(xmlTextReaderPtr reader, xmlNodePtr cur) {
             cur = parent;
             cur->children = NULL;
         }
-    } 
-} 
- 
-/** 
- * 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); 
-    } 
-} 
- 
+    }
+}
+
+/**
+ * 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);
+    }
+}
+
 static void
 xmlTextReaderFreeIDTableEntry(void *id, const xmlChar *name ATTRIBUTE_UNUSED) {
     xmlFreeID((xmlIDPtr) id);
 }
 
-/** 
- * xmlTextReaderFreeIDTable: 
- * @table:  An id table 
- * 
- * Deallocate the memory used by an ID hash table. 
- */ 
-static void 
-xmlTextReaderFreeIDTable(xmlIDTablePtr table) { 
+/**
+ * xmlTextReaderFreeIDTable:
+ * @table:  An id table
+ *
+ * Deallocate the memory used by an ID hash table.
+ */
+static void
+xmlTextReaderFreeIDTable(xmlIDTablePtr table) {
     xmlHashFree(table, xmlTextReaderFreeIDTableEntry);
-} 
- 
-/** 
- * 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) { 
-	        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) { 
-	    /* 
+}
+
+/**
+ * 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) {
+	        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 available, 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 { 
-		/* 
+	     * 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 been raised already.
-		 */ 
-		if (node == oldnode) 
-		    break; 
+		 */
+		if (node == oldnode)
+		    break;
                 goto skip_children;
-	    } 
-#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); 
-	} 
+	    }
+#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);
+	}
 skip_children:
-	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, 
+	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 aren't 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)) { 
-	/* 
+     * 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 available, 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; 
-    } 
+	 * 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->node->doc;
-    buff = xmlBufferCreate(); 
+    buff = xmlBufferCreate();
     if (buff == NULL)
         return NULL;
-    for (cur_node = reader->node->children; cur_node != NULL; 
-         cur_node = cur_node->next) { 
+    for (cur_node = reader->node->children; cur_node != NULL;
+         cur_node = cur_node->next) {
         /* XXX: Why is the node copied? */
-        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; 
- 
-    if (xmlTextReaderExpand(reader) == NULL) { 
-        return NULL; 
-    } 
+        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;
+
+    if (xmlTextReaderExpand(reader) == NULL) {
+        return NULL;
+    }
     node = reader->node;
     doc = node->doc;
     /* XXX: Why is the node copied? */
-	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 (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 */
 	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); 
-    } 
+    }
+
+    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; 
-    /* 
+    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 dictionary 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->vctxt.vstateTab != NULL) && 
-	    (reader->ctxt->vctxt.vstateMax > 0)){ 
+     */
+    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->vctxt.vstateTab != NULL) &&
+	    (reader->ctxt->vctxt.vstateMax > 0)){
             while (reader->ctxt->vctxt.vstateNr > 0)
                 xmlValidatePopElement(&reader->ctxt->vctxt, NULL, NULL, NULL);
-	    xmlFree(reader->ctxt->vctxt.vstateTab); 
-	    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->ctxt->myDoc != NULL) {
 	    if (reader->preserve == 0)
 		xmlTextReaderFreeDoc(reader, reader->ctxt->myDoc);
 	    reader->ctxt->myDoc = NULL;
 	}
-	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. 
- * 
+	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 progressed past
- * what's left in reader->input, and there is an allocation problem. Best 
- * would be to rewrite it differently. 
- * 
- * Returns the xmlParserInputBufferPtr attached to the XML or NULL 
- *    in case of error. 
- */ 
-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. 
- * 
+ * 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 positioned on an
  *         attribute 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 
- * 
+ *         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 xmlReaderTypes 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; 
+ */
+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); 
-                    } 
+
+	    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); 
+                } else
+                    xmlBufEmpty(reader->buffer);
+	        xmlBufGetNodeContent(reader->buffer, node);
 		ret = xmlBufContent(reader->buffer);
 		if (ret == NULL) {
 		    /* error on the buffer best to reallocate */
@@ -3673,2309 +3673,2309 @@ xmlTextReaderConstValue(xmlTextReaderPtr reader) {
 		    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 &#0; 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 
- * 
+	    }
+	    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 &#0; 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 corresponding 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 
- * 
+ * 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 non-negative 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 
- * 
+ */
+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 corresponding 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 
+ * 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) LIBXML_ATTR_FORMAT(1,0);
- 
-static void XMLCDECL 
+
+static void XMLCDECL
 xmlTextReaderValidityError(void *ctxt, const char *msg, ...) LIBXML_ATTR_FORMAT(2,3);
- 
-static void XMLCDECL 
+
+static void XMLCDECL
 xmlTextReaderValidityWarning(void *ctxt, const char *msg, ...) LIBXML_ATTR_FORMAT(2,3);
- 
-static void XMLCDECL 
+
+static void XMLCDECL
 xmlTextReaderValidityErrorRelay(void *ctx, const char *msg, ...) LIBXML_ATTR_FORMAT(2,3);
 
 static void XMLCDECL
 xmlTextReaderValidityWarningRelay(void *ctx, const char *msg, ...) LIBXML_ATTR_FORMAT(2,3);
 
 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(). 
+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 deactivated.
- @ The @schema should not be freed until the reader is deallocated 
- * or its use has been deactivated. 
- * 
+ @ 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 (de)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 
- * 
+ *         -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 (de)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(). 
+ *         -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 deactivated.
  * The @schema should not be freed until the reader is deallocated
- * or its use has been deactivated. 
- * 
+ * or its use has been deactivated.
+ *
  * Returns 0 in case the Schema validation could be (de)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); 
-    } 
-} 
- 
+ *         -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 LIBXML_ATTR_FORMAT(2,3)
-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); 
- 
-} 
- 
+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 LIBXML_ATTR_FORMAT(2,3)
-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); 
-    } 
+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; 
-    /* 
+    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 dictionary 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 */ 
+     */
+    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 */