check if __THROW is defined

Windows does not have it at all, so we gotta check this otherwise compile may fail

src/md5.c

@@ -1,6 +1,6 @@
 // SONIC ROBO BLAST 2
 //-----------------------------------------------------------------------------
-// Copyright (C) 1995-1996 by the Free Software Foundation, Inc.
+// Copyright (C) 1995-2025 by the Free Software Foundation, Inc.
 //
 // This program is free software distributed under the
 // terms of the GNU General Public License, version 2.
@@ -33,7 +33,7 @@
 #include "endian.h"
 
 #if defined (SRB2_BIG_ENDIAN)
- #define SWAP(n)							\
+ #define SWAP(n) \
     (((n) << 24) | (((n) & 0xff00) << 8) | (((n) >> 8) & 0xff00) | ((n) >> 24))
 #else
  #define SWAP(n) (n)
@@ -46,27 +46,31 @@ static const unsigned char fillbuf[64] = { 0x80, 0 /*, 0, 0, ...  */ };
 /* Structure to save state of computation between the single steps.  */
 struct md5_ctx
 {
-  md5_uint32 A;
-  md5_uint32 B;
-  md5_uint32 C;
-  md5_uint32 D;
+	md5_uint32 A;
+	md5_uint32 B;
+	md5_uint32 C;
+	md5_uint32 D;
 
-  md5_uint32 total[2];
-  md5_uint32 buflen;
-  char buffer[128];
+	md5_uint32 total[2];
+	md5_uint32 buflen;
+	union
+	{
+		char buffer[128];
+		md5_uint32 buffer32[32];
+	};
 };
 
 /* Initialize structure containing state of computation.
    (RFC 1321, 3.3: Step 3)  */
-static void md5_init_ctx (struct md5_ctx *ctx)
+static void md5_init_ctx(struct md5_ctx *ctx)
 {
-  ctx->A = 0x67452301;
-  ctx->B = 0xefcdab89;
-  ctx->C = 0x98badcfe;
-  ctx->D = 0x10325476;
+	ctx->A = 0x67452301;
+	ctx->B = 0xefcdab89;
+	ctx->C = 0x98badcfe;
+	ctx->D = 0x10325476;
 
-  ctx->total[0] = ctx->total[1] = 0;
-  ctx->buflen = 0;
+	ctx->total[0] = ctx->total[1] = 0;
+	ctx->buflen = 0;
 }
 
 /* Put result from CTX in first 16 bytes following RESBUF.  The result
@@ -74,14 +78,14 @@ static void md5_init_ctx (struct md5_ctx *ctx)
 
    IMPORTANT: On some systems it is required that RESBUF is correctly
    aligned for a 32 bits value.  */
-static void *md5_read_ctx (const struct md5_ctx *ctx, void *resbuf)
+static void *md5_read_ctx(const struct md5_ctx *ctx, void *resbuf)
 {
-  ((md5_uint32 *) resbuf)[0] = SWAP (ctx->A);
-  ((md5_uint32 *) resbuf)[1] = SWAP (ctx->B);
-  ((md5_uint32 *) resbuf)[2] = SWAP (ctx->C);
-  ((md5_uint32 *) resbuf)[3] = SWAP (ctx->D);
+	((md5_uint32 *) resbuf)[0] = SWAP(ctx->A);
+	((md5_uint32 *) resbuf)[1] = SWAP(ctx->B);
+	((md5_uint32 *) resbuf)[2] = SWAP(ctx->C);
+	((md5_uint32 *) resbuf)[3] = SWAP(ctx->D);
 
-  return resbuf;
+	return resbuf;
 }
 
 /* These are the four functions used in the four steps of the MD5 algorithm
@@ -96,200 +100,215 @@ static void *md5_read_ctx (const struct md5_ctx *ctx, void *resbuf)
 /* Process LEN bytes of BUFFER, accumulating context into CTX.
    It is assumed that LEN % 64 == 0.  */
 
-static void md5_process_block (const void *buffer, size_t len, struct md5_ctx *ctx)
+static void md5_process_block(const void *buffer, size_t len, struct md5_ctx *ctx)
 {
-  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;
+	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;
+	md5_uint32 lolen = len;
 
-  /* First increment the byte count.  RFC 1321 specifies the possible
-     length of the file up to 2^64 bits.  Here we only compute the
-     number of bytes.  Do a double word increment.  */
-  ctx->total[0] = (md5_uint32)(len+ctx->total[0]);
-  if (ctx->total[0] < len)
-    ++ctx->total[1];
+	/* First increment the byte count.  RFC 1321 specifies the possible
+	length of the file up to 2^64 bits.  Here we only compute the
+	number of bytes.  Do a double word increment.  */
+	ctx->total[0] += lolen;
+	ctx->total[1] += (len >> 31 >> 1) + (ctx->total[0] < lolen);
 
-  /* Process all bytes in the buffer with 64 bytes in each round of
-     the loop.  */
-  while (words < endp)
-    {
-      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;
+	/* Process all bytes in the buffer with 64 bytes in each round of
+	the loop.  */
+	while (words < endp)
+	{
+		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
-	 unit is a 32-bit word and it is determined to work on words in
-	 little endian byte order we perhaps have to change the byte order
-	 before the computation.  To reduce the work for the next steps
-	 we store the swapped words in the array CORRECT_WORDS.  */
+		/* First round: using the given function, the context and a constant
+		the next context is computed.  Because the algorithms processing
+		unit is a 32-bit word and it is determined to work on words in
+		little endian byte order we perhaps have to change the byte order
+		before the computation.  To reduce the work for the next steps
+		we store the swapped words in the array CORRECT_WORDS.  */
 
-#define OP(a, b, c, d, s, T)						\
-      do								\
-        {								\
-	  a += FF (b, c, d) + (*cwp++ = SWAP (*words)) + T;		\
-	  ++words;							\
-	  CYCLIC (a, s);						\
-	  a += b;							\
-        }								\
-      while (0)
+#define OP(a, b, c, d, s, T)									\
+		do														\
+		{														\
+			a += FF (b, c, d) + (*cwp++ = SWAP (*words)) + T;	\
+			++words;											\
+			CYCLIC (a, s);										\
+			a += b;												\
+		}														\
+		while (0)
 
-      /* It is unfortunate that C does not provide an operator for
-	 cyclic rotation.  Hope the C compiler is smart enough.  */
+		/* It is unfortunate that C does not provide an operator for
+		cyclic rotation.  Hope the C compiler is smart enough.  */
 #define CYCLIC(w, s) (w = (w << s) | (w >> (32 - s)))
 
-      /* Before we start, one word to the strange constants.
-	 They are defined in RFC 1321 as
+		/* Before we start, one word to the strange constants.
+		They are defined in RFC 1321 as
 
-	 T[i] = (int) (4294967296.0 * fabs (sin (i))), i = 1..64
-       */
+		T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64
+		*/
 
-      /* Round 1.  */
-      OP (A, B, C, D,  7, 0xd76aa478);
-      OP (D, A, B, C, 12, 0xe8c7b756);
-      OP (C, D, A, B, 17, 0x242070db);
-      OP (B, C, D, A, 22, 0xc1bdceee);
-      OP (A, B, C, D,  7, 0xf57c0faf);
-      OP (D, A, B, C, 12, 0x4787c62a);
-      OP (C, D, A, B, 17, 0xa8304613);
-      OP (B, C, D, A, 22, 0xfd469501);
-      OP (A, B, C, D,  7, 0x698098d8);
-      OP (D, A, B, C, 12, 0x8b44f7af);
-      OP (C, D, A, B, 17, 0xffff5bb1);
-      OP (B, C, D, A, 22, 0x895cd7be);
-      OP (A, B, C, D,  7, 0x6b901122);
-      OP (D, A, B, C, 12, 0xfd987193);
-      OP (C, D, A, B, 17, 0xa679438e);
-      OP (B, C, D, A, 22, 0x49b40821);
+		/* Round 1.  */
+		OP (A, B, C, D,  7, 0xd76aa478);
+		OP (D, A, B, C, 12, 0xe8c7b756);
+		OP (C, D, A, B, 17, 0x242070db);
+		OP (B, C, D, A, 22, 0xc1bdceee);
+		OP (A, B, C, D,  7, 0xf57c0faf);
+		OP (D, A, B, C, 12, 0x4787c62a);
+		OP (C, D, A, B, 17, 0xa8304613);
+		OP (B, C, D, A, 22, 0xfd469501);
+		OP (A, B, C, D,  7, 0x698098d8);
+		OP (D, A, B, C, 12, 0x8b44f7af);
+		OP (C, D, A, B, 17, 0xffff5bb1);
+		OP (B, C, D, A, 22, 0x895cd7be);
+		OP (A, B, C, D,  7, 0x6b901122);
+		OP (D, A, B, C, 12, 0xfd987193);
+		OP (C, D, A, B, 17, 0xa679438e);
+		OP (B, C, D, A, 22, 0x49b40821);
 
-      /* For the second to fourth round we have the possibly swapped words
-	 in CORRECT_WORDS.  Redefine the macro to take an additional first
-	 argument specifying the function to use.  */
+		/* For the second to fourth round we have the possibly swapped words
+		in CORRECT_WORDS.  Redefine the macro to take an additional first
+		argument specifying the function to use.  */
 #undef OP
-#define OP(f, a, b, c, d, k, s, T)               \
-	do                                           \
-	{                                            \
-		a += f (b, c, d) + correct_words[k] + T; \
-		CYCLIC (a, s);                           \
-		a += b;                                  \
-	}                                            \
-      while (0)
+#define OP(f, a, b, c, d, k, s, T)						\
+		do												\
+		{												\
+			a += f (b, c, d) + correct_words[k] + T;	\
+			CYCLIC (a, s);								\
+			a += b;										\
+		}												\
+		while (0)
 
-      /* Round 2.  */
-      OP (FG, A, B, C, D,  1,  5, 0xf61e2562);
-      OP (FG, D, A, B, C,  6,  9, 0xc040b340);
-      OP (FG, C, D, A, B, 11, 14, 0x265e5a51);
-      OP (FG, B, C, D, A,  0, 20, 0xe9b6c7aa);
-      OP (FG, A, B, C, D,  5,  5, 0xd62f105d);
-      OP (FG, D, A, B, C, 10,  9, 0x02441453);
-      OP (FG, C, D, A, B, 15, 14, 0xd8a1e681);
-      OP (FG, B, C, D, A,  4, 20, 0xe7d3fbc8);
-      OP (FG, A, B, C, D,  9,  5, 0x21e1cde6);
-      OP (FG, D, A, B, C, 14,  9, 0xc33707d6);
-      OP (FG, C, D, A, B,  3, 14, 0xf4d50d87);
-      OP (FG, B, C, D, A,  8, 20, 0x455a14ed);
-      OP (FG, A, B, C, D, 13,  5, 0xa9e3e905);
-      OP (FG, D, A, B, C,  2,  9, 0xfcefa3f8);
-      OP (FG, C, D, A, B,  7, 14, 0x676f02d9);
-      OP (FG, B, C, D, A, 12, 20, 0x8d2a4c8a);
+		/* Round 2.  */
+		OP (FG, A, B, C, D,  1,  5, 0xf61e2562);
+		OP (FG, D, A, B, C,  6,  9, 0xc040b340);
+		OP (FG, C, D, A, B, 11, 14, 0x265e5a51);
+		OP (FG, B, C, D, A,  0, 20, 0xe9b6c7aa);
+		OP (FG, A, B, C, D,  5,  5, 0xd62f105d);
+		OP (FG, D, A, B, C, 10,  9, 0x02441453);
+		OP (FG, C, D, A, B, 15, 14, 0xd8a1e681);
+		OP (FG, B, C, D, A,  4, 20, 0xe7d3fbc8);
+		OP (FG, A, B, C, D,  9,  5, 0x21e1cde6);
+		OP (FG, D, A, B, C, 14,  9, 0xc33707d6);
+		OP (FG, C, D, A, B,  3, 14, 0xf4d50d87);
+		OP (FG, B, C, D, A,  8, 20, 0x455a14ed);
+		OP (FG, A, B, C, D, 13,  5, 0xa9e3e905);
+		OP (FG, D, A, B, C,  2,  9, 0xfcefa3f8);
+		OP (FG, C, D, A, B,  7, 14, 0x676f02d9);
+		OP (FG, B, C, D, A, 12, 20, 0x8d2a4c8a);
 
-      /* Round 3.  */
-      OP (FH, A, B, C, D,  5,  4, 0xfffa3942);
-      OP (FH, D, A, B, C,  8, 11, 0x8771f681);
-      OP (FH, C, D, A, B, 11, 16, 0x6d9d6122);
-      OP (FH, B, C, D, A, 14, 23, 0xfde5380c);
-      OP (FH, A, B, C, D,  1,  4, 0xa4beea44);
-      OP (FH, D, A, B, C,  4, 11, 0x4bdecfa9);
-      OP (FH, C, D, A, B,  7, 16, 0xf6bb4b60);
-      OP (FH, B, C, D, A, 10, 23, 0xbebfbc70);
-      OP (FH, A, B, C, D, 13,  4, 0x289b7ec6);
-      OP (FH, D, A, B, C,  0, 11, 0xeaa127fa);
-      OP (FH, C, D, A, B,  3, 16, 0xd4ef3085);
-      OP (FH, B, C, D, A,  6, 23, 0x04881d05);
-      OP (FH, A, B, C, D,  9,  4, 0xd9d4d039);
-      OP (FH, D, A, B, C, 12, 11, 0xe6db99e5);
-      OP (FH, C, D, A, B, 15, 16, 0x1fa27cf8);
-      OP (FH, B, C, D, A,  2, 23, 0xc4ac5665);
+		/* Round 3.  */
+		OP (FH, A, B, C, D,  5,  4, 0xfffa3942);
+		OP (FH, D, A, B, C,  8, 11, 0x8771f681);
+		OP (FH, C, D, A, B, 11, 16, 0x6d9d6122);
+		OP (FH, B, C, D, A, 14, 23, 0xfde5380c);
+		OP (FH, A, B, C, D,  1,  4, 0xa4beea44);
+		OP (FH, D, A, B, C,  4, 11, 0x4bdecfa9);
+		OP (FH, C, D, A, B,  7, 16, 0xf6bb4b60);
+		OP (FH, B, C, D, A, 10, 23, 0xbebfbc70);
+		OP (FH, A, B, C, D, 13,  4, 0x289b7ec6);
+		OP (FH, D, A, B, C,  0, 11, 0xeaa127fa);
+		OP (FH, C, D, A, B,  3, 16, 0xd4ef3085);
+		OP (FH, B, C, D, A,  6, 23, 0x04881d05);
+		OP (FH, A, B, C, D,  9,  4, 0xd9d4d039);
+		OP (FH, D, A, B, C, 12, 11, 0xe6db99e5);
+		OP (FH, C, D, A, B, 15, 16, 0x1fa27cf8);
+		OP (FH, B, C, D, A,  2, 23, 0xc4ac5665);
 
-      /* Round 4.  */
-      OP (FI, A, B, C, D,  0,  6, 0xf4292244);
-      OP (FI, D, A, B, C,  7, 10, 0x432aff97);
-      OP (FI, C, D, A, B, 14, 15, 0xab9423a7);
-      OP (FI, B, C, D, A,  5, 21, 0xfc93a039);
-      OP (FI, A, B, C, D, 12,  6, 0x655b59c3);
-      OP (FI, D, A, B, C,  3, 10, 0x8f0ccc92);
-      OP (FI, C, D, A, B, 10, 15, 0xffeff47d);
-      OP (FI, B, C, D, A,  1, 21, 0x85845dd1);
-      OP (FI, A, B, C, D,  8,  6, 0x6fa87e4f);
-      OP (FI, D, A, B, C, 15, 10, 0xfe2ce6e0);
-      OP (FI, C, D, A, B,  6, 15, 0xa3014314);
-      OP (FI, B, C, D, A, 13, 21, 0x4e0811a1);
-      OP (FI, A, B, C, D,  4,  6, 0xf7537e82);
-      OP (FI, D, A, B, C, 11, 10, 0xbd3af235);
-      OP (FI, C, D, A, B,  2, 15, 0x2ad7d2bb);
-      OP (FI, B, C, D, A,  9, 21, 0xeb86d391);
+		/* Round 4.  */
+		OP (FI, A, B, C, D,  0,  6, 0xf4292244);
+		OP (FI, D, A, B, C,  7, 10, 0x432aff97);
+		OP (FI, C, D, A, B, 14, 15, 0xab9423a7);
+		OP (FI, B, C, D, A,  5, 21, 0xfc93a039);
+		OP (FI, A, B, C, D, 12,  6, 0x655b59c3);
+		OP (FI, D, A, B, C,  3, 10, 0x8f0ccc92);
+		OP (FI, C, D, A, B, 10, 15, 0xffeff47d);
+		OP (FI, B, C, D, A,  1, 21, 0x85845dd1);
+		OP (FI, A, B, C, D,  8,  6, 0x6fa87e4f);
+		OP (FI, D, A, B, C, 15, 10, 0xfe2ce6e0);
+		OP (FI, C, D, A, B,  6, 15, 0xa3014314);
+		OP (FI, B, C, D, A, 13, 21, 0x4e0811a1);
+		OP (FI, A, B, C, D,  4,  6, 0xf7537e82);
+		OP (FI, D, A, B, C, 11, 10, 0xbd3af235);
+		OP (FI, C, D, A, B,  2, 15, 0x2ad7d2bb);
+		OP (FI, B, C, D, A,  9, 21, 0xeb86d391);
 
-      /* Add the starting values of the context.  */
-      A += A_save;
-      B += B_save;
-      C += C_save;
-      D += D_save;
-    }
+		/* Add the starting values of the context.  */
+		A += A_save;
+		B += B_save;
+		C += C_save;
+		D += D_save;
+	}
 
-  /* Put checksum in context given as argument.  */
-  ctx->A = A;
-  ctx->B = B;
-  ctx->C = C;
-  ctx->D = D;
+	/* Put checksum in context given as argument.  */
+	ctx->A = A;
+	ctx->B = B;
+	ctx->C = C;
+	ctx->D = D;
 }
 
 
-static void md5_process_bytes (const void *buffer, size_t len, struct md5_ctx *ctx)
+static void md5_process_bytes(const void *buffer, size_t len, struct md5_ctx *ctx)
 {
-  /* When we already have some bits in our internal buffer concatenate
-     both inputs first.  */
-  if (ctx->buflen != 0)
-    {
-      size_t left_over = ctx->buflen;
-      size_t add = 128 - left_over > len ? len : 128 - left_over;
-
-      memcpy (&ctx->buffer[left_over], buffer, add);
-      ctx->buflen = (md5_uint32)(add+ctx->buflen);
-
-      if (left_over + add > 64)
+	/* When we already have some bits in our internal buffer concatenate
+	*    both inputs first.  */
+	if (ctx->buflen != 0)
 	{
-	  md5_process_block (ctx->buffer, (left_over + add) & ~63, ctx);
-	  /* The regions in the following copy operation cannot overlap.  */
-	  memcpy (ctx->buffer, &ctx->buffer[(left_over + add) & ~63],
-		  (left_over + add) & 63);
-	  ctx->buflen = (md5_uint32)((left_over + add) & 63);
+		size_t left_over = ctx->buflen;
+		size_t add = 128 - left_over > len ? len : 128 - left_over;
+
+		memcpy (&ctx->buffer[left_over], buffer, add);
+		ctx->buflen += add;
+
+		if (ctx->buflen > 64)
+		{
+			md5_process_block(ctx->buffer, ctx->buflen & ~63, ctx);
+
+			ctx->buflen &= 63;
+			/* The regions in the following copy operation cannot overlap.  */
+			memcpy (ctx->buffer, &ctx->buffer[(left_over + add) & ~63],
+					ctx->buflen);
+		}
+
+		buffer = (const char *) buffer + add;
+		len -= add;
 	}
 
-      buffer = (const char *) buffer + add;
-      len -= add;
-    }
+	/* Process available complete blocks.  */
+	if (len >= 64)
+	{
+		while (len > 64)
+		{
+			md5_process_block(memcpy(ctx->buffer, buffer, 64), 64, ctx);
+			buffer = (const char *) buffer + 64;
+			len -= 64;
+		}
+	}
 
-  /* Process available complete blocks.  */
-  if (len > 64)
-    {
-      md5_process_block (buffer, len & ~63, ctx);
-      buffer = (const char *) buffer + (len & ~63);
-      len &= 63;
-    }
+	/* Move remaining bytes in internal buffer.  */
+	if (len > 0)
+	{
+		size_t left_over = ctx->buflen;
 
-  /* Move remaining bytes in internal buffer.  */
-  if (len > 0)
-    {
-      memcpy (ctx->buffer, buffer, len);
-      ctx->buflen = (md5_uint32)len;
-    }
+		memcpy(&ctx->buffer[left_over], buffer, len);
+		left_over += len;
+
+		if (left_over >= 64)
+		{
+			md5_process_block (ctx->buffer, 64, ctx);
+			left_over -= 64;
+			memcpy(ctx->buffer, &ctx->buffer[64], left_over);
+		}
+
+		ctx->buflen = left_over;
+	}
 }
 
 
@@ -298,100 +317,98 @@ static void md5_process_bytes (const void *buffer, size_t len, struct md5_ctx *c
 
    IMPORTANT: On some systems it is required that RESBUF is correctly
    aligned for a 32 bits value.  */
-static void *md5_finish_ctx (struct md5_ctx *ctx, void *resbuf)
+static void *md5_finish_ctx(struct md5_ctx *ctx, void *resbuf)
 {
-  /* Take yet unprocessed bytes into account.  */
-  md5_uint32 bytes = ctx->buflen;
-  size_t pad;
-  md5_uint32 *buffer = NULL;
+	/* Take yet unprocessed bytes into account.  */
+	md5_uint32 bytes = ctx->buflen;
+	size_t pad;
 
-  /* Now count remaining bytes.  */
-  ctx->total[0] += bytes;
-  if (ctx->total[0] < bytes)
-    ++ctx->total[1];
+	/* Now count remaining bytes.  */
+	ctx->total[0] += bytes;
+	if (ctx->total[0] < bytes)
+		++ctx->total[1];
 
-  pad = bytes >= 56 ? 64 + 56 - bytes : 56 - bytes;
-  memcpy (&ctx->buffer[bytes], fillbuf, pad);
+	pad = bytes >= 56 ? 64 + 56 - bytes : 56 - bytes;
+	memcpy(&ctx->buffer[bytes], fillbuf, pad);
 
-  /* Put the 64-bit file length in *bits* at the end of the buffer.  */
-  buffer = (void *)&ctx->buffer[bytes + pad];
-  *buffer = SWAP (ctx->total[0] << 3);
-  buffer = (void *)&ctx->buffer[bytes + pad + 4];
-  *buffer = SWAP ((ctx->total[1] << 3) | (ctx->total[0] >> 29));
+	/* Put the 64-bit file length in *bits* at the end of the buffer.  */
+	ctx->buffer32[(bytes + pad) / 4] = SWAP (ctx->total[0] << 3);
+	ctx->buffer32[(bytes + pad + 4) / 4] = SWAP ((ctx->total[1] << 3)
+											| (ctx->total[0] >> 29));
 
-  /* Process last bytes.  */
-  md5_process_block (ctx->buffer, bytes + pad + 8, ctx);
+	/* Process last bytes.  */
+	md5_process_block(ctx->buffer, bytes + pad + 8, ctx);
 
-  return md5_read_ctx (ctx, resbuf);
+	return md5_read_ctx(ctx, resbuf);
 }
 
 /* Compute MD5 message digest for bytes read from STREAM.  The
    resulting message digest number will be written into the 16 bytes
    beginning at RESBLOCK.  */
-int md5_stream (FILE *stream, void *resblock)
+int md5_stream(FILE *stream, void *resblock)
 {
-  /* Important: BLOCKSIZE must be a multiple of 64.  */
+	/* Important: BLOCKSIZE must be a multiple of 64.  */
 #define BLOCKSIZE 4096
-  struct md5_ctx ctx;
-  char buffer[BLOCKSIZE + 72];
-  size_t sum = 0;
+	struct md5_ctx ctx;
+	char buffer[BLOCKSIZE + 72];
+	size_t sum = 0;
 
-  /* Initialize the computation context.  */
-  md5_init_ctx (&ctx);
+	/* Initialize the computation context.  */
+	md5_init_ctx(&ctx);
 
-  /* Iterate over full file contents.  */
-  while (1)
-    {
-      /* We read the file in blocks of BLOCKSIZE bytes.  One call of the
-	 computation function processes the whole buffer so that with the
-	 next round of the loop another block can be read.  */
-      size_t n;
-      sum = 0;
-
-      /* Read block.  Take care for partial reads.  */
-      do
+	/* Iterate over full file contents.  */
+	while (1)
 	{
-	  n = fread (buffer + sum, 1, BLOCKSIZE - sum, stream);
+		/* We read the file in blocks of BLOCKSIZE bytes.  One call of the
+		computation function processes the whole buffer so that with the
+		next round of the loop another block can be read.  */
+		size_t n;
+		sum = 0;
 
-	  sum += n;
+		/* Read block.  Take care for partial reads.  */
+		do
+		{
+			n = fread(buffer + sum, 1, BLOCKSIZE - sum, stream);
+			sum += n;
+		}
+
+		while (sum < BLOCKSIZE && n != 0);
+		if (n == 0 && ferror(stream))
+		  return 1;
+
+		/* If end of file is reached, end the loop.  */
+		if (n == 0)
+			break;
+
+		/* Process buffer with BLOCKSIZE bytes.  Note that
+		BLOCKSIZE % 64 == 0
+		*/
+		md5_process_block(buffer, BLOCKSIZE, &ctx);
 	}
-      while (sum < BLOCKSIZE && n != 0);
-      if (n == 0 && ferror (stream))
-        return 1;
 
-      /* If end of file is reached, end the loop.  */
-      if (n == 0)
-	break;
+	/* Add the last bytes if necessary.  */
+	if (sum > 0)
+		md5_process_bytes(buffer, sum, &ctx);
 
-      /* Process buffer with BLOCKSIZE bytes.  Note that
-			BLOCKSIZE % 64 == 0
-       */
-      md5_process_block (buffer, BLOCKSIZE, &ctx);
-    }
-
-  /* Add the last bytes if necessary.  */
-  if (sum > 0)
-    md5_process_bytes (buffer, sum, &ctx);
-
-  /* Construct result in desired memory.  */
-  md5_finish_ctx (&ctx, resblock);
-  return 0;
+	/* Construct result in desired memory.  */
+	md5_finish_ctx(&ctx, resblock);
+	return 0;
 }
 
 /* Compute MD5 message digest for LEN bytes beginning at BUFFER.  The
    result is always in little endian byte order, so that a byte-wise
    output yields to the wanted ASCII representation of the message
    digest.  */
-void *md5_buffer (const char *buffer, size_t len, void *resblock)
+void *md5_buffer(const char *buffer, size_t len, void *resblock)
 {
-  struct md5_ctx ctx;
+	struct md5_ctx ctx;
 
-  /* Initialize the computation context.  */
-  md5_init_ctx (&ctx);
+	/* Initialize the computation context.  */
+	md5_init_ctx(&ctx);
 
-  /* Process whole buffer but last len % 64 bytes.  */
-  md5_process_bytes (buffer, len, &ctx);
+	/* Process whole buffer but last len % 64 bytes.  */
+	md5_process_bytes (buffer, len, &ctx);
 
-  /* Put result in desired memory area.  */
-  return md5_finish_ctx (&ctx, resblock);
+	/* Put result in desired memory area.  */
+	return md5_finish_ctx(&ctx, resblock);
 }

src/md5.h

@@ -1,6 +1,6 @@
 // SONIC ROBO BLAST 2
 //-----------------------------------------------------------------------------
-// Copyright (C) 1995-1996 by the Free Software Foundation, Inc.
+// Copyright (C) 1995-2025 by the Free Software Foundation, Inc.
 //
 // This program is free software distributed under the
 // terms of the GNU General Public License, version 2.
@@ -24,108 +24,32 @@
 
 #define MD5_LEN 16
 
-/* 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.  */
+/*	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.  */
 
-#ifdef _LIBC
-# include <sys/types.h>
-typedef u_int32_t md5_uint32;
+#include <stdint.h>
+typedef uint32_t md5_uint32;
+typedef uintptr_t md5_uintptr;
+
+#if defined (__THROW)
+#define THROWFUNC __THROW
 #else
-# if defined __STDC__ && __STDC__
-#  define UINT_MAX_32_BITS 4294967295U
-# else
-#  define UINT_MAX_32_BITS 0xFFFFFFFF
-# endif
-
-/* If UINT_MAX isn't defined, assume it's a 32-bit type.
-   This should be valid for all systems GNU cares about because
-   that doesn't include 16-bit systems, and only modern systems
-   (that certainly have <limits.h>) have 64+-bit integral types.  */
-
-# ifndef UINT_MAX
-#  define UINT_MAX UINT_MAX_32_BITS
-# endif
-
-# 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
-     /* The following line is intended to evoke an error.
-        Using #error is not portable enough.  */
-     "Cannot determine unsigned 32-bit data type."
-#   endif
-#  endif
-# endif
+#define THROWFUNC
 #endif
 
-#undef __P
-#if defined (__STDC__) && __STDC__
-#define	__P(x) x
-#else
-#define	__P(x) ()
-#endif
+/*	Compute MD5 message digest for bytes read from STREAM.  The
+	resulting message digest number will be written into the 16 bytes
+	beginning at RESBLOCK.  */
+int md5_stream(FILE *stream, void *resblock) THROWFUNC;
 
-/*
- * The following three functions are build up the low level used in
- * the functions `md5_stream' and `md5_buffer'.
- */
-#if 0
-/* Initialize structure containing state of computation.
-   (RFC 1321, 3.3: Step 3)  */
-extern void md5_init_ctx __P ((struct md5_ctx *ctx));
+/*	Compute MD5 message digest for LEN bytes beginning at BUFFER.  The
+	result is always in little endian byte order, so that a byte-wise
+	output yields to the wanted ASCII representation of the message
+	digest.  */
+extern void *md5_buffer(const char *buffer, size_t len, void *resblock) THROWFUNC;
 
-/* Starting with the result of former calls of this function (or the
-   initialization function update the context for the next LEN bytes
-   starting at BUFFER.
-   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));
-
-/* Starting with the result of former calls of this function (or the
-   initialization function update the context for the next LEN bytes
-   starting at BUFFER.
-   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));
-
-/* Process the remaining bytes in the buffer and put result from CTX
-   in first 16 bytes following RESBUF.  The result is always in little
-   endian byte order, so that a byte-wise output yields to the wanted
-   ASCII representation of the message digest.
-
-   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));
-
-
-/* Put result from CTX in first 16 bytes following RESBUF.  The result is
-   always in little endian byte order, so that a byte-wise output yields
-   to the wanted ASCII representation of the message digest.
-
-   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));
-
-#endif
-
-/* Compute MD5 message digest for bytes read from STREAM.  The
-   resulting message digest number will be written into the 16 bytes
-   beginning at RESBLOCK.  */
-int md5_stream __P ((FILE *stream, void *resblock));
-
-/* Compute MD5 message digest for LEN bytes beginning at BUFFER.  The
-   result is always in little endian byte order, so that a byte-wise
-   output yields to the wanted ASCII representation of the message
-   digest.  */
-extern void *md5_buffer __P ((const char *buffer, size_t len, void *resblock));
-
-#endif
+#endif /* md5.h */