9
3

ldebug.c 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698
  1. /*
  2. ** $Id: ldebug.c,v 2.121 2016/10/19 12:32:10 roberto Exp $
  3. ** Debug Interface
  4. ** See Copyright Notice in lua.h
  5. */
  6. #define ldebug_c
  7. #define LUA_CORE
  8. #include "lprefix.h"
  9. #include <stdarg.h>
  10. #include <stddef.h>
  11. #include <string.h>
  12. #include "lua.h"
  13. #include "lapi.h"
  14. #include "lcode.h"
  15. #include "ldebug.h"
  16. #include "ldo.h"
  17. #include "lfunc.h"
  18. #include "lobject.h"
  19. #include "lopcodes.h"
  20. #include "lstate.h"
  21. #include "lstring.h"
  22. #include "ltable.h"
  23. #include "ltm.h"
  24. #include "lvm.h"
  25. #define noLuaClosure(f) ((f) == NULL || (f)->c.tt == LUA_TCCL)
  26. /* Active Lua function (given call info) */
  27. #define ci_func(ci) (clLvalue((ci)->func))
  28. static const char *funcnamefromcode (lua_State *L, CallInfo *ci,
  29. const char **name);
  30. static int currentpc (CallInfo *ci) {
  31. lua_assert(isLua(ci));
  32. return pcRel(ci->u.l.savedpc, ci_func(ci)->p);
  33. }
  34. static int currentline (CallInfo *ci) {
  35. return getfuncline(ci_func(ci)->p, currentpc(ci));
  36. }
  37. /*
  38. ** If function yielded, its 'func' can be in the 'extra' field. The
  39. ** next function restores 'func' to its correct value for debugging
  40. ** purposes. (It exchanges 'func' and 'extra'; so, when called again,
  41. ** after debugging, it also "re-restores" ** 'func' to its altered value.
  42. */
  43. static void swapextra (lua_State *L) {
  44. if (L->status == LUA_YIELD) {
  45. CallInfo *ci = L->ci; /* get function that yielded */
  46. StkId temp = ci->func; /* exchange its 'func' and 'extra' values */
  47. ci->func = restorestack(L, ci->extra);
  48. ci->extra = savestack(L, temp);
  49. }
  50. }
  51. /*
  52. ** This function can be called asynchronously (e.g. during a signal).
  53. ** Fields 'oldpc', 'basehookcount', and 'hookcount' (set by
  54. ** 'resethookcount') are for debug only, and it is no problem if they
  55. ** get arbitrary values (causes at most one wrong hook call). 'hookmask'
  56. ** is an atomic value. We assume that pointers are atomic too (e.g., gcc
  57. ** ensures that for all platforms where it runs). Moreover, 'hook' is
  58. ** always checked before being called (see 'luaD_hook').
  59. */
  60. LUA_API void lua_sethook (lua_State *L, lua_Hook func, int mask, int count) {
  61. if (func == NULL || mask == 0) { /* turn off hooks? */
  62. mask = 0;
  63. func = NULL;
  64. }
  65. if (isLua(L->ci))
  66. L->oldpc = L->ci->u.l.savedpc;
  67. L->hook = func;
  68. L->basehookcount = count;
  69. resethookcount(L);
  70. L->hookmask = cast_byte(mask);
  71. }
  72. LUA_API lua_Hook lua_gethook (lua_State *L) {
  73. return L->hook;
  74. }
  75. LUA_API int lua_gethookmask (lua_State *L) {
  76. return L->hookmask;
  77. }
  78. LUA_API int lua_gethookcount (lua_State *L) {
  79. return L->basehookcount;
  80. }
  81. LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar) {
  82. int status;
  83. CallInfo *ci;
  84. if (level < 0) return 0; /* invalid (negative) level */
  85. lua_lock(L);
  86. for (ci = L->ci; level > 0 && ci != &L->base_ci; ci = ci->previous)
  87. level--;
  88. if (level == 0 && ci != &L->base_ci) { /* level found? */
  89. status = 1;
  90. ar->i_ci = ci;
  91. }
  92. else status = 0; /* no such level */
  93. lua_unlock(L);
  94. return status;
  95. }
  96. static const char *upvalname (Proto *p, int uv) {
  97. TString *s = check_exp(uv < p->sizeupvalues, p->upvalues[uv].name);
  98. if (s == NULL) return "?";
  99. else return getstr(s);
  100. }
  101. static const char *findvararg (CallInfo *ci, int n, StkId *pos) {
  102. int nparams = clLvalue(ci->func)->p->numparams;
  103. if (n >= cast_int(ci->u.l.base - ci->func) - nparams)
  104. return NULL; /* no such vararg */
  105. else {
  106. *pos = ci->func + nparams + n;
  107. return "(*vararg)"; /* generic name for any vararg */
  108. }
  109. }
  110. static const char *findlocal (lua_State *L, CallInfo *ci, int n,
  111. StkId *pos) {
  112. const char *name = NULL;
  113. StkId base;
  114. if (isLua(ci)) {
  115. if (n < 0) /* access to vararg values? */
  116. return findvararg(ci, -n, pos);
  117. else {
  118. base = ci->u.l.base;
  119. name = luaF_getlocalname(ci_func(ci)->p, n, currentpc(ci));
  120. }
  121. }
  122. else
  123. base = ci->func + 1;
  124. if (name == NULL) { /* no 'standard' name? */
  125. StkId limit = (ci == L->ci) ? L->top : ci->next->func;
  126. if (limit - base >= n && n > 0) /* is 'n' inside 'ci' stack? */
  127. name = "(*temporary)"; /* generic name for any valid slot */
  128. else
  129. return NULL; /* no name */
  130. }
  131. *pos = base + (n - 1);
  132. return name;
  133. }
  134. LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n) {
  135. const char *name;
  136. lua_lock(L);
  137. swapextra(L);
  138. if (ar == NULL) { /* information about non-active function? */
  139. if (!isLfunction(L->top - 1)) /* not a Lua function? */
  140. name = NULL;
  141. else /* consider live variables at function start (parameters) */
  142. name = luaF_getlocalname(clLvalue(L->top - 1)->p, n, 0);
  143. }
  144. else { /* active function; get information through 'ar' */
  145. StkId pos = NULL; /* to avoid warnings */
  146. name = findlocal(L, ar->i_ci, n, &pos);
  147. if (name) {
  148. setobj2s(L, L->top, pos);
  149. api_incr_top(L);
  150. }
  151. }
  152. swapextra(L);
  153. lua_unlock(L);
  154. return name;
  155. }
  156. LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n) {
  157. StkId pos = NULL; /* to avoid warnings */
  158. const char *name;
  159. lua_lock(L);
  160. swapextra(L);
  161. name = findlocal(L, ar->i_ci, n, &pos);
  162. if (name) {
  163. setobjs2s(L, pos, L->top - 1);
  164. L->top--; /* pop value */
  165. }
  166. swapextra(L);
  167. lua_unlock(L);
  168. return name;
  169. }
  170. static void funcinfo (lua_Debug *ar, Closure *cl) {
  171. if (noLuaClosure(cl)) {
  172. ar->source = "=[C]";
  173. ar->linedefined = -1;
  174. ar->lastlinedefined = -1;
  175. ar->what = "C";
  176. }
  177. else {
  178. Proto *p = cl->l.p;
  179. ar->source = p->source ? getstr(p->source) : "=?";
  180. ar->linedefined = p->linedefined;
  181. ar->lastlinedefined = p->lastlinedefined;
  182. ar->what = (ar->linedefined == 0) ? "main" : "Lua";
  183. }
  184. luaO_chunkid(ar->short_src, ar->source, LUA_IDSIZE);
  185. }
  186. static void collectvalidlines (lua_State *L, Closure *f) {
  187. if (noLuaClosure(f)) {
  188. setnilvalue(L->top);
  189. api_incr_top(L);
  190. }
  191. else {
  192. int i;
  193. TValue v;
  194. int *lineinfo = f->l.p->lineinfo;
  195. Table *t = luaH_new(L); /* new table to store active lines */
  196. sethvalue(L, L->top, t); /* push it on stack */
  197. api_incr_top(L);
  198. setbvalue(&v, 1); /* boolean 'true' to be the value of all indices */
  199. for (i = 0; i < f->l.p->sizelineinfo; i++) /* for all lines with code */
  200. luaH_setint(L, t, lineinfo[i], &v); /* table[line] = true */
  201. }
  202. }
  203. static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name) {
  204. if (ci == NULL) /* no 'ci'? */
  205. return NULL; /* no info */
  206. else if (ci->callstatus & CIST_FIN) { /* is this a finalizer? */
  207. *name = "__gc";
  208. return "metamethod"; /* report it as such */
  209. }
  210. /* calling function is a known Lua function? */
  211. else if (!(ci->callstatus & CIST_TAIL) && isLua(ci->previous))
  212. return funcnamefromcode(L, ci->previous, name);
  213. else return NULL; /* no way to find a name */
  214. }
  215. static int auxgetinfo (lua_State *L, const char *what, lua_Debug *ar,
  216. Closure *f, CallInfo *ci) {
  217. int status = 1;
  218. for (; *what; what++) {
  219. switch (*what) {
  220. case 'S': {
  221. funcinfo(ar, f);
  222. break;
  223. }
  224. case 'l': {
  225. ar->currentline = (ci && isLua(ci)) ? currentline(ci) : -1;
  226. break;
  227. }
  228. case 'u': {
  229. ar->nups = (f == NULL) ? 0 : f->c.nupvalues;
  230. if (noLuaClosure(f)) {
  231. ar->isvararg = 1;
  232. ar->nparams = 0;
  233. }
  234. else {
  235. ar->isvararg = f->l.p->is_vararg;
  236. ar->nparams = f->l.p->numparams;
  237. }
  238. break;
  239. }
  240. case 't': {
  241. ar->istailcall = (ci) ? ci->callstatus & CIST_TAIL : 0;
  242. break;
  243. }
  244. case 'n': {
  245. ar->namewhat = getfuncname(L, ci, &ar->name);
  246. if (ar->namewhat == NULL) {
  247. ar->namewhat = ""; /* not found */
  248. ar->name = NULL;
  249. }
  250. break;
  251. }
  252. case 'L':
  253. case 'f': /* handled by lua_getinfo */
  254. break;
  255. default: status = 0; /* invalid option */
  256. }
  257. }
  258. return status;
  259. }
  260. LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar) {
  261. int status;
  262. Closure *cl;
  263. CallInfo *ci;
  264. StkId func;
  265. lua_lock(L);
  266. swapextra(L);
  267. if (*what == '>') {
  268. ci = NULL;
  269. func = L->top - 1;
  270. api_check(L, ttisfunction(func), "function expected");
  271. what++; /* skip the '>' */
  272. L->top--; /* pop function */
  273. }
  274. else {
  275. ci = ar->i_ci;
  276. func = ci->func;
  277. lua_assert(ttisfunction(ci->func));
  278. }
  279. cl = ttisclosure(func) ? clvalue(func) : NULL;
  280. status = auxgetinfo(L, what, ar, cl, ci);
  281. if (strchr(what, 'f')) {
  282. setobjs2s(L, L->top, func);
  283. api_incr_top(L);
  284. }
  285. swapextra(L); /* correct before option 'L', which can raise a mem. error */
  286. if (strchr(what, 'L'))
  287. collectvalidlines(L, cl);
  288. lua_unlock(L);
  289. return status;
  290. }
  291. /*
  292. ** {======================================================
  293. ** Symbolic Execution
  294. ** =======================================================
  295. */
  296. static const char *getobjname (Proto *p, int lastpc, int reg,
  297. const char **name);
  298. /*
  299. ** find a "name" for the RK value 'c'
  300. */
  301. static void kname (Proto *p, int pc, int c, const char **name) {
  302. if (ISK(c)) { /* is 'c' a constant? */
  303. TValue *kvalue = &p->k[INDEXK(c)];
  304. if (ttisstring(kvalue)) { /* literal constant? */
  305. *name = svalue(kvalue); /* it is its own name */
  306. return;
  307. }
  308. /* else no reasonable name found */
  309. }
  310. else { /* 'c' is a register */
  311. const char *what = getobjname(p, pc, c, name); /* search for 'c' */
  312. if (what && *what == 'c') { /* found a constant name? */
  313. return; /* 'name' already filled */
  314. }
  315. /* else no reasonable name found */
  316. }
  317. *name = "?"; /* no reasonable name found */
  318. }
  319. static int filterpc (int pc, int jmptarget) {
  320. if (pc < jmptarget) /* is code conditional (inside a jump)? */
  321. return -1; /* cannot know who sets that register */
  322. else return pc; /* current position sets that register */
  323. }
  324. /*
  325. ** try to find last instruction before 'lastpc' that modified register 'reg'
  326. */
  327. static int findsetreg (Proto *p, int lastpc, int reg) {
  328. int pc;
  329. int setreg = -1; /* keep last instruction that changed 'reg' */
  330. int jmptarget = 0; /* any code before this address is conditional */
  331. for (pc = 0; pc < lastpc; pc++) {
  332. Instruction i = p->code[pc];
  333. OpCode op = GET_OPCODE(i);
  334. int a = GETARG_A(i);
  335. switch (op) {
  336. case OP_LOADNIL: {
  337. int b = GETARG_B(i);
  338. if (a <= reg && reg <= a + b) /* set registers from 'a' to 'a+b' */
  339. setreg = filterpc(pc, jmptarget);
  340. break;
  341. }
  342. case OP_TFORCALL: {
  343. if (reg >= a + 2) /* affect all regs above its base */
  344. setreg = filterpc(pc, jmptarget);
  345. break;
  346. }
  347. case OP_CALL:
  348. case OP_TAILCALL: {
  349. if (reg >= a) /* affect all registers above base */
  350. setreg = filterpc(pc, jmptarget);
  351. break;
  352. }
  353. case OP_JMP: {
  354. int b = GETARG_sBx(i);
  355. int dest = pc + 1 + b;
  356. /* jump is forward and do not skip 'lastpc'? */
  357. if (pc < dest && dest <= lastpc) {
  358. if (dest > jmptarget)
  359. jmptarget = dest; /* update 'jmptarget' */
  360. }
  361. break;
  362. }
  363. default:
  364. if (testAMode(op) && reg == a) /* any instruction that set A */
  365. setreg = filterpc(pc, jmptarget);
  366. break;
  367. }
  368. }
  369. return setreg;
  370. }
  371. static const char *getobjname (Proto *p, int lastpc, int reg,
  372. const char **name) {
  373. int pc;
  374. *name = luaF_getlocalname(p, reg + 1, lastpc);
  375. if (*name) /* is a local? */
  376. return "local";
  377. /* else try symbolic execution */
  378. pc = findsetreg(p, lastpc, reg);
  379. if (pc != -1) { /* could find instruction? */
  380. Instruction i = p->code[pc];
  381. OpCode op = GET_OPCODE(i);
  382. switch (op) {
  383. case OP_MOVE: {
  384. int b = GETARG_B(i); /* move from 'b' to 'a' */
  385. if (b < GETARG_A(i))
  386. return getobjname(p, pc, b, name); /* get name for 'b' */
  387. break;
  388. }
  389. case OP_GETTABUP:
  390. case OP_GETTABLE: {
  391. int k = GETARG_C(i); /* key index */
  392. int t = GETARG_B(i); /* table index */
  393. const char *vn = (op == OP_GETTABLE) /* name of indexed variable */
  394. ? luaF_getlocalname(p, t + 1, pc)
  395. : upvalname(p, t);
  396. kname(p, pc, k, name);
  397. return (vn && strcmp(vn, LUA_ENV) == 0) ? "global" : "field";
  398. }
  399. case OP_GETUPVAL: {
  400. *name = upvalname(p, GETARG_B(i));
  401. return "upvalue";
  402. }
  403. case OP_LOADK:
  404. case OP_LOADKX: {
  405. int b = (op == OP_LOADK) ? GETARG_Bx(i)
  406. : GETARG_Ax(p->code[pc + 1]);
  407. if (ttisstring(&p->k[b])) {
  408. *name = svalue(&p->k[b]);
  409. return "constant";
  410. }
  411. break;
  412. }
  413. case OP_SELF: {
  414. int k = GETARG_C(i); /* key index */
  415. kname(p, pc, k, name);
  416. return "method";
  417. }
  418. default: break; /* go through to return NULL */
  419. }
  420. }
  421. return NULL; /* could not find reasonable name */
  422. }
  423. /*
  424. ** Try to find a name for a function based on the code that called it.
  425. ** (Only works when function was called by a Lua function.)
  426. ** Returns what the name is (e.g., "for iterator", "method",
  427. ** "metamethod") and sets '*name' to point to the name.
  428. */
  429. static const char *funcnamefromcode (lua_State *L, CallInfo *ci,
  430. const char **name) {
  431. TMS tm = (TMS)0; /* (initial value avoids warnings) */
  432. Proto *p = ci_func(ci)->p; /* calling function */
  433. int pc = currentpc(ci); /* calling instruction index */
  434. Instruction i = p->code[pc]; /* calling instruction */
  435. if (ci->callstatus & CIST_HOOKED) { /* was it called inside a hook? */
  436. *name = "?";
  437. return "hook";
  438. }
  439. switch (GET_OPCODE(i)) {
  440. case OP_CALL:
  441. case OP_TAILCALL:
  442. return getobjname(p, pc, GETARG_A(i), name); /* get function name */
  443. case OP_TFORCALL: { /* for iterator */
  444. *name = "for iterator";
  445. return "for iterator";
  446. }
  447. /* other instructions can do calls through metamethods */
  448. case OP_SELF: case OP_GETTABUP: case OP_GETTABLE:
  449. tm = TM_INDEX;
  450. break;
  451. case OP_SETTABUP: case OP_SETTABLE:
  452. tm = TM_NEWINDEX;
  453. break;
  454. case OP_ADD: case OP_SUB: case OP_MUL: case OP_MOD:
  455. case OP_POW: case OP_DIV: case OP_IDIV: case OP_BAND:
  456. case OP_BOR: case OP_BXOR: case OP_SHL: case OP_SHR: {
  457. int offset = cast_int(GET_OPCODE(i)) - cast_int(OP_ADD); /* ORDER OP */
  458. tm = cast(TMS, offset + cast_int(TM_ADD)); /* ORDER TM */
  459. break;
  460. }
  461. case OP_UNM: tm = TM_UNM; break;
  462. case OP_BNOT: tm = TM_BNOT; break;
  463. case OP_LEN: tm = TM_LEN; break;
  464. case OP_CONCAT: tm = TM_CONCAT; break;
  465. case OP_EQ: tm = TM_EQ; break;
  466. case OP_LT: tm = TM_LT; break;
  467. case OP_LE: tm = TM_LE; break;
  468. default:
  469. return NULL; /* cannot find a reasonable name */
  470. }
  471. *name = getstr(G(L)->tmname[tm]);
  472. return "metamethod";
  473. }
  474. /* }====================================================== */
  475. /*
  476. ** The subtraction of two potentially unrelated pointers is
  477. ** not ISO C, but it should not crash a program; the subsequent
  478. ** checks are ISO C and ensure a correct result.
  479. */
  480. static int isinstack (CallInfo *ci, const TValue *o) {
  481. ptrdiff_t i = o - ci->u.l.base;
  482. return (0 <= i && i < (ci->top - ci->u.l.base) && ci->u.l.base + i == o);
  483. }
  484. /*
  485. ** Checks whether value 'o' came from an upvalue. (That can only happen
  486. ** with instructions OP_GETTABUP/OP_SETTABUP, which operate directly on
  487. ** upvalues.)
  488. */
  489. static const char *getupvalname (CallInfo *ci, const TValue *o,
  490. const char **name) {
  491. LClosure *c = ci_func(ci);
  492. int i;
  493. for (i = 0; i < c->nupvalues; i++) {
  494. if (c->upvals[i]->v == o) {
  495. *name = upvalname(c->p, i);
  496. return "upvalue";
  497. }
  498. }
  499. return NULL;
  500. }
  501. static const char *varinfo (lua_State *L, const TValue *o) {
  502. const char *name = NULL; /* to avoid warnings */
  503. CallInfo *ci = L->ci;
  504. const char *kind = NULL;
  505. if (isLua(ci)) {
  506. kind = getupvalname(ci, o, &name); /* check whether 'o' is an upvalue */
  507. if (!kind && isinstack(ci, o)) /* no? try a register */
  508. kind = getobjname(ci_func(ci)->p, currentpc(ci),
  509. cast_int(o - ci->u.l.base), &name);
  510. }
  511. return (kind) ? luaO_pushfstring(L, " (%s '%s')", kind, name) : "";
  512. }
  513. l_noret luaG_typeerror (lua_State *L, const TValue *o, const char *op) {
  514. const char *t = luaT_objtypename(L, o);
  515. luaG_runerror(L, "attempt to %s a %s value%s", op, t, varinfo(L, o));
  516. }
  517. l_noret luaG_concaterror (lua_State *L, const TValue *p1, const TValue *p2) {
  518. if (ttisstring(p1) || cvt2str(p1)) p1 = p2;
  519. luaG_typeerror(L, p1, "concatenate");
  520. }
  521. l_noret luaG_opinterror (lua_State *L, const TValue *p1,
  522. const TValue *p2, const char *msg) {
  523. lua_Number temp;
  524. if (!tonumber(p1, &temp)) /* first operand is wrong? */
  525. p2 = p1; /* now second is wrong */
  526. luaG_typeerror(L, p2, msg);
  527. }
  528. /*
  529. ** Error when both values are convertible to numbers, but not to integers
  530. */
  531. l_noret luaG_tointerror (lua_State *L, const TValue *p1, const TValue *p2) {
  532. lua_Integer temp;
  533. if (!tointeger(p1, &temp))
  534. p2 = p1;
  535. luaG_runerror(L, "number%s has no integer representation", varinfo(L, p2));
  536. }
  537. l_noret luaG_ordererror (lua_State *L, const TValue *p1, const TValue *p2) {
  538. const char *t1 = luaT_objtypename(L, p1);
  539. const char *t2 = luaT_objtypename(L, p2);
  540. if (strcmp(t1, t2) == 0)
  541. luaG_runerror(L, "attempt to compare two %s values", t1);
  542. else
  543. luaG_runerror(L, "attempt to compare %s with %s", t1, t2);
  544. }
  545. /* add src:line information to 'msg' */
  546. const char *luaG_addinfo (lua_State *L, const char *msg, TString *src,
  547. int line) {
  548. char buff[LUA_IDSIZE];
  549. if (src)
  550. luaO_chunkid(buff, getstr(src), LUA_IDSIZE);
  551. else { /* no source available; use "?" instead */
  552. buff[0] = '?'; buff[1] = '\0';
  553. }
  554. return luaO_pushfstring(L, "%s:%d: %s", buff, line, msg);
  555. }
  556. l_noret luaG_errormsg (lua_State *L) {
  557. if (L->errfunc != 0) { /* is there an error handling function? */
  558. StkId errfunc = restorestack(L, L->errfunc);
  559. setobjs2s(L, L->top, L->top - 1); /* move argument */
  560. setobjs2s(L, L->top - 1, errfunc); /* push function */
  561. L->top++; /* assume EXTRA_STACK */
  562. luaD_callnoyield(L, L->top - 2, 1); /* call it */
  563. }
  564. luaD_throw(L, LUA_ERRRUN);
  565. }
  566. l_noret luaG_runerror (lua_State *L, const char *fmt, ...) {
  567. CallInfo *ci = L->ci;
  568. const char *msg;
  569. va_list argp;
  570. va_start(argp, fmt);
  571. msg = luaO_pushvfstring(L, fmt, argp); /* format message */
  572. va_end(argp);
  573. if (isLua(ci)) /* if Lua function, add source:line information */
  574. luaG_addinfo(L, msg, ci_func(ci)->p->source, currentline(ci));
  575. luaG_errormsg(L);
  576. }
  577. void luaG_traceexec (lua_State *L) {
  578. CallInfo *ci = L->ci;
  579. lu_byte mask = L->hookmask;
  580. int counthook = (--L->hookcount == 0 && (mask & LUA_MASKCOUNT));
  581. if (counthook)
  582. resethookcount(L); /* reset count */
  583. else if (!(mask & LUA_MASKLINE))
  584. return; /* no line hook and count != 0; nothing to be done */
  585. if (ci->callstatus & CIST_HOOKYIELD) { /* called hook last time? */
  586. ci->callstatus &= ~CIST_HOOKYIELD; /* erase mark */
  587. return; /* do not call hook again (VM yielded, so it did not move) */
  588. }
  589. if (counthook)
  590. luaD_hook(L, LUA_HOOKCOUNT, -1); /* call count hook */
  591. if (mask & LUA_MASKLINE) {
  592. Proto *p = ci_func(ci)->p;
  593. int npc = pcRel(ci->u.l.savedpc, p);
  594. int newline = getfuncline(p, npc);
  595. if (npc == 0 || /* call linehook when enter a new function, */
  596. ci->u.l.savedpc <= L->oldpc || /* when jump back (loop), or when */
  597. newline != getfuncline(p, pcRel(L->oldpc, p))) /* enter a new line */
  598. luaD_hook(L, LUA_HOOKLINE, newline); /* call line hook */
  599. }
  600. L->oldpc = ci->u.l.savedpc;
  601. if (L->status == LUA_YIELD) { /* did hook yield? */
  602. if (counthook)
  603. L->hookcount = 1; /* undo decrement to zero */
  604. ci->u.l.savedpc--; /* undo increment (resume will increment it again) */
  605. ci->callstatus |= CIST_HOOKYIELD; /* mark that it yielded */
  606. ci->func = L->top - 1; /* protect stack below results */
  607. luaD_throw(L, LUA_YIELD);
  608. }
  609. }