From 0acd55898d0aaae8dbc14c8a1bc1e3bdffc8701b Mon Sep 17 00:00:00 2001 From: Roberto Ierusalimschy Date: Sat, 27 Jul 2024 13:32:59 -0300 Subject: [PATCH] Added gcc option '-Wconversion' No warnings for standard numerical types. Still pending alternative numerical types. --- lapi.c | 26 +++++----- lauxlib.c | 8 +-- lbaselib.c | 15 +++--- lcode.c | 34 ++++++------ lcode.h | 2 +- ldebug.c | 4 +- ldo.c | 10 ++-- ldump.c | 18 +++---- lfunc.c | 14 ++--- lfunc.h | 8 +-- lgc.c | 14 ++--- lgc.h | 4 +- liolib.c | 8 +-- llex.c | 2 +- llimits.h | 11 ++++ lmathlib.c | 12 ++--- lmem.c | 6 +-- lmem.h | 2 +- loadlib.c | 8 +-- lobject.c | 68 ++++++++++++------------ lobject.h | 20 +++---- lopcodes.h | 7 ++- loslib.c | 2 +- lparser.c | 34 ++++++------ lparser.h | 2 +- lstate.c | 5 +- lstate.h | 2 +- lstring.c | 8 +-- lstring.h | 3 +- lstrlib.c | 132 +++++++++++++++++++++++++---------------------- ltable.c | 67 ++++++++++++------------ ltable.h | 10 ++-- ltablib.c | 4 +- ltests.c | 62 +++++++++++----------- ltm.c | 4 +- ltm.h | 6 +-- lua.c | 2 +- lundump.c | 62 ++++++++++++---------- lutf8lib.c | 4 +- lvm.c | 37 ++++++------- lvm.h | 4 +- lzio.h | 2 +- makefile | 2 +- manual/manual.of | 2 +- 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 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; icapture[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; isizek; 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.