commit 197e249433027e72e5d4ef1a13c4edc6c24bca6c
parent 2aff75f58eb202dbf245787f2ae98c43124724f4
Author: Roberto Ierusalimschy <roberto@inf.puc-rio.br>
Date: Mon, 10 Mar 2014 14:56:07 -0300
"indent -kr -i2 -br -brf -nut" plus a few manual formating
Diffstat:
| M | ldump.c | | | 278 | ++++++++++++++++++++++++++++++++++++++++--------------------------------------- |
| M | lundump.c | | | 429 | +++++++++++++++++++++++++++++++++++++++++-------------------------------------- |
2 files changed, 363 insertions(+), 344 deletions(-)
diff --git a/ldump.c b/ldump.c
@@ -1,5 +1,5 @@
/*
-** $Id: ldump.c,v 2.23 2014/02/28 16:13:01 roberto Exp roberto $
+** $Id: ldump.c,v 2.24 2014/03/01 15:18:44 roberto Exp roberto $
** save precompiled Lua chunks
** See Copyright Notice in lua.h
*/
@@ -15,176 +15,180 @@
#include "lstate.h"
#include "lundump.h"
+
typedef struct {
- lua_State* L;
- lua_Writer writer;
- void* data;
- int strip;
- int status;
+ lua_State *L;
+ lua_Writer writer;
+ void *data;
+ int strip;
+ int status;
} DumpState;
#define DumpVar(x,D) DumpBlock(&x,sizeof(x),D)
#define DumpVector(v,n,D) DumpBlock(v,(n)*sizeof((v)[0]),D)
-static void DumpBlock(const void* b, size_t size, DumpState* D)
-{
- if (D->status==0)
- {
- lua_unlock(D->L);
- D->status=(*D->writer)(D->L,b,size,D->data);
- lua_lock(D->L);
- }
+
+static void DumpBlock (const void *b, size_t size, DumpState *D) {
+ if (D->status == 0) {
+ lua_unlock(D->L);
+ D->status = (*D->writer)(D->L, b, size, D->data);
+ lua_lock(D->L);
+ }
}
-static void DumpByte(int y, DumpState* D)
-{
- lu_byte x=(lu_byte)y;
- DumpVar(x,D);
+
+static void DumpByte (int y, DumpState *D) {
+ lu_byte x = (lu_byte)y;
+ DumpVar(x, D);
}
-static void DumpInt(int x, DumpState* D)
-{
- DumpVar(x,D);
+
+static void DumpInt (int x, DumpState *D) {
+ DumpVar(x, D);
}
-static void DumpNumber(lua_Number x, DumpState* D)
-{
- DumpVar(x,D);
+
+static void DumpNumber (lua_Number x, DumpState *D) {
+ DumpVar(x, D);
}
-static void DumpInteger(lua_Integer x, DumpState* D)
-{
- DumpVar(x,D);
+
+static void DumpInteger (lua_Integer x, DumpState *D) {
+ DumpVar(x, D);
}
-static void DumpString(const TString* s, DumpState* D)
-{
- if (s==NULL) DumpByte(0,D);
- else {
- size_t size = s->tsv.len+1; /* include trailing '\0' */
- if (size < 0xFF) DumpByte(size,D);
- else
- {
- DumpByte(0xFF,D);
- DumpVar(size,D);
+
+static void DumpString (const TString *s, DumpState *D) {
+ if (s == NULL)
+ DumpByte(0, D);
+ else {
+ size_t size = s->tsv.len + 1; /* include trailing '\0' */
+ if (size < 0xFF)
+ DumpByte(size, D);
+ else {
+ DumpByte(0xFF, D);
+ DumpVar(size, D);
+ }
+ DumpVector(getstr(s), size - 1, D); /* no need to save '\0' */
}
- DumpVector(getstr(s),size-1,D); /* no need to save '\0' */
- }
}
-static void DumpCode(const Proto* f, DumpState* D)
-{
- DumpInt(f->sizecode,D);
- DumpVector(f->code,f->sizecode,D);
+
+static void DumpCode (const Proto *f, DumpState *D) {
+ DumpInt(f->sizecode, D);
+ DumpVector(f->code, f->sizecode, D);
}
-static void DumpFunction(const Proto* f, DumpState* D);
-
-static void DumpConstants(const Proto* f, DumpState* D)
-{
- int i,n=f->sizek;
- DumpInt(n,D);
- for (i=0; i<n; i++)
- {
- const TValue* o=&f->k[i];
- DumpByte(ttype(o),D);
- switch (ttype(o))
- {
- case LUA_TNIL:
- break;
- case LUA_TBOOLEAN:
- DumpByte(bvalue(o),D);
- break;
- case LUA_TNUMFLT:
- DumpNumber(fltvalue(o),D);
- break;
- case LUA_TNUMINT:
- DumpInteger(ivalue(o),D);
- break;
- case LUA_TSHRSTR: case LUA_TLNGSTR:
- DumpString(rawtsvalue(o),D);
- break;
- default: lua_assert(0);
+
+static void DumpFunction(const Proto *f, DumpState *D);
+
+static void DumpConstants (const Proto *f, DumpState *D) {
+ int i;
+ int n = f->sizek;
+ DumpInt(n, D);
+ for (i = 0; i < n; i++) {
+ const TValue *o = &f->k[i];
+ DumpByte(ttype(o), D);
+ switch (ttype(o)) {
+ case LUA_TNIL:
+ break;
+ case LUA_TBOOLEAN:
+ DumpByte(bvalue(o), D);
+ break;
+ case LUA_TNUMFLT:
+ DumpNumber(fltvalue(o), D);
+ break;
+ case LUA_TNUMINT:
+ DumpInteger(ivalue(o), D);
+ break;
+ case LUA_TSHRSTR:
+ case LUA_TLNGSTR:
+ DumpString(rawtsvalue(o), D);
+ break;
+ default:
+ lua_assert(0);
+ }
}
- }
- n=f->sizep;
- DumpInt(n,D);
- for (i=0; i<n; i++) DumpFunction(f->p[i],D);
+ n = f->sizep;
+ DumpInt(n, D);
+ for (i = 0; i < n; i++)
+ DumpFunction(f->p[i], D);
}
-static void DumpUpvalues(const Proto* f, DumpState* D)
-{
- int i,n=f->sizeupvalues;
- DumpInt(n,D);
- for (i=0; i<n; i++)
- {
- DumpByte(f->upvalues[i].instack,D);
- DumpByte(f->upvalues[i].idx,D);
- }
+
+static void DumpUpvalues (const Proto *f, DumpState *D) {
+ int i, n = f->sizeupvalues;
+ DumpInt(n, D);
+ for (i = 0; i < n; i++) {
+ DumpByte(f->upvalues[i].instack, D);
+ DumpByte(f->upvalues[i].idx, D);
+ }
}
-static void DumpDebug(const Proto* f, DumpState* D)
-{
- int i,n;
- DumpString((D->strip) ? NULL : f->source,D);
- n= (D->strip) ? 0 : f->sizelineinfo;
- DumpInt(n,D);
- DumpVector(f->lineinfo,n,D);
- n= (D->strip) ? 0 : f->sizelocvars;
- DumpInt(n,D);
- for (i=0; i<n; i++)
- {
- DumpString(f->locvars[i].varname,D);
- DumpInt(f->locvars[i].startpc,D);
- DumpInt(f->locvars[i].endpc,D);
- }
- n= (D->strip) ? 0 : f->sizeupvalues;
- DumpInt(n,D);
- for (i=0; i<n; i++) DumpString(f->upvalues[i].name,D);
+
+static void DumpDebug (const Proto *f, DumpState *D) {
+ int i, n;
+ DumpString((D->strip) ? NULL : f->source, D);
+ n = (D->strip) ? 0 : f->sizelineinfo;
+ DumpInt(n, D);
+ DumpVector(f->lineinfo, n, D);
+ n = (D->strip) ? 0 : f->sizelocvars;
+ DumpInt(n, D);
+ for (i = 0; i < n; i++) {
+ DumpString(f->locvars[i].varname, D);
+ DumpInt(f->locvars[i].startpc, D);
+ DumpInt(f->locvars[i].endpc, D);
+ }
+ n = (D->strip) ? 0 : f->sizeupvalues;
+ DumpInt(n, D);
+ for (i = 0; i < n; i++)
+ DumpString(f->upvalues[i].name, D);
}
-static void DumpFunction(const Proto* f, DumpState* D)
-{
- DumpInt(f->linedefined,D);
- DumpInt(f->lastlinedefined,D);
- DumpByte(f->numparams,D);
- DumpByte(f->is_vararg,D);
- DumpByte(f->maxstacksize,D);
- DumpCode(f,D);
- DumpConstants(f,D);
- DumpUpvalues(f,D);
- DumpDebug(f,D);
+
+static void DumpFunction (const Proto *f, DumpState *D) {
+ DumpInt(f->linedefined, D);
+ DumpInt(f->lastlinedefined, D);
+ DumpByte(f->numparams, D);
+ DumpByte(f->is_vararg, D);
+ DumpByte(f->maxstacksize, D);
+ DumpCode(f, D);
+ DumpConstants(f, D);
+ DumpUpvalues(f, D);
+ DumpDebug(f, D);
}
-static void DumpHeader(DumpState* D)
-{
- DumpBlock(LUA_SIGNATURE,sizeof(LUA_SIGNATURE),D);
- DumpBlock(LUAC_DATA,sizeof(LUAC_DATA),D);
- DumpByte(LUAC_VERSION,D);
- DumpByte(LUAC_FORMAT,D);
- DumpByte(sizeof(int),D);
- DumpByte(sizeof(size_t),D);
- DumpByte(sizeof(Instruction),D);
- DumpByte(sizeof(lua_Integer),D);
- DumpByte(sizeof(lua_Number),D);
- DumpInteger(LUAC_INT,D);
- DumpNumber(LUAC_NUM,D);
+
+static void DumpHeader (DumpState *D) {
+ DumpBlock(LUA_SIGNATURE, sizeof(LUA_SIGNATURE), D);
+ DumpBlock(LUAC_DATA, sizeof(LUAC_DATA), D);
+ DumpByte(LUAC_VERSION, D);
+ DumpByte(LUAC_FORMAT, D);
+ DumpByte(sizeof(int), D);
+ DumpByte(sizeof(size_t), D);
+ DumpByte(sizeof(Instruction), D);
+ DumpByte(sizeof(lua_Integer), D);
+ DumpByte(sizeof(lua_Number), D);
+ DumpInteger(LUAC_INT, D);
+ DumpNumber(LUAC_NUM, D);
}
+
/*
** dump Lua function as precompiled chunk
*/
-int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip)
-{
- DumpState D;
- D.L=L;
- D.writer=w;
- D.data=data;
- D.strip=strip;
- D.status=0;
- DumpHeader(&D);
- DumpByte(f->sizeupvalues,&D);
- DumpFunction(f,&D);
- return D.status;
+int luaU_dump(lua_State *L, const Proto *f, lua_Writer w, void *data,
+ int strip) {
+ DumpState D;
+ D.L = L;
+ D.writer = w;
+ D.data = data;
+ D.strip = strip;
+ D.status = 0;
+ DumpHeader(&D);
+ DumpByte(f->sizeupvalues, &D);
+ DumpFunction(f, &D);
+ return D.status;
}
+
diff --git a/lundump.c b/lundump.c
@@ -1,5 +1,5 @@
/*
-** $Id: lundump.c,v 2.29 2014/02/28 16:13:01 roberto Exp roberto $
+** $Id: lundump.c,v 2.30 2014/03/01 15:18:44 roberto Exp roberto $
** load precompiled Lua chunks
** See Copyright Notice in lua.h
*/
@@ -20,227 +20,242 @@
#include "lundump.h"
#include "lzio.h"
-typedef struct {
- lua_State* L;
- ZIO* Z;
- Mbuffer* b;
- const char* name;
-} LoadState;
-
-static l_noret error(LoadState* S, const char* why)
-{
- luaO_pushfstring(S->L,"%s: %s precompiled chunk",S->name,why);
- luaD_throw(S->L,LUA_ERRSYNTAX);
-}
#define LoadVar(S,x) LoadBlock(S,&x,sizeof(x))
#define LoadVector(S,b,n) LoadBlock(S,b,(n)*sizeof((b)[0]))
#if !defined(luai_verifycode)
-#define luai_verifycode(L,b,f) /* empty */
+#define luai_verifycode(L,b,f) /* empty */
#endif
-static void LoadBlock(LoadState* S, void* b, size_t size)
-{
- if (luaZ_read(S->Z,b,size)!=0) error(S,"truncated");
-}
-
-static lu_byte LoadByte(LoadState* S)
-{
- lu_byte x;
- LoadVar(S,x);
- return x;
-}
-
-static int LoadInt(LoadState* S)
-{
- int x;
- LoadVar(S,x);
- if (x<0) error(S,"corrupted");
- return x;
-}
-
-static lua_Number LoadNumber(LoadState* S)
-{
- lua_Number x;
- LoadVar(S,x);
- return x;
-}
-
-static lua_Integer LoadInteger(LoadState* S)
-{
- lua_Integer x;
- LoadVar(S,x);
- return x;
-}
-
-static TString* LoadString(LoadState* S)
-{
- size_t size = LoadByte(S);
- if (size == 0xFF) LoadVar(S,size);
- if (size==0)
- return NULL;
- else
- {
- char* s=luaZ_openspace(S->L,S->b,--size);
- LoadVector(S,s,size);
- return luaS_newlstr(S->L,s,size);
- }
-}
-
-static void LoadCode(LoadState* S, Proto* f)
-{
- int n=LoadInt(S);
- f->code=luaM_newvector(S->L,n,Instruction);
- f->sizecode=n;
- LoadVector(S,f->code,n);
-}
-
-static void LoadFunction(LoadState* S, Proto* f);
-
-static void LoadConstants(LoadState* S, Proto* f)
-{
- int i,n;
- n=LoadInt(S);
- f->k=luaM_newvector(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);
- switch (t)
- {
- case LUA_TNIL:
- setnilvalue(o);
- break;
- case LUA_TBOOLEAN:
- setbvalue(o,LoadByte(S));
- break;
- case LUA_TNUMFLT:
- setnvalue(o,LoadNumber(S));
- break;
- case LUA_TNUMINT:
- setivalue(o,LoadInteger(S));
- break;
- case LUA_TSHRSTR: case LUA_TLNGSTR:
- setsvalue2n(S->L,o,LoadString(S));
- break;
- default: lua_assert(0);
+
+typedef struct {
+ lua_State *L;
+ ZIO *Z;
+ Mbuffer *b;
+ const char *name;
+} LoadState;
+
+
+static l_noret error(LoadState *S, const char *why) {
+ luaO_pushfstring(S->L, "%s: %s precompiled chunk", S->name, why);
+ luaD_throw(S->L, LUA_ERRSYNTAX);
+}
+
+
+static void LoadBlock (LoadState *S, void *b, size_t size) {
+ if (luaZ_read(S->Z, b, size) != 0)
+ error(S, "truncated");
+}
+
+
+static lu_byte LoadByte (LoadState *S) {
+ lu_byte x;
+ LoadVar(S, x);
+ return x;
+}
+
+
+static int LoadInt (LoadState *S) {
+ int x;
+ LoadVar(S, x);
+ if (x < 0)
+ error(S, "corrupted");
+ return x;
+}
+
+
+static lua_Number LoadNumber (LoadState *S) {
+ lua_Number x;
+ LoadVar(S, x);
+ return x;
+}
+
+
+static lua_Integer LoadInteger (LoadState *S) {
+ lua_Integer x;
+ LoadVar(S, x);
+ return x;
+}
+
+
+static TString *LoadString (LoadState *S) {
+ size_t size = LoadByte(S);
+ if (size == 0xFF)
+ LoadVar(S, size);
+ if (size == 0)
+ return NULL;
+ else {
+ char *s = luaZ_openspace(S->L, S->b, --size);
+ LoadVector(S, s, size);
+ return luaS_newlstr(S->L, s, size);
}
- }
- n=LoadInt(S);
- f->p=luaM_newvector(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]);
- }
-}
-
-static void LoadUpvalues(LoadState* S, Proto* f)
-{
- int i,n;
- n=LoadInt(S);
- f->upvalues=luaM_newvector(S->L,n,Upvaldesc);
- f->sizeupvalues=n;
- for (i=0; i<n; i++) f->upvalues[i].name=NULL;
- for (i=0; i<n; i++)
- {
- f->upvalues[i].instack=LoadByte(S);
- f->upvalues[i].idx=LoadByte(S);
- }
-}
-
-static void LoadDebug(LoadState* S, Proto* f)
-{
- int i,n;
- f->source=LoadString(S);
- n=LoadInt(S);
- f->lineinfo=luaM_newvector(S->L,n,int);
- f->sizelineinfo=n;
- LoadVector(S,f->lineinfo,n);
- n=LoadInt(S);
- f->locvars=luaM_newvector(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=LoadString(S);
- f->locvars[i].startpc=LoadInt(S);
- f->locvars[i].endpc=LoadInt(S);
- }
- n=LoadInt(S);
- for (i=0; i<n; i++) f->upvalues[i].name=LoadString(S);
-}
-
-static void LoadFunction(LoadState* S, Proto* 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);
- LoadDebug(S,f);
-}
-
-static void checkstring(LoadState *S, const char *s, const char *msg)
-{
- char buff[sizeof(LUA_SIGNATURE)+sizeof(LUAC_DATA)]; /* larger than each */
- LoadVector(S,buff,strlen(s)+1);
- if (strcmp(s,buff)!=0) error(S,msg);
-}
-
-static void fchecksize(LoadState *S, size_t size, const char *tname)
-{
- if (LoadByte(S) != size)
- error(S,luaO_pushfstring(S->L,"%s size mismatch in",tname));
}
+
+static void LoadCode (LoadState *S, Proto *f) {
+ int n = LoadInt(S);
+ f->code = luaM_newvector(S->L, n, Instruction);
+ f->sizecode = n;
+ LoadVector(S, f->code, n);
+}
+
+
+static void LoadFunction(LoadState *S, Proto *f);
+
+
+static void LoadConstants (LoadState *S, Proto *f) {
+ int i, n;
+ n = LoadInt(S);
+ f->k = luaM_newvector(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);
+ switch (t) {
+ case LUA_TNIL:
+ setnilvalue(o);
+ break;
+ case LUA_TBOOLEAN:
+ setbvalue(o, LoadByte(S));
+ break;
+ case LUA_TNUMFLT:
+ setnvalue(o, LoadNumber(S));
+ break;
+ case LUA_TNUMINT:
+ setivalue(o, LoadInteger(S));
+ break;
+ case LUA_TSHRSTR:
+ case LUA_TLNGSTR:
+ setsvalue2n(S->L, o, LoadString(S));
+ break;
+ default:
+ lua_assert(0);
+ }
+ }
+ n = LoadInt(S);
+ f->p = luaM_newvector(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]);
+ }
+}
+
+
+static void LoadUpvalues (LoadState *S, Proto *f) {
+ int i, n;
+ n = LoadInt(S);
+ f->upvalues = luaM_newvector(S->L, n, Upvaldesc);
+ f->sizeupvalues = n;
+ for (i = 0; i < n; i++)
+ f->upvalues[i].name = NULL;
+ for (i = 0; i < n; i++) {
+ f->upvalues[i].instack = LoadByte(S);
+ f->upvalues[i].idx = LoadByte(S);
+ }
+}
+
+
+static void LoadDebug (LoadState *S, Proto *f) {
+ int i, n;
+ f->source = LoadString(S);
+ n = LoadInt(S);
+ f->lineinfo = luaM_newvector(S->L, n, int);
+ f->sizelineinfo = n;
+ LoadVector(S, f->lineinfo, n);
+ n = LoadInt(S);
+ f->locvars = luaM_newvector(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 = LoadString(S);
+ f->locvars[i].startpc = LoadInt(S);
+ f->locvars[i].endpc = LoadInt(S);
+ }
+ n = LoadInt(S);
+ for (i = 0; i < n; i++)
+ f->upvalues[i].name = LoadString(S);
+}
+
+
+static void LoadFunction (LoadState *S, Proto *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);
+ LoadDebug(S, f);
+}
+
+
+static void checkstring (LoadState *S, const char *s, const char *msg) {
+ char buff[sizeof(LUA_SIGNATURE) + sizeof(LUAC_DATA)]; /* larger than each */
+ LoadVector(S, buff, strlen(s) + 1);
+ if (strcmp(s, buff) != 0)
+ error(S, msg);
+}
+
+
+static void fchecksize (LoadState *S, size_t size, const char *tname) {
+ if (LoadByte(S) != size)
+ error(S, luaO_pushfstring(S->L, "%s size mismatch in", tname));
+}
+
+
#define checksize(S,t) fchecksize(S,sizeof(t),#t)
-static void checkHeader(LoadState* S)
-{
- checkstring(S,LUA_SIGNATURE+1,"not a");
- checkstring(S,LUAC_DATA,"corrupted");
- if (LoadByte(S) != LUAC_VERSION) error(S,"version mismatch in");
- if (LoadByte(S) != LUAC_FORMAT) error(S,"format mismatch in");
- checksize(S,int);
- checksize(S,size_t);
- checksize(S,Instruction);
- checksize(S,lua_Integer);
- checksize(S,lua_Number);
- if (LoadInteger(S) != LUAC_INT) error(S,"endianess mismatch in");
- if (LoadNumber(S) != LUAC_NUM) error(S,"float format mismatch in");
+static void checkHeader (LoadState *S) {
+ checkstring(S, LUA_SIGNATURE + 1, "not a");
+ checkstring(S, LUAC_DATA, "corrupted");
+ if (LoadByte(S) != LUAC_VERSION)
+ error(S, "version mismatch in");
+ if (LoadByte(S) != LUAC_FORMAT)
+ error(S, "format mismatch in");
+ checksize(S, int);
+ checksize(S, size_t);
+ checksize(S, Instruction);
+ checksize(S, lua_Integer);
+ checksize(S, lua_Number);
+ if (LoadInteger(S) != LUAC_INT)
+ error(S, "endianess mismatch in");
+ if (LoadNumber(S) != LUAC_NUM)
+ error(S, "float format mismatch in");
}
+
/*
** load precompiled chunk
*/
-Closure* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name)
-{
- LoadState S;
- Closure* cl;
- if (*name=='@' || *name=='=')
- S.name=name+1;
- else if (*name==LUA_SIGNATURE[0])
- S.name="binary string";
- else
- S.name=name;
- S.L=L;
- S.Z=Z;
- S.b=buff;
- checkHeader(&S);
- cl=luaF_newLclosure(L,LoadByte(&S));
- setclLvalue(L,L->top,cl); incr_top(L);
- cl->l.p=luaF_newproto(L);
- LoadFunction(&S,cl->l.p);
- lua_assert(cl->l.nupvalues==cl->l.p->sizeupvalues);
- luai_verifycode(L,buff,cl->l.p);
- return cl;
+Closure *luaU_undump(lua_State *L, ZIO *Z, Mbuffer *buff,
+ const char *name) {
+ LoadState S;
+ Closure *cl;
+ if (*name == '@' || *name == '=')
+ S.name = name + 1;
+ else if (*name == LUA_SIGNATURE[0])
+ S.name = "binary string";
+ else
+ S.name = name;
+ S.L = L;
+ S.Z = Z;
+ S.b = buff;
+ checkHeader(&S);
+ cl = luaF_newLclosure(L, LoadByte(&S));
+ setclLvalue(L, L->top, cl);
+ incr_top(L);
+ cl->l.p = luaF_newproto(L);
+ LoadFunction(&S, cl->l.p);
+ lua_assert(cl->l.nupvalues == cl->l.p->sizeupvalues);
+ luai_verifycode(L, buff, cl->l.p);
+ return cl;
}
+
