Imported Upstream version 2.8.0+dfsg1

1 files changed, 50 insertions, 119 deletions

diff --git a/xmlreader.c b/xmlreader.c
index 00083d0..77ac71b 100644
--- a/xmlreader.c
+++ b/xmlreader.c
@@ -44,8 +44,6 @@
 #include <libxml/pattern.h>
 #endif
 
-#include "buf.h"
-
 #define MAX_ERR_MSG_SIZE 64000
 
 /*
@@ -137,7 +135,7 @@ struct _xmlTextReader {
     int				depth;  /* depth of the current node */
     xmlNodePtr			faketext;/* fake xmlNs chld */
     int				preserve;/* preserve the resulting document */
-    xmlBufPtr		        buffer; /* used to return const xmlChar * */
+    xmlBufferPtr		buffer; /* used to return const xmlChar * */
     xmlDictPtr			dict;	/* the context dictionnary */
 
     /* entity stack when traversing entities content */
@@ -809,10 +807,9 @@ xmlTextReaderCDataBlock(void *ctx, const xmlChar *ch, int len)
  */
 static int
 xmlTextReaderPushData(xmlTextReaderPtr reader) {
-    xmlBufPtr inbuf;
+    xmlBufferPtr inbuf;
     int val, s;
     xmlTextReaderState oldstate;
-    int alloc;
 
     if ((reader->input == NULL) || (reader->input->buffer == NULL))
 	return(-1);
@@ -820,18 +817,17 @@ xmlTextReaderPushData(xmlTextReaderPtr reader) {
     oldstate = reader->state;
     reader->state = XML_TEXTREADER_NONE;
     inbuf = reader->input->buffer;
-    alloc = xmlBufGetAllocationScheme(inbuf);
 
     while (reader->state == XML_TEXTREADER_NONE) {
-	if (xmlBufUse(inbuf) < reader->cur + CHUNK_SIZE) {
+	if (inbuf->use < reader->cur + CHUNK_SIZE) {
 	    /*
 	     * Refill the buffer unless we are at the end of the stream
 	     */
 	    if (reader->mode != XML_TEXTREADER_MODE_EOF) {
 		val = xmlParserInputBufferRead(reader->input, 4096);
 		if ((val == 0) &&
-		    (alloc == XML_BUFFER_ALLOC_IMMUTABLE)) {
-		    if (xmlBufUse(inbuf) == reader->cur) {
+		    (inbuf->alloc == XML_BUFFER_ALLOC_IMMUTABLE)) {
+		    if (inbuf->use == reader->cur) {
 			reader->mode = XML_TEXTREADER_MODE_EOF;
 			reader->state = oldstate;
 		    }
@@ -854,20 +850,20 @@ xmlTextReaderPushData(xmlTextReaderPtr reader) {
 	 * parse by block of CHUNK_SIZE bytes, various tests show that
 	 * it's the best tradeoff at least on a 1.2GH Duron
 	 */
-	if (xmlBufUse(inbuf) >= reader->cur + CHUNK_SIZE) {
+	if (inbuf->use >= reader->cur + CHUNK_SIZE) {
 	    val = xmlParseChunk(reader->ctxt,
-                 (const char *) xmlBufContent(inbuf) + reader->cur,
-                                CHUNK_SIZE, 0);
+		          (const char *) &inbuf->content[reader->cur],
+			  CHUNK_SIZE, 0);
 	    reader->cur += CHUNK_SIZE;
 	    if (val != 0)
 		reader->ctxt->wellFormed = 0;
 	    if (reader->ctxt->wellFormed == 0)
 		break;
 	} else {
-	    s = xmlBufUse(inbuf) - reader->cur;
+	    s = inbuf->use - reader->cur;
 	    val = xmlParseChunk(reader->ctxt,
-		 (const char *) xmlBufContent(inbuf) + reader->cur,
-			        s, 0);
+		          (const char *) &inbuf->content[reader->cur],
+			  s, 0);
 	    reader->cur += s;
 	    if (val != 0)
 		reader->ctxt->wellFormed = 0;
@@ -879,10 +875,10 @@ xmlTextReaderPushData(xmlTextReaderPtr reader) {
      * Discard the consumed input when needed and possible
      */
     if (reader->mode == XML_TEXTREADER_MODE_INTERACTIVE) {
-        if (alloc != XML_BUFFER_ALLOC_IMMUTABLE) {
+        if (inbuf->alloc != XML_BUFFER_ALLOC_IMMUTABLE) {
 	    if ((reader->cur >= 4096) &&
-		(xmlBufUse(inbuf) - reader->cur <= CHUNK_SIZE)) {
-		val = xmlBufShrink(inbuf, reader->cur);
+		(inbuf->use - reader->cur <= CHUNK_SIZE)) {
+		val = xmlBufferShrink(inbuf, reader->cur);
 		if (val >= 0) {
 		    reader->cur -= val;
 		}
@@ -896,11 +892,11 @@ xmlTextReaderPushData(xmlTextReaderPtr reader) {
      */
     else if (reader->mode == XML_TEXTREADER_MODE_EOF) {
 	if (reader->state != XML_TEXTREADER_DONE) {
-	    s = xmlBufUse(inbuf) - reader->cur;
+	    s = inbuf->use - reader->cur;
 	    val = xmlParseChunk(reader->ctxt,
-		 (const char *) xmlBufContent(inbuf) + reader->cur,
-			        s, 1);
-	    reader->cur = xmlBufUse(inbuf);
+		    (const char *) &inbuf->content[reader->cur],
+		    s, 1);
+	    reader->cur = inbuf->use;
 	    reader->state  = XML_TEXTREADER_DONE;
 	    if (val != 0) {
 	        if (reader->ctxt->wellFormed)
@@ -911,11 +907,8 @@ xmlTextReaderPushData(xmlTextReaderPtr reader) {
 	}
     }
     reader->state = oldstate;
-    if (reader->ctxt->wellFormed == 0) {
+    if (reader->ctxt->wellFormed == 0)
 	reader->mode = XML_TEXTREADER_MODE_EOF;
-        return(-1);
-    }
-
     return(0);
 }
 
@@ -984,7 +977,7 @@ printf("Expand failed !\n");
  * xmlTextReaderValidateCData:
  * @reader:  the xmlTextReaderPtr used
  * @data:  pointer to the CData
- * @len:  length of the CData block in bytes.
+ * @len:  lenght of the CData block in bytes.
  *
  * Push some CData for validation
  */
@@ -1228,9 +1221,6 @@ xmlTextReaderCollectSiblings(xmlNodePtr node)
     xmlBufferPtr buffer;
     xmlChar *ret;
 
-    if ((node == NULL) || (node->type == XML_NAMESPACE_DECL))
-        return(NULL);
-
     buffer = xmlBufferCreate();
     if (buffer == NULL)
        return NULL;
@@ -1409,7 +1399,8 @@ get_next_node:
 #endif
 	    (reader->entNr == 0) &&
 	    (reader->node->prev != NULL) &&
-            (reader->node->prev->type != XML_DTD_NODE)) {
+            (reader->node->prev->type != XML_DTD_NODE) &&
+	    (reader->entNr == 0)) {
 	    xmlNodePtr tmp = reader->node->prev;
 	    if ((tmp->extra & NODE_IS_PRESERVED) == 0) {
 		xmlUnlinkNode(tmp);
@@ -1458,7 +1449,8 @@ get_next_node:
 #endif
 	    (reader->entNr == 0) &&
 	    (oldnode->type != XML_DTD_NODE) &&
-	    ((oldnode->extra & NODE_IS_PRESERVED) == 0)) {
+	    ((oldnode->extra & NODE_IS_PRESERVED) == 0) &&
+	    (reader->entNr == 0)) {
 	    xmlUnlinkNode(oldnode);
 	    xmlTextReaderFreeNode(reader, oldnode);
 	}
@@ -1724,8 +1716,8 @@ xmlTextReaderReadInnerXml(xmlTextReaderPtr reader ATTRIBUTE_UNUSED)
  *
  * Reads the contents of the current node, including child nodes and markup.
  *
- * Returns a string containing the node and any XML content, or NULL if the
- *         current node cannot be serialized. The string must be deallocated
+ * 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 *
@@ -2070,7 +2062,7 @@ xmlNewTextReader(xmlParserInputBufferPtr input, const char *URI) {
     ret->entMax = 0;
     ret->entNr = 0;
     ret->input = input;
-    ret->buffer = xmlBufCreateSize(100);
+    ret->buffer = xmlBufferCreateSize(100);
     if (ret->buffer == NULL) {
         xmlFree(ret);
         xmlGenericError(xmlGenericErrorContext,
@@ -2079,7 +2071,7 @@ xmlNewTextReader(xmlParserInputBufferPtr input, const char *URI) {
     }
     ret->sax = (xmlSAXHandler *) xmlMalloc(sizeof(xmlSAXHandler));
     if (ret->sax == NULL) {
-	xmlBufFree(ret->buffer);
+	xmlBufferFree(ret->buffer);
 	xmlFree(ret);
         xmlGenericError(xmlGenericErrorContext,
 		"xmlNewTextReader : malloc failed\n");
@@ -2112,13 +2104,12 @@ xmlNewTextReader(xmlParserInputBufferPtr input, const char *URI) {
     ret->mode = XML_TEXTREADER_MODE_INITIAL;
     ret->node = NULL;
     ret->curnode = NULL;
-    if (xmlBufUse(ret->input->buffer) < 4) {
+    if (ret->input->buffer->use < 4) {
 	xmlParserInputBufferRead(input, 4);
     }
-    if (xmlBufUse(ret->input->buffer) >= 4) {
+    if (ret->input->buffer->use >= 4) {
 	ret->ctxt = xmlCreatePushParserCtxt(ret->sax, NULL,
-			     (const char *) xmlBufContent(ret->input->buffer),
-                                            4, URI);
+			(const char *) ret->input->buffer->content, 4, URI);
 	ret->base = 0;
 	ret->cur = 4;
     } else {
@@ -2130,7 +2121,7 @@ xmlNewTextReader(xmlParserInputBufferPtr input, const char *URI) {
     if (ret->ctxt == NULL) {
         xmlGenericError(xmlGenericErrorContext,
 		"xmlNewTextReader : malloc failed\n");
-	xmlBufFree(ret->buffer);
+	xmlBufferFree(ret->buffer);
 	xmlFree(ret->sax);
 	xmlFree(ret);
 	return(NULL);
@@ -2260,7 +2251,7 @@ xmlFreeTextReader(xmlTextReaderPtr reader) {
     if ((reader->input != NULL)  && (reader->allocs & XML_TEXTREADER_INPUT))
 	xmlFreeParserInputBuffer(reader->input);
     if (reader->buffer != NULL)
-        xmlBufFree(reader->buffer);
+        xmlBufferFree(reader->buffer);
     if (reader->entTab != NULL)
 	xmlFree(reader->entTab);
     if (reader->dict != NULL)
@@ -3608,17 +3599,16 @@ xmlTextReaderConstValue(xmlTextReaderPtr reader) {
 		(attr->children->next == NULL))
 		return(attr->children->content);
 	    else {
+		if (reader->buffer == NULL)
+		    reader->buffer = xmlBufferCreateSize(100);
 		if (reader->buffer == NULL) {
-		    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));
+		    xmlGenericError(xmlGenericErrorContext,
+				    "xmlTextReaderSetup : malloc failed\n");
+		    return (NULL);
+		}
+	        reader->buffer->use = 0;
+	        xmlNodeBufGetContent(reader->buffer, node);
+		return(reader->buffer->content);
 	    }
 	    break;
 	}
@@ -4153,60 +4143,6 @@ xmlTextReaderRelaxNGSetSchema(xmlTextReaderPtr reader, xmlRelaxNGPtr schema) {
 }
 
 /**
- * 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
@@ -4273,10 +4209,6 @@ xmlTextReaderSetSchema(xmlTextReaderPtr reader, xmlSchemaPtr schema) {
 	reader->xsdValidCtxt = NULL;
 	return(-1);
     }
-    xmlSchemaValidateSetLocator(reader->xsdValidCtxt,
-                                xmlTextReaderLocator,
-				(void *) reader);
-
     if (reader->errorFunc != NULL) {
 	xmlSchemaSetValidErrors(reader->xsdValidCtxt,
 			xmlTextReaderValidityErrorRelay,
@@ -4491,9 +4423,6 @@ xmlTextReaderSchemaValidateInternal(xmlTextReaderPtr reader,
 	    return(-1);
 	}
     }
-    xmlSchemaValidateSetLocator(reader->xsdValidCtxt,
-                                xmlTextReaderLocator,
-				(void *) reader);
     /*
     * Redirect the validation context's error channels to use
     * the reader channels.
@@ -5111,7 +5040,7 @@ xmlTextReaderSetup(xmlTextReaderPtr reader,
 	reader->allocs |= XML_TEXTREADER_INPUT;
     }
     if (reader->buffer == NULL)
-        reader->buffer = xmlBufCreateSize(100);
+        reader->buffer = xmlBufferCreateSize(100);
     if (reader->buffer == NULL) {
         xmlGenericError(xmlGenericErrorContext,
                         "xmlTextReaderSetup : malloc failed\n");
@@ -5152,14 +5081,13 @@ xmlTextReaderSetup(xmlTextReaderPtr reader,
     reader->node = NULL;
     reader->curnode = NULL;
     if (input != NULL) {
-        if (xmlBufUse(reader->input->buffer) < 4) {
+        if (reader->input->buffer->use < 4) {
             xmlParserInputBufferRead(input, 4);
         }
         if (reader->ctxt == NULL) {
-            if (xmlBufUse(reader->input->buffer) >= 4) {
+            if (reader->input->buffer->use >= 4) {
                 reader->ctxt = xmlCreatePushParserCtxt(reader->sax, NULL,
-		       (const char *) xmlBufContent(reader->input->buffer),
-                                      4, URL);
+		       (const char *) reader->input->buffer->content, 4, URL);
                 reader->base = 0;
                 reader->cur = 4;
             } else {
@@ -5188,7 +5116,10 @@ xmlTextReaderSetup(xmlTextReaderPtr reader,
 		inputStream->filename = (char *)
 		    xmlCanonicPath((const xmlChar *) URL);
 	    inputStream->buf = buf;
-            xmlBufResetInput(buf->buffer, inputStream);
+	    inputStream->base = inputStream->buf->buffer->content;
+	    inputStream->cur = inputStream->buf->buffer->content;
+	    inputStream->end =
+            &inputStream->buf->buffer->content[inputStream->buf->buffer->use];
 
 	    inputPush(reader->ctxt, inputStream);
 	    reader->cur = 0;