1/*
2** $Id: lundump.c $
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 <limits.h>
14#include <string.h>
15
16#include "lua.h"
17
18#include "ldebug.h"
19#include "ldo.h"
20#include "lfunc.h"
21#include "lmem.h"
22#include "lobject.h"
23#include "lstring.h"
24#include "lundump.h"
25#include "lzio.h"
26
27
28#if !defined(luai_verifycode)
29#define luai_verifycode(L,f) /* empty */
30#endif
31
32
33typedef struct {
34 lua_State *L;
35 ZIO *Z;
36 const char *name;
37} LoadState;
38
39
40static l_noret error (LoadState *S, const char *why) {
41 luaO_pushfstring(S->L, "%s: bad binary format (%s)", S->name, why);
42 luaD_throw(S->L, LUA_ERRSYNTAX);
43}
44
45
46/*
47** All high-level loads go through loadVector; you can change it to
48** adapt to the endianness of the input
49*/
50#define loadVector(S,b,n) loadBlock(S,b,(n)*sizeof((b)[0]))
51
52static void loadBlock (LoadState *S, void *b, size_t size) {
53 if (luaZ_read(S->Z, b, size) != 0)
54 error(S, "truncated chunk");
55}
56
57
58#define loadVar(S,x) loadVector(S,&x,1)
59
60
61static lu_byte loadByte (LoadState *S) {
62 int b = zgetc(S->Z);
63 if (b == EOZ)
64 error(S, "truncated chunk");
65 return cast_byte(b);
66}
67
68
69static size_t loadUnsigned (LoadState *S, size_t limit) {
70 size_t x = 0;
71 int b;
72 limit >>= 7;
73 do {
74 b = loadByte(S);
75 if (x >= limit)
76 error(S, "integer overflow");
77 x = (x << 7) | (b & 0x7f);
78 } while ((b & 0x80) == 0);
79 return x;
80}
81
82
83static size_t loadSize (LoadState *S) {
84 return loadUnsigned(S, ~(size_t)0);
85}
86
87
88static int loadInt (LoadState *S) {
89 return cast_int(loadUnsigned(S, INT_MAX));
90}
91
92
93static lua_Number loadNumber (LoadState *S) {
94 lua_Number x;
95 loadVar(S, x);
96 return x;
97}
98
99
100static lua_Integer loadInteger (LoadState *S) {
101 lua_Integer x;
102 loadVar(S, x);
103 return x;
104}
105
106
107/*
108** Load a nullable string into prototype 'p'.
109*/
110static TString *loadStringN (LoadState *S, Proto *p) {
111 lua_State *L = S->L;
112 TString *ts;
113 size_t size = loadSize(S);
114 if (size == 0) /* no string? */
115 return NULL;
116 else if (--size <= LUAI_MAXSHORTLEN) { /* short string? */
117 char buff[LUAI_MAXSHORTLEN];
118 loadVector(S, buff, size); /* load string into buffer */
119 ts = luaS_newlstr(L, buff, size); /* create string */
120 }
121 else { /* long string */
122 ts = luaS_createlngstrobj(L, size); /* create string */
123 setsvalue2s(L, L->top, ts); /* anchor it ('loadVector' can GC) */
124 luaD_inctop(L);
125 loadVector(S, getstr(ts), size); /* load directly in final place */
126 L->top--; /* pop string */
127 }
128 luaC_objbarrier(L, p, ts);
129 return ts;
130}
131
132
133/*
134** Load a non-nullable string into prototype 'p'.
135*/
136static TString *loadString (LoadState *S, Proto *p) {
137 TString *st = loadStringN(S, p);
138 if (st == NULL)
139 error(S, "bad format for constant string");
140 return st;
141}
142
143
144static void loadCode (LoadState *S, Proto *f) {
145 int n = loadInt(S);
146 f->code = luaM_newvectorchecked(S->L, n, Instruction);
147 f->sizecode = n;
148 loadVector(S, f->code, n);
149}
150
151
152static void loadFunction(LoadState *S, Proto *f, TString *psource);
153
154
155static void loadConstants (LoadState *S, Proto *f) {
156 int i;
157 int n = loadInt(S);
158 f->k = luaM_newvectorchecked(S->L, n, TValue);
159 f->sizek = n;
160 for (i = 0; i < n; i++)
161 setnilvalue(&f->k[i]);
162 for (i = 0; i < n; i++) {
163 TValue *o = &f->k[i];
164 int t = loadByte(S);
165 switch (t) {
166 case LUA_VNIL:
167 setnilvalue(o);
168 break;
169 case LUA_VFALSE:
170 setbfvalue(o);
171 break;
172 case LUA_VTRUE:
173 setbtvalue(o);
174 break;
175 case LUA_VNUMFLT:
176 setfltvalue(o, loadNumber(S));
177 break;
178 case LUA_VNUMINT:
179 setivalue(o, loadInteger(S));
180 break;
181 case LUA_VSHRSTR:
182 case LUA_VLNGSTR:
183 setsvalue2n(S->L, o, loadString(S, f));
184 break;
185 default: lua_assert(0);
186 }
187 }
188}
189
190
191static void loadProtos (LoadState *S, Proto *f) {
192 int i;
193 int n = loadInt(S);
194 f->p = luaM_newvectorchecked(S->L, n, Proto *);
195 f->sizep = n;
196 for (i = 0; i < n; i++)
197 f->p[i] = NULL;
198 for (i = 0; i < n; i++) {
199 f->p[i] = luaF_newproto(S->L);
200 luaC_objbarrier(S->L, f, f->p[i]);
201 loadFunction(S, f->p[i], f->source);
202 }
203}
204
205
206/*
207** Load the upvalues for a function. The names must be filled first,
208** because the filling of the other fields can raise read errors and
209** the creation of the error message can call an emergency collection;
210** in that case all prototypes must be consistent for the GC.
211*/
212static void loadUpvalues (LoadState *S, Proto *f) {
213 int i, n;
214 n = loadInt(S);
215 f->upvalues = luaM_newvectorchecked(S->L, n, Upvaldesc);
216 f->sizeupvalues = n;
217 for (i = 0; i < n; i++) /* make array valid for GC */
218 f->upvalues[i].name = NULL;
219 for (i = 0; i < n; i++) { /* following calls can raise errors */
220 f->upvalues[i].instack = loadByte(S);
221 f->upvalues[i].idx = loadByte(S);
222 f->upvalues[i].kind = loadByte(S);
223 }
224}
225
226
227static void loadDebug (LoadState *S, Proto *f) {
228 int i, n;
229 n = loadInt(S);
230 f->lineinfo = luaM_newvectorchecked(S->L, n, ls_byte);
231 f->sizelineinfo = n;
232 loadVector(S, f->lineinfo, n);
233 n = loadInt(S);
234 f->abslineinfo = luaM_newvectorchecked(S->L, n, AbsLineInfo);
235 f->sizeabslineinfo = n;
236 for (i = 0; i < n; i++) {
237 f->abslineinfo[i].pc = loadInt(S);
238 f->abslineinfo[i].line = loadInt(S);
239 }
240 n = loadInt(S);
241 f->locvars = luaM_newvectorchecked(S->L, n, LocVar);
242 f->sizelocvars = n;
243 for (i = 0; i < n; i++)
244 f->locvars[i].varname = NULL;
245 for (i = 0; i < n; i++) {
246 f->locvars[i].varname = loadStringN(S, f);
247 f->locvars[i].startpc = loadInt(S);
248 f->locvars[i].endpc = loadInt(S);
249 }
250 n = loadInt(S);
251 for (i = 0; i < n; i++)
252 f->upvalues[i].name = loadStringN(S, f);
253}
254
255
256static void loadFunction (LoadState *S, Proto *f, TString *psource) {
257 f->source = loadStringN(S, f);
258 if (f->source == NULL) /* no source in dump? */
259 f->source = psource; /* reuse parent's source */
260 f->linedefined = loadInt(S);
261 f->lastlinedefined = loadInt(S);
262 f->numparams = loadByte(S);
263 f->is_vararg = loadByte(S);
264 f->maxstacksize = loadByte(S);
265 loadCode(S, f);
266 loadConstants(S, f);
267 loadUpvalues(S, f);
268 loadProtos(S, f);
269 loadDebug(S, f);
270}
271
272
273static void checkliteral (LoadState *S, const char *s, const char *msg) {
274 char buff[sizeof(LUA_SIGNATURE) + sizeof(LUAC_DATA)]; /* larger than both */
275 size_t len = strlen(s);
276 loadVector(S, buff, len);
277 if (memcmp(s, buff, len) != 0)
278 error(S, msg);
279}
280
281
282static void fchecksize (LoadState *S, size_t size, const char *tname) {
283 if (loadByte(S) != size)
284 error(S, luaO_pushfstring(S->L, "%s size mismatch", tname));
285}
286
287
288#define checksize(S,t) fchecksize(S,sizeof(t),#t)
289
290static void checkHeader (LoadState *S) {
291 /* skip 1st char (already read and checked) */
292 checkliteral(S, &LUA_SIGNATURE[1], "not a binary chunk");
293 if (loadByte(S) != LUAC_VERSION)
294 error(S, "version mismatch");
295 if (loadByte(S) != LUAC_FORMAT)
296 error(S, "format mismatch");
297 checkliteral(S, LUAC_DATA, "corrupted chunk");
298 checksize(S, Instruction);
299 checksize(S, lua_Integer);
300 checksize(S, lua_Number);
301 if (loadInteger(S) != LUAC_INT)
302 error(S, "integer format mismatch");
303 if (loadNumber(S) != LUAC_NUM)
304 error(S, "float format mismatch");
305}
306
307
308/*
309** Load precompiled chunk.
310*/
311LClosure *luaU_undump(lua_State *L, ZIO *Z, const char *name) {
312 LoadState S;
313 LClosure *cl;
314 if (*name == '@' || *name == '=')
315 S.name = name + 1;
316 else if (*name == LUA_SIGNATURE[0])
317 S.name = "binary string";
318 else
319 S.name = name;
320 S.L = L;
321 S.Z = Z;
322 checkHeader(&S);
323 cl = luaF_newLclosure(L, loadByte(&S));
324 setclLvalue2s(L, L->top, cl);
325 luaD_inctop(L);
326 cl->p = luaF_newproto(L);
327 luaC_objbarrier(L, cl, cl->p);
328 loadFunction(&S, cl->p, NULL);
329 lua_assert(cl->nupvalues == cl->p->sizeupvalues);
330 luai_verifycode(L, cl->p);
331 return cl;
332}
333
334