Upgrade to libxml 2.9.2 and libxslt 1.1.28

third_party/libxml/src/xmlsave.c

 /*
  * xmlsave.c: Implemetation of the document serializer
  *
  * See Copyright for the status of this software.
  *
  * daniel@veillard.com
  */
 
 #define IN_LIBXML
 #include "libxml.h"
 
 #include <string.h>
 #include <libxml/xmlmemory.h>
 #include <libxml/parserInternals.h>
 #include <libxml/tree.h>
 #include <libxml/xmlsave.h>
 
 #define MAX_INDENT 60
 
 #include <libxml/HTMLtree.h>
 
+#include "buf.h"
+#include "enc.h"
+#include "save.h"
+
 /************************************************************************
  *                                                                      *
  *                      XHTML detection                                 *
  *                                                                      *
  ************************************************************************/
 #define XHTML_STRICT_PUBLIC_ID BAD_CAST \
    "-//W3C//DTD XHTML 1.0 Strict//EN"
 #define XHTML_STRICT_SYSTEM_ID BAD_CAST \
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"
 #define XHTML_FRAME_PUBLIC_ID BAD_CAST \
@@ skipping 27 matching lines @@
     if (systemID != NULL) {
         if (xmlStrEqual(systemID, XHTML_STRICT_SYSTEM_ID)) return(1);
         if (xmlStrEqual(systemID, XHTML_FRAME_SYSTEM_ID)) return(1);
         if (xmlStrEqual(systemID, XHTML_TRANS_SYSTEM_ID)) return(1);
     }
     return(0);
 }
 
 #ifdef LIBXML_OUTPUT_ENABLED
 
-#define TODO                                                            \
+#define TODO                                                            \
     xmlGenericError(xmlGenericErrorContext,                             \
             "Unimplemented block at %s:%d\n",                           \
             __FILE__, __LINE__);
 
 struct _xmlSaveCtxt {
     void *_private;
     int type;
     int fd;
     const xmlChar *filename;
     const xmlChar *encoding;
     xmlCharEncodingHandlerPtr handler;
     xmlOutputBufferPtr buf;
     xmlDocPtr doc;
     int options;
     int level;
     int format;
     char indent[MAX_INDENT + 1];        /* array for indenting output */
     int indent_nr;
     int indent_size;
     xmlCharEncodingOutputFunc escape;   /* used for element content */
     xmlCharEncodingOutputFunc escapeAttr;/* used for attribute content */
 };
 
 /************************************************************************
  *                                                                      *
- *                      Output error handlers                           *
+ *                      Output error handlers                           *
  *                                                                      *
  ************************************************************************/
 /**
  * xmlSaveErrMemory:
  * @extra:  extra informations
  *
  * Handle an out of memory condition
  */
 static void
 xmlSaveErrMemory(const char *extra)
@@ skipping 97 matching lines @@
 static int
 xmlEscapeEntities(unsigned char* out, int *outlen,
                  const xmlChar* in, int *inlen) {
     unsigned char* outstart = out;
     const unsigned char* base = in;
     unsigned char* outend = out + *outlen;
     const unsigned char* inend;
     int val;
 
     inend = in + (*inlen);
-    
+
     while ((in < inend) && (out < outend)) {
-        if (*in == '<') {
+        if (*in == '<') {
             if (outend - out < 4) break;
             *out++ = '&';
             *out++ = 'l';
             *out++ = 't';
             *out++ = ';';
             in++;
             continue;
         } else if (*in == '>') {
             if (outend - out < 4) break;
             *out++ = '&';
@@ skipping 175 matching lines @@
      */
 
     /* Re-check this option as it may already have been set */
     if ((ret->options & XML_SAVE_NO_EMPTY) && ! (options & XML_SAVE_NO_EMPTY)) {
         options |= XML_SAVE_NO_EMPTY;
     }
 
     ret->options = options;
     if (options & XML_SAVE_FORMAT)
         ret->format = 1;
+    else if (options & XML_SAVE_WSNONSIG)
+        ret->format = 2;
 
     return(ret);
 }
 
 /************************************************************************
  *                                                                      *
- *              Dumping XML tree content to a simple buffer             *
+ *              Dumping XML tree content to a simple buffer             *
  *                                                                      *
  ************************************************************************/
 /**
  * xmlAttrSerializeContent:
  * @buf:  the XML buffer output
  * @doc:  the document
  * @attr:  the attribute pointer
  *
  * Serialize the attribute in the buffer
  */
 static void
 xmlAttrSerializeContent(xmlOutputBufferPtr buf, xmlAttrPtr attr)
 {
     xmlNodePtr children;
 
     children = attr->children;
     while (children != NULL) {
         switch (children->type) {
             case XML_TEXT_NODE:
-                xmlAttrSerializeTxtContent(buf->buffer, attr->doc,
-                                           attr, children->content);
+                xmlBufAttrSerializeTxtContent(buf->buffer, attr->doc,
+                                              attr, children->content);
                 break;
             case XML_ENTITY_REF_NODE:
-                xmlBufferAdd(buf->buffer, BAD_CAST "&", 1);
-                xmlBufferAdd(buf->buffer, children->name,
+                xmlBufAdd(buf->buffer, BAD_CAST "&", 1);
+                xmlBufAdd(buf->buffer, children->name,
                              xmlStrlen(children->name));
-                xmlBufferAdd(buf->buffer, BAD_CAST ";", 1);
+                xmlBufAdd(buf->buffer, BAD_CAST ";", 1);
                 break;
             default:
                 /* should not happen unless we have a badly built tree */
                 break;
         }
         children = children->next;
     }
 }
 
+/**
+ * xmlBufDumpNotationTable:
+ * @buf:  an xmlBufPtr output
+ * @table:  A notation table
+ *
+ * This will dump the content of the notation table as an XML DTD definition
+ */
+void
+xmlBufDumpNotationTable(xmlBufPtr buf, xmlNotationTablePtr table) {
+    xmlBufferPtr buffer;
+
+    buffer = xmlBufferCreate();
+    if (buffer == NULL) {
+        /*
+         * TODO set the error in buf
+         */
+        return;
+    }
+    xmlDumpNotationTable(buffer, table);
+    xmlBufMergeBuffer(buf, buffer);
+}
+
+/**
+ * xmlBufDumpElementDecl:
+ * @buf:  an xmlBufPtr output
+ * @elem:  An element table
+ *
+ * This will dump the content of the element declaration as an XML
+ * DTD definition
+ */
+void
+xmlBufDumpElementDecl(xmlBufPtr buf, xmlElementPtr elem) {
+    xmlBufferPtr buffer;
+
+    buffer = xmlBufferCreate();
+    if (buffer == NULL) {
+        /*
+         * TODO set the error in buf
+         */
+        return;
+    }
+    xmlDumpElementDecl(buffer, elem);
+    xmlBufMergeBuffer(buf, buffer);
+}
+
+/**
+ * xmlBufDumpAttributeDecl:
+ * @buf:  an xmlBufPtr output
+ * @attr:  An attribute declaration
+ *
+ * This will dump the content of the attribute declaration as an XML
+ * DTD definition
+ */
+void
+xmlBufDumpAttributeDecl(xmlBufPtr buf, xmlAttributePtr attr) {
+    xmlBufferPtr buffer;
+
+    buffer = xmlBufferCreate();
+    if (buffer == NULL) {
+        /*
+         * TODO set the error in buf
+         */
+        return;
+    }
+    xmlDumpAttributeDecl(buffer, attr);
+    xmlBufMergeBuffer(buf, buffer);
+}
+
+/**
+ * xmlBufDumpEntityDecl:
+ * @buf:  an xmlBufPtr output
+ * @ent:  An entity table
+ *
+ * This will dump the content of the entity table as an XML DTD definition
+ */
+void
+xmlBufDumpEntityDecl(xmlBufPtr buf, xmlEntityPtr ent) {
+    xmlBufferPtr buffer;
+
+    buffer = xmlBufferCreate();
+    if (buffer == NULL) {
+        /*
+         * TODO set the error in buf
+         */
+        return;
+    }
+    xmlDumpEntityDecl(buffer, ent);
+    xmlBufMergeBuffer(buf, buffer);
+}
+
 /************************************************************************
  *                                                                      *
- *              Dumping XML tree content to an I/O output buffer        *
+ *              Dumping XML tree content to an I/O output buffer        *
  *                                                                      *
  ************************************************************************/
 
 static int xmlSaveSwitchEncoding(xmlSaveCtxtPtr ctxt, const char *encoding) {
     xmlOutputBufferPtr buf = ctxt->buf;
 
     if ((encoding != NULL) && (buf->encoder == NULL) && (buf->conv == NULL)) {
         buf->encoder = xmlFindCharEncodingHandler((const char *)encoding);
         if (buf->encoder == NULL) {
             xmlSaveErr(XML_SAVE_UNKNOWN_ENCODING, NULL,
                        (const char *)encoding);
             return(-1);
         }
-        buf->conv = xmlBufferCreate();
+        buf->conv = xmlBufCreate();
         if (buf->conv == NULL) {
             xmlCharEncCloseFunc(buf->encoder);
             xmlSaveErrMemory("creating encoding buffer");
             return(-1);
         }
         /*
          * initialize the state, e.g. if outputting a BOM
          */
-        xmlCharEncOutFunc(buf->encoder, buf->conv, NULL);
+        xmlCharEncOutput(buf, 1);
     }
     return(0);
 }
 
 static int xmlSaveClearEncoding(xmlSaveCtxtPtr ctxt) {
     xmlOutputBufferPtr buf = ctxt->buf;
     xmlOutputBufferFlush(buf);
     xmlCharEncCloseFunc(buf->encoder);
-    xmlBufferFree(buf->conv);
+    xmlBufFree(buf->conv);
     buf->encoder = NULL;
     buf->conv = NULL;
     return(0);
 }
 
 #ifdef LIBXML_HTML_ENABLED
 static void
 xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cur);
 #endif
 static void xmlNodeListDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cur);
 static void xmlNodeDumpOutputInternal(xmlSaveCtxtPtr ctxt, xmlNodePtr cur);
 void xmlNsListDumpOutput(xmlOutputBufferPtr buf, xmlNsPtr cur);
 static int xmlDocContentDumpOutput(xmlSaveCtxtPtr ctxt, xmlDocPtr cur);
 
 /**
+ * xmlOutputBufferWriteWSNonSig:
+ * @ctxt:  The save context
+ * @extra: Number of extra indents to apply to ctxt->level
+ *
+ * Write out formatting for non-significant whitespace output.
+ */
+static void
+xmlOutputBufferWriteWSNonSig(xmlSaveCtxtPtr ctxt, int extra)
+{
+    int i;
+    if ((ctxt == NULL) || (ctxt->buf == NULL))
+        return;
+    xmlOutputBufferWrite(ctxt->buf, 1, "\n");
+    for (i = 0; i < (ctxt->level + extra); i += ctxt->indent_nr) {
+        xmlOutputBufferWrite(ctxt->buf, ctxt->indent_size *
+                ((ctxt->level + extra - i) > ctxt->indent_nr ?
+                 ctxt->indent_nr : (ctxt->level + extra - i)),
+                ctxt->indent);
+    }
+}
+
+/**
  * xmlNsDumpOutput:
  * @buf:  the XML buffer output
  * @cur:  a namespace
+ * @ctxt: the output save context. Optional.
  *
  * Dump a local Namespace definition.
  * Should be called in the context of attributes dumps.
+ * If @ctxt is supplied, @buf should be its buffer.
  */
 static void
-xmlNsDumpOutput(xmlOutputBufferPtr buf, xmlNsPtr cur) {
+xmlNsDumpOutput(xmlOutputBufferPtr buf, xmlNsPtr cur, xmlSaveCtxtPtr ctxt) {
     if ((cur == NULL) || (buf == NULL)) return;
     if ((cur->type == XML_LOCAL_NAMESPACE) && (cur->href != NULL)) {
         if (xmlStrEqual(cur->prefix, BAD_CAST "xml"))
             return;
 
+        if (ctxt != NULL && ctxt->format == 2)
+            xmlOutputBufferWriteWSNonSig(ctxt, 2);
+        else
+            xmlOutputBufferWrite(buf, 1, " ");
+
         /* Within the context of an element attributes */
         if (cur->prefix != NULL) {
-            xmlOutputBufferWrite(buf, 7, " xmlns:");
+            xmlOutputBufferWrite(buf, 6, "xmlns:");
             xmlOutputBufferWriteString(buf, (const char *)cur->prefix);
         } else
-            xmlOutputBufferWrite(buf, 6, " xmlns");
+            xmlOutputBufferWrite(buf, 5, "xmlns");
         xmlOutputBufferWrite(buf, 1, "=");
-        xmlBufferWriteQuotedString(buf->buffer, cur->href);
+        xmlBufWriteQuotedString(buf->buffer, cur->href);
     }
 }
 
+/**
+ * xmlNsDumpOutputCtxt
+ * @ctxt: the save context
+ * @cur:  a namespace
+ *
+ * Dump a local Namespace definition to a save context.
+ * Should be called in the context of attribute dumps.
+ */
+static void
+xmlNsDumpOutputCtxt(xmlSaveCtxtPtr ctxt, xmlNsPtr cur) {
+    xmlNsDumpOutput(ctxt->buf, cur, ctxt);
+}
+
+/**
+ * xmlNsListDumpOutputCtxt
+ * @ctxt: the save context
+ * @cur:  the first namespace
+ *
+ * Dump a list of local namespace definitions to a save context.
+ * Should be called in the context of attribute dumps.
+ */
+static void
+xmlNsListDumpOutputCtxt(xmlSaveCtxtPtr ctxt, xmlNsPtr cur) {
+    while (cur != NULL) {
+        xmlNsDumpOutput(ctxt->buf, cur, ctxt);
+        cur = cur->next;
+    }
+}
+
 /**
  * xmlNsListDumpOutput:
  * @buf:  the XML buffer output
  * @cur:  the first namespace
  *
  * Dump a list of local Namespace definitions.
  * Should be called in the context of attributes dumps.
  */
 void
 xmlNsListDumpOutput(xmlOutputBufferPtr buf, xmlNsPtr cur) {
     while (cur != NULL) {
-        xmlNsDumpOutput(buf, cur);
+        xmlNsDumpOutput(buf, cur, NULL);
         cur = cur->next;
     }
 }
 
 /**
  * xmlDtdDumpOutput:
  * @buf:  the XML buffer output
  * @dtd:  the pointer to the DTD
- * 
+ *
  * Dump the XML document DTD, if any.
  */
 static void
 xmlDtdDumpOutput(xmlSaveCtxtPtr ctxt, xmlDtdPtr dtd) {
     xmlOutputBufferPtr buf;
     int format, level;
     xmlDocPtr doc;
 
     if (dtd == NULL) return;
     if ((ctxt == NULL) || (ctxt->buf == NULL))
         return;
     buf = ctxt->buf;
     xmlOutputBufferWrite(buf, 10, "<!DOCTYPE ");
     xmlOutputBufferWriteString(buf, (const char *)dtd->name);
     if (dtd->ExternalID != NULL) {
         xmlOutputBufferWrite(buf, 8, " PUBLIC ");
-        xmlBufferWriteQuotedString(buf->buffer, dtd->ExternalID);
+        xmlBufWriteQuotedString(buf->buffer, dtd->ExternalID);
         xmlOutputBufferWrite(buf, 1, " ");
-        xmlBufferWriteQuotedString(buf->buffer, dtd->SystemID);
+        xmlBufWriteQuotedString(buf->buffer, dtd->SystemID);
     }  else if (dtd->SystemID != NULL) {
         xmlOutputBufferWrite(buf, 8, " SYSTEM ");
-        xmlBufferWriteQuotedString(buf->buffer, dtd->SystemID);
+        xmlBufWriteQuotedString(buf->buffer, dtd->SystemID);
     }
     if ((dtd->entities == NULL) && (dtd->elements == NULL) &&
         (dtd->attributes == NULL) && (dtd->notations == NULL) &&
         (dtd->pentities == NULL)) {
         xmlOutputBufferWrite(buf, 1, ">");
         return;
     }
     xmlOutputBufferWrite(buf, 3, " [\n");
     /*
      * Dump the notations first they are not in the DTD children list
      * Do this only on a standalone DTD or on the internal subset though.
      */
     if ((dtd->notations != NULL) && ((dtd->doc == NULL) ||
         (dtd->doc->intSubset == dtd))) {
-        xmlDumpNotationTable(buf->buffer, (xmlNotationTablePtr) dtd->notations);
+        xmlBufDumpNotationTable(buf->buffer,
+                                (xmlNotationTablePtr) dtd->notations);
     }
     format = ctxt->format;
     level = ctxt->level;
     doc = ctxt->doc;
     ctxt->format = 0;
     ctxt->level = -1;
     ctxt->doc = dtd->doc;
     xmlNodeListDumpOutput(ctxt, dtd->children);
     ctxt->format = format;
     ctxt->level = level;
     ctxt->doc = doc;
     xmlOutputBufferWrite(buf, 2, "]>");
 }
 
 /**
  * xmlAttrDumpOutput:
  * @buf:  the XML buffer output
  * @cur:  the attribute pointer
  *
  * Dump an XML attribute
  */
 static void
 xmlAttrDumpOutput(xmlSaveCtxtPtr ctxt, xmlAttrPtr cur) {
     xmlOutputBufferPtr buf;
 
     if (cur == NULL) return;
     buf = ctxt->buf;
     if (buf == NULL) return;
-    xmlOutputBufferWrite(buf, 1, " ");
+    if (ctxt->format == 2)
+        xmlOutputBufferWriteWSNonSig(ctxt, 2);
+    else
+        xmlOutputBufferWrite(buf, 1, " ");
     if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
         xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
         xmlOutputBufferWrite(buf, 1, ":");
     }
     xmlOutputBufferWriteString(buf, (const char *)cur->name);
     xmlOutputBufferWrite(buf, 2, "=\"");
     xmlAttrSerializeContent(buf, cur);
     xmlOutputBufferWrite(buf, 1, "\"");
 }
 
@@ skipping 23 matching lines @@
  *
  * Dump an XML node list, recursive behaviour, children are printed too.
  */
 static void
 xmlNodeListDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cur) {
     xmlOutputBufferPtr buf;
 
     if (cur == NULL) return;
     buf = ctxt->buf;
     while (cur != NULL) {
-        if ((ctxt->format) && (xmlIndentTreeOutput) &&
+        if ((ctxt->format == 1) && (xmlIndentTreeOutput) &&
             ((cur->type == XML_ELEMENT_NODE) ||
              (cur->type == XML_COMMENT_NODE) ||
              (cur->type == XML_PI_NODE)))
             xmlOutputBufferWrite(buf, ctxt->indent_size *
-                                 (ctxt->level > ctxt->indent_nr ? 
+                                 (ctxt->level > ctxt->indent_nr ?
                                   ctxt->indent_nr : ctxt->level),
                                  ctxt->indent);
         xmlNodeDumpOutputInternal(ctxt, cur);
-        if (ctxt->format) {
+        if (ctxt->format == 1) {
             xmlOutputBufferWrite(buf, 1, "\n");
         }
         cur = cur->next;
     }
 }
 
 #ifdef LIBXML_HTML_ENABLED
 /**
  * xmlNodeDumpOutputInternal:
  * @cur:  the current node
@@ skipping 92 matching lines @@
 #endif
     if (cur->type == XML_DTD_NODE) {
         xmlDtdDumpOutput(ctxt, (xmlDtdPtr) cur);
         return;
     }
     if (cur->type == XML_DOCUMENT_FRAG_NODE) {
         xmlNodeListDumpOutput(ctxt, cur->children);
         return;
     }
     if (cur->type == XML_ELEMENT_DECL) {
-        xmlDumpElementDecl(buf->buffer, (xmlElementPtr) cur);
+        xmlBufDumpElementDecl(buf->buffer, (xmlElementPtr) cur);
         return;
     }
     if (cur->type == XML_ATTRIBUTE_DECL) {
-        xmlDumpAttributeDecl(buf->buffer, (xmlAttributePtr) cur);
+        xmlBufDumpAttributeDecl(buf->buffer, (xmlAttributePtr) cur);
         return;
     }
     if (cur->type == XML_ENTITY_DECL) {
-        xmlDumpEntityDecl(buf->buffer, (xmlEntityPtr) cur);
+        xmlBufDumpEntityDecl(buf->buffer, (xmlEntityPtr) cur);
         return;
     }
     if (cur->type == XML_TEXT_NODE) {
         if (cur->content != NULL) {
             if (cur->name != xmlStringTextNoenc) {
                 xmlOutputBufferWriteEscape(buf, cur->content, ctxt->escape);
             } else {
                 /*
                  * Disable escaping, needed for XSLT
                  */
                 xmlOutputBufferWriteString(buf, (const char *) cur->content);
             }
         }
 
         return;
     }
     if (cur->type == XML_PI_NODE) {
         if (cur->content != NULL) {
             xmlOutputBufferWrite(buf, 2, "<?");
             xmlOutputBufferWriteString(buf, (const char *)cur->name);
             if (cur->content != NULL) {
-                xmlOutputBufferWrite(buf, 1, " ");
+                if (ctxt->format == 2)
+                    xmlOutputBufferWriteWSNonSig(ctxt, 0);
+                else
+                    xmlOutputBufferWrite(buf, 1, " ");
                 xmlOutputBufferWriteString(buf, (const char *)cur->content);
             }
             xmlOutputBufferWrite(buf, 2, "?>");
         } else {
             xmlOutputBufferWrite(buf, 2, "<?");
             xmlOutputBufferWriteString(buf, (const char *)cur->name);
+            if (ctxt->format == 2)
+                xmlOutputBufferWriteWSNonSig(ctxt, 0);
             xmlOutputBufferWrite(buf, 2, "?>");
         }
         return;
     }
     if (cur->type == XML_COMMENT_NODE) {
         if (cur->content != NULL) {
             xmlOutputBufferWrite(buf, 4, "<!--");
             xmlOutputBufferWriteString(buf, (const char *)cur->content);
             xmlOutputBufferWrite(buf, 3, "-->");
         }
@@ skipping 27 matching lines @@
                 xmlOutputBufferWrite(buf, 3, "]]>");
             }
         }
         return;
     }
     if (cur->type == XML_ATTRIBUTE_NODE) {
         xmlAttrDumpOutput(ctxt, (xmlAttrPtr) cur);
         return;
     }
     if (cur->type == XML_NAMESPACE_DECL) {
-        xmlNsDumpOutput(buf, (xmlNsPtr) cur);
+        xmlNsDumpOutputCtxt(ctxt, (xmlNsPtr) cur);
         return;
     }
 
     format = ctxt->format;
     if (format == 1) {
         tmp = cur->children;
         while (tmp != NULL) {
             if ((tmp->type == XML_TEXT_NODE) ||
                 (tmp->type == XML_CDATA_SECTION_NODE) ||
                 (tmp->type == XML_ENTITY_REF_NODE)) {
                 ctxt->format = 0;
                 break;
             }
             tmp = tmp->next;
         }
     }
     xmlOutputBufferWrite(buf, 1, "<");
     if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
         xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
         xmlOutputBufferWrite(buf, 1, ":");
     }
 
     xmlOutputBufferWriteString(buf, (const char *)cur->name);
     if (cur->nsDef)
-        xmlNsListDumpOutput(buf, cur->nsDef);
+        xmlNsListDumpOutputCtxt(ctxt, cur->nsDef);
     if (cur->properties != NULL)
         xmlAttrListDumpOutput(ctxt, cur->properties);
 
     if (((cur->type == XML_ELEMENT_NODE) || (cur->content == NULL)) &&
         (cur->children == NULL) && ((ctxt->options & XML_SAVE_NO_EMPTY) == 0)) {
+        if (ctxt->format == 2)
+            xmlOutputBufferWriteWSNonSig(ctxt, 0);
         xmlOutputBufferWrite(buf, 2, "/>");
         ctxt->format = format;
         return;
     }
+    if (ctxt->format == 2)
+        xmlOutputBufferWriteWSNonSig(ctxt, 1);
     xmlOutputBufferWrite(buf, 1, ">");
     if ((cur->type != XML_ELEMENT_NODE) && (cur->content != NULL)) {
         xmlOutputBufferWriteEscape(buf, cur->content, ctxt->escape);
     }
     if (cur->children != NULL) {
-        if (ctxt->format) xmlOutputBufferWrite(buf, 1, "\n");
+        if (ctxt->format == 1) xmlOutputBufferWrite(buf, 1, "\n");
         if (ctxt->level >= 0) ctxt->level++;
         xmlNodeListDumpOutput(ctxt, cur->children);
         if (ctxt->level > 0) ctxt->level--;
-        if ((xmlIndentTreeOutput) && (ctxt->format))
+        if ((xmlIndentTreeOutput) && (ctxt->format == 1))
             xmlOutputBufferWrite(buf, ctxt->indent_size *
-                                 (ctxt->level > ctxt->indent_nr ? 
+                                 (ctxt->level > ctxt->indent_nr ?
                                   ctxt->indent_nr : ctxt->level),
                                  ctxt->indent);
     }
     xmlOutputBufferWrite(buf, 2, "</");
     if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
         xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
         xmlOutputBufferWrite(buf, 1, ":");
     }
 
     xmlOutputBufferWriteString(buf, (const char *)cur->name);
+    if (ctxt->format == 2)
+        xmlOutputBufferWriteWSNonSig(ctxt, 0);
     xmlOutputBufferWrite(buf, 1, ">");
     ctxt->format = format;
 }
 
 /**
  * xmlDocContentDumpOutput:
  * @cur:  the document
  *
  * Dump an XML document.
  */
@@ skipping 83 matching lines @@
             if (ctxt->escapeAttr == xmlEscapeEntities)
                 ctxt->escapeAttr = NULL;
         }
 
 
         /*
          * Save the XML declaration
          */
         if ((ctxt->options & XML_SAVE_NO_DECL) == 0) {
             xmlOutputBufferWrite(buf, 14, "<?xml version=");
-            if (cur->version != NULL) 
-                xmlBufferWriteQuotedString(buf->buffer, cur->version);
+            if (cur->version != NULL)
+                xmlBufWriteQuotedString(buf->buffer, cur->version);
             else
                 xmlOutputBufferWrite(buf, 5, "\"1.0\"");
             if (encoding != NULL) {
                 xmlOutputBufferWrite(buf, 10, " encoding=");
-                xmlBufferWriteQuotedString(buf->buffer, (xmlChar *) encoding);
+                xmlBufWriteQuotedString(buf->buffer, (xmlChar *) encoding);
             }
             switch (cur->standalone) {
                 case 0:
                     xmlOutputBufferWrite(buf, 16, " standalone=\"no\"");
                     break;
                 case 1:
                     xmlOutputBufferWrite(buf, 17, " standalone=\"yes\"");
                     break;
             }
             xmlOutputBufferWrite(buf, 3, "?>\n");
@@ skipping 137 matching lines @@
         else
         if ((cur->ns == NULL) && (xmlStrEqual(cur->name, BAD_CAST "name")))
             name = cur;
         else
         if ((cur->ns == NULL) && (xmlStrEqual(cur->name, BAD_CAST "lang")))
             lang = cur;
         else
         if ((cur->ns != NULL) && (xmlStrEqual(cur->name, BAD_CAST "lang")) &&
             (xmlStrEqual(cur->ns->prefix, BAD_CAST "xml")))
             xml_lang = cur;
-        else if ((cur->ns == NULL) && 
+        else if ((cur->ns == NULL) &&
                  ((cur->children == NULL) ||
                   (cur->children->content == NULL) ||
                   (cur->children->content[0] == 0)) &&
                  (htmlIsBooleanAttr(cur->name))) {
             if (cur->children != NULL)
                 xmlFreeNode(cur->children);
             cur->children = xmlNewText(cur->name);
             if (cur->children != NULL)
                 cur->children->parent = (xmlNodePtr) cur;
         }
@@ skipping 19 matching lines @@
             xmlOutputBufferWrite(buf, 1, "\"");
         }
     }
     /*
      * C.7.
      */
     if ((lang != NULL) && (xml_lang == NULL)) {
         xmlOutputBufferWrite(buf, 11, " xml:lang=\"");
         xmlAttrSerializeContent(buf, lang);
         xmlOutputBufferWrite(buf, 1, "\"");
-    } else 
+    } else
     if ((xml_lang != NULL) && (lang == NULL)) {
         xmlOutputBufferWrite(buf, 7, " lang=\"");
         xmlAttrSerializeContent(buf, xml_lang);
         xmlOutputBufferWrite(buf, 1, "\"");
     }
 }
 
 /**
  * xhtmlNodeListDumpOutput:
  * @buf:  the XML buffer output
  * @doc:  the XHTML document
  * @cur:  the first node
  * @level: the imbrication level for indenting
  * @format: is formatting allowed
  * @encoding:  an optional encoding string
  *
  * Dump an XML node list, recursive behaviour, children are printed too.
  * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1
  * or xmlKeepBlanksDefault(0) was called
  */
 static void
 xhtmlNodeListDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cur) {
     xmlOutputBufferPtr buf;
 
     if (cur == NULL) return;
     buf = ctxt->buf;
     while (cur != NULL) {
-        if ((ctxt->format) && (xmlIndentTreeOutput) &&
+        if ((ctxt->format == 1) && (xmlIndentTreeOutput) &&
             (cur->type == XML_ELEMENT_NODE))
             xmlOutputBufferWrite(buf, ctxt->indent_size *
-                                 (ctxt->level > ctxt->indent_nr ? 
+                                 (ctxt->level > ctxt->indent_nr ?
                                   ctxt->indent_nr : ctxt->level),
                                  ctxt->indent);
         xhtmlNodeDumpOutput(ctxt, cur);
-        if (ctxt->format) {
+        if (ctxt->format == 1) {
             xmlOutputBufferWrite(buf, 1, "\n");
         }
         cur = cur->next;
     }
 }
 
 /**
  * xhtmlNodeDumpOutput:
  * @buf:  the XML buffer output
  * @doc:  the XHTML document
@@ skipping 14 matching lines @@
     if (cur == NULL) return;
     if ((cur->type == XML_DOCUMENT_NODE) ||
         (cur->type == XML_HTML_DOCUMENT_NODE)) {
         xmlDocContentDumpOutput(ctxt, (xmlDocPtr) cur);
         return;
     }
     if (cur->type == XML_XINCLUDE_START)
         return;
     if (cur->type == XML_XINCLUDE_END)
         return;
+    if (cur->type == XML_NAMESPACE_DECL) {
+        xmlNsDumpOutputCtxt(ctxt, (xmlNsPtr) cur);
+        return;
+    }
     if (cur->type == XML_DTD_NODE) {
         xmlDtdDumpOutput(ctxt, (xmlDtdPtr) cur);
         return;
     }
     if (cur->type == XML_DOCUMENT_FRAG_NODE) {
         xhtmlNodeListDumpOutput(ctxt, cur->children);
         return;
     }
     buf = ctxt->buf;
     if (cur->type == XML_ELEMENT_DECL) {
-        xmlDumpElementDecl(buf->buffer, (xmlElementPtr) cur);
+        xmlBufDumpElementDecl(buf->buffer, (xmlElementPtr) cur);
         return;
     }
     if (cur->type == XML_ATTRIBUTE_DECL) {
-        xmlDumpAttributeDecl(buf->buffer, (xmlAttributePtr) cur);
+        xmlBufDumpAttributeDecl(buf->buffer, (xmlAttributePtr) cur);
         return;
     }
     if (cur->type == XML_ENTITY_DECL) {
-        xmlDumpEntityDecl(buf->buffer, (xmlEntityPtr) cur);
+        xmlBufDumpEntityDecl(buf->buffer, (xmlEntityPtr) cur);
         return;
     }
     if (cur->type == XML_TEXT_NODE) {
         if (cur->content != NULL) {
             if ((cur->name == xmlStringText) ||
                 (cur->name != xmlStringTextNoenc)) {
                 xmlOutputBufferWriteEscape(buf, cur->content, ctxt->escape);
             } else {
                 /*
                  * Disable escaping, needed for XSLT
@@ skipping 59 matching lines @@
     }
     if (cur->type == XML_ATTRIBUTE_NODE) {
         xmlAttrDumpOutput(ctxt, (xmlAttrPtr) cur);
         return;
     }
 
     format = ctxt->format;
     if (format == 1) {
         tmp = cur->children;
         while (tmp != NULL) {
-            if ((tmp->type == XML_TEXT_NODE) || 
+            if ((tmp->type == XML_TEXT_NODE) ||
                 (tmp->type == XML_ENTITY_REF_NODE)) {
                 format = 0;
                 break;
             }
             tmp = tmp->next;
         }
     }
     xmlOutputBufferWrite(buf, 1, "<");
     if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
         xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
         xmlOutputBufferWrite(buf, 1, ":");
     }
 
     xmlOutputBufferWriteString(buf, (const char *)cur->name);
     if (cur->nsDef)
-        xmlNsListDumpOutput(buf, cur->nsDef);
+        xmlNsListDumpOutputCtxt(ctxt, cur->nsDef);
     if ((xmlStrEqual(cur->name, BAD_CAST "html") &&
         (cur->ns == NULL) && (cur->nsDef == NULL))) {
         /*
          * 3.1.1. Strictly Conforming Documents A.3.1.1 3/
          */
         xmlOutputBufferWriteString(buf,
                 " xmlns=\"http://www.w3.org/1999/xhtml\"");
     }
     if (cur->properties != NULL)
         xhtmlAttrListDumpOutput(ctxt, cur->properties);
 
-        if ((cur->type == XML_ELEMENT_NODE) && 
-                (cur->parent != NULL) && 
-                (cur->parent->parent == (xmlNodePtr) cur->doc) && 
-                xmlStrEqual(cur->name, BAD_CAST"head") && 
+        if ((cur->type == XML_ELEMENT_NODE) &&
+                (cur->parent != NULL) &&
+                (cur->parent->parent == (xmlNodePtr) cur->doc) &&
+                xmlStrEqual(cur->name, BAD_CAST"head") &&
                 xmlStrEqual(cur->parent->name, BAD_CAST"html")) {
 
                 tmp = cur->children;
                 while (tmp != NULL) {
                         if (xmlStrEqual(tmp->name, BAD_CAST"meta")) {
                                 xmlChar *httpequiv;
 
                                 httpequiv = xmlGetProp(tmp, BAD_CAST"http-equiv");
                                 if (httpequiv != NULL) {
                                         if (xmlStrcasecmp(httpequiv, BAD_CAST"Content-Type") == 0) {
@@ skipping 12 matching lines @@
     if ((cur->type == XML_ELEMENT_NODE) && (cur->children == NULL)) {
         if (((cur->ns == NULL) || (cur->ns->prefix == NULL)) &&
             ((xhtmlIsEmpty(cur) == 1) && (addmeta == 0))) {
             /*
              * C.2. Empty Elements
              */
             xmlOutputBufferWrite(buf, 3, " />");
         } else {
                 if (addmeta == 1) {
                         xmlOutputBufferWrite(buf, 1, ">");
-                        if (ctxt->format) {
+                        if (ctxt->format == 1) {
                                 xmlOutputBufferWrite(buf, 1, "\n");
                                 if (xmlIndentTreeOutput)
                                         xmlOutputBufferWrite(buf, ctxt->indent_size *
-                                        (ctxt->level + 1 > ctxt->indent_nr ? 
+                                        (ctxt->level + 1 > ctxt->indent_nr ?
                                         ctxt->indent_nr : ctxt->level + 1), ctxt->indent);
                         }
                         xmlOutputBufferWriteString(buf,
                                 "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=");
                         if (ctxt->encoding) {
                                 xmlOutputBufferWriteString(buf, (const char *)ctxt->encoding);
                         } else {
                                 xmlOutputBufferWrite(buf, 5, "UTF-8");
                         }
                         xmlOutputBufferWrite(buf, 4, "\" />");
-                        if (ctxt->format)
+                        if (ctxt->format == 1)
                                 xmlOutputBufferWrite(buf, 1, "\n");
                 } else {
                         xmlOutputBufferWrite(buf, 1, ">");
                 }
             /*
              * C.3. Element Minimization and Empty Element Content
              */
             xmlOutputBufferWrite(buf, 2, "</");
             if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
                 xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
                 xmlOutputBufferWrite(buf, 1, ":");
             }
             xmlOutputBufferWriteString(buf, (const char *)cur->name);
             xmlOutputBufferWrite(buf, 1, ">");
         }
         return;
     }
     xmlOutputBufferWrite(buf, 1, ">");
         if (addmeta == 1) {
-                if (ctxt->format) {
+                if (ctxt->format == 1) {
                         xmlOutputBufferWrite(buf, 1, "\n");
                         if (xmlIndentTreeOutput)
                                 xmlOutputBufferWrite(buf, ctxt->indent_size *
-                                (ctxt->level + 1 > ctxt->indent_nr ? 
+                                (ctxt->level + 1 > ctxt->indent_nr ?
                                 ctxt->indent_nr : ctxt->level + 1), ctxt->indent);
                 }
                 xmlOutputBufferWriteString(buf,
                         "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=");
                 if (ctxt->encoding) {
                         xmlOutputBufferWriteString(buf, (const char *)ctxt->encoding);
                 } else {
                         xmlOutputBufferWrite(buf, 5, "UTF-8");
                 }
                 xmlOutputBufferWrite(buf, 4, "\" />");
@@ skipping 69 matching lines @@
                 ctxt->level = level;
                 ctxt->format = indent;
             }
             child = child->next;
         }
     }
 #endif
 
     if (cur->children != NULL) {
         int indent = ctxt->format;
-        
-        if (format) xmlOutputBufferWrite(buf, 1, "\n");
+
+        if (format == 1) xmlOutputBufferWrite(buf, 1, "\n");
         if (ctxt->level >= 0) ctxt->level++;
         ctxt->format = format;
         xhtmlNodeListDumpOutput(ctxt, cur->children);
         if (ctxt->level > 0) ctxt->level--;
         ctxt->format = indent;
-        if ((xmlIndentTreeOutput) && (format))
+        if ((xmlIndentTreeOutput) && (format == 1))
             xmlOutputBufferWrite(buf, ctxt->indent_size *
-                                 (ctxt->level > ctxt->indent_nr ? 
+                                 (ctxt->level > ctxt->indent_nr ?
                                   ctxt->indent_nr : ctxt->level),
                                  ctxt->indent);
     }
     xmlOutputBufferWrite(buf, 2, "</");
     if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
         xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
         xmlOutputBufferWrite(buf, 1, ":");
     }
 
     xmlOutputBufferWriteString(buf, (const char *)cur->name);
@@ skipping 245 matching lines @@
     if (ctxt == NULL) return(-1);
     ctxt->escapeAttr = escape;
     return(0);
 }
 
 /************************************************************************
  *                                                                      *
  *              Public entry points based on buffers                    *
  *                                                                      *
  ************************************************************************/
+
 /**
- * xmlAttrSerializeTxtContent:
- * @buf:  the XML buffer output
+ * xmlBufAttrSerializeTxtContent:
+ * @buf:  and xmlBufPtr output
  * @doc:  the document
  * @attr: the attribute node
  * @string: the text content
  *
- * Serialize text attribute values to an xml simple buffer
+ * Serialize text attribute values to an xmlBufPtr
  */
 void
-xmlAttrSerializeTxtContent(xmlBufferPtr buf, xmlDocPtr doc,
-                           xmlAttrPtr attr, const xmlChar * string)
+xmlBufAttrSerializeTxtContent(xmlBufPtr buf, xmlDocPtr doc,
+                              xmlAttrPtr attr, const xmlChar * string)
 {
     xmlChar *base, *cur;
 
     if (string == NULL)
         return;
     base = cur = (xmlChar *) string;
     while (*cur != 0) {
         if (*cur == '\n') {
             if (base != cur)
-                xmlBufferAdd(buf, base, cur - base);
-            xmlBufferAdd(buf, BAD_CAST "&#10;", 5);
+                xmlBufAdd(buf, base, cur - base);
+            xmlBufAdd(buf, BAD_CAST "&#10;", 5);
             cur++;
             base = cur;
         } else if (*cur == '\r') {
             if (base != cur)
-                xmlBufferAdd(buf, base, cur - base);
-            xmlBufferAdd(buf, BAD_CAST "&#13;", 5);
+                xmlBufAdd(buf, base, cur - base);
+            xmlBufAdd(buf, BAD_CAST "&#13;", 5);
             cur++;
             base = cur;
         } else if (*cur == '\t') {
             if (base != cur)
-                xmlBufferAdd(buf, base, cur - base);
-            xmlBufferAdd(buf, BAD_CAST "&#9;", 4);
+                xmlBufAdd(buf, base, cur - base);
+            xmlBufAdd(buf, BAD_CAST "&#9;", 4);
             cur++;
             base = cur;
         } else if (*cur == '"') {
             if (base != cur)
-                xmlBufferAdd(buf, base, cur - base);
-            xmlBufferAdd(buf, BAD_CAST "&quot;", 6);
+                xmlBufAdd(buf, base, cur - base);
+            xmlBufAdd(buf, BAD_CAST "&quot;", 6);
             cur++;
             base = cur;
         } else if (*cur == '<') {
             if (base != cur)
-                xmlBufferAdd(buf, base, cur - base);
-            xmlBufferAdd(buf, BAD_CAST "&lt;", 4);
+                xmlBufAdd(buf, base, cur - base);
+            xmlBufAdd(buf, BAD_CAST "&lt;", 4);
             cur++;
             base = cur;
         } else if (*cur == '>') {
             if (base != cur)
-                xmlBufferAdd(buf, base, cur - base);
-            xmlBufferAdd(buf, BAD_CAST "&gt;", 4);
+                xmlBufAdd(buf, base, cur - base);
+            xmlBufAdd(buf, BAD_CAST "&gt;", 4);
             cur++;
             base = cur;
         } else if (*cur == '&') {
             if (base != cur)
-                xmlBufferAdd(buf, base, cur - base);
-            xmlBufferAdd(buf, BAD_CAST "&amp;", 5);
+                xmlBufAdd(buf, base, cur - base);
+            xmlBufAdd(buf, BAD_CAST "&amp;", 5);
             cur++;
             base = cur;
         } else if ((*cur >= 0x80) && ((doc == NULL) ||
                                       (doc->encoding == NULL))) {
             /*
              * We assume we have UTF-8 content.
              */
             unsigned char tmp[12];
             int val = 0, l = 1;
 
             if (base != cur)
-                xmlBufferAdd(buf, base, cur - base);
+                xmlBufAdd(buf, base, cur - base);
             if (*cur < 0xC0) {
                 xmlSaveErr(XML_SAVE_NOT_UTF8, (xmlNodePtr) attr, NULL);
                 if (doc != NULL)
                     doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1");
                 xmlSerializeHexCharRef(tmp, *cur);
-                xmlBufferAdd(buf, (xmlChar *) tmp, -1);
+                xmlBufAdd(buf, (xmlChar *) tmp, -1);
                 cur++;
                 base = cur;
                 continue;
             } else if (*cur < 0xE0) {
                 val = (cur[0]) & 0x1F;
                 val <<= 6;
                 val |= (cur[1]) & 0x3F;
                 l = 2;
             } else if (*cur < 0xF0) {
                 val = (cur[0]) & 0x0F;
                 val <<= 6;
                 val |= (cur[1]) & 0x3F;
                 val <<= 6;
                 val |= (cur[2]) & 0x3F;
                 l = 3;
             } else if (*cur < 0xF8) {
                 val = (cur[0]) & 0x07;
                 val <<= 6;
                 val |= (cur[1]) & 0x3F;
                 val <<= 6;
                 val |= (cur[2]) & 0x3F;
                 val <<= 6;
                 val |= (cur[3]) & 0x3F;
                 l = 4;
             }
             if ((l == 1) || (!IS_CHAR(val))) {
                 xmlSaveErr(XML_SAVE_CHAR_INVALID, (xmlNodePtr) attr, NULL);
                 if (doc != NULL)
                     doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1");
-                
+
                 xmlSerializeHexCharRef(tmp, *cur);
-                xmlBufferAdd(buf, (xmlChar *) tmp, -1);
+                xmlBufAdd(buf, (xmlChar *) tmp, -1);
                 cur++;
                 base = cur;
                 continue;
             }
             /*
              * We could do multiple things here. Just save
              * as a char ref
              */
             xmlSerializeHexCharRef(tmp, val);
-            xmlBufferAdd(buf, (xmlChar *) tmp, -1);
+            xmlBufAdd(buf, (xmlChar *) tmp, -1);
             cur += l;
             base = cur;
         } else {
             cur++;
         }
     }
     if (base != cur)
-        xmlBufferAdd(buf, base, cur - base);
+        xmlBufAdd(buf, base, cur - base);
 }
 
 /**
+ * xmlAttrSerializeTxtContent:
+ * @buf:  the XML buffer output
+ * @doc:  the document
+ * @attr: the attribute node
+ * @string: the text content
+ *
+ * Serialize text attribute values to an xml simple buffer
+ */
+void
+xmlAttrSerializeTxtContent(xmlBufferPtr buf, xmlDocPtr doc,
+                           xmlAttrPtr attr, const xmlChar * string)
+{
+    xmlBufPtr buffer;
+
+    if ((buf == NULL) || (string == NULL))
+        return;
+    buffer = xmlBufFromBuffer(buf);
+    if (buffer == NULL)
+        return;
+    xmlBufAttrSerializeTxtContent(buffer, doc, attr, string);
+    xmlBufBackToBuffer(buffer);
+}
+
+/**
  * xmlNodeDump:
  * @buf:  the XML buffer output
  * @doc:  the document
  * @cur:  the current node
  * @level: the imbrication level for indenting
  * @format: is formatting allowed
  *
  * Dump an XML node, recursive behaviour,children are printed too.
  * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1
  * or xmlKeepBlanksDefault(0) was called
+ * Since this is using xmlBuffer structures it is limited to 2GB and somehow
+ * deprecated, use xmlBufNodeDump() instead.
  *
  * Returns the number of bytes written to the buffer or -1 in case of error
  */
 int
 xmlNodeDump(xmlBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur, int level,
             int format)
 {
-    unsigned int use;
+    xmlBufPtr buffer;
+    int ret;
+
+    if ((buf == NULL) || (cur == NULL))
+        return(-1);
+    buffer = xmlBufFromBuffer(buf);
+    if (buffer == NULL)
+        return(-1);
+    ret = xmlBufNodeDump(buffer, doc, cur, level, format);
+    xmlBufBackToBuffer(buffer);
+    if (ret > INT_MAX)
+        return(-1);
+    return((int) ret);
+}
+
+/**
+ * xmlBufNodeDump:
+ * @buf:  the XML buffer output
+ * @doc:  the document
+ * @cur:  the current node
+ * @level: the imbrication level for indenting
+ * @format: is formatting allowed
+ *
+ * Dump an XML node, recursive behaviour,children are printed too.
+ * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1
+ * or xmlKeepBlanksDefault(0) was called
+ *
+ * Returns the number of bytes written to the buffer, in case of error 0
+ *     is returned or @buf stores the error
+ */
+
+size_t
+xmlBufNodeDump(xmlBufPtr buf, xmlDocPtr doc, xmlNodePtr cur, int level,
+            int format)
+{
+    size_t use;
     int ret;
     xmlOutputBufferPtr outbuf;
+    int oldalloc;
 
     xmlInitParser();
 
     if (cur == NULL) {
 #ifdef DEBUG_TREE
         xmlGenericError(xmlGenericErrorContext,
                         "xmlNodeDump : node == NULL\n");
 #endif
         return (-1);
     }
@@ skipping 10 matching lines @@
         return (-1);
     }
     memset(outbuf, 0, (size_t) sizeof(xmlOutputBuffer));
     outbuf->buffer = buf;
     outbuf->encoder = NULL;
     outbuf->writecallback = NULL;
     outbuf->closecallback = NULL;
     outbuf->context = NULL;
     outbuf->written = 0;
 
-    use = buf->use;
+    use = xmlBufUse(buf);
+    oldalloc = xmlBufGetAllocationScheme(buf);
+    xmlBufSetAllocationScheme(buf, XML_BUFFER_ALLOC_DOUBLEIT);
     xmlNodeDumpOutput(outbuf, doc, cur, level, format, NULL);
+    xmlBufSetAllocationScheme(buf, oldalloc);
     xmlFree(outbuf);
-    ret = buf->use - use;
+    ret = xmlBufUse(buf) - use;
     return (ret);
 }
 
 /**
  * xmlElemDump:
  * @f:  the FILE * for the output
  * @doc:  the document
  * @cur:  the current node
  *
  * Dump an XML/HTML node, recursive behaviour, children are printed too.
@@ skipping 66 matching lines @@
 
     if ((buf == NULL) || (cur == NULL)) return;
 
     if (encoding == NULL)
         encoding = "UTF-8";
 
     memset(&ctxt, 0, sizeof(ctxt));
     ctxt.doc = doc;
     ctxt.buf = buf;
     ctxt.level = level;
-    ctxt.format = format;
+    ctxt.format = format ? 1 : 0;
     ctxt.encoding = (const xmlChar *) encoding;
     xmlSaveCtxtInit(&ctxt);
     ctxt.options |= XML_SAVE_AS_XML;
 
 #ifdef LIBXML_HTML_ENABLED
     dtd = xmlGetIntSubset(doc);
     if (dtd != NULL) {
         is_xhtml = xmlIsXHTML(dtd->SystemID, dtd->ExternalID);
         if (is_xhtml < 0)
             is_xhtml = 0;
@@ skipping 65 matching lines @@
 
     if ((out_buff = xmlAllocOutputBuffer(conv_hdlr)) == NULL ) {
         xmlSaveErrMemory("creating buffer");
         return;
     }
 
     memset(&ctxt, 0, sizeof(ctxt));
     ctxt.doc = out_doc;
     ctxt.buf = out_buff;
     ctxt.level = 0;
-    ctxt.format = format;
+    ctxt.format = format ? 1 : 0;
     ctxt.encoding = (const xmlChar *) txt_encoding;
     xmlSaveCtxtInit(&ctxt);
     ctxt.options |= XML_SAVE_AS_XML;
     xmlDocContentDumpOutput(&ctxt, out_doc);
     xmlOutputBufferFlush(out_buff);
     if (out_buff->conv != NULL) {
-        *doc_txt_len = out_buff->conv->use;
-        *doc_txt_ptr = xmlStrndup(out_buff->conv->content, *doc_txt_len);
+        *doc_txt_len = xmlBufUse(out_buff->conv);
+        *doc_txt_ptr = xmlStrndup(xmlBufContent(out_buff->conv), *doc_txt_len);
     } else {
-        *doc_txt_len = out_buff->buffer->use;
-        *doc_txt_ptr = xmlStrndup(out_buff->buffer->content, *doc_txt_len);
+        *doc_txt_len = xmlBufUse(out_buff->buffer);
+        *doc_txt_ptr = xmlStrndup(xmlBufContent(out_buff->buffer),*doc_txt_len);
     }
     (void)xmlOutputBufferClose(out_buff);
 
     if ((*doc_txt_ptr == NULL) && (*doc_txt_len > 0)) {
         *doc_txt_len = 0;
         xmlSaveErrMemory("creating output");
     }
 
     return;
 }
@@ skipping 87 matching lines @@
             cur->encoding = NULL;
             encoding = NULL;
         }
     }
     buf = xmlOutputBufferCreateFile(f, handler);
     if (buf == NULL) return(-1);
     memset(&ctxt, 0, sizeof(ctxt));
     ctxt.doc = cur;
     ctxt.buf = buf;
     ctxt.level = 0;
-    ctxt.format = format;
+    ctxt.format = format ? 1 : 0;
     ctxt.encoding = (const xmlChar *) encoding;
     xmlSaveCtxtInit(&ctxt);
     ctxt.options |= XML_SAVE_AS_XML;
     xmlDocContentDumpOutput(&ctxt, cur);
 
     ret = xmlOutputBufferClose(buf);
     return(ret);
 }
 
 /**
@@ skipping 69 matching lines @@
     if ((cur == NULL) ||
         ((cur->type != XML_DOCUMENT_NODE) &&
          (cur->type != XML_HTML_DOCUMENT_NODE))) {
         xmlOutputBufferClose(buf);
         return(-1);
     }
     memset(&ctxt, 0, sizeof(ctxt));
     ctxt.doc = cur;
     ctxt.buf = buf;
     ctxt.level = 0;
-    ctxt.format = format;
+    ctxt.format = format ? 1 : 0;
     ctxt.encoding = (const xmlChar *) encoding;
     xmlSaveCtxtInit(&ctxt);
     ctxt.options |= XML_SAVE_AS_XML;
     xmlDocContentDumpOutput(&ctxt, cur);
     ret = xmlOutputBufferClose(buf);
     return (ret);
 }
 
 /**
  * xmlSaveFormatFileEnc:
@@ skipping 25 matching lines @@
     if (encoding != NULL) {
 
             handler = xmlFindCharEncodingHandler(encoding);
             if (handler == NULL)
                 return(-1);
     }
 
 #ifdef HAVE_ZLIB_H
     if (cur->compression < 0) cur->compression = xmlGetCompressMode();
 #endif
-    /* 
+    /*
      * save the content to a temp buffer.
      */
     buf = xmlOutputBufferCreateFilename(filename, handler, cur->compression);
     if (buf == NULL) return(-1);
     memset(&ctxt, 0, sizeof(ctxt));
     ctxt.doc = cur;
     ctxt.buf = buf;
     ctxt.level = 0;
-    ctxt.format = format;
+    ctxt.format = format ? 1 : 0;
     ctxt.encoding = (const xmlChar *) encoding;
     xmlSaveCtxtInit(&ctxt);
     ctxt.options |= XML_SAVE_AS_XML;
 
     xmlDocContentDumpOutput(&ctxt, cur);
 
     ret = xmlOutputBufferClose(buf);
     return(ret);
 }
 
@@ skipping 44 matching lines @@
  */
 int
 xmlSaveFile(const char *filename, xmlDocPtr cur) {
     return(xmlSaveFormatFileEnc(filename, cur, NULL, 0));
 }
 
 #endif /* LIBXML_OUTPUT_ENABLED */
 
 #define bottom_xmlsave
 #include "elfgcchack.h"