nik/lush
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Code style in 'ldump'/'lundump'.

Browse Source 
- function names start with lower case;
- state is always the first parameter.
This commit is contained in:
Roberto Ierusalimschy
2020-02-27 15:17:44 -03:00
parent 6eb53b7526
commit e8a52281d9
2 changed files with 149 additions and 149 deletions
Download Patch File Download Diff File Expand all files Collapse all files

146
lundump.c
View File

@@ -44,21 +44,21 @@ static l_noret error (LoadState *S, const char *why) {
/*
** All high-level loads go through LoadVector; you can change it to
** All high-level loads go through loadVector; you can change it to
** adapt to the endianness of the input
*/
#define LoadVector(S,b,n) LoadBlock(S,b,(n)*sizeof((b)[0]))
#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 (LoadState *S, void *b, size_t size) {
if (luaZ_read(S->Z, b, size) != 0)
error(S, "truncated chunk");
}
#define LoadVar(S,x) LoadVector(S,&x,1)
#define loadVar(S,x) loadVector(S,&x,1)
static lu_byte LoadByte (LoadState *S) {
static lu_byte loadByte (LoadState *S) {
int b = zgetc(S->Z);
if (b == EOZ)
error(S, "truncated chunk");
@@ -66,12 +66,12 @@ static lu_byte LoadByte (LoadState *S) {
}
static size_t LoadUnsigned (LoadState *S, size_t limit) {
static size_t loadUnsigned (LoadState *S, size_t limit) {
size_t x = 0;
int b;
limit >>= 7;
do {
b = LoadByte(S);
b = loadByte(S);
if (x >= limit)
error(S, "integer overflow");
x = (x << 7) | (b & 0x7f);
@@ -80,45 +80,45 @@ static size_t LoadUnsigned (LoadState *S, size_t limit) {
}
static size_t LoadSize (LoadState *S) {
return LoadUnsigned(S, ~(size_t)0);
static size_t loadSize (LoadState *S) {
return loadUnsigned(S, ~(size_t)0);
}
static int LoadInt (LoadState *S) {
return cast_int(LoadUnsigned(S, INT_MAX));
static int loadInt (LoadState *S) {
return cast_int(loadUnsigned(S, INT_MAX));
}
static lua_Number LoadNumber (LoadState *S) {
static lua_Number loadNumber (LoadState *S) {
lua_Number x;
LoadVar(S, x);
loadVar(S, x);
return x;
}
static lua_Integer LoadInteger (LoadState *S) {
static lua_Integer loadInteger (LoadState *S) {
lua_Integer x;
LoadVar(S, x);
loadVar(S, x);
return x;
}
/*
** Load a nullable string
** Load a nullable string.
*/
static TString *LoadStringN (LoadState *S) {
size_t size = LoadSize(S);
static TString *loadStringN (LoadState *S) {
size_t size = loadSize(S);
if (size == 0)
return NULL;
else if (--size <= LUAI_MAXSHORTLEN) { /* short string? */
char buff[LUAI_MAXSHORTLEN];
LoadVector(S, buff, size);
loadVector(S, buff, size);
return luaS_newlstr(S->L, buff, size);
}
else { /* long string */
TString *ts = luaS_createlngstrobj(S->L, size);
LoadVector(S, getstr(ts), size); /* load directly in final place */
loadVector(S, getstr(ts), size); /* load directly in final place */
return ts;
}
}
@@ -127,35 +127,35 @@ static TString *LoadStringN (LoadState *S) {
/*
** Load a non-nullable string.
*/
static TString *LoadString (LoadState *S) {
TString *st = LoadStringN(S);
static TString *loadString (LoadState *S) {
TString *st = loadStringN(S);
if (st == NULL)
error(S, "bad format for constant string");
return st;
}
static void LoadCode (LoadState *S, Proto *f) {
int n = LoadInt(S);
static void loadCode (LoadState *S, Proto *f) {
int n = loadInt(S);
f->code = luaM_newvectorchecked(S->L, n, Instruction);
f->sizecode = n;
LoadVector(S, f->code, n);
loadVector(S, f->code, n);
}
static void LoadFunction(LoadState *S, Proto *f, TString *psource);
static void loadFunction(LoadState *S, Proto *f, TString *psource);
static void LoadConstants (LoadState *S, Proto *f) {
static void loadConstants (LoadState *S, Proto *f) {
int i;
int n = LoadInt(S);
int n = loadInt(S);
f->k = luaM_newvectorchecked(S->L, n, TValue);
f->sizek = n;
for (i = 0; i < n; i++)
setnilvalue(&f->k[i]);
for (i = 0; i < n; i++) {
TValue *o = &f->k[i];
int t = LoadByte(S);
int t = loadByte(S);
switch (t) {
case LUA_VNIL:
setnilvalue(o);
@@ -167,14 +167,14 @@ static void LoadConstants (LoadState *S, Proto *f) {
setbtvalue(o);
break;
case LUA_VNUMFLT:
setfltvalue(o, LoadNumber(S));
setfltvalue(o, loadNumber(S));
break;
case LUA_VNUMINT:
setivalue(o, LoadInteger(S));
setivalue(o, loadInteger(S));
break;
case LUA_VSHRSTR:
case LUA_VLNGSTR:
setsvalue2n(S->L, o, LoadString(S));
setsvalue2n(S->L, o, loadString(S));
break;
default: lua_assert(0);
}
@@ -182,91 +182,91 @@ static void LoadConstants (LoadState *S, Proto *f) {
}
static void LoadProtos (LoadState *S, Proto *f) {
static void loadProtos (LoadState *S, Proto *f) {
int i;
int n = LoadInt(S);
int n = loadInt(S);
f->p = luaM_newvectorchecked(S->L, n, Proto *);
f->sizep = n;
for (i = 0; i < n; i++)
f->p[i] = NULL;
for (i = 0; i < n; i++) {
f->p[i] = luaF_newproto(S->L);
LoadFunction(S, f->p[i], f->source);
loadFunction(S, f->p[i], f->source);
}
}
static void LoadUpvalues (LoadState *S, Proto *f) {
static void loadUpvalues (LoadState *S, Proto *f) {
int i, n;
n = LoadInt(S);
n = loadInt(S);
f->upvalues = luaM_newvectorchecked(S->L, n, Upvaldesc);
f->sizeupvalues = n;
for (i = 0; i < n; i++) {
f->upvalues[i].name = NULL;
f->upvalues[i].instack = LoadByte(S);
f->upvalues[i].idx = LoadByte(S);
f->upvalues[i].kind = LoadByte(S);
f->upvalues[i].instack = loadByte(S);
f->upvalues[i].idx = loadByte(S);
f->upvalues[i].kind = loadByte(S);
}
}
static void LoadDebug (LoadState *S, Proto *f) {
static void loadDebug (LoadState *S, Proto *f) {
int i, n;
n = LoadInt(S);
n = loadInt(S);
f->lineinfo = luaM_newvectorchecked(S->L, n, ls_byte);
f->sizelineinfo = n;
LoadVector(S, f->lineinfo, n);
n = LoadInt(S);
loadVector(S, f->lineinfo, n);
n = loadInt(S);
f->abslineinfo = luaM_newvectorchecked(S->L, n, AbsLineInfo);
f->sizeabslineinfo = n;
for (i = 0; i < n; i++) {
f->abslineinfo[i].pc = LoadInt(S);
f->abslineinfo[i].line = LoadInt(S);
f->abslineinfo[i].pc = loadInt(S);
f->abslineinfo[i].line = loadInt(S);
}
n = LoadInt(S);
n = loadInt(S);
f->locvars = luaM_newvectorchecked(S->L, n, LocVar);
f->sizelocvars = n;
for (i = 0; i < n; i++)
f->locvars[i].varname = NULL;
for (i = 0; i < n; i++) {
f->locvars[i].varname = LoadStringN(S);
f->locvars[i].startpc = LoadInt(S);
f->locvars[i].endpc = LoadInt(S);
f->locvars[i].varname = loadStringN(S);
f->locvars[i].startpc = loadInt(S);
f->locvars[i].endpc = loadInt(S);
}
n = LoadInt(S);
n = loadInt(S);
for (i = 0; i < n; i++)
f->upvalues[i].name = LoadStringN(S);
f->upvalues[i].name = loadStringN(S);
}
static void LoadFunction (LoadState *S, Proto *f, TString *psource) {
f->source = LoadStringN(S);
static void loadFunction (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 */
f->linedefined = LoadInt(S);
f->lastlinedefined = LoadInt(S);
f->numparams = LoadByte(S);
f->is_vararg = LoadByte(S);
f->maxstacksize = LoadByte(S);
LoadCode(S, f);
LoadConstants(S, f);
LoadUpvalues(S, f);
LoadProtos(S, f);
LoadDebug(S, f);
f->linedefined = loadInt(S);
f->lastlinedefined = loadInt(S);
f->numparams = loadByte(S);
f->is_vararg = loadByte(S);
f->maxstacksize = loadByte(S);
loadCode(S, f);
loadConstants(S, f);
loadUpvalues(S, f);
loadProtos(S, f);
loadDebug(S, f);
}
static void checkliteral (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);
loadVector(S, buff, len);
if (memcmp(s, buff, len) != 0)
error(S, msg);
}
static void fchecksize (LoadState *S, size_t size, const char *tname) {
if (LoadByte(S) != size)
if (loadByte(S) != size)
error(S, luaO_pushfstring(S->L, "%s size mismatch", tname));
}
@@ -276,23 +276,23 @@ static void fchecksize (LoadState *S, size_t size, const char *tname) {
static void checkHeader (LoadState *S) {
/* skip 1st char (already read and checked) */
checkliteral(S, &LUA_SIGNATURE[1], "not a binary chunk");
if (LoadInt(S) != LUAC_VERSION)
if (loadInt(S) != LUAC_VERSION)
error(S, "version mismatch");
if (LoadByte(S) != LUAC_FORMAT)
if (loadByte(S) != LUAC_FORMAT)
error(S, "format mismatch");
checkliteral(S, LUAC_DATA, "corrupted chunk");
checksize(S, Instruction);
checksize(S, lua_Integer);
checksize(S, lua_Number);
if (LoadInteger(S) != LUAC_INT)
if (loadInteger(S) != LUAC_INT)
error(S, "integer format mismatch");
if (LoadNumber(S) != LUAC_NUM)
if (loadNumber(S) != LUAC_NUM)
error(S, "float format mismatch");
}
/*
** load precompiled chunk
** Load precompiled chunk.
*/
LClosure *luaU_undump(lua_State *L, ZIO *Z, const char *name) {
LoadState S;
@@ -306,11 +306,11 @@ LClosure *luaU_undump(lua_State *L, ZIO *Z, const char *name) {
S.L = L;
S.Z = Z;
checkHeader(&S);
cl = luaF_newLclosure(L, LoadByte(&S));
cl = luaF_newLclosure(L, loadByte(&S));
setclLvalue2s(L, L->top, cl);
luaD_inctop(L);
cl->p = luaF_newproto(L);
LoadFunction(&S, cl->p, NULL);
loadFunction(&S, cl->p, NULL);
lua_assert(cl->nupvalues == cl->p->sizeupvalues);
luai_verifycode(L, buff, cl->p);
return cl;