--- a/ChangeLog	Sun Feb 11 21:31:59 2007 +0000
+++ b/ChangeLog	Sun Feb 11 21:33:27 2007 +0000
@@ -1,5 +1,13 @@
 2007-02-11  Bruno Haible  <bruno@clisp.org>
 
+	Ensure O(n) worst-case complexity of mbscasestr.
+	* lib/mbscasestr.c: Include stdbool.h.
+	(knuth_morris_pratt_unibyte, knuth_morris_pratt_multibyte): New
+	functions.
+	(mbscasestr): Add some bookkeeping. Invoke knuth_morris_pratt_* when
+	the bookkeeping indicates that it's worth it.
+	* modules/mbscasestr (Depends-on): Add stdbool, mbslen, strnlen.
+
 	* modules/mbscasestr-tests: New file.
 	* tests/test-mbscasestr1.c: New file.
 	* tests/test-mbscasestr2.sh: New file.

--- a/lib/mbscasestr.c	Sun Feb 11 21:31:59 2007 +0000
+++ b/lib/mbscasestr.c	Sun Feb 11 21:33:27 2007 +0000
@@ -22,6 +22,7 @@
 #include <string.h>
 
 #include <ctype.h>
+#include <stdbool.h>
 #include <stddef.h>  /* for NULL, in case a nonstandard string.h lacks it */
 
 #if HAVE_MBRTOWC
@@ -30,6 +31,217 @@
 
 #define TOLOWER(Ch) (isupper (Ch) ? tolower (Ch) : (Ch))
 
+/* Knuth-Morris-Pratt algorithm.
+   See http://en.wikipedia.org/wiki/Knuth-Morris-Pratt_algorithm
+   Return a boolean indicating success.  */
+
+static bool
+knuth_morris_pratt_unibyte (const char *haystack, const char *needle,
+			    const char **resultp)
+{
+  size_t m = strlen (needle);
+
+  /* Allocate the table.  */
+  size_t *table = (size_t *) malloc (m * sizeof (size_t));
+  if (table == NULL)
+    return false;
+  /* Fill the table.
+     For 0 < i < m:
+       0 < table[i] <= i is defined such that
+       rhaystack[0..i-1] == needle[0..i-1] and rhaystack[i] != needle[i]
+       implies
+       forall 0 <= x < table[i]: rhaystack[x..x+m-1] != needle[0..m-1],
+       and table[i] is as large as possible with this property.
+     table[0] remains uninitialized.  */
+  {
+    size_t i, j;
+
+    table[1] = 1;
+    j = 0;
+    for (i = 2; i < m; i++)
+      {
+	unsigned char b = TOLOWER ((unsigned char) needle[i - 1]);
+
+	for (;;)
+	  {
+	    if (b == TOLOWER ((unsigned char) needle[j]))
+	      {
+		table[i] = i - ++j;
+		break;
+	      }
+	    if (j == 0)
+	      {
+		table[i] = i;
+		break;
+	      }
+	    j = j - table[j];
+	  }
+      }
+  }
+
+  /* Search, using the table to accelerate the processing.  */
+  {
+    size_t j;
+    const char *rhaystack;
+    const char *phaystack;
+
+    *resultp = NULL;
+    j = 0;
+    rhaystack = haystack;
+    phaystack = haystack;
+    /* Invariant: phaystack = rhaystack + j.  */
+    while (*phaystack != '\0')
+      if (TOLOWER ((unsigned char) needle[j])
+	  == TOLOWER ((unsigned char) *phaystack))
+	{
+	  j++;
+	  phaystack++;
+	  if (j == m)
+	    {
+	      /* The entire needle has been found.  */
+	      *resultp = rhaystack;
+	      break;
+	    }
+	}
+      else if (j > 0)
+	{
+	  /* Found a match of needle[0..j-1], mismatch at needle[j].  */
+	  rhaystack += table[j];
+	  j -= table[j];
+	}
+      else
+	{
+	  /* Found a mismatch at needle[0] already.  */
+	  rhaystack++;
+	  phaystack++;
+	}
+  }
+
+  free (table);
+  return true;
+}
+
+#if HAVE_MBRTOWC
+static bool
+knuth_morris_pratt_multibyte (const char *haystack, const char *needle,
+			      const char **resultp)
+{
+  size_t m = mbslen (needle);
+  mbchar_t *needle_mbchars;
+  size_t *table;
+
+  /* Allocate room for needle_mbchars and the table.  */
+  char *memory = (char *) malloc (m * (sizeof (mbchar_t) + sizeof (size_t)));
+  if (memory == NULL)
+    return false;
+  needle_mbchars = (mbchar_t *) memory;
+  table = (size_t *) (memory + m * sizeof (mbchar_t));
+
+  /* Fill needle_mbchars.  */
+  {
+    mbui_iterator_t iter;
+    size_t j;
+
+    j = 0;
+    for (mbui_init (iter, needle); mbui_avail (iter); mbui_advance (iter), j++)
+      {
+	mb_copy (&needle_mbchars[j], &mbui_cur (iter));
+	if (needle_mbchars[j].wc_valid)
+	  needle_mbchars[j].wc = towlower (needle_mbchars[j].wc);
+      }
+  }
+
+  /* Fill the table.
+     For 0 < i < m:
+       0 < table[i] <= i is defined such that
+       rhaystack[0..i-1] == needle[0..i-1] and rhaystack[i] != needle[i]
+       implies
+       forall 0 <= x < table[i]: rhaystack[x..x+m-1] != needle[0..m-1],
+       and table[i] is as large as possible with this property.
+     table[0] remains uninitialized.  */
+  {
+    size_t i, j;
+
+    table[1] = 1;
+    j = 0;
+    for (i = 2; i < m; i++)
+      {
+	mbchar_t *b = &needle_mbchars[i - 1];
+
+	for (;;)
+	  {
+	    if (mb_equal (*b, needle_mbchars[j]))
+	      {
+		table[i] = i - ++j;
+		break;
+	      }
+	    if (j == 0)
+	      {
+		table[i] = i;
+		break;
+	      }
+	    j = j - table[j];
+	  }
+      }
+  }
+
+  /* Search, using the table to accelerate the processing.  */
+  {
+    size_t j;
+    mbui_iterator_t rhaystack;
+    mbui_iterator_t phaystack;
+
+    *resultp = NULL;
+    j = 0;
+    mbui_init (rhaystack, haystack);
+    mbui_init (phaystack, haystack);
+    /* Invariant: phaystack = rhaystack + j.  */
+    while (mbui_avail (phaystack))
+      {
+	mbchar_t c;
+
+	mb_copy (&c, &mbui_cur (phaystack));
+	if (c.wc_valid)
+	  c.wc = towlower (c.wc);
+	if (mb_equal (needle_mbchars[j], c))
+	  {
+	    j++;
+	    mbui_advance (phaystack);
+	    if (j == m)
+	      {
+		/* The entire needle has been found.  */
+		*resultp = mbui_cur_ptr (rhaystack);
+		break;
+	      }
+	  }
+	else if (j > 0)
+	  {
+	    /* Found a match of needle[0..j-1], mismatch at needle[j].  */
+	    size_t count = table[j];
+	    j -= count;
+	    for (; count > 0; count--)
+	      {
+		if (!mbui_avail (rhaystack))
+		  abort ();
+		mbui_advance (rhaystack);
+	      }
+	  }
+	else
+	  {
+	    /* Found a mismatch at needle[0] already.  */
+	    if (!mbui_avail (rhaystack))
+	      abort ();
+	    mbui_advance (rhaystack);
+	    mbui_advance (phaystack);
+	  }
+      }
+  }
+
+  free (memory);
+  return true;
+}
+#endif
+
 /* Find the first occurrence of the character string NEEDLE in the character
    string HAYSTACK, using case-insensitive comparison.
    Note: This function may, in multibyte locales, return success even if
@@ -50,9 +262,31 @@
       mbui_init (iter_needle, needle);
       if (mbui_avail (iter_needle))
 	{
+	  /* Minimizing the worst-case complexity:
+	     Let n = mbslen(haystack), m = mbslen(needle).
+	     The naïve algorithm is O(n*m) worst-case.
+	     The Knuth-Morris-Pratt algorithm is O(n) worst-case but it needs a
+	     memory allocation.
+	     To achieve linear complexity and yet amortize the cost of the
+	     memory allocation, we activate the Knuth-Morris-Pratt algorithm
+	     only once the naïve algorithm has already run for some time; more
+	     precisely, when
+	       - the outer loop count is >= 10,
+	       - the average number of comparisons per outer loop is >= 5,
+	       - the total number of comparisons is >= m.
+	     But we try it only once.  If the memory allocation attempt failed,
+	     we don't retry it.  */
+	  bool try_kmp = true;
+	  size_t outer_loop_count = 0;
+	  size_t comparison_count = 0;
+	  size_t last_ccount = 0;		   /* last comparison count */
+	  mbui_iterator_t iter_needle_last_ccount; /* = needle + last_ccount */
+
 	  mbchar_t b;
 	  mbui_iterator_t iter_haystack;
 
+	  mbui_init (iter_needle_last_ccount, needle);
+
 	  mb_copy (&b, &mbui_cur (iter_needle));
 	  if (b.wc_valid)
 	    b.wc = towlower (b.wc);
@@ -66,6 +300,35 @@
 		/* No match.  */
 		return NULL;
 
+	      /* See whether it's advisable to use an asymptotically faster
+		 algorithm.  */
+	      if (try_kmp
+		  && outer_loop_count >= 10
+		  && comparison_count >= 5 * outer_loop_count)
+		{
+		  /* See if needle + comparison_count now reaches the end of
+		     needle.  */
+		  size_t count = comparison_count - last_ccount;
+		  for (;
+		       count > 0 && mbui_avail (iter_needle_last_ccount);
+		       count--)
+		    mbui_advance (iter_needle_last_ccount);
+		  last_ccount = comparison_count;
+		  if (!mbui_avail (iter_needle_last_ccount))
+		    {
+		      /* Try the Knuth-Morris-Pratt algorithm.  */
+		      const char *result;
+		      bool success =
+			knuth_morris_pratt_multibyte (haystack, needle,
+						      &result);
+		      if (success)
+			return (char *) result;
+		      try_kmp = false;
+		    }
+		}
+
+	      outer_loop_count++;
+	      comparison_count++;
 	      mb_copy (&c, &mbui_cur (iter_haystack));
 	      if (c.wc_valid)
 		c.wc = towlower (c.wc);
@@ -91,6 +354,7 @@
 		      if (!mbui_avail (rhaystack))
 			/* No match.  */
 			return NULL;
+		      comparison_count++;
 		      if (!mb_caseequal (mbui_cur (rhaystack),
 					 mbui_cur (rneedle)))
 			/* Nothing in this round.  */
@@ -107,6 +371,26 @@
     {
       if (*needle != '\0')
 	{
+	  /* Minimizing the worst-case complexity:
+	     Let n = strlen(haystack), m = strlen(needle).
+	     The naïve algorithm is O(n*m) worst-case.
+	     The Knuth-Morris-Pratt algorithm is O(n) worst-case but it needs a
+	     memory allocation.
+	     To achieve linear complexity and yet amortize the cost of the
+	     memory allocation, we activate the Knuth-Morris-Pratt algorithm
+	     only once the naïve algorithm has already run for some time; more
+	     precisely, when
+	       - the outer loop count is >= 10,
+	       - the average number of comparisons per outer loop is >= 5,
+	       - the total number of comparisons is >= m.
+	     But we try it only once.  If the memory allocation attempt failed,
+	     we don't retry it.  */
+	  bool try_kmp = true;
+	  size_t outer_loop_count = 0;
+	  size_t comparison_count = 0;
+	  size_t last_ccount = 0;		   /* last comparison count */
+	  const char *needle_last_ccount = needle; /* = needle + last_ccount */
+
 	  /* Speed up the following searches of needle by caching its first
 	     character.  */
 	  unsigned char b = TOLOWER ((unsigned char) *needle);
@@ -117,6 +401,39 @@
 	      if (*haystack == '\0')
 		/* No match.  */
 		return NULL;
+
+	      /* See whether it's advisable to use an asymptotically faster
+		 algorithm.  */
+	      if (try_kmp
+		  && outer_loop_count >= 10
+		  && comparison_count >= 5 * outer_loop_count)
+		{
+		  /* See if needle + comparison_count now reaches the end of
+		     needle.  */
+		  if (needle_last_ccount != NULL)
+		    {
+		      needle_last_ccount +=
+			strnlen (needle_last_ccount,
+				 comparison_count - last_ccount);
+		      if (*needle_last_ccount == '\0')
+			needle_last_ccount = NULL;
+		      last_ccount = comparison_count;
+		    }
+		  if (needle_last_ccount == NULL)
+		    {
+		      /* Try the Knuth-Morris-Pratt algorithm.  */
+		      const char *result;
+		      bool success =
+			knuth_morris_pratt_unibyte (haystack, needle - 1,
+						    &result);
+		      if (success)
+			return (char *) result;
+		      try_kmp = false;
+		    }
+		}
+
+	      outer_loop_count++;
+	      comparison_count++;
 	      if (TOLOWER ((unsigned char) *haystack) == b)
 		/* The first character matches.  */
 		{
@@ -131,6 +448,7 @@
 		      if (*rhaystack == '\0')
 			/* No match.  */
 			return NULL;
+		      comparison_count++;
 		      if (TOLOWER ((unsigned char) *rhaystack)
 			  != TOLOWER ((unsigned char) *rneedle))
 			/* Nothing in this round.  */

--- a/modules/mbscasestr	Sun Feb 11 21:31:59 2007 +0000
+++ b/modules/mbscasestr	Sun Feb 11 21:33:27 2007 +0000
@@ -8,7 +8,10 @@
 
 Depends-on:
 mbuiter
+stdbool
 string
+mbslen
+strnlen
 
 configure.ac:
 gl_FUNC_MBSCASESTR