1 /* $NetBSD: lundump.c,v 1.1.1.2 2012/03/15 00:08:14 alnsn Exp $ */ 2 3 /* 4 ** $Id: lundump.c,v 1.1.1.2 2012/03/15 00:08:14 alnsn Exp $ 5 ** load precompiled Lua chunks 6 ** See Copyright Notice in lua.h 7 */ 8 9 #include <string.h> 10 11 #define lundump_c 12 #define LUA_CORE 13 14 #include "lua.h" 15 16 #include "ldebug.h" 17 #include "ldo.h" 18 #include "lfunc.h" 19 #include "lmem.h" 20 #include "lobject.h" 21 #include "lstring.h" 22 #include "lundump.h" 23 #include "lzio.h" 24 25 typedef struct { 26 lua_State* L; 27 ZIO* Z; 28 Mbuffer* b; 29 const char* name; 30 } LoadState; 31 32 #ifdef LUAC_TRUST_BINARIES 33 #define IF(c,s) 34 #define error(S,s) 35 #else 36 #define IF(c,s) if (c) error(S,s) 37 38 static void error(LoadState* S, const char* why) 39 { 40 luaO_pushfstring(S->L,"%s: %s in precompiled chunk",S->name,why); 41 luaD_throw(S->L,LUA_ERRSYNTAX); 42 } 43 #endif 44 45 #define LoadMem(S,b,n,size) LoadBlock(S,b,(n)*(size)) 46 #define LoadByte(S) (lu_byte)LoadChar(S) 47 #define LoadVar(S,x) LoadMem(S,&x,1,sizeof(x)) 48 #define LoadVector(S,b,n,size) LoadMem(S,b,n,size) 49 50 static void LoadBlock(LoadState* S, void* b, size_t size) 51 { 52 size_t r=luaZ_read(S->Z,b,size); 53 IF (r!=0, "unexpected end"); 54 } 55 56 static int LoadChar(LoadState* S) 57 { 58 char x; 59 LoadVar(S,x); 60 return x; 61 } 62 63 static int LoadInt(LoadState* S) 64 { 65 int x; 66 LoadVar(S,x); 67 IF (x<0, "bad integer"); 68 return x; 69 } 70 71 static lua_Number LoadNumber(LoadState* S) 72 { 73 lua_Number x; 74 LoadVar(S,x); 75 return x; 76 } 77 78 static TString* LoadString(LoadState* S) 79 { 80 size_t size; 81 LoadVar(S,size); 82 if (size==0) 83 return NULL; 84 else 85 { 86 char* s=luaZ_openspace(S->L,S->b,size); 87 LoadBlock(S,s,size); 88 return luaS_newlstr(S->L,s,size-1); /* remove trailing '\0' */ 89 } 90 } 91 92 static void LoadCode(LoadState* S, Proto* f) 93 { 94 int n=LoadInt(S); 95 f->code=luaM_newvector(S->L,n,Instruction); 96 f->sizecode=n; 97 LoadVector(S,f->code,n,sizeof(Instruction)); 98 } 99 100 static Proto* LoadFunction(LoadState* S, TString* p); 101 102 static void LoadConstants(LoadState* S, Proto* f) 103 { 104 int i,n; 105 n=LoadInt(S); 106 f->k=luaM_newvector(S->L,n,TValue); 107 f->sizek=n; 108 for (i=0; i<n; i++) setnilvalue(&f->k[i]); 109 for (i=0; i<n; i++) 110 { 111 TValue* o=&f->k[i]; 112 int t=LoadChar(S); 113 switch (t) 114 { 115 case LUA_TNIL: 116 setnilvalue(o); 117 break; 118 case LUA_TBOOLEAN: 119 setbvalue(o,LoadChar(S)!=0); 120 break; 121 case LUA_TNUMBER: 122 setnvalue(o,LoadNumber(S)); 123 break; 124 case LUA_TSTRING: 125 setsvalue2n(S->L,o,LoadString(S)); 126 break; 127 default: 128 error(S,"bad constant"); 129 break; 130 } 131 } 132 n=LoadInt(S); 133 f->p=luaM_newvector(S->L,n,Proto*); 134 f->sizep=n; 135 for (i=0; i<n; i++) f->p[i]=NULL; 136 for (i=0; i<n; i++) f->p[i]=LoadFunction(S,f->source); 137 } 138 139 static void LoadDebug(LoadState* S, Proto* f) 140 { 141 int i,n; 142 n=LoadInt(S); 143 f->lineinfo=luaM_newvector(S->L,n,int); 144 f->sizelineinfo=n; 145 LoadVector(S,f->lineinfo,n,sizeof(int)); 146 n=LoadInt(S); 147 f->locvars=luaM_newvector(S->L,n,LocVar); 148 f->sizelocvars=n; 149 for (i=0; i<n; i++) f->locvars[i].varname=NULL; 150 for (i=0; i<n; i++) 151 { 152 f->locvars[i].varname=LoadString(S); 153 f->locvars[i].startpc=LoadInt(S); 154 f->locvars[i].endpc=LoadInt(S); 155 } 156 n=LoadInt(S); 157 f->upvalues=luaM_newvector(S->L,n,TString*); 158 f->sizeupvalues=n; 159 for (i=0; i<n; i++) f->upvalues[i]=NULL; 160 for (i=0; i<n; i++) f->upvalues[i]=LoadString(S); 161 } 162 163 static Proto* LoadFunction(LoadState* S, TString* p) 164 { 165 Proto* f; 166 if (++S->L->nCcalls > LUAI_MAXCCALLS) error(S,"code too deep"); 167 f=luaF_newproto(S->L); 168 setptvalue2s(S->L,S->L->top,f); incr_top(S->L); 169 f->source=LoadString(S); if (f->source==NULL) f->source=p; 170 f->linedefined=LoadInt(S); 171 f->lastlinedefined=LoadInt(S); 172 f->nups=LoadByte(S); 173 f->numparams=LoadByte(S); 174 f->is_vararg=LoadByte(S); 175 f->maxstacksize=LoadByte(S); 176 LoadCode(S,f); 177 LoadConstants(S,f); 178 LoadDebug(S,f); 179 IF (!luaG_checkcode(f), "bad code"); 180 S->L->top--; 181 S->L->nCcalls--; 182 return f; 183 } 184 185 static void LoadHeader(LoadState* S) 186 { 187 char h[LUAC_HEADERSIZE]; 188 char s[LUAC_HEADERSIZE]; 189 luaU_header(h); 190 LoadBlock(S,s,LUAC_HEADERSIZE); 191 IF (memcmp(h,s,LUAC_HEADERSIZE)!=0, "bad header"); 192 } 193 194 /* 195 ** load precompiled chunk 196 */ 197 Proto* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name) 198 { 199 LoadState S; 200 if (*name=='@' || *name=='=') 201 S.name=name+1; 202 else if (*name==LUA_SIGNATURE[0]) 203 S.name="binary string"; 204 else 205 S.name=name; 206 S.L=L; 207 S.Z=Z; 208 S.b=buff; 209 LoadHeader(&S); 210 return LoadFunction(&S,luaS_newliteral(L,"=?")); 211 } 212 213 /* 214 * make header 215 */ 216 void luaU_header (char* h) 217 { 218 int x=1; 219 memcpy(h,LUA_SIGNATURE,sizeof(LUA_SIGNATURE)-1); 220 h+=sizeof(LUA_SIGNATURE)-1; 221 *h++=(char)LUAC_VERSION; 222 *h++=(char)LUAC_FORMAT; 223 *h++=(char)*(char*)&x; /* endianness */ 224 *h++=(char)sizeof(int); 225 *h++=(char)sizeof(size_t); 226 *h++=(char)sizeof(Instruction); 227 *h++=(char)sizeof(lua_Number); 228 *h++=(char)(((lua_Number)0.5)==0); /* is lua_Number integral? */ 229 } 230