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