X-Git-Url: http://erislabs.net/gitweb/?a=blobdiff_plain;f=lib%2Fmemcoll.c;h=e5ef36397b6a5af2b9361ff71fb42064c2e25947;hb=53ed71f6a1cc4207b1972b73e4b5e1e830c8119d;hp=11a61ad60c5535ba065fea018d76da7a8f24abb4;hpb=8b13b4035ef3cd79149f4a555a84ac632aa73e03;p=gnulib.git

diff --git a/lib/memcoll.c b/lib/memcoll.c
index 11a61ad60..e5ef36397 100644
--- a/lib/memcoll.c
+++ b/lib/memcoll.c
@@ -1,5 +1,6 @@
 /* Locale-specific memory comparison.
-   Copyright 1999 Free Software Foundation, Inc.
+
+   Copyright (C) 1999, 2002, 2003, 2004, 2006 Free Software Foundation, Inc.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -13,96 +14,83 @@
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software Foundation,
-   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+   Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
 
 /* Contributed by Paul Eggert <eggert@twinsun.com>.  */
 
-#if HAVE_CONFIG_H
-# include <config.h>
-#endif
+#include <config.h>
 
-#ifndef __GNUC__
-# ifdef HAVE_ALLOCA_H
-#  include <alloca.h>
-# else
-#  ifdef _AIX
- #  pragma alloca
-#  else
-#   ifdef _WIN32
-#    include <malloc.h>
-#    include <io.h>
-#   else
-#    ifndef alloca
-char *alloca ();
-#    endif
-#   endif
-#  endif
-# endif
-#endif
+#include "memcoll.h"
 
-#if HAVE_STRING_H
-# include <string.h>
-#endif
+#include <errno.h>
+#include <string.h>
 
 /* Compare S1 (with length S1LEN) and S2 (with length S2LEN) according
-   to the LC_COLLATE locale.  S1 and S2 do not overlap, but may be
-   adjacent.  Temporarily modify the bytes after S1 and S2, but
-   restore their original contents before returning.  */
+   to the LC_COLLATE locale.  S1 and S2 do not overlap, and are not
+   adjacent.  Perhaps temporarily modify the bytes after S1 and S2,
+   but restore their original contents before returning.  Set errno to an
+   error number if there is an error, and to zero otherwise.  */
 int
 memcoll (char *s1, size_t s1len, char *s2, size_t s2len)
 {
   int diff;
-  char n1;
-  char n2;
 
-  /* We will temporarily set the bytes after S1 and S2 to zero, so if
-     S1 and S2 are adjacent, compare to a temporary copy of the
-     earlier, to avoid temporarily stomping on the later.  */
+#if HAVE_STRCOLL
 
-  if (s1 + s1len == s2)
-    {
-      char *s2copy = alloca (s2len + 1);
-      memcpy (s2copy, s2, s2len);
-      s2 = s2copy;
-    }
+  /* strcoll is slow on many platforms, so check for the common case
+     where the arguments are bytewise equal.  Otherwise, walk through
+     the buffers using strcoll on each substring.  */
 
-  if (s2 + s2len == s1)
+  if (s1len == s2len && memcmp (s1, s2, s1len) == 0)
     {
-      char *s1copy = alloca (s1len + 1);
-      memcpy (s1copy, s1, s1len);
-      s1 = s1copy;
+      errno = 0;
+      diff = 0;
     }
+  else
+    {
+      char n1 = s1[s1len];
+      char n2 = s2[s2len];
 
-  n1 = s1[s1len];  s1[s1len++] = '\0';
-  n2 = s2[s2len];  s2[s2len++] = '\0';
+      s1[s1len++] = '\0';
+      s2[s2len++] = '\0';
 
-  while (! (diff = strcoll (s1, s2)))
-    {
-      /* strcoll found no difference, but perhaps it was fooled by NUL
-	 characters in the data.  Work around this problem by advancing
-	 past the NUL chars.  */
-      size_t size1 = strlen (s1) + 1;
-      size_t size2 = strlen (s2) + 1;
-      s1 += size1;
-      s2 += size2;
-      s1len -= size1;
-      s2len -= size2;
-
-      if (s1len == 0)
-	{
-	  if (s2len != 0)
-	    diff = -1;
-	  break;
-	}
-      else if (s2len == 0)
+      while (! (errno = 0, (diff = strcoll (s1, s2)) || errno))
 	{
-	  diff = 1;
-	  break;
+	  /* strcoll found no difference, but perhaps it was fooled by NUL
+	     characters in the data.  Work around this problem by advancing
+	     past the NUL chars.  */
+	  size_t size1 = strlen (s1) + 1;
+	  size_t size2 = strlen (s2) + 1;
+	  s1 += size1;
+	  s2 += size2;
+	  s1len -= size1;
+	  s2len -= size2;
+
+	  if (s1len == 0)
+	    {
+	      if (s2len != 0)
+		diff = -1;
+	      break;
+	    }
+	  else if (s2len == 0)
+	    {
+	      diff = 1;
+	      break;
+	    }
 	}
+
+      s1[s1len - 1] = n1;
+      s2[s2len - 1] = n2;
     }
 
-  s1[s1len - 1] = n1;
-  s2[s2len - 1] = n2;
+#else
+
+  diff = memcmp (s1, s2, s1len < s2len ? s1len : s2len);
+  if (! diff)
+    diff = s1len < s2len ? -1 : s1len != s2len;
+  errno = 0;
+
+#endif
 
   return diff;
 }