diff options
author | David Walter Seikel | 2014-04-21 20:59:39 +1000 |
---|---|---|
committer | David Walter Seikel | 2014-04-21 20:59:39 +1000 |
commit | 9621add2918cc4943e6693b74ae85d51dd264fcf (patch) | |
tree | fff1edf2c69d7a08a0e12885eecc9b96ed847a6a /LuaSL/testLua/yueliang-0.4.1/orig-5.1.3/ldump.lua | |
parent | LuaSL_test's window doesn't need to be so huge. (diff) | |
download | SledjHamr-9621add2918cc4943e6693b74ae85d51dd264fcf.zip SledjHamr-9621add2918cc4943e6693b74ae85d51dd264fcf.tar.gz SledjHamr-9621add2918cc4943e6693b74ae85d51dd264fcf.tar.bz2 SledjHamr-9621add2918cc4943e6693b74ae85d51dd264fcf.tar.xz |
We don't need the testlua directory any more.
Diffstat (limited to 'LuaSL/testLua/yueliang-0.4.1/orig-5.1.3/ldump.lua')
-rw-r--r-- | LuaSL/testLua/yueliang-0.4.1/orig-5.1.3/ldump.lua | 372 |
1 files changed, 0 insertions, 372 deletions
diff --git a/LuaSL/testLua/yueliang-0.4.1/orig-5.1.3/ldump.lua b/LuaSL/testLua/yueliang-0.4.1/orig-5.1.3/ldump.lua deleted file mode 100644 index b9380e1..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/orig-5.1.3/ldump.lua +++ /dev/null | |||
@@ -1,372 +0,0 @@ | |||
1 | --[[-------------------------------------------------------------------- | ||
2 | |||
3 | ldump.lua | ||
4 | Save precompiled Lua chunks | ||
5 | This file is part of Yueliang. | ||
6 | |||
7 | Copyright (c) 2006 Kein-Hong Man <khman@users.sf.net> | ||
8 | The COPYRIGHT file describes the conditions | ||
9 | under which this software may be distributed. | ||
10 | |||
11 | See the ChangeLog for more information. | ||
12 | |||
13 | ----------------------------------------------------------------------]] | ||
14 | |||
15 | --[[-------------------------------------------------------------------- | ||
16 | -- Notes: | ||
17 | -- * WARNING! byte order (little endian) and data type sizes for header | ||
18 | -- signature values hard-coded; see luaU:header | ||
19 | -- * chunk writer generators are included, see below | ||
20 | -- * one significant difference is that instructions are still in table | ||
21 | -- form (with OP/A/B/C/Bx fields) and luaP:Instruction() is needed to | ||
22 | -- convert them into 4-char strings | ||
23 | -- | ||
24 | -- Not implemented: | ||
25 | -- * DumpVar, DumpMem has been removed | ||
26 | -- * DumpVector folded into folded into DumpDebug, DumpCode | ||
27 | -- | ||
28 | -- Added: | ||
29 | -- * for convenience, the following two functions have been added: | ||
30 | -- luaU:make_setS: create a chunk writer that writes to a string | ||
31 | -- luaU:make_setF: create a chunk writer that writes to a file | ||
32 | -- (lua.h contains a typedef for lua_Writer/lua_Chunkwriter, and | ||
33 | -- a Lua-based implementation exists, writer() in lstrlib.c) | ||
34 | -- * luaU:ttype(o) (from lobject.h) | ||
35 | -- * for converting number types to its binary equivalent: | ||
36 | -- luaU:from_double(x): encode double value for writing | ||
37 | -- luaU:from_int(x): encode integer value for writing | ||
38 | -- (error checking is limited for these conversion functions) | ||
39 | -- (double conversion does not support denormals or NaNs) | ||
40 | -- | ||
41 | -- Changed in 5.1.x: | ||
42 | -- * the dumper was mostly rewritten in Lua 5.1.x, so notes on the | ||
43 | -- differences between 5.0.x and 5.1.x is limited | ||
44 | -- * LUAC_VERSION bumped to 0x51, LUAC_FORMAT added | ||
45 | -- * developer is expected to adjust LUAC_FORMAT in order to identify | ||
46 | -- non-standard binary chunk formats | ||
47 | -- * header signature code is smaller, has been simplified, and is | ||
48 | -- tested as a single unit; its logic is shared with the undumper | ||
49 | -- * no more endian conversion, invalid endianness mean rejection | ||
50 | -- * opcode field sizes are no longer exposed in the header | ||
51 | -- * code moved to front of a prototype, followed by constants | ||
52 | -- * debug information moved to the end of the binary chunk, and the | ||
53 | -- relevant functions folded into a single function | ||
54 | -- * luaU:dump returns a writer status code | ||
55 | -- * chunk writer now implements status code because dumper uses it | ||
56 | -- * luaU:endianness removed | ||
57 | ----------------------------------------------------------------------]] | ||
58 | |||
59 | --requires luaP | ||
60 | luaU = {} | ||
61 | |||
62 | -- mark for precompiled code ('<esc>Lua') (from lua.h) | ||
63 | luaU.LUA_SIGNATURE = "\27Lua" | ||
64 | |||
65 | -- constants used by dumper (from lua.h) | ||
66 | luaU.LUA_TNUMBER = 3 | ||
67 | luaU.LUA_TSTRING = 4 | ||
68 | luaU.LUA_TNIL = 0 | ||
69 | luaU.LUA_TBOOLEAN = 1 | ||
70 | luaU.LUA_TNONE = -1 | ||
71 | |||
72 | -- constants for header of binary files (from lundump.h) | ||
73 | luaU.LUAC_VERSION = 0x51 -- this is Lua 5.1 | ||
74 | luaU.LUAC_FORMAT = 0 -- this is the official format | ||
75 | luaU.LUAC_HEADERSIZE = 12 -- size of header of binary files | ||
76 | |||
77 | --[[-------------------------------------------------------------------- | ||
78 | -- Additional functions to handle chunk writing | ||
79 | -- * to use make_setS and make_setF, see test_ldump.lua elsewhere | ||
80 | ----------------------------------------------------------------------]] | ||
81 | |||
82 | ------------------------------------------------------------------------ | ||
83 | -- create a chunk writer that writes to a string | ||
84 | -- * returns the writer function and a table containing the string | ||
85 | -- * to get the final result, look in buff.data | ||
86 | ------------------------------------------------------------------------ | ||
87 | function luaU:make_setS() | ||
88 | local buff = {} | ||
89 | buff.data = "" | ||
90 | local writer = | ||
91 | function(s, buff) -- chunk writer | ||
92 | if not s then return 0 end | ||
93 | buff.data = buff.data..s | ||
94 | return 0 | ||
95 | end | ||
96 | return writer, buff | ||
97 | end | ||
98 | |||
99 | ------------------------------------------------------------------------ | ||
100 | -- create a chunk writer that writes to a file | ||
101 | -- * returns the writer function and a table containing the file handle | ||
102 | -- * if a nil is passed, then writer should close the open file | ||
103 | ------------------------------------------------------------------------ | ||
104 | function luaU:make_setF(filename) | ||
105 | local buff = {} | ||
106 | buff.h = io.open(filename, "wb") | ||
107 | if not buff.h then return nil end | ||
108 | local writer = | ||
109 | function(s, buff) -- chunk writer | ||
110 | if not buff.h then return 0 end | ||
111 | if not s then | ||
112 | if buff.h:close() then return 0 end | ||
113 | else | ||
114 | if buff.h:write(s) then return 0 end | ||
115 | end | ||
116 | return 1 | ||
117 | end | ||
118 | return writer, buff | ||
119 | end | ||
120 | |||
121 | ------------------------------------------------------------------------ | ||
122 | -- works like the lobject.h version except that TObject used in these | ||
123 | -- scripts only has a 'value' field, no 'tt' field (native types used) | ||
124 | ------------------------------------------------------------------------ | ||
125 | function luaU:ttype(o) | ||
126 | local tt = type(o.value) | ||
127 | if tt == "number" then return self.LUA_TNUMBER | ||
128 | elseif tt == "string" then return self.LUA_TSTRING | ||
129 | elseif tt == "nil" then return self.LUA_TNIL | ||
130 | elseif tt == "boolean" then return self.LUA_TBOOLEAN | ||
131 | else | ||
132 | return self.LUA_TNONE -- the rest should not appear | ||
133 | end | ||
134 | end | ||
135 | |||
136 | ----------------------------------------------------------------------- | ||
137 | -- converts a IEEE754 double number to an 8-byte little-endian string | ||
138 | -- * luaU:from_double() and luaU:from_int() are adapted from ChunkBake | ||
139 | -- * supports +/- Infinity, but not denormals or NaNs | ||
140 | ----------------------------------------------------------------------- | ||
141 | function luaU:from_double(x) | ||
142 | local function grab_byte(v) | ||
143 | local c = v % 256 | ||
144 | return (v - c) / 256, string.char(c) | ||
145 | end | ||
146 | local sign = 0 | ||
147 | if x < 0 then sign = 1; x = -x end | ||
148 | local mantissa, exponent = math.frexp(x) | ||
149 | if x == 0 then -- zero | ||
150 | mantissa, exponent = 0, 0 | ||
151 | elseif x == 1/0 then | ||
152 | mantissa, exponent = 0, 2047 | ||
153 | else | ||
154 | mantissa = (mantissa * 2 - 1) * math.ldexp(0.5, 53) | ||
155 | exponent = exponent + 1022 | ||
156 | end | ||
157 | local v, byte = "" -- convert to bytes | ||
158 | x = math.floor(mantissa) | ||
159 | for i = 1,6 do | ||
160 | x, byte = grab_byte(x); v = v..byte -- 47:0 | ||
161 | end | ||
162 | x, byte = grab_byte(exponent * 16 + x); v = v..byte -- 55:48 | ||
163 | x, byte = grab_byte(sign * 128 + x); v = v..byte -- 63:56 | ||
164 | return v | ||
165 | end | ||
166 | |||
167 | ----------------------------------------------------------------------- | ||
168 | -- converts a number to a little-endian 32-bit integer string | ||
169 | -- * input value assumed to not overflow, can be signed/unsigned | ||
170 | ----------------------------------------------------------------------- | ||
171 | function luaU:from_int(x) | ||
172 | local v = "" | ||
173 | x = math.floor(x) | ||
174 | if x < 0 then x = 4294967296 + x end -- ULONG_MAX+1 | ||
175 | for i = 1, 4 do | ||
176 | local c = x % 256 | ||
177 | v = v..string.char(c); x = math.floor(x / 256) | ||
178 | end | ||
179 | return v | ||
180 | end | ||
181 | |||
182 | --[[-------------------------------------------------------------------- | ||
183 | -- Functions to make a binary chunk | ||
184 | -- * many functions have the size parameter removed, since output is | ||
185 | -- in the form of a string and some sizes are implicit or hard-coded | ||
186 | ----------------------------------------------------------------------]] | ||
187 | |||
188 | --[[-------------------------------------------------------------------- | ||
189 | -- struct DumpState: | ||
190 | -- L -- lua_State (not used in this script) | ||
191 | -- writer -- lua_Writer (chunk writer function) | ||
192 | -- data -- void* (chunk writer context or data already written) | ||
193 | -- strip -- if true, don't write any debug information | ||
194 | -- status -- if non-zero, an error has occured | ||
195 | ----------------------------------------------------------------------]] | ||
196 | |||
197 | ------------------------------------------------------------------------ | ||
198 | -- dumps a block of bytes | ||
199 | -- * lua_unlock(D.L), lua_lock(D.L) unused | ||
200 | ------------------------------------------------------------------------ | ||
201 | function luaU:DumpBlock(b, D) | ||
202 | if D.status == 0 then | ||
203 | -- lua_unlock(D->L); | ||
204 | D.status = D.write(b, D.data) | ||
205 | -- lua_lock(D->L); | ||
206 | end | ||
207 | end | ||
208 | |||
209 | ------------------------------------------------------------------------ | ||
210 | -- dumps a char | ||
211 | ------------------------------------------------------------------------ | ||
212 | function luaU:DumpChar(y, D) | ||
213 | self:DumpBlock(string.char(y), D) | ||
214 | end | ||
215 | |||
216 | ------------------------------------------------------------------------ | ||
217 | -- dumps a 32-bit signed or unsigned integer (for int) (hard-coded) | ||
218 | ------------------------------------------------------------------------ | ||
219 | function luaU:DumpInt(x, D) | ||
220 | self:DumpBlock(self:from_int(x), D) | ||
221 | end | ||
222 | |||
223 | ------------------------------------------------------------------------ | ||
224 | -- dumps a lua_Number (hard-coded as a double) | ||
225 | ------------------------------------------------------------------------ | ||
226 | function luaU:DumpNumber(x, D) | ||
227 | self:DumpBlock(self:from_double(x), D) | ||
228 | end | ||
229 | |||
230 | ------------------------------------------------------------------------ | ||
231 | -- dumps a Lua string (size type is hard-coded) | ||
232 | ------------------------------------------------------------------------ | ||
233 | function luaU:DumpString(s, D) | ||
234 | if s == nil then | ||
235 | self:DumpInt(0, D) | ||
236 | else | ||
237 | s = s.."\0" -- include trailing '\0' | ||
238 | self:DumpInt(#s, D) | ||
239 | self:DumpBlock(s, D) | ||
240 | end | ||
241 | end | ||
242 | |||
243 | ------------------------------------------------------------------------ | ||
244 | -- dumps instruction block from function prototype | ||
245 | ------------------------------------------------------------------------ | ||
246 | function luaU:DumpCode(f, D) | ||
247 | local n = f.sizecode | ||
248 | --was DumpVector | ||
249 | self:DumpInt(n, D) | ||
250 | for i = 0, n - 1 do | ||
251 | self:DumpBlock(luaP:Instruction(f.code[i]), D) | ||
252 | end | ||
253 | end | ||
254 | |||
255 | ------------------------------------------------------------------------ | ||
256 | -- dump constant pool from function prototype | ||
257 | -- * bvalue(o), nvalue(o) and rawtsvalue(o) macros removed | ||
258 | ------------------------------------------------------------------------ | ||
259 | function luaU:DumpConstants(f, D) | ||
260 | local n = f.sizek | ||
261 | self:DumpInt(n, D) | ||
262 | for i = 0, n - 1 do | ||
263 | local o = f.k[i] -- TValue | ||
264 | local tt = self:ttype(o) | ||
265 | self:DumpChar(tt, D) | ||
266 | if tt == self.LUA_TNIL then | ||
267 | elseif tt == self.LUA_TBOOLEAN then | ||
268 | self:DumpChar(o.value and 1 or 0, D) | ||
269 | elseif tt == self.LUA_TNUMBER then | ||
270 | self:DumpNumber(o.value, D) | ||
271 | elseif tt == self.LUA_TSTRING then | ||
272 | self:DumpString(o.value, D) | ||
273 | else | ||
274 | --lua_assert(0) -- cannot happen | ||
275 | end | ||
276 | end | ||
277 | n = f.sizep | ||
278 | self:DumpInt(n, D) | ||
279 | for i = 0, n - 1 do | ||
280 | self:DumpFunction(f.p[i], f.source, D) | ||
281 | end | ||
282 | end | ||
283 | |||
284 | ------------------------------------------------------------------------ | ||
285 | -- dump debug information | ||
286 | ------------------------------------------------------------------------ | ||
287 | function luaU:DumpDebug(f, D) | ||
288 | local n | ||
289 | n = D.strip and 0 or f.sizelineinfo -- dump line information | ||
290 | --was DumpVector | ||
291 | self:DumpInt(n, D) | ||
292 | for i = 0, n - 1 do | ||
293 | self:DumpInt(f.lineinfo[i], D) | ||
294 | end | ||
295 | n = D.strip and 0 or f.sizelocvars -- dump local information | ||
296 | self:DumpInt(n, D) | ||
297 | for i = 0, n - 1 do | ||
298 | self:DumpString(f.locvars[i].varname, D) | ||
299 | self:DumpInt(f.locvars[i].startpc, D) | ||
300 | self:DumpInt(f.locvars[i].endpc, D) | ||
301 | end | ||
302 | n = D.strip and 0 or f.sizeupvalues -- dump upvalue information | ||
303 | self:DumpInt(n, D) | ||
304 | for i = 0, n - 1 do | ||
305 | self:DumpString(f.upvalues[i], D) | ||
306 | end | ||
307 | end | ||
308 | |||
309 | ------------------------------------------------------------------------ | ||
310 | -- dump child function prototypes from function prototype | ||
311 | ------------------------------------------------------------------------ | ||
312 | function luaU:DumpFunction(f, p, D) | ||
313 | local source = f.source | ||
314 | if source == p or D.strip then source = nil end | ||
315 | self:DumpString(source, D) | ||
316 | self:DumpInt(f.lineDefined, D) | ||
317 | self:DumpInt(f.lastlinedefined, D) | ||
318 | self:DumpChar(f.nups, D) | ||
319 | self:DumpChar(f.numparams, D) | ||
320 | self:DumpChar(f.is_vararg, D) | ||
321 | self:DumpChar(f.maxstacksize, D) | ||
322 | self:DumpCode(f, D) | ||
323 | self:DumpConstants(f, D) | ||
324 | self:DumpDebug(f, D) | ||
325 | end | ||
326 | |||
327 | ------------------------------------------------------------------------ | ||
328 | -- dump Lua header section (some sizes hard-coded) | ||
329 | ------------------------------------------------------------------------ | ||
330 | function luaU:DumpHeader(D) | ||
331 | local h = self:header() | ||
332 | assert(#h == self.LUAC_HEADERSIZE) -- fixed buffer now an assert | ||
333 | self:DumpBlock(h, D) | ||
334 | end | ||
335 | |||
336 | ------------------------------------------------------------------------ | ||
337 | -- make header (from lundump.c) | ||
338 | -- returns the header string | ||
339 | ------------------------------------------------------------------------ | ||
340 | function luaU:header() | ||
341 | local x = 1 | ||
342 | return self.LUA_SIGNATURE.. | ||
343 | string.char( | ||
344 | self.LUAC_VERSION, | ||
345 | self.LUAC_FORMAT, | ||
346 | x, -- endianness (1=little) | ||
347 | 4, -- sizeof(int) | ||
348 | 4, -- sizeof(size_t) | ||
349 | 4, -- sizeof(Instruction) | ||
350 | 8, -- sizeof(lua_Number) | ||
351 | 0) -- is lua_Number integral? | ||
352 | end | ||
353 | |||
354 | ------------------------------------------------------------------------ | ||
355 | -- dump Lua function as precompiled chunk | ||
356 | -- (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip) | ||
357 | -- * w, data are created from make_setS, make_setF | ||
358 | ------------------------------------------------------------------------ | ||
359 | function luaU:dump(L, f, w, data, strip) | ||
360 | local D = {} -- DumpState | ||
361 | D.L = L | ||
362 | D.write = w | ||
363 | D.data = data | ||
364 | D.strip = strip | ||
365 | D.status = 0 | ||
366 | self:DumpHeader(D) | ||
367 | self:DumpFunction(f, nil, D) | ||
368 | -- added: for a chunk writer writing to a file, this final call with | ||
369 | -- nil data is to indicate to the writer to close the file | ||
370 | D.write(nil, D.data) | ||
371 | return D.status | ||
372 | end | ||