From e8a52281d9cba1c8dd49a06e7523d7e39794ecc1 Mon Sep 17 00:00:00 2001 From: Roberto Ierusalimschy Date: Thu, 27 Feb 2020 15:17:44 -0300 Subject: Code style in 'ldump'/'lundump'. - function names start with lower case; - state is always the first parameter. --- lundump.c | 146 +++++++++++++++++++++++++++++++------------------------------- 1 file changed, 73 insertions(+), 73 deletions(-) (limited to 'lundump.c') diff --git a/lundump.c b/lundump.c index 1fa322f6..17364999 100644 --- a/lundump.c +++ b/lundump.c @@ -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; -- cgit v1.2.3-55-g6feb