Update.

1999-10-25  Thorsten Kukuk  <kukuk@suse.de>

	* md5-crypt/md5.h: Remove prototypes for public interface. md5 is
	used only internal.
	* md5-crypt/md5-crypt.c: Use internal names for md5 functions,
	remove weak alias for public names.
	* md5-crypt/md5.c: Remove weak aliase.

1999-10-25  Andreas Jaeger  <aj@suse.de>

	* math/README.libm-test: New file, documents libm-test.inc.

1999-10-25  Andreas Jaeger  <aj@suse.de>

	* math/gen-libm-test.pl: Only generate a new ulps file when -n is
	given.
	(print_ulps_file): Fix loops to not read @tests and @functions
	since those are not initialized with -n now.
	(parse_ulps): Set $results{..}{"kind"}.

3 files changed, 27 insertions, 63 deletions

diff --git a/md5-crypt/md5-crypt.c b/md5-crypt/md5-crypt.c
index 6dd6740671..126103503c 100644
--- a/md5-crypt/md5-crypt.c
+++ b/md5-crypt/md5-crypt.c
@@ -1,5 +1,5 @@
 /* One way encryption based on MD5 sum.
-   Copyright (C) 1996, 1997 Free Software Foundation, Inc.
+   Copyright (C) 1996, 1997, 1999 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1996.
 
@@ -39,11 +39,7 @@ static const char b64t[64] =
 /* Prototypes for local functions.  */
 extern char *__md5_crypt_r __P ((const char *key, const char *salt,
 				 char *buffer, int buflen));
-extern char *md5_crypt_r __P ((const char *key, const char *salt,
-			       char *buffer, int buflen));
 extern char *__md5_crypt __P ((const char *key, const char *salt));
-extern char *md5_crypt __P ((const char *key, const char *salt));
-
 
 
 /* This entry point is equivalent to the `crypt' function in Unix
@@ -73,42 +69,42 @@ __md5_crypt_r (key, salt, buffer, buflen)
   key_len = strlen (key);
 
   /* Prepare for the real work.  */
-  md5_init_ctx (&ctx);
+  __md5_init_ctx (&ctx);
 
   /* Add the key string.  */
-  md5_process_bytes (key, key_len, &ctx);
+  __md5_process_bytes (key, key_len, &ctx);
 
   /* Because the SALT argument need not always have the salt prefix we
      add it separately.  */
-  md5_process_bytes (md5_salt_prefix, sizeof (md5_salt_prefix) - 1, &ctx);
+  __md5_process_bytes (md5_salt_prefix, sizeof (md5_salt_prefix) - 1, &ctx);
 
   /* The last part is the salt string.  This must be at most 8
      characters and it ends at the first `$' character (for
      compatibility which existing solutions).  */
-  md5_process_bytes (salt, salt_len, &ctx);
+  __md5_process_bytes (salt, salt_len, &ctx);
 
 
   /* Compute alternate MD5 sum with input KEY, SALT, and KEY.  The
      final result will be added to the first context.  */
-  md5_init_ctx (&alt_ctx);
+  __md5_init_ctx (&alt_ctx);
 
   /* Add key.  */
-  md5_process_bytes (key, key_len, &alt_ctx);
+  __md5_process_bytes (key, key_len, &alt_ctx);
 
   /* Add salt.  */
-  md5_process_bytes (salt, salt_len, &alt_ctx);
+  __md5_process_bytes (salt, salt_len, &alt_ctx);
 
   /* Add key again.  */
-  md5_process_bytes (key, key_len, &alt_ctx);
+  __md5_process_bytes (key, key_len, &alt_ctx);
 
   /* Now get result of this (16 bytes) and add it to the other
      context.  */
-  md5_finish_ctx (&alt_ctx, alt_result);
+  __md5_finish_ctx (&alt_ctx, alt_result);
 
   /* Add for any character in the key one byte of the alternate sum.  */
   for (cnt = key_len; cnt > 16; cnt -= 16)
-    md5_process_bytes (alt_result, 16, &ctx);
-  md5_process_bytes (alt_result, cnt, &ctx);
+    __md5_process_bytes (alt_result, 16, &ctx);
+  __md5_process_bytes (alt_result, cnt, &ctx);
 
   /* For the following code we need a NUL byte.  */
   *alt_result = '\0';
@@ -118,11 +114,11 @@ __md5_crypt_r (key, salt, buffer, buflen)
      bit the first character of the key.  This does not seem to be
      what was intended but we have to follow this to be compatible.  */
   for (cnt = key_len; cnt > 0; cnt >>= 1)
-    md5_process_bytes ((cnt & 1) != 0 ? (const char *) alt_result : key, 1,
-		       &ctx);
+    __md5_process_bytes ((cnt & 1) != 0 ? (const char *) alt_result : key, 1,
+			 &ctx);
 
   /* Create intermediate result.  */
-  md5_finish_ctx (&ctx, alt_result);
+  __md5_finish_ctx (&ctx, alt_result);
 
   /* Now comes another weirdness.  In fear of password crackers here
      comes a quite long loop which just processes the output of the
@@ -130,30 +126,30 @@ __md5_crypt_r (key, salt, buffer, buflen)
   for (cnt = 0; cnt < 1000; ++cnt)
     {
       /* New context.  */
-      md5_init_ctx (&ctx);
+      __md5_init_ctx (&ctx);
 
       /* Add key or last result.  */
       if ((cnt & 1) != 0)
-	md5_process_bytes (key, key_len, &ctx);
+	__md5_process_bytes (key, key_len, &ctx);
       else
-	md5_process_bytes (alt_result, 16, &ctx);
+	__md5_process_bytes (alt_result, 16, &ctx);
 
       /* Add salt for numbers not divisible by 3.  */
       if (cnt % 3 != 0)
-	md5_process_bytes (salt, salt_len, &ctx);
+	__md5_process_bytes (salt, salt_len, &ctx);
 
       /* Add key for numbers not divisible by 7.  */
       if (cnt % 7 != 0)
-	md5_process_bytes (key, key_len, &ctx);
+	__md5_process_bytes (key, key_len, &ctx);
 
       /* Add key or last result.  */
       if ((cnt & 1) != 0)
-	md5_process_bytes (alt_result, 16, &ctx);
+	__md5_process_bytes (alt_result, 16, &ctx);
       else
-	md5_process_bytes (key, key_len, &ctx);
+	__md5_process_bytes (key, key_len, &ctx);
 
       /* Create intermediate result.  */
-      md5_finish_ctx (&ctx, alt_result);
+      __md5_finish_ctx (&ctx, alt_result);
     }
 
   /* Now we can construct the result string.  It consists of three
@@ -204,13 +200,10 @@ __md5_crypt_r (key, salt, buffer, buflen)
 
   return buffer;
 }
-weak_alias (__md5_crypt_r, md5_crypt_r)
 
 
 char *
-__md5_crypt (key, salt)
-     const char *key;
-     const char *salt;
+__md5_crypt (const char *key, const char *salt)
 {
   /* We don't want to have an arbitrary limit in the size of the
      password.  We can compute the size of the result in advance and
@@ -228,4 +221,3 @@ __md5_crypt (key, salt)
 
   return __md5_crypt_r (key, salt, buffer, buflen);
 }
-weak_alias (__md5_crypt, md5_crypt)
diff --git a/md5-crypt/md5.c b/md5-crypt/md5.c
index 00aab15828..478429f8e6 100644
--- a/md5-crypt/md5.c
+++ b/md5-crypt/md5.c
@@ -1,6 +1,6 @@
 /* md5.c - Functions to compute MD5 message digest of files or memory blocks
    according to the definition of MD5 in RFC 1321 from April 1992.
-   Copyright (C) 1995, 1996, 1997 Free Software Foundation, Inc.
+   Copyright (C) 1995, 1996, 1997, 1999 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -43,7 +43,7 @@
 #  define WORDS_BIGENDIAN 1
 # endif
 /* We need to keep the namespace clean so define the MD5 function
-   protected using leading __ and use weak aliases.  */
+   protected using leading __ .  */
 # define md5_init_ctx __md5_init_ctx
 # define md5_process_block __md5_process_block
 # define md5_process_bytes __md5_process_bytes
@@ -426,22 +426,3 @@ md5_process_block (buffer, len, ctx)
   ctx->C = C;
   ctx->D = D;
 }
-
-
-#ifdef _LIBC
-/* Define weak aliases.  */
-# undef md5_init_ctx
-weak_alias (__md5_init_ctx, md5_init_ctx)
-# undef md5_process_block
-weak_alias (__md5_process_block, md5_process_block)
-# undef md5_process_bytes
-weak_alias (__md5_process_bytes, md5_process_bytes)
-# undef md5_finish_ctx
-weak_alias (__md5_finish_ctx, md5_finish_ctx)
-# undef md5_read_ctx
-weak_alias (__md5_read_ctx, md5_read_ctx)
-# undef md5_stream
-weak_alias (__md5_stream, md5_stream)
-# undef md5_buffer
-weak_alias (__md5_buffer, md5_buffer)
-#endif
diff --git a/md5-crypt/md5.h b/md5-crypt/md5.h
index dacc1ae73b..fbc2bdbf93 100644
--- a/md5-crypt/md5.h
+++ b/md5-crypt/md5.h
@@ -1,6 +1,6 @@
 /* Declaration of functions and data types used for MD5 sum computing
    library functions.
-   Copyright (C) 1995, 1996, 1997 Free Software Foundation, Inc.
+   Copyright (C) 1995, 1996, 1997, 1999 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -98,7 +98,6 @@ struct md5_ctx
 /* Initialize structure containing state of computation.
    (RFC 1321, 3.3: Step 3)  */
 extern void __md5_init_ctx __P ((struct md5_ctx *ctx));
-extern void md5_init_ctx __P ((struct md5_ctx *ctx));
 
 /* Starting with the result of former calls of this function (or the
    initialization function update the context for the next LEN bytes
@@ -106,8 +105,6 @@ extern void md5_init_ctx __P ((struct md5_ctx *ctx));
    It is necessary that LEN is a multiple of 64!!! */
 extern void __md5_process_block __P ((const void *buffer, size_t len,
 				      struct md5_ctx *ctx));
-extern void md5_process_block __P ((const void *buffer, size_t len,
-				    struct md5_ctx *ctx));
 
 /* Starting with the result of former calls of this function (or the
    initialization function update the context for the next LEN bytes
@@ -115,8 +112,6 @@ extern void md5_process_block __P ((const void *buffer, size_t len,
    It is NOT required that LEN is a multiple of 64.  */
 extern void __md5_process_bytes __P ((const void *buffer, size_t len,
 				      struct md5_ctx *ctx));
-extern void md5_process_bytes __P ((const void *buffer, size_t len,
-				    struct md5_ctx *ctx));
 
 /* Process the remaining bytes in the buffer and put result from CTX
    in first 16 bytes following RESBUF.  The result is always in little
@@ -126,7 +121,6 @@ extern void md5_process_bytes __P ((const void *buffer, size_t len,
    IMPORTANT: On some systems it is required that RESBUF is correctly
    aligned for a 32 bits value.  */
 extern void *__md5_finish_ctx __P ((struct md5_ctx *ctx, void *resbuf));
-extern void *md5_finish_ctx __P ((struct md5_ctx *ctx, void *resbuf));
 
 
 /* Put result from CTX in first 16 bytes following RESBUF.  The result is
@@ -136,7 +130,6 @@ extern void *md5_finish_ctx __P ((struct md5_ctx *ctx, void *resbuf));
    IMPORTANT: On some systems it is required that RESBUF is correctly
    aligned for a 32 bits value.  */
 extern void *__md5_read_ctx __P ((const struct md5_ctx *ctx, void *resbuf));
-extern void *md5_read_ctx __P ((const struct md5_ctx *ctx, void *resbuf));
 
 
 /* Compute MD5 message digest for bytes read from STREAM.  The
@@ -150,7 +143,5 @@ extern int __md5_stream __P ((FILE *stream, void *resblock));
    digest.  */
 extern void *__md5_buffer __P ((const char *buffer, size_t len,
 				void *resblock));
-extern void *md5_buffer __P ((const char *buffer, size_t len,
-			      void *resblock));
 
 #endif /* md5.h */