Line | Branch | Decision | Exec | Source |
---|---|---|---|---|
1 | /* | |||
2 | ** $Id: ldebug.c $ | |||
3 | ** Debug Interface | |||
4 | ** See Copyright Notice in lua.h | |||
5 | */ | |||
6 | ||||
7 | #define ldebug_c | |||
8 | #define LUA_CORE | |||
9 | ||||
10 | #include "lprefix.h" | |||
11 | ||||
12 | ||||
13 | #include <stdarg.h> | |||
14 | #include <stddef.h> | |||
15 | #include <string.h> | |||
16 | ||||
17 | #include "lua.h" | |||
18 | ||||
19 | #include "lapi.h" | |||
20 | #include "lcode.h" | |||
21 | #include "ldebug.h" | |||
22 | #include "ldo.h" | |||
23 | #include "lfunc.h" | |||
24 | #include "lobject.h" | |||
25 | #include "lopcodes.h" | |||
26 | #include "lstate.h" | |||
27 | #include "lstring.h" | |||
28 | #include "ltable.h" | |||
29 | #include "ltm.h" | |||
30 | #include "lvm.h" | |||
31 | ||||
32 | ||||
33 | ||||
34 | #define noLuaClosure(f) ((f) == NULL || (f)->c.tt == LUA_VCCL) | |||
35 | ||||
36 | ||||
37 | static const char *funcnamefromcall (lua_State *L, CallInfo *ci, | |||
38 | const char **name); | |||
39 | ||||
40 | ||||
41 | 10 | static int currentpc (CallInfo *ci) { | ||
42 | lua_assert(isLua(ci)); | |||
43 | 10 | return pcRel(ci->u.l.savedpc, ci_func(ci)->p); | ||
44 | } | |||
45 | ||||
46 | ||||
47 | /* | |||
48 | ** Get a "base line" to find the line corresponding to an instruction. | |||
49 | ** Base lines are regularly placed at MAXIWTHABS intervals, so usually | |||
50 | ** an integer division gets the right place. When the source file has | |||
51 | ** large sequences of empty/comment lines, it may need extra entries, | |||
52 | ** so the original estimate needs a correction. | |||
53 | ** If the original estimate is -1, the initial 'if' ensures that the | |||
54 | ** 'while' will run at least once. | |||
55 | ** The assertion that the estimate is a lower bound for the correct base | |||
56 | ** is valid as long as the debug info has been generated with the same | |||
57 | ** value for MAXIWTHABS or smaller. (Previous releases use a little | |||
58 | ** smaller value.) | |||
59 | */ | |||
60 | 6 | static int getbaseline (const Proto *f, int pc, int *basepc) { | ||
61 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
1/2✓ Decision 'true' taken 6 times.
✗ Decision 'false' not taken.
|
6 | if (f->sizeabslineinfo == 0 || pc < f->abslineinfo[0].pc) { |
62 | 6 | *basepc = -1; /* start from the beginning */ | ||
63 | 6 | return f->linedefined; | ||
64 | } | |||
65 | else { | |||
66 | ✗ | int i = cast_uint(pc) / MAXIWTHABS - 1; /* get an estimate */ | ||
67 | /* estimate must be a lower bound of the correct base */ | |||
68 | lua_assert(i < 0 || | |||
69 | (i < f->sizeabslineinfo && f->abslineinfo[i].pc <= pc)); | |||
70 | ✗ | while (i + 1 < f->sizeabslineinfo && pc >= f->abslineinfo[i + 1].pc) | ||
71 | ✗ | i++; /* low estimate; adjust it */ | ||
72 | ✗ | *basepc = f->abslineinfo[i].pc; | ||
73 | ✗ | return f->abslineinfo[i].line; | ||
74 | } | |||
75 | } | |||
76 | ||||
77 | ||||
78 | /* | |||
79 | ** Get the line corresponding to instruction 'pc' in function 'f'; | |||
80 | ** first gets a base line and from there does the increments until | |||
81 | ** the desired instruction. | |||
82 | */ | |||
83 | 6 | int luaG_getfuncline (const Proto *f, int pc) { | ||
84 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
|
1/2✗ Decision 'true' not taken.
✓ Decision 'false' taken 6 times.
|
6 | if (f->lineinfo == NULL) /* no debug information? */ |
85 | ✗ | return -1; | ||
86 | else { | |||
87 | int basepc; | |||
88 | 6 | int baseline = getbaseline(f, pc, &basepc); | ||
89 |
2/2✓ Branch 0 taken 70 times.
✓ Branch 1 taken 6 times.
|
2/2✓ Decision 'true' taken 70 times.
✓ Decision 'false' taken 6 times.
|
76 | while (basepc++ < pc) { /* walk until given instruction */ |
90 | lua_assert(f->lineinfo[basepc] != ABSLINEINFO); | |||
91 | 70 | baseline += f->lineinfo[basepc]; /* correct line */ | ||
92 | } | |||
93 | 6 | return baseline; | ||
94 | } | |||
95 | } | |||
96 | ||||
97 | ||||
98 | 6 | static int getcurrentline (CallInfo *ci) { | ||
99 | 6 | return luaG_getfuncline(ci_func(ci)->p, currentpc(ci)); | ||
100 | } | |||
101 | ||||
102 | ||||
103 | /* | |||
104 | ** Set 'trap' for all active Lua frames. | |||
105 | ** This function can be called during a signal, under "reasonable" | |||
106 | ** assumptions. A new 'ci' is completely linked in the list before it | |||
107 | ** becomes part of the "active" list, and we assume that pointers are | |||
108 | ** atomic; see comment in next function. | |||
109 | ** (A compiler doing interprocedural optimizations could, theoretically, | |||
110 | ** reorder memory writes in such a way that the list could be | |||
111 | ** temporarily broken while inserting a new element. We simply assume it | |||
112 | ** has no good reasons to do that.) | |||
113 | */ | |||
114 | ✗ | static void settraps (CallInfo *ci) { | ||
115 | ✗ | for (; ci != NULL; ci = ci->previous) | ||
116 | ✗ | if (isLua(ci)) | ||
117 | ✗ | ci->u.l.trap = 1; | ||
118 | ✗ | } | ||
119 | ||||
120 | ||||
121 | /* | |||
122 | ** This function can be called during a signal, under "reasonable" | |||
123 | ** assumptions. | |||
124 | ** Fields 'basehookcount' and 'hookcount' (set by 'resethookcount') | |||
125 | ** are for debug only, and it is no problem if they get arbitrary | |||
126 | ** values (causes at most one wrong hook call). 'hookmask' is an atomic | |||
127 | ** value. We assume that pointers are atomic too (e.g., gcc ensures that | |||
128 | ** for all platforms where it runs). Moreover, 'hook' is always checked | |||
129 | ** before being called (see 'luaD_hook'). | |||
130 | */ | |||
131 | ✗ | LUA_API void lua_sethook (lua_State *L, lua_Hook func, int mask, int count) { | ||
132 | ✗ | if (func == NULL || mask == 0) { /* turn off hooks? */ | ||
133 | ✗ | mask = 0; | ||
134 | ✗ | func = NULL; | ||
135 | } | |||
136 | ✗ | L->hook = func; | ||
137 | ✗ | L->basehookcount = count; | ||
138 | ✗ | resethookcount(L); | ||
139 | ✗ | L->hookmask = cast_byte(mask); | ||
140 | ✗ | if (mask) | ||
141 | ✗ | settraps(L->ci); /* to trace inside 'luaV_execute' */ | ||
142 | ✗ | } | ||
143 | ||||
144 | ||||
145 | ✗ | LUA_API lua_Hook lua_gethook (lua_State *L) { | ||
146 | ✗ | return L->hook; | ||
147 | } | |||
148 | ||||
149 | ||||
150 | ✗ | LUA_API int lua_gethookmask (lua_State *L) { | ||
151 | ✗ | return L->hookmask; | ||
152 | } | |||
153 | ||||
154 | ||||
155 | ✗ | LUA_API int lua_gethookcount (lua_State *L) { | ||
156 | ✗ | return L->basehookcount; | ||
157 | } | |||
158 | ||||
159 | ||||
160 | 10 | LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar) { | ||
161 | int status; | |||
162 | CallInfo *ci; | |||
163 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
|
1/2✗ Decision 'true' not taken.
✓ Decision 'false' taken 10 times.
|
10 | if (level < 0) return 0; /* invalid (negative) level */ |
164 | lua_lock(L); | |||
165 |
3/4✓ Branch 0 taken 6 times.
✓ Branch 1 taken 10 times.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
|
0/1? Decision couldn't be analyzed.
|
16 | for (ci = L->ci; level > 0 && ci != &L->base_ci; ci = ci->previous) |
166 | 6 | level--; | ||
167 |
2/4✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 10 times.
✗ Branch 3 not taken.
|
1/2✓ Decision 'true' taken 10 times.
✗ Decision 'false' not taken.
|
10 | if (level == 0 && ci != &L->base_ci) { /* level found? */ |
168 | 10 | status = 1; | ||
169 | 10 | ar->i_ci = ci; | ||
170 | } | |||
171 | ✗ | else status = 0; /* no such level */ | ||
172 | lua_unlock(L); | |||
173 | 10 | return status; | ||
174 | } | |||
175 | ||||
176 | ||||
177 | 4 | static const char *upvalname (const Proto *p, int uv) { | ||
178 | 4 | TString *s = check_exp(uv < p->sizeupvalues, p->upvalues[uv].name); | ||
179 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
1/2✗ Decision 'true' not taken.
✓ Decision 'false' taken 4 times.
|
4 | if (s == NULL) return "?"; |
180 | 4 | else return getstr(s); | ||
181 | } | |||
182 | ||||
183 | ||||
184 | ✗ | static const char *findvararg (CallInfo *ci, int n, StkId *pos) { | ||
185 | ✗ | if (clLvalue(s2v(ci->func.p))->p->is_vararg) { | ||
186 | ✗ | int nextra = ci->u.l.nextraargs; | ||
187 | ✗ | if (n >= -nextra) { /* 'n' is negative */ | ||
188 | ✗ | *pos = ci->func.p - nextra - (n + 1); | ||
189 | ✗ | return "(vararg)"; /* generic name for any vararg */ | ||
190 | } | |||
191 | } | |||
192 | ✗ | return NULL; /* no such vararg */ | ||
193 | } | |||
194 | ||||
195 | ||||
196 | ✗ | const char *luaG_findlocal (lua_State *L, CallInfo *ci, int n, StkId *pos) { | ||
197 | ✗ | StkId base = ci->func.p + 1; | ||
198 | ✗ | const char *name = NULL; | ||
199 | ✗ | if (isLua(ci)) { | ||
200 | ✗ | if (n < 0) /* access to vararg values? */ | ||
201 | ✗ | return findvararg(ci, n, pos); | ||
202 | else | |||
203 | ✗ | name = luaF_getlocalname(ci_func(ci)->p, n, currentpc(ci)); | ||
204 | } | |||
205 | ✗ | if (name == NULL) { /* no 'standard' name? */ | ||
206 | ✗ | StkId limit = (ci == L->ci) ? L->top.p : ci->next->func.p; | ||
207 | ✗ | if (limit - base >= n && n > 0) { /* is 'n' inside 'ci' stack? */ | ||
208 | /* generic name for any valid slot */ | |||
209 | ✗ | name = isLua(ci) ? "(temporary)" : "(C temporary)"; | ||
210 | } | |||
211 | else | |||
212 | ✗ | return NULL; /* no name */ | ||
213 | } | |||
214 | ✗ | if (pos) | ||
215 | ✗ | *pos = base + (n - 1); | ||
216 | ✗ | return name; | ||
217 | } | |||
218 | ||||
219 | ||||
220 | ✗ | LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n) { | ||
221 | const char *name; | |||
222 | lua_lock(L); | |||
223 | ✗ | if (ar == NULL) { /* information about non-active function? */ | ||
224 | ✗ | if (!isLfunction(s2v(L->top.p - 1))) /* not a Lua function? */ | ||
225 | ✗ | name = NULL; | ||
226 | else /* consider live variables at function start (parameters) */ | |||
227 | ✗ | name = luaF_getlocalname(clLvalue(s2v(L->top.p - 1))->p, n, 0); | ||
228 | } | |||
229 | else { /* active function; get information through 'ar' */ | |||
230 | ✗ | StkId pos = NULL; /* to avoid warnings */ | ||
231 | ✗ | name = luaG_findlocal(L, ar->i_ci, n, &pos); | ||
232 | ✗ | if (name) { | ||
233 | ✗ | setobjs2s(L, L->top.p, pos); | ||
234 | ✗ | api_incr_top(L); | ||
235 | } | |||
236 | } | |||
237 | lua_unlock(L); | |||
238 | ✗ | return name; | ||
239 | } | |||
240 | ||||
241 | ||||
242 | ✗ | LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n) { | ||
243 | ✗ | StkId pos = NULL; /* to avoid warnings */ | ||
244 | const char *name; | |||
245 | lua_lock(L); | |||
246 | ✗ | name = luaG_findlocal(L, ar->i_ci, n, &pos); | ||
247 | ✗ | if (name) { | ||
248 | ✗ | setobjs2s(L, pos, L->top.p - 1); | ||
249 | ✗ | L->top.p--; /* pop value */ | ||
250 | } | |||
251 | lua_unlock(L); | |||
252 | ✗ | return name; | ||
253 | } | |||
254 | ||||
255 | ||||
256 | 6 | static void funcinfo (lua_Debug *ar, Closure *cl) { | ||
257 |
2/4✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6 times.
|
1/2✗ Decision 'true' not taken.
✓ Decision 'false' taken 6 times.
|
6 | if (noLuaClosure(cl)) { |
258 | ✗ | ar->source = "=[C]"; | ||
259 | ✗ | ar->srclen = LL("=[C]"); | ||
260 | ✗ | ar->linedefined = -1; | ||
261 | ✗ | ar->lastlinedefined = -1; | ||
262 | ✗ | ar->what = "C"; | ||
263 | } | |||
264 | else { | |||
265 | 6 | const Proto *p = cl->l.p; | ||
266 |
1/2✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
|
1/2✓ Decision 'true' taken 6 times.
✗ Decision 'false' not taken.
|
6 | if (p->source) { |
267 | 6 | ar->source = getstr(p->source); | ||
268 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 1 time.
|
6 | ar->srclen = tsslen(p->source); | |
269 | } | |||
270 | else { | |||
271 | ✗ | ar->source = "=?"; | ||
272 | ✗ | ar->srclen = LL("=?"); | ||
273 | } | |||
274 | 6 | ar->linedefined = p->linedefined; | ||
275 | 6 | ar->lastlinedefined = p->lastlinedefined; | ||
276 |
1/2✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
|
6 | ar->what = (ar->linedefined == 0) ? "main" : "Lua"; | |
277 | } | |||
278 | 6 | luaO_chunkid(ar->short_src, ar->source, ar->srclen); | ||
279 | 6 | } | ||
280 | ||||
281 | ||||
282 | ✗ | static int nextline (const Proto *p, int currentline, int pc) { | ||
283 | ✗ | if (p->lineinfo[pc] != ABSLINEINFO) | ||
284 | ✗ | return currentline + p->lineinfo[pc]; | ||
285 | else | |||
286 | ✗ | return luaG_getfuncline(p, pc); | ||
287 | } | |||
288 | ||||
289 | ||||
290 | ✗ | static void collectvalidlines (lua_State *L, Closure *f) { | ||
291 | ✗ | if (noLuaClosure(f)) { | ||
292 | ✗ | setnilvalue(s2v(L->top.p)); | ||
293 | ✗ | api_incr_top(L); | ||
294 | } | |||
295 | else { | |||
296 | int i; | |||
297 | TValue v; | |||
298 | ✗ | const Proto *p = f->l.p; | ||
299 | ✗ | int currentline = p->linedefined; | ||
300 | ✗ | Table *t = luaH_new(L); /* new table to store active lines */ | ||
301 | ✗ | sethvalue2s(L, L->top.p, t); /* push it on stack */ | ||
302 | ✗ | api_incr_top(L); | ||
303 | ✗ | setbtvalue(&v); /* boolean 'true' to be the value of all indices */ | ||
304 | ✗ | if (!p->is_vararg) /* regular function? */ | ||
305 | ✗ | i = 0; /* consider all instructions */ | ||
306 | else { /* vararg function */ | |||
307 | lua_assert(GET_OPCODE(p->code[0]) == OP_VARARGPREP); | |||
308 | ✗ | currentline = nextline(p, currentline, 0); | ||
309 | ✗ | i = 1; /* skip first instruction (OP_VARARGPREP) */ | ||
310 | } | |||
311 | ✗ | for (; i < p->sizelineinfo; i++) { /* for each instruction */ | ||
312 | ✗ | currentline = nextline(p, currentline, i); /* get its line */ | ||
313 | ✗ | luaH_setint(L, t, currentline, &v); /* table[line] = true */ | ||
314 | } | |||
315 | } | |||
316 | ✗ | } | ||
317 | ||||
318 | ||||
319 | 4 | static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name) { | ||
320 | /* calling function is a known function? */ | |||
321 |
2/4✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
|
1/2✓ Decision 'true' taken 4 times.
✗ Decision 'false' not taken.
|
4 | if (ci != NULL && !(ci->callstatus & CIST_TAIL)) |
322 | 4 | return funcnamefromcall(L, ci->previous, name); | ||
323 | ✗ | else return NULL; /* no way to find a name */ | ||
324 | } | |||
325 | ||||
326 | ||||
327 | 10 | static int auxgetinfo (lua_State *L, const char *what, lua_Debug *ar, | ||
328 | Closure *f, CallInfo *ci) { | |||
329 | 10 | int status = 1; | ||
330 |
2/2✓ Branch 0 taken 16 times.
✓ Branch 1 taken 10 times.
|
2/2✓ Decision 'true' taken 16 times.
✓ Decision 'false' taken 10 times.
|
26 | for (; *what; what++) { |
331 |
3/8✓ Branch 0 taken 6 times.
✓ Branch 1 taken 6 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 4 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
16 | switch (*what) { | |
332 |
1/1✓ Decision 'true' taken 6 times.
|
6 | case 'S': { | |
333 | 6 | funcinfo(ar, f); | ||
334 | 6 | break; | ||
335 | } | |||
336 |
1/1✓ Decision 'true' taken 6 times.
|
6 | case 'l': { | |
337 |
2/4✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
|
6 | ar->currentline = (ci && isLua(ci)) ? getcurrentline(ci) : -1; | |
338 | 6 | break; | ||
339 | } | |||
340 | ✗ | case 'u': { | ||
341 | ✗ | ar->nups = (f == NULL) ? 0 : f->c.nupvalues; | ||
342 | ✗ | if (noLuaClosure(f)) { | ||
343 | ✗ | ar->isvararg = 1; | ||
344 | ✗ | ar->nparams = 0; | ||
345 | } | |||
346 | else { | |||
347 | ✗ | ar->isvararg = f->l.p->is_vararg; | ||
348 | ✗ | ar->nparams = f->l.p->numparams; | ||
349 | } | |||
350 | ✗ | break; | ||
351 | } | |||
352 | ✗ | case 't': { | ||
353 | ✗ | ar->istailcall = (ci) ? ci->callstatus & CIST_TAIL : 0; | ||
354 | ✗ | break; | ||
355 | } | |||
356 |
1/1✓ Decision 'true' taken 4 times.
|
4 | case 'n': { | |
357 | 4 | ar->namewhat = getfuncname(L, ci, &ar->name); | ||
358 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
1/2✗ Decision 'true' not taken.
✓ Decision 'false' taken 4 times.
|
4 | if (ar->namewhat == NULL) { |
359 | ✗ | ar->namewhat = ""; /* not found */ | ||
360 | ✗ | ar->name = NULL; | ||
361 | } | |||
362 | 4 | break; | ||
363 | } | |||
364 | ✗ | case 'r': { | ||
365 | ✗ | if (ci == NULL || !(ci->callstatus & CIST_TRAN)) | ||
366 | ✗ | ar->ftransfer = ar->ntransfer = 0; | ||
367 | else { | |||
368 | ✗ | ar->ftransfer = ci->u2.transferinfo.ftransfer; | ||
369 | ✗ | ar->ntransfer = ci->u2.transferinfo.ntransfer; | ||
370 | } | |||
371 | ✗ | break; | ||
372 | } | |||
373 | ✗ | case 'L': | ||
374 | case 'f': /* handled by lua_getinfo */ | |||
375 | ✗ | break; | ||
376 | ✗ | default: status = 0; /* invalid option */ | ||
377 | } | |||
378 | } | |||
379 | 10 | return status; | ||
380 | } | |||
381 | ||||
382 | ||||
383 | 10 | LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar) { | ||
384 | int status; | |||
385 | Closure *cl; | |||
386 | CallInfo *ci; | |||
387 | TValue *func; | |||
388 | lua_lock(L); | |||
389 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
|
1/2✗ Decision 'true' not taken.
✓ Decision 'false' taken 10 times.
|
10 | if (*what == '>') { |
390 | ✗ | ci = NULL; | ||
391 | ✗ | func = s2v(L->top.p - 1); | ||
392 | api_check(L, ttisfunction(func), "function expected"); | |||
393 | ✗ | what++; /* skip the '>' */ | ||
394 | ✗ | L->top.p--; /* pop function */ | ||
395 | } | |||
396 | else { | |||
397 | 10 | ci = ar->i_ci; | ||
398 | 10 | func = s2v(ci->func.p); | ||
399 | lua_assert(ttisfunction(func)); | |||
400 | } | |||
401 |
3/4✓ Branch 0 taken 4 times.
✓ Branch 1 taken 6 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 4 times.
|
10 | cl = ttisclosure(func) ? clvalue(func) : NULL; | |
402 | 10 | status = auxgetinfo(L, what, ar, cl, ci); | ||
403 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
|
1/2✗ Decision 'true' not taken.
✓ Decision 'false' taken 10 times.
|
10 | if (strchr(what, 'f')) { |
404 | ✗ | setobj2s(L, L->top.p, func); | ||
405 | ✗ | api_incr_top(L); | ||
406 | } | |||
407 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
|
1/2✗ Decision 'true' not taken.
✓ Decision 'false' taken 10 times.
|
10 | if (strchr(what, 'L')) |
408 | ✗ | collectvalidlines(L, cl); | ||
409 | lua_unlock(L); | |||
410 | 10 | return status; | ||
411 | } | |||
412 | ||||
413 | ||||
414 | /* | |||
415 | ** {====================================================== | |||
416 | ** Symbolic Execution | |||
417 | ** ======================================================= | |||
418 | */ | |||
419 | ||||
420 | static const char *getobjname (const Proto *p, int lastpc, int reg, | |||
421 | const char **name); | |||
422 | ||||
423 | ||||
424 | /* | |||
425 | ** Find a "name" for the constant 'c'. | |||
426 | */ | |||
427 | 4 | static void kname (const Proto *p, int c, const char **name) { | ||
428 | 4 | TValue *kvalue = &p->k[c]; | ||
429 |
1/2✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
|
4 | *name = (ttisstring(kvalue)) ? svalue(kvalue) : "?"; | |
430 | 4 | } | ||
431 | ||||
432 | ||||
433 | /* | |||
434 | ** Find a "name" for the register 'c'. | |||
435 | */ | |||
436 | ✗ | static void rname (const Proto *p, int pc, int c, const char **name) { | ||
437 | ✗ | const char *what = getobjname(p, pc, c, name); /* search for 'c' */ | ||
438 | ✗ | if (!(what && *what == 'c')) /* did not find a constant name? */ | ||
439 | ✗ | *name = "?"; | ||
440 | ✗ | } | ||
441 | ||||
442 | ||||
443 | /* | |||
444 | ** Find a "name" for a 'C' value in an RK instruction. | |||
445 | */ | |||
446 | ✗ | static void rkname (const Proto *p, int pc, Instruction i, const char **name) { | ||
447 | ✗ | int c = GETARG_C(i); /* key index */ | ||
448 | ✗ | if (GETARG_k(i)) /* is 'c' a constant? */ | ||
449 | ✗ | kname(p, c, name); | ||
450 | else /* 'c' is a register */ | |||
451 | ✗ | rname(p, pc, c, name); | ||
452 | ✗ | } | ||
453 | ||||
454 | ||||
455 | 8 | static int filterpc (int pc, int jmptarget) { | ||
456 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
|
1/2✗ Decision 'true' not taken.
✓ Decision 'false' taken 8 times.
|
8 | if (pc < jmptarget) /* is code conditional (inside a jump)? */ |
457 | ✗ | return -1; /* cannot know who sets that register */ | ||
458 | 8 | else return pc; /* current position sets that register */ | ||
459 | } | |||
460 | ||||
461 | ||||
462 | /* | |||
463 | ** Try to find last instruction before 'lastpc' that modified register 'reg'. | |||
464 | */ | |||
465 | 4 | static int findsetreg (const Proto *p, int lastpc, int reg) { | ||
466 | int pc; | |||
467 | 4 | int setreg = -1; /* keep last instruction that changed 'reg' */ | ||
468 | 4 | int jmptarget = 0; /* any code before this address is conditional */ | ||
469 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
1/2✗ Decision 'true' not taken.
✓ Decision 'false' taken 4 times.
|
4 | if (testMMMode(GET_OPCODE(p->code[lastpc]))) |
470 | ✗ | lastpc--; /* previous instruction was not actually executed */ | ||
471 |
2/2✓ Branch 0 taken 33 times.
✓ Branch 1 taken 4 times.
|
2/2✓ Decision 'true' taken 33 times.
✓ Decision 'false' taken 4 times.
|
37 | for (pc = 0; pc < lastpc; pc++) { |
472 | 33 | Instruction i = p->code[pc]; | ||
473 | 33 | OpCode op = GET_OPCODE(i); | ||
474 | 33 | int a = GETARG_A(i); | ||
475 | int change; /* true if current instruction changed 'reg' */ | |||
476 |
1/5✗ Branch 0 not taken.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 33 times.
|
33 | switch (op) { | |
477 | ✗ | case OP_LOADNIL: { /* set registers from 'a' to 'a+b' */ | ||
478 | ✗ | int b = GETARG_B(i); | ||
479 | ✗ | change = (a <= reg && reg <= a + b); | ||
480 | ✗ | break; | ||
481 | } | |||
482 | ✗ | case OP_TFORCALL: { /* affect all regs above its base */ | ||
483 | ✗ | change = (reg >= a + 2); | ||
484 | ✗ | break; | ||
485 | } | |||
486 | ✗ | case OP_CALL: | ||
487 | case OP_TAILCALL: { /* affect all registers above base */ | |||
488 | ✗ | change = (reg >= a); | ||
489 | ✗ | break; | ||
490 | } | |||
491 | ✗ | case OP_JMP: { /* doesn't change registers, but changes 'jmptarget' */ | ||
492 | ✗ | int b = GETARG_sJ(i); | ||
493 | ✗ | int dest = pc + 1 + b; | ||
494 | /* jump does not skip 'lastpc' and is larger than current one? */ | |||
495 | ✗ | if (dest <= lastpc && dest > jmptarget) | ||
496 | ✗ | jmptarget = dest; /* update 'jmptarget' */ | ||
497 | ✗ | change = 0; | ||
498 | ✗ | break; | ||
499 | } | |||
500 |
1/1✓ Decision 'true' taken 33 times.
|
33 | default: /* any instruction that sets A */ | |
501 |
4/4✓ Branch 0 taken 27 times.
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 8 times.
✓ Branch 3 taken 19 times.
|
33 | change = (testAMode(op) && reg == a); | |
502 | 33 | break; | ||
503 | } | |||
504 |
2/2✓ Branch 0 taken 8 times.
✓ Branch 1 taken 25 times.
|
2/2✓ Decision 'true' taken 8 times.
✓ Decision 'false' taken 25 times.
|
33 | if (change) |
505 | 8 | setreg = filterpc(pc, jmptarget); | ||
506 | } | |||
507 | 4 | return setreg; | ||
508 | } | |||
509 | ||||
510 | ||||
511 | /* | |||
512 | ** Check whether table being indexed by instruction 'i' is the | |||
513 | ** environment '_ENV' | |||
514 | */ | |||
515 | 4 | static const char *gxf (const Proto *p, int pc, Instruction i, int isup) { | ||
516 | 4 | int t = GETARG_B(i); /* table index */ | ||
517 | const char *name; /* name of indexed variable */ | |||
518 |
1/2✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
|
1/2✓ Decision 'true' taken 4 times.
✗ Decision 'false' not taken.
|
4 | if (isup) /* is an upvalue? */ |
519 | 4 | name = upvalname(p, t); | ||
520 | else | |||
521 | ✗ | getobjname(p, pc, t, &name); | ||
522 |
2/4✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
|
4 | return (name && strcmp(name, LUA_ENV) == 0) ? "global" : "field"; | |
523 | } | |||
524 | ||||
525 | ||||
526 | 4 | static const char *getobjname (const Proto *p, int lastpc, int reg, | ||
527 | const char **name) { | |||
528 | int pc; | |||
529 | 4 | *name = luaF_getlocalname(p, reg + 1, lastpc); | ||
530 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
1/2✗ Decision 'true' not taken.
✓ Decision 'false' taken 4 times.
|
4 | if (*name) /* is a local? */ |
531 | ✗ | return "local"; | ||
532 | /* else try symbolic execution */ | |||
533 | 4 | pc = findsetreg(p, lastpc, reg); | ||
534 |
1/2✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
|
1/2✓ Decision 'true' taken 4 times.
✗ Decision 'false' not taken.
|
4 | if (pc != -1) { /* could find instruction? */ |
535 | 4 | Instruction i = p->code[pc]; | ||
536 | 4 | OpCode op = GET_OPCODE(i); | ||
537 |
1/9✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
|
4 | switch (op) { | |
538 | ✗ | case OP_MOVE: { | ||
539 | ✗ | int b = GETARG_B(i); /* move from 'b' to 'a' */ | ||
540 | ✗ | if (b < GETARG_A(i)) | ||
541 | ✗ | return getobjname(p, pc, b, name); /* get name for 'b' */ | ||
542 | ✗ | break; | ||
543 | } | |||
544 |
1/1✓ Decision 'true' taken 4 times.
|
4 | case OP_GETTABUP: { | |
545 | 4 | int k = GETARG_C(i); /* key index */ | ||
546 | 4 | kname(p, k, name); | ||
547 | 4 | return gxf(p, pc, i, 1); | ||
548 | } | |||
549 | ✗ | case OP_GETTABLE: { | ||
550 | ✗ | int k = GETARG_C(i); /* key index */ | ||
551 | ✗ | rname(p, pc, k, name); | ||
552 | ✗ | return gxf(p, pc, i, 0); | ||
553 | } | |||
554 | ✗ | case OP_GETI: { | ||
555 | ✗ | *name = "integer index"; | ||
556 | ✗ | return "field"; | ||
557 | } | |||
558 | ✗ | case OP_GETFIELD: { | ||
559 | ✗ | int k = GETARG_C(i); /* key index */ | ||
560 | ✗ | kname(p, k, name); | ||
561 | ✗ | return gxf(p, pc, i, 0); | ||
562 | } | |||
563 | ✗ | case OP_GETUPVAL: { | ||
564 | ✗ | *name = upvalname(p, GETARG_B(i)); | ||
565 | ✗ | return "upvalue"; | ||
566 | } | |||
567 | ✗ | case OP_LOADK: | ||
568 | case OP_LOADKX: { | |||
569 | ✗ | int b = (op == OP_LOADK) ? GETARG_Bx(i) | ||
570 | ✗ | : GETARG_Ax(p->code[pc + 1]); | ||
571 | ✗ | if (ttisstring(&p->k[b])) { | ||
572 | ✗ | *name = svalue(&p->k[b]); | ||
573 | ✗ | return "constant"; | ||
574 | } | |||
575 | ✗ | break; | ||
576 | } | |||
577 | ✗ | case OP_SELF: { | ||
578 | ✗ | rkname(p, pc, i, name); | ||
579 | ✗ | return "method"; | ||
580 | } | |||
581 | ✗ | default: break; /* go through to return NULL */ | ||
582 | } | |||
583 | } | |||
584 | ✗ | return NULL; /* could not find reasonable name */ | ||
585 | } | |||
586 | ||||
587 | ||||
588 | /* | |||
589 | ** Try to find a name for a function based on the code that called it. | |||
590 | ** (Only works when function was called by a Lua function.) | |||
591 | ** Returns what the name is (e.g., "for iterator", "method", | |||
592 | ** "metamethod") and sets '*name' to point to the name. | |||
593 | */ | |||
594 | 4 | static const char *funcnamefromcode (lua_State *L, const Proto *p, | ||
595 | int pc, const char **name) { | |||
596 | 4 | TMS tm = (TMS)0; /* (initial value avoids warnings) */ | ||
597 | 4 | Instruction i = p->code[pc]; /* calling instruction */ | ||
598 |
1/14✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
|
4 | switch (GET_OPCODE(i)) { | |
599 |
1/1✓ Decision 'true' taken 4 times.
|
4 | case OP_CALL: | |
600 | case OP_TAILCALL: | |||
601 |
1/1✓ Decision 'true' taken 4 times.
|
4 | return getobjname(p, pc, GETARG_A(i), name); /* get function name */ | |
602 | ✗ | case OP_TFORCALL: { /* for iterator */ | ||
603 | ✗ | *name = "for iterator"; | ||
604 | ✗ | return "for iterator"; | ||
605 | } | |||
606 | /* other instructions can do calls through metamethods */ | |||
607 | ✗ | case OP_SELF: case OP_GETTABUP: case OP_GETTABLE: | ||
608 | case OP_GETI: case OP_GETFIELD: | |||
609 | ✗ | tm = TM_INDEX; | ||
610 | ✗ | break; | ||
611 | ✗ | case OP_SETTABUP: case OP_SETTABLE: case OP_SETI: case OP_SETFIELD: | ||
612 | ✗ | tm = TM_NEWINDEX; | ||
613 | ✗ | break; | ||
614 | ✗ | case OP_MMBIN: case OP_MMBINI: case OP_MMBINK: { | ||
615 | ✗ | tm = cast(TMS, GETARG_C(i)); | ||
616 | ✗ | break; | ||
617 | } | |||
618 | ✗ | case OP_UNM: tm = TM_UNM; break; | ||
619 | ✗ | case OP_BNOT: tm = TM_BNOT; break; | ||
620 | ✗ | case OP_LEN: tm = TM_LEN; break; | ||
621 | ✗ | case OP_CONCAT: tm = TM_CONCAT; break; | ||
622 | ✗ | case OP_EQ: tm = TM_EQ; break; | ||
623 | /* no cases for OP_EQI and OP_EQK, as they don't call metamethods */ | |||
624 | ✗ | case OP_LT: case OP_LTI: case OP_GTI: tm = TM_LT; break; | ||
625 | ✗ | case OP_LE: case OP_LEI: case OP_GEI: tm = TM_LE; break; | ||
626 | ✗ | case OP_CLOSE: case OP_RETURN: tm = TM_CLOSE; break; | ||
627 | ✗ | default: | ||
628 | ✗ | return NULL; /* cannot find a reasonable name */ | ||
629 | } | |||
630 | ✗ | *name = getstr(G(L)->tmname[tm]) + 2; | ||
631 | ✗ | return "metamethod"; | ||
632 | } | |||
633 | ||||
634 | ||||
635 | /* | |||
636 | ** Try to find a name for a function based on how it was called. | |||
637 | */ | |||
638 | 4 | static const char *funcnamefromcall (lua_State *L, CallInfo *ci, | ||
639 | const char **name) { | |||
640 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
1/2✗ Decision 'true' not taken.
✓ Decision 'false' taken 4 times.
|
4 | if (ci->callstatus & CIST_HOOKED) { /* was it called inside a hook? */ |
641 | ✗ | *name = "?"; | ||
642 | ✗ | return "hook"; | ||
643 | } | |||
644 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
1/2✗ Decision 'true' not taken.
✓ Decision 'false' taken 4 times.
|
4 | else if (ci->callstatus & CIST_FIN) { /* was it called as a finalizer? */ |
645 | ✗ | *name = "__gc"; | ||
646 | ✗ | return "metamethod"; /* report it as such */ | ||
647 | } | |||
648 |
1/2✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
|
1/2✓ Decision 'true' taken 4 times.
✗ Decision 'false' not taken.
|
4 | else if (isLua(ci)) |
649 | 4 | return funcnamefromcode(L, ci_func(ci)->p, currentpc(ci), name); | ||
650 | else | |||
651 | ✗ | return NULL; | ||
652 | } | |||
653 | ||||
654 | /* }====================================================== */ | |||
655 | ||||
656 | ||||
657 | ||||
658 | /* | |||
659 | ** Check whether pointer 'o' points to some value in the stack frame of | |||
660 | ** the current function and, if so, returns its index. Because 'o' may | |||
661 | ** not point to a value in this stack, we cannot compare it with the | |||
662 | ** region boundaries (undefined behavior in ISO C). | |||
663 | */ | |||
664 | ✗ | static int instack (CallInfo *ci, const TValue *o) { | ||
665 | int pos; | |||
666 | ✗ | StkId base = ci->func.p + 1; | ||
667 | ✗ | for (pos = 0; base + pos < ci->top.p; pos++) { | ||
668 | ✗ | if (o == s2v(base + pos)) | ||
669 | ✗ | return pos; | ||
670 | } | |||
671 | ✗ | return -1; /* not found */ | ||
672 | } | |||
673 | ||||
674 | ||||
675 | /* | |||
676 | ** Checks whether value 'o' came from an upvalue. (That can only happen | |||
677 | ** with instructions OP_GETTABUP/OP_SETTABUP, which operate directly on | |||
678 | ** upvalues.) | |||
679 | */ | |||
680 | ✗ | static const char *getupvalname (CallInfo *ci, const TValue *o, | ||
681 | const char **name) { | |||
682 | ✗ | LClosure *c = ci_func(ci); | ||
683 | int i; | |||
684 | ✗ | for (i = 0; i < c->nupvalues; i++) { | ||
685 | ✗ | if (c->upvals[i]->v.p == o) { | ||
686 | ✗ | *name = upvalname(c->p, i); | ||
687 | ✗ | return "upvalue"; | ||
688 | } | |||
689 | } | |||
690 | ✗ | return NULL; | ||
691 | } | |||
692 | ||||
693 | ||||
694 | ✗ | static const char *formatvarinfo (lua_State *L, const char *kind, | ||
695 | const char *name) { | |||
696 | ✗ | if (kind == NULL) | ||
697 | ✗ | return ""; /* no information */ | ||
698 | else | |||
699 | ✗ | return luaO_pushfstring(L, " (%s '%s')", kind, name); | ||
700 | } | |||
701 | ||||
702 | /* | |||
703 | ** Build a string with a "description" for the value 'o', such as | |||
704 | ** "variable 'x'" or "upvalue 'y'". | |||
705 | */ | |||
706 | ✗ | static const char *varinfo (lua_State *L, const TValue *o) { | ||
707 | ✗ | CallInfo *ci = L->ci; | ||
708 | ✗ | const char *name = NULL; /* to avoid warnings */ | ||
709 | ✗ | const char *kind = NULL; | ||
710 | ✗ | if (isLua(ci)) { | ||
711 | ✗ | kind = getupvalname(ci, o, &name); /* check whether 'o' is an upvalue */ | ||
712 | ✗ | if (!kind) { /* not an upvalue? */ | ||
713 | ✗ | int reg = instack(ci, o); /* try a register */ | ||
714 | ✗ | if (reg >= 0) /* is 'o' a register? */ | ||
715 | ✗ | kind = getobjname(ci_func(ci)->p, currentpc(ci), reg, &name); | ||
716 | } | |||
717 | } | |||
718 | ✗ | return formatvarinfo(L, kind, name); | ||
719 | } | |||
720 | ||||
721 | ||||
722 | /* | |||
723 | ** Raise a type error | |||
724 | */ | |||
725 | ✗ | static l_noret typeerror (lua_State *L, const TValue *o, const char *op, | ||
726 | const char *extra) { | |||
727 | ✗ | const char *t = luaT_objtypename(L, o); | ||
728 | ✗ | luaG_runerror(L, "attempt to %s a %s value%s", op, t, extra); | ||
729 | } | |||
730 | ||||
731 | ||||
732 | /* | |||
733 | ** Raise a type error with "standard" information about the faulty | |||
734 | ** object 'o' (using 'varinfo'). | |||
735 | */ | |||
736 | ✗ | l_noret luaG_typeerror (lua_State *L, const TValue *o, const char *op) { | ||
737 | ✗ | typeerror(L, o, op, varinfo(L, o)); | ||
738 | } | |||
739 | ||||
740 | ||||
741 | /* | |||
742 | ** Raise an error for calling a non-callable object. Try to find a name | |||
743 | ** for the object based on how it was called ('funcnamefromcall'); if it | |||
744 | ** cannot get a name there, try 'varinfo'. | |||
745 | */ | |||
746 | ✗ | l_noret luaG_callerror (lua_State *L, const TValue *o) { | ||
747 | ✗ | CallInfo *ci = L->ci; | ||
748 | ✗ | const char *name = NULL; /* to avoid warnings */ | ||
749 | ✗ | const char *kind = funcnamefromcall(L, ci, &name); | ||
750 | ✗ | const char *extra = kind ? formatvarinfo(L, kind, name) : varinfo(L, o); | ||
751 | ✗ | typeerror(L, o, "call", extra); | ||
752 | } | |||
753 | ||||
754 | ||||
755 | ✗ | l_noret luaG_forerror (lua_State *L, const TValue *o, const char *what) { | ||
756 | ✗ | luaG_runerror(L, "bad 'for' %s (number expected, got %s)", | ||
757 | what, luaT_objtypename(L, o)); | |||
758 | } | |||
759 | ||||
760 | ||||
761 | ✗ | l_noret luaG_concaterror (lua_State *L, const TValue *p1, const TValue *p2) { | ||
762 | ✗ | if (ttisstring(p1) || cvt2str(p1)) p1 = p2; | ||
763 | ✗ | luaG_typeerror(L, p1, "concatenate"); | ||
764 | } | |||
765 | ||||
766 | ||||
767 | ✗ | l_noret luaG_opinterror (lua_State *L, const TValue *p1, | ||
768 | const TValue *p2, const char *msg) { | |||
769 | ✗ | if (!ttisnumber(p1)) /* first operand is wrong? */ | ||
770 | ✗ | p2 = p1; /* now second is wrong */ | ||
771 | ✗ | luaG_typeerror(L, p2, msg); | ||
772 | } | |||
773 | ||||
774 | ||||
775 | /* | |||
776 | ** Error when both values are convertible to numbers, but not to integers | |||
777 | */ | |||
778 | ✗ | l_noret luaG_tointerror (lua_State *L, const TValue *p1, const TValue *p2) { | ||
779 | lua_Integer temp; | |||
780 | ✗ | if (!luaV_tointegerns(p1, &temp, LUA_FLOORN2I)) | ||
781 | ✗ | p2 = p1; | ||
782 | ✗ | luaG_runerror(L, "number%s has no integer representation", varinfo(L, p2)); | ||
783 | } | |||
784 | ||||
785 | ||||
786 | ✗ | l_noret luaG_ordererror (lua_State *L, const TValue *p1, const TValue *p2) { | ||
787 | ✗ | const char *t1 = luaT_objtypename(L, p1); | ||
788 | ✗ | const char *t2 = luaT_objtypename(L, p2); | ||
789 | ✗ | if (strcmp(t1, t2) == 0) | ||
790 | ✗ | luaG_runerror(L, "attempt to compare two %s values", t1); | ||
791 | else | |||
792 | ✗ | luaG_runerror(L, "attempt to compare %s with %s", t1, t2); | ||
793 | } | |||
794 | ||||
795 | ||||
796 | /* add src:line information to 'msg' */ | |||
797 | 1 | const char *luaG_addinfo (lua_State *L, const char *msg, TString *src, | ||
798 | int line) { | |||
799 | char buff[LUA_IDSIZE]; | |||
800 |
1/2✓ Branch 0 taken 1 time.
✗ Branch 1 not taken.
|
1/2✓ Decision 'true' taken 1 time.
✗ Decision 'false' not taken.
|
1 | if (src) |
801 |
1/2✓ Branch 0 taken 1 time.
✗ Branch 1 not taken.
|
1 | luaO_chunkid(buff, getstr(src), tsslen(src)); | |
802 | else { /* no source available; use "?" instead */ | |||
803 | ✗ | buff[0] = '?'; buff[1] = '\0'; | ||
804 | } | |||
805 | 1 | return luaO_pushfstring(L, "%s:%d: %s", buff, line, msg); | ||
806 | } | |||
807 | ||||
808 | ||||
809 | 6 | l_noret luaG_errormsg (lua_State *L) { | ||
810 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
|
1/2✗ Decision 'true' not taken.
✓ Decision 'false' taken 6 times.
|
6 | if (L->errfunc != 0) { /* is there an error handling function? */ |
811 | ✗ | StkId errfunc = restorestack(L, L->errfunc); | ||
812 | lua_assert(ttisfunction(s2v(errfunc))); | |||
813 | ✗ | setobjs2s(L, L->top.p, L->top.p - 1); /* move argument */ | ||
814 | ✗ | setobjs2s(L, L->top.p - 1, errfunc); /* push function */ | ||
815 | ✗ | L->top.p++; /* assume EXTRA_STACK */ | ||
816 | ✗ | luaD_callnoyield(L, L->top.p - 2, 1); /* call it */ | ||
817 | } | |||
818 | 6 | luaD_throw(L, LUA_ERRRUN); | ||
819 | } | |||
820 | ||||
821 | ||||
822 | ✗ | l_noret luaG_runerror (lua_State *L, const char *fmt, ...) { | ||
823 | ✗ | CallInfo *ci = L->ci; | ||
824 | const char *msg; | |||
825 | va_list argp; | |||
826 | ✗ | luaC_checkGC(L); /* error message uses memory */ | ||
827 | ✗ | va_start(argp, fmt); | ||
828 | ✗ | msg = luaO_pushvfstring(L, fmt, argp); /* format message */ | ||
829 | ✗ | va_end(argp); | ||
830 | ✗ | if (isLua(ci)) { /* if Lua function, add source:line information */ | ||
831 | ✗ | luaG_addinfo(L, msg, ci_func(ci)->p->source, getcurrentline(ci)); | ||
832 | ✗ | setobjs2s(L, L->top.p - 2, L->top.p - 1); /* remove 'msg' */ | ||
833 | ✗ | L->top.p--; | ||
834 | } | |||
835 | ✗ | luaG_errormsg(L); | ||
836 | } | |||
837 | ||||
838 | ||||
839 | /* | |||
840 | ** Check whether new instruction 'newpc' is in a different line from | |||
841 | ** previous instruction 'oldpc'. More often than not, 'newpc' is only | |||
842 | ** one or a few instructions after 'oldpc' (it must be after, see | |||
843 | ** caller), so try to avoid calling 'luaG_getfuncline'. If they are | |||
844 | ** too far apart, there is a good chance of a ABSLINEINFO in the way, | |||
845 | ** so it goes directly to 'luaG_getfuncline'. | |||
846 | */ | |||
847 | ✗ | static int changedline (const Proto *p, int oldpc, int newpc) { | ||
848 | ✗ | if (p->lineinfo == NULL) /* no debug information? */ | ||
849 | ✗ | return 0; | ||
850 | ✗ | if (newpc - oldpc < MAXIWTHABS / 2) { /* not too far apart? */ | ||
851 | ✗ | int delta = 0; /* line difference */ | ||
852 | ✗ | int pc = oldpc; | ||
853 | ✗ | for (;;) { | ||
854 | ✗ | int lineinfo = p->lineinfo[++pc]; | ||
855 | ✗ | if (lineinfo == ABSLINEINFO) | ||
856 | ✗ | break; /* cannot compute delta; fall through */ | ||
857 | ✗ | delta += lineinfo; | ||
858 | ✗ | if (pc == newpc) | ||
859 | ✗ | return (delta != 0); /* delta computed successfully */ | ||
860 | } | |||
861 | } | |||
862 | /* either instructions are too far apart or there is an absolute line | |||
863 | info in the way; compute line difference explicitly */ | |||
864 | ✗ | return (luaG_getfuncline(p, oldpc) != luaG_getfuncline(p, newpc)); | ||
865 | } | |||
866 | ||||
867 | ||||
868 | /* | |||
869 | ** Traces the execution of a Lua function. Called before the execution | |||
870 | ** of each opcode, when debug is on. 'L->oldpc' stores the last | |||
871 | ** instruction traced, to detect line changes. When entering a new | |||
872 | ** function, 'npci' will be zero and will test as a new line whatever | |||
873 | ** the value of 'oldpc'. Some exceptional conditions may return to | |||
874 | ** a function without setting 'oldpc'. In that case, 'oldpc' may be | |||
875 | ** invalid; if so, use zero as a valid value. (A wrong but valid 'oldpc' | |||
876 | ** at most causes an extra call to a line hook.) | |||
877 | ** This function is not "Protected" when called, so it should correct | |||
878 | ** 'L->top.p' before calling anything that can run the GC. | |||
879 | */ | |||
880 | ✗ | int luaG_traceexec (lua_State *L, const Instruction *pc) { | ||
881 | ✗ | CallInfo *ci = L->ci; | ||
882 | ✗ | lu_byte mask = L->hookmask; | ||
883 | ✗ | const Proto *p = ci_func(ci)->p; | ||
884 | int counthook; | |||
885 | ✗ | if (!(mask & (LUA_MASKLINE | LUA_MASKCOUNT))) { /* no hooks? */ | ||
886 | ✗ | ci->u.l.trap = 0; /* don't need to stop again */ | ||
887 | ✗ | return 0; /* turn off 'trap' */ | ||
888 | } | |||
889 | ✗ | pc++; /* reference is always next instruction */ | ||
890 | ✗ | ci->u.l.savedpc = pc; /* save 'pc' */ | ||
891 | ✗ | counthook = (--L->hookcount == 0 && (mask & LUA_MASKCOUNT)); | ||
892 | ✗ | if (counthook) | ||
893 | ✗ | resethookcount(L); /* reset count */ | ||
894 | ✗ | else if (!(mask & LUA_MASKLINE)) | ||
895 | ✗ | return 1; /* no line hook and count != 0; nothing to be done now */ | ||
896 | ✗ | if (ci->callstatus & CIST_HOOKYIELD) { /* called hook last time? */ | ||
897 | ✗ | ci->callstatus &= ~CIST_HOOKYIELD; /* erase mark */ | ||
898 | ✗ | return 1; /* do not call hook again (VM yielded, so it did not move) */ | ||
899 | } | |||
900 | ✗ | if (!isIT(*(ci->u.l.savedpc - 1))) /* top not being used? */ | ||
901 | ✗ | L->top.p = ci->top.p; /* correct top */ | ||
902 | ✗ | if (counthook) | ||
903 | ✗ | luaD_hook(L, LUA_HOOKCOUNT, -1, 0, 0); /* call count hook */ | ||
904 | ✗ | if (mask & LUA_MASKLINE) { | ||
905 | /* 'L->oldpc' may be invalid; use zero in this case */ | |||
906 | ✗ | int oldpc = (L->oldpc < p->sizecode) ? L->oldpc : 0; | ||
907 | ✗ | int npci = pcRel(pc, p); | ||
908 | ✗ | if (npci <= oldpc || /* call hook when jump back (loop), */ | ||
909 | ✗ | changedline(p, oldpc, npci)) { /* or when enter new line */ | ||
910 | ✗ | int newline = luaG_getfuncline(p, npci); | ||
911 | ✗ | luaD_hook(L, LUA_HOOKLINE, newline, 0, 0); /* call line hook */ | ||
912 | } | |||
913 | ✗ | L->oldpc = npci; /* 'pc' of last call to line hook */ | ||
914 | } | |||
915 | ✗ | if (L->status == LUA_YIELD) { /* did hook yield? */ | ||
916 | ✗ | if (counthook) | ||
917 | ✗ | L->hookcount = 1; /* undo decrement to zero */ | ||
918 | ✗ | ci->u.l.savedpc--; /* undo increment (resume will increment it again) */ | ||
919 | ✗ | ci->callstatus |= CIST_HOOKYIELD; /* mark that it yielded */ | ||
920 | ✗ | luaD_throw(L, LUA_YIELD); | ||
921 | } | |||
922 | ✗ | return 1; /* keep 'trap' on */ | ||
923 | } | |||
924 | ||||
925 |