[PATCH] crypto/md5: don't depend on stdint

[Paul Eggert]

Here's a simple patch to remove crypto/md5's dependence on
stdint.  It complicates the code in md5.h a bit, but the
result is closer to what's already in glibc.  This will
make it quite a bit easier for Emacs to use crypto/md5.

I haven't pushed this yet.

* lib/md5.h, lib/md5.c:
All uses of uint32_t changed to md5_uint32, as the glibc
version does.
* lib/md5.h: Do not include <stdint.h> unconditionally.
(md5_uint32): New typedef (actually, resurrected from libc).
On ordinary hosts, if not _LIBC, deduce it from <limits.h>.
Default it to <stdint.h> uint32_t on weird hosts.
* modules/crypto/md5 (Depends-on): Remove stdint.
---
 ChangeLog          |   12 +++++++++++
 lib/md5.c          |   34 ++++++++++++++++----------------
 lib/md5.h          |   53 +++++++++++++++++++++++++++++++++++++++++++--------
 modules/crypto/md5 |    1 -
 4 files changed, 73 insertions(+), 27 deletions(-)

diff --git a/ChangeLog b/ChangeLog
index c2c1946..9022e14 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,15 @@
+2011-02-18  Paul Eggert  <address@hidden>
+
+       crypto/md5: don't depend on stdint
+       * lib/md5.h, lib/md5.c:
+       All uses of uint32_t changed to md5_uint32, as the glibc
+       version does.
+       * lib/md5.h: Do not include <stdint.h> unconditionally.
+       (md5_uint32): New typedef (actually, resurrected from libc).
+       On ordinary hosts, if not _LIBC, deduce it from <limits.h>.
+       Default it to <stdint.h> uint32_t on weird hosts.
+       * modules/crypto/md5 (Depends-on): Remove stdint.
+
 2011-02-17  Paul Eggert  <address@hidden>
 
        * NEWS: Mention 2011-02-08 change to stdlib.
diff --git a/lib/md5.c b/lib/md5.c
index d37ca72..e30f0c3 100644
--- a/lib/md5.c
+++ b/lib/md5.c
@@ -82,9 +82,9 @@ md5_init_ctx (struct md5_ctx *ctx)
 
 /* Copy the 4 byte value from v into the memory location pointed to by *cp,
    If your architecture allows unaligned access this is equivalent to
-   * (uint32_t *) cp = v  */
+   * (md5_uint32 *) cp = v  */
 static inline void
-set_uint32 (char *cp, uint32_t v)
+set_uint32 (char *cp, md5_uint32 v)
 {
   memcpy (cp, &v, sizeof v);
 }
@@ -109,7 +109,7 @@ void *
 md5_finish_ctx (struct md5_ctx *ctx, void *resbuf)
 {
   /* Take yet unprocessed bytes into account.  */
-  uint32_t bytes = ctx->buflen;
+  md5_uint32 bytes = ctx->buflen;
   size_t size = (bytes < 56) ? 64 / 4 : 64 * 2 / 4;
 
   /* Now count remaining bytes.  */
@@ -255,7 +255,7 @@ md5_process_bytes (const void *buffer, size_t len, struct 
md5_ctx *ctx)
     {
 #if !_STRING_ARCH_unaligned
 # define alignof(type) offsetof (struct { char c; type x; }, x)
-# define UNALIGNED_P(p) (((size_t) p) % alignof (uint32_t) != 0)
+# define UNALIGNED_P(p) (((size_t) p) % alignof (md5_uint32) != 0)
       if (UNALIGNED_P (buffer))
         while (len > 64)
           {
@@ -305,14 +305,14 @@ md5_process_bytes (const void *buffer, size_t len, struct 
md5_ctx *ctx)
 void
 md5_process_block (const void *buffer, size_t len, struct md5_ctx *ctx)
 {
-  uint32_t correct_words[16];
-  const uint32_t *words = buffer;
-  size_t nwords = len / sizeof (uint32_t);
-  const uint32_t *endp = words + nwords;
-  uint32_t A = ctx->A;
-  uint32_t B = ctx->B;
-  uint32_t C = ctx->C;
-  uint32_t D = ctx->D;
+  md5_uint32 correct_words[16];
+  const md5_uint32 *words = buffer;
+  size_t nwords = len / sizeof (md5_uint32);
+  const md5_uint32 *endp = words + nwords;
+  md5_uint32 A = ctx->A;
+  md5_uint32 B = ctx->B;
+  md5_uint32 C = ctx->C;
+  md5_uint32 D = ctx->D;
 
   /* First increment the byte count.  RFC 1321 specifies the possible
      length of the file up to 2^64 bits.  Here we only compute the
@@ -325,11 +325,11 @@ md5_process_block (const void *buffer, size_t len, struct 
md5_ctx *ctx)
      the loop.  */
   while (words < endp)
     {
-      uint32_t *cwp = correct_words;
-      uint32_t A_save = A;
-      uint32_t B_save = B;
-      uint32_t C_save = C;
-      uint32_t D_save = D;
+      md5_uint32 *cwp = correct_words;
+      md5_uint32 A_save = A;
+      md5_uint32 B_save = B;
+      md5_uint32 C_save = C;
+      md5_uint32 D_save = D;
 
       /* First round: using the given function, the context and a constant
          the next context is computed.  Because the algorithms processing
diff --git a/lib/md5.h b/lib/md5.h
index 8b06466..98bcdfc 100644
--- a/lib/md5.h
+++ b/lib/md5.h
@@ -22,7 +22,6 @@
 #define _MD5_H 1
 
 #include <stdio.h>
-#include <stdint.h>
 
 #define MD5_DIGEST_SIZE 16
 #define MD5_BLOCK_SIZE 64
@@ -58,17 +57,53 @@
 extern "C" {
 # endif
 
+/* The following contortions are an attempt to use the C preprocessor
+   to determine an unsigned integral type that is 32 bits wide.  An
+   alternative approach is to use autoconf's AC_CHECK_SIZEOF macro, but
+   doing that would require that the configure script compile and *run*
+   the resulting executable.  Locally running cross-compiled executables
+   is usually not possible.  */
+
+#if defined _LIBC
+# include <stdint.h>
+typedef uint32_t md5_uint32;
+#else
+# if defined __STDC__ && __STDC__
+#  define UINT_MAX_32_BITS 4294967295U
+# else
+#  define UINT_MAX_32_BITS 0xFFFFFFFF
+# endif
+
+# include <limits.h>
+
+# if UINT_MAX == UINT_MAX_32_BITS
+   typedef unsigned int md5_uint32;
+# else
+#  if USHRT_MAX == UINT_MAX_32_BITS
+    typedef unsigned short md5_uint32;
+#  else
+#   if ULONG_MAX == UINT_MAX_32_BITS
+     typedef unsigned long md5_uint32;
+#   else
+     /* A machine this weird should have <stdint.h>.  */
+#    include <stdint.h>
+     typedef uint32_t md5_uint32;
+#   endif
+#  endif
+# endif
+#endif
+
 /* Structure to save state of computation between the single steps.  */
 struct md5_ctx
 {
-  uint32_t A;
-  uint32_t B;
-  uint32_t C;
-  uint32_t D;
-
-  uint32_t total[2];
-  uint32_t buflen;
-  uint32_t buffer[32];
+  md5_uint32 A;
+  md5_uint32 B;
+  md5_uint32 C;
+  md5_uint32 D;
+
+  md5_uint32 total[2];
+  md5_uint32 buflen;
+  md5_uint32 buffer[32];
 };
 
 /*
diff --git a/modules/crypto/md5 b/modules/crypto/md5
index 7e529e7..33dd4b6 100644
--- a/modules/crypto/md5
+++ b/modules/crypto/md5
@@ -7,7 +7,6 @@ lib/md5.c
 m4/md5.m4
 
 Depends-on:
-stdint
 
 configure.ac:
 gl_MD5
-- 
1.7.4