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