Merge branch 'Saturn-Next' into netstuff

lmao oops idk dumb copy paste sry

src/blua/lapi.c

@@ -434,7 +434,7 @@ LUA_API void lua_pushnumber (lua_State *L, lua_Number n) {
 LUA_API void lua_pushlstring (lua_State *L, const char *s, size_t len) {
   lua_lock(L);
   luaC_checkGC(L);
-  setsvalue2s(L, L->top, (len == 0) ? luaS_new(L, "") : luaS_newlstr(L, s, len));
+  setsvalue2s(L, L->top, (len == 0) ? luaS_newlstr(L, "", 0) : luaS_newlstr(L, s, len));
   api_incr_top(L);
   lua_unlock(L);
 }
@@ -519,23 +519,6 @@ LUA_API int lua_pushthread (lua_State *L) {
 ** get functions (Lua -> stack)
 */
 
-static void auxgetstr (lua_State *L, const TValue *t, const char *k) {
-  const TValue *slot;
-  TValue key;
-  TString *str = luaS_new(L, k);
-  api_checkvalidindex(L, t);
-  if (luaV_fastget(L, t, str, slot, luaH_getstr)) {
-    setobj2s(L, L->top, slot);
-    api_incr_top(L);
-  }
-  else {
-    setsvalue(L, &key, str);
-    luaV_finishget(L, t, L->top, L->top, slot);
-    api_incr_top(L);
-  }
-  lua_unlock(L);
-}
-
 
 LUA_API void lua_gettable (lua_State *L, int idx) {
   StkId t;
@@ -548,8 +531,15 @@ LUA_API void lua_gettable (lua_State *L, int idx) {
 
 
 LUA_API void lua_getfield (lua_State *L, int idx, const char *k) {
+  StkId t;
+  TValue key;
   lua_lock(L);
-  auxgetstr(L, index2adr(L, idx), k);
+  t = index2adr(L, idx);
+  api_checkvalidindex(L, t);
+  setsvalue(L, &key, luaS_new(L, k));
+  luaV_gettable(L, t, &key, L->top);
+  api_incr_top(L);
+  lua_unlock(L);
 }
 
 
@@ -640,26 +630,6 @@ LUA_API void lua_getfenv (lua_State *L, int idx) {
 ** set functions (stack -> Lua)
 */
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wcast-qual"
-static void auxsetstr (lua_State *L, const TValue *t, const char *k) {
-  TValue key;
-  const TValue *slot;
-  TString *str = luaS_new(L, k);
-  api_checknelems(L, 1);
-  api_checkvalidindex(L, t);
-  if (luaV_fastset(L, t, str, slot, luaH_setstr, L->top)) {
-    setobj2t(L, cast(TValue *, slot), L->top - 1);
-    L->top--;  /* pop value */
-  }
-  else {
-    setsvalue2s(L, &key, str);
-    luaV_finishset(L, t, &key, L->top - 1, slot);
-    L->top--;  /* pop value */
-  }
-  lua_unlock(L);
-}
-
 
 LUA_API void lua_settable (lua_State *L, int idx) {
   StkId t;
@@ -672,12 +642,18 @@ LUA_API void lua_settable (lua_State *L, int idx) {
   lua_unlock(L);
 }
 
-#pragma GCC diagnostic pop
-
 
 LUA_API void lua_setfield (lua_State *L, int idx, const char *k) {
+  StkId t;
+  TValue key;
   lua_lock(L);
-  auxsetstr(L, index2adr(L, idx), k);
+  api_checknelems(L, 1);
+  t = index2adr(L, idx);
+  api_checkvalidindex(L, t);
+  setsvalue(L, &key, luaS_new(L, k));
+  luaV_settable(L, t, &key, L->top - 1);
+  L->top--;  /* pop value */
+  lua_unlock(L);
 }
 
 

src/blua/lauxlib.c

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

src/blua/lcode.c

@@ -626,20 +626,8 @@ static void codenot (FuncState *fs, expdesc *e) {
   removevalues(fs, e->t);
 }
 
-/*
-** Check whether expression 'e' is a literal string
-*/
-static int isKstr (FuncState *fs, expdesc *e) {
-  return (e->k == VK && ttisstring(&fs->f->k[e->u.s.info]));
-}
 
-/*
-** Create expression 't[k]'. 't' must have its final result already in a
-** register or upvalue. Upvalues can only be indexed by literal strings.
-*/
 void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k) {
-  if (t->k == VUPVAL && !isKstr(fs, k))  /* upvalue indexed by non string? */
-    luaK_exp2anyreg(fs, t);  /* put it in a register */
   t->u.s.aux = luaK_exp2RK(fs, k);
   t->k = VINDEXED;
 }
@@ -802,19 +790,18 @@ 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: 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;
-    }
+    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;
     default: lua_assert(0);
   }
 }

src/blua/lcode.h

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

src/blua/ldebug.c

@@ -542,39 +542,16 @@ 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)];
-  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";
+  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 */
 }
 
 

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 (n <= L->stacksize)  /* double size is enough? */
+  if (l_likely(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_unlikely(L->hookmask & LUA_MASKCALL))
+    if (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,21 +356,20 @@ static int read_line (lua_State *L, FILE *f) {
 
 
 static int read_chars (lua_State *L, FILE *f, size_t n) {
-  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 */
+  size_t rlen;  /* how much to read */
+  size_t nr;  /* number of chars actually read */
   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 > tbr) rlen = tbr;  /* cannot read more than asked */
+    if (rlen > n) rlen = n;  /* cannot read more than asked */
     nr = fread(p, sizeof(char), rlen, f);
     luaL_addsize(&b, nr);
-    tbr -= nr;  /* still have to read 'tbr' chars */
-  } while (tbr > 0 && nr == rlen);  /* until end of count or eof */
+    n -= nr;  /* still have to read `n' chars */
+  } while (n > 0 && nr == rlen);  /* until end of count or eof */
   luaL_pushresult(&b);  /* close buffer */
-  return (tbr == 0 || tbr < n);  /* true iff read something */
+  return (n == 0 || lua_objlen(L, -1) > 0);
 }
 
 
@@ -433,13 +432,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 success;
+  int sucess;
   if (f == NULL)  /* file is already closed? */
     luaL_error(L, "file is already closed");
-  success = read_line(L, f);
+  sucess = read_line(L, f);
   if (ferror(f))
     return luaL_error(L, "%s", strerror(errno));
-  if (success) return 1;
+  if (sucess) return 1;
   else {  /* EOF */
     if (lua_toboolean(L, lua_upvalueindex(2))) {  /* generator created file? */
       lua_settop(L, 0);

src/blua/lopcodes.h

@@ -232,8 +232,6 @@ OP_VARARG/*	A B	R(A), R(A+1), ..., R(A+B-1) = vararg		*/
   (*) In OP_SETLIST, if (B == 0) then B = `top';
       if (C == 0) then next `instruction' is real C
 
-  (*) In OP_SELF, the index must be a string.
-
   (*) For comparisons, A specifies what condition the test should accept
       (true or false).
 

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},                 /* ^, .. (right associative) */
-   {3, 3}, {3, 3}, {3, 3},          /* ==, <, <= */
-   {3, 3}, {3, 3}, {3, 3},          /* ~=, >, >= */
-   {2, 2}, {1, 1}                   /* and, or */
+   {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) */
    ,{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_unlikely(l+1 > (MAX_SIZET - sizeof(TString))/sizeof(char)))
+  if (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,72 +72,18 @@ static TString *newlstr (lua_State *L, const char *str, size_t l,
 }
 
 
-// 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
+TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
+  GCObject *o;
   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 (ts->tsv.hash == h &&
-        ts->tsv.len == l &&
-       (memcmp(str, getstr(ts), l) == 0)) {
+    if (l_unlikely(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/ltm.c

@@ -61,7 +61,7 @@ TValue *luaT_gettm (Table *events, TMS event, TString *ename) {
 }
 
 
-TValue *luaT_gettmbyobj (lua_State *L, const TValue *o, TMS event) {
+TValue *luaT_gettmbyobj (lua_State *L, TValue *o, TMS event) {
   Table *mt;
   switch (ttype(o)) {
     case LUA_TTABLE:

src/blua/ltm.h

@@ -55,7 +55,7 @@ LUAI_DATA const char *const luaT_typenames[];
 
 
 LUAI_FUNC TValue *luaT_gettm (Table *events, TMS event, TString *ename);
-LUAI_FUNC TValue *luaT_gettmbyobj (lua_State *L, const TValue *o, TMS event);
+LUAI_FUNC TValue *luaT_gettmbyobj (lua_State *L, TValue *o, TMS event);
 LUAI_FUNC void luaT_init (lua_State *L);
 
 #endif

src/blua/lvm.c

@@ -28,7 +28,7 @@
 
 
 
-/* limit for table tag-method chains (to avoid infinite loops) */
+/* limit for table tag-method chains (to avoid loops) */
 #define MAXTAGLOOP	100
 
 
@@ -105,94 +105,61 @@ static void callTM (lua_State *L, const TValue *f, const TValue *p1,
 }
 
 
-/*
-** Finish the table access 'val = t[key]'.
-** if 'slot' is NULL, 't' is not a table; otherwise, 'slot' points to
-** t[k] entry (which must be nil).
-*/
-void luaV_finishget (lua_State *L, const TValue *t, TValue *key, StkId val,
-                      const TValue *slot) {
-  int loop;  /* counter to avoid infinite loops */
-  const TValue *tm;  /* metamethod */
+void luaV_gettable (lua_State *L, TValue *t, TValue *key, StkId val) {
+  int loop;
   for (loop = 0; loop < MAXTAGLOOP; loop++) {
-    if (slot == NULL) {  /* 't' is not a table? */
-      lua_assert(!ttistable(t));
-      tm = luaT_gettmbyobj(L, t, TM_INDEX);
-      if (l_unlikely(ttisnil(tm)))
-        luaG_typeerror(L, t, "index");  /* no metamethod */
-      /* else will try the metamethod */
-    }
-    else {  /* 't' is a table */
-      lua_assert(ttisnil(slot));
-      tm = fasttm(L, hvalue(t)->metatable, TM_INDEX);  /* table's metamethod */
-      if (tm == NULL) {  /* no metamethod? */
-        setnilvalue(val);  /* result is nil */
+    TValue *tm;
+    if (ttistable(t)) {  /* `t' is a table? */
+      Table *h = hvalue(t);
+      const TValue *res = luaH_get(h, key); /* do a primitive get */
+      if (!ttisnil(res) ||  /* result is no nil? */
+          (tm = fasttm(L, h->metatable, TM_INDEX)) == NULL) { /* or no TM? */
+        setobj2s(L, val, res);
         return;
       }
-      /* else will try the metamethod */
+      /* else will try the tag method */
     }
-    if (ttisfunction(tm)) {  /* is metamethod a function? */
-      callTMres(L, val, tm, t, key);  /* call it */
+    else if (l_unlikely(ttisnil(tm = luaT_gettmbyobj(L, t, TM_INDEX))))
+      luaG_typeerror(L, t, "index");
+    if (ttisfunction(tm)) {
+      callTMres(L, val, tm, t, key);
       return;
     }
-    t = tm;  /* else try to access 'tm[key]' */
-    if (luaV_fastget(L,t,key,slot,luaH_get)) {  /* fast track? */
-      setobj2s(L, val, slot);  /* done */
-      return;
-    }
-    /* else repeat (tail call 'luaV_finishget') */
+    t = tm;  /* else repeat with `tm' */
   }
-  luaG_runerror(L, "'__index' chain too long; possible loop");
+  luaG_runerror(L, "loop in gettable");
 }
 
-/*
-** Finish a table assignment 't[key] = val'.
-** If 'slot' is NULL, 't' is not a table.  Otherwise, 'slot' points
-** to the entry 't[key]', or to 'luaO_nilobject' if there is no such
-** entry.  (The value at 'slot' must be nil, otherwise 'luaV_fastset'
-** would have done the job.)
-*/
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wcast-qual"
-void luaV_finishset (lua_State *L, const TValue *t, TValue *key,
-                     StkId val, const TValue *slot) {
-  int loop;  /* counter to avoid infinite loops */
+
+void luaV_settable (lua_State *L, TValue *t, TValue *key, StkId val) {
+  int loop;
   for (loop = 0; loop < MAXTAGLOOP; loop++) {
-    const TValue *tm;
-    if (slot != NULL) {
-      lua_assert(ttistable(t) && ttisnil(slot));
+    TValue *tm = NULL;
+    if (ttistable(t)) {  /* `t' is a table? */
       Table *h = hvalue(t);
-      /* must check the metamethod */
-      /* slot is nil=> look for newindex, slot is not nil => look for usedindex */
-      if (!((ttisnil(slot) && ((tm = fasttm(L, h->metatable, TM_NEWINDEX)) != NULL)) ||
-         ((!ttisnil(slot)) && ((tm = fasttm(L, h->metatable, TM_USEDINDEX)) != NULL)))) {
-        /* no metamethod and (now) there is an entry with given key */
-        setobj2t(L, cast(TValue *, slot), val);
+      TValue *oldval = luaH_set(L, h, key); /* do a primitive set */
+      /* oldval is nil=> look for newindex, oldval is not nil => look for usedindex */
+      if (!((ttisnil(oldval) && ((tm = fasttm(L, h->metatable, TM_NEWINDEX)) != NULL)) ||
+         ((!ttisnil(oldval)) && ((tm = fasttm(L, h->metatable, TM_USEDINDEX)) != NULL)))) {
+        setobj2t(L, oldval, val);
         luaC_barriert(L, h, val);
         return;
       }
-      /* else will try the metamethod */
+      /* else will try the tag method */
     }
-    else {  /* not a table; check metamethod */
-      if (l_unlikely(ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX))))
-        luaG_typeerror(L, t, "index");
-    }
-    /* try the metamethod */
+    else if (l_unlikely(ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX))))
+      luaG_typeerror(L, t, "index");
     if (ttisfunction(tm)) {
       callTM(L, tm, t, key, val);
       return;
     }
-    t = tm;  /* else repeat assignment over 'tm' */
-    if (luaV_fastset(L, t, key, slot, luaH_set, val))
-      return;  /* done */
-    /* else loop */
+    t = tm;  /* else repeat with `tm' */
   }
-  luaG_runerror(L, "settable chain too long; possible loop");
+  luaG_runerror(L, "loop in settable");
 }
-#pragma GCC diagnostic pop
 
 
-static int call_binTM (lua_State *L, const TValue *p1, const TValue *p2,
+static int call_binTM (lua_State *L, TValue *p1, TValue *p2,
                        StkId res, TMS event) {
   const TValue *tm = luaT_gettmbyobj(L, p1, event);  /* try first operand */
   if (ttisnil(tm))
@@ -217,7 +184,7 @@ static const TValue *get_compTM (lua_State *L, Table *mt1, Table *mt2,
 }
 
 
-static int call_orderTM (lua_State *L, const TValue *p1, const TValue *p2,
+static int call_orderTM (lua_State *L, TValue *p1, TValue *p2,
                          TMS event) {
   const TValue *tm1 = luaT_gettmbyobj(L, p1, event);
   const TValue *tm2;
@@ -399,7 +366,6 @@ 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)) { \
@@ -411,24 +377,6 @@ static void Arith (lua_State *L, StkId ra, TValue *rb,
       }
 
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wcast-qual"
-
-/*
-** copy of 'luaV_gettable', but protecting call to potential metamethod
-** (which can reallocate the stack)
-*/
-#define gettableProtected(L,t,k,v)  { const TValue *slot; \
-  if (luaV_fastget(L,t,k,slot,luaH_get)) { setobj2s(L, v, slot); } \
-  else Protect(luaV_finishget(L,t,k,v,slot)); }
-
-
-/* same for 'luaV_settable' */
-#define settableProtected(L,t,k,v) { const TValue *slot; \
-  if (!luaV_fastset(L,t,k,slot,luaH_set,v)) \
-    Protect(luaV_finishset(L,t,k,v,slot)); }
-
-
 
 void luaV_execute (lua_State *L, int nexeccalls) {
   LClosure *cl;
@@ -438,12 +386,13 @@ void luaV_execute (lua_State *L, int nexeccalls) {
  reentry:  /* entry point */
   lua_assert(isLua(L->ci));
   pc = L->savedpc;
-  cl = &clvalue(L->ci->func)->l;  /* local reference to function's closure */
-  k = cl->p->k;  /* local reference to function's constant table */
-  base = L->base;  /* local copy of function's base */
+  cl = &clvalue(L->ci->func)->l;
+  base = L->base;
+  k = cl->p->k;
   /* 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);
@@ -453,28 +402,26 @@ 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--);
@@ -482,13 +429,11 @@ 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);
@@ -497,14 +442,10 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_GETTABLE: {
-        StkId ra = RA(i);
-        StkId rb = RB(i);
-        TValue *rc = RKC(i);
-        gettableProtected(L, rb, rc, ra);
+        Protect(luaV_gettable(L, RB(i), RKC(i), ra));
         continue;
       }
       case OP_SETGLOBAL: {
-        StkId ra = RA(i);
         TValue g;
         sethvalue(L, &g, cl->env);
         lua_assert(ttisstring(KBx(i)));
@@ -512,21 +453,16 @@ 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: {
-        StkId ra = RA(i);
-        TValue *rb = RKB(i);
-        TValue *rc = RKC(i);
-        settableProtected(L, ra, rb, rc);
+        Protect(luaV_settable(L, ra, RKB(i), RKC(i)));
         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)));
@@ -534,16 +470,9 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_SELF: {
-        StkId ra = RA(i);
-        const TValue *slot;
         StkId rb = RB(i);
-        TValue *rc = RKC(i);
-        TString *key = rawtsvalue(rc);  /* key must be a string */
-        setobjs2s(L, ra + 1, rb);
-        if (luaV_fastget(L, rb, key, slot, luaH_getstr)) {
-          setobj2s(L, ra, slot);
-        }
-        else Protect(luaV_finishget(L, rb, rc, ra, slot));
+        setobjs2s(L, ra+1, rb);
+        Protect(luaV_gettable(L, rb, RKC(i), ra));
         continue;
       }
       case OP_ADD: {
@@ -559,7 +488,6 @@ 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)) {
@@ -575,7 +503,6 @@ 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)) {
@@ -595,27 +522,26 @@ 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);
@@ -627,7 +553,6 @@ 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);
@@ -639,13 +564,11 @@ 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: {
@@ -703,14 +626,12 @@ 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);
@@ -720,7 +641,6 @@ 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 */
@@ -742,7 +662,6 @@ 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;
@@ -775,7 +694,6 @@ 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);
@@ -791,7 +709,6 @@ 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);
@@ -804,7 +721,6 @@ 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;
@@ -821,7 +737,6 @@ 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);
@@ -838,7 +753,6 @@ 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;
@@ -861,12 +775,10 @@ 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;
@@ -887,7 +799,6 @@ 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;
@@ -911,5 +822,3 @@ void luaV_execute (lua_State *L, int nexeccalls) {
     }
   }
 }
-
-#pragma GCC diagnostic pop

src/blua/lvm.h

@@ -22,61 +22,14 @@
 	(ttype(o1) == ttype(o2) && luaV_equalval(L, o1, o2))
 
 
-/*
-** fast track for 'gettable': if 't' is a table and 't[k]' is not nil,
-** return 1 with 'slot' pointing to 't[k]' (final result).  Otherwise,
-** return 0 (meaning it will have to check metamethod) with 'slot'
-** pointing to a nil 't[k]' (if 't' is a table) or NULL (otherwise).
-** 'f' is the raw get function to use.
-*/
-#define luaV_fastget(L,t,k,slot,f) \
-  (!ttistable(t)  \
-   ? (slot = NULL, 0)  /* not a table; 'slot' is NULL and result is 0 */  \
-   : (slot = f(hvalue(t), k),  /* else, do raw access */  \
-      !ttisnil(slot)))  /* result not nil? */
-
-/*
-** standard implementation for 'gettable'
-*/
-#define luaV_gettable(L,t,k,v) { const TValue *slot; \
-  if (luaV_fastget(L,t,k,slot,luaH_get)) { setobj2s(L, v, slot); } \
-  else luaV_finishget(L,t,k,v,slot); }
-
-
-/*
-** Fast track for set table. If 't' is a table and 't[k]' is not nil,
-** call GC barrier, do a raw 't[k]=v', and return true; otherwise,
-** return false with 'slot' equal to NULL (if 't' is not a table) or
-** 'nil'. (This is needed by 'luaV_finishget'.) Note that, if the macro
-** returns true, there is no need to 'invalidateTMcache', because the
-** call is not creating a new entry.
-*/
-#define luaV_fastset(L,t,k,slot,f,v) \
-  (!ttistable(t) \
-   ? (slot = NULL, 0) \
-   : (slot = f(L, hvalue(t), k), \
-     ttisnil(slot) ? 0 \
-     : (__extension__ ({ \
-          if (valiswhite(v) && isblack(obj2gco(hvalue(t)))) \
-            luaC_barrierback(L, hvalue(t)); \
-          setobj2t(L, cast(TValue *,slot), v); \
-          1; \
-        }))))
-
-#define luaV_settable(L,t,k,v) { const TValue *slot; \
-  if (!luaV_fastset(L,t,k,slot,luaH_set,v)) \
-    luaV_finishset(L,t,k,v,slot); }
-
-
-
 LUAI_FUNC int luaV_lessthan (lua_State *L, TValue *l, TValue *r);
 LUAI_FUNC int luaV_equalval (lua_State *L, const TValue *t1, const TValue *t2);
 LUAI_FUNC const TValue *luaV_tonumber (const TValue *obj, TValue *n);
 LUAI_FUNC int luaV_tostring (lua_State *L, StkId obj);
-LUAI_FUNC void luaV_finishget (lua_State *L, const TValue *t, TValue *key,
-                               StkId val, const TValue *tm);
-LUAI_FUNC void luaV_finishset (lua_State *L, const TValue *t, TValue *key,
-                               StkId val, const TValue *oldval);
+LUAI_FUNC void luaV_gettable (lua_State *L, TValue *t, TValue *key,
+                                            StkId val);
+LUAI_FUNC void luaV_settable (lua_State *L, TValue *t, TValue *key,
+                                            StkId val);
 LUAI_FUNC void luaV_execute (lua_State *L, int nexeccalls);
 LUAI_FUNC void luaV_concat (lua_State *L, int total, int last);
 

src/command.c

@@ -1178,7 +1178,7 @@ consvar_t *CV_FindVar(const char *name)
 	consvar_t *cvar;
 
 	for (cvar = consvar_vars; cvar; cvar = cvar->next)
-		if (fasticmp(name,cvar->name))
+		if (fasticmp(name, cvar->name))
 			return cvar;
 
 	return NULL;

src/console.c

@@ -46,16 +46,16 @@
 #ifdef HAVE_THREADS
 I_mutex con_mutex;
 
-// g_in_exiting_signal_handler is an evil hack
+// I_In_Exiting_Signal_Handler is an evil hack
 // 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 (!g_in_exiting_signal_handler) { I_lock_mutex(&con_mutex); }
-#  define Unlock_state()  if (!g_in_exiting_signal_handler) { I_unlock_mutex(con_mutex); }
-#else/*HAVE_THREADS*/
+#  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); }
+#else /*HAVE_THREADS*/
 #  define Lock_state()
 #  define Unlock_state()
-#endif/*HAVE_THREADS*/
+#endif /*HAVE_THREADS*/
 
 static boolean con_started = false; // console has been initialised
        boolean con_startup = false; // true at game startup, screen need refreshing

src/d_clisrv.h

@@ -660,9 +660,11 @@ extern UINT8 hu_redownloadinggamestate;
 #endif
 extern boolean hu_stopped; // kart, true when the game is stopped for players due to a disconnecting or connecting player
 
+#define SAVEGAMESIZE (768*1024)
+
 typedef struct rewind_s
 {
-	UINT8 savebuffer[(768*1024)];
+	UINT8 savebuffer[SAVEGAMESIZE];
 	tic_t leveltime;
 	size_t demopos;
 

src/d_main.c

@@ -697,6 +697,11 @@ void D_SRB2Loop(void)
 
 	for (;;)
 	{
+		if (I_Interrupted())
+		{
+			I_Quit();
+		}
+
 		// capbudget is the minimum precise_t duration of a single loop iteration
 		precise_t capbudget;
 		precise_t elapsed;

src/d_net.c

@@ -612,12 +612,8 @@ void Net_WaitAllAckReceived(UINT32 timeout)
 
 static void InitNode(node_t *node)
 {
-	node->acktosend_head = node->acktosend_tail = 0;
-	memset(node->acktosend, 0, sizeof(node->acktosend));
-	node->firstacktosend = 0;
+	memset(node, 0, sizeof(node_t));
 	node->nextacknum = 1;
-	node->remotefirstack = 0;
-	node->flags = 0;
 }
 
 static void InitAck(void)

src/d_netcmd.c

@@ -1208,11 +1208,11 @@ static boolean AllowedPlayerNameChar(char ch)
 
 static boolean EnsurePlayerNameIsGood(char *name, INT32 playernum)
 {
-	INT32 ix;
+	size_t ix, len = strlen(name);
 
-	if (strlen(name) == 0 || strlen(name) > MAXPLAYERNAME)
+	if (len == 0 || len > MAXPLAYERNAME)
 		return false; // Empty or too long.
-	if (name[0] == ' ' || name[strlen(name)-1] == ' ')
+	if (name[0] == ' ' || name[len-1] == ' ')
 		return false; // Starts or ends with a space.
 	if (isdigit(name[0]))
 		return false; // Starts with a digit.
@@ -1226,20 +1226,19 @@ static boolean EnsurePlayerNameIsGood(char *name, INT32 playernum)
 
 	// Also, anything over 0x80 is disallowed too, since compilers love to
 	// differ on whether they're printable characters or not.
-	for (ix = 0; name[ix] != '\0'; ix++)
+	for (ix = 0; ix < len; ix++)
 		if (!AllowedPlayerNameChar(name[ix]))
 			return false;
 
 	// Check if a player is currently using the name, case-insensitively.
 	for (ix = 0; ix < MAXPLAYERS; ix++)
 	{
-		if (ix != playernum && playeringame[ix]
+		if (ix != (size_t)playernum && playeringame[ix]
 			&& fasticmp(name, player_names[ix]))
 		{
 			// We shouldn't kick people out just because
 			// they joined the game with the same name
 			// as someone else -- modify the name instead.
-			size_t len = strlen(name);
 
 			// Recursion!
 			// Slowly strip characters off the end of the
@@ -1458,7 +1457,9 @@ UINT8 CanChangeSkin(INT32 playernum)
 				return true;
 		}
 
-		if (players[playernum].spectator || players[playernum].playerstate == PST_DEAD || players[playernum].playerstate == PST_REBORN)
+		if (players[playernum].spectator ||
+			players[playernum].playerstate == PST_DEAD ||
+			players[playernum].playerstate == PST_REBORN)
 			return true;
 
 		return false;
@@ -1492,445 +1493,144 @@ static void ForceAllSkins(INT32 forcedskin)
 	}
 }
 
-static INT32 snacpending = 0, snac2pending = 0, snac3pending = 0, snac4pending = 0, chmappending = 0;
+static INT32 chmappending;
+static INT32 snacpending[MAXSPLITSCREENPLAYERS];
+
+// wonky compat, idk if anything uses this....
+#define playerisbot (splitplayer == 1 && botingame)
 
 // name, color, or skin has changed
 //
-static void SendNameAndColor(void)
+static void SendNameAndColor(UINT8 splitplayer)
 {
 	char buf[MAXPLAYERNAME+2];
 	char *p;
 
 	p = buf;
 
+	// splitscreen
+	if (splitscreen < splitplayer && !playerisbot)
+		return;
+
+	const INT32 pnum = P_GetLocalPlayerNumForNum(splitplayer);
+
+	player_t *player = &players[pnum];
+
+	// TODO: make those cvars arrays
+	consvar_t *playercolor, *playername, *playerskin;
+	consvar_t *colorvars[] = {&cv_playercolor, &cv_playercolor2, &cv_playercolor3, &cv_playercolor4};
+	consvar_t *namevars[] = {&cv_playername, &cv_playername2, &cv_playername3, &cv_playername4};
+	consvar_t *skinvars[] = {&cv_skin, &cv_skin2, &cv_skin3, &cv_skin4};
+
+	playercolor = colorvars[splitplayer];
+	playername  = namevars[splitplayer];
+	playerskin  = skinvars[splitplayer];
+
 	// normal player colors
 	if (G_GametypeHasTeams())
 	{
-		if (players[consoleplayer].ctfteam == 1 && cv_playercolor.value != skincolor_redteam)
-			CV_StealthSetValue(&cv_playercolor, skincolor_redteam);
-		else if (players[consoleplayer].ctfteam == 2 && cv_playercolor.value != skincolor_blueteam)
-			CV_StealthSetValue(&cv_playercolor, skincolor_blueteam);
+		if (player->ctfteam == 1 && playercolor->value != skincolor_redteam)
+			CV_StealthSetValue(playercolor, skincolor_redteam);
+		else if (player->ctfteam == 2 && playercolor->value != skincolor_blueteam)
+			CV_StealthSetValue(playercolor, skincolor_blueteam);
 	}
 
 	// never allow the color "none"
-	if (!cv_playercolor.value)
+	if (!playercolor->value)
 	{
-		if (players[consoleplayer].skincolor)
-			CV_StealthSetValue(&cv_playercolor, players[consoleplayer].skincolor);
-		else if (skins[players[consoleplayer].skin].prefcolor)
-			CV_StealthSetValue(&cv_playercolor, skins[players[consoleplayer].skin].prefcolor);
+		if (player->skincolor)
+			CV_StealthSetValue(playercolor, player->skincolor);
+		else if (skins[player->skin].prefcolor)
+			CV_StealthSetValue(playercolor, skins[player->skin].prefcolor);
 		else
-			CV_StealthSet(&cv_playercolor, cv_playercolor.defaultvalue);
+			CV_StealthSet(playercolor, playercolor->defaultvalue);
 	}
 
-	if (fastcmp(cv_playername.string, player_names[consoleplayer])
-		&& cv_playercolor.value == players[consoleplayer].skincolor
-		&& fastcmp(cv_skin.string, skins[players[consoleplayer].skin].name))
-		return;
-
 	// We'll handle it later if we're not playing.
 	if (!Playing())
 		return;
 
+	if (fastcmp(playername->string, player_names[pnum])
+		&& playercolor->value == player->skincolor
+		&& fastcmp(playerskin->string, skins[player->skin].name))
+		return;
+
+	if (playerisbot)
+	{
+		players[pnum].skincolor = botcolor;
+		if (players[pnum].mo)
+			players[pnum].mo->color = players[pnum].skincolor;
+		SetPlayerSkinByNum(pnum, botskin-1);
+		return;
+	}
+
 	// If you're not in a netgame, merely update the skin, color, and name.
 	if (!netgame)
 	{
 		INT32 foundskin;
 
-		CleanupPlayerName(consoleplayer, cv_playername.zstring);
-		strcpy(player_names[consoleplayer], cv_playername.zstring);
+		CleanupPlayerName(pnum, playername->zstring);
+		strcpy(player_names[pnum], playername->zstring);
 
-		players[consoleplayer].skincolor = cv_playercolor.value;
+		player->skincolor = playercolor->value;
 
-		if (players[consoleplayer].mo)
-			players[consoleplayer].mo->color = players[consoleplayer].skincolor;
+		if (player->mo)
+			player->mo->color = player->skincolor;
 
-		if ((foundskin = R_SkinAvailable(cv_skin.string)) != -1)
+		if ((foundskin = R_SkinAvailable(playerskin->string)) != -1)
 		{
-			cv_skin.value = foundskin;
-			SetPlayerSkin(consoleplayer, cv_skin.string);
-			CV_StealthSet(&cv_skin, skins[cv_skin.value].name);
+			playerskin->value = foundskin;
+			SetPlayerSkin(pnum, playerskin->string);
+			CV_StealthSet(playerskin, skins[playerskin->value].name);
 		}
 		else
 		{
-			cv_skin.value = players[consoleplayer].skin;
-			CV_StealthSet(&cv_skin, skins[players[consoleplayer].skin].name);
+			playerskin->value = player->skin;
+			CV_StealthSet(playerskin, skins[player->skin].name);
 			// will always be same as current
-			SetPlayerSkin(consoleplayer, cv_skin.string);
+			SetPlayerSkin(pnum, playerskin->string);
 		}
 
 		return;
 	}
 
-	snacpending++;
+	snacpending[splitplayer]++;
 
 	// Don't change name if muted
-	if (player_name_changes[consoleplayer] >= MAXNAMECHANGES)
+	if (player_name_changes[pnum] >= MAXNAMECHANGES)
 	{
-		CV_StealthSet(&cv_playername, player_names[consoleplayer]);
+		CV_StealthSet(playername, player_names[pnum]);
 		HU_AddChatText("\x85*You must wait to change your name again", false);
 	}
-	else if (cv_mute.value && !(server || IsPlayerAdmin(consoleplayer)))
-		CV_StealthSet(&cv_playername, player_names[consoleplayer]);
+	else if (cv_mute.value && !(server || IsPlayerAdmin(pnum)))
+		CV_StealthSet(playername, player_names[pnum]);
 	else // Cleanup name if changing it
-		CleanupPlayerName(consoleplayer, cv_playername.zstring);
+		CleanupPlayerName(pnum, playername->zstring);
 
 	// Don't change skin if the server doesn't want you to.
-	if (!CanChangeSkin(consoleplayer))
-		CV_StealthSet(&cv_skin, skins[players[consoleplayer].skin].name);
+	if (!CanChangeSkin(pnum))
+		CV_StealthSet(playerskin, skins[player->skin].name);
 
 	// check if player has the skin loaded (cv_skin may have
 	// the name of a skin that was available in the previous game)
-	cv_skin.value = R_SkinAvailable(cv_skin.string);
-	if (cv_skin.value < 0)
+	playerskin->value = R_SkinAvailable(playerskin->string);
+	if (playerskin->value < 0)
 	{
-		INT32 skinnum = players[consoleplayer].skin;
-		CV_StealthSet(&cv_skin, skins[skinnum].name);
-		cv_skin.value = skinnum;
+		INT32 skinnum = player->skin;
+		CV_StealthSet(playerskin, skins[skinnum].name);
+		playerskin->value = skinnum;
 	}
 
 	// Finally write out the complete packet and send it off.
-	WRITESTRINGN(p, cv_playername.zstring, MAXPLAYERNAME);
-	WRITEUINT8(p, (UINT8)cv_playercolor.value);
-	WRITEUINT8(p, (UINT8)cv_skin.value);
-	SendNetXCmdForPlayer(0, XD_NAMEANDCOLOR, buf, p - buf);
-}
-
-// splitscreen
-static void SendNameAndColor2(void)
-{
-	INT32 secondplaya = -1;
-	char buf[MAXPLAYERNAME+2];
-	char *p;
-
-	if (splitscreen < 1 && !botingame)
-		return; // can happen if skin2/color2/name2 changed
-
-	if (displayplayers[1] != consoleplayer)
-		secondplaya = displayplayers[1];
-	else if (!netgame) // HACK
-		secondplaya = 1;
-
-	if (secondplaya == -1)
-		return;
-
-	p = buf;
-
-	// normal player colors
-	if (G_GametypeHasTeams())
-	{
-		if (players[secondplaya].ctfteam == 1 && cv_playercolor2.value != skincolor_redteam)
-			CV_StealthSetValue(&cv_playercolor2, skincolor_redteam);
-		else if (players[secondplaya].ctfteam == 2 && cv_playercolor2.value != skincolor_blueteam)
-			CV_StealthSetValue(&cv_playercolor2, skincolor_blueteam);
-	}
-
-	// never allow the color "none"
-	if (!cv_playercolor2.value)
-	{
-		if (players[secondplaya].skincolor)
-			CV_StealthSetValue(&cv_playercolor2, players[secondplaya].skincolor);
-		else if (skins[players[secondplaya].skin].prefcolor)
-			CV_StealthSetValue(&cv_playercolor2, skins[players[secondplaya].skin].prefcolor);
-		else
-			CV_StealthSet(&cv_playercolor2, cv_playercolor2.defaultvalue);
-	}
-
-	// We'll handle it later if we're not playing.
-	if (!Playing())
-		return;
-
-	// If you're not in a netgame, merely update the skin, color, and name.
-	if (botingame)
-	{
-		players[secondplaya].skincolor = botcolor;
-		if (players[secondplaya].mo)
-			players[secondplaya].mo->color = players[secondplaya].skincolor;
-		SetPlayerSkinByNum(secondplaya, botskin-1);
-		return;
-	}
-	else if (!netgame)
-	{
-		INT32 foundskin;
-
-		CleanupPlayerName(secondplaya, cv_playername2.zstring);
-		strcpy(player_names[secondplaya], cv_playername2.zstring);
-
-		// don't use displayplayers[1]: the second player must be 1
-		players[secondplaya].skincolor = cv_playercolor2.value;
-		if (players[secondplaya].mo)
-			players[secondplaya].mo->color = players[secondplaya].skincolor;
-
-		if ((foundskin = R_SkinAvailable(cv_skin2.string)) != -1)
-		{
-			cv_skin2.value = foundskin;
-			SetPlayerSkin(secondplaya, cv_skin2.string);
-		}
-		else
-		{
-			cv_skin2.value = players[secondplaya].skin;
-			CV_StealthSet(&cv_skin2, skins[players[secondplaya].skin].name);
-			// will always be same as current
-			SetPlayerSkin(secondplaya, cv_skin2.string);
-		}
-		return;
-	}
-
-	snac2pending++;
-
-	// Don't change name if muted
-	if (player_name_changes[displayplayers[1]] >= MAXNAMECHANGES)
-	{
-		CV_StealthSet(&cv_playername2, player_names[displayplayers[1]]);
-		HU_AddChatText("\x85*You must wait to change your name again", false);
-	}
-	else if (cv_mute.value && !(server || IsPlayerAdmin(displayplayers[1])))
-		CV_StealthSet(&cv_playername2, player_names[displayplayers[1]]);
-	else // Cleanup name if changing it
-		CleanupPlayerName(displayplayers[1], cv_playername2.zstring);
-
-	// Don't change skin if the server doesn't want you to.
-	if (!CanChangeSkin(displayplayers[1]))
-		CV_StealthSet(&cv_skin2, skins[players[displayplayers[1]].skin].name);
-
-	// check if player has the skin loaded (cv_skin2 may have
-	// the name of a skin that was available in the previous game)
-	cv_skin2.value = R_SkinAvailable(cv_skin2.string);
-	if (cv_skin2.value < 0)
-	{
-		INT32 skinnum = players[displayplayers[1]].skin;
-		CV_StealthSet(&cv_skin2, skins[skinnum].name);
-		cv_skin2.value = skinnum;
-	}
-
-	// Finally write out the complete packet and send it off.
-	WRITESTRINGN(p, cv_playername2.zstring, MAXPLAYERNAME);
-	WRITEUINT8(p, (UINT8)cv_playercolor2.value);
-	WRITEUINT8(p, (UINT8)cv_skin2.value);
-	SendNetXCmdForPlayer(1, XD_NAMEANDCOLOR, buf, p - buf);
-}
-
-static void SendNameAndColor3(void)
-{
-	INT32 thirdplaya = -1;
-	char buf[MAXPLAYERNAME+2];
-	char *p;
-
-	if (splitscreen < 2)
-		return; // can happen if skin3/color3/name3 changed
-
-	if (displayplayers[2] != consoleplayer)
-		thirdplaya = displayplayers[2];
-	else if (!netgame) // HACK
-		thirdplaya = 2;
-
-	if (thirdplaya == -1)
-		return;
-
-	p = buf;
-
-	// normal player colors
-	if (G_GametypeHasTeams())
-	{
-		if (players[thirdplaya].ctfteam == 1 && cv_playercolor3.value != skincolor_redteam)
-			CV_StealthSetValue(&cv_playercolor3, skincolor_redteam);
-		else if (players[thirdplaya].ctfteam == 2 && cv_playercolor3.value != skincolor_blueteam)
-			CV_StealthSetValue(&cv_playercolor3, skincolor_blueteam);
-	}
-
-	// never allow the color "none"
-	if (!cv_playercolor3.value)
-	{
-		if (players[thirdplaya].skincolor)
-			CV_StealthSetValue(&cv_playercolor3, players[thirdplaya].skincolor);
-		else if (skins[players[thirdplaya].skin].prefcolor)
-			CV_StealthSetValue(&cv_playercolor3, skins[players[thirdplaya].skin].prefcolor);
-		else
-			CV_StealthSet(&cv_playercolor3, cv_playercolor3.defaultvalue);
-	}
-
-	// We'll handle it later if we're not playing.
-	if (!Playing())
-		return;
-
-	// If you're not in a netgame, merely update the skin, color, and name.
-	if (!netgame)
-	{
-		INT32 foundskin;
-
-		CleanupPlayerName(thirdplaya, cv_playername3.zstring);
-		strcpy(player_names[thirdplaya], cv_playername3.zstring);
-
-		// don't use displayplayers[2]: the third player must be 2
-		players[thirdplaya].skincolor = cv_playercolor3.value;
-		if (players[thirdplaya].mo)
-			players[thirdplaya].mo->color = players[thirdplaya].skincolor;
-
-		if ((foundskin = R_SkinAvailable(cv_skin3.string)) != -1)
-		{
-			cv_skin3.value = foundskin;
-			SetPlayerSkin(thirdplaya, cv_skin3.string);
-		}
-		else
-		{
-			cv_skin3.value = players[thirdplaya].skin;
-			CV_StealthSet(&cv_skin3, skins[players[thirdplaya].skin].name);
-			// will always be same as current
-			SetPlayerSkin(thirdplaya, cv_skin3.string);
-		}
-		return;
-	}
-
-	snac3pending++;
-
-	// Don't change name if muted
-	if (player_name_changes[displayplayers[2]] >= MAXNAMECHANGES)
-	{
-		CV_StealthSet(&cv_playername3, player_names[displayplayers[2]]);
-		HU_AddChatText("\x85*You must wait to change your name again", false);
-	}
-	else if (cv_mute.value && !(server || IsPlayerAdmin(displayplayers[2])))
-		CV_StealthSet(&cv_playername3, player_names[displayplayers[2]]);
-	else // Cleanup name if changing it
-		CleanupPlayerName(displayplayers[2], cv_playername3.zstring);
-
-	// Don't change skin if the server doesn't want you to.
-	if (!CanChangeSkin(displayplayers[2]))
-		CV_StealthSet(&cv_skin3, skins[players[displayplayers[2]].skin].name);
-
-	// check if player has the skin loaded (cv_skin3 may have
-	// the name of a skin that was available in the previous game)
-	cv_skin3.value = R_SkinAvailable(cv_skin3.string);
-	if (cv_skin3.value < 0)
-	{
-		INT32 skinnum = players[displayplayers[2]].skin;
-		CV_StealthSet(&cv_skin3, skins[skinnum].name);
-		cv_skin3.value = skinnum;
-	}
-
-	// Finally write out the complete packet and send it off.
-	WRITESTRINGN(p, cv_playername3.zstring, MAXPLAYERNAME);
-	WRITEUINT8(p, (UINT8)cv_playercolor3.value);
-	WRITEUINT8(p, (UINT8)cv_skin3.value);
-	SendNetXCmdForPlayer(2, XD_NAMEANDCOLOR, buf, p - buf);
-}
-
-static void SendNameAndColor4(void)
-{
-	INT32 fourthplaya = -1;
-	char buf[MAXPLAYERNAME+2];
-	char *p;
-
-	if (splitscreen < 3)
-		return; // can happen if skin4/color4/name4 changed
-
-	if (displayplayers[3] != consoleplayer)
-		fourthplaya = displayplayers[3];
-	else if (!netgame) // HACK
-		fourthplaya = 3;
-
-	if (fourthplaya == -1)
-		return;
-
-	p = buf;
-
-	// normal player colors
-	if (G_GametypeHasTeams())
-	{
-		if (players[fourthplaya].ctfteam == 1 && cv_playercolor4.value != skincolor_redteam)
-			CV_StealthSetValue(&cv_playercolor4, skincolor_redteam);
-		else if (players[fourthplaya].ctfteam == 2 && cv_playercolor4.value != skincolor_blueteam)
-			CV_StealthSetValue(&cv_playercolor4, skincolor_blueteam);
-	}
-
-	// never allow the color "none"
-	if (!cv_playercolor4.value)
-	{
-		if (players[fourthplaya].skincolor)
-			CV_StealthSetValue(&cv_playercolor4, players[fourthplaya].skincolor);
-		else if (skins[players[fourthplaya].skin].prefcolor)
-			CV_StealthSetValue(&cv_playercolor4, skins[players[fourthplaya].skin].prefcolor);
-		else
-			CV_StealthSet(&cv_playercolor4, cv_playercolor4.defaultvalue);
-	}
-
-	// We'll handle it later if we're not playing.
-	if (!Playing())
-		return;
-
-	// If you're not in a netgame, merely update the skin, color, and name.
-	if (botingame)
-	{
-		players[fourthplaya].skincolor = botcolor;
-		if (players[fourthplaya].mo)
-			players[fourthplaya].mo->color = players[fourthplaya].skincolor;
-		SetPlayerSkinByNum(fourthplaya, botskin-1);
-		return;
-	}
-	else if (!netgame)
-	{
-		INT32 foundskin;
-
-		CleanupPlayerName(fourthplaya, cv_playername4.zstring);
-		strcpy(player_names[fourthplaya], cv_playername4.zstring);
-
-		// don't use displayplayers[3]: the second player must be 4
-		players[fourthplaya].skincolor = cv_playercolor4.value;
-		if (players[fourthplaya].mo)
-			players[fourthplaya].mo->color = players[fourthplaya].skincolor;
-
-		if ((foundskin = R_SkinAvailable(cv_skin4.string)) != -1)
-		{
-			cv_skin4.value = foundskin;
-			SetPlayerSkin(fourthplaya, cv_skin4.string);
-		}
-		else
-		{
-			cv_skin4.value = players[fourthplaya].skin;
-			CV_StealthSet(&cv_skin4, skins[players[fourthplaya].skin].name);
-			// will always be same as current
-			SetPlayerSkin(fourthplaya, cv_skin4.string);
-		}
-		return;
-	}
-
-	snac4pending++;
-
-	// Don't change name if muted
-	if (player_name_changes[displayplayers[3]] >= MAXNAMECHANGES)
-	{
-		CV_StealthSet(&cv_playername4, player_names[displayplayers[3]]);
-		HU_AddChatText("\x85*You must wait to change your name again", false);
-	}
-	else if (cv_mute.value && !(server || IsPlayerAdmin(displayplayers[3])))
-		CV_StealthSet(&cv_playername4, player_names[displayplayers[3]]);
-	else // Cleanup name if changing it
-		CleanupPlayerName(displayplayers[3], cv_playername4.zstring);
-
-	// Don't change skin if the server doesn't want you to.
-	if (!CanChangeSkin(displayplayers[3]))
-		CV_StealthSet(&cv_skin4, skins[players[displayplayers[3]].skin].name);
-
-	// check if player has the skin loaded (cv_skin4 may have
-	// the name of a skin that was available in the previous game)
-	cv_skin4.value = R_SkinAvailable(cv_skin4.string);
-	if (cv_skin4.value < 0)
-	{
-		INT32 skinnum = players[displayplayers[3]].skin;
-		CV_StealthSet(&cv_skin4, skins[skinnum].name);
-		cv_skin4.value = skinnum;
-	}
-
-	// Finally write out the complete packet and send it off.
-	WRITESTRINGN(p, cv_playername4.zstring, MAXPLAYERNAME);
-	WRITEUINT8(p, (UINT8)cv_playercolor4.value);
-	WRITEUINT8(p, (UINT8)cv_skin4.value);
-	SendNetXCmdForPlayer(3, XD_NAMEANDCOLOR, buf, p - buf);
+	WRITESTRINGN(p, playername->zstring, MAXPLAYERNAME);
+	WRITEUINT8(p, (UINT8)playercolor->value);
+	WRITEUINT8(p, (UINT8)playerskin->value);
+	SendNetXCmdForPlayer(splitplayer, XD_NAMEANDCOLOR, buf, p - buf);
 }
 
 static void Got_NameAndColor(const UINT8 **cp, INT32 playernum)
 {
-	player_t *p = &players[playernum];
+	player_t *player = &players[playernum];
 	char name[MAXPLAYERNAME+1];
 	UINT8 color, skin;
 
@@ -1939,19 +1639,14 @@ static void Got_NameAndColor(const UINT8 **cp, INT32 playernum)
 		I_Error("There is no player %d!", playernum);
 #endif
 
-	if (playernum == consoleplayer)
-		snacpending--; // TODO: make snacpending an array instead of 4 separate vars?
-	else if (playernum == displayplayers[1])
-		snac2pending--;
-	else if (playernum == displayplayers[2])
-		snac3pending--;
-	else if (playernum == displayplayers[3])
-		snac4pending--;
-
+	if (P_IsLocalPlayer(player))
+	{
+		snacpending[playernum]--;
 #ifdef PARANOIA
-	if (snacpending < 0 || snac2pending < 0 || snac3pending < 0 || snac4pending < 0)
-		I_Error("snacpending negative!");
+		if (snacpending[playernum] < 0)
+			I_Error("snacpending negative!");
 #endif
+	}
 
 	READSTRINGN(*cp, name, MAXPLAYERNAME);
 	color = READUINT8(*cp);
@@ -1965,33 +1660,32 @@ static void Got_NameAndColor(const UINT8 **cp, INT32 playernum)
 	}
 
 	// set color
-	p->skincolor = color % MAXSKINCOLORS;
-	if (p->mo)
-		p->mo->color = (UINT8)p->skincolor;
+	player->skincolor = color % MAXSKINCOLORS;
+	if (player->mo)
+		player->mo->color = (UINT8)player->skincolor;
 	demo_extradata[playernum] |= DXD_COLOR;
 
 	// normal player colors
-	if (server && (p != &players[consoleplayer] && p != &players[displayplayers[1]]
-		&& p != &players[displayplayers[2]] && p != &players[displayplayers[3]]))
+	if (server && !P_IsLocalPlayer(player))
 	{
 		boolean kick = false;
 
 		// team colors
 		if (G_GametypeHasTeams())
 		{
-			if (p->ctfteam == 1 && p->skincolor != skincolor_redteam)
+			if (player->ctfteam == 1 && player->skincolor != skincolor_redteam)
 				kick = true;
-			else if (p->ctfteam == 2 && p->skincolor != skincolor_blueteam)
+			else if (player->ctfteam == 2 && player->skincolor != skincolor_blueteam)
 				kick = true;
 		}
 
 		// don't allow color "none"
-		if (!p->skincolor)
+		if (!player->skincolor)
 			kick = true;
 
 		if (kick)
 		{
-			CONS_Alert(CONS_WARNING, M_GetText("Illegal color change received from %s (team: %d), color: %d)\n"), player_names[playernum], p->ctfteam, p->skincolor);
+			CONS_Alert(CONS_WARNING, M_GetText("Illegal color change received from %s (team: %d), color: %d)\n"), player_names[playernum], player->ctfteam, player->skincolor);
 			SendKick(playernum, KICK_MSG_CON_FAIL);
 			return;
 		}
@@ -2003,6 +1697,7 @@ static void Got_NameAndColor(const UINT8 **cp, INT32 playernum)
 		const INT32 forcedskin = cv_forceskin.value;
 		SetPlayerSkinByNum(playernum, forcedskin);
 
+		// TODO: make cv_skin an array
 		if (playernum == consoleplayer)
 			CV_StealthSet(&cv_skin, skins[forcedskin].name);
 		else if (playernum == displayplayers[1])
@@ -2016,44 +1711,16 @@ static void Got_NameAndColor(const UINT8 **cp, INT32 playernum)
 		SetPlayerSkinByNum(playernum, skin);
 }
 
-void SendWeaponPref(void)
+void SendWeaponPref(UINT8 splitplayer)
 {
 	UINT8 buf[1];
 
 	buf[0] = 0;
-	if (cv_flipcam[0].value)
+
+	if (cv_flipcam[splitplayer].value)
 		buf[0] |= 1;
-	SendNetXCmdForPlayer(0, XD_WEAPONPREF, buf, 1);
-}
 
-void SendWeaponPref2(void)
-{
-	UINT8 buf[1];
-
-	buf[0] = 0;
-	if (cv_flipcam[1].value)
-		buf[0] |= 1;
-	SendNetXCmdForPlayer(1, XD_WEAPONPREF, buf, 1);
-}
-
-void SendWeaponPref3(void)
-{
-	UINT8 buf[1];
-
-	buf[0] = 0;
-	if (cv_flipcam[2].value)
-		buf[0] |= 1;
-	SendNetXCmdForPlayer(2, XD_WEAPONPREF, buf, 1);
-}
-
-void SendWeaponPref4(void)
-{
-	UINT8 buf[1];
-
-	buf[0] = 0;
-	if (cv_flipcam[3].value)
-		buf[0] |= 1;
-	SendNetXCmdForPlayer(3, XD_WEAPONPREF, buf, 1);
+	SendNetXCmdForPlayer(splitplayer, XD_WEAPONPREF, buf, 1);
 }
 
 static void Got_WeaponPref(const UINT8 **cp, INT32 playernum)
@@ -2069,23 +1736,10 @@ static void Got_WeaponPref(const UINT8 **cp, INT32 playernum)
 		player->pflags |= PF_ANALOGMODE;
 }
 
-void D_SendPlayerConfig(void)
+void D_SendPlayerConfig(UINT8 splitplayer)
 {
-	SendNameAndColor();
-	if (splitscreen || botingame)
-		SendNameAndColor2();
-	if (splitscreen > 1)
-		SendNameAndColor3();
-	if (splitscreen > 2)
-		SendNameAndColor4();
-
-	SendWeaponPref();
-	if (splitscreen)
-		SendWeaponPref2();
-	if (splitscreen > 1)
-		SendWeaponPref3();
-	if (splitscreen > 2)
-		SendWeaponPref4();
+	SendNameAndColor(splitplayer);
+	SendWeaponPref(splitplayer);
 }
 
 // Only works for displayplayer, sorry!
@@ -2108,10 +1762,12 @@ INT32 D_LookupPlayer(const char *s)
 		return playernum;
 	}
 
+	const size_t len = strlen(s);
+
 	for (playernum = 0; playernum < MAXPLAYERS; ++playernum)
 	{
 		/* Match name case-insensitively: fully, or partially the start. */
-		if (playeringame[playernum] && (strnicmp(player_names[playernum], s, strlen(s)) == 0))
+		if (playeringame[playernum] && (strnicmp(player_names[playernum], s, len) == 0))
 		{
 			return playernum;
 		}
@@ -2151,13 +1807,15 @@ static void GetViewablePlayerPlaceRange(INT32 *first, INT32 *last)
 	(*last) = 0;
 
 	for (i = 0; i < MAXPLAYERS; ++i)
-		if (G_CouldView(i))
 	{
-		place = players[i].kartstuff[k_position];
-		if (place < (*first))
-			(*first) = place;
-		if (place > (*last))
-			(*last) = place;
+		if (G_CouldView(i))
+		{
+			place = players[i].kartstuff[k_position];
+			if (place < (*first))
+				(*first) = place;
+			if (place > (*last))
+				(*last) = place;
+		}
 	}
 }
 
@@ -2491,7 +2149,7 @@ void D_MapChange(INT32 mapnum, INT32 newgametype, boolean pencoremode, boolean r
 				displayplayers[1] = 1;
 				playeringame[1] = true;
 				players[1].bot = 1;
-				SendNameAndColor2();
+				SendNameAndColor(1);
 			}
 		}
 
@@ -5768,50 +5426,54 @@ static void ForceSkin_OnChange(void)
 	}
 }
 
-//Allows the player's name to be changed if cv_mute is off.
+// Allows the player's name to be changed if cv_mute is off.
 static void Name_OnChange(void)
 {
 	if (cv_mute.value && !(server || IsPlayerAdmin(consoleplayer)))
 	{
 		CONS_Alert(CONS_NOTICE, M_GetText("You may not change your name when chat is muted.\n"));
 		CV_StealthSet(&cv_playername, player_names[consoleplayer]);
+		return;
 	}
-	else
-		SendNameAndColor();
+
+	SendNameAndColor(0);
 
 }
 
 static void Name2_OnChange(void)
 {
-	if (cv_mute.value) //Secondary player can't be admin.
+	if (cv_mute.value) // Secondary player can't be admin.
 	{
 		CONS_Alert(CONS_NOTICE, M_GetText("You may not change your name when chat is muted.\n"));
 		CV_StealthSet(&cv_playername2, player_names[displayplayers[1]]);
+		return;
 	}
-	else
-		SendNameAndColor2();
+
+	SendNameAndColor(1);
 }
 
 static void Name3_OnChange(void)
 {
-	if (cv_mute.value) //Third player can't be admin.
+	if (cv_mute.value) // Third player can't be admin.
 	{
 		CONS_Alert(CONS_NOTICE, M_GetText("You may not change your name when chat is muted.\n"));
 		CV_StealthSet(&cv_playername3, player_names[displayplayers[2]]);
+		return;
 	}
-	else
-		SendNameAndColor3();
+
+	SendNameAndColor(2);
 }
 
 static void Name4_OnChange(void)
 {
-	if (cv_mute.value) //Secondary player can't be admin.
+	if (cv_mute.value) // Secondary player can't be admin.
 	{
 		CONS_Alert(CONS_NOTICE, M_GetText("You may not change your name when chat is muted.\n"));
 		CV_StealthSet(&cv_playername4, player_names[displayplayers[3]]);
+		return;
 	}
-	else
-		SendNameAndColor4();
+
+	SendNameAndColor(3);
 }
 
 /** Sends a skin change for the console player, unless that player is moving.
@@ -5833,7 +5495,7 @@ static void Skin_OnChange(void)
 	}
 
 	if (CanChangeSkin(consoleplayer) && !P_PlayerMoving(consoleplayer))
-		SendNameAndColor();
+		SendNameAndColor(0);
 	else
 	{
 		CONS_Alert(CONS_NOTICE, M_GetText("You can't change your skin at the moment.\n"));
@@ -5854,7 +5516,7 @@ static void Skin2_OnChange(void)
 		return; // do whatever you want
 
 	if (CanChangeSkin(displayplayers[1]) && !P_PlayerMoving(displayplayers[1]))
-		SendNameAndColor2();
+		SendNameAndColor(1);
 	else
 	{
 		CONS_Alert(CONS_NOTICE, M_GetText("You can't change your skin at the moment.\n"));
@@ -5870,7 +5532,7 @@ static void Skin3_OnChange(void)
 		return; // do whatever you want
 
 	if (CanChangeSkin(displayplayers[2]) && !P_PlayerMoving(displayplayers[2]))
-		SendNameAndColor3();
+		SendNameAndColor(2);
 	else
 	{
 		CONS_Alert(CONS_NOTICE, M_GetText("You can't change your skin at the moment.\n"));
@@ -5886,7 +5548,7 @@ static void Skin4_OnChange(void)
 		return; // do whatever you want
 
 	if (CanChangeSkin(displayplayers[3]) && !P_PlayerMoving(displayplayers[3]))
-		SendNameAndColor4();
+		SendNameAndColor(3);
 	else
 	{
 		CONS_Alert(CONS_NOTICE, M_GetText("You can't change your skin at the moment.\n"));
@@ -5999,7 +5661,7 @@ static void Color_OnChange(void)
 	if (!P_PlayerMoving(consoleplayer))
 	{
 		// Color change menu scrolling fix is no longer necessary
-		SendNameAndColor();
+		SendNameAndColor(0);
 	}
 	else
 	{
@@ -6021,7 +5683,7 @@ static void Color2_OnChange(void)
 	if (!P_PlayerMoving(displayplayers[1]))
 	{
 		// Color change menu scrolling fix is no longer necessary
-		SendNameAndColor2();
+		SendNameAndColor(1);
 	}
 	else
 	{
@@ -6038,7 +5700,7 @@ static void Color3_OnChange(void)
 	if (!P_PlayerMoving(displayplayers[2]))
 	{
 		// Color change menu scrolling fix is no longer necessary
-		SendNameAndColor3();
+		SendNameAndColor(2);
 	}
 	else
 	{
@@ -6055,7 +5717,7 @@ static void Color4_OnChange(void)
 	if (!P_PlayerMoving(displayplayers[3]))
 	{
 		// Color change menu scrolling fix is no longer necessary
-		SendNameAndColor4();
+		SendNameAndColor(3);
 	}
 	else
 	{

src/d_netcmd.h

@@ -21,10 +21,7 @@ extern "C" {
 
 #include "command.h"
 
-void SendWeaponPref(void);
-void SendWeaponPref2(void);
-void SendWeaponPref3(void);
-void SendWeaponPref4(void);
+void SendWeaponPref(UINT8 splitplayer);
 
 // console vars
 extern consvar_t cv_playername;
@@ -295,7 +292,7 @@ typedef union {
 // add game commands, needs cleanup
 void D_RegisterServerCommands(void);
 void D_RegisterClientCommands(void);
-void D_SendPlayerConfig(void);
+void D_SendPlayerConfig(UINT8 splitplayer);
 void Command_ExitGame_f(void);
 void Command_Retry_f(void);
 void D_GameTypeChanged(INT32 lastgametype); // not a real _OnChange function anymore

src/d_netfil.c

@@ -960,7 +960,7 @@ void Got_Filetxpak(void)
 		|| fastcmp(filename, "music.kart")
 		|| fastcmp(filename, "patch.kart")
 		))
-		I_Error("Tried to download \"%s\"", filename);
+		I_Error("Tried to download base-game file: \"%s\"", filename);
 
 	if (filenum >= fileneedednum)
 	{
@@ -1019,21 +1019,21 @@ void Got_Filetxpak(void)
 
 		switch(file->status)
 		{
-		case FS_NOTFOUND:
-			s = "FS_NOTFOUND";
-			break;
-		case FS_FOUND:
-			s = "FS_FOUND";
-			break;
-		case FS_OPEN:
-			s = "FS_OPEN";
-			break;
-		case FS_MD5SUMBAD:
-			s = "FS_MD5SUMBAD";
-			break;
-		default:
-			s = "unknown";
-			break;
+			case FS_NOTFOUND:
+				s = "FS_NOTFOUND";
+				break;
+			case FS_FOUND:
+				s = "FS_FOUND";
+				break;
+			case FS_OPEN:
+				s = "FS_OPEN";
+				break;
+			case FS_MD5SUMBAD:
+				s = "FS_MD5SUMBAD";
+				break;
+			default:
+				s = "unknown";
+				break;
 		}
 
 		I_Error("Received a file not requested (file id: %d, file status: %s)\n", filenum, s);

src/dedicated/i_system.c

@@ -984,7 +984,7 @@ void I_SleepDuration(precise_t duration)
 #endif
 }
 
-boolean g_in_exiting_signal_handler = false;
+static volatile sig_atomic_t g_in_exiting_signal_handler = false;
 
 static void I_PrintSignal(INT32 signal_num, boolean core_dumped, char *signal_msg)
 {
@@ -1048,6 +1048,11 @@ static void I_ReportSignal(int num, int coredumped)
 	I_OutputMsg("\nProcess killed by signal: %s\n\n", sigmsg);
 }
 
+boolean I_In_Exiting_Signal_Handler(void)
+{
+	return g_in_exiting_signal_handler;
+}
+
 #ifndef NEWSIGNALHANDLER
 FUNCNORETURN static ATTRNORETURN void signal_handler(INT32 num)
 {
@@ -1067,11 +1072,17 @@ FUNCNORETURN static ATTRNORETURN void signal_handler(INT32 num)
 }
 #endif
 
-FUNCNORETURN static ATTRNORETURN void quit_handler(int num)
+static volatile sig_atomic_t interrupted = 0;
+
+boolean I_Interrupted(void)
 {
-	signal(num, SIG_DFL); //default signal action
-	raise(num);
-	I_Quit();
+	return interrupted;
+}
+
+static void quit_handler(int num)
+{
+	(void)num;
+	interrupted = 1;
 }
 
 #ifdef HAVE_LIBBACKTRACE

src/dehacked.c

@@ -173,7 +173,7 @@ FUNCPRINTF static void deh_warning(const char *first, ...)
 	vsnprintf(buf, 1000, first, argptr); // sizeof only returned 4 here. it didn't like that pointer.
 	va_end(argptr);
 
-	if(dbg_line == -1) // Not in a SOC, line number unknown.
+	if (dbg_line == -1) // Not in a SOC, line number unknown.
 		CONS_Alert(CONS_WARNING, "%s\n", buf);
 	else
 		CONS_Alert(CONS_WARNING, "Line %u: %s\n", dbg_line, buf);
@@ -8545,7 +8545,7 @@ static inline int lib_action(lua_State *L)
 
 // Hardcoded A_Action name to call for super() or NULL if super() would be invalid.
 // Set in lua_infolib.
-const char *superactions[MAXRECURSION];
+const char *superactions[MAXRECURSION] = {};
 UINT8 superstack = 0;
 
 static int lib_dummysuper(lua_State *L)

src/g_game.c

@@ -69,9 +69,6 @@ UINT8 botcolor = 0;
 
 JoyType_t Joystick[MAXSPLITSCREENPLAYERS] = {};
 
-// 1024 bytes is plenty for a savegame
-#define SAVEGAMESIZE (1024)
-
 // SRB2kart
 char gamedatafilename[64] = "kartdata.dat";
 char timeattackfolder[64] = "kart";
@@ -3902,7 +3899,7 @@ void G_SaveGame(UINT32 savegameslot)
 		char name[VERSIONSIZE];
 		size_t length;
 
-		save.p = save.buffer = (UINT8 *)Z_Malloc(SAVEGAMESIZE, PU_STATIC, NULL);
+		save.p = save.buffer = (UINT8 *)Z_Malloc(1024, PU_STATIC, NULL); // 1024 bytes is plenty for a savegame
 		if (!save.p)
 		{
 			CONS_Alert(CONS_ERROR, M_GetText("No more free memory for saving game data\n"));

src/http-mserv.c

@@ -318,6 +318,7 @@ static void
 HMS_end (struct HMS_buffer *buffer)
 {
 	curl_easy_cleanup(buffer->curl);
+	free(buffer->errbuf);
 	free(buffer->buffer);
 	free(buffer);
 }

src/i_system.h

@@ -43,7 +43,7 @@ extern UINT8 graphics_started;
 extern UINT8 keyboard_started;
 
 /** \brief Set to true when inside a signal handler that will exit the program. */
-extern boolean g_in_exiting_signal_handler;
+boolean I_In_Exiting_Signal_Handler(void);
 
 /**	\brief	The I_GetFreeMem function
 
@@ -195,6 +195,10 @@ INT32 I_StartupSystem(void);
 */
 void I_ShutdownSystem(void);
 
+/**	\brief To check if a Interrupt or Terminate Signal was fired
+ */
+boolean I_Interrupted(void);
+
 /**	\brief	The I_GetDiskFreeSpace function
 
 	\param	freespace	a INT64 pointer to hold the free space amount

src/i_tcp.c

@@ -496,8 +496,10 @@ static void cleanupnodes(void)
 
 	// Why can't I start at zero?
 	for (j = 1; j < MAXNETNODES; j++)
+	{
 		if (!(nodeingame[j] || SV_SendingFile(j)))
 			nodeconnected[j] = false;
+	}
 }
 
 static SINT8 getfreenode(void)
@@ -507,11 +509,13 @@ static SINT8 getfreenode(void)
 	cleanupnodes();
 
 	for (j = 0; j < MAXNETNODES; j++)
+	{
 		if (!nodeconnected[j])
 		{
 			nodeconnected[j] = true;
 			return j;
 		}
+	}
 
 	/** \warning No free node? Just in case a node might not have been freed properly,
 	  *          look if there are connected nodes that aren't in game, and forget them.
@@ -812,7 +816,7 @@ static void SOCK_Send(void)
 static void SOCK_FreeNodenum(INT32 numnode)
 {
 	// can't disconnect from self :)
-	if (!numnode || numnode > MAXNETNODES)
+	if (numnode <= 0 || numnode > MAXNETNODES)
 		return;
 
 	DEBFILE(va("Free node %d (%s)\n", numnode, SOCK_GetNodeAddress(numnode)));
@@ -1432,14 +1436,12 @@ static void SOCK_RegisterHolePunch(void)
 
 static boolean SOCK_OpenSocket(void)
 {
-	size_t i;
-
-	memset(clientaddress, 0, sizeof (clientaddress));
+	memset(clientaddress, 0, sizeof(clientaddress));
 
+	memset(nodeconnected, false, sizeof(nodeconnected));
 	nodeconnected[0] = true; // always connected to self
-	for (i = 1; i < MAXNETNODES; i++)
-		nodeconnected[i] = false;
 	nodeconnected[BROADCASTADDR] = true;
+
 	I_NetSend = SOCK_Send;
 	I_NetGet = SOCK_Get;
 	I_NetCloseSocket = SOCK_CloseSocket;
@@ -1479,7 +1481,7 @@ static boolean SOCK_Ban(INT32 node)
 {
 	INT32 ban;
 
-	if (node > MAXNETNODES)
+	if (node < 0 || node > MAXNETNODES)
 		return false;
 
 	ban = numbans;

src/k_hud.c

@@ -931,21 +931,21 @@ const char *K_GetItemPatch(UINT8 item, boolean tiny)
 
 //}
 
-INT32 ITEM_X, ITEM_Y;	// Item Window
-INT32 TIME_X, TIME_Y;	// Time Sticker
-INT32 LAPS_X, LAPS_Y;	// Lap Sticker
-INT32 SPDM_X, SPDM_Y;	// Speedometer
-INT32 POSI_X, POSI_Y;	// Position Number
-INT32 FACE_X, FACE_Y;	// Top-four Faces
-INT32 STCD_X, STCD_Y;	// Starting countdown
-INT32 CHEK_Y;			// CHECK graphic
-INT32 MINI_X, MINI_Y;	// Minimap
-INT32 WANT_X, WANT_Y;	// Battle WANTED poster
+static INT32 ITEM_X, ITEM_Y;	// Item Window
+static INT32 TIME_X, TIME_Y;	// Time Sticker
+static INT32 LAPS_X, LAPS_Y;	// Lap Sticker
+static INT32 SPDM_X, SPDM_Y;	// Speedometer
+static INT32 POSI_X, POSI_Y;	// Position Number
+static INT32 FACE_X, FACE_Y;	// Top-four Faces
+static INT32 STCD_X, STCD_Y;	// Starting countdown
+static INT32 CHEK_Y;			// CHECK graphic
+static INT32 MINI_X, MINI_Y;	// Minimap
+static INT32 WANT_X, WANT_Y;	// Battle WANTED poster
 
 // This is for the P2 and P4 side of splitscreen. Then we'll flip P1's and P2's to the bottom with V_SPLITSCREEN.
-INT32 ITEM2_X, ITEM2_Y;
-INT32 LAPS2_X, LAPS2_Y;
-INT32 POSI2_X, POSI2_Y;
+static INT32 ITEM2_X, ITEM2_Y;
+static INT32 LAPS2_X, LAPS2_Y;
+static INT32 POSI2_X, POSI2_Y;
 
 static void K_initKartHUD(void)
 {
@@ -3816,7 +3816,7 @@ static void K_drawKartMinimap(void)
 
 		if (cv_showminimapangle.value && (minidoticon || minilighticon) && !playertimedout)
 		{
-			UINT8 *colormap;
+			UINT8 *colormap = NULL;
 			drawinfo_t dims;
 			fixed_t interpx, interpy;
 			fixed_t xoff = 0, yoff = 0;
@@ -3827,10 +3827,27 @@ static void K_drawKartMinimap(void)
 			if (encoremode)
 				ang = ANGLE_180 - ang;
 
-			if (mobj->colorized)
-				colormap = R_GetTranslationColormap(TC_RAINBOW, mobj->color, GTC_CACHE);
-			else
-				colormap = R_GetLocalTranslationColormap(mobj->skin, mobj->localskin, mobj->color, GTC_CACHE, mobj->skinlocal);
+			if (mobj->color)
+			{
+				if (mobj->colorized)
+				{
+					colormap = R_GetTranslationColormap(TC_RAINBOW, mobj->color, GTC_CACHE);
+				}
+				else
+				{
+					const INT32 skinnum = K_GetMobjLocalSkinNum(mobj->skin, mobj->localskin, mobj->skinlocal);
+
+					// special case if startcolor is not the default (160 / Green)
+					if (skinnum && skins[skinnum].starttranscolor != skins[0].starttranscolor)
+					{
+						colormap = R_GetTranslationColormap(TC_DEFAULT, mobj->color, GTC_CACHE);
+					}
+					else
+					{
+						colormap = R_GetLocalTranslationColormap(mobj->skin, mobj->localskin, mobj->color, GTC_CACHE, mobj->skinlocal);
+					}
+				}
+			}
 
 			interpx = lerp(mobj->old_x, mobj->x);
 			interpy = lerp(mobj->old_y, mobj->y);

src/k_kart.c

@@ -660,13 +660,22 @@ INT32 K_GetSkinNum(player_t *player)
 
 //
 // returns the mobj skinnumber
-// accounts for localskins
+// accounts for localskins ?
 //
 INT32 K_GetMobjSkinNum(const skin_t *skin, boolean local)
 {
 	return skin - K_GetSkinArray(local);
 }
 
+//
+// returns the mobj skinnumber
+// accounts for localskins
+//
+INT32 K_GetMobjLocalSkinNum(const skin_t *skin, const skin_t *localskin, boolean local)
+{
+	return localskin ? (localskin - K_GetSkinArray(local)) : (skin - skins);
+}
+
 //
 // returns the players skinnumber
 // accounts for localskins

src/m_menu.c

@@ -4016,16 +4016,16 @@ boolean replaynamesloaded = false;
 #ifdef HAVE_THREADS
 I_mutex replayquerymutex;
 
-// g_in_exiting_signal_handler is an evil hack
+// I_In_Exiting_Signal_Handler is an evil hack
 // 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 (!g_in_exiting_signal_handler) { I_lock_mutex(&replayquerymutex); }
-#  define Unlock_search_state()  if (!g_in_exiting_signal_handler) { I_unlock_mutex(replayquerymutex); }
-#else/*HAVE_THREADS*/
+#  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); }
+#else /*HAVE_THREADS*/
 #  define Lock_search_state()
 #  define Unlock_search_state()
-#endif/*HAVE_THREADS*/
+#endif /*HAVE_THREADS*/
 
 
 #define MAXREPLAYQUERY 37

src/mserv.c

@@ -262,6 +262,7 @@ Finish_registration (void)
 	{
 		CONS_Printf("\n");
 		CONS_Alert(CONS_NOTICE, "%s\n", rules);
+		free(rules);
 	}
 
 	if (registered)

src/p_inter.c

@@ -831,7 +831,7 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
 			{
 				S_StartSound(toucher, special->info->seesound);
 
-				if (player->pflags & PF_NIGHTSMODE)
+				if (UNLIKELY(player->pflags & PF_NIGHTSMODE))
 				{
 					player->bumpertime = TICRATE/2;
 					if (special->threshold > 0)
@@ -1131,7 +1131,7 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
 					S_StartSound(toucher, special->info->painsound);
 					return;
 				}
-				else if (((player->pflags & PF_NIGHTSMODE) && (player->pflags & PF_DRILLING)) || (player->pflags & (PF_JUMPED|PF_SPINNING|PF_GLIDING))
+				else if (UNLIKELY((player->pflags & PF_NIGHTSMODE) && (player->pflags & PF_DRILLING)) || (player->pflags & (PF_JUMPED|PF_SPINNING|PF_GLIDING))
 						|| player->powers[pw_invulnerability] || player->powers[pw_super]) // Do you possess the ability to subdue the object?
 				{
 					// Shatter the shield!

src/p_local.h

@@ -30,8 +30,6 @@ extern "C" {
 
 #define FLOATSPEED (FRACUNIT*4)
 
-//#define VIEWHEIGHTS "41"
-
 // Maximum player score.
 #define MAXSCORE 999999990
 
@@ -239,14 +237,10 @@ void P_InstaThrustEvenIn2D(mobj_t *mo, angle_t angle, fixed_t move);
 boolean P_LookForEnemies(player_t *player);
 void P_NukeEnemies(mobj_t *inflictor, mobj_t *source, fixed_t radius);
 void P_HomingAttack(mobj_t *source, mobj_t *enemy); /// \todo doesn't belong in p_user
-//boolean P_SuperReady(player_t *player);
 boolean P_AnalogMove(player_t *player);
-/*boolean P_TransferToNextMare(player_t *player);
-UINT8 P_FindLowestMare(void);*/
 UINT8 P_FindLowestLap(void);
 UINT8 P_FindHighestLap(void);
 void P_FindEmerald(void);
-//void P_TransferToAxis(player_t *player, INT32 axisnum);
 boolean P_PlayerMoving(INT32 pnum);
 void P_Telekinesis(player_t *player, fixed_t thrust, fixed_t range);
 

src/p_mobj.c

@@ -919,12 +919,7 @@ static void P_PlayerFlip(mobj_t *mo)
 	G_GhostAddFlip((INT32) (mo->player - players));
 	// Flip aiming to match!
 
-	if (UNLIKELY(mo->player->pflags & PF_NIGHTSMODE)) // NiGHTS doesn't use flipcam
-	{
-		if (mo->tracer)
-			mo->tracer->eflags ^= MFE_VERTICALFLIP;
-	}
-	else if (mo->player->pflags & PF_FLIPCAM)
+	if (mo->player->pflags & PF_FLIPCAM)
 	{
 		UINT8 i;
 
@@ -946,6 +941,11 @@ static void P_PlayerFlip(mobj_t *mo)
 				camera[i].z += FixedMul(20*FRACUNIT, mo->scale);
 		}
 	}
+	else if (UNLIKELY(mo->player->pflags & PF_NIGHTSMODE)) // NiGHTS doesn't use flipcam
+	{
+		if (mo->tracer)
+			mo->tracer->eflags ^= MFE_VERTICALFLIP;
+	}
 }
 
 //
@@ -3252,7 +3252,7 @@ void P_CalcChasePostImg(player_t *player, camera_t *thiscam)
 		player_flipcam = cv_flipcam[pnum].value;
 	}
 
-	const boolean flipcam = (player_flipcam && !(player->pflags & PF_NIGHTSMODE) && player->mo->eflags & MFE_VERTICALFLIP);
+	const boolean flipcam = (player_flipcam && player->mo->eflags & MFE_VERTICALFLIP && LIKELY(!(player->pflags & PF_NIGHTSMODE)));
 	UINT8 postimgtype = 0;
 
 	if (encoremode)
@@ -8553,7 +8553,7 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
 
 				if (mobj->tracer && mobj->tracer->player)
 				{
-					if (!(mobj->tracer->player->pflags & PF_NIGHTSMODE))
+					if (LIKELY(!(mobj->tracer->player->pflags & PF_NIGHTSMODE)))
 					{
 						mobj->flags &= ~MF_NOGRAVITY;
 						mobj->flags2 &= ~MF2_DONTDRAW;
@@ -8577,7 +8577,7 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
 						P_SetTarget(&mobj->target, NULL);
 					}
 
-					if (mobj->tracer->player->pflags & PF_NIGHTSMODE)
+					if (UNLIKELY(mobj->tracer->player->pflags & PF_NIGHTSMODE))
 					{
 						if (mobj->tracer->player->bonustime)
 						{

src/p_spec.c

@@ -4399,7 +4399,7 @@ static void P_RunSpecialSectorCheck(player_t *player, sector_t *sector)
 
 	// The list of specials that activate without floor touch
 	// Check Section 1
-	switch(GETSECSPECIAL(sector->special, 1))
+	switch (GETSECSPECIAL(sector->special, 1))
 	{
 		//case 2: // Damage (water)
 		case 8: // Instant kill
@@ -4410,7 +4410,7 @@ static void P_RunSpecialSectorCheck(player_t *player, sector_t *sector)
 	}
 
 	// Check Section 2
-	switch(GETSECSPECIAL(sector->special, 2))
+	switch (GETSECSPECIAL(sector->special, 2))
 	{
 		case 2: // Linedef executor (All players needed)
 		case 4: // Linedef executor
@@ -4421,7 +4421,7 @@ static void P_RunSpecialSectorCheck(player_t *player, sector_t *sector)
 	}
 
 	// Check Section 4
-	switch(GETSECSPECIAL(sector->special, 4))
+	switch (GETSECSPECIAL(sector->special, 4))
 	{
 		case 2: // Level Exit / GOAL Sector / Flag Return
 		case 1: // Starpost activator

src/p_user.c

@@ -4109,7 +4109,7 @@ boolean P_MoveChaseCamera(player_t *player, camera_t *thiscam, boolean resetcall
 			angle -= (angle - thiscam->pitch)/2;
 	}
 
-	if (player->playerstate != PST_DEAD && !((player->pflags & PF_NIGHTSMODE) && player->exiting))
+	if (player->playerstate != PST_DEAD && LIKELY(!((player->pflags & PF_NIGHTSMODE) && player->exiting)))
 		angle += (focusaiming < ANGLE_180 ? focusaiming/2 : InvAngle(InvAngle(focusaiming)/2)); // overcomplicated version of '((signed)focusaiming)/2;'
 
 	if (!camstill && !timeover) // Keep the view still...

src/r_draw.cpp

@@ -437,8 +437,7 @@ UINT8* R_GetTranslationColormap(INT32 skinnum, skincolors_t color, UINT8 flags)
 
 UINT8* R_GetLocalTranslationColormap(skin_t *skin, skin_t *localskin, skincolors_t color, UINT8 flags, boolean local)
 {
-	const INT32 skinnum = localskin ? (localskin - K_GetSkinArray(local)) : (skin - skins);
-	return RGetTranslationColormap(skinnum, color, flags, (localskin && local));
+	return RGetTranslationColormap(K_GetMobjLocalSkinNum(skin, localskin, local), color, flags, (localskin && local));
 }
 
 patch_t* R_GetSkinFaceRank(player_t* ply)

src/r_main.cpp

@@ -280,22 +280,22 @@ static void Fov_OnChange(void)
 
 static void FlipCam_OnChange(void)
 {
-	SendWeaponPref();
+	SendWeaponPref(0);
 }
 
 static void FlipCam2_OnChange(void)
 {
-	SendWeaponPref2();
+	SendWeaponPref(1);
 }
 
 static void FlipCam3_OnChange(void)
 {
-	SendWeaponPref3();
+	SendWeaponPref(2);
 }
 
 static void FlipCam4_OnChange(void)
 {
-	SendWeaponPref4();
+	SendWeaponPref(3);
 }
 
 static void Precipstuff_OnChange(void)

src/r_skins.h

@@ -92,6 +92,7 @@ INT32 R_LocalSkinAvailable(const char *name, boolean local);
 // had to move those here Zzz...
 INT32 K_GetSkinNum(player_t *player);
 INT32 K_GetMobjSkinNum(const skin_t *skin, boolean local);
+INT32 K_GetMobjLocalSkinNum(const skin_t *skin, const skin_t *localskin, boolean local);
 skin_t *K_GetPlayerSkin(player_t *player);
 skin_t *K_GetMobjSkin(const mobj_t *mobj);
 patch_t *K_GetFacePrefix(player_t *player, INT32 skinnum);

src/sdl/i_system.cpp

@@ -1577,7 +1577,7 @@ static void write_backtrace(bt_crash_reason_t reason)
 static std::thread::id g_main_thread_id;
 #endif
 
-boolean g_in_exiting_signal_handler = false;
+static volatile sig_atomic_t g_in_exiting_signal_handler = false;
 
 static void I_PrintSignal(INT32 signal_num, boolean core_dumped, char *signal_msg, char *signal_name)
 {
@@ -1712,6 +1712,11 @@ static void I_ReportSignal(int num, int coredumped)
 	I_ShowErrorBox(sigttl, sigmsg);
 }
 
+boolean I_In_Exiting_Signal_Handler(void)
+{
+	return g_in_exiting_signal_handler;
+}
+
 #ifndef NEWSIGNALHANDLER
 FUNCNORETURN static ATTRNORETURN void signal_handler(INT32 num)
 {
@@ -1741,21 +1746,17 @@ FUNCNORETURN static ATTRNORETURN void signal_handler(INT32 num)
 }
 #endif
 
-FUNCNORETURN static ATTRNORETURN void quit_handler(int num)
-{
-#ifdef HAVE_THREADS
-	if (g_main_thread_id != std::this_thread::get_id())
-	{
-		// Do not attempt any sort of recovery if this signal triggers off the main thread
-		signal(num, SIG_DFL);
-		raise(num);
-		exit(-2);
-	}
-#endif
+static volatile sig_atomic_t interrupted = false;
 
-	signal(num, SIG_DFL); //default signal action
-	raise(num);
-	I_Quit();
+boolean I_Interrupted(void)
+{
+	return interrupted;
+}
+
+static void quit_handler(int num)
+{
+	(void)num;
+	interrupted = true;
 }
 
 static void I_RegisterSignals(void)

src/sdl/i_video.c

@@ -2027,7 +2027,8 @@ void I_ShutdownGraphics(void)
 		SDL_DestroyWindow(window);
 	window = NULL;
 
-	SDL_QuitSubSystem(SDL_INIT_VIDEO);
+	if (SDL_WasInit(SDL_INIT_VIDEO) == SDL_INIT_VIDEO)
+		SDL_QuitSubSystem(SDL_INIT_VIDEO);
 	framebuffer = SDL_FALSE;
 }
 

src/sdl/mixer_sound.c

@@ -237,7 +237,8 @@ void I_ShutdownSound(void)
 	Mix_Quit();
 #endif
 
-	SDL_QuitSubSystem(SDL_INIT_AUDIO);
+	if (SDL_WasInit(SDL_INIT_AUDIO) == SDL_INIT_AUDIO)
+		SDL_QuitSubSystem(SDL_INIT_AUDIO);
 
 #ifdef HAVE_LIBGME
 	if (gme)