Update libxml to 2.7.7.

third_party/libxml/HTMLtree.c

 /*
  * HTMLtree.c : implementation of access function for an HTML tree.
  *
  * See Copyright for the status of this software.
  *
  * daniel@veillard.com
  */
 
 
 #define IN_LIBXML
@@ skipping 142 matching lines @@
  * @encoding:  the encoding string
  * 
  * Sets the current encoding in the Meta tags
  * NOTE: this will not change the document content encoding, just
  * the META flag associated.
  *
  * Returns 0 in case of success and -1 in case of error
  */
 int
 htmlSetMetaEncoding(htmlDocPtr doc, const xmlChar *encoding) {
-    htmlNodePtr cur, meta;
-    const xmlChar *content;
+    htmlNodePtr cur, meta = NULL, head = NULL;
+    const xmlChar *content = NULL;
     char newcontent[100];
 
 
     if (doc == NULL)
         return(-1);
 
+    /* html isn't a real encoding it's just libxml2 way to get entities */
+    if (!xmlStrcasecmp(encoding, BAD_CAST "html"))
+        return(-1);
+
     if (encoding != NULL) {
         snprintf(newcontent, sizeof(newcontent), "text/html; charset=%s",
                 (char *)encoding);
         newcontent[sizeof(newcontent) - 1] = 0;
     }
 
     cur = doc->children;
 
     /*
      * Search the html
@@ skipping 13 matching lines @@
         return(-1);
     cur = cur->children;
 
     /*
      * Search the head
      */
     while (cur != NULL) {
         if ((cur->type == XML_ELEMENT_NODE) && (cur->name != NULL)) {
             if (xmlStrcasecmp(cur->name, BAD_CAST"head") == 0)
                 break;
-            if (xmlStrcasecmp(cur->name, BAD_CAST"meta") == 0)
+            if (xmlStrcasecmp(cur->name, BAD_CAST"meta") == 0) {
+                head = cur->parent;
                 goto found_meta;
+            }
         }
         cur = cur->next;
     }
     if (cur == NULL)
         return(-1);
 found_head:
-    if (cur->children == NULL) {
-        if (encoding == NULL)
-            return(0);
-        meta = xmlNewDocNode(doc, NULL, BAD_CAST"meta", NULL);
-        xmlAddChild(cur, meta);
-        xmlNewProp(meta, BAD_CAST"http-equiv", BAD_CAST"Content-Type");
-        xmlNewProp(meta, BAD_CAST"content", BAD_CAST newcontent);
-        return(0);
-    }
+    head = cur;
+    if (cur->children == NULL)
+        goto create;
     cur = cur->children;
 
 found_meta:
-    if (encoding != NULL) {
-        /*
-         * Create a new Meta element with the right attributes
-         */
-
-        meta = xmlNewDocNode(doc, NULL, BAD_CAST"meta", NULL);
-        xmlAddPrevSibling(cur, meta);
-        xmlNewProp(meta, BAD_CAST"http-equiv", BAD_CAST"Content-Type");
-        xmlNewProp(meta, BAD_CAST"content", BAD_CAST newcontent);
-    }
-
     /*
-     * Search and destroy all the remaining the meta elements carrying
+     * Search and update all the remaining the meta elements carrying
      * encoding informations
      */
     while (cur != NULL) {
         if ((cur->type == XML_ELEMENT_NODE) && (cur->name != NULL)) {
             if (xmlStrcasecmp(cur->name, BAD_CAST"meta") == 0) {
                 xmlAttrPtr attr = cur->properties;
                 int http;
                 const xmlChar *value;
 
                 content = NULL;
                 http = 0;
                 while (attr != NULL) {
                     if ((attr->children != NULL) &&
                         (attr->children->type == XML_TEXT_NODE) &&
                         (attr->children->next == NULL)) {
                         value = attr->children->content;
                         if ((!xmlStrcasecmp(attr->name, BAD_CAST"http-equiv"))
                          && (!xmlStrcasecmp(value, BAD_CAST"Content-Type")))
                             http = 1;
-                        else 
+                        else
                         {
                            if ((value != NULL) && 
-                                (!xmlStrcasecmp(attr->name, BAD_CAST"content")))
-                              content = value;
+                               (!xmlStrcasecmp(attr->name, BAD_CAST"content")))
+                               content = value;
                         }
                         if ((http != 0) && (content != NULL))
                             break;
                     }
                     attr = attr->next;
                 }
                 if ((http != 0) && (content != NULL)) {
                     meta = cur;
-                    cur = cur->next;
-                    xmlUnlinkNode(meta);
-                    xmlFreeNode(meta);
-                    continue;
+                    break;
                 }
 
             }
         }
         cur = cur->next;
     }
+create:
+    if (meta == NULL) {
+        if ((encoding != NULL) && (head != NULL)) {
+            /*
+             * Create a new Meta element with the right attributes
+             */
+
+            meta = xmlNewDocNode(doc, NULL, BAD_CAST"meta", NULL);
+            if (head->children == NULL)
+                xmlAddChild(head, meta);
+            else
+                xmlAddPrevSibling(head->children, meta);
+            xmlNewProp(meta, BAD_CAST"http-equiv", BAD_CAST"Content-Type");
+            xmlNewProp(meta, BAD_CAST"content", BAD_CAST newcontent);
+        }
+    } else {
+        /* change the document only if there is a real encoding change */
+        if (xmlStrcasestr(content, encoding) == NULL) {
+            xmlSetProp(meta, BAD_CAST"content", BAD_CAST newcontent);
+        }
+    }
+
+
     return(0);
 }
 
 /**
  * booleanHTMLAttrs:
  *
  * These are the HTML attributes which will be output
  * in minimized form, i.e. <option selected="selected"> will be
  * output as <option selected>, as per XSLT 1.0 16.2 "HTML Output Method"
  *
@@ skipping 20 matching lines @@
 
     while (htmlBooleanAttrs[i] != NULL) {
         if (xmlStrcasecmp((const xmlChar *)htmlBooleanAttrs[i], name) == 0)
             return 1;
         i++;
     }
     return 0;
 }
 
 #ifdef LIBXML_OUTPUT_ENABLED
+/*
+ * private routine exported from xmlIO.c
+ */
+xmlOutputBufferPtr
+xmlAllocOutputBufferInternal(xmlCharEncodingHandlerPtr encoder);
 /************************************************************************
  *                                                                      *
  *                      Output error handlers                           *
  *                                                                      *
  ************************************************************************/
 /**
  * htmlSaveErrMemory:
  * @extra:  extra informations
  *
  * Handle an out of memory condition
@@ skipping 230 matching lines @@
     }
 
     /*
      * Fallback to HTML or ASCII when the encoding is unspecified
      */
     if (handler == NULL)
         handler = xmlFindCharEncodingHandler("HTML");
     if (handler == NULL)
         handler = xmlFindCharEncodingHandler("ascii");
 
-    buf = xmlAllocOutputBuffer(handler);
+    buf = xmlAllocOutputBufferInternal(handler);
     if (buf == NULL) {
         *mem = NULL;
         *size = 0;
         return;
     }
 
         htmlDocContentDumpFormatOutput(buf, cur, NULL, format);
 
     xmlOutputBufferFlush(buf);
     if (buf->conv != NULL) {
@@ skipping 563 matching lines @@
  */
 int
 htmlSaveFileFormat(const char *filename, xmlDocPtr cur,
                    const char *encoding, int format) {
     xmlOutputBufferPtr buf;
     xmlCharEncodingHandlerPtr handler = NULL;
     int ret;
 
     if ((cur == NULL) || (filename == NULL))
         return(-1);
-       
+
     xmlInitParser();
 
     if (encoding != NULL) {
         xmlCharEncoding enc;
 
         enc = xmlParseCharEncoding(encoding);
         if (enc != cur->charset) {
             if (cur->charset != XML_CHAR_ENCODING_UTF8) {
                 /*
                  * Not supported yet
                  */
                 return(-1);
             }
 
             handler = xmlFindCharEncodingHandler(encoding);
             if (handler == NULL)
                 return(-1);
-            htmlSetMetaEncoding(cur, (const xmlChar *) encoding);
         }
+        htmlSetMetaEncoding(cur, (const xmlChar *) encoding);
     } else {
         htmlSetMetaEncoding(cur, (const xmlChar *) "UTF-8");
     }
 
     /*
      * Fallback to HTML or ASCII when the encoding is unspecified
      */
     if (handler == NULL)
         handler = xmlFindCharEncodingHandler("HTML");
     if (handler == NULL)
@@ skipping 25 matching lines @@
 int
 htmlSaveFileEnc(const char *filename, xmlDocPtr cur, const char *encoding) {
     return(htmlSaveFileFormat(filename, cur, encoding, 1));
 }
 
 #endif /* LIBXML_OUTPUT_ENABLED */
 
 #define bottom_HTMLtree
 #include "elfgcchack.h"
 #endif /* LIBXML_HTML_ENABLED */