Remove ansidecl.h and clean up for use by other packages. [LONG_MAX <= LONG_MAX_32_BI...

diff --git a/sysdeps/generic/memchr.c b/sysdeps/generic/memchr.c
index d17f9c6..1731574 100644 (file)
--- a/sysdeps/generic/memchr.c
+++ b/sysdeps/generic/memchr.c
@@ -20,17 +20,44 @@ License along with the GNU C Library; see the file COPYING.LIB.  If
 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
 Cambridge, MA 02139, USA.  */
 
-#include <ansidecl.h>
-#include <string.h>
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#undef __ptr_t
+#if defined (__cplusplus) || (defined (__STDC__) && __STDC__)
+# define __ptr_t void *
+#else /* Not C++ or ANSI C.  */
+# define __ptr_t char *
+#endif /* C++ or ANSI C.  */
+
+#if defined (HAVE_STRING_H) || defined (_LIBC)
+# include <string.h>
+#endif
+
+#if defined (HAVE_LIMIT_H) || defined (_LIBC)
+# include <limit.h>
+#endif
+
+#define LONG_MAX_32_BITS 2147483647
+
+#ifndef LONG_MAX
+#define LONG_MAX LONG_MAX_32_BITS
+#endif
+
+#include <sys/types.h>
 
 
 /* Search no more than N bytes of S for C.  */
 
-PTR
-DEFUN(memchr, (s, c, n), CONST PTR s AND int c AND size_t n)
+__ptr_t
+memchr (s, c, n)
+     const __ptr_t s;
+     int c;
+     size_t n;
 {
-  CONST unsigned char *char_ptr;
-  CONST unsigned long int *longword_ptr;
+  const unsigned char *char_ptr;
+  const unsigned long int *longword_ptr;
   unsigned long int longword, magic_bits, charmask;
 
   c = (unsigned char) c;
@@ -41,7 +68,7 @@ DEFUN(memchr, (s, c, n), CONST PTR s AND int c AND size_t n)
                               & (sizeof (longword) - 1)) != 0;
        --n, ++char_ptr)
     if (*char_ptr == c)
-      return (PTR) char_ptr;
+      return (__ptr_t) char_ptr;
 
   /* All these elucidatory comments refer to 4-byte longwords,
      but the theory applies equally well to 8-byte longwords.  */
@@ -57,21 +84,22 @@ DEFUN(memchr, (s, c, n), CONST PTR s AND int c AND size_t n)
 
      The 1-bits make sure that carries propagate to the next 0-bit.
      The 0-bits provide holes for carries to fall into.  */
-  switch (sizeof (longword))
-    {
-    case 4: magic_bits = 0x7efefeffL; break;
-    case 8: magic_bits = (0x7efefefeL << 32) | 0xfefefeffL; break;
-    default:
-      abort ();
-    }
+
+  if (sizeof (longword) != 4 && sizeof (longword) != 8)
+    abort ();
+
+#if LONG_MAX <= LONG_MAX_32_BITS
+  magic_bits = 0x7efefeff;
+#else
+  magic_bits = ((unsigned long int) 0x7efefefe << 32) | 0xfefefeff;
+#endif
 
   /* Set up a longword, each of whose bytes is C.  */
   charmask = c | (c << 8);
   charmask |= charmask << 16;
-  if (sizeof (longword) > 4)
-    charmask |= charmask << 32;
-  if (sizeof (longword) > 8)
-    abort ();
+#if LONG_MAX > LONG_MAX_32_BITS
+  charmask |= charmask << 32;
+#endif
 
   /* Instead of the traditional loop which tests each character,
      we will test a longword at a time.  The tricky part is testing
@@ -128,41 +156,40 @@ DEFUN(memchr, (s, c, n), CONST PTR s AND int c AND size_t n)
          /* Which of the bytes was C?  If none of them were, it was
             a misfire; continue the search.  */
 
-         CONST unsigned char *cp = (CONST unsigned char *) (longword_ptr - 1);
+         const unsigned char *cp = (const unsigned char *) (longword_ptr - 1);
 
          if (cp[0] == c)
-           return (PTR) cp;
+           return (__ptr_t) cp;
          if (cp[1] == c)
-           return (PTR) &cp[1];
+           return (__ptr_t) &cp[1];
          if (cp[2] == c)
-           return (PTR) &cp[2];
+           return (__ptr_t) &cp[2];
          if (cp[3] == c)
-           return (PTR) &cp[3];
-         if (sizeof (longword) > 4)
-           {
-             if (cp[4] == c)
-               return (PTR) &cp[4];
-             if (cp[5] == c)
-               return (PTR) &cp[5];
-             if (cp[6] == c)
-               return (PTR) &cp[6];
-             if (cp[7] == c)
-               return (PTR) &cp[7];
-           }
+           return (__ptr_t) &cp[3];
+#if LONG_MAX > 2147483647
+         if (cp[4] == c)
+           return (__ptr_t) &cp[4];
+         if (cp[5] == c)
+           return (__ptr_t) &cp[5];
+         if (cp[6] == c)
+           return (__ptr_t) &cp[6];
+         if (cp[7] == c)
+           return (__ptr_t) &cp[7];
+#endif
        }
 
       n -= sizeof (longword);
     }
 
-  char_ptr = (CONST unsigned char *) longword_ptr;
+  char_ptr = (const unsigned char *) longword_ptr;
 
   while (n-- > 0)
     {
       if (*char_ptr == c)
-       return (PTR) char_ptr;
+       return (__ptr_t) char_ptr;
       else
        ++char_ptr;
     }
 
-  return NULL;
+  return 0;
 }