diff options
author | Roberto Ierusalimschy <roberto@inf.puc-rio.br> | 2020-02-27 15:17:44 -0300 |
---|---|---|
committer | Roberto Ierusalimschy <roberto@inf.puc-rio.br> | 2020-02-27 15:17:44 -0300 |
commit | e8a52281d9cba1c8dd49a06e7523d7e39794ecc1 (patch) | |
tree | 25c6b35371e795bda67efe9db71be3b2f6421f28 /ldump.c | |
parent | 6eb53b752617fae9e1329bfe2cfecdcbb593c398 (diff) | |
download | lua-e8a52281d9cba1c8dd49a06e7523d7e39794ecc1.tar.gz lua-e8a52281d9cba1c8dd49a06e7523d7e39794ecc1.tar.bz2 lua-e8a52281d9cba1c8dd49a06e7523d7e39794ecc1.zip |
Code style in 'ldump'/'lundump'.
- function names start with lower case;
- state is always the first parameter.
Diffstat (limited to 'ldump.c')
-rw-r--r-- | ldump.c | 152 |
1 files changed, 76 insertions, 76 deletions
@@ -29,15 +29,15 @@ typedef struct { | |||
29 | 29 | ||
30 | 30 | ||
31 | /* | 31 | /* |
32 | ** All high-level dumps go through DumpVector; you can change it to | 32 | ** All high-level dumps go through dumpVector; you can change it to |
33 | ** change the endianness of the result | 33 | ** change the endianness of the result |
34 | */ | 34 | */ |
35 | #define DumpVector(v,n,D) DumpBlock(v,(n)*sizeof((v)[0]),D) | 35 | #define dumpVector(D,v,n) dumpBlock(D,v,(n)*sizeof((v)[0])) |
36 | 36 | ||
37 | #define DumpLiteral(s,D) DumpBlock(s, sizeof(s) - sizeof(char), D) | 37 | #define dumpLiteral(D, s) dumpBlock(D,s,sizeof(s) - sizeof(char)) |
38 | 38 | ||
39 | 39 | ||
40 | static void DumpBlock (const void *b, size_t size, DumpState *D) { | 40 | static void dumpBlock (DumpState *D, const void *b, size_t size) { |
41 | if (D->status == 0 && size > 0) { | 41 | if (D->status == 0 && size > 0) { |
42 | lua_unlock(D->L); | 42 | lua_unlock(D->L); |
43 | D->status = (*D->writer)(D->L, b, size, D->data); | 43 | D->status = (*D->writer)(D->L, b, size, D->data); |
@@ -46,19 +46,19 @@ static void DumpBlock (const void *b, size_t size, DumpState *D) { | |||
46 | } | 46 | } |
47 | 47 | ||
48 | 48 | ||
49 | #define DumpVar(x,D) DumpVector(&x,1,D) | 49 | #define dumpVar(D,x) dumpVector(D,&x,1) |
50 | 50 | ||
51 | 51 | ||
52 | static void DumpByte (int y, DumpState *D) { | 52 | static void dumpByte (DumpState *D, int y) { |
53 | lu_byte x = (lu_byte)y; | 53 | lu_byte x = (lu_byte)y; |
54 | DumpVar(x, D); | 54 | dumpVar(D, x); |
55 | } | 55 | } |
56 | 56 | ||
57 | 57 | ||
58 | /* DumpInt Buff Size */ | 58 | /* dumpInt Buff Size */ |
59 | #define DIBS ((sizeof(size_t) * 8 / 7) + 1) | 59 | #define DIBS ((sizeof(size_t) * 8 / 7) + 1) |
60 | 60 | ||
61 | static void DumpSize (size_t x, DumpState *D) { | 61 | static void dumpSize (DumpState *D, size_t x) { |
62 | lu_byte buff[DIBS]; | 62 | lu_byte buff[DIBS]; |
63 | int n = 0; | 63 | int n = 0; |
64 | do { | 64 | do { |
@@ -66,63 +66,63 @@ static void DumpSize (size_t x, DumpState *D) { | |||
66 | x >>= 7; | 66 | x >>= 7; |
67 | } while (x != 0); | 67 | } while (x != 0); |
68 | buff[DIBS - 1] |= 0x80; /* mark last byte */ | 68 | buff[DIBS - 1] |= 0x80; /* mark last byte */ |
69 | DumpVector(buff + DIBS - n, n, D); | 69 | dumpVector(D, buff + DIBS - n, n); |
70 | } | 70 | } |
71 | 71 | ||
72 | 72 | ||
73 | static void DumpInt (int x, DumpState *D) { | 73 | static void dumpInt (DumpState *D, int x) { |
74 | DumpSize(x, D); | 74 | dumpSize(D, x); |
75 | } | 75 | } |
76 | 76 | ||
77 | 77 | ||
78 | static void DumpNumber (lua_Number x, DumpState *D) { | 78 | static void dumpNumber (DumpState *D, lua_Number x) { |
79 | DumpVar(x, D); | 79 | dumpVar(D, x); |
80 | } | 80 | } |
81 | 81 | ||
82 | 82 | ||
83 | static void DumpInteger (lua_Integer x, DumpState *D) { | 83 | static void dumpInteger (DumpState *D, lua_Integer x) { |
84 | DumpVar(x, D); | 84 | dumpVar(D, x); |
85 | } | 85 | } |
86 | 86 | ||
87 | 87 | ||
88 | static void DumpString (const TString *s, DumpState *D) { | 88 | static void dumpString (DumpState *D, const TString *s) { |
89 | if (s == NULL) | 89 | if (s == NULL) |
90 | DumpSize(0, D); | 90 | dumpSize(D, 0); |
91 | else { | 91 | else { |
92 | size_t size = tsslen(s); | 92 | size_t size = tsslen(s); |
93 | const char *str = getstr(s); | 93 | const char *str = getstr(s); |
94 | DumpSize(size + 1, D); | 94 | dumpSize(D, size + 1); |
95 | DumpVector(str, size, D); | 95 | dumpVector(D, str, size); |
96 | } | 96 | } |
97 | } | 97 | } |
98 | 98 | ||
99 | 99 | ||
100 | static void DumpCode (const Proto *f, DumpState *D) { | 100 | static void dumpCode (DumpState *D, const Proto *f) { |
101 | DumpInt(f->sizecode, D); | 101 | dumpInt(D, f->sizecode); |
102 | DumpVector(f->code, f->sizecode, D); | 102 | dumpVector(D, f->code, f->sizecode); |
103 | } | 103 | } |
104 | 104 | ||
105 | 105 | ||
106 | static void DumpFunction(const Proto *f, TString *psource, DumpState *D); | 106 | static void dumpFunction(DumpState *D, const Proto *f, TString *psource); |
107 | 107 | ||
108 | static void DumpConstants (const Proto *f, DumpState *D) { | 108 | static void dumpConstants (DumpState *D, const Proto *f) { |
109 | int i; | 109 | int i; |
110 | int n = f->sizek; | 110 | int n = f->sizek; |
111 | DumpInt(n, D); | 111 | dumpInt(D, n); |
112 | for (i = 0; i < n; i++) { | 112 | for (i = 0; i < n; i++) { |
113 | const TValue *o = &f->k[i]; | 113 | const TValue *o = &f->k[i]; |
114 | int tt = ttypetag(o); | 114 | int tt = ttypetag(o); |
115 | DumpByte(tt, D); | 115 | dumpByte(D, tt); |
116 | switch (tt) { | 116 | switch (tt) { |
117 | case LUA_VNUMFLT: | 117 | case LUA_VNUMFLT: |
118 | DumpNumber(fltvalue(o), D); | 118 | dumpNumber(D, fltvalue(o)); |
119 | break; | 119 | break; |
120 | case LUA_VNUMINT: | 120 | case LUA_VNUMINT: |
121 | DumpInteger(ivalue(o), D); | 121 | dumpInteger(D, ivalue(o)); |
122 | break; | 122 | break; |
123 | case LUA_VSHRSTR: | 123 | case LUA_VSHRSTR: |
124 | case LUA_VLNGSTR: | 124 | case LUA_VLNGSTR: |
125 | DumpString(tsvalue(o), D); | 125 | dumpString(D, tsvalue(o)); |
126 | break; | 126 | break; |
127 | default: | 127 | default: |
128 | lua_assert(tt == LUA_VNIL || tt == LUA_VFALSE || tt == LUA_VTRUE); | 128 | lua_assert(tt == LUA_VNIL || tt == LUA_VFALSE || tt == LUA_VTRUE); |
@@ -131,79 +131,79 @@ static void DumpConstants (const Proto *f, DumpState *D) { | |||
131 | } | 131 | } |
132 | 132 | ||
133 | 133 | ||
134 | static void DumpProtos (const Proto *f, DumpState *D) { | 134 | static void dumpProtos (DumpState *D, const Proto *f) { |
135 | int i; | 135 | int i; |
136 | int n = f->sizep; | 136 | int n = f->sizep; |
137 | DumpInt(n, D); | 137 | dumpInt(D, n); |
138 | for (i = 0; i < n; i++) | 138 | for (i = 0; i < n; i++) |
139 | DumpFunction(f->p[i], f->source, D); | 139 | dumpFunction(D, f->p[i], f->source); |
140 | } | 140 | } |
141 | 141 | ||
142 | 142 | ||
143 | static void DumpUpvalues (const Proto *f, DumpState *D) { | 143 | static void dumpUpvalues (DumpState *D, const Proto *f) { |
144 | int i, n = f->sizeupvalues; | 144 | int i, n = f->sizeupvalues; |
145 | DumpInt(n, D); | 145 | dumpInt(D, n); |
146 | for (i = 0; i < n; i++) { | 146 | for (i = 0; i < n; i++) { |
147 | DumpByte(f->upvalues[i].instack, D); | 147 | dumpByte(D, f->upvalues[i].instack); |
148 | DumpByte(f->upvalues[i].idx, D); | 148 | dumpByte(D, f->upvalues[i].idx); |
149 | DumpByte(f->upvalues[i].kind, D); | 149 | dumpByte(D, f->upvalues[i].kind); |
150 | } | 150 | } |
151 | } | 151 | } |
152 | 152 | ||
153 | 153 | ||
154 | static void DumpDebug (const Proto *f, DumpState *D) { | 154 | static void dumpDebug (DumpState *D, const Proto *f) { |
155 | int i, n; | 155 | int i, n; |
156 | n = (D->strip) ? 0 : f->sizelineinfo; | 156 | n = (D->strip) ? 0 : f->sizelineinfo; |
157 | DumpInt(n, D); | 157 | dumpInt(D, n); |
158 | DumpVector(f->lineinfo, n, D); | 158 | dumpVector(D, f->lineinfo, n); |
159 | n = (D->strip) ? 0 : f->sizeabslineinfo; | 159 | n = (D->strip) ? 0 : f->sizeabslineinfo; |
160 | DumpInt(n, D); | 160 | dumpInt(D, n); |
161 | for (i = 0; i < n; i++) { | 161 | for (i = 0; i < n; i++) { |
162 | DumpInt(f->abslineinfo[i].pc, D); | 162 | dumpInt(D, f->abslineinfo[i].pc); |
163 | DumpInt(f->abslineinfo[i].line, D); | 163 | dumpInt(D, f->abslineinfo[i].line); |
164 | } | 164 | } |
165 | n = (D->strip) ? 0 : f->sizelocvars; | 165 | n = (D->strip) ? 0 : f->sizelocvars; |
166 | DumpInt(n, D); | 166 | dumpInt(D, n); |
167 | for (i = 0; i < n; i++) { | 167 | for (i = 0; i < n; i++) { |
168 | DumpString(f->locvars[i].varname, D); | 168 | dumpString(D, f->locvars[i].varname); |
169 | DumpInt(f->locvars[i].startpc, D); | 169 | dumpInt(D, f->locvars[i].startpc); |
170 | DumpInt(f->locvars[i].endpc, D); | 170 | dumpInt(D, f->locvars[i].endpc); |
171 | } | 171 | } |
172 | n = (D->strip) ? 0 : f->sizeupvalues; | 172 | n = (D->strip) ? 0 : f->sizeupvalues; |
173 | DumpInt(n, D); | 173 | dumpInt(D, n); |
174 | for (i = 0; i < n; i++) | 174 | for (i = 0; i < n; i++) |
175 | DumpString(f->upvalues[i].name, D); | 175 | dumpString(D, f->upvalues[i].name); |
176 | } | 176 | } |
177 | 177 | ||
178 | 178 | ||
179 | static void DumpFunction (const Proto *f, TString *psource, DumpState *D) { | 179 | static void dumpFunction (DumpState *D, const Proto *f, TString *psource) { |
180 | if (D->strip || f->source == psource) | 180 | if (D->strip || f->source == psource) |
181 | DumpString(NULL, D); /* no debug info or same source as its parent */ | 181 | dumpString(D, NULL); /* no debug info or same source as its parent */ |
182 | else | 182 | else |
183 | DumpString(f->source, D); | 183 | dumpString(D, f->source); |
184 | DumpInt(f->linedefined, D); | 184 | dumpInt(D, f->linedefined); |
185 | DumpInt(f->lastlinedefined, D); | 185 | dumpInt(D, f->lastlinedefined); |
186 | DumpByte(f->numparams, D); | 186 | dumpByte(D, f->numparams); |
187 | DumpByte(f->is_vararg, D); | 187 | dumpByte(D, f->is_vararg); |
188 | DumpByte(f->maxstacksize, D); | 188 | dumpByte(D, f->maxstacksize); |
189 | DumpCode(f, D); | 189 | dumpCode(D, f); |
190 | DumpConstants(f, D); | 190 | dumpConstants(D, f); |
191 | DumpUpvalues(f, D); | 191 | dumpUpvalues(D, f); |
192 | DumpProtos(f, D); | 192 | dumpProtos(D, f); |
193 | DumpDebug(f, D); | 193 | dumpDebug(D, f); |
194 | } | 194 | } |
195 | 195 | ||
196 | 196 | ||
197 | static void DumpHeader (DumpState *D) { | 197 | static void dumpHeader (DumpState *D) { |
198 | DumpLiteral(LUA_SIGNATURE, D); | 198 | dumpLiteral(D, LUA_SIGNATURE); |
199 | DumpInt(LUAC_VERSION, D); | 199 | dumpInt(D, LUAC_VERSION); |
200 | DumpByte(LUAC_FORMAT, D); | 200 | dumpByte(D, LUAC_FORMAT); |
201 | DumpLiteral(LUAC_DATA, D); | 201 | dumpLiteral(D, LUAC_DATA); |
202 | DumpByte(sizeof(Instruction), D); | 202 | dumpByte(D, sizeof(Instruction)); |
203 | DumpByte(sizeof(lua_Integer), D); | 203 | dumpByte(D, sizeof(lua_Integer)); |
204 | DumpByte(sizeof(lua_Number), D); | 204 | dumpByte(D, sizeof(lua_Number)); |
205 | DumpInteger(LUAC_INT, D); | 205 | dumpInteger(D, LUAC_INT); |
206 | DumpNumber(LUAC_NUM, D); | 206 | dumpNumber(D, LUAC_NUM); |
207 | } | 207 | } |
208 | 208 | ||
209 | 209 | ||
@@ -218,9 +218,9 @@ int luaU_dump(lua_State *L, const Proto *f, lua_Writer w, void *data, | |||
218 | D.data = data; | 218 | D.data = data; |
219 | D.strip = strip; | 219 | D.strip = strip; |
220 | D.status = 0; | 220 | D.status = 0; |
221 | DumpHeader(&D); | 221 | dumpHeader(&D); |
222 | DumpByte(f->sizeupvalues, &D); | 222 | dumpByte(&D, f->sizeupvalues); |
223 | DumpFunction(f, NULL, &D); | 223 | dumpFunction(&D, f, NULL); |
224 | return D.status; | 224 | return D.status; |
225 | } | 225 | } |
226 | 226 | ||