| 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 |