Upgrade to libxml 2.9.2 and libxslt 1.1.28

third_party/libxml/src/xmlIO.c

Index: third_party/libxml/src/xmlIO.c
diff --git a/third_party/libxml/src/xmlIO.c b/third_party/libxml/src/xmlIO.c
index 29623dc1eaa072f51c84273d9da9042895d7050d..e628ab094c9313d13be0985deca0ab37e408aba4 100644
--- a/third_party/libxml/src/xmlIO.c
+++ b/third_party/libxml/src/xmlIO.c
@@ -35,6 +35,9 @@
 #ifdef HAVE_ZLIB_H
 #include <zlib.h>
 #endif
+#ifdef HAVE_LZMA_H
+#include <lzma.h>
+#endif
 
 #if defined(WIN32) || defined(_WIN32)
 #include <windows.h>
@@ -85,12 +88,17 @@
 #include <libxml/parserInternals.h>
 #include <libxml/xmlIO.h>
 #include <libxml/uri.h>
+#include <libxml/nanohttp.h>
+#include <libxml/nanoftp.h>
 #include <libxml/xmlerror.h>
 #ifdef LIBXML_CATALOG_ENABLED
 #include <libxml/catalog.h>
 #endif
 #include <libxml/globals.h>
 
+#include "buf.h"
+#include "enc.h"
+
 /* #define VERBOSE_FAILURE */
 /* #define DEBUG_EXTERNAL_ENTITIES */
 /* #define DEBUG_INPUT */
@@ -763,13 +771,21 @@ int
 xmlCheckFilename (const char *path)
 {
 #ifdef HAVE_STAT
-	struct stat stat_buffer;
+    struct stat stat_buffer;
 #endif
-	if (path == NULL)
-		return(0);
+    if (path == NULL)
+	return(0);
 
 #ifdef HAVE_STAT
 #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
+    /*
+     * On Windows stat and wstat do not work with long pathname,
+     * which start with '\\?\'
+     */
+    if ((path[0] == '\\') && (path[1] == '\\') && (path[2] == '?') &&
+	(path[3] == '\\') )
+	    return 1;
+
     if (xmlWrapStat(path, &stat_buffer) == -1)
         return 0;
 #else
@@ -784,7 +800,14 @@ xmlCheckFilename (const char *path)
     return 1;
 }
 
-static int
+/**
+ * xmlNop:
+ *
+ * No Operation function, does nothing, no input
+ *
+ * Returns zero
+ */
+int
 xmlNop(void) {
     return(0);
 }
@@ -871,7 +894,7 @@ xmlFileMatch (const char *filename ATTRIBUTE_UNUSED) {
  */
 static void *
 xmlFileOpen_real (const char *filename) {
-    const char *path = NULL;
+    const char *path = filename;
     FILE *fd;
 
     if (filename == NULL)
@@ -901,11 +924,8 @@ xmlFileOpen_real (const char *filename) {
 #else
 	path = &filename[5];
 #endif
-    } else
-	path = filename;
+    }
 
-    if (path == NULL)
-	return(NULL);
     if (!xmlCheckFilename(path))
         return(NULL);
 
@@ -985,7 +1005,7 @@ xmlFileOpenW (const char *filename) {
 #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
     fd = xmlWrapOpen(path, 1);
 #else
- 	   fd = fopen(path, "wb");
+	   fd = fopen(path, "wb");
 #endif /* WIN32 */
 
 	 if (fd == NULL) xmlIOErr(0, path);
@@ -1143,7 +1163,12 @@ xmlGzfileOpen_real (const char *filename) {
     gzFile fd;
 
     if (!strcmp(filename, "-")) {
-        fd = gzdopen(dup(0), "rb");
+        int duped_fd = dup(fileno(stdin));
+        fd = gzdopen(duped_fd, "rb");
+        if (fd == Z_NULL && duped_fd >= 0) {
+            close(duped_fd);  /* gzdOpen() does not close on failure */
+        }
+
 	return((void *) fd);
     }
 
@@ -1217,7 +1242,12 @@ xmlGzfileOpenW (const char *filename, int compression) {
 
     snprintf(mode, sizeof(mode), "wb%d", compression);
     if (!strcmp(filename, "-")) {
-        fd = gzdopen(dup(1), mode);
+        int duped_fd = dup(fileno(stdout));
+        fd = gzdopen(duped_fd, "rb");
+        if (fd == Z_NULL && duped_fd >= 0) {
+            close(duped_fd);  /* gzdOpen() does not close on failure */
+        }
+
 	return((void *) fd);
     }
 
@@ -1304,6 +1334,125 @@ xmlGzfileClose (void * context) {
 }
 #endif /* HAVE_ZLIB_H */
 
+#ifdef HAVE_LZMA_H
+/************************************************************************
+ *									*
+ *		I/O for compressed file accesses			*
+ *									*
+ ************************************************************************/
+#include "xzlib.h"
+/**
+ * xmlXzfileMatch:
+ * @filename:  the URI for matching
+ *
+ * input from compressed file test
+ *
+ * Returns 1 if matches, 0 otherwise
+ */
+static int
+xmlXzfileMatch (const char *filename ATTRIBUTE_UNUSED) {
+    return(1);
+}
+
+/**
+ * xmlXzFileOpen_real:
+ * @filename:  the URI for matching
+ *
+ * input from compressed file open
+ * if @filename is " " then the standard input is used
+ *
+ * Returns an I/O context or NULL in case of error
+ */
+static void *
+xmlXzfileOpen_real (const char *filename) {
+    const char *path = NULL;
+    xzFile fd;
+
+    if (!strcmp(filename, "-")) {
+        fd = __libxml2_xzdopen(dup(fileno(stdin)), "rb");
+	return((void *) fd);
+    }
+
+    if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file://localhost/", 17)) {
+	path = &filename[16];
+    } else if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file:///", 8)) {
+	path = &filename[7];
+    } else if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file:/", 6)) {
+        /* lots of generators seems to lazy to read RFC 1738 */
+	path = &filename[5];
+    } else
+	path = filename;
+
+    if (path == NULL)
+	return(NULL);
+    if (!xmlCheckFilename(path))
+        return(NULL);
+
+    fd = __libxml2_xzopen(path, "rb");
+    return((void *) fd);
+}
+
+/**
+ * xmlXzfileOpen:
+ * @filename:  the URI for matching
+ *
+ * Wrapper around xmlXzfileOpen_real that try it with an unescaped
+ * version of @filename, if this fails fallback to @filename
+ *
+ * Returns a handler or NULL in case or failure
+ */
+static void *
+xmlXzfileOpen (const char *filename) {
+    char *unescaped;
+    void *retval;
+
+    retval = xmlXzfileOpen_real(filename);
+    if (retval == NULL) {
+	unescaped = xmlURIUnescapeString(filename, 0, NULL);
+	if (unescaped != NULL) {
+	    retval = xmlXzfileOpen_real(unescaped);
+	}
+	xmlFree(unescaped);
+    }
+
+    return retval;
+}
+
+/**
+ * xmlXzfileRead:
+ * @context:  the I/O context
+ * @buffer:  where to drop data
+ * @len:  number of bytes to write
+ *
+ * Read @len bytes to @buffer from the compressed I/O channel.
+ *
+ * Returns the number of bytes written
+ */
+static int
+xmlXzfileRead (void * context, char * buffer, int len) {
+    int ret;
+
+    ret = __libxml2_xzread((xzFile) context, &buffer[0], len);
+    if (ret < 0) xmlIOErr(0, "xzread()");
+    return(ret);
+}
+
+/**
+ * xmlXzfileClose:
+ * @context:  the I/O context
+ *
+ * Close a compressed I/O channel
+ */
+static int
+xmlXzfileClose (void * context) {
+    int ret;
+
+    ret =  (__libxml2_xzclose((xzFile) context) == LZMA_OK ) ? 0 : -1;
+    if (ret < 0) xmlIOErr(0, "xzclose()");
+    return(ret);
+}
+#endif /* HAVE_LZMA_H */
+
 #ifdef LIBXML_HTTP_ENABLED
 /************************************************************************
  *									*
@@ -1912,8 +2061,8 @@ xmlIOHTTPCloseWrite( void * context, const char * http_mthd ) {
 	/*  Pull the data out of the memory output buffer  */
 
 	xmlOutputBufferPtr	dctxt = ctxt->doc_buff;
-	http_content = (char *)dctxt->buffer->content;
-	content_lgth = dctxt->buffer->use;
+	http_content = (char *) xmlBufContent(dctxt->buffer);
+	content_lgth = xmlBufUse(dctxt->buffer);
     }
 
     if ( http_content == NULL ) {
@@ -2179,6 +2328,10 @@ xmlRegisterDefaultInputCallbacks(void) {
     xmlRegisterInputCallbacks(xmlGzfileMatch, xmlGzfileOpen,
 	                      xmlGzfileRead, xmlGzfileClose);
 #endif /* HAVE_ZLIB_H */
+#ifdef HAVE_LZMA_H
+    xmlRegisterInputCallbacks(xmlXzfileMatch, xmlXzfileOpen,
+	                      xmlXzfileRead, xmlXzfileClose);
+#endif /* HAVE_ZLIB_H */
 
 #ifdef LIBXML_HTTP_ENABLED
     xmlRegisterInputCallbacks(xmlIOHTTPMatch, xmlIOHTTPOpen,
@@ -2276,15 +2429,15 @@ xmlAllocParserInputBuffer(xmlCharEncoding enc) {
 	return(NULL);
     }
     memset(ret, 0, (size_t) sizeof(xmlParserInputBuffer));
-    ret->buffer = xmlBufferCreateSize(2 * xmlDefaultBufferSize);
+    ret->buffer = xmlBufCreateSize(2 * xmlDefaultBufferSize);
     if (ret->buffer == NULL) {
         xmlFree(ret);
 	return(NULL);
     }
-    ret->buffer->alloc = XML_BUFFER_ALLOC_DOUBLEIT;
+    xmlBufSetAllocationScheme(ret->buffer, XML_BUFFER_ALLOC_DOUBLEIT);
     ret->encoder = xmlGetCharEncodingHandler(enc);
     if (ret->encoder != NULL)
-        ret->raw = xmlBufferCreateSize(2 * xmlDefaultBufferSize);
+        ret->raw = xmlBufCreateSize(2 * xmlDefaultBufferSize);
     else
         ret->raw = NULL;
     ret->readcallback = NULL;
@@ -2315,19 +2468,19 @@ xmlAllocOutputBuffer(xmlCharEncodingHandlerPtr encoder) {
 	return(NULL);
     }
     memset(ret, 0, (size_t) sizeof(xmlOutputBuffer));
-    ret->buffer = xmlBufferCreate();
+    ret->buffer = xmlBufCreate();
     if (ret->buffer == NULL) {
         xmlFree(ret);
 	return(NULL);
     }
 
     /* try to avoid a performance problem with Windows realloc() */
-    if (ret->buffer->alloc == XML_BUFFER_ALLOC_EXACT)
-        ret->buffer->alloc = XML_BUFFER_ALLOC_DOUBLEIT;
+    if (xmlBufGetAllocationScheme(ret->buffer) == XML_BUFFER_ALLOC_EXACT)
+        xmlBufSetAllocationScheme(ret->buffer, XML_BUFFER_ALLOC_DOUBLEIT);
 
     ret->encoder = encoder;
     if (encoder != NULL) {
-        ret->conv = xmlBufferCreateSize(4000);
+        ret->conv = xmlBufCreateSize(4000);
 	if (ret->conv == NULL) {
 	    xmlFree(ret);
 	    return(NULL);
@@ -2336,7 +2489,7 @@ xmlAllocOutputBuffer(xmlCharEncodingHandlerPtr encoder) {
 	/*
 	 * This call is designed to initiate the encoder state
 	 */
-	xmlCharEncOutFunc(encoder, ret->conv, NULL);
+	xmlCharEncOutput(ret, 1);
     } else
         ret->conv = NULL;
     ret->writecallback = NULL;
@@ -2365,7 +2518,7 @@ xmlAllocOutputBufferInternal(xmlCharEncodingHandlerPtr encoder) {
 	return(NULL);
     }
     memset(ret, 0, (size_t) sizeof(xmlOutputBuffer));
-    ret->buffer = xmlBufferCreate();
+    ret->buffer = xmlBufCreate();
     if (ret->buffer == NULL) {
         xmlFree(ret);
 	return(NULL);
@@ -2374,15 +2527,12 @@ xmlAllocOutputBufferInternal(xmlCharEncodingHandlerPtr encoder) {
 
     /*
      * For conversion buffers we use the special IO handling
-     * We don't do that from the exported API to avoid confusing
-     * user's code.
      */
-    ret->buffer->alloc = XML_BUFFER_ALLOC_IO;
-    ret->buffer->contentIO = ret->buffer->content;
+    xmlBufSetAllocationScheme(ret->buffer, XML_BUFFER_ALLOC_IO);
 
     ret->encoder = encoder;
     if (encoder != NULL) {
-        ret->conv = xmlBufferCreateSize(4000);
+        ret->conv = xmlBufCreateSize(4000);
 	if (ret->conv == NULL) {
 	    xmlFree(ret);
 	    return(NULL);
@@ -2391,7 +2541,7 @@ xmlAllocOutputBufferInternal(xmlCharEncodingHandlerPtr encoder) {
 	/*
 	 * This call is designed to initiate the encoder state
 	 */
-	xmlCharEncOutFunc(encoder, ret->conv, NULL);
+        xmlCharEncOutput(ret, 1);
     } else
         ret->conv = NULL;
     ret->writecallback = NULL;
@@ -2415,7 +2565,7 @@ xmlFreeParserInputBuffer(xmlParserInputBufferPtr in) {
     if (in == NULL) return;
 
     if (in->raw) {
-        xmlBufferFree(in->raw);
+        xmlBufFree(in->raw);
 	in->raw = NULL;
     }
     if (in->encoder != NULL) {
@@ -2425,7 +2575,7 @@ xmlFreeParserInputBuffer(xmlParserInputBufferPtr in) {
 	in->closecallback(in->context);
     }
     if (in->buffer != NULL) {
-        xmlBufferFree(in->buffer);
+        xmlBufFree(in->buffer);
 	in->buffer = NULL;
     }
 
@@ -2457,14 +2607,14 @@ xmlOutputBufferClose(xmlOutputBufferPtr out)
     }
     written = out->written;
     if (out->conv) {
-        xmlBufferFree(out->conv);
+        xmlBufFree(out->conv);
         out->conv = NULL;
     }
     if (out->encoder != NULL) {
         xmlCharEncCloseFunc(out->encoder);
     }
     if (out->buffer != NULL) {
-        xmlBufferFree(out->buffer);
+        xmlBufFree(out->buffer);
         out->buffer = NULL;
     }
 
@@ -2533,6 +2683,12 @@ __xmlParserInputBufferCreateFilename(const char *URI, xmlCharEncoding enc) {
 #endif
 	}
 #endif
+#ifdef HAVE_LZMA_H
+	if ((xmlInputCallbackTable[i].opencallback == xmlXzfileOpen) &&
+		(strcmp(URI, "-") != 0)) {
+            ret->compressed = __libxml2_xzcompressed(context);
+	}
+#endif
     }
     else
       xmlInputCallbackTable[i].closecallback (context);
@@ -2794,6 +2950,39 @@ xmlOutputBufferCreateBuffer(xmlBufferPtr buffer,
     return(ret);
 }
 
+/**
+ * xmlOutputBufferGetContent:
+ * @out:  an xmlOutputBufferPtr
+ *
+ * Gives a pointer to the data currently held in the output buffer
+ *
+ * Returns a pointer to the data or NULL in case of error
+ */
+const xmlChar *
+xmlOutputBufferGetContent(xmlOutputBufferPtr out) {
+    if ((out == NULL) || (out->buffer == NULL))
+        return(NULL);
+
+    return(xmlBufContent(out->buffer));
+}
+
+/**
+ * xmlOutputBufferGetSize:
+ * @out:  an xmlOutputBufferPtr
+ *
+ * Gives the length of the data currently held in the output buffer
+ *
+ * Returns 0 in case or error or no data is held, the size otherwise
+ */
+size_t
+xmlOutputBufferGetSize(xmlOutputBufferPtr out) {
+    if ((out == NULL) || (out->buffer == NULL))
+        return(0);
+
+    return(xmlBufUse(out->buffer));
+}
+
+
 #endif /* LIBXML_OUTPUT_ENABLED */
 
 /**
@@ -2846,7 +3035,7 @@ xmlParserInputBufferCreateMem(const char *mem, int size, xmlCharEncoding enc) {
         ret->context = (void *) mem;
 	ret->readcallback = (xmlInputReadCallback) xmlNop;
 	ret->closecallback = NULL;
-	errcode = xmlBufferAdd(ret->buffer, (const xmlChar *) mem, size);
+	errcode = xmlBufAdd(ret->buffer, (const xmlChar *) mem, size);
 	if (errcode != 0) {
 	    xmlFree(ret);
 	    return(NULL);
@@ -2883,14 +3072,14 @@ xmlParserInputBufferCreateStatic(const char *mem, int size,
 	return(NULL);
     }
     memset(ret, 0, (size_t) sizeof(xmlParserInputBuffer));
-    ret->buffer = xmlBufferCreateStatic((void *)mem, (size_t) size);
+    ret->buffer = xmlBufCreateStatic((void *)mem, (size_t) size);
     if (ret->buffer == NULL) {
         xmlFree(ret);
 	return(NULL);
     }
     ret->encoder = xmlGetCharEncodingHandler(enc);
     if (ret->encoder != NULL)
-        ret->raw = xmlBufferCreateSize(2 * xmlDefaultBufferSize);
+        ret->raw = xmlBufCreateSize(2 * xmlDefaultBufferSize);
     else
         ret->raw = NULL;
     ret->compressed = -1;
@@ -3059,33 +3248,33 @@ xmlParserInputBufferPush(xmlParserInputBufferPtr in,
 	 * Store the data in the incoming raw buffer
 	 */
         if (in->raw == NULL) {
-	    in->raw = xmlBufferCreate();
+	    in->raw = xmlBufCreate();
 	}
-	ret = xmlBufferAdd(in->raw, (const xmlChar *) buf, len);
+	ret = xmlBufAdd(in->raw, (const xmlChar *) buf, len);
 	if (ret != 0)
 	    return(-1);
 
 	/*
 	 * convert as much as possible to the parser reading buffer.
 	 */
-	use = in->raw->use;
-	nbchars = xmlCharEncInFunc(in->encoder, in->buffer, in->raw);
+	use = xmlBufUse(in->raw);
+	nbchars = xmlCharEncInput(in, 1);
 	if (nbchars < 0) {
 	    xmlIOErr(XML_IO_ENCODER, NULL);
 	    in->error = XML_IO_ENCODER;
 	    return(-1);
 	}
-	in->rawconsumed += (use - in->raw->use);
+	in->rawconsumed += (use - xmlBufUse(in->raw));
     } else {
 	nbchars = len;
-        ret = xmlBufferAdd(in->buffer, (xmlChar *) buf, nbchars);
+        ret = xmlBufAdd(in->buffer, (xmlChar *) buf, nbchars);
 	if (ret != 0)
 	    return(-1);
     }
 #ifdef DEBUG_INPUT
     xmlGenericError(xmlGenericErrorContext,
 	    "I/O: pushed %d chars, buffer %d/%d\n",
-            nbchars, in->buffer->use, in->buffer->size);
+            nbchars, xmlBufUse(in->buffer), xmlBufLength(in->buffer));
 #endif
     return(nbchars);
 }
@@ -3123,29 +3312,23 @@ xmlParserInputBufferGrow(xmlParserInputBufferPtr in, int len) {
     char *buffer = NULL;
     int res = 0;
     int nbchars = 0;
-    int buffree;
-    unsigned int needSize;
 
     if ((in == NULL) || (in->error)) return(-1);
     if ((len <= MINLEN) && (len != 4))
         len = MINLEN;
 
-    buffree = in->buffer->size - in->buffer->use;
-    if (buffree <= 0) {
+    if (xmlBufAvail(in->buffer) <= 0) {
 	xmlIOErr(XML_IO_BUFFER_FULL, NULL);
 	in->error = XML_IO_BUFFER_FULL;
 	return(-1);
     }
 
-    needSize = in->buffer->use + len + 1;
-    if (needSize > in->buffer->size){
-        if (!xmlBufferResize(in->buffer, needSize)){
-	    xmlIOErrMemory("growing input buffer");
-	    in->error = XML_ERR_NO_MEMORY;
-            return(-1);
-        }
+    if (xmlBufGrow(in->buffer, len + 1) < 0) {
+        xmlIOErrMemory("growing input buffer");
+        in->error = XML_ERR_NO_MEMORY;
+        return(-1);
     }
-    buffer = (char *)&in->buffer->content[in->buffer->use];
+    buffer = (char *)xmlBufEnd(in->buffer);
 
     /*
      * Call the read method for this I/O type.
@@ -3162,6 +3345,17 @@ xmlParserInputBufferGrow(xmlParserInputBufferPtr in, int len) {
     if (res < 0) {
 	return(-1);
     }
+
+    /*
+     * try to establish compressed status of input if not done already
+     */
+    if (in->compressed == -1) {
+#ifdef HAVE_LZMA_H
+	if (in->readcallback == xmlXzfileRead)
+            in->compressed = __libxml2_xzcompressed(in->context);
+#endif
+    }
+
     len = res;
     if (in->encoder != NULL) {
         unsigned int use;
@@ -3170,32 +3364,31 @@ xmlParserInputBufferGrow(xmlParserInputBufferPtr in, int len) {
 	 * Store the data in the incoming raw buffer
 	 */
         if (in->raw == NULL) {
-	    in->raw = xmlBufferCreate();
+	    in->raw = xmlBufCreate();
 	}
-	res = xmlBufferAdd(in->raw, (const xmlChar *) buffer, len);
+	res = xmlBufAdd(in->raw, (const xmlChar *) buffer, len);
 	if (res != 0)
 	    return(-1);
 
 	/*
 	 * convert as much as possible to the parser reading buffer.
 	 */
-	use = in->raw->use;
-	nbchars = xmlCharEncInFunc(in->encoder, in->buffer, in->raw);
+	use = xmlBufUse(in->raw);
+	nbchars = xmlCharEncInput(in, 1);
 	if (nbchars < 0) {
 	    xmlIOErr(XML_IO_ENCODER, NULL);
 	    in->error = XML_IO_ENCODER;
 	    return(-1);
 	}
-	in->rawconsumed += (use - in->raw->use);
+	in->rawconsumed += (use - xmlBufUse(in->raw));
     } else {
 	nbchars = len;
-   	in->buffer->use += nbchars;
-	buffer[nbchars] = 0;
+        xmlBufAddLen(in->buffer, nbchars);
     }
 #ifdef DEBUG_INPUT
     xmlGenericError(xmlGenericErrorContext,
-	    "I/O: read %d chars, buffer %d/%d\n",
-            nbchars, in->buffer->use, in->buffer->size);
+	    "I/O: read %d chars, buffer %d\n",
+            nbchars, xmlBufUse(in->buffer));
 #endif
     return(nbchars);
 }
@@ -3217,8 +3410,7 @@ xmlParserInputBufferRead(xmlParserInputBufferPtr in, int len) {
     if ((in == NULL) || (in->error)) return(-1);
     if (in->readcallback != NULL)
 	return(xmlParserInputBufferGrow(in, len));
-    else if ((in->buffer != NULL) &&
-             (in->buffer->alloc == XML_BUFFER_ALLOC_IMMUTABLE))
+    else if (xmlBufGetAllocationScheme(in->buffer) == XML_BUFFER_ALLOC_IMMUTABLE)
 	return(0);
     else
         return(-1);
@@ -3263,30 +3455,30 @@ xmlOutputBufferWrite(xmlOutputBufferPtr out, int len, const char *buf) {
 	     * Store the data in the incoming raw buffer
 	     */
 	    if (out->conv == NULL) {
-		out->conv = xmlBufferCreate();
+		out->conv = xmlBufCreate();
 	    }
-	    ret = xmlBufferAdd(out->buffer, (const xmlChar *) buf, chunk);
+	    ret = xmlBufAdd(out->buffer, (const xmlChar *) buf, chunk);
 	    if (ret != 0)
 	        return(-1);
 
-	    if ((out->buffer->use < MINLEN) && (chunk == len))
+	    if ((xmlBufUse(out->buffer) < MINLEN) && (chunk == len))
 		goto done;
 
 	    /*
 	     * convert as much as possible to the parser reading buffer.
 	     */
-	    ret = xmlCharEncOutFunc(out->encoder, out->conv, out->buffer);
+	    ret = xmlCharEncOutput(out, 0);
 	    if ((ret < 0) && (ret != -3)) {
 		xmlIOErr(XML_IO_ENCODER, NULL);
 		out->error = XML_IO_ENCODER;
 		return(-1);
 	    }
-	    nbchars = out->conv->use;
+	    nbchars = xmlBufUse(out->conv);
 	} else {
-	    ret = xmlBufferAdd(out->buffer, (const xmlChar *) buf, chunk);
+	    ret = xmlBufAdd(out->buffer, (const xmlChar *) buf, chunk);
 	    if (ret != 0)
 	        return(-1);
-	    nbchars = out->buffer->use;
+	    nbchars = xmlBufUse(out->buffer);
 	}
 	buf += chunk;
 	len -= chunk;
@@ -3300,14 +3492,14 @@ xmlOutputBufferWrite(xmlOutputBufferPtr out, int len, const char *buf) {
 	     */
 	    if (out->encoder != NULL) {
 		ret = out->writecallback(out->context,
-				 (const char *)out->conv->content, nbchars);
+                           (const char *)xmlBufContent(out->conv), nbchars);
 		if (ret >= 0)
-		    xmlBufferShrink(out->conv, ret);
+		    xmlBufShrink(out->conv, ret);
 	    } else {
 		ret = out->writecallback(out->context,
-				 (const char *)out->buffer->content, nbchars);
+                           (const char *)xmlBufContent(out->buffer), nbchars);
 		if (ret >= 0)
-		    xmlBufferShrink(out->buffer, ret);
+		    xmlBufShrink(out->buffer, ret);
 	    }
 	    if (ret < 0) {
 		xmlIOErr(XML_IO_WRITE, NULL);
@@ -3351,7 +3543,7 @@ xmlEscapeContent(unsigned char* out, int *outlen,
     inend = in + (*inlen);
 
     while ((in < inend) && (out < outend)) {
-   	if (*in == '<') {
+	if (*in == '<') {
 	    if (outend - out < 4) break;
 	    *out++ = '&';
 	    *out++ = 'l';
@@ -3415,7 +3607,8 @@ xmlOutputBufferWriteEscape(xmlOutputBufferPtr out, const xmlChar *str,
 
     if ((out == NULL) || (out->error) || (str == NULL) ||
         (out->buffer == NULL) ||
-	(out->buffer->alloc == XML_BUFFER_ALLOC_IMMUTABLE)) return(-1);
+	(xmlBufGetAllocationScheme(out->buffer) == XML_BUFFER_ALLOC_IMMUTABLE))
+        return(-1);
     len = strlen((const char *)str);
     if (len < 0) return(0);
     if (out->error) return(-1);
@@ -3428,14 +3621,14 @@ xmlOutputBufferWriteEscape(xmlOutputBufferPtr out, const xmlChar *str,
 	 * how many bytes to consume and how many bytes to store.
 	 */
 	cons = len;
-	chunk = (out->buffer->size - out->buffer->use) - 1;
+	chunk = xmlBufAvail(out->buffer) - 1;
 
         /*
 	 * make sure we have enough room to save first, if this is
 	 * not the case force a flush, but make sure we stay in the loop
 	 */
 	if (chunk < 40) {
-	    if (xmlBufferGrow(out->buffer, out->buffer->size + 100) < 0)
+	    if (xmlBufGrow(out->buffer, 100) < 0)
 	        return(-1);
             oldwritten = -1;
 	    continue;
@@ -3449,36 +3642,33 @@ xmlOutputBufferWriteEscape(xmlOutputBufferPtr out, const xmlChar *str,
 	     * Store the data in the incoming raw buffer
 	     */
 	    if (out->conv == NULL) {
-		out->conv = xmlBufferCreate();
+		out->conv = xmlBufCreate();
 	    }
-	    ret = escaping(out->buffer->content + out->buffer->use ,
+	    ret = escaping(xmlBufEnd(out->buffer) ,
 	                   &chunk, str, &cons);
 	    if ((ret < 0) || (chunk == 0)) /* chunk==0 => nothing done */
 	        return(-1);
-	    out->buffer->use += chunk;
-	    out->buffer->content[out->buffer->use] = 0;
+            xmlBufAddLen(out->buffer, chunk);
 
-	    if ((out->buffer->use < MINLEN) && (cons == len))
+	    if ((xmlBufUse(out->buffer) < MINLEN) && (cons == len))
 		goto done;
 
 	    /*
 	     * convert as much as possible to the output buffer.
 	     */
-	    ret = xmlCharEncOutFunc(out->encoder, out->conv, out->buffer);
+	    ret = xmlCharEncOutput(out, 0);
 	    if ((ret < 0) && (ret != -3)) {
 		xmlIOErr(XML_IO_ENCODER, NULL);
 		out->error = XML_IO_ENCODER;
 		return(-1);
 	    }
-	    nbchars = out->conv->use;
+	    nbchars = xmlBufUse(out->conv);
 	} else {
-	    ret = escaping(out->buffer->content + out->buffer->use ,
-	                   &chunk, str, &cons);
+	    ret = escaping(xmlBufEnd(out->buffer), &chunk, str, &cons);
 	    if ((ret < 0) || (chunk == 0)) /* chunk==0 => nothing done */
 	        return(-1);
-	    out->buffer->use += chunk;
-	    out->buffer->content[out->buffer->use] = 0;
-	    nbchars = out->buffer->use;
+            xmlBufAddLen(out->buffer, chunk);
+	    nbchars = xmlBufUse(out->buffer);
 	}
 	str += cons;
 	len -= cons;
@@ -3492,14 +3682,14 @@ xmlOutputBufferWriteEscape(xmlOutputBufferPtr out, const xmlChar *str,
 	     */
 	    if (out->encoder != NULL) {
 		ret = out->writecallback(out->context,
-				 (const char *)out->conv->content, nbchars);
+                           (const char *)xmlBufContent(out->conv), nbchars);
 		if (ret >= 0)
-		    xmlBufferShrink(out->conv, ret);
+		    xmlBufShrink(out->conv, ret);
 	    } else {
 		ret = out->writecallback(out->context,
-				 (const char *)out->buffer->content, nbchars);
+                           (const char *)xmlBufContent(out->buffer), nbchars);
 		if (ret >= 0)
-		    xmlBufferShrink(out->buffer, ret);
+		    xmlBufShrink(out->buffer, ret);
 	    }
 	    if (ret < 0) {
 		xmlIOErr(XML_IO_WRITE, NULL);
@@ -3507,8 +3697,8 @@ xmlOutputBufferWriteEscape(xmlOutputBufferPtr out, const xmlChar *str,
 		return(ret);
 	    }
 	    out->written += ret;
-	} else if (out->buffer->size - out->buffer->use < MINLEN) {
-	    xmlBufferResize(out->buffer, out->buffer->size + MINLEN);
+	} else if (xmlBufAvail(out->buffer) < MINLEN) {
+	    xmlBufGrow(out->buffer, MINLEN);
 	}
 	written += nbchars;
     } while ((len > 0) && (oldwritten != written));
@@ -3566,14 +3756,16 @@ xmlOutputBufferFlush(xmlOutputBufferPtr out) {
      */
     if ((out->conv != NULL) && (out->encoder != NULL)) {
 	/*
-	 * convert as much as possible to the parser reading buffer.
+	 * convert as much as possible to the parser output buffer.
 	 */
-	nbchars = xmlCharEncOutFunc(out->encoder, out->conv, out->buffer);
-	if (nbchars < 0) {
-	    xmlIOErr(XML_IO_ENCODER, NULL);
-	    out->error = XML_IO_ENCODER;
-	    return(-1);
-	}
+	do {
+	    nbchars = xmlCharEncOutput(out, 0);
+	    if (nbchars < 0) {
+		xmlIOErr(XML_IO_ENCODER, NULL);
+		out->error = XML_IO_ENCODER;
+		return(-1);
+	    }
+	} while (nbchars);
     }
 
     /*
@@ -3582,14 +3774,16 @@ xmlOutputBufferFlush(xmlOutputBufferPtr out) {
     if ((out->conv != NULL) && (out->encoder != NULL) &&
 	(out->writecallback != NULL)) {
 	ret = out->writecallback(out->context,
-	           (const char *)out->conv->content, out->conv->use);
+                                 (const char *)xmlBufContent(out->conv),
+                                 xmlBufUse(out->conv));
 	if (ret >= 0)
-	    xmlBufferShrink(out->conv, ret);
+	    xmlBufShrink(out->conv, ret);
     } else if (out->writecallback != NULL) {
 	ret = out->writecallback(out->context,
-	           (const char *)out->buffer->content, out->buffer->use);
+                                 (const char *)xmlBufContent(out->buffer),
+                                 xmlBufUse(out->buffer));
 	if (ret >= 0)
-	    xmlBufferShrink(out->buffer, ret);
+	    xmlBufShrink(out->buffer, ret);
     }
     if (ret < 0) {
 	xmlIOErr(XML_IO_FLUSH, NULL);