Line |
Branch |
Decision |
Exec |
Source |
1 |
|
|
|
/* |
2 |
|
|
|
** $Id: ldump.c $ |
3 |
|
|
|
** save precompiled Lua chunks |
4 |
|
|
|
** See Copyright Notice in lua.h |
5 |
|
|
|
*/ |
6 |
|
|
|
|
7 |
|
|
|
#define ldump_c |
8 |
|
|
|
#define LUA_CORE |
9 |
|
|
|
|
10 |
|
|
|
#include "lprefix.h" |
11 |
|
|
|
|
12 |
|
|
|
|
13 |
|
|
|
#include <limits.h> |
14 |
|
|
|
#include <stddef.h> |
15 |
|
|
|
|
16 |
|
|
|
#include "lua.h" |
17 |
|
|
|
|
18 |
|
|
|
#include "lobject.h" |
19 |
|
|
|
#include "lstate.h" |
20 |
|
|
|
#include "lundump.h" |
21 |
|
|
|
|
22 |
|
|
|
|
23 |
|
|
|
typedef struct { |
24 |
|
|
|
lua_State *L; |
25 |
|
|
|
lua_Writer writer; |
26 |
|
|
|
void *data; |
27 |
|
|
|
int strip; |
28 |
|
|
|
int status; |
29 |
|
|
|
} DumpState; |
30 |
|
|
|
|
31 |
|
|
|
|
32 |
|
|
|
/* |
33 |
|
|
|
** All high-level dumps go through dumpVector; you can change it to |
34 |
|
|
|
** change the endianness of the result |
35 |
|
|
|
*/ |
36 |
|
|
|
#define dumpVector(D,v,n) dumpBlock(D,v,(n)*sizeof((v)[0])) |
37 |
|
|
|
|
38 |
|
|
|
#define dumpLiteral(D, s) dumpBlock(D,s,sizeof(s) - sizeof(char)) |
39 |
|
|
|
|
40 |
|
|
|
|
41 |
|
|
✗ |
static void dumpBlock (DumpState *D, const void *b, size_t size) { |
42 |
|
|
✗ |
if (D->status == 0 && size > 0) { |
43 |
|
|
|
lua_unlock(D->L); |
44 |
|
|
✗ |
D->status = (*D->writer)(D->L, b, size, D->data); |
45 |
|
|
|
lua_lock(D->L); |
46 |
|
|
|
} |
47 |
|
|
✗ |
} |
48 |
|
|
|
|
49 |
|
|
|
|
50 |
|
|
|
#define dumpVar(D,x) dumpVector(D,&x,1) |
51 |
|
|
|
|
52 |
|
|
|
|
53 |
|
|
✗ |
static void dumpByte (DumpState *D, int y) { |
54 |
|
|
✗ |
lu_byte x = (lu_byte)y; |
55 |
|
|
✗ |
dumpVar(D, x); |
56 |
|
|
✗ |
} |
57 |
|
|
|
|
58 |
|
|
|
|
59 |
|
|
|
/* |
60 |
|
|
|
** 'dumpSize' buffer size: each byte can store up to 7 bits. (The "+6" |
61 |
|
|
|
** rounds up the division.) |
62 |
|
|
|
*/ |
63 |
|
|
|
#define DIBS ((sizeof(size_t) * CHAR_BIT + 6) / 7) |
64 |
|
|
|
|
65 |
|
|
✗ |
static void dumpSize (DumpState *D, size_t x) { |
66 |
|
|
|
lu_byte buff[DIBS]; |
67 |
|
|
✗ |
int n = 0; |
68 |
|
|
|
do { |
69 |
|
|
✗ |
buff[DIBS - (++n)] = x & 0x7f; /* fill buffer in reverse order */ |
70 |
|
|
✗ |
x >>= 7; |
71 |
|
|
✗ |
} while (x != 0); |
72 |
|
|
✗ |
buff[DIBS - 1] |= 0x80; /* mark last byte */ |
73 |
|
|
✗ |
dumpVector(D, buff + DIBS - n, n); |
74 |
|
|
✗ |
} |
75 |
|
|
|
|
76 |
|
|
|
|
77 |
|
|
✗ |
static void dumpInt (DumpState *D, int x) { |
78 |
|
|
✗ |
dumpSize(D, x); |
79 |
|
|
✗ |
} |
80 |
|
|
|
|
81 |
|
|
|
|
82 |
|
|
✗ |
static void dumpNumber (DumpState *D, lua_Number x) { |
83 |
|
|
✗ |
dumpVar(D, x); |
84 |
|
|
✗ |
} |
85 |
|
|
|
|
86 |
|
|
|
|
87 |
|
|
✗ |
static void dumpInteger (DumpState *D, lua_Integer x) { |
88 |
|
|
✗ |
dumpVar(D, x); |
89 |
|
|
✗ |
} |
90 |
|
|
|
|
91 |
|
|
|
|
92 |
|
|
✗ |
static void dumpString (DumpState *D, const TString *s) { |
93 |
|
|
✗ |
if (s == NULL) |
94 |
|
|
✗ |
dumpSize(D, 0); |
95 |
|
|
|
else { |
96 |
|
|
✗ |
size_t size = tsslen(s); |
97 |
|
|
✗ |
const char *str = getstr(s); |
98 |
|
|
✗ |
dumpSize(D, size + 1); |
99 |
|
|
✗ |
dumpVector(D, str, size); |
100 |
|
|
|
} |
101 |
|
|
✗ |
} |
102 |
|
|
|
|
103 |
|
|
|
|
104 |
|
|
✗ |
static void dumpCode (DumpState *D, const Proto *f) { |
105 |
|
|
✗ |
dumpInt(D, f->sizecode); |
106 |
|
|
✗ |
dumpVector(D, f->code, f->sizecode); |
107 |
|
|
✗ |
} |
108 |
|
|
|
|
109 |
|
|
|
|
110 |
|
|
|
static void dumpFunction(DumpState *D, const Proto *f, TString *psource); |
111 |
|
|
|
|
112 |
|
|
✗ |
static void dumpConstants (DumpState *D, const Proto *f) { |
113 |
|
|
|
int i; |
114 |
|
|
✗ |
int n = f->sizek; |
115 |
|
|
✗ |
dumpInt(D, n); |
116 |
|
|
✗ |
for (i = 0; i < n; i++) { |
117 |
|
|
✗ |
const TValue *o = &f->k[i]; |
118 |
|
|
✗ |
int tt = ttypetag(o); |
119 |
|
|
✗ |
dumpByte(D, tt); |
120 |
|
|
✗ |
switch (tt) { |
121 |
|
|
✗ |
case LUA_VNUMFLT: |
122 |
|
|
✗ |
dumpNumber(D, fltvalue(o)); |
123 |
|
|
✗ |
break; |
124 |
|
|
✗ |
case LUA_VNUMINT: |
125 |
|
|
✗ |
dumpInteger(D, ivalue(o)); |
126 |
|
|
✗ |
break; |
127 |
|
|
✗ |
case LUA_VSHRSTR: |
128 |
|
|
|
case LUA_VLNGSTR: |
129 |
|
|
✗ |
dumpString(D, tsvalue(o)); |
130 |
|
|
✗ |
break; |
131 |
|
|
✗ |
default: |
132 |
|
|
|
lua_assert(tt == LUA_VNIL || tt == LUA_VFALSE || tt == LUA_VTRUE); |
133 |
|
|
|
} |
134 |
|
|
|
} |
135 |
|
|
✗ |
} |
136 |
|
|
|
|
137 |
|
|
|
|
138 |
|
|
✗ |
static void dumpProtos (DumpState *D, const Proto *f) { |
139 |
|
|
|
int i; |
140 |
|
|
✗ |
int n = f->sizep; |
141 |
|
|
✗ |
dumpInt(D, n); |
142 |
|
|
✗ |
for (i = 0; i < n; i++) |
143 |
|
|
✗ |
dumpFunction(D, f->p[i], f->source); |
144 |
|
|
✗ |
} |
145 |
|
|
|
|
146 |
|
|
|
|
147 |
|
|
✗ |
static void dumpUpvalues (DumpState *D, const Proto *f) { |
148 |
|
|
✗ |
int i, n = f->sizeupvalues; |
149 |
|
|
✗ |
dumpInt(D, n); |
150 |
|
|
✗ |
for (i = 0; i < n; i++) { |
151 |
|
|
✗ |
dumpByte(D, f->upvalues[i].instack); |
152 |
|
|
✗ |
dumpByte(D, f->upvalues[i].idx); |
153 |
|
|
✗ |
dumpByte(D, f->upvalues[i].kind); |
154 |
|
|
|
} |
155 |
|
|
✗ |
} |
156 |
|
|
|
|
157 |
|
|
|
|
158 |
|
|
✗ |
static void dumpDebug (DumpState *D, const Proto *f) { |
159 |
|
|
|
int i, n; |
160 |
|
|
✗ |
n = (D->strip) ? 0 : f->sizelineinfo; |
161 |
|
|
✗ |
dumpInt(D, n); |
162 |
|
|
✗ |
dumpVector(D, f->lineinfo, n); |
163 |
|
|
✗ |
n = (D->strip) ? 0 : f->sizeabslineinfo; |
164 |
|
|
✗ |
dumpInt(D, n); |
165 |
|
|
✗ |
for (i = 0; i < n; i++) { |
166 |
|
|
✗ |
dumpInt(D, f->abslineinfo[i].pc); |
167 |
|
|
✗ |
dumpInt(D, f->abslineinfo[i].line); |
168 |
|
|
|
} |
169 |
|
|
✗ |
n = (D->strip) ? 0 : f->sizelocvars; |
170 |
|
|
✗ |
dumpInt(D, n); |
171 |
|
|
✗ |
for (i = 0; i < n; i++) { |
172 |
|
|
✗ |
dumpString(D, f->locvars[i].varname); |
173 |
|
|
✗ |
dumpInt(D, f->locvars[i].startpc); |
174 |
|
|
✗ |
dumpInt(D, f->locvars[i].endpc); |
175 |
|
|
|
} |
176 |
|
|
✗ |
n = (D->strip) ? 0 : f->sizeupvalues; |
177 |
|
|
✗ |
dumpInt(D, n); |
178 |
|
|
✗ |
for (i = 0; i < n; i++) |
179 |
|
|
✗ |
dumpString(D, f->upvalues[i].name); |
180 |
|
|
✗ |
} |
181 |
|
|
|
|
182 |
|
|
|
|
183 |
|
|
✗ |
static void dumpFunction (DumpState *D, const Proto *f, TString *psource) { |
184 |
|
|
✗ |
if (D->strip || f->source == psource) |
185 |
|
|
✗ |
dumpString(D, NULL); /* no debug info or same source as its parent */ |
186 |
|
|
|
else |
187 |
|
|
✗ |
dumpString(D, f->source); |
188 |
|
|
✗ |
dumpInt(D, f->linedefined); |
189 |
|
|
✗ |
dumpInt(D, f->lastlinedefined); |
190 |
|
|
✗ |
dumpByte(D, f->numparams); |
191 |
|
|
✗ |
dumpByte(D, f->is_vararg); |
192 |
|
|
✗ |
dumpByte(D, f->maxstacksize); |
193 |
|
|
✗ |
dumpCode(D, f); |
194 |
|
|
✗ |
dumpConstants(D, f); |
195 |
|
|
✗ |
dumpUpvalues(D, f); |
196 |
|
|
✗ |
dumpProtos(D, f); |
197 |
|
|
✗ |
dumpDebug(D, f); |
198 |
|
|
✗ |
} |
199 |
|
|
|
|
200 |
|
|
|
|
201 |
|
|
✗ |
static void dumpHeader (DumpState *D) { |
202 |
|
|
✗ |
dumpLiteral(D, LUA_SIGNATURE); |
203 |
|
|
✗ |
dumpByte(D, LUAC_VERSION); |
204 |
|
|
✗ |
dumpByte(D, LUAC_FORMAT); |
205 |
|
|
✗ |
dumpLiteral(D, LUAC_DATA); |
206 |
|
|
✗ |
dumpByte(D, sizeof(Instruction)); |
207 |
|
|
✗ |
dumpByte(D, sizeof(lua_Integer)); |
208 |
|
|
✗ |
dumpByte(D, sizeof(lua_Number)); |
209 |
|
|
✗ |
dumpInteger(D, LUAC_INT); |
210 |
|
|
✗ |
dumpNumber(D, LUAC_NUM); |
211 |
|
|
✗ |
} |
212 |
|
|
|
|
213 |
|
|
|
|
214 |
|
|
|
/* |
215 |
|
|
|
** dump Lua function as precompiled chunk |
216 |
|
|
|
*/ |
217 |
|
|
✗ |
int luaU_dump(lua_State *L, const Proto *f, lua_Writer w, void *data, |
218 |
|
|
|
int strip) { |
219 |
|
|
|
DumpState D; |
220 |
|
|
✗ |
D.L = L; |
221 |
|
|
✗ |
D.writer = w; |
222 |
|
|
✗ |
D.data = data; |
223 |
|
|
✗ |
D.strip = strip; |
224 |
|
|
✗ |
D.status = 0; |
225 |
|
|
✗ |
dumpHeader(&D); |
226 |
|
|
✗ |
dumpByte(&D, f->sizeupvalues); |
227 |
|
|
✗ |
dumpFunction(&D, f, NULL); |
228 |
|
|
✗ |
return D.status; |
229 |
|
|
|
} |
230 |
|
|
|
|
231 |
|
|
|
|