File: | game/lua/ldebug.cpp |
Location: | line 612, column 24 |
Description: | Access to field 'source' results in a dereference of a null pointer |
1 | /* | ||||
2 | ** $Id: ldebug.c,v 2.29.1.6 2008/05/08 16:56:26 roberto Exp $ | ||||
3 | ** Debug Interface | ||||
4 | ** See Copyright Notice in lua.h | ||||
5 | */ | ||||
6 | |||||
7 | |||||
8 | #include <stdarg.h> | ||||
9 | #include <stddef.h> | ||||
10 | #include <string.h> | ||||
11 | |||||
12 | |||||
13 | #define ldebug_c | ||||
14 | #define LUA_CORE | ||||
15 | |||||
16 | #include "lua.h" | ||||
17 | |||||
18 | #include "lapi.h" | ||||
19 | #include "lcode.h" | ||||
20 | #include "ldebug.h" | ||||
21 | #include "ldo.h" | ||||
22 | #include "lfunc.h" | ||||
23 | #include "lobject.h" | ||||
24 | #include "lopcodes.h" | ||||
25 | #include "lstate.h" | ||||
26 | #include "lstring.h" | ||||
27 | #include "ltable.h" | ||||
28 | #include "ltm.h" | ||||
29 | #include "lvm.h" | ||||
30 | |||||
31 | |||||
32 | |||||
33 | static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name); | ||||
34 | |||||
35 | |||||
36 | static int currentpc (lua_State *L, CallInfo *ci) { | ||||
37 | if (!isLua(ci)(((((ci)->func)->tt) == 6) && (!((&((ci)-> func)->value.gc->cl))->c.isC))) return -1; /* function is not a Lua function? */ | ||||
38 | if (ci == L->ci) | ||||
39 | ci->savedpc = L->savedpc; | ||||
40 | return pcRel(ci->savedpc, ci_func(ci)->l.p)(((int)((ci->savedpc) - (((&((ci)->func)->value. gc->cl))->l.p)->code)) - 1); | ||||
41 | } | ||||
42 | |||||
43 | |||||
44 | static int currentline (lua_State *L, CallInfo *ci) { | ||||
45 | int pc = currentpc(L, ci); | ||||
46 | if (pc < 0) | ||||
47 | return -1; /* only active lua functions have current-line information */ | ||||
48 | else | ||||
49 | return getline(ci_func(ci)->l.p, pc)(((((&((ci)->func)->value.gc->cl))->l.p)-> lineinfo) ? (((&((ci)->func)->value.gc->cl))-> l.p)->lineinfo[pc] : 0); | ||||
50 | } | ||||
51 | |||||
52 | |||||
53 | /* | ||||
54 | ** this function can be called asynchronous (e.g. during a signal) | ||||
55 | */ | ||||
56 | LUA_APIextern int lua_sethook (lua_State *L, lua_Hook func, int mask, int count) { | ||||
57 | if (func == NULL__null || mask == 0) { /* turn off hooks? */ | ||||
58 | mask = 0; | ||||
59 | func = NULL__null; | ||||
60 | } | ||||
61 | L->hook = func; | ||||
62 | L->basehookcount = count; | ||||
63 | resethookcount(L)(L->hookcount = L->basehookcount); | ||||
64 | L->hookmask = cast_byte(mask)((lu_byte)((mask))); | ||||
65 | return 1; | ||||
66 | } | ||||
67 | |||||
68 | |||||
69 | LUA_APIextern lua_Hook lua_gethook (lua_State *L) { | ||||
70 | return L->hook; | ||||
71 | } | ||||
72 | |||||
73 | |||||
74 | LUA_APIextern int lua_gethookmask (lua_State *L) { | ||||
75 | return L->hookmask; | ||||
76 | } | ||||
77 | |||||
78 | |||||
79 | LUA_APIextern int lua_gethookcount (lua_State *L) { | ||||
80 | return L->basehookcount; | ||||
81 | } | ||||
82 | |||||
83 | |||||
84 | LUA_APIextern int lua_getstack (lua_State *L, int level, lua_Debug *ar) { | ||||
85 | int status; | ||||
86 | CallInfo *ci; | ||||
87 | lua_lock(L)((void) 0); | ||||
88 | for (ci = L->ci; level > 0 && ci > L->base_ci; ci--) { | ||||
89 | level--; | ||||
90 | if (f_isLua(ci)(!((&((ci)->func)->value.gc->cl))->c.isC)) /* Lua function? */ | ||||
91 | level -= ci->tailcalls; /* skip lost tail calls */ | ||||
92 | } | ||||
93 | if (level == 0 && ci > L->base_ci) { /* level found? */ | ||||
94 | status = 1; | ||||
95 | ar->i_ci = cast_int(ci - L->base_ci)((int)((ci - L->base_ci))); | ||||
96 | } | ||||
97 | else if (level < 0) { /* level is of a lost tail call? */ | ||||
98 | status = 1; | ||||
99 | ar->i_ci = 0; | ||||
100 | } | ||||
101 | else status = 0; /* no such level */ | ||||
102 | lua_unlock(L)((void) 0); | ||||
103 | return status; | ||||
104 | } | ||||
105 | |||||
106 | |||||
107 | static Proto *getluaproto (CallInfo *ci) { | ||||
108 | return (isLua(ci)(((((ci)->func)->tt) == 6) && (!((&((ci)-> func)->value.gc->cl))->c.isC)) ? ci_func(ci)((&((ci)->func)->value.gc->cl))->l.p : NULL__null); | ||||
109 | } | ||||
110 | |||||
111 | |||||
112 | static const char *findlocal (lua_State *L, CallInfo *ci, int n) { | ||||
113 | const char *name; | ||||
114 | Proto *fp = getluaproto(ci); | ||||
115 | if (fp && (name = luaF_getlocalname(fp, n, currentpc(L, ci))) != NULL__null) | ||||
116 | return name; /* is a local variable in a Lua function */ | ||||
117 | else { | ||||
118 | StkId limit = (ci == L->ci) ? L->top : (ci+1)->func; | ||||
119 | if (limit - ci->base >= n && n > 0) /* is 'n' inside 'ci' stack? */ | ||||
120 | return "(*temporary)"; | ||||
121 | else | ||||
122 | return NULL__null; | ||||
123 | } | ||||
124 | } | ||||
125 | |||||
126 | |||||
127 | LUA_APIextern const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n) { | ||||
128 | CallInfo *ci = L->base_ci + ar->i_ci; | ||||
129 | const char *name = findlocal(L, ci, n); | ||||
130 | lua_lock(L)((void) 0); | ||||
131 | if (name) | ||||
132 | luaA_pushobject(L, ci->base + (n - 1)); | ||||
133 | lua_unlock(L)((void) 0); | ||||
134 | return name; | ||||
135 | } | ||||
136 | |||||
137 | |||||
138 | LUA_APIextern const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n) { | ||||
139 | CallInfo *ci = L->base_ci + ar->i_ci; | ||||
140 | const char *name = findlocal(L, ci, n); | ||||
141 | lua_lock(L)((void) 0); | ||||
142 | if (name) | ||||
143 | setobjs2s(L, ci->base + (n - 1), L->top - 1){ const TValue *o2=(L->top - 1); TValue *o1=(ci->base + (n - 1)); o1->value = o2->value; o1->tt=o2->tt; ( (void)0); }; | ||||
144 | L->top--; /* pop value */ | ||||
145 | lua_unlock(L)((void) 0); | ||||
146 | return name; | ||||
147 | } | ||||
148 | |||||
149 | |||||
150 | static void funcinfo (lua_Debug *ar, Closure *cl) { | ||||
151 | if (cl->c.isC) { | ||||
152 | ar->source = "=[C]"; | ||||
153 | ar->linedefined = -1; | ||||
154 | ar->lastlinedefined = -1; | ||||
155 | ar->what = "C"; | ||||
156 | } | ||||
157 | else { | ||||
158 | ar->source = getstr(cl->l.p->source)((const char *)((cl->l.p->source) + 1)); | ||||
159 | ar->linedefined = cl->l.p->linedefined; | ||||
160 | ar->lastlinedefined = cl->l.p->lastlinedefined; | ||||
161 | ar->what = (ar->linedefined == 0) ? "main" : "Lua"; | ||||
162 | } | ||||
163 | luaO_chunkid(ar->short_src, ar->source, LUA_IDSIZE60); | ||||
164 | } | ||||
165 | |||||
166 | |||||
167 | static void info_tailcall (lua_Debug *ar) { | ||||
168 | ar->name = ar->namewhat = ""; | ||||
169 | ar->what = "tail"; | ||||
170 | ar->lastlinedefined = ar->linedefined = ar->currentline = -1; | ||||
171 | ar->source = "=(tail call)"; | ||||
172 | luaO_chunkid(ar->short_src, ar->source, LUA_IDSIZE60); | ||||
173 | ar->nups = 0; | ||||
174 | } | ||||
175 | |||||
176 | |||||
177 | static void collectvalidlines (lua_State *L, Closure *f) { | ||||
178 | if (f == NULL__null || f->c.isC) { | ||||
179 | setnilvalue(L->top)((L->top)->tt=0); | ||||
180 | } | ||||
181 | else { | ||||
182 | Table *t = luaH_new(L, 0, 0); | ||||
183 | int *lineinfo = f->l.p->lineinfo; | ||||
184 | int i; | ||||
185 | for (i=0; i<f->l.p->sizelineinfo; i++) | ||||
186 | setbvalue(luaH_setnum(L, t, lineinfo[i]), 1){ TValue *i_o=(luaH_setnum(L, t, lineinfo[i])); i_o->value .b=(1); i_o->tt=1; }; | ||||
187 | sethvalue(L, L->top, t){ TValue *i_o=(L->top); i_o->value.gc=((GCObject *)((t) )); i_o->tt=5; ((void)0); }; | ||||
188 | } | ||||
189 | incr_top(L){if ((char *)L->stack_last - (char *)L->top <= (1)*( int)sizeof(TValue)) luaD_growstack(L, 1); else ((void)0);; L-> top++;}; | ||||
190 | } | ||||
191 | |||||
192 | |||||
193 | static int auxgetinfo (lua_State *L, const char *what, lua_Debug *ar, | ||||
194 | Closure *f, CallInfo *ci) { | ||||
195 | int status = 1; | ||||
196 | if (f == NULL__null) { | ||||
197 | info_tailcall(ar); | ||||
198 | return status; | ||||
199 | } | ||||
200 | for (; *what; what++) { | ||||
201 | switch (*what) { | ||||
202 | case 'S': { | ||||
203 | funcinfo(ar, f); | ||||
204 | break; | ||||
205 | } | ||||
206 | case 'l': { | ||||
207 | ar->currentline = (ci) ? currentline(L, ci) : -1; | ||||
208 | break; | ||||
209 | } | ||||
210 | case 'u': { | ||||
211 | ar->nups = f->c.nupvalues; | ||||
212 | break; | ||||
213 | } | ||||
214 | case 'n': { | ||||
215 | ar->namewhat = (ci) ? getfuncname(L, ci, &ar->name) : NULL__null; | ||||
216 | if (ar->namewhat == NULL__null) { | ||||
217 | ar->namewhat = ""; /* not found */ | ||||
218 | ar->name = NULL__null; | ||||
219 | } | ||||
220 | break; | ||||
221 | } | ||||
222 | case 'L': | ||||
223 | case 'f': /* handled by lua_getinfo */ | ||||
224 | break; | ||||
225 | default: status = 0; /* invalid option */ | ||||
226 | } | ||||
227 | } | ||||
228 | return status; | ||||
229 | } | ||||
230 | |||||
231 | |||||
232 | LUA_APIextern int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar) { | ||||
233 | int status; | ||||
234 | Closure *f = NULL__null; | ||||
235 | CallInfo *ci = NULL__null; | ||||
236 | lua_lock(L)((void) 0); | ||||
237 | if (*what == '>') { | ||||
238 | StkId func = L->top - 1; | ||||
239 | luai_apicheck(L, ttisfunction(func)){ (void)L; (__builtin_expect(!((((func)->tt) == 6)), 0) ? __assert_rtn (__func__, "src/game/lua/ldebug.cpp", 239, "(((func)->tt) == 6)" ) : (void)0); }; | ||||
240 | what++; /* skip the '>' */ | ||||
241 | f = clvalue(func)(&(func)->value.gc->cl); | ||||
242 | L->top--; /* pop function */ | ||||
243 | } | ||||
244 | else if (ar->i_ci != 0) { /* no tail call? */ | ||||
245 | ci = L->base_ci + ar->i_ci; | ||||
246 | lua_assert(ttisfunction(ci->func))((void)0); | ||||
247 | f = clvalue(ci->func)(&(ci->func)->value.gc->cl); | ||||
248 | } | ||||
249 | status = auxgetinfo(L, what, ar, f, ci); | ||||
250 | if (strchr(what, 'f')) { | ||||
251 | if (f == NULL__null) setnilvalue(L->top)((L->top)->tt=0); | ||||
252 | else setclvalue(L, L->top, f){ TValue *i_o=(L->top); i_o->value.gc=((GCObject *)((f) )); i_o->tt=6; ((void)0); }; | ||||
253 | incr_top(L){if ((char *)L->stack_last - (char *)L->top <= (1)*( int)sizeof(TValue)) luaD_growstack(L, 1); else ((void)0);; L-> top++;}; | ||||
254 | } | ||||
255 | if (strchr(what, 'L')) | ||||
256 | collectvalidlines(L, f); | ||||
257 | lua_unlock(L)((void) 0); | ||||
258 | return status; | ||||
259 | } | ||||
260 | |||||
261 | |||||
262 | /* | ||||
263 | ** {====================================================== | ||||
264 | ** Symbolic Execution and code checker | ||||
265 | ** ======================================================= | ||||
266 | */ | ||||
267 | |||||
268 | #define check(x) if (!(x)) return 0; | ||||
269 | |||||
270 | #define checkjump(pt,pc) check(0 <= pc && pc < pt->sizecode) | ||||
271 | |||||
272 | #define checkreg(pt,reg) check((reg) < (pt)->maxstacksize) | ||||
273 | |||||
274 | |||||
275 | |||||
276 | static int precheck (const Proto *pt) { | ||||
277 | check(pt->maxstacksize <= MAXSTACK250); | ||||
278 | check(pt->numparams+(pt->is_vararg & VARARG_HASARG1) <= pt->maxstacksize); | ||||
279 | check(!(pt->is_vararg & VARARG_NEEDSARG4) || | ||||
280 | (pt->is_vararg & VARARG_HASARG1)); | ||||
281 | check(pt->sizeupvalues <= pt->nups); | ||||
282 | check(pt->sizelineinfo == pt->sizecode || pt->sizelineinfo == 0); | ||||
283 | check(pt->sizecode > 0 && GET_OPCODE(pt->code[pt->sizecode-1])(((OpCode)(((pt->code[pt->sizecode-1])>>0) & ( (~((~(Instruction)0)<<6))<<0)))) == OP_RETURN); | ||||
284 | return 1; | ||||
285 | } | ||||
286 | |||||
287 | |||||
288 | #define checkopenop(pt,pc)luaG_checkopenop((pt)->code[(pc)+1]) luaG_checkopenop((pt)->code[(pc)+1]) | ||||
289 | |||||
290 | int luaG_checkopenop (Instruction i) { | ||||
291 | switch (GET_OPCODE(i)(((OpCode)(((i)>>0) & ((~((~(Instruction)0)<< 6))<<0))))) { | ||||
292 | case OP_CALL: | ||||
293 | case OP_TAILCALL: | ||||
294 | case OP_RETURN: | ||||
295 | case OP_SETLIST: { | ||||
296 | check(GETARG_B(i)(((int)(((i)>>(((0 + 6) + 8) + 9)) & ((~((~(Instruction )0)<<9))<<0)))) == 0); | ||||
297 | return 1; | ||||
298 | } | ||||
299 | default: return 0; /* invalid instruction after an open call */ | ||||
300 | } | ||||
301 | } | ||||
302 | |||||
303 | |||||
304 | static int checkArgMode (const Proto *pt, int r, enum OpArgMask mode) { | ||||
305 | switch (mode) { | ||||
306 | case OpArgN: check(r == 0); break; | ||||
307 | case OpArgU: break; | ||||
308 | case OpArgR: checkreg(pt, r); break; | ||||
309 | case OpArgK: | ||||
310 | check(ISK(r)((r) & (1 << (9 - 1))) ? INDEXK(r)((int)(r) & ~(1 << (9 - 1))) < pt->sizek : r < pt->maxstacksize); | ||||
311 | break; | ||||
312 | } | ||||
313 | return 1; | ||||
314 | } | ||||
315 | |||||
316 | |||||
317 | static Instruction symbexec (const Proto *pt, int lastpc, int reg) { | ||||
318 | int pc; | ||||
319 | int last; /* stores position of last instruction that changed `reg' */ | ||||
320 | last = pt->sizecode-1; /* points to final return (a `neutral' instruction) */ | ||||
321 | check(precheck(pt)); | ||||
322 | for (pc = 0; pc < lastpc; pc++) { | ||||
323 | Instruction i = pt->code[pc]; | ||||
324 | OpCode op = GET_OPCODE(i)(((OpCode)(((i)>>0) & ((~((~(Instruction)0)<< 6))<<0)))); | ||||
325 | int a = GETARG_A(i)(((int)(((i)>>(0 + 6)) & ((~((~(Instruction)0)<< 8))<<0)))); | ||||
326 | int b = 0; | ||||
327 | int c = 0; | ||||
328 | check(op < NUM_OPCODES(((int)(OP_VARARG)) + 1)); | ||||
329 | checkreg(pt, a); | ||||
330 | switch (getOpMode(op)(((enum OpMode)(luaP_opmodes[op] & 3)))) { | ||||
331 | case iABC: { | ||||
332 | b = GETARG_B(i)(((int)(((i)>>(((0 + 6) + 8) + 9)) & ((~((~(Instruction )0)<<9))<<0)))); | ||||
333 | c = GETARG_C(i)(((int)(((i)>>((0 + 6) + 8)) & ((~((~(Instruction)0 )<<9))<<0)))); | ||||
334 | check(checkArgMode(pt, b, getBMode(op)(((enum OpArgMask)((luaP_opmodes[op] >> 4) & 3))))); | ||||
335 | check(checkArgMode(pt, c, getCMode(op)(((enum OpArgMask)((luaP_opmodes[op] >> 2) & 3))))); | ||||
336 | break; | ||||
337 | } | ||||
338 | case iABx: { | ||||
339 | b = GETARG_Bx(i)(((int)(((i)>>((0 + 6) + 8)) & ((~((~(Instruction)0 )<<(9 + 9)))<<0)))); | ||||
340 | if (getBMode(op)(((enum OpArgMask)((luaP_opmodes[op] >> 4) & 3))) == OpArgK) check(b < pt->sizek); | ||||
341 | break; | ||||
342 | } | ||||
343 | case iAsBx: { | ||||
344 | b = GETARG_sBx(i)((((int)(((i)>>((0 + 6) + 8)) & ((~((~(Instruction) 0)<<(9 + 9)))<<0))))-(((1<<(9 + 9))-1)>> 1)); | ||||
345 | if (getBMode(op)(((enum OpArgMask)((luaP_opmodes[op] >> 4) & 3))) == OpArgR) { | ||||
346 | int dest = pc+1+b; | ||||
347 | check(0 <= dest && dest < pt->sizecode); | ||||
348 | if (dest > 0) { | ||||
349 | int j; | ||||
350 | /* check that it does not jump to a setlist count; this | ||||
351 | is tricky, because the count from a previous setlist may | ||||
352 | have the same value of an invalid setlist; so, we must | ||||
353 | go all the way back to the first of them (if any) */ | ||||
354 | for (j = 0; j < dest; j++) { | ||||
355 | Instruction d = pt->code[dest-1-j]; | ||||
356 | if (!(GET_OPCODE(d)(((OpCode)(((d)>>0) & ((~((~(Instruction)0)<< 6))<<0)))) == OP_SETLIST && GETARG_C(d)(((int)(((d)>>((0 + 6) + 8)) & ((~((~(Instruction)0 )<<9))<<0)))) == 0)) break; | ||||
357 | } | ||||
358 | /* if 'j' is even, previous value is not a setlist (even if | ||||
359 | it looks like one) */ | ||||
360 | check((j&1) == 0); | ||||
361 | } | ||||
362 | } | ||||
363 | break; | ||||
364 | } | ||||
365 | } | ||||
366 | if (testAMode(op)(luaP_opmodes[op] & (1 << 6))) { | ||||
367 | if (a == reg) last = pc; /* change register `a' */ | ||||
368 | } | ||||
369 | if (testTMode(op)(luaP_opmodes[op] & (1 << 7))) { | ||||
370 | check(pc+2 < pt->sizecode); /* check skip */ | ||||
371 | check(GET_OPCODE(pt->code[pc+1])(((OpCode)(((pt->code[pc+1])>>0) & ((~((~(Instruction )0)<<6))<<0)))) == OP_JMP); | ||||
372 | } | ||||
373 | switch (op) { | ||||
374 | case OP_LOADBOOL: { | ||||
375 | if (c == 1) { /* does it jump? */ | ||||
376 | check(pc+2 < pt->sizecode); /* check its jump */ | ||||
377 | check(GET_OPCODE(pt->code[pc+1])(((OpCode)(((pt->code[pc+1])>>0) & ((~((~(Instruction )0)<<6))<<0)))) != OP_SETLIST || | ||||
378 | GETARG_C(pt->code[pc+1])(((int)(((pt->code[pc+1])>>((0 + 6) + 8)) & ((~( (~(Instruction)0)<<9))<<0)))) != 0); | ||||
379 | } | ||||
380 | break; | ||||
381 | } | ||||
382 | case OP_LOADNIL: { | ||||
383 | if (a <= reg && reg <= b) | ||||
384 | last = pc; /* set registers from `a' to `b' */ | ||||
385 | break; | ||||
386 | } | ||||
387 | case OP_GETUPVAL: | ||||
388 | case OP_SETUPVAL: { | ||||
389 | check(b < pt->nups); | ||||
390 | break; | ||||
391 | } | ||||
392 | case OP_GETGLOBAL: | ||||
393 | case OP_SETGLOBAL: { | ||||
394 | check(ttisstring(&pt->k[b])(((&pt->k[b])->tt) == 4)); | ||||
395 | break; | ||||
396 | } | ||||
397 | case OP_SELF: { | ||||
398 | checkreg(pt, a+1); | ||||
399 | if (reg == a+1) last = pc; | ||||
400 | break; | ||||
401 | } | ||||
402 | case OP_CONCAT: { | ||||
403 | check(b < c); /* at least two operands */ | ||||
404 | break; | ||||
405 | } | ||||
406 | case OP_TFORLOOP: { | ||||
407 | check(c >= 1); /* at least one result (control variable) */ | ||||
408 | checkreg(pt, a+2+c); /* space for results */ | ||||
409 | if (reg >= a+2) last = pc; /* affect all regs above its base */ | ||||
410 | break; | ||||
411 | } | ||||
412 | case OP_FORLOOP: | ||||
413 | case OP_FORPREP: | ||||
414 | checkreg(pt, a+3); | ||||
415 | /* go through */ | ||||
416 | case OP_JMP: { | ||||
417 | int dest = pc+1+b; | ||||
418 | /* not full check and jump is forward and do not skip `lastpc'? */ | ||||
419 | if (reg != NO_REG((1<<8)-1) && pc < dest && dest <= lastpc) | ||||
420 | pc += b; /* do the jump */ | ||||
421 | break; | ||||
422 | } | ||||
423 | case OP_CALL: | ||||
424 | case OP_TAILCALL: { | ||||
425 | if (b != 0) { | ||||
426 | checkreg(pt, a+b-1); | ||||
427 | } | ||||
428 | c--; /* c = num. returns */ | ||||
429 | if (c == LUA_MULTRET(-1)) { | ||||
430 | check(checkopenop(pt, pc)luaG_checkopenop((pt)->code[(pc)+1])); | ||||
431 | } | ||||
432 | else if (c != 0) | ||||
433 | checkreg(pt, a+c-1); | ||||
434 | if (reg >= a) last = pc; /* affect all registers above base */ | ||||
435 | break; | ||||
436 | } | ||||
437 | case OP_RETURN: { | ||||
438 | b--; /* b = num. returns */ | ||||
439 | if (b > 0) checkreg(pt, a+b-1); | ||||
440 | break; | ||||
441 | } | ||||
442 | case OP_SETLIST: { | ||||
443 | if (b > 0) checkreg(pt, a + b); | ||||
444 | if (c == 0) { | ||||
445 | pc++; | ||||
446 | check(pc < pt->sizecode - 1); | ||||
447 | } | ||||
448 | break; | ||||
449 | } | ||||
450 | case OP_CLOSURE: { | ||||
451 | int nup, j; | ||||
452 | check(b < pt->sizep); | ||||
453 | nup = pt->p[b]->nups; | ||||
454 | check(pc + nup < pt->sizecode); | ||||
455 | for (j = 1; j <= nup; j++) { | ||||
456 | OpCode op1 = GET_OPCODE(pt->code[pc + j])(((OpCode)(((pt->code[pc + j])>>0) & ((~((~(Instruction )0)<<6))<<0)))); | ||||
457 | check(op1 == OP_GETUPVAL || op1 == OP_MOVE); | ||||
458 | } | ||||
459 | if (reg != NO_REG((1<<8)-1)) /* tracing? */ | ||||
460 | pc += nup; /* do not 'execute' these pseudo-instructions */ | ||||
461 | break; | ||||
462 | } | ||||
463 | case OP_VARARG: { | ||||
464 | check((pt->is_vararg & VARARG_ISVARARG2) && | ||||
465 | !(pt->is_vararg & VARARG_NEEDSARG4)); | ||||
466 | b--; | ||||
467 | if (b == LUA_MULTRET(-1)) check(checkopenop(pt, pc)luaG_checkopenop((pt)->code[(pc)+1])); | ||||
468 | checkreg(pt, a+b-1); | ||||
469 | break; | ||||
470 | } | ||||
471 | default: break; | ||||
472 | } | ||||
473 | } | ||||
474 | return pt->code[last]; | ||||
475 | } | ||||
476 | |||||
477 | #undef check | ||||
478 | #undef checkjump | ||||
479 | #undef checkreg | ||||
480 | |||||
481 | /* }====================================================== */ | ||||
482 | |||||
483 | |||||
484 | int luaG_checkcode (const Proto *pt) { | ||||
485 | return (symbexec(pt, pt->sizecode, NO_REG((1<<8)-1)) != 0); | ||||
486 | } | ||||
487 | |||||
488 | |||||
489 | static const char *kname (Proto *p, int c) { | ||||
490 | if (ISK(c)((c) & (1 << (9 - 1))) && ttisstring(&p->k[INDEXK(c)])(((&p->k[((int)(c) & ~(1 << (9 - 1)))])-> tt) == 4)) | ||||
491 | return svalue(&p->k[INDEXK(c)])((const char *)(((&(&p->k[((int)(c) & ~(1 << (9 - 1)))])->value.gc->ts)) + 1)); | ||||
492 | else | ||||
493 | return "?"; | ||||
494 | } | ||||
495 | |||||
496 | |||||
497 | static const char *getobjname (lua_State *L, CallInfo *ci, int stackpos, | ||||
498 | const char **name) { | ||||
499 | if (isLua(ci)(((((ci)->func)->tt) == 6) && (!((&((ci)-> func)->value.gc->cl))->c.isC))) { /* a Lua function? */ | ||||
500 | Proto *p = ci_func(ci)((&((ci)->func)->value.gc->cl))->l.p; | ||||
501 | int pc = currentpc(L, ci); | ||||
502 | Instruction i; | ||||
503 | *name = luaF_getlocalname(p, stackpos+1, pc); | ||||
504 | if (*name) /* is a local? */ | ||||
505 | return "local"; | ||||
506 | i = symbexec(p, pc, stackpos); /* try symbolic execution */ | ||||
507 | lua_assert(pc != -1)((void)0); | ||||
508 | switch (GET_OPCODE(i)(((OpCode)(((i)>>0) & ((~((~(Instruction)0)<< 6))<<0))))) { | ||||
509 | case OP_GETGLOBAL: { | ||||
510 | int g = GETARG_Bx(i)(((int)(((i)>>((0 + 6) + 8)) & ((~((~(Instruction)0 )<<(9 + 9)))<<0)))); /* global index */ | ||||
511 | lua_assert(ttisstring(&p->k[g]))((void)0); | ||||
512 | *name = svalue(&p->k[g])((const char *)(((&(&p->k[g])->value.gc->ts) ) + 1)); | ||||
513 | return "global"; | ||||
514 | } | ||||
515 | case OP_MOVE: { | ||||
516 | int a = GETARG_A(i)(((int)(((i)>>(0 + 6)) & ((~((~(Instruction)0)<< 8))<<0)))); | ||||
517 | int b = GETARG_B(i)(((int)(((i)>>(((0 + 6) + 8) + 9)) & ((~((~(Instruction )0)<<9))<<0)))); /* move from `b' to `a' */ | ||||
518 | if (b < a) | ||||
519 | return getobjname(L, ci, b, name); /* get name for `b' */ | ||||
520 | break; | ||||
521 | } | ||||
522 | case OP_GETTABLE: { | ||||
523 | int k = GETARG_C(i)(((int)(((i)>>((0 + 6) + 8)) & ((~((~(Instruction)0 )<<9))<<0)))); /* key index */ | ||||
524 | *name = kname(p, k); | ||||
525 | return "field"; | ||||
526 | } | ||||
527 | case OP_GETUPVAL: { | ||||
528 | int u = GETARG_B(i)(((int)(((i)>>(((0 + 6) + 8) + 9)) & ((~((~(Instruction )0)<<9))<<0)))); /* upvalue index */ | ||||
529 | *name = p->upvalues ? getstr(p->upvalues[u])((const char *)((p->upvalues[u]) + 1)) : "?"; | ||||
530 | return "upvalue"; | ||||
531 | } | ||||
532 | case OP_SELF: { | ||||
533 | int k = GETARG_C(i)(((int)(((i)>>((0 + 6) + 8)) & ((~((~(Instruction)0 )<<9))<<0)))); /* key index */ | ||||
534 | *name = kname(p, k); | ||||
535 | return "method"; | ||||
536 | } | ||||
537 | default: break; | ||||
538 | } | ||||
539 | } | ||||
540 | return NULL__null; /* no useful name found */ | ||||
541 | } | ||||
542 | |||||
543 | |||||
544 | static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name) { | ||||
545 | Instruction i; | ||||
546 | if ((isLua(ci)(((((ci)->func)->tt) == 6) && (!((&((ci)-> func)->value.gc->cl))->c.isC)) && ci->tailcalls > 0) || !isLua(ci - 1)(((((ci - 1)->func)->tt) == 6) && (!((&((ci - 1)->func)->value.gc->cl))->c.isC))) | ||||
547 | return NULL__null; /* calling function is not Lua (or is unknown) */ | ||||
548 | ci--; /* calling function */ | ||||
549 | i = ci_func(ci)((&((ci)->func)->value.gc->cl))->l.p->code[currentpc(L, ci)]; | ||||
550 | if (GET_OPCODE(i)(((OpCode)(((i)>>0) & ((~((~(Instruction)0)<< 6))<<0)))) == OP_CALL || GET_OPCODE(i)(((OpCode)(((i)>>0) & ((~((~(Instruction)0)<< 6))<<0)))) == OP_TAILCALL || | ||||
551 | GET_OPCODE(i)(((OpCode)(((i)>>0) & ((~((~(Instruction)0)<< 6))<<0)))) == OP_TFORLOOP) | ||||
552 | return getobjname(L, ci, GETARG_A(i)(((int)(((i)>>(0 + 6)) & ((~((~(Instruction)0)<< 8))<<0)))), name); | ||||
553 | else | ||||
554 | return NULL__null; /* no useful name can be found */ | ||||
555 | } | ||||
556 | |||||
557 | |||||
558 | /* only ANSI way to check whether a pointer points to an array */ | ||||
559 | static int isinstack (CallInfo *ci, const TValue *o) { | ||||
560 | StkId p; | ||||
561 | for (p = ci->base; p < ci->top; p++) | ||||
562 | if (o == p) return 1; | ||||
563 | return 0; | ||||
564 | } | ||||
565 | |||||
566 | |||||
567 | void luaG_typeerror (lua_State *L, const TValue *o, const char *op) { | ||||
568 | const char *name = NULL__null; | ||||
569 | const char *t = luaT_typenames[ttype(o)((o)->tt)]; | ||||
570 | const char *kind = (isinstack(L->ci, o)) ? | ||||
571 | getobjname(L, L->ci, cast_int(o - L->base)((int)((o - L->base))), &name) : | ||||
572 | NULL__null; | ||||
573 | if (kind) | ||||
574 | luaG_runerror(L, "attempt to %s %s " LUA_QS"'" "%s" "'" " (a %s value)", | ||||
575 | op, kind, name, t); | ||||
576 | else | ||||
577 | luaG_runerror(L, "attempt to %s a %s value", op, t); | ||||
578 | } | ||||
579 | |||||
580 | |||||
581 | void luaG_concaterror (lua_State *L, StkId p1, StkId p2) { | ||||
582 | if (ttisstring(p1)(((p1)->tt) == 4) || ttisnumber(p1)(((p1)->tt) == 3)) p1 = p2; | ||||
583 | lua_assert(!ttisstring(p1) && !ttisnumber(p1))((void)0); | ||||
584 | luaG_typeerror(L, p1, "concatenate"); | ||||
585 | } | ||||
586 | |||||
587 | |||||
588 | void luaG_aritherror (lua_State *L, const TValue *p1, const TValue *p2) { | ||||
589 | TValue temp; | ||||
590 | if (luaV_tonumber(p1, &temp) == NULL__null) | ||||
591 | p2 = p1; /* first operand is wrong */ | ||||
592 | luaG_typeerror(L, p2, "perform arithmetic on"); | ||||
593 | } | ||||
594 | |||||
595 | |||||
596 | int luaG_ordererror (lua_State *L, const TValue *p1, const TValue *p2) { | ||||
597 | const char *t1 = luaT_typenames[ttype(p1)((p1)->tt)]; | ||||
598 | const char *t2 = luaT_typenames[ttype(p2)((p2)->tt)]; | ||||
599 | if (t1[2] == t2[2]) | ||||
600 | luaG_runerror(L, "attempt to compare two %s values", t1); | ||||
601 | else | ||||
602 | luaG_runerror(L, "attempt to compare %s with %s", t1, t2); | ||||
603 | return 0; | ||||
604 | } | ||||
605 | |||||
606 | |||||
607 | static void addinfo (lua_State *L, const char *msg) { | ||||
608 | CallInfo *ci = L->ci; | ||||
609 | if (isLua(ci)(((((ci)->func)->tt) == 6) && (!((&((ci)-> func)->value.gc->cl))->c.isC))) { /* is Lua code? */ | ||||
| |||||
610 | char buff[LUA_IDSIZE60]; /* add file:line information */ | ||||
611 | int line = currentline(L, ci); | ||||
612 | luaO_chunkid(buff, getstr(getluaproto(ci)->source)((const char *)((getluaproto(ci)->source) + 1)), LUA_IDSIZE60); | ||||
| |||||
613 | luaO_pushfstring(L, "%s:%d: %s", buff, line, msg); | ||||
614 | } | ||||
615 | } | ||||
616 | |||||
617 | |||||
618 | void luaG_errormsg (lua_State *L) { | ||||
619 | if (L->errfunc != 0) { /* is there an error handling function? */ | ||||
620 | StkId errfunc = restorestack(L, L->errfunc)((TValue *)((char *)L->stack + (L->errfunc))); | ||||
621 | if (!ttisfunction(errfunc)(((errfunc)->tt) == 6)) luaD_throw(L, LUA_ERRERR5); | ||||
622 | setobjs2s(L, L->top, L->top - 1){ const TValue *o2=(L->top - 1); TValue *o1=(L->top); o1 ->value = o2->value; o1->tt=o2->tt; ((void)0); }; /* move argument */ | ||||
623 | setobjs2s(L, L->top - 1, errfunc){ const TValue *o2=(errfunc); TValue *o1=(L->top - 1); o1-> value = o2->value; o1->tt=o2->tt; ((void)0); }; /* push function */ | ||||
624 | incr_top(L){if ((char *)L->stack_last - (char *)L->top <= (1)*( int)sizeof(TValue)) luaD_growstack(L, 1); else ((void)0);; L-> top++;}; | ||||
625 | luaD_call(L, L->top - 2, 1); /* call it */ | ||||
626 | } | ||||
627 | luaD_throw(L, LUA_ERRRUN2); | ||||
628 | } | ||||
629 | |||||
630 | |||||
631 | void luaG_runerror (lua_State *L, const char *fmt, ...) { | ||||
632 | va_list argp; | ||||
633 | va_start(argp, fmt)__builtin_va_start(argp, fmt); | ||||
634 | addinfo(L, luaO_pushvfstring(L, fmt, argp)); | ||||
| |||||
635 | va_end(argp)__builtin_va_end(argp); | ||||
636 | luaG_errormsg(L); | ||||
637 | } |