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