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