lua-users home
lua-l archive

[Date Prev][Date Next][Thread Prev][Thread Next] [Date Index] [Thread Index]




Le mer. 15 avr. 2020 à 15:45, Luiz Henrique de Figueiredo <lhf@tecgraf.puc-rio.br> a écrit :
Lua 5.4.0 (rc1) is now available for testing at
        http://www.lua.org/work/lua-5.4.0-rc1.tar.gz

The checksums are
        MD5     276c5d873d9358fd82d1a3c372123e38  -
        SHA1    33257f2b5c3fb4966b3a5a67611c1d4aaf72dca8  -

This is the final version of Lua 5.4.0 (rc1).

The main changes in Lua 5.4.0 are listed at
        http://www.lua.org/work/doc/#changes

An updated reference manual is included and also available at
        http://www.lua.org/work/doc

The complete diffs from beta to rc1 are available at
        http://www.lua.org/work/diffs-lua-5.4.0-beta-rc1.html
        http://www.lua.org/work/diffu-lua-5.4.0-beta-rc1.html

A test suite is available at
        http://www.lua.org/work/lua-5.4.0-tests.tar.gz

To build Lua in a common Unix-like platform, just do
        make
The Makefile will guess your platform using uname and build Lua for it.
We welcome feedback on this, which is new, especially more uname targets
with explicit rules and fixes for existing ones.

We also welcome feedback on the listings output by luac -l -l, because
luac has been rewritten to account for the new VM instructions.

All feedback welcome. Thanks.

find in attachment some fixes for minor issues (found with a linter).

François
 
--lhf

remove unused macro

diff --git a/src/loadlib.c b/src/loadlib.c
index 56167f6..96a4296 100644
--- a/src/loadlib.c
+++ b/src/loadlib.c
@@ -269,9 +269,6 @@
 #endif
 
 
-#define AUXMARK         "\1"	/* auxiliary mark */
-
-
 /*
 ** return registry.LUA_NOENV as a boolean
 */
diff --git a/src/luac.c b/src/luac.c
index 9417a88..7288432 100644
--- a/src/luac.c
+++ b/src/luac.c
@@ -329,7 +329,6 @@
 
 #define COMMENT		"\t; "
 #define EXTRAARG	GETARG_Ax(code[pc+1])
-#define EXTRAARGC	EXTRAARG*(MAXARG_C+1)
 #define ISK		(isk ? "k" : "")
 
 static void PrintCode(const Proto* f)
-- 

remove useless include

note: stddef.h could be more useful in lopnames.h

diff --git a/src/lopcodes.c b/src/lopcodes.c
index 4e983e0..c67aa22 100644
--- a/src/lopcodes.c
+++ b/src/lopcodes.c
@@ -10,8 +10,6 @@
 #include "lprefix.h"
 
 
-#include <stddef.h>
-
 #include "lopcodes.h"
 
 
-- 
remove extraneous comma

diff --git a/src/lvm.h b/src/lvm.h
index 7103857..d20f85a 100644
--- a/src/lvm.h
+++ b/src/lvm.h
@@ -43,7 +43,7 @@
 typedef enum {
   F2Ieq,  /* no rounding; accepts only integral values */
   F2Ifloor,  /* takes the floor of the number */
-  F2Iceil,  /* takes the ceil of the number */
+  F2Iceil  /* takes the ceil of the number */
 } F2Imod;
 
 
-- 
const parameters in static function

diff --git a/src/lapi.c b/src/lapi.c
index 3e24781..871fad2 100644
--- a/src/lapi.c
+++ b/src/lapi.c
@@ -851,7 +851,7 @@ LUA_API void lua_seti (lua_State *L, int idx, lua_Integer n) {
 }
 
 
-static void aux_rawset (lua_State *L, int idx, TValue *key, int n) {
+static void aux_rawset (lua_State *L, int idx, const TValue *key, int n) {
   Table *t;
   TValue *slot;
   lua_lock(L);
@@ -1309,7 +1309,7 @@ LUA_API void *lua_newuserdatauv (lua_State *L, size_t size, int nuvalue) {
 
 
 
-static const char *aux_upvalue (TValue *fi, int n, TValue **val,
+static const char *aux_upvalue (const TValue *fi, int n, TValue **val,
                                 GCObject **owner) {
   switch (ttypetag(fi)) {
     case LUA_VCCL: {  /* C closure */
diff --git a/src/lauxlib.c b/src/lauxlib.c
index 7235909..907db63 100644
--- a/src/lauxlib.c
+++ b/src/lauxlib.c
@@ -517,7 +517,7 @@ static void newbox (lua_State *L) {
 ** Compute new size for buffer 'B', enough to accommodate extra 'sz'
 ** bytes.
 */
-static size_t newbuffsize (luaL_Buffer *B, size_t sz) {
+static size_t newbuffsize (const luaL_Buffer *B, size_t sz) {
   size_t newsize = B->size * 2;  /* double buffer size */
   if (MAX_SIZET - sz < B->n)  /* overflow in (B->n + sz)? */
     return luaL_error(B->L, "buffer too large");
diff --git a/src/lcode.c b/src/lcode.c
index 6f241c9..4d0e7ac 100644
--- a/src/lcode.c
+++ b/src/lcode.c
@@ -70,7 +70,7 @@ static int tonumeral (const expdesc *e, TValue *v) {
 /*
 ** Get the constant value from a constant expression
 */
-static TValue *const2val (FuncState *fs, const expdesc *e) {
+static TValue *const2val (const FuncState *fs, const expdesc *e) {
   lua_assert(e->k == VCONST);
   return &fs->ls->dyd->actvar.arr[e->u.info].k;
 }
@@ -112,7 +112,7 @@ int luaK_exp2const (FuncState *fs, const expdesc *e, TValue *v) {
 ** previous one, return an invalid instruction (to avoid wrong
 ** optimizations).
 */
-static Instruction *previousinstruction (FuncState *fs) {
+static Instruction *previousinstruction (const FuncState *fs) {
   static const Instruction invalidinstruction = ~(Instruction)0;
   if (fs->pc > fs->lasttarget)
     return &fs->f->code[fs->pc - 1];  /* previous instruction */
@@ -150,7 +150,7 @@ void luaK_nil (FuncState *fs, int from, int n) {
 ** Gets the destination address of a jump instruction. Used to traverse
 ** a list of jumps.
 */
-static int getjump (FuncState *fs, int pc) {
+static int getjump (const FuncState *fs, int pc) {
   int offset = GETARG_sJ(fs->f->code[pc]);
   if (offset == NO_JUMP)  /* point to itself represents end of list */
     return NO_JUMP;  /* end of list */
@@ -163,7 +163,7 @@ static int getjump (FuncState *fs, int pc) {
 ** Fix jump instruction at position 'pc' to jump to 'dest'.
 ** (Jump addresses are relative in Lua)
 */
-static void fixjump (FuncState *fs, int pc, int dest) {
+static void fixjump (const FuncState *fs, int pc, int dest) {
   Instruction *jmp = &fs->f->code[pc];
   int offset = dest - (pc + 1);
   lua_assert(dest != NO_JUMP);
@@ -239,7 +239,7 @@ int luaK_getlabel (FuncState *fs) {
 ** jump (that is, its condition), or the jump itself if it is
 ** unconditional.
 */
-static Instruction *getjumpcontrol (FuncState *fs, int pc) {
+static Instruction *getjumpcontrol (const FuncState *fs, int pc) {
   Instruction *pi = &fs->f->code[pc];
   if (pc >= 1 && testTMode(GET_OPCODE(*(pi-1))))
     return pi-1;
@@ -255,7 +255,7 @@ static Instruction *getjumpcontrol (FuncState *fs, int pc) {
 ** register. Otherwise, change instruction to a simple 'TEST' (produces
 ** no register value)
 */
-static int patchtestreg (FuncState *fs, int node, int reg) {
+static int patchtestreg (const FuncState *fs, int node, int reg) {
   Instruction *i = getjumpcontrol(fs, node);
   if (GET_OPCODE(*i) != OP_TESTSET)
     return 0;  /* cannot patch other instructions */
@@ -273,7 +273,7 @@ static int patchtestreg (FuncState *fs, int node, int reg) {
 /*
 ** Traverse a list of tests ensuring no one produces a value
 */
-static void removevalues (FuncState *fs, int list) {
+static void removevalues (const FuncState *fs, int list) {
   for (; list != NO_JUMP; list = getjump(fs, list))
       patchtestreg(fs, list, NO_REG);
 }
@@ -284,7 +284,7 @@ static void removevalues (FuncState *fs, int list) {
 ** registers: tests producing values jump to 'vtarget' (and put their
 ** values in 'reg'), other tests jump to 'dtarget'.
 */
-static void patchlistaux (FuncState *fs, int list, int vtarget, int reg,
+static void patchlistaux (const FuncState *fs, int list, int vtarget, int reg,
                           int dtarget) {
   while (list != NO_JUMP) {
     int next = getjump(fs, list);
@@ -522,7 +522,7 @@ static void freeregs (FuncState *fs, int r1, int r2) {
 /*
 ** Free register used by expression 'e' (if any)
 */
-static void freeexp (FuncState *fs, expdesc *e) {
+static void freeexp (FuncState *fs, const expdesc *e) {
   if (e->k == VNONRELOC)
     freereg(fs, e->u.info);
 }
@@ -532,7 +532,7 @@ static void freeexp (FuncState *fs, expdesc *e) {
 ** Free registers used by expressions 'e1' and 'e2' (if any) in proper
 ** order.
 */
-static void freeexps (FuncState *fs, expdesc *e1, expdesc *e2) {
+static void freeexps (FuncState *fs, const expdesc *e1, const expdesc *e2) {
   int r1 = (e1->k == VNONRELOC) ? e1->u.info : -1;
   int r2 = (e2->k == VNONRELOC) ? e2->u.info : -1;
   freeregs(fs, r1, r2);
@@ -546,7 +546,7 @@ static void freeexps (FuncState *fs, expdesc *e1, expdesc *e2) {
 ** as keys (nil cannot be a key, integer keys can collapse with float
 ** keys), the caller must provide a useful 'key' for indexing the cache.
 */
-static int addk (FuncState *fs, TValue *key, TValue *v) {
+static int addk (FuncState *fs, const TValue *key, const TValue *v) {
   lua_State *L = fs->ls->L;
   Proto *f = fs->f;
   TValue *idx = luaH_set(L, fs->ls->h, key);  /* index scanner table */
@@ -676,7 +676,7 @@ static void luaK_float (FuncState *fs, int reg, lua_Number f) {
 /*
 ** Convert a constant in 'v' into an expression description 'e'
 */
-static void const2exp (TValue *v, expdesc *e) {
+static void const2exp (const TValue *v, expdesc *e) {
   switch (ttypetag(v)) {
     case LUA_VNUMINT:
       e->k = VKINT; e->u.ival = ivalue(v);
@@ -881,7 +881,7 @@ static int code_loadbool (FuncState *fs, int A, OpCode op) {
 ** check whether list has any jump that do not produce a value
 ** or produce an inverted value
 */
-static int need_value (FuncState *fs, int list) {
+static int need_value (const FuncState *fs, int list) {
   for (; list != NO_JUMP; list = getjump(fs, list)) {
     Instruction i = *getjumpcontrol(fs, list);
     if (GET_OPCODE(i) != OP_TESTSET) return 1;
@@ -1081,7 +1081,7 @@ void luaK_self (FuncState *fs, expdesc *e, expdesc *key) {
 /*
 ** Negate condition 'e' (where 'e' is a comparison).
 */
-static void negatecondition (FuncState *fs, expdesc *e) {
+static void negatecondition (const FuncState *fs, const expdesc *e) {
   Instruction *pc = getjumpcontrol(fs, e->u.info);
   lua_assert(testTMode(GET_OPCODE(*pc)) && GET_OPCODE(*pc) != OP_TESTSET &&
                                            GET_OPCODE(*pc) != OP_TEST);
@@ -1200,7 +1200,7 @@ static void codenot (FuncState *fs, expdesc *e) {
 /*
 ** Check whether expression 'e' is a small literal string
 */
-static int isKstr (FuncState *fs, expdesc *e) {
+static int isKstr (const FuncState *fs, const expdesc *e) {
   return (e->k == VK && !hasjumps(e) && e->u.info <= MAXARG_B &&
           ttisshrstring(&fs->f->k[e->u.info]));
 }
@@ -1235,7 +1235,7 @@ static int isSCint (expdesc *e) {
 ** Check whether expression 'e' is a literal integer or float in
 ** proper range to fit in a register (sB or sC).
 */
-static int isSCnumber (expdesc *e, int *pi, int *isfloat) {
+static int isSCnumber (const expdesc *e, int *pi, int *isfloat) {
   lua_Integer i;
   if (e->k == VKINT)
     i = e->u.ival;
@@ -1294,7 +1294,7 @@ void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k) {
 ** Bitwise operations need operands convertible to integers; division
 ** operations cannot have 0 as divisor.
 */
-static int validop (int op, TValue *v1, TValue *v2) {
+static int validop (int op, const TValue *v1, const TValue *v2) {
   switch (op) {
     case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR:
     case LUA_OPSHL: case LUA_OPSHR: case LUA_OPBNOT: {  /* conversion errors */
@@ -1312,7 +1312,7 @@ static int validop (int op, TValue *v1, TValue *v2) {
 ** Try to "constant-fold" an operation; return 1 iff successful.
 ** (In this case, 'e1' has the final result.)
 */
-static int constfolding (FuncState *fs, int op, expdesc *e1,
+static int constfolding (const FuncState *fs, int op, expdesc *e1,
                                         const expdesc *e2) {
   TValue v1, v2, res;
   if (!tonumeral(e1, &v1) || !tonumeral(e2, &v2) || !validop(op, &v1, &v2))
@@ -1353,7 +1353,7 @@ static void codeunexpval (FuncState *fs, OpCode op, expdesc *e, int line) {
 ** operators).
 ** Expression to produce final result will be encoded in 'e1'.
 */
-static void finishbinexpval (FuncState *fs, expdesc *e1, expdesc *e2,
+static void finishbinexpval (FuncState *fs, expdesc *e1, const expdesc *e2,
                              OpCode op, int v2, int flip, int line,
                              OpCode mmop, TMS event) {
   int v1 = luaK_exp2anyreg(fs, e1);
@@ -1384,7 +1384,7 @@ static void codebinexpval (FuncState *fs, OpCode op,
 ** Code binary operators with immediate operands.
 */
 static void codebini (FuncState *fs, OpCode op,
-                       expdesc *e1, expdesc *e2, int flip, int line,
+                       expdesc *e1, const expdesc *e2, int flip, int line,
                        TMS event) {
   int v2 = int2sC(cast_int(e2->u.ival));  /* immediate operand */
   lua_assert(e2->k == VKINT);
@@ -1619,7 +1619,7 @@ void luaK_infix (FuncState *fs, BinOpr op, expdesc *v) {
 ** For '(e1 .. e2.1 .. e2.2)' (which is '(e1 .. (e2.1 .. e2.2))',
 ** because concatenation is right associative), merge both CONCATs.
 */
-static void codeconcat (FuncState *fs, expdesc *e1, expdesc *e2, int line) {
+static void codeconcat (FuncState *fs, const expdesc *e1, const expdesc *e2, int line) {
   Instruction *ie2 = previousinstruction(fs);
   if (GET_OPCODE(*ie2) == OP_CONCAT) {  /* is 'e2' a concatenation? */
     int n = GETARG_B(*ie2);  /* # of elements concatenated in 'e2' */
@@ -1766,7 +1766,7 @@ void luaK_setlist (FuncState *fs, int base, int nelems, int tostore) {
 /*
 ** return the final target of a jump (skipping jumps to jumps)
 */
-static int finaltarget (Instruction *code, int i) {
+static int finaltarget (const Instruction *code, int i) {
   int count;
   for (count = 0; count < 100; count++) {  /* avoid infinite loops */
     Instruction pc = code[i];
diff --git a/src/lcorolib.c b/src/lcorolib.c
index 7d6e585..be9d7ba 100644
--- a/src/lcorolib.c
+++ b/src/lcorolib.c
@@ -120,7 +120,7 @@ static const char *const statname[] =
   {"running", "dead", "suspended", "normal"};
 
 
-static int auxstatus (lua_State *L, lua_State *co) {
+static int auxstatus (const lua_State *L, lua_State *co) {
   if (L == co) return COS_RUN;
   else {
     switch (lua_status(co)) {
diff --git a/src/ldebug.c b/src/ldebug.c
index eaac16f..c6c838c 100644
--- a/src/ldebug.c
+++ b/src/ldebug.c
@@ -38,11 +38,11 @@
 #define ci_func(ci)		(clLvalue(s2v((ci)->func)))
 
 
-static const char *funcnamefromcode (lua_State *L, CallInfo *ci,
+static const char *funcnamefromcode (const lua_State *L, const CallInfo *ci,
                                     const char **name);
 
 
-static int currentpc (CallInfo *ci) {
+static int currentpc (const CallInfo *ci) {
   lua_assert(isLua(ci));
   return pcRel(ci->u.l.savedpc, ci_func(ci)->p);
 }
@@ -101,7 +101,7 @@ int luaG_getfuncline (const Proto *f, int pc) {
 }
 
 
-static int getcurrentline (CallInfo *ci) {
+static int getcurrentline (const CallInfo *ci) {
   return luaG_getfuncline(ci_func(ci)->p, currentpc(ci));
 }
 
@@ -187,7 +187,7 @@ static const char *upvalname (const Proto *p, int uv) {
 }
 
 
-static const char *findvararg (CallInfo *ci, int n, StkId *pos) {
+static const char *findvararg (const CallInfo *ci, int n, StkId *pos) {
   if (clLvalue(s2v(ci->func))->p->is_vararg) {
     int nextra = ci->u.l.nextraargs;
     if (n <= nextra) {
@@ -259,7 +259,7 @@ LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n) {
 }
 
 
-static void funcinfo (lua_Debug *ar, Closure *cl) {
+static void funcinfo (lua_Debug *ar, const Closure *cl) {
   if (noLuaClosure(cl)) {
     ar->source = "=[C]";
     ar->srclen = LL("=[C]");
@@ -293,7 +293,7 @@ static int nextline (const Proto *p, int currentline, int pc) {
 }
 
 
-static void collectvalidlines (lua_State *L, Closure *f) {
+static void collectvalidlines (lua_State *L, const Closure *f) {
   if (noLuaClosure(f)) {
     setnilvalue(s2v(L->top));
     api_incr_top(L);
@@ -315,7 +315,7 @@ static void collectvalidlines (lua_State *L, Closure *f) {
 }
 
 
-static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name) {
+static const char *getfuncname (const lua_State *L, const CallInfo *ci, const char **name) {
   if (ci == NULL)  /* no 'ci'? */
     return NULL;  /* no info */
   else if (ci->callstatus & CIST_FIN) {  /* is this a finalizer? */
@@ -329,8 +329,8 @@ static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name) {
 }
 
 
-static int auxgetinfo (lua_State *L, const char *what, lua_Debug *ar,
-                       Closure *f, CallInfo *ci) {
+static int auxgetinfo (const lua_State *L, const char *what, lua_Debug *ar,
+                       const Closure *f, const CallInfo *ci) {
   int status = 1;
   for (; *what; what++) {
     switch (*what) {
@@ -596,7 +596,7 @@ static const char *getobjname (const Proto *p, int lastpc, int reg,
 ** Returns what the name is (e.g., "for iterator", "method",
 ** "metamethod") and sets '*name' to point to the name.
 */
-static const char *funcnamefromcode (lua_State *L, CallInfo *ci,
+static const char *funcnamefromcode (const lua_State *L, const CallInfo *ci,
                                      const char **name) {
   TMS tm = (TMS)0;  /* (initial value avoids warnings) */
   const Proto *p = ci_func(ci)->p;  /* calling function */
@@ -653,7 +653,7 @@ static const char *funcnamefromcode (lua_State *L, CallInfo *ci,
 ** not ISO C, but it should not crash a program; the subsequent
 ** checks are ISO C and ensure a correct result.
 */
-static int isinstack (CallInfo *ci, const TValue *o) {
+static int isinstack (const CallInfo *ci, const TValue *o) {
   StkId base = ci->func + 1;
   ptrdiff_t i = cast(StkId, o) - base;
   return (0 <= i && i < (ci->top - base) && s2v(base + i) == o);
@@ -665,7 +665,7 @@ static int isinstack (CallInfo *ci, const TValue *o) {
 ** with instructions OP_GETTABUP/OP_SETTABUP, which operate directly on
 ** upvalues.)
 */
-static const char *getupvalname (CallInfo *ci, const TValue *o,
+static const char *getupvalname (const CallInfo *ci, const TValue *o,
                                  const char **name) {
   LClosure *c = ci_func(ci);
   int i;
diff --git a/src/ldo.c b/src/ldo.c
index 64fe291..5f0d663 100644
--- a/src/ldo.c
+++ b/src/ldo.c
@@ -232,7 +232,7 @@ int luaD_growstack (lua_State *L, int n, int raiseerror) {
 }
 
 
-static int stackinuse (lua_State *L) {
+static int stackinuse (const lua_State *L) {
   CallInfo *ci;
   StkId lim = L->top;
   for (ci = L->ci; ci != NULL; ci = ci->previous) {
@@ -581,7 +581,7 @@ static void unroll (lua_State *L, void *ud) {
 ** Try to find a suspended protected call (a "recover point") for the
 ** given thread.
 */
-static CallInfo *findpcall (lua_State *L) {
+static CallInfo *findpcall (const lua_State *L) {
   CallInfo *ci;
   for (ci = L->ci; ci != NULL; ci = ci->previous) {  /* search for a pcall */
     if (ci->callstatus & CIST_YPCALL)
diff --git a/src/ldump.c b/src/ldump.c
index fbadbcc..5d4295e 100644
--- a/src/ldump.c
+++ b/src/ldump.c
@@ -103,7 +103,7 @@ static void dumpCode (DumpState *D, const Proto *f) {
 }
 
 
-static void dumpFunction(DumpState *D, const Proto *f, TString *psource);
+static void dumpFunction(DumpState *D, const Proto *f, const TString *psource);
 
 static void dumpConstants (DumpState *D, const Proto *f) {
   int i;
@@ -176,7 +176,7 @@ static void dumpDebug (DumpState *D, const Proto *f) {
 }
 
 
-static void dumpFunction (DumpState *D, const Proto *f, TString *psource) {
+static void dumpFunction (DumpState *D, const Proto *f, const TString *psource) {
   if (D->strip || f->source == psource)
     dumpString(D, NULL);  /* no debug info or same source as its parent */
   else
diff --git a/src/lfunc.c b/src/lfunc.c
index 10100e5..9997d3f 100644
--- a/src/lfunc.c
+++ b/src/lfunc.c
@@ -110,7 +110,7 @@ static void callclose (lua_State *L, void *ud) {
 ** Prepare closing method plus its arguments for object 'obj' with
 ** error message 'err'. (This function assumes EXTRA_STACK.)
 */
-static int prepclosingmethod (lua_State *L, TValue *obj, TValue *err) {
+static int prepclosingmethod (lua_State *L, const TValue *obj, const TValue *err) {
   StkId top = L->top;
   const TValue *tm = luaT_gettmbyobj(L, obj, TM_CLOSE);
   if (ttisnil(tm))  /* no metamethod? */
diff --git a/src/lgc.c b/src/lgc.c
index f26c921..48f7603 100644
--- a/src/lgc.c
+++ b/src/lgc.c
@@ -520,7 +520,7 @@ static int traverseudata (global_State *g, Udata *u) {
 ** arrays can be larger than needed; the extra slots are filled with
 ** NULL, so the use of 'markobjectN')
 */
-static int traverseproto (global_State *g, Proto *f) {
+static int traverseproto (global_State *g, const Proto *f) {
   int i;
   markobjectN(g, f->source);
   for (i = 0; i < f->sizek; i++)  /* mark literals */
@@ -535,7 +535,7 @@ static int traverseproto (global_State *g, Proto *f) {
 }
 
 
-static int traverseCclosure (global_State *g, CClosure *cl) {
+static int traverseCclosure (global_State *g, const CClosure *cl) {
   int i;
   for (i = 0; i < cl->nupvalues; i++)  /* mark its upvalues */
     markvalue(g, &cl->upvalue[i]);
@@ -546,7 +546,7 @@ static int traverseCclosure (global_State *g, CClosure *cl) {
 ** Traverse a Lua closure, marking its prototype and its upvalues.
 ** (Both can be NULL while closure is being created.)
 */
-static int traverseLclosure (global_State *g, LClosure *cl) {
+static int traverseLclosure (global_State *g, const LClosure *cl) {
   int i;
   markobjectN(g, cl->p);  /* mark its prototype */
   for (i = 0; i < cl->nupvalues; i++) {  /* visit its upvalues */
@@ -680,7 +680,7 @@ static void clearbykeys (global_State *g, GCObject *l) {
 ** clear entries with unmarked values from all weaktables in list 'l' up
 ** to element 'f'
 */
-static void clearbyvalues (global_State *g, GCObject *l, GCObject *f) {
+static void clearbyvalues (global_State *g, GCObject *l, const GCObject *f) {
   for (; l != f; l = gco2t(l)->gclist) {
     Table *h = gco2t(l);
     Node *n, *limit = gnodelast(h);
@@ -996,8 +996,8 @@ static void sweep2old (lua_State *L, GCObject **p) {
 ** non-dead objects, advance their ages and clear the color of
 ** new objects. (Old objects keep their colors.)
 */
-static GCObject **sweepgen (lua_State *L, global_State *g, GCObject **p,
-                            GCObject *limit) {
+static GCObject **sweepgen (lua_State *L, const global_State *g, GCObject **p,
+                            const GCObject *limit) {
   static const lu_byte nextage[] = {
     G_SURVIVAL,  /* from G_NEW */
     G_OLD1,      /* from G_SURVIVAL */
@@ -1030,7 +1030,7 @@ static GCObject **sweepgen (lua_State *L, global_State *g, GCObject **p,
 ** Traverse a list making all its elements white and clearing their
 ** age.
 */
-static void whitelist (global_State *g, GCObject *p) {
+static void whitelist (const global_State *g, GCObject *p) {
   int white = luaC_white(g);
   for (; p != NULL; p = p->next)
     p->marked = cast_byte((p->marked & maskcolors) | white);
@@ -1104,7 +1104,7 @@ static void correctgraylists (global_State *g) {
 ** Gray objects are already in some gray list, and so will be visited
 ** in the atomic step.
 */
-static void markold (global_State *g, GCObject *from, GCObject *to) {
+static void markold (global_State *g, GCObject *from, const GCObject *to) {
   GCObject *p;
   for (p = from; p != to; p = p->next) {
     if (getage(p) == G_OLD1) {
@@ -1387,7 +1387,7 @@ static void entersweep (lua_State *L) {
 ** Delete all objects in list 'p' until (but not including) object
 ** 'limit'.
 */
-static void deletelist (lua_State *L, GCObject *p, GCObject *limit) {
+static void deletelist (lua_State *L, GCObject *p, const GCObject *limit) {
   while (p != limit) {
     GCObject *next = p->next;
     freeobj(L, p);
diff --git a/src/lobject.c b/src/lobject.c
index b4efae4..ed7beac 100644
--- a/src/lobject.c
+++ b/src/lobject.c
@@ -340,7 +340,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 int tostringbuff (const TValue *obj, char *buff) {
   int len;
   lua_assert(ttisnumber(obj));
   if (ttisinteger(obj))
@@ -446,7 +446,7 @@ static void addstr2buff (BuffFS *buff, const char *str, size_t slen) {
 /*
 ** Add a number to the buffer.
 */
-static void addnum2buff (BuffFS *buff, TValue *num) {
+static void addnum2buff (BuffFS *buff, const TValue *num) {
   char *numbuff = getbuff(buff, MAXNUMBER2STR);
   int len = tostringbuff(num, numbuff);  /* format number into 'numbuff' */
   addsize(buff, len);
diff --git a/src/loslib.c b/src/loslib.c
index 29449e4..97297ca 100644
--- a/src/loslib.c
+++ b/src/loslib.c
@@ -225,7 +225,7 @@ static void setboolfield (lua_State *L, const char *key, int value) {
 /*
 ** Set all fields from structure 'tm' in the table on top of the stack
 */
-static void setallfields (lua_State *L, struct tm *stm) {
+static void setallfields (lua_State *L, const struct tm *stm) {
   setfield(L, "year", stm->tm_year, 1900);
   setfield(L, "month", stm->tm_mon, 1);
   setfield(L, "day", stm->tm_mday, 0);
diff --git a/src/lparser.c b/src/lparser.c
index b0dbb65..ec00acc 100644
--- a/src/lparser.c
+++ b/src/lparser.c
@@ -71,7 +71,7 @@ static l_noret error_expected (LexState *ls, int token) {
 }
 
 
-static l_noret errorlimit (FuncState *fs, int limit, const char *what) {
+static l_noret errorlimit (const FuncState *fs, int limit, const char *what) {
   lua_State *L = fs->ls->L;
   const char *msg;
   int line = fs->f->linedefined;
@@ -84,7 +84,7 @@ static l_noret errorlimit (FuncState *fs, int limit, const char *what) {
 }
 
 
-static void checklimit (FuncState *fs, int v, int l, const char *what) {
+static void checklimit (const FuncState *fs, int v, int l, const char *what) {
   if (v > l) errorlimit(fs, l, what);
 }
 
@@ -172,7 +172,7 @@ 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 int registerlocalvar (const 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 +190,7 @@ static int registerlocalvar (LexState *ls, FuncState *fs, TString *varname) {
 ** Create a new local variable with the given 'name'. Return its index
 ** in the function.
 */
-static int new_localvar (LexState *ls, TString *name) {
+static int new_localvar (const LexState *ls, TString *name) {
   lua_State *L = ls->L;
   FuncState *fs = ls->fs;
   Dyndata *dyd = ls->dyd;
@@ -215,7 +215,7 @@ static int new_localvar (LexState *ls, TString *name) {
 ** Return the "variable description" (Vardesc) of a given
 ** variable
 */
-static Vardesc *getlocalvardesc (FuncState *fs, int i) {
+static Vardesc *getlocalvardesc (const FuncState *fs, int i) {
   return &fs->ls->dyd->actvar.arr[fs->firstlocal + i];
 }
 
@@ -224,7 +224,7 @@ static Vardesc *getlocalvardesc (FuncState *fs, int i) {
 ** Convert 'nvar' (number of active variables at some point) to
 ** number of variables in the stack at that point.
 */
-static int stacklevel (FuncState *fs, int nvar) {
+static int stacklevel (const FuncState *fs, int nvar) {
   while (nvar > 0) {
     Vardesc *vd = getlocalvardesc(fs, nvar - 1);
     if (vd->vd.kind != RDKCTC)  /* is in the stack? */
@@ -247,7 +247,7 @@ int luaY_nvarstack (FuncState *fs) {
 /*
 ** Get the debug-information entry for current variable 'i'.
 */
-static LocVar *localdebuginfo (FuncState *fs, int i) {
+static LocVar *localdebuginfo (const FuncState *fs, int i) {
   Vardesc *vd = getlocalvardesc(fs, i);
   if (vd->vd.kind == RDKCTC)
     return NULL;  /* no debug info. for constants */
@@ -259,7 +259,7 @@ static LocVar *localdebuginfo (FuncState *fs, int i) {
 }
 
 
-static void init_var (FuncState *fs, expdesc *e, int i) {
+static void init_var (const FuncState *fs, expdesc *e, int i) {
   e->f = e->t = NO_JUMP;
   e->k = VLOCAL;
   e->u.var.vidx = i;
@@ -267,7 +267,7 @@ static void init_var (FuncState *fs, expdesc *e, int i) {
 }
 
 
-static void check_readonly (LexState *ls, expdesc *e) {
+static void check_readonly (LexState *ls, const expdesc *e) {
   FuncState *fs = ls->fs;
   TString *varname = NULL;  /* to be set if variable is const */
   switch (e->k) {
@@ -301,7 +301,7 @@ static void check_readonly (LexState *ls, expdesc *e) {
 /*
 ** Start the scope for the last 'nvars' created variables.
 */
-static void adjustlocalvars (LexState *ls, int nvars) {
+static void adjustlocalvars (const LexState *ls, int nvars) {
   FuncState *fs = ls->fs;
   int stklevel = luaY_nvarstack(fs);
   int i;
@@ -332,7 +332,7 @@ static void removevars (FuncState *fs, int tolevel) {
 ** Search the upvalues of the function 'fs' for one
 ** with the given 'name'.
 */
-static int searchupvalue (FuncState *fs, TString *name) {
+static int searchupvalue (const FuncState *fs, const TString *name) {
   int i;
   Upvaldesc *up = fs->f->upvalues;
   for (i = 0; i < fs->nups; i++) {
@@ -354,7 +354,7 @@ static Upvaldesc *allocupvalue (FuncState *fs) {
 }
 
 
-static int newupvalue (FuncState *fs, TString *name, expdesc *v) {
+static int newupvalue (FuncState *fs, TString *name, const expdesc *v) {
   Upvaldesc *up = allocupvalue(fs);
   FuncState *prev = fs->prev;
   if (v->k == VLOCAL) {
@@ -379,7 +379,7 @@ static int newupvalue (FuncState *fs, TString *name, expdesc *v) {
 ** Look for an active local variable with the name 'n' in the
 ** function 'fs'.
 */
-static int searchvar (FuncState *fs, TString *n, expdesc *var) {
+static int searchvar (const FuncState *fs, const TString *n, expdesc *var) {
   int i;
   for (i = cast_int(fs->nactvar) - 1; i >= 0; i--) {
     Vardesc *vd = getlocalvardesc(fs, i);
@@ -459,7 +459,7 @@ static void singlevar (LexState *ls, expdesc *var) {
 ** Adjust the number of results from an expression list 'e' with 'nexps'
 ** expressions to 'nvars' values.
 */
-static void adjust_assign (LexState *ls, int nvars, int nexps, expdesc *e) {
+static void adjust_assign (const LexState *ls, int nvars, int nexps, expdesc *e) {
   FuncState *fs = ls->fs;
   int needed = nvars - nexps;  /* extra values needed */
   if (hasmultret(e->k)) {  /* last expression has multiple returns? */
@@ -493,7 +493,7 @@ static void adjust_assign (LexState *ls, int nvars, int nexps, expdesc *e) {
 ** Generates an error that a goto jumps into the scope of some
 ** local variable.
 */
-static l_noret jumpscopeerror (LexState *ls, Labeldesc *gt) {
+static l_noret jumpscopeerror (LexState *ls, const Labeldesc *gt) {
   const char *varname = getstr(getlocalvardesc(ls->fs, gt->nactvar)->vd.name);
   const char *msg = "<goto %s> at line %d jumps into the scope of local '%s'";
   msg = luaO_pushfstring(ls->L, msg, getstr(gt->name), gt->line, varname);
@@ -506,7 +506,7 @@ static l_noret jumpscopeerror (LexState *ls, Labeldesc *gt) {
 ** from the list of pending goto's.
 ** If it jumps into the scope of some variable, raises an error.
 */
-static void solvegoto (LexState *ls, int g, Labeldesc *label) {
+static void solvegoto (LexState *ls, int g, const Labeldesc *label) {
   int i;
   Labellist *gl = &ls->dyd->gt;  /* list of goto's */
   Labeldesc *gt = &gl->arr[g];  /* goto to be resolved */
@@ -523,7 +523,7 @@ static void solvegoto (LexState *ls, int g, Labeldesc *label) {
 /*
 ** Search for an active label with the given name.
 */
-static Labeldesc *findlabel (LexState *ls, TString *name) {
+static Labeldesc *findlabel (const LexState *ls, const TString *name) {
   int i;
   Dyndata *dyd = ls->dyd;
   /* check labels in current function for a match */
@@ -539,7 +539,7 @@ static Labeldesc *findlabel (LexState *ls, TString *name) {
 /*
 ** Adds a new label/goto in the corresponding list.
 */
-static int newlabelentry (LexState *ls, Labellist *l, TString *name,
+static int newlabelentry (const LexState *ls, Labellist *l, TString *name,
                           int line, int pc) {
   int n = l->n;
   luaM_growvector(ls->L, l->arr, n, l->size,
@@ -554,7 +554,7 @@ static int newlabelentry (LexState *ls, Labellist *l, TString *name,
 }
 
 
-static int newgotoentry (LexState *ls, TString *name, int line, int pc) {
+static int newgotoentry (const LexState *ls, TString *name, int line, int pc) {
   return newlabelentry(ls, &ls->dyd->gt, name, line, pc);
 }
 
@@ -564,7 +564,7 @@ static int newgotoentry (LexState *ls, TString *name, int line, int pc) {
 ** pending gotos in current block and solves them. Return true
 ** if any of the goto's need to close upvalues.
 */
-static int solvegotos (LexState *ls, Labeldesc *lb) {
+static int solvegotos (LexState *ls, const Labeldesc *lb) {
   Labellist *gl = &ls->dyd->gt;
   int i = ls->fs->bl->firstgoto;
   int needsclose = 0;
@@ -607,7 +607,7 @@ static int createlabel (LexState *ls, TString *name, int line,
 /*
 ** Adjust pending gotos to outer level of a block.
 */
-static void movegotosout (FuncState *fs, BlockCnt *bl) {
+static void movegotosout (const FuncState *fs, const BlockCnt *bl) {
   int i;
   Labellist *gl = &fs->ls->dyd->gt;
   /* correct pending gotos to current block */
@@ -637,7 +637,7 @@ static void enterblock (FuncState *fs, BlockCnt *bl, lu_byte isloop) {
 /*
 ** generates an error for an undefined 'goto'.
 */
-static l_noret undefgoto (LexState *ls, Labeldesc *gt) {
+static l_noret undefgoto (LexState *ls, const Labeldesc *gt) {
   const char *msg;
   if (eqstr(gt->name, luaS_newliteral(ls->L, "break"))) {
     msg = "break outside loop at line %d";
@@ -677,7 +677,7 @@ static void leaveblock (FuncState *fs) {
 /*
 ** adds a new prototype into list of prototypes
 */
-static Proto *addprototype (LexState *ls) {
+static Proto *addprototype (const LexState *ls) {
   Proto *clp;
   lua_State *L = ls->L;
   FuncState *fs = ls->fs;
@@ -701,7 +701,7 @@ static Proto *addprototype (LexState *ls) {
 ** are in use at that time.
 
 */
-static void codeclosure (LexState *ls, expdesc *v) {
+static void codeclosure (const LexState *ls, expdesc *v) {
   FuncState *fs = ls->fs->prev;
   init_exp(v, VRELOC, luaK_codeABx(fs, OP_CLOSURE, 0, fs->np - 1));
   luaK_exp2nextreg(fs, v);  /* fix it at the last register */
@@ -766,7 +766,7 @@ static void close_func (LexState *ls) {
 ** 'until' closes syntactical blocks, but do not close scope,
 ** so it is handled in separate.
 */
-static int block_follow (LexState *ls, int withuntil) {
+static int block_follow (const LexState *ls, int withuntil) {
   switch (ls->t.token) {
     case TK_ELSE: case TK_ELSEIF:
     case TK_END: case TK_EOS:
@@ -1309,7 +1309,7 @@ struct LHS_assign {
 ** table. If so, save original upvalue/local value in a safe place and
 ** use this safe copy in the previous assignment.
 */
-static void check_conflict (LexState *ls, struct LHS_assign *lh, expdesc *v) {
+static void check_conflict (const LexState *ls, struct LHS_assign *lh, const expdesc *v) {
   FuncState *fs = ls->fs;
   int extra = fs->freereg;  /* eventual position to save local variable */
   int conflict = 0;
@@ -1508,7 +1508,7 @@ static void exp1 (LexState *ls) {
 ** (Jump addresses are relative in Lua). 'back' true means
 ** a back jump.
 */
-static void fixforjump (FuncState *fs, int pc, int dest, int back) {
+static void fixforjump (const FuncState *fs, int pc, int dest, int back) {
   Instruction *jmp = &fs->f->code[pc];
   int offset = dest - (pc + 1);
   if (back)
@@ -1734,7 +1734,7 @@ static int getlocalattribute (LexState *ls) {
 }
 
 
-static void checktoclose (LexState *ls, int level) {
+static void checktoclose (const LexState *ls, int level) {
   if (level != -1) {  /* is there a to-be-closed variable? */
     FuncState *fs = ls->fs;
     markupval(fs, level + 1);
diff --git a/src/lstring.c b/src/lstring.c
index 6f15747..c0f9c3b 100644
--- a/src/lstring.c
+++ b/src/lstring.c
@@ -183,7 +183,7 @@ void luaS_remove (lua_State *L, TString *ts) {
 }
 
 
-static void growstrtab (lua_State *L, stringtable *tb) {
+static void growstrtab (lua_State *L, const stringtable *tb) {
   if (unlikely(tb->nuse == MAX_INT)) {  /* too many strings? */
     luaC_fullgc(L, 1);  /* try to free some... */
     if (tb->nuse == MAX_INT)  /* still too many? */
diff --git a/src/lstrlib.c b/src/lstrlib.c
index 2ba8bde..02f8167 100644
--- a/src/lstrlib.c
+++ b/src/lstrlib.c
@@ -381,7 +381,7 @@ static const char *match (MatchState *ms, const char *s, const char *p);
 #define SPECIALS	"^$*+?.([%-"
 
 
-static int check_capture (MatchState *ms, int l) {
+static int check_capture (const MatchState *ms, int l) {
   l -= '1';
   if (l < 0 || l >= ms->level || ms->capture[l].len == CAP_UNFINISHED)
     return luaL_error(ms->L, "invalid capture index %%%d", l + 1);
@@ -389,7 +389,7 @@ static int check_capture (MatchState *ms, int l) {
 }
 
 
-static int capture_to_close (MatchState *ms) {
+static int capture_to_close (const MatchState *ms) {
   int level = ms->level;
   for (level--; level>=0; level--)
     if (ms->capture[level].len == CAP_UNFINISHED) return level;
@@ -397,7 +397,7 @@ static int capture_to_close (MatchState *ms) {
 }
 
 
-static const char *classend (MatchState *ms, const char *p) {
+static const char *classend (const MatchState *ms, const char *p) {
   switch (*p++) {
     case L_ESC: {
       if (p == ms->p_end)
@@ -464,7 +464,7 @@ static int matchbracketclass (int c, const char *p, const char *ec) {
 }
 
 
-static int singlematch (MatchState *ms, const char *s, const char *p,
+static int singlematch (const MatchState *ms, const char *s, const char *p,
                         const char *ep) {
   if (s >= ms->src_end)
     return 0;
@@ -480,7 +480,7 @@ static int singlematch (MatchState *ms, const char *s, const char *p,
 }
 
 
-static const char *matchbalance (MatchState *ms, const char *s,
+static const char *matchbalance (const MatchState *ms, const char *s,
                                    const char *p) {
   if (p >= ms->p_end - 1)
     luaL_error(ms->L, "malformed pattern (missing arguments to '%%b')");
@@ -553,7 +553,7 @@ static const char *end_capture (MatchState *ms, const char *s,
 }
 
 
-static const char *match_capture (MatchState *ms, const char *s, int l) {
+static const char *match_capture (const MatchState *ms, const char *s, int l) {
   size_t len;
   l = check_capture(ms, l);
   len = ms->capture[l].len;
@@ -696,7 +696,7 @@ 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 size_t get_onecapture (const MatchState *ms, int i, const char *s,
                               const char *e, const char **cap) {
   if (i >= ms->level) {
     if (i != 0)
@@ -719,8 +719,8 @@ static size_t get_onecapture (MatchState *ms, int i, const char *s,
 /*
 ** Push the i-th capture on the stack.
 */
-static void push_onecapture (MatchState *ms, int i, const char *s,
-                                                    const char *e) {
+static void push_onecapture (const MatchState *ms, int i, const char *s,
+                                                          const char *e) {
   const char *cap;
   ptrdiff_t l = get_onecapture(ms, i, s, e, &cap);
   if (l != CAP_POSITION)
@@ -729,7 +729,7 @@ static void push_onecapture (MatchState *ms, int i, const char *s,
 }
 
 
-static int push_captures (MatchState *ms, const char *s, const char *e) {
+static int push_captures (const MatchState *ms, const char *s, const char *e) {
   int i;
   int nlevels = (ms->level == 0 && s) ? 1 : ms->level;
   luaL_checkstack(ms->L, nlevels, "too many captures");
@@ -865,8 +865,8 @@ static int gmatch (lua_State *L) {
 }
 
 
-static void add_s (MatchState *ms, luaL_Buffer *b, const char *s,
-                                                   const char *e) {
+static void add_s (const MatchState *ms, luaL_Buffer *b, const char *s,
+                                                         const char *e) {
   size_t l;
   lua_State *L = ms->L;
   const char *news = lua_tolstring(L, 3, &l);
@@ -900,8 +900,8 @@ static void add_s (MatchState *ms, luaL_Buffer *b, const char *s,
 ** Return true if the original string was changed. (Function calls and
 ** table indexing resulting in nil or false do not change the subject.)
 */
-static int add_value (MatchState *ms, luaL_Buffer *b, const char *s,
-                                      const char *e, int tr) {
+static int add_value (const MatchState *ms, luaL_Buffer *b, const char *s,
+                                            const char *e, int tr) {
   lua_State *L = ms->L;
   switch (tr) {
     case LUA_TFUNCTION: {  /* call the function */
@@ -1418,7 +1418,7 @@ static int getnum (const char **fmt, int df) {
 ** Read an integer numeral and raises an error if it is larger
 ** than the maximum size for integers.
 */
-static int getnumlimit (Header *h, const char **fmt, int df) {
+static int getnumlimit (const Header *h, const char **fmt, int df) {
   int sz = getnum(fmt, df);
   if (sz > MAXINTSIZE || sz <= 0)
     return luaL_error(h->L, "integral size (%d) out of limits [1,%d]",
diff --git a/src/ltable.c b/src/ltable.c
index d7eb69a..b109c64 100644
--- a/src/ltable.c
+++ b/src/ltable.c
@@ -252,7 +252,7 @@ static unsigned int setlimittosize (Table *t) {
 ** "Generic" get version. (Not that generic: not valid for integers,
 ** which may be in array part, nor for floats with integral values.)
 */
-static const TValue *getgeneric (Table *t, const TValue *key) {
+static const TValue *getgeneric (const Table *t, const TValue *key) {
   Node *n = mainpositionTV(t, key);
   for (;;) {  /* check whether 'key' is somewhere in the chain */
     if (equalkey(key, n))
@@ -284,7 +284,7 @@ static unsigned int arrayindex (lua_Integer k) {
 ** elements in the array part, then elements in the hash part. The
 ** beginning of a traversal is signaled by 0.
 */
-static unsigned int findindex (lua_State *L, Table *t, TValue *key,
+static unsigned int findindex (lua_State *L, const Table *t, const TValue *key,
                                unsigned int asize) {
   unsigned int i;
   if (ttisnil(key)) return 0;  /* first iteration */
@@ -324,7 +324,7 @@ int luaH_next (lua_State *L, Table *t, StkId key) {
 }
 
 
-static void freehash (lua_State *L, Table *t) {
+static void freehash (lua_State *L, const Table *t) {
   if (!isdummy(t))
     luaM_freearray(L, t->node, cast_sizet(sizenode(t)));
 }
@@ -344,7 +344,7 @@ static void freehash (lua_State *L, Table *t) {
 ** will go to the array part; return the optimal size.  (The condition
 ** 'twotoi > 0' in the for loop stops the loop if 'twotoi' overflows.)
 */
-static unsigned int computesizes (unsigned int nums[], unsigned int *pna) {
+static unsigned int computesizes (const unsigned int nums[], unsigned int *pna) {
   int i;
   unsigned int twotoi;  /* 2^i (candidate for optimal size) */
   unsigned int a = 0;  /* number of elements smaller than 2^i */
@@ -461,7 +461,7 @@ static void setnodevector (lua_State *L, Table *t, unsigned int size) {
 /*
 ** (Re)insert all elements from the hash part of 'ot' into table 't'.
 */
-static void reinsert (lua_State *L, Table *ot, Table *t) {
+static void reinsert (lua_State *L, const Table *ot, Table *t) {
   int j;
   int size = sizenode(ot);
   for (j = 0; j < size; j++) {
diff --git a/src/lundump.c b/src/lundump.c
index 1736499..45b2485 100644
--- a/src/lundump.c
+++ b/src/lundump.c
@@ -37,7 +37,7 @@ typedef struct {
 } LoadState;
 
 
-static l_noret error (LoadState *S, const char *why) {
+static l_noret error (const LoadState *S, const char *why) {
   luaO_pushfstring(S->L, "%s: bad binary format (%s)", S->name, why);
   luaD_throw(S->L, LUA_ERRSYNTAX);
 }
@@ -49,7 +49,7 @@ static l_noret error (LoadState *S, const char *why) {
 */
 #define loadVector(S,b,n)	loadBlock(S,b,(n)*sizeof((b)[0]))
 
-static void loadBlock (LoadState *S, void *b, size_t size) {
+static void loadBlock (const LoadState *S, void *b, size_t size) {
   if (luaZ_read(S->Z, b, size) != 0)
     error(S, "truncated chunk");
 }
@@ -58,7 +58,7 @@ static void loadBlock (LoadState *S, void *b, size_t size) {
 #define loadVar(S,x)		loadVector(S,&x,1)
 
 
-static lu_byte loadByte (LoadState *S) {
+static lu_byte loadByte (const LoadState *S) {
   int b = zgetc(S->Z);
   if (b == EOZ)
     error(S, "truncated chunk");
@@ -66,7 +66,7 @@ static lu_byte loadByte (LoadState *S) {
 }
 
 
-static size_t loadUnsigned (LoadState *S, size_t limit) {
+static size_t loadUnsigned (const LoadState *S, size_t limit) {
   size_t x = 0;
   int b;
   limit >>= 7;
@@ -80,24 +80,24 @@ static size_t loadUnsigned (LoadState *S, size_t limit) {
 }
 
 
-static size_t loadSize (LoadState *S) {
+static size_t loadSize (const LoadState *S) {
   return loadUnsigned(S, ~(size_t)0);
 }
 
 
-static int loadInt (LoadState *S) {
+static int loadInt (const LoadState *S) {
   return cast_int(loadUnsigned(S, INT_MAX));
 }
 
 
-static lua_Number loadNumber (LoadState *S) {
+static lua_Number loadNumber (const LoadState *S) {
   lua_Number x;
   loadVar(S, x);
   return x;
 }
 
 
-static lua_Integer loadInteger (LoadState *S) {
+static lua_Integer loadInteger (const LoadState *S) {
   lua_Integer x;
   loadVar(S, x);
   return x;
@@ -107,7 +107,7 @@ static lua_Integer loadInteger (LoadState *S) {
 /*
 ** Load a nullable string.
 */
-static TString *loadStringN (LoadState *S) {
+static TString *loadStringN (const LoadState *S) {
   size_t size = loadSize(S);
   if (size == 0)
     return NULL;
@@ -127,7 +127,7 @@ static TString *loadStringN (LoadState *S) {
 /*
 ** Load a non-nullable string.
 */
-static TString *loadString (LoadState *S) {
+static TString *loadString (const LoadState *S) {
   TString *st = loadStringN(S);
   if (st == NULL)
     error(S, "bad format for constant string");
@@ -135,7 +135,7 @@ static TString *loadString (LoadState *S) {
 }
 
 
-static void loadCode (LoadState *S, Proto *f) {
+static void loadCode (const LoadState *S, Proto *f) {
   int n = loadInt(S);
   f->code = luaM_newvectorchecked(S->L, n, Instruction);
   f->sizecode = n;
@@ -143,10 +143,10 @@ static void loadCode (LoadState *S, Proto *f) {
 }
 
 
-static void loadFunction(LoadState *S, Proto *f, TString *psource);
+static void loadFunction(const LoadState *S, Proto *f, TString *psource);
 
 
-static void loadConstants (LoadState *S, Proto *f) {
+static void loadConstants (const LoadState *S, Proto *f) {
   int i;
   int n = loadInt(S);
   f->k = luaM_newvectorchecked(S->L, n, TValue);
@@ -182,7 +182,7 @@ static void loadConstants (LoadState *S, Proto *f) {
 }
 
 
-static void loadProtos (LoadState *S, Proto *f) {
+static void loadProtos (const LoadState *S, Proto *f) {
   int i;
   int n = loadInt(S);
   f->p = luaM_newvectorchecked(S->L, n, Proto *);
@@ -196,7 +196,7 @@ static void loadProtos (LoadState *S, Proto *f) {
 }
 
 
-static void loadUpvalues (LoadState *S, Proto *f) {
+static void loadUpvalues (const LoadState *S, Proto *f) {
   int i, n;
   n = loadInt(S);
   f->upvalues = luaM_newvectorchecked(S->L, n, Upvaldesc);
@@ -210,7 +210,7 @@ static void loadUpvalues (LoadState *S, Proto *f) {
 }
 
 
-static void loadDebug (LoadState *S, Proto *f) {
+static void loadDebug (const LoadState *S, Proto *f) {
   int i, n;
   n = loadInt(S);
   f->lineinfo = luaM_newvectorchecked(S->L, n, ls_byte);
@@ -239,7 +239,7 @@ static void loadDebug (LoadState *S, Proto *f) {
 }
 
 
-static void loadFunction (LoadState *S, Proto *f, TString *psource) {
+static void loadFunction (const LoadState *S, Proto *f, TString *psource) {
   f->source = loadStringN(S);
   if (f->source == NULL)  /* no source in dump? */
     f->source = psource;  /* reuse parent's source */
@@ -256,7 +256,7 @@ static void loadFunction (LoadState *S, Proto *f, TString *psource) {
 }
 
 
-static void checkliteral (LoadState *S, const char *s, const char *msg) {
+static void checkliteral (const LoadState *S, const char *s, const char *msg) {
   char buff[sizeof(LUA_SIGNATURE) + sizeof(LUAC_DATA)]; /* larger than both */
   size_t len = strlen(s);
   loadVector(S, buff, len);
@@ -265,7 +265,7 @@ static void checkliteral (LoadState *S, const char *s, const char *msg) {
 }
 
 
-static void fchecksize (LoadState *S, size_t size, const char *tname) {
+static void fchecksize (const LoadState *S, size_t size, const char *tname) {
   if (loadByte(S) != size)
     error(S, luaO_pushfstring(S->L, "%s size mismatch", tname));
 }
@@ -273,7 +273,7 @@ static void fchecksize (LoadState *S, size_t size, const char *tname) {
 
 #define checksize(S,t)	fchecksize(S,sizeof(t),#t)
 
-static void checkHeader (LoadState *S) {
+static void checkHeader (const LoadState *S) {
   /* skip 1st char (already read and checked) */
   checkliteral(S, &LUA_SIGNATURE[1], "not a binary chunk");
   if (loadInt(S) != LUAC_VERSION)
diff --git a/src/lvm.c b/src/lvm.c
index e7781db..4eb8b2e 100644
--- a/src/lvm.c
+++ b/src/lvm.c
@@ -781,7 +781,7 @@ lua_Integer luaV_shiftl (lua_Integer x, lua_Integer y) {
 ** create a new Lua closure, push it in the stack, and initialize
 ** its upvalues.
 */
-static void pushclosure (lua_State *L, Proto *p, UpVal **encup, StkId base,
+static void pushclosure (lua_State *L, Proto *p, UpVal * const *encup, StkId base,
                          StkId ra) {
   int nup = p->sizeupvalues;
   Upvaldesc *uv = p->upvalues;
--