]>
Commit | Line | Data |
---|---|---|
1e59de90 TL |
1 | /* |
2 | ** $Id: lundump.c,v 2.44.1.1 2017/04/19 17:20:42 roberto Exp $ | |
3 | ** load precompiled Lua chunks | |
4 | ** See Copyright Notice in lua.h | |
5 | */ | |
6 | ||
7 | #define lundump_c | |
8 | #define LUA_CORE | |
9 | ||
10 | #include "lprefix.h" | |
11 | ||
12 | ||
13 | #include <string.h> | |
14 | ||
15 | #include "lua.h" | |
16 | ||
17 | #include "ldebug.h" | |
18 | #include "ldo.h" | |
19 | #include "lfunc.h" | |
20 | #include "lmem.h" | |
21 | #include "lobject.h" | |
22 | #include "lstring.h" | |
23 | #include "lundump.h" | |
24 | #include "lzio.h" | |
25 | ||
26 | ||
27 | #if !defined(luai_verifycode) | |
28 | #define luai_verifycode(L,b,f) /* empty */ | |
29 | #endif | |
30 | ||
31 | ||
32 | typedef struct { | |
33 | lua_State *L; | |
34 | ZIO *Z; | |
35 | const char *name; | |
36 | } LoadState; | |
37 | ||
38 | ||
39 | static l_noret error(LoadState *S, const char *why) { | |
40 | luaO_pushfstring(S->L, "%s: %s precompiled chunk", S->name, why); | |
41 | luaD_throw(S->L, LUA_ERRSYNTAX); | |
42 | } | |
43 | ||
44 | ||
45 | /* | |
46 | ** All high-level loads go through LoadVector; you can change it to | |
47 | ** adapt to the endianness of the input | |
48 | */ | |
49 | #define LoadVector(S,b,n) LoadBlock(S,b,(n)*sizeof((b)[0])) | |
50 | ||
51 | static void LoadBlock (LoadState *S, void *b, size_t size) { | |
52 | if (luaZ_read(S->Z, b, size) != 0) | |
53 | error(S, "truncated"); | |
54 | } | |
55 | ||
56 | ||
57 | #define LoadVar(S,x) LoadVector(S,&x,1) | |
58 | ||
59 | ||
60 | static lu_byte LoadByte (LoadState *S) { | |
61 | lu_byte x; | |
62 | LoadVar(S, x); | |
63 | return x; | |
64 | } | |
65 | ||
66 | ||
67 | static int LoadInt (LoadState *S) { | |
68 | int x; | |
69 | LoadVar(S, x); | |
70 | return x; | |
71 | } | |
72 | ||
73 | ||
74 | static lua_Number LoadNumber (LoadState *S) { | |
75 | lua_Number x; | |
76 | LoadVar(S, x); | |
77 | return x; | |
78 | } | |
79 | ||
80 | ||
81 | static lua_Integer LoadInteger (LoadState *S) { | |
82 | lua_Integer x; | |
83 | LoadVar(S, x); | |
84 | return x; | |
85 | } | |
86 | ||
87 | ||
88 | static TString *LoadString (LoadState *S, Proto *p) { | |
89 | lua_State *L = S->L; | |
90 | size_t size = LoadByte(S); | |
91 | TString *ts; | |
92 | if (size == 0xFF) | |
93 | LoadVar(S, size); | |
94 | if (size == 0) | |
95 | return NULL; | |
96 | else if (--size <= LUAI_MAXSHORTLEN) { /* short string? */ | |
97 | char buff[LUAI_MAXSHORTLEN]; | |
98 | LoadVector(S, buff, size); | |
99 | ts = luaS_newlstr(L, buff, size); | |
100 | } | |
101 | else { /* long string */ | |
102 | ts = luaS_createlngstrobj(L, size); | |
103 | setsvalue2s(L, L->top, ts); /* anchor it ('loadVector' can GC) */ | |
104 | luaD_inctop(L); | |
105 | LoadVector(S, getstr(ts), size); /* load directly in final place */ | |
106 | L->top--; /* pop string */ | |
107 | } | |
108 | luaC_objbarrier(L, p, ts); | |
109 | return ts; | |
110 | } | |
111 | ||
112 | ||
113 | static void LoadCode (LoadState *S, Proto *f) { | |
114 | int n = LoadInt(S); | |
115 | f->code = luaM_newvector(S->L, n, Instruction); | |
116 | f->sizecode = n; | |
117 | LoadVector(S, f->code, n); | |
118 | } | |
119 | ||
120 | ||
121 | static void LoadFunction(LoadState *S, Proto *f, TString *psource); | |
122 | ||
123 | ||
124 | static void LoadConstants (LoadState *S, Proto *f) { | |
125 | int i; | |
126 | int n = LoadInt(S); | |
127 | f->k = luaM_newvector(S->L, n, TValue); | |
128 | f->sizek = n; | |
129 | for (i = 0; i < n; i++) | |
130 | setnilvalue(&f->k[i]); | |
131 | for (i = 0; i < n; i++) { | |
132 | TValue *o = &f->k[i]; | |
133 | int t = LoadByte(S); | |
134 | switch (t) { | |
135 | case LUA_TNIL: | |
136 | setnilvalue(o); | |
137 | break; | |
138 | case LUA_TBOOLEAN: | |
139 | setbvalue(o, LoadByte(S)); | |
140 | break; | |
141 | case LUA_TNUMFLT: | |
142 | setfltvalue(o, LoadNumber(S)); | |
143 | break; | |
144 | case LUA_TNUMINT: | |
145 | setivalue(o, LoadInteger(S)); | |
146 | break; | |
147 | case LUA_TSHRSTR: | |
148 | case LUA_TLNGSTR: | |
149 | setsvalue2n(S->L, o, LoadString(S, f)); | |
150 | break; | |
151 | default: | |
152 | lua_assert(0); | |
153 | } | |
154 | } | |
155 | } | |
156 | ||
157 | ||
158 | static void LoadProtos (LoadState *S, Proto *f) { | |
159 | int i; | |
160 | int n = LoadInt(S); | |
161 | f->p = luaM_newvector(S->L, n, Proto *); | |
162 | f->sizep = n; | |
163 | for (i = 0; i < n; i++) | |
164 | f->p[i] = NULL; | |
165 | for (i = 0; i < n; i++) { | |
166 | f->p[i] = luaF_newproto(S->L); | |
167 | luaC_objbarrier(S->L, f, f->p[i]); | |
168 | LoadFunction(S, f->p[i], f->source); | |
169 | } | |
170 | } | |
171 | ||
172 | ||
173 | static void LoadUpvalues (LoadState *S, Proto *f) { | |
174 | int i, n; | |
175 | n = LoadInt(S); | |
176 | f->upvalues = luaM_newvector(S->L, n, Upvaldesc); | |
177 | f->sizeupvalues = n; | |
178 | for (i = 0; i < n; i++) | |
179 | f->upvalues[i].name = NULL; | |
180 | for (i = 0; i < n; i++) { | |
181 | f->upvalues[i].instack = LoadByte(S); | |
182 | f->upvalues[i].idx = LoadByte(S); | |
183 | } | |
184 | } | |
185 | ||
186 | ||
187 | static void LoadDebug (LoadState *S, Proto *f) { | |
188 | int i, n; | |
189 | n = LoadInt(S); | |
190 | f->lineinfo = luaM_newvector(S->L, n, int); | |
191 | f->sizelineinfo = n; | |
192 | LoadVector(S, f->lineinfo, n); | |
193 | n = LoadInt(S); | |
194 | f->locvars = luaM_newvector(S->L, n, LocVar); | |
195 | f->sizelocvars = n; | |
196 | for (i = 0; i < n; i++) | |
197 | f->locvars[i].varname = NULL; | |
198 | for (i = 0; i < n; i++) { | |
199 | f->locvars[i].varname = LoadString(S, f); | |
200 | f->locvars[i].startpc = LoadInt(S); | |
201 | f->locvars[i].endpc = LoadInt(S); | |
202 | } | |
203 | n = LoadInt(S); | |
204 | for (i = 0; i < n; i++) | |
205 | f->upvalues[i].name = LoadString(S, f); | |
206 | } | |
207 | ||
208 | ||
209 | static void LoadFunction (LoadState *S, Proto *f, TString *psource) { | |
210 | f->source = LoadString(S, f); | |
211 | if (f->source == NULL) /* no source in dump? */ | |
212 | f->source = psource; /* reuse parent's source */ | |
213 | f->linedefined = LoadInt(S); | |
214 | f->lastlinedefined = LoadInt(S); | |
215 | f->numparams = LoadByte(S); | |
216 | f->is_vararg = LoadByte(S); | |
217 | f->maxstacksize = LoadByte(S); | |
218 | LoadCode(S, f); | |
219 | LoadConstants(S, f); | |
220 | LoadUpvalues(S, f); | |
221 | LoadProtos(S, f); | |
222 | LoadDebug(S, f); | |
223 | } | |
224 | ||
225 | ||
226 | static void checkliteral (LoadState *S, const char *s, const char *msg) { | |
227 | char buff[sizeof(LUA_SIGNATURE) + sizeof(LUAC_DATA)]; /* larger than both */ | |
228 | size_t len = strlen(s); | |
229 | LoadVector(S, buff, len); | |
230 | if (memcmp(s, buff, len) != 0) | |
231 | error(S, msg); | |
232 | } | |
233 | ||
234 | ||
235 | static void fchecksize (LoadState *S, size_t size, const char *tname) { | |
236 | if (LoadByte(S) != size) | |
237 | error(S, luaO_pushfstring(S->L, "%s size mismatch in", tname)); | |
238 | } | |
239 | ||
240 | ||
241 | #define checksize(S,t) fchecksize(S,sizeof(t),#t) | |
242 | ||
243 | static void checkHeader (LoadState *S) { | |
244 | checkliteral(S, LUA_SIGNATURE + 1, "not a"); /* 1st char already checked */ | |
245 | if (LoadByte(S) != LUAC_VERSION) | |
246 | error(S, "version mismatch in"); | |
247 | if (LoadByte(S) != LUAC_FORMAT) | |
248 | error(S, "format mismatch in"); | |
249 | checkliteral(S, LUAC_DATA, "corrupted"); | |
250 | checksize(S, int); | |
251 | checksize(S, size_t); | |
252 | checksize(S, Instruction); | |
253 | checksize(S, lua_Integer); | |
254 | checksize(S, lua_Number); | |
255 | if (LoadInteger(S) != LUAC_INT) | |
256 | error(S, "endianness mismatch in"); | |
257 | if (LoadNumber(S) != LUAC_NUM) | |
258 | error(S, "float format mismatch in"); | |
259 | } | |
260 | ||
261 | ||
262 | /* | |
263 | ** load precompiled chunk | |
264 | */ | |
265 | LClosure *luaU_undump(lua_State *L, ZIO *Z, const char *name) { | |
266 | LoadState S; | |
267 | LClosure *cl; | |
268 | if (*name == '@' || *name == '=') | |
269 | S.name = name + 1; | |
270 | else if (*name == LUA_SIGNATURE[0]) | |
271 | S.name = "binary string"; | |
272 | else | |
273 | S.name = name; | |
274 | S.L = L; | |
275 | S.Z = Z; | |
276 | checkHeader(&S); | |
277 | cl = luaF_newLclosure(L, LoadByte(&S)); | |
278 | setclLvalue(L, L->top, cl); | |
279 | luaD_inctop(L); | |
280 | cl->p = luaF_newproto(L); | |
281 | luaC_objbarrier(L, cl, cl->p); | |
282 | LoadFunction(&S, cl->p, NULL); | |
283 | lua_assert(cl->nupvalues == cl->p->sizeupvalues); | |
284 | luai_verifycode(L, buff, cl->p); | |
285 | return cl; | |
286 | } | |
287 |