hash_sparse: change length checks

dont early return on 0 len, let it be the falltrough case, this seems to help branch prediction

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

@@ -269,13 +269,13 @@ endif
 
 ifdef USEASAN
 # compile with asan
-opts+=-fsanitize=address
+opts+=-O1 -fsanitize=address -fno-omit-frame-pointer -fno-common
 libs+=-fsanitize=address
 endif
 
 ifdef USEUBSAN
-# compile with asan
-opts+=-fsanitize=undefined
+# compile with ubsan
+opts+=-O1 -fsanitize=undefined -fno-omit-frame-pointer
 libs+=-fsanitize=undefined
 endif
 
@@ -295,6 +295,7 @@ opts+=$(debug_opts)
 
 opts+=$(foreach v,$(passthru_opts),$(if $($(v)),-D$(v)))
 
+CWFLAGS+=-std=gnu17
 CXXFLAGS+=-std=c++17 # force c17 for c++ since most vpss run older ubuntu versions with old compilers
 
 opts+=$(WFLAGS) $(CFLAGS)

src/Makefile.d/versions.mk

@@ -20,7 +20,8 @@ $(foreach v,$(join $(wordlist 2,$(_n),- $(gcc_versions)),\
 CXXFLAGS+= -Wno-aggregate-return
 
 # -W -Wno-unused
-WFLAGS:=-Wall -Wno-trigraphs -Wnull-dereference
+WFLAGS:=-Wall -Wnull-dereference
+#WFLAGS+=-Wno-trigraphs
 ifdef GCC152
 WFLAGS+=-Wzero-as-null-pointer-constant
 endif
@@ -31,7 +32,7 @@ ifndef RELAXWARNINGS
  WFLAGS+=-W
 #WFLAGS+=-Wno-sign-compare
 ifndef GCC295
- WFLAGS+=-Wno-div-by-zero
+# WFLAGS+=-Wno-div-by-zero
 endif
 #WFLAGS+=-Wsystem-headers
 WFLAGS+=-Wfloat-equal
@@ -62,7 +63,7 @@ endif
 endif
  WFLAGS+=-Wsign-compare
 ifdef GCC91
- WFLAGS+=-Wno-error=address-of-packed-member
+# WFLAGS+=-Wno-error=address-of-packed-member
 endif
 ifdef GCC45
  WFLAGS+=-Wlogical-op
@@ -105,14 +106,14 @@ endif
 endif
 WFLAGS+=-Wformat-y2k
 ifdef GCC71
-WFLAGS+=-Wno-error=format-overflow=2
+#WFLAGS+=-Wno-error=format-overflow=2
 endif
 WFLAGS+=-Wformat-security
 ifndef GCC29
 #WFLAGS+=-Winit-self
 endif
 ifdef GCC46
-WFLAGS+=-Wno-suggest-attribute=noreturn
+#WFLAGS+=-Wno-suggest-attribute=noreturn
 endif
 
 ifdef NOLDWARNING
@@ -130,21 +131,21 @@ ifdef GCC44
 #WFLAGS+=-Wno-error=array-bounds
 endif
 ifdef GCC46
- WFLAGS+=-Wno-error=suggest-attribute=noreturn
+# WFLAGS+=-Wno-error=suggest-attribute=noreturn
 endif
 ifdef GCC54
- WFLAGS+=-Wno-logical-op -Wno-error=logical-op
+# WFLAGS+=-Wno-logical-op -Wno-error=logical-op
 endif
 ifdef GCC61
- WFLAGS+=-Wno-tautological-compare -Wno-error=tautological-compare
+# WFLAGS+=-Wno-tautological-compare -Wno-error=tautological-compare
 endif
 ifdef GCC71
  WFLAGS+=-Wimplicit-fallthrough=4
 endif
 ifdef GCC81
- WFLAGS+=-Wno-error=format-overflow
- WFLAGS+=-Wno-format-overflow
- WFLAGS+=-Wno-error=multistatement-macros
+# WFLAGS+=-Wno-error=format-overflow
+# WFLAGS+=-Wno-format-overflow
+# WFLAGS+=-Wno-error=multistatement-macros
 endif
 
 ifneq (,$(filter $(CC) $(CXX),clang clang++))
@@ -183,6 +184,6 @@ endif
 # Lua
 ifdef GCC43
 ifndef GCC44
-WFLAGS+=-Wno-logical-op
+#WFLAGS+=-Wno-logical-op
 endif
 endif

src/blua/lauxlib.c

@@ -20,6 +20,7 @@
 #define lauxlib_c
 #define LUA_LIB
 
+#include "ldebug.h"
 #include "lua.h"
 
 #include "lauxlib.h"
@@ -468,8 +469,19 @@ LUALIB_API char *luaL_prepbuffer (luaL_Buffer *B) {
 
 
 LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l) {
-  while (l--)
-    luaL_addchar(B, *s++);
+ while (l) {
+    size_t space = bufffree(B);
+    if (space == 0) {
+      luaL_prepbuffer(B);
+      lua_assert(bufffree(B) == LUAL_BUFFERSIZE);
+      space = LUAL_BUFFERSIZE;
+    }
+    if (space > l) space = l;
+    memcpy(B->p, s, space);
+    B->p += space;
+    s += space;
+    l -= space;
+  }
 }
 
 
@@ -686,6 +698,6 @@ static int panic (lua_State *L) {
 
 LUALIB_API lua_State *luaL_newstate (void) {
   lua_State *L = lua_newstate(l_alloc, NULL);
-  if (L) lua_atpanic(L, &panic);
+  if (l_likely(L)) lua_atpanic(L, &panic);
   return L;
 }

src/blua/lcode.c

@@ -790,18 +790,19 @@ void luaK_posfix (FuncState *fs, BinOpr op, expdesc *e1, expdesc *e2) {
     case OPR_BXOR: codearith(fs, OP_BXOR, e1, e2); break;
     case OPR_BSHL: codearith(fs, OP_BSHL, e1, e2); break;
     case OPR_BSHR: codearith(fs, OP_BSHR, e1, e2); break;
-    case OPR_ADD: codearith(fs, OP_ADD, e1, e2); break;
-    case OPR_SUB: codearith(fs, OP_SUB, e1, e2); break;
-    case OPR_MUL: codearith(fs, OP_MUL, e1, e2); break;
-    case OPR_DIV: codearith(fs, OP_DIV, e1, e2); break;
-    case OPR_MOD: codearith(fs, OP_MOD, e1, e2); break;
-    case OPR_POW: codearith(fs, OP_POW, e1, e2); break;
-    case OPR_EQ: codecomp(fs, OP_EQ, 1, e1, e2); break;
-    case OPR_NE: codecomp(fs, OP_EQ, 0, e1, e2); break;
-    case OPR_LT: codecomp(fs, OP_LT, 1, e1, e2); break;
-    case OPR_LE: codecomp(fs, OP_LE, 1, e1, e2); break;
-    case OPR_GT: codecomp(fs, OP_LT, 0, e1, e2); break;
-    case OPR_GE: codecomp(fs, OP_LE, 0, e1, e2); break;
+    case OPR_ADD: case OPR_SUB: case OPR_MUL: case OPR_DIV:
+    case OPR_MOD: case OPR_POW: {
+      codearith(fs, op - OPR_ADD + OP_ADD, e1, e2);
+      break;
+    }
+    case OPR_EQ: case OPR_LT: case OPR_LE: {
+      codecomp(fs, op - OPR_EQ + OP_EQ, 1, e1, e2);
+      break;
+    }
+    case OPR_NE: case OPR_GT: case OPR_GE: {
+      codecomp(fs, op - OPR_NE + OP_EQ, 0, e1, e2);
+      break;
+    }
     default: lua_assert(0);
   }
 }

src/blua/lcode.h

@@ -21,13 +21,13 @@
 
 
 /*
-** grep "ORDER OPR" if you change these enums
+** grep "ORDER OPR" if you change these enums  (ORDER OP)
 */
 typedef enum BinOpr {
   OPR_ADD, OPR_SUB, OPR_MUL, OPR_DIV, OPR_MOD, OPR_POW,
   OPR_CONCAT,
-  OPR_NE, OPR_EQ,
-  OPR_LT, OPR_LE, OPR_GT, OPR_GE,
+  OPR_EQ, OPR_LT, OPR_LE,
+  OPR_NE, OPR_GT, OPR_GE,
   OPR_AND, OPR_OR,
   OPR_BAND, OPR_BOR, OPR_BXOR,
   OPR_BSHL, OPR_BSHR,

src/blua/ldebug.c

@@ -542,16 +542,39 @@ static const char *getobjname (lua_State *L, CallInfo *ci, int stackpos,
 
 
 static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name) {
+  TMS tm = 0;
   Instruction i;
   if ((isLua(ci) && ci->tailcalls > 0) || !isLua(ci - 1))
     return NULL;  /* calling function is not Lua (or is unknown) */
   ci--;  /* calling function */
   i = ci_func(ci)->l.p->code[currentpc(L, ci)];
-  if (GET_OPCODE(i) == OP_CALL || GET_OPCODE(i) == OP_TAILCALL ||
-      GET_OPCODE(i) == OP_TFORLOOP)
-    return getobjname(L, ci, GETARG_A(i), name);
-  else
-    return NULL;  /* no useful name can be found */
+  switch (GET_OPCODE(i)) {
+    case OP_CALL:
+    case OP_TAILCALL:
+    case OP_TFORLOOP:
+      return getobjname(L, ci, GETARG_A(i), name);
+    case OP_GETGLOBAL:
+    case OP_SELF:
+    case OP_GETTABLE: tm = TM_INDEX; break;
+    case OP_SETGLOBAL:
+    case OP_SETTABLE: tm = TM_NEWINDEX; break;
+    case OP_EQ: tm = TM_EQ; break;
+    case OP_ADD: tm = TM_ADD; break;
+    case OP_SUB: tm = TM_SUB; break;
+    case OP_MUL: tm = TM_MUL; break;
+    case OP_DIV: tm = TM_DIV; break;
+    case OP_MOD: tm = TM_MOD; break;
+    case OP_POW: tm = TM_POW; break;
+    case OP_UNM: tm = TM_UNM; break;
+    case OP_LEN: tm = TM_LEN; break;
+    case OP_LT: tm = TM_LT; break;
+    case OP_LE: tm = TM_LE; break;
+    case OP_CONCAT: tm = TM_CONCAT; break;
+    default:
+      return NULL;  /* else no useful name can be found */
+  }
+  *name = getstr(G(L)->tmname[tm]);
+  return "metamethod";
 }
 
 

src/blua/ldo.c

@@ -164,7 +164,7 @@ void luaD_reallocCI (lua_State *L, int newsize) {
 
 
 void luaD_growstack (lua_State *L, int n) {
-  if (l_likely(n <= L->stacksize))  /* double size is enough? */
+  if (n <= L->stacksize)  /* double size is enough? */
     luaD_reallocstack(L, 2*L->stacksize);
   else
     luaD_reallocstack(L, L->stacksize + n);
@@ -318,7 +318,7 @@ int luaD_precall (lua_State *L, StkId func, int nresults) {
     ci->top = L->top + LUA_MINSTACK;
     lua_assert(ci->top <= L->stack_last);
     ci->nresults = nresults;
-    if (L->hookmask & LUA_MASKCALL)
+    if (l_unlikely(L->hookmask & LUA_MASKCALL))
       luaD_callhook(L, LUA_HOOKCALL, -1);
     lua_unlock(L);
     n = (*curr_func(L)->c.f)(L);  /* do the actual call */

src/blua/liolib.c

@@ -356,20 +356,21 @@ static int read_line (lua_State *L, FILE *f) {
 
 
 static int read_chars (lua_State *L, FILE *f, size_t n) {
-  size_t rlen;  /* how much to read */
-  size_t nr;  /* number of chars actually read */
+  size_t tbr = n;  /* number of chars to be read */
+  size_t rlen;  /* how much to read in each cycle */
+  size_t nr;  /* number of chars actually read in each cycle */
   luaL_Buffer b;
   luaL_buffinit(L, &b);
   rlen = LUAL_BUFFERSIZE;  /* try to read that much each time */
   do {
     char *p = luaL_prepbuffer(&b);
-    if (rlen > n) rlen = n;  /* cannot read more than asked */
+    if (rlen > tbr) rlen = tbr;  /* cannot read more than asked */
     nr = fread(p, sizeof(char), rlen, f);
     luaL_addsize(&b, nr);
-    n -= nr;  /* still have to read `n' chars */
-  } while (n > 0 && nr == rlen);  /* until end of count or eof */
+    tbr -= nr;  /* still have to read 'tbr' chars */
+  } while (tbr > 0 && nr == rlen);  /* until end of count or eof */
   luaL_pushresult(&b);  /* close buffer */
-  return (n == 0 || lua_objlen(L, -1) > 0);
+  return (tbr == 0 || tbr < n);  /* true iff read something */
 }
 
 
@@ -432,13 +433,13 @@ static int f_read (lua_State *L) {
 
 static int io_readline (lua_State *L) {
   FILE *f = *(FILE **)lua_touserdata(L, lua_upvalueindex(1));
-  int sucess;
+  int success;
   if (f == NULL)  /* file is already closed? */
     luaL_error(L, "file is already closed");
-  sucess = read_line(L, f);
+  success = read_line(L, f);
   if (ferror(f))
     return luaL_error(L, "%s", strerror(errno));
-  if (sucess) return 1;
+  if (success) return 1;
   else {  /* EOF */
     if (lua_toboolean(L, lua_upvalueindex(2))) {  /* generator created file? */
       lua_settop(L, 0);

src/blua/lparser.c

@@ -881,10 +881,10 @@ static const struct {
   lu_byte right; /* right priority */
 } priority[] = {  /* ORDER OPR */
    {6, 6}, {6, 6}, {7, 7}, {7, 7}, {7, 7},  /* `+' `-' `/' `%' */
-   {10, 9}, {5, 4},                 /* power and concat (right associative) */
-   {3, 3}, {3, 3},                  /* equality and inequality */
-   {3, 3}, {3, 3}, {3, 3}, {3, 3},  /* order */
-   {2, 2}, {1, 1}                   /* logical (and/or) */
+   {10, 9}, {5, 4},                 /* ^, .. (right associative) */
+   {3, 3}, {3, 3}, {3, 3},          /* ==, <, <= */
+   {3, 3}, {3, 3}, {3, 3},          /* ~=, >, >= */
+   {2, 2}, {1, 1}                   /* and, or */
    ,{6, 6}, {6, 6}, {6, 6},           /* bit-wise (band/bor/bxor) */
    {7, 7}, {7, 7}		    /* shl/shr */
 };

src/blua/lstring.c

@@ -51,7 +51,7 @@ static TString *newlstr (lua_State *L, const char *str, size_t l,
                                        unsigned int h) {
   TString *ts;
   stringtable *tb;
-  if (l+1 > (MAX_SIZET - sizeof(TString))/sizeof(char))
+  if (l_unlikely(l+1 > (MAX_SIZET - sizeof(TString))/sizeof(char)))
     luaM_toobig(L);
   ts = cast(TString *, luaM_malloc(L, (l+1)*sizeof(char)+sizeof(TString)));
   ts->tsv.len = l;
@@ -72,18 +72,72 @@ static TString *newlstr (lua_State *L, const char *str, size_t l,
 }
 
 
-TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
-  GCObject *o;
+// string hash taken from luaJIT
+
+/* Unaligned load of uint32_t. */
+static inline __attribute__((always_inline)) uint32_t getu32(const void* ptr)
+{
+  uint32_t result;
+  memcpy(&result, ptr, 4);
+  return result;
+}
+
+// smol macro to look a little less messy lul
+#define getu8(p) *cast(const uint8_t *, p)
+
+/* Keyed sparse ARX string hash. Constant time. */
+static unsigned hash_sparse(const char *str, size_t len)
+{
+  /* Constants taken from lookup3 hash by Bob Jenkins. */
+  unsigned int a, b, h = cast(unsigned int, len);
+#define rol(x, n) (((x)<<(n)) | ((x)>>(-cast(int, n)&(8*sizeof(x)-1))))
+  if (len >= 4) {  /* Caveat: unaligned access! */
+    a  = getu32(str);
+    h ^= getu32(str+len-4);
+    b  = getu32(str+(len>>1)-2);
+    h ^= b; h -= rol(b, 14);
+    b += getu32(str+(len>>2)-1);
+  } else if (len > 0) {
+    a  = getu8(str);
+    h ^= getu8(str+len-1);
+    b  = getu8(str+(len>>1));
+    h ^= b; h -= rol(b, 14);
+  } else {
+    return 0;
+  }
+  a ^= h; a -= rol(h, 11);
+  b ^= a; b -= rol(a, 25);
+  h ^= b; h -= rol(b, 16);
+#undef rol
+  return h;
+}
+
+#undef getu8
+
+
+static inline __attribute__((always_inline)) unsigned luaS_hash (const char *str, size_t l) {
+#if 0
   unsigned int h = cast(unsigned int, l);  /* seed */
   size_t step = (l>>5)+1;  /* if string is too long, don't hash all its chars */
   size_t l1;
   for (l1=l; l1>=step; l1-=step)  /* compute hash */
     h = h ^ ((h<<5)+(h>>2)+cast(unsigned char, str[l1-1]));
+  return h;
+#else
+  return hash_sparse(str, l);
+#endif
+}
+
+TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
+  GCObject *o;
+  unsigned int h = luaS_hash(str, l);
   for (o = G(L)->strt.hash[lmod(h, G(L)->strt.size)];
        o != NULL;
        o = o->gch.next) {
     TString *ts = rawgco2ts(o);
-    if (l_unlikely(ts->tsv.len == l && (memcmp(str, getstr(ts), l) == 0))) {
+    if (ts->tsv.hash == h &&
+        ts->tsv.len == l &&
+       (memcmp(str, getstr(ts), l) == 0)) {
       /* string may be dead */
       if (isdead(G(L), o)) changewhite(o);
       return ts;

src/blua/lvm.c

@@ -28,7 +28,7 @@
 
 
 
-/* limit for table tag-method chains (to avoid loops) */
+/* limit for table tag-method chains (to avoid infinite loops) */
 #define MAXTAGLOOP	100
 
 
@@ -366,6 +366,7 @@ static void Arith (lua_State *L, StkId ra, TValue *rb,
 
 
 #define arith_op(op,tm) { \
+        StkId ra = RA(i); \
         TValue *rb = RKB(i); \
         TValue *rc = RKC(i); \
         if (ttisnumber(rb) && ttisnumber(rc)) { \
@@ -392,7 +393,6 @@ void luaV_execute (lua_State *L, int nexeccalls) {
   /* main loop of interpreter */
   for (;;) {
     const Instruction i = *pc++;
-    StkId ra;
     if ((L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) &&
         (--L->hookcount == 0 || L->hookmask & LUA_MASKLINE)) {
       traceexec(L, pc);
@@ -402,26 +402,28 @@ void luaV_execute (lua_State *L, int nexeccalls) {
       }
       base = L->base;
     }
-    /* warning!! several calls may realloc the stack and invalidate `ra' */
-    ra = RA(i);
     lua_assert(base == L->base && L->base == L->ci->base);
     lua_assert(base <= L->top && L->top <= L->stack + L->stacksize);
     lua_assert(L->top == L->ci->top || luaG_checkopenop(i));
     switch (GET_OPCODE(i)) {
       case OP_MOVE: {
+        StkId ra = RA(i);
         setobjs2s(L, ra, RB(i));
         continue;
       }
       case OP_LOADK: {
+        StkId ra = RA(i);
         setobj2s(L, ra, KBx(i));
         continue;
       }
       case OP_LOADBOOL: {
+        StkId ra = RA(i);
         setbvalue(ra, GETARG_B(i));
         if (GETARG_C(i)) pc++;  /* skip next instruction (if C) */
         continue;
       }
       case OP_LOADNIL: {
+        StkId ra = RA(i);
         TValue *rb = RB(i);
         do {
           setnilvalue(rb--);
@@ -429,11 +431,13 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_GETUPVAL: {
+        StkId ra = RA(i);
         int b = GETARG_B(i);
         setobj2s(L, ra, cl->upvals[b]->v);
         continue;
       }
       case OP_GETGLOBAL: {
+        StkId ra = RA(i);
         TValue g;
         TValue *rb = KBx(i);
         sethvalue(L, &g, cl->env);
@@ -442,10 +446,14 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_GETTABLE: {
-        Protect(luaV_gettable(L, RB(i), RKC(i), ra));
+        StkId ra = RA(i);
+        StkId rb = RB(i);
+        TValue *rc = RKC(i);
+        Protect(luaV_gettable(L, rb, rc, ra));
         continue;
       }
       case OP_SETGLOBAL: {
+        StkId ra = RA(i);
         TValue g;
         sethvalue(L, &g, cl->env);
         lua_assert(ttisstring(KBx(i)));
@@ -453,16 +461,21 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_SETUPVAL: {
+        StkId ra = RA(i);
         UpVal *uv = cl->upvals[GETARG_B(i)];
         setobj(L, uv->v, ra);
         luaC_barrier(L, uv, ra);
         continue;
       }
       case OP_SETTABLE: {
-        Protect(luaV_settable(L, ra, RKB(i), RKC(i)));
+        StkId ra = RA(i);
+        TValue *rb = RKB(i);
+        TValue *rc = RKC(i);
+        Protect(luaV_settable(L, ra, rb, rc));
         continue;
       }
       case OP_NEWTABLE: {
+        StkId ra = RA(i);
         int b = GETARG_B(i);
         int c = GETARG_C(i);
         sethvalue(L, ra, luaH_new(L, luaO_fb2int(b), luaO_fb2int(c)));
@@ -470,6 +483,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_SELF: {
+        StkId ra = RA(i);
         StkId rb = RB(i);
         setobjs2s(L, ra+1, rb);
         Protect(luaV_gettable(L, rb, RKC(i), ra));
@@ -488,6 +502,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_DIV: {
+        StkId ra = RA(i);
         TValue *rb = RKB(i);
         TValue *rc = RKC(i);
         if (ttisnumber(rb) && ttisnumber(rc)) {
@@ -503,6 +518,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_MOD: {
+        StkId ra = RA(i);
         TValue *rb = RKB(i);
         TValue *rc = RKC(i);
         if (ttisnumber(rb) && ttisnumber(rc)) {
@@ -522,26 +538,27 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_BAND: {
-	arith_op(luai_numand, TM_AND);
-	continue;
+        arith_op(luai_numand, TM_AND);
+        continue;
       }
       case OP_BOR: {
-	arith_op(luai_numor, TM_OR);
-	continue;
+        arith_op(luai_numor, TM_OR);
+        continue;
       }
       case OP_BXOR: {
-	arith_op(luai_numxor, TM_XOR);
-	continue;
+        arith_op(luai_numxor, TM_XOR);
+        continue;
       }
       case OP_BSHL: {
-	arith_op(luai_numshl, TM_SHL);
-	continue;
+        arith_op(luai_numshl, TM_SHL);
+        continue;
       }
       case OP_BSHR: {
-	arith_op(luai_numshr, TM_SHR);
-	continue;
+        arith_op(luai_numshr, TM_SHR);
+        continue;
       }
       case OP_BNOT: {
+        StkId ra = RA(i);
         TValue *rb = RB(i);
         if (ttisnumber(rb)) {
           lua_Number nb = nvalue(rb);
@@ -553,6 +570,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_UNM: {
+        StkId ra = RA(i);
         TValue *rb = RB(i);
         if (ttisnumber(rb)) {
           lua_Number nb = nvalue(rb);
@@ -564,11 +582,13 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_NOT: {
+        StkId ra = RA(i);
         int res = l_isfalse(RB(i));  /* next assignment may change this value */
         setbvalue(ra, res);
         continue;
       }
       case OP_LEN: {
+        StkId ra = RA(i);
         TValue *rb = RB(i);
         switch (ttype(rb)) {
           case LUA_TTABLE: {
@@ -626,12 +646,14 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_TEST: {
+        StkId ra = RA(i);
         if (l_isfalse(ra) != GETARG_C(i))
           dojump(L, pc, GETARG_sBx(*pc));
         pc++;
         continue;
       }
       case OP_TESTSET: {
+        StkId ra = RA(i);
         TValue *rb = RB(i);
         if (l_isfalse(rb) != GETARG_C(i)) {
           setobjs2s(L, ra, rb);
@@ -641,6 +663,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_CALL: {
+        StkId ra = RA(i);
         int b = GETARG_B(i);
         int nresults = GETARG_C(i) - 1;
         if (b != 0) L->top = ra+b;  /* else previous instruction set top */
@@ -662,6 +685,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         }
       }
       case OP_TAILCALL: {
+        StkId ra = RA(i);
         int b = GETARG_B(i);
         if (b != 0) L->top = ra+b;  /* else previous instruction set top */
         L->savedpc = pc;
@@ -694,6 +718,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         }
       }
       case OP_RETURN: {
+        StkId ra = RA(i);
         int b = GETARG_B(i);
         if (b != 0) L->top = ra+b-1;
         if (L->openupval) luaF_close(L, base);
@@ -709,6 +734,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         }
       }
       case OP_FORLOOP: {
+        StkId ra = RA(i);
         lua_Number step = nvalue(ra+2);
         lua_Number idx = luai_numadd(nvalue(ra), step); /* increment index */
         lua_Number limit = nvalue(ra+1);
@@ -721,6 +747,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_FORPREP: {
+        StkId ra = RA(i);
         const TValue *init = ra;
         const TValue *plimit = ra+1;
         const TValue *pstep = ra+2;
@@ -737,6 +764,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_TFORLOOP: {
+        StkId ra = RA(i);
         StkId cb = ra + 3;  /* call base */
         setobjs2s(L, cb+2, ra+2);
         setobjs2s(L, cb+1, ra+1);
@@ -753,6 +781,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_SETLIST: {
+        StkId ra = RA(i);
         int n = GETARG_B(i);
         int c = GETARG_C(i);
         int last;
@@ -775,10 +804,12 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_CLOSE: {
+        StkId ra = RA(i);
         luaF_close(L, ra);
         continue;
       }
       case OP_CLOSURE: {
+        StkId ra = RA(i);
         Proto *p;
         Closure *ncl;
         int nup, j;
@@ -799,6 +830,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_VARARG: {
+        StkId ra = RA(i);
         int b = GETARG_B(i) - 1;
         int j;
         CallInfo *ci = L->ci;

src/console.c

@@ -50,8 +50,8 @@ I_mutex con_mutex;
 // to avoid infinite SIGABRT recursion in the signal handler
 // due to poisoned locks or mach-o kernel not supporting locks in signals
 // or something like that. idk
-#  define Lock_state()    if (!I_In_Exiting_Signal_Handler()) { I_LockMutex(&con_mutex); }
-#  define Unlock_state()  if (!I_In_Exiting_Signal_Handler()) { I_UnlockMutex(con_mutex); }
+#  define Lock_state()    if (!I_In_Exiting_Signal_Handler()) { I_lock_mutex(&con_mutex); }
+#  define Unlock_state()  if (!I_In_Exiting_Signal_Handler()) { I_unlock_mutex(con_mutex); }
 #else /*HAVE_THREADS*/
 #  define Lock_state()
 #  define Unlock_state()

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/d_clisrv.c

@@ -173,11 +173,11 @@ static UINT16 resynch_delay[MAXNETNODES]; // delay time before the player can be
 static UINT32 resynch_status[MAXNETNODES]; // 0 bit means synched for that player, 1 means possibly desynched
 static UINT8 resynch_sent[MAXNETNODES][MAXPLAYERS]; // what synch packets have we attempted to send to the player
 static UINT8 resynch_inprogress[MAXNETNODES];
-static UINT8 resynch_local_inprogress = false; // WE are desynched and getting packets to fix it.
-UINT8 hu_resynching = 0;
+static boolean resynch_local_inprogress = false; // WE are desynched and getting packets to fix it.
+boolean hu_resynching = false;
 
 #ifdef SATURNPAK
-UINT8 hu_redownloadinggamestate = 0;
+boolean hu_redownloadinggamestate = false;
 static UINT8 gamestate_resend_counter[MAXNETNODES];
 #endif
 
@@ -192,7 +192,7 @@ static UINT8 mynode; // my address pointofview server
 
 #ifdef SATURNPAK
 static boolean cl_redownloadinggamestate = false;
-boolean is_client_saturn[MAXNETNODES];
+static boolean is_client_saturn[MAXNETNODES];
 #endif
 
 #ifdef SATURNJOIN
@@ -2756,6 +2756,11 @@ static boolean CL_ServerConnectionTicker(const char *tmpsave, tic_t *oldtic, tic
 	{
 		INT32 key;
 
+		if (I_Interrupted())
+		{
+			I_Quit();
+		}
+
 		I_OsPolling();
 
 		if (cl_mode == CL_CONFIRMCONNECT)

src/d_clisrv.h

@@ -654,9 +654,9 @@ void D_ResetTiccmds(void);
 
 tic_t GetLag(INT32 node);
 
-extern UINT8 hu_resynching;
+extern boolean hu_resynching;
 #ifdef SATURNPAK
-extern UINT8 hu_redownloadinggamestate;
+extern boolean hu_redownloadinggamestate;
 #endif
 extern boolean hu_stopped; // kart, true when the game is stopped for players due to a disconnecting or connecting player
 

src/d_main.c

@@ -130,8 +130,8 @@ static size_t startuppwadcount = 0;
 // autoloading
 static char *autoloadwadfiles[MAX_WADFILES];
 static char *autoloadwadfilespost[MAX_WADFILES];
-static size_t autoloadcount = 0;
-static size_t postloadcount = 0;
+static size_t autoloadwadcount = 0;
+static size_t postloadwadcount = 0;
 //
 
 boolean devparm = false; // started game with -devparm
@@ -1037,25 +1037,38 @@ static INT32 D_DetectFileType(const char* filename)
 }
 
 // autoload that shit
-static void D_AutoloadFile(const char *file, char **filearray, size_t index)
+static void D_AutoloadFile(const char *file, char **filearray, size_t *index)
 {
 	char *newfile;
 	INT32 fileType = D_DetectFileType(file);
 
+	if (*index >= MAX_WADFILES)
+	{
+		CONS_Printf("D_AutoloadFile: Failed to add file %s! Too many autoloaded files\n", file);
+		return;
+	}
+
 	if (!fileType)
 	{
 		CONS_Printf("D_AutoloadFile: File %s is unknown or invalid\n", file);
 		return;
 	}
 
+	if (fileType == 1)
+	{
+		CONS_Printf("D_AutoloadFile: File %s is a directory\n", file);
+		return;
+	}
+
 	if (fileType <= 6)
 	{
 		newfile = malloc(strlen(file) + 1);
 		if (!newfile)
-			I_Error("No more free memory to AutoloadFile %s",file);
+			I_Error("D_AutoloadFile: No more free memory to autoload file %s", file);
 
 		strcpy(newfile, file);
-		filearray[index] = newfile;
+		filearray[*index] = newfile;
+		(*index)++;
 	}
 	else
 	{
@@ -1098,7 +1111,7 @@ static void D_FindAddonsToAutoload(void)
 	// If the file is found, run our shit
 	if (!autoloadconfigfile) // nope outta here
 	{
-		autoloadcount = postloadcount = 0; // so D_AddAutoloadFiles can skip everything since nothings there to autoload
+		autoloadwadcount = postloadwadcount = 0; // so D_AddAutoloadFiles can skip everything since nothings there to autoload
 		return;
 	}
 
@@ -1124,27 +1137,34 @@ static void D_FindAddonsToAutoload(void)
 		if (newline)
 			*newline = '\0';
 
+		// ok so theres still issues with players adding stuff to autoload by accident
+		// sometimes this stuff contains maps
+		// you can probably imagine how that goes in a netgame....
+		if (W_CheckAutoLoadContainsMap(wadsToAutoload))
+		{
+			CONS_Printf("Autoload: file %s contains map data! skipping...", wadsToAutoload);
+			continue;
+		}
+
 		if (!postload && W_CheckPostLoadList(wadsToAutoload))
 		{
-			CONS_Printf("forcing postload for file %s\n", wadsToAutoload);
+			CONS_Printf("Autoload: forcing postload for file %s\n", wadsToAutoload);
 			postload = true;
 		}
 
 		// LOAD IT
 		if (!postload)
 		{
-			D_AutoloadFile(wadsToAutoload, autoloadwadfiles, autoloadcount);
-			autoloadcount++;
+			D_AutoloadFile(wadsToAutoload, autoloadwadfiles, &autoloadwadcount);
 		}
 		else
 		{
-			D_AutoloadFile(wadsToAutoload, autoloadwadfilespost, postloadcount);
-			postloadcount++;
+			D_AutoloadFile(wadsToAutoload, autoloadwadfilespost, &postloadwadcount);
 		}
 	}
 
-	autoloadwadfiles[autoloadcount] = NULL;
-	autoloadwadfilespost[postloadcount] = NULL;
+	autoloadwadfiles[autoloadwadcount] = NULL;
+	autoloadwadfilespost[postloadwadcount] = NULL;
 
 	// we dont want memory leaks around here do we?
 	fclose(autoloadconfigfile);
@@ -1153,7 +1173,7 @@ static void D_FindAddonsToAutoload(void)
 static void D_AddAutoloadFiles(void)
 {
 	// nothing to autoload
-	if (autoloadcount == 0)
+	if (autoloadwadcount == 0)
 		return;
 
 	CONS_Printf("D_AutoloadFile(): Loading autoloaded addons...\n");
@@ -1161,15 +1181,15 @@ static void D_AddAutoloadFiles(void)
 	if (W_AddAutoloadedLocalFiles(autoloadwadfiles) == 0)
 		CONS_Printf("D_AutoloadFile(): Are you sure you put in valid files or what?\n");
 
-	D_CleanFile(autoloadwadfiles, autoloadcount);
+	D_CleanFile(autoloadwadfiles, autoloadwadcount);
 
-	autoloadcount = 0;
+	autoloadwadcount = 0;
 }
 
 void D_AddPostloadFiles(void)
 {
 	// nothing to postload
-	if (postloadcount == 0 || !netgame)
+	if (postloadwadcount == 0 || !netgame)
 		return;
 
 	CONS_Printf("D_AddPostloadFiles(): Loading postloaded addons...\n");
@@ -1177,9 +1197,9 @@ void D_AddPostloadFiles(void)
 	if (W_AddAutoloadedLocalFiles(autoloadwadfilespost) == 0)
 		CONS_Printf("D_AddPostloadFiles(): Are you sure you put in valid files or what?\n");
 
-	D_CleanFile(autoloadwadfilespost, postloadcount);
+	D_CleanFile(autoloadwadfilespost, postloadwadcount);
 
-	postloadcount = 0;
+	postloadwadcount = 0;
 }
 
 // ==========================================================================
@@ -2023,7 +2043,7 @@ void D_SRB2Main(void)
 	if (M_CheckProtoParam("replay"))
 	{
 		const char *replayurl = M_GetProtoParam();
-		char *replayname = strrchr(replayurl, '/');
+		gconst char *replayname = strrchr(replayurl, '/');
 
 		if (!replayname || !replayurl)
 			I_Error("REPLAY: Invalid URL.");

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.c

@@ -115,20 +115,25 @@ char *myfgets(char *buf, size_t bufsize, MYFILE *f)
 	size_t i = 0;
 	if (myfeof(f))
 		return NULL;
+
 	// we need one byte for a null terminated string
 	bufsize--;
+
 	while (i < bufsize && !myfeof(f))
 	{
 		char c = *f->curpos++;
+
 		if (c == '^')
 			buf[i++] = myfget_color(f);
 		else if (c == '\\')
 			buf[i++] = myfget_hex(f);
 		else if (c != '\r')
 			buf[i++] = c;
+
 		if (c == '\n')
 			break;
 	}
+
 	buf[i] = '\0';
 
 	dbg_line++;
@@ -138,25 +143,31 @@ char *myfgets(char *buf, size_t bufsize, MYFILE *f)
 static char *myhashfgets(char *buf, size_t bufsize, MYFILE *f)
 {
 	size_t i = 0;
+
 	if (myfeof(f))
 		return NULL;
+
 	// we need one byte for a null terminated string
 	bufsize--;
+
 	while (i < bufsize && !myfeof(f))
 	{
 		char c = *f->curpos++;
+
 		if (c == '^')
 			buf[i++] = myfget_color(f);
 		else if (c == '\\')
 			buf[i++] = myfget_hex(f);
 		else if (c != '\r')
 			buf[i++] = c;
+
 		if (c == '\n') // Ensure debug line is right...
 			dbg_line++;
+
 		if (c == '#')
 			break;
 	}
-	i++;
+
 	buf[i] = '\0';
 
 	return buf;
@@ -315,7 +326,10 @@ static void readPlayer(MYFILE *f, INT32 num)
 					goto done;
 				PlayerMenu[num].status = IT_CALL;
 
-				for (i = 0; i < MAXLINELEN-3; i++)
+				// A friendly neighborhood alias for brevity's sake
+				const size_t note_size = sizeof(description[num].notes);
+
+				for (i = 0; i < (INT32)(MAXLINELEN-note_size-3); i++)
 				{
 					if (s[i] == '=')
 					{
@@ -323,10 +337,12 @@ static void readPlayer(MYFILE *f, INT32 num)
 						break;
 					}
 				}
+
 				if (playertext)
 				{
-					strcpy(description[num].notes, playertext);
-					strcat(description[num].notes, myhashfgets(playertext, sizeof (description[num].notes), f));
+					strlcpy(description[num].notes, playertext, note_size);
+					strlcat(description[num].notes,
+							myhashfgets(playertext, note_size, f), note_size);
 				}
 				else
 					strcpy(description[num].notes, "");
@@ -335,7 +351,7 @@ static void readPlayer(MYFILE *f, INT32 num)
 				// It works down here, though.
 				{
 					INT32 numline = 0;
-					for (i = 0; (size_t)i < sizeof(description[num].notes)-1; i++)
+					for (i = 0; (size_t)i < note_size-1; i++)
 					{
 						if (numline < 20 && description[num].notes[i] == '\n')
 							numline++;
@@ -344,6 +360,7 @@ static void readPlayer(MYFILE *f, INT32 num)
 							break;
 					}
 				}
+
 				description[num].notes[strlen(description[num].notes)-1] = '\0';
 				description[num].notes[i] = '\0';
 				continue;

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/doomtype.h

@@ -68,8 +68,21 @@ extern "C" {
 	#define strnicmp(x,y,n) strncasecmp(x,y,n)
 #endif
 
-char *nongnu_strcasestr(const char *in, const char *what);
+// glibc 2.43 made alot of standard lib functions propagate the constness of its input pointers
+// to not cause warnings or compile issues on older glibc versions we do this silly thing
+// to not have a gazillion glibc version checks
+#if defined(__GLIBC_PREREQ)
+#if __GLIBC_PREREQ(2, 43)
+	#define gconst const
+#else
+	#define gconst
+#endif
+#else
+	#define gconst
+#endif
+
 #ifndef _GNU_SOURCE
+char *nongnu_strcasestr(const char *in, const char *what);
 #define strcasestr nongnu_strcasestr
 #endif
 
@@ -127,9 +140,9 @@ size_t strlcpy(char *dst, const char *src, size_t dsize);
 #define STRBUFCPY(dst,src) strlcpy(dst, src, sizeof dst)
 
 /* Boolean type definition */
+#include <stdbool.h>
 
 #ifndef _WIN32
-#include <stdbool.h>
 // dont use stdbools _BOOL type
 // its smaller (1 byte) than the old interger bool (4 bytes)
 // which results in packed struct sizes being mismatched between vanilla and this
@@ -137,9 +150,7 @@ size_t strlcpy(char *dst, const char *src, size_t dsize);
 // which we cant use as enumeration constants
 typedef int32_t boolean;
 #else
-#define false FALSE
-#define true TRUE
-#define boolean BOOL
+#define boolean int32_t
 #endif
 
 /* 7.18.2.1  Limits of exact-width integer types */

src/f_wipe.c

@@ -361,6 +361,11 @@ void F_RunWipe(UINT8 wipetype, boolean drawMenu)
 	// on for fade-to-black
 	for (;;)
 	{
+		if (I_Interrupted())
+		{
+			I_Quit();
+		}
+
 		// get fademask first so we can tell if it exists or not
 		fmask = F_GetFadeMask(wipetype, wipeframe++);
 

src/g_game.c

@@ -4150,6 +4150,7 @@ static void measurekeywords(mapsearchfreq_t *fr,
 {
 	char *qp;
 	char *sp;
+
 	if (wanttable)
 		(*dimp) = Z_Realloc((*dimp), 255 * sizeof (struct searchdim),
 				PU_STATIC, NULL);
@@ -4164,10 +4165,12 @@ static void measurekeywords(mapsearchfreq_t *fr,
 				(*dimp)[(*cuntp)].pos = sp - s;
 				(*dimp)[(*cuntp)].siz = strlen(qp);
 			}
+
 			(*cuntp)++;
 			fr->total++;
 		}
 	}
+
 	if (wanttable)
 		(*dimp) = Z_Realloc((*dimp), (*cuntp) * sizeof (struct searchdim),
 				PU_STATIC, NULL);

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/hardware/hw_draw.c

@@ -222,7 +222,7 @@ void HWR_DrawStretchyFixedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t p
 
 	if (alphalevel)
 	{
-		FSurfaceInfo Surf;
+		FSurfaceInfo Surf = {};
 		Surf.PolyColor.s.red = Surf.PolyColor.s.green = Surf.PolyColor.s.blue = 0xff;
 
 		switch (alphalevel)
@@ -385,7 +385,7 @@ void HWR_DrawCroppedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale,
 	// clip it since it is used for bunny scroll in doom I
 	if (alphalevel)
 	{
-		FSurfaceInfo Surf;
+		FSurfaceInfo Surf = {};
 		Surf.PolyColor.s.red = Surf.PolyColor.s.green = Surf.PolyColor.s.blue = 0xff;
 
 		switch (alphalevel)
@@ -490,7 +490,7 @@ void HWR_DrawFlatFill(INT32 x, INT32 y, INT32 w, INT32 h, lumpnum_t flatlumpnum)
 void HWR_FadeScreenMenuBack(UINT16 color, UINT8 strength)
 {
 	FOutVector  v[4];
-	FSurfaceInfo Surf;
+	FSurfaceInfo Surf = {};
 	FBITFIELD poly_flags = PF_NoTexture|PF_Modulated|PF_NoDepthTest;
 
 	v[0].x = v[3].x = -1.0f;
@@ -543,7 +543,7 @@ void HWR_FadeScreenMenuBack(UINT16 color, UINT8 strength)
 void HWR_DrawConsoleBack(UINT32 color, INT32 height)
 {
 	FOutVector  v[4];
-	FSurfaceInfo Surf;
+	FSurfaceInfo Surf = {};
 
 	// setup some neat-o translucency effect
 	if (!height) //cool hack 0 height is full height
@@ -598,7 +598,7 @@ void HWR_drawAMline(const fline_t *fl, INT32 color)
 void HWR_DrawDiag(INT32 x, INT32 y, INT32 wh, INT32 color)
 {
 	FOutVector v[4];
-	FSurfaceInfo Surf;
+	FSurfaceInfo Surf = {};
 	float fx, fy, fw, fh, fwait = 0;
 	RGBA_t *palette;
 
@@ -702,7 +702,7 @@ void HWR_DrawDiag(INT32 x, INT32 y, INT32 wh, INT32 color)
 void HWR_DrawConsoleFill(INT32 x, INT32 y, INT32 w, INT32 h, UINT32 color, INT32 options)
 {
 	FOutVector v[4];
-	FSurfaceInfo Surf;
+	FSurfaceInfo Surf = {};
 	float fx, fy, fw, fh;
 
 	if (w < 0 || h < 0)
@@ -820,7 +820,7 @@ void HWR_DrawConsoleFill(INT32 x, INT32 y, INT32 w, INT32 h, UINT32 color, INT32
 void HWR_DrawFill(INT32 x, INT32 y, INT32 w, INT32 h, INT32 color)
 {
 	FOutVector v[4];
-	FSurfaceInfo Surf;
+	FSurfaceInfo Surf = {};
 	float fx, fy, fw, fh;
 
 	if (w < 0 || h < 0)

src/hardware/hw_main.cpp

@@ -242,7 +242,6 @@ consvar_t cv_glportals = {"gr_portals", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL,
 
 consvar_t cv_glpaletterendering = {"gr_paletteshader", "Off", CV_CALL|CV_SAVE, CV_OnOff, CV_glpaletterendering_OnChange, 0, NULL, NULL, 0, 0, NULL};
 consvar_t cv_glpalettedepth = {"gr_palettedepth", "16 bits", CV_SAVE|CV_CALL, glpalettedepth_cons_t, CV_glpalettedepth_OnChange, 0, NULL, NULL, 0, 0, NULL};
-consvar_t cv_glflashpal = {"gr_flashpal", "On", CV_CALL|CV_SAVE, CV_OnOff, CV_glpaletterendering_OnChange, 0, NULL, NULL, 0, 0, NULL};
 
 consvar_t cv_gltexturedepth = {"gr_texturedepth", "32 bits", CV_CALL|CV_SAVE, gltexdepth_cons_t, CV_gltextureformat_OnChange, 0, NULL, NULL, 0, 0, NULL};
 
@@ -551,7 +550,7 @@ static FUINT HWR_CalcSlopeLight(FUINT lightnum, pslope_t *slope, const sector_t
 // Render a floor or ceiling convex polygon
 static void HWR_RenderPlane(subsector_t *subsector, extrasubsector_t *xsub, boolean isceiling, fixed_t fixedheight, FBITFIELD PolyFlags, INT32 lightlevel, lumpnum_t lumpnum, sector_t *FOFsector, UINT8 alpha, extracolormap_t *planecolormap)
 {
-	FSurfaceInfo Surf;
+	FSurfaceInfo Surf = {};
 	FOutVector *v3d;
 	polyvertex_t *pv;
 	pslope_t *slope = NULL;
@@ -1376,7 +1375,7 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
 	extracolormap_t *colormap = gl_frontsector->extra_colormap;
 	lightnum = HWR_CalcWallLight(lightnum, gl_curline, colormap);
 
-	FSurfaceInfo Surf;
+	FSurfaceInfo Surf = {};
 
 	Surf.PolyColor.s.alpha = 255;
 
@@ -2675,7 +2674,7 @@ static void HWR_RenderPolyObjectPlane(polyobj_t *polysector, boolean isceiling,
 	float           scrollx = 0.0f, scrolly = 0.0f;
 	float           anglef  = 0.0f, cosangf = 0.0f, sinangf = 0.0f;
 	angle_t         angle = 0;
-	FSurfaceInfo    Surf;
+	FSurfaceInfo    Surf = {};
 	fixed_t         tempxsow, tempytow;
 	size_t          nrPlaneVerts;
 
@@ -2842,9 +2841,8 @@ static void HWR_AddPolyObjectPlanes(void)
 			light = R_GetPlaneLight(gl_frontsector, polyobjsector->floorheight, true);
 			if (po_ptrs[i]->translucency > 0)
 			{
-				FSurfaceInfo Surf;
+				FSurfaceInfo Surf = {};
 				FBITFIELD blendmode;
-				memset(&Surf, 0x00, sizeof(Surf));
 				blendmode = HWR_TranstableToAlpha(po_ptrs[i]->translucency, &Surf);
 				HWR_AddTransparentPolyobjectFloor(levelflats[polyobjsector->floorpic].lumpnum, po_ptrs[i], false, polyobjsector->floorheight,
 												(light == -1 ? gl_frontsector->lightlevel : *gl_frontsector->lightlist[light].lightlevel), Surf.PolyColor.s.alpha, polyobjsector, blendmode, (light == -1 ? gl_frontsector->extra_colormap : gl_frontsector->lightlist[light].extra_colormap));
@@ -2865,9 +2863,8 @@ static void HWR_AddPolyObjectPlanes(void)
 			light = R_GetPlaneLight(gl_frontsector, polyobjsector->ceilingheight, true);
 			if (po_ptrs[i]->translucency > 0)
 			{
-				FSurfaceInfo Surf;
+				FSurfaceInfo Surf = {};
 				FBITFIELD blendmode;
-				memset(&Surf, 0x00, sizeof(Surf));
 				blendmode = HWR_TranstableToAlpha(po_ptrs[i]->translucency, &Surf);
 				HWR_AddTransparentPolyobjectFloor(levelflats[polyobjsector->ceilingpic].lumpnum, po_ptrs[i], true, polyobjsector->ceilingheight,
 												(light == -1 ? gl_frontsector->lightlevel : *gl_frontsector->lightlist[light].lightlevel), Surf.PolyColor.s.alpha, polyobjsector, blendmode, (light == -1 ? gl_frontsector->extra_colormap : gl_frontsector->lightlist[light].extra_colormap));
@@ -3419,7 +3416,7 @@ static void HWR_DrawSpriteShadow(gl_vissprite_t *spr, patch_t *gpatch, GLPatch_t
 {
 	float this_scale = 1.0f;
 	FOutVector swallVerts[4];
-	FSurfaceInfo sSurf;
+	FSurfaceInfo sSurf = {};
 	FBITFIELD blendmode = 0;
 	fixed_t floorheight, mobjfloor;
 	pslope_t *floorslope;
@@ -3655,7 +3652,7 @@ static void HWR_SplitSprite(gl_vissprite_t *spr, const boolean papersprite)
 	FOutVector baseWallVerts[4]; // This is what the verts should end up as
 	patch_t *gpatch;
 	GLPatch_t *hwrpatch;
-	FSurfaceInfo Surf;
+	FSurfaceInfo Surf = {};
 	extracolormap_t *colormap;
 	INT32 lightlevel;
 	boolean lightset = true;
@@ -3940,7 +3937,7 @@ static void HWR_DrawSprite(gl_vissprite_t *spr)
 	FOutVector wallVerts[4];
 	patch_t *gpatch; // sprite patch converted to hardware
 	GLPatch_t *hwrpatch;
-	FSurfaceInfo Surf;
+	FSurfaceInfo Surf = {};
 	FBITFIELD blend = 0;
 
 	INT32 shader = SHADER_NONE;
@@ -4105,7 +4102,7 @@ static void HWR_DrawPrecipitationSprite(gl_vissprite_t *spr)
 	FOutVector wallVerts[4];
 	patch_t *gpatch; // sprite patch converted to hardware
 	GLPatch_t *hwrpatch;
-	FSurfaceInfo Surf;
+	FSurfaceInfo Surf = {};
 
 	INT32 shader = SHADER_NONE;
 
@@ -4850,7 +4847,7 @@ static void HWR_ProjectSprite(mobj_t *thing)
 		flip = sprframe->flip; // Will only be 0x00 or 0xFF
 
 		if (papersprite && ang < ANGLE_180)
-			flip ^= 0xFFFF;
+			flip ^= 0xFF;
 	}
 	else
 	{
@@ -5913,7 +5910,6 @@ void HWR_AddCommands(void)
 
 	CV_RegisterVar(&cv_glpaletterendering);
 	CV_RegisterVar(&cv_glpalettedepth);
-	CV_RegisterVar(&cv_glflashpal);
 }
 
 // --------------------------------------------------------------------------
@@ -6070,7 +6066,7 @@ static void HWR_DoPostProcessor(void)
 {
 	// Armageddon Blast Flash!
 	// Could this even be considered postprocessor?
-	if (!HWR_PalRenderFlashpal())
+	if (!HWR_ShouldUsePaletteRendering())
 	{
 		const player_t *player = &players[displayplayers[viewssnum]];
 
@@ -6083,7 +6079,7 @@ static void HWR_DoPostProcessor(void)
 				{-4.0f, -4.0f, 4.0f, 0.0f, 0.0f}
 			};
 
-			FSurfaceInfo Surf;
+			FSurfaceInfo Surf = {};
 
 			// This won't change if the flash palettes are changed unfortunately, but it works for its purpose
 			if (player->flashpal == PAL_NUKE)

src/hardware/hw_main.h

@@ -208,7 +208,6 @@ extern consvar_t cv_glportals;
 
 extern consvar_t cv_glpaletterendering;
 extern consvar_t cv_glpalettedepth;
-extern consvar_t cv_glflashpal;
 
 FUNCINLINE static ATTRINLINE boolean HWR_UseShader(void)
 {
@@ -220,11 +219,6 @@ FUNCINLINE static ATTRINLINE boolean HWR_ShouldUsePaletteRendering(void)
 	return (cv_glpaletterendering.value && (pLocalPalette != NULL) && HWR_UseShader());
 }
 
-FUNCINLINE static ATTRINLINE boolean HWR_PalRenderFlashpal(void)
-{
-	return (cv_glflashpal.value && HWR_ShouldUsePaletteRendering());
-}
-
 // Returns a pointer to the palette which should be used for caching textures.
 FUNCINLINE static ATTRINLINE RGBA_t *HWR_GetTexturePalette(void)
 {

src/hardware/hw_md2.c

@@ -1099,7 +1099,7 @@ void HWR_DrawMD2(gl_vissprite_t *spr)
 	INT32 frame = 0;
 	INT32 nextFrame = -1;
 	FTransform p;
-	FSurfaceInfo Surf;
+	FSurfaceInfo Surf = {};
 
 	if (!cv_glmdls.value || spr->precip)
 		return;
@@ -1336,8 +1336,8 @@ void HWR_DrawMD2(gl_vissprite_t *spr)
 		if (spr->mobj->frame & FF_ANIMATE)
 		{
 			// set duration and tics to be the correct values for FF_ANIMATE states
-			durs = (float)spr->mobj->state->var2;
-			tics = (float)spr->mobj->anim_duration;
+			durs = spr->mobj->state->var2;
+			tics = (INT32)spr->mobj->anim_duration;
 		}
 
 		//FIXME: this is not yet correct
@@ -1475,7 +1475,7 @@ void HWR_Draw2DModel(md2_t *md2, INT32 x, INT32 y, INT32 skinnum, skincolors_t c
 	patch_t *gpatch, *blendgpatch;
 	GLPatch_t *hwrPatch = NULL, *hwrBlendPatch = NULL;
 	FTransform p;
-	FSurfaceInfo Surf;
+	FSurfaceInfo Surf = {};
 
 	if (!md2->model)
 	{
@@ -1526,7 +1526,6 @@ void HWR_Draw2DModel(md2_t *md2, INT32 x, INT32 y, INT32 skinnum, skincolors_t c
 	if (blendgpatch)
 		hwrBlendPatch = ((GLPatch_t *)blendgpatch->hardware);
 
-	memset(&Surf, 0x00, sizeof(FSurfaceInfo));
 	Surf.PolyColor.rgba = 0xFFFFFFFF;
 	Surf.PolyFlags = PF_Occlude | PF_Modulated;
 

src/hardware/hw_shaders.c

@@ -109,7 +109,7 @@ boolean HWR_InitShaders(void)
 // returns INT32_MAX if not found
 static INT32 strstr_int(const char *str1, const char *str2)
 {
-	char *location = strstr(str1, str2);
+	gconst char *location = strstr(str1, str2);
 	if (location)
 		return location - str1;
 	else

src/hardware/r_opengl/r_opengl.c

@@ -1383,19 +1383,19 @@ void GL_Flush(void)
 // -----------------+
 INT32 GL_isExtAvailable(const char *extension, const GLubyte *start)
 {
-	GLubyte         *where, *terminator;
+	gconst GLubyte *where, *terminator;
 
 	if (!extension || !start)
 		return 0;
 
-	where = (GLubyte *) strchr(extension, ' ');
+	where = (gconst GLubyte *)strchr(extension, ' ');
 
 	if (where || *extension == '\0')
 		return 0;
 
 	for (;;)
 	{
-		where = (GLubyte *) strstr((const char *) start, extension);
+		where = (gconst GLubyte *)strstr((const char *)start, extension);
 
 		if (!where)
 			break;

src/k_kart.c

@@ -2159,7 +2159,13 @@ static void K_GetKartBoostPower(player_t *player)
 		&& player->speed > 0
 		&& !player->spectator)
 	{
-		K_SpawnWipeoutTrail(player->mo, true);
+		mobj_t *dust = K_SpawnWipeoutTrail(player->mo, true);
+
+		// Technically, all mobjs that think can cause desynchs if they are spawned conditionally, so best we can do
+		// is to hide them if you are in saltyhop jump
+		if (dust && player->mo->salty.jump)
+			dust->flags2 |= MF2_DONTDRAW;
+
 		if (leveltime % 6 == 0)
 			S_StartSound(player->mo, sfx_cdfm70);
 	}
@@ -3634,7 +3640,7 @@ void K_SpawnSparkleTrail(mobj_t *mo)
 	P_SetMobjState(sparkle, S_KARTINVULN_LARGE1);
 }
 
-void K_SpawnWipeoutTrail(mobj_t *mo, boolean translucent)
+mobj_t *K_SpawnWipeoutTrail(mobj_t *mo, boolean translucent)
 {
 	mobj_t *dust;
 	angle_t aoff;
@@ -3675,6 +3681,8 @@ void K_SpawnWipeoutTrail(mobj_t *mo, boolean translucent)
 
 	if (translucent)
 		dust->flags2 |= MF2_SHADOW;
+
+	return dust;
 }
 
 //	K_DriftDustHandling
@@ -6175,6 +6183,13 @@ void K_KartUpdatePosition(player_t *player)
 						}
 					}
 
+					// the player should NOT be checked against themselves! lol
+					// otherwise prevcheck will effectively be halved
+					// sadly this stuff is exposed to lua and atleast one script uses those so we cant fix it
+					// oh well
+					//if (player == &players[i])
+						//continue;
+
 					const boolean isprevcheckpointi = mo->health == players[i].starpostnum;
 					const boolean isnextcheckpointi = mo->health == (players[i].starpostnum + 1);
 

src/k_kart.h

@@ -57,7 +57,7 @@ boolean K_ShouldSlopeRoll(mobj_t *mobj);
 void K_RollMobjBySlopes(mobj_t *mo, pslope_t *slope);
 void K_SpawnBoostTrail(player_t *player);
 void K_SpawnSparkleTrail(mobj_t *mo);
-void K_SpawnWipeoutTrail(mobj_t *mo, boolean translucent);
+mobj_t *K_SpawnWipeoutTrail(mobj_t *mo, boolean translucent);
 void K_DriftDustHandling(mobj_t *spawner);
 void K_PuntMine(mobj_t *mine, mobj_t *punter);
 void K_DoSneaker(player_t *player, INT32 type);

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_menu.c

@@ -4020,8 +4020,8 @@ I_mutex replayquerymutex;
 // to avoid infinite SIGABRT recursion in the signal handler
 // due to poisoned locks or mach-o kernel not supporting locks in signals
 // or something like that. idk
-#  define Lock_search_state()    if (!I_In_Exiting_Signal_Handler()) { I_LockMutex(&replayquerymutex); }
-#  define Unlock_search_state()  if (!I_In_Exiting_Signal_Handler()) { I_UnlockMutex(replayquerymutex); }
+#  define Lock_search_state()    if (!I_In_Exiting_Signal_Handler()) { I_lock_mutex(&replayquerymutex); }
+#  define Unlock_search_state()  if (!I_In_Exiting_Signal_Handler()) { I_unlock_mutex(replayquerymutex); }
 #else /*HAVE_THREADS*/
 #  define Lock_search_state()
 #  define Unlock_search_state()

src/m_menudefs.c

@@ -1023,8 +1023,6 @@ static menuitem_t OP_OpenGLOptionsMenu[] =
 	{IT_STRING | IT_CVAR,	NULL, "Fallback Player 3D Model",	&cv_glfallbackplayermodel,	20},
 	{IT_STRING | IT_CVAR,	NULL, "Shaders",					&cv_glshaders,				25},
 	{IT_STRING | IT_CVAR,	NULL, "Palette Rendering",			&cv_glpaletterendering,		30},
-	{IT_STRING | IT_CVAR,   NULL, "Palette Rendering Flashpals",&cv_glflashpal,				35},
-	//{IT_STRING | IT_CVAR, 	NULL, "Min Shader Brightness", 		&cv_glsecbright,			40},
 
 	{IT_STRING | IT_CVAR,	NULL, "Texture Quality",			&cv_gltexturedepth,			45},
 	{IT_STRING | IT_CVAR,	NULL, "Texture Filter",				&cv_glfiltermode,			50},

src/m_misc.c

@@ -788,10 +788,10 @@ static void M_PNGText(png_structp png_ptr, png_infop png_info_ptr, PNG_CONST png
 	else
 		snprintf(locationtxt, 40, "Unknown");
 
-	memset(png_infotext,0x00,sizeof (png_infotext));
+	memset(png_infotext, 0x00, sizeof(png_infotext));
 
 	for (i = 0; i < SRB2PNGTXT; i++)
-		png_infotext[i].key  = keytxt[i];
+		png_infotext[i].key = keytxt[i];
 
 	png_infotext[0].text = titletxt;
 	if (movie)
@@ -804,9 +804,15 @@ static void M_PNGText(png_structp png_ptr, png_infop png_info_ptr, PNG_CONST png
 	png_infotext[5].text = locationtxt;
 	png_infotext[6].text = interfacetxt;
 	png_infotext[7].text = rendermodetxt;
-	png_infotext[8].text = strncpy(ctrevision, comprevision, sizeof(ctrevision)-1);
-	png_infotext[9].text = strncpy(ctdate, compdate, sizeof(ctdate)-1);
-	png_infotext[10].text = strncpy(cttime, comptime, sizeof(cttime)-1);
+	strncpy(ctrevision, comprevision, sizeof(ctrevision)-1);
+	ctrevision[sizeof(ctrevision)-1] = '\0';
+	png_infotext[8].text = ctrevision;
+	strncpy(ctdate, compdate, sizeof(ctdate)-1);
+	ctdate[sizeof(ctdate)-1] = '\0';
+	png_infotext[9].text = ctdate;
+	strncpy(cttime, comptime, sizeof(cttime)-1);
+	cttime[sizeof(cttime)-1] = '\0';
+	png_infotext[10].text = cttime;
 
 	png_set_text(png_ptr, png_info_ptr, png_infotext, SRB2PNGTXT);
 #undef SRB2PNGTXT
@@ -1454,9 +1460,9 @@ INT32 axtoi(const char *hexStg)
 
 void CopyCaretColors(char *p, const char *s, int n)
 {
-	char *t;
-	int   m;
-	int   c;
+	gconst char *t;
+	int          m;
+	int          c;
 
 	if (!n)
 		return;
@@ -1564,6 +1570,7 @@ char *M_GetToken(const char *inputString)
 	{
 		startPos = endPos;
 	}
+
 	if (stringToUse == NULL)
 		return NULL;
 
@@ -1634,7 +1641,8 @@ char *M_GetToken(const char *inputString)
 	}
 
 	// If the end of the string is reached, no token is to be read
-	if (startPos == stringLength) {
+	if (startPos == stringLength)
+	{
 		endPos = stringLength;
 		return NULL;
 	}
@@ -1644,7 +1652,7 @@ char *M_GetToken(const char *inputString)
 			|| stringToUse[startPos] == '}')
 	{
 		endPos = startPos + 1;
-		texturesToken = (char *)Z_Malloc(2*sizeof(char),PU_STATIC,NULL);
+		texturesToken = (char *)Z_Malloc(2*sizeof(char), PU_STATIC, NULL);
 		texturesToken[0] = stringToUse[startPos];
 		texturesToken[1] = '\0';
 		return texturesToken;
@@ -1855,8 +1863,10 @@ int M_PathParts(const char *path)
 	int n;
 	const char *p;
 	const char *t;
+
 	if (path == NULL)
 		return 0;
+
 	for (n = 0, p = path ;; ++n)
 	{
 		t = p;
@@ -1869,6 +1879,7 @@ int M_PathParts(const char *path)
 			break;
 		}
 	}
+
 	return n;
 }
 
@@ -1911,7 +1922,9 @@ void M_MkdirEachUntil(const char *cpath, int start, int end, int mode)
 		if (!( p = strchr(p, PATHSEP[0]) ))
 			return;
 	}
+
 	p += strspn(p, PATHSEP);
+
 	for (;;)
 	{
 		if (end > 0 && !--end)
@@ -1956,6 +1969,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/p_setup.c

@@ -414,7 +414,7 @@ void P_UpdateSegLightOffset(seg_t *li)
 		angle_t liAngle = R_PointToAngle2(0, 0, (li->v1->x - li->v2->x), (li->v1->y - li->v2->y)) - ANGLE_90;
 
 		light = FixedMul(FINECOSINE(liAngle >> ANGLETOFINESHIFT), FINECOSINE(maplighting.angle >> ANGLETOFINESHIFT))
-		+ FixedMul(FINESINE(liAngle >> ANGLETOFINESHIFT), FINESINE(maplighting.angle >> ANGLETOFINESHIFT));
+			  + FixedMul(FINESINE(liAngle >> ANGLETOFINESHIFT), FINESINE(maplighting.angle >> ANGLETOFINESHIFT));
 		light = (light + FRACUNIT) / 2;
 	}
 	else
@@ -1914,7 +1914,7 @@ static void P_LoadMapBSP(const virtres_t* virt)
 	if (numsubsectors <= 0)
 		I_Error("Level has no subsectors (did you forget to run it through a nodesbuilder?)");
 	if (numnodes <= 0)
-		I_Error("Level has no nodes");
+		I_Error("Level has no nodes (does your map have at least 2 sectors?)");
 	if (numsegs <= 0)
 		I_Error("Level has no segs");
 
@@ -2077,10 +2077,10 @@ static void P_LevelInitStuff(boolean reloadinggamestate)
 	stagefailed = false;
 
 	// earthquake camera
-	memset(&quake,0,sizeof(struct quake));
+	memset(&quake, 0, sizeof(struct quake));
 
 	// song credit init
-	memset(&cursongcredit,0,sizeof(struct cursongcredit));
+	memset(&cursongcredit, 0, sizeof(struct cursongcredit));
 	cursongcredit.trans = NUMTRANSMAPS;
 
 	for (i = 0; i < MAXPLAYERS; i++)
@@ -2174,14 +2174,14 @@ static INT32 P_MakeBufferMD5(const char *buffer, size_t len, void *resblock)
 	memset(resblock, 0x00, 16);
 	return 1;
 #else
-	tic_t t = I_GetTime();
+	precise_t t = I_GetPreciseTime();
 
 	CONS_Debug(DBG_SETUP, "Making MD5\n");
 
 	if (md5_buffer(buffer, len, resblock) == NULL)
 		return 1;
 
-	CONS_Debug(DBG_SETUP, "MD5 calc took %f seconds\n", (float)(I_GetTime() - t)/NEWTICRATE);
+	CONS_Debug(DBG_SETUP, "MD5 calc took %f seconds\n", (float)(I_GetPreciseTime() - t)/I_GetPrecisePrecision());
 
 	return 0;
 #endif
@@ -2203,10 +2203,10 @@ static void P_MakeMapMD5(virtres_t *virt, void *dest)
 	virtlump_t* virtmthings = vres_Find(virt, "THINGS");
 	virtlump_t* virtsides   = vres_Find(virt, "SIDEDEFS");
 
-	P_MakeBufferMD5((char*)virtlines->data,   virtlines->size, linemd5);
-	P_MakeBufferMD5((char*)virtsectors->data, virtsectors->size,  sectormd5);
-	P_MakeBufferMD5((char*)virtmthings->data, virtmthings->size,   thingmd5);
-	P_MakeBufferMD5((char*)virtsides->data,   virtsides->size, sidedefmd5);
+	P_MakeBufferMD5((char*)virtlines->data,   virtlines->size,   linemd5);
+	P_MakeBufferMD5((char*)virtsectors->data, virtsectors->size, sectormd5);
+	P_MakeBufferMD5((char*)virtmthings->data, virtmthings->size, thingmd5);
+	P_MakeBufferMD5((char*)virtsides->data,   virtsides->size,   sidedefmd5);
 
 	for (i = 0; i < 16; i++)
 		resmd5[i] = (linemd5[i] + sectormd5[i] + thingmd5[i] + sidedefmd5[i]) & 0xFF;

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/r_things.cpp

@@ -2960,7 +2960,7 @@ fixed_t R_DoPlayerFade(mobj_t *thing)
 	fixed_t fadealpha = FRACUNIT;
 	static constexpr tic_t countdownstarttime = (15 * TICRATE) / 4; // starttime - (3*TICRATE)
 
-	if (thing->player == viewplayer || viewplayer->exiting || camera[R_GetViewNumber()].freecam || leveltime < countdownstarttime)
+	if (thing->player == viewplayer || viewplayer->exiting || viewplayer->spectator || camera[R_GetViewNumber()].freecam || leveltime < countdownstarttime)
 		return fadealpha;
 
 	const INT32 playerdist     = (FixedMul((thing->x - viewx), viewcos) + FixedMul((thing->y - viewy), viewsin)) >> FRACBITS;

src/s_sound.c

@@ -116,9 +116,7 @@ consvar_t cv_skipintromusic = {"skipintromusic", "No", CV_SAVE, CV_YesNo, NULL,
 
 boolean keepmapmusic = false; // keep the current music on map restart
 boolean skipintromus = false; // skip the intro fanfare
-static boolean resumekeepmusic = false;
 static music_t keepmusic;
-static void S_SetKeepMusResume(void);
 
 #ifdef HAVE_OPENMPT
 openmpt_module *openmpt_mhandle = NULL;
@@ -1301,7 +1299,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;
@@ -1438,7 +1436,7 @@ void S_LoadMusicDefs(UINT16 wadnum)
 			stoken = strtok(stoken, " ");
 			if (stoken)
 			{
-				if (! ReadMusicDefFields(wadnum, line, stoken, &def))
+				if (!ReadMusicDefFields(wadnum, line, stoken, &def))
 					break;
 			}
 
@@ -1483,7 +1481,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)
@@ -1848,8 +1846,6 @@ void S_StopMusic(void)
 
 	mapmusic.resume = (cv_resume.value && fasticmp(music.name, mapmusic.name)) ? I_GetSongPosition() : 0;
 
-	S_SetKeepMusResume();
-
 	if (I_SongPaused())
 		I_ResumeSong();
 
@@ -1976,17 +1972,6 @@ void S_ResetKeepAndSpecialMus(void)
 	keepmapmusic = skipintromus = false;
 }
 
-// saves the current song position everytime a song stops
-// so we can resume it in some cases
-static void S_SetKeepMusResume(void)
-{
-	keepmusic.resume = 0;
-
-	if (fasticmp(music.name, mapmusic.name))
-	{
-		keepmusic.resume = I_GetSongPosition();
-	}
-}
 
 // determine if we should keep the music on a map restart
 // this gets called BEFORE the level gets loaded in G_DoLoadLevel
@@ -1995,7 +1980,7 @@ void S_KeepMusic(void)
 	static INT16 oldmap = -1;
 	static boolean oldencore = false;
 
-	keepmapmusic = resumekeepmusic = false;
+	keepmapmusic = false;
 
 	if (!cv_keepmusic.value)
 	{
@@ -2009,9 +1994,7 @@ void S_KeepMusic(void)
 
 	if (oldmap == gamemap && oldencore == encoremode)
 	{
-		const boolean musicchanged = S_CheckMusicException();
-		resumekeepmusic = (musicchanged && keepmusic.resume);
-		keepmapmusic = (!musicchanged || resumekeepmusic);
+		keepmapmusic = (S_CheckMusicException() == false);
 	}
 
 	oldencore = encoremode;
@@ -2072,12 +2055,6 @@ void S_InitMapMusic(void)
 
 	if (keepmapmusic)
 	{
-		// this is kinda silly, but we can use it to fade back into the map song at the saved point, should the current music be different from the map music
-		if (resumekeepmusic)
-		{
-			S_ChangeMusicEx(mapmusic.name, mapmusic.flags, true, keepmusic.resume, 0, 500);
-		}
-
 		return;
 	}
 

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/sdl/mixer_sound.c

@@ -216,8 +216,13 @@ void I_StartupSound(void)
 				SDLmixlinked->major, SDLmixlinked->minor, SDLmixlinked->patch);
 
 #ifdef HAVE_OPENMPT
-	I_OutputMsg("libopenmpt version: %s\n", openmpt_get_string("library_version"));
-	I_OutputMsg("libopenmpt build date: %s\n", openmpt_get_string("build"));
+	const char *openmptstr;
+	openmptstr = openmpt_get_string("library_version");
+	I_OutputMsg("libopenmpt version: %s\n", openmptstr);
+	openmpt_free_string(openmptstr);
+	openmptstr = openmpt_get_string("build");
+	I_OutputMsg("libopenmpt build date: %s\n", openmptstr);
+	openmpt_free_string(openmptstr);
 #endif
 
 	sound_started = true;

src/st_stuff.c

@@ -180,7 +180,7 @@ static void ST_doPaletteStuff(void)
 	INT32 palette = 0;
 
 #ifdef HWRENDER
-	if (rendermode == render_opengl && !HWR_PalRenderFlashpal())
+	if (rendermode == render_opengl && !HWR_ShouldUsePaletteRendering())
 		return;
 #endif
 

src/strcasestr.c

@@ -23,24 +23,26 @@ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
+#ifndef _GNU_SOURCE
+
 #include <string.h>
 #include <ctype.h>
 #include <stddef.h>
 
-static inline int
-trycmp (char **pp, char *cp,
-		const char *q, size_t qn)
+static inline int trycmp(char **pp, char *cp, const char *q, size_t qn)
 {
 	char *p;
 	p = (*pp);
+
 	if (strncasecmp(p, q, qn) == 0)
 		return 0;
+
 	(*pp) = strchr(&p[1], (*cp));
+
 	return 1;
 }
 
-static inline void
-swapp (char ***ppap, char ***ppbp, char **cpap, char **cpbp)
+static inline void swapp(char ***ppap, char ***ppbp, char **cpap, char **cpbp)
 {
 	char **pp;
 	char  *p;
@@ -54,8 +56,7 @@ swapp (char ***ppap, char ***ppbp, char **cpap, char **cpbp)
 	*cpbp =   p;
 }
 
-char *
-nongnu_strcasestr (const char *s, const char *q)
+char *nongnu_strcasestr(const char *s, const char *q)
 {
 	size_t  qn;
 
@@ -113,3 +114,5 @@ nongnu_strcasestr (const char *s, const char *q)
 
 	return NULL;
 }
+
+#endif

src/v_paldeltas.h

@@ -0,0 +1,525 @@
+#ifndef H_PALDELTA
+#define H_PALDELTA
+
+// those are the differences in palette indices between the main srb2 playpal and its white and nuke subpalettes
+// this is probably not the best way of doing any of this, but it works lol
+
+static const INT16 pPaletteDeltaFlash[256][3] = {
+    {   6,   6,   6},
+    {  12,  12,  12},
+    {  18,  18,  18},
+    {  24,  24,  24},
+    {  30,  30,  30},
+    {  36,  36,  36},
+    {  42,  42,  42},
+    {  48,  48,  48},
+    {  54,  54,  54},
+    {  60,  60,  60},
+    {  66,  66,  66},
+    {  72,  72,  72},
+    {  78,  78,  78},
+    {  84,  84,  84},
+    {  90,  90,  90},
+    {  95,  95,  95},
+    { 101, 101, 101},
+    { 107, 107, 107},
+    { 113, 113, 113},
+    { 119, 119, 119},
+    { 125, 125, 125},
+    { 131, 131, 131},
+    { 137, 137, 137},
+    { 143, 143, 143},
+    { 149, 149, 149},
+    { 155, 155, 155},
+    { 161, 161, 161},
+    { 167, 167, 167},
+    { 173, 173, 173},
+    { 179, 179, 179},
+    { 185, 185, 185},
+    { 191, 191, 191},
+    {  48,  66,  84},
+    {  54,  71,  89},
+    {  60,  77,  95},
+    {  66,  83, 100},
+    {  72,  88, 105},
+    {  79,  94, 111},
+    {  85,  99, 117},
+    {  91, 105, 123},
+    {  96, 111, 129},
+    { 102, 117, 135},
+    { 108, 123, 141},
+    { 114, 128, 146},
+    { 120, 134, 152},
+    { 127, 140, 158},
+    { 133, 145, 163},
+    { 140, 152, 170},
+    {  48,  98, 134},
+    {  57, 104, 137},
+    {  63, 107, 140},
+    {  69, 110, 143},
+    {  75, 116, 146},
+    {  84, 119, 149},
+    {  90, 125, 152},
+    {  95, 128, 155},
+    { 101, 131, 158},
+    { 110, 137, 161},
+    { 119, 140, 164},
+    { 128, 143, 167},
+    { 134, 149, 170},
+    { 143, 155, 173},
+    { 152, 158, 176},
+    { 158, 164, 179},
+    {   0,  15,  24},
+    {   0,  21,  33},
+    {   0,  27,  42},
+    {   0,  33,  51},
+    {   0,  36,  57},
+    {   0,  42,  66},
+    {   0,  48,  75},
+    {   0,  51,  81},
+    {   0,  57,  93},
+    {   6,  63,  98},
+    {  12,  69, 104},
+    {  18,  75, 110},
+    {  24,  81, 116},
+    {  30,  87, 122},
+    {  36,  93, 128},
+    {  39,  95, 131},
+    {   0,  12,  26},
+    {   0,  26,  52},
+    {   0,  39,  78},
+    {   0,  52, 102},
+    {   0,  65, 127},
+    {   0,  78, 150},
+    {   0,  91, 172},
+    {   0, 102, 191},
+    {   9, 108, 191},
+    {  19, 114, 191},
+    {  29, 120, 191},
+    {  39, 127, 191},
+    {  48, 133, 191},
+    {  58, 139, 191},
+    {  68, 145, 191},
+    {  78, 150, 191},
+    {   0,   0,  12},
+    {   0,   0,  36},
+    {   0,   0,  60},
+    {   0,   0,  84},
+    {   0,   0, 107},
+    {   0,   0, 131},
+    {   0,   0, 155},
+    {   0,   0, 179},
+    {   0,   0, 191},
+    {  36,  36, 191},
+    {  60,  60, 191},
+    {  84,  84, 191},
+    { 107, 107, 191},
+    { 131, 131, 191},
+    { 155, 155, 191},
+    { 179, 179, 191},
+    {   0,   0, 104},
+    {  15,  27, 125},
+    {  30,  51, 140},
+    {  45,  75, 155},
+    {  60,  98, 167},
+    {  75, 122, 176},
+    {  90, 140, 185},
+    { 104, 158, 191},
+    {   0,   0,   0},
+    {   0,  24,  24},
+    {   0,  48,  48},
+    {   0,  72,  72},
+    {   0,  95,  95},
+    {   0, 119, 119},
+    {   0, 143, 143},
+    {   0, 167, 167},
+    {   0, 191, 191},
+    {  12, 191, 191},
+    {  24, 191, 191},
+    {  36, 191, 191},
+    {  48, 191, 191},
+    {  60, 191, 191},
+    {  72, 191, 191},
+    {  84, 191, 191},
+    {  95, 191, 191},
+    { 107, 191, 191},
+    { 119, 191, 191},
+    { 131, 191, 191},
+    { 143, 191, 191},
+    { 155, 191, 191},
+    { 167, 191, 191},
+    { 179, 191, 191},
+    {   0,  54,  54},
+    {   9,  69,  69},
+    {  18,  84,  84},
+    {  27,  98,  98},
+    {  39, 110, 110},
+    {  48, 122, 122},
+    {  57, 131, 131},
+    {  66, 143, 143},
+    {  85, 156, 191},
+    {  91, 161, 191},
+    {  96, 166, 191},
+    { 102, 172, 191},
+    { 108, 177, 191},
+    { 114, 182, 191},
+    { 120, 187, 191},
+    { 127, 191, 191},
+    { 101,   0, 131},
+    { 106,  11, 134},
+    { 111,  23, 138},
+    { 117,  35, 142},
+    { 123,  47, 145},
+    { 129,  59, 149},
+    { 134,  71, 153},
+    { 140,  83, 157},
+    { 145,  95, 160},
+    { 151, 106, 164},
+    { 157, 118, 168},
+    { 162, 130, 172},
+    { 168, 142, 175},
+    { 173, 154, 179},
+    { 179, 166, 183},
+    { 185, 179, 187},
+    {  24,   0,  65},
+    {  42,  20,  80},
+    {  61,  41,  95},
+    {  79,  61, 110},
+    {  97,  82, 124},
+    { 115, 101, 139},
+    { 135, 123, 154},
+    { 153, 143, 169},
+    { 191,   0, 191},
+    { 191,  24, 191},
+    { 191,  48, 191},
+    { 191,  72, 191},
+    { 191,  95, 191},
+    { 191, 119, 191},
+    { 191, 143, 191},
+    { 191, 167, 191},
+    {   0, 107,   0},
+    {   0, 191,   0},
+    {  24, 191,  24},
+    {  48, 191,  48},
+    {  72, 191,  72},
+    {  95, 191,  95},
+    { 119, 191, 119},
+    { 143, 191, 143},
+    {  16,  16,   9},
+    {  44,  44,  22},
+    {  73,  73,  36},
+    { 101, 101,  51},
+    { 127, 127,  66},
+    { 142, 142,  93},
+    { 156, 156, 121},
+    { 170, 170, 151},
+    {  31,  10,   0},
+    {  48,  15,   0},
+    {  64,  21,   0},
+    {  79,  25,   0},
+    {  95,  30,   0},
+    { 111,  36,   0},
+    { 127,  41,   0},
+    { 143,  48,   0},
+    { 149,  73,  24},
+    { 155,  84,  48},
+    { 161, 101,  72},
+    { 167, 119,  95},
+    { 191,  48,  48},
+    { 191,  95,  95},
+    { 191, 119, 119},
+    { 191, 143, 143},
+    {  18,  18,   0},
+    {  42,  42,   0},
+    {  61,  61,   0},
+    {  86,  86,   0},
+    { 104, 104,   0},
+    { 129, 129,   0},
+    { 154, 154,   0},
+    { 172, 172,   0},
+    { 191, 191,   0},
+    { 191, 191,  18},
+    { 191, 191,  36},
+    { 191, 191,  55},
+    { 191, 191,  74},
+    { 191, 191,  92},
+    { 191, 191, 110},
+    { 191, 191, 129},
+    { 191, 191, 131},
+    { 191, 191, 143},
+    { 191, 191, 149},
+    { 191, 191, 161},
+    { 191, 191, 167},
+    { 191, 191, 179},
+    { 191, 191, 185},
+    { 191,   0,   0},
+    {  36,  95,  36},
+    {  54, 107,  54},
+    {  72, 119,  72},
+    {  90, 131,  90},
+    { 107, 143, 107},
+    { 125, 155, 125},
+    { 143, 167, 143},
+    { 161, 179, 161}
+};
+
+static const INT16 pPaletteDeltaNuke[256][3] = {
+    {   6,-133,-133},
+    {  12,-125,-125},
+    {  18,-117,-117},
+    {  24,-109,-109},
+    {  30,-101,-101},
+    {  36, -93, -93},
+    {  42, -85, -85},
+    {  48, -77, -77},
+    {  54, -69, -69},
+    {  60, -61, -61},
+    {  66, -53, -53},
+    {  72, -45, -45},
+    {  78, -37, -37},
+    {  84, -29, -29},
+    {  90, -21, -21},
+    {  95, -14, -14},
+    { 101,  -6,  -6},
+    { 107,   2,   2},
+    { 113,  10,  10},
+    { 119,  18,  18},
+    { 125,  26,  26},
+    { 131,  34,  34},
+    { 137,  42,  42},
+    { 143,  50,  50},
+    { 149,  58,  58},
+    { 155,  66,  66},
+    { 161,  74,  74},
+    { 167,  82,  82},
+    { 173,  90,  90},
+    { 179,  98,  98},
+    { 185, 106, 106},
+    { 191, 113, 113},
+    {  48, -53, -29},
+    {  54, -46, -22},
+    {  60, -38, -14},
+    {  66, -30,  -7},
+    {  72, -23,   0},
+    {  79, -15,   8},
+    {  85,  -8,  16},
+    {  91,  -1,  23},
+    {  96,   7,  31},
+    { 102,  15,  39},
+    { 108,  23,  47},
+    { 114,  30,  54},
+    { 120,  38,  62},
+    { 127,  46,  70},
+    { 133,  53,  77},
+    { 140,  62,  86},
+    {  48, -10,  38},
+    {  57,  -2,  42},
+    {  63,   2,  46},
+    {  69,   6,  50},
+    {  75,  14,  54},
+    {  84,  18,  58},
+    {  90,  26,  62},
+    {  95,  30,  66},
+    { 101,  34,  70},
+    { 110,  42,  74},
+    { 119,  46,  78},
+    { 128,  50,  82},
+    { 134,  58,  86},
+    { 143,  66,  90},
+    { 152,  70,  94},
+    { 158,  78,  98},
+    {   0,-121,-109},
+    {   0,-113, -97},
+    {   0,-105, -85},
+    {   0, -97, -73},
+    {   0, -93, -65},
+    {   0, -85, -53},
+    {   0, -77, -41},
+    {   0, -73, -33},
+    {   0, -65, -17},
+    {   6, -57, -10},
+    {  12, -49,  -2},
+    {  18, -41,   6},
+    {  24, -33,  14},
+    {  30, -25,  22},
+    {  36, -17,  30},
+    {  39, -14,  34},
+    {   0,-124,-106},
+    {   0,-106, -71},
+    {   0, -89, -37},
+    {   0, -71,  -4},
+    {   0, -54,  28},
+    {   0, -37,  59},
+    {   0, -20,  88},
+    {   0,  -4, 113},
+    {   9,   4, 113},
+    {  19,  12, 113},
+    {  29,  20, 113},
+    {  39,  28, 113},
+    {  48,  36, 113},
+    {  58,  44, 113},
+    {  68,  52, 113},
+    {  78,  59, 113},
+    {   0,-141,-125},
+    {   0,-141, -93},
+    {   0,-141, -61},
+    {   0,-141, -29},
+    {   0,-141,   2},
+    {   0,-141,  34},
+    {   0,-141,  66},
+    {   0,-141,  98},
+    {   0,-141, 113},
+    {  36, -93, 113},
+    {  60, -61, 113},
+    {  84, -29, 113},
+    { 107,   2, 113},
+    { 131,  34, 113},
+    { 155,  66, 113},
+    { 179,  98, 113},
+    {   0,-141,  -2},
+    {  15,-105,  26},
+    {  30, -73,  46},
+    {  45, -41,  66},
+    {  60, -10,  82},
+    {  75,  22,  94},
+    {  90,  46, 106},
+    { 104,  70, 113},
+    {   0,-141,-141},
+    {   0,-109,-109},
+    {   0, -77, -77},
+    {   0, -45, -45},
+    {   0, -14, -14},
+    {   0,  18,  18},
+    {   0,  50,  50},
+    {   0,  82,  82},
+    {   0, 113, 113},
+    {  12, 113, 113},
+    {  24, 113, 113},
+    {  36, 113, 113},
+    {  48, 113, 113},
+    {  60, 113, 113},
+    {  72, 113, 113},
+    {  84, 113, 113},
+    {  95, 113, 113},
+    { 107, 113, 113},
+    { 119, 113, 113},
+    { 131, 113, 113},
+    { 143, 113, 113},
+    { 155, 113, 113},
+    { 167, 113, 113},
+    { 179, 113, 113},
+    {   0, -69, -69},
+    {   9, -49, -49},
+    {  18, -29, -29},
+    {  27, -10, -10},
+    {  39,   6,   6},
+    {  48,  22,  22},
+    {  57,  34,  34},
+    {  66,  50,  50},
+    {  85,  67, 113},
+    {  91,  74, 113},
+    {  96,  81, 113},
+    { 102,  88, 113},
+    { 108,  95, 113},
+    { 114, 102, 113},
+    { 120, 108, 113},
+    { 127, 113, 113},
+    { 101,-141,  34},
+    { 106,-126,  38},
+    { 111,-110,  43},
+    { 117, -94,  48},
+    { 123, -78,  53},
+    { 129, -62,  58},
+    { 134, -46,  63},
+    { 140, -30,  68},
+    { 145, -14,  73},
+    { 151,   1,  78},
+    { 157,  17,  83},
+    { 162,  33,  88},
+    { 168,  49,  93},
+    { 173,  65,  98},
+    { 179,  81, 103},
+    { 185,  98, 109},
+    {  24,-141, -54},
+    {  42,-114, -34},
+    {  61, -86, -14},
+    {  79, -59,   6},
+    {  97, -32,  25},
+    { 115,  -6,  45},
+    { 135,  23,  65},
+    { 153,  50,  84},
+    { 191,-141, 113},
+    { 191,-109, 113},
+    { 191, -77, 113},
+    { 191, -45, 113},
+    { 191, -14, 113},
+    { 191,  18, 113},
+    { 191,  50, 113},
+    { 191,  82, 113},
+    {   0,   2,-141},
+    {   0, 113,-141},
+    {  24, 113,-109},
+    {  48, 113, -77},
+    {  72, 113, -45},
+    {  95, 113, -14},
+    { 119, 113,  18},
+    { 143, 113,  50},
+    {  16,-119,-129},
+    {  44, -82,-111},
+    {  73, -43, -92},
+    { 101,  -6, -73},
+    { 127,  29, -53},
+    { 142,  48, -17},
+    { 156,  67,  21},
+    { 170,  86,  61},
+    {  31,-127,-141},
+    {  48,-121,-141},
+    {  64,-113,-141},
+    {  79,-107,-141},
+    {  95,-100,-141},
+    { 111, -93,-141},
+    { 127, -86,-141},
+    { 143, -77,-141},
+    { 149, -43,-109},
+    { 155, -29, -77},
+    { 161,  -6, -45},
+    { 167,  18, -14},
+    { 191, -77, -77},
+    { 191, -14, -14},
+    { 191,  18,  18},
+    { 191,  50,  50},
+    {  18,-117,-141},
+    {  42, -84,-141},
+    {  61, -59,-141},
+    {  86, -26,-141},
+    { 104,  -2,-141},
+    { 129,  31,-141},
+    { 154,  64,-141},
+    { 172,  89,-141},
+    { 191, 113,-141},
+    { 191, 113,-117},
+    { 191, 113, -92},
+    { 191, 113, -67},
+    { 191, 113, -42},
+    { 191, 113, -18},
+    { 191, 113,   6},
+    { 191, 113,  31},
+    { 191, 113,  34},
+    { 191, 113,  50},
+    { 191, 113,  58},
+    { 191, 113,  74},
+    { 191, 113,  82},
+    { 191, 113,  98},
+    { 191, 113, 106},
+    { 191,-141,-141},
+    {  36, -14, -93},
+    {  54,   2, -69},
+    {  72,  18, -45},
+    {  90,  34, -21},
+    { 107,  50,   2},
+    { 125,  66,  26},
+    { 143,  82,  50},
+    { 161,  98,  74}
+};
+
+#endif

src/v_video.c

@@ -91,6 +91,7 @@ consvar_t cv_menucaps = {"menucaps", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NUL
 // local copy of the palette for V_GetColor()
 RGBA_t *pLocalPalette = NULL;
 RGBA_t *pGammaCorrectedPalette = NULL;
+static RGBA_t *pFallbackFlashPal = NULL;
 
 static size_t currentPaletteSize;
 
@@ -409,6 +410,58 @@ UINT32 V_GammaCorrect(UINT32 input, double power)
 	return result.rgba;
 }
 
+#include "v_paldeltas.h"
+// remaps a palette with given "deltas"
+// this is used with premade deltas between the srb2 palette and its both flashpals
+// so we may approximate generate our own, should the current palette miss them
+static void ApplyPaletteDelta(const RGBA_t *pal_in, RGBA_t *pal_out, const INT16 pal_delta[][3])
+{
+	size_t i;
+
+	for (i = 0; i < 256; i++)
+	{
+		INT16 r = (INT16)pal_in[i].s.red   + pal_delta[i][0];
+		INT16 g = (INT16)pal_in[i].s.green + pal_delta[i][1];
+		INT16 b = (INT16)pal_in[i].s.blue  + pal_delta[i][2];
+		pal_out[i].s.red   = (UINT8)CLAMP(r, 0 , 255);
+		pal_out[i].s.green = (UINT8)CLAMP(g, 0 , 255);
+		pal_out[i].s.blue  = (UINT8)CLAMP(b, 0 , 255);
+		pal_out[i].s.alpha = 0xFF; // pal_in[i].s.alpha
+	}
+}
+
+static void GenerateFlashPalettes(void)
+{
+	size_t i, palsize;
+	RGBA_t *pFlashPalGammaCorrectedPalette = NULL;
+
+	// generate flashpalettes if the current palette does not provide any subpalettes
+	if (currentPaletteSize >= (14 * (256 * 3))) // 14 palettes are in playpal
+		return;
+
+	palsize = (2*256);
+
+	pFallbackFlashPal = Z_Malloc(sizeof(*pFallbackFlashPal)*palsize, PU_STATIC, NULL);
+	pFlashPalGammaCorrectedPalette = Z_Malloc(sizeof (*pFlashPalGammaCorrectedPalette)*palsize, PU_STATIC, NULL);
+
+	// apply our deltas to the palettes to get the white and red "flashes"
+	ApplyPaletteDelta(pLocalPalette, pFallbackFlashPal, pPaletteDeltaFlash);
+	ApplyPaletteDelta(pLocalPalette, pFallbackFlashPal+256, pPaletteDeltaNuke);
+
+	// apply colour and gamma correction if needed
+	if (Cubeapply)
+	{
+		for (i = 0; i < palsize; i++)
+		{
+			pFlashPalGammaCorrectedPalette[i].rgba = V_GammaDecode(pFallbackFlashPal[i].rgba);
+			V_CubeApply(&pFlashPalGammaCorrectedPalette[i]);
+			pFallbackFlashPal[i].rgba = V_GammaEncode(pFlashPalGammaCorrectedPalette[i].rgba);
+		}
+	}
+
+	Z_Free(pFlashPalGammaCorrectedPalette);
+}
+
 // keep a copy of the palette so that we can get the RGB value for a color index at any time.
 static void LoadPalette(const char *lumpname)
 {
@@ -428,6 +481,8 @@ static void LoadPalette(const char *lumpname)
 
 	Z_Free(pLocalPalette);
 	Z_Free(pGammaCorrectedPalette);
+	Z_Free(pFallbackFlashPal);
+	pFallbackFlashPal = NULL;
 
 	pLocalPalette = Z_Malloc(sizeof (*pLocalPalette)*palsize, PU_STATIC, NULL);
 	pGammaCorrectedPalette = Z_Malloc(sizeof (*pGammaCorrectedPalette)*palsize, PU_STATIC, NULL);
@@ -447,12 +502,19 @@ static void LoadPalette(const char *lumpname)
 		pLocalPalette[i].s.alpha = 0xFF;
 
 		pGammaCorrectedPalette[i].rgba = V_GammaDecode(pLocalPalette[i].rgba);
+	}
 
-		if (!Cubeapply)
-			continue;
+	GenerateFlashPalettes();
 
-		V_CubeApply(&pGammaCorrectedPalette[i]);
-		pLocalPalette[i].rgba = V_GammaEncode(pGammaCorrectedPalette[i].rgba);
+	// gotta apply any colour and gamma adjustments afterwards
+	// so we dont double apply it to the generated flashpals
+	if (Cubeapply)
+	{
+		for (i = 0; i < palsize; i++)
+		{
+			V_CubeApply(&pGammaCorrectedPalette[i]);
+			pLocalPalette[i].rgba = V_GammaEncode(pGammaCorrectedPalette[i].rgba);
+		}
 	}
 }
 
@@ -543,6 +605,7 @@ void V_ReloadPalette(void)
 // -------------+
 void V_SetPalette(INT32 palettenum)
 {
+	RGBA_t *pal = NULL;
 	if (!pLocalPalette)
 		V_ReloadPalette();
 
@@ -554,24 +617,47 @@ void V_SetPalette(INT32 palettenum)
 		if (palettenum == 0)
 		{
 			palettenum = cv_palettenum.value;
-
-			if (palettenum * 256U > currentPaletteSize - 256)
-			{
-				CONS_Alert(CONS_WARNING, "cv_palettenum %d out of range\n", palettenum);
-				palettenum = 0;
-			}
 		}
 	}
 
+	// in many cases custom palettes do not provide the needed subpalettes for flashpals to work
+	// before this would mean the renderer gets passed random data out of allocated memory bounds
+	// which was not very cool :chonkbuncle:
+	// gladly 2.1 only actually has 2 different subpalettes
+	// one for "white flash" and one red/pinkish one for nuke
+	// since we checked the palette earlier we should have generated those ourselves
+	if (((size_t)palettenum >= currentPaletteSize / (256 * 3)))
+	{
+		CONS_Debug(DBG_RENDER, "palettenum %d out of range\n", palettenum);
+
+		// if for some reason we did not generate flashpals
+		// just fall back to the main palette i guess?
+		if (pFallbackFlashPal != NULL)
+		{
+			if (palettenum == PAL_NUKE)
+				pal = &pFallbackFlashPal[256];
+			else
+				pal = pFallbackFlashPal;
+		}
+		else
+		{
+			pal = pLocalPalette;
+		}
+	}
+	else
+	{
+		pal = &pLocalPalette[palettenum*256];
+	}
+
 #ifdef HWRENDER
 	if (rendermode == render_opengl)
-		HWR_SetPalette(&pLocalPalette[palettenum*256]);
+		HWR_SetPalette(pal);
 #if defined (__unix__) || defined (UNIXCOMMON) || defined (HAVE_SDL)
 	else
 #endif
 #endif
 	if (rendermode != render_none)
-		I_SetPalette(&pLocalPalette[palettenum*256]);
+		I_SetPalette(pal);
 }
 
 void V_SetPaletteLump(const char *pal)
@@ -3309,167 +3395,6 @@ INT32 V_SubStringLengthToFit(const char *string, INT32 width, INT32 option)
 	return max(i-1, 0);
 }
 
-char V_GetSkincolorChar(INT32 color)
-{
-	char cstart = 0x80;
-
-	switch (color)
-	{
-		case SKINCOLOR_WHITE:
-		case SKINCOLOR_SILVER:
-		case SKINCOLOR_SLATE:
-			cstart = 0x80; // White
-			break;
-
-		case SKINCOLOR_GREY:
-		case SKINCOLOR_NICKEL:
-		case SKINCOLOR_BLACK:
-		case SKINCOLOR_SKUNK:
-		case SKINCOLOR_JET:
-			cstart = 0x86; // V_GRAYMAP
-			break;
-
-		case SKINCOLOR_SEPIA:
-		case SKINCOLOR_BEIGE:
-		case SKINCOLOR_WALNUT:
-		case SKINCOLOR_BROWN:
-		case SKINCOLOR_LEATHER:
-		case SKINCOLOR_RUST:
-		case SKINCOLOR_WRISTWATCH:
-			cstart = 0x8e; // V_BROWNMAP
-			break;
-
-		case SKINCOLOR_FAIRY:
-		case SKINCOLOR_SALMON:
-		case SKINCOLOR_PINK:
-		case SKINCOLOR_ROSE:
-		case SKINCOLOR_BRICK:
-		case SKINCOLOR_LEMONADE:
-		case SKINCOLOR_BUBBLEGUM:
-		case SKINCOLOR_LILAC:
-			cstart = 0x8d; // V_PINKMAP
-			break;
-
-		case SKINCOLOR_CINNAMON:
-		case SKINCOLOR_RUBY:
-		case SKINCOLOR_RASPBERRY:
-		case SKINCOLOR_CHERRY:
-		case SKINCOLOR_RED:
-		case SKINCOLOR_CRIMSON:
-		case SKINCOLOR_MAROON:
-		case SKINCOLOR_FLAME:
-		case SKINCOLOR_SCARLET:
-		case SKINCOLOR_KETCHUP:
-			cstart = 0x85; // V_REDMAP
-			break;
-
-		case SKINCOLOR_DAWN:
-		case SKINCOLOR_SUNSET:
-		case SKINCOLOR_CREAMSICLE:
-		case SKINCOLOR_ORANGE:
-		case SKINCOLOR_PUMPKIN:
-		case SKINCOLOR_ROSEWOOD:
-		case SKINCOLOR_BURGUNDY:
-		case SKINCOLOR_TANGERINE:
-			cstart = 0x87; // V_ORANGEMAP
-			break;
-
-		case SKINCOLOR_PEACH:
-		case SKINCOLOR_CARAMEL:
-		case SKINCOLOR_CREAM:
-			cstart = 0x8f; // V_PEACHMAP
-			break;
-
-		case SKINCOLOR_GOLD:
-		case SKINCOLOR_ROYAL:
-		case SKINCOLOR_BRONZE:
-		case SKINCOLOR_COPPER:
-		case SKINCOLOR_THUNDER:
-			cstart = 0x8a; // V_GOLDMAP
-			break;
-
-		case SKINCOLOR_POPCORN:
-		case SKINCOLOR_QUARRY:
-		case SKINCOLOR_YELLOW:
-		case SKINCOLOR_MUSTARD:
-		case SKINCOLOR_CROCODILE:
-		case SKINCOLOR_OLIVE:
-			cstart = 0x82; // V_YELLOWMAP
-			break;
-
-		case SKINCOLOR_ARTICHOKE:
-		case SKINCOLOR_VOMIT:
-		case SKINCOLOR_GARDEN:
-		case SKINCOLOR_TEA:
-		case SKINCOLOR_PISTACHIO:
-			cstart = 0x8b; // V_TEAMAP
-			break;
-
-		case SKINCOLOR_LIME:
-		case SKINCOLOR_HANDHELD:
-		case SKINCOLOR_MOSS:
-		case SKINCOLOR_CAMOUFLAGE:
-		case SKINCOLOR_ROBOHOOD:
-		case SKINCOLOR_MINT:
-		case SKINCOLOR_GREEN:
-		case SKINCOLOR_PINETREE:
-		case SKINCOLOR_EMERALD:
-		case SKINCOLOR_SWAMP:
-		case SKINCOLOR_DREAM:
-		case SKINCOLOR_PLAGUE:
-		case SKINCOLOR_ALGAE:
-			cstart = 0x83; // V_GREENMAP
-			break;
-
-		case SKINCOLOR_CARIBBEAN:
-		case SKINCOLOR_AZURE:
-		case SKINCOLOR_AQUA:
-		case SKINCOLOR_TEAL:
-		case SKINCOLOR_CYAN:
-		case SKINCOLOR_JAWZ:
-		case SKINCOLOR_CERULEAN:
-		case SKINCOLOR_NAVY:
-		case SKINCOLOR_SAPPHIRE:
-			cstart = 0x88; // V_SKYMAP
-			break;
-
-		case SKINCOLOR_PIGEON:
-		case SKINCOLOR_PLATINUM:
-		case SKINCOLOR_STEEL:
-			cstart = 0x8c; // V_STEELMAP
-			break;
-
-		case SKINCOLOR_PERIWINKLE:
-		case SKINCOLOR_BLUE:
-		case SKINCOLOR_BLUEBERRY:
-		case SKINCOLOR_NOVA:
-			cstart = 0x84; // V_BLUEMAP
-			break;
-
-		case SKINCOLOR_ULTRAVIOLET:
-		case SKINCOLOR_PURPLE:
-		case SKINCOLOR_FUCHSIA:
-			cstart = 0x81; // V_PURPLEMAP
-			break;
-
-		case SKINCOLOR_PASTEL:
-		case SKINCOLOR_MOONSLAM:
-		case SKINCOLOR_DUSK:
-		case SKINCOLOR_TOXIC:
-		case SKINCOLOR_MAUVE:
-		case SKINCOLOR_LAVENDER:
-		case SKINCOLOR_BYZANTIUM:
-		case SKINCOLOR_POMEGRANATE:
-			cstart = 0x89; // V_LAVENDERMAP
-			break;
-
-		default:
-			break;
-	}
-
-	return cstart;
-}
-
 INT32 V_SkinColorToHighlightcolor(skincolors_t color)
 {
 	switch (color)

src/v_video.h

@@ -287,8 +287,6 @@ INT32 V_ThinSubStringWidth(const char *string, INT32 length, INT32 option);
 // Find maximum length for substring taken from current string to fit into given width
 INT32 V_SubStringLengthToFit(const char *string, INT32 width, INT32 option);
 
-char V_GetSkincolorChar(INT32 color);
-
 INT32 V_SkinColorToHighlightcolor(skincolors_t color);
 
 // this is pretty dumb, but has to be done like this, otherwise the fps counter just disappears sometimes for no reason lol

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");
@@ -339,7 +365,7 @@ static inline INT32 W_MakeFileMD5(const char *filename, void *resblock)
 
 	if ((fhandle = fopen(filename, "rb")) != NULL)
 	{
-		tic_t t = I_GetTime();
+		precise_t t = I_GetPreciseTime();
 
 		CONS_Debug(DBG_SETUP, "Making MD5 for %s\n",filename);
 
@@ -350,7 +376,7 @@ static inline INT32 W_MakeFileMD5(const char *filename, void *resblock)
 		}
 
 		CONS_Debug(DBG_SETUP, "MD5 calc for %s took %f seconds\n",
-			filename, (float)(I_GetTime() - t)/NEWTICRATE);
+			filename, (float)(I_GetPreciseTime() - t)/I_GetPrecisePrecision());
 
 		fclose(fhandle);
 		return 0;
@@ -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,8 +721,9 @@ 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));
-		strlcpy(fullname, (char*)(zentry + 1), SHORT(zentry->namelen) + 1);
+		fullname = (char *)(malloc(SHORT(zentry->namelen) + 1));
+		strncpy(fullname, (char *)(zentry + 1), SHORT(zentry->namelen));
+		fullname[zentry->namelen] = 0;
 
 		// Strip away file address and extension for the 8char name.
 		if ((trimname = strrchr(fullname, '/')) != NULL)
@@ -712,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))
 		{
@@ -895,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);
@@ -930,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.
@@ -1030,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
@@ -1053,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));
 }
 
 //
@@ -1107,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;
@@ -1139,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;
 }
 
@@ -1184,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;
 }
 
@@ -1206,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;
 		}
@@ -1222,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);
 }
 
 //
@@ -1292,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
@@ -1313,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;
 	}
@@ -1325,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;
@@ -1334,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
@@ -1355,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
@@ -1384,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;
 
@@ -1394,7 +1388,7 @@ lumpnum_t W_GetNumForLongName(const char *name)
 		I_Error("W_GetNumForLongName: %s not found!\n", name);
 
 	return i;
-}
+}*/
 
 //
 // W_CheckNumForNameInBlock
@@ -1411,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;
 }
 
@@ -1596,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
@@ -1615,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);
@@ -1643,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
@@ -1663,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);
@@ -1700,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;
 		}
@@ -1888,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);
 	}
@@ -1910,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;
@@ -1921,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)
@@ -1939,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
 
@@ -1962,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);
@@ -1997,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);
@@ -2006,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);
 
@@ -2199,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;
 
@@ -2213,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)))
 	{
@@ -2224,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;
@@ -2236,8 +2250,9 @@ static int W_VerifyPK3(FILE *fp, lumpchecklist_t *checklist, boolean status)
 
 		if (verified == true)
 		{
-			fullname = (char*)(malloc(SHORT(zentry->namelen) + 1));
-			strlcpy(fullname, (char*)(zentry + 1), SHORT(zentry->namelen) + 1);
+			fullname = (char *)(malloc(SHORT(zentry->namelen) + 1));
+			strncpy(fullname, (char *)(zentry + 1), SHORT(zentry->namelen));
+			fullname[zentry->namelen] = 0;
 
 			// Strip away file address and extension for the 8char name.
 			if ((trimname = strrchr(fullname, '/')) != NULL)
@@ -2446,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;
 
@@ -2460,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)))
 	{
@@ -2471,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;
@@ -2481,8 +2496,9 @@ static int W_CheckPK3Contains(FILE *fp, lumpchecklist_t *checklist)
 			return false;
 		}
 
-		fullname = (char*)(malloc(SHORT(zentry->namelen) + 1));
-		strlcpy(fullname, (char*)(zentry + 1), SHORT(zentry->namelen) + 1);
+		fullname = (char *)(malloc(SHORT(zentry->namelen) + 1));
+		strncpy(fullname, (char *)(zentry + 1), SHORT(zentry->namelen));
+		fullname[zentry->namelen] = 0;
 
 		// Strip away file address and extension for the 8char name.
 		if ((trimname = strrchr(fullname, '/')) != NULL)
@@ -2573,6 +2589,18 @@ static int W_CheckFileContains(const char *filename, lumpchecklist_t *checklist)
 	return contains;
 }
 
+int W_CheckAutoLoadContainsMap(const char *filename)
+{
+	// for now this checks for map marker
+	static lumpchecklist_t autoloadblacklist[] =
+	{
+		{"MAP", 3},
+		{NULL,  0},
+	};
+
+	return W_CheckFileContains(filename, autoloadblacklist);
+}
+
 int W_CheckPostLoadList(const char *filename)
 {
 	static lumpchecklist_t postloadlist[] =
@@ -2585,7 +2613,6 @@ int W_CheckPostLoadList(const char *filename)
 		{"SOC_", 		4},
 		{"MAINCFG",		7},
 		{"OBJCTCFG", 	8},
-		{"MAP",			3},
 
 		{NULL, 0},
 	};
@@ -2618,14 +2645,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++)
 		{
@@ -2637,7 +2664,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");
 
@@ -2646,11 +2673,12 @@ virtres_t* vres_GetMap(lumpnum_t lumpnum)
 		{
 			if (vsizecache[realentry] == 0)
 				continue;
+
 			vlumps[i].size = vsizecache[realentry];
 
 			const char *name = (fileinfo + realentry)->name;
 
-			if (strlen(name) == 5 && memcmp(name, "MAP", 3) == 0)
+			if (strnlen(name, 8) == 5 && memcmp(name, "MAP", 3) == 0)
 			{
 				numlumps--; // We skip map marker, so 1 of entries becomes empty
 				continue; // This will skip i++ so we will write to same entry
@@ -2659,7 +2687,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);
@@ -2686,7 +2714,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");
 
@@ -2707,11 +2735,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
 
@@ -243,6 +241,7 @@ void W_VerifyFileMD5(UINT16 wadfilenum, const char *matchmd5);
 
 int W_VerifyNMUSlumps(const char *filename, FILE *handle, boolean exit_on_error);
 
+int W_CheckAutoLoadContainsMap(const char *filename);
 int W_CheckPostLoadList(const char *filename);
 
 #ifdef __cplusplus

src/z_zone.cpp

@@ -523,11 +523,19 @@ void Z_CheckHeap(INT32 tag)
 #ifdef VALGRIND_MEMPOOL_EXISTS
 		if (!VALGRIND_MEMPOOL_EXISTS(block))
 		{
-			I_Error("Z_CheckHeap %d: block %u"
+			I_Error("Z_CheckHeap :"
+#ifdef ZDEBUG
+				" %s %d"
+#endif
+				" block %u"
 #ifdef ZDEBUG
 				" (owned by %s:%d)"
 #endif
-				" should not exist", i, blocknumon
+				" should not exist"
+#ifdef ZDEBUG
+				, file, line
+#endif
+				, blocknumon
 #ifdef ZDEBUG
 				, block->ownerfile, block->ownerline
 #endif