Update libxml to 2.7.7.

third_party/libxml/xmlreader.c

 /*
  * xmlreader.c: implements the xmlTextReader streaming node API
  *
- * NOTE: 
+ * 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:
@@ skipping 22 matching lines @@
 #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
 
+#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 (i.e. it may need
+ * something involving a memcpy) 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
+      #define VA_COPY(dest,src) (dest) = (src)
+    #endif
+  #endif
+#endif
+
 /* #define DEBUG_CALLBACKS */
 /* #define DEBUG_READER */
 
 /**
  * TODO:
  *
  * macro to flag unimplemented blocks
  */
-#define TODO                                                            \
+#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
 
@@ skipping 34 matching lines @@
     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 */
+    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 */
     xmlBufferPtr                buffer; /* used to return const xmlChar * */
     xmlDictPtr                  dict;   /* the context dictionnary */
 
     /* entity stack when traversing entities content */
     xmlNodePtr         ent;          /* Current Entity Ref Node */
@@ skipping 57 matching lines @@
  *                                                                      *
  ************************************************************************/
 /**
  * DICT_FREE:
  * @str:  a string
  *
  * Free a string if it is not owned by the "dict" dictionnary in the
  * current scope
  */
 #define DICT_FREE(str)                                          \
-        if ((str) && ((!dict) ||                                \
+        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
  *
@@ skipping 24 matching lines @@
  */
 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) 
+    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);
     }
@@ skipping 569 matching lines @@
                     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 
+            } else
                 break;
         }
         /*
          * parse by block of CHUNK_SIZE bytes, various tests show that
          * it's the best tradeoff at least on a 1.2GH Duron
          */
         if (inbuf->use >= reader->cur + CHUNK_SIZE) {
             val = xmlParseChunk(reader->ctxt,
                           (const char *) &inbuf->content[reader->cur],
                           CHUNK_SIZE, 0);
@@ skipping 28 matching lines @@
     }
 
     /*
      * 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 = inbuf->use - reader->cur;
             val = xmlParseChunk(reader->ctxt,
-                    (const char *) &inbuf->content[reader->cur], 
+                    (const char *) &inbuf->content[reader->cur],
                     s, 1);
             reader->cur = inbuf->use;
             reader->state  = XML_TEXTREADER_DONE;
             if ((val != 0) || (reader->ctxt->wellFormed == 0))
                 return(-1);
         }
     }
     reader->state = oldstate;
     return(0);
 }
@@ skipping 119 matching lines @@
                 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) 
+            if (node == reader->rngFullNode)
                 reader->rngFullNode = NULL;
             return;
         }
         ret = xmlRelaxNGValidatePopElement(reader->rngValidCtxt,
                                            reader->ctxt->myDoc,
                                            node);
         if (ret != 1)
             reader->rngValidErrors++;
     }
 #endif
@@ skipping 14 matching lines @@
     xmlParserCtxtPtr ctxt = reader->ctxt;
 
     do {
         if (node->type == XML_ENTITY_REF_NODE) {
             /*
              * Case where the underlying tree is not availble, lookup the entity
              * and walk it.
              */
             if ((node->children == NULL) && (ctxt->sax != NULL) &&
                 (ctxt->sax->getEntity != NULL)) {
-                node->children = (xmlNodePtr) 
+                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 {
@@ skipping 169 matching lines @@
  *
  *  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);
     if (reader->ctxt->wellFormed != 1)
         return(-1);
 
@@ skipping 159 matching lines @@
             reader->state = XML_TEXTREADER_DONE;
             if (val != 0)
                 return(-1);
         }
         reader->node = NULL;
         reader->depth = -1;
 
         /*
          * Cleanup of the old node
          */
-        if ((reader->preserves == 0) &&
+        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) &&
             (reader->entNr == 0)) {
             xmlUnlinkNode(oldnode);
             xmlTextReaderFreeNode(reader, oldnode);
         }
@@ skipping 32 matching lines @@
     /*
      * 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, 
+            xmlXIncludeSetFlags(reader->xincctxt,
                                 reader->parserFlags & (~XML_PARSE_NOXINCNODE));
         }
         /*
          * expand that node and process it
          */
         if (xmlTextReaderExpand(reader) == NULL)
             return -1;
         xmlXIncludeProcessNode(reader->xincctxt, reader->node);
     }
     if ((reader->node != NULL) && (reader->node->type == XML_XINCLUDE_START)) {
         reader->in_xinclude++;
         goto get_next_node;
-    } 
+    }
     if ((reader->node != NULL) && (reader->node->type == XML_XINCLUDE_END)) {
         reader->in_xinclude--;
         goto get_next_node;
     }
 #endif
     /*
      * Handle entities enter and exit when in entity replacement mode
      */
     if ((reader->node != NULL) &&
         (reader->node->type == XML_ENTITY_REF_NODE) &&
         (reader->ctxt != NULL) && (reader->ctxt->replaceEntities == 1)) {
         /*
          * Case where the underlying tree is not availble, lookup the entity
          * and walk it.
          */
         if ((reader->node->children == NULL) && (reader->ctxt->sax != NULL) &&
             (reader->ctxt->sax->getEntity != NULL)) {
-            reader->node->children = (xmlNodePtr) 
+            reader->node->children = (xmlNodePtr)
                 reader->ctxt->sax->getEntity(reader->ctxt, reader->node->name);
         }
 
         if ((reader->node->children != NULL) &&
             (reader->node->children->type == XML_ENTITY_DECL) &&
             (reader->node->children->children != NULL)) {
             xmlTextReaderEntPush(reader, reader->node);
             reader->node = reader->node->children->children;
         }
 #ifdef LIBXML_REGEXP_ENABLED
     } else if ((reader->node != NULL) &&
                (reader->node->type == XML_ENTITY_REF_NODE) &&
                (reader->ctxt != NULL) && (reader->validate)) {
         xmlTextReaderValidateEntity(reader);
 #endif /* LIBXML_REGEXP_ENABLED */
     }
     if ((reader->node != NULL) &&
         (reader->node->type == XML_ENTITY_DECL) &&
         (reader->ent != NULL) && (reader->ent->children == reader->node)) {
         reader->node = xmlTextReaderEntPop(reader);
         reader->depth++;
         goto get_next_node;
     }
 #ifdef LIBXML_REGEXP_ENABLED
     if ((reader->validate) && (reader->node != NULL)) {
         xmlNodePtr node = reader->node;
 
-        if ((node->type == XML_ELEMENT_NODE) && 
+        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->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);
 }
 
@@ skipping 70 matching lines @@
 }
 
 #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 
+ *         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;
 
@@ skipping 25 matching lines @@
 #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 XML content, or NULL if the current node
- *         is neither an element nor attribute, or has no child nodes. The 
+ *         is neither an element nor attribute, or has no child nodes. The
  *         string must be deallocated by the caller.
  */
 xmlChar *
 xmlTextReaderReadOuterXml(xmlTextReaderPtr reader ATTRIBUTE_UNUSED)
 {
     xmlChar *resbuf;
     xmlNodePtr node;
     xmlBufferPtr buff;
     xmlDocPtr doc;
 
@@ skipping 137 matching lines @@
             reader->state = XML_TEXTREADER_END;
             return(0);
         }
 
         reader->node = reader->doc->children;
         reader->state = XML_TEXTREADER_START;
         return(1);
     }
 
     if (reader->state != XML_TEXTREADER_BACKTRACK) {
-        if (reader->node->children != 0) {
-            reader->node = reader->node->children;
-            reader->depth++;
+        /* Here removed traversal to child, because we want to skip the subtree,
+        replace with traversal to sibling to skip subtree */
+        if (reader->node->next != 0) {
+            /* Move to sibling if present,skipping sub-tree */
+            reader->node = reader->node->next;
             reader->state = XML_TEXTREADER_START;
             return(1);
         }
 
+        /* if reader->node->next is NULL mean no subtree for current node,
+        so need to move to sibling of parent node if present */
         if ((reader->node->type == XML_ELEMENT_NODE) ||
             (reader->node->type == XML_ATTRIBUTE_NODE)) {
             reader->state = XML_TEXTREADER_BACKTRACK;
-            return(1);
+            /* 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;
-        return(1);
+        /* 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
@@ skipping 182 matching lines @@
     if (ret->input->buffer->use >= 4) {
         ret->ctxt = xmlCreatePushParserCtxt(ret->sax, NULL,
                         (const char *) ret->input->buffer->content, 4, URI);
         ret->base = 0;
         ret->cur = 4;
     } else {
         ret->ctxt = xmlCreatePushParserCtxt(ret->sax, NULL, NULL, 0, URI);
         ret->base = 0;
         ret->cur = 0;
     }
-    
+
     if (ret->ctxt == NULL) {
         xmlGenericError(xmlGenericErrorContext,
                 "xmlNewTextReader : malloc failed\n");
         xmlBufferFree(ret->buffer);
         xmlFree(ret->sax);
         xmlFree(ret);
         return(NULL);
     }
     ret->ctxt->parseMode = XML_PARSE_READER;
     ret->ctxt->_private = ret;
@@ skipping 87 matching lines @@
 #ifdef LIBXML_PATTERN_ENABLED
     if (reader->patternTab != NULL) {
         int i;
         for (i = 0;i < reader->patternNr;i++) {
             if (reader->patternTab[i] != NULL)
                 xmlFreePattern(reader->patternTab[i]);
         }
         xmlFree(reader->patternTab);
     }
 #endif
+    if (reader->faketext != NULL) {
+        xmlFreeNode(reader->faketext);
+    }
     if (reader->ctxt != NULL) {
         if (reader->dict == reader->ctxt->dict)
             reader->dict = NULL;
         if (reader->ctxt->myDoc != NULL) {
             if (reader->preserve == 0)
                 xmlTextReaderFreeDoc(reader, reader->ctxt->myDoc);
             reader->ctxt->myDoc = NULL;
         }
         if ((reader->ctxt->vctxt.vstateTab != NULL) &&
             (reader->ctxt->vctxt.vstateMax > 0)){
             xmlFree(reader->ctxt->vctxt.vstateTab);
             reader->ctxt->vctxt.vstateTab = NULL;
             reader->ctxt->vctxt.vstateMax = 0;
         }
         if (reader->allocs & XML_TEXTREADER_CTXT)
             xmlFreeParserCtxt(reader->ctxt);
     }
     if (reader->sax != NULL)
         xmlFree(reader->sax);
     if ((reader->input != NULL)  && (reader->allocs & XML_TEXTREADER_INPUT))
         xmlFreeParserInputBuffer(reader->input);
-    if (reader->faketext != NULL) {
-        xmlFreeNode(reader->faketext);
-    }
     if (reader->buffer != NULL)
         xmlBufferFree(reader->buffer);
     if (reader->entTab != NULL)
         xmlFree(reader->entTab);
     if (reader->dict != NULL)
         xmlDictFree(reader->dict);
     xmlFree(reader);
 }
 
 /************************************************************************
@@ skipping 50 matching lines @@
     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) 
+    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;
@@ skipping 109 matching lines @@
     /* 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) || 
+                        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));
 }
@@ skipping 91 matching lines @@
 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) 
+    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;
@@ skipping 66 matching lines @@
              */
             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;
             }
@@ skipping 56 matching lines @@
     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) || 
+                        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;
@@ skipping 125 matching lines @@
     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, 
+            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 {
@@ skipping 17 matching lines @@
 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                   *
@@ skipping 11 matching lines @@
 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);
@@ skipping 17 matching lines @@
  *
  * Get the node type of the current node
  * Reference:
  * http://www.gnu.org/software/dotgnu/pnetlib-doc/System/Xml/XmlNodeType.html
  *
  * Returns the xmlNodeType of the current node or -1 in case of error
  */
 int
 xmlTextReaderNodeType(xmlTextReaderPtr reader) {
     xmlNodePtr node;
-    
+
     if (reader == NULL)
         return(-1);
     if (reader->node == NULL)
         return(XML_READER_TYPE_NONE);
     if (reader->curnode != NULL)
         node = reader->curnode;
     else
         node = reader->node;
     switch (node->type) {
         case XML_ELEMENT_NODE:
@@ skipping 75 matching lines @@
 #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
+ * 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;
@@ skipping 40 matching lines @@
         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
+ * 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:
@@ skipping 103 matching lines @@
     }
     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
+ * 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;
@@ skipping 42 matching lines @@
         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
+ * 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;
@@ skipping 34 matching lines @@
         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
+ * 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:
@@ skipping 237 matching lines @@
     /* 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.
+ * 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));
 }
 
@@ skipping 204 matching lines @@
  * Hacking interface allowing to get the xmlNodePtr correponding to the
  * current node being accessed by the xmlTextReader. This is dangerous
  * because the underlying node may be destroyed on the next Reads.
  *
  * Returns the xmlNodePtr or NULL in case of error.
  */
 xmlNodePtr
 xmlTextReaderCurrentNode(xmlTextReaderPtr reader) {
     if (reader == NULL)
         return(NULL);
-    
+
     if (reader->curnode != NULL)
         return(reader->curnode);
     return(reader->node);
 }
 
 /**
  * xmlTextReaderPreserve:
  * @reader:  the xmlTextReaderPtr used
  *
  * This tells the XML Reader to preserve the current node.
  * The caller must also use xmlTextReaderCurrentDoc() to
  * keep an handle on the resulting document once parsing has finished
  *
  * Returns the xmlNodePtr or NULL in case of error.
  */
 xmlNodePtr
 xmlTextReaderPreserve(xmlTextReaderPtr reader) {
     xmlNodePtr cur, parent;
 
     if (reader == NULL)
         return(NULL);
-    
+
     if (reader->curnode != NULL)
         cur = reader->curnode;
     else
         cur = reader->node;
     if (cur == NULL)
         return(NULL);
 
     if ((cur->type != XML_DOCUMENT_NODE) && (cur->type != XML_DTD_NODE)) {
         cur->extra |= NODE_IS_PRESERVED;
         cur->extra |= NODE_IS_SPRESERVED;
     }
     reader->preserves++;
-        
+
     parent = cur->parent;;
     while (parent != NULL) {
         if (parent->type == XML_ELEMENT_NODE)
             parent->extra |= NODE_IS_PRESERVED;
         parent = parent->parent;
     }
     return(cur);
 }
 
 #ifdef LIBXML_PATTERN_ENABLED
 /**
  * xmlTextReaderPreservePattern:
  * @reader:  the xmlTextReaderPtr used
  * @pattern:  an XPath subset pattern
  * @namespaces: the prefix definitions, array of [URI, prefix] or NULL
- * 
+ *
  * This tells the XML Reader to preserve all nodes matched by the
  * pattern. The caller must also use xmlTextReaderCurrentDoc() to
  * keep an handle on the resulting document once parsing has finished
  *
  * Returns a positive number in case of success and -1 in case of error
  */
 int
 xmlTextReaderPreservePattern(xmlTextReaderPtr reader, const xmlChar *pattern,
                              const xmlChar **namespaces)
 {
     xmlPatternPtr comp;
 
     if ((reader == NULL) || (pattern == NULL))
         return(-1);
-    
+
     comp = xmlPatterncompile(pattern, reader->dict, 0, namespaces);
     if (comp == NULL)
         return(-1);
 
     if (reader->patternMax <= 0) {
         reader->patternMax = 4;
         reader->patternTab = (xmlPatternPtr *) xmlMalloc(reader->patternMax *
                                               sizeof(reader->patternTab[0]));
         if (reader->patternTab == NULL) {
             xmlGenericError(xmlGenericErrorContext, "xmlMalloc failed !\n");
@@ skipping 16 matching lines @@
     reader->patternTab[reader->patternNr] = comp;
     return(reader->patternNr++);
 }
 #endif
 
 /**
  * xmlTextReaderCurrentDoc:
  * @reader:  the xmlTextReaderPtr used
  *
  * Hacking interface allowing to get the xmlDocPtr correponding to the
- * current document being accessed by the xmlTextReader. 
+ * current document being accessed by the xmlTextReader.
  * NOTE: as a result of this call, the reader will not destroy the
  *       associated XML document and calling xmlFreeDoc() on the result
  *       is needed once the reader parsing has finished.
  *
  * Returns the xmlDocPtr or NULL in case of error.
  */
 xmlDocPtr
 xmlTextReaderCurrentDoc(xmlTextReaderPtr reader) {
     if (reader == NULL)
         return(NULL);
     if (reader->doc != NULL)
         return(reader->doc);
     if ((reader->ctxt == NULL) || (reader->ctxt->myDoc == NULL))
         return(NULL);
-    
+
     reader->preserve = 1;
     return(reader->ctxt->myDoc);
 }
 
 #ifdef LIBXML_SCHEMAS_ENABLED
+static char *xmlTextReaderBuildMessage(const char *msg, va_list ap);
 
-static char *
-xmlTextReaderBuildMessage(const char *msg, va_list ap);
-
-static void XMLCDECL 
+static void XMLCDECL
 xmlTextReaderValidityError(void *ctxt, const char *msg, ...);
 
-static void XMLCDECL 
+static void XMLCDECL
 xmlTextReaderValidityWarning(void *ctxt, const char *msg, ...);
 
-static void XMLCDECL xmlTextReaderValidityErrorRelay(void *ctx, const char *msg, ...)
+static void XMLCDECL
+xmlTextReaderValidityErrorRelay(void *ctx, const char *msg, ...)
 {
-        xmlTextReaderPtr reader = (xmlTextReaderPtr) ctx;
-        char * str;
-        va_list ap;
+    xmlTextReaderPtr reader = (xmlTextReaderPtr) ctx;
 
-        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);
+    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, ...)
+static void XMLCDECL
+xmlTextReaderValidityWarningRelay(void *ctx, const char *msg, ...)
 {
-        xmlTextReaderPtr reader = (xmlTextReaderPtr) ctx;
-        char * str;
-        va_list ap;
+    xmlTextReaderPtr reader = (xmlTextReaderPtr) ctx;
 
-        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);
+    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
+  xmlTextReaderStructuredError(void *ctxt, xmlErrorPtr error);
 
-static void xmlTextReaderValidityStructuredRelay(void * userData, xmlErrorPtr error)
+static void
+xmlTextReaderValidityStructuredRelay(void *userData, xmlErrorPtr error)
 {
-        xmlTextReaderPtr reader = (xmlTextReaderPtr) userData;
+    xmlTextReaderPtr reader = (xmlTextReaderPtr) userData;
 
-        if (reader->sErrorFunc) {
-                reader->sErrorFunc(reader->errorFuncArg, error);
-        } else {
-                xmlTextReaderStructuredError(reader, error);
-        }
+    if (reader->sErrorFunc) {
+        reader->sErrorFunc(reader->errorFuncArg, error);
+    } else {
+        xmlTextReaderStructuredError(reader, error);
+    }
 }
-
 /**
  * xmlTextReaderRelaxNGSetSchema:
  * @reader:  the xmlTextReaderPtr used
  * @schema:  a precompiled RelaxNG schema
  *
  * Use RelaxNG to validate the document as it is processed.
  * Activation is only possible before the first Read().
  * if @schema is NULL, then RelaxNG validation is desactivated.
  @ The @schema should not be freed until the reader is deallocated
  * or its use has been deactivated.
@@ skipping 29 matching lines @@
     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, 
+                xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt,
                         xmlTextReaderValidityStructuredRelay,
                         reader);
     }
     reader->rngValidErrors = 0;
     reader->rngFullNode = NULL;
     reader->validate = XML_TEXTREADER_VALIDATE_RNG;
     return(0);
 }
 
 /**
@@ skipping 15 matching lines @@
     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->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);       
+            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);
@@ skipping 37 matching lines @@
  *
  * Returns 0 in case the RelaxNG validation could be (de)activated and
  *         -1 in case of error.
  */
 int
 xmlTextReaderRelaxNGValidate(xmlTextReaderPtr reader, const char *rng) {
     xmlRelaxNGParserCtxtPtr ctxt;
 
     if (reader == NULL)
         return(-1);
-    
+
     if (rng == NULL) {
         if (reader->rngValidCtxt != NULL) {
             xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
             reader->rngValidCtxt = NULL;
         }
         if (reader->rngSchemas != NULL) {
             xmlRelaxNGFree(reader->rngSchemas);
             reader->rngSchemas = NULL;
         }
         return(0);
     }
     if (reader->mode != XML_TEXTREADER_MODE_INITIAL)
         return(-1);
     if (reader->rngSchemas != NULL) {
         xmlRelaxNGFree(reader->rngSchemas);
         reader->rngSchemas = NULL;
     }
     if (reader->rngValidCtxt != NULL) {
         xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
         reader->rngValidCtxt = NULL;
     }
     ctxt = xmlRelaxNGNewParserCtxt(rng);
     if (reader->errorFunc != NULL) {
         xmlRelaxNGSetParserErrors(ctxt,
                          xmlTextReaderValidityErrorRelay,
                          xmlTextReaderValidityWarningRelay,
                          reader);
     }
     if (reader->sErrorFunc != NULL) {
-        xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt, 
+        xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt,
                         xmlTextReaderValidityStructuredRelay,
                         reader);
     }
     reader->rngSchemas = xmlRelaxNGParse(ctxt);
     xmlRelaxNGFreeParserCtxt(ctxt);
     if (reader->rngSchemas == NULL)
         return(-1);
     reader->rngValidCtxt = xmlRelaxNGNewValidCtxt(reader->rngSchemas);
     if (reader->rngValidCtxt == NULL) {
         xmlRelaxNGFree(reader->rngSchemas);
         reader->rngSchemas = NULL;
         return(-1);
     }
     if (reader->errorFunc != NULL) {
         xmlRelaxNGSetValidErrors(reader->rngValidCtxt,
                          xmlTextReaderValidityErrorRelay,
                          xmlTextReaderValidityWarningRelay,
                          reader);
     }
         if (reader->sErrorFunc != NULL) {
-                xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt, 
+                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);       
+            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);
         }
@@ skipping 11 matching lines @@
             &(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. */ 
+        /* 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) {      
+        if (reader->xsdPlug == NULL) {
             reader->xsdValidCtxt = NULL;
             reader->xsdPreserveCtxt = 0;
             return(-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) {
         xmlSchemaSetValidErrors(reader->xsdValidCtxt,
                          xmlTextReaderValidityErrorRelay,
                          xmlTextReaderValidityWarningRelay,
                          reader);
     }
         if (reader->sErrorFunc != NULL) {
-                xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt, 
+                xmlSchemaSetValidStructuredErrors(reader->xsdValidCtxt,
                         xmlTextReaderValidityStructuredRelay,
                         reader);
     }
     reader->xsdValidErrors = 0;
     reader->validate = XML_TEXTREADER_VALIDATE_XSD;
     return(0);
 }
 
 /**
  * xmlTextReaderSchemaValidateCtxt:
@@ skipping 50 matching lines @@
 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; 
+        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
  *
@@ skipping 20 matching lines @@
 
 /************************************************************************
  *                                                                      *
  *                      Error Handling Extensions                       *
  *                                                                      *
  ************************************************************************/
 
 /* helper to build a xmlMalloc'ed string from a format and va_list */
 static char *
 xmlTextReaderBuildMessage(const char *msg, va_list ap) {
-    int size;
+    int size = 0;
     int chars;
     char *larger;
-    char *str;
-
-    str = (char *) xmlMallocAtomic(150);
-    if (str == NULL) {
-        xmlGenericError(xmlGenericErrorContext, "xmlMalloc failed !\n");
-        return NULL;
-    }
-
-    size = 150;
+    char *str = NULL;
+    va_list aq;
 
     while (1) {
-        chars = vsnprintf(str, size, msg, ap);
-        if ((chars > -1) && (chars < size))
+        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 > -1)
-            size += chars + 1;
-        else
-            size += 100;
+        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");
-            xmlFree(str);
+            if (str)
+                xmlFree(str);
             return NULL;
         }
         str = larger;
     }
 
     return str;
 }
 
 /**
  * xmlTextReaderLocatorLineNumber:
@@ skipping 15 matching lines @@
         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.
+ * 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;
+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);
+        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;
+static void
+xmlTextReaderStructuredError(void *ctxt, xmlErrorPtr error)
+{
+    xmlParserCtxtPtr ctx = (xmlParserCtxtPtr) ctxt;
 
-  if (error && reader->sErrorFunc) {
-        reader->sErrorFunc(reader->errorFuncArg,
-                           (xmlErrorPtr) error);
-  }
+    xmlTextReaderPtr reader = (xmlTextReaderPtr) ctx->_private;
+
+    if (error && reader->sErrorFunc) {
+        reader->sErrorFunc(reader->errorFuncArg, (xmlErrorPtr) error);
+    }
 }
 
-static void XMLCDECL 
-xmlTextReaderError(void *ctxt, const char *msg, ...) {
+static void XMLCDECL
+xmlTextReaderError(void *ctxt, const char *msg, ...)
+{
     va_list ap;
 
-    va_start(ap,msg);
+    va_start(ap, msg);
     xmlTextReaderGenericError(ctxt,
                               XML_PARSER_SEVERITY_ERROR,
-                              xmlTextReaderBuildMessage(msg,ap));
+                              xmlTextReaderBuildMessage(msg, ap));
     va_end(ap);
 
 }
 
-static void XMLCDECL 
-xmlTextReaderWarning(void *ctxt, const char *msg, ...) {
+static void XMLCDECL
+xmlTextReaderWarning(void *ctxt, const char *msg, ...)
+{
     va_list ap;
 
-    va_start(ap,msg);
+    va_start(ap, msg);
     xmlTextReaderGenericError(ctxt,
                               XML_PARSER_SEVERITY_WARNING,
-                              xmlTextReaderBuildMessage(msg,ap));
+                              xmlTextReaderBuildMessage(msg, ap));
     va_end(ap);
 }
 
-static void XMLCDECL 
-xmlTextReaderValidityError(void *ctxt, const char *msg, ...) {
+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);
+        /*
+         * 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, ...) {
+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);
+        /*
+         * 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) {
+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;
+        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);
-                }
+        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;
+    } 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);
-                }
+        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;
+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);
-                }
+        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;
+    } 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);
-                }
+        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);
+xmlTextReaderIsValid(xmlTextReaderPtr reader)
+{
+    if (reader == NULL)
+        return (-1);
 #ifdef LIBXML_SCHEMAS_ENABLED
     if (reader->validate == XML_TEXTREADER_VALIDATE_RNG)
-        return(reader->rngValidErrors == 0);
+        return (reader->rngValidErrors == 0);
     if (reader->validate == XML_TEXTREADER_VALIDATE_XSD)
-        return(reader->xsdValidErrors == 0);
+        return (reader->xsdValidErrors == 0);
 #endif
     if ((reader->ctxt != NULL) && (reader->ctxt->validate == 1))
-        return(reader->ctxt->valid);
-    return(0);
+        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;
+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);
@@ skipping 92 matching lines @@
             }
 
             if (URL == NULL)
                 inputStream->filename = NULL;
             else
                 inputStream->filename = (char *)
                     xmlCanonicPath((const xmlChar *) URL);
             inputStream->buf = buf;
             inputStream->base = inputStream->buf->buffer->content;
             inputStream->cur = inputStream->buf->buffer->content;
-            inputStream->end = 
-                &inputStream->buf->buffer->content[inputStream->buf->buffer->use];
+            inputStream->end =
+            &inputStream->buf->buffer->content[inputStream->buf->buffer->use];
 
             inputPush(reader->ctxt, inputStream);
             reader->cur = 0;
         }
         if (reader->ctxt == NULL) {
             xmlGenericError(xmlGenericErrorContext,
                             "xmlTextReaderSetup : malloc failed\n");
             return (-1);
         }
     }
@@ skipping 80 matching lines @@
  *
  * 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);
 
@@ skipping 20 matching lines @@
 
 /**
  * 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,
@@ skipping 15 matching lines @@
  * 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);
@@ skipping 16 matching lines @@
  * 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;
 
@@ skipping 14 matching lines @@
     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);
 
@@ skipping 27 matching lines @@
  * 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);
@@ skipping 13 matching lines @@
  * @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);
@@ skipping 14 matching lines @@
  * @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);
@@ skipping 14 matching lines @@
  * @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)
         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 */
+                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);
+        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 */
+        else if (cur == '=')    /*no op , end of the base64 stream */
             is_end = 1;
         else {
             is_ignore = 1;
-            if (nbintmp == 0)
-                inblk = incur;
-        }
+            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 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;
-                }
+                if (outcur + 3 >= outmax) {
+                    retval = 2;
+                    break;
+                }
 
                 for (i = 0; i < nbouttmp; i++)
-                    to[outcur++] = outtmp[i];
-                inblk = incur;
+                    to[outcur++] = outtmp[i];
+                inblk = incur;
             }
 
             if (is_break) {
-                retval = 0;
+                retval = 0;
                 break;
-            }
+            }
         }
     }
 
     *tolen = outcur;
     *inlen = inblk;
     return (retval);
 }
 
 /*
  * Test routine for the xmlBase64Decode function
  */
 #if 0
-int main(int argc, char **argv) {
+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);
-    
+    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;
+        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);
+        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);
+    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;
+        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);
+        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);
+    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 */