Upgrade to libxml 2.9.2 and libxslt 1.1.28

third_party/libxml/src/xmlreader.c

 /*
  * 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
@@ skipping 26 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
 
+#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 (i.e. it may need
- * something involving a memcpy) but (hopefully) will be
- * sufficient for libxml2.
+ * 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
-      #define VA_COPY(dest,src) (dest) = (src)
+      #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:
  *
@@ skipping 54 matching lines @@
     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 */
-    xmlBufferPtr                buffer; /* used to return const xmlChar * */
+    xmlBufPtr                   buffer; /* used to return const xmlChar * */
     xmlDictPtr                  dict;   /* the context dictionnary */
 
     /* entity stack when traversing entities content */
     xmlNodePtr         ent;          /* Current Entity Ref Node */
     int                entNr;        /* Depth of the entities stack */
     int                entMax;       /* Max depth of the entities stack */
     xmlNodePtr        *entTab;       /* array of entities */
 
     /* error handling */
     xmlTextReaderErrorFunc errorFunc;    /* callback function */
     void                  *errorFuncArg; /* callback function user argument */
 
 #ifdef LIBXML_SCHEMAS_ENABLED
     /* Handling of RelaxNG validation */
     xmlRelaxNGPtr          rngSchemas;  /* The Relax NG schemas */
     xmlRelaxNGValidCtxtPtr rngValidCtxt;/* The Relax NG validation context */
+    int                    rngPreserveCtxt; /* 1 if the context was provided by the user */
     int                    rngValidErrors;/* The number of errors detected */
     xmlNodePtr             rngFullNode; /* the node if RNG not progressive */
     /* Handling of Schemas validation */
     xmlSchemaPtr          xsdSchemas;   /* The Schemas schemas */
     xmlSchemaValidCtxtPtr xsdValidCtxt;/* The Schemas validation context */
     int                   xsdPreserveCtxt; /* 1 if the context was provided by the user */
     int                   xsdValidErrors;/* The number of errors detected */
     xmlSchemaSAXPlugPtr   xsdPlug;      /* the schemas plug in SAX pipeline */
 #endif
 #ifdef LIBXML_XINCLUDE_ENABLED
@@ skipping 107 matching lines @@
  * xmlTextReaderFreeProp:
  * @reader:  the xmlTextReaderPtr used
  * @cur:  the node
  *
  * Free a node.
  */
 static void
 xmlTextReaderFreeProp(xmlTextReaderPtr reader, xmlAttrPtr cur) {
     xmlDictPtr dict;
 
-    dict = reader->ctxt->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))
@@ skipping 16 matching lines @@
 /**
  * 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;
-    if (cur == NULL) return;
+
     while (cur != NULL) {
         next = cur->next;
         xmlTextReaderFreeProp(reader, cur);
         cur = next;
     }
 }
 
 /**
  * xmlTextReaderFreeNodeList:
  * @reader:  the xmlTextReaderPtr used
  * @cur:  the first node in the list
  *
  * Free a node and all its siblings, this is a recursive behaviour, all
  * the children are freed too.
  */
 static void
 xmlTextReaderFreeNodeList(xmlTextReaderPtr reader, xmlNodePtr cur) {
     xmlNodePtr next;
     xmlDictPtr dict;
 
-    dict = reader->ctxt->dict;
+    if ((reader != NULL) && (reader->ctxt != NULL))
+        dict = reader->ctxt->dict;
+    else
+        dict = NULL;
     if (cur == NULL) return;
     if (cur->type == XML_NAMESPACE_DECL) {
         xmlFreeNsList((xmlNsPtr) cur);
         return;
     }
     if ((cur->type == XML_DOCUMENT_NODE) ||
         (cur->type == XML_HTML_DOCUMENT_NODE)) {
         xmlFreeDoc((xmlDocPtr) cur);
         return;
     }
@@ skipping 56 matching lines @@
  * @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;
 
-    dict = reader->ctxt->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);
@@ skipping 371 matching lines @@
  * 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) {
-    xmlBufferPtr inbuf;
+    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 (inbuf->use < reader->cur + CHUNK_SIZE) {
+        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) &&
-                    (inbuf->alloc == XML_BUFFER_ALLOC_IMMUTABLE)) {
-                    if (inbuf->use == reader->cur) {
+                    (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 (inbuf->use >= reader->cur + CHUNK_SIZE) {
+        if (xmlBufUse(inbuf) >= reader->cur + CHUNK_SIZE) {
             val = xmlParseChunk(reader->ctxt,
-                          (const char *) &inbuf->content[reader->cur],
-                          CHUNK_SIZE, 0);
+                 (const char *) xmlBufContent(inbuf) + reader->cur,
+                                CHUNK_SIZE, 0);
             reader->cur += CHUNK_SIZE;
-            if ((val != 0) || (reader->ctxt->wellFormed == 0))
-                return(-1);
+            if (val != 0)
+                reader->ctxt->wellFormed = 0;
+            if (reader->ctxt->wellFormed == 0)
+                break;
         } else {
-            s = inbuf->use - reader->cur;
+            s = xmlBufUse(inbuf) - reader->cur;
             val = xmlParseChunk(reader->ctxt,
-                          (const char *) &inbuf->content[reader->cur],
-                          s, 0);
+                 (const char *) xmlBufContent(inbuf) + reader->cur,
+                                s, 0);
             reader->cur += s;
-            if ((val != 0) || (reader->ctxt->wellFormed == 0))
-                return(-1);
+            if (val != 0)
+                reader->ctxt->wellFormed = 0;
             break;
         }
     }
 
     /*
      * Discard the consumed input when needed and possible
      */
     if (reader->mode == XML_TEXTREADER_MODE_INTERACTIVE) {
-        if (inbuf->alloc != XML_BUFFER_ALLOC_IMMUTABLE) {
+        if (alloc != XML_BUFFER_ALLOC_IMMUTABLE) {
             if ((reader->cur >= 4096) &&
-                (inbuf->use - reader->cur <= CHUNK_SIZE)) {
-                val = xmlBufferShrink(inbuf, reader->cur);
+                (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 = inbuf->use - reader->cur;
+            s = xmlBufUse(inbuf) - reader->cur;
             val = xmlParseChunk(reader->ctxt,
-                    (const char *) &inbuf->content[reader->cur],
-                    s, 1);
-            reader->cur = inbuf->use;
+                 (const char *) xmlBufContent(inbuf) + reader->cur,
+                                s, 1);
+            reader->cur = xmlBufUse(inbuf);
             reader->state  = XML_TEXTREADER_DONE;
-            if ((val != 0) || (reader->ctxt->wellFormed == 0))
-                return(-1);
+            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
  */
@@ skipping 48 matching lines @@
         if (ret != 1)
             reader->rngValidErrors++;
     }
 #endif
 }
 
 /**
  * xmlTextReaderValidateCData:
  * @reader:  the xmlTextReaderPtr used
  * @data:  pointer to the CData
- * @len:  lenght of the CData block in bytes.
+ * @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,
@@ skipping 223 matching lines @@
  *  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;
@@ skipping 32 matching lines @@
     xmlNodePtr oldnode = NULL;
 
 
     if (reader == NULL)
         return(-1);
     reader->curnode = NULL;
     if (reader->doc != NULL)
         return(xmlTextReaderReadTree(reader));
     if (reader->ctxt == NULL)
         return(-1);
-    if (reader->ctxt->wellFormed != 1)
-        return(-1);
 
 #ifdef DEBUG_READER
     fprintf(stderr, "\nREAD ");
     DUMP_READER
 #endif
     if (reader->mode == XML_TEXTREADER_MODE_INITIAL) {
         reader->mode = XML_TEXTREADER_MODE_INTERACTIVE;
         /*
          * Initial state
          */
@@ skipping 106 matching lines @@
 
         /*
          * Cleanup of the old node
          */
         if ((reader->preserves == 0) &&
 #ifdef LIBXML_XINCLUDE_ENABLED
             (reader->in_xinclude == 0) &&
 #endif
             (reader->entNr == 0) &&
             (reader->node->prev != NULL) &&
-            (reader->node->prev->type != XML_DTD_NODE)) {
+            (reader->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) && (reader->node->type == XML_ELEMENT_NODE))
+    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) ||
@@ skipping 112 matching lines @@
 #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)) {
+    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));
@@ skipping 143 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
- *         string must be deallocated by the caller.
+ * Returns a string containing the node and any XML content, or NULL if the
+ *         current node cannot be serialized. The string must be deallocated
+ *         by the caller.
  */
 xmlChar *
 xmlTextReaderReadOuterXml(xmlTextReaderPtr reader ATTRIBUTE_UNUSED)
 {
     xmlChar *resbuf;
     xmlNodePtr node;
     xmlBufferPtr buff;
     xmlDocPtr doc;
 
     node = reader->node;
     doc = reader->doc;
     if (xmlTextReaderExpand(reader) == NULL) {
         return NULL;
     }
-    node = xmlDocCopyNode(node, doc, 1);
+        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;
 
@@ skipping 24 matching lines @@
     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
@@ skipping 260 matching lines @@
         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 = xmlBufferCreateSize(100);
+    ret->buffer = xmlBufCreateSize(100);
     if (ret->buffer == NULL) {
         xmlFree(ret);
         xmlGenericError(xmlGenericErrorContext,
                 "xmlNewTextReader : malloc failed\n");
         return(NULL);
     }
     ret->sax = (xmlSAXHandler *) xmlMalloc(sizeof(xmlSAXHandler));
     if (ret->sax == NULL) {
-        xmlBufferFree(ret->buffer);
+        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;
@@ skipping 12 matching lines @@
 #endif /* LIBXML_SAX1_ENABLED */
     ret->characters = ret->sax->characters;
     ret->sax->characters = xmlTextReaderCharacters;
     ret->sax->ignorableWhitespace = xmlTextReaderCharacters;
     ret->cdataBlock = ret->sax->cdataBlock;
     ret->sax->cdataBlock = xmlTextReaderCDataBlock;
 
     ret->mode = XML_TEXTREADER_MODE_INITIAL;
     ret->node = NULL;
     ret->curnode = NULL;
-    if (ret->input->buffer->use < 4) {
+    if (xmlBufUse(ret->input->buffer) < 4) {
         xmlParserInputBufferRead(input, 4);
     }
-    if (ret->input->buffer->use >= 4) {
+    if (xmlBufUse(ret->input->buffer) >= 4) {
         ret->ctxt = xmlCreatePushParserCtxt(ret->sax, NULL,
-                        (const char *) ret->input->buffer->content, 4, URI);
+                             (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");
-        xmlBufferFree(ret->buffer);
+        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;
     /*
@@ skipping 52 matching lines @@
 void
 xmlFreeTextReader(xmlTextReaderPtr reader) {
     if (reader == NULL)
         return;
 #ifdef LIBXML_SCHEMAS_ENABLED
     if (reader->rngSchemas != NULL) {
         xmlRelaxNGFree(reader->rngSchemas);
         reader->rngSchemas = NULL;
     }
     if (reader->rngValidCtxt != NULL) {
-        xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
+        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;
@@ skipping 35 matching lines @@
             reader->ctxt->vctxt.vstateMax = 0;
         }
         if (reader->allocs & XML_TEXTREADER_CTXT)
             xmlFreeParserCtxt(reader->ctxt);
     }
     if (reader->sax != NULL)
         xmlFree(reader->sax);
     if ((reader->input != NULL)  && (reader->allocs & XML_TEXTREADER_INPUT))
         xmlFreeParserInputBuffer(reader->input);
     if (reader->buffer != NULL)
-        xmlBufferFree(reader->buffer);
+        xmlBufFree(reader->buffer);
     if (reader->entTab != NULL)
         xmlFree(reader->entTab);
     if (reader->dict != NULL)
         xmlDictFree(reader->dict);
     xmlFree(reader);
 }
 
 /************************************************************************
  *                                                                      *
  *                      Methods for XmlTextReader                       *
@@ skipping 1327 matching lines @@
         case XML_NAMESPACE_DECL:
             return(((xmlNsPtr) node)->href);
         case XML_ATTRIBUTE_NODE:{
             xmlAttrPtr attr = (xmlAttrPtr) node;
 
             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 = xmlBufferCreateSize(100);
                 if (reader->buffer == NULL) {
-                    xmlGenericError(xmlGenericErrorContext,
-                                    "xmlTextReaderSetup : malloc failed\n");
-                    return (NULL);
-                }
-                reader->buffer->use = 0;
-                xmlNodeBufGetContent(reader->buffer, node);
-                return(reader->buffer->content);
+                    reader->buffer = xmlBufCreateSize(100);
+                    if (reader->buffer == NULL) {
+                        xmlGenericError(xmlGenericErrorContext,
+                                        "xmlTextReaderSetup : malloc failed\n");
+                        return (NULL);
+                    }
+                } else
+                    xmlBufEmpty(reader->buffer);
+                xmlBufGetNodeContent(reader->buffer, node);
+                return(xmlBufContent(reader->buffer));
             }
             break;
         }
         case XML_TEXT_NODE:
         case XML_CDATA_SECTION_NODE:
         case XML_PI_NODE:
         case XML_COMMENT_NODE:
             return(node->content);
         default:
             break;
@@ skipping 474 matching lines @@
 int
 xmlTextReaderRelaxNGSetSchema(xmlTextReaderPtr reader, xmlRelaxNGPtr schema) {
     if (reader == NULL)
         return(-1);
     if (schema == NULL) {
         if (reader->rngSchemas != NULL) {
             xmlRelaxNGFree(reader->rngSchemas);
             reader->rngSchemas = NULL;
         }
         if (reader->rngValidCtxt != NULL) {
-            xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
+            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) {
-        xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
+        if (! reader->rngPreserveCtxt)
+            xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
         reader->rngValidCtxt = NULL;
     }
+    reader->rngPreserveCtxt = 0;
     reader->rngValidCtxt = xmlRelaxNGNewValidCtxt(schema);
     if (reader->rngValidCtxt == NULL)
         return(-1);
     if (reader->errorFunc != NULL) {
         xmlRelaxNGSetValidErrors(reader->rngValidCtxt,
                         xmlTextReaderValidityErrorRelay,
                         xmlTextReaderValidityWarningRelay,
                         reader);
     }
         if (reader->sErrorFunc != NULL) {
                 xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt,
                         xmlTextReaderValidityStructuredRelay,
                         reader);
     }
     reader->rngValidErrors = 0;
     reader->rngFullNode = NULL;
     reader->validate = XML_TEXTREADER_VALIDATE_RNG;
     return(0);
 }
 
 /**
+ * xmlTextReaderLocator:
+ * @ctx: the xmlTextReaderPtr used
+ * @file: returned file information
+ * @line: returned line information
+ *
+ * Internal locator function for the readers
+ *
+ * Returns 0 in case the Schema validation could be (des)activated and
+ *         -1 in case of error.
+ */
+static int
+xmlTextReaderLocator(void *ctx, const char **file, unsigned long *line) {
+    xmlTextReaderPtr reader;
+
+    if ((ctx == NULL) || ((file == NULL) && (line == NULL)))
+        return(-1);
+
+    if (file != NULL)
+        *file = NULL;
+    if (line != NULL)
+        *line = 0;
+
+    reader = (xmlTextReaderPtr) ctx;
+    if ((reader->ctxt != NULL) && (reader->ctxt->input != NULL)) {
+        if (file != NULL)
+            *file = reader->ctxt->input->filename;
+        if (line != NULL)
+            *line = reader->ctxt->input->line;
+        return(0);
+    }
+    if (reader->node != NULL) {
+        long res;
+        int ret = 0;
+
+        if (line != NULL) {
+            res = xmlGetLineNo(reader->node);
+            if (res > 0)
+                *line = (unsigned long) res;
+            else
+                ret = -1;
+        }
+        if (file != NULL) {
+            xmlDocPtr doc = reader->node->doc;
+            if ((doc != NULL) && (doc->URL != NULL))
+                *file = (const char *) doc->URL;
+            else
+                ret = -1;
+        }
+        return(ret);
+    }
+    return(-1);
+}
+
+/**
  * xmlTextReaderSetSchema:
  * @reader:  the xmlTextReaderPtr used
  * @schema:  a precompiled Schema schema
  *
  * Use XSD Schema to validate the document as it is processed.
  * Activation is only possible before the first Read().
  * if @schema is NULL, then Schema validation is desactivated.
  @ The @schema should not be freed until the reader is deallocated
  * or its use has been deactivated.
  *
@@ skipping 46 matching lines @@
     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);
 }
 
 /**
- * xmlTextReaderRelaxNGValidate:
+ * 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 @rng is NULL, then RelaxNG validation is deactivated.
+ * 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.
+ *         -1 in case of error.
  */
-int
-xmlTextReaderRelaxNGValidate(xmlTextReaderPtr reader, const char *rng) {
-    xmlRelaxNGParserCtxtPtr ctxt;
+static int
+xmlTextReaderRelaxNGValidateInternal(xmlTextReaderPtr reader,
+                                     const char *rng,
+                                     xmlRelaxNGValidCtxtPtr ctxt,
+                                     int options ATTRIBUTE_UNUSED)
+{
+    if (reader == NULL)
+        return(-1);
 
-    if (reader == NULL)
-        return(-1);
+    if ((rng != NULL) && (ctxt != NULL))
+        return (-1);
 
-    if (rng == NULL) {
-        if (reader->rngValidCtxt != NULL) {
+    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;
-        }
-        if (reader->rngSchemas != NULL) {
-            xmlRelaxNGFree(reader->rngSchemas);
-            reader->rngSchemas = NULL;
-        }
-        return(0);
+        reader->rngValidCtxt = NULL;
     }
-    if (reader->mode != XML_TEXTREADER_MODE_INITIAL)
-        return(-1);
+    reader->rngPreserveCtxt = 0;
     if (reader->rngSchemas != NULL) {
         xmlRelaxNGFree(reader->rngSchemas);
         reader->rngSchemas = NULL;
     }
-    if (reader->rngValidCtxt != NULL) {
-        xmlRelaxNGFreeValidCtxt(reader->rngValidCtxt);
-        reader->rngValidCtxt = NULL;
+
+    if ((rng == NULL) && (ctxt == NULL)) {
+        /* We just want to deactivate the validation, so get out. */
+        return(0);
     }
-    ctxt = xmlRelaxNGNewParserCtxt(rng);
-    if (reader->errorFunc != NULL) {
-        xmlRelaxNGSetParserErrors(ctxt,
-                         xmlTextReaderValidityErrorRelay,
-                         xmlTextReaderValidityWarningRelay,
-                         reader);
+
+
+    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;
     }
-    if (reader->sErrorFunc != NULL) {
-        xmlRelaxNGSetValidStructuredErrors(reader->rngValidCtxt,
-                        xmlTextReaderValidityStructuredRelay,
-                        reader);
-    }
-    reader->rngSchemas = xmlRelaxNGParse(ctxt);
-    xmlRelaxNGFreeParserCtxt(ctxt);
-    if (reader->rngSchemas == NULL)
-        return(-1);
-    reader->rngValidCtxt = xmlRelaxNGNewValidCtxt(reader->rngSchemas);
-    if (reader->rngValidCtxt == NULL) {
-        xmlRelaxNGFree(reader->rngSchemas);
-        reader->rngSchemas = NULL;
-        return(-1);
-    }
+    /*
+    * 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);
@@ skipping 92 matching lines @@
         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,
@@ skipping 40 matching lines @@
  * 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
@@ skipping 497 matching lines @@
         (reader->allocs & XML_TEXTREADER_INPUT)) {
         xmlFreeParserInputBuffer(reader->input);
         reader->input = NULL;
         reader->allocs -= XML_TEXTREADER_INPUT;
     }
     if (input != NULL) {
         reader->input = input;
         reader->allocs |= XML_TEXTREADER_INPUT;
     }
     if (reader->buffer == NULL)
-        reader->buffer = xmlBufferCreateSize(100);
+        reader->buffer = xmlBufCreateSize(100);
     if (reader->buffer == NULL) {
         xmlGenericError(xmlGenericErrorContext,
                         "xmlTextReaderSetup : malloc failed\n");
         return (-1);
     }
     if (reader->sax == NULL)
         reader->sax = (xmlSAXHandler *) xmlMalloc(sizeof(xmlSAXHandler));
     if (reader->sax == NULL) {
         xmlGenericError(xmlGenericErrorContext,
                         "xmlTextReaderSetup : malloc failed\n");
@@ skipping 20 matching lines @@
     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 (reader->input->buffer->use < 4) {
+        if (xmlBufUse(reader->input->buffer) < 4) {
             xmlParserInputBufferRead(input, 4);
         }
         if (reader->ctxt == NULL) {
-            if (reader->input->buffer->use >= 4) {
+            if (xmlBufUse(reader->input->buffer) >= 4) {
                 reader->ctxt = xmlCreatePushParserCtxt(reader->sax, NULL,
-                       (const char *) reader->input->buffer->content, 4, URL);
+                       (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;
-            inputStream->base = inputStream->buf->buffer->content;
-            inputStream->cur = inputStream->buf->buffer->content;
-            inputStream->end =
-            &inputStream->buf->buffer->content[inputStream->buf->buffer->use];
+            xmlBufResetInput(buf->buffer, inputStream);
 
             inputPush(reader->ctxt, inputStream);
             reader->cur = 0;
         }
         if (reader->ctxt == NULL) {
             xmlGenericError(xmlGenericErrorContext,
                             "xmlTextReaderSetup : malloc failed\n");
             return (-1);
         }
     }
@@ skipping 267 matching lines @@
                int options)
 {
     xmlTextReaderPtr reader;
     xmlParserInputBufferPtr input;
 
     if (ioread == NULL)
         return (NULL);
 
     input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx,
                                          XML_CHAR_ENCODING_NONE);
-    if (input == NULL)
+    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);
 }
 
@@ skipping 196 matching lines @@
 {
     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 (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
@@ skipping 191 matching lines @@
     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 */