src/CMakeLists.txt

@@ -54,7 +54,7 @@ set(SRB2_CORE_SOURCES
 	string.c
 	tables.c
 	v_video.c
-	w_wad.c
+	w_wad.cpp
 	y_inter.c
 	z_zone.cpp
 )

src/console.h

@@ -13,6 +13,10 @@
 #ifndef __CONSOLE__
 #define __CONSOLE__
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include "d_event.h"
 #include "command.h"
 #include "i_threads.h"
@@ -63,4 +67,8 @@ boolean CON_Ready(void);
 
 void CON_LogMessage(const char *msg);
 
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
 #endif

src/dedicated/i_system.c

@@ -1384,6 +1384,7 @@ static void I_Fork(void)
 
 INT32 I_StartupSystem(void)
 {
+	W_Startup();
 	I_StartupConsole();
 #ifdef NEWSIGNALHANDLER
 	// This is useful when debugging. It lets GDB attach to

src/dehacked.h

@@ -13,6 +13,10 @@
 #ifndef __DEHACKED_H__
 #define __DEHACKED_H__
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include "m_fixed.h" // for get_number
 #include "info.h"
 
@@ -71,4 +75,9 @@ typedef struct
 } MYFILE;
 #define myfeof(a) (a->data + a->size <= a->curpos)
 char *myfgets(char *buf, size_t bufsize, MYFILE *f);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
 #endif

src/doomdef.h

@@ -516,22 +516,6 @@ extern boolean capslock;
 // i_system.c, replace getchar() once the keyboard has been appropriated
 INT32 I_GetKey(void);
 
-/* http://www.cse.yorku.ca/~oz/hash.html */
-static inline
-UINT32 quickncasehash (const char *p, size_t n)
-{
-	size_t i = 0;
-	UINT32 x = 5381;
-
-	while (i < n && p[i])
-	{
-		x = (x * 33) ^ tolower(p[i]);
-		i++;
-	}
-
-	return x;
-}
-
 #ifndef __cplusplus
 #ifndef min // Double-Check with WATTCP-32's cdefs.h
 #define min(x, y) (((x) < (y)) ? (x) : (y))

src/hardware/hw_cache.c

@@ -15,8 +15,6 @@
 
 #ifdef HWRENDER
 
-#include <unordered_set>
-
 #include "hw_main.h"
 #include "hw_glob.h"
 #include "hw_gl.h"
@@ -100,7 +98,7 @@ static void HWR_DrawColumnInCache(const column_t *patchcol, UINT8 *block, GLMipm
 			position = 0;
 		}
 
-		position = std::max(((position * scale_y) + (FRACUNIT/2)) >> FRACBITS, 0);
+		position = max(((position * scale_y) + (FRACUNIT/2)) >> FRACBITS, 0);
 
 		if (position + count >= pblockheight)
 			count = pblockheight - position;
@@ -164,7 +162,7 @@ static void HWR_DrawPatchInCache(GLMipmap_t *mipmap,
 	fixed_t xfrac, xfracstep;
 	fixed_t yfracstep, scale_y;
 	const column_t *patchcol;
-	UINT8 *block = static_cast<UINT8 *>(mipmap->data);
+	UINT8 *block = (UINT8 *)(mipmap->data);
 	INT32 bpp;
 	INT32 blockmodulo;
 	RGBA_t *palette;
@@ -214,7 +212,7 @@ static void HWR_DrawTexturePatchInCache(GLMipmap_t *mipmap,
 	fixed_t xfrac, xfracstep;
 	fixed_t yfracstep, scale_y;
 	const column_t *patchcol;
-	UINT8 *block = static_cast<UINT8 *>(mipmap->data);
+	UINT8 *block = (UINT8 *)(mipmap->data);
 	INT32 bpp;
 	INT32 blockmodulo;
 	INT32 width, height;
@@ -290,7 +288,7 @@ static UINT8 *MakeBlock(GLMipmap_t *glMipmap)
 	INT32 blocksize = (glMipmap->width * glMipmap->height);
 
 	bpp = format2bpp(glMipmap->format);
-	block = static_cast<UINT8 *>(Z_Malloc(blocksize*bpp, PU_HWRCACHE, &(glMipmap->data)));
+	block = (UINT8 *)(Z_Malloc(blocksize*bpp, PU_HWRCACHE, &(glMipmap->data)));
 
 	switch (bpp)
 	{
@@ -327,7 +325,7 @@ static void HWR_GenerateTexture(INT32 texnum, GLMapTexture_t *gltex, boolean noe
 	texture = textures[texnum];
 
 	gltex->mipmap.flags = TF_CHROMAKEYED | TF_WRAPXY;
-	gltex->mipmap.format = static_cast<GLTextureFormat_t>(textureformat);
+	gltex->mipmap.format = (GLTextureFormat_t)(textureformat);
 
 	// hack the Legacy skies..
 	if (UNLIKELY(memcmp(texture->name, "SKY", 3) == 0 &&
@@ -346,7 +344,7 @@ static void HWR_GenerateTexture(INT32 texnum, GLMapTexture_t *gltex, boolean noe
 		colormap += COLORMAP_REMAPOFFSET;
 #endif
 
-	gltex->mipmap.colormap = static_cast<GLColormap_t *>(Z_Calloc(sizeof(*gltex->mipmap.colormap), PU_HWRPATCHCOLMIPMAP, NULL));
+	gltex->mipmap.colormap = (GLColormap_t *)(Z_Calloc(sizeof(*gltex->mipmap.colormap), PU_HWRPATCHCOLMIPMAP, NULL));
 	gltex->mipmap.colormap->source = colormap;
 	memcpy(gltex->mipmap.colormap->data, colormap, 256 * sizeof(UINT8));
 
@@ -379,7 +377,7 @@ static void HWR_GenerateTexture(INT32 texnum, GLMapTexture_t *gltex, boolean noe
 	// Composite the columns together.
 	for (i = 0, patch = texture->patches; i < texture->patchcount; i++, patch++)
 	{
-		pdata = static_cast<UINT8 *>(W_CacheLumpNumPwad(patch->wad, patch->lump, PU_LEVEL));
+		pdata = (UINT8 *)(W_CacheLumpNumPwad(patch->wad, patch->lump, PU_LEVEL));
 		realpatch = (softwarepatch_t *)pdata;
 
 		HWR_DrawTexturePatchInCache(&gltex->mipmap, blockwidth, blockheight, texture, patch, realpatch);
@@ -415,7 +413,7 @@ void HWR_MakePatch(const patch_t *patch, GLPatch_t *glPatch, GLMipmap_t *glMipma
 		glMipmap->flags = 0;
 
 		// setup the texture info
-		glMipmap->format = static_cast<GLTextureFormat_t>(patchformat);
+		glMipmap->format = (GLTextureFormat_t)(patchformat);
 
 		glPatch->max_s = (float)patch->width / (float)glMipmap->width;
 		glPatch->max_t = (float)patch->height / (float)glMipmap->height;
@@ -457,7 +455,7 @@ static void HWR_FreeTextureData(patch_t *patch)
 	if (!patch || !patch->hardware)
 		return;
 
-	glPatch = static_cast<GLPatch_t *>(patch->hardware);
+	glPatch = (GLPatch_t *)(patch->hardware);
 
 	if (vid.glstate == VID_GL_LIBRARY_LOADED)
 		GL_DeleteTexture(glPatch->mipmap);
@@ -473,7 +471,7 @@ void HWR_FreeTexture(patch_t *patch)
 
 	if (patch->hardware)
 	{
-		GLPatch_t *glPatch = static_cast<GLPatch_t *>(patch->hardware);
+		GLPatch_t *glPatch = (GLPatch_t *)(patch->hardware);
 
 		HWR_FreeTextureColormaps(patch);
 
@@ -499,7 +497,7 @@ static void HWR_FreeTextureColormaps(patch_t *patch)
 	if (!patch)
 		return;
 
-	pat = static_cast<GLPatch_t *>(patch->hardware);
+	pat = (GLPatch_t *)(patch->hardware);
 	if (!pat)
 		return;
 
@@ -614,24 +612,20 @@ void HWR_FreeMapTextures(void)
 	gl_numtextures = 0;
 }
 
+#define NAME    flatcheck
+#define KEY_TY  UINT32
+#define HASH_FN vt_hash_integer
+#define CMPR_FN vt_cmpr_integer
+#include "../verstable.h"
+
 static void HWR_PrecacheLevelFlats(void)
 {
 	// lookup for flats that may´ve been already loaded
-	// too lazy to make a hashtable or smth so unordered set will do :carbuncle:
-	std::unordered_set<UINT32> flatpresent;
+	flatcheck flatpresent;
+	flatcheck_init(&flatpresent);
 	size_t i, j;
 	INT32 k;
 
-	auto load_flat = [&](lumpnum_t lump, boolean noencoremap)
-	{
-		// flat already loaded?
-		if (flatpresent.count(lump) == 0)
-		{
-			HWR_GetFlat(lump, noencoremap);
-			flatpresent.insert(lump);
-		}
-	};
-
 	// special case for encore
 #ifdef GLENCORE
 	if (encoremap)
@@ -649,14 +643,23 @@ static void HWR_PrecacheLevelFlats(void)
 
 				const levelflat_t *levelflat = &levelflats[pic];
 
-				load_flat(levelflat->lumpnum, R_NoEncore(sec, ceiling));
+				if (flatcheck_is_end(flatcheck_get(&flatpresent, levelflat->lumpnum)))
+				{
+					HWR_GetFlat(levelflat->lumpnum, R_NoEncore(sec, ceiling));
+					flatcheck_insert(&flatpresent, levelflat->lumpnum);
+				}
 
 				if (levelflat->speed) // is it an animated flat ?
 				{
 					// start from 0, occasionally basenumlump != flat->lumpnum
 					for (k = 0; k < levelflat->numpics; k++)
 					{
-						load_flat(levelflat->baselumpnum + k, R_NoEncore(sec, ceiling));
+						lumpnum_t lump = levelflat->baselumpnum + k;
+						if (flatcheck_is_end(flatcheck_get(&flatpresent, lump)))
+						{
+							HWR_GetFlat(lump, R_NoEncore(sec, ceiling));
+							flatcheck_insert(&flatpresent, lump);
+						}
 					}
 				}
 			}
@@ -671,18 +674,29 @@ static void HWR_PrecacheLevelFlats(void)
 		{
 			const levelflat_t *levelflat = &levelflats[i];
 
-			load_flat(levelflat->lumpnum, false);
+			if (flatcheck_is_end(flatcheck_get(&flatpresent, levelflat->lumpnum)))
+			{
+				HWR_GetFlat(levelflat->lumpnum, false);
+				flatcheck_insert(&flatpresent, levelflat->lumpnum);
+			}
 
 			if (levelflat->speed) // is it an animated flat ?
 			{
 				// start from 0, occasionally basenumlump != flat->lumpnum
 				for (k = 0; k < levelflat->numpics; k++)
 				{
-					load_flat(levelflat->baselumpnum + k, false);
+					lumpnum_t lump = levelflat->baselumpnum + k;
+					if (flatcheck_is_end(flatcheck_get(&flatpresent, lump)))
+					{
+						HWR_GetFlat(lump, false);
+						flatcheck_insert(&flatpresent, lump);
+					}
 				}
 			}
 		}
 	}
+
+	flatcheck_cleanup(&flatpresent);
 }
 
 static void HWR_PrecacheLevelTextures(void)
@@ -692,7 +706,7 @@ static void HWR_PrecacheLevelTextures(void)
 	size_t i, j, f;
 	INT32 h;
 
-	texturepresent = static_cast<char *>(calloc(gl_numtextures, sizeof(*texturepresent)));
+	texturepresent = (char *)(calloc(gl_numtextures, sizeof(*texturepresent)));
 	if (texturepresent == NULL)
 		I_Error("%s: Out of memory looking up textures", "HWR_PrecacheLevel");
 
@@ -867,7 +881,7 @@ void HWR_LoadMapTextures(size_t pnumtextures)
 	HWR_FreeMapTextures();
 
 	gl_numtextures = pnumtextures;
-	gl_textures = static_cast<GLMapTextureSet_t *>(calloc(gl_numtextures, sizeof(*gl_textures))); // *2 - 1 for encore-remapped texture and another for noencore texture (unused when not in encore), see: GLMapTextureSet_t
+	gl_textures = (GLMapTextureSet_t *)(calloc(gl_numtextures, sizeof(*gl_textures))); // *2 - 1 for encore-remapped texture and another for noencore texture (unused when not in encore), see: GLMapTextureSet_t
 
 	if (gl_textures == NULL)
 		I_Error("HWR_LoadMapTextures: ran out of memory for OpenGL textures. Sad!");
@@ -964,7 +978,7 @@ static void HWR_CacheFlat(GLMipmap_t *glMipmap, lumpnum_t flatlumpnum)
 	W_ReadLump(flatlumpnum, Z_Malloc(size, PU_HWRCACHE, &glMipmap->data));
 
 #ifdef GLENCORE
-	flat = static_cast<UINT8 *>(glMipmap->data);
+	flat = (UINT8 *)(glMipmap->data);
 	for (steppy = 0; steppy < size; steppy++)
 	{
 		if (flat[steppy] == HWR_PATCHES_CHROMAKEY_COLORINDEX)
@@ -1008,7 +1022,7 @@ void HWR_GetFlat(lumpnum_t flatlumpnum, boolean noencoremap)
 		if (!noencoremap && encoremap)
 			colormap += COLORMAP_REMAPOFFSET;
 #endif
-		glMipmap->colormap = static_cast<GLColormap_t *>(Z_Calloc(sizeof(*glMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL));
+		glMipmap->colormap = (GLColormap_t *)(Z_Calloc(sizeof(*glMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL));
 		glMipmap->colormap->source = colormap;
 		memcpy(glMipmap->colormap->data, colormap, 256 * sizeof(UINT8));
 	}
@@ -1032,7 +1046,7 @@ void HWR_GetFlat(lumpnum_t flatlumpnum, boolean noencoremap)
 // --------------------+
 static void HWR_LoadPatchMipmap(patch_t *patch, GLMipmap_t *glMipmap)
 {
-	GLPatch_t *glPatch = static_cast<GLPatch_t *>(patch->hardware);
+	GLPatch_t *glPatch = (GLPatch_t *)(patch->hardware);
 
 	if (!glMipmap->downloaded)
 	{
@@ -1053,7 +1067,7 @@ static void HWR_LoadPatchMipmap(patch_t *patch, GLMipmap_t *glMipmap)
 // ----------------------+
 static void HWR_UpdatePatchMipmap(patch_t *patch, GLMipmap_t *glMipmap)
 {
-	GLPatch_t *glPatch = static_cast<GLPatch_t *>(patch->hardware);
+	GLPatch_t *glPatch = (GLPatch_t *)(patch->hardware);
 	HWR_MakePatch(patch, glPatch, glMipmap, true);
 
 	// If hardware does not have the texture, then call GL_SetTexture to upload it
@@ -1089,7 +1103,7 @@ void HWR_GetMappedPatch(patch_t *patch, const UINT8 *colormap)
 
 	if (!patch->hardware)
 		Patch_CreateGL(patch);
-	glPatch = static_cast<GLPatch_t *>(patch->hardware);
+	glPatch = (GLPatch_t *)(patch->hardware);
 
 	// Blatant hack for encore colormapping aside...
 	if (colormap == colormaps || colormap == NULL || colormap == (const UINT8*)(COLORMAP_REMAPOFFSET))
@@ -1125,12 +1139,12 @@ void HWR_GetMappedPatch(patch_t *patch, const UINT8 *colormap)
 	//              (it have a liste of mipmap)
 	//    this malloc is cleared in HWR_FreeColormapCache
 	//    (...) unfortunately z_malloc fragment alot the memory :(so malloc is better
-	newMipmap = static_cast<GLMipmap_t *>(calloc(1, sizeof (*newMipmap)));
+	newMipmap = (GLMipmap_t *)(calloc(1, sizeof (*newMipmap)));
 	if (newMipmap == NULL)
 		I_Error("%s: Out of memory", "HWR_GetMappedPatch");
 	glMipmap->nextcolormap = newMipmap;
 
-	newMipmap->colormap = static_cast<GLColormap_t *>(Z_Calloc(sizeof(*newMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL));
+	newMipmap->colormap = (GLColormap_t *)(Z_Calloc(sizeof(*newMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL));
 	newMipmap->colormap->source = colormap;
 	memcpy(newMipmap->colormap->data, colormap, 256 * sizeof(UINT8));
 
@@ -1153,7 +1167,7 @@ patch_t *HWR_GetCachedGLPatchPwad(UINT16 wadnum, UINT16 lumpnum)
 	{
 		void *ptr = Z_Calloc(sizeof(patch_t), PU_PATCH, &lumpcache[lumpnum]);
 		Patch_Create(NULL, 0, ptr);
-		Patch_AllocateHardwarePatch(static_cast<patch_t *>(ptr));
+		Patch_AllocateHardwarePatch((patch_t *)(ptr));
 	}
 
 	return (patch_t *)(lumpcache[lumpnum]);
@@ -1170,7 +1184,7 @@ static void HWR_DrawFadeMaskInCache(GLMipmap_t *mipmap, INT32 pblockwidth, INT32
 {
 	INT32 i,j;
 	fixed_t posx, posy, stepx, stepy;
-	UINT8 *block = static_cast<UINT8 *>(mipmap->data); // places the data directly into here
+	UINT8 *block = (UINT8 *)(mipmap->data); // places the data directly into here
 	UINT8 *flat;
 	UINT8 *dest, *src, texel;
 	RGBA_t col;
@@ -1326,7 +1340,7 @@ void HWR_SetPalette(RGBA_t *palette)
 static void HWR_SetPaletteLookup(RGBA_t *palette)
 {
 	int r, g, b;
-	UINT8 *lut = static_cast<UINT8 *>(Z_Malloc(
+	UINT8 *lut = (UINT8 *)(Z_Malloc(
 		HWR_PALETTE_LUT_SIZE*HWR_PALETTE_LUT_SIZE*HWR_PALETTE_LUT_SIZE*sizeof(UINT8),
 		PU_STATIC, NULL));
 #define STEP_SIZE (256/HWR_PALETTE_LUT_SIZE)
@@ -1371,7 +1385,7 @@ void HWR_SetMapPalette(void)
 		if (palsize < 768) // 256 * 3
 			I_Error("HWR_SetMapPalette: A programmer assumed palette lumps are at least 768 bytes long, but apparently this was a wrong assumption!\n");
 
-		RGB_data = static_cast<UINT8 *>(W_CacheLumpNum(lumpnum, PU_CACHE));
+		RGB_data = (UINT8 *)(W_CacheLumpNum(lumpnum, PU_CACHE));
 		// we got the RGB palette now, but we need it in RGBA format.
 		for (i = 0; i < 256; i++)
 		{
@@ -1406,7 +1420,7 @@ static UINT32 HWR_CreateLightTable(UINT8 *lighttable)
 {
 	UINT32 i, id;
 	RGBA_t *palette = HWR_GetTexturePalette();
-	RGBA_t *hw_lighttable = static_cast<RGBA_t *>(Z_Malloc(256 * 32 * sizeof(RGBA_t), PU_STATIC, NULL));
+	RGBA_t *hw_lighttable = (RGBA_t *)(Z_Malloc(256 * 32 * sizeof(RGBA_t), PU_STATIC, NULL));
 
 	// To make the palette index -> RGBA mapping easier for the shader,
 	// the hardware lighttable is composed of RGBA colors instead of palette indices.

src/hardware/hw_data.h

@@ -54,7 +54,7 @@ struct GLMipmap_s
 	UINT16					width, height;
 	UINT32					downloaded; // The GPU has this texture.
 
-	struct	GLMipmap_s		*nextcolormap;
+	struct GLMipmap_s		*nextcolormap;
 	struct GLColormap_s		*colormap;
 };
 typedef struct GLMipmap_s GLMipmap_t;

src/lzf.h

@@ -13,6 +13,10 @@
 #define LZF_H
 #include <stdio.h>
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /***********************************************************************
 **
 **	lzf -- an extremely fast/free compression/decompression-method
@@ -71,5 +75,9 @@ size_t
 lzf_decompress (const void *const in_data,  size_t in_len,
                 void             *out_data, size_t out_len);
 
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
 #endif
 

src/m_misc.c

@@ -1956,6 +1956,22 @@ UINT32 FNV1a_Hash(const char *message, size_t size)
 	return hash;
 }
 
+// Behaves like the old quickncasehash
+// Stops either if it encounters null terminator
+// or reaches size
+UINT32 FNV1a_QuickCaseHash(const char *message, size_t size)
+{
+	UINT32 hash = FNV1A_OFFSET_BASIS;
+
+	for (size_t i = 0; i < size && message[i]; i++)
+	{
+		hash ^= tolower(message[i]);
+		hash *= FNV1A_PRIME;
+	}
+
+	return hash;
+}
+
 UINT32 FNV1a_HashString(const char *message)
 {
 	UINT32 hash = FNV1A_OFFSET_BASIS;

src/m_misc.h

@@ -123,6 +123,7 @@ FUNCMATH UINT8 M_CountBits(UINT32 num, UINT8 size);
 
 // Hashes some message using FNV-1a
 UINT32 FNV1a_Hash(const char *message, size_t size);
+UINT32 FNV1a_QuickCaseHash(const char *message, size_t size);
 UINT32 FNV1a_HashString(const char *message);
 UINT32 FNV1a_HashLowercaseString(const char *message);
 

src/md5.h

@@ -16,6 +16,10 @@
 #ifndef _MD5_H
 #define _MD5_H 1
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include <stdio.h>
 
 #if defined (HAVE_LIMITS_H) || (defined (_LIBC) && _LIBC) || defined (_WIN32)
@@ -52,4 +56,8 @@ int md5_stream(FILE *stream, void *resblock) THROWFUNC;
 	digest.  */
 extern void *md5_buffer(const char *buffer, size_t len, void *resblock) THROWFUNC;
 
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
 #endif /* md5.h */

src/r_data.c

@@ -622,7 +622,7 @@ Rloadtextures (INT32 i, INT32 w)
 
 		// Set texture properties.
 		memcpy(texture->name, W_CheckNameForNumPwad(wadnum, lumpnum), sizeof(texture->name));
-		texture->hash = quickncasehash(texture->name, 8);
+		texture->hash = FNV1a_QuickCaseHash(texture->name, 8);
 
 		texture->width = SHORT(patchlump.width);
 		texture->height = SHORT(patchlump.height);
@@ -1066,7 +1066,7 @@ 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);
 			memcpy(resultTexture->name, newTextureName, 8);
-			resultTexture->hash = quickncasehash(newTextureName, 8);
+			resultTexture->hash = FNV1a_QuickCaseHash(newTextureName, 8);
 			resultTexture->width = newTextureWidth;
 			resultTexture->height = newTextureHeight;
 			resultTexture->type = TEXTURETYPE_COMPOSITE;
@@ -1755,7 +1755,7 @@ INT32 R_CheckTextureNumForName(const char *name)
 	if (name[0] == '-')
 		return 0;
 
-	hash = quickncasehash(name, 8);
+	hash = FNV1a_QuickCaseHash(name, 8);
 
 	for (i = 0; i < tidcachelen; i++)
 		if (tidcache[i].hash == hash && !strncasecmp(tidcache[i].name, name, 8))

src/s_sound.c

@@ -1301,7 +1301,7 @@ static boolean ReadMusicDefFields(UINT16 wadnum, int line, char *stoken, musicde
 
 				STRBUFCPY(def->name, value);
 				strlwr(def->name);
-				def->hash = quickncasehash (def->name, 6);
+				def->hash = FNV1a_QuickCaseHash(def->name, 6);
 			}
 
 			(*defp) = def;
@@ -1483,7 +1483,7 @@ void S_InitMusicDefs(void)
 //
 musicdef_t *S_FindMusicCredit(const char *musname)
 {
-	UINT32 hash = quickncasehash(musname, 6);
+	UINT32 hash = FNV1a_QuickCaseHash(musname, 6);
 	musicdef_t *def;
 
 	for (INT32 i = 0; i < nummusicdefs; ++i)

src/sdl/i_system.cpp

@@ -1886,6 +1886,9 @@ INT32 I_StartupSystem(void)
 	SDL_version SDLlinked;
 	SDL_VERSION(&SDLcompiled)
 	SDL_GetVersion(&SDLlinked);
+
+	W_Startup();
+
 	I_StartupConsole();
 #ifdef NEWSIGNALHANDLER
 	// This is useful when debugging. It lets GDB attach to

src/w_wad.c

@@ -87,18 +87,32 @@ typedef struct
 } lumpchecklist_t;
 
 // Must be a power of two
-#define LUMPNUMCACHESIZE 64
+#define LUMPNUMCACHESIZE 2048 // should be reasonable ig
 #define LUMPNUMCACHENAME 32
 
-typedef struct lumpnum_cache_s
-{
-	char lumpname[LUMPNUMCACHENAME];
-	lumpnum_t lumpnum;
-	UINT32 hash;
-} lumpnum_cache_t;
+#define NAME      lumpnum_map
+#define KEY_TY    char *
+#define KEY_GET_CONST
+#define VAL_TY    lumpnum_t
+#define HASH_FN   vt_hash_string
+#define CMPR_FN   vt_cmpr_string
+#define KEY_DTOR_FN free
+#include "verstable.h"
 
-static lumpnum_cache_t lumpnumcache[LUMPNUMCACHESIZE];
-static UINT16 lumpnumcacheindex = 0;
+#define NAME      folder_map
+#define KEY_TY    char *
+#define KEY_GET_CONST
+#define VAL_TY    UINT16
+#define HASH_FN   vt_hash_string
+#define CMPR_FN   vt_cmpr_string
+#define KEY_DTOR_FN free
+#include "verstable.h"
+
+static lumpnum_map lumpnumcache;
+
+typedef struct FolderCache {
+	folder_map map;
+} FolderCache;
 
 static const char pat_central[] = {0x50, 0x4b, 0x01, 0x02, 0x00};
 static const char pat_end[] = {0x50, 0x4b, 0x05, 0x06, 0x00};
@@ -116,6 +130,8 @@ wadfile_t *wadfiles[MAX_WADFILES] = {}; // 0 to numwadfiles-1 are valid
 // being ejected
 void W_Shutdown(void)
 {
+	lumpnum_map_cleanup(&lumpnumcache);
+
 	while (numwadfiles--)
 	{
 		wadfile_t *wad = wadfiles[numwadfiles];
@@ -127,18 +143,28 @@ void W_Shutdown(void)
 
 		while (wad->numlumps--)
 		{
-			Z_Free(wad->lumpinfo[wad->numlumps].longname);
+			//Z_Free(wad->lumpinfo[wad->numlumps].longname);
 			Z_Free(wad->lumpinfo[wad->numlumps].fullname);
 		}
 
-		M_AATreeFree(wad->startfolders);
-		M_AATreeFree(wad->endfolders);
+		folder_map_cleanup(&wad->startfolders->map);
+		free(wad->startfolders);
+		folder_map_cleanup(&wad->endfolders->map);
+		free(wad->endfolders);
 
 		Z_Free(wad->lumpinfo);
 		Z_Free(wad);
 	}
 }
 
+// the lumpnum cache needs to be initialized before use
+// call this as early as possible!
+void W_Startup(void)
+{
+	lumpnum_map_init(&lumpnumcache);
+	lumpnum_map_reserve(&lumpnumcache, LUMPNUMCACHESIZE);
+}
+
 //===========================================================================
 //                                                        LUMP BASED ROUTINES
 //===========================================================================
@@ -259,7 +285,7 @@ static inline void W_LoadDehackedLumpsPK3(UINT16 wadnum)
 			lumpinfo_t *lump_p = &wadfiles[wadnum]->lumpinfo[posStart];
 
 			size_t length = len + 1 + strlen(lump_p->fullname); // length of file name, '|', and lump name
-			char *name = malloc(length + 1);
+			char *name = (char *)(malloc(length + 1));
 
 			if (!name)
 				I_Error("W_LoadDehackedLumpsPK3: Out of memory!\n");
@@ -295,7 +321,7 @@ static inline void W_LoadDehackedLumps(UINT16 wadnum)
 		if (memcmp(lump_p->name, "SOC_", 4) == 0) // Check for generic SOC lump
 		{   // shameless copy+paste of code from LUA_LoadLump
 			size_t length = len + 1 + strlen(lump_p->fullname); // length of file name, '|', and lump name
-			char *name = malloc(length + 1);
+			char *name = (char *)(malloc(length + 1));
 
 			if (!name)
 				I_Error("W_LoadDehackedLumps: Out of memory!\n");
@@ -360,12 +386,12 @@ static inline INT32 W_MakeFileMD5(const char *filename, void *resblock)
 }
 
 // Invalidates the cache of lump numbers. Call this whenever a wad is added.
-static void W_InvalidateLumpnumCache(void)
+FUNCINLINE static ATTRINLINE void W_InvalidateLumpnumCache(void)
 {
-	memset(lumpnumcache, 0, sizeof(lumpnumcache));
+	lumpnum_map_clear(&lumpnumcache);
 }
 
-UINT32 W_HashLumpName(const char *name)
+FUNCINLINE static ATTRINLINE UINT32 W_HashLumpName(const char *name)
 {
 	return FNV1a_HashLowercaseString(name);
 }
@@ -391,28 +417,28 @@ static restype_t ResourceFileDetect(const char* filename)
  */
 static lumpinfo_t* ResGetLumpsStandalone(FILE* handle, UINT16* numlumps, const char* lumpname)
 {
-	lumpinfo_t* lumpinfo = Z_Calloc(sizeof (*lumpinfo), PU_STATIC, NULL);
+	lumpinfo_t* lumpinfo = (lumpinfo_t *)(Z_Calloc(sizeof (*lumpinfo), PU_STATIC, NULL));
 	lumpinfo->position = 0;
 	fseek(handle, 0, SEEK_END);
-	lumpinfo->size = ftell(handle);
+	lumpinfo->size = (size_t)(ftell(handle));
 	fseek(handle, 0, SEEK_SET);
 	strlcpy(lumpinfo->name, lumpname, sizeof(lumpinfo->name));
 	lumpinfo->namelength = strlen(lumpinfo->name);
 	lumpinfo->hash.name = W_HashLumpName(lumpname);
 
 	// Allocate the lump's long name.
-	lumpinfo->longname = Z_Malloc((lumpinfo->namelength + 1) * sizeof(char), PU_STATIC, NULL);
+	/*lumpinfo->longname = (char *)(Z_Malloc((lumpinfo->namelength + 1) * sizeof(char), PU_STATIC, NULL));
 	strcpy(lumpinfo->longname, lumpname);
 	lumpinfo->longname[lumpinfo->namelength] = '\0';
 	lumpinfo->longnamelength = lumpinfo->namelength;
-	lumpinfo->hash.longname = lumpinfo->hash.name;
+	lumpinfo->hash.longname = lumpinfo->hash.name;*/
 
 	// Allocate the lump's full name.
-	lumpinfo->fullname = Z_Malloc((lumpinfo->namelength + 1) * sizeof(char), PU_STATIC, NULL);
+	lumpinfo->fullname = (char *)(Z_Malloc((lumpinfo->namelength + 1) * sizeof(char), PU_STATIC, NULL));
 	strcpy(lumpinfo->fullname, lumpname);
 	lumpinfo->fullname[lumpinfo->namelength] = '\0';
 	lumpinfo->fullnamelength = lumpinfo->namelength;
-	lumpinfo->hash.fullname = lumpinfo->hash.name;
+	//lumpinfo->hash.fullname = lumpinfo->hash.name;
 
 	*numlumps = 1;
 	return lumpinfo;
@@ -456,7 +482,7 @@ static lumpinfo_t* ResGetLumpsWad(FILE* handle, UINT16* nlmp, const char* filena
 
 	// read wad file directory
 	i = header.numlumps * sizeof(*fileinfo);
-	fileinfov = fileinfo = malloc(i);
+	fileinfov = fileinfo = (filelump_t *)(malloc(i));
 
 	if (fseek(handle, header.infotableofs, SEEK_SET) == -1
 	 || fread(fileinfo, 1, i, handle) < i)
@@ -468,7 +494,7 @@ static lumpinfo_t* ResGetLumpsWad(FILE* handle, UINT16* nlmp, const char* filena
 	numlumps = header.numlumps;
 
 	// fill in lumpinfo for this wad
-	lump_p = lumpinfo = Z_Malloc(numlumps * sizeof (*lumpinfo), PU_STATIC, NULL);
+	lump_p = lumpinfo = (lumpinfo_t *)(Z_Malloc(numlumps * sizeof (*lumpinfo), PU_STATIC, NULL));
 
 	for (i = 0; i < numlumps; i++, lump_p++, fileinfo++)
 	{
@@ -512,18 +538,18 @@ static lumpinfo_t* ResGetLumpsWad(FILE* handle, UINT16* nlmp, const char* filena
 		lump_p->hash.name = W_HashLumpName(lump_p->name);
 
 		// Allocate the lump's long name.
-		lump_p->longname = Z_Malloc(9 * sizeof(char), PU_STATIC, NULL);
+		/*lump_p->longname = (char *)(Z_Malloc(9 * sizeof(char), PU_STATIC, NULL));
 		strncpy(lump_p->longname, fileinfo->name, 8);
 		lump_p->longname[8] = '\0';
 		lump_p->longnamelength = lump_p->namelength;
-		lump_p->hash.longname = lump_p->hash.name;
+		lump_p->hash.longname = lump_p->hash.name;*/
 
 		// Allocate the lump's full name.
-		lump_p->fullname = Z_Malloc(9 * sizeof(char), PU_STATIC, NULL);
+		lump_p->fullname = (char *)(Z_Malloc(9 * sizeof(char), PU_STATIC, NULL));
 		strncpy(lump_p->fullname, fileinfo->name, 8);
 		lump_p->fullname[8] = '\0';
 		lump_p->fullnamelength = lump_p->namelength;
-		lump_p->hash.fullname = lump_p->hash.name;
+		//lump_p->hash.fullname = lump_p->hash.name;
 	}
 
 	*nlmp = numlumps;
@@ -540,24 +566,24 @@ static boolean ResFindSignature(FILE* handle, const char endPat[], UINT32 startp
 	int c;
 
 	fseek(handle, 0, SEEK_END);
-	size_t len = ftell(handle);
+	size_t len = (size_t)(ftell(handle));
 
 	fseek(handle, startpos, SEEK_SET);
-	size_t remaining = len - startpos;
-	size_t chunkpos = startpos;
+	size_t remaining = (size_t)(len - startpos);
+	size_t chunkpos = (size_t)(startpos);
 
 	s = endPat;
 
 	//128k buffers
 	size_t buffer_size = min(128 * 1024 * sizeof(char), remaining);
-	CLEANUP(pfree) char* buffer = (char*)(malloc(buffer_size));
+	CLEANUP(pfree) char* buffer = (char *)(malloc(buffer_size));
 
 	size_t bytes_read = 0;
 	while ((bytes_read = fread(buffer, 1, buffer_size, handle)) > 0)
 	{
 		for (size_t i = 0; i < bytes_read; i++)
 		{
-			c = (int)buffer[i];
+			c = (int)(buffer[i]);
 
 			if (*s != c && s > endPat) // No match?
 				s = endPat; // We "reset" the counter by sending the s pointer back to the start of the array.
@@ -569,7 +595,7 @@ static boolean ResFindSignature(FILE* handle, const char endPat[], UINT32 startp
 				if (*s == 0x00) // The array pointer has reached the key char which marks the end. It means we have matched the signature.
 				{
 					//the original function would leave the FILE* seeked to the end of the match
-					size_t foundpos = chunkpos + i + 1;
+					size_t foundpos = (size_t)(chunkpos + i + 1);
 					fseek(handle, foundpos, SEEK_SET);
 					return true;
 				}
@@ -646,7 +672,7 @@ static lumpinfo_t* ResGetLumpsZip(FILE* handle, UINT16* nlmp)
 	// Contains entry number (number of lumps), and central directory start offset.
 	fseek(handle, 0, SEEK_END);
 
-	const long startpos = (ftell(handle) - (22 + 65536));
+	const long startpos = ftell(handle) - (22 + 65536);
 	if (!ResFindSignature(handle, pat_end, max(0l, startpos)))
 	{
 		CONS_Alert(CONS_ERROR, "Missing central directory\n");
@@ -662,11 +688,11 @@ static lumpinfo_t* ResGetLumpsZip(FILE* handle, UINT16* nlmp)
 
 	numlumps = SHORT(zend.entries);
 
-	lump_p = lumpinfo = Z_Malloc(numlumps * sizeof (*lumpinfo), PU_STATIC, NULL);
+	lump_p = lumpinfo = (lumpinfo_t *)(Z_Malloc(numlumps * sizeof (*lumpinfo), PU_STATIC, NULL));
 
 	fseek(handle, LONG(zend.cdiroffset), SEEK_SET);
 
-	CLEANUP(Z_Pfree) char *cdir = Z_Malloc(LONG(zend.cdirsize), PU_STATIC, &cdir);
+	CLEANUP(Z_Pfree) char *cdir = (char *)(Z_Malloc(LONG(zend.cdirsize), PU_STATIC, &cdir));
 
 	if (fread(cdir, 1, LONG(zend.cdirsize), handle) < (UINT32)(LONG(zend.cdirsize)))
 	{
@@ -679,7 +705,7 @@ static lumpinfo_t* ResGetLumpsZip(FILE* handle, UINT16* nlmp)
 
 	for (i = 0; i < numlumps; i++, lump_p++)
 	{
-		zentry_t *zentry = (zentry_t*)(cdir + offset);
+		zentry_t *zentry = (zentry_t *)(cdir + offset);
 		char* fullname;
 		char* trimname;
 		char* dotpos;
@@ -695,7 +721,7 @@ static lumpinfo_t* ResGetLumpsZip(FILE* handle, UINT16* nlmp)
 		lump_p->disksize = LONG(zentry->compsize);
 		lump_p->size = LONG(zentry->size);
 
-		fullname = (char*)(malloc(SHORT(zentry->namelen) + 1));
+		fullname = (char *)(malloc(SHORT(zentry->namelen) + 1));
 		strncpy(fullname, (char *)(zentry + 1), SHORT(zentry->namelen));
 		fullname[zentry->namelen] = 0;
 
@@ -713,15 +739,15 @@ static lumpinfo_t* ResGetLumpsZip(FILE* handle, UINT16* nlmp)
 		lump_p->namelength = strlen(lump_p->name);
 		lump_p->hash.name = W_HashLumpName(lump_p->name);
 
-		lump_p->longname = Z_Calloc(dotpos - trimname + 1, PU_STATIC, NULL);
+		/*lump_p->longname = (char *)(Z_Calloc(dotpos - trimname + 1, PU_STATIC, NULL));
 		strlcpy(lump_p->longname, trimname, dotpos - trimname + 1);
 		lump_p->longnamelength = strlen(lump_p->longname);
-		lump_p->hash.longname = W_HashLumpName(lump_p->longname);
+		lump_p->hash.longname = W_HashLumpName(lump_p->longname);*/
 
-		lump_p->fullname = (char*)(Z_Calloc(SHORT(zentry->namelen) + 1, PU_STATIC, NULL));
+		lump_p->fullname = (char *)(Z_Calloc(SHORT(zentry->namelen) + 1, PU_STATIC, NULL));
 		strncpy(lump_p->fullname, fullname, SHORT(zentry->namelen));
 		lump_p->fullnamelength = zentry->namelen;
-		lump_p->hash.fullname = W_HashLumpName(lump_p->fullname);
+		//lump_p->hash.fullname = W_HashLumpName(lump_p->fullname);
 
 		switch(SHORT(zentry->compression))
 		{
@@ -896,17 +922,19 @@ UINT16 W_InitFile(const char *filename, boolean local, boolean startup)
 	//
 	// link wad file to search files
 	//
-	wadfile = Z_Calloc(sizeof (*wadfile), PU_STATIC, NULL);
+	wadfile = (wadfile_t *)(Z_Calloc(sizeof (*wadfile), PU_STATIC, NULL));
 	wadfile->filename = Z_StrDup(filename);
 	wadfile->handle = handle;
-	wadfile->numlumps = (UINT16)numlumps;
+	wadfile->numlumps = (UINT16)(numlumps);
 	wadfile->lumpinfo = lumpinfo;
 	wadfile->important = important;
 	fseek(handle, 0, SEEK_END);
-	wadfile->filesize = (unsigned)ftell(handle);
+	wadfile->filesize = (unsigned)(ftell(handle));
 	wadfile->type = type;
-	wadfile->startfolders = M_AATreeAlloc(AATREE_STRING);
-	wadfile->endfolders = M_AATreeAlloc(AATREE_STRING);
+	wadfile->startfolders = (FolderCache *)malloc(sizeof(FolderCache));
+	folder_map_init(&wadfile->startfolders->map);
+	wadfile->endfolders = (FolderCache *)malloc(sizeof(FolderCache));
+	folder_map_init(&wadfile->endfolders->map);
 
 	// already generated, just copy it over
 	memcpy(&wadfile->md5sum, &md5sum, 16);
@@ -931,7 +959,7 @@ UINT16 W_InitFile(const char *filename, boolean local, boolean startup)
 #ifdef HWRENDER
 	// Read shaders from file
 	if (rendermode == render_opengl && (vid.glstate == VID_GL_LIBRARY_LOADED))
-		HWR_LoadCustomShadersFromFile(numwadfiles - 1, (type == RET_PK3));
+		HWR_LoadCustomShadersFromFile(numwadfiles - 1, (boolean)(type == RET_PK3));
 #endif
 
 	// TODO: HACK ALERT - Load Lua & SOC stuff right here. I feel like this should be out of this place, but... Let's stick with this for now.
@@ -1031,7 +1059,7 @@ INT32 W_AddAutoloadedLocalFiles(char **filenames)
 /** Make sure a lump number is valid.
   * Compiles away to nothing if PARANOIA is not defined.
   */
-static boolean TestValidLump(UINT16 wad, UINT16 lump)
+static inline boolean TestValidLump(UINT16 wad, UINT16 lump)
 {
 	I_Assert(wad < MAX_WADFILES);
 	if (!wadfiles[wad]) // make sure the wad file exists
@@ -1054,7 +1082,7 @@ const char *W_CheckNameForNumPwad(UINT16 wad, UINT16 lump)
 
 const char *W_CheckNameForNum(lumpnum_t lumpnum)
 {
-	return W_CheckNameForNumPwad(WADFILENUM(lumpnum),LUMPNUM(lumpnum));
+	return W_CheckNameForNumPwad(WADFILENUM(lumpnum), LUMPNUM(lumpnum));
 }
 
 //
@@ -1108,7 +1136,7 @@ UINT16 W_CheckNumForNamePwad(const char *name, UINT16 wad, UINT16 startlump)
 // Should be the only version, but that's not possible until we fix
 // all the instances of non null-terminated strings in the codebase...
 //
-UINT16 W_CheckNumForLongNamePwad(const char *name, UINT16 wad, UINT16 startlump)
+/*UINT16 W_CheckNumForLongNamePwad(const char *name, UINT16 wad, UINT16 startlump)
 {
 	UINT16 i;
 	UINT32 hash;
@@ -1140,43 +1168,46 @@ UINT16 W_CheckNumForLongNamePwad(const char *name, UINT16 wad, UINT16 startlump)
 
 	// not found.
 	return INT16_MAX;
-}
+}*/
 
 UINT16 W_CheckNumForMarkerStartPwad(const char *name, UINT16 wad, UINT16 startlump)
 {
 	UINT16 marker;
+
 	marker = W_CheckNumForNamePwad(name, wad, startlump);
 	if (marker != INT16_MAX)
 		marker++; // Do not count the first marker
+
 	return marker;
 }
 
 // Look for the first lump from a folder.
 UINT16 W_CheckNumForFolderStartPK3(const char *name, UINT16 wad, UINT16 startlump)
 {
-	size_t name_length;
-	INT32 i;
+	UINT16 i;
+	size_t namelen;
 	lumpinfo_t *lump_p = wadfiles[wad]->lumpinfo + startlump;
-	name_length = strlen(name);
 
-	void *val = M_AATreeGetString(wadfiles[wad]->startfolders, name);
-	if (val != NULL)
-		return (uintptr_t)val;
+	folder_map_itr it = folder_map_get(&wadfiles[wad]->startfolders->map, name);
+	if (!folder_map_is_end(it))
+		return it.data->val;
+
+	namelen = strlen(name);
 
 	for (i = startlump; i < wadfiles[wad]->numlumps; i++, lump_p++)
 	{
-		if (strnicmp(name, lump_p->fullname, name_length) == 0)
+		if (strnicmp(name, lump_p->fullname, namelen) == 0)
 		{
 			/* SLADE is special and puts a single directory entry. Skip that. */
-			if (strlen(lump_p->fullname) == name_length)
+			if (lump_p->fullnamelength == namelen)
 				i++;
 
-			M_AATreeSetString(wadfiles[wad]->startfolders, name, (void *)(uintptr_t)i);
+			folder_map_insert(&wadfiles[wad]->startfolders->map, strdup(name), i);
 			return i;
 		}
 	}
 
-	M_AATreeSetString(wadfiles[wad]->startfolders, name, (void *)INT16_MAX);
+	folder_map_insert(&wadfiles[wad]->startfolders->map, strdup(name), INT16_MAX);
 	return INT16_MAX;
 }
 
@@ -1185,21 +1216,23 @@ UINT16 W_CheckNumForFolderStartPK3(const char *name, UINT16 wad, UINT16 startlum
 // Returns the position of the lumpinfo entry.
 UINT16 W_CheckNumForFolderEndPK3(const char *name, UINT16 wad, UINT16 startlump)
 {
-	INT32 i;
+	UINT16 i;
+	size_t namelen;
 	lumpinfo_t *lump_p = wadfiles[wad]->lumpinfo + startlump;
-	size_t name_length = strlen(name);
 
-	void *val = M_AATreeGetString(wadfiles[wad]->endfolders, name);
-	if (val != NULL)
-		return (uintptr_t)val;
+	folder_map_itr it = folder_map_get(&wadfiles[wad]->endfolders->map, name);
+	if (!folder_map_is_end(it))
+		return it.data->val;
+
+	namelen = strlen(name);
 
 	for (i = startlump; i < wadfiles[wad]->numlumps; i++, lump_p++)
 	{
-		if (strnicmp(name, lump_p->fullname, name_length))
+		if (strnicmp(name, lump_p->fullname, namelen))
 			break;
 	}
 
-	M_AATreeSetString(wadfiles[wad]->endfolders, name, (void *)(uintptr_t)i);
+	folder_map_insert(&wadfiles[wad]->endfolders->map, strdup(name), i);
 	return i;
 }
 
@@ -1207,13 +1240,15 @@ UINT16 W_CheckNumForFolderEndPK3(const char *name, UINT16 wad, UINT16 startlump)
 // Returns lump position in PK3's lumpinfo, or INT16_MAX if not found.
 UINT16 W_CheckNumForFullNamePK3(const char *name, UINT16 wad, UINT16 startlump)
 {
-	INT32 i;
+	UINT16 i;
+	size_t namelen;
 	lumpinfo_t *lump_p = wadfiles[wad]->lumpinfo + startlump;
-	size_t name_length = strlen(name);
+
+	namelen = strlen(name);
 
 	for (i = startlump; i < wadfiles[wad]->numlumps; i++, lump_p++)
 	{
-		if (!strnicmp(name, lump_p->fullname, name_length))
+		if (!strnicmp(name, lump_p->fullname, namelen))
 		{
 			return i;
 		}
@@ -1223,61 +1258,19 @@ UINT16 W_CheckNumForFullNamePK3(const char *name, UINT16 wad, UINT16 startlump)
 	return INT16_MAX;
 }
 
-static lumpnum_t CheckLumpInCache(const char *name, boolean longname)
+FUNCINLINE static ATTRINLINE lumpnum_t CheckLumpInCache(const char *name)
 {
-	if (longname)
-	{
-		UINT32 hash = quickncasehash(name, 32);
-
-		// Loop backwards so that we check most recent entries first
-		for (INT32 i = lumpnumcacheindex + LUMPNUMCACHESIZE; i > lumpnumcacheindex; i--)
-		{
-			if (lumpnumcache[i & (LUMPNUMCACHESIZE - 1)].hash == hash
-				&& fasticmp(lumpnumcache[i & (LUMPNUMCACHESIZE - 1)].lumpname, name))
-			{
-				lumpnumcacheindex = i & (LUMPNUMCACHESIZE - 1);
-				return lumpnumcache[lumpnumcacheindex].lumpnum;
-			}
-		}
-	}
-	else
-	{
-		UINT32 hash = quickncasehash(name, 8);
-
-		// Loop backwards so that we check most recent entries first
-		for (INT32 i = lumpnumcacheindex + LUMPNUMCACHESIZE; i > lumpnumcacheindex; i--)
-		{
-			if (lumpnumcache[i & (LUMPNUMCACHESIZE - 1)].hash == hash
-				&& lumpnumcache[i & (LUMPNUMCACHESIZE - 1)].lumpname[8] == '\0'
-				&& strnicmp(lumpnumcache[i & (LUMPNUMCACHESIZE - 1)].lumpname, name, 8) == 0)
-			{
-				lumpnumcacheindex = i & (LUMPNUMCACHESIZE - 1);
-				return lumpnumcache[lumpnumcacheindex].lumpnum;
-			}
-		}
-	}
+	lumpnum_map_itr it = lumpnum_map_get(&lumpnumcache, name);
+	if (!lumpnum_map_is_end(it))
+		return it.data->val;
 
 	return LUMPERROR;
 }
 
-static void AddLumpToCache(lumpnum_t lumpnum, const char *name, boolean longname)
+FUNCINLINE static ATTRINLINE void AddLumpToCache(lumpnum_t lumpnum, const char *name)
 {
-	if (longname && strlen(name) >= LUMPNUMCACHENAME)
-		return;
-
-	lumpnumcacheindex = (lumpnumcacheindex + 1) & (LUMPNUMCACHESIZE - 1);
-	memset(lumpnumcache[lumpnumcacheindex].lumpname, '\0', LUMPNUMCACHENAME);
-	if (longname)
-	{
-		strlcpy(lumpnumcache[lumpnumcacheindex].lumpname, name, LUMPNUMCACHENAME);
-		lumpnumcache[lumpnumcacheindex].hash = quickncasehash(name, LUMPNUMCACHENAME);
-	}
-	else
-	{
-		strncpy(lumpnumcache[lumpnumcacheindex].lumpname, name, 8);
-		lumpnumcache[lumpnumcacheindex].hash = quickncasehash(name, 8);
-	}
-	lumpnumcache[lumpnumcacheindex].lumpnum = lumpnum;
+	I_Assert(strlen(name) <= 8); // we dont have longnames, so assume this is a non terminated string
+	lumpnum_map_insert(&lumpnumcache, strdup(name), lumpnum);
 }
 
 //
@@ -1293,14 +1286,14 @@ lumpnum_t W_CheckNumForName(const char *name)
 		return LUMPERROR;
 
 	// Check the lumpnumcache first.
-	lumpnum_t cachenum = CheckLumpInCache(name, false);
+	lumpnum_t cachenum = CheckLumpInCache(name);
 	if (cachenum != LUMPERROR)
 		return cachenum;
 
 	// scan wad files backwards so patch lump files take precedence
 	for (i = numwadfiles - 1; i >= 0; i--)
 	{
-		check = W_CheckNumForNamePwad(name, (UINT16)i, 0);
+		check = W_CheckNumForNamePwad(name, (UINT16)(i), 0);
 
 		if (check != INT16_MAX)
 			break; //found it
@@ -1314,7 +1307,7 @@ lumpnum_t W_CheckNumForName(const char *name)
 	{
 		// Update the cache.
 		lumpnum_t lumpnum = (i << 16) | check;
-		AddLumpToCache(lumpnum, name, false);
+		AddLumpToCache(lumpnum, name);
 
 		return lumpnum;
 	}
@@ -1326,7 +1319,7 @@ lumpnum_t W_CheckNumForName(const char *name)
 // Should be the only version, but that's not possible until we fix
 // all the instances of non null-terminated strings in the codebase...
 //
-lumpnum_t W_CheckNumForLongName(const char *name)
+/*lumpnum_t W_CheckNumForLongName(const char *name)
 {
 	INT32 i;
 	lumpnum_t check = INT16_MAX;
@@ -1335,14 +1328,14 @@ lumpnum_t W_CheckNumForLongName(const char *name)
 		return LUMPERROR;
 
 	// Check the lumpnumcache first.
-	lumpnum_t cachenum = CheckLumpInCache(name, true);
+	lumpnum_t cachenum = CheckLumpInCache(name);
 	if (cachenum != LUMPERROR)
 		return cachenum;
 
 	// scan wad files backwards so patch lump files take precedence
 	for (i = numwadfiles - 1; i >= 0; i--)
 	{
-		check = W_CheckNumForLongNamePwad(name, (UINT16)i, 0);
+		check = W_CheckNumForLongNamePwad(name, (UINT16)(i), 0);
 
 		if (check != INT16_MAX)
 			break; //found it
@@ -1356,11 +1349,11 @@ lumpnum_t W_CheckNumForLongName(const char *name)
 	{
 		// Update the cache.
 		lumpnum_t lumpnum = (i << 16) | check;
-		AddLumpToCache(lumpnum, name, true);
+		AddLumpToCache(lumpnum, name);
 
 		return lumpnum;
 	}
-}
+}*/
 
 //
 // W_GetNumForName
@@ -1385,7 +1378,7 @@ lumpnum_t W_GetNumForName(const char *name)
 // Should be the only version, but that's not possible until we fix
 // all the instances of non null-terminated strings in the codebase...
 //
-lumpnum_t W_GetNumForLongName(const char *name)
+/*lumpnum_t W_GetNumForLongName(const char *name)
 {
 	lumpnum_t i;
 
@@ -1395,7 +1388,7 @@ lumpnum_t W_GetNumForLongName(const char *name)
 		I_Error("W_GetNumForLongName: %s not found!\n", name);
 
 	return i;
-}
+}*/
 
 //
 // W_CheckNumForNameInBlock
@@ -1412,32 +1405,49 @@ lumpnum_t W_CheckNumForNameInBlock(const char *name, const char *blockstart, con
 	{
 		if (wadfiles[i]->type == RET_WAD)
 		{
-			bsid = W_CheckNumForNamePwad(blockstart, (UINT16)i, 0);
+			bsid = W_CheckNumForNamePwad(blockstart, (UINT16)(i), 0);
 			if (bsid == INT16_MAX)
 				continue; // Start block doesn't exist?
-			beid = W_CheckNumForNamePwad(blockend, (UINT16)i, 0);
+			beid = W_CheckNumForNamePwad(blockend, (UINT16)(i), 0);
 			if (beid == INT16_MAX)
 				continue; // End block doesn't exist?
 
-			check = W_CheckNumForNamePwad(name, (UINT16)i, bsid);
+			check = W_CheckNumForNamePwad(name, (UINT16)(i), bsid);
 			if (check < beid)
-				return (i<<16)+check; // found it, in our constraints
+				return (i << 16)+check; // found it, in our constraints
 		}
 	}
+
 	return LUMPERROR;
 }
 
 // Used by Lua. Case sensitive lump checking, quickly...
 UINT8 W_LumpExists(const char *name)
 {
-	INT32 i,j;
+	INT32 i, j;
+	UINT32 hash;
+	size_t namelen;
+
+	// Check the lumpnumcache first.
+	lumpnum_t cachenum = CheckLumpInCache(name);
+	if (cachenum != LUMPERROR)
+		return true;
+
+	namelen = strlen(name);
+	hash = W_HashLumpName(name);
+
 	for (i = numwadfiles - 1; i >= 0; i--)
 	{
 		lumpinfo_t *lump_p = wadfiles[i]->lumpinfo;
 		for (j = 0; j < wadfiles[i]->numlumps; ++j, ++lump_p)
-			if (fastcmp(lump_p->name, name))
+		{
+			if (lump_p->namelength == namelen
+			 && lump_p->hash.name == hash
+			 && fastcmp(lump_p->name, name))
 				return true;
+		}
 	}
+
 	return false;
 }
 
@@ -1597,13 +1607,13 @@ size_t W_ReadLumpHeaderPwad(UINT16 wad, UINT16 lump, void *dest, size_t size, si
 	fseek(handle, (long)(l->position + offset), SEEK_SET);
 
 	// But let's not copy it yet. We support different compression formats on lumps, so we need to take that into account.
-	switch(wadfiles[wad]->lumpinfo[lump].compression)
+	switch (wadfiles[wad]->lumpinfo[lump].compression)
 	{
 	case CM_NOCOMPRESSION:		// If it's uncompressed, we directly write the data into our destination, and return the bytes read.
 #ifdef NO_PNG_LUMPS
 		{
 			size_t bytesread = fread(dest, 1, size, handle);
-			ErrorIfPNG((UINT8 *)dest, bytesread, wadfiles[wad]->filename, l->fullname);
+			ErrorIfPNG((UINT8 *)(dest), bytesread, wadfiles[wad]->filename, l->fullname);
 			return bytesread;
 		}
 #else
@@ -1616,8 +1626,8 @@ size_t W_ReadLumpHeaderPwad(UINT16 wad, UINT16 lump, void *dest, size_t size, si
 			char *decData; // Lump's decompressed real data.
 			size_t retval; // Helper var, lzf_decompress returns 0 when an error occurs.
 
-			rawData = Z_Malloc(l->disksize, PU_STATIC, NULL);
-			decData = Z_Malloc(l->size, PU_STATIC, NULL);
+			rawData = (char *)(Z_Malloc(l->disksize, PU_STATIC, NULL));
+			decData = (char *)(Z_Malloc(l->size, PU_STATIC, NULL));
 
 			if (fread(rawData, 1, l->disksize, handle) < l->disksize)
 				I_Error("wad %d, lump %d: cannot read compressed data", wad, lump);
@@ -1644,7 +1654,7 @@ size_t W_ReadLumpHeaderPwad(UINT16 wad, UINT16 lump, void *dest, size_t size, si
 			Z_Free(rawData);
 			Z_Free(decData);
 #ifdef NO_PNG_LUMPS
-			ErrorIfPNG((UINT8 *)dest, size, wadfiles[wad]->filename, l->fullname);
+			ErrorIfPNG((UINT8 *)(dest), size, wadfiles[wad]->filename, l->fullname);
 #endif
 			return size;
 #else
@@ -1664,8 +1674,8 @@ size_t W_ReadLumpHeaderPwad(UINT16 wad, UINT16 lump, void *dest, size_t size, si
 			unsigned long rawSize = l->disksize;
 			unsigned long decSize = size;
 
-			rawData = Z_Malloc(rawSize, PU_STATIC, NULL);
-			decData = dest;
+			rawData = (UINT8 *)(Z_Malloc(rawSize, PU_STATIC, NULL));
+			decData = (UINT8 *)(dest);
 
 			if (fread(rawData, 1, rawSize, handle) < rawSize)
 				I_Error("wad %d, lump %d: cannot read compressed data", wad, lump);
@@ -1701,7 +1711,7 @@ size_t W_ReadLumpHeaderPwad(UINT16 wad, UINT16 lump, void *dest, size_t size, si
 			Z_Free(rawData);
 
 #ifdef NO_PNG_LUMPS
-			ErrorIfPNG((UINT8 *)dest, size, wadfiles[wad]->filename, l->fullname);
+			ErrorIfPNG((UINT8 *)(dest), size, wadfiles[wad]->filename, l->fullname);
 #endif
 			return size;
 		}
@@ -1889,7 +1899,7 @@ void *W_CacheSoftwarePatchNumPwad(UINT16 wad, UINT16 lump, INT32 tag)
 		W_ReadLumpHeaderPwad(wad, lump, lumpdata, 0, 0);
 
 		dest = Z_Calloc(sizeof(patch_t), tag, &lumpcache[lump]);
-		Patch_Create((softwarepatch_t*)lumpdata, len, dest);
+		Patch_Create((softwarepatch_t *)(lumpdata), len, dest);
 
 		Z_Free(lumpdata);
 	}
@@ -1911,7 +1921,7 @@ void *W_CachePatchNumPwad(UINT16 wad, UINT16 lump, INT32 tag)
 	if (!TestValidLump(wad, lump))
 		return NULL;
 
-	patch = (patch_t *)W_CacheSoftwarePatchNumPwad(wad, lump, tag);
+	patch = (patch_t *)(W_CacheSoftwarePatchNumPwad(wad, lump, tag));
 
 	if (patch == NULL)
 		return NULL;
@@ -1922,7 +1932,7 @@ void *W_CachePatchNumPwad(UINT16 wad, UINT16 lump, INT32 tag)
 		Patch_CreateGL(patch);
 #endif
 
-	return (void *)patch;
+	return (void*)(patch);
 }
 
 void *W_CachePatchNum(lumpnum_t lumpnum, INT32 tag)
@@ -1940,17 +1950,20 @@ void *W_GetCachedPatchNumPwad(UINT16 wad, UINT16 lump)
 
 #ifdef ROTSPRITE
 // Caches a rotsprite for patch rotation.
-void *W_GetCachedRotPatchPwad(UINT16 wadnum, UINT16 lumpnum)
+void *W_GetCachedRotPatchPwad(UINT16 wad, UINT16 lump)
 {
-	lumpcache_t *rotcache = wadfiles[wadnum]->rotcache;
+	if (!TestValidLump(wad, lump))
+		return NULL;
 
-	if (!rotcache[lumpnum])
+	lumpcache_t *rotcache = wadfiles[wad]->rotcache;
+
+	if (!rotcache[lump])
 	{
 		rotsprite_t *rspr = RotatedPatch_Create(ROTANGLES);
-		Z_SetUser(rspr, (void **)(&rotcache[lumpnum]));
+		Z_SetUser(rspr, (void**)(&rotcache[lump]));
 	}
 
-	return (void *)(rotcache[lumpnum]);
+	return (void*)(rotcache[lump]);
 }
 #endif // ROTSPRITE
 
@@ -1963,7 +1976,7 @@ void W_UnlockCachedPatch(void *patch)
 	// have different lifetimes from software's.
 #ifdef HWRENDER
 	if (rendermode == render_opengl)
-		HWR_UnlockCachedPatch((GLPatch_t *)((patch_t *)patch)->hardware);
+		HWR_UnlockCachedPatch((GLPatch_t *)(((patch_t *)(patch))->hardware));
 	else
 #endif
 	Z_ChangeTag(patch, PU_PATCH);
@@ -1998,7 +2011,7 @@ void *W_CachePatchNameRotated(const char *name, INT32 rotationangle, INT32 tag)
 	if (rotationangle < 1 || rotationangle >= ROTANGLES)
 		return W_CachePatchNum(num, tag);
 
-	rspr = (rotsprite_t *)W_GetCachedRotPatchPwad(WADFILENUM(num),LUMPNUM(num));
+	rspr = (rotsprite_t *)(W_GetCachedRotPatchPwad(WADFILENUM(num), LUMPNUM(num)));
 
 	if (rspr == NULL)
 		return W_CachePatchNum(W_GetNumForName("MISSING"), tag);
@@ -2007,7 +2020,7 @@ void *W_CachePatchNameRotated(const char *name, INT32 rotationangle, INT32 tag)
 	{
 		INT32 xpivot = 0, ypivot = 0;
 
-		ptr = (patch_t *)W_CachePatchNum(num, PU_PATCH);
+		ptr = (patch_t *)(W_CachePatchNum(num, PU_PATCH));
 		if (ptr == NULL)
 			return W_CachePatchNum(W_GetNumForName("MISSING"), tag);
 
@@ -2200,7 +2213,7 @@ static int W_VerifyPK3(FILE *fp, lumpchecklist_t *checklist, boolean status)
 	fseek(fp, 0, SEEK_END);
 	file_size = ftell(fp);
 
-	const long startpos = (file_size - (22 + 65536));
+	const long startpos = file_size - (22 + 65536);
 	if (!ResFindSignature(fp, pat_end, max(0l, startpos)))
 		return true;
 
@@ -2214,7 +2227,7 @@ static int W_VerifyPK3(FILE *fp, lumpchecklist_t *checklist, boolean status)
 
 	fseek(fp, LONG(zend.cdiroffset), SEEK_SET);
 
-	CLEANUP(pfree) char *cdir = (char*)(malloc(LONG(zend.cdirsize)));
+	CLEANUP(pfree) char *cdir = (char *)(malloc(LONG(zend.cdirsize)));
 
 	if (fread(cdir, 1, LONG(zend.cdirsize), fp) < (UINT32)(LONG(zend.cdirsize)))
 	{
@@ -2225,7 +2238,7 @@ static int W_VerifyPK3(FILE *fp, lumpchecklist_t *checklist, boolean status)
 
 	for (i = 0; i < numlumps; i++)
 	{
-		zentry_t *zentry = (zentry_t*)(cdir + offset);
+		zentry_t *zentry = (zentry_t *)(cdir + offset);
 		char* fullname;
 		char* trimname;
 		char* dotpos;
@@ -2237,7 +2250,7 @@ static int W_VerifyPK3(FILE *fp, lumpchecklist_t *checklist, boolean status)
 
 		if (verified == true)
 		{
-			fullname = (char*)(malloc(SHORT(zentry->namelen) + 1));
+			fullname = (char *)(malloc(SHORT(zentry->namelen) + 1));
 			strncpy(fullname, (char *)(zentry + 1), SHORT(zentry->namelen));
 			fullname[zentry->namelen] = 0;
 
@@ -2448,7 +2461,7 @@ static int W_CheckPK3Contains(FILE *fp, lumpchecklist_t *checklist)
 	fseek(fp, 0, SEEK_END);
 	file_size = ftell(fp);
 
-	const long startpos = (file_size - (22 + 65536));
+	const long startpos = file_size - (22 + 65536);
 	if (!ResFindSignature(fp, pat_end, max(0l, startpos)))
 		return true;
 
@@ -2462,7 +2475,7 @@ static int W_CheckPK3Contains(FILE *fp, lumpchecklist_t *checklist)
 
 	fseek(fp, LONG(zend.cdiroffset), SEEK_SET);
 
-	CLEANUP(pfree) char *cdir = (char*)(malloc(LONG(zend.cdirsize)));
+	CLEANUP(pfree) char *cdir = (char *)(malloc(LONG(zend.cdirsize)));
 
 	if (fread(cdir, 1, LONG(zend.cdirsize), fp) < (UINT32)(LONG(zend.cdirsize)))
 	{
@@ -2473,7 +2486,7 @@ static int W_CheckPK3Contains(FILE *fp, lumpchecklist_t *checklist)
 
 	for (i = 0; i < numlumps; i++)
 	{
-		zentry_t *zentry = (zentry_t*)(cdir + offset);
+		zentry_t *zentry = (zentry_t *)(cdir + offset);
 		CLEANUP(pfree) char* fullname = NULL;
 		char* trimname;
 		char* dotpos;
@@ -2483,7 +2496,7 @@ static int W_CheckPK3Contains(FILE *fp, lumpchecklist_t *checklist)
 			return false;
 		}
 
-		fullname = (char*)(malloc(SHORT(zentry->namelen) + 1));
+		fullname = (char *)(malloc(SHORT(zentry->namelen) + 1));
 		strncpy(fullname, (char *)(zentry + 1), SHORT(zentry->namelen));
 		fullname[zentry->namelen] = 0;
 
@@ -2621,14 +2634,14 @@ virtres_t* vres_GetMap(lumpnum_t lumpnum)
 		size_t *vsizecache;
 
 		// Remember that we're assuming that the WAD will have a specific set of lumps in a specific order.
-		UINT8 *wadData = (UINT8*)(W_CacheLumpNum(lumpnum, PU_LEVEL));
+		UINT8 *wadData = (UINT8 *)(W_CacheLumpNum(lumpnum, PU_LEVEL));
 		if (wadData == NULL)
 			I_Error("vres_GetMap: Invalid WadData!\n");
 
-		filelump_t *fileinfo = (filelump_t *)(wadData + LONG(((wadinfo_t *)wadData)->infotableofs));
+		filelump_t *fileinfo = (filelump_t *)(wadData + LONG(((wadinfo_t *)(wadData))->infotableofs));
 
-		i = LONG(((wadinfo_t *)wadData)->numlumps);
-		vsizecache = (size_t*)(Z_Malloc(sizeof(size_t)*i, PU_LEVEL, NULL));
+		i = LONG(((wadinfo_t *)(wadData))->numlumps);
+		vsizecache = (size_t *)(Z_Malloc(sizeof(size_t)*i, PU_LEVEL, NULL));
 
 		for (realentry = 0; realentry < i; realentry++)
 		{
@@ -2640,7 +2653,7 @@ virtres_t* vres_GetMap(lumpnum_t lumpnum)
 			numlumps++;
 		}
 
-		vlumps = (virtlump_t*)(Z_Malloc(sizeof(virtlump_t)*numlumps, PU_LEVEL, NULL));
+		vlumps = (virtlump_t *)(Z_Malloc(sizeof(virtlump_t)*numlumps, PU_LEVEL, NULL));
 		if (vlumps == NULL)
 			I_Error("vres_GetMap: Out of memory!\n");
 
@@ -2662,7 +2675,7 @@ virtres_t* vres_GetMap(lumpnum_t lumpnum)
 			// Play it safe with the name in this case.
 			memcpy(vlumps[i].name, name, 8);
 			vlumps[i].name[8] = '\0';
-			vlumps[i].data = (UINT8*)(
+			vlumps[i].data = (UINT8 *)(
 				Z_Malloc(vlumps[i].size, PU_LEVEL, NULL) // This is memory inefficient, sorry about that.
 			);
 			memcpy(vlumps[i].data, wadData + LONG((fileinfo + realentry)->filepos), vlumps[i].size);
@@ -2689,7 +2702,7 @@ virtres_t* vres_GetMap(lumpnum_t lumpnum)
 		}
 		numlumps++;
 
-		vlumps = (virtlump_t*)(Z_Malloc(sizeof(virtlump_t)*numlumps, PU_LEVEL, NULL));
+		vlumps = (virtlump_t *)(Z_Malloc(sizeof(virtlump_t)*numlumps, PU_LEVEL, NULL));
 		if (vlumps == NULL)
 			I_Error("vres_GetMap: Out of memory!\n");
 
@@ -2710,11 +2723,11 @@ virtres_t* vres_GetMap(lumpnum_t lumpnum)
 			vlumps[i].size = W_LumpLength(lumpnum);
 			memcpy(vlumps[i].name, name, 8);
 			vlumps[i].name[8] = '\0';
-			vlumps[i].data = (UINT8*)(W_CacheLumpNum(lumpnum, PU_LEVEL));
+			vlumps[i].data = (UINT8 *)(W_CacheLumpNum(lumpnum, PU_LEVEL));
 		}
 	}
 
-	vres = (virtres_t*)(Z_Malloc(sizeof(virtres_t), PU_LEVEL, NULL));
+	vres = (virtres_t *)(Z_Malloc(sizeof(virtres_t), PU_LEVEL, NULL));
 	vres->vlumps = vlumps;
 	vres->numlumps = numlumps;
 

src/w_wad.h

@@ -68,11 +68,11 @@ typedef struct
 	unsigned long position; // filelump_t filepos
 	unsigned long disksize; // filelump_t size
 	char name[9];           // filelump_t name[] e.g. "LongEntr"
-	char *longname;         //                   e.g. "LongEntryName"
+	//char *longname;         //                   e.g. "LongEntryName"
 	char *fullname;         //                   e.g. "Folder/Subfolder/LongEntryName.extension"
 
 	size_t namelength;      // length of name
-	size_t longnamelength;  // length of longname
+	//size_t longnamelength;  // length of longname
 	size_t fullnamelength;  // length of fullname
 
 	size_t size; // real (uncompressed) size
@@ -80,8 +80,8 @@ typedef struct
 
 	struct {
 		UINT32 name;        // hash of name
-		UINT32 longname;    // hash of longname
-		UINT32 fullname;    // hash of fullname
+		//UINT32 longname;    // hash of longname
+		//UINT32 fullname;    // hash of fullname
 	} hash;
 } lumpinfo_t;
 
@@ -126,7 +126,6 @@ typedef enum restype
 	RET_UNKNOWN,
 } restype_t;
 
-
 typedef struct wadfile_s
 {
 	char *filename;
@@ -137,8 +136,8 @@ typedef struct wadfile_s
 #ifdef ROTSPRITE
 	lumpcache_t *rotcache; // Cache rotsprites for rotating patches.
 #endif
-	aatree_t *startfolders;
-	aatree_t *endfolders;
+	struct FolderCache *startfolders;
+	struct FolderCache *endfolders;
 	UINT16 numlumps; // this wad's number of resources
 	FILE *handle;
 	UINT32 filesize; // for network
@@ -155,6 +154,7 @@ extern wadfile_t *wadfiles[MAX_WADFILES];
 
 // =========================================================================
 
+void W_Startup(void);
 void W_Shutdown(void);
 
 // Opens a WAD file. Returns the FILE * handle for the file, or NULL if not found or could not be opened
@@ -174,13 +174,11 @@ INT32 W_AddAutoloadedLocalFiles(char **filenames);
 
 #define W_FileHasFolders(wadfile) ((wadfile)->type == RET_PK3)
 
-UINT32 W_HashLumpName(const char *name);
-
 const char *W_CheckNameForNumPwad(UINT16 wad, UINT16 lump);
 const char *W_CheckNameForNum(lumpnum_t lumpnum);
 
 UINT16 W_CheckNumForNamePwad(const char *name, UINT16 wad, UINT16 startlump); // checks only in one pwad
-UINT16 W_CheckNumForLongNamePwad(const char *name, UINT16 wad, UINT16 startlump);
+//UINT16 W_CheckNumForLongNamePwad(const char *name, UINT16 wad, UINT16 startlump);
 
 /* Find the first lump after F_START for instance. */
 UINT16 W_CheckNumForMarkerStartPwad(const char *name, UINT16 wad, UINT16 startlump);
@@ -190,9 +188,9 @@ UINT16 W_CheckNumForFolderStartPK3(const char *name, UINT16 wad, UINT16 startlum
 UINT16 W_CheckNumForFolderEndPK3(const char *name, UINT16 wad, UINT16 startlump);
 
 lumpnum_t W_CheckNumForName(const char *name);
-lumpnum_t W_CheckNumForLongName(const char *name);
+//lumpnum_t W_CheckNumForLongName(const char *name);
 lumpnum_t W_GetNumForName(const char *name); // like W_CheckNumForName but I_Error on LUMPERROR
-lumpnum_t W_GetNumForLongName(const char *name);
+//lumpnum_t W_GetNumForLongName(const char *name);
 lumpnum_t W_CheckNumForNameInBlock(const char *name, const char *blockstart, const char *blockend);
 UINT8 W_LumpExists(const char *name); // Lua uses this.
 UINT8 W_CheckMultipleLumps(const char* lump, ...); // variadic version of above lmao
@@ -233,7 +231,7 @@ void *W_CacheSoftwarePatchNumPwad(UINT16 wad, UINT16 lump, INT32 tag);
 void *W_CacheSoftwarePatchNum(lumpnum_t lumpnum, INT32 tag);
 
 #ifdef ROTSPRITE
-void *W_GetCachedRotPatchPwad(UINT16 wadnum, UINT16 lumpnum); // Get patch-based rotsprites from the cache.
+void *W_GetCachedRotPatchPwad(UINT16 wad, UINT16 lump); // Get patch-based rotsprites from the cache.
 void *W_CachePatchNameRotated(const char *name, INT32 rotationangle, INT32 tag);
 #endif