Upgrade to libxml 2.9.2 and libxslt 1.1.28

third_party/libxslt/libexslt/strings.c

 #define IN_LIBEXSLT
 #include "libexslt/libexslt.h"
 
 #if defined(WIN32) && !defined (__CYGWIN__) && (!__MINGW32__)
 #include <win32config.h>
 #else
 #include "config.h"
 #endif
 
 #include <libxml/tree.h>
 #include <libxml/xpath.h>
 #include <libxml/xpathInternals.h>
 #include <libxml/parser.h>
 #include <libxml/encoding.h>
 #include <libxml/uri.h>
 
 #include <libxslt/xsltconfig.h>
 #include <libxslt/xsltutils.h>
 #include <libxslt/xsltInternals.h>
 #include <libxslt/extensions.h>
 
 #include "exslt.h"
 
 /**
  * exsltStrTokenizeFunction:
  * @ctxt: an XPath parser context
  * @nargs: the number of arguments
  *
  * Splits up a string on the characters of the delimiter string and returns a
- * node set of token elements, each containing one token from the string. 
+ * node set of token elements, each containing one token from the string.
  */
 static void
 exsltStrTokenizeFunction(xmlXPathParserContextPtr ctxt, int nargs)
 {
     xsltTransformContextPtr tctxt;
     xmlChar *str, *delimiters, *cur;
     const xmlChar *token, *delimiter;
     xmlNodePtr node;
     xmlDocPtr container;
     xmlXPathObjectPtr ret = NULL;
@@ skipping 58 matching lines @@
                                            (const xmlChar *) "token", token);
                         xmlAddChild((xmlNodePtr) container, node);
                         xmlXPathNodeSetAddUnique(ret->nodesetval, node);
                         *cur = *delimiter; /* restore the changed byte */
                         token = cur + clen;
                         break;
                     }
                 }
             }
             if (token != cur) {
-                node = xmlNewDocRawNode(container, NULL,
+                node = xmlNewDocRawNode(container, NULL,
                                     (const xmlChar *) "token", token);
                 xmlAddChild((xmlNodePtr) container, node);
                 xmlXPathNodeSetAddUnique(ret->nodesetval, node);
             }
             /*
              * Mark it as a function result in order to avoid garbage
              * collecting of tree fragments
              */
             xsltExtensionInstructionResultRegister(tctxt, ret);
         }
     }
 
 fail:
     if (str != NULL)
         xmlFree(str);
     if (delimiters != NULL)
         xmlFree(delimiters);
     if (ret != NULL)
         valuePush(ctxt, ret);
     else
         valuePush(ctxt, xmlXPathNewNodeSet(NULL));
 }
 
 /**
  * exsltStrSplitFunction:
  * @ctxt: an XPath parser context
  * @nargs: the number of arguments
  *
  * Splits up a string on a delimiting string and returns a node set of token
- * elements, each containing one token from the string. 
+ * elements, each containing one token from the string.
  */
 static void
 exsltStrSplitFunction(xmlXPathParserContextPtr ctxt, int nargs) {
     xsltTransformContextPtr tctxt;
     xmlChar *str, *delimiter, *cur;
     const xmlChar *token;
     xmlNodePtr node;
     xmlDocPtr container;
     xmlXPathObjectPtr ret = NULL;
     int delimiterLength;
@@ skipping 178 matching lines @@
 
     ret = (xmlChar *) xmlURIUnescapeString((const char *)str,0,NULL);
     if (!xmlCheckUTF8(ret)) {
         /* FIXME: instead of throwing away the whole URI, we should
         only discard the invalid sequence(s). How to do that? */
         xmlXPathReturnEmptyString(ctxt);
         xmlFree(str);
         xmlFree(ret);
         return;
     }
-    
+
     xmlXPathReturnString(ctxt, ret);
 
     if (str != NULL)
         xmlFree(str);
 }
 
 /**
  * exsltStrPaddingFunction:
  * @ctxt: an XPath parser context
  * @nargs: the number of arguments
  *
  * Creates a padding string of a certain length.
  */
 static void
 exsltStrPaddingFunction (xmlXPathParserContextPtr ctxt, int nargs) {
-    int number, str_len = 0;
-    xmlChar *str = NULL, *ret = NULL, *tmp;
+    int number, str_len = 0, str_size = 0;
+    xmlChar *str = NULL, *ret = NULL;
 
     if ((nargs < 1) || (nargs > 2)) {
         xmlXPathSetArityError(ctxt);
         return;
     }
 
     if (nargs == 2) {
         str = xmlXPathPopString(ctxt);
         str_len = xmlUTF8Strlen(str);
+        str_size = xmlStrlen(str);
     }
     if (str_len == 0) {
         if (str != NULL) xmlFree(str);
         str = xmlStrdup((const xmlChar *) " ");
         str_len = 1;
+        str_size = 1;
     }
 
     number = (int) xmlXPathPopNumber(ctxt);
 
     if (number <= 0) {
         xmlXPathReturnEmptyString(ctxt);
         xmlFree(str);
         return;
     }
 
     while (number >= str_len) {
-        ret = xmlStrncat(ret, str, str_len);
+        ret = xmlStrncat(ret, str, str_size);
         number -= str_len;
     }
-    tmp = xmlUTF8Strndup (str, number);
-    ret = xmlStrcat(ret, tmp);
-    if (tmp != NULL)
-        xmlFree (tmp);
+    if (number > 0) {
+        str_size = xmlUTF8Strsize(str, number);
+        ret = xmlStrncat(ret, str, str_size);
+    }
 
     xmlXPathReturnString(ctxt, ret);
 
     if (str != NULL)
         xmlFree(str);
 }
 
 /**
  * exsltStrAlignFunction:
  * @ctxt: an XPath parser context
@@ skipping 40 matching lines @@
             int right_start;
 
             ret = xmlUTF8Strndup (padding, left);
             ret = xmlStrcat (ret, str);
 
             right_start = xmlUTF8Strsize (padding, left + str_l);
             ret = xmlStrcat (ret, padding + right_start);
         } else {
             int str_s;
 
-            str_s = xmlStrlen (str);
+            str_s = xmlUTF8Strsize(padding, str_l);
             ret = xmlStrdup (str);
             ret = xmlStrcat (ret, padding + str_s);
         }
     }
 
     xmlXPathReturnString (ctxt, ret);
 
     xmlFree(str);
     xmlFree(padding);
     xmlFree(alignment);
@@ skipping 39 matching lines @@
 
         xmlFree(tmp);
     }
 
     xmlXPathFreeObject (obj);
 
     xmlXPathReturnString(ctxt, ret);
 }
 
 /**
- * exsltStrReplaceInternal:
- * @str: string to modify
- * @searchStr: string to find
- * @replaceStr: string to replace occurrences of searchStr
+ * exsltStrReturnString:
+ * @ctxt: an XPath parser context
+ * @str: a string
+ * @len: length of string
  *
- * Search and replace string function used by exsltStrReplaceFunction
+ * Returns a string as a node set.
  */
-static xmlChar*
-exsltStrReplaceInternal(const xmlChar* str, const xmlChar* searchStr, 
-                        const xmlChar* replaceStr)
+static int
+exsltStrReturnString(xmlXPathParserContextPtr ctxt, const xmlChar *str,
+                     int len)
 {
-    const xmlChar *curr, *next;
-    xmlChar *ret = NULL;
-    int searchStrSize;
-
-    curr = str;
-    searchStrSize = xmlStrlen(searchStr);
-
-    do {
-      next = xmlStrstr(curr, searchStr);
-      if (next == NULL) {
-        ret = xmlStrcat (ret, curr);
-        break;
-      }
-
-      ret = xmlStrncat (ret, curr, next - curr);
-      ret = xmlStrcat (ret, replaceStr);
-      curr = next + searchStrSize;
-    } while (*curr != 0);
-
-    return ret;
+    xsltTransformContextPtr tctxt = xsltXPathGetTransformContext(ctxt);
+    xmlDocPtr container;
+    xmlNodePtr text_node;
+    xmlXPathObjectPtr ret;
+
+    container = xsltCreateRVT(tctxt);
+    if (container == NULL) {
+        xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
+        return(-1);
+    }
+    xsltRegisterLocalRVT(tctxt, container);
+
+    text_node = xmlNewTextLen(str, len);
+    if (text_node == NULL) {
+        xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
+        return(-1);
+    }
+    xmlAddChild((xmlNodePtr) container, text_node);
+
+    ret = xmlXPathNewNodeSet(text_node);
+    if (ret == NULL) {
+        xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
+        return(-1);
+    }
+
+    xsltExtensionInstructionResultRegister(tctxt, ret);
+    valuePush(ctxt, ret);
+
+    return(0);
 }
+
 /**
  * exsltStrReplaceFunction:
  * @ctxt: an XPath parser context
  * @nargs: the number of arguments
  *
- * Takes a string, and two node sets and returns the string with all strings in 
+ * Takes a string, and two node sets and returns the string with all strings in
  * the first node set replaced by all strings in the second node set.
  */
 static void
 exsltStrReplaceFunction (xmlXPathParserContextPtr ctxt, int nargs) {
-    xmlChar *str = NULL, *searchStr = NULL, *replaceStr = NULL;
-    xmlNodeSetPtr replaceSet = NULL, searchSet = NULL;
-    xmlChar *ret = NULL, *retSwap = NULL;
-    int i;
+    int i, i_empty, n, slen0, rlen0, *slen, *rlen;
+    void *mem = NULL;
+    const xmlChar *src, *start;
+    xmlChar *string, *search_str = NULL, *replace_str = NULL;
+    xmlChar **search, **replace;
+    xmlNodeSetPtr search_set = NULL, replace_set = NULL;
+    xmlBufferPtr buf;
 
     if (nargs  != 3) {
-      xmlXPathSetArityError(ctxt);
-      return;
-    }
-
-    /* pull out replace argument */
+        xmlXPathSetArityError(ctxt);
+        return;
+    }
+
+    /* get replace argument */
+
+    if (!xmlXPathStackIsNodeSet(ctxt))
+        replace_str = xmlXPathPopString(ctxt);
+    else
+        replace_set = xmlXPathPopNodeSet(ctxt);
+
+    if (xmlXPathCheckError(ctxt))
+        goto fail_replace;
+
+    /* get search argument */
+
     if (!xmlXPathStackIsNodeSet(ctxt)) {
-      replaceStr = xmlXPathPopString(ctxt);
-    }
-                else {
-      replaceSet = xmlXPathPopNodeSet(ctxt);
-      if (xmlXPathCheckError(ctxt)) {
-        xmlXPathSetTypeError(ctxt);
-        goto fail;
-      }
-    }
-
-    /* behavior driven by search argument from here on */
-    if (!xmlXPathStackIsNodeSet(ctxt)) {
-      searchStr = xmlXPathPopString(ctxt);
-      str = xmlXPathPopString(ctxt);
-
-      if (replaceStr == NULL) {
-        xmlXPathSetTypeError(ctxt);
-        goto fail;
-      }
-
-      ret = exsltStrReplaceInternal(str, searchStr, replaceStr);
-    }
-                else {
-      searchSet = xmlXPathPopNodeSet(ctxt);
-      if (searchSet == NULL || xmlXPathCheckError(ctxt)) {
-        xmlXPathSetTypeError(ctxt);
-        goto fail;
-      }
-
-      str = xmlXPathPopString(ctxt);
-      ret = xmlStrdup(str);
-
-      for (i = 0; i < searchSet->nodeNr; i++) {
-        searchStr = xmlXPathCastNodeToString(searchSet->nodeTab[i]);
-
-        if (replaceSet != NULL) {
-          replaceStr = NULL;
-          if (i < replaceSet->nodeNr) {
-            replaceStr = xmlXPathCastNodeToString(replaceSet->nodeTab[i]);
-          }
-
-          retSwap = exsltStrReplaceInternal(ret, searchStr, replaceStr);
-          
-          if (replaceStr != NULL) {
-            xmlFree(replaceStr);
-            replaceStr = NULL;
-          }
+        search_str = xmlXPathPopString(ctxt);
+        n = 1;
+    }
+    else {
+        search_set = xmlXPathPopNodeSet(ctxt);
+        n = search_set != NULL ? search_set->nodeNr : 0;
+    }
+
+    if (xmlXPathCheckError(ctxt))
+        goto fail_search;
+
+    /* get string argument */
+
+    string = xmlXPathPopString(ctxt);
+    if (xmlXPathCheckError(ctxt))
+        goto fail_string;
+
+    /* check for empty search node list */
+
+    if (n <= 0) {
+        exsltStrReturnString(ctxt, string, xmlStrlen(string));
+        goto done_empty_search;
+    }
+
+    /* allocate memory for string pointer and length arrays */
+
+    if (n == 1) {
+        search = &search_str;
+        replace = &replace_str;
+        slen = &slen0;
+        rlen = &rlen0;
+    }
+    else {
+        mem = xmlMalloc(2 * n * (sizeof(const xmlChar *) + sizeof(int)));
+        if (mem == NULL) {
+            xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
+            goto fail_malloc;
+        }
+        search = (xmlChar **) mem;
+        replace = search + n;
+        slen = (int *) (replace + n);
+        rlen = slen + n;
+    }
+
+    /* process arguments */
+
+    i_empty = -1;
+
+    for (i=0; i<n; ++i) {
+        if (search_set != NULL) {
+            search[i] = xmlXPathCastNodeToString(search_set->nodeTab[i]);
+            if (search[i] == NULL) {
+                n = i;
+                goto fail_process_args;
+            }
+        }
+
+        slen[i] = xmlStrlen(search[i]);
+        if (i_empty < 0 && slen[i] == 0)
+            i_empty = i;
+
+        if (replace_set != NULL) {
+            if (i < replace_set->nodeNr) {
+                replace[i] = xmlXPathCastNodeToString(replace_set->nodeTab[i]);
+                if (replace[i] == NULL) {
+                    n = i + 1;
+                    goto fail_process_args;
+                }
+            }
+            else
+                replace[i] = NULL;
         }
         else {
-          retSwap = exsltStrReplaceInternal(ret, searchStr, replaceStr);
-        }
-
-                                xmlFree(ret);
-        if (searchStr != NULL) {
-          xmlFree(searchStr);
-          searchStr = NULL;
-        }
-
-                                ret = retSwap;
-                        }
-
-      if (replaceSet != NULL)
-        xmlXPathFreeNodeSet(replaceSet);
-
-      if (searchSet != NULL)
-        xmlXPathFreeNodeSet(searchSet);
-                }
-
-    xmlXPathReturnString(ctxt, ret);
-
- fail:
-    if (replaceStr != NULL)
-      xmlFree(replaceStr);
-
-    if (searchStr != NULL)
-      xmlFree(searchStr);
-
-    if (str != NULL)
-      xmlFree(str);
+            if (i == 0)
+                replace[i] = replace_str;
+            else
+                replace[i] = NULL;
+        }
+
+        if (replace[i] == NULL)
+            rlen[i] = 0;
+        else
+            rlen[i] = xmlStrlen(replace[i]);
+    }
+
+    if (i_empty >= 0 && rlen[i_empty] == 0)
+        i_empty = -1;
+
+    /* replace operation */
+
+    buf = xmlBufferCreate();
+    if (buf == NULL) {
+        xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
+        goto fail_buffer;
+    }
+    src = string;
+    start = string;
+
+    while (*src != 0) {
+        int max_len = 0, i_match = 0;
+
+        for (i=0; i<n; ++i) {
+            if (*src == search[i][0] &&
+                slen[i] > max_len &&
+                xmlStrncmp(src, search[i], slen[i]) == 0)
+            {
+                i_match = i;
+                max_len = slen[i];
+            }
+        }
+
+        if (max_len == 0) {
+            if (i_empty >= 0 && start < src) {
+                if (xmlBufferAdd(buf, start, src - start) ||
+                    xmlBufferAdd(buf, replace[i_empty], rlen[i_empty]))
+                {
+                    xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
+                    goto fail_buffer_add;
+                }
+                start = src;
+            }
+
+            src += xmlUTF8Size(src);
+        }
+        else {
+            if ((start < src &&
+                 xmlBufferAdd(buf, start, src - start)) ||
+                (rlen[i_match] &&
+                 xmlBufferAdd(buf, replace[i_match], rlen[i_match])))
+            {
+                xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
+                goto fail_buffer_add;
+            }
+
+            src += slen[i_match];
+            start = src;
+        }
+    }
+
+    if (start < src && xmlBufferAdd(buf, start, src - start)) {
+        xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
+        goto fail_buffer_add;
+    }
+
+    /* create result node set */
+
+    exsltStrReturnString(ctxt, xmlBufferContent(buf), xmlBufferLength(buf));
+
+    /* clean up */
+
+fail_buffer_add:
+    xmlBufferFree(buf);
+
+fail_buffer:
+fail_process_args:
+    if (search_set != NULL) {
+        for (i=0; i<n; ++i)
+            xmlFree(search[i]);
+    }
+    if (replace_set != NULL) {
+        for (i=0; i<n; ++i) {
+            if (replace[i] != NULL)
+                xmlFree(replace[i]);
+        }
+    }
+
+    if (mem != NULL)
+        xmlFree(mem);
+
+fail_malloc:
+done_empty_search:
+    xmlFree(string);
+
+fail_string:
+    if (search_set != NULL)
+        xmlXPathFreeNodeSet(search_set);
+    else
+        xmlFree(search_str);
+
+fail_search:
+    if (replace_set != NULL)
+        xmlXPathFreeNodeSet(replace_set);
+    else
+        xmlFree(replace_str);
+
+fail_replace:
+    return;
 }
 
 /**
  * exsltStrRegister:
  *
  * Registers the EXSLT - Strings module
  */
 
 void
 exsltStrRegister (void) {
@@ skipping 48 matching lines @@
                                    (const xmlChar *) "padding",
                                    (const xmlChar *) EXSLT_STRINGS_NAMESPACE,
                                    exsltStrPaddingFunction)
         && !xmlXPathRegisterFuncNS(ctxt,
                                    (const xmlChar *) "align",
                                    (const xmlChar *) EXSLT_STRINGS_NAMESPACE,
                                    exsltStrAlignFunction)
         && !xmlXPathRegisterFuncNS(ctxt,
                                    (const xmlChar *) "concat",
                                    (const xmlChar *) EXSLT_STRINGS_NAMESPACE,
-                                   exsltStrConcatFunction)
-        && !xmlXPathRegisterFuncNS(ctxt,
-                                   (const xmlChar *) "replace",
-                                   (const xmlChar *) EXSLT_STRINGS_NAMESPACE,
-                                   exsltStrReplaceFunction)) {
+                                   exsltStrConcatFunction)) {
         return 0;
     }
     return -1;
 }