Added gcc option '-Wconversion'

No warnings for standard numerical types. Still pending alternative
numerical types.

44 files changed, 398 insertions, 359 deletions

diff --git a/lapi.c b/lapi.c
index a9ab1d08..1f4e9f96 100644
--- a/lapi.c
+++ b/lapi.c
@@ -58,7 +58,7 @@ static void advancegc (lua_State *L, size_t delta) {
   delta >>= 5;  /* one object for each 32 bytes (empirical) */
   if (delta > 0) {
     global_State *g = G(L);
-    luaE_setdebt(g, g->GCdebt - delta);
+    luaE_setdebt(g, g->GCdebt - cast(l_obj, delta));
   }
 }
 
@@ -437,9 +437,9 @@ LUA_API const char *lua_tolstring (lua_State *L, int idx, size_t *len) {
 LUA_API lua_Unsigned lua_rawlen (lua_State *L, int idx) {
   const TValue *o = index2value(L, idx);
   switch (ttypetag(o)) {
-    case LUA_VSHRSTR: return tsvalue(o)->shrlen;
-    case LUA_VLNGSTR: return tsvalue(o)->u.lnglen;
-    case LUA_VUSERDATA: return uvalue(o)->len;
+    case LUA_VSHRSTR: return cast(lua_Unsigned, tsvalue(o)->shrlen);
+    case LUA_VLNGSTR: return cast(lua_Unsigned, tsvalue(o)->u.lnglen);
+    case LUA_VUSERDATA: return cast(lua_Unsigned, uvalue(o)->len);
     case LUA_VTABLE: return luaH_getn(hvalue(o));
     default: return 0;
   }
@@ -667,7 +667,7 @@ LUA_API int lua_pushthread (lua_State *L) {
 
 
 static int auxgetstr (lua_State *L, const TValue *t, const char *k) {
-  int tag;
+  lu_byte tag;
   TString *str = luaS_new(L, k);
   luaV_fastget(t, str, s2v(L->top.p), luaH_getstr, tag);
   if (!tagisempty(tag)) {
@@ -685,7 +685,7 @@ static int auxgetstr (lua_State *L, const TValue *t, const char *k) {
 
 static void getGlobalTable (lua_State *L, TValue *gt) {
   Table *registry = hvalue(&G(L)->l_registry);
-  int tag = luaH_getint(registry, LUA_RIDX_GLOBALS, gt);
+  lu_byte tag = luaH_getint(registry, LUA_RIDX_GLOBALS, gt);
   (void)tag;  /* avoid not-used warnings when checks are off */
   api_check(L, novariant(tag) == LUA_TTABLE, "global table must exist");
 }
@@ -700,7 +700,7 @@ LUA_API int lua_getglobal (lua_State *L, const char *name) {
 
 
 LUA_API int lua_gettable (lua_State *L, int idx) {
-  int tag;
+  lu_byte tag;
   TValue *t;
   lua_lock(L);
   api_checkpop(L, 1);
@@ -721,7 +721,7 @@ LUA_API int lua_getfield (lua_State *L, int idx, const char *k) {
 
 LUA_API int lua_geti (lua_State *L, int idx, lua_Integer n) {
   TValue *t;
-  int tag;
+  lu_byte tag;
   lua_lock(L);
   t = index2value(L, idx);
   luaV_fastgeti(t, n, s2v(L->top.p), tag);
@@ -736,7 +736,7 @@ LUA_API int lua_geti (lua_State *L, int idx, lua_Integer n) {
 }
 
 
-static int finishrawget (lua_State *L, int tag) {
+static int finishrawget (lua_State *L, lu_byte tag) {
   if (tagisempty(tag))  /* avoid copying empty items to the stack */
     setnilvalue(s2v(L->top.p));
   api_incr_top(L);
@@ -754,7 +754,7 @@ l_sinline Table *gettable (lua_State *L, int idx) {
 
 LUA_API int lua_rawget (lua_State *L, int idx) {
   Table *t;
-  int tag;
+  lu_byte tag;
   lua_lock(L);
   api_checkpop(L, 1);
   t = gettable(L, idx);
@@ -766,7 +766,7 @@ LUA_API int lua_rawget (lua_State *L, int idx) {
 
 LUA_API int lua_rawgeti (lua_State *L, int idx, lua_Integer n) {
   Table *t;
-  int tag;
+  lu_byte tag;
   lua_lock(L);
   t = gettable(L, idx);
   luaH_fastgeti(t, n, s2v(L->top.p), tag);
@@ -1231,7 +1231,7 @@ LUA_API int lua_gc (lua_State *L, int what, ...) {
       api_check(L, 0 <= param && param < LUA_GCPN, "invalid parameter");
       res = cast_int(luaO_applyparam(g->gcparams[param], 100));
       if (value >= 0)
-        g->gcparams[param] = luaO_codeparam(value);
+        g->gcparams[param] = luaO_codeparam(cast_uint(value));
       break;
     }
     default: res = -1;  /* invalid option */
@@ -1353,7 +1353,7 @@ LUA_API void *lua_newuserdatauv (lua_State *L, size_t size, int nuvalue) {
   Udata *u;
   lua_lock(L);
   api_check(L, 0 <= nuvalue && nuvalue < USHRT_MAX, "invalid value");
-  u = luaS_newudata(L, size, nuvalue);
+  u = luaS_newudata(L, size, cast(unsigned short, nuvalue));
   setuvalue(L, s2v(L->top.p), u);
   api_incr_top(L);
   advancegc(L, size);
diff --git a/lauxlib.c b/lauxlib.c
index 5aeec55f..b70b7ae6 100644
--- a/lauxlib.c
+++ b/lauxlib.c
@@ -539,7 +539,7 @@ static void newbox (lua_State *L) {
 static size_t newbuffsize (luaL_Buffer *B, size_t sz) {
   size_t newsize = (B->size / 2) * 3;  /* buffer size * 1.5 */
   if (l_unlikely(sz > MAX_SIZE - B->n - 1))
-    return luaL_error(B->L, "resulting string too large");
+    return cast_sizet(luaL_error(B->L, "resulting string too large"));
   if (newsize < B->n + sz + 1 || newsize > MAX_SIZE) {
     /* newsize was not big enough or too big */
     newsize = B->n + sz + 1;
@@ -725,7 +725,7 @@ LUALIB_API void luaL_unref (lua_State *L, int t, int ref) {
 */
 
 typedef struct LoadF {
-  int n;  /* number of pre-read characters */
+  unsigned n;  /* number of pre-read characters */
   FILE *f;  /* file being read */
   char buff[BUFSIZ];  /* area for reading file */
 } LoadF;
@@ -825,7 +825,7 @@ LUALIB_API int luaL_loadfilex (lua_State *L, const char *filename,
     }
   }
   if (c != EOF)
-    lf.buff[lf.n++] = c;  /* 'c' is the first character of the stream */
+    lf.buff[lf.n++] = cast_char(c);  /* 'c' is the first character */
   status = lua_load(L, getF, &lf, lua_tostring(L, -1), mode);
   readstatus = ferror(lf.f);
   errno = 0;  /* no useful error number until here */
@@ -1020,7 +1020,7 @@ LUALIB_API void luaL_addgsub (luaL_Buffer *b, const char *s,
   const char *wild;
   size_t l = strlen(p);
   while ((wild = strstr(s, p)) != NULL) {
-    luaL_addlstring(b, s, wild - s);  /* push prefix */
+    luaL_addlstring(b, s, ct_diff2sz(wild - s));  /* push prefix */
     luaL_addstring(b, r);  /* push replacement in place of pattern */
     s = wild + l;  /* continue after 'p' */
   }
diff --git a/lbaselib.c b/lbaselib.c
index 8b034340..a7b6c3ed 100644
--- a/lbaselib.c
+++ b/lbaselib.c
@@ -58,21 +58,22 @@ static int luaB_warn (lua_State *L) {
 
 #define SPACECHARS      " \f\n\r\t\v"
 
-static const char *b_str2int (const char *s, int base, lua_Integer *pn) {
+static const char *b_str2int (const char *s, unsigned base, lua_Integer *pn) {
   lua_Unsigned n = 0;
   int neg = 0;
   s += strspn(s, SPACECHARS);  /* skip initial spaces */
   if (*s == '-') { s++; neg = 1; }  /* handle sign */
   else if (*s == '+') s++;
-  if (!isalnum((unsigned char)*s))  /* no digit? */
+  if (!isalnum(cast_uchar(*s)))  /* no digit? */
     return NULL;
   do {
-    int digit = (isdigit((unsigned char)*s)) ? *s - '0'
-                   : (toupper((unsigned char)*s) - 'A') + 10;
+    unsigned digit = cast_uint(isdigit(cast_uchar(*s))
+                               ? *s - '0'
+                               : (toupper(cast_uchar(*s)) - 'A') + 10);
     if (digit >= base) return NULL;  /* invalid numeral */
     n = n * base + digit;
     s++;
-  } while (isalnum((unsigned char)*s));
+  } while (isalnum(cast_uchar(*s)));
   s += strspn(s, SPACECHARS);  /* skip trailing spaces */
   *pn = (lua_Integer)((neg) ? (0u - n) : n);
   return s;
@@ -102,7 +103,7 @@ static int luaB_tonumber (lua_State *L) {
     luaL_checktype(L, 1, LUA_TSTRING);  /* no numbers as strings */
     s = lua_tolstring(L, 1, &l);
     luaL_argcheck(L, 2 <= base && base <= 36, 2, "base out of range");
-    if (b_str2int(s, (int)base, &n) == s + l) {
+    if (b_str2int(s, cast_uint(base), &n) == s + l) {
       lua_pushinteger(L, n);
       return 1;
     }  /* else not a number */
@@ -159,7 +160,7 @@ static int luaB_rawlen (lua_State *L) {
   int t = lua_type(L, 1);
   luaL_argexpected(L, t == LUA_TTABLE || t == LUA_TSTRING, 1,
                       "table or string");
-  lua_pushinteger(L, lua_rawlen(L, 1));
+  lua_pushinteger(L, l_castU2S(lua_rawlen(L, 1)));
   return 1;
 }
 
diff --git a/lcode.c b/lcode.c
index 0799306e..47e5424e 100644
--- a/lcode.c
+++ b/lcode.c
@@ -335,7 +335,7 @@ static void savelineinfo (FuncState *fs, Proto *f, int line) {
   }
   luaM_growvector(fs->ls->L, f->lineinfo, pc, f->sizelineinfo, ls_byte,
                   INT_MAX, "opcodes");
-  f->lineinfo[pc] = linedif;
+  f->lineinfo[pc] = cast(ls_byte, linedif);
   fs->previousline = line;  /* last line saved */
 }
 
@@ -409,7 +409,7 @@ int luaK_codevABCk (FuncState *fs, OpCode o, int A, int B, int C, int k) {
 /*
 ** Format and emit an 'iABx' instruction.
 */
-int luaK_codeABx (FuncState *fs, OpCode o, int A, unsigned int Bc) {
+int luaK_codeABx (FuncState *fs, OpCode o, int A, int Bc) {
   lua_assert(getOpMode(o) == iABx);
   lua_assert(A <= MAXARG_A && Bc <= MAXARG_Bx);
   return luaK_code(fs, CREATE_ABx(o, A, Bc));
@@ -420,7 +420,7 @@ int luaK_codeABx (FuncState *fs, OpCode o, int A, unsigned int Bc) {
 ** Format and emit an 'iAsBx' instruction.
 */
 static int codeAsBx (FuncState *fs, OpCode o, int A, int Bc) {
-  unsigned int b = cast_uint(Bc) + OFFSET_sBx;
+  int b = Bc + OFFSET_sBx;
   lua_assert(getOpMode(o) == iAsBx);
   lua_assert(A <= MAXARG_A && b <= MAXARG_Bx);
   return luaK_code(fs, CREATE_ABx(o, A, b));
@@ -431,7 +431,7 @@ static int codeAsBx (FuncState *fs, OpCode o, int A, int Bc) {
 ** Format and emit an 'isJ' instruction.
 */
 static int codesJ (FuncState *fs, OpCode o, int sj, int k) {
-  unsigned int j = cast_uint(sj) + OFFSET_sJ;
+  int j = sj + OFFSET_sJ;
   lua_assert(getOpMode(o) == isJ);
   lua_assert(j <= MAXARG_sJ && (k & ~1) == 0);
   return luaK_code(fs, CREATE_sJ(o, j, k));
@@ -483,7 +483,7 @@ void luaK_checkstack (FuncState *fs, int n) {
 */
 void luaK_reserveregs (FuncState *fs, int n) {
   luaK_checkstack(fs, n);
-  fs->freereg += n;
+  fs->freereg =  cast_byte(fs->freereg + n);
 }
 
 
@@ -1290,25 +1290,25 @@ void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k) {
   if (t->k == VUPVAL && !isKstr(fs, k))  /* upvalue indexed by non 'Kstr'? */
     luaK_exp2anyreg(fs, t);  /* put it in a register */
   if (t->k == VUPVAL) {
-    int temp = t->u.info;  /* upvalue index */
+    lu_byte temp = cast_byte(t->u.info);  /* upvalue index */
     lua_assert(isKstr(fs, k));
     t->u.ind.t = temp;  /* (can't do a direct assignment; values overlap) */
-    t->u.ind.idx = k->u.info;  /* literal short string */
+    t->u.ind.idx = cast(short, k->u.info);  /* literal short string */
     t->k = VINDEXUP;
   }
   else {
     /* register index of the table */
-    t->u.ind.t = (t->k == VLOCAL) ? t->u.var.ridx: t->u.info;
+    t->u.ind.t = cast_byte((t->k == VLOCAL) ? t->u.var.ridx: t->u.info);
     if (isKstr(fs, k)) {
-      t->u.ind.idx = k->u.info;  /* literal short string */
+      t->u.ind.idx = cast(short, k->u.info);  /* literal short string */
       t->k = VINDEXSTR;
     }
-    else if (isCint(k)) {
-      t->u.ind.idx = cast_int(k->u.ival);  /* int. constant in proper range */
+    else if (isCint(k)) {  /* int. constant in proper range? */
+      t->u.ind.idx = cast(short, k->u.ival);
       t->k = VINDEXI;
     }
     else {
-      t->u.ind.idx = luaK_exp2anyreg(fs, k);  /* register */
+      t->u.ind.idx = cast(short, luaK_exp2anyreg(fs, k));  /* register */
       t->k = VINDEXED;
     }
   }
@@ -1623,7 +1623,7 @@ void luaK_prefix (FuncState *fs, UnOpr opr, expdesc *e, int line) {
   luaK_dischargevars(fs, e);
   switch (opr) {
     case OPR_MINUS: case OPR_BNOT:  /* use 'ef' as fake 2nd operand */
-      if (constfolding(fs, opr + LUA_OPUNM, e, &ef))
+      if (constfolding(fs, cast_int(opr + LUA_OPUNM), e, &ef))
         break;
       /* else */ /* FALLTHROUGH */
     case OPR_LEN:
@@ -1711,7 +1711,7 @@ static void codeconcat (FuncState *fs, expdesc *e1, expdesc *e2, int line) {
 void luaK_posfix (FuncState *fs, BinOpr opr,
                   expdesc *e1, expdesc *e2, int line) {
   luaK_dischargevars(fs, e2);
-  if (foldbinop(opr) && constfolding(fs, opr + LUA_OPADD, e1, e2))
+  if (foldbinop(opr) && constfolding(fs, cast_int(opr + LUA_OPADD), e1, e2))
     return;  /* done by folding */
   switch (opr) {
     case OPR_AND: {
@@ -1797,11 +1797,11 @@ void luaK_fixline (FuncState *fs, int line) {
 
 void luaK_settablesize (FuncState *fs, int pc, int ra, int asize, int hsize) {
   Instruction *inst = &fs->f->code[pc];
-  int rb = (hsize != 0) ? luaO_ceillog2(hsize) + 1 : 0;  /* hash size */
   int extra = asize / (MAXARG_vC + 1);  /* higher bits of array size */
   int rc = asize % (MAXARG_vC + 1);  /* lower bits of array size */
   int k = (extra > 0);  /* true iff needs extra argument */
-  *inst = CREATE_vABCk(OP_NEWTABLE, ra, rb, rc, k);
+  hsize = (hsize != 0) ? luaO_ceillog2(cast_uint(hsize)) + 1 : 0;
+  *inst = CREATE_vABCk(OP_NEWTABLE, ra, hsize, rc, k);
   *(inst + 1) = CREATE_Ax(OP_EXTRAARG, extra);
 }
 
@@ -1825,7 +1825,7 @@ void luaK_setlist (FuncState *fs, int base, int nelems, int tostore) {
     luaK_codevABCk(fs, OP_SETLIST, base, tostore, nelems, 1);
     codeextraarg(fs, extra);
   }
-  fs->freereg = base + 1;  /* free registers with list values */
+  fs->freereg = cast_byte(base + 1);  /* free registers with list values */
 }
 
 
diff --git a/lcode.h b/lcode.h
index c1f16da0..414ebe39 100644
--- a/lcode.h
+++ b/lcode.h
@@ -60,7 +60,7 @@ typedef enum UnOpr { OPR_MINUS, OPR_BNOT, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr;
 #define luaK_jumpto(fs,t)       luaK_patchlist(fs, luaK_jump(fs), t)
 
 LUAI_FUNC int luaK_code (FuncState *fs, Instruction i);
-LUAI_FUNC int luaK_codeABx (FuncState *fs, OpCode o, int A, unsigned Bx);
+LUAI_FUNC int luaK_codeABx (FuncState *fs, OpCode o, int A, int Bx);
 LUAI_FUNC int luaK_codeABCk (FuncState *fs, OpCode o, int A, int B, int C,
                                             int k);
 LUAI_FUNC int luaK_codevABCk (FuncState *fs, OpCode o, int A, int B, int C,
diff --git a/ldebug.c b/ldebug.c
index 1c8b57c8..a3a536bb 100644
--- a/ldebug.c
+++ b/ldebug.c
@@ -63,7 +63,7 @@ static int getbaseline (const Proto *f, int pc, int *basepc) {
     return f->linedefined;
   }
   else {
-    int i = cast_uint(pc) / MAXIWTHABS - 1;  /* get an estimate */
+    int i = pc / MAXIWTHABS - 1;  /* get an estimate */
     /* estimate must be a lower bound of the correct base */
     lua_assert(i < 0 ||
               (i < f->sizeabslineinfo && f->abslineinfo[i].pc <= pc));
@@ -921,7 +921,7 @@ int luaG_tracecall (lua_State *L) {
 */
 int luaG_traceexec (lua_State *L, const Instruction *pc) {
   CallInfo *ci = L->ci;
-  lu_byte mask = L->hookmask;
+  lu_byte mask = cast_byte(L->hookmask);
   const Proto *p = ci_func(ci)->p;
   int counthook;
   if (!(mask & (LUA_MASKLINE | LUA_MASKCOUNT))) {  /* no hooks? */
diff --git a/ldo.c b/ldo.c
index 933a55bf..1d1b7a71 100644
--- a/ldo.c
+++ b/ldo.c
@@ -241,7 +241,7 @@ int luaD_reallocstack (lua_State *L, int newsize, int raiseerror) {
   int oldsize = stacksize(L);
   int i;
   StkId newstack;
-  int oldgcstop = G(L)->gcstopem;
+  lu_byte oldgcstop = G(L)->gcstopem;
   lua_assert(newsize <= MAXSTACK || newsize == ERRORSTACKSIZE);
   relstack(L);  /* change pointers to offsets */
   G(L)->gcstopem = 1;  /* stop emergency collection */
@@ -357,7 +357,7 @@ void luaD_hook (lua_State *L, int event, int line,
                               int ftransfer, int ntransfer) {
   lua_Hook hook = L->hook;
   if (hook && L->allowhook) {  /* make sure there is a hook */
-    int mask = CIST_HOOKED;
+    unsigned mask = CIST_HOOKED;
     CallInfo *ci = L->ci;
     ptrdiff_t top = savestack(L, L->top.p);  /* preserve original 'top' */
     ptrdiff_t ci_top = savestack(L, ci->top.p);  /* idem for 'ci->top' */
@@ -1058,9 +1058,9 @@ int luaD_protectedparser (lua_State *L, ZIO *z, const char *name,
   luaZ_initbuffer(L, &p.buff);
   status = luaD_pcall(L, f_parser, &p, savestack(L, L->top.p), L->errfunc);
   luaZ_freebuffer(L, &p.buff);
-  luaM_freearray(L, p.dyd.actvar.arr, p.dyd.actvar.size);
-  luaM_freearray(L, p.dyd.gt.arr, p.dyd.gt.size);
-  luaM_freearray(L, p.dyd.label.arr, p.dyd.label.size);
+  luaM_freearray(L, p.dyd.actvar.arr, cast_sizet(p.dyd.actvar.size));
+  luaM_freearray(L, p.dyd.gt.arr, cast_sizet(p.dyd.gt.size));
+  luaM_freearray(L, p.dyd.label.arr, cast_sizet(p.dyd.label.size));
   decnny(L);
   return status;
 }
diff --git a/ldump.c b/ldump.c
index a1e09856..71d9a5b1 100644
--- a/ldump.c
+++ b/ldump.c
@@ -27,7 +27,7 @@ typedef struct {
   lua_State *L;
   lua_Writer writer;
   void *data;
-  lu_mem offset;  /* current position relative to beginning of dump */
+  size_t offset;  /* current position relative to beginning of dump */
   int strip;
   int status;
   Table *h;  /* table to track saved strings */
@@ -63,11 +63,11 @@ static void dumpBlock (DumpState *D, const void *b, size_t size) {
 ** Dump enough zeros to ensure that current position is a multiple of
 ** 'align'.
 */
-static void dumpAlign (DumpState *D, int align) {
-  int padding = align - (D->offset % align);
+static void dumpAlign (DumpState *D, unsigned align) {
+  unsigned padding = align - cast_uint(D->offset % align);
   if (padding < align) {  /* padding == align means no padding */
     static lua_Integer paddingContent = 0;
-    lua_assert(cast_uint(align) <= sizeof(lua_Integer));
+    lua_assert(align <= sizeof(lua_Integer));
     dumpBlock(D, &paddingContent, padding);
   }
   lua_assert(D->offset % align == 0);
@@ -94,10 +94,10 @@ static void dumpByte (DumpState *D, int y) {
 */
 static void dumpVarint (DumpState *D, size_t x) {
   lu_byte buff[DIBS];
-  int n = 1;
+  unsigned n = 1;
   buff[DIBS - 1] = x & 0x7f;  /* fill least-significant byte */
   while ((x >>= 7) != 0)  /* fill other bytes in reverse order */
-    buff[DIBS - (++n)] = (x & 0x7f) | 0x80;
+    buff[DIBS - (++n)] = cast_byte((x & 0x7f) | 0x80);
   dumpVector(D, buff + DIBS - n, n);
 }
 
@@ -159,7 +159,7 @@ static void dumpCode (DumpState *D, const Proto *f) {
   dumpInt(D, f->sizecode);
   dumpAlign(D, sizeof(f->code[0]));
   lua_assert(f->code != NULL);
-  dumpVector(D, f->code, f->sizecode);
+  dumpVector(D, f->code, cast_uint(f->sizecode));
 }
 
 
@@ -216,13 +216,13 @@ static void dumpDebug (DumpState *D, const Proto *f) {
   n = (D->strip) ? 0 : f->sizelineinfo;
   dumpInt(D, n);
   if (f->lineinfo != NULL)
-    dumpVector(D, f->lineinfo, n);
+    dumpVector(D, f->lineinfo, cast_uint(n));
   n = (D->strip) ? 0 : f->sizeabslineinfo;
   dumpInt(D, n);
   if (n > 0) {
     /* 'abslineinfo' is an array of structures of int's */
     dumpAlign(D, sizeof(int));
-    dumpVector(D, f->abslineinfo, n);
+    dumpVector(D, f->abslineinfo, cast_uint(n));
   }
   n = (D->strip) ? 0 : f->sizelocvars;
   dumpInt(D, n);
diff --git a/lfunc.c b/lfunc.c
index d63d05fc..d650c000 100644
--- a/lfunc.c
+++ b/lfunc.c
@@ -266,14 +266,14 @@ Proto *luaF_newproto (lua_State *L) {
 
 void luaF_freeproto (lua_State *L, Proto *f) {
   if (!(f->flag & PF_FIXED)) {
-    luaM_freearray(L, f->code, f->sizecode);
-    luaM_freearray(L, f->lineinfo, f->sizelineinfo);
-    luaM_freearray(L, f->abslineinfo, f->sizeabslineinfo);
+    luaM_freearray(L, f->code, cast_sizet(f->sizecode));
+    luaM_freearray(L, f->lineinfo, cast_sizet(f->sizelineinfo));
+    luaM_freearray(L, f->abslineinfo, cast_sizet(f->sizeabslineinfo));
   }
-  luaM_freearray(L, f->p, f->sizep);
-  luaM_freearray(L, f->k, f->sizek);
-  luaM_freearray(L, f->locvars, f->sizelocvars);
-  luaM_freearray(L, f->upvalues, f->sizeupvalues);
+  luaM_freearray(L, f->p, cast_sizet(f->sizep));
+  luaM_freearray(L, f->k, cast_sizet(f->sizek));
+  luaM_freearray(L, f->locvars, cast_sizet(f->sizelocvars));
+  luaM_freearray(L, f->upvalues, cast_sizet(f->sizeupvalues));
   luaM_free(L, f);
 }
 
diff --git a/lfunc.h b/lfunc.h
index 3be265ef..162b55ec 100644
--- a/lfunc.h
+++ b/lfunc.h
@@ -11,11 +11,11 @@
 #include "lobject.h"
 
 
-#define sizeCclosure(n) (cast_int(offsetof(CClosure, upvalue)) + \
-                         cast_int(sizeof(TValue)) * (n))
+#define sizeCclosure(n)  \
+        (offsetof(CClosure, upvalue) + sizeof(TValue) * cast_uint(n))
 
-#define sizeLclosure(n) (cast_int(offsetof(LClosure, upvals)) + \
-                         cast_int(sizeof(TValue *)) * (n))
+#define sizeLclosure(n)  \
+        (offsetof(LClosure, upvals) + sizeof(TValue *) * cast_uint(n))
 
 
 /* test whether thread is in 'twups' list */
diff --git a/lgc.c b/lgc.c
index 0ad3a16f..93d2249b 100644
--- a/lgc.c
+++ b/lgc.c
@@ -246,7 +246,7 @@ void luaC_fix (lua_State *L, GCObject *o) {
 ** create a new collectable object (with given type, size, and offset)
 ** and link it to 'allgc' list.
 */
-GCObject *luaC_newobjdt (lua_State *L, int tt, size_t sz, size_t offset) {
+GCObject *luaC_newobjdt (lua_State *L, lu_byte tt, size_t sz, size_t offset) {
   global_State *g = G(L);
   char *p = cast_charp(luaM_newobject(L, novariant(tt), sz));
   GCObject *o = cast(GCObject *, p + offset);
@@ -262,7 +262,7 @@ GCObject *luaC_newobjdt (lua_State *L, int tt, size_t sz, size_t offset) {
 /*
 ** create a new collectable object with no offset.
 */
-GCObject *luaC_newobj (lua_State *L, int tt, size_t sz) {
+GCObject *luaC_newobj (lua_State *L, lu_byte tt, size_t sz) {
   return luaC_newobjdt(L, tt, sz, 0);
 }
 
@@ -813,7 +813,7 @@ static void freeobj (lua_State *L, GCObject *o) {
     case LUA_VSHRSTR: {
       TString *ts = gco2ts(o);
       luaS_remove(L, ts);  /* remove it from hash table */
-      luaM_freemem(L, ts, sizestrshr(ts->shrlen));
+      luaM_freemem(L, ts, sizestrshr(cast_uint(ts->shrlen)));
       break;
     }
     case LUA_VLNGSTR: {
@@ -922,7 +922,7 @@ static void GCTM (lua_State *L) {
   if (!notm(tm)) {  /* is there a finalizer? */
     int status;
     lu_byte oldah = L->allowhook;
-    int oldgcstp  = g->gcstp;
+    lu_byte oldgcstp  = g->gcstp;
     g->gcstp |= GCSTPGC;  /* avoid GC steps */
     L->allowhook = 0;  /* stop debug hooks during GC metamethod */
     setobj2s(L, L->top.p++, tm);  /* push finalizer... */
@@ -1235,7 +1235,7 @@ static void finishgencycle (lua_State *L, global_State *g) {
 ** the "sweep all" state to clear all objects, which are mostly black
 ** in generational mode.
 */
-static void minor2inc (lua_State *L, global_State *g, int kind) {
+static void minor2inc (lua_State *L, global_State *g, lu_byte kind) {
   g->GCmajorminor = g->marked;  /* number of live objects */
   g->gckind = kind;
   g->reallyold = g->old1 = g->survival = NULL;
@@ -1522,7 +1522,7 @@ static l_obj atomic (lua_State *L) {
 ** elements. The fast case sweeps the whole list.
 */
 static void sweepstep (lua_State *L, global_State *g,
-                       int nextstate, GCObject **nextlist, int fast) {
+                       lu_byte nextstate, GCObject **nextlist, int fast) {
   if (g->sweepgc)
     g->sweepgc = sweeplist(L, g->sweepgc, fast ? MAX_LOBJ : GCSWEEPMAX);
   else {  /* enter next state */
@@ -1706,7 +1706,7 @@ static void fullinc (lua_State *L, global_State *g) {
 void luaC_fullgc (lua_State *L, int isemergency) {
   global_State *g = G(L);
   lua_assert(!g->gcemergency);
-  g->gcemergency = isemergency;  /* set flag */
+  g->gcemergency = cast_byte(isemergency);  /* set flag */
   switch (g->gckind) {
     case KGC_GENMINOR: fullgen(L, g); break;
     case KGC_INC: fullinc(L, g); break;
diff --git a/lgc.h b/lgc.h
index 5b71ddb9..a30755d0 100644
--- a/lgc.h
+++ b/lgc.h
@@ -245,8 +245,8 @@ LUAI_FUNC void luaC_freeallobjects (lua_State *L);
 LUAI_FUNC void luaC_step (lua_State *L);
 LUAI_FUNC void luaC_runtilstate (lua_State *L, int state, int fast);
 LUAI_FUNC void luaC_fullgc (lua_State *L, int isemergency);
-LUAI_FUNC GCObject *luaC_newobj (lua_State *L, int tt, size_t sz);
-LUAI_FUNC GCObject *luaC_newobjdt (lua_State *L, int tt, size_t sz,
+LUAI_FUNC GCObject *luaC_newobj (lua_State *L, lu_byte tt, size_t sz);
+LUAI_FUNC GCObject *luaC_newobjdt (lua_State *L, lu_byte tt, size_t sz,
                                                  size_t offset);
 LUAI_FUNC void luaC_barrier_ (lua_State *L, GCObject *o, GCObject *v);
 LUAI_FUNC void luaC_barrierback_ (lua_State *L, GCObject *o);
diff --git a/liolib.c b/liolib.c
index 4349f860..17522bb2 100644
--- a/liolib.c
+++ b/liolib.c
@@ -443,7 +443,7 @@ static int nextc (RN *rn) {
     return 0;  /* fail */
   }
   else {
-    rn->buff[rn->n++] = rn->c;  /* save current char */
+    rn->buff[rn->n++] = cast_char(rn->c);  /* save current char */
     rn->c = l_getc(rn->f);  /* read next one */
     return 1;
   }
@@ -524,15 +524,15 @@ static int read_line (lua_State *L, FILE *f, int chop) {
   luaL_buffinit(L, &b);
   do {  /* may need to read several chunks to get whole line */
     char *buff = luaL_prepbuffer(&b);  /* preallocate buffer space */
-    int i = 0;
+    unsigned i = 0;
     l_lockfile(f);  /* no memory errors can happen inside the lock */
     while (i < LUAL_BUFFERSIZE && (c = l_getc(f)) != EOF && c != '\n')
-      buff[i++] = c;  /* read up to end of line or buffer limit */
+      buff[i++] = cast_char(c);  /* read up to end of line or buffer limit */
     l_unlockfile(f);
     luaL_addsize(&b, i);
   } while (c != EOF && c != '\n');  /* repeat until end of line */
   if (!chop && c == '\n')  /* want a newline and have one? */
-    luaL_addchar(&b, c);  /* add ending newline to result */
+    luaL_addchar(&b, '\n');  /* add ending newline to result */
   luaL_pushresult(&b);  /* close buffer */
   /* return ok if read something (either a newline or something else) */
   return (c == '\n' || lua_rawlen(L, -1) > 0);
diff --git a/llex.c b/llex.c
index 3446f4e0..b2e77c9c 100644
--- a/llex.c
+++ b/llex.c
@@ -350,7 +350,7 @@ static unsigned long readutf8esc (LexState *ls) {
   int i = 4;  /* chars to be removed: '\', 'u', '{', and first digit */
   save_and_next(ls);  /* skip 'u' */
   esccheck(ls, ls->current == '{', "missing '{'");
-  r = gethexa(ls);  /* must have at least one digit */
+  r = cast_ulong(gethexa(ls));  /* must have at least one digit */
   while (cast_void(save_and_next(ls)), lisxdigit(ls->current)) {
     i++;
     esccheck(ls, r <= (0x7FFFFFFFu >> 4), "UTF-8 value too large");
diff --git a/llimits.h b/llimits.h
index 0f3a8ecd..e7da009b 100644
--- a/llimits.h
+++ b/llimits.h
@@ -130,6 +130,7 @@ typedef LUAI_UACINT l_uacInt;
 #define cast_num(i)     cast(lua_Number, (i))
 #define cast_int(i)     cast(int, (i))
 #define cast_uint(i)    cast(unsigned int, (i))
+#define cast_ulong(i)   cast(unsigned long, (i))
 #define cast_byte(i)    cast(lu_byte, (i))
 #define cast_uchar(i)   cast(unsigned char, (i))
 #define cast_char(i)    cast(char, (i))
@@ -151,6 +152,16 @@ typedef LUAI_UACINT l_uacInt;
 #define l_castU2S(i)    ((lua_Integer)(i))
 #endif
 
+/*
+** cast a size_t to lua_Integer: These casts are always valid for
+** sizes of Lua objects (see MAX_SIZE)
+*/
+#define cast_st2S(sz)   ((lua_Integer)(sz))
+
+/* Cast a ptrdiff_t to size_t, when it is known that the minuend
+** comes from the subtraend (the base)
+*/
+#define ct_diff2sz(df)  ((size_t)(df))
 
 /*
 ** Special type equivalent to '(void*)' for functions (to suppress some
diff --git a/lmathlib.c b/lmathlib.c
index 2bdcb637..f8b24d1d 100644
--- a/lmathlib.c
+++ b/lmathlib.c
@@ -578,7 +578,7 @@ static int math_random (lua_State *L) {
       low = 1;
       up = luaL_checkinteger(L, 1);
       if (up == 0) {  /* single 0 as argument? */
-        lua_pushinteger(L, I2UInt(rv));  /* full random integer */
+        lua_pushinteger(L, l_castU2S(I2UInt(rv)));  /* full random integer */
         return 1;
       }
       break;
@@ -594,7 +594,7 @@ static int math_random (lua_State *L) {
   luaL_argcheck(L, low <= up, 1, "interval is empty");
   /* project random integer into the interval [0, up - low] */
   p = project(I2UInt(rv), (lua_Unsigned)up - (lua_Unsigned)low, state);
-  lua_pushinteger(L, p + (lua_Unsigned)low);
+  lua_pushinteger(L, l_castU2S(p) + low);
   return 1;
 }
 
@@ -608,8 +608,8 @@ static void setseed (lua_State *L, Rand64 *state,
   state[3] = Int2I(0);
   for (i = 0; i < 16; i++)
     nextrand(state);  /* discard initial values to "spread" seed */
-  lua_pushinteger(L, n1);
-  lua_pushinteger(L, n2);
+  lua_pushinteger(L, l_castU2S(n1));
+  lua_pushinteger(L, l_castU2S(n2));
 }
 
 
@@ -621,8 +621,8 @@ static int math_randomseed (lua_State *L) {
     n2 = I2UInt(nextrand(state->s));  /* in case seed is not that random... */
   }
   else {
-    n1 = luaL_checkinteger(L, 1);
-    n2 = luaL_optinteger(L, 2, 0);
+    n1 = l_castS2U(luaL_checkinteger(L, 1));
+    n2 = l_castS2U(luaL_optinteger(L, 2, 0));
   }
   setseed(L, state->s, n1, n2);
   return 2;  /* return seeds */
diff --git a/lmem.c b/lmem.c
index dfd8a49b..d02c9fdc 100644
--- a/lmem.c
+++ b/lmem.c
@@ -95,7 +95,7 @@ static void *firsttry (global_State *g, void *block, size_t os, size_t ns) {
 
 
 void *luaM_growaux_ (lua_State *L, void *block, int nelems, int *psize,
-                     int size_elems, int limit, const char *what) {
+                     unsigned size_elems, int limit, const char *what) {
   void *newblock;
   int size = *psize;
   if (nelems + 1 <= size)  /* does one extra element still fit? */
@@ -203,9 +203,9 @@ void *luaM_malloc_ (lua_State *L, size_t size, int tag) {
     return NULL;  /* that's all */
   else {
     global_State *g = G(L);
-    void *newblock = firsttry(g, NULL, tag, size);
+    void *newblock = firsttry(g, NULL, cast_sizet(tag), size);
     if (l_unlikely(newblock == NULL)) {
-      newblock = tryagain(L, NULL, tag, size);
+      newblock = tryagain(L, NULL, cast_sizet(tag), size);
       if (newblock == NULL)
         luaM_error(L);
     }
diff --git a/lmem.h b/lmem.h
index c5dada9c..aa306105 100644
--- a/lmem.h
+++ b/lmem.h
@@ -85,7 +85,7 @@ LUAI_FUNC void *luaM_saferealloc_ (lua_State *L, void *block, size_t oldsize,
                                                               size_t size);
 LUAI_FUNC void luaM_free_ (lua_State *L, void *block, size_t osize);
 LUAI_FUNC void *luaM_growaux_ (lua_State *L, void *block, int nelems,
-                               int *size, int size_elem, int limit,
+                               int *size, unsigned size_elem, int limit,
                                const char *what);
 LUAI_FUNC void *luaM_shrinkvector_ (lua_State *L, void *block, int *nelem,
                                     int final_n, int size_elem);
diff --git a/loadlib.c b/loadlib.c
index 84f56ea6..e5ed1352 100644
--- a/loadlib.c
+++ b/loadlib.c
@@ -288,13 +288,13 @@ static void setpath (lua_State *L, const char *fieldname,
     luaL_Buffer b;
     luaL_buffinit(L, &b);
     if (path < dftmark) {  /* is there a prefix before ';;'? */
-      luaL_addlstring(&b, path, dftmark - path);  /* add it */
+      luaL_addlstring(&b, path, ct_diff2sz(dftmark - path));  /* add it */
       luaL_addchar(&b, *LUA_PATH_SEP);
     }
     luaL_addstring(&b, dft);  /* add default */
     if (dftmark < path + len - 2) {  /* is there a suffix after ';;'? */
       luaL_addchar(&b, *LUA_PATH_SEP);
-      luaL_addlstring(&b, dftmark + 2, (path + len - 2) - dftmark);
+      luaL_addlstring(&b, dftmark + 2, ct_diff2sz((path + len - 2) - dftmark));
     }
     luaL_pushresult(&b);
   }
@@ -543,7 +543,7 @@ static int loadfunc (lua_State *L, const char *filename, const char *modname) {
   mark = strchr(modname, *LUA_IGMARK);
   if (mark) {
     int stat;
-    openfunc = lua_pushlstring(L, modname, mark - modname);
+    openfunc = lua_pushlstring(L, modname, ct_diff2sz(mark - modname));
     openfunc = lua_pushfstring(L, LUA_POF"%s", openfunc);
     stat = lookforfunc(L, filename, openfunc);
     if (stat != ERRFUNC) return stat;
@@ -568,7 +568,7 @@ static int searcher_Croot (lua_State *L) {
   const char *p = strchr(name, '.');
   int stat;
   if (p == NULL) return 0;  /* is root */
-  lua_pushlstring(L, name, p - name);
+  lua_pushlstring(L, name, ct_diff2sz(p - name));
   filename = findfile(L, lua_tostring(L, -1), "cpath", LUA_CSUBSEP);
   if (filename == NULL) return 1;  /* root not found */
   if ((stat = loadfunc(L, filename, name)) != 0) {
diff --git a/lobject.c b/lobject.c
index 45a27311..1c4ea1af 100644
--- a/lobject.c
+++ b/lobject.c
@@ -32,7 +32,7 @@
 /*
 ** Computes ceil(log2(x))
 */
-int luaO_ceillog2 (unsigned int x) {
+lu_byte luaO_ceillog2 (unsigned int x) {
   static const lu_byte log_2[256] = {  /* log_2[i - 1] = ceil(log2(i)) */
     0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
     6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
@@ -46,7 +46,7 @@ int luaO_ceillog2 (unsigned int x) {
   int l = 0;
   x--;
   while (x >= 256) { l += 8; x >>= 8; }
-  return l + log_2[x];
+  return cast_byte(l + log_2[x]);
 }
 
 /*
@@ -57,16 +57,19 @@ int luaO_ceillog2 (unsigned int x) {
 ** to signal that. So, the real value is (1xxxx) * 2^(eeee - 7 - 1) if
 ** eeee != 0, and (xxxx) * 2^-7 otherwise (subnormal numbers).
 */
-unsigned int luaO_codeparam (unsigned int p) {
+lu_byte luaO_codeparam (unsigned int p) {
   if (p >= (cast(lu_mem, 0x1F) << (0xF - 7 - 1)) * 100u)  /* overflow? */
     return 0xFF;  /* return maximum value */
   else {
     p = (cast(l_uint32, p) * 128 + 99) / 100;  /* round up the division */
-    if (p < 0x10)  /* subnormal number? */
-      return p;  /* exponent bits are already zero; nothing else to do */
-    else {
-      int log = luaO_ceillog2(p + 1) - 5;  /* preserve 5 bits */
-      return ((p >> log) - 0x10) | ((log + 1) << 4);
+    if (p < 0x10) {  /* subnormal number? */
+      /* exponent bits are already zero; nothing else to do */
+      return cast_byte(p);
+    }
+    else {  /* p >= 0x10 implies ceil(log2(p + 1)) >= 5 */
+      /* preserve 5 bits in 'p' */
+      unsigned log = luaO_ceillog2(p + 1) - 5u;
+      return cast_byte(((p >> log) - 0x10) | ((log + 1) << 4));
     }
   }
 }
@@ -81,7 +84,7 @@ unsigned int luaO_codeparam (unsigned int p) {
 ** more significant bits, as long as the multiplication does not
 ** overflow, so we check which order is best.
 */
-l_obj luaO_applyparam (unsigned int p, l_obj x) {
+l_obj luaO_applyparam (lu_byte p, l_obj x) {
   unsigned int m = p & 0xF;  /* mantissa */
   int e = (p >> 4);  /* exponent */
   if (e > 0) {  /* normalized? */
@@ -189,9 +192,9 @@ void luaO_arith (lua_State *L, int op, const TValue *p1, const TValue *p2,
 }
 
 
-int luaO_hexavalue (int c) {
-  if (lisdigit(c)) return c - '0';
-  else return (ltolower(c) - 'a') + 10;
+lu_byte luaO_hexavalue (int c) {
+  if (lisdigit(c)) return cast_byte(c - '0');
+  else return cast_byte((ltolower(c) - 'a') + 10);
 }
 
 
@@ -349,7 +352,7 @@ static const char *l_str2int (const char *s, lua_Integer *result) {
       int d = *s - '0';
       if (a >= MAXBY10 && (a > MAXBY10 || d > MAXLASTD + neg))  /* overflow? */
         return NULL;  /* do not accept it (as integer) */
-      a = a * 10 + d;
+      a = a * 10 + cast_uint(d);
       empty = 0;
     }
   }
@@ -373,7 +376,7 @@ size_t luaO_str2num (const char *s, TValue *o) {
   }
   else
     return 0;  /* conversion failed */
-  return (e - s) + 1;  /* success; return string size */
+  return ct_diff2sz(e - s) + 1;  /* success; return string size */
 }
 
 
@@ -409,7 +412,7 @@ int luaO_utf8esc (char *buff, unsigned long x) {
 /*
 ** Convert a number object to a string, adding it to a buffer
 */
-static int tostringbuff (TValue *obj, char *buff) {
+static unsigned tostringbuff (TValue *obj, char *buff) {
   int len;
   lua_assert(ttisnumber(obj));
   if (ttisinteger(obj))
@@ -421,7 +424,7 @@ static int tostringbuff (TValue *obj, char *buff) {
       buff[len++] = '0';  /* adds '.0' to result */
     }
   }
-  return len;
+  return cast_uint(len);
 }
 
 
@@ -430,7 +433,7 @@ static int tostringbuff (TValue *obj, char *buff) {
 */
 void luaO_tostring (lua_State *L, TValue *obj) {
   char buff[MAXNUMBER2STR];
-  int len = tostringbuff(obj, buff);
+  unsigned len = tostringbuff(obj, buff);
   setsvalue(L, obj, luaS_newlstr(L, buff, len));
 }
 
@@ -448,13 +451,13 @@ void luaO_tostring (lua_State *L, TValue *obj) {
 ** (LUA_IDSIZE + MAXNUMBER2STR) + a minimal space for basic messages,
 ** so that 'luaG_addinfo' can work directly on the buffer.
 */
-#define BUFVFS          (LUA_IDSIZE + MAXNUMBER2STR + 95)
+#define BUFVFS          cast_uint(LUA_IDSIZE + MAXNUMBER2STR + 95)
 
 /* buffer used by 'luaO_pushvfstring' */
 typedef struct BuffFS {
   lua_State *L;
   int pushed;  /* true if there is a part of the result on the stack */
-  int blen;  /* length of partial string in 'space' */
+  unsigned blen;  /* length of partial string in 'space' */
   char space[BUFVFS];  /* holds last part of the result */
 } BuffFS;
 
@@ -492,7 +495,7 @@ static void clearbuff (BuffFS *buff) {
 ** Get a space of size 'sz' in the buffer. If buffer has not enough
 ** space, empty it. 'sz' must fit in an empty buffer.
 */
-static char *getbuff (BuffFS *buff, int sz) {
+static char *getbuff (BuffFS *buff, unsigned sz) {
   lua_assert(buff->blen <= BUFVFS); lua_assert(sz <= BUFVFS);
   if (sz > BUFVFS - buff->blen)  /* not enough space? */
     clearbuff(buff);
@@ -509,9 +512,9 @@ static char *getbuff (BuffFS *buff, int sz) {
 */
 static void addstr2buff (BuffFS *buff, const char *str, size_t slen) {
   if (slen <= BUFVFS) {  /* does string fit into buffer? */
-    char *bf = getbuff(buff, cast_int(slen));
+    char *bf = getbuff(buff, cast_uint(slen));
     memcpy(bf, str, slen);  /* add string to buffer */
-    addsize(buff, cast_int(slen));
+    addsize(buff, cast_uint(slen));
   }
   else {  /* string larger than buffer */
     clearbuff(buff);  /* string comes after buffer's content */
@@ -525,7 +528,7 @@ static void addstr2buff (BuffFS *buff, const char *str, size_t slen) {
 */
 static void addnum2buff (BuffFS *buff, TValue *num) {
   char *numbuff = getbuff(buff, MAXNUMBER2STR);
-  int len = tostringbuff(num, numbuff);  /* format number into 'numbuff' */
+  unsigned len = tostringbuff(num, numbuff);  /* format number into 'numbuff' */
   addsize(buff, len);
 }
 
@@ -537,10 +540,10 @@ static void addnum2buff (BuffFS *buff, TValue *num) {
 const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) {
   BuffFS buff;  /* holds last part of the result */
   const char *e;  /* points to next '%' */
-  buff.pushed = buff.blen = 0;
+  buff.pushed = 0;  buff.blen = 0;
   buff.L = L;
   while ((e = strchr(fmt, '%')) != NULL) {
-    addstr2buff(&buff, fmt, e - fmt);  /* add 'fmt' up to '%' */
+    addstr2buff(&buff, fmt, ct_diff2sz(e - fmt));  /* add 'fmt' up to '%' */
     switch (*(e + 1)) {  /* conversion specifier */
       case 's': {  /* zero-terminated string */
         const char *s = va_arg(argp, char *);
@@ -549,7 +552,7 @@ const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) {
         break;
       }
       case 'c': {  /* an 'int' as a character */
-        char c = cast_uchar(va_arg(argp, int));
+        char c = cast_char(va_arg(argp, int));
         addstr2buff(&buff, &c, sizeof(char));
         break;
       }
@@ -572,17 +575,17 @@ const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) {
         break;
       }
       case 'p': {  /* a pointer */
-        const int sz = 3 * sizeof(void*) + 8; /* enough space for '%p' */
+        const unsigned sz = 3 * sizeof(void*) + 8; /* enough space for '%p' */
         char *bf = getbuff(&buff, sz);
         void *p = va_arg(argp, void *);
         int len = lua_pointer2str(bf, sz, p);
-        addsize(&buff, len);
+        addsize(&buff, cast_uint(len));
         break;
       }
-      case 'U': {  /* a 'long' as a UTF-8 sequence */
+      case 'U': {  /* an 'unsigned long' as a UTF-8 sequence */
         char bf[UTF8BUFFSZ];
-        int len = luaO_utf8esc(bf, va_arg(argp, long));
-        addstr2buff(&buff, bf + UTF8BUFFSZ - len, len);
+        int len = luaO_utf8esc(bf, va_arg(argp, unsigned long));
+        addstr2buff(&buff, bf + UTF8BUFFSZ - len, cast_uint(len));
         break;
       }
       case '%': {
@@ -648,7 +651,8 @@ void luaO_chunkid (char *out, const char *source, size_t srclen) {
       addstr(out, source, srclen);  /* keep it */
     }
     else {
-      if (nl != NULL) srclen = nl - source;  /* stop at first newline */
+      if (nl != NULL)
+        srclen = ct_diff2sz(nl - source);  /* stop at first newline */
       if (srclen > bufflen) srclen = bufflen;
       addstr(out, source, srclen);
       addstr(out, RETS, LL(RETS));
diff --git a/lobject.h b/lobject.h
index 641e782c..fb66dff7 100644
--- a/lobject.h
+++ b/lobject.h
@@ -432,13 +432,13 @@ typedef struct TString {
 
 /* get string length from 'TString *ts' */
 #define tsslen(ts)  \
-        (strisshr(ts) ? cast_uint((ts)->shrlen) : (ts)->u.lnglen)
+        (strisshr(ts) ? cast_sizet((ts)->shrlen) : (ts)->u.lnglen)
 
 /*
 ** Get string and length */
 #define getlstr(ts, len)  \
         (strisshr(ts) \
-        ? (cast_void((len) = (ts)->shrlen), rawgetshrstr(ts)) \
+        ? (cast_void((len) = cast_sizet((ts)->shrlen)), rawgetshrstr(ts)) \
         : (cast_void((len) = (ts)->u.lnglen), (ts)->contents))
 
 /* }================================================================== */
@@ -517,8 +517,8 @@ typedef struct Udata0 {
 
 /* compute the offset of the memory area of a userdata */
 #define udatamemoffset(nuv) \
-        ((nuv) == 0 ? offsetof(Udata0, bindata)  \
-                    : offsetof(Udata, uv) + (sizeof(UValue) * (nuv)))
+       ((nuv) == 0 ? offsetof(Udata0, bindata)  \
+                   : offsetof(Udata, uv) + (sizeof(UValue) * (nuv)))
 
 /* get the address of the memory block inside 'Udata' */
 #define getudatamem(u)  (cast_charp(u) + udatamemoffset((u)->nuvalue))
@@ -825,10 +825,10 @@ typedef struct Table {
 ** 'module' operation for hashing (size is always a power of 2)
 */
 #define lmod(s,size) \
-        (check_exp((size&(size-1))==0, (cast_int((s) & ((size)-1)))))
+        (check_exp((size&(size-1))==0, (cast_uint(s) & cast_uint((size)-1))))
 
 
-#define twoto(x)        (1<<(x))
+#define twoto(x)        (1u<<(x))
 #define sizenode(t)     (twoto((t)->lsizenode))
 
 
@@ -836,16 +836,16 @@ typedef struct Table {
 #define UTF8BUFFSZ      8
 
 LUAI_FUNC int luaO_utf8esc (char *buff, unsigned long x);
-LUAI_FUNC int luaO_ceillog2 (unsigned int x);
-LUAI_FUNC unsigned int luaO_codeparam (unsigned int p);
-LUAI_FUNC l_obj luaO_applyparam (unsigned int p, l_obj x);
+LUAI_FUNC lu_byte luaO_ceillog2 (unsigned int x);
+LUAI_FUNC lu_byte luaO_codeparam (unsigned int p);
+LUAI_FUNC l_obj luaO_applyparam (lu_byte p, l_obj x);
 
 LUAI_FUNC int luaO_rawarith (lua_State *L, int op, const TValue *p1,
                              const TValue *p2, TValue *res);
 LUAI_FUNC void luaO_arith (lua_State *L, int op, const TValue *p1,
                            const TValue *p2, StkId res);
 LUAI_FUNC size_t luaO_str2num (const char *s, TValue *o);
-LUAI_FUNC int luaO_hexavalue (int c);
+LUAI_FUNC lu_byte luaO_hexavalue (int c);
 LUAI_FUNC void luaO_tostring (lua_State *L, TValue *obj);
 LUAI_FUNC const char *luaO_pushvfstring (lua_State *L, const char *fmt,
                                                        va_list argp);
diff --git a/lopcodes.h b/lopcodes.h
index 736946e3..31f6fac0 100644
--- a/lopcodes.h
+++ b/lopcodes.h
@@ -72,8 +72,11 @@ enum OpMode {iABC, ivABC, iABx, iAsBx, iAx, isJ};
 ** so they must fit in ints.
 */
 
-/* Check whether type 'int' has at least 'b' bits ('b' < 32) */
-#define L_INTHASBITS(b)         ((UINT_MAX >> ((b) - 1)) >= 1)
+/*
+** Check whether type 'int' has at least 'b' + 1 bits.
+** 'b' < 32; +1 for the sign bit.
+*/
+#define L_INTHASBITS(b)         ((UINT_MAX >> (b)) >= 1)
 
 
 #if L_INTHASBITS(SIZE_Bx)
diff --git a/loslib.c b/loslib.c
index 8280331b..4623ad5e 100644
--- a/loslib.c
+++ b/loslib.c
@@ -275,7 +275,7 @@ static int getfield (lua_State *L, const char *key, int d, int delta) {
 static const char *checkoption (lua_State *L, const char *conv,
                                 ptrdiff_t convlen, char *buff) {
   const char *option = LUA_STRFTIMEOPTIONS;
-  int oplen = 1;  /* length of options being checked */
+  unsigned oplen = 1;  /* length of options being checked */
   for (; *option != '\0' && oplen <= convlen; option += oplen) {
     if (*option == '|')  /* next block? */
       oplen++;  /* will check options with next length (+1) */
diff --git a/lparser.c b/lparser.c
index 0ed9631a..452ab19e 100644
--- a/lparser.c
+++ b/lparser.c
@@ -172,7 +172,8 @@ static void codename (LexState *ls, expdesc *e) {
 ** Register a new local variable in the active 'Proto' (for debug
 ** information).
 */
-static int registerlocalvar (LexState *ls, FuncState *fs, TString *varname) {
+static short registerlocalvar (LexState *ls, FuncState *fs,
+                               TString *varname) {
   Proto *f = fs->f;
   int oldsize = f->sizelocvars;
   luaM_growvector(ls->L, f->locvars, fs->ndebugvars, f->sizelocvars,
@@ -190,7 +191,7 @@ static int registerlocalvar (LexState *ls, FuncState *fs, TString *varname) {
 ** Create a new local variable with the given 'name' and given 'kind'.
 ** Return its index in the function.
 */
-static int new_localvarkind (LexState *ls, TString *name, int kind) {
+static int new_localvarkind (LexState *ls, TString *name, lu_byte kind) {
   lua_State *L = ls->L;
   FuncState *fs = ls->fs;
   Dyndata *dyd = ls->dyd;
@@ -234,11 +235,11 @@ static Vardesc *getlocalvardesc (FuncState *fs, int vidx) {
 ** register. For that, search for the highest variable below that level
 ** that is in a register and uses its register index ('ridx') plus one.
 */
-static int reglevel (FuncState *fs, int nvar) {
+static lu_byte reglevel (FuncState *fs, int nvar) {
   while (nvar-- > 0) {
     Vardesc *vd = getlocalvardesc(fs, nvar);  /* get previous variable */
     if (vd->vd.kind != RDKCTC)  /* is in a register? */
-      return vd->vd.ridx + 1;
+      return cast_byte(vd->vd.ridx + 1);
   }
   return 0;  /* no variables in registers */
 }
@@ -248,7 +249,7 @@ static int reglevel (FuncState *fs, int nvar) {
 ** Return the number of variables in the register stack for the given
 ** function.
 */
-int luaY_nvarstack (FuncState *fs) {
+lu_byte luaY_nvarstack (FuncState *fs) {
   return reglevel(fs, fs->nactvar);
 }
 
@@ -274,7 +275,7 @@ static LocVar *localdebuginfo (FuncState *fs, int vidx) {
 static void init_var (FuncState *fs, expdesc *e, int vidx) {
   e->f = e->t = NO_JUMP;
   e->k = VLOCAL;
-  e->u.var.vidx = vidx;
+  e->u.var.vidx = cast(unsigned short, vidx);
   e->u.var.ridx = getlocalvardesc(fs, vidx)->vd.ridx;
 }
 
@@ -323,7 +324,7 @@ static void adjustlocalvars (LexState *ls, int nvars) {
   for (i = 0; i < nvars; i++) {
     int vidx = fs->nactvar++;
     Vardesc *var = getlocalvardesc(fs, vidx);
-    var->vd.ridx = reglevel++;
+    var->vd.ridx = cast_byte(reglevel++);
     var->vd.pidx = registerlocalvar(ls, fs, var->vd.name);
   }
 }
@@ -505,7 +506,7 @@ static void adjust_assign (LexState *ls, int nvars, int nexps, expdesc *e) {
   if (needed > 0)
     luaK_reserveregs(fs, needed);  /* registers for extra values */
   else  /* adding 'needed' is actually a subtraction */
-    fs->freereg += needed;  /* remove extra values */
+    fs->freereg = cast_byte(fs->freereg + needed);  /* remove extra values */
 }
 
 
@@ -682,7 +683,7 @@ static void leaveblock (FuncState *fs) {
   BlockCnt *bl = fs->bl;
   LexState *ls = fs->ls;
   int hasclose = 0;
-  int stklevel = reglevel(fs, bl->nactvar);  /* level outside the block */
+  lu_byte stklevel = reglevel(fs, bl->nactvar);  /* level outside the block */
   removevars(fs, bl->nactvar);  /* remove block locals */
   lua_assert(bl->nactvar == fs->nactvar);  /* back to level on entry */
   if (bl->isloop)  /* has to fix pending breaks? */
@@ -856,7 +857,7 @@ typedef struct ConsControl {
 static void recfield (LexState *ls, ConsControl *cc) {
   /* recfield -> (NAME | '['exp']') = exp */
   FuncState *fs = ls->fs;
-  int reg = ls->fs->freereg;
+  lu_byte reg = ls->fs->freereg;
   expdesc tab, key, val;
   if (ls->t.token == TK_NAME) {
     checklimit(fs, cc->nh, INT_MAX, "items in a constructor");
@@ -939,7 +940,7 @@ static void field (LexState *ls, ConsControl *cc) {
 static int maxtostore (FuncState *fs) {
   int numfreeregs = MAX_FSTACK - fs->freereg;
   if (numfreeregs >= 160)  /* "lots" of registers? */
-    return numfreeregs / 5u;  /* use up to 1/5 of them */
+    return numfreeregs / 5;  /* use up to 1/5 of them */
   else if (numfreeregs >= 80)  /* still "enough" registers? */
     return 10;  /* one 'SETLIST' instruction for each 10 values */
   else  /* save registers for potential more nesting */
@@ -1090,8 +1091,9 @@ static void funcargs (LexState *ls, expdesc *f) {
   }
   init_exp(f, VCALL, luaK_codeABC(fs, OP_CALL, base, nparams+1, 2));
   luaK_fixline(fs, line);
-  fs->freereg = base+1;  /* call removes function and arguments and leaves
-                            one result (unless changed later) */
+  /* call removes function and arguments and leaves one result (unless
+     changed later) */
+  fs->freereg = cast_byte(base + 1);
 }
 
 
@@ -1356,7 +1358,7 @@ struct LHS_assign {
 */
 static void check_conflict (LexState *ls, struct LHS_assign *lh, expdesc *v) {
   FuncState *fs = ls->fs;
-  int extra = fs->freereg;  /* eventual position to save local variable */
+  lu_byte extra = fs->freereg;  /* eventual position to save local variable */
   int conflict = 0;
   for (; lh; lh = lh->prev) {  /* check all previous assignments */
     if (vkisindexed(lh->v.k)) {  /* assignment to table field? */
@@ -1723,7 +1725,7 @@ static void localfunc (LexState *ls) {
 }
 
 
-static int getlocalattribute (LexState *ls) {
+static lu_byte getlocalattribute (LexState *ls) {
   /* ATTRIB -> ['<' Name '>'] */
   if (testnext(ls, '<')) {
     TString *ts = str_checkname(ls);
@@ -1760,7 +1762,7 @@ static void localstat (LexState *ls) {
   expdesc e;
   do {
     TString *vname = str_checkname(ls);
-    int kind = getlocalattribute(ls);
+    lu_byte kind = getlocalattribute(ls);
     vidx = new_localvarkind(ls, vname, kind);
     if (kind == RDKTOCLOSE) {  /* to-be-closed? */
       if (toclose != -1)  /* one already present? */
diff --git a/lparser.h b/lparser.h
index 5e4500f1..535dc9da 100644
--- a/lparser.h
+++ b/lparser.h
@@ -163,7 +163,7 @@ typedef struct FuncState {
 } FuncState;
 
 
-LUAI_FUNC int luaY_nvarstack (FuncState *fs);
+LUAI_FUNC lu_byte luaY_nvarstack (FuncState *fs);
 LUAI_FUNC LClosure *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff,
                                  Dyndata *dyd, const char *name, int firstchar);
 
diff --git a/lstate.c b/lstate.c
index 4511bc00..eb71ed8c 100644
--- a/lstate.c
+++ b/lstate.c
@@ -190,7 +190,8 @@ static void freestack (lua_State *L) {
   L->ci = &L->base_ci;  /* free the entire 'ci' list */
   freeCI(L);
   lua_assert(L->nci == 0);
-  luaM_freearray(L, L->stack.p, stacksize(L) + EXTRA_STACK);  /* free stack */
+  /* free stack */
+  luaM_freearray(L, L->stack.p, cast_sizet(stacksize(L) + EXTRA_STACK));
 }
 
 
@@ -266,7 +267,7 @@ static void close_state (lua_State *L) {
     luaC_freeallobjects(L);  /* collect all objects */
     luai_userstateclose(L);
   }
-  luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size);
+  luaM_freearray(L, G(L)->strt.hash, cast_sizet(G(L)->strt.size));
   freestack(L);
   lua_assert(g->totalbytes == sizeof(LG));
   lua_assert(gettotalobjs(g) == 1);
diff --git a/lstate.h b/lstate.h
index ff86d825..aa9687ae 100644
--- a/lstate.h
+++ b/lstate.h
@@ -259,7 +259,7 @@ struct CallInfo {
 #define getcistrecst(ci)     (((ci)->callstatus >> CIST_RECST) & 7)
 #define setcistrecst(ci,st)  \
   check_exp(((st) & 7) == (st),   /* status must fit in three bits */  \
-            ((ci)->callstatus = ((ci)->callstatus & ~(7 << CIST_RECST))  \
+            ((ci)->callstatus = ((ci)->callstatus & ~(7u << CIST_RECST))  \
                                 | (cast(l_uint32, st) << CIST_RECST)))
 
 
diff --git a/lstring.c b/lstring.c
index 86ee2411..0c89a51b 100644
--- a/lstring.c
+++ b/lstring.c
@@ -164,7 +164,7 @@ size_t luaS_sizelngstr (size_t len, int kind) {
 /*
 ** creates a new string object
 */
-static TString *createstrobj (lua_State *L, size_t totalsize, int tag,
+static TString *createstrobj (lua_State *L, size_t totalsize, lu_byte tag,
                               unsigned h) {
   TString *ts;
   GCObject *o;
@@ -233,7 +233,7 @@ static TString *internshrstr (lua_State *L, const char *str, size_t l) {
     list = &tb->hash[lmod(h, tb->size)];  /* rehash with new size */
   }
   ts = createstrobj(L, sizestrshr(l), LUA_VSHRSTR, h);
-  ts->shrlen = cast_byte(l);
+  ts->shrlen = cast(ls_byte, l);
   getshrstr(ts)[l] = '\0';  /* ending 0 */
   memcpy(getshrstr(ts), str, l * sizeof(char));
   ts->u.hnext = *list;
@@ -283,7 +283,7 @@ TString *luaS_new (lua_State *L, const char *str) {
 }
 
 
-Udata *luaS_newudata (lua_State *L, size_t s, int nuvalue) {
+Udata *luaS_newudata (lua_State *L, size_t s, unsigned short nuvalue) {
   Udata *u;
   int i;
   GCObject *o;
@@ -301,7 +301,7 @@ Udata *luaS_newudata (lua_State *L, size_t s, int nuvalue) {
 
 
 struct NewExt {
-  int kind;
+  ls_byte kind;
   const char *s;
    size_t len;
   TString *ts;  /* output */
diff --git a/lstring.h b/lstring.h
index c88357aa..26f4b8e1 100644
--- a/lstring.h
+++ b/lstring.h
@@ -61,7 +61,8 @@ LUAI_FUNC void luaS_resize (lua_State *L, int newsize);
 LUAI_FUNC void luaS_clearcache (global_State *g);
 LUAI_FUNC void luaS_init (lua_State *L);
 LUAI_FUNC void luaS_remove (lua_State *L, TString *ts);
-LUAI_FUNC Udata *luaS_newudata (lua_State *L, size_t s, int nuvalue);
+LUAI_FUNC Udata *luaS_newudata (lua_State *L, size_t s,
+                                              unsigned short nuvalue);
 LUAI_FUNC TString *luaS_newlstr (lua_State *L, const char *str, size_t l);
 LUAI_FUNC TString *luaS_new (lua_State *L, const char *str);
 LUAI_FUNC TString *luaS_createlngstrobj (lua_State *L, size_t l);
diff --git a/lstrlib.c b/lstrlib.c
index 8d6573a6..e9421c27 100644
--- a/lstrlib.c
+++ b/lstrlib.c
@@ -113,7 +113,7 @@ static int str_lower (lua_State *L) {
   const char *s = luaL_checklstring(L, 1, &l);
   char *p = luaL_buffinitsize(L, &b, l);
   for (i=0; i<l; i++)
-    p[i] = tolower(cast_uchar(s[i]));
+    p[i] = cast_char(tolower(cast_uchar(s[i])));
   luaL_pushresultsize(&b, l);
   return 1;
 }
@@ -126,7 +126,7 @@ static int str_upper (lua_State *L) {
   const char *s = luaL_checklstring(L, 1, &l);
   char *p = luaL_buffinitsize(L, &b, l);
   for (i=0; i<l; i++)
-    p[i] = toupper(cast_uchar(s[i]));
+    p[i] = cast_char(toupper(cast_uchar(s[i])));
   luaL_pushresultsize(&b, l);
   return 1;
 }
@@ -139,7 +139,7 @@ static int str_rep (lua_State *L) {
   const char *sep = luaL_optlstring(L, 3, "", &lsep);
   if (n <= 0)
     lua_pushliteral(L, "");
-  else if (l_unlikely(l + lsep < l || l + lsep > MAX_SIZE / n))
+  else if (l_unlikely(l + lsep < l || l + lsep > MAX_SIZE / cast_sizet(n)))
     return luaL_error(L, "resulting string too large");
   else {
     size_t totallen = ((size_t)n * (l + lsep)) - lsep;
@@ -172,7 +172,7 @@ static int str_byte (lua_State *L) {
   n = (int)(pose -  posi) + 1;
   luaL_checkstack(L, n, "string slice too long");
   for (i=0; i<n; i++)
-    lua_pushinteger(L, cast_uchar(s[posi+i-1]));
+    lua_pushinteger(L, cast_uchar(s[posi + cast_uint(i) - 1]));
   return n;
 }
 
@@ -181,13 +181,13 @@ static int str_char (lua_State *L) {
   int n = lua_gettop(L);  /* number of arguments */
   int i;
   luaL_Buffer b;
-  char *p = luaL_buffinitsize(L, &b, n);
+  char *p = luaL_buffinitsize(L, &b, cast_uint(n));
   for (i=1; i<=n; i++) {
     lua_Unsigned c = (lua_Unsigned)luaL_checkinteger(L, i);
     luaL_argcheck(L, c <= (lua_Unsigned)UCHAR_MAX, i, "value out of range");
-    p[i - 1] = cast_uchar(c);
+    p[i - 1] = cast_char(cast_uchar(c));
   }
-  luaL_pushresultsize(&b, n);
+  luaL_pushresultsize(&b, cast_uint(n));
   return 1;
 }
 
@@ -352,10 +352,10 @@ typedef struct MatchState {
   const char *p_end;  /* end ('\0') of pattern */
   lua_State *L;
   int matchdepth;  /* control for recursive depth (to avoid C stack overflow) */
-  unsigned char level;  /* total number of captures (finished or unfinished) */
+  int level;  /* total number of captures (finished or unfinished) */
   struct {
     const char *init;
-    ptrdiff_t len;
+    ptrdiff_t len;  /* length or special value (CAP_*) */
   } capture[LUA_MAXCAPTURES];
 } MatchState;
 
@@ -550,7 +550,7 @@ static const char *end_capture (MatchState *ms, const char *s,
 static const char *match_capture (MatchState *ms, const char *s, int l) {
   size_t len;
   l = check_capture(ms, l);
-  len = ms->capture[l].len;
+  len = cast_sizet(ms->capture[l].len);
   if ((size_t)(ms->src_end-s) >= len &&
       memcmp(ms->capture[l].init, s, len) == 0)
     return s+len;
@@ -674,7 +674,7 @@ static const char *lmemfind (const char *s1, size_t l1,
       if (memcmp(init, s2+1, l2) == 0)
         return init-1;
       else {  /* correct 'l1' and 's1' to try again */
-        l1 -= init-s1;
+        l1 -= ct_diff2sz(init - s1);
         s1 = init;
       }
     }
@@ -690,13 +690,13 @@ static const char *lmemfind (const char *s1, size_t l1,
 ** its length and put its address in '*cap'. If it is an integer
 ** (a position), push it on the stack and return CAP_POSITION.
 */
-static size_t get_onecapture (MatchState *ms, int i, const char *s,
+static ptrdiff_t get_onecapture (MatchState *ms, int i, const char *s,
                               const char *e, const char **cap) {
   if (i >= ms->level) {
     if (l_unlikely(i != 0))
       luaL_error(ms->L, "invalid capture index %%%d", i + 1);
     *cap = s;
-    return e - s;
+    return (e - s);
   }
   else {
     ptrdiff_t capl = ms->capture[i].len;
@@ -718,7 +718,7 @@ static void push_onecapture (MatchState *ms, int i, const char *s,
   const char *cap;
   ptrdiff_t l = get_onecapture(ms, i, s, e, &cap);
   if (l != CAP_POSITION)
-    lua_pushlstring(ms->L, cap, l);
+    lua_pushlstring(ms->L, cap, cast_sizet(l));
   /* else position was already pushed */
 }
 
@@ -776,7 +776,7 @@ static int str_find_aux (lua_State *L, int find) {
     const char *s2 = lmemfind(s + init, ls - init, p, lp);
     if (s2) {
       lua_pushinteger(L, (s2 - s) + 1);
-      lua_pushinteger(L, (s2 - s) + lp);
+      lua_pushinteger(L, cast_st2S(ct_diff2sz(s2 - s) + lp));
       return 2;
     }
   }
@@ -866,23 +866,23 @@ static void add_s (MatchState *ms, luaL_Buffer *b, const char *s,
   const char *news = lua_tolstring(L, 3, &l);
   const char *p;
   while ((p = (char *)memchr(news, L_ESC, l)) != NULL) {
-    luaL_addlstring(b, news, p - news);
+    luaL_addlstring(b, news, ct_diff2sz(p - news));
     p++;  /* skip ESC */
     if (*p == L_ESC)  /* '%%' */
       luaL_addchar(b, *p);
     else if (*p == '0')  /* '%0' */
-        luaL_addlstring(b, s, e - s);
+        luaL_addlstring(b, s, ct_diff2sz(e - s));
     else if (isdigit(cast_uchar(*p))) {  /* '%n' */
       const char *cap;
       ptrdiff_t resl = get_onecapture(ms, *p - '1', s, e, &cap);
       if (resl == CAP_POSITION)
         luaL_addvalue(b);  /* add position to accumulated result */
       else
-        luaL_addlstring(b, cap, resl);
+        luaL_addlstring(b, cap, cast_sizet(resl));
     }
     else
       luaL_error(L, "invalid use of '%c' in replacement string", L_ESC);
-    l -= p + 1 - news;
+    l -= ct_diff2sz(p + 1 - news);
     news = p + 1;
   }
   luaL_addlstring(b, news, l);
@@ -917,7 +917,7 @@ static int add_value (MatchState *ms, luaL_Buffer *b, const char *s,
   }
   if (!lua_toboolean(L, -1)) {  /* nil or false? */
     lua_pop(L, 1);  /* remove value */
-    luaL_addlstring(b, s, e - s);  /* keep original text */
+    luaL_addlstring(b, s, ct_diff2sz(e - s));  /* keep original text */
     return 0;  /* no changes */
   }
   else if (l_unlikely(!lua_isstring(L, -1)))
@@ -936,7 +936,8 @@ static int str_gsub (lua_State *L) {
   const char *p = luaL_checklstring(L, 2, &lp);  /* pattern */
   const char *lastmatch = NULL;  /* end of last match */
   int tr = lua_type(L, 3);  /* replacement type */
-  lua_Integer max_s = luaL_optinteger(L, 4, srcl + 1);  /* max replacements */
+  /* max replacements */
+  lua_Integer max_s = luaL_optinteger(L, 4, cast_st2S(srcl) + 1);
   int anchor = (*p == '^');
   lua_Integer n = 0;  /* replacement count */
   int changed = 0;  /* change flag */
@@ -966,7 +967,7 @@ static int str_gsub (lua_State *L) {
   if (!changed)  /* no changes? */
     lua_pushvalue(L, 1);  /* return original string */
   else {  /* something changed */
-    luaL_addlstring(&b, src, ms.src_end-src);
+    luaL_addlstring(&b, src, ct_diff2sz(ms.src_end - src));
     luaL_pushresult(&b);  /* create and return new string */
   }
   lua_pushinteger(L, n);  /* number of substitutions */
@@ -1004,15 +1005,15 @@ static int str_gsub (lua_State *L) {
 /*
 ** Add integer part of 'x' to buffer and return new 'x'
 */
-static lua_Number adddigit (char *buff, int n, lua_Number x) {
+static lua_Number adddigit (char *buff, unsigned n, lua_Number x) {
   lua_Number dd = l_mathop(floor)(x);  /* get integer part from 'x' */
   int d = (int)dd;
-  buff[n] = (d < 10 ? d + '0' : d - 10 + 'a');  /* add to buffer */
+  buff[n] = cast_char(d < 10 ? d + '0' : d - 10 + 'a');  /* add to buffer */
   return x - dd;  /* return what is left */
 }
 
 
-static int num2straux (char *buff, int sz, lua_Number x) {
+static int num2straux (char *buff, unsigned sz, lua_Number x) {
   /* if 'inf' or 'NaN', format it like '%g' */
   if (x != x || x == (lua_Number)HUGE_VAL || x == -(lua_Number)HUGE_VAL)
     return l_sprintf(buff, sz, LUA_NUMBER_FMT, (LUAI_UACNUMBER)x);
@@ -1023,7 +1024,7 @@ static int num2straux (char *buff, int sz, lua_Number x) {
   else {
     int e;
     lua_Number m = l_mathop(frexp)(x, &e);  /* 'x' fraction and exponent */
-    int n = 0;  /* character count */
+    unsigned n = 0;  /* character count */
     if (m < 0) {  /* is number negative? */
       buff[n++] = '-';  /* add sign */
       m = -m;  /* make it positive */
@@ -1037,20 +1038,20 @@ static int num2straux (char *buff, int sz, lua_Number x) {
         m = adddigit(buff, n++, m * 16);
       } while (m > 0);
     }
-    n += l_sprintf(buff + n, sz - n, "p%+d", e);  /* add exponent */
+    n += cast_uint(l_sprintf(buff + n, sz - n, "p%+d", e));  /* add exponent */
     lua_assert(n < sz);
-    return n;
+    return cast_int(n);
   }
 }
 
 
-static int lua_number2strx (lua_State *L, char *buff, int sz,
+static int lua_number2strx (lua_State *L, char *buff, unsigned sz,
                             const char *fmt, lua_Number x) {
   int n = num2straux(buff, sz, x);
   if (fmt[SIZELENMOD] == 'A') {
     int i;
     for (i = 0; i < n; i++)
-      buff[i] = toupper(cast_uchar(buff[i]));
+      buff[i] = cast_char(toupper(cast_uchar(buff[i])));
   }
   else if (l_unlikely(fmt[SIZELENMOD] != 'a'))
     return luaL_error(L, "modifiers for format '%%a'/'%%A' not implemented");
@@ -1151,9 +1152,9 @@ static int quotefloat (lua_State *L, char *buff, lua_Number n) {
     int  nb = lua_number2strx(L, buff, MAX_ITEM,
                                  "%" LUA_NUMBER_FRMLEN "a", n);
     /* ensures that 'buff' string uses a dot as the radix character */
-    if (memchr(buff, '.', nb) == NULL) {  /* no dot? */
+    if (memchr(buff, '.', cast_uint(nb)) == NULL) {  /* no dot? */
       char point = lua_getlocaledecpoint();  /* try locale point */
-      char *ppoint = (char *)memchr(buff, point, nb);
+      char *ppoint = (char *)memchr(buff, point, cast_uint(nb));
       if (ppoint) *ppoint = '.';  /* change it to a dot */
     }
     return nb;
@@ -1183,7 +1184,7 @@ static void addliteral (lua_State *L, luaL_Buffer *b, int arg) {
                            : LUA_INTEGER_FMT;  /* else use default format */
         nb = l_sprintf(buff, MAX_ITEM, format, (LUAI_UACINT)n);
       }
-      luaL_addsize(b, nb);
+      luaL_addsize(b, cast_uint(nb));
       break;
     }
     case LUA_TNIL: case LUA_TBOOLEAN: {
@@ -1277,7 +1278,7 @@ static int str_format (lua_State *L) {
       luaL_addchar(&b, *strfrmt++);  /* %% */
     else { /* format item */
       char form[MAX_FORMAT];  /* to store the format ('%...') */
-      int maxitem = MAX_ITEM;  /* maximum length for the result */
+      unsigned maxitem = MAX_ITEM;  /* maximum length for the result */
       char *buff = luaL_prepbuffsize(&b, maxitem);  /* to put result */
       int nb = 0;  /* number of bytes in result */
       if (++arg > top)
@@ -1360,8 +1361,8 @@ static int str_format (lua_State *L) {
           return luaL_error(L, "invalid conversion '%s' to 'format'", form);
         }
       }
-      lua_assert(nb < maxitem);
-      luaL_addsize(&b, nb);
+      lua_assert(cast_uint(nb) < maxitem);
+      luaL_addsize(&b, cast_uint(nb));
     }
   }
   luaL_pushresult(&b);
@@ -1409,7 +1410,7 @@ static const union {
 typedef struct Header {
   lua_State *L;
   int islittle;
-  int maxalign;
+  unsigned maxalign;
 } Header;
 
 
@@ -1443,7 +1444,7 @@ static size_t getnum (const char **fmt, size_t df) {
   else {
     size_t a = 0;
     do {
-      a = a*10 + (*((*fmt)++) - '0');
+      a = a*10 + cast_uint(*((*fmt)++) - '0');
     } while (digit(**fmt) && a <= (MAX_SIZE - 9)/10);
     return a;
   }
@@ -1454,12 +1455,12 @@ static size_t getnum (const char **fmt, size_t df) {
 ** Read an integer numeral and raises an error if it is larger
 ** than the maximum size of integers.
 */
-static int getnumlimit (Header *h, const char **fmt, int df) {
+static unsigned getnumlimit (Header *h, const char **fmt, size_t df) {
   size_t sz = getnum(fmt, df);
   if (l_unlikely((sz - 1u) >= MAXINTSIZE))
-    return luaL_error(h->L, "integral size (%d) out of limits [1,%d]",
-                            sz, MAXINTSIZE);
-  return cast_int(sz);
+    return cast_uint(luaL_error(h->L,
+               "integral size (%d) out of limits [1,%d]", sz, MAXINTSIZE));
+  return cast_uint(sz);
 }
 
 
@@ -1510,7 +1511,7 @@ static KOption getoption (Header *h, const char **fmt, size_t *size) {
     case '>': h->islittle = 0; break;
     case '=': h->islittle = nativeendian.little; break;
     case '!': {
-      const int maxalign = offsetof(struct cD, u);
+      const size_t maxalign = offsetof(struct cD, u);
       h->maxalign = getnumlimit(h, fmt, maxalign);
       break;
     }
@@ -1529,8 +1530,8 @@ static KOption getoption (Header *h, const char **fmt, size_t *size) {
 ** the maximum alignment ('maxalign'). Kchar option needs no alignment
 ** despite its size.
 */
-static KOption getdetails (Header *h, size_t totalsize,
-                           const char **fmt, size_t *psize, int *ntoalign) {
+static KOption getdetails (Header *h, size_t totalsize, const char **fmt,
+                           size_t *psize, unsigned *ntoalign) {
   KOption opt = getoption(h, fmt, psize);
   size_t align = *psize;  /* usually, alignment follows size */
   if (opt == Kpaddalign) {  /* 'X' gets alignment from following option */
@@ -1540,11 +1541,15 @@ static KOption getdetails (Header *h, size_t totalsize,
   if (align <= 1 || opt == Kchar)  /* need no alignment? */
     *ntoalign = 0;
   else {
-    if (align > cast_sizet(h->maxalign))  /* enforce maximum alignment */
+    if (align > h->maxalign)  /* enforce maximum alignment */
       align = h->maxalign;
     if (l_unlikely(!ispow2(align)))  /* not a power of 2? */
       luaL_argerror(h->L, 1, "format asks for alignment not power of 2");
-    *ntoalign = (align - (int)(totalsize & (align - 1))) & (align - 1);
+    else {
+      /* 'szmoda' = totalsize % align */
+      unsigned szmoda = cast_uint(totalsize & (align - 1));
+      *ntoalign = cast_uint((align - szmoda) & (align - 1));
+    }
   }
   return opt;
 }
@@ -1557,9 +1562,9 @@ static KOption getdetails (Header *h, size_t totalsize,
 ** bytes if necessary (by default they would be zeros).
 */
 static void packint (luaL_Buffer *b, lua_Unsigned n,
-                     int islittle, int size, int neg) {
+                     int islittle, unsigned size, int neg) {
   char *buff = luaL_prepbuffsize(b, size);
-  int i;
+  unsigned i;
   buff[islittle ? 0 : size - 1] = (char)(n & MC);  /* first byte */
   for (i = 1; i < size; i++) {
     n >>= NB;
@@ -1578,7 +1583,7 @@ static void packint (luaL_Buffer *b, lua_Unsigned n,
 ** given 'islittle' is different from native endianness.
 */
 static void copywithendian (char *dest, const char *src,
-                            int size, int islittle) {
+                            unsigned size, int islittle) {
   if (islittle == nativeendian.little)
     memcpy(dest, src, size);
   else {
@@ -1599,7 +1604,7 @@ static int str_pack (lua_State *L) {
   lua_pushnil(L);  /* mark to separate arguments from string buffer */
   luaL_buffinit(L, &b);
   while (*fmt != '\0') {
-    int ntoalign;
+    unsigned ntoalign;
     size_t size;
     KOption opt = getdetails(&h, totalsize, &fmt, &size, &ntoalign);
     luaL_argcheck(L, size + ntoalign <= MAX_SIZE - totalsize, arg,
@@ -1615,7 +1620,7 @@ static int str_pack (lua_State *L) {
           lua_Integer lim = (lua_Integer)1 << ((size * NB) - 1);
           luaL_argcheck(L, -lim <= n && n < lim, arg, "integer overflow");
         }
-        packint(&b, (lua_Unsigned)n, h.islittle, size, (n < 0));
+        packint(&b, (lua_Unsigned)n, h.islittle, cast_uint(size), (n < 0));
         break;
       }
       case Kuint: {  /* unsigned integers */
@@ -1623,7 +1628,7 @@ static int str_pack (lua_State *L) {
         if (size < SZINT)  /* need overflow check? */
           luaL_argcheck(L, (lua_Unsigned)n < ((lua_Unsigned)1 << (size * NB)),
                            arg, "unsigned overflow");
-        packint(&b, (lua_Unsigned)n, h.islittle, size, 0);
+        packint(&b, (lua_Unsigned)n, h.islittle, cast_uint(size), 0);
         break;
       }
       case Kfloat: {  /* C float */
@@ -1669,7 +1674,8 @@ static int str_pack (lua_State *L) {
         luaL_argcheck(L, size >= sizeof(lua_Unsigned) ||
                          len < ((lua_Unsigned)1 << (size * NB)),
                          arg, "string length does not fit in given size");
-        packint(&b, (lua_Unsigned)len, h.islittle, size, 0);  /* pack length */
+        /* pack length */
+        packint(&b, (lua_Unsigned)len, h.islittle, cast_uint(size), 0);
         luaL_addlstring(&b, s, len);
         totalsize += len;
         break;
@@ -1697,20 +1703,20 @@ static int str_pack (lua_State *L) {
 static int str_packsize (lua_State *L) {
   Header h;
   const char *fmt = luaL_checkstring(L, 1);  /* format string */
-  lua_Integer totalsize = 0;  /* accumulate total size of result */
+  size_t totalsize = 0;  /* accumulate total size of result */
   initheader(L, &h);
   while (*fmt != '\0') {
-    int ntoalign;
+    unsigned ntoalign;
     size_t size;
     KOption opt = getdetails(&h, totalsize, &fmt, &size, &ntoalign);
     luaL_argcheck(L, opt != Kstring && opt != Kzstr, 1,
                      "variable-length format");
     size += ntoalign;  /* total space used by option */
-    luaL_argcheck(L, totalsize <= LUA_MAXINTEGER - cast(lua_Integer, size),
+    luaL_argcheck(L, totalsize <= LUA_MAXINTEGER - size,
                      1, "format result too large");
     totalsize += size;
   }
-  lua_pushinteger(L, totalsize);
+  lua_pushinteger(L, cast_st2S(totalsize));
   return 1;
 }
 
@@ -1759,7 +1765,7 @@ static int str_unpack (lua_State *L) {
   luaL_argcheck(L, pos <= ld, 3, "initial position out of string");
   initheader(L, &h);
   while (*fmt != '\0') {
-    int ntoalign;
+    unsigned ntoalign;
     size_t size;
     KOption opt = getdetails(&h, pos, &fmt, &size, &ntoalign);
     luaL_argcheck(L, ntoalign + size <= ld - pos, 2,
@@ -1771,8 +1777,8 @@ static int str_unpack (lua_State *L) {
     switch (opt) {
       case Kint:
       case Kuint: {
-        lua_Integer res = unpackint(L, data + pos, h.islittle, size,
-                                       (opt == Kint));
+        lua_Integer res = unpackint(L, data + pos, h.islittle,
+                                       cast_int(size), (opt == Kint));
         lua_pushinteger(L, res);
         break;
       }
@@ -1800,7 +1806,7 @@ static int str_unpack (lua_State *L) {
       }
       case Kstring: {
         lua_Unsigned len = (lua_Unsigned)unpackint(L, data + pos,
-                                                      h.islittle, size, 0);
+                                          h.islittle, cast_int(size), 0);
         luaL_argcheck(L, len <= ld - pos - size, 2, "data string too short");
         lua_pushlstring(L, data + pos + size, len);
         pos += len;  /* skip string */
@@ -1820,7 +1826,7 @@ static int str_unpack (lua_State *L) {
     }
     pos += size;
   }
-  lua_pushinteger(L, pos + 1);  /* next position */
+  lua_pushinteger(L, cast_st2S(pos) + 1);  /* next position */
   return n + 1;
 }
 
diff --git a/ltable.c b/ltable.c
index 1be291c7..c2d957e9 100644
--- a/ltable.c
+++ b/ltable.c
@@ -109,7 +109,7 @@ typedef union {
 ** for other types, it is better to avoid modulo by power of 2, as
 ** they can have many 2 factors.
 */
-#define hashmod(t,n)    (gnode(t, ((n) % ((sizenode(t)-1)|1))))
+#define hashmod(t,n)    (gnode(t, ((n) % ((sizenode(t)-1u)|1u))))
 
 
 #define hashstr(t,str)          hashpow2(t, (str)->hash)
@@ -139,7 +139,7 @@ static const TValue absentkey = {ABSTKEYCONSTANT};
 static Node *hashint (const Table *t, lua_Integer i) {
   lua_Unsigned ui = l_castS2U(i);
   if (ui <= cast_uint(INT_MAX))
-    return hashmod(t, cast_int(ui));
+    return gnode(t, cast_int(ui) % cast_int((sizenode(t)-1) | 1));
   else
     return hashmod(t, ui);
 }
@@ -159,7 +159,7 @@ static Node *hashint (const Table *t, lua_Integer i) {
 ** INT_MIN.
 */
 #if !defined(l_hashfloat)
-static int l_hashfloat (lua_Number n) {
+static unsigned l_hashfloat (lua_Number n) {
   int i;
   lua_Integer ni;
   n = l_mathop(frexp)(n, &i) * -cast_num(INT_MIN);
@@ -169,7 +169,7 @@ static int l_hashfloat (lua_Number n) {
   }
   else {  /* normal case */
     unsigned int u = cast_uint(i) + cast_uint(ni);
-    return cast_int(u <= cast_uint(INT_MAX) ? u : ~u);
+    return (u <= cast_uint(INT_MAX) ? u : ~u);
   }
 }
 #endif
@@ -370,7 +370,7 @@ static unsigned findindex (lua_State *L, Table *t, TValue *key,
     const TValue *n = getgeneric(t, key, 1);
     if (l_unlikely(isabstkey(n)))
       luaG_runerror(L, "invalid key to 'next'");  /* key not found */
-    i = cast_int(nodefromval(n) - gnode(t, 0));  /* key index in hash table */
+    i = cast_uint(nodefromval(n) - gnode(t, 0));  /* key index in hash table */
     /* hash elements are numbered after array ones */
     return (i + 1) + asize;
   }
@@ -381,14 +381,14 @@ int luaH_next (lua_State *L, Table *t, StkId key) {
   unsigned int asize = luaH_realasize(t);
   unsigned int i = findindex(L, t, s2v(key), asize);  /* find original key */
   for (; i < asize; i++) {  /* try first array part */
-    int tag = *getArrTag(t, i);
+    lu_byte tag = *getArrTag(t, i);
     if (!tagisempty(tag)) {  /* a non-empty entry? */
-      setivalue(s2v(key), i + 1);
+      setivalue(s2v(key), cast_int(i) + 1);
       farr2val(t, i, tag, s2v(key + 1));
       return 1;
     }
   }
-  for (i -= asize; cast_int(i) < sizenode(t); i++) {  /* hash part */
+  for (i -= asize; i < sizenode(t); i++) {  /* hash part */
     if (!isempty(gval(gnode(t, i)))) {  /* a non-empty entry? */
       Node *n = gnode(t, i);
       getnodekey(L, s2v(key), n);
@@ -485,7 +485,7 @@ static unsigned computesizes (unsigned nums[], unsigned *pna) {
 }
 
 
-static int countint (lua_Integer key, unsigned int *nums) {
+static unsigned countint (lua_Integer key, unsigned int *nums) {
   unsigned int k = arrayindex(key);
   if (k != 0) {  /* is 'key' an appropriate array index? */
     nums[luaO_ceillog2(k)]++;  /* count as such */
@@ -496,7 +496,7 @@ static int countint (lua_Integer key, unsigned int *nums) {
 }
 
 
-l_sinline int arraykeyisempty (const Table *t, lua_Integer key) {
+l_sinline int arraykeyisempty (const Table *t, lua_Unsigned key) {
   int tag = *getArrTag(t, key - 1);
   return tagisempty(tag);
 }
@@ -534,10 +534,10 @@ static unsigned numusearray (const Table *t, unsigned *nums) {
 }
 
 
-static int numusehash (const Table *t, unsigned *nums, unsigned *pna) {
-  int totaluse = 0;  /* total number of elements */
-  int ause = 0;  /* elements added to 'nums' (can go to array part) */
-  int i = sizenode(t);
+static unsigned numusehash (const Table *t, unsigned *nums, unsigned *pna) {
+  unsigned totaluse = 0;  /* total number of elements */
+  unsigned ause = 0;  /* elements added to 'nums' (can go to array part) */
+  unsigned i = sizenode(t);
   while (i--) {
     Node *n = &t->node[i];
     if (!isempty(gval(n))) {
@@ -646,8 +646,8 @@ static void setnodevector (lua_State *L, Table *t, unsigned size) {
 ** (Re)insert all elements from the hash part of 'ot' into table 't'.
 */
 static void reinsert (lua_State *L, Table *ot, Table *t) {
-  int j;
-  int size = sizenode(ot);
+  unsigned j;
+  unsigned size = sizenode(ot);
   for (j = 0; j < size; j++) {
     Node *old = gnode(ot, j);
     if (!isempty(gval(old))) {
@@ -673,10 +673,10 @@ static void exchangehashpart (Table *t1, Table *t2) {
   int bitdummy1 = t1->flags & BITDUMMY;
   t1->lsizenode = t2->lsizenode;
   t1->node = t2->node;
-  t1->flags = (t1->flags & NOTBITDUMMY) | (t2->flags & BITDUMMY);
+  t1->flags = cast_byte((t1->flags & NOTBITDUMMY) | (t2->flags & BITDUMMY));
   t2->lsizenode = lsizenode;
   t2->node = node;
-  t2->flags = (t2->flags & NOTBITDUMMY) | bitdummy1;
+  t2->flags = cast_byte((t2->flags & NOTBITDUMMY) | bitdummy1);
 }
 
 
@@ -689,11 +689,12 @@ static void reinsertOldSlice (lua_State *L, Table *t, unsigned oldasize,
   unsigned i;
   t->alimit = newasize;  /* pretend array has new size... */
   for (i = newasize; i < oldasize; i++) {  /* traverse vanishing slice */
-    int tag = *getArrTag(t, i);
+    lu_byte tag = *getArrTag(t, i);
     if (!tagisempty(tag)) {  /* a non-empty entry? */
       TValue aux;
       farr2val(t, i, tag, &aux);  /* copy entry into 'aux' */
-      luaH_setint(L, t, i + 1, &aux);  /* re-insert it into the table */
+      /* re-insert it into the table */
+      luaH_setint(L, t, cast_int(i) + 1, &aux);
     }
   }
   t->alimit = oldasize;  /* restore current size... */
@@ -756,7 +757,7 @@ void luaH_resize (lua_State *L, Table *t, unsigned newasize,
 
 
 void luaH_resizearray (lua_State *L, Table *t, unsigned int nasize) {
-  int nsize = allocsizenode(t);
+  unsigned nsize = allocsizenode(t);
   luaH_resize(L, t, nasize, nsize);
 }
 
@@ -768,7 +769,7 @@ static void rehash (lua_State *L, Table *t, const TValue *ek) {
   unsigned int na;  /* number of keys in the array part */
   unsigned int nums[MAXABITS + 1];
   int i;
-  int totaluse;
+  unsigned totaluse;
   for (i = 0; i <= MAXABITS; i++) nums[i] = 0;  /* reset counts */
   setlimittosize(t);
   na = numusearray(t, nums);  /* count keys in array part */
@@ -795,7 +796,7 @@ Table *luaH_new (lua_State *L) {
   GCObject *o = luaC_newobj(L, LUA_VTABLE, sizeof(Table));
   Table *t = gco2t(o);
   t->metatable = NULL;
-  t->flags = cast_byte(maskflags);  /* table has no metamethod fields */
+  t->flags = maskflags;  /* table has no metamethod fields */
   t->array = NULL;
   t->alimit = 0;
   setnodevector(L, t, 0);
@@ -825,7 +826,7 @@ static Node *getfreepos (Table *t) {
   }
   else {  /* no 'lastfree' information */
     if (!isdummy(t)) {
-      int i = sizenode(t);
+      unsigned i = sizenode(t);
       while (i--) {  /* do a linear search */
         Node *free = gnode(t, i);
         if (keyisnil(free))
@@ -919,13 +920,13 @@ static const TValue *getintfromhash (Table *t, lua_Integer key) {
 }
 
 
-static int hashkeyisempty (Table *t, lua_Integer key) {
-  const TValue *val = getintfromhash(t, key);
+static int hashkeyisempty (Table *t, lua_Unsigned key) {
+  const TValue *val = getintfromhash(t, l_castU2S(key));
   return isempty(val);
 }
 
 
-static int finishnodeget (const TValue *val, TValue *res) {
+static lu_byte finishnodeget (const TValue *val, TValue *res) {
   if (!ttisnil(val)) {
     setobj(((lua_State*)NULL), res, val);
   }
@@ -933,9 +934,9 @@ static int finishnodeget (const TValue *val, TValue *res) {
 }
 
 
-int luaH_getint (Table *t, lua_Integer key, TValue *res) {
+lu_byte luaH_getint (Table *t, lua_Integer key, TValue *res) {
   if (keyinarray(t, key)) {
-    int tag = *getArrTag(t, key - 1);
+    lu_byte tag = *getArrTag(t, key - 1);
     if (!tagisempty(tag))
       farr2val(t, key - 1, tag, res);
     return tag;
@@ -964,7 +965,7 @@ const TValue *luaH_Hgetshortstr (Table *t, TString *key) {
 }
 
 
-int luaH_getshortstr (Table *t, TString *key, TValue *res) {
+lu_byte luaH_getshortstr (Table *t, TString *key, TValue *res) {
   return finishnodeget(luaH_Hgetshortstr(t, key), res);
 }
 
@@ -980,7 +981,7 @@ static const TValue *Hgetstr (Table *t, TString *key) {
 }
 
 
-int luaH_getstr (Table *t, TString *key, TValue *res) {
+lu_byte luaH_getstr (Table *t, TString *key, TValue *res) {
   return finishnodeget(Hgetstr(t, key), res);
 }
 
@@ -997,7 +998,7 @@ TString *luaH_getstrkey (Table *t, TString *key) {
 /*
 ** main search function
 */
-int luaH_get (Table *t, const TValue *key, TValue *res) {
+lu_byte luaH_get (Table *t, const TValue *key, TValue *res) {
   const TValue *slot;
   switch (ttypetag(key)) {
     case LUA_VSHRSTR:
@@ -1259,7 +1260,7 @@ lua_Unsigned luaH_getn (Table *t) {
   /* (3) 'limit' is the last element and either is zero or present in table */
   lua_assert(limit == luaH_realasize(t) &&
              (limit == 0 || !arraykeyisempty(t, limit)));
-  if (isdummy(t) || hashkeyisempty(t, cast(lua_Integer, limit + 1)))
+  if (isdummy(t) || hashkeyisempty(t, limit + 1))
     return limit;  /* 'limit + 1' is absent */
   else  /* 'limit + 1' is also present */
     return hash_search(t, limit);
diff --git a/ltable.h b/ltable.h
index 2e7f86fd..c6a87807 100644
--- a/ltable.h
+++ b/ltable.h
@@ -20,7 +20,7 @@
 ** may have any of these metamethods. (First access that fails after the
 ** clearing will set the bit again.)
 */
-#define invalidateTMcache(t)    ((t)->flags &= ~maskflags)
+#define invalidateTMcache(t)    ((t)->flags &= cast_byte(~maskflags))
 
 
 /*
@@ -137,10 +137,10 @@
   (*tag = (val)->tt_, *getArrVal(h,(k)) = (val)->value_)
 
 
-LUAI_FUNC int luaH_get (Table *t, const TValue *key, TValue *res);
-LUAI_FUNC int luaH_getshortstr (Table *t, TString *key, TValue *res);
-LUAI_FUNC int luaH_getstr (Table *t, TString *key, TValue *res);
-LUAI_FUNC int luaH_getint (Table *t, lua_Integer key, TValue *res);
+LUAI_FUNC lu_byte luaH_get (Table *t, const TValue *key, TValue *res);
+LUAI_FUNC lu_byte luaH_getshortstr (Table *t, TString *key, TValue *res);
+LUAI_FUNC lu_byte luaH_getstr (Table *t, TString *key, TValue *res);
+LUAI_FUNC lu_byte luaH_getint (Table *t, lua_Integer key, TValue *res);
 
 /* Special get for metamethods */
 LUAI_FUNC const TValue *luaH_Hgetshortstr (Table *t, TString *key);
diff --git a/ltablib.c b/ltablib.c
index b5948591..538d585d 100644
--- a/ltablib.c
+++ b/ltablib.c
@@ -192,7 +192,7 @@ static int tconcat (lua_State *L) {
 static int tpack (lua_State *L) {
   int i;
   int n = lua_gettop(L);  /* number of elements to pack */
-  lua_createtable(L, n, 1);  /* create result table */
+  lua_createtable(L, cast_uint(n), 1);  /* create result table */
   lua_insert(L, 1);  /* put it at index 1 */
   for (i = n; i >= 1; i--)  /* assign elements */
     lua_seti(L, 1, i);
@@ -207,7 +207,7 @@ static int tunpack (lua_State *L) {
   lua_Integer i = luaL_optinteger(L, 2, 1);
   lua_Integer e = luaL_opt(L, luaL_checkinteger, 3, luaL_len(L, 1));
   if (i > e) return 0;  /* empty range */
-  n = (lua_Unsigned)e - i;  /* number of elements minus 1 (avoid overflows) */
+  n = l_castS2U(e) - l_castS2U(i);  /* number of elements minus 1 */
   if (l_unlikely(n >= (unsigned int)INT_MAX  ||
                  !lua_checkstack(L, (int)(++n))))
     return luaL_error(L, "too many results to unpack");
diff --git a/ltests.c b/ltests.c
index ad40801e..8a6b4065 100644
--- a/ltests.c
+++ b/ltests.c
@@ -217,7 +217,7 @@ void *debug_realloc (void *ud, void *b, size_t oldsize, size_t size) {
     mc->memlimit = limit ? strtoul(limit, NULL, 10) : ULONG_MAX;
   }
   if (block == NULL) {
-    type = (oldsize < LUA_NUMTYPES) ? oldsize : 0;
+    type = (oldsize < LUA_NUMTYPES) ? cast_int(oldsize) : 0;
     oldsize = 0;
   }
   else {
@@ -567,7 +567,7 @@ static l_obj checkgraylist (global_State *g, GCObject *o) {
 ** Check objects in gray lists.
 */
 static l_obj checkgrays (global_State *g) {
-  int total = 0;  /* count number of elements in all lists */
+  l_obj total = 0;  /* count number of elements in all lists */
   if (!keepinvariant(g)) return total;
   total += checkgraylist(g, g->gray);
   total += checkgraylist(g, g->grayagain);
@@ -778,7 +778,7 @@ static int listk (lua_State *L) {
   luaL_argcheck(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1),
                  1, "Lua function expected");
   p = getproto(obj_at(L, 1));
-  lua_createtable(L, p->sizek, 0);
+  lua_createtable(L, cast_uint(p->sizek), 0);
   for (i=0; i<p->sizek; i++) {
     pushobject(L, p->k+i);
     lua_rawseti(L, -2, i+1);
@@ -794,7 +794,7 @@ static int listabslineinfo (lua_State *L) {
                  1, "Lua function expected");
   p = getproto(obj_at(L, 1));
   luaL_argcheck(L, p->abslineinfo != NULL, 1, "function has no debug info");
-  lua_createtable(L, 2 * p->sizeabslineinfo, 0);
+  lua_createtable(L, 2u * cast_uint(p->sizeabslineinfo), 0);
   for (i=0; i < p->sizeabslineinfo; i++) {
     lua_pushinteger(L, p->abslineinfo[i].pc);
     lua_rawseti(L, -2, 2 * i + 1);
@@ -847,9 +847,9 @@ static int get_limits (lua_State *L) {
 
 static int mem_query (lua_State *L) {
   if (lua_isnone(L, 1)) {
-    lua_pushinteger(L, l_memcontrol.total);
-    lua_pushinteger(L, l_memcontrol.numblocks);
-    lua_pushinteger(L, l_memcontrol.maxmem);
+    lua_pushinteger(L, cast(lua_Integer, l_memcontrol.total));
+    lua_pushinteger(L, cast(lua_Integer, l_memcontrol.numblocks));
+    lua_pushinteger(L, cast(lua_Integer, l_memcontrol.maxmem));
     return 3;
   }
   else if (lua_isnumber(L, 1)) {
@@ -863,7 +863,7 @@ static int mem_query (lua_State *L) {
     int i;
     for (i = LUA_NUMTYPES - 1; i >= 0; i--) {
       if (strcmp(t, ttypename(i)) == 0) {
-        lua_pushinteger(L, l_memcontrol.objcount[i]);
+        lua_pushinteger(L, cast(lua_Integer, l_memcontrol.objcount[i]));
         return 1;
       }
     }
@@ -874,9 +874,9 @@ static int mem_query (lua_State *L) {
 
 static int alloc_count (lua_State *L) {
   if (lua_isnone(L, 1))
-    l_memcontrol.countlimit = ~0L;
+    l_memcontrol.countlimit = cast(unsigned long, ~0L);
   else
-    l_memcontrol.countlimit = luaL_checkinteger(L, 1);
+    l_memcontrol.countlimit = cast(unsigned long, luaL_checkinteger(L, 1));
   return 0;
 }
 
@@ -975,26 +975,26 @@ static int gc_state (lua_State *L) {
 static int hash_query (lua_State *L) {
   if (lua_isnone(L, 2)) {
     luaL_argcheck(L, lua_type(L, 1) == LUA_TSTRING, 1, "string expected");
-    lua_pushinteger(L, tsvalue(obj_at(L, 1))->hash);
+    lua_pushinteger(L, cast_int(tsvalue(obj_at(L, 1))->hash));
   }
   else {
     TValue *o = obj_at(L, 1);
     Table *t;
     luaL_checktype(L, 2, LUA_TTABLE);
     t = hvalue(obj_at(L, 2));
-    lua_pushinteger(L, luaH_mainposition(t, o) - t->node);
+    lua_pushinteger(L, cast(lua_Integer, luaH_mainposition(t, o) - t->node));
   }
   return 1;
 }
 
 
 static int stacklevel (lua_State *L) {
-  unsigned long a = 0;
-  lua_pushinteger(L, (L->top.p - L->stack.p));
+  int a = 0;
+  lua_pushinteger(L, cast(lua_Integer, L->top.p - L->stack.p));
   lua_pushinteger(L, stacksize(L));
-  lua_pushinteger(L, L->nCcalls);
+  lua_pushinteger(L, cast(lua_Integer, L->nCcalls));
   lua_pushinteger(L, L->nci);
-  lua_pushinteger(L, (unsigned long)&a);
+  lua_pushinteger(L, (lua_Integer)(size_t)&a);
   return 5;
 }
 
@@ -1007,9 +1007,9 @@ static int table_query (lua_State *L) {
   t = hvalue(obj_at(L, 1));
   asize = luaH_realasize(t);
   if (i == -1) {
-    lua_pushinteger(L, asize);
-    lua_pushinteger(L, allocsizenode(t));
-    lua_pushinteger(L, t->alimit);
+    lua_pushinteger(L, cast(lua_Integer, asize));
+    lua_pushinteger(L, cast(lua_Integer, allocsizenode(t)));
+    lua_pushinteger(L, cast(lua_Integer, t->alimit));
     return 3;
   }
   else if (cast_uint(i) < asize) {
@@ -1018,7 +1018,7 @@ static int table_query (lua_State *L) {
     api_incr_top(L);
     lua_pushnil(L);
   }
-  else if ((i -= asize) < sizenode(t)) {
+  else if (cast_uint(i -= cast_int(asize)) < sizenode(t)) {
     TValue k;
     getnodekey(L, &k, gnode(t, i));
     if (!isempty(gval(gnode(t, i))) ||
@@ -1054,7 +1054,7 @@ static int query_GCparams (lua_State *L) {
 
 static int test_codeparam (lua_State *L) {
   lua_Integer p = luaL_checkinteger(L, 1);
-  lua_pushinteger(L, luaO_codeparam(p));
+  lua_pushinteger(L, luaO_codeparam(cast_uint(p)));
   return 1;
 }
 
@@ -1062,7 +1062,7 @@ static int test_codeparam (lua_State *L) {
 static int test_applyparam (lua_State *L) {
   lua_Integer p = luaL_checkinteger(L, 1);
   lua_Integer x = luaL_checkinteger(L, 2);
-  lua_pushinteger(L, luaO_applyparam(p, x));
+  lua_pushinteger(L, luaO_applyparam(cast_byte(p), x));
   return 1;
 }
 
@@ -1147,7 +1147,7 @@ static int upvalue (lua_State *L) {
 
 static int newuserdata (lua_State *L) {
   size_t size = cast_sizet(luaL_optinteger(L, 1, 0));
-  int nuv = luaL_optinteger(L, 2, 0);
+  int nuv = cast_int(luaL_optinteger(L, 2, 0));
   char *p = cast_charp(lua_newuserdatauv(L, size, nuv));
   while (size--) *p++ = '\0';
   return 1;
@@ -1227,8 +1227,8 @@ static lua_State *getstate (lua_State *L) {
 
 static int loadlib (lua_State *L) {
   lua_State *L1 = getstate(L);
-  int load = luaL_checkinteger(L, 2);
-  int preload = luaL_checkinteger(L, 3);
+  int load = cast_int(luaL_checkinteger(L, 2));
+  int preload = cast_int(luaL_checkinteger(L, 3));
   luaL_openselectedlibs(L1, load, preload);
   luaL_requiref(L1, "T", luaB_opentests, 0);
   lua_assert(lua_type(L1, -1) == LUA_TTABLE);
@@ -1490,13 +1490,13 @@ static int runC (lua_State *L, lua_State *L1, const char *pc) {
     }
     else if EQ("append") {
       int t = getindex;
-      int i = lua_rawlen(L1, t);
+      int i = cast_int(lua_rawlen(L1, t));
       lua_rawseti(L1, t, i + 1);
     }
     else if EQ("arith") {
       int op;
       skip(&pc);
-      op = strchr(ops, *pc++) - ops;
+      op = cast_int(strchr(ops, *pc++) - ops);
       lua_arith(L1, op);
     }
     else if EQ("call") {
@@ -1538,7 +1538,7 @@ static int runC (lua_State *L, lua_State *L1, const char *pc) {
     }
     else if EQ("func2num") {
       lua_CFunction func = lua_tocfunction(L1, getindex);
-      lua_pushnumber(L1, cast_sizet(func));
+      lua_pushinteger(L1, cast(lua_Integer, func));
     }
     else if EQ("getfield") {
       int t = getindex;
@@ -1624,13 +1624,13 @@ static int runC (lua_State *L, lua_State *L1, const char *pc) {
       lua_pushinteger(L1, lua_resetthread(L1));  /* deprecated */
     }
     else if EQ("newuserdata") {
-      lua_newuserdata(L1, getnum);
+      lua_newuserdata(L1, cast_sizet(getnum));
     }
     else if EQ("next") {
       lua_next(L1, -2);
     }
     else if EQ("objsize") {
-      lua_pushinteger(L1, lua_rawlen(L1, getindex));
+      lua_pushinteger(L1, l_castU2S(lua_rawlen(L1, getindex)));
     }
     else if EQ("pcall") {
       int narg = getnum;
@@ -1903,7 +1903,7 @@ static int Cfunck (lua_State *L, int status, lua_KContext ctx) {
   lua_setglobal(L, "status");
   lua_pushinteger(L, ctx);
   lua_setglobal(L, "ctx");
-  return runC(L, L, lua_tostring(L, ctx));
+  return runC(L, L, lua_tostring(L, cast_int(ctx)));
 }
 
 
diff --git a/ltm.c b/ltm.c
index 236f3bb4..8eca2d6e 100644
--- a/ltm.c
+++ b/ltm.c
@@ -116,8 +116,8 @@ void luaT_callTM (lua_State *L, const TValue *f, const TValue *p1,
 }
 
 
-int luaT_callTMres (lua_State *L, const TValue *f, const TValue *p1,
-                    const TValue *p2, StkId res) {
+lu_byte luaT_callTMres (lua_State *L, const TValue *f, const TValue *p1,
+                        const TValue *p2, StkId res) {
   ptrdiff_t result = savestack(L, res);
   StkId func = L->top.p;
   setobj2s(L, func, f);  /* push function (assume EXTRA_STACK) */
diff --git a/ltm.h b/ltm.h
index df05b741..ba2e4760 100644
--- a/ltm.h
+++ b/ltm.h
@@ -51,7 +51,7 @@ typedef enum {
 ** corresponding metamethod field. (Bit 6 of the flag indicates that
 ** the table is using the dummy node; bit 7 is used for 'isrealasize'.)
 */
-#define maskflags       (~(~0u << (TM_EQ + 1)))
+#define maskflags       cast_byte(~(~0u << (TM_EQ + 1)))
 
 
 /*
@@ -81,8 +81,8 @@ LUAI_FUNC void luaT_init (lua_State *L);
 
 LUAI_FUNC void luaT_callTM (lua_State *L, const TValue *f, const TValue *p1,
                             const TValue *p2, const TValue *p3);
-LUAI_FUNC int luaT_callTMres (lua_State *L, const TValue *f,
-                              const TValue *p1, const TValue *p2, StkId p3);
+LUAI_FUNC lu_byte luaT_callTMres (lua_State *L, const TValue *f,
+                               const TValue *p1, const TValue *p2, StkId p3);
 LUAI_FUNC void luaT_trybinTM (lua_State *L, const TValue *p1, const TValue *p2,
                               StkId res, TMS event);
 LUAI_FUNC void luaT_tryconcatTM (lua_State *L);
diff --git a/lua.c b/lua.c
index 3d807c98..9693ad68 100644
--- a/lua.c
+++ b/lua.c
@@ -185,7 +185,7 @@ static void print_version (void) {
 static void createargtable (lua_State *L, char **argv, int argc, int script) {
   int i, narg;
   narg = argc - (script + 1);  /* number of positive indices */
-  lua_createtable(L, narg, script + 1);
+  lua_createtable(L, cast_uint(narg), cast_uint(script + 1));
   for (i = 0; i < argc; i++) {
     lua_pushstring(L, argv[i]);
     lua_rawseti(L, -2, i - script);
diff --git a/lundump.c b/lundump.c
index b5dbaec9..4d6e8bd2 100644
--- a/lundump.c
+++ b/lundump.c
@@ -36,7 +36,7 @@ typedef struct {
   ZIO *Z;
   const char *name;
   Table *h;  /* list for string reuse */
-  lu_mem offset;  /* current position relative to beginning of dump */
+  size_t offset;  /* current position relative to beginning of dump */
   lua_Integer nstr;  /* number of strings in the list */
   lu_byte fixed;  /* dump is fixed in memory */
 } LoadState;
@@ -61,8 +61,8 @@ static void loadBlock (LoadState *S, void *b, size_t size) {
 }
 
 
-static void loadAlign (LoadState *S, int align) {
-  int padding = align - (S->offset % align);
+static void loadAlign (LoadState *S, unsigned align) {
+  unsigned padding = align - cast_uint(S->offset % align);
   if (padding < align) {  /* apd == align means no padding */
     lua_Integer paddingContent;
     loadBlock(S, &paddingContent, padding);
@@ -113,11 +113,19 @@ static size_t loadSize (LoadState *S) {
 }
 
 
+/*
+** Read an non-negative int */
+static unsigned loadUint (LoadState *S) {
+  return cast_uint(loadVarint(S, cast_sizet(INT_MAX)));
+}
+
+
 static int loadInt (LoadState *S) {
   return cast_int(loadVarint(S, cast_sizet(INT_MAX)));
 }
 
 
+
 static lua_Number loadNumber (LoadState *S) {
   lua_Number x;
   loadVar(S, x);
@@ -180,15 +188,15 @@ static void loadString (LoadState *S, Proto *p, TString **sl) {
 
 
 static void loadCode (LoadState *S, Proto *f) {
-  int n = loadInt(S);
+  unsigned n = loadUint(S);
   loadAlign(S, sizeof(f->code[0]));
   if (S->fixed) {
     f->code = getaddr(S, n, Instruction);
-    f->sizecode = n;
+    f->sizecode = cast_int(n);
   }
   else {
     f->code = luaM_newvectorchecked(S->L, n, Instruction);
-    f->sizecode = n;
+    f->sizecode = cast_int(n);
     loadVector(S, f->code, n);
   }
 }
@@ -198,10 +206,10 @@ static void loadFunction(LoadState *S, Proto *f);
 
 
 static void loadConstants (LoadState *S, Proto *f) {
-  int i;
-  int n = loadInt(S);
+  unsigned i;
+  unsigned n = loadUint(S);
   f->k = luaM_newvectorchecked(S->L, n, TValue);
-  f->sizek = n;
+  f->sizek = cast_int(n);
   for (i = 0; i < n; i++)
     setnilvalue(&f->k[i]);
   for (i = 0; i < n; i++) {
@@ -240,10 +248,10 @@ static void loadConstants (LoadState *S, Proto *f) {
 
 
 static void loadProtos (LoadState *S, Proto *f) {
-  int i;
-  int n = loadInt(S);
+  unsigned i;
+  unsigned n = loadUint(S);
   f->p = luaM_newvectorchecked(S->L, n, Proto *);
-  f->sizep = n;
+  f->sizep = cast_int(n);
   for (i = 0; i < n; i++)
     f->p[i] = NULL;
   for (i = 0; i < n; i++) {
@@ -261,10 +269,10 @@ static void loadProtos (LoadState *S, Proto *f) {
 ** in that case all prototypes must be consistent for the GC.
 */
 static void loadUpvalues (LoadState *S, Proto *f) {
-  int i, n;
-  n = loadInt(S);
+  unsigned i;
+  unsigned n = loadUint(S);
   f->upvalues = luaM_newvectorchecked(S->L, n, Upvaldesc);
-  f->sizeupvalues = n;
+  f->sizeupvalues = cast_int(n);
   for (i = 0; i < n; i++)  /* make array valid for GC */
     f->upvalues[i].name = NULL;
   for (i = 0; i < n; i++) {  /* following calls can raise errors */
@@ -276,33 +284,33 @@ static void loadUpvalues (LoadState *S, Proto *f) {
 
 
 static void loadDebug (LoadState *S, Proto *f) {
-  int i, n;
-  n = loadInt(S);
+  unsigned i;
+  unsigned n = loadUint(S);
   if (S->fixed) {
     f->lineinfo = getaddr(S, n, ls_byte);
-    f->sizelineinfo = n;
+    f->sizelineinfo = cast_int(n);
   }
   else {
     f->lineinfo = luaM_newvectorchecked(S->L, n, ls_byte);
-    f->sizelineinfo = n;
+    f->sizelineinfo = cast_int(n);
     loadVector(S, f->lineinfo, n);
   }
-  n = loadInt(S);
+  n = loadUint(S);
   if (n > 0) {
     loadAlign(S, sizeof(int));
     if (S->fixed) {
       f->abslineinfo = getaddr(S, n, AbsLineInfo);
-      f->sizeabslineinfo = n;
+      f->sizeabslineinfo = cast_int(n);
     }
     else {
       f->abslineinfo = luaM_newvectorchecked(S->L, n, AbsLineInfo);
-      f->sizeabslineinfo = n;
+      f->sizeabslineinfo = cast_int(n);
       loadVector(S, f->abslineinfo, n);
     }
   }
-  n = loadInt(S);
+  n = loadUint(S);
   f->locvars = luaM_newvectorchecked(S->L, n, LocVar);
-  f->sizelocvars = n;
+  f->sizelocvars = cast_int(n);
   for (i = 0; i < n; i++)
     f->locvars[i].varname = NULL;
   for (i = 0; i < n; i++) {
@@ -310,9 +318,9 @@ static void loadDebug (LoadState *S, Proto *f) {
     f->locvars[i].startpc = loadInt(S);
     f->locvars[i].endpc = loadInt(S);
   }
-  n = loadInt(S);
+  n = loadUint(S);
   if (n != 0)  /* does it have debug information? */
-    n = f->sizeupvalues;  /* must be this many */
+    n = cast_uint(f->sizeupvalues);  /* must be this many */
   for (i = 0; i < n; i++)
     loadString(S, f, &f->upvalues[i].name);
 }
@@ -384,7 +392,7 @@ LClosure *luaU_undump (lua_State *L, ZIO *Z, const char *name, int fixed) {
     S.name = name;
   S.L = L;
   S.Z = Z;
-  S.fixed = fixed;
+  S.fixed = cast_byte(fixed);
   S.offset = 1;  /* fist byte was already read */
   checkHeader(&S);
   cl = luaF_newLclosure(L, loadByte(&S));
diff --git a/lutf8lib.c b/lutf8lib.c
index 243196c8..6dfdd1f4 100644
--- a/lutf8lib.c
+++ b/lutf8lib.c
@@ -180,7 +180,7 @@ static int byteoffset (lua_State *L) {
   size_t len;
   const char *s = luaL_checklstring(L, 1, &len);
   lua_Integer n  = luaL_checkinteger(L, 2);
-  lua_Integer posi = (n >= 0) ? 1 : len + 1;
+  lua_Integer posi = (n >= 0) ? 1 : cast_st2S(len) + 1;
   posi = u_posrelat(luaL_optinteger(L, 3, posi), len);
   luaL_argcheck(L, 1 <= posi && --posi <= (lua_Integer)len, 3,
                    "position out of bounds");
@@ -239,7 +239,7 @@ static int iter_aux (lua_State *L, int strict) {
     const char *next = utf8_decode(s + n, &code, strict);
     if (next == NULL || iscontp(next))
       return luaL_error(L, MSGInvalid);
-    lua_pushinteger(L, n + 1);
+    lua_pushinteger(L, l_castU2S(n + 1));
     lua_pushinteger(L, code);
     return 2;
   }
diff --git a/lvm.c b/lvm.c
index 5771c31a..33da5609 100644
--- a/lvm.c
+++ b/lvm.c
@@ -288,8 +288,8 @@ static int floatforloop (StkId ra) {
 /*
 ** Finish the table access 'val = t[key]' and return the tag of the result.
 */
-int luaV_finishget (lua_State *L, const TValue *t, TValue *key, StkId val,
-                      int tag) {
+lu_byte luaV_finishget (lua_State *L, const TValue *t, TValue *key,
+                                      StkId val, lu_byte tag) {
   int loop;  /* counter to avoid infinite loops */
   const TValue *tm;  /* metamethod */
   for (loop = 0; loop < MAXTAGLOOP; loop++) {
@@ -690,7 +690,7 @@ void luaV_objlen (lua_State *L, StkId ra, const TValue *rb) {
       Table *h = hvalue(rb);
       tm = fasttm(L, h->metatable, TM_LEN);
       if (tm) break;  /* metamethod? break switch to call it */
-      setivalue(s2v(ra), luaH_getn(h));  /* else primitive len */
+      setivalue(s2v(ra), l_castU2S(luaH_getn(h)));  /* else primitive len */
       return;
     }
     case LUA_VSHRSTR: {
@@ -698,7 +698,7 @@ void luaV_objlen (lua_State *L, StkId ra, const TValue *rb) {
       return;
     }
     case LUA_VLNGSTR: {
-      setivalue(s2v(ra), tsvalue(rb)->u.lnglen);
+      setivalue(s2v(ra), cast_st2S(tsvalue(rb)->u.lnglen));
       return;
     }
     default: {  /* try metamethod */
@@ -1255,7 +1255,7 @@ void luaV_execute (lua_State *L, CallInfo *ci) {
         TValue *upval = cl->upvals[GETARG_B(i)]->v.p;
         TValue *rc = KC(i);
         TString *key = tsvalue(rc);  /* key must be a short string */
-        int tag;
+        lu_byte tag;
         luaV_fastget(upval, key, s2v(ra), luaH_getshortstr, tag);
         if (tagisempty(tag))
           Protect(luaV_finishget(L, upval, rc, ra, tag));
@@ -1265,7 +1265,7 @@ void luaV_execute (lua_State *L, CallInfo *ci) {
         StkId ra = RA(i);
         TValue *rb = vRB(i);
         TValue *rc = vRC(i);
-        int tag;
+        lu_byte tag;
         if (ttisinteger(rc)) {  /* fast track for integers? */
           luaV_fastgeti(rb, ivalue(rc), s2v(ra), tag);
         }
@@ -1279,7 +1279,7 @@ void luaV_execute (lua_State *L, CallInfo *ci) {
         StkId ra = RA(i);
         TValue *rb = vRB(i);
         int c = GETARG_C(i);
-        int tag;
+        lu_byte tag;
         luaV_fastgeti(rb, c, s2v(ra), tag);
         if (tagisempty(tag)) {
           TValue key;
@@ -1293,7 +1293,7 @@ void luaV_execute (lua_State *L, CallInfo *ci) {
         TValue *rb = vRB(i);
         TValue *rc = KC(i);
         TString *key = tsvalue(rc);  /* key must be a short string */
-        int tag;
+        lu_byte tag;
         luaV_fastget(rb, key, s2v(ra), luaH_getshortstr, tag);
         if (tagisempty(tag))
           Protect(luaV_finishget(L, rb, rc, ra, tag));
@@ -1359,14 +1359,15 @@ void luaV_execute (lua_State *L, CallInfo *ci) {
       }
       vmcase(OP_NEWTABLE) {
         StkId ra = RA(i);
-        int b = GETARG_vB(i);  /* log2(hash size) + 1 */
-        int c = GETARG_vC(i);  /* array size */
+        unsigned b = cast_uint(GETARG_vB(i));  /* log2(hash size) + 1 */
+        unsigned c = cast_uint(GETARG_vC(i));  /* array size */
         Table *t;
         if (b > 0)
-          b = 1 << (b - 1);  /* hash size is 2^(b - 1) */
+          b = 1u << (b - 1);  /* hash size is 2^(b - 1) */
         if (TESTARG_k(i)) {  /* non-zero extra argument? */
           lua_assert(GETARG_Ax(*pc) != 0);
-          c += GETARG_Ax(*pc) * (MAXARG_vC + 1);  /* add it to array size */
+          /* add it to array size */
+          c += cast_uint(GETARG_Ax(*pc)) * (MAXARG_vC + 1);
         }
         pc++;  /* skip extra argument */
         L->top.p = ra + 1;  /* correct top in case of emergency GC */
@@ -1379,7 +1380,7 @@ void luaV_execute (lua_State *L, CallInfo *ci) {
       }
       vmcase(OP_SELF) {
         StkId ra = RA(i);
-        int tag;
+        lu_byte tag;
         TValue *rb = vRB(i);
         TValue *rc = RKC(i);
         TString *key = tsvalue(rc);  /* key must be a string */
@@ -1786,7 +1787,7 @@ void luaV_execute (lua_State *L, CallInfo *ci) {
           if (count > 0) {  /* still more iterations? */
             lua_Integer step = ivalue(s2v(ra + 1));
             lua_Integer idx = ivalue(s2v(ra + 2));  /* control variable */
-            chgivalue(s2v(ra), count - 1);  /* update counter */
+            chgivalue(s2v(ra), l_castU2S(count - 1));  /* update counter */
             idx = intop(+, idx, step);  /* add step to index */
             chgivalue(s2v(ra + 2), idx);  /* update control variable */
             pc -= GETARG_Bx(i);  /* jump back */
@@ -1851,16 +1852,16 @@ void luaV_execute (lua_State *L, CallInfo *ci) {
       }}
       vmcase(OP_SETLIST) {
         StkId ra = RA(i);
-        int n = GETARG_vB(i);
-        unsigned int last = GETARG_vC(i);
+        unsigned n = cast_uint(GETARG_vB(i));
+        unsigned int last = cast_uint(GETARG_vC(i));
         Table *h = hvalue(s2v(ra));
         if (n == 0)
-          n = cast_int(L->top.p - ra) - 1;  /* get up to the top */
+          n = cast_uint(L->top.p - ra) - 1;  /* get up to the top */
         else
           L->top.p = ci->top.p;  /* correct top in case of emergency GC */
         last += n;
         if (TESTARG_k(i)) {
-          last += GETARG_Ax(*pc) * (MAXARG_vC + 1);
+          last += cast_uint(GETARG_Ax(*pc)) * (MAXARG_vC + 1);
           pc++;
         }
         /* when 'n' is known, table should have proper size */
diff --git a/lvm.h b/lvm.h
index a11db83c..c8898559 100644
--- a/lvm.h
+++ b/lvm.h
@@ -120,8 +120,8 @@ LUAI_FUNC int luaV_tointeger (const TValue *obj, lua_Integer *p, F2Imod mode);
 LUAI_FUNC int luaV_tointegerns (const TValue *obj, lua_Integer *p,
                                 F2Imod mode);
 LUAI_FUNC int luaV_flttointeger (lua_Number n, lua_Integer *p, F2Imod mode);
-LUAI_FUNC int luaV_finishget (lua_State *L, const TValue *t, TValue *key,
-                                            StkId val, int tag);
+LUAI_FUNC lu_byte luaV_finishget (lua_State *L, const TValue *t, TValue *key,
+                                                StkId val, lu_byte tag);
 LUAI_FUNC void luaV_finishset (lua_State *L, const TValue *t, TValue *key,
                                              TValue *val, int aux);
 LUAI_FUNC void luaV_finishOp (lua_State *L);
diff --git a/lzio.h b/lzio.h
index 55cc74ad..49047c98 100644
--- a/lzio.h
+++ b/lzio.h
@@ -32,7 +32,7 @@ typedef struct Mbuffer {
 #define luaZ_sizebuffer(buff)   ((buff)->buffsize)
 #define luaZ_bufflen(buff)      ((buff)->n)
 
-#define luaZ_buffremove(buff,i) ((buff)->n -= (i))
+#define luaZ_buffremove(buff,i) ((buff)->n -= cast_sizet(i))
 #define luaZ_resetbuffer(buff) ((buff)->n = 0)
 
 
diff --git a/makefile b/makefile
index 58b12f8e..b37fdb28 100644
--- a/makefile
+++ b/makefile
@@ -14,11 +14,11 @@ CWARNSCPP= \
         -Wdisabled-optimization \
         -Wdouble-promotion \
         -Wmissing-declarations \
+        -Wconversion \
         # the next warnings might be useful sometimes,
         # but usually they generate too much noise
         # -Werror \
         # -pedantic   # warns if we use jump tables \
-        # -Wconversion  \
         # -Wsign-conversion \
         # -Wstrict-overflow=2 \
         # -Wformat=2 \
diff --git a/manual/manual.of b/manual/manual.of
index c7f6904a..93e3a114 100644
--- a/manual/manual.of
+++ b/manual/manual.of
@@ -3995,7 +3995,7 @@ The conversion specifiers can only be
 @Char{%p} (inserts a pointer),
 @Char{%d} (inserts an @T{int}),
 @Char{%c} (inserts an @T{int} as a one-byte character), and
-@Char{%U} (inserts a @T{long int} as a @x{UTF-8} byte sequence).
+@Char{%U} (inserts an @T{unsigned long} as a @x{UTF-8} byte sequence).
 
 This function may raise errors due to memory overflow
 or an invalid conversion specifier.