Upgrade to libxml 2.9.2 and libxslt 1.1.28

third_party/libxml/src/xmlstring.c

 /*
  * string.c : an XML string utilities module
  *
  * This module provides various utility functions for manipulating
  * the xmlChar* type. All functions named xmlStr* have been moved here
- * from the parser.c file (their original home). 
+ * from the parser.c file (their original home).
  *
  * See Copyright for the status of this software.
  *
  * UTF8 string routines from:
  * William Brack <wbrack@mmm.com.hk>
  *
  * daniel@veillard.com
  */
 
 #define IN_LIBXML
@@ skipping 16 matching lines @@
  * @cur:  the input xmlChar *
  * @len:  the len of @cur
  *
  * a strndup for array of xmlChar's
  *
  * Returns a new xmlChar * or NULL
  */
 xmlChar *
 xmlStrndup(const xmlChar *cur, int len) {
     xmlChar *ret;
-    
+
     if ((cur == NULL) || (len < 0)) return(NULL);
     ret = (xmlChar *) xmlMallocAtomic((len + 1) * sizeof(xmlChar));
     if (ret == NULL) {
         xmlErrMemory(NULL, NULL);
         return(NULL);
     }
     memcpy(ret, cur, len * sizeof(xmlChar));
     ret[len] = 0;
     return(ret);
 }
@@ skipping 24 matching lines @@
  *
  * a strndup for char's to xmlChar's
  *
  * Returns a new xmlChar * or NULL
  */
 
 xmlChar *
 xmlCharStrndup(const char *cur, int len) {
     int i;
     xmlChar *ret;
-    
+
     if ((cur == NULL) || (len < 0)) return(NULL);
     ret = (xmlChar *) xmlMallocAtomic((len + 1) * sizeof(xmlChar));
     if (ret == NULL) {
         xmlErrMemory(NULL, NULL);
         return(NULL);
     }
     for (i = 0;i < len;i++) {
         ret[i] = (xmlChar) cur[i];
         if (ret[i] == 0) return(ret);
     }
@@ skipping 64 matching lines @@
     } while (*str2++);
     return(1);
 }
 
 /**
  * xmlStrQEqual:
  * @pref:  the prefix of the QName
  * @name:  the localname of the QName
  * @str:  the second xmlChar *
  *
- * Check if a QName is Equal to a given string 
+ * Check if a QName is Equal to a given string
  *
  * Returns 1 if they are equal, 0 if they are different
  */
 
 int
 xmlStrQEqual(const xmlChar *pref, const xmlChar *name, const xmlChar *str) {
     if (pref == NULL) return(xmlStrEqual(name, str));
     if (name == NULL) return(0);
     if (str == NULL) return(0);
 
@@ skipping 149 matching lines @@
  * @val:  the xmlChar to search (needle)
  *
  * a strstr for xmlChar's
  *
  * Returns the xmlChar * for the first occurrence or NULL.
  */
 
 const xmlChar *
 xmlStrstr(const xmlChar *str, const xmlChar *val) {
     int n;
-    
+
     if (str == NULL) return(NULL);
     if (val == NULL) return(NULL);
     n = xmlStrlen(val);
 
     if (n == 0) return(str);
     while (*str != 0) { /* non input consuming */
         if (*str == *val) {
             if (!xmlStrncmp(str, val, n)) return((const xmlChar *) str);
         }
         str++;
     }
     return(NULL);
 }
 
 /**
  * xmlStrcasestr:
  * @str:  the xmlChar * array (haystack)
  * @val:  the xmlChar to search (needle)
  *
  * a case-ignoring strstr for xmlChar's
  *
  * Returns the xmlChar * for the first occurrence or NULL.
  */
 
 const xmlChar *
 xmlStrcasestr(const xmlChar *str, const xmlChar *val) {
     int n;
-    
+
     if (str == NULL) return(NULL);
     if (val == NULL) return(NULL);
     n = xmlStrlen(val);
 
     if (n == 0) return(str);
     while (*str != 0) { /* non input consuming */
         if (casemap[*str] == casemap[*val])
             if (!xmlStrncasecmp(str, val, n)) return(str);
         str++;
     }
     return(NULL);
 }
 
 /**
  * xmlStrsub:
  * @str:  the xmlChar * array (haystack)
  * @start:  the index of the first char (zero based)
  * @len:  the length of the substring
  *
  * Extract a substring of a given string
  *
  * Returns the xmlChar * for the first occurrence or NULL.
  */
 
 xmlChar *
 xmlStrsub(const xmlChar *str, int start, int len) {
     int i;
-    
+
     if (str == NULL) return(NULL);
     if (start < 0) return(NULL);
     if (len < 0) return(NULL);
 
     for (i = 0;i < start;i++) {
         if (*str == 0) return(NULL);
         str++;
     }
     if (*str == 0) return(NULL);
     return(xmlStrndup(str, len));
@@ skipping 102 matching lines @@
  * encoded in UTF-8 or an encoding with 8bit based chars, we assume
  * a termination mark of '0'.
  *
  * Returns a new xmlChar * containing the concatenated string.
  */
 xmlChar *
 xmlStrcat(xmlChar *cur, const xmlChar *add) {
     const xmlChar *p = add;
 
     if (add == NULL) return(cur);
-    if (cur == NULL) 
+    if (cur == NULL)
         return(xmlStrdup(add));
 
     while (*p != 0) p++; /* non input consuming */
     return(xmlStrncat(cur, add, p - add));
 }
 
 /**
  * xmlStrPrintf:
  * @buf:   the result buffer.
  * @len:   the result buffer length.
  * @msg:   the message with printf formatting.
  * @...:   extra parameters for the message.
  *
  * Formats @msg and places result into @buf.
  *
  * Returns the number of characters written to @buf or -1 if an error occurs.
  */
-int XMLCDECL 
+int XMLCDECL
 xmlStrPrintf(xmlChar *buf, int len, const xmlChar *msg, ...) {
     va_list args;
     int ret;
-    
+
     if((buf == NULL) || (msg == NULL)) {
         return(-1);
     }
-    
+
     va_start(args, msg);
     ret = vsnprintf((char *) buf, len, (const char *) msg, args);
     va_end(args);
     buf[len - 1] = 0; /* be safe ! */
-    
+
     return(ret);
 }
 
 /**
  * xmlStrVPrintf:
  * @buf:   the result buffer.
  * @len:   the result buffer length.
  * @msg:   the message with printf formatting.
  * @ap:    extra parameters for the message.
  *
  * Formats @msg and places result into @buf.
  *
  * Returns the number of characters written to @buf or -1 if an error occurs.
  */
-int 
+int
 xmlStrVPrintf(xmlChar *buf, int len, const xmlChar *msg, va_list ap) {
     int ret;
-    
+
     if((buf == NULL) || (msg == NULL)) {
         return(-1);
     }
-    
+
     ret = vsnprintf((char *) buf, len, (const char *) msg, ap);
     buf[len - 1] = 0; /* be safe ! */
-    
+
     return(ret);
 }
 
 /************************************************************************
  *                                                                      *
  *              Generic UTF8 handling routines                          *
  *                                                                      *
  * From rfc2044: encoding of the Unicode values on UTF-8:               *
  *                                                                      *
  * UCS-4 range (hex.)           UTF-8 octet sequence (binary)           *
@@ skipping 262 matching lines @@
  * @len:  the len of @utf (in chars)
  *
  * a strndup for array of UTF8's
  *
  * Returns a new UTF8 * or NULL
  */
 xmlChar *
 xmlUTF8Strndup(const xmlChar *utf, int len) {
     xmlChar *ret;
     int i;
-    
+
     if ((utf == NULL) || (len < 0)) return(NULL);
     i = xmlUTF8Strsize(utf, len);
     ret = (xmlChar *) xmlMallocAtomic((i + 1) * sizeof(xmlChar));
     if (ret == NULL) {
         xmlGenericError(xmlGenericErrorContext,
                 "malloc of %ld byte failed\n",
                 (len + 1) * (long)sizeof(xmlChar));
         return(NULL);
     }
     memcpy(ret, utf, i * sizeof(xmlChar));
@@ skipping 103 matching lines @@
                 if ( (*utf++ & 0xc0) != 0x80 )
                     return(NULL);
         }
     }
 
     return(xmlUTF8Strndup(utf, len));
 }
 
 #define bottom_xmlstring
 #include "elfgcchack.h"