[BACK]Return to xmlsave.c CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2

Diff for /embedaddon/libxml2/xmlsave.c between versions 1.1.1.2 and 1.1.1.3

version 1.1.1.2, 2013/07/22 01:22:18 version 1.1.1.3, 2014/06/15 19:53:29
Line 19 Line 19
   
 #include <libxml/HTMLtree.h>  #include <libxml/HTMLtree.h>
   
   #include "buf.h"
   #include "enc.h"
   #include "save.h"
   
 /************************************************************************  /************************************************************************
  *                                                                      *   *                                                                      *
  *                      XHTML detection                                 *   *                      XHTML detection                                 *
Line 66  xmlIsXHTML(const xmlChar *systemID, const xmlChar *pub Line 70  xmlIsXHTML(const xmlChar *systemID, const xmlChar *pub
   
 #ifdef LIBXML_OUTPUT_ENABLED  #ifdef LIBXML_OUTPUT_ENABLED
   
#define TODO                                                            \#define TODO                                                            \
     xmlGenericError(xmlGenericErrorContext,                             \      xmlGenericError(xmlGenericErrorContext,                             \
             "Unimplemented block at %s:%d\n",                           \              "Unimplemented block at %s:%d\n",                           \
             __FILE__, __LINE__);              __FILE__, __LINE__);
Line 92  struct _xmlSaveCtxt { Line 96  struct _xmlSaveCtxt {
   
 /************************************************************************  /************************************************************************
  *                                                                      *   *                                                                      *
 *                      Output error handlers                           * *                        Output error handlers                           *
  *                                                                      *   *                                                                      *
  ************************************************************************/   ************************************************************************/
 /**  /**
Line 210  xmlEscapeEntities(unsigned char* out, int *outlen, Line 214  xmlEscapeEntities(unsigned char* out, int *outlen,
     int val;      int val;
   
     inend = in + (*inlen);      inend = in + (*inlen);
    
     while ((in < inend) && (out < outend)) {      while ((in < inend) && (out < outend)) {
        if (*in == '<') {        if (*in == '<') {
             if (outend - out < 4) break;              if (outend - out < 4) break;
             *out++ = '&';              *out++ = '&';
             *out++ = 'l';              *out++ = 'l';
Line 416  xmlNewSaveCtxt(const char *encoding, int options) Line 420  xmlNewSaveCtxt(const char *encoding, int options)
   
 /************************************************************************  /************************************************************************
  *                                                                      *   *                                                                      *
 *              Dumping XML tree content to a simple buffer             * *                Dumping XML tree content to a simple buffer             *
  *                                                                      *   *                                                                      *
  ************************************************************************/   ************************************************************************/
 /**  /**
Line 436  xmlAttrSerializeContent(xmlOutputBufferPtr buf, xmlAtt Line 440  xmlAttrSerializeContent(xmlOutputBufferPtr buf, xmlAtt
     while (children != NULL) {      while (children != NULL) {
         switch (children->type) {          switch (children->type) {
             case XML_TEXT_NODE:              case XML_TEXT_NODE:
                xmlAttrSerializeTxtContent(buf->buffer, attr->doc,                xmlBufAttrSerializeTxtContent(buf->buffer, attr->doc,
                                           attr, children->content);                                              attr, children->content);
                 break;                  break;
             case XML_ENTITY_REF_NODE:              case XML_ENTITY_REF_NODE:
                xmlBufferAdd(buf->buffer, BAD_CAST "&", 1);                xmlBufAdd(buf->buffer, BAD_CAST "&", 1);
                xmlBufferAdd(buf->buffer, children->name,                xmlBufAdd(buf->buffer, children->name,
                              xmlStrlen(children->name));                               xmlStrlen(children->name));
                xmlBufferAdd(buf->buffer, BAD_CAST ";", 1);                xmlBufAdd(buf->buffer, BAD_CAST ";", 1);
                 break;                  break;
             default:              default:
                 /* should not happen unless we have a badly built tree */                  /* should not happen unless we have a badly built tree */
Line 453  xmlAttrSerializeContent(xmlOutputBufferPtr buf, xmlAtt Line 457  xmlAttrSerializeContent(xmlOutputBufferPtr buf, xmlAtt
     }      }
 }  }
   
   /**
    * 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        *
  *                                                                      *   *                                                                      *
  ************************************************************************/   ************************************************************************/
   
Line 469  static int xmlSaveSwitchEncoding(xmlSaveCtxtPtr ctxt,  Line 563  static int xmlSaveSwitchEncoding(xmlSaveCtxtPtr ctxt, 
                        (const char *)encoding);                         (const char *)encoding);
             return(-1);              return(-1);
         }          }
        buf->conv = xmlBufferCreate();        buf->conv = xmlBufCreate();
         if (buf->conv == NULL) {          if (buf->conv == NULL) {
             xmlCharEncCloseFunc(buf->encoder);              xmlCharEncCloseFunc(buf->encoder);
             xmlSaveErrMemory("creating encoding buffer");              xmlSaveErrMemory("creating encoding buffer");
Line 478  static int xmlSaveSwitchEncoding(xmlSaveCtxtPtr ctxt,  Line 572  static int xmlSaveSwitchEncoding(xmlSaveCtxtPtr ctxt, 
         /*          /*
          * initialize the state, e.g. if outputting a BOM           * initialize the state, e.g. if outputting a BOM
          */           */
        xmlCharEncOutFunc(buf->encoder, buf->conv, NULL);        xmlCharEncOutput(buf, 1);
     }      }
     return(0);      return(0);
 }  }
Line 487  static int xmlSaveClearEncoding(xmlSaveCtxtPtr ctxt) { Line 581  static int xmlSaveClearEncoding(xmlSaveCtxtPtr ctxt) {
     xmlOutputBufferPtr buf = ctxt->buf;      xmlOutputBufferPtr buf = ctxt->buf;
     xmlOutputBufferFlush(buf);      xmlOutputBufferFlush(buf);
     xmlCharEncCloseFunc(buf->encoder);      xmlCharEncCloseFunc(buf->encoder);
    xmlBufferFree(buf->conv);    xmlBufFree(buf->conv);
     buf->encoder = NULL;      buf->encoder = NULL;
     buf->conv = NULL;      buf->conv = NULL;
     return(0);      return(0);
Line 553  xmlNsDumpOutput(xmlOutputBufferPtr buf, xmlNsPtr cur,  Line 647  xmlNsDumpOutput(xmlOutputBufferPtr buf, xmlNsPtr cur, 
         } else          } else
             xmlOutputBufferWrite(buf, 5, "xmlns");              xmlOutputBufferWrite(buf, 5, "xmlns");
         xmlOutputBufferWrite(buf, 1, "=");          xmlOutputBufferWrite(buf, 1, "=");
        xmlBufferWriteQuotedString(buf->buffer, cur->href);        xmlBufWriteQuotedString(buf->buffer, cur->href);
     }      }
 }  }
   
Line 606  xmlNsListDumpOutput(xmlOutputBufferPtr buf, xmlNsPtr c Line 700  xmlNsListDumpOutput(xmlOutputBufferPtr buf, xmlNsPtr c
  * xmlDtdDumpOutput:   * xmlDtdDumpOutput:
  * @buf:  the XML buffer output   * @buf:  the XML buffer output
  * @dtd:  the pointer to the DTD   * @dtd:  the pointer to the DTD
 *  *
  * Dump the XML document DTD, if any.   * Dump the XML document DTD, if any.
  */   */
 static void  static void
Line 623  xmlDtdDumpOutput(xmlSaveCtxtPtr ctxt, xmlDtdPtr dtd) { Line 717  xmlDtdDumpOutput(xmlSaveCtxtPtr ctxt, xmlDtdPtr dtd) {
     xmlOutputBufferWriteString(buf, (const char *)dtd->name);      xmlOutputBufferWriteString(buf, (const char *)dtd->name);
     if (dtd->ExternalID != NULL) {      if (dtd->ExternalID != NULL) {
         xmlOutputBufferWrite(buf, 8, " PUBLIC ");          xmlOutputBufferWrite(buf, 8, " PUBLIC ");
        xmlBufferWriteQuotedString(buf->buffer, dtd->ExternalID);        xmlBufWriteQuotedString(buf->buffer, dtd->ExternalID);
         xmlOutputBufferWrite(buf, 1, " ");          xmlOutputBufferWrite(buf, 1, " ");
        xmlBufferWriteQuotedString(buf->buffer, dtd->SystemID);        xmlBufWriteQuotedString(buf->buffer, dtd->SystemID);
     }  else if (dtd->SystemID != NULL) {      }  else if (dtd->SystemID != NULL) {
         xmlOutputBufferWrite(buf, 8, " SYSTEM ");          xmlOutputBufferWrite(buf, 8, " SYSTEM ");
        xmlBufferWriteQuotedString(buf->buffer, dtd->SystemID);        xmlBufWriteQuotedString(buf->buffer, dtd->SystemID);
     }      }
     if ((dtd->entities == NULL) && (dtd->elements == NULL) &&      if ((dtd->entities == NULL) && (dtd->elements == NULL) &&
         (dtd->attributes == NULL) && (dtd->notations == NULL) &&          (dtd->attributes == NULL) && (dtd->notations == NULL) &&
Line 643  xmlDtdDumpOutput(xmlSaveCtxtPtr ctxt, xmlDtdPtr dtd) { Line 737  xmlDtdDumpOutput(xmlSaveCtxtPtr ctxt, xmlDtdPtr dtd) {
      */       */
     if ((dtd->notations != NULL) && ((dtd->doc == NULL) ||      if ((dtd->notations != NULL) && ((dtd->doc == NULL) ||
         (dtd->doc->intSubset == dtd))) {          (dtd->doc->intSubset == dtd))) {
        xmlDumpNotationTable(buf->buffer, (xmlNotationTablePtr) dtd->notations);        xmlBufDumpNotationTable(buf->buffer,
                                 (xmlNotationTablePtr) dtd->notations);
     }      }
     format = ctxt->format;      format = ctxt->format;
     level = ctxt->level;      level = ctxt->level;
Line 724  xmlNodeListDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr  Line 819  xmlNodeListDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr 
              (cur->type == XML_COMMENT_NODE) ||               (cur->type == XML_COMMENT_NODE) ||
              (cur->type == XML_PI_NODE)))               (cur->type == XML_PI_NODE)))
             xmlOutputBufferWrite(buf, ctxt->indent_size *              xmlOutputBufferWrite(buf, ctxt->indent_size *
                                 (ctxt->level > ctxt->indent_nr ?                                  (ctxt->level > ctxt->indent_nr ?
                                   ctxt->indent_nr : ctxt->level),                                    ctxt->indent_nr : ctxt->level),
                                  ctxt->indent);                                   ctxt->indent);
         xmlNodeDumpOutputInternal(ctxt, cur);          xmlNodeDumpOutputInternal(ctxt, cur);
Line 841  xmlNodeDumpOutputInternal(xmlSaveCtxtPtr ctxt, xmlNode Line 936  xmlNodeDumpOutputInternal(xmlSaveCtxtPtr ctxt, xmlNode
         return;          return;
     }      }
     if (cur->type == XML_ELEMENT_DECL) {      if (cur->type == XML_ELEMENT_DECL) {
        xmlDumpElementDecl(buf->buffer, (xmlElementPtr) cur);        xmlBufDumpElementDecl(buf->buffer, (xmlElementPtr) cur);
         return;          return;
     }      }
     if (cur->type == XML_ATTRIBUTE_DECL) {      if (cur->type == XML_ATTRIBUTE_DECL) {
        xmlDumpAttributeDecl(buf->buffer, (xmlAttributePtr) cur);        xmlBufDumpAttributeDecl(buf->buffer, (xmlAttributePtr) cur);
         return;          return;
     }      }
     if (cur->type == XML_ENTITY_DECL) {      if (cur->type == XML_ENTITY_DECL) {
        xmlDumpEntityDecl(buf->buffer, (xmlEntityPtr) cur);        xmlBufDumpEntityDecl(buf->buffer, (xmlEntityPtr) cur);
         return;          return;
     }      }
     if (cur->type == XML_TEXT_NODE) {      if (cur->type == XML_TEXT_NODE) {
Line 980  xmlNodeDumpOutputInternal(xmlSaveCtxtPtr ctxt, xmlNode Line 1075  xmlNodeDumpOutputInternal(xmlSaveCtxtPtr ctxt, xmlNode
         if (ctxt->level > 0) ctxt->level--;          if (ctxt->level > 0) ctxt->level--;
         if ((xmlIndentTreeOutput) && (ctxt->format == 1))          if ((xmlIndentTreeOutput) && (ctxt->format == 1))
             xmlOutputBufferWrite(buf, ctxt->indent_size *              xmlOutputBufferWrite(buf, ctxt->indent_size *
                                 (ctxt->level > ctxt->indent_nr ?                                  (ctxt->level > ctxt->indent_nr ?
                                   ctxt->indent_nr : ctxt->level),                                    ctxt->indent_nr : ctxt->level),
                                  ctxt->indent);                                   ctxt->indent);
     }      }
Line 1096  xmlDocContentDumpOutput(xmlSaveCtxtPtr ctxt, xmlDocPtr Line 1191  xmlDocContentDumpOutput(xmlSaveCtxtPtr ctxt, xmlDocPtr
          */           */
         if ((ctxt->options & XML_SAVE_NO_DECL) == 0) {          if ((ctxt->options & XML_SAVE_NO_DECL) == 0) {
             xmlOutputBufferWrite(buf, 14, "<?xml version=");              xmlOutputBufferWrite(buf, 14, "<?xml version=");
            if (cur->version != NULL)             if (cur->version != NULL)
                xmlBufferWriteQuotedString(buf->buffer, cur->version);                xmlBufWriteQuotedString(buf->buffer, cur->version);
             else              else
                 xmlOutputBufferWrite(buf, 5, "\"1.0\"");                  xmlOutputBufferWrite(buf, 5, "\"1.0\"");
             if (encoding != NULL) {              if (encoding != NULL) {
                 xmlOutputBufferWrite(buf, 10, " encoding=");                  xmlOutputBufferWrite(buf, 10, " encoding=");
                xmlBufferWriteQuotedString(buf->buffer, (xmlChar *) encoding);                xmlBufWriteQuotedString(buf->buffer, (xmlChar *) encoding);
             }              }
             switch (cur->standalone) {              switch (cur->standalone) {
                 case 0:                  case 0:
Line 1260  xhtmlAttrListDumpOutput(xmlSaveCtxtPtr ctxt, xmlAttrPt Line 1355  xhtmlAttrListDumpOutput(xmlSaveCtxtPtr ctxt, xmlAttrPt
         if ((cur->ns != NULL) && (xmlStrEqual(cur->name, BAD_CAST "lang")) &&          if ((cur->ns != NULL) && (xmlStrEqual(cur->name, BAD_CAST "lang")) &&
             (xmlStrEqual(cur->ns->prefix, BAD_CAST "xml")))              (xmlStrEqual(cur->ns->prefix, BAD_CAST "xml")))
             xml_lang = cur;              xml_lang = cur;
        else if ((cur->ns == NULL) &&         else if ((cur->ns == NULL) &&
                  ((cur->children == NULL) ||                   ((cur->children == NULL) ||
                   (cur->children->content == NULL) ||                    (cur->children->content == NULL) ||
                   (cur->children->content[0] == 0)) &&                    (cur->children->content[0] == 0)) &&
Line 1300  xhtmlAttrListDumpOutput(xmlSaveCtxtPtr ctxt, xmlAttrPt Line 1395  xhtmlAttrListDumpOutput(xmlSaveCtxtPtr ctxt, xmlAttrPt
         xmlOutputBufferWrite(buf, 11, " xml:lang=\"");          xmlOutputBufferWrite(buf, 11, " xml:lang=\"");
         xmlAttrSerializeContent(buf, lang);          xmlAttrSerializeContent(buf, lang);
         xmlOutputBufferWrite(buf, 1, "\"");          xmlOutputBufferWrite(buf, 1, "\"");
    } else     } else
     if ((xml_lang != NULL) && (lang == NULL)) {      if ((xml_lang != NULL) && (lang == NULL)) {
         xmlOutputBufferWrite(buf, 7, " lang=\"");          xmlOutputBufferWrite(buf, 7, " lang=\"");
         xmlAttrSerializeContent(buf, xml_lang);          xmlAttrSerializeContent(buf, xml_lang);
Line 1331  xhtmlNodeListDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePt Line 1426  xhtmlNodeListDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePt
         if ((ctxt->format == 1) && (xmlIndentTreeOutput) &&          if ((ctxt->format == 1) && (xmlIndentTreeOutput) &&
             (cur->type == XML_ELEMENT_NODE))              (cur->type == XML_ELEMENT_NODE))
             xmlOutputBufferWrite(buf, ctxt->indent_size *              xmlOutputBufferWrite(buf, ctxt->indent_size *
                                 (ctxt->level > ctxt->indent_nr ?                                  (ctxt->level > ctxt->indent_nr ?
                                   ctxt->indent_nr : ctxt->level),                                    ctxt->indent_nr : ctxt->level),
                                  ctxt->indent);                                   ctxt->indent);
         xhtmlNodeDumpOutput(ctxt, cur);          xhtmlNodeDumpOutput(ctxt, cur);
Line 1370  xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cu Line 1465  xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cu
         return;          return;
     if (cur->type == XML_XINCLUDE_END)      if (cur->type == XML_XINCLUDE_END)
         return;          return;
       if (cur->type == XML_NAMESPACE_DECL) {
           xmlNsDumpOutputCtxt(ctxt, (xmlNsPtr) cur);
           return;
       }
     if (cur->type == XML_DTD_NODE) {      if (cur->type == XML_DTD_NODE) {
         xmlDtdDumpOutput(ctxt, (xmlDtdPtr) cur);          xmlDtdDumpOutput(ctxt, (xmlDtdPtr) cur);
         return;          return;
Line 1380  xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cu Line 1479  xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cu
     }      }
     buf = ctxt->buf;      buf = ctxt->buf;
     if (cur->type == XML_ELEMENT_DECL) {      if (cur->type == XML_ELEMENT_DECL) {
        xmlDumpElementDecl(buf->buffer, (xmlElementPtr) cur);        xmlBufDumpElementDecl(buf->buffer, (xmlElementPtr) cur);
         return;          return;
     }      }
     if (cur->type == XML_ATTRIBUTE_DECL) {      if (cur->type == XML_ATTRIBUTE_DECL) {
        xmlDumpAttributeDecl(buf->buffer, (xmlAttributePtr) cur);        xmlBufDumpAttributeDecl(buf->buffer, (xmlAttributePtr) cur);
         return;          return;
     }      }
     if (cur->type == XML_ENTITY_DECL) {      if (cur->type == XML_ENTITY_DECL) {
        xmlDumpEntityDecl(buf->buffer, (xmlEntityPtr) cur);        xmlBufDumpEntityDecl(buf->buffer, (xmlEntityPtr) cur);
         return;          return;
     }      }
     if (cur->type == XML_TEXT_NODE) {      if (cur->type == XML_TEXT_NODE) {
Line 1468  xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cu Line 1567  xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cu
     if (format == 1) {      if (format == 1) {
         tmp = cur->children;          tmp = cur->children;
         while (tmp != NULL) {          while (tmp != NULL) {
            if ((tmp->type == XML_TEXT_NODE) ||             if ((tmp->type == XML_TEXT_NODE) ||
                 (tmp->type == XML_ENTITY_REF_NODE)) {                  (tmp->type == XML_ENTITY_REF_NODE)) {
                 format = 0;                  format = 0;
                 break;                  break;
Line 1496  xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cu Line 1595  xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cu
     if (cur->properties != NULL)      if (cur->properties != NULL)
         xhtmlAttrListDumpOutput(ctxt, cur->properties);          xhtmlAttrListDumpOutput(ctxt, cur->properties);
   
        if ((cur->type == XML_ELEMENT_NODE) &&         if ((cur->type == XML_ELEMENT_NODE) &&
                (cur->parent != NULL) &&                 (cur->parent != NULL) &&
                (cur->parent->parent == (xmlNodePtr) cur->doc) &&                 (cur->parent->parent == (xmlNodePtr) cur->doc) &&
                xmlStrEqual(cur->name, BAD_CAST"head") &&                 xmlStrEqual(cur->name, BAD_CAST"head") &&
                 xmlStrEqual(cur->parent->name, BAD_CAST"html")) {                  xmlStrEqual(cur->parent->name, BAD_CAST"html")) {
   
                 tmp = cur->children;                  tmp = cur->children;
Line 1536  xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cu Line 1635  xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cu
                                 xmlOutputBufferWrite(buf, 1, "\n");                                  xmlOutputBufferWrite(buf, 1, "\n");
                                 if (xmlIndentTreeOutput)                                  if (xmlIndentTreeOutput)
                                         xmlOutputBufferWrite(buf, ctxt->indent_size *                                          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);                                          ctxt->indent_nr : ctxt->level + 1), ctxt->indent);
                         }                          }
                         xmlOutputBufferWriteString(buf,                          xmlOutputBufferWriteString(buf,
Line 1571  xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cu Line 1670  xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cu
                         xmlOutputBufferWrite(buf, 1, "\n");                          xmlOutputBufferWrite(buf, 1, "\n");
                         if (xmlIndentTreeOutput)                          if (xmlIndentTreeOutput)
                                 xmlOutputBufferWrite(buf, ctxt->indent_size *                                  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);                                  ctxt->indent_nr : ctxt->level + 1), ctxt->indent);
                 }                  }
                 xmlOutputBufferWriteString(buf,                  xmlOutputBufferWriteString(buf,
Line 1661  xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cu Line 1760  xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cu
   
     if (cur->children != NULL) {      if (cur->children != NULL) {
         int indent = ctxt->format;          int indent = ctxt->format;
        
         if (format == 1) xmlOutputBufferWrite(buf, 1, "\n");          if (format == 1) xmlOutputBufferWrite(buf, 1, "\n");
         if (ctxt->level >= 0) ctxt->level++;          if (ctxt->level >= 0) ctxt->level++;
         ctxt->format = format;          ctxt->format = format;
Line 1670  xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cu Line 1769  xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cu
         ctxt->format = indent;          ctxt->format = indent;
         if ((xmlIndentTreeOutput) && (format == 1))          if ((xmlIndentTreeOutput) && (format == 1))
             xmlOutputBufferWrite(buf, ctxt->indent_size *              xmlOutputBufferWrite(buf, ctxt->indent_size *
                                 (ctxt->level > ctxt->indent_nr ?                                  (ctxt->level > ctxt->indent_nr ?
                                   ctxt->indent_nr : ctxt->level),                                    ctxt->indent_nr : ctxt->level),
                                  ctxt->indent);                                   ctxt->indent);
     }      }
Line 1936  xmlSaveSetAttrEscape(xmlSaveCtxtPtr ctxt, xmlCharEncod Line 2035  xmlSaveSetAttrEscape(xmlSaveCtxtPtr ctxt, xmlCharEncod
  *              Public entry points based on buffers                    *   *              Public entry points based on buffers                    *
  *                                                                      *   *                                                                      *
  ************************************************************************/   ************************************************************************/
   
 /**  /**
 * xmlAttrSerializeTxtContent: * xmlBufAttrSerializeTxtContent:
 * @buf:  the XML buffer output * @buf:  and xmlBufPtr output
  * @doc:  the document   * @doc:  the document
  * @attr: the attribute node   * @attr: the attribute node
  * @string: the text content   * @string: the text content
  *   *
 * Serialize text attribute values to an xml simple buffer * Serialize text attribute values to an xmlBufPtr
  */   */
 void  void
xmlAttrSerializeTxtContent(xmlBufferPtr buf, xmlDocPtr doc,xmlBufAttrSerializeTxtContent(xmlBufPtr buf, xmlDocPtr doc,
                           xmlAttrPtr attr, const xmlChar * string)                              xmlAttrPtr attr, const xmlChar * string)
 {  {
     xmlChar *base, *cur;      xmlChar *base, *cur;
   
Line 1957  xmlAttrSerializeTxtContent(xmlBufferPtr buf, xmlDocPtr Line 2057  xmlAttrSerializeTxtContent(xmlBufferPtr buf, xmlDocPtr
     while (*cur != 0) {      while (*cur != 0) {
         if (*cur == '\n') {          if (*cur == '\n') {
             if (base != cur)              if (base != cur)
                xmlBufferAdd(buf, base, cur - base);                xmlBufAdd(buf, base, cur - base);
            xmlBufferAdd(buf, BAD_CAST "&#10;", 5);            xmlBufAdd(buf, BAD_CAST "&#10;", 5);
             cur++;              cur++;
             base = cur;              base = cur;
         } else if (*cur == '\r') {          } else if (*cur == '\r') {
             if (base != cur)              if (base != cur)
                xmlBufferAdd(buf, base, cur - base);                xmlBufAdd(buf, base, cur - base);
            xmlBufferAdd(buf, BAD_CAST "&#13;", 5);            xmlBufAdd(buf, BAD_CAST "&#13;", 5);
             cur++;              cur++;
             base = cur;              base = cur;
         } else if (*cur == '\t') {          } else if (*cur == '\t') {
             if (base != cur)              if (base != cur)
                xmlBufferAdd(buf, base, cur - base);                xmlBufAdd(buf, base, cur - base);
            xmlBufferAdd(buf, BAD_CAST "&#9;", 4);            xmlBufAdd(buf, BAD_CAST "&#9;", 4);
             cur++;              cur++;
             base = cur;              base = cur;
         } else if (*cur == '"') {          } else if (*cur == '"') {
             if (base != cur)              if (base != cur)
                xmlBufferAdd(buf, base, cur - base);                xmlBufAdd(buf, base, cur - base);
            xmlBufferAdd(buf, BAD_CAST "&quot;", 6);            xmlBufAdd(buf, BAD_CAST "&quot;", 6);
             cur++;              cur++;
             base = cur;              base = cur;
         } else if (*cur == '<') {          } else if (*cur == '<') {
             if (base != cur)              if (base != cur)
                xmlBufferAdd(buf, base, cur - base);                xmlBufAdd(buf, base, cur - base);
            xmlBufferAdd(buf, BAD_CAST "&lt;", 4);            xmlBufAdd(buf, BAD_CAST "&lt;", 4);
             cur++;              cur++;
             base = cur;              base = cur;
         } else if (*cur == '>') {          } else if (*cur == '>') {
             if (base != cur)              if (base != cur)
                xmlBufferAdd(buf, base, cur - base);                xmlBufAdd(buf, base, cur - base);
            xmlBufferAdd(buf, BAD_CAST "&gt;", 4);            xmlBufAdd(buf, BAD_CAST "&gt;", 4);
             cur++;              cur++;
             base = cur;              base = cur;
         } else if (*cur == '&') {          } else if (*cur == '&') {
             if (base != cur)              if (base != cur)
                xmlBufferAdd(buf, base, cur - base);                xmlBufAdd(buf, base, cur - base);
            xmlBufferAdd(buf, BAD_CAST "&amp;", 5);            xmlBufAdd(buf, BAD_CAST "&amp;", 5);
             cur++;              cur++;
             base = cur;              base = cur;
         } else if ((*cur >= 0x80) && ((doc == NULL) ||          } else if ((*cur >= 0x80) && ((doc == NULL) ||
Line 2006  xmlAttrSerializeTxtContent(xmlBufferPtr buf, xmlDocPtr Line 2106  xmlAttrSerializeTxtContent(xmlBufferPtr buf, xmlDocPtr
             int val = 0, l = 1;              int val = 0, l = 1;
   
             if (base != cur)              if (base != cur)
                xmlBufferAdd(buf, base, cur - base);                xmlBufAdd(buf, base, cur - base);
             if (*cur < 0xC0) {              if (*cur < 0xC0) {
                 xmlSaveErr(XML_SAVE_NOT_UTF8, (xmlNodePtr) attr, NULL);                  xmlSaveErr(XML_SAVE_NOT_UTF8, (xmlNodePtr) attr, NULL);
                 if (doc != NULL)                  if (doc != NULL)
                     doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1");                      doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1");
                 xmlSerializeHexCharRef(tmp, *cur);                  xmlSerializeHexCharRef(tmp, *cur);
                xmlBufferAdd(buf, (xmlChar *) tmp, -1);                xmlBufAdd(buf, (xmlChar *) tmp, -1);
                 cur++;                  cur++;
                 base = cur;                  base = cur;
                 continue;                  continue;
Line 2042  xmlAttrSerializeTxtContent(xmlBufferPtr buf, xmlDocPtr Line 2142  xmlAttrSerializeTxtContent(xmlBufferPtr buf, xmlDocPtr
                 xmlSaveErr(XML_SAVE_CHAR_INVALID, (xmlNodePtr) attr, NULL);                  xmlSaveErr(XML_SAVE_CHAR_INVALID, (xmlNodePtr) attr, NULL);
                 if (doc != NULL)                  if (doc != NULL)
                     doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1");                      doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1");
                
                 xmlSerializeHexCharRef(tmp, *cur);                  xmlSerializeHexCharRef(tmp, *cur);
                xmlBufferAdd(buf, (xmlChar *) tmp, -1);                xmlBufAdd(buf, (xmlChar *) tmp, -1);
                 cur++;                  cur++;
                 base = cur;                  base = cur;
                 continue;                  continue;
Line 2054  xmlAttrSerializeTxtContent(xmlBufferPtr buf, xmlDocPtr Line 2154  xmlAttrSerializeTxtContent(xmlBufferPtr buf, xmlDocPtr
              * as a char ref               * as a char ref
              */               */
             xmlSerializeHexCharRef(tmp, val);              xmlSerializeHexCharRef(tmp, val);
            xmlBufferAdd(buf, (xmlChar *) tmp, -1);            xmlBufAdd(buf, (xmlChar *) tmp, -1);
             cur += l;              cur += l;
             base = cur;              base = cur;
         } else {          } else {
Line 2062  xmlAttrSerializeTxtContent(xmlBufferPtr buf, xmlDocPtr Line 2162  xmlAttrSerializeTxtContent(xmlBufferPtr buf, xmlDocPtr
         }          }
     }      }
     if (base != 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:   * xmlNodeDump:
  * @buf:  the XML buffer output   * @buf:  the XML buffer output
  * @doc:  the document   * @doc:  the document
Line 2076  xmlAttrSerializeTxtContent(xmlBufferPtr buf, xmlDocPtr Line 2200  xmlAttrSerializeTxtContent(xmlBufferPtr buf, xmlDocPtr
  * Dump an XML node, recursive behaviour,children are printed too.   * Dump an XML node, recursive behaviour,children are printed too.
  * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1   * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1
  * or xmlKeepBlanksDefault(0) was called   * 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   * Returns the number of bytes written to the buffer or -1 in case of error
  */   */
Line 2083  int Line 2209  int
 xmlNodeDump(xmlBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur, int level,  xmlNodeDump(xmlBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur, int level,
             int format)              int format)
 {  {
    unsigned int use;    xmlBufPtr buffer;
     int ret;      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;      xmlOutputBufferPtr outbuf;
       int oldalloc;
   
     xmlInitParser();      xmlInitParser();
   
Line 2116  xmlNodeDump(xmlBufferPtr buf, xmlDocPtr doc, xmlNodePt Line 2278  xmlNodeDump(xmlBufferPtr buf, xmlDocPtr doc, xmlNodePt
     outbuf->context = NULL;      outbuf->context = NULL;
     outbuf->written = 0;      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);      xmlNodeDumpOutput(outbuf, doc, cur, level, format, NULL);
       xmlBufSetAllocationScheme(buf, oldalloc);
     xmlFree(outbuf);      xmlFree(outbuf);
    ret = buf->use - use;    ret = xmlBufUse(buf) - use;
     return (ret);      return (ret);
 }  }
   
Line 2299  xmlDocDumpFormatMemoryEnc(xmlDocPtr out_doc, xmlChar * Line 2464  xmlDocDumpFormatMemoryEnc(xmlDocPtr out_doc, xmlChar *
     xmlDocContentDumpOutput(&ctxt, out_doc);      xmlDocContentDumpOutput(&ctxt, out_doc);
     xmlOutputBufferFlush(out_buff);      xmlOutputBufferFlush(out_buff);
     if (out_buff->conv != NULL) {      if (out_buff->conv != NULL) {
        *doc_txt_len = out_buff->conv->use;        *doc_txt_len = xmlBufUse(out_buff->conv);
        *doc_txt_ptr = xmlStrndup(out_buff->conv->content, *doc_txt_len);        *doc_txt_ptr = xmlStrndup(xmlBufContent(out_buff->conv), *doc_txt_len);
     } else {      } else {
        *doc_txt_len = out_buff->buffer->use;        *doc_txt_len = xmlBufUse(out_buff->buffer);
        *doc_txt_ptr = xmlStrndup(out_buff->buffer->content, *doc_txt_len);        *doc_txt_ptr = xmlStrndup(xmlBufContent(out_buff->buffer),*doc_txt_len);
     }      }
     (void)xmlOutputBufferClose(out_buff);      (void)xmlOutputBufferClose(out_buff);
   
Line 2547  xmlSaveFormatFileEnc( const char * filename, xmlDocPtr Line 2712  xmlSaveFormatFileEnc( const char * filename, xmlDocPtr
 #ifdef HAVE_ZLIB_H  #ifdef HAVE_ZLIB_H
     if (cur->compression < 0) cur->compression = xmlGetCompressMode();      if (cur->compression < 0) cur->compression = xmlGetCompressMode();
 #endif  #endif
    /*     /*
      * save the content to a temp buffer.       * save the content to a temp buffer.
      */       */
     buf = xmlOutputBufferCreateFilename(filename, handler, cur->compression);      buf = xmlOutputBufferCreateFilename(filename, handler, cur->compression);
Removed from v.1.1.1.2  
changed lines
  Added in v.1.1.1.3

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>