kc3-lang/libxml2/xmlsave.c

Branch - branch -master- tag -v2.9.9-rc2v2.9.9-rc1v2.9.9v2.9.8-rc1v2.9.8v2.9.7-rc1v2.9.7v2.9.6-rc1v2.9.6v2.9.5-rc2v2.9.5-rc1v2.9.5v2.9.4-rc2v2.9.4-rc1v2.9.4v2.9.3v2.9.2-rc2v2.9.2-rc1v2.9.2v2.9.14v2.9.13v2.9.12v2.9.11v2.9.10-rc1v2.9.10v2.9.1v2.9.0-rc2v2.9.0v2.8.0-rc2v2.8.0-rc1v2.8.0v2.7.8v2.7.7v2.7.6v2.7.5v2.7.4v2.15.1v2.15.0v2.14.6v2.14.5v2.14.4v2.14.3v2.14.2v2.14.1v2.14.0v2.13.9v2.13.8v2.13.7v2.13.6v2.13.5v2.13.4v2.13.3v2.13.2v2.13.1v2.13.0v2.12.9v2.12.8v2.12.7v2.12.6v2.12.5v2.12.4v2.12.3v2.12.2v2.12.10v2.12.1v2.12.0v2.11.9v2.11.8v2.11.7v2.11.6v2.11.5v2.11.4v2.11.3v2.11.2v2.11.1v2.11.0v2.10.4v2.10.3v2.10.2v2.10.1v2.10.0helpPRE_MUCKUP3PRE_MUCKUP2PRE_MUCKUPLIB_XML_1_XLIB_XML_1_8_3LIB_XML_1_7_3LIB_XML_1_7_1LIB_XML_1_7_0LIB_XML_1_6_2LIB_XML_1_6_1LIB_XML_1_4LIB_XML_1_3LIB_XML_1_1LIBXML_TEST_2_0_0LIBXML_2_6_10LIBXML_2_5_6LIBXML_2_5_5LIBXML_2_5_4LIBXML_2_5_3LIBXML_2_5_2LIBXML_2_5_1LIBXML_2_4_7LIBXML_2_4_6LIBXML_2_4_4LIBXML_2_4_30LIBXML_2_4_3LIBXML_2_4_29LIBXML_2_4_27LIBXML_2_4_26LIBXML_2_4_25LIBXML_2_4_24LIBXML_2_4_23LIBXML_2_4_22LIBXML_2_4_20LIBXML_2_4_2LIBXML_2_4_18LIBXML_2_4_16LIBXML_2_4_14LIBXML_2_4_13LIBXML_2_4_12LIBXML_2_4_11LIBXML_2_4_0LIBXML_2_3_9LIBXML_2_3_8LIBXML_2_3_7LIBXML_2_3_6LIBXML_2_3_5LIBXML_2_3_4LIBXML_2_3_3LIBXML_2_3_2LIBXML_2_3_14LIBXML_2_3_13LIBXML_2_3_12LIBXML_2_3_11LIBXML_2_3_10LIBXML_2_3_0LIBXML_2_2_8LIBXML_2_2_7LIBXML_2_2_6LIBXML_2_2_4LIBXML_2_2_3LIBXML_2_2_1LIBXML_2_1_1LIBXML_2_1_0LIBXML_2_0_0LIBXML_1_8_9LIBXML_1_8_8LIBXML_1_8_6LIBXML_1_8_5LIBXML_1_8_17LIBXML_1_8_16LIBXML_1_8_14LIBXML_1_8_12LIBXML_1_8_10_REALLIBXML_1_8_10LIBXML_1_5_0LIBXML_0_99LIBXML2_6_0LIBXML2_2_6_9LIBXML2_2_6_8LIBXML2_2_6_7LIBXML2_2_6_6LIBXML2_2_6_5LIBXML2_2_6_4LIBXML2_2_6_3LIBXML2_2_6_28LIBXML2_2_6_27LIBXML2_2_6_26LIBXML2_2_6_24LIBXML2_2_6_23LIBXML2_2_6_22LIBXML2_2_6_21LIBXML2_2_6_20LIBXML2_2_6_2LIBXML2_2_6_19LIBXML2_2_6_18LIBXML2_2_6_16LIBXML2_2_6_15LIBXML2_2_6_14LIBXML2_2_6_13LIBXML2_2_6_12LIBXML2_2_6_11LIBXML2_2_6_1LIBXML2_2_5_xLIBXML2_2_5_9LIBXML2_2_5_8LIBXML2_2_5_7LIBXML2_2_5_11LIBXML2_2_5_10LIBXML2_2_5_0LIBXML2_2_4_21LIBXML2.7.3LIBXML2.7.2LIBXML2.7.1LIBXML2.7.0LIBXML2.6.32GNUMERIC_FIRST_PUBLIC_RELEASEGNOME_PRINT_0_24GNOME_0_30FOR_GNOME_0_99_1EAZEL-NAUTILUS-MS-AUG07ChangeLogCVE-2021-3541CVE-2016-4483CVE-2016-4449CVE-2016-3705CVE-2016-3627CVE-2016-1840CVE-2016-1839CVE-2016-1838CVE-2016-1837CVE-2016-1836CVE-2016-1835CVE-2016-1834CVE-2016-1833CVE-2016-1762CVE-2015-8317CVE-2015-8242CVE-2015-8035CVE-2015-7942-2CVE-2015-7942CVE-2015-7941_2CVE-2015-7941_1CVE-2015-7500CVE-2015-7499-2CVE-2015-7499-1CVE-2015-7498CVE-2015-7497CVE-2015-5312CVE-2015-1819CVE-2014-3660CVE-2014-0191CVE-2013-2877

• Show log

  Commit

• Hash : 7bd8d1d9
  Author :
  Date : 2025-05-28T15:53:38
  

  doc: Prefix autolinks with '#'
  
  Use `#func` instead of `func()` to ignore parameters and make all
  autolinks work.
  

Download

• xmlsave.c

• /*
   * xmlsave.c: Implementation of the document serializer
   *
   * See Copyright for the status of this software.
   *
   * Author: Daniel Veillard
   */
  
  #define IN_LIBXML
  #include "libxml.h"
  
  #include <limits.h>
  #include <stdlib.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 "private/buf.h"
  #include "private/enc.h"
  #include "private/error.h"
  #include "private/html.h"
  #include "private/io.h"
  #include "private/save.h"
  
  #ifdef LIBXML_OUTPUT_ENABLED
  
  #define XHTML_NS_NAME BAD_CAST "http://www.w3.org/1999/xhtml"
  
  struct _xmlSaveCtxt {
      const xmlChar *encoding;
      xmlCharEncodingHandlerPtr handler;
      xmlOutputBufferPtr buf;
      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 */
  };
  
  /************************************************************************
   *									*
   *			Output error handlers				*
   *									*
   ************************************************************************/
  /**
   * Handle an out of memory condition
   *
   * @param out  an output buffer
   */
  static void
  xmlSaveErrMemory(xmlOutputBufferPtr out)
  {
      if (out != NULL)
          out->error = XML_ERR_NO_MEMORY;
      xmlRaiseMemoryError(NULL, NULL, NULL, XML_FROM_OUTPUT, NULL);
  }
  
  /**
   * Handle an out of memory condition
   *
   * @param out  an output buffer
   * @param code  the error number
   * @param node  the location of the error.
   * @param extra  extra information
   */
  static void
  xmlSaveErr(xmlOutputBufferPtr out, int code, xmlNodePtr node,
             const char *extra)
  {
      const char *msg = NULL;
      int res;
  
      /* Don't overwrite catastrophic errors */
      if ((out != NULL) &&
          (out->error != XML_ERR_OK) &&
          (xmlIsCatastrophicError(XML_ERR_FATAL, out->error)))
          return;
  
      if (code == XML_ERR_NO_MEMORY) {
          xmlSaveErrMemory(out);
          return;
      }
  
      if (out != NULL)
          out->error = code;
  
      if (code == XML_ERR_UNSUPPORTED_ENCODING) {
          msg = "Unsupported encoding: %s";
      } else {
          msg = xmlErrString(code);
          extra = NULL;
      }
  
      res = xmlRaiseError(NULL, NULL, NULL, NULL, node,
                          XML_FROM_OUTPUT, code, XML_ERR_ERROR, NULL, 0,
                          extra, NULL, NULL, 0, 0,
                          msg, extra);
      if (res < 0)
          xmlSaveErrMemory(out);
  }
  
  /************************************************************************
   *									*
   *			Allocation and deallocation			*
   *									*
   ************************************************************************/
  
  /**
   * Sets the indent string.
   *
   * @since 2.14.0
   *
   * @param ctxt  save context
   * @param indent  indent string
   * @returns 0 on success, -1 if the string is NULL, empty or too long.
   */
  int
  xmlSaveSetIndentString(xmlSaveCtxt *ctxt, const char *indent) {
      size_t len;
      int i;
  
      if ((ctxt == NULL) || (indent == NULL))
          return(-1);
  
      len = strlen(indent);
      if ((len <= 0) || (len > MAX_INDENT))
          return(-1);
  
      ctxt->indent_size = len;
      ctxt->indent_nr = MAX_INDENT / ctxt->indent_size;
      for (i = 0; i < ctxt->indent_nr; i++)
          memcpy(&ctxt->indent[i * ctxt->indent_size], indent, len);
  
      return(0);
  }
  
  /**
   * Initialize a saving context
   *
   * @param ctxt  the saving context
   * @param options  save options
   */
  static void
  xmlSaveCtxtInit(xmlSaveCtxtPtr ctxt, int options)
  {
      if (ctxt == NULL) return;
  
      xmlSaveSetIndentString(ctxt, xmlTreeIndentString);
  
      if (options & XML_SAVE_FORMAT)
          ctxt->format = 1;
      else if (options & XML_SAVE_WSNONSIG)
          ctxt->format = 2;
  
      if (((options & XML_SAVE_EMPTY) == 0) &&
          (xmlSaveNoEmptyTags))
  	options |= XML_SAVE_NO_EMPTY;
  
      ctxt->options = options;
  }
  
  /**
   * Free a saving context, destroying the output in any remaining buffer
   */
  static void
  xmlFreeSaveCtxt(xmlSaveCtxtPtr ctxt)
  {
      if (ctxt == NULL) return;
      if (ctxt->encoding != NULL)
          xmlFree((char *) ctxt->encoding);
      if (ctxt->buf != NULL)
          xmlOutputBufferClose(ctxt->buf);
      xmlFree(ctxt);
  }
  
  /**
   * Create a new saving context
   *
   * @returns the new structure or NULL in case of error
   */
  static xmlSaveCtxtPtr
  xmlNewSaveCtxt(const char *encoding, int options)
  {
      xmlSaveCtxtPtr ret;
  
      ret = (xmlSaveCtxtPtr) xmlMalloc(sizeof(xmlSaveCtxt));
      if (ret == NULL) {
  	xmlSaveErrMemory(NULL);
  	return ( NULL );
      }
      memset(ret, 0, sizeof(xmlSaveCtxt));
  
      if (encoding != NULL) {
          xmlParserErrors res;
  
          res = xmlOpenCharEncodingHandler(encoding, /* output */ 1,
                                           &ret->handler);
  	if (res != XML_ERR_OK) {
  	    xmlSaveErr(NULL, res, NULL, encoding);
              xmlFreeSaveCtxt(ret);
  	    return(NULL);
  	}
          ret->encoding = xmlStrdup((const xmlChar *)encoding);
      }
  
      xmlSaveCtxtInit(ret, options);
  
      return(ret);
  }
  
  /************************************************************************
   *									*
   *		Dumping XML tree content to a simple buffer		*
   *									*
   ************************************************************************/
  
  static void
  xmlSaveWriteText(xmlSaveCtxt *ctxt, const xmlChar *text, unsigned flags) {
      if (ctxt->encoding == NULL)
          flags |= XML_ESCAPE_NON_ASCII;
  
      xmlSerializeText(ctxt->buf, text, SIZE_MAX, flags);
  }
  
  /**
   * Serialize the attribute in the buffer
   *
   * @param ctxt  save context
   * @param attr  the attribute pointer
   */
  static void
  xmlSaveWriteAttrContent(xmlSaveCtxt *ctxt, xmlAttrPtr attr)
  {
      xmlNodePtr children;
      xmlOutputBufferPtr buf = ctxt->buf;
  
      children = attr->children;
      while (children != NULL) {
          switch (children->type) {
              case XML_TEXT_NODE:
  	        xmlSaveWriteText(ctxt, children->content, XML_ESCAPE_ATTR);
  		break;
              case XML_ENTITY_REF_NODE:
                  xmlOutputBufferWrite(buf, 1, "&");
                  xmlOutputBufferWriteString(buf, (const char *) children->name);
                  xmlOutputBufferWrite(buf, 1, ";");
                  break;
              default:
                  /* should not happen unless we have a badly built tree */
                  break;
          }
          children = children->next;
      }
  }
  
  /**
   * This will dump the content the notation declaration as an XML DTD definition
   *
   * @param buf  the XML buffer output
   * @param nota  A notation declaration
   */
  static void
  xmlBufDumpNotationDecl(xmlOutputBufferPtr buf, xmlNotationPtr nota) {
      xmlOutputBufferWrite(buf, 11, "<!NOTATION ");
      xmlOutputBufferWriteString(buf, (const char *) nota->name);
  
      if (nota->PublicID != NULL) {
  	xmlOutputBufferWrite(buf, 8, " PUBLIC ");
  	xmlOutputBufferWriteQuotedString(buf, nota->PublicID);
  	if (nota->SystemID != NULL) {
  	    xmlOutputBufferWrite(buf, 1, " ");
  	    xmlOutputBufferWriteQuotedString(buf, nota->SystemID);
  	}
      } else {
  	xmlOutputBufferWrite(buf, 8, " SYSTEM ");
  	xmlOutputBufferWriteQuotedString(buf, nota->SystemID);
      }
  
      xmlOutputBufferWrite(buf, 3, " >\n");
  }
  
  /**
   * This is called with the hash scan function, and just reverses args
   *
   * @param nota  A notation declaration
   * @param buf  the XML buffer output
   * @param name  unused
   */
  static void
  xmlBufDumpNotationDeclScan(void *nota, void *buf,
                             const xmlChar *name ATTRIBUTE_UNUSED) {
      xmlBufDumpNotationDecl((xmlOutputBufferPtr) buf, (xmlNotationPtr) nota);
  }
  
  /**
   * This will dump the content of the notation table as an XML DTD definition
   *
   * @param buf  an xmlBuf output
   * @param table  A notation table
   */
  static void
  xmlBufDumpNotationTable(xmlOutputBufferPtr buf, xmlNotationTablePtr table) {
      xmlHashScan(table, xmlBufDumpNotationDeclScan, buf);
  }
  
  /**
   * Dump the occurrence operator of an element.
   *
   * @param buf  output buffer
   * @param cur  element table
   */
  static void
  xmlBufDumpElementOccur(xmlOutputBufferPtr buf, xmlElementContentPtr cur) {
      switch (cur->ocur) {
          case XML_ELEMENT_CONTENT_ONCE:
              break;
          case XML_ELEMENT_CONTENT_OPT:
              xmlOutputBufferWrite(buf, 1, "?");
              break;
          case XML_ELEMENT_CONTENT_MULT:
              xmlOutputBufferWrite(buf, 1, "*");
              break;
          case XML_ELEMENT_CONTENT_PLUS:
              xmlOutputBufferWrite(buf, 1, "+");
              break;
      }
  }
  
  /**
   * This will dump the content of the element table as an XML DTD definition
   *
   * @param buf  output buffer
   * @param content  element table
   */
  static void
  xmlBufDumpElementContent(xmlOutputBufferPtr buf,
                           xmlElementContentPtr content) {
      xmlElementContentPtr cur;
  
      if (content == NULL) return;
  
      xmlOutputBufferWrite(buf, 1, "(");
      cur = content;
  
      do {
          if (cur == NULL) return;
  
          switch (cur->type) {
              case XML_ELEMENT_CONTENT_PCDATA:
                  xmlOutputBufferWrite(buf, 7, "#PCDATA");
                  break;
              case XML_ELEMENT_CONTENT_ELEMENT:
                  if (cur->prefix != NULL) {
                      xmlOutputBufferWriteString(buf,
                              (const char *) cur->prefix);
                      xmlOutputBufferWrite(buf, 1, ":");
                  }
                  xmlOutputBufferWriteString(buf, (const char *) cur->name);
                  break;
              case XML_ELEMENT_CONTENT_SEQ:
              case XML_ELEMENT_CONTENT_OR:
                  if ((cur != content) &&
                      (cur->parent != NULL) &&
                      ((cur->type != cur->parent->type) ||
                       (cur->ocur != XML_ELEMENT_CONTENT_ONCE)))
                      xmlOutputBufferWrite(buf, 1, "(");
                  cur = cur->c1;
                  continue;
          }
  
          while (cur != content) {
              xmlElementContentPtr parent = cur->parent;
  
              if (parent == NULL) return;
  
              if (((cur->type == XML_ELEMENT_CONTENT_OR) ||
                   (cur->type == XML_ELEMENT_CONTENT_SEQ)) &&
                  ((cur->type != parent->type) ||
                   (cur->ocur != XML_ELEMENT_CONTENT_ONCE)))
                  xmlOutputBufferWrite(buf, 1, ")");
              xmlBufDumpElementOccur(buf, cur);
  
              if (cur == parent->c1) {
                  if (parent->type == XML_ELEMENT_CONTENT_SEQ)
                      xmlOutputBufferWrite(buf, 3, " , ");
                  else if (parent->type == XML_ELEMENT_CONTENT_OR)
                      xmlOutputBufferWrite(buf, 3, " | ");
  
                  cur = parent->c2;
                  break;
              }
  
              cur = parent;
          }
      } while (cur != content);
  
      xmlOutputBufferWrite(buf, 1, ")");
      xmlBufDumpElementOccur(buf, content);
  }
  
  /**
   * This will dump the content of the element declaration as an XML
   * DTD definition
   *
   * @param buf  an xmlBuf output
   * @param elem  An element table
   */
  static void
  xmlBufDumpElementDecl(xmlOutputBufferPtr buf, xmlElementPtr elem) {
      xmlOutputBufferWrite(buf, 10, "<!ELEMENT ");
      if (elem->prefix != NULL) {
          xmlOutputBufferWriteString(buf, (const char *) elem->prefix);
          xmlOutputBufferWrite(buf, 1, ":");
      }
      xmlOutputBufferWriteString(buf, (const char *) elem->name);
      xmlOutputBufferWrite(buf, 1, " ");
  
      switch (elem->etype) {
  	case XML_ELEMENT_TYPE_EMPTY:
  	    xmlOutputBufferWrite(buf, 5, "EMPTY");
  	    break;
  	case XML_ELEMENT_TYPE_ANY:
  	    xmlOutputBufferWrite(buf, 3, "ANY");
  	    break;
  	case XML_ELEMENT_TYPE_MIXED:
  	case XML_ELEMENT_TYPE_ELEMENT:
  	    xmlBufDumpElementContent(buf, elem->content);
  	    break;
          default:
              /* assert(0); */
              break;
      }
  
      xmlOutputBufferWrite(buf, 2, ">\n");
  }
  
  /**
   * This will dump the content of the enumeration
   *
   * @param buf  output buffer
   * @param cur  an enumeration
   */
  static void
  xmlBufDumpEnumeration(xmlOutputBufferPtr buf, xmlEnumerationPtr cur) {
      while (cur != NULL) {
          xmlOutputBufferWriteString(buf, (const char *) cur->name);
          if (cur->next != NULL)
              xmlOutputBufferWrite(buf, 3, " | ");
  
          cur = cur->next;
      }
  
      xmlOutputBufferWrite(buf, 1, ")");
  }
  /**
   * This will dump the content of the attribute declaration as an XML
   * DTD definition
   *
   * @param ctxt  save context
   * @param attr  an attribute declaration
   */
  static void
  xmlSaveWriteAttributeDecl(xmlSaveCtxtPtr ctxt, xmlAttributePtr attr) {
      xmlOutputBufferPtr buf = ctxt->buf;
  
      xmlOutputBufferWrite(buf, 10, "<!ATTLIST ");
      xmlOutputBufferWriteString(buf, (const char *) attr->elem);
      xmlOutputBufferWrite(buf, 1, " ");
      if (attr->prefix != NULL) {
  	xmlOutputBufferWriteString(buf, (const char *) attr->prefix);
  	xmlOutputBufferWrite(buf, 1, ":");
      }
      xmlOutputBufferWriteString(buf, (const char *) attr->name);
  
      switch (attr->atype) {
  	case XML_ATTRIBUTE_CDATA:
  	    xmlOutputBufferWrite(buf, 6, " CDATA");
  	    break;
  	case XML_ATTRIBUTE_ID:
  	    xmlOutputBufferWrite(buf, 3, " ID");
  	    break;
  	case XML_ATTRIBUTE_IDREF:
  	    xmlOutputBufferWrite(buf, 6, " IDREF");
  	    break;
  	case XML_ATTRIBUTE_IDREFS:
  	    xmlOutputBufferWrite(buf, 7, " IDREFS");
  	    break;
  	case XML_ATTRIBUTE_ENTITY:
  	    xmlOutputBufferWrite(buf, 7, " ENTITY");
  	    break;
  	case XML_ATTRIBUTE_ENTITIES:
  	    xmlOutputBufferWrite(buf, 9, " ENTITIES");
  	    break;
  	case XML_ATTRIBUTE_NMTOKEN:
  	    xmlOutputBufferWrite(buf, 8, " NMTOKEN");
  	    break;
  	case XML_ATTRIBUTE_NMTOKENS:
  	    xmlOutputBufferWrite(buf, 9, " NMTOKENS");
  	    break;
  	case XML_ATTRIBUTE_ENUMERATION:
  	    xmlOutputBufferWrite(buf, 2, " (");
  	    xmlBufDumpEnumeration(buf, attr->tree);
  	    break;
  	case XML_ATTRIBUTE_NOTATION:
  	    xmlOutputBufferWrite(buf, 11, " NOTATION (");
  	    xmlBufDumpEnumeration(buf, attr->tree);
  	    break;
  	default:
              /* assert(0); */
              break;
      }
  
      switch (attr->def) {
  	case XML_ATTRIBUTE_NONE:
  	    break;
  	case XML_ATTRIBUTE_REQUIRED:
  	    xmlOutputBufferWrite(buf, 10, " #REQUIRED");
  	    break;
  	case XML_ATTRIBUTE_IMPLIED:
  	    xmlOutputBufferWrite(buf, 9, " #IMPLIED");
  	    break;
  	case XML_ATTRIBUTE_FIXED:
  	    xmlOutputBufferWrite(buf, 7, " #FIXED");
  	    break;
  	default:
              /* assert(0); */
              break;
      }
  
      if (attr->defaultValue != NULL) {
          xmlOutputBufferWrite(buf, 2, " \"");
          xmlSaveWriteText(ctxt, attr->defaultValue, XML_ESCAPE_ATTR);
          xmlOutputBufferWrite(buf, 1, "\"");
      }
  
      xmlOutputBufferWrite(buf, 2, ">\n");
  }
  
  /**
   * This will dump the quoted string value, taking care of the special
   * treatment required by %
   *
   * @param buf  output buffer
   * @param content  entity content.
   */
  static void
  xmlBufDumpEntityContent(xmlOutputBufferPtr buf, const xmlChar *content) {
      const char * base, *cur;
  
      if (content == NULL)
          return;
  
      xmlOutputBufferWrite(buf, 1, "\"");
      base = cur = (const char *) content;
      while (*cur != 0) {
          if (*cur == '"') {
              if (base != cur)
                  xmlOutputBufferWrite(buf, cur - base, base);
              xmlOutputBufferWrite(buf, 6, "&quot;");
              cur++;
              base = cur;
          } else if (*cur == '%') {
              if (base != cur)
                  xmlOutputBufferWrite(buf, cur - base, base);
              xmlOutputBufferWrite(buf, 6, "&#x25;");
              cur++;
              base = cur;
          } else {
              cur++;
          }
      }
      if (base != cur)
          xmlOutputBufferWrite(buf, cur - base, base);
      xmlOutputBufferWrite(buf, 1, "\"");
  }
  
  /**
   * This will dump the content of the entity table as an XML DTD definition
   *
   * @param buf  an xmlBuf output
   * @param ent  An entity table
   */
  static void
  xmlBufDumpEntityDecl(xmlOutputBufferPtr buf, xmlEntityPtr ent) {
      if ((ent->etype == XML_INTERNAL_PARAMETER_ENTITY) ||
          (ent->etype == XML_EXTERNAL_PARAMETER_ENTITY))
          xmlOutputBufferWrite(buf, 11, "<!ENTITY % ");
      else
          xmlOutputBufferWrite(buf, 9, "<!ENTITY ");
      xmlOutputBufferWriteString(buf, (const char *) ent->name);
      xmlOutputBufferWrite(buf, 1, " ");
  
      if ((ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY) ||
          (ent->etype == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) ||
          (ent->etype == XML_EXTERNAL_PARAMETER_ENTITY)) {
          if (ent->ExternalID != NULL) {
               xmlOutputBufferWrite(buf, 7, "PUBLIC ");
               xmlOutputBufferWriteQuotedString(buf, ent->ExternalID);
               xmlOutputBufferWrite(buf, 1, " ");
          } else {
               xmlOutputBufferWrite(buf, 7, "SYSTEM ");
          }
          xmlOutputBufferWriteQuotedString(buf, ent->SystemID);
      }
  
      if (ent->etype == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
          if (ent->content != NULL) { /* Should be true ! */
              xmlOutputBufferWrite(buf, 7, " NDATA ");
              if (ent->orig != NULL)
                  xmlOutputBufferWriteString(buf, (const char *) ent->orig);
              else
                  xmlOutputBufferWriteString(buf, (const char *) ent->content);
          }
      }
  
      if ((ent->etype == XML_INTERNAL_GENERAL_ENTITY) ||
          (ent->etype == XML_INTERNAL_PARAMETER_ENTITY)) {
          /*
           * We could save the original quote character and avoid
           * calling xmlOutputBufferWriteQuotedString here.
           */
          if (ent->orig != NULL)
              xmlOutputBufferWriteQuotedString(buf, ent->orig);
          else
              xmlBufDumpEntityContent(buf, ent->content);
      }
  
      xmlOutputBufferWrite(buf, 2, ">\n");
  }
  
  /************************************************************************
   *									*
   *		Dumping XML tree content to an I/O output buffer	*
   *									*
   ************************************************************************/
  
  static int
  xmlSaveSwitchEncoding(xmlSaveCtxtPtr ctxt, const char *encoding) {
      xmlOutputBufferPtr buf = ctxt->buf;
      xmlCharEncodingHandler *handler;
      xmlParserErrors res;
  
      /* shouldn't happen */
      if ((buf->encoder != NULL) || (buf->conv != NULL))
          return(-1);
  
      res = xmlOpenCharEncodingHandler(encoding, /* output */ 1, &handler);
      if (res != XML_ERR_OK) {
          xmlSaveErr(buf, res, NULL, encoding);
          return(-1);
      }
  
      if (handler != NULL) {
          xmlBufPtr newbuf;
  
          newbuf = xmlBufCreate(4000 /* MINLEN */);
          if (newbuf == NULL) {
              xmlCharEncCloseFunc(handler);
              xmlSaveErrMemory(buf);
              return(-1);
          }
  
          buf->conv = buf->buffer;
          buf->buffer = newbuf;
          buf->encoder = handler;
      }
  
      ctxt->encoding = (const xmlChar *) encoding;
  
      /*
       * initialize the state, e.g. if outputting a BOM
       */
      xmlCharEncOutput(buf, 1);
  
      return(0);
  }
  
  static int
  xmlSaveClearEncoding(xmlSaveCtxtPtr ctxt) {
      xmlOutputBufferPtr buf = ctxt->buf;
  
      xmlOutputBufferFlush(buf);
  
      if (buf->encoder != NULL) {
          xmlCharEncCloseFunc(buf->encoder);
          buf->encoder = NULL;
          xmlBufFree(buf->buffer);
          buf->buffer = buf->conv;
          buf->conv = NULL;
      }
  
      ctxt->encoding = NULL;
  
      return(0);
  }
  
  #ifdef LIBXML_HTML_ENABLED
  static void
  xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cur);
  #endif
  static void
  xmlNodeDumpOutputInternal(xmlSaveCtxtPtr ctxt, xmlNodePtr cur);
  static int
  xmlSaveDocInternal(xmlSaveCtxtPtr ctxt, xmlDocPtr cur,
                     const xmlChar *encoding);
  
  static void
  xmlSaveWriteIndent(xmlSaveCtxtPtr ctxt, int extra)
  {
      int level;
  
      if ((ctxt->options & XML_SAVE_NO_INDENT) ||
          (((ctxt->options & XML_SAVE_INDENT) == 0) &&
           (xmlIndentTreeOutput == 0)))
          return;
  
      level = ctxt->level + extra;
      if (level > ctxt->indent_nr)
          level = ctxt->indent_nr;
      xmlOutputBufferWrite(ctxt->buf, ctxt->indent_size * level, ctxt->indent);
  }
  
  /**
   * Write out formatting for non-significant whitespace output.
   *
   * @param ctxt  The save context
   * @param extra  Number of extra indents to apply to ctxt->level
   */
  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);
      }
  }
  
  /**
   * Dump a local Namespace definition.
   * Should be called in the context of attributes dumps.
   * If `ctxt` is supplied, `buf` should be its buffer.
   *
   * @param buf  the XML buffer output
   * @param cur  a namespace
   * @param ctxt  the output save context. Optional.
   */
  static void
  xmlNsDumpOutput(xmlOutputBufferPtr buf, xmlNsPtr cur, xmlSaveCtxtPtr ctxt) {
      unsigned escapeFlags = XML_ESCAPE_ATTR;
  
      if ((cur == NULL) || (buf == NULL)) return;
  
      if ((ctxt == NULL) || (ctxt->encoding == NULL))
          escapeFlags |= XML_ESCAPE_NON_ASCII;
  
      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, 6, "xmlns:");
  	    xmlOutputBufferWriteString(buf, (const char *)cur->prefix);
  	} else
  	    xmlOutputBufferWrite(buf, 5, "xmlns");
          xmlOutputBufferWrite(buf, 2, "=\"");
          xmlSerializeText(buf, cur->href, SIZE_MAX, escapeFlags);
          xmlOutputBufferWrite(buf, 1, "\"");
      }
  }
  
  /**
   * Dump a list of local namespace definitions to a save context.
   * Should be called in the context of attribute dumps.
   *
   * @param ctxt  the save context
   * @param cur  the first namespace
   */
  static void
  xmlNsListDumpOutputCtxt(xmlSaveCtxtPtr ctxt, xmlNsPtr cur) {
      while (cur != NULL) {
          xmlNsDumpOutput(ctxt->buf, cur, ctxt);
  	cur = cur->next;
      }
  }
  
  /**
   * Serialize a list of namespace definitions.
   *
   * @param buf  the XML buffer output
   * @param cur  the first namespace
   */
  void
  xmlNsListDumpOutput(xmlOutputBuffer *buf, xmlNs *cur) {
      while (cur != NULL) {
          xmlNsDumpOutput(buf, cur, NULL);
  	cur = cur->next;
      }
  }
  
  /**
   * Dump the XML document DTD, if any.
   *
   * @param ctxt  the save context
   * @param dtd  the pointer to the DTD
   */
  static void
  xmlDtdDumpOutput(xmlSaveCtxtPtr ctxt, xmlDtdPtr dtd) {
      xmlOutputBufferPtr buf;
      xmlNodePtr cur;
      int format, level;
  
      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 ");
  	xmlOutputBufferWriteQuotedString(buf, dtd->ExternalID);
  	xmlOutputBufferWrite(buf, 1, " ");
  	xmlOutputBufferWriteQuotedString(buf, dtd->SystemID);
      }  else if (dtd->SystemID != NULL) {
  	xmlOutputBufferWrite(buf, 8, " SYSTEM ");
  	xmlOutputBufferWriteQuotedString(buf, 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))) {
          xmlBufDumpNotationTable(buf, (xmlNotationTablePtr) dtd->notations);
      }
      format = ctxt->format;
      level = ctxt->level;
      ctxt->format = 0;
      ctxt->level = -1;
      for (cur = dtd->children; cur != NULL; cur = cur->next) {
          xmlNodeDumpOutputInternal(ctxt, cur);
      }
      ctxt->format = format;
      ctxt->level = level;
      xmlOutputBufferWrite(buf, 2, "]>");
  }
  
  /**
   * Dump an XML attribute
   *
   * @param ctxt  the save context
   * @param cur  the attribute pointer
   */
  static void
  xmlAttrDumpOutput(xmlSaveCtxtPtr ctxt, xmlAttrPtr cur) {
      xmlOutputBufferPtr buf;
  
      if (cur == NULL) return;
      buf = ctxt->buf;
      if (buf == NULL) return;
      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, "=\"");
  #ifdef LIBXML_HTML_ENABLED
      if ((ctxt->options & XML_SAVE_XHTML) &&
          (cur->ns == NULL) &&
          ((cur->children == NULL) ||
           (cur->children->content == NULL) ||
           (cur->children->content[0] == 0)) &&
          (htmlIsBooleanAttr(cur->name))) {
          xmlOutputBufferWriteString(buf, (const char *) cur->name);
      } else
  #endif
      {
          xmlSaveWriteAttrContent(ctxt, cur);
      }
      xmlOutputBufferWrite(buf, 1, "\"");
  }
  
  #ifdef LIBXML_HTML_ENABLED
  /**
   * Dump an HTML node, recursive behaviour, children are printed too.
   *
   * @param ctxt  the save context
   * @param cur  the current node
   */
  static int
  htmlNodeDumpOutputInternal(xmlSaveCtxtPtr ctxt, xmlNodePtr cur) {
      int switched_encoding = 0;
      int format = 0;
  
      xmlInitParser();
  
      if (ctxt->encoding == NULL) {
          const char *encoding = NULL;
  
          if (cur->doc != NULL)
              encoding = (char *) cur->doc->encoding;
  
          if (encoding == NULL)
              encoding = "HTML";
  
  	if (xmlSaveSwitchEncoding(ctxt, encoding) < 0)
  	    return(-1);
  	switched_encoding = 1;
      }
  
      if (ctxt->options & XML_SAVE_FORMAT)
          format = 1;
  
      htmlNodeDumpInternal(ctxt->buf, cur, (char *) ctxt->encoding, format);
  
      if (switched_encoding) {
  	xmlSaveClearEncoding(ctxt);
      }
  
      return(0);
  }
  #endif
  
  /**
   * Dump an XML node, recursive behaviour, children are printed too.
   *
   * @param ctxt  the save context
   * @param cur  the current node
   */
  static void
  xmlNodeDumpOutputInternal(xmlSaveCtxtPtr ctxt, xmlNodePtr cur) {
      int format = ctxt->format;
      xmlNodePtr tmp, root, unformattedNode = NULL, parent;
      xmlAttrPtr attr;
      xmlChar *start, *end;
      xmlOutputBufferPtr buf;
  
      if (cur == NULL) return;
      buf = ctxt->buf;
  
      root = cur;
      parent = cur->parent;
      while (1) {
          switch (cur->type) {
          case XML_DOCUMENT_NODE:
          case XML_HTML_DOCUMENT_NODE:
  	    xmlSaveDocInternal(ctxt, (xmlDocPtr) cur, ctxt->encoding);
  	    break;
  
          case XML_DTD_NODE:
              xmlDtdDumpOutput(ctxt, (xmlDtdPtr) cur);
              break;
  
          case XML_DOCUMENT_FRAG_NODE:
              /* Always validate cur->parent when descending. */
              if ((cur->parent == parent) && (cur->children != NULL)) {
                  parent = cur;
                  cur = cur->children;
                  continue;
              }
  	    break;
  
          case XML_ELEMENT_DECL:
              xmlBufDumpElementDecl(buf, (xmlElementPtr) cur);
              break;
  
          case XML_ATTRIBUTE_DECL:
              xmlSaveWriteAttributeDecl(ctxt, (xmlAttributePtr) cur);
              break;
  
          case XML_ENTITY_DECL:
              xmlBufDumpEntityDecl(buf, (xmlEntityPtr) cur);
              break;
  
          case XML_ELEMENT_NODE:
  	    if ((cur != root) && (ctxt->format == 1))
                  xmlSaveWriteIndent(ctxt, 0);
  
              /*
               * Some users like lxml are known to pass nodes with a corrupted
               * tree structure. Fall back to a recursive call to handle this
               * case.
               */
              if ((cur->parent != parent) && (cur->children != NULL)) {
                  xmlNodeDumpOutputInternal(ctxt, cur);
                  break;
              }
  
              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)
                  xmlNsListDumpOutputCtxt(ctxt, cur->nsDef);
              for (attr = cur->properties; attr != NULL; attr = attr->next)
                  xmlAttrDumpOutput(ctxt, attr);
  
              if (cur->children == NULL) {
                  if ((ctxt->options & XML_SAVE_NO_EMPTY) == 0) {
                      if (ctxt->format == 2)
                          xmlOutputBufferWriteWSNonSig(ctxt, 0);
                      xmlOutputBufferWrite(buf, 2, "/>");
                  } else {
                      if (ctxt->format == 2)
                          xmlOutputBufferWriteWSNonSig(ctxt, 1);
                      xmlOutputBufferWrite(buf, 3, "></");
                      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, ">");
                  }
              } else {
                  if (ctxt->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;
                              unformattedNode = cur;
                              break;
                          }
                          tmp = tmp->next;
                      }
                  }
                  if (ctxt->format == 2)
                      xmlOutputBufferWriteWSNonSig(ctxt, 1);
                  xmlOutputBufferWrite(buf, 1, ">");
                  if (ctxt->format == 1) xmlOutputBufferWrite(buf, 1, "\n");
                  if (ctxt->level >= 0) ctxt->level++;
                  parent = cur;
                  cur = cur->children;
                  continue;
              }
  
              break;
  
          case XML_TEXT_NODE:
  	    if (cur->content == NULL)
                  break;
  	    if (cur->name != xmlStringTextNoenc) {
                  if (ctxt->escape)
                      xmlOutputBufferWriteEscape(buf, cur->content,
                                                 ctxt->escape);
  #ifdef TEST_OUTPUT_BUFFER_WRITE_ESCAPE
                  else if (ctxt->encoding)
                      xmlOutputBufferWriteEscape(buf, cur->content, NULL);
  #endif
                  else
                      xmlSaveWriteText(ctxt, cur->content, /* flags */ 0);
  	    } else {
  		/*
  		 * Disable escaping, needed for XSLT
  		 */
  		xmlOutputBufferWriteString(buf, (const char *) cur->content);
  	    }
  	    break;
  
          case XML_PI_NODE:
  	    if ((cur != root) && (ctxt->format == 1))
                  xmlSaveWriteIndent(ctxt, 0);
  
              if (cur->content != NULL) {
                  xmlOutputBufferWrite(buf, 2, "<?");
                  xmlOutputBufferWriteString(buf, (const char *)cur->name);
                  if (cur->content != NULL) {
                      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, "?>");
              }
              break;
  
          case XML_COMMENT_NODE:
  	    if ((cur != root) && (ctxt->format == 1))
                  xmlSaveWriteIndent(ctxt, 0);
  
              if (cur->content != NULL) {
                  xmlOutputBufferWrite(buf, 4, "<!--");
                  xmlOutputBufferWriteString(buf, (const char *)cur->content);
                  xmlOutputBufferWrite(buf, 3, "-->");
              }
              break;
  
          case XML_ENTITY_REF_NODE:
              xmlOutputBufferWrite(buf, 1, "&");
              xmlOutputBufferWriteString(buf, (const char *)cur->name);
              xmlOutputBufferWrite(buf, 1, ";");
              break;
  
          case XML_CDATA_SECTION_NODE:
              if (cur->content == NULL || *cur->content == '\0') {
                  xmlOutputBufferWrite(buf, 12, "<![CDATA[]]>");
              } else {
                  start = end = cur->content;
                  while (*end != '\0') {
                      if ((*end == ']') && (*(end + 1) == ']') &&
                          (*(end + 2) == '>')) {
                          end = end + 2;
                          xmlOutputBufferWrite(buf, 9, "<![CDATA[");
                          xmlOutputBufferWrite(buf, end - start,
                                  (const char *)start);
                          xmlOutputBufferWrite(buf, 3, "]]>");
                          start = end;
                      }
                      end++;
                  }
                  if (start != end) {
                      xmlOutputBufferWrite(buf, 9, "<![CDATA[");
                      xmlOutputBufferWriteString(buf, (const char *)start);
                      xmlOutputBufferWrite(buf, 3, "]]>");
                  }
              }
              break;
  
          case XML_ATTRIBUTE_NODE:
              xmlAttrDumpOutput(ctxt, (xmlAttrPtr) cur);
              break;
  
          case XML_NAMESPACE_DECL:
              xmlNsDumpOutput(buf, (xmlNsPtr) cur, ctxt);
              break;
  
          default:
              break;
          }
  
          while (1) {
              if (cur == root)
                  return;
              if ((ctxt->format == 1) &&
                  (cur->type != XML_XINCLUDE_START) &&
                  (cur->type != XML_XINCLUDE_END))
                  xmlOutputBufferWrite(buf, 1, "\n");
              if (cur->next != NULL) {
                  cur = cur->next;
                  break;
              }
  
              cur = parent;
              /* cur->parent was validated when descending. */
              parent = cur->parent;
  
              if (cur->type == XML_ELEMENT_NODE) {
                  if (ctxt->level > 0) ctxt->level--;
                  if (ctxt->format == 1)
                      xmlSaveWriteIndent(ctxt, 0);
  
                  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, ">");
  
                  if (cur == unformattedNode) {
                      ctxt->format = format;
                      unformattedNode = NULL;
                  }
              }
          }
      }
  }
  
  /**
   * Dump an XML document.
   *
   * @param ctxt  the save context
   * @param cur  the document
   * @param encoding  character encoding (optional)
   */
  static int
  xmlSaveDocInternal(xmlSaveCtxtPtr ctxt, xmlDocPtr cur,
                     const xmlChar *encoding) {
  #ifdef LIBXML_HTML_ENABLED
      xmlDtdPtr dtd;
      int is_xhtml = 0;
  #endif
      xmlOutputBufferPtr buf = ctxt->buf;
      int switched_encoding = 0;
  
      xmlInitParser();
  
      if ((cur->type != XML_HTML_DOCUMENT_NODE) &&
          (cur->type != XML_DOCUMENT_NODE))
  	 return(-1);
  
      if (encoding == NULL)
  	encoding = cur->encoding;
  
      if (((cur->type == XML_HTML_DOCUMENT_NODE) &&
           ((ctxt->options & XML_SAVE_AS_XML) == 0) &&
           ((ctxt->options & XML_SAVE_XHTML) == 0)) ||
          (ctxt->options & XML_SAVE_AS_HTML)) {
  #ifdef LIBXML_HTML_ENABLED
          int format = 0;
  
  	if (ctxt->encoding == NULL) {
              if (encoding == NULL)
                  encoding = BAD_CAST "HTML";
  
  	    if (xmlSaveSwitchEncoding(ctxt, (const char*) encoding) < 0) {
  		return(-1);
  	    }
              switched_encoding = 1;
  	}
  
          if (ctxt->options & XML_SAVE_FORMAT)
              format = 1;
          htmlNodeDumpInternal(buf, (htmlNodePtr) cur, (char *) ctxt->encoding,
                               format);
  #else
          return(-1);
  #endif
      } else if ((cur->type == XML_DOCUMENT_NODE) ||
                 (ctxt->options & XML_SAVE_AS_XML) ||
                 (ctxt->options & XML_SAVE_XHTML)) {
  	if ((encoding != NULL) && (ctxt->encoding == NULL)) {
              if (xmlSaveSwitchEncoding(ctxt, (const char *) encoding) < 0)
                  return(-1);
              switched_encoding = 1;
  	}
  
  	/*
  	 * Save the XML declaration
  	 */
  	if ((ctxt->options & XML_SAVE_NO_DECL) == 0) {
  	    xmlOutputBufferWrite(buf, 15, "<?xml version=\"");
  	    if (cur->version != NULL)
  		xmlOutputBufferWriteString(buf, (char *) cur->version);
  	    else
  		xmlOutputBufferWrite(buf, 3, "1.0");
  	    xmlOutputBufferWrite(buf, 1, "\"");
  	    if (encoding != NULL) {
  		xmlOutputBufferWrite(buf, 11, " encoding=\"");
  		xmlOutputBufferWriteString(buf, (char *) encoding);
  	        xmlOutputBufferWrite(buf, 1, "\"");
  	    }
  	    switch (cur->standalone) {
  		case 0:
  		    xmlOutputBufferWrite(buf, 16, " standalone=\"no\"");
  		    break;
  		case 1:
  		    xmlOutputBufferWrite(buf, 17, " standalone=\"yes\"");
  		    break;
  	    }
  	    xmlOutputBufferWrite(buf, 3, "?>\n");
  	}
  
  #ifdef LIBXML_HTML_ENABLED
          if (ctxt->options & XML_SAVE_XHTML)
              is_xhtml = 1;
  	if ((ctxt->options & XML_SAVE_NO_XHTML) == 0) {
  	    dtd = xmlGetIntSubset(cur);
  	    if (dtd != NULL) {
  		is_xhtml = xmlIsXHTML(dtd->SystemID, dtd->ExternalID);
  		if (is_xhtml < 0) is_xhtml = 0;
  	    }
  	}
  #endif
  	if (cur->children != NULL) {
  	    xmlNodePtr child = cur->children;
  
  	    while (child != NULL) {
  		ctxt->level = 0;
  #ifdef LIBXML_HTML_ENABLED
  		if (is_xhtml)
  		    xhtmlNodeDumpOutput(ctxt, child);
  		else
  #endif
  		    xmlNodeDumpOutputInternal(ctxt, child);
                  if ((child->type != XML_XINCLUDE_START) &&
                      (child->type != XML_XINCLUDE_END))
                      xmlOutputBufferWrite(buf, 1, "\n");
  		child = child->next;
  	    }
  	}
      }
  
      /*
       * Restore the state of the saving context at the end of the document
       */
      if (switched_encoding) {
  	xmlSaveClearEncoding(ctxt);
      }
  
      return(0);
  }
  
  #ifdef LIBXML_HTML_ENABLED
  /************************************************************************
   *									*
   *		Functions specific to XHTML serialization		*
   *									*
   ************************************************************************/
  
  /**
   * Check if a node is an empty xhtml node
   *
   * @param node  the node
   * @returns 1 if the node is an empty node, 0 if not and -1 in case of error
   */
  static int
  xhtmlIsEmpty(xmlNodePtr node) {
      if (node == NULL)
  	return(-1);
      if (node->type != XML_ELEMENT_NODE)
  	return(0);
      if ((node->ns != NULL) && (!xmlStrEqual(node->ns->href, XHTML_NS_NAME)))
  	return(0);
      if (node->children != NULL)
  	return(0);
      switch (node->name ? node->name[0] : 0) {
  	case 'a':
  	    if (xmlStrEqual(node->name, BAD_CAST "area"))
  		return(1);
  	    return(0);
  	case 'b':
  	    if (xmlStrEqual(node->name, BAD_CAST "br"))
  		return(1);
  	    if (xmlStrEqual(node->name, BAD_CAST "base"))
  		return(1);
  	    if (xmlStrEqual(node->name, BAD_CAST "basefont"))
  		return(1);
  	    return(0);
  	case 'c':
  	    if (xmlStrEqual(node->name, BAD_CAST "col"))
  		return(1);
  	    return(0);
  	case 'f':
  	    if (xmlStrEqual(node->name, BAD_CAST "frame"))
  		return(1);
  	    return(0);
  	case 'h':
  	    if (xmlStrEqual(node->name, BAD_CAST "hr"))
  		return(1);
  	    return(0);
  	case 'i':
  	    if (xmlStrEqual(node->name, BAD_CAST "img"))
  		return(1);
  	    if (xmlStrEqual(node->name, BAD_CAST "input"))
  		return(1);
  	    if (xmlStrEqual(node->name, BAD_CAST "isindex"))
  		return(1);
  	    return(0);
  	case 'l':
  	    if (xmlStrEqual(node->name, BAD_CAST "link"))
  		return(1);
  	    return(0);
  	case 'm':
  	    if (xmlStrEqual(node->name, BAD_CAST "meta"))
  		return(1);
  	    return(0);
  	case 'p':
  	    if (xmlStrEqual(node->name, BAD_CAST "param"))
  		return(1);
  	    return(0);
      }
      return(0);
  }
  
  /**
   * Dump a list of XML attributes
   *
   * @param ctxt  the save context
   * @param cur  the first attribute pointer
   */
  static void
  xhtmlAttrListDumpOutput(xmlSaveCtxtPtr ctxt, xmlAttrPtr cur) {
      xmlAttrPtr xml_lang = NULL;
      xmlAttrPtr lang = NULL;
      xmlAttrPtr name = NULL;
      xmlAttrPtr id = NULL;
      xmlNodePtr parent;
      xmlOutputBufferPtr buf;
  
      if (cur == NULL) return;
      buf = ctxt->buf;
      parent = cur->parent;
      while (cur != NULL) {
  	if ((cur->ns == NULL) && (xmlStrEqual(cur->name, BAD_CAST "id")))
  	    id = cur;
  	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;
          xmlAttrDumpOutput(ctxt, cur);
  	cur = cur->next;
      }
      /*
       * C.8
       */
      if ((name != NULL) && (id == NULL)) {
  	if ((parent != NULL) && (parent->name != NULL) &&
  	    ((xmlStrEqual(parent->name, BAD_CAST "a")) ||
  	     (xmlStrEqual(parent->name, BAD_CAST "p")) ||
  	     (xmlStrEqual(parent->name, BAD_CAST "div")) ||
  	     (xmlStrEqual(parent->name, BAD_CAST "img")) ||
  	     (xmlStrEqual(parent->name, BAD_CAST "map")) ||
  	     (xmlStrEqual(parent->name, BAD_CAST "applet")) ||
  	     (xmlStrEqual(parent->name, BAD_CAST "form")) ||
  	     (xmlStrEqual(parent->name, BAD_CAST "frame")) ||
  	     (xmlStrEqual(parent->name, BAD_CAST "iframe")))) {
  	    xmlOutputBufferWrite(buf, 5, " id=\"");
              xmlSaveWriteAttrContent(ctxt, name);
  	    xmlOutputBufferWrite(buf, 1, "\"");
  	}
      }
      /*
       * C.7.
       */
      if ((lang != NULL) && (xml_lang == NULL)) {
  	xmlOutputBufferWrite(buf, 11, " xml:lang=\"");
          xmlSaveWriteAttrContent(ctxt, lang);
  	xmlOutputBufferWrite(buf, 1, "\"");
      } else
      if ((xml_lang != NULL) && (lang == NULL)) {
  	xmlOutputBufferWrite(buf, 7, " lang=\"");
          xmlSaveWriteAttrContent(ctxt, xml_lang);
  	xmlOutputBufferWrite(buf, 1, "\"");
      }
  }
  
  /**
   * Dump an XHTML node, recursive behaviour, children are printed too.
   *
   * @param ctxt  the save context
   * @param cur  the current node
   */
  static void
  xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cur) {
      int format = ctxt->format, addmeta, oldoptions;
      xmlNodePtr tmp, root, unformattedNode = NULL, parent;
      xmlChar *start, *end;
      xmlOutputBufferPtr buf = ctxt->buf;
  
      if (cur == NULL) return;
  
      oldoptions = ctxt->options;
      ctxt->options |= XML_SAVE_XHTML;
  
      root = cur;
      parent = cur->parent;
      while (1) {
          switch (cur->type) {
          case XML_DOCUMENT_NODE:
          case XML_HTML_DOCUMENT_NODE:
              xmlSaveDocInternal(ctxt, (xmlDocPtr) cur, ctxt->encoding);
  	    break;
  
          case XML_NAMESPACE_DECL:
  	    xmlNsDumpOutput(buf, (xmlNsPtr) cur, ctxt);
  	    break;
  
          case XML_DTD_NODE:
              xmlDtdDumpOutput(ctxt, (xmlDtdPtr) cur);
  	    break;
  
          case XML_DOCUMENT_FRAG_NODE:
              /* Always validate cur->parent when descending. */
              if ((cur->parent == parent) && (cur->children != NULL)) {
                  parent = cur;
                  cur = cur->children;
                  continue;
              }
              break;
  
          case XML_ELEMENT_DECL:
              xmlBufDumpElementDecl(buf, (xmlElementPtr) cur);
  	    break;
  
          case XML_ATTRIBUTE_DECL:
              xmlSaveWriteAttributeDecl(ctxt, (xmlAttributePtr) cur);
  	    break;
  
          case XML_ENTITY_DECL:
              xmlBufDumpEntityDecl(buf, (xmlEntityPtr) cur);
  	    break;
  
          case XML_ELEMENT_NODE:
              addmeta = 0;
  
  	    if ((cur != root) && (ctxt->format == 1))
                  xmlSaveWriteIndent(ctxt, 0);
  
              /*
               * Some users like lxml are known to pass nodes with a corrupted
               * tree structure. Fall back to a recursive call to handle this
               * case.
               */
              if ((cur->parent != parent) && (cur->children != NULL)) {
                  xhtmlNodeDumpOutput(ctxt, cur);
                  break;
              }
  
              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)
                  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 ((parent != NULL) &&
                  (parent->parent == (xmlNodePtr) cur->doc) &&
                  xmlStrEqual(cur->name, BAD_CAST"head") &&
                  xmlStrEqual(parent->name, BAD_CAST"html")) {
  
                  tmp = cur->children;
                  while (tmp != NULL) {
                      if (xmlStrEqual(tmp->name, BAD_CAST"meta")) {
                          int res;
                          xmlChar *httpequiv;
  
                          res = xmlNodeGetAttrValue(tmp, BAD_CAST "http-equiv",
                                                    NULL, &httpequiv);
                          if (res < 0) {
                              xmlSaveErrMemory(buf);
                          } else if (res == 0) {
                              if (xmlStrcasecmp(httpequiv,
                                          BAD_CAST"Content-Type") == 0) {
                                  xmlFree(httpequiv);
                                  break;
                              }
                              xmlFree(httpequiv);
                          }
                      }
                      tmp = tmp->next;
                  }
                  if (tmp == NULL)
                      addmeta = 1;
              }
  
              if (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 == 1) {
                              xmlOutputBufferWrite(buf, 1, "\n");
                              xmlSaveWriteIndent(ctxt, 1);
                          }
                          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 == 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, ">");
                  }
              } else {
                  xmlOutputBufferWrite(buf, 1, ">");
                  if (addmeta == 1) {
                      if (ctxt->format == 1) {
                          xmlOutputBufferWrite(buf, 1, "\n");
                          xmlSaveWriteIndent(ctxt, 1);
                      }
                      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 == 1) {
                      tmp = cur->children;
                      while (tmp != NULL) {
                          if ((tmp->type == XML_TEXT_NODE) ||
                              (tmp->type == XML_ENTITY_REF_NODE)) {
                              unformattedNode = cur;
                              ctxt->format = 0;
                              break;
                          }
                          tmp = tmp->next;
                      }
                  }
  
                  if (ctxt->format == 1) xmlOutputBufferWrite(buf, 1, "\n");
                  if (ctxt->level >= 0) ctxt->level++;
                  parent = cur;
                  cur = cur->children;
                  continue;
              }
  
              break;
  
          case XML_TEXT_NODE:
  	    if (cur->content == NULL)
                  break;
  	    if ((cur->name == xmlStringText) ||
  		(cur->name != xmlStringTextNoenc)) {
                  if (ctxt->escape)
                      xmlOutputBufferWriteEscape(buf, cur->content,
                                                 ctxt->escape);
                  else
                      xmlSaveWriteText(ctxt, cur->content, /* flags */ 0);
  	    } else {
  		/*
  		 * Disable escaping, needed for XSLT
  		 */
  		xmlOutputBufferWriteString(buf, (const char *) cur->content);
  	    }
  	    break;
  
          case XML_PI_NODE:
              if (cur->content != NULL) {
                  xmlOutputBufferWrite(buf, 2, "<?");
                  xmlOutputBufferWriteString(buf, (const char *)cur->name);
                  if (cur->content != NULL) {
                      xmlOutputBufferWrite(buf, 1, " ");
                      xmlOutputBufferWriteString(buf,
                              (const char *)cur->content);
                  }
                  xmlOutputBufferWrite(buf, 2, "?>");
              } else {
                  xmlOutputBufferWrite(buf, 2, "<?");
                  xmlOutputBufferWriteString(buf, (const char *)cur->name);
                  xmlOutputBufferWrite(buf, 2, "?>");
              }
              break;
  
          case XML_COMMENT_NODE:
              if (cur->content != NULL) {
                  xmlOutputBufferWrite(buf, 4, "<!--");
                  xmlOutputBufferWriteString(buf, (const char *)cur->content);
                  xmlOutputBufferWrite(buf, 3, "-->");
              }
              break;
  
          case XML_ENTITY_REF_NODE:
              xmlOutputBufferWrite(buf, 1, "&");
              xmlOutputBufferWriteString(buf, (const char *)cur->name);
              xmlOutputBufferWrite(buf, 1, ";");
              break;
  
          case XML_CDATA_SECTION_NODE:
              if (cur->content == NULL || *cur->content == '\0') {
                  xmlOutputBufferWrite(buf, 12, "<![CDATA[]]>");
              } else {
                  start = end = cur->content;
                  while (*end != '\0') {
                      if (*end == ']' && *(end + 1) == ']' &&
                          *(end + 2) == '>') {
                          end = end + 2;
                          xmlOutputBufferWrite(buf, 9, "<![CDATA[");
                          xmlOutputBufferWrite(buf, end - start,
                                  (const char *)start);
                          xmlOutputBufferWrite(buf, 3, "]]>");
                          start = end;
                      }
                      end++;
                  }
                  if (start != end) {
                      xmlOutputBufferWrite(buf, 9, "<![CDATA[");
                      xmlOutputBufferWriteString(buf, (const char *)start);
                      xmlOutputBufferWrite(buf, 3, "]]>");
                  }
              }
              break;
  
          case XML_ATTRIBUTE_NODE:
              xmlAttrDumpOutput(ctxt, (xmlAttrPtr) cur);
  	    break;
  
          default:
              break;
          }
  
          while (1) {
              if (cur == root)
                  return;
              if (ctxt->format == 1)
                  xmlOutputBufferWrite(buf, 1, "\n");
              if (cur->next != NULL) {
                  cur = cur->next;
                  break;
              }
  
              cur = parent;
              /* cur->parent was validated when descending. */
              parent = cur->parent;
  
              if (cur->type == XML_ELEMENT_NODE) {
                  if (ctxt->level > 0) ctxt->level--;
                  if (ctxt->format == 1)
                      xmlSaveWriteIndent(ctxt, 0);
  
                  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, ">");
  
                  if (cur == unformattedNode) {
                      ctxt->format = format;
                      unformattedNode = NULL;
                  }
              }
          }
      }
  
      ctxt->options = oldoptions;
  }
  #endif
  
  /************************************************************************
   *									*
   *			Public entry points				*
   *									*
   ************************************************************************/
  
  /**
   * Create a document saving context serializing to a file descriptor
   * with the encoding and the options given.
   *
   * If `encoding` is NULL, #xmlSaveDoc uses the document's
   * encoding and #xmlSaveTree uses UTF-8.
   *
   * This function doesn't allow to distinguish unsupported
   * encoding errors from failed memory allocations.
   *
   * @param fd  a file descriptor number
   * @param encoding  the encoding name to use (optional)
   * @param options  a set of xmlSaveOptions
   * @returns a new serialization context or NULL in case of error.
   */
  xmlSaveCtxt *
  xmlSaveToFd(int fd, const char *encoding, int options)
  {
      xmlSaveCtxtPtr ret;
  
      ret = xmlNewSaveCtxt(encoding, options);
      if (ret == NULL) return(NULL);
      ret->buf = xmlOutputBufferCreateFd(fd, ret->handler);
      if (ret->buf == NULL) {
          xmlCharEncCloseFunc(ret->handler);
  	xmlFreeSaveCtxt(ret);
  	return(NULL);
      }
      return(ret);
  }
  
  /**
   * Create a document saving context serializing to a filename
   * with the encoding and the options given.
   *
   * If `encoding` is NULL, #xmlSaveDoc uses the document's
   * encoding and #xmlSaveTree uses UTF-8.
   *
   * This function doesn't allow to distinguish unsupported
   * encoding errors from failed memory allocations.
   *
   * @param filename  a file name or an URL
   * @param encoding  the encoding name to use or NULL
   * @param options  a set of xmlSaveOptions
   * @returns a new serialization context or NULL in case of error.
   */
  xmlSaveCtxt *
  xmlSaveToFilename(const char *filename, const char *encoding, int options)
  {
      xmlSaveCtxtPtr ret;
      int compression = 0; /* TODO handle compression option */
  
      ret = xmlNewSaveCtxt(encoding, options);
      if (ret == NULL) return(NULL);
      ret->buf = xmlOutputBufferCreateFilename(filename, ret->handler,
                                               compression);
      if (ret->buf == NULL) {
          xmlCharEncCloseFunc(ret->handler);
  	xmlFreeSaveCtxt(ret);
  	return(NULL);
      }
      return(ret);
  }
  
  /**
   * Create a document saving context serializing to a buffer
   * with the encoding and the options given.
   *
   * If `encoding` is NULL, #xmlSaveDoc uses the document's
   * encoding and #xmlSaveTree uses UTF-8.
   *
   * This function doesn't allow to distinguish unsupported
   * encoding errors from failed memory allocations.
   *
   * @param buffer  a buffer
   * @param encoding  the encoding name to use or NULL
   * @param options  a set of xmlSaveOptions
   * @returns a new serialization context or NULL in case of error.
   */
  
  xmlSaveCtxt *
  xmlSaveToBuffer(xmlBuffer *buffer, const char *encoding, int options)
  {
      xmlSaveCtxtPtr ret;
  
      ret = xmlNewSaveCtxt(encoding, options);
      if (ret == NULL) return(NULL);
      ret->buf = xmlOutputBufferCreateBuffer(buffer, ret->handler);
      if (ret->buf == NULL) {
          xmlCharEncCloseFunc(ret->handler);
  	xmlFreeSaveCtxt(ret);
  	return(NULL);
      }
      return(ret);
  }
  
  /**
   * Create a document saving context serializing to a file descriptor
   * with the encoding and the options given
   *
   * If `encoding` is NULL, #xmlSaveDoc uses the document's
   * encoding and #xmlSaveTree uses UTF-8.
   *
   * This function doesn't allow to distinguish unsupported
   * encoding errors from failed memory allocations.
   *
   * @param iowrite  an I/O write function
   * @param ioclose  an I/O close function
   * @param ioctx  an I/O handler
   * @param encoding  the encoding name to use or NULL
   * @param options  a set of xmlSaveOptions
   * @returns a new serialization context or NULL in case of error.
   */
  xmlSaveCtxt *
  xmlSaveToIO(xmlOutputWriteCallback iowrite,
              xmlOutputCloseCallback ioclose,
              void *ioctx, const char *encoding, int options)
  {
      xmlSaveCtxtPtr ret;
  
      ret = xmlNewSaveCtxt(encoding, options);
      if (ret == NULL) return(NULL);
      ret->buf = xmlOutputBufferCreateIO(iowrite, ioclose, ioctx, ret->handler);
      if (ret->buf == NULL) {
          xmlCharEncCloseFunc(ret->handler);
  	xmlFreeSaveCtxt(ret);
  	return(NULL);
      }
      return(ret);
  }
  
  /**
   * Serialize a document.
   *
   * If the save context has no encoding, uses the document's
   * encoding. If the document has no encoding, uses ASCII
   * without an encoding declaration.
   *
   * @param ctxt  a document saving context
   * @param doc  a document
   * @returns 0 on success or -1 in case of error.
   */
  long
  xmlSaveDoc(xmlSaveCtxt *ctxt, xmlDoc *doc)
  {
      long ret = 0;
  
      if ((ctxt == NULL) || (doc == NULL)) return(-1);
      if (xmlSaveDocInternal(ctxt, doc, ctxt->encoding) < 0)
          return(-1);
      return(ret);
  }
  
  /**
   * Serialize a subtree starting.
   *
   * If the save context has no encoding, uses UTF-8.
   *
   * @param ctxt  a document saving context
   * @param cur  the root of the subtree to save
   * @returns 0 on success or -1 in case of error.
   */
  long
  xmlSaveTree(xmlSaveCtxt *ctxt, xmlNode *cur)
  {
      long ret = 0;
  
      if ((ctxt == NULL) || (cur == NULL)) return(-1);
  #ifdef LIBXML_HTML_ENABLED
      if (ctxt->options & XML_SAVE_XHTML) {
          xhtmlNodeDumpOutput(ctxt, cur);
          return(ret);
      }
      if (((cur->type != XML_NAMESPACE_DECL) && (cur->doc != NULL) &&
           (cur->doc->type == XML_HTML_DOCUMENT_NODE) &&
           ((ctxt->options & XML_SAVE_AS_XML) == 0)) ||
          (ctxt->options & XML_SAVE_AS_HTML)) {
  	htmlNodeDumpOutputInternal(ctxt, cur);
  	return(ret);
      }
  #endif
      xmlNodeDumpOutputInternal(ctxt, cur);
      return(ret);
  }
  
  /**
   * Serialize a notation declaration.
   *
   * @param ctxt  save context
   * @param cur  notation
   * @returns 0 on succes, -1 on error.
   */
  int
  xmlSaveNotationDecl(xmlSaveCtxt *ctxt, xmlNotation *cur) {
      if (ctxt == NULL)
          return(-1);
      xmlBufDumpNotationDecl(ctxt->buf, cur);
      return(0);
  }
  
  /**
   * Serialize notation declarations of a document.
   *
   * @param ctxt  save context
   * @param cur  notation table
   * @returns 0 on succes, -1 on error.
   */
  int
  xmlSaveNotationTable(xmlSaveCtxt *ctxt, xmlNotationTable *cur) {
      if (ctxt == NULL)
          return(-1);
      xmlBufDumpNotationTable(ctxt->buf, cur);
      return(0);
  }
  
  /**
   * Flush a document saving context, i.e. make sure that all
   * buffered input has been processed.
   *
   * @param ctxt  a document saving context
   * @returns the number of bytes written or -1 in case of error.
   */
  int
  xmlSaveFlush(xmlSaveCtxt *ctxt)
  {
      if (ctxt == NULL) return(-1);
      if (ctxt->buf == NULL) return(-1);
      return(xmlOutputBufferFlush(ctxt->buf));
  }
  
  /**
   * Close a document saving context, i.e. make sure that all
   * buffered input has been processed and free the context struct.
   *
   * @param ctxt  a document saving context
   * @returns the number of bytes written or -1 in case of error.
   */
  int
  xmlSaveClose(xmlSaveCtxt *ctxt)
  {
      int ret;
  
      if (ctxt == NULL) return(-1);
      ret = xmlSaveFlush(ctxt);
      xmlFreeSaveCtxt(ctxt);
      return(ret);
  }
  
  /**
   * Close a document saving context, i.e. make sure that all
   * buffered input has been processed and free the context struct.
   *
   * @since 2.13.0
   *
   * @param ctxt  a document saving context
   * @returns an xmlParserErrors code.
   */
  xmlParserErrors
  xmlSaveFinish(xmlSaveCtxt *ctxt)
  {
      int ret;
  
      if (ctxt == NULL)
          return(XML_ERR_INTERNAL_ERROR);
  
      ret = xmlOutputBufferClose(ctxt->buf);
      ctxt->buf = NULL;
      if (ret < 0)
          ret = -ret;
      else
          ret = XML_ERR_OK;
  
      xmlFreeSaveCtxt(ctxt);
      return(ret);
  }
  
  /**
   * Set a custom escaping function to be used for text in element
   * content.
   *
   * @deprecated Don't use.
   *
   * @param ctxt  a document saving context
   * @param escape  the escaping function
   * @returns 0 if successful or -1 in case of error.
   */
  int
  xmlSaveSetEscape(xmlSaveCtxt *ctxt, xmlCharEncodingOutputFunc escape)
  {
      if (ctxt == NULL) return(-1);
      ctxt->escape = escape;
      return(0);
  }
  
  /**
   * Has no effect.
   *
   * @deprecated Don't use.
   *
   * @param ctxt  a document saving context
   * @param escape  the escaping function
   * @returns 0 if successful or -1 in case of error.
   */
  int
  xmlSaveSetAttrEscape(xmlSaveCtxt *ctxt,
                       xmlCharEncodingOutputFunc escape ATTRIBUTE_UNUSED)
  {
      if (ctxt == NULL) return(-1);
      return(0);
  }
  
  /************************************************************************
   *									*
   *		Public entry points based on buffers			*
   *									*
   ************************************************************************/
  
  /**
   * Serialize attribute text to an output buffer.
   *
   * @param buf  output buffer
   * @param doc  the document
   * @param string  the text content
   */
  void
  xmlBufAttrSerializeTxtContent(xmlOutputBuffer *buf, xmlDoc *doc,
                                const xmlChar *string)
  {
      int flags = XML_ESCAPE_ATTR;
  
      if ((doc == NULL) || (doc->encoding == NULL))
          flags |= XML_ESCAPE_NON_ASCII;
      xmlSerializeText(buf, string, SIZE_MAX, flags);
  }
  
  /**
   * Serialize attribute text to an xmlBuffer.
   *
   * @param buf  the XML buffer output
   * @param doc  the document
   * @param attr  the attribute node
   * @param string  the text content
   */
  void
  xmlAttrSerializeTxtContent(xmlBuffer *buf, xmlDoc *doc,
                             xmlAttr *attr ATTRIBUTE_UNUSED,
                             const xmlChar *string)
  {
      xmlOutputBufferPtr out;
  
      if ((buf == NULL) || (string == NULL))
          return;
      out = xmlOutputBufferCreateBuffer(buf, NULL);
      xmlBufAttrSerializeTxtContent(out, doc, string);
      xmlOutputBufferFlush(out);
      if ((out == NULL) || (out->error))
          xmlFree(xmlBufferDetach(buf));
      xmlOutputBufferClose(out);
  }
  
  /**
   * Serialize an XML node to an xmlBuffer.
   *
   * Uses the document's encoding. If the document has no encoding,
   * uses ASCII without an encoding declaration.
   *
   * Note that `format` only works if the document was parsed with
   * XML_PARSE_NOBLANKS.
   *
   * Since this is using xmlBuffer structures it is limited to 2GB and
   * somewhat deprecated, use #xmlNodeDumpOutput instead.
   *
   * @param buf  the XML buffer output
   * @param doc  the document
   * @param cur  the current node
   * @param level  the initial indenting level
   * @param format  is formatting allowed
   * @returns the number of bytes written to the buffer or -1 in case of error
   */
  int
  xmlNodeDump(xmlBuffer *buf, xmlDoc *doc, xmlNode *cur, int level,
              int format)
  {
      xmlBufPtr buffer;
      size_t ret1;
      int ret2;
  
      if ((buf == NULL) || (cur == NULL))
          return(-1);
      if (level < 0)
          level = 0;
      else if (level > 100)
          level = 100;
      buffer = xmlBufFromBuffer(buf);
      if (buffer == NULL)
          return(-1);
      ret1 = xmlBufNodeDump(buffer, doc, cur, level, format);
      ret2 = xmlBufBackToBuffer(buffer, buf);
      if ((ret1 == (size_t) -1) || (ret2 < 0))
          return(-1);
      return(ret1 > INT_MAX ? INT_MAX : ret1);
  }
  
  /**
   * Serialize an XML node to an xmlBuf.
   *
   * Uses the document's encoding. If the document has no encoding,
   * uses ASCII without an encoding declaration.
   *
   * Note that `format` only works if the document was parsed with
   * XML_PARSE_NOBLANKS.
   *
   * @param buf  the XML buffer output
   * @param doc  the document
   * @param cur  the current node
   * @param level  the imbrication level for indenting
   * @param format  is formatting allowed
   * @returns the number of bytes written to the buffer, in case of error 0
   *     is returned or `buf` stores the error
   */
  
  size_t
  xmlBufNodeDump(xmlBuf *buf, xmlDoc *doc, xmlNode *cur, int level,
              int format)
  {
      size_t use;
      size_t ret;
      xmlOutputBufferPtr outbuf;
  
      xmlInitParser();
  
      if (cur == NULL) {
          return ((size_t) -1);
      }
      if (buf == NULL) {
          return ((size_t) -1);
      }
      outbuf = (xmlOutputBufferPtr) xmlMalloc(sizeof(xmlOutputBuffer));
      if (outbuf == NULL) {
          xmlSaveErrMemory(NULL);
          return ((size_t) -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 = xmlBufUse(buf);
      xmlNodeDumpOutput(outbuf, doc, cur, level, format, NULL);
      if (outbuf->error)
          ret = (size_t) -1;
      else
          ret = xmlBufUse(buf) - use;
      xmlFree(outbuf);
      return (ret);
  }
  
  /**
   * Serialize an XML node to a `FILE`.
   *
   * Uses the document's encoding. If the document has no encoding,
   * uses ASCII without an encoding declaration.
   *
   * @param f  the FILE * for the output
   * @param doc  the document
   * @param cur  the current node
   */
  void
  xmlElemDump(FILE * f, xmlDoc *doc, xmlNode *cur)
  {
      xmlOutputBufferPtr outbuf;
  
      xmlInitParser();
  
      if (cur == NULL) {
          return;
      }
  
      outbuf = xmlOutputBufferCreateFile(f, NULL);
      if (outbuf == NULL)
          return;
  #ifdef LIBXML_HTML_ENABLED
      if ((doc != NULL) && (doc->type == XML_HTML_DOCUMENT_NODE))
          htmlNodeDumpOutput(outbuf, doc, cur, NULL);
      else
  #endif /* LIBXML_HTML_ENABLED */
          xmlNodeDumpOutput(outbuf, doc, cur, 0, 1, NULL);
      xmlOutputBufferClose(outbuf);
  }
  
  /************************************************************************
   *									*
   *		Saving functions front-ends				*
   *									*
   ************************************************************************/
  
  /**
   * Serialize an XML node to an output buffer.
   *
   * If `encoding` is NULL, uses the document's encoding. If the
   * document has no encoding, serializes as ASCII without an
   * encoding declaration.
   *
   * Note that `format` only works if the document was parsed with
   * XML_PARSE_NOBLANKS.
   *
   * @param buf  the XML buffer output
   * @param doc  the document
   * @param cur  the current node
   * @param level  the imbrication level for indenting
   * @param format  is formatting allowed
   * @param encoding  an optional encoding string
   */
  void
  xmlNodeDumpOutput(xmlOutputBuffer *buf, xmlDoc *doc, xmlNode *cur,
                    int level, int format, const char *encoding)
  {
      xmlSaveCtxt ctxt;
      int options;
  #ifdef LIBXML_HTML_ENABLED
      xmlDtdPtr dtd;
      int is_xhtml = 0;
  #endif
  
      (void) doc;
  
      xmlInitParser();
  
      if ((buf == NULL) || (cur == NULL)) return;
  
      if (level < 0)
          level = 0;
      else if (level > 100)
          level = 100;
  
      if (encoding == NULL)
          encoding = "UTF-8";
  
      memset(&ctxt, 0, sizeof(ctxt));
      ctxt.buf = buf;
      ctxt.level = level;
      ctxt.encoding = (const xmlChar *) encoding;
  
      options = XML_SAVE_AS_XML;
      if (format)
          options |= XML_SAVE_FORMAT;
      xmlSaveCtxtInit(&ctxt, options);
  
  #ifdef LIBXML_HTML_ENABLED
      dtd = xmlGetIntSubset(doc);
      if (dtd != NULL) {
  	is_xhtml = xmlIsXHTML(dtd->SystemID, dtd->ExternalID);
  	if (is_xhtml < 0)
  	    is_xhtml = 0;
      }
  
      if (is_xhtml)
          xhtmlNodeDumpOutput(&ctxt, cur);
      else
  #endif
          xmlNodeDumpOutputInternal(&ctxt, cur);
  }
  
  static void
  xmlDocDumpInternal(xmlOutputBufferPtr buf, xmlDocPtr doc, const char *encoding,
                     int format) {
      xmlSaveCtxt ctxt;
      int options;
  
      memset(&ctxt, 0, sizeof(ctxt));
      ctxt.buf = buf;
  
      if (buf->encoder != NULL) {
          /*
           * Keep original encoding
           */
          encoding = buf->encoder->name;
          ctxt.encoding = BAD_CAST encoding;
      }
  
      options = XML_SAVE_AS_XML;
      if (format)
          options |= XML_SAVE_FORMAT;
      xmlSaveCtxtInit(&ctxt, options);
  
      xmlSaveDocInternal(&ctxt, doc, (const xmlChar *) encoding);
  }
  
  /**
   * Serialize an XML document to memory.
   *
   * If `encoding` is NULL, uses the document's encoding. If the
   * document has no encoding, serializes as ASCII without an
   * encoding declaration.
   *
   * It is up to the caller of this function to free the returned
   * memory with #xmlFree.
   *
   * Note that `format` only works if the document was parsed with
   * XML_PARSE_NOBLANKS.
   *
   * @param out_doc  Document to generate XML text from
   * @param doc_txt_ptr  Memory pointer for allocated XML text
   * @param doc_txt_len  Length of the generated XML text
   * @param txt_encoding  Character encoding to use when generating XML text
   * @param format  should formatting spaces been added
   */
  
  void
  xmlDocDumpFormatMemoryEnc(xmlDoc *out_doc, xmlChar **doc_txt_ptr,
  		int * doc_txt_len, const char * txt_encoding,
  		int format) {
      xmlOutputBufferPtr buf = NULL;
  
      if (doc_txt_len != NULL)
          *doc_txt_len = 0;
  
      if (doc_txt_ptr == NULL)
          return;
      *doc_txt_ptr = NULL;
  
      if (out_doc == NULL)
          return;
  
      buf = xmlAllocOutputBuffer(NULL);
      if (buf == NULL) {
          xmlSaveErrMemory(NULL);
          return;
      }
  
      xmlDocDumpInternal(buf, out_doc, txt_encoding, format);
  
      xmlOutputBufferFlush(buf);
  
      if (!buf->error) {
          if (doc_txt_len != NULL)
              *doc_txt_len = xmlBufUse(buf->buffer);
          *doc_txt_ptr = xmlBufDetach(buf->buffer);
      }
  
      xmlOutputBufferClose(buf);
  }
  
  /**
   * Same as #xmlDocDumpFormatMemoryEnc with `encoding` set to
   * NULL and `format` set to 0.
   *
   * @param cur  the document
   * @param mem  OUT: the memory pointer
   * @param size  OUT: the memory length
   */
  void
  xmlDocDumpMemory(xmlDoc *cur, xmlChar**mem, int *size) {
      xmlDocDumpFormatMemoryEnc(cur, mem, size, NULL, 0);
  }
  
  /**
   * Same as #xmlDocDumpFormatMemoryEnc with `encoding` set to
   * NULL.
   *
   * @param cur  the document
   * @param mem  OUT: the memory pointer
   * @param size  OUT: the memory length
   * @param format  should formatting spaces been added
   */
  void
  xmlDocDumpFormatMemory(xmlDoc *cur, xmlChar**mem, int *size, int format) {
      xmlDocDumpFormatMemoryEnc(cur, mem, size, NULL, format);
  }
  
  /**
   * Same as #xmlDocDumpFormatMemoryEnc with `format` set to 0.
   *
   * @param out_doc  Document to generate XML text from
   * @param doc_txt_ptr  Memory pointer for allocated XML text
   * @param doc_txt_len  Length of the generated XML text
   * @param txt_encoding  Character encoding to use when generating XML text
   */
  
  void
  xmlDocDumpMemoryEnc(xmlDoc *out_doc, xmlChar **doc_txt_ptr,
  	            int * doc_txt_len, const char * txt_encoding) {
      xmlDocDumpFormatMemoryEnc(out_doc, doc_txt_ptr, doc_txt_len,
  	                      txt_encoding, 0);
  }
  
  /**
   * Serialize an XML document to a `FILE`.
   *
   * Uses the document's encoding. If the document has no encoding,
   * uses ASCII without an encoding declaration.
   *
   * Note that `format` only works if the document was parsed with
   * XML_PARSE_NOBLANKS.
   *
   * @param f  the FILE*
   * @param cur  the document
   * @param format  should formatting spaces been added
   * @returns the number of bytes written or -1 in case of failure.
   */
  int
  xmlDocFormatDump(FILE *f, xmlDoc *cur, int format) {
      xmlOutputBufferPtr buf;
  
      if (cur == NULL) {
  	return(-1);
      }
  
      buf = xmlOutputBufferCreateFile(f, NULL);
      if (buf == NULL) return(-1);
  
      xmlDocDumpInternal(buf, cur, NULL, format);
  
      return(xmlOutputBufferClose(buf));
  }
  
  /**
   * Serialize an XML document to a `FILE`.
   *
   * Uses the document's encoding. If the document has no encoding,
   * uses ASCII without an encoding declaration.
   *
   * @param f  the FILE*
   * @param cur  the document
   * @returns the number of bytes written or -1 in case of failure.
   */
  int
  xmlDocDump(FILE *f, xmlDoc *cur) {
      return(xmlDocFormatDump (f, cur, 0));
  }
  
  /**
   * Same as #xmlSaveFormatFileTo with `format` set to 0.
   *
   * WARNING: This calls #xmlOutputBufferClose and frees `buf`.
   *
   * @param buf  an output I/O buffer
   * @param cur  the document
   * @param encoding  the encoding if any assuming the I/O layer handles the transcoding
   * @returns the number of bytes written or -1 in case of failure.
   */
  int
  xmlSaveFileTo(xmlOutputBuffer *buf, xmlDoc *cur, const char *encoding) {
      return(xmlSaveFormatFileTo(buf, cur, encoding, 0));
  }
  
  /**
   * Serialize an XML document to an output buffer.
   *
   * If the output buffer already uses a (non-default) encoding,
   * `encoding` is ignored. If the output buffer has no encoding
   * and `encoding` is NULL, uses the document's encoding or
   * ASCII without an encoding declaration.
   *
   * Note that `format` only works if the document was parsed with
   * XML_PARSE_NOBLANKS.
   *
   * WARNING: This calls #xmlOutputBufferClose and frees `buf`.
   *
   * @param buf  an output I/O buffer
   * @param cur  the document
   * @param encoding  the encoding if any assuming the I/O layer handles the transcoding
   * @param format  should formatting spaces been added
   * @returns the number of bytes written or -1 in case of failure.
   */
  int
  xmlSaveFormatFileTo(xmlOutputBuffer *buf, xmlDoc *cur,
                      const char *encoding, int format)
  {
      if (buf == NULL) return(-1);
      if ((cur == NULL) ||
          ((cur->type != XML_DOCUMENT_NODE) &&
  	 (cur->type != XML_HTML_DOCUMENT_NODE))) {
          xmlOutputBufferClose(buf);
  	return(-1);
      }
  
      xmlDocDumpInternal(buf, cur, encoding, format);
  
      return(xmlOutputBufferClose(buf));
  }
  
  /**
   * Serialize an XML document to a file using the given encoding.
   * If `filename` is `"-"`, stdout is used. This is potentially
   * insecure and might be changed in a future version.
   *
   * If `encoding` is NULL, uses the document's encoding. If the
   * document has no encoding, serializes as ASCII without an
   * encoding declaration.
   *
   * Note that `format` only works if the document was parsed with
   * XML_PARSE_NOBLANKS.
   *
   * @param filename  the filename or URL to output
   * @param cur  the document being saved
   * @param encoding  the name of the encoding to use or NULL.
   * @param format  should formatting spaces be added.
   * @returns the number of bytes written or -1 in case of error.
   */
  int
  xmlSaveFormatFileEnc( const char * filename, xmlDoc *cur,
  			const char * encoding, int format ) {
      xmlOutputBufferPtr buf;
  
      if (cur == NULL)
  	return(-1);
  
  #ifdef LIBXML_ZLIB_ENABLED
      if (cur->compression < 0) cur->compression = xmlGetCompressMode();
  #endif
      /*
       * save the content to a temp buffer.
       */
      buf = xmlOutputBufferCreateFilename(filename, NULL, cur->compression);
      if (buf == NULL) return(-1);
  
      xmlDocDumpInternal(buf, cur, encoding, format);
  
      return(xmlOutputBufferClose(buf));
  }
  
  
  /**
   * Same as #xmlSaveFormatFileEnc with `format` set to 0.
   *
   * @param filename  the filename (or URL)
   * @param cur  the document
   * @param encoding  the name of an encoding (or NULL)
   * @returns the number of bytes written or -1 in case of failure.
   */
  int
  xmlSaveFileEnc(const char *filename, xmlDoc *cur, const char *encoding) {
      return ( xmlSaveFormatFileEnc( filename, cur, encoding, 0 ) );
  }
  
  /**
   * Same as #xmlSaveFormatFileEnc with `encoding` set to NULL.
   *
   * @param filename  the filename (or URL)
   * @param cur  the document
   * @param format  should formatting spaces been added
   * @returns the number of bytes written or -1 in case of failure.
   */
  int
  xmlSaveFormatFile(const char *filename, xmlDoc *cur, int format) {
      return ( xmlSaveFormatFileEnc( filename, cur, NULL, format ) );
  }
  
  /**
   * Same as #xmlSaveFormatFileEnc with `encoding` set to NULL
   * and `format` set to 0.
   *
   * @param filename  the filename (or URL)
   * @param cur  the document
   * @returns the number of bytes written or -1 in case of failure.
   */
  int
  xmlSaveFile(const char *filename, xmlDoc *cur) {
      return(xmlSaveFormatFileEnc(filename, cur, NULL, 0));
  }
  
  #endif /* LIBXML_OUTPUT_ENABLED */
  
  

Download