Line data Source code
1 : /*
2 : ** $Id: ldump.c,v 2.37.1.1 2017/04/19 17:20:42 roberto Exp $
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 <stddef.h>
14 :
15 : #include "lua.h"
16 :
17 : #include "lobject.h"
18 : #include "lstate.h"
19 : #include "lundump.h"
20 :
21 :
22 : typedef struct {
23 : lua_State *L;
24 : lua_Writer writer;
25 : void *data;
26 : int strip;
27 : int status;
28 : } DumpState;
29 :
30 :
31 : /*
32 : ** All high-level dumps go through DumpVector; you can change it to
33 : ** change the endianness of the result
34 : */
35 : #define DumpVector(v,n,D) DumpBlock(v,(n)*sizeof((v)[0]),D)
36 :
37 : #define DumpLiteral(s,D) DumpBlock(s, sizeof(s) - sizeof(char), D)
38 :
39 :
40 705 : static void DumpBlock (const void *b, size_t size, DumpState *D) {
41 705 : if (D->status == 0 && size > 0) {
42 : lua_unlock(D->L);
43 700 : D->status = (*D->writer)(D->L, b, size, D->data);
44 : lua_lock(D->L);
45 : }
46 705 : }
47 :
48 :
49 : #define DumpVar(x,D) DumpVector(&x,1,D)
50 :
51 :
52 330 : static void DumpByte (int y, DumpState *D) {
53 330 : lu_byte x = (lu_byte)y;
54 330 : DumpVar(x, D);
55 330 : }
56 :
57 :
58 205 : static void DumpInt (int x, DumpState *D) {
59 205 : DumpVar(x, D);
60 205 : }
61 :
62 :
63 14 : static void DumpNumber (lua_Number x, DumpState *D) {
64 14 : DumpVar(x, D);
65 14 : }
66 :
67 :
68 15 : static void DumpInteger (lua_Integer x, DumpState *D) {
69 15 : DumpVar(x, D);
70 15 : }
71 :
72 :
73 92 : static void DumpString (const TString *s, DumpState *D) {
74 92 : if (s == NULL)
75 11 : DumpByte(0, D);
76 : else {
77 81 : size_t size = tsslen(s) + 1; /* include trailing '\0' */
78 81 : const char *str = getstr(s);
79 81 : if (size < 0xFF)
80 81 : DumpByte(cast_int(size), D);
81 : else {
82 0 : DumpByte(0xFF, D);
83 0 : DumpVar(size, D);
84 : }
85 81 : DumpVector(str, size - 1, D); /* no need to save '\0' */
86 : }
87 92 : }
88 :
89 :
90 19 : static void DumpCode (const Proto *f, DumpState *D) {
91 19 : DumpInt(f->sizecode, D);
92 19 : DumpVector(f->code, f->sizecode, D);
93 19 : }
94 :
95 :
96 : static void DumpFunction(const Proto *f, TString *psource, DumpState *D);
97 :
98 19 : static void DumpConstants (const Proto *f, DumpState *D) {
99 : int i;
100 19 : int n = f->sizek;
101 19 : DumpInt(n, D);
102 75 : for (i = 0; i < n; i++) {
103 56 : const TValue *o = &f->k[i];
104 56 : DumpByte(ttype(o), D);
105 56 : switch (ttype(o)) {
106 3 : case LUA_TNIL:
107 3 : break;
108 3 : case LUA_TBOOLEAN:
109 3 : DumpByte(bvalue(o), D);
110 3 : break;
111 3 : case LUA_TNUMFLT:
112 3 : DumpNumber(fltvalue(o), D);
113 3 : break;
114 4 : case LUA_TNUMINT:
115 4 : DumpInteger(ivalue(o), D);
116 4 : break;
117 43 : case LUA_TSHRSTR:
118 : case LUA_TLNGSTR:
119 43 : DumpString(tsvalue(o), D);
120 43 : break;
121 56 : default:
122 : lua_assert(0);
123 : }
124 : }
125 19 : }
126 :
127 :
128 19 : static void DumpProtos (const Proto *f, DumpState *D) {
129 : int i;
130 19 : int n = f->sizep;
131 19 : DumpInt(n, D);
132 27 : for (i = 0; i < n; i++)
133 8 : DumpFunction(f->p[i], f->source, D);
134 19 : }
135 :
136 :
137 19 : static void DumpUpvalues (const Proto *f, DumpState *D) {
138 19 : int i, n = f->sizeupvalues;
139 19 : DumpInt(n, D);
140 36 : for (i = 0; i < n; i++) {
141 17 : DumpByte(f->upvalues[i].instack, D);
142 17 : DumpByte(f->upvalues[i].idx, D);
143 : }
144 19 : }
145 :
146 :
147 19 : static void DumpDebug (const Proto *f, DumpState *D) {
148 : int i, n;
149 19 : n = (D->strip) ? 0 : f->sizelineinfo;
150 19 : DumpInt(n, D);
151 19 : DumpVector(f->lineinfo, n, D);
152 19 : n = (D->strip) ? 0 : f->sizelocvars;
153 19 : DumpInt(n, D);
154 36 : for (i = 0; i < n; i++) {
155 17 : DumpString(f->locvars[i].varname, D);
156 17 : DumpInt(f->locvars[i].startpc, D);
157 17 : DumpInt(f->locvars[i].endpc, D);
158 : }
159 19 : n = (D->strip) ? 0 : f->sizeupvalues;
160 19 : DumpInt(n, D);
161 32 : for (i = 0; i < n; i++)
162 13 : DumpString(f->upvalues[i].name, D);
163 19 : }
164 :
165 :
166 19 : static void DumpFunction (const Proto *f, TString *psource, DumpState *D) {
167 19 : if (D->strip || f->source == psource)
168 11 : DumpString(NULL, D); /* no debug info or same source as its parent */
169 : else
170 8 : DumpString(f->source, D);
171 19 : DumpInt(f->linedefined, D);
172 19 : DumpInt(f->lastlinedefined, D);
173 19 : DumpByte(f->numparams, D);
174 19 : DumpByte(f->is_vararg, D);
175 19 : DumpByte(f->maxstacksize, D);
176 19 : DumpCode(f, D);
177 19 : DumpConstants(f, D);
178 19 : DumpUpvalues(f, D);
179 19 : DumpProtos(f, D);
180 19 : DumpDebug(f, D);
181 19 : }
182 :
183 :
184 11 : static void DumpHeader (DumpState *D) {
185 11 : DumpLiteral(LUA_SIGNATURE, D);
186 11 : DumpByte(LUAC_VERSION, D);
187 11 : DumpByte(LUAC_FORMAT, D);
188 11 : DumpLiteral(LUAC_DATA, D);
189 11 : DumpByte(sizeof(int), D);
190 11 : DumpByte(sizeof(size_t), D);
191 11 : DumpByte(sizeof(Instruction), D);
192 11 : DumpByte(sizeof(lua_Integer), D);
193 11 : DumpByte(sizeof(lua_Number), D);
194 11 : DumpInteger(LUAC_INT, D);
195 11 : DumpNumber(LUAC_NUM, D);
196 11 : }
197 :
198 :
199 : /*
200 : ** dump Lua function as precompiled chunk
201 : */
202 11 : int luaU_dump(lua_State *L, const Proto *f, lua_Writer w, void *data,
203 : int strip) {
204 : DumpState D;
205 11 : D.L = L;
206 11 : D.writer = w;
207 11 : D.data = data;
208 11 : D.strip = strip;
209 11 : D.status = 0;
210 11 : DumpHeader(&D);
211 11 : DumpByte(f->sizeupvalues, &D);
212 11 : DumpFunction(f, NULL, &D);
213 11 : return D.status;
214 : }
215 :
|
