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