]>
git.proxmox.com Git - ceph.git/blob - ceph/src/jaegertracing/opentelemetry-cpp/third_party/prometheus-cpp/3rdparty/civetweb/src/third_party/lua-5.4.3/src/ldebug.c
4 ** See Copyright Notice in lua.h
34 #define noLuaClosure(f) ((f) == NULL || (f)->c.tt == LUA_VCCL)
37 static const char *funcnamefromcode (lua_State
*L
, CallInfo
*ci
,
41 static int currentpc (CallInfo
*ci
) {
42 lua_assert(isLua(ci
));
43 return pcRel(ci
->u
.l
.savedpc
, ci_func(ci
)->p
);
48 ** Get a "base line" to find the line corresponding to an instruction.
49 ** Base lines are regularly placed at MAXIWTHABS intervals, so usually
50 ** an integer division gets the right place. When the source file has
51 ** large sequences of empty/comment lines, it may need extra entries,
52 ** so the original estimate needs a correction.
53 ** If the original estimate is -1, the initial 'if' ensures that the
54 ** 'while' will run at least once.
55 ** The assertion that the estimate is a lower bound for the correct base
56 ** is valid as long as the debug info has been generated with the same
57 ** value for MAXIWTHABS or smaller. (Previous releases use a little
60 static int getbaseline (const Proto
*f
, int pc
, int *basepc
) {
61 if (f
->sizeabslineinfo
== 0 || pc
< f
->abslineinfo
[0].pc
) {
62 *basepc
= -1; /* start from the beginning */
63 return f
->linedefined
;
66 int i
= cast_uint(pc
) / MAXIWTHABS
- 1; /* get an estimate */
67 /* estimate must be a lower bond of the correct base */
69 (i
< f
->sizeabslineinfo
&& f
->abslineinfo
[i
].pc
<= pc
));
70 while (i
+ 1 < f
->sizeabslineinfo
&& pc
>= f
->abslineinfo
[i
+ 1].pc
)
71 i
++; /* low estimate; adjust it */
72 *basepc
= f
->abslineinfo
[i
].pc
;
73 return f
->abslineinfo
[i
].line
;
79 ** Get the line corresponding to instruction 'pc' in function 'f';
80 ** first gets a base line and from there does the increments until
81 ** the desired instruction.
83 int luaG_getfuncline (const Proto
*f
, int pc
) {
84 if (f
->lineinfo
== NULL
) /* no debug information? */
88 int baseline
= getbaseline(f
, pc
, &basepc
);
89 while (basepc
++ < pc
) { /* walk until given instruction */
90 lua_assert(f
->lineinfo
[basepc
] != ABSLINEINFO
);
91 baseline
+= f
->lineinfo
[basepc
]; /* correct line */
98 static int getcurrentline (CallInfo
*ci
) {
99 return luaG_getfuncline(ci_func(ci
)->p
, currentpc(ci
));
104 ** Set 'trap' for all active Lua frames.
105 ** This function can be called during a signal, under "reasonable"
106 ** assumptions. A new 'ci' is completely linked in the list before it
107 ** becomes part of the "active" list, and we assume that pointers are
108 ** atomic; see comment in next function.
109 ** (A compiler doing interprocedural optimizations could, theoretically,
110 ** reorder memory writes in such a way that the list could be
111 ** temporarily broken while inserting a new element. We simply assume it
112 ** has no good reasons to do that.)
114 static void settraps (CallInfo
*ci
) {
115 for (; ci
!= NULL
; ci
= ci
->previous
)
122 ** This function can be called during a signal, under "reasonable"
124 ** Fields 'basehookcount' and 'hookcount' (set by 'resethookcount')
125 ** are for debug only, and it is no problem if they get arbitrary
126 ** values (causes at most one wrong hook call). 'hookmask' is an atomic
127 ** value. We assume that pointers are atomic too (e.g., gcc ensures that
128 ** for all platforms where it runs). Moreover, 'hook' is always checked
129 ** before being called (see 'luaD_hook').
131 LUA_API
void lua_sethook (lua_State
*L
, lua_Hook func
, int mask
, int count
) {
132 if (func
== NULL
|| mask
== 0) { /* turn off hooks? */
137 L
->basehookcount
= count
;
139 L
->hookmask
= cast_byte(mask
);
141 settraps(L
->ci
); /* to trace inside 'luaV_execute' */
145 LUA_API lua_Hook
lua_gethook (lua_State
*L
) {
150 LUA_API
int lua_gethookmask (lua_State
*L
) {
155 LUA_API
int lua_gethookcount (lua_State
*L
) {
156 return L
->basehookcount
;
160 LUA_API
int lua_getstack (lua_State
*L
, int level
, lua_Debug
*ar
) {
163 if (level
< 0) return 0; /* invalid (negative) level */
165 for (ci
= L
->ci
; level
> 0 && ci
!= &L
->base_ci
; ci
= ci
->previous
)
167 if (level
== 0 && ci
!= &L
->base_ci
) { /* level found? */
171 else status
= 0; /* no such level */
177 static const char *upvalname (const Proto
*p
, int uv
) {
178 TString
*s
= check_exp(uv
< p
->sizeupvalues
, p
->upvalues
[uv
].name
);
179 if (s
== NULL
) return "?";
180 else return getstr(s
);
184 static const char *findvararg (CallInfo
*ci
, int n
, StkId
*pos
) {
185 if (clLvalue(s2v(ci
->func
))->p
->is_vararg
) {
186 int nextra
= ci
->u
.l
.nextraargs
;
187 if (n
>= -nextra
) { /* 'n' is negative */
188 *pos
= ci
->func
- nextra
- (n
+ 1);
189 return "(vararg)"; /* generic name for any vararg */
192 return NULL
; /* no such vararg */
196 const char *luaG_findlocal (lua_State
*L
, CallInfo
*ci
, int n
, StkId
*pos
) {
197 StkId base
= ci
->func
+ 1;
198 const char *name
= NULL
;
200 if (n
< 0) /* access to vararg values? */
201 return findvararg(ci
, n
, pos
);
203 name
= luaF_getlocalname(ci_func(ci
)->p
, n
, currentpc(ci
));
205 if (name
== NULL
) { /* no 'standard' name? */
206 StkId limit
= (ci
== L
->ci
) ? L
->top
: ci
->next
->func
;
207 if (limit
- base
>= n
&& n
> 0) { /* is 'n' inside 'ci' stack? */
208 /* generic name for any valid slot */
209 name
= isLua(ci
) ? "(temporary)" : "(C temporary)";
212 return NULL
; /* no name */
215 *pos
= base
+ (n
- 1);
220 LUA_API
const char *lua_getlocal (lua_State
*L
, const lua_Debug
*ar
, int n
) {
223 if (ar
== NULL
) { /* information about non-active function? */
224 if (!isLfunction(s2v(L
->top
- 1))) /* not a Lua function? */
226 else /* consider live variables at function start (parameters) */
227 name
= luaF_getlocalname(clLvalue(s2v(L
->top
- 1))->p
, n
, 0);
229 else { /* active function; get information through 'ar' */
230 StkId pos
= NULL
; /* to avoid warnings */
231 name
= luaG_findlocal(L
, ar
->i_ci
, n
, &pos
);
233 setobjs2s(L
, L
->top
, pos
);
242 LUA_API
const char *lua_setlocal (lua_State
*L
, const lua_Debug
*ar
, int n
) {
243 StkId pos
= NULL
; /* to avoid warnings */
246 name
= luaG_findlocal(L
, ar
->i_ci
, n
, &pos
);
248 setobjs2s(L
, pos
, L
->top
- 1);
249 L
->top
--; /* pop value */
256 static void funcinfo (lua_Debug
*ar
, Closure
*cl
) {
257 if (noLuaClosure(cl
)) {
259 ar
->srclen
= LL("=[C]");
260 ar
->linedefined
= -1;
261 ar
->lastlinedefined
= -1;
265 const Proto
*p
= cl
->l
.p
;
267 ar
->source
= getstr(p
->source
);
268 ar
->srclen
= tsslen(p
->source
);
272 ar
->srclen
= LL("=?");
274 ar
->linedefined
= p
->linedefined
;
275 ar
->lastlinedefined
= p
->lastlinedefined
;
276 ar
->what
= (ar
->linedefined
== 0) ? "main" : "Lua";
278 luaO_chunkid(ar
->short_src
, ar
->source
, ar
->srclen
);
282 static int nextline (const Proto
*p
, int currentline
, int pc
) {
283 if (p
->lineinfo
[pc
] != ABSLINEINFO
)
284 return currentline
+ p
->lineinfo
[pc
];
286 return luaG_getfuncline(p
, pc
);
290 static void collectvalidlines (lua_State
*L
, Closure
*f
) {
291 if (noLuaClosure(f
)) {
292 setnilvalue(s2v(L
->top
));
298 const Proto
*p
= f
->l
.p
;
299 int currentline
= p
->linedefined
;
300 Table
*t
= luaH_new(L
); /* new table to store active lines */
301 sethvalue2s(L
, L
->top
, t
); /* push it on stack */
303 setbtvalue(&v
); /* boolean 'true' to be the value of all indices */
304 for (i
= 0; i
< p
->sizelineinfo
; i
++) { /* for all instructions */
305 currentline
= nextline(p
, currentline
, i
); /* get its line */
306 luaH_setint(L
, t
, currentline
, &v
); /* table[line] = true */
312 static const char *getfuncname (lua_State
*L
, CallInfo
*ci
, const char **name
) {
313 if (ci
== NULL
) /* no 'ci'? */
314 return NULL
; /* no info */
315 else if (ci
->callstatus
& CIST_FIN
) { /* is this a finalizer? */
317 return "metamethod"; /* report it as such */
319 /* calling function is a known Lua function? */
320 else if (!(ci
->callstatus
& CIST_TAIL
) && isLua(ci
->previous
))
321 return funcnamefromcode(L
, ci
->previous
, name
);
322 else return NULL
; /* no way to find a name */
326 static int auxgetinfo (lua_State
*L
, const char *what
, lua_Debug
*ar
,
327 Closure
*f
, CallInfo
*ci
) {
329 for (; *what
; what
++) {
336 ar
->currentline
= (ci
&& isLua(ci
)) ? getcurrentline(ci
) : -1;
340 ar
->nups
= (f
== NULL
) ? 0 : f
->c
.nupvalues
;
341 if (noLuaClosure(f
)) {
346 ar
->isvararg
= f
->l
.p
->is_vararg
;
347 ar
->nparams
= f
->l
.p
->numparams
;
352 ar
->istailcall
= (ci
) ? ci
->callstatus
& CIST_TAIL
: 0;
356 ar
->namewhat
= getfuncname(L
, ci
, &ar
->name
);
357 if (ar
->namewhat
== NULL
) {
358 ar
->namewhat
= ""; /* not found */
364 if (ci
== NULL
|| !(ci
->callstatus
& CIST_TRAN
))
365 ar
->ftransfer
= ar
->ntransfer
= 0;
367 ar
->ftransfer
= ci
->u2
.transferinfo
.ftransfer
;
368 ar
->ntransfer
= ci
->u2
.transferinfo
.ntransfer
;
373 case 'f': /* handled by lua_getinfo */
375 default: status
= 0; /* invalid option */
382 LUA_API
int lua_getinfo (lua_State
*L
, const char *what
, lua_Debug
*ar
) {
390 func
= s2v(L
->top
- 1);
391 api_check(L
, ttisfunction(func
), "function expected");
392 what
++; /* skip the '>' */
393 L
->top
--; /* pop function */
397 func
= s2v(ci
->func
);
398 lua_assert(ttisfunction(func
));
400 cl
= ttisclosure(func
) ? clvalue(func
) : NULL
;
401 status
= auxgetinfo(L
, what
, ar
, cl
, ci
);
402 if (strchr(what
, 'f')) {
403 setobj2s(L
, L
->top
, func
);
406 if (strchr(what
, 'L'))
407 collectvalidlines(L
, cl
);
414 ** {======================================================
415 ** Symbolic Execution
416 ** =======================================================
419 static const char *getobjname (const Proto
*p
, int lastpc
, int reg
,
424 ** Find a "name" for the constant 'c'.
426 static void kname (const Proto
*p
, int c
, const char **name
) {
427 TValue
*kvalue
= &p
->k
[c
];
428 *name
= (ttisstring(kvalue
)) ? svalue(kvalue
) : "?";
433 ** Find a "name" for the register 'c'.
435 static void rname (const Proto
*p
, int pc
, int c
, const char **name
) {
436 const char *what
= getobjname(p
, pc
, c
, name
); /* search for 'c' */
437 if (!(what
&& *what
== 'c')) /* did not find a constant name? */
443 ** Find a "name" for a 'C' value in an RK instruction.
445 static void rkname (const Proto
*p
, int pc
, Instruction i
, const char **name
) {
446 int c
= GETARG_C(i
); /* key index */
447 if (GETARG_k(i
)) /* is 'c' a constant? */
449 else /* 'c' is a register */
450 rname(p
, pc
, c
, name
);
454 static int filterpc (int pc
, int jmptarget
) {
455 if (pc
< jmptarget
) /* is code conditional (inside a jump)? */
456 return -1; /* cannot know who sets that register */
457 else return pc
; /* current position sets that register */
462 ** Try to find last instruction before 'lastpc' that modified register 'reg'.
464 static int findsetreg (const Proto
*p
, int lastpc
, int reg
) {
466 int setreg
= -1; /* keep last instruction that changed 'reg' */
467 int jmptarget
= 0; /* any code before this address is conditional */
468 if (testMMMode(GET_OPCODE(p
->code
[lastpc
])))
469 lastpc
--; /* previous instruction was not actually executed */
470 for (pc
= 0; pc
< lastpc
; pc
++) {
471 Instruction i
= p
->code
[pc
];
472 OpCode op
= GET_OPCODE(i
);
474 int change
; /* true if current instruction changed 'reg' */
476 case OP_LOADNIL
: { /* set registers from 'a' to 'a+b' */
478 change
= (a
<= reg
&& reg
<= a
+ b
);
481 case OP_TFORCALL
: { /* affect all regs above its base */
482 change
= (reg
>= a
+ 2);
486 case OP_TAILCALL
: { /* affect all registers above base */
490 case OP_JMP
: { /* doesn't change registers, but changes 'jmptarget' */
491 int b
= GETARG_sJ(i
);
492 int dest
= pc
+ 1 + b
;
493 /* jump does not skip 'lastpc' and is larger than current one? */
494 if (dest
<= lastpc
&& dest
> jmptarget
)
495 jmptarget
= dest
; /* update 'jmptarget' */
499 default: /* any instruction that sets A */
500 change
= (testAMode(op
) && reg
== a
);
504 setreg
= filterpc(pc
, jmptarget
);
511 ** Check whether table being indexed by instruction 'i' is the
512 ** environment '_ENV'
514 static const char *gxf (const Proto
*p
, int pc
, Instruction i
, int isup
) {
515 int t
= GETARG_B(i
); /* table index */
516 const char *name
; /* name of indexed variable */
517 if (isup
) /* is an upvalue? */
518 name
= upvalname(p
, t
);
520 getobjname(p
, pc
, t
, &name
);
521 return (name
&& strcmp(name
, LUA_ENV
) == 0) ? "global" : "field";
525 static const char *getobjname (const Proto
*p
, int lastpc
, int reg
,
528 *name
= luaF_getlocalname(p
, reg
+ 1, lastpc
);
529 if (*name
) /* is a local? */
531 /* else try symbolic execution */
532 pc
= findsetreg(p
, lastpc
, reg
);
533 if (pc
!= -1) { /* could find instruction? */
534 Instruction i
= p
->code
[pc
];
535 OpCode op
= GET_OPCODE(i
);
538 int b
= GETARG_B(i
); /* move from 'b' to 'a' */
540 return getobjname(p
, pc
, b
, name
); /* get name for 'b' */
544 int k
= GETARG_C(i
); /* key index */
546 return gxf(p
, pc
, i
, 1);
549 int k
= GETARG_C(i
); /* key index */
550 rname(p
, pc
, k
, name
);
551 return gxf(p
, pc
, i
, 0);
554 *name
= "integer index";
558 int k
= GETARG_C(i
); /* key index */
560 return gxf(p
, pc
, i
, 0);
563 *name
= upvalname(p
, GETARG_B(i
));
568 int b
= (op
== OP_LOADK
) ? GETARG_Bx(i
)
569 : GETARG_Ax(p
->code
[pc
+ 1]);
570 if (ttisstring(&p
->k
[b
])) {
571 *name
= svalue(&p
->k
[b
]);
577 rkname(p
, pc
, i
, name
);
580 default: break; /* go through to return NULL */
583 return NULL
; /* could not find reasonable name */
588 ** Try to find a name for a function based on the code that called it.
589 ** (Only works when function was called by a Lua function.)
590 ** Returns what the name is (e.g., "for iterator", "method",
591 ** "metamethod") and sets '*name' to point to the name.
593 static const char *funcnamefromcode (lua_State
*L
, CallInfo
*ci
,
595 TMS tm
= (TMS
)0; /* (initial value avoids warnings) */
596 const Proto
*p
= ci_func(ci
)->p
; /* calling function */
597 int pc
= currentpc(ci
); /* calling instruction index */
598 Instruction i
= p
->code
[pc
]; /* calling instruction */
599 if (ci
->callstatus
& CIST_HOOKED
) { /* was it called inside a hook? */
603 switch (GET_OPCODE(i
)) {
606 return getobjname(p
, pc
, GETARG_A(i
), name
); /* get function name */
607 case OP_TFORCALL
: { /* for iterator */
608 *name
= "for iterator";
609 return "for iterator";
611 /* other instructions can do calls through metamethods */
612 case OP_SELF
: case OP_GETTABUP
: case OP_GETTABLE
:
613 case OP_GETI
: case OP_GETFIELD
:
616 case OP_SETTABUP
: case OP_SETTABLE
: case OP_SETI
: case OP_SETFIELD
:
619 case OP_MMBIN
: case OP_MMBINI
: case OP_MMBINK
: {
620 tm
= cast(TMS
, GETARG_C(i
));
623 case OP_UNM
: tm
= TM_UNM
; break;
624 case OP_BNOT
: tm
= TM_BNOT
; break;
625 case OP_LEN
: tm
= TM_LEN
; break;
626 case OP_CONCAT
: tm
= TM_CONCAT
; break;
627 case OP_EQ
: tm
= TM_EQ
; break;
628 /* no cases for OP_EQI and OP_EQK, as they don't call metamethods */
629 case OP_LT
: case OP_LTI
: case OP_GTI
: tm
= TM_LT
; break;
630 case OP_LE
: case OP_LEI
: case OP_GEI
: tm
= TM_LE
; break;
631 case OP_CLOSE
: case OP_RETURN
: tm
= TM_CLOSE
; break;
633 return NULL
; /* cannot find a reasonable name */
635 *name
= getstr(G(L
)->tmname
[tm
]) + 2;
639 /* }====================================================== */
644 ** Check whether pointer 'o' points to some value in the stack
645 ** frame of the current function. Because 'o' may not point to a
646 ** value in this stack, we cannot compare it with the region
647 ** boundaries (undefined behaviour in ISO C).
649 static int isinstack (CallInfo
*ci
, const TValue
*o
) {
651 for (pos
= ci
->func
+ 1; pos
< ci
->top
; pos
++) {
655 return 0; /* not found */
660 ** Checks whether value 'o' came from an upvalue. (That can only happen
661 ** with instructions OP_GETTABUP/OP_SETTABUP, which operate directly on
664 static const char *getupvalname (CallInfo
*ci
, const TValue
*o
,
666 LClosure
*c
= ci_func(ci
);
668 for (i
= 0; i
< c
->nupvalues
; i
++) {
669 if (c
->upvals
[i
]->v
== o
) {
670 *name
= upvalname(c
->p
, i
);
678 static const char *varinfo (lua_State
*L
, const TValue
*o
) {
679 const char *name
= NULL
; /* to avoid warnings */
680 CallInfo
*ci
= L
->ci
;
681 const char *kind
= NULL
;
683 kind
= getupvalname(ci
, o
, &name
); /* check whether 'o' is an upvalue */
684 if (!kind
&& isinstack(ci
, o
)) /* no? try a register */
685 kind
= getobjname(ci_func(ci
)->p
, currentpc(ci
),
686 cast_int(cast(StkId
, o
) - (ci
->func
+ 1)), &name
);
688 return (kind
) ? luaO_pushfstring(L
, " (%s '%s')", kind
, name
) : "";
692 l_noret
luaG_typeerror (lua_State
*L
, const TValue
*o
, const char *op
) {
693 const char *t
= luaT_objtypename(L
, o
);
694 luaG_runerror(L
, "attempt to %s a %s value%s", op
, t
, varinfo(L
, o
));
698 l_noret
luaG_callerror (lua_State
*L
, const TValue
*o
) {
699 CallInfo
*ci
= L
->ci
;
700 const char *name
= NULL
; /* to avoid warnings */
701 const char *what
= (isLua(ci
)) ? funcnamefromcode(L
, ci
, &name
) : NULL
;
703 const char *t
= luaT_objtypename(L
, o
);
704 luaG_runerror(L
, "%s '%s' is not callable (a %s value)", what
, name
, t
);
707 luaG_typeerror(L
, o
, "call");
711 l_noret
luaG_forerror (lua_State
*L
, const TValue
*o
, const char *what
) {
712 luaG_runerror(L
, "bad 'for' %s (number expected, got %s)",
713 what
, luaT_objtypename(L
, o
));
717 l_noret
luaG_concaterror (lua_State
*L
, const TValue
*p1
, const TValue
*p2
) {
718 if (ttisstring(p1
) || cvt2str(p1
)) p1
= p2
;
719 luaG_typeerror(L
, p1
, "concatenate");
723 l_noret
luaG_opinterror (lua_State
*L
, const TValue
*p1
,
724 const TValue
*p2
, const char *msg
) {
725 if (!ttisnumber(p1
)) /* first operand is wrong? */
726 p2
= p1
; /* now second is wrong */
727 luaG_typeerror(L
, p2
, msg
);
732 ** Error when both values are convertible to numbers, but not to integers
734 l_noret
luaG_tointerror (lua_State
*L
, const TValue
*p1
, const TValue
*p2
) {
736 if (!luaV_tointegerns(p1
, &temp
, LUA_FLOORN2I
))
738 luaG_runerror(L
, "number%s has no integer representation", varinfo(L
, p2
));
742 l_noret
luaG_ordererror (lua_State
*L
, const TValue
*p1
, const TValue
*p2
) {
743 const char *t1
= luaT_objtypename(L
, p1
);
744 const char *t2
= luaT_objtypename(L
, p2
);
745 if (strcmp(t1
, t2
) == 0)
746 luaG_runerror(L
, "attempt to compare two %s values", t1
);
748 luaG_runerror(L
, "attempt to compare %s with %s", t1
, t2
);
752 /* add src:line information to 'msg' */
753 const char *luaG_addinfo (lua_State
*L
, const char *msg
, TString
*src
,
755 char buff
[LUA_IDSIZE
];
757 luaO_chunkid(buff
, getstr(src
), tsslen(src
));
758 else { /* no source available; use "?" instead */
759 buff
[0] = '?'; buff
[1] = '\0';
761 return luaO_pushfstring(L
, "%s:%d: %s", buff
, line
, msg
);
765 l_noret
luaG_errormsg (lua_State
*L
) {
766 if (L
->errfunc
!= 0) { /* is there an error handling function? */
767 StkId errfunc
= restorestack(L
, L
->errfunc
);
768 lua_assert(ttisfunction(s2v(errfunc
)));
769 setobjs2s(L
, L
->top
, L
->top
- 1); /* move argument */
770 setobjs2s(L
, L
->top
- 1, errfunc
); /* push function */
771 L
->top
++; /* assume EXTRA_STACK */
772 luaD_callnoyield(L
, L
->top
- 2, 1); /* call it */
774 luaD_throw(L
, LUA_ERRRUN
);
778 l_noret
luaG_runerror (lua_State
*L
, const char *fmt
, ...) {
779 CallInfo
*ci
= L
->ci
;
782 luaC_checkGC(L
); /* error message uses memory */
784 msg
= luaO_pushvfstring(L
, fmt
, argp
); /* format message */
786 if (isLua(ci
)) /* if Lua function, add source:line information */
787 luaG_addinfo(L
, msg
, ci_func(ci
)->p
->source
, getcurrentline(ci
));
793 ** Check whether new instruction 'newpc' is in a different line from
794 ** previous instruction 'oldpc'. More often than not, 'newpc' is only
795 ** one or a few instructions after 'oldpc' (it must be after, see
796 ** caller), so try to avoid calling 'luaG_getfuncline'. If they are
797 ** too far apart, there is a good chance of a ABSLINEINFO in the way,
798 ** so it goes directly to 'luaG_getfuncline'.
800 static int changedline (const Proto
*p
, int oldpc
, int newpc
) {
801 if (p
->lineinfo
== NULL
) /* no debug information? */
803 if (newpc
- oldpc
< MAXIWTHABS
/ 2) { /* not too far apart? */
804 int delta
= 0; /* line diference */
807 int lineinfo
= p
->lineinfo
[++pc
];
808 if (lineinfo
== ABSLINEINFO
)
809 break; /* cannot compute delta; fall through */
812 return (delta
!= 0); /* delta computed successfully */
815 /* either instructions are too far apart or there is an absolute line
816 info in the way; compute line difference explicitly */
817 return (luaG_getfuncline(p
, oldpc
) != luaG_getfuncline(p
, newpc
));
822 ** Traces the execution of a Lua function. Called before the execution
823 ** of each opcode, when debug is on. 'L->oldpc' stores the last
824 ** instruction traced, to detect line changes. When entering a new
825 ** function, 'npci' will be zero and will test as a new line whatever
826 ** the value of 'oldpc'. Some exceptional conditions may return to
827 ** a function without setting 'oldpc'. In that case, 'oldpc' may be
828 ** invalid; if so, use zero as a valid value. (A wrong but valid 'oldpc'
829 ** at most causes an extra call to a line hook.)
830 ** This function is not "Protected" when called, so it should correct
831 ** 'L->top' before calling anything that can run the GC.
833 int luaG_traceexec (lua_State
*L
, const Instruction
*pc
) {
834 CallInfo
*ci
= L
->ci
;
835 lu_byte mask
= L
->hookmask
;
836 const Proto
*p
= ci_func(ci
)->p
;
838 if (!(mask
& (LUA_MASKLINE
| LUA_MASKCOUNT
))) { /* no hooks? */
839 ci
->u
.l
.trap
= 0; /* don't need to stop again */
840 return 0; /* turn off 'trap' */
842 pc
++; /* reference is always next instruction */
843 ci
->u
.l
.savedpc
= pc
; /* save 'pc' */
844 counthook
= (--L
->hookcount
== 0 && (mask
& LUA_MASKCOUNT
));
846 resethookcount(L
); /* reset count */
847 else if (!(mask
& LUA_MASKLINE
))
848 return 1; /* no line hook and count != 0; nothing to be done now */
849 if (ci
->callstatus
& CIST_HOOKYIELD
) { /* called hook last time? */
850 ci
->callstatus
&= ~CIST_HOOKYIELD
; /* erase mark */
851 return 1; /* do not call hook again (VM yielded, so it did not move) */
853 if (!isIT(*(ci
->u
.l
.savedpc
- 1))) /* top not being used? */
854 L
->top
= ci
->top
; /* correct top */
856 luaD_hook(L
, LUA_HOOKCOUNT
, -1, 0, 0); /* call count hook */
857 if (mask
& LUA_MASKLINE
) {
858 /* 'L->oldpc' may be invalid; use zero in this case */
859 int oldpc
= (L
->oldpc
< p
->sizecode
) ? L
->oldpc
: 0;
860 int npci
= pcRel(pc
, p
);
861 if (npci
<= oldpc
|| /* call hook when jump back (loop), */
862 changedline(p
, oldpc
, npci
)) { /* or when enter new line */
863 int newline
= luaG_getfuncline(p
, npci
);
864 luaD_hook(L
, LUA_HOOKLINE
, newline
, 0, 0); /* call line hook */
866 L
->oldpc
= npci
; /* 'pc' of last call to line hook */
868 if (L
->status
== LUA_YIELD
) { /* did hook yield? */
870 L
->hookcount
= 1; /* undo decrement to zero */
871 ci
->u
.l
.savedpc
--; /* undo increment (resume will increment it again) */
872 ci
->callstatus
|= CIST_HOOKYIELD
; /* mark that it yielded */
873 luaD_throw(L
, LUA_YIELD
);
875 return 1; /* keep 'trap' on */