Update libxml to 2.7.7.

third_party/libxml/encoding.c

 /*
  * encoding.c : implements the encoding conversion functions needed for XML
  *
  * Related specs: 
  * rfc2044        (UTF-8 and UTF-16) F. Yergeau Alis Technologies
  * rfc2781        UTF-16, an encoding of ISO 10646, P. Hoffman, F. Yergeau
  * [ISO-10646]    UTF-8 and UTF-16 in Annexes
  * [ISO-8859-1]   ISO Latin-1 characters codes.
  * [UNICODE]      The Unicode Consortium, "The Unicode Standard --
  *                Worldwide Character Encoding -- Version 1.0", Addison-
@@ skipping 1448 matching lines @@
 
 /**
  * xmlRegisterCharEncodingHandler:
  * @handler:  the xmlCharEncodingHandlerPtr handler block
  *
  * Register the char encoding handler, surprising, isn't it ?
  */
 void
 xmlRegisterCharEncodingHandler(xmlCharEncodingHandlerPtr handler) {
     if (handlers == NULL) xmlInitCharEncodingHandlers();
-    if (handler == NULL) {
+    if ((handler == NULL) || (handlers == NULL)) {
         xmlEncodingErr(XML_I18N_NO_HANDLER,
                 "xmlRegisterCharEncodingHandler: NULL handler !\n", NULL);
         return;
     }
 
     if (nbCharEncodingHandler >= MAX_ENCODING_HANDLERS) {
         xmlEncodingErr(XML_I18N_EXCESS_HANDLER,
         "xmlRegisterCharEncodingHandler: Too many handler registered, see %s\n",
                        "MAX_ENCODING_HANDLERS");
         return;
@@ skipping 23 matching lines @@
             return(NULL);
         case XML_CHAR_ENCODING_UTF16LE:
             return(xmlUTF16LEHandler);
         case XML_CHAR_ENCODING_UTF16BE:
             return(xmlUTF16BEHandler);
         case XML_CHAR_ENCODING_EBCDIC:
             handler = xmlFindCharEncodingHandler("EBCDIC");
             if (handler != NULL) return(handler);
             handler = xmlFindCharEncodingHandler("ebcdic");
             if (handler != NULL) return(handler);
+            handler = xmlFindCharEncodingHandler("EBCDIC-US");
+            if (handler != NULL) return(handler);
             break;
         case XML_CHAR_ENCODING_UCS4BE:
             handler = xmlFindCharEncodingHandler("ISO-10646-UCS-4");
             if (handler != NULL) return(handler);
             handler = xmlFindCharEncodingHandler("UCS-4");
             if (handler != NULL) return(handler);
             handler = xmlFindCharEncodingHandler("UCS4");
             if (handler != NULL) return(handler);
             break;
         case XML_CHAR_ENCODING_UCS4LE:
@@ skipping 126 matching lines @@
 
     /*
      * Check first for directly registered encoding names
      */
     for (i = 0;i < 99;i++) {
         upper[i] = toupper(name[i]);
         if (upper[i] == 0) break;
     }
     upper[i] = 0;
 
-    for (i = 0;i < nbCharEncodingHandler; i++)
-        if (!strcmp(upper, handlers[i]->name)) {
+    if (handlers != NULL) {
+        for (i = 0;i < nbCharEncodingHandler; i++) {
+            if (!strcmp(upper, handlers[i]->name)) {
 #ifdef DEBUG_ENCODING
-            xmlGenericError(xmlGenericErrorContext,
-                    "Found registered handler for encoding %s\n", name);
+                xmlGenericError(xmlGenericErrorContext,
+                        "Found registered handler for encoding %s\n", name);
 #endif
-            return(handlers[i]);
-        }
+                return(handlers[i]);
+            }
+        }
+    }
 
 #ifdef LIBXML_ICONV_ENABLED
     /* check whether iconv can handle this */
     icv_in = iconv_open("UTF-8", name);
     icv_out = iconv_open(name, "UTF-8");
     if (icv_in == (iconv_t) -1) {
         icv_in = iconv_open("UTF-8", upper);
     }
     if (icv_out == (iconv_t) -1) {
         icv_out = iconv_open(upper, "UTF-8");
@@ skipping 205 matching lines @@
     /* if (err == U_TRUNCATED_CHAR_FOUND) */
     return -3;
 }
 #endif /* LIBXML_ICU_ENABLED */
 
 /************************************************************************
  *                                                                      *
  *              The real API used by libxml for on-the-fly conversion   *
  *                                                                      *
  ************************************************************************/
+int
+xmlCharEncFirstLineInt(xmlCharEncodingHandler *handler, xmlBufferPtr out,
+                       xmlBufferPtr in, int len);
 
 /**
- * xmlCharEncFirstLine:
+ * xmlCharEncFirstLineInt:
  * @handler:    char enconding transformation data structure
  * @out:  an xmlBuffer for the output.
  * @in:  an xmlBuffer for the input
- *     
+ * @len:  number of bytes to convert for the first line, or -1
+ *
  * Front-end for the encoding handler input function, but handle only
  * the very first line, i.e. limit itself to 45 chars.
- *     
- * Returns the number of byte written if success, or 
+ *
+ * Returns the number of byte written if success, or
  *     -1 general error
  *     -2 if the transcoding fails (for *in is not valid utf8 string or
  *        the result of transformation can't fit into the encoding we want), or
  */
 int
-xmlCharEncFirstLine(xmlCharEncodingHandler *handler, xmlBufferPtr out,
-                 xmlBufferPtr in) {
+xmlCharEncFirstLineInt(xmlCharEncodingHandler *handler, xmlBufferPtr out,
+                       xmlBufferPtr in, int len) {
     int ret = -2;
     int written;
     int toconv;
 
     if (handler == NULL) return(-1);
     if (out == NULL) return(-1);
     if (in == NULL) return(-1);
 
     /* calculate space available */
     written = out->size - out->use;
     toconv = in->use;
     /*
      * echo '<?xml version="1.0" encoding="UCS4"?>' | wc -c => 38
      * 45 chars should be sufficient to reach the end of the encoding
      * declaration without going too far inside the document content.
      * on UTF-16 this means 90bytes, on UCS4 this means 180
+     * The actual value depending on guessed encoding is passed as @len
+     * if provided
      */
-    if (toconv > 180)
-        toconv  = 180;
+    if (len >= 0) {
+        if (toconv > len)
+            toconv = len;
+    } else {
+        if (toconv > 180)
+            toconv = 180;
+    }
     if (toconv * 2 >= written) {
         xmlBufferGrow(out, toconv);
         written = out->size - out->use - 1;
     }
 
     if (handler->input != NULL) {
         ret = handler->input(&out->content[out->use], &written,
                              in->content, &toconv);
         xmlBufferShrink(in, toconv);
         out->use += written;
@@ skipping 44 matching lines @@
 #endif /* DEBUG_ENCODING */
     /*
      * Ignore when input buffer is not on a boundary
      */
     if (ret == -3) ret = 0;
     if (ret == -1) ret = 0;
     return(ret);
 }
 
 /**
+ * xmlCharEncFirstLine:
+ * @handler:    char enconding transformation data structure
+ * @out:  an xmlBuffer for the output.
+ * @in:  an xmlBuffer for the input
+ *
+ * Front-end for the encoding handler input function, but handle only
+ * the very first line, i.e. limit itself to 45 chars.
+ *
+ * Returns the number of byte written if success, or
+ *     -1 general error
+ *     -2 if the transcoding fails (for *in is not valid utf8 string or
+ *        the result of transformation can't fit into the encoding we want), or
+ */
+int
+xmlCharEncFirstLine(xmlCharEncodingHandler *handler, xmlBufferPtr out,
+                 xmlBufferPtr in) {
+    return(xmlCharEncFirstLineInt(handler, out, in, -1));
+}
+
+/**
  * xmlCharEncInFunc:
  * @handler:    char encoding transformation data structure
  * @out:  an xmlBuffer for the output.
  * @in:  an xmlBuffer for the input
- *     
+ *
  * Generic front-end for the encoding handler input function
- *     
- * Returns the number of byte written if success, or 
+ *
+ * Returns the number of byte written if success, or
  *     -1 general error
  *     -2 if the transcoding fails (for *in is not valid utf8 string or
  *        the result of transformation can't fit into the encoding we want), or
  */
 int
 xmlCharEncInFunc(xmlCharEncodingHandler * handler, xmlBufferPtr out,
                  xmlBufferPtr in)
 {
     int ret = -2;
     int written;
@@ skipping 165 matching lines @@
     toconv = in->use;
     if (toconv == 0)
         return(0);
     if (toconv * 4 >= written) {
         xmlBufferGrow(out, toconv * 4);
         written = out->size - out->use - 1;
     }
     if (handler->output != NULL) {
         ret = handler->output(&out->content[out->use], &written,
                               in->content, &toconv);
-        xmlBufferShrink(in, toconv);
-        out->use += written;
-        writtentot += written;
+        if (written > 0) {
+            xmlBufferShrink(in, toconv);
+            out->use += written;
+            writtentot += written;
+        } 
         out->content[out->use] = 0;
     }
 #ifdef LIBXML_ICONV_ENABLED
     else if (handler->iconv_out != NULL) {
         ret = xmlIconvWrapper(handler->iconv_out, &out->content[out->use],
                               &written, in->content, &toconv);
         xmlBufferShrink(in, toconv);
         out->use += written;
         writtentot += written;
         out->content[out->use] = 0;
@@ skipping 1325 matching lines @@
     xmlNewCharEncodingHandler ("ISO-8859-14", ISO8859_14ToUTF8, UTF8ToISO8859_14);
     xmlNewCharEncodingHandler ("ISO-8859-15", ISO8859_15ToUTF8, UTF8ToISO8859_15);
     xmlNewCharEncodingHandler ("ISO-8859-16", ISO8859_16ToUTF8, UTF8ToISO8859_16);
 }
 
 #endif
 #endif
 
 #define bottom_encoding
 #include "elfgcchack.h"
+