?login_element?

Subversion Repositories NedoOS

Rev

Blame | Last modification | View Log | Download | RSS feed

  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.  
  95. LUA_API lua_Hook lua_gethook (lua_State *L) {
  96.   return L->hook;
  97. }
  98.  
  99.  
  100. LUA_API int lua_gethookmask (lua_State *L) {
  101.   return L->hookmask;
  102. }
  103.  
  104.  
  105. LUA_API int lua_gethookcount (lua_State *L) {
  106.   return L->basehookcount;
  107. }
  108.  
  109.  
  110. LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar) {
  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;
  223.     ar->lastlinedefined = p->lastlinedefined;
  224.     ar->what = (ar->linedefined == 0) ? "main" : "Lua";
  225.   }
  226.   luaO_chunkid(ar->short_src, ar->source, LUA_IDSIZE);
  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;
  327.     lua_assert(ttisfunction(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.  
  598. l_noret luaG_opinterror (lua_State *L, const TValue *p1,
  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.  
  641. l_noret luaG_errormsg (lua_State *L) {
  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.   }
  649.   luaD_throw(L, LUA_ERRRUN);
  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.  
  667. void luaG_traceexec (lua_State *L) {
  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.  
  701.