Upgrade to libxml 2.9.2 and libxslt 1.1.28

third_party/libxml/src/xmlwriter.c

 
 /*
  * xmlwriter.c: XML text writer implementation
  *
  * For license and disclaimer see the license and disclaimer of
  * libxml2.
  *
  * alfred@mickautsch.de
  */
 
 #define IN_LIBXML
 #include "libxml.h"
 #include <string.h>
 
 #include <libxml/xmlmemory.h>
 #include <libxml/parser.h>
 #include <libxml/uri.h>
 #include <libxml/HTMLtree.h>
 
 #ifdef LIBXML_WRITER_ENABLED
 
 #include <libxml/xmlwriter.h>
 
+#include "buf.h"
+#include "enc.h"
+#include "save.h"
+
 #define B64LINELEN 72
 #define B64CRLF "\r\n"
 
 /*
  * The following VA_COPY was coded following an example in
  * the Samba project.  It may not be sufficient for some
- * esoteric implementations of va_list (i.e. it may need
- * something involving a memcpy) but (hopefully) will be
- * sufficient for libxml2.
+ * esoteric implementations of va_list but (hopefully) will
+ * be sufficient for libxml2.
  */
 #ifndef VA_COPY
   #ifdef HAVE_VA_COPY
     #define VA_COPY(dest, src) va_copy(dest, src)
   #else
     #ifdef HAVE___VA_COPY
       #define VA_COPY(dest,src) __va_copy(dest, src)
     #else
-      #define VA_COPY(dest,src) (dest) = (src)
+      #ifndef VA_LIST_IS_ARRAY
+        #define VA_COPY(dest,src) (dest) = (src)
+      #else
+        #include <string.h>
+        #define VA_COPY(dest,src) memcpy((char *)(dest),(char *)(src),sizeof(va_list))
+      #endif
     #endif
   #endif
 #endif
 
 /*
  * Types are kept private
  */
 typedef enum {
     XML_TEXTWRITER_NONE = 0,
     XML_TEXTWRITER_NAME,
@@ skipping 489 matching lines @@
         if (encoder == NULL) {
             xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
                             "xmlTextWriterStartDocument : out of memory!\n");
             return -1;
         }
     }
 
     writer->out->encoder = encoder;
     if (encoder != NULL) {
         if (writer->out->conv == NULL) {
-            writer->out->conv = xmlBufferCreateSize(4000);
+            writer->out->conv = xmlBufCreateSize(4000);
         }
-        xmlCharEncOutFunc(encoder, writer->out->conv, NULL);
+        xmlCharEncOutput(writer->out, 1);
         if ((writer->doc != NULL) && (writer->doc->encoding == NULL))
             writer->doc->encoding = xmlStrdup((xmlChar *)writer->out->encoder->name);
     } else
         writer->out->conv = NULL;
 
     sum = 0;
     count = xmlOutputBufferWriteString(writer->out, "<?xml version=");
     if (count < 0)
         return -1;
     sum += count;
@@ skipping 503 matching lines @@
     buf = xmlStrcat(buf, name);
 
     sum = 0;
     count = xmlTextWriterStartElement(writer, buf);
     xmlFree(buf);
     if (count < 0)
         return -1;
     sum += count;
 
     if (namespaceURI != 0) {
-        xmlTextWriterNsStackEntry *p = (xmlTextWriterNsStackEntry *) 
+        xmlTextWriterNsStackEntry *p = (xmlTextWriterNsStackEntry *)
         xmlMalloc(sizeof(xmlTextWriterNsStackEntry));
         if (p == 0) {
-            xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY, 
+            xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
                             "xmlTextWriterStartElementNS : out of memory!\n");
             return -1;
         }
 
         buf = xmlStrdup(BAD_CAST "xmlns");
         if (prefix != 0) {
             buf = xmlStrcat(buf, BAD_CAST ":");
             buf = xmlStrcat(buf, prefix);
         }
 
@@ skipping 403 matching lines @@
                 case XML_TEXTWRITER_NAME:
                 case XML_TEXTWRITER_TEXT:
 #if 0
                     buf = NULL;
                     xmlOutputBufferWriteEscape(writer->out, content, NULL);
 #endif
                     buf = xmlEncodeSpecialChars(NULL, content);
                     break;
                 case XML_TEXTWRITER_ATTRIBUTE:
                     buf = NULL;
-                    xmlAttrSerializeTxtContent(writer->out->buffer, writer->doc,
-                                               NULL, content);
+                    xmlBufAttrSerializeTxtContent(writer->out->buffer,
+                                                  writer->doc, NULL, content);
                     break;
                 default:
                     break;
             }
         }
     }
 
     if (buf != NULL) {
         count = xmlTextWriterWriteRaw(writer, buf);
 
@@ skipping 140 matching lines @@
 
 /**
  * xmlOutputBufferWriteBinHex:
  * @out: the xmlOutputBufferPtr
  * @data:   binary data
  * @len:  the number of bytes to encode
  *
  * Write hqx encoded data to an xmlOutputBuffer.
  * ::todo
  *
- * Returns the bytes written (may be 0 because of buffering) 
+ * Returns the bytes written (may be 0 because of buffering)
  * or -1 in case of error
  */
 static int
 xmlOutputBufferWriteBinHex(xmlOutputBufferPtr out,
                            int len, const unsigned char *data)
 {
     int count;
     int sum;
-    static char hex[16] = 
-        {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
+    static char hex[16] =
+        {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
     int i;
 
     if ((out == NULL) || (data == NULL) || (len < 0)) {
         return -1;
     }
 
     sum = 0;
     for (i = 0; i < len; i++) {
         count =
             xmlOutputBufferWrite(out, 1,
@@ skipping 155 matching lines @@
         buf = xmlStrdup(BAD_CAST "xmlns");
         if (prefix != 0) {
             buf = xmlStrcat(buf, BAD_CAST ":");
             buf = xmlStrcat(buf, prefix);
         }
 
         nsentry.prefix = buf;
         nsentry.uri = (xmlChar *)namespaceURI;
         nsentry.elem = xmlListFront(writer->nodes);
 
-        curns = (xmlTextWriterNsStackEntry *)xmlListSearch(writer->nsstack, 
+        curns = (xmlTextWriterNsStackEntry *)xmlListSearch(writer->nsstack,
                                                            (void *)&nsentry);
         if ((curns != NULL)) {
             xmlFree(buf);
             if (xmlStrcmp(curns->uri, namespaceURI) == 0) {
                 /* Namespace already defined on element skip */
                 buf = NULL;
             } else {
                 /* Prefix mismatch so error out */
                 return -1;
             }
@@ skipping 364 matching lines @@
                           const xmlChar * content)
 {
     int count;
     int sum;
 
     sum = 0;
     count = xmlTextWriterStartElement(writer, name);
     if (count == -1)
         return -1;
     sum += count;
-    count = xmlTextWriterWriteString(writer, content);
-    if (count == -1)
-        return -1;
-    sum += count;
+    if (content != NULL) {
+        count = xmlTextWriterWriteString(writer, content);
+        if (count == -1)
+            return -1;
+        sum += count;
+    }
     count = xmlTextWriterEndElement(writer);
     if (count == -1)
         return -1;
     sum += count;
 
     return sum;
 }
 
 /**
  * xmlTextWriterWriteFormatElementNS:
@@ skipping 238 matching lines @@
             if (count < 0)
                 return -1;
             sum += count;
             break;
         default:
             return -1;
     }
 
     if (writer->indent) {
         count = xmlOutputBufferWriteString(writer->out, "\n");
-        if (count < 0)
-        return -1;
+        if (count < 0)
+        return -1;
         sum += count;
     }
 
     xmlListPopFront(writer->nodes);
     return sum;
 }
 
 /**
  * xmlTextWriterWriteFormatPI:
  * @writer:  the xmlTextWriterPtr
@@ skipping 2088 matching lines @@
         xmlFree(writer->ichar);
     writer->ichar = xmlStrdup(str);
 
     if (!writer->ichar)
         return -1;
     else
         return 0;
 }
 
 /**
+ * xmlTextWriterSetQuoteChar:
+ * @writer:  the xmlTextWriterPtr
+ * @quotechar:  the quote character
+ *
+ * Set the character used for quoting attributes.
+ *
+ * Returns -1 on error or 0 otherwise.
+ */
+int
+xmlTextWriterSetQuoteChar(xmlTextWriterPtr writer, xmlChar quotechar)
+{
+    if ((writer == NULL) || ((quotechar != '\'') && (quotechar != '"')))
+        return -1;
+
+    writer->qchar = quotechar;
+
+    return 0;
+}
+
+/**
  * xmlTextWriterWriteIndent:
  * @writer:  the xmlTextWriterPtr
  *
  * Write indent string.
  *
  * Returns -1 on error or the number of strings written.
  */
 static int
 xmlTextWriterWriteIndent(xmlTextWriterPtr writer)
 {
@@ skipping 85 matching lines @@
             return -1;
         sum += count;
     }
 
     return sum;
 }
 
 #define bottom_xmlwriter
 #include "elfgcchack.h"
 #endif