strtoumax: fix typo in previous commit.

[gnulib.git] / lib / memcoll.c

diff --git a/lib/memcoll.c b/lib/memcoll.c
index 8e48551..1f5c2e3 100644 (file)
--- a/lib/memcoll.c
+++ b/lib/memcoll.c
@@ -1,6 +1,6 @@
 /* Locale-specific memory comparison.
 
-   Copyright (C) 1999, 2002-2004, 2006, 2009-2010 Free Software Foundation,
+   Copyright (C) 1999, 2002-2004, 2006, 2009-2013 Free Software Foundation,
    Inc.
 
    This program is free software: you can redistribute it and/or modify
@@ -26,13 +26,16 @@
 #include <stdlib.h>
 #include <string.h>
 
-/* Ensure strcoll operates on the entire input strings, in case they contain
-   NUL bytes. */
-
-static inline int
-strcoll_loop (const char *s1, size_t s1len, const char *s2, size_t s2len)
+/* Compare S1 (with size S1SIZE) and S2 (with length S2SIZE) according
+   to the LC_COLLATE locale.  S1 and S2 are both blocks of memory with
+   nonzero sizes, and the last byte in each block must be a null byte.
+   Set errno to an error number if there is an error, and to zero
+   otherwise.  */
+static int
+strcoll_loop (char const *s1, size_t s1size, char const *s2, size_t s2size)
 {
   int diff;
+
   while (! (errno = 0, (diff = strcoll (s1, s2)) || errno))
     {
       /* strcoll found no difference, but perhaps it was fooled by NUL
@@ -42,21 +45,15 @@ strcoll_loop (const char *s1, size_t s1len, const char *s2, size_t s2len)
       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;
-        }
+      s1size -= size1;
+      s2size -= size2;
+
+      if (s1size == 0)
+        return - (s2size != 0);
+      if (s2size == 0)
+        return 1;
     }
+
   return diff;
 }
 
@@ -65,7 +62,6 @@ strcoll_loop (const char *s1, size_t s1len, const char *s2, size_t s2len)
    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)
 {
@@ -85,36 +81,31 @@ memcoll (char *s1, size_t s1len, char *s2, size_t s2len)
       char n1 = s1[s1len];
       char n2 = s2[s2len];
 
-      s1[s1len++] = '\0';
-      s2[s2len++] = '\0';
+      s1[s1len] = '\0';
+      s2[s2len] = '\0';
 
-      diff = strcoll_loop (s1, s1len, s2, s2len);
+      diff = strcoll_loop (s1, s1len + 1, s2, s2len + 1);
 
-      s1[s1len - 1] = n1;
-      s2[s2len - 1] = n2;
+      s1[s1len] = n1;
+      s2[s2len] = n2;
     }
 
   return diff;
 }
 
-/* Like memcoll, but S1 and S2 are known to be NUL delimited, thus no
-   modification to S1 or S2 are needed. */
+/* Compare S1 (a memory block of size S1SIZE, with a NUL as last byte)
+   and S2 (a memory block of size S2SIZE, with a NUL as last byte)
+   according to the LC_COLLATE locale.  S1SIZE and S2SIZE must be > 0.
+   Set errno to an error number if there is an error, and to zero
+   otherwise.  */
 int
-memcoll0 (const char *s1, size_t s1len, const char *s2, size_t s2len)
+memcoll0 (char const *s1, size_t s1size, char const *s2, size_t s2size)
 {
-  int diff;
-  if (!(s1len > 0 && s1[s1len] == '\0'))
-    abort ();
-  if (!(s2len > 0 && s2[s2len] == '\0'))
-    abort ();
-
-  if (s1len == s2len && memcmp (s1, s2, s1len) == 0)
+  if (s1size == s2size && memcmp (s1, s2, s1size) == 0)
     {
       errno = 0;
-      diff = 0;
+      return 0;
     }
   else
-    diff = strcoll_loop (s1, s1len, s2, s2len);
-
-  return diff;
+    return strcoll_loop (s1, s1size, s2, s2size);
 }