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 */

src/p_setup.c

@@ -2345,7 +2345,9 @@ static void P_RunLevelScript(const char *scriptname)
 		lumpnum_t lumpnum;
 		char newname[9];
 
-		strlcpy(newname, scriptname, sizeof(newname));
+		strncpy(newname, scriptname, 8);
+
+		newname[8] = '\0';
 
 		lumpnum = W_CheckNumForName(newname);
 
@@ -3312,12 +3314,6 @@ UINT16 P_PartialAddWadFile(const char *wadfilename, boolean local)
 	if (!mapsadded)
 		CONS_Printf(M_GetText("No maps added\n"));
 
-#ifdef HWRENDER
-	// Free GPU textures before freeing patches.
-	if (rendermode == render_opengl && (vid.glstate == VID_GL_LIBRARY_LOADED))
-		HWR_ClearAllTextures();
-#endif
-
 	//
 	// search for sprite replacements
 	//
@@ -3328,7 +3324,7 @@ UINT16 P_PartialAddWadFile(const char *wadfilename, boolean local)
 	// Reload it all anyway, just in case they
 	// added some textures but didn't insert a
 	// TEXTURES/etc. list.
-	R_LoadTexturesPwad(wadnum);
+	//R_LoadTexturesPwad(wadnum);
 
 	// everything from MultiSetupWadFile until ST_Start was here originally
 
@@ -3392,8 +3388,13 @@ boolean P_MultiSetupWadFiles(boolean fullsetup)
 
 	if (partadd_stage == 1)
 	{
+#ifdef HWRENDER
+		// Free GPU textures before freeing patches.
+		if (rendermode == render_opengl && (vid.glstate == VID_GL_LIBRARY_LOADED))
+			HWR_ClearAllTextures();
+#endif
 		// Reload all textures, unconditionally for better or worse.
-		//R_LoadTextures();
+		R_LoadTextures();
 
 		if (fullsetup)
 			++partadd_stage;

src/r_data.c

@@ -235,7 +235,6 @@ UINT32 ASTBlendTexturePixel(RGBA_t background, RGBA_t foreground, int style, UIN
 // Painfully simple texture id cacheing to make maps load faster. :3
 static struct {
 	char name[9];
-	UINT32 hash;
 	INT32 id;
 } *tidcache = NULL;
 static INT32 tidcachelen = 0;
@@ -521,151 +520,32 @@ void R_FlushTextureCache(void)
 int R_CountTexturesInTEXTURESLump(UINT16 wadNum, UINT16 lumpNum);
 void R_ParseTEXTURESLump(UINT16 wadNum, UINT16 lumpNum, INT32 *index);
 
+//
+// R_LoadTextures
+// Initializes the texture list with the textures from the world map.
+//
 #define TX_START "TX_START"
 #define TX_END "TX_END"
-
-static INT32
-Rloadtextures (INT32 i, INT32 w)
+void R_LoadTextures(void)
 {
+	INT32 i, k, w;
 	UINT16 j;
-	INT32 k;
 	UINT16 texstart, texend, texturesLumpPos;
 	softwarepatch_t *patchlump;
 	texpatch_t *patch;
 	texture_t *texture;
 
-	// Get the lump numbers for the markers in the WAD, if they exist.
-	if (W_FileHasFolders(wadfiles[w]))
+	// Free previous memory before numtextures change.
+	if (numtextures)
 	{
-		texstart = W_CheckNumForFolderStartPK3("textures/", (UINT16)w, 0);
-		texend = W_CheckNumForFolderEndPK3("textures/", (UINT16)w, texstart);
-		texturesLumpPos = W_CheckNumForNamePwad("TEXTURES", (UINT16)w, 0);
-		while (texturesLumpPos != INT16_MAX)
+		for (i = 0; i < numtextures; i++)
 		{
-			R_ParseTEXTURESLump(w, texturesLumpPos, &i);
-			texturesLumpPos = W_CheckNumForNamePwad("TEXTURES", (UINT16)w, texturesLumpPos + 1);
+			Z_Free(textures[i]);
+			Z_Free(texturecache[i]);
 		}
+		Z_Free(texturetranslation);
+		Z_Free(textures);
 	}
-	else
-	{
-		texstart = W_CheckNumForMarkerStartPwad(TX_START, (UINT16)w, 0);
-		texend = W_CheckNumForNamePwad(TX_END, (UINT16)w, 0);
-		texturesLumpPos = W_CheckNumForNamePwad("TEXTURES", (UINT16)w, 0);
-		if (texturesLumpPos != INT16_MAX)
-			R_ParseTEXTURESLump(w, texturesLumpPos, &i);
-	}
-
-	if (texstart == INT16_MAX || texend == INT16_MAX)
-		return i;
-
-	// Work through each lump between the markers in the WAD.
-	for (j = 0; j < (texend - texstart); j++)
-	{
-		UINT16 wadnum = (UINT16)w;
-		lumpnum_t lumpnum = texstart + j;
-
-		if (W_FileHasFolders(wadfiles[w]))
-		{
-			if (W_IsLumpFolder(wadnum, lumpnum)) // Check if lump is a folder
-				continue; // If it is then SKIP IT
-		}
-
-		patchlump = (softwarepatch_t *)W_CacheLumpNumPwad(wadnum, lumpnum, PU_STATIC);
-
-		//CONS_Printf("\n\"%s\" is a single patch, dimensions %d x %d",W_CheckNameForNumPwad((wadnum, lumpnum), patchlump->width, patchlump->height);
-		texture = textures[i] = Z_Calloc(sizeof(texture_t) + sizeof(texpatch_t), PU_STATIC, NULL);
-
-		// Set texture properties.
-		M_Memcpy(texture->name, W_CheckNameForNumPwad(wadnum, lumpnum), sizeof(texture->name));
-		texture->hash = quickncasehash(texture->name, 8);
-		texture->width = SHORT(patchlump->width);
-		texture->height = SHORT(patchlump->height);
-		texture->type = TEXTURETYPE_SINGLEPATCH;
-		texture->patchcount = 1;
-		texture->holes = false;
-
-		// Allocate information for the texture's patches.
-		patch = &texture->patches[0];
-
-		patch->originx = patch->originy = 0;
-		patch->wad = wadnum;
-		patch->lump = texstart + j;
-
-		Z_Free(patchlump);
-
-		// determine width power of 2
-#if 1
-        // [WDJ] only need to determine if exact power of 2.
-        k = 1;
-        while (k < texture->width)
-            k<<=1;
-#else
-		// Largest power of 2 that fits within width.
-		k = 1;
-		while (k << 1 <= texture->width)
-			k <<= 1;
-#endif
-		if (k != texture->width)
-		{
-			// Odd width
-			k = 1;  // make texturewidthmask = 0
-		}
-
-		texturewidthmask[i] = k - 1;
-		textureheight[i] = texture->height << FRACBITS;
-		i++;
-	}
-
-	return i;
-}
-
-static INT32
-count_range
-(		const char * marker_start,
-		const char * marker_end,
-		const char * folder,
-		UINT16 wadnum)
-{
-	UINT16 j;
-	UINT16 texstart, texend;
-	INT32 count = 0;
-
-	// Count flats
-	if (W_FileHasFolders(wadfiles[wadnum]))
-	{
-		texstart = W_CheckNumForFolderStartPK3(folder, wadnum, 0);
-		texend = W_CheckNumForFolderEndPK3(folder, wadnum, texstart);
-	}
-	else
-	{
-		texstart = W_CheckNumForMarkerStartPwad(marker_start, wadnum, 0);
-		texend = W_CheckNumForNamePwad(marker_end, wadnum, texstart);
-	}
-
-	if (texstart != INT16_MAX && texend != INT16_MAX)
-	{
-		// PK3s have subfolders, so we can't just make a simple sum
-		if (W_FileHasFolders(wadfiles[wadnum]))
-		{
-			for (j = texstart; j < texend; j++)
-			{
-				if (!W_IsLumpFolder(wadnum, j)) // Check if lump is a folder; if not, then count it
-					count++;
-			}
-		}
-		else // Add all the textures between markers
-		{
-			count += (texend - texstart);
-		}
-	}
-
-	return count;
-}
-
-static INT32 R_CountTextures(UINT16 wadnum)
-{
-	UINT16 texturesLumpPos;
-	INT32 count = 0;
 
 	// Load patches and textures.
 
@@ -674,80 +554,152 @@ static INT32 R_CountTextures(UINT16 wadnum)
 	// the markers.
 	// This system will allocate memory for all duplicate/patched textures even if it never uses them,
 	// but the alternative is to spend a ton of time checking and re-checking all previous entries just to skip any potentially patched textures.
-
-	// Count the textures from TEXTURES lumps
-	texturesLumpPos = W_CheckNumForNamePwad("TEXTURES", wadnum, 0);
-
-	while (texturesLumpPos != INT16_MAX)
+	for (w = 0, numtextures = 0; w < numwadfiles; w++)
 	{
-		count += R_CountTexturesInTEXTURESLump(wadnum, texturesLumpPos);
-		texturesLumpPos = W_CheckNumForNamePwad("TEXTURES", wadnum, texturesLumpPos + 1);
+		if (W_FileHasFolders(wadfiles[w]))
+		{
+			texstart = W_CheckNumForFolderStartPK3("textures/", (UINT16)w, 0);
+			texend = W_CheckNumForFolderEndPK3("textures/", (UINT16)w, texstart);
+		}
+		else
+		{
+			texstart = W_CheckNumForNamePwad(TX_START, (UINT16)w, 0) + 1;
+			texend = W_CheckNumForNamePwad(TX_END, (UINT16)w, 0);
+		}
+
+		texturesLumpPos = W_CheckNumForNamePwad("TEXTURES", (UINT16)w, 0);
+		while (texturesLumpPos != INT16_MAX)
+		{
+			numtextures += R_CountTexturesInTEXTURESLump((UINT16)w, (UINT16)texturesLumpPos);
+			texturesLumpPos = W_CheckNumForNamePwad("TEXTURES", (UINT16)w, texturesLumpPos + 1);
+		}
+
+		// Add all the textures between TX_START and TX_END
+		if (texstart == INT16_MAX || texend == INT16_MAX)
+			continue;
+
+		// PK3s have subfolders, so we can't just make a simple sum
+		if (W_FileHasFolders(wadfiles[w]))
+		{
+			for (j = texstart; j < texend; j++)
+			{
+				if (W_IsLumpFolder((UINT16)w, j)) // Check if lump is a folder; if not, then count it
+					continue;
+
+				numtextures++;
+			}
+		}
+		else
+		{
+			numtextures += (UINT32)(texend - texstart);
+		}
 	}
 
-	// Count single-patch textures
-	count += count_range(TX_START, TX_END, "textures/", wadnum);
-
-	return count;
-}
-
-static void
-recallocuser
-(		void * user,
-		size_t old,
-		size_t new)
-{
-	char *p = Z_Realloc(*(void**)user,
-			new, PU_STATIC, user);
-
-	if (new > old)
-		memset(&p[old], 0, (new - old));
-}
-
-static void R_AllocateTextures(INT32 add)
-{
-	const INT32 newtextures = (numtextures + add);
-	const size_t newsize = newtextures * sizeof (void*);
-	const size_t oldsize = numtextures * sizeof (void*);
-
-	INT32 i;
+	// If no textures found by this point, bomb out
+	if (!numtextures)
+		I_Error("No textures detected in any WADs!\n");
 
 	// Allocate memory and initialize to 0 for all the textures we are initialising.
-	recallocuser(&textures, oldsize, newsize);
+	// There are actually 5 buffers allocated in one for convenience.
+	textures = Z_Calloc((numtextures * sizeof(void *)) * 5, PU_STATIC, NULL);
 
 	// Allocate texture column offset table.
-	recallocuser(&texturecolumnofs, oldsize, newsize);
+	texturecolumnofs = (void *)((UINT8 *)textures + (numtextures * sizeof(void *)));
 	// Allocate texture referencing cache.
-	recallocuser(&texturecache, oldsize, newsize);
-	// Allocate texture width table.
-	recallocuser(&texturewidthmask, oldsize, newsize);
-	// Allocate texture height table.
-	recallocuser(&textureheight, oldsize, newsize);
+	texturecache     = (void *)((UINT8 *)textures + ((numtextures * sizeof(void *)) * 2));
+	// Allocate texture width mask table.
+	texturewidthmask = (void *)((UINT8 *)textures + ((numtextures * sizeof(void *)) * 3));
+	// Allocate texture height mask table.
+	textureheight    = (void *)((UINT8 *)textures + ((numtextures * sizeof(void *)) * 4));
 	// Create translation table for global animation.
-	Z_Realloc(texturetranslation, (newtextures + 1) * sizeof(*texturetranslation), PU_STATIC, &texturetranslation);
+	texturetranslation = Z_Malloc((numtextures + 1) * sizeof(*texturetranslation), PU_STATIC, NULL);
 
-	for (i = 0; i < numtextures; ++i)
-	{
-		// R_FlushTextureCache relies on the user for
-		// Z_Free, texturecache has been reallocated so the
-		// user is now garbage memory.
-		Z_SetUser(texturecache[i], (void**)&texturecache[i]);
-	}
-
-	while (i < newtextures)
-	{
+	for (i = 0; i < numtextures; i++)
 		texturetranslation[i] = i;
-		i++;
+
+	for (i = 0, w = 0; w < numwadfiles; w++)
+	{
+		// Get the lump numbers for the markers in the WAD, if they exist.
+		if (W_FileHasFolders(wadfiles[w]))
+		{
+			texstart = W_CheckNumForFolderStartPK3("textures/", (UINT16)w, 0);
+			texend = W_CheckNumForFolderEndPK3("textures/", (UINT16)w, texstart);
+			texturesLumpPos = W_CheckNumForNamePwad("TEXTURES", (UINT16)w, 0);
+			while (texturesLumpPos != INT16_MAX)
+			{
+				R_ParseTEXTURESLump(w, texturesLumpPos, &i);
+				texturesLumpPos = W_CheckNumForNamePwad("TEXTURES", (UINT16)w, texturesLumpPos + 1);
+			}
+		}
+		else
+		{
+			texstart = W_CheckNumForNamePwad(TX_START, (UINT16)w, 0) + 1;
+			texend = W_CheckNumForNamePwad(TX_END, (UINT16)w, 0);
+			texturesLumpPos = W_CheckNumForNamePwad("TEXTURES", (UINT16)w, 0);
+			if (texturesLumpPos != INT16_MAX)
+				R_ParseTEXTURESLump(w, texturesLumpPos, &i);
+		}
+
+		if (texstart == INT16_MAX || texend == INT16_MAX)
+			continue;
+
+		// Work through each lump between the markers in the WAD.
+		for (j = 0; j < (texend - texstart); j++)
+		{
+			UINT16 wadnum = (UINT16)w;
+			lumpnum_t lumpnum = texstart + j;
+
+			if (W_FileHasFolders(wadfiles[w]))
+			{
+				if (W_IsLumpFolder(wadnum, lumpnum)) // Check if lump is a folder
+					continue; // If it is then SKIP IT
+			}
+
+			patchlump = (softwarepatch_t *)W_CacheLumpNumPwad(wadnum, lumpnum, PU_STATIC);
+
+			//CONS_Printf("\n\"%s\" is a single patch, dimensions %d x %d",W_CheckNameForNumPwad(wadnum, lumpnum), patchlump->width, patchlump->height);
+			texture = textures[i] = Z_Calloc(sizeof(texture_t) + sizeof(texpatch_t), PU_STATIC, NULL);
+
+			// Set texture properties.
+			M_Memcpy(texture->name, W_CheckNameForNumPwad(wadnum, lumpnum), sizeof(texture->name));
+			texture->width = SHORT(patchlump->width);
+			texture->height = SHORT(patchlump->height);
+			texture->type = TEXTURETYPE_SINGLEPATCH;
+			texture->patchcount = 1;
+			texture->holes = false;
+
+			// Allocate information for the texture's patches.
+			patch = &texture->patches[0];
+
+			patch->originx = patch->originy = 0;
+			patch->wad = wadnum;
+			patch->lump = texstart + j;
+
+			Z_Free(patchlump);
+
+			// determine width power of 2
+#if 1
+			// [WDJ] only need to determine if exact power of 2.
+			k = 1;
+			while (k < texture->width)
+				k<<=1;
+#else
+			// Largest power of 2 that fits within width.
+			k = 1;
+			while (k << 1 <= texture->width)
+				k <<= 1;
+#endif
+			if (k != texture->width)
+			{
+				// Odd width
+				k = 1;  // make texturewidthmask = 0
+			}
+
+			texturewidthmask[i] = k - 1;
+			textureheight[i] = texture->height << FRACBITS;
+			i++;
+		}
 	}
-}
-
-static INT32 R_DefineTextures(INT32 i, UINT16 w)
-{
-	return Rloadtextures(i, w);
-}
-
-static void R_FinishLoadingTextures(INT32 add)
-{
-	numtextures += add;
 
 #ifdef HWRENDER
 	if (rendermode == render_opengl)
@@ -755,46 +707,6 @@ static void R_FinishLoadingTextures(INT32 add)
 #endif
 }
 
-//
-// R_LoadTextures
-// Initializes the texture list with the textures from the world map.
-//
-void R_LoadTextures(void)
-{
-	INT32 i, w;
-	INT32 newtextures = 0;
-
-	for (w = 0; w < numwadfiles; w++)
-	{
-		newtextures += R_CountTextures((UINT16)w);
-	}
-
-	// If no textures found by this point, bomb out
-	if (!newtextures)
-		I_Error("No textures detected in any WADs!\n");
-
-	R_AllocateTextures(newtextures);
-
-	for (i = 0, w = 0; w < numwadfiles; w++)
-	{
-		i = R_DefineTextures(i, w);
-	}
-
-	R_FinishLoadingTextures(i);
-}
-
-void R_LoadTexturesPwad(UINT16 wadnum)
-{
-	INT32 newtextures = R_CountTextures(wadnum);
-
-	if (!newtextures)
-		return;
-
-	R_AllocateTextures(newtextures);
-	newtextures = R_DefineTextures(numtextures, wadnum) - numtextures;
-	R_FinishLoadingTextures(newtextures);
-}
-
 static texpatch_t *R_ParsePatch(boolean actuallyLoadPatch)
 {
 	char *texturesToken;
@@ -1046,7 +958,6 @@ static texture_t *R_ParseTexture(boolean actuallyLoadTexture)
 			// Allocate memory for a zero-patch texture. Obviously, we'll be adding patches momentarily.
 			resultTexture = (texture_t *)Z_Calloc(sizeof(texture_t), PU_STATIC, NULL);
 			M_Memcpy(resultTexture->name, newTextureName, 8);
-			resultTexture->hash = quickncasehash(newTextureName, 8);
 			resultTexture->width = newTextureWidth;
 			resultTexture->height = newTextureHeight;
 			resultTexture->type = TEXTURETYPE_COMPOSITE;
@@ -1830,22 +1741,19 @@ void R_ClearTextureNumCache(boolean btell)
 INT32 R_CheckTextureNumForName(const char *name)
 {
 	INT32 i;
-	UINT32 hash;
 
 	// "NoTexture" marker.
 	if (name[0] == '-')
 		return 0;
 
-	hash = quickncasehash(name, 8);
-
 	for (i = 0; i < tidcachelen; i++)
-		if (tidcache[i].hash == hash && !strncasecmp(tidcache[i].name, name, 8))
+		if (!strncasecmp(tidcache[i].name, name, 8))
 			return tidcache[i].id;
 
 	// Need to parse the list backwards, so textures loaded more recently are used in lieu of ones loaded earlier
 	//for (i = 0; i < numtextures; i++) <- old
 	for (i = (numtextures - 1); i >= 0; i--) // <- new
-		if (textures[i]->hash == hash && !strncasecmp(textures[i]->name, name, 8))
+		if (!strncasecmp(textures[i]->name, name, 8))
 		{
 			tidcachelen++;
 			Z_Realloc(tidcache, tidcachelen * sizeof(*tidcache), PU_STATIC, &tidcache);
@@ -1854,7 +1762,6 @@ INT32 R_CheckTextureNumForName(const char *name)
 #ifndef ZDEBUG
 			CONS_Debug(DBG_SETUP, "texture #%s: %s\n", sizeu1(tidcachelen), tidcache[tidcachelen-1].name);
 #endif
-			tidcache[tidcachelen-1].hash = hash;
 			tidcache[tidcachelen-1].id = i;
 			return i;
 		}

src/r_data.h

@@ -53,7 +53,6 @@ typedef struct
 	// Keep name for switch changing, etc.
 	char name[8];
 	UINT8 type; // TEXTURETYPE_
-	UINT32 hash;
 	INT16 width, height;
 	boolean holes;
 	// All the patches[patchcount] are drawn back to front into the cached texture.
@@ -77,7 +76,6 @@ extern CV_PossibleValue_t Color_cons_t[];
 
 // Load TEXTURE1/TEXTURE2/PNAMES definitions, create lookup tables
 void R_LoadTextures(void);
-void R_LoadTexturesPwad(UINT16 wadnum);
 void R_FlushTextureCache(void);
 
 UINT8 *R_GenerateTexture(size_t texnum);