LLVMFuzzerTestOneInput: 145| 6|LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 146| 6| lua_State *L = luaL_newstate(); 147| 6| if (L == NULL) { ------------------ | Branch (147:9): [True: 0, False: 6] ------------------ 148| 0| return 0; 149| 0| } 150| 6| dochunk(L, luaL_loadbufferx(L, data, size, "test", "t")); 151| | 152| 6| lua_close(L); 153| 6| return 0; 154| 6|} fuzz_lua.c:dochunk: 134| 6|static int dochunk (lua_State *L, int status) { 135| 6| if (status == LUA_OK) status = docall(L, 0, 0); ------------------ | | 49| 6|#define LUA_OK 0 ------------------ | Branch (135:7): [True: 0, False: 6] ------------------ 136| 6| return report(L, status); 137| 6|} fuzz_lua.c:report: 89| 6|static int report (lua_State *L, int status) { 90| 6| if (status != LUA_OK) { ------------------ | | 49| 6|#define LUA_OK 0 ------------------ | Branch (90:7): [True: 6, False: 0] ------------------ 91| 6| const char *msg = lua_tostring(L, -1); ------------------ | | 397| 6|#define lua_tostring(L,i) lua_tolstring(L, (i), NULL) ------------------ 92| 6| l_message(progname, msg); 93| 6| lua_pop(L, 1); /* remove message */ ------------------ | | 375| 6|#define lua_pop(L,n) lua_settop(L, -(n)-1) ------------------ 94| 6| } 95| 6| return status; 96| 6|} fuzz_lua.c:l_message: 78| 6|static void l_message (const char *pname, const char *msg) { 79| 6| if (pname) lua_writestringerror("%s: ", pname); ------------------ | | 271| 6| (fprintf(stderr, (s), (p)), fflush(stderr)) ------------------ | Branch (79:7): [True: 6, False: 0] ------------------ 80| 6| lua_writestringerror("%s\n", msg); ------------------ | | 271| 6| (fprintf(stderr, (s), (p)), fflush(stderr)) ------------------ 81| 6|} lua_atpanic: 144| 6|LUA_API lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf) { 145| 6| lua_CFunction old; 146| 6| lua_lock(L); ------------------ | | 264| 6|#define lua_lock(L) ((void) 0) ------------------ 147| 6| old = G(L)->panic; ------------------ | | 335| 6|#define G(L) (L->l_G) ------------------ 148| 6| G(L)->panic = panicf; ------------------ | | 335| 6|#define G(L) (L->l_G) ------------------ 149| 6| lua_unlock(L); ------------------ | | 265| 6|#define lua_unlock(L) ((void) 0) ------------------ 150| 6| return old; 151| 6|} lua_settop: 181| 6|LUA_API void lua_settop (lua_State *L, int idx) { 182| 6| CallInfo *ci; 183| 6| StkId func, newtop; 184| 6| ptrdiff_t diff; /* difference for new top */ 185| 6| lua_lock(L); ------------------ | | 264| 6|#define lua_lock(L) ((void) 0) ------------------ 186| 6| ci = L->ci; 187| 6| func = ci->func.p; 188| 6| if (idx >= 0) { ------------------ | Branch (188:7): [True: 0, False: 6] ------------------ 189| 0| api_check(L, idx <= ci->top.p - (func + 1), "new top too large"); ------------------ | | 126| 0|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 123| 0|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | ------------------ | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 190| 0| diff = ((func + 1) + idx) - L->top.p; 191| 0| for (; diff > 0; diff--) ------------------ | Branch (191:12): [True: 0, False: 0] ------------------ 192| 0| setnilvalue(s2v(L->top.p++)); /* clear new slots */ ------------------ | | 200| 0|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 193| 0| } 194| 6| else { 195| 6| api_check(L, -(idx+1) <= (L->top.p - (func + 1)), "invalid new top"); ------------------ | | 126| 6|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 123| 6|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | ------------------ | | | | | | 114| 6|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 196| 6| diff = idx + 1; /* will "subtract" index (as it is negative) */ 197| 6| } 198| 6| api_check(L, L->tbclist.p < L->top.p, "previous pop of an unclosed slot"); ------------------ | | 126| 6|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 123| 6|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | ------------------ | | | | | | 114| 6|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 199| 6| newtop = L->top.p + diff; 200| 6| if (diff < 0 && L->tbclist.p >= newtop) { ------------------ | Branch (200:7): [True: 6, False: 0] | Branch (200:19): [True: 0, False: 6] ------------------ 201| 0| lua_assert(hastocloseCfunc(ci->nresults)); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 202| 0| newtop = luaF_close(L, newtop, CLOSEKTOP, 0); ------------------ | | 47| 0|#define CLOSEKTOP (-1) ------------------ 203| 0| } 204| 6| L->top.p = newtop; /* correct top only after closing any upvalue */ 205| 6| lua_unlock(L); ------------------ | | 265| 6|#define lua_unlock(L) ((void) 0) ------------------ 206| 6|} lua_tolstring: 405| 6|LUA_API const char *lua_tolstring (lua_State *L, int idx, size_t *len) { 406| 6| TValue *o; 407| 6| lua_lock(L); ------------------ | | 264| 6|#define lua_lock(L) ((void) 0) ------------------ 408| 6| o = index2value(L, idx); 409| 6| if (!ttisstring(o)) { ------------------ | | 363| 6|#define ttisstring(o) checktype((o), LUA_TSTRING) | | ------------------ | | | | 92| 6|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 6|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 6|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (409:7): [True: 0, False: 6] ------------------ 410| 0| if (!cvt2str(o)) { /* not convertible? */ ------------------ | | 17| 0|#define cvt2str(o) ttisnumber(o) | | ------------------ | | | | 326| 0|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | | | ------------------ | | | | | | 92| 0|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 0|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 0|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (410:9): [True: 0, False: 0] ------------------ 411| 0| if (len != NULL) *len = 0; ------------------ | Branch (411:11): [True: 0, False: 0] ------------------ 412| 0| lua_unlock(L); ------------------ | | 265| 0|#define lua_unlock(L) ((void) 0) ------------------ 413| 0| return NULL; 414| 0| } 415| 0| luaO_tostring(L, o); 416| 0| luaC_checkGC(L); ------------------ | | 172| 0|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 168| 0| { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 335| 0|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (168:8): [True: 0, False: 0] | | | | ------------------ | | | | 169| 0| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 374| 0|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 417| 0| o = index2value(L, idx); /* previous call may reallocate the stack */ 418| 0| } 419| 6| if (len != NULL) ------------------ | Branch (419:7): [True: 0, False: 6] ------------------ 420| 0| *len = vslen(o); ------------------ | | 413| 0|#define vslen(o) tsslen(tsvalue(o)) | | ------------------ | | | | 410| 0|#define tsslen(s) ((s)->tt == LUA_VSHRSTR ? (s)->shrlen : (s)->u.lnglen) | | | | ------------------ | | | | | | 360| 0|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | | | | | ------------------ | | | | | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (410:20): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 421| 6| lua_unlock(L); ------------------ | | 265| 6|#define lua_unlock(L) ((void) 0) ------------------ 422| 6| return svalue(o); ------------------ | | 407| 6|#define svalue(o) getstr(tsvalue(o)) | | ------------------ | | | | 403| 6|#define getstr(ts) ((ts)->contents) | | ------------------ ------------------ 423| 6|} lua_load: 1088| 6| const char *chunkname, const char *mode) { 1089| 6| ZIO z; 1090| 6| int status; 1091| 6| lua_lock(L); ------------------ | | 264| 6|#define lua_lock(L) ((void) 0) ------------------ 1092| 6| if (!chunkname) chunkname = "?"; ------------------ | Branch (1092:7): [True: 0, False: 6] ------------------ 1093| 6| luaZ_init(L, &z, reader, data); 1094| 6| status = luaD_protectedparser(L, &z, chunkname, mode); 1095| 6| if (status == LUA_OK) { /* no errors? */ ------------------ | | 49| 6|#define LUA_OK 0 ------------------ | Branch (1095:7): [True: 0, False: 6] ------------------ 1096| 0| LClosure *f = clLvalue(s2v(L->top.p - 1)); /* get new function */ ------------------ | | 604| 0|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 1097| 0| if (f->nupvalues >= 1) { /* does it have an upvalue? */ ------------------ | Branch (1097:9): [True: 0, False: 0] ------------------ 1098| | /* get global table from registry */ 1099| 0| const TValue *gt = getGtable(L); ------------------ | | 663| 0| (&hvalue(&G(L)->l_registry)->array[LUA_RIDX_GLOBALS - 1]) | | ------------------ | | | | 684| 0|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | (&hvalue(&G(L)->l_registry)->array[LUA_RIDX_GLOBALS - 1]) | | ------------------ | | | | 85| 0|#define LUA_RIDX_GLOBALS 2 | | ------------------ ------------------ 1100| | /* set global table as 1st upvalue of 'f' (may be LUA_ENV) */ 1101| 0| setobj(L, f->upvals[0]->v.p, gt); ------------------ | | 119| 0| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | 120| 0| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 121| 0| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 114| 0|#define lua_assert(c) ((void)0) | | ------------------ ------------------ 1102| 0| luaC_barrier(L, f->upvals[0], gt); ------------------ | | 179| 0|#define luaC_barrier(L,p,v) ( \ | | 180| 0| iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 300| 0|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 298| 0|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (300:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 175| 0|#define luaC_objbarrier(L,p,o) ( \ | | | | 176| 0| (isblack(p) && iswhite(o)) ? \ | | | | ------------------ | | | | | | 88| 0|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | ------------------ | | | | | | | | 67| 0|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | ------------------ | | | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (isblack(p) && iswhite(o)) ? \ | | | | ------------------ | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 177| 0| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 138| 0|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 138| 0|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1103| 0| } 1104| 0| } 1105| 6| lua_unlock(L); ------------------ | | 265| 6|#define lua_unlock(L) ((void) 0) ------------------ 1106| 6| return status; 1107| 6|} lua_setwarnf: 1327| 6|void lua_setwarnf (lua_State *L, lua_WarnFunction f, void *ud) { 1328| 6| lua_lock(L); ------------------ | | 264| 6|#define lua_lock(L) ((void) 0) ------------------ 1329| 6| G(L)->ud_warn = ud; ------------------ | | 335| 6|#define G(L) (L->l_G) ------------------ 1330| 6| G(L)->warnf = f; ------------------ | | 335| 6|#define G(L) (L->l_G) ------------------ 1331| 6| lua_unlock(L); ------------------ | | 265| 6|#define lua_unlock(L) ((void) 0) ------------------ 1332| 6|} lapi.c:index2value: 60| 6|static TValue *index2value (lua_State *L, int idx) { 61| 6| CallInfo *ci = L->ci; 62| 6| if (idx > 0) { ------------------ | Branch (62:7): [True: 0, False: 6] ------------------ 63| 0| StkId o = ci->func.p + idx; 64| 0| api_check(L, idx <= ci->top.p - (ci->func.p + 1), "unacceptable index"); ------------------ | | 126| 0|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 123| 0|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | ------------------ | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 65| 0| if (o >= L->top.p) return &G(L)->nilvalue; ------------------ | | 335| 0|#define G(L) (L->l_G) ------------------ | Branch (65:9): [True: 0, False: 0] ------------------ 66| 0| else return s2v(o); ------------------ | | 172| 0|#define s2v(o) (&(o)->val) ------------------ 67| 0| } 68| 6| else if (!ispseudo(idx)) { /* negative index */ ------------------ | | 50| 6|#define ispseudo(i) ((i) <= LUA_REGISTRYINDEX) | | ------------------ | | | | 44| 6|#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000) | | | | ------------------ | | | | | | 740| 6|#define LUAI_MAXSTACK 1000000 | | | | ------------------ | | ------------------ ------------------ | Branch (68:12): [True: 6, False: 0] ------------------ 69| 6| api_check(L, idx != 0 && -idx <= L->top.p - (ci->func.p + 1), ------------------ | | 126| 6|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 123| 6|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | ------------------ | | | | | | 114| 6|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 70| 6| "invalid index"); 71| 6| return s2v(L->top.p + idx); ------------------ | | 172| 6|#define s2v(o) (&(o)->val) ------------------ 72| 6| } 73| 0| else if (idx == LUA_REGISTRYINDEX) ------------------ | | 44| 0|#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000) | | ------------------ | | | | 740| 0|#define LUAI_MAXSTACK 1000000 | | ------------------ ------------------ | Branch (73:12): [True: 0, False: 0] ------------------ 74| 0| return &G(L)->l_registry; ------------------ | | 335| 0|#define G(L) (L->l_G) ------------------ 75| 0| else { /* upvalues */ 76| 0| idx = LUA_REGISTRYINDEX - idx; ------------------ | | 44| 0|#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000) | | ------------------ | | | | 740| 0|#define LUAI_MAXSTACK 1000000 | | ------------------ ------------------ 77| 0| api_check(L, idx <= MAXUPVAL + 1, "upvalue index too large"); ------------------ | | 126| 0|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 123| 0|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | ------------------ | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 78| 0| if (ttisCclosure(s2v(ci->func.p))) { /* C closure? */ ------------------ | | 597| 0|#define ttisCclosure(o) checktag((o), ctb(LUA_VCCL)) | | ------------------ | | | | 91| 0|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 79| 0| CClosure *func = clCvalue(s2v(ci->func.p)); ------------------ | | 606| 0|#define clCvalue(o) check_exp(ttisCclosure(o), gco2ccl(val_(o).gc)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 80| 0| return (idx <= func->nupvalues) ? &func->upvalue[idx-1] ------------------ | Branch (80:14): [True: 0, False: 0] ------------------ 81| 0| : &G(L)->nilvalue; ------------------ | | 335| 0|#define G(L) (L->l_G) ------------------ 82| 0| } 83| 0| else { /* light C function or Lua function (through a hook)?) */ 84| 0| api_check(L, ttislcf(s2v(ci->func.p)), "caller not a C function"); ------------------ | | 126| 0|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 123| 0|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | ------------------ | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 85| 0| return &G(L)->nilvalue; /* no upvalues */ ------------------ | | 335| 0|#define G(L) (L->l_G) ------------------ 86| 0| } 87| 0| } 88| 6|} luaL_loadbufferx: 835| 6| const char *name, const char *mode) { 836| 6| LoadS ls; 837| 6| ls.s = buff; 838| 6| ls.size = size; 839| 6| return lua_load(L, getS, &ls, name, mode); 840| 6|} luaL_newstate: 1094| 6|LUALIB_API lua_State *luaL_newstate (void) { 1095| 6| lua_State *L = lua_newstate(l_alloc, NULL); 1096| 6| if (l_likely(L)) { ------------------ | | 687| 6|#define l_likely(x) luai_likely(x) | | ------------------ | | | | 675| 6|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | ------------------ | | | | | Branch (675:25): [True: 6, False: 0] | | | | ------------------ | | ------------------ ------------------ 1097| 6| lua_atpanic(L, &panic); 1098| 6| lua_setwarnf(L, warnfoff, L); /* default is warnings off */ 1099| 6| } 1100| 6| return L; 1101| 6|} lauxlib.c:getS: 824| 7|static const char *getS (lua_State *L, void *ud, size_t *size) { 825| 7| LoadS *ls = (LoadS *)ud; 826| 7| (void)L; /* not used */ 827| 7| if (ls->size == 0) return NULL; ------------------ | Branch (827:7): [True: 1, False: 6] ------------------ 828| 6| *size = ls->size; 829| 6| ls->size = 0; 830| 6| return ls->s; 831| 7|} lauxlib.c:l_alloc: 1017| 877|static void *l_alloc (void *ud, void *ptr, size_t osize, size_t nsize) { 1018| 877| (void)ud; (void)osize; /* not used */ 1019| 877| if (nsize == 0) { ------------------ | Branch (1019:7): [True: 458, False: 419] ------------------ 1020| 458| free(ptr); 1021| 458| return NULL; 1022| 458| } 1023| 419| else 1024| 419| return realloc(ptr, nsize); 1025| 877|} luaK_code: 382| 8|int luaK_code (FuncState *fs, Instruction i) { 383| 8| Proto *f = fs->f; 384| | /* put new instruction in code array */ 385| 8| luaM_growvector(fs->ls->L, f->code, fs->pc, f->sizecode, Instruction, ------------------ | | 67| 8| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 136| 16|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 68| 8| luaM_limitN(limit,t),e))) ------------------ 386| 8| MAX_INT, "opcodes"); 387| 8| f->code[fs->pc++] = i; 388| 8| savelineinfo(fs, f, fs->ls->lastline); 389| 8| return fs->pc - 1; /* index of new instruction */ 390| 8|} luaK_codeABCk: 397| 7|int luaK_codeABCk (FuncState *fs, OpCode o, int a, int b, int c, int k) { 398| 7| lua_assert(getOpMode(o) == iABC); ------------------ | | 114| 7|#define lua_assert(c) ((void)0) ------------------ 399| 7| lua_assert(a <= MAXARG_A && b <= MAXARG_B && ------------------ | | 114| 7|#define lua_assert(c) ((void)0) ------------------ 400| 7| c <= MAXARG_C && (k & ~1) == 0); 401| 7| return luaK_code(fs, CREATE_ABCk(o, a, b, c, k)); ------------------ | | 156| 7|#define CREATE_ABCk(o,a,b,c,k) ((cast(Instruction, o)<freereg + n; 468| 2| if (newstack > fs->f->maxstacksize) { ------------------ | Branch (468:7): [True: 0, False: 2] ------------------ 469| 0| if (newstack >= MAXREGS) ------------------ | | 35| 0|#define MAXREGS 255 ------------------ | Branch (469:9): [True: 0, False: 0] ------------------ 470| 0| luaX_syntaxerror(fs->ls, 471| 0| "function or expression needs too many registers"); 472| 0| fs->f->maxstacksize = cast_byte(newstack); ------------------ | | 143| 0|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 473| 0| } 474| 2|} luaK_reserveregs: 480| 2|void luaK_reserveregs (FuncState *fs, int n) { 481| 2| luaK_checkstack(fs, n); 482| 2| fs->freereg += n; 483| 2|} luaK_dischargevars: 772| 6|void luaK_dischargevars (FuncState *fs, expdesc *e) { 773| 6| switch (e->k) { 774| 0| case VCONST: { ------------------ | Branch (774:5): [True: 0, False: 6] ------------------ 775| 0| const2exp(const2val(fs, e), e); 776| 0| break; 777| 0| } 778| 0| case VLOCAL: { /* already in a register */ ------------------ | Branch (778:5): [True: 0, False: 6] ------------------ 779| 0| e->u.info = e->u.var.ridx; 780| 0| e->k = VNONRELOC; /* becomes a non-relocatable value */ 781| 0| break; 782| 0| } 783| 1| case VUPVAL: { /* move value to some (pending) register */ ------------------ | Branch (783:5): [True: 1, False: 5] ------------------ 784| 1| e->u.info = luaK_codeABC(fs, OP_GETUPVAL, 0, e->u.info, 0); ------------------ | | 48| 1|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 785| 1| e->k = VRELOC; 786| 1| break; 787| 0| } 788| 0| case VINDEXUP: { ------------------ | Branch (788:5): [True: 0, False: 6] ------------------ 789| 0| e->u.info = luaK_codeABC(fs, OP_GETTABUP, 0, e->u.ind.t, e->u.ind.idx); ------------------ | | 48| 0|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 790| 0| e->k = VRELOC; 791| 0| break; 792| 0| } 793| 0| case VINDEXI: { ------------------ | Branch (793:5): [True: 0, False: 6] ------------------ 794| 0| freereg(fs, e->u.ind.t); 795| 0| e->u.info = luaK_codeABC(fs, OP_GETI, 0, e->u.ind.t, e->u.ind.idx); ------------------ | | 48| 0|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 796| 0| e->k = VRELOC; 797| 0| break; 798| 0| } 799| 0| case VINDEXSTR: { ------------------ | Branch (799:5): [True: 0, False: 6] ------------------ 800| 0| freereg(fs, e->u.ind.t); 801| 0| e->u.info = luaK_codeABC(fs, OP_GETFIELD, 0, e->u.ind.t, e->u.ind.idx); ------------------ | | 48| 0|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 802| 0| e->k = VRELOC; 803| 0| break; 804| 0| } 805| 0| case VINDEXED: { ------------------ | Branch (805:5): [True: 0, False: 6] ------------------ 806| 0| freeregs(fs, e->u.ind.t, e->u.ind.idx); 807| 0| e->u.info = luaK_codeABC(fs, OP_GETTABLE, 0, e->u.ind.t, e->u.ind.idx); ------------------ | | 48| 0|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 808| 0| e->k = VRELOC; 809| 0| break; 810| 0| } 811| 0| case VVARARG: case VCALL: { ------------------ | Branch (811:5): [True: 0, False: 6] | Branch (811:19): [True: 0, False: 6] ------------------ 812| 0| luaK_setoneret(fs, e); 813| 0| break; 814| 0| } 815| 5| default: break; /* there is one value available (somewhere) */ ------------------ | Branch (815:5): [True: 5, False: 1] ------------------ 816| 6| } 817| 6|} luaK_exp2nextreg: 942| 2|void luaK_exp2nextreg (FuncState *fs, expdesc *e) { 943| 2| luaK_dischargevars(fs, e); 944| 2| freeexp(fs, e); 945| 2| luaK_reserveregs(fs, 1); 946| 2| exp2reg(fs, e, fs->freereg - 1); 947| 2|} luaK_exp2anyreg: 954| 2|int luaK_exp2anyreg (FuncState *fs, expdesc *e) { 955| 2| luaK_dischargevars(fs, e); 956| 2| if (e->k == VNONRELOC) { /* expression already has a register? */ ------------------ | Branch (956:7): [True: 0, False: 2] ------------------ 957| 0| if (!hasjumps(e)) /* no jumps? */ ------------------ | | 38| 0|#define hasjumps(e) ((e)->t != (e)->f) ------------------ | Branch (957:9): [True: 0, False: 0] ------------------ 958| 0| return e->u.info; /* result is already in a register */ 959| 0| if (e->u.info >= luaY_nvarstack(fs)) { /* reg. is not a local? */ ------------------ | Branch (959:9): [True: 0, False: 0] ------------------ 960| 0| exp2reg(fs, e, e->u.info); /* put final result in it */ 961| 0| return e->u.info; 962| 0| } 963| | /* else expression has jumps and cannot change its register 964| | to hold the jump values, because it is a local variable. 965| | Go through to the default case. */ 966| 0| } 967| 2| luaK_exp2nextreg(fs, e); /* default: use next available register */ 968| 2| return e->u.info; 969| 2|} luaK_exp2anyregup: 976| 3|void luaK_exp2anyregup (FuncState *fs, expdesc *e) { 977| 3| if (e->k != VUPVAL || hasjumps(e)) ------------------ | | 38| 3|#define hasjumps(e) ((e)->t != (e)->f) | | ------------------ | | | Branch (38:21): [True: 0, False: 3] | | ------------------ ------------------ | Branch (977:7): [True: 0, False: 3] ------------------ 978| 0| luaK_exp2anyreg(fs, e); 979| 3|} luaK_isKint: 1228| 1|int luaK_isKint (expdesc *e) { 1229| 1| return (e->k == VKINT && !hasjumps(e)); ------------------ | | 38| 0|#define hasjumps(e) ((e)->t != (e)->f) ------------------ | Branch (1229:11): [True: 0, False: 1] | Branch (1229:28): [True: 0, False: 0] ------------------ 1230| 1|} luaK_indexed: 1278| 3|void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k) { 1279| 3| if (k->k == VKSTR) ------------------ | Branch (1279:7): [True: 3, False: 0] ------------------ 1280| 3| str2K(fs, k); 1281| 3| lua_assert(!hasjumps(t) && ------------------ | | 114| 3|#define lua_assert(c) ((void)0) ------------------ 1282| 3| (t->k == VLOCAL || t->k == VNONRELOC || t->k == VUPVAL)); 1283| 3| if (t->k == VUPVAL && !isKstr(fs, k)) /* upvalue indexed by non 'Kstr'? */ ------------------ | Branch (1283:7): [True: 3, False: 0] | Branch (1283:25): [True: 1, False: 2] ------------------ 1284| 1| luaK_exp2anyreg(fs, t); /* put it in a register */ 1285| 3| if (t->k == VUPVAL) { ------------------ | Branch (1285:7): [True: 2, False: 1] ------------------ 1286| 2| t->u.ind.t = t->u.info; /* upvalue index */ 1287| 2| t->u.ind.idx = k->u.info; /* literal string */ 1288| 2| t->k = VINDEXUP; 1289| 2| } 1290| 1| else { 1291| | /* register index of the table */ 1292| 1| t->u.ind.t = (t->k == VLOCAL) ? t->u.var.ridx: t->u.info; ------------------ | Branch (1292:18): [True: 0, False: 1] ------------------ 1293| 1| if (isKstr(fs, k)) { ------------------ | Branch (1293:9): [True: 0, False: 1] ------------------ 1294| 0| t->u.ind.idx = k->u.info; /* literal string */ 1295| 0| t->k = VINDEXSTR; 1296| 0| } 1297| 1| else if (isCint(k)) { ------------------ | Branch (1297:14): [True: 0, False: 1] ------------------ 1298| 0| t->u.ind.idx = cast_int(k->u.ival); /* int. constant in proper range */ ------------------ | | 141| 0|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1299| 0| t->k = VINDEXI; 1300| 0| } 1301| 1| else { 1302| 1| t->u.ind.idx = luaK_exp2anyreg(fs, k); /* register */ 1303| 1| t->k = VINDEXED; 1304| 1| } 1305| 1| } 1306| 3|} lcode.c:savelineinfo: 329| 8|static void savelineinfo (FuncState *fs, Proto *f, int line) { 330| 8| int linedif = line - fs->previousline; 331| 8| int pc = fs->pc - 1; /* last instruction coded */ 332| 8| if (abs(linedif) >= LIMLINEDIFF || fs->iwthabs++ >= MAXIWTHABS) { ------------------ | | 319| 16|#define LIMLINEDIFF 0x80 ------------------ if (abs(linedif) >= LIMLINEDIFF || fs->iwthabs++ >= MAXIWTHABS) { ------------------ | | 35| 8|#define MAXIWTHABS 128 ------------------ | Branch (332:7): [True: 0, False: 8] | Branch (332:38): [True: 0, False: 8] ------------------ 333| 0| luaM_growvector(fs->ls->L, f->abslineinfo, fs->nabslineinfo, ------------------ | | 67| 0| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 68| 0| luaM_limitN(limit,t),e))) ------------------ 334| 0| f->sizeabslineinfo, AbsLineInfo, MAX_INT, "lines"); 335| 0| f->abslineinfo[fs->nabslineinfo].pc = pc; 336| 0| f->abslineinfo[fs->nabslineinfo++].line = line; 337| 0| linedif = ABSLINEINFO; /* signal that there is absolute information */ ------------------ | | 27| 0|#define ABSLINEINFO (-0x80) ------------------ 338| 0| fs->iwthabs = 1; /* restart counter */ 339| 0| } 340| 8| luaM_growvector(fs->ls->L, f->lineinfo, pc, f->sizelineinfo, ls_byte, ------------------ | | 67| 8| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 136| 16|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 68| 8| luaM_limitN(limit,t),e))) ------------------ 341| 8| MAX_INT, "opcodes"); 342| 8| f->lineinfo[pc] = linedif; 343| 8| fs->previousline = line; /* last line saved */ 344| 8|} lcode.c:luaK_codek: 451| 1|static int luaK_codek (FuncState *fs, int reg, int k) { 452| 1| if (k <= MAXARG_Bx) ------------------ | | 72| 1|#define MAXARG_Bx ((1<ls->L; 546| 3| Proto *f = fs->f; 547| 3| const TValue *idx = luaH_get(fs->ls->h, key); /* query scanner table */ 548| 3| int k, oldsize; 549| 3| if (ttisinteger(idx)) { /* is there an index there? */ ------------------ | | 328| 3|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 3|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 3|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 0, False: 3] | | | | ------------------ | | ------------------ ------------------ 550| 0| k = cast_int(ivalue(idx)); ------------------ | | 141| 0|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 551| | /* correct value? (warning: must distinguish floats from integers!) */ 552| 0| if (k < fs->nk && ttypetag(&f->k[k]) == ttypetag(v) && ------------------ | | 84| 0|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 0|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ if (k < fs->nk && ttypetag(&f->k[k]) == ttypetag(v) && ------------------ | | 84| 0|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 0|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ | Branch (552:9): [True: 0, False: 0] | Branch (552:23): [True: 0, False: 0] ------------------ 553| 0| luaV_rawequalobj(&f->k[k], v)) ------------------ | | 75| 0|#define luaV_rawequalobj(t1,t2) luaV_equalobj(NULL,t1,t2) | | ------------------ | | | Branch (75:34): [True: 0, False: 0] | | ------------------ ------------------ 554| 0| return k; /* reuse index */ 555| 0| } 556| | /* constant not found; create a new entry */ 557| 3| oldsize = f->sizek; 558| 3| k = fs->nk; 559| | /* numerical value does not need GC barrier; 560| | table has no metatable, so it does not need to invalidate cache */ 561| 3| setivalue(&val, k); ------------------ | | 345| 3| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 3|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 3|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 562| 3| luaH_finishset(L, fs->ls->h, key, idx, &val); 563| 3| luaM_growvector(L, f->k, k, f->sizek, TValue, MAXARG_Ax, "constants"); ------------------ | | 67| 3| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 136| 6|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 68| 3| luaM_limitN(limit,t),e))) ------------------ 564| 15| while (oldsize < f->sizek) setnilvalue(&f->k[oldsize++]); ------------------ | | 200| 12|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 15|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ | Branch (564:10): [True: 12, False: 3] ------------------ 565| 3| setobj(L, &f->k[k], v); ------------------ | | 119| 3| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | 120| 3| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | ------------------ | | | | 114| 3|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 121| 3| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 107| 3| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 3|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 3| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 114| 3|#define lua_assert(c) ((void)0) | | ------------------ ------------------ 566| 3| fs->nk++; 567| 3| luaC_barrier(L, f, v); ------------------ | | 179| 3|#define luaC_barrier(L,p,v) ( \ | | 180| 3| iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 300| 3|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 77| 3|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 298| 3|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (300:26): [True: 3, False: 0] | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 175| 3|#define luaC_objbarrier(L,p,o) ( \ | | | | 176| 3| (isblack(p) && iswhite(o)) ? \ | | | | ------------------ | | | | | | 88| 3|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | ------------------ | | | | | | | | 67| 3|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | ------------------ | | | | | | | | | | 62| 6|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (62:24): [True: 0, False: 3] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (isblack(p) && iswhite(o)) ? \ | | | | ------------------ | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 177| 3| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 138| 3|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 3|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 138| 0|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 568| 3| return k; 569| 3|} lcode.c:freeexp: 517| 2|static void freeexp (FuncState *fs, expdesc *e) { 518| 2| if (e->k == VNONRELOC) ------------------ | Branch (518:7): [True: 0, False: 2] ------------------ 519| 0| freereg(fs, e->u.info); 520| 2|} lcode.c:exp2reg: 914| 2|static void exp2reg (FuncState *fs, expdesc *e, int reg) { 915| 2| discharge2reg(fs, e, reg); 916| 2| if (e->k == VJMP) /* expression itself is a test? */ ------------------ | Branch (916:7): [True: 0, False: 2] ------------------ 917| 0| luaK_concat(fs, &e->t, e->u.info); /* put this jump in 't' list */ 918| 2| if (hasjumps(e)) { ------------------ | | 38| 2|#define hasjumps(e) ((e)->t != (e)->f) | | ------------------ | | | Branch (38:21): [True: 0, False: 2] | | ------------------ ------------------ 919| 0| int final; /* position after whole expression */ 920| 0| int p_f = NO_JUMP; /* position of an eventual LOAD false */ ------------------ | | 20| 0|#define NO_JUMP (-1) ------------------ 921| 0| int p_t = NO_JUMP; /* position of an eventual LOAD true */ ------------------ | | 20| 0|#define NO_JUMP (-1) ------------------ 922| 0| if (need_value(fs, e->t) || need_value(fs, e->f)) { ------------------ | Branch (922:9): [True: 0, False: 0] | Branch (922:33): [True: 0, False: 0] ------------------ 923| 0| int fj = (e->k == VJMP) ? NO_JUMP : luaK_jump(fs); ------------------ | | 20| 0|#define NO_JUMP (-1) ------------------ | Branch (923:16): [True: 0, False: 0] ------------------ 924| 0| p_f = code_loadbool(fs, reg, OP_LFALSESKIP); /* skip next inst. */ 925| 0| p_t = code_loadbool(fs, reg, OP_LOADTRUE); 926| | /* jump around these booleans if 'e' is not a test */ 927| 0| luaK_patchtohere(fs, fj); 928| 0| } 929| 0| final = luaK_getlabel(fs); 930| 0| patchlistaux(fs, e->f, final, reg, p_f); 931| 0| patchlistaux(fs, e->t, final, reg, p_t); 932| 0| } 933| 2| e->f = e->t = NO_JUMP; ------------------ | | 20| 2|#define NO_JUMP (-1) ------------------ 934| 2| e->u.info = reg; 935| 2| e->k = VNONRELOC; 936| 2|} lcode.c:discharge2reg: 825| 2|static void discharge2reg (FuncState *fs, expdesc *e, int reg) { 826| 2| luaK_dischargevars(fs, e); 827| 2| switch (e->k) { 828| 0| case VNIL: { ------------------ | Branch (828:5): [True: 0, False: 2] ------------------ 829| 0| luaK_nil(fs, reg, 1); 830| 0| break; 831| 0| } 832| 0| case VFALSE: { ------------------ | Branch (832:5): [True: 0, False: 2] ------------------ 833| 0| luaK_codeABC(fs, OP_LOADFALSE, reg, 0, 0); ------------------ | | 48| 0|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 834| 0| break; 835| 0| } 836| 0| case VTRUE: { ------------------ | Branch (836:5): [True: 0, False: 2] ------------------ 837| 0| luaK_codeABC(fs, OP_LOADTRUE, reg, 0, 0); ------------------ | | 48| 0|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 838| 0| break; 839| 0| } 840| 0| case VKSTR: { ------------------ | Branch (840:5): [True: 0, False: 2] ------------------ 841| 0| str2K(fs, e); 842| 0| } /* FALLTHROUGH */ 843| 1| case VK: { ------------------ | Branch (843:5): [True: 1, False: 1] ------------------ 844| 1| luaK_codek(fs, reg, e->u.info); 845| 1| break; 846| 0| } 847| 0| case VKFLT: { ------------------ | Branch (847:5): [True: 0, False: 2] ------------------ 848| 0| luaK_float(fs, reg, e->u.nval); 849| 0| break; 850| 0| } 851| 0| case VKINT: { ------------------ | Branch (851:5): [True: 0, False: 2] ------------------ 852| 0| luaK_int(fs, reg, e->u.ival); 853| 0| break; 854| 0| } 855| 1| case VRELOC: { ------------------ | Branch (855:5): [True: 1, False: 1] ------------------ 856| 1| Instruction *pc = &getinstruction(fs, e); ------------------ | | 55| 1|#define getinstruction(fs,e) ((fs)->f->code[(e)->u.info]) ------------------ 857| 1| SETARG_A(*pc, reg); /* instruction will put result in 'reg' */ ------------------ | | 126| 1|#define SETARG_A(i,v) setarg(i, v, POS_A, SIZE_A) | | ------------------ | | | | 122| 1|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 1|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 1|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 1| ((cast(Instruction, v)<u.info) ------------------ | Branch (861:11): [True: 0, False: 0] ------------------ 862| 0| luaK_codeABC(fs, OP_MOVE, reg, e->u.info, 0); ------------------ | | 48| 0|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 863| 0| break; 864| 0| } 865| 0| default: { ------------------ | Branch (865:5): [True: 0, False: 2] ------------------ 866| 0| lua_assert(e->k == VJMP); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 867| 0| return; /* nothing to do... */ 868| 0| } 869| 2| } 870| 2| e->u.info = reg; 871| 2| e->k = VNONRELOC; 872| 2|} lcode.c:stringK: 575| 3|static int stringK (FuncState *fs, TString *s) { 576| 3| TValue o; 577| 3| setsvalue(fs->ls->L, &o, s); ------------------ | | 372| 3| { TValue *io = (obj); TString *x_ = (x); \ | | 373| 3| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 72| 3|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 390| 3|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 3|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 114| 3|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 374| 3| checkliveness(L,io); } | | ------------------ | | | | 107| 3| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 3|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 3| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 578| 3| return addk(fs, &o, &o); /* use string itself as key */ 579| 3|} lcode.c:str2K: 737| 3|static void str2K (FuncState *fs, expdesc *e) { 738| 3| lua_assert(e->k == VKSTR); ------------------ | | 114| 3|#define lua_assert(c) ((void)0) ------------------ 739| 3| e->u.info = stringK(fs, e->u.strval); 740| 3| e->k = VK; 741| 3|} lcode.c:isKstr: 1220| 4|static int isKstr (FuncState *fs, expdesc *e) { 1221| 4| return (e->k == VK && !hasjumps(e) && e->u.info <= MAXARG_B && ------------------ | | 38| 8|#define hasjumps(e) ((e)->t != (e)->f) ------------------ return (e->k == VK && !hasjumps(e) && e->u.info <= MAXARG_B && ------------------ | | 96| 8|#define MAXARG_B ((1<f->k[e->u.info])); ------------------ | | 364| 4|#define ttisshrstring(o) checktag((o), ctb(LUA_VSHRSTR)) | | ------------------ | | | | 91| 4|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 4|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 2, False: 2] | | | | ------------------ | | ------------------ ------------------ 1223| 4|} lcode.c:isCint: 1237| 1|static int isCint (expdesc *e) { 1238| 1| return luaK_isKint(e) && (l_castS2U(e->u.ival) <= l_castS2U(MAXARG_C)); ------------------ | | 152| 0|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ return luaK_isKint(e) && (l_castS2U(e->u.ival) <= l_castS2U(MAXARG_C)); ------------------ | | 152| 0|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ | Branch (1238:10): [True: 0, False: 1] | Branch (1238:28): [True: 0, False: 0] ------------------ 1239| 1|} luaG_addinfo: 798| 6| int line) { 799| 6| char buff[LUA_IDSIZE]; 800| 6| if (src) ------------------ | Branch (800:7): [True: 6, False: 0] ------------------ 801| 6| luaO_chunkid(buff, getstr(src), tsslen(src)); ------------------ | | 403| 6|#define getstr(ts) ((ts)->contents) ------------------ luaO_chunkid(buff, getstr(src), tsslen(src)); ------------------ | | 410| 6|#define tsslen(s) ((s)->tt == LUA_VSHRSTR ? (s)->shrlen : (s)->u.lnglen) | | ------------------ | | | | 360| 6|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | | | ------------------ | | | | | | 42| 6|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | ------------------ | | ------------------ | | | Branch (410:20): [True: 6, False: 0] | | ------------------ ------------------ 802| 0| else { /* no source available; use "?" instead */ 803| 0| buff[0] = '?'; buff[1] = '\0'; 804| 0| } 805| 6| return luaO_pushfstring(L, "%s:%d: %s", buff, line, msg); 806| 6|} luaD_seterrorobj: 91| 6|void luaD_seterrorobj (lua_State *L, int errcode, StkId oldtop) { 92| 6| switch (errcode) { 93| 0| case LUA_ERRMEM: { /* memory error? */ ------------------ | | 53| 0|#define LUA_ERRMEM 4 ------------------ | Branch (93:5): [True: 0, False: 6] ------------------ 94| 0| setsvalue2s(L, oldtop, G(L)->memerrmsg); /* reuse preregistered msg. */ ------------------ | | 377| 0|#define setsvalue2s(L,o,s) setsvalue(L,s2v(o),s) | | ------------------ | | | | 372| 0| { TValue *io = (obj); TString *x_ = (x); \ | | | | 373| 0| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 72| 0|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 374| 0| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 95| 0| break; 96| 0| } 97| 0| case LUA_ERRERR: { ------------------ | | 54| 0|#define LUA_ERRERR 5 ------------------ | Branch (97:5): [True: 0, False: 6] ------------------ 98| 0| setsvalue2s(L, oldtop, luaS_newliteral(L, "error in error handling")); ------------------ | | 377| 0|#define setsvalue2s(L,o,s) setsvalue(L,s2v(o),s) | | ------------------ | | | | 372| 0| { TValue *io = (obj); TString *x_ = (x); \ | | | | 373| 0| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 72| 0|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 374| 0| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 99| 0| break; 100| 0| } 101| 0| case LUA_OK: { /* special case only for closing upvalues */ ------------------ | | 49| 0|#define LUA_OK 0 ------------------ | Branch (101:5): [True: 0, False: 6] ------------------ 102| 0| setnilvalue(s2v(oldtop)); /* no error message */ ------------------ | | 200| 0|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 103| 0| break; 104| 0| } 105| 6| default: { ------------------ | Branch (105:5): [True: 6, False: 0] ------------------ 106| 6| lua_assert(errorstatus(errcode)); /* real error */ ------------------ | | 114| 6|#define lua_assert(c) ((void)0) ------------------ 107| 6| setobjs2s(L, oldtop, L->top.p - 1); /* error message on current top */ ------------------ | | 129| 6|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 6| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 6| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 6|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 6| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 6| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 6|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 6| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 6|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 108| 6| break; 109| 0| } 110| 6| } 111| 6| L->top.p = oldtop + 1; 112| 6|} luaD_throw: 115| 6|l_noret luaD_throw (lua_State *L, int errcode) { 116| 6| if (L->errorJmp) { /* thread has an error handler? */ ------------------ | Branch (116:7): [True: 6, False: 0] ------------------ 117| 6| L->errorJmp->status = errcode; /* set status */ 118| 6| LUAI_THROW(L, L->errorJmp); /* jump to it */ ------------------ | | 66| 6|#define LUAI_THROW(L,c) _longjmp((c)->b, 1) ------------------ 119| 6| } 120| 0| else { /* thread has no error handler */ 121| 0| global_State *g = G(L); ------------------ | | 335| 0|#define G(L) (L->l_G) ------------------ 122| 0| errcode = luaE_resetthread(L, errcode); /* close all upvalues */ 123| 0| if (g->mainthread->errorJmp) { /* main thread has a handler? */ ------------------ | Branch (123:9): [True: 0, False: 0] ------------------ 124| 0| setobjs2s(L, g->mainthread->top.p++, L->top.p - 1); /* copy error obj. */ ------------------ | | 129| 0|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 0| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 0| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 0| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 125| 0| luaD_throw(g->mainthread, errcode); /* re-throw in main thread */ 126| 0| } 127| 0| else { /* no handler at all; abort */ 128| 0| if (g->panic) { /* panic function? */ ------------------ | Branch (128:11): [True: 0, False: 0] ------------------ 129| 0| lua_unlock(L); ------------------ | | 265| 0|#define lua_unlock(L) ((void) 0) ------------------ 130| 0| g->panic(L); /* call panic function (last chance to jump out) */ 131| 0| } 132| 0| abort(); 133| 0| } 134| 0| } 135| 6|} luaD_rawrunprotected: 138| 24|int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) { 139| 24| l_uint32 oldnCcalls = L->nCcalls; 140| 24| struct lua_longjmp lj; 141| 24| lj.status = LUA_OK; ------------------ | | 49| 24|#define LUA_OK 0 ------------------ 142| 24| lj.previous = L->errorJmp; /* chain new error handler */ 143| 24| L->errorJmp = &lj; 144| 24| LUAI_TRY(L, &lj, ------------------ | | 67| 24|#define LUAI_TRY(L,c,a) if (_setjmp((c)->b) == 0) { a } | | ------------------ | | | Branch (67:30): [True: 24, False: 0] | | ------------------ ------------------ 145| 24| (*f)(L, ud); 146| 24| ); 147| 24| L->errorJmp = lj.previous; /* restore old error handler */ 148| 24| L->nCcalls = oldnCcalls; 149| 24| return lj.status; 150| 24|} luaD_shrinkstack: 300| 9|void luaD_shrinkstack (lua_State *L) { 301| 9| int inuse = stackinuse(L); 302| 9| int max = (inuse > LUAI_MAXSTACK / 3) ? LUAI_MAXSTACK : inuse * 3; ------------------ | | 740| 9|#define LUAI_MAXSTACK 1000000 ------------------ int max = (inuse > LUAI_MAXSTACK / 3) ? LUAI_MAXSTACK : inuse * 3; ------------------ | | 740| 0|#define LUAI_MAXSTACK 1000000 ------------------ | Branch (302:13): [True: 0, False: 9] ------------------ 303| | /* if thread is currently not handling a stack overflow and its 304| | size is larger than maximum "reasonable" size, shrink it */ 305| 9| if (inuse <= LUAI_MAXSTACK && stacksize(L) > max) { ------------------ | | 740| 18|#define LUAI_MAXSTACK 1000000 ------------------ if (inuse <= LUAI_MAXSTACK && stacksize(L) > max) { ------------------ | | 147| 9|#define stacksize(th) cast_int((th)->stack_last.p - (th)->stack.p) | | ------------------ | | | | 141| 9|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 9|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ | Branch (305:7): [True: 9, False: 0] | Branch (305:33): [True: 0, False: 9] ------------------ 306| 0| int nsize = (inuse > LUAI_MAXSTACK / 2) ? LUAI_MAXSTACK : inuse * 2; ------------------ | | 740| 0|#define LUAI_MAXSTACK 1000000 ------------------ int nsize = (inuse > LUAI_MAXSTACK / 2) ? LUAI_MAXSTACK : inuse * 2; ------------------ | | 740| 0|#define LUAI_MAXSTACK 1000000 ------------------ | Branch (306:17): [True: 0, False: 0] ------------------ 307| 0| luaD_reallocstack(L, nsize, 0); /* ok if that fails */ 308| 0| } 309| 9| else /* don't change stack */ 310| 9| condmovestack(L,{},{}); /* (change only for debugging) */ ------------------ | | 366| 9|#define condmovestack(L,pre,pos) ((void)0) ------------------ 311| 9| luaE_shrinkCI(L); /* shrink CI list */ 312| 9|} luaD_inctop: 315| 12|void luaD_inctop (lua_State *L) { 316| 12| luaD_checkstack(L, 1); ------------------ | | 32| 12|#define luaD_checkstack(L,n) luaD_checkstackaux(L,n,(void)0,(void)0) | | ------------------ | | | | 27| 12| if (l_unlikely(L->stack_last.p - L->top.p <= (n))) \ | | | | ------------------ | | | | | | 688| 12|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 12|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 12] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 28| 12| { pre; luaD_growstack(L, n, 1); pos; } \ | | | | 29| 12| else { condmovestack(L,pre,pos); } | | | | ------------------ | | | | | | 366| 12|#define condmovestack(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 317| 12| L->top.p++; 318| 12|} luaD_closeprotected: 924| 12|int luaD_closeprotected (lua_State *L, ptrdiff_t level, int status) { 925| 12| CallInfo *old_ci = L->ci; 926| 12| lu_byte old_allowhooks = L->allowhook; 927| 12| for (;;) { /* keep closing upvalues until no more errors */ 928| 12| struct CloseP pcl; 929| 12| pcl.level = restorestack(L, level); pcl.status = status; ------------------ | | 37| 12|#define restorestack(L,n) cast(StkId, cast_charp(L->stack.p) + (n)) | | ------------------ | | | | 136| 12|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 930| 12| status = luaD_rawrunprotected(L, &closepaux, &pcl); 931| 12| if (l_likely(status == LUA_OK)) /* no more errors? */ ------------------ | | 687| 12|#define l_likely(x) luai_likely(x) | | ------------------ | | | | 675| 12|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | ------------------ | | | | | Branch (675:25): [True: 12, False: 0] | | | | ------------------ | | ------------------ ------------------ 932| 12| return pcl.status; 933| 0| else { /* an error occurred; restore saved state and repeat */ 934| 0| L->ci = old_ci; 935| 0| L->allowhook = old_allowhooks; 936| 0| } 937| 12| } 938| 12|} luaD_pcall: 947| 6| ptrdiff_t old_top, ptrdiff_t ef) { 948| 6| int status; 949| 6| CallInfo *old_ci = L->ci; 950| 6| lu_byte old_allowhooks = L->allowhook; 951| 6| ptrdiff_t old_errfunc = L->errfunc; 952| 6| L->errfunc = ef; 953| 6| status = luaD_rawrunprotected(L, func, u); 954| 6| if (l_unlikely(status != LUA_OK)) { /* an error occurred? */ ------------------ | | 688| 6|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 6|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 6, False: 0] | | | | ------------------ | | ------------------ ------------------ 955| 6| L->ci = old_ci; 956| 6| L->allowhook = old_allowhooks; 957| 6| status = luaD_closeprotected(L, old_top, status); 958| 6| luaD_seterrorobj(L, status, restorestack(L, old_top)); ------------------ | | 37| 6|#define restorestack(L,n) cast(StkId, cast_charp(L->stack.p) + (n)) | | ------------------ | | | | 136| 6|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 959| 6| luaD_shrinkstack(L); /* restore stack size in case of overflow */ 960| 6| } 961| 6| L->errfunc = old_errfunc; 962| 6| return status; 963| 6|} luaD_protectedparser: 1006| 6| const char *mode) { 1007| 6| struct SParser p; 1008| 6| int status; 1009| 6| incnny(L); /* cannot yield during parsing */ ------------------ | | 111| 6|#define incnny(L) ((L)->nCcalls += 0x10000) ------------------ 1010| 6| p.z = z; p.name = name; p.mode = mode; 1011| 6| p.dyd.actvar.arr = NULL; p.dyd.actvar.size = 0; 1012| 6| p.dyd.gt.arr = NULL; p.dyd.gt.size = 0; 1013| 6| p.dyd.label.arr = NULL; p.dyd.label.size = 0; 1014| 6| luaZ_initbuffer(L, &p.buff); ------------------ | | 29| 6|#define luaZ_initbuffer(L, buff) ((buff)->buffer = NULL, (buff)->buffsize = 0) ------------------ 1015| 6| status = luaD_pcall(L, f_parser, &p, savestack(L, L->top.p), L->errfunc); ------------------ | | 36| 6|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 6|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 6|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 6|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 6|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1016| 6| luaZ_freebuffer(L, &p.buff); ------------------ | | 44| 6|#define luaZ_freebuffer(L, buff) luaZ_resizebuffer(L, buff, 0) | | ------------------ | | | | 40| 6| ((buff)->buffer = luaM_reallocvchar(L, (buff)->buffer, \ | | | | ------------------ | | | | | | 53| 6| cast_charp(luaM_saferealloc_(L, (b), (on)*sizeof(char), (n)*sizeof(char))) | | | | | | ------------------ | | | | | | | | 146| 6|#define cast_charp(i) cast(char *, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 6|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 41| 6| (buff)->buffsize, size), \ | | | | 42| 6| (buff)->buffsize = size) | | ------------------ ------------------ 1017| 6| luaM_freearray(L, p.dyd.actvar.arr, p.dyd.actvar.size); ------------------ | | 57| 6|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 1018| 6| luaM_freearray(L, p.dyd.gt.arr, p.dyd.gt.size); ------------------ | | 57| 6|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 1019| 6| luaM_freearray(L, p.dyd.label.arr, p.dyd.label.size); ------------------ | | 57| 6|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 1020| 6| decnny(L); ------------------ | | 114| 6|#define decnny(L) ((L)->nCcalls -= 0x10000) ------------------ 1021| 6| return status; 1022| 6|} ldo.c:stackinuse: 276| 9|static int stackinuse (lua_State *L) { 277| 9| CallInfo *ci; 278| 9| int res; 279| 9| StkId lim = L->top.p; 280| 18| for (ci = L->ci; ci != NULL; ci = ci->previous) { ------------------ | Branch (280:20): [True: 9, False: 9] ------------------ 281| 9| if (lim < ci->top.p) lim = ci->top.p; ------------------ | Branch (281:9): [True: 9, False: 0] ------------------ 282| 9| } 283| 9| lua_assert(lim <= L->stack_last.p + EXTRA_STACK); ------------------ | | 114| 9|#define lua_assert(c) ((void)0) ------------------ 284| 9| res = cast_int(lim - L->stack.p) + 1; /* part of stack in use */ ------------------ | | 141| 9|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 9|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 285| 9| if (res < LUA_MINSTACK) ------------------ | | 80| 9|#define LUA_MINSTACK 20 ------------------ | Branch (285:7): [True: 0, False: 9] ------------------ 286| 0| res = LUA_MINSTACK; /* ensure a minimum size */ ------------------ | | 80| 0|#define LUA_MINSTACK 20 ------------------ 287| 9| return res; 288| 9|} ldo.c:closepaux: 914| 12|static void closepaux (lua_State *L, void *ud) { 915| 12| struct CloseP *pcl = cast(struct CloseP *, ud); ------------------ | | 136| 12|#define cast(t, exp) ((t)(exp)) ------------------ 916| 12| luaF_close(L, pcl->level, pcl->status, 0); 917| 12|} ldo.c:f_parser: 988| 6|static void f_parser (lua_State *L, void *ud) { 989| 6| LClosure *cl; 990| 6| struct SParser *p = cast(struct SParser *, ud); ------------------ | | 136| 6|#define cast(t, exp) ((t)(exp)) ------------------ 991| 6| int c = zgetc(p->z); /* read first character */ ------------------ | | 20| 6|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | ------------------ | | | | 144| 0|#define cast_uchar(i) cast(unsigned char, (i)) | | | | ------------------ | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | | Branch (20:20): [True: 0, False: 6] | | ------------------ ------------------ 992| 6| if (c == LUA_SIGNATURE[0]) { ------------------ | | 33| 6|#define LUA_SIGNATURE "\x1bLua" ------------------ | Branch (992:7): [True: 0, False: 6] ------------------ 993| 0| checkmode(L, p->mode, "binary"); 994| 0| cl = luaU_undump(L, p->z, p->name); 995| 0| } 996| 6| else { 997| 6| checkmode(L, p->mode, "text"); 998| 6| cl = luaY_parser(L, p->z, &p->buff, &p->dyd, p->name, c); 999| 6| } 1000| 6| lua_assert(cl->nupvalues == cl->p->sizeupvalues); ------------------ | | 114| 6|#define lua_assert(c) ((void)0) ------------------ 1001| 6| luaF_initupvals(L, cl); 1002| 6|} ldo.c:checkmode: 979| 6|static void checkmode (lua_State *L, const char *mode, const char *x) { 980| 6| if (mode && strchr(mode, x[0]) == NULL) { ------------------ | Branch (980:7): [True: 6, False: 0] | Branch (980:15): [True: 0, False: 6] ------------------ 981| 0| luaO_pushfstring(L, 982| 0| "attempt to load a %s chunk (mode is '%s')", x, mode); 983| 0| luaD_throw(L, LUA_ERRSYNTAX); ------------------ | | 52| 0|#define LUA_ERRSYNTAX 3 ------------------ 984| 0| } 985| 6|} luaF_newLclosure: 35| 6|LClosure *luaF_newLclosure (lua_State *L, int nupvals) { 36| 6| GCObject *o = luaC_newobj(L, LUA_VLCL, sizeLclosure(nupvals)); ------------------ | | 590| 6|#define LUA_VLCL makevariant(LUA_TFUNCTION, 0) /* Lua closure */ | | ------------------ | | | | 42| 6|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ GCObject *o = luaC_newobj(L, LUA_VLCL, sizeLclosure(nupvals)); ------------------ | | 17| 6|#define sizeLclosure(n) (cast_int(offsetof(LClosure, upvals)) + \ | | ------------------ | | | | 141| 6|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 6|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | 18| 6| cast_int(sizeof(TValue *)) * (n)) | | ------------------ | | | | 141| 6|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 6|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 37| 6| LClosure *c = gco2lcl(o); ------------------ | | 376| 6|#define gco2lcl(o) check_exp((o)->tt == LUA_VLCL, &((cast_u(o))->cl.l)) | | ------------------ | | | | 115| 6|#define check_exp(c,e) (e) | | ------------------ ------------------ 38| 6| c->p = NULL; 39| 6| c->nupvalues = cast_byte(nupvals); ------------------ | | 143| 6|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 6|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 40| 12| while (nupvals--) c->upvals[nupvals] = NULL; ------------------ | Branch (40:10): [True: 6, False: 6] ------------------ 41| 6| return c; 42| 6|} luaF_closeupval: 193| 12|void luaF_closeupval (lua_State *L, StkId level) { 194| 12| UpVal *uv; 195| 12| StkId upl; /* stack index pointed by 'uv' */ 196| 12| while ((uv = L->openupval) != NULL && (upl = uplevel(uv)) >= level) { ------------------ | | 35| 0|#define uplevel(up) check_exp(upisopen(up), cast(StkId, (up)->v.p)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (196:10): [True: 0, False: 12] | Branch (196:41): [True: 0, False: 0] ------------------ 197| 0| TValue *slot = &uv->u.value; /* new position for value */ 198| 0| lua_assert(uplevel(uv) < L->top.p); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 199| 0| luaF_unlinkupval(uv); /* remove upvalue from 'openupval' list */ 200| 0| setobj(L, slot, uv->v.p); /* move value to upvalue slot */ ------------------ | | 119| 0| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | 120| 0| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 121| 0| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 114| 0|#define lua_assert(c) ((void)0) | | ------------------ ------------------ 201| 0| uv->v.p = slot; /* now current value lives here */ 202| 0| if (!iswhite(uv)) { /* neither white nor dead? */ ------------------ | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | ------------------ | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | ------------------ ------------------ | Branch (202:9): [True: 0, False: 0] ------------------ 203| 0| nw2black(uv); /* closed upvalues cannot be gray */ ------------------ | | 100| 0| check_exp(!iswhite(x), l_setbit((x)->marked, BLACKBIT)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 204| 0| luaC_barrier(L, uv, slot); ------------------ | | 179| 0|#define luaC_barrier(L,p,v) ( \ | | 180| 0| iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 300| 0|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 298| 0|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (300:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 175| 0|#define luaC_objbarrier(L,p,o) ( \ | | | | 176| 0| (isblack(p) && iswhite(o)) ? \ | | | | ------------------ | | | | | | 88| 0|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | ------------------ | | | | | | | | 67| 0|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | ------------------ | | | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (isblack(p) && iswhite(o)) ? \ | | | | ------------------ | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 177| 0| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 138| 0|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 138| 0|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 205| 0| } 206| 0| } 207| 12|} luaF_close: 227| 12|StkId luaF_close (lua_State *L, StkId level, int status, int yy) { 228| 12| ptrdiff_t levelrel = savestack(L, level); ------------------ | | 36| 12|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 12|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 12|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 12|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 12|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 229| 12| luaF_closeupval(L, level); /* first, close the upvalues */ 230| 12| while (L->tbclist.p >= level) { /* traverse tbc's down to that level */ ------------------ | Branch (230:10): [True: 0, False: 12] ------------------ 231| 0| StkId tbc = L->tbclist.p; /* get variable index */ 232| 0| poptbclist(L); /* remove it from list */ 233| 0| prepcallclosemth(L, tbc, status, yy); /* close variable */ 234| 0| level = restorestack(L, levelrel); ------------------ | | 37| 0|#define restorestack(L,n) cast(StkId, cast_charp(L->stack.p) + (n)) | | ------------------ | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 235| 0| } 236| 12| return level; 237| 12|} luaF_newproto: 240| 6|Proto *luaF_newproto (lua_State *L) { 241| 6| GCObject *o = luaC_newobj(L, LUA_VPROTO, sizeof(Proto)); ------------------ | | 509| 6|#define LUA_VPROTO makevariant(LUA_TPROTO, 0) | | ------------------ | | | | 42| 6|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ 242| 6| Proto *f = gco2p(o); ------------------ | | 381| 6|#define gco2p(o) check_exp((o)->tt == LUA_VPROTO, &((cast_u(o))->p)) | | ------------------ | | | | 115| 6|#define check_exp(c,e) (e) | | ------------------ ------------------ 243| 6| f->k = NULL; 244| 6| f->sizek = 0; 245| 6| f->p = NULL; 246| 6| f->sizep = 0; 247| 6| f->code = NULL; 248| 6| f->sizecode = 0; 249| 6| f->lineinfo = NULL; 250| 6| f->sizelineinfo = 0; 251| 6| f->abslineinfo = NULL; 252| 6| f->sizeabslineinfo = 0; 253| 6| f->upvalues = NULL; 254| 6| f->sizeupvalues = 0; 255| 6| f->numparams = 0; 256| 6| f->is_vararg = 0; 257| 6| f->maxstacksize = 0; 258| 6| f->locvars = NULL; 259| 6| f->sizelocvars = 0; 260| 6| f->linedefined = 0; 261| 6| f->lastlinedefined = 0; 262| 6| f->source = NULL; 263| 6| return f; 264| 6|} luaF_freeproto: 267| 6|void luaF_freeproto (lua_State *L, Proto *f) { 268| 6| luaM_freearray(L, f->code, f->sizecode); ------------------ | | 57| 6|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 269| 6| luaM_freearray(L, f->p, f->sizep); ------------------ | | 57| 6|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 270| 6| luaM_freearray(L, f->k, f->sizek); ------------------ | | 57| 6|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 271| 6| luaM_freearray(L, f->lineinfo, f->sizelineinfo); ------------------ | | 57| 6|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 272| 6| luaM_freearray(L, f->abslineinfo, f->sizeabslineinfo); ------------------ | | 57| 6|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 273| 6| luaM_freearray(L, f->locvars, f->sizelocvars); ------------------ | | 57| 6|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 274| 6| luaM_freearray(L, f->upvalues, f->sizeupvalues); ------------------ | | 57| 6|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 275| 6| luaM_free(L, f); ------------------ | | 56| 6|#define luaM_free(L, b) luaM_free_(L, (b), sizeof(*(b))) ------------------ 276| 6|} luaC_fix: 243| 294|void luaC_fix (lua_State *L, GCObject *o) { 244| 294| global_State *g = G(L); ------------------ | | 335| 294|#define G(L) (L->l_G) ------------------ 245| 294| lua_assert(g->allgc == o); /* object must be 1st in 'allgc' list! */ ------------------ | | 114| 294|#define lua_assert(c) ((void)0) ------------------ 246| 294| set2gray(o); /* they will be gray forever */ ------------------ | | 75| 294|#define set2gray(x) resetbits(x->marked, maskcolors) | | ------------------ | | | | 60| 294|#define resetbits(x,m) ((x) &= cast_byte(~(m))) | | | | ------------------ | | | | | | 143| 294|#define cast_byte(i) cast(lu_byte, (i)) | | | | | | ------------------ | | | | | | | | 136| 294|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 247| 294| setage(o, G_OLD); /* and old forever */ ------------------ | | 117| 294|#define setage(o,a) ((o)->marked = cast_byte(((o)->marked & (~AGEBITS)) | a)) | | ------------------ | | | | 143| 294|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 136| 294|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 248| 294| g->allgc = o->next; /* remove object from 'allgc' list */ 249| 294| o->next = g->fixedgc; /* link it to 'fixedgc' list */ 250| 294| g->fixedgc = o; 251| 294|} luaC_newobjdt: 258| 350|GCObject *luaC_newobjdt (lua_State *L, int tt, size_t sz, size_t offset) { 259| 350| global_State *g = G(L); ------------------ | | 335| 350|#define G(L) (L->l_G) ------------------ 260| 350| char *p = cast_charp(luaM_newobject(L, novariant(tt), sz)); ------------------ | | 146| 350|#define cast_charp(i) cast(char *, (i)) | | ------------------ | | | | 136| 350|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 261| 350| GCObject *o = cast(GCObject *, p + offset); ------------------ | | 136| 350|#define cast(t, exp) ((t)(exp)) ------------------ 262| 350| o->marked = luaC_white(g); ------------------ | | 102| 350|#define luaC_white(g) cast_byte((g)->currentwhite & WHITEBITS) | | ------------------ | | | | 143| 350|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 136| 350|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 263| 350| o->tt = tt; 264| 350| o->next = g->allgc; 265| 350| g->allgc = o; 266| 350| return o; 267| 350|} luaC_newobj: 270| 350|GCObject *luaC_newobj (lua_State *L, int tt, size_t sz) { 271| 350| return luaC_newobjdt(L, tt, sz, 0); 272| 350|} luaC_changemode: 1358| 6|void luaC_changemode (lua_State *L, int newmode) { 1359| 6| global_State *g = G(L); ------------------ | | 335| 6|#define G(L) (L->l_G) ------------------ 1360| 6| if (newmode != g->gckind) { ------------------ | Branch (1360:7): [True: 0, False: 6] ------------------ 1361| 0| if (newmode == KGC_GEN) /* entering generational mode? */ ------------------ | | 152| 0|#define KGC_GEN 1 /* generational gc */ ------------------ | Branch (1361:9): [True: 0, False: 0] ------------------ 1362| 0| entergen(L, g); 1363| 0| else 1364| 0| enterinc(g); /* entering incremental mode */ 1365| 0| } 1366| 6| g->lastatomic = 0; 1367| 6|} luaC_freeallobjects: 1509| 6|void luaC_freeallobjects (lua_State *L) { 1510| 6| global_State *g = G(L); ------------------ | | 335| 6|#define G(L) (L->l_G) ------------------ 1511| 6| g->gcstp = GCSTPCLS; /* no extra finalizers after here */ ------------------ | | 157| 6|#define GCSTPCLS 4 /* bit true when closing Lua state */ ------------------ 1512| 6| luaC_changemode(L, KGC_INC); ------------------ | | 151| 6|#define KGC_INC 0 /* incremental gc */ ------------------ 1513| 6| separatetobefnz(g, 1); /* separate all objects with finalizers */ 1514| 6| lua_assert(g->finobj == NULL); ------------------ | | 114| 6|#define lua_assert(c) ((void)0) ------------------ 1515| 6| callallpendingfinalizers(L); 1516| 6| deletelist(L, g->allgc, obj2gco(g->mainthread)); ------------------ | | 390| 6|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | ------------------ | | | | 115| 6|#define check_exp(c,e) (e) | | ------------------ ------------------ 1517| 6| lua_assert(g->finobj == NULL); /* no new finalizers */ ------------------ | | 114| 6|#define lua_assert(c) ((void)0) ------------------ 1518| 6| deletelist(L, g->fixedgc, NULL); /* collect fixed objects */ 1519| 6| lua_assert(g->strt.nuse == 0); ------------------ | | 114| 6|#define lua_assert(c) ((void)0) ------------------ 1520| 6|} luaC_step: 1688| 3|void luaC_step (lua_State *L) { 1689| 3| global_State *g = G(L); ------------------ | | 335| 3|#define G(L) (L->l_G) ------------------ 1690| 3| if (!gcrunning(g)) /* not running? */ ------------------ | | 158| 3|#define gcrunning(g) ((g)->gcstp == 0) ------------------ | Branch (1690:7): [True: 0, False: 3] ------------------ 1691| 0| luaE_setdebt(g, -2000); 1692| 3| else { 1693| 3| if(isdecGCmodegen(g)) ------------------ | | 149| 3|#define isdecGCmodegen(g) (g->gckind == KGC_GEN || g->lastatomic != 0) | | ------------------ | | | | 152| 6|#define KGC_GEN 1 /* generational gc */ | | ------------------ | | | Branch (149:28): [True: 0, False: 3] | | | Branch (149:52): [True: 0, False: 3] | | ------------------ ------------------ 1694| 0| genstep(L, g); 1695| 3| else 1696| 3| incstep(L, g); 1697| 3| } 1698| 3|} lgc.c:linkgclist_: 148| 21|static void linkgclist_ (GCObject *o, GCObject **pnext, GCObject **list) { 149| 21| lua_assert(!isgray(o)); /* cannot be in a gray list */ ------------------ | | 114| 21|#define lua_assert(c) ((void)0) ------------------ 150| 21| *pnext = *list; 151| 21| *list = o; 152| 21| set2gray(o); /* now it is */ ------------------ | | 75| 21|#define set2gray(x) resetbits(x->marked, maskcolors) | | ------------------ | | | | 60| 21|#define resetbits(x,m) ((x) &= cast_byte(~(m))) | | | | ------------------ | | | | | | 143| 21|#define cast_byte(i) cast(lu_byte, (i)) | | | | | | ------------------ | | | | | | | | 136| 21|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 153| 21|} lgc.c:getgclist: 125| 39|static GCObject **getgclist (GCObject *o) { 126| 39| switch (o->tt) { 127| 18| case LUA_VTABLE: return &gco2t(o)->gclist; ------------------ | | 680| 18|#define LUA_VTABLE makevariant(LUA_TTABLE, 0) | | ------------------ | | | | 42| 18|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VTABLE: return &gco2t(o)->gclist; ------------------ | | 380| 18|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 115| 18|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (127:5): [True: 18, False: 21] ------------------ 128| 6| case LUA_VLCL: return &gco2lcl(o)->gclist; ------------------ | | 590| 6|#define LUA_VLCL makevariant(LUA_TFUNCTION, 0) /* Lua closure */ | | ------------------ | | | | 42| 6|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VLCL: return &gco2lcl(o)->gclist; ------------------ | | 376| 6|#define gco2lcl(o) check_exp((o)->tt == LUA_VLCL, &((cast_u(o))->cl.l)) | | ------------------ | | | | 115| 6|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (128:5): [True: 6, False: 33] ------------------ 129| 0| case LUA_VCCL: return &gco2ccl(o)->gclist; ------------------ | | 592| 0|#define LUA_VCCL makevariant(LUA_TFUNCTION, 2) /* C closure */ | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VCCL: return &gco2ccl(o)->gclist; ------------------ | | 377| 0|#define gco2ccl(o) check_exp((o)->tt == LUA_VCCL, &((cast_u(o))->cl.c)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (129:5): [True: 0, False: 39] ------------------ 130| 9| case LUA_VTHREAD: return &gco2th(o)->gclist; ------------------ | | 262| 9|#define LUA_VTHREAD makevariant(LUA_TTHREAD, 0) | | ------------------ | | | | 42| 9|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VTHREAD: return &gco2th(o)->gclist; ------------------ | | 382| 9|#define gco2th(o) check_exp((o)->tt == LUA_VTHREAD, &((cast_u(o))->th)) | | ------------------ | | | | 115| 9|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (130:5): [True: 9, False: 30] ------------------ 131| 6| case LUA_VPROTO: return &gco2p(o)->gclist; ------------------ | | 509| 6|#define LUA_VPROTO makevariant(LUA_TPROTO, 0) | | ------------------ | | | | 42| 6|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VPROTO: return &gco2p(o)->gclist; ------------------ | | 381| 6|#define gco2p(o) check_exp((o)->tt == LUA_VPROTO, &((cast_u(o))->p)) | | ------------------ | | | | 115| 6|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (131:5): [True: 6, False: 33] ------------------ 132| 0| case LUA_VUSERDATA: { ------------------ | | 431| 0|#define LUA_VUSERDATA makevariant(LUA_TUSERDATA, 0) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (132:5): [True: 0, False: 39] ------------------ 133| 0| Udata *u = gco2u(o); ------------------ | | 375| 0|#define gco2u(o) check_exp((o)->tt == LUA_VUSERDATA, &((cast_u(o))->u)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 134| 0| lua_assert(u->nuvalue > 0); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 135| 0| return &u->gclist; 136| 0| } 137| 0| default: lua_assert(0); return 0; ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ | Branch (137:5): [True: 0, False: 39] ------------------ 138| 39| } 139| 39|} lgc.c:reallymarkobject: 297| 24|static void reallymarkobject (global_State *g, GCObject *o) { 298| 24| switch (o->tt) { 299| 5| case LUA_VSHRSTR: ------------------ | | 360| 5|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 5|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (299:5): [True: 5, False: 19] ------------------ 300| 6| case LUA_VLNGSTR: { ------------------ | | 361| 6|#define LUA_VLNGSTR makevariant(LUA_TSTRING, 1) /* long strings */ | | ------------------ | | | | 42| 6|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (300:5): [True: 1, False: 23] ------------------ 301| 6| set2black(o); /* nothing to visit */ ------------------ | | 80| 6| (x->marked = cast_byte((x->marked & ~WHITEBITS) | bitmask(BLACKBIT))) | | ------------------ | | | | 143| 6|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 136| 6|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 302| 6| break; 303| 5| } 304| 0| case LUA_VUPVAL: { ------------------ | | 586| 0|#define LUA_VUPVAL makevariant(LUA_TUPVAL, 0) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (304:5): [True: 0, False: 24] ------------------ 305| 0| UpVal *uv = gco2upv(o); ------------------ | | 383| 0|#define gco2upv(o) check_exp((o)->tt == LUA_VUPVAL, &((cast_u(o))->upv)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 306| 0| if (upisopen(uv)) ------------------ | | 32| 0|#define upisopen(up) ((up)->v.p != &(up)->u.value) | | ------------------ | | | Branch (32:22): [True: 0, False: 0] | | ------------------ ------------------ 307| 0| set2gray(uv); /* open upvalues are kept gray */ ------------------ | | 75| 0|#define set2gray(x) resetbits(x->marked, maskcolors) | | ------------------ | | | | 60| 0|#define resetbits(x,m) ((x) &= cast_byte(~(m))) | | | | ------------------ | | | | | | 143| 0|#define cast_byte(i) cast(lu_byte, (i)) | | | | | | ------------------ | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 308| 0| else 309| 0| set2black(uv); /* closed upvalues are visited here */ ------------------ | | 80| 0| (x->marked = cast_byte((x->marked & ~WHITEBITS) | bitmask(BLACKBIT))) | | ------------------ | | | | 143| 0|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 310| 0| markvalue(g, uv->v.p); /* mark its content */ ------------------ | | 94| 0|#define markvalue(g,o) { checkliveness(g->mainthread,o); \ | | ------------------ | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | 95| 0| if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 83| 0|#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 300| 0|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 0|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 305| 0|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 311| 0| break; 312| 5| } 313| 0| case LUA_VUSERDATA: { ------------------ | | 431| 0|#define LUA_VUSERDATA makevariant(LUA_TUSERDATA, 0) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (313:5): [True: 0, False: 24] ------------------ 314| 0| Udata *u = gco2u(o); ------------------ | | 375| 0|#define gco2u(o) check_exp((o)->tt == LUA_VUSERDATA, &((cast_u(o))->u)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 315| 0| if (u->nuvalue == 0) { /* no user values? */ ------------------ | Branch (315:11): [True: 0, False: 0] ------------------ 316| 0| markobjectN(g, u->metatable); /* mark its metatable */ ------------------ | | 105| 0|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 99| 0|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (105:32): [True: 0, False: 0] | | ------------------ ------------------ 317| 0| set2black(u); /* nothing else to mark */ ------------------ | | 80| 0| (x->marked = cast_byte((x->marked & ~WHITEBITS) | bitmask(BLACKBIT))) | | ------------------ | | | | 143| 0|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 318| 0| break; 319| 0| } 320| | /* else... */ 321| 0| } /* FALLTHROUGH */ 322| 12| case LUA_VLCL: case LUA_VCCL: case LUA_VTABLE: ------------------ | | 590| 3|#define LUA_VLCL makevariant(LUA_TFUNCTION, 0) /* Lua closure */ | | ------------------ | | | | 42| 3|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VLCL: case LUA_VCCL: case LUA_VTABLE: ------------------ | | 592| 3|#define LUA_VCCL makevariant(LUA_TFUNCTION, 2) /* C closure */ | | ------------------ | | | | 42| 3|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VLCL: case LUA_VCCL: case LUA_VTABLE: ------------------ | | 680| 12|#define LUA_VTABLE makevariant(LUA_TTABLE, 0) | | ------------------ | | | | 42| 12|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (322:5): [True: 3, False: 21] | Branch (322:20): [True: 0, False: 24] | Branch (322:35): [True: 9, False: 15] ------------------ 323| 18| case LUA_VTHREAD: case LUA_VPROTO: { ------------------ | | 262| 15|#define LUA_VTHREAD makevariant(LUA_TTHREAD, 0) | | ------------------ | | | | 42| 15|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VTHREAD: case LUA_VPROTO: { ------------------ | | 509| 18|#define LUA_VPROTO makevariant(LUA_TPROTO, 0) | | ------------------ | | | | 42| 18|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (323:5): [True: 3, False: 21] | Branch (323:23): [True: 3, False: 21] ------------------ 324| 18| linkobjgclist(o, g->gray); /* to be visited later */ ------------------ | | 159| 18|#define linkobjgclist(o,p) linkgclist_(obj2gco(o), getgclist(o), &(p)) | | ------------------ | | | | 390| 18|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 18|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 325| 18| break; 326| 15| } 327| 0| default: lua_assert(0); break; ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ | Branch (327:5): [True: 0, False: 24] ------------------ 328| 24| } 329| 24|} lgc.c:sweeptolive: 849| 3|static GCObject **sweeptolive (lua_State *L, GCObject **p) { 850| 3| GCObject **old = p; 851| 3| do { 852| 3| p = sweeplist(L, p, 1, NULL); 853| 3| } while (p == old); ------------------ | Branch (853:12): [True: 0, False: 3] ------------------ 854| 3| return p; 855| 3|} lgc.c:sweeplist: 823| 12| int *countout) { 824| 12| global_State *g = G(L); ------------------ | | 335| 12|#define G(L) (L->l_G) ------------------ 825| 12| int ow = otherwhite(g); ------------------ | | 94| 12|#define otherwhite(g) ((g)->currentwhite ^ WHITEBITS) | | ------------------ | | | | 84| 12|#define WHITEBITS bit2mask(WHITE0BIT, WHITE1BIT) | | | | ------------------ | | | | | | 64| 12|#define bit2mask(b1,b2) (bitmask(b1) | bitmask(b2)) | | | | | | ------------------ | | | | | | | | 63| 12|#define bitmask(b) (1<<(b)) | | | | | | ------------------ | | | | | | #define bit2mask(b1,b2) (bitmask(b1) | bitmask(b2)) | | | | | | ------------------ | | | | | | | | 63| 12|#define bitmask(b) (1<<(b)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 826| 12| int i; 827| 12| int white = luaC_white(g); /* current white */ ------------------ | | 102| 12|#define luaC_white(g) cast_byte((g)->currentwhite & WHITEBITS) | | ------------------ | | | | 143| 12|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 136| 12|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 828| 36| for (i = 0; *p != NULL && i < countin; i++) { ------------------ | Branch (828:15): [True: 27, False: 9] | Branch (828:29): [True: 24, False: 3] ------------------ 829| 24| GCObject *curr = *p; 830| 24| int marked = curr->marked; 831| 24| if (isdeadm(ow, marked)) { /* is 'curr' dead? */ ------------------ | | 95| 24|#define isdeadm(ow,m) ((m) & (ow)) | | ------------------ | | | Branch (95:23): [True: 0, False: 24] | | ------------------ ------------------ 832| 0| *p = curr->next; /* remove 'curr' from list */ 833| 0| freeobj(L, curr); /* erase 'curr' */ 834| 0| } 835| 24| else { /* change mark to 'white' */ 836| 24| curr->marked = cast_byte((marked & ~maskgcbits) | white); ------------------ | | 143| 24|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 24|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 837| 24| p = &curr->next; /* go to next element */ 838| 24| } 839| 24| } 840| 12| if (countout) ------------------ | Branch (840:7): [True: 9, False: 3] ------------------ 841| 9| *countout = i; /* number of elements traversed */ 842| 12| return (*p == NULL) ? NULL : p; ------------------ | Branch (842:10): [True: 9, False: 3] ------------------ 843| 12|} lgc.c:freeobj: 770| 350|static void freeobj (lua_State *L, GCObject *o) { 771| 350| switch (o->tt) { 772| 6| case LUA_VPROTO: ------------------ | | 509| 6|#define LUA_VPROTO makevariant(LUA_TPROTO, 0) | | ------------------ | | | | 42| 6|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (772:5): [True: 6, False: 344] ------------------ 773| 6| luaF_freeproto(L, gco2p(o)); ------------------ | | 381| 6|#define gco2p(o) check_exp((o)->tt == LUA_VPROTO, &((cast_u(o))->p)) | | ------------------ | | | | 115| 6|#define check_exp(c,e) (e) | | ------------------ ------------------ 774| 6| break; 775| 0| case LUA_VUPVAL: ------------------ | | 586| 0|#define LUA_VUPVAL makevariant(LUA_TUPVAL, 0) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (775:5): [True: 0, False: 350] ------------------ 776| 0| freeupval(L, gco2upv(o)); ------------------ | | 383| 0|#define gco2upv(o) check_exp((o)->tt == LUA_VUPVAL, &((cast_u(o))->upv)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 777| 0| break; 778| 6| case LUA_VLCL: { ------------------ | | 590| 6|#define LUA_VLCL makevariant(LUA_TFUNCTION, 0) /* Lua closure */ | | ------------------ | | | | 42| 6|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (778:5): [True: 6, False: 344] ------------------ 779| 6| LClosure *cl = gco2lcl(o); ------------------ | | 376| 6|#define gco2lcl(o) check_exp((o)->tt == LUA_VLCL, &((cast_u(o))->cl.l)) | | ------------------ | | | | 115| 6|#define check_exp(c,e) (e) | | ------------------ ------------------ 780| 6| luaM_freemem(L, cl, sizeLclosure(cl->nupvalues)); ------------------ | | 55| 6|#define luaM_freemem(L, b, s) luaM_free_(L, (b), (s)) ------------------ 781| 6| break; 782| 0| } 783| 0| case LUA_VCCL: { ------------------ | | 592| 0|#define LUA_VCCL makevariant(LUA_TFUNCTION, 2) /* C closure */ | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (783:5): [True: 0, False: 350] ------------------ 784| 0| CClosure *cl = gco2ccl(o); ------------------ | | 377| 0|#define gco2ccl(o) check_exp((o)->tt == LUA_VCCL, &((cast_u(o))->cl.c)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 785| 0| luaM_freemem(L, cl, sizeCclosure(cl->nupvalues)); ------------------ | | 55| 0|#define luaM_freemem(L, b, s) luaM_free_(L, (b), (s)) ------------------ 786| 0| break; 787| 0| } 788| 18| case LUA_VTABLE: ------------------ | | 680| 18|#define LUA_VTABLE makevariant(LUA_TTABLE, 0) | | ------------------ | | | | 42| 18|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (788:5): [True: 18, False: 332] ------------------ 789| 18| luaH_free(L, gco2t(o)); ------------------ | | 380| 18|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 115| 18|#define check_exp(c,e) (e) | | ------------------ ------------------ 790| 18| break; 791| 0| case LUA_VTHREAD: ------------------ | | 262| 0|#define LUA_VTHREAD makevariant(LUA_TTHREAD, 0) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (791:5): [True: 0, False: 350] ------------------ 792| 0| luaE_freethread(L, gco2th(o)); ------------------ | | 382| 0|#define gco2th(o) check_exp((o)->tt == LUA_VTHREAD, &((cast_u(o))->th)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 793| 0| break; 794| 0| case LUA_VUSERDATA: { ------------------ | | 431| 0|#define LUA_VUSERDATA makevariant(LUA_TUSERDATA, 0) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (794:5): [True: 0, False: 350] ------------------ 795| 0| Udata *u = gco2u(o); ------------------ | | 375| 0|#define gco2u(o) check_exp((o)->tt == LUA_VUSERDATA, &((cast_u(o))->u)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 796| 0| luaM_freemem(L, o, sizeudata(u->nuvalue, u->len)); ------------------ | | 55| 0|#define luaM_freemem(L, b, s) luaM_free_(L, (b), (s)) | | ------------------ | | | Branch (55:51): [True: 0, False: 0] | | ------------------ ------------------ 797| 0| break; 798| 0| } 799| 313| case LUA_VSHRSTR: { ------------------ | | 360| 313|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 313|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (799:5): [True: 313, False: 37] ------------------ 800| 313| TString *ts = gco2ts(o); ------------------ | | 374| 313| check_exp(novariant((o)->tt) == LUA_TSTRING, &((cast_u(o))->ts)) | | ------------------ | | | | 115| 313|#define check_exp(c,e) (e) | | ------------------ ------------------ 801| 313| luaS_remove(L, ts); /* remove it from hash table */ 802| 313| luaM_freemem(L, ts, sizelstring(ts->shrlen)); ------------------ | | 55| 313|#define luaM_freemem(L, b, s) luaM_free_(L, (b), (s)) ------------------ 803| 313| break; 804| 0| } 805| 7| case LUA_VLNGSTR: { ------------------ | | 361| 7|#define LUA_VLNGSTR makevariant(LUA_TSTRING, 1) /* long strings */ | | ------------------ | | | | 42| 7|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (805:5): [True: 7, False: 343] ------------------ 806| 7| TString *ts = gco2ts(o); ------------------ | | 374| 7| check_exp(novariant((o)->tt) == LUA_TSTRING, &((cast_u(o))->ts)) | | ------------------ | | | | 115| 7|#define check_exp(c,e) (e) | | ------------------ ------------------ 807| 7| luaM_freemem(L, ts, sizelstring(ts->u.lnglen)); ------------------ | | 55| 7|#define luaM_freemem(L, b, s) luaM_free_(L, (b), (s)) ------------------ 808| 7| break; 809| 0| } 810| 0| default: lua_assert(0); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ | Branch (810:5): [True: 0, False: 350] ------------------ 811| 350| } 812| 350|} lgc.c:atomic: 1523| 3|static lu_mem atomic (lua_State *L) { 1524| 3| global_State *g = G(L); ------------------ | | 335| 3|#define G(L) (L->l_G) ------------------ 1525| 3| lu_mem work = 0; 1526| 3| GCObject *origweak, *origall; 1527| 3| GCObject *grayagain = g->grayagain; /* save original list */ 1528| 3| g->grayagain = NULL; 1529| 3| lua_assert(g->ephemeron == NULL && g->weak == NULL); ------------------ | | 114| 3|#define lua_assert(c) ((void)0) ------------------ 1530| 3| lua_assert(!iswhite(g->mainthread)); ------------------ | | 114| 3|#define lua_assert(c) ((void)0) ------------------ 1531| 3| g->gcstate = GCSatomic; ------------------ | | 33| 3|#define GCSatomic 2 ------------------ 1532| 3| markobject(g, L); /* mark running thread */ ------------------ | | 99| 3|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | ------------------ | | | | 87| 3|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 62| 3|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (62:24): [True: 0, False: 3] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 1533| | /* registry and global metatables may be changed by API */ 1534| 3| markvalue(g, &g->l_registry); ------------------ | | 94| 3|#define markvalue(g,o) { checkliveness(g->mainthread,o); \ | | ------------------ | | | | 107| 3| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 3|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 3| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | 95| 3| if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 83| 3|#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 300| 6|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 3|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 3|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 3, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 87| 3|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 3|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 3] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 305| 0|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 1535| 3| markmt(g); /* mark global metatables */ 1536| 3| work += propagateall(g); /* empties 'gray' list */ 1537| | /* remark occasional upvalues of (maybe) dead threads */ 1538| 3| work += remarkupvals(g); 1539| 3| work += propagateall(g); /* propagate changes */ 1540| 3| g->gray = grayagain; 1541| 3| work += propagateall(g); /* traverse 'grayagain' list */ 1542| 3| convergeephemerons(g); 1543| | /* at this point, all strongly accessible objects are marked. */ 1544| | /* Clear values from weak tables, before checking finalizers */ 1545| 3| clearbyvalues(g, g->weak, NULL); 1546| 3| clearbyvalues(g, g->allweak, NULL); 1547| 3| origweak = g->weak; origall = g->allweak; 1548| 3| separatetobefnz(g, 0); /* separate objects to be finalized */ 1549| 3| work += markbeingfnz(g); /* mark objects that will be finalized */ 1550| 3| work += propagateall(g); /* remark, to propagate 'resurrection' */ 1551| 3| convergeephemerons(g); 1552| | /* at this point, all resurrected objects are marked. */ 1553| | /* remove dead objects from weak tables */ 1554| 3| clearbykeys(g, g->ephemeron); /* clear keys from all ephemeron tables */ 1555| 3| clearbykeys(g, g->allweak); /* clear keys from all 'allweak' tables */ 1556| | /* clear values from resurrected weak tables */ 1557| 3| clearbyvalues(g, g->weak, origweak); 1558| 3| clearbyvalues(g, g->allweak, origall); 1559| 3| luaS_clearcache(g); 1560| 3| g->currentwhite = cast_byte(otherwhite(g)); /* flip current white */ ------------------ | | 143| 3|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 3|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1561| 3| lua_assert(g->gray == NULL); ------------------ | | 114| 3|#define lua_assert(c) ((void)0) ------------------ 1562| 3| return work; /* estimate of slots marked by 'atomic' */ 1563| 3|} lgc.c:markmt: 335| 6|static void markmt (global_State *g) { 336| 6| int i; 337| 60| for (i=0; i < LUA_NUMTAGS; i++) ------------------ | | 426| 60|#define LUA_NUMTAGS LUA_NUMTYPES | | ------------------ | | | | 75| 60|#define LUA_NUMTYPES 9 | | ------------------ ------------------ | Branch (337:13): [True: 54, False: 6] ------------------ 338| 54| markobjectN(g, g->mt[i]); ------------------ | | 105| 54|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 99| 0|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (105:32): [True: 0, False: 54] | | ------------------ ------------------ 339| 6|} lgc.c:propagateall: 674| 12|static lu_mem propagateall (global_State *g) { 675| 12| lu_mem tot = 0; 676| 15| while (g->gray) ------------------ | Branch (676:10): [True: 3, False: 12] ------------------ 677| 3| tot += propagatemark(g); 678| 12| return tot; 679| 12|} lgc.c:propagatemark: 658| 21|static lu_mem propagatemark (global_State *g) { 659| 21| GCObject *o = g->gray; 660| 21| nw2black(o); ------------------ | | 100| 21| check_exp(!iswhite(x), l_setbit((x)->marked, BLACKBIT)) | | ------------------ | | | | 115| 21|#define check_exp(c,e) (e) | | ------------------ ------------------ 661| 21| g->gray = *getgclist(o); /* remove from 'gray' list */ 662| 21| switch (o->tt) { 663| 9| case LUA_VTABLE: return traversetable(g, gco2t(o)); ------------------ | | 680| 9|#define LUA_VTABLE makevariant(LUA_TTABLE, 0) | | ------------------ | | | | 42| 9|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VTABLE: return traversetable(g, gco2t(o)); ------------------ | | 380| 9|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 115| 9|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (663:5): [True: 9, False: 12] ------------------ 664| 0| case LUA_VUSERDATA: return traverseudata(g, gco2u(o)); ------------------ | | 431| 0|#define LUA_VUSERDATA makevariant(LUA_TUSERDATA, 0) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VUSERDATA: return traverseudata(g, gco2u(o)); ------------------ | | 375| 0|#define gco2u(o) check_exp((o)->tt == LUA_VUSERDATA, &((cast_u(o))->u)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (664:5): [True: 0, False: 21] ------------------ 665| 3| case LUA_VLCL: return traverseLclosure(g, gco2lcl(o)); ------------------ | | 590| 3|#define LUA_VLCL makevariant(LUA_TFUNCTION, 0) /* Lua closure */ | | ------------------ | | | | 42| 3|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VLCL: return traverseLclosure(g, gco2lcl(o)); ------------------ | | 376| 3|#define gco2lcl(o) check_exp((o)->tt == LUA_VLCL, &((cast_u(o))->cl.l)) | | ------------------ | | | | 115| 3|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (665:5): [True: 3, False: 18] ------------------ 666| 0| case LUA_VCCL: return traverseCclosure(g, gco2ccl(o)); ------------------ | | 592| 0|#define LUA_VCCL makevariant(LUA_TFUNCTION, 2) /* C closure */ | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VCCL: return traverseCclosure(g, gco2ccl(o)); ------------------ | | 377| 0|#define gco2ccl(o) check_exp((o)->tt == LUA_VCCL, &((cast_u(o))->cl.c)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (666:5): [True: 0, False: 21] ------------------ 667| 3| case LUA_VPROTO: return traverseproto(g, gco2p(o)); ------------------ | | 509| 3|#define LUA_VPROTO makevariant(LUA_TPROTO, 0) | | ------------------ | | | | 42| 3|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VPROTO: return traverseproto(g, gco2p(o)); ------------------ | | 381| 3|#define gco2p(o) check_exp((o)->tt == LUA_VPROTO, &((cast_u(o))->p)) | | ------------------ | | | | 115| 3|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (667:5): [True: 3, False: 18] ------------------ 668| 6| case LUA_VTHREAD: return traversethread(g, gco2th(o)); ------------------ | | 262| 6|#define LUA_VTHREAD makevariant(LUA_TTHREAD, 0) | | ------------------ | | | | 42| 6|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VTHREAD: return traversethread(g, gco2th(o)); ------------------ | | 382| 6|#define gco2th(o) check_exp((o)->tt == LUA_VTHREAD, &((cast_u(o))->th)) | | ------------------ | | | | 115| 6|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (668:5): [True: 6, False: 15] ------------------ 669| 0| default: lua_assert(0); return 0; ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ | Branch (669:5): [True: 0, False: 21] ------------------ 670| 21| } 671| 21|} lgc.c:traversetable: 542| 9|static lu_mem traversetable (global_State *g, Table *h) { 543| 9| const char *weakkey, *weakvalue; 544| 9| const TValue *mode = gfasttm(g, h->metatable, TM_MODE); ------------------ | | 65| 9|#define gfasttm(g,et,e) ((et) == NULL ? NULL : \ | | ------------------ | | | Branch (65:26): [True: 9, False: 0] | | ------------------ | | 66| 9| ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e])) | | ------------------ | | | Branch (66:3): [True: 0, False: 0] | | ------------------ ------------------ 545| 9| markobjectN(g, h->metatable); ------------------ | | 105| 9|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 99| 0|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (105:32): [True: 0, False: 9] | | ------------------ ------------------ 546| 9| if (mode && ttisstring(mode) && /* is there a weak mode? */ ------------------ | | 363| 0|#define ttisstring(o) checktype((o), LUA_TSTRING) | | ------------------ | | | | 92| 9|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 0|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 0|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (546:7): [True: 0, False: 9] ------------------ 547| 9| (cast_void(weakkey = strchr(svalue(mode), 'k')), ------------------ | | 138| 0|#define cast_void(i) cast(void, (i)) | | ------------------ | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (547:7): [True: 0, False: 0] ------------------ 548| 0| cast_void(weakvalue = strchr(svalue(mode), 'v')), ------------------ | | 138| 0|#define cast_void(i) cast(void, (i)) | | ------------------ | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 549| 0| (weakkey || weakvalue))) { /* is really weak? */ ------------------ | Branch (549:9): [True: 0, False: 0] | Branch (549:20): [True: 0, False: 0] ------------------ 550| 0| if (!weakkey) /* strong keys? */ ------------------ | Branch (550:9): [True: 0, False: 0] ------------------ 551| 0| traverseweakvalue(g, h); 552| 0| else if (!weakvalue) /* strong values? */ ------------------ | Branch (552:14): [True: 0, False: 0] ------------------ 553| 0| traverseephemeron(g, h, 0); 554| 0| else /* all weak */ 555| 0| linkgclist(h, g->allweak); /* nothing to traverse now */ ------------------ | | 146| 0|#define linkgclist(o,p) linkgclist_(obj2gco(o), &(o)->gclist, &(p)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 556| 0| } 557| 9| else /* not weak */ 558| 9| traversestrongtable(g, h); 559| 9| return 1 + h->alimit + 2 * allocsizenode(h); ------------------ | | 31| 9|#define allocsizenode(t) (isdummy(t) ? 0 : sizenode(t)) | | ------------------ | | | | 27| 9|#define isdummy(t) ((t)->lastfree == NULL) | | | | ------------------ | | | | | Branch (27:21): [True: 6, False: 3] | | | | ------------------ | | ------------------ | | #define allocsizenode(t) (isdummy(t) ? 0 : sizenode(t)) | | ------------------ | | | | 793| 3|#define sizenode(t) (twoto((t)->lsizenode)) | | | | ------------------ | | | | | | 792| 3|#define twoto(x) (1<<(x)) | | | | ------------------ | | ------------------ ------------------ 560| 9|} lgc.c:clearkey: 171| 6|static void clearkey (Node *n) { 172| 6| lua_assert(isempty(gval(n))); ------------------ | | 114| 6|#define lua_assert(c) ((void)0) ------------------ 173| 6| if (keyiscollectable(n)) ------------------ | | 766| 6|#define keyiscollectable(n) (keytt(n) & BIT_ISCOLLECTABLE) | | ------------------ | | | | 755| 6|#define keytt(node) ((node)->u.key_tt) | | ------------------ | | #define keyiscollectable(n) (keytt(n) & BIT_ISCOLLECTABLE) | | ------------------ | | | | 298| 6|#define BIT_ISCOLLECTABLE (1 << 6) | | ------------------ | | | Branch (766:29): [True: 0, False: 6] | | ------------------ ------------------ 174| 0| setdeadkey(n); /* unused key; remove it */ ------------------ | | 778| 0|#define setdeadkey(node) (keytt(node) = LUA_TDEADKEY) | | ------------------ | | | | 755| 0|#define keytt(node) ((node)->u.key_tt) | | ------------------ | | #define setdeadkey(node) (keytt(node) = LUA_TDEADKEY) | | ------------------ | | | | 24| 0|#define LUA_TDEADKEY (LUA_NUMTYPES+2) /* removed keys in tables */ | | | | ------------------ | | | | | | 75| 0|#define LUA_NUMTYPES 9 | | | | ------------------ | | ------------------ ------------------ 175| 6|} lgc.c:genlink: 430| 9|static void genlink (global_State *g, GCObject *o) { 431| 9| lua_assert(isblack(o)); ------------------ | | 114| 9|#define lua_assert(c) ((void)0) ------------------ 432| 9| if (getage(o) == G_TOUCHED1) { /* touched in this cycle? */ ------------------ | | 116| 9|#define getage(o) ((o)->marked & AGEBITS) | | ------------------ | | | | 114| 9|#define AGEBITS 7 /* all age bits (111) */ | | ------------------ ------------------ if (getage(o) == G_TOUCHED1) { /* touched in this cycle? */ ------------------ | | 111| 9|#define G_TOUCHED1 5 /* old object touched this cycle */ ------------------ | Branch (432:7): [True: 0, False: 9] ------------------ 433| 0| linkobjgclist(o, g->grayagain); /* link it back in 'grayagain' */ ------------------ | | 159| 0|#define linkobjgclist(o,p) linkgclist_(obj2gco(o), getgclist(o), &(p)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 434| 0| } /* everything else do not need to be linked back */ 435| 9| else if (getage(o) == G_TOUCHED2) ------------------ | | 116| 9|#define getage(o) ((o)->marked & AGEBITS) | | ------------------ | | | | 114| 9|#define AGEBITS 7 /* all age bits (111) */ | | ------------------ ------------------ else if (getage(o) == G_TOUCHED2) ------------------ | | 112| 9|#define G_TOUCHED2 6 /* old object touched in previous cycle */ ------------------ | Branch (435:12): [True: 0, False: 9] ------------------ 436| 0| changeage(o, G_TOUCHED2, G_OLD); /* advance age */ ------------------ | | 121| 0| check_exp(getage(o) == (f), (o)->marked ^= ((f)^(t))) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 437| 9|} lgc.c:traversestrongtable: 523| 9|static void traversestrongtable (global_State *g, Table *h) { 524| 9| Node *n, *limit = gnodelast(h); ------------------ | | 122| 9|#define gnodelast(h) gnode(h, cast_sizet(sizenode(h))) | | ------------------ | | | | 13| 9|#define gnode(t,i) (&(t)->node[i]) | | ------------------ ------------------ 525| 9| unsigned int i; 526| 9| unsigned int asize = luaH_realasize(h); 527| 15| for (i = 0; i < asize; i++) /* traverse array part */ ------------------ | Branch (527:15): [True: 6, False: 9] ------------------ 528| 6| markvalue(g, &h->array[i]); ------------------ | | 94| 6|#define markvalue(g,o) { checkliveness(g->mainthread,o); \ | | ------------------ | | | | 107| 6| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 6|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 6| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | 95| 6| if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 83| 6|#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 300| 12|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 6|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 6|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 6, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 87| 6|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 6|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 3, False: 3] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 305| 3|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 115| 3|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 529| 18| for (n = gnode(h, 0); n < limit; n++) { /* traverse hash part */ ------------------ | | 13| 9|#define gnode(t,i) (&(t)->node[i]) ------------------ | Branch (529:25): [True: 9, False: 9] ------------------ 530| 9| if (isempty(gval(n))) /* entry is empty? */ ------------------ | | 217| 9|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 9|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 9|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 9|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 9|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 6, False: 3] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 531| 6| clearkey(n); /* clear its key */ 532| 3| else { 533| 3| lua_assert(!keyisnil(n)); ------------------ | | 114| 3|#define lua_assert(c) ((void)0) ------------------ 534| 3| markkey(g, n); ------------------ | | 97| 3|#define markkey(g, n) { if keyiswhite(n) reallymarkobject(g,gckey(n)); } | | ------------------ | | | | 85| 3|#define keyiswhite(n) (keyiscollectable(n) && iswhite(gckey(n))) | | | | ------------------ | | | | | | 766| 6|#define keyiscollectable(n) (keytt(n) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 755| 3|#define keytt(node) ((node)->u.key_tt) | | | | | | ------------------ | | | | | | #define keyiscollectable(n) (keytt(n) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 3|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (766:29): [True: 3, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define keyiswhite(n) (keyiscollectable(n) && iswhite(gckey(n))) | | | | ------------------ | | | | | | 87| 3|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 3|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 3] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define markkey(g, n) { if keyiswhite(n) reallymarkobject(g,gckey(n)); } | | ------------------ | | | | 768| 0|#define gckey(n) (keyval(n).gc) | | | | ------------------ | | | | | | 756| 0|#define keyval(node) ((node)->u.key_val) | | | | ------------------ | | ------------------ ------------------ 535| 3| markvalue(g, gval(n)); ------------------ | | 94| 3|#define markvalue(g,o) { checkliveness(g->mainthread,o); \ | | ------------------ | | | | 107| 3| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 3|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 3| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | 95| 3| if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 83| 3|#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 300| 6|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 3|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 3|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 3, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 87| 3|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 3|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 3] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 305| 0|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 536| 3| } 537| 9| } 538| 9| genlink(g, obj2gco(h)); ------------------ | | 390| 9|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | ------------------ | | | | 115| 9|#define check_exp(c,e) (e) | | ------------------ ------------------ 539| 9|} lgc.c:traverseLclosure: 604| 3|static int traverseLclosure (global_State *g, LClosure *cl) { 605| 3| int i; 606| 3| markobjectN(g, cl->p); /* mark its prototype */ ------------------ | | 105| 3|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 99| 3|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 87| 3|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 3|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 3, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 390| 3|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 3|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (105:32): [True: 3, False: 0] | | ------------------ ------------------ 607| 6| for (i = 0; i < cl->nupvalues; i++) { /* visit its upvalues */ ------------------ | Branch (607:15): [True: 3, False: 3] ------------------ 608| 3| UpVal *uv = cl->upvals[i]; 609| 3| markobjectN(g, uv); /* mark upvalue */ ------------------ | | 105| 3|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 99| 0|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (105:32): [True: 0, False: 3] | | ------------------ ------------------ 610| 3| } 611| 3| return 1 + cl->nupvalues; 612| 3|} lgc.c:traverseproto: 578| 3|static int traverseproto (global_State *g, Proto *f) { 579| 3| int i; 580| 3| markobjectN(g, f->source); ------------------ | | 105| 3|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 99| 3|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 87| 3|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 3|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 3, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 390| 3|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 3|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (105:32): [True: 3, False: 0] | | ------------------ ------------------ 581| 3| for (i = 0; i < f->sizek; i++) /* mark literals */ ------------------ | Branch (581:15): [True: 0, False: 3] ------------------ 582| 0| markvalue(g, &f->k[i]); ------------------ | | 94| 0|#define markvalue(g,o) { checkliveness(g->mainthread,o); \ | | ------------------ | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | 95| 0| if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 83| 0|#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 300| 0|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 0|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 305| 0|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 583| 15| for (i = 0; i < f->sizeupvalues; i++) /* mark upvalue names */ ------------------ | Branch (583:15): [True: 12, False: 3] ------------------ 584| 12| markobjectN(g, f->upvalues[i].name); ------------------ | | 105| 12|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 99| 3|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 87| 3|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 3|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 3] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (105:32): [True: 3, False: 9] | | ------------------ ------------------ 585| 3| for (i = 0; i < f->sizep; i++) /* mark nested protos */ ------------------ | Branch (585:15): [True: 0, False: 3] ------------------ 586| 0| markobjectN(g, f->p[i]); ------------------ | | 105| 0|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 99| 0|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (105:32): [True: 0, False: 0] | | ------------------ ------------------ 587| 3| for (i = 0; i < f->sizelocvars; i++) /* mark local-variable names */ ------------------ | Branch (587:15): [True: 0, False: 3] ------------------ 588| 0| markobjectN(g, f->locvars[i].varname); ------------------ | | 105| 0|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 99| 0|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (105:32): [True: 0, False: 0] | | ------------------ ------------------ 589| 3| return 1 + f->sizek + f->sizeupvalues + f->sizep + f->sizelocvars; 590| 3|} lgc.c:traversethread: 627| 6|static int traversethread (global_State *g, lua_State *th) { 628| 6| UpVal *uv; 629| 6| StkId o = th->stack.p; 630| 6| if (isold(th) || g->gcstate == GCSpropagate) ------------------ | | 118| 12|#define isold(o) (getage(o) > G_SURVIVAL) | | ------------------ | | | | 116| 6|#define getage(o) ((o)->marked & AGEBITS) | | | | ------------------ | | | | | | 114| 6|#define AGEBITS 7 /* all age bits (111) */ | | | | ------------------ | | ------------------ | | #define isold(o) (getage(o) > G_SURVIVAL) | | ------------------ | | | | 107| 6|#define G_SURVIVAL 1 /* created in previous cycle */ | | ------------------ | | | Branch (118:18): [True: 0, False: 6] | | ------------------ ------------------ if (isold(th) || g->gcstate == GCSpropagate) ------------------ | | 31| 6|#define GCSpropagate 0 ------------------ | Branch (630:20): [True: 3, False: 3] ------------------ 631| 3| linkgclist(th, g->grayagain); /* insert into 'grayagain' list */ ------------------ | | 146| 3|#define linkgclist(o,p) linkgclist_(obj2gco(o), &(o)->gclist, &(p)) | | ------------------ | | | | 390| 3|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 3|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 632| 6| if (o == NULL) ------------------ | Branch (632:7): [True: 0, False: 6] ------------------ 633| 0| return 1; /* stack not completely built yet */ 634| 6| lua_assert(g->gcstate == GCSatomic || ------------------ | | 114| 6|#define lua_assert(c) ((void)0) ------------------ 635| 6| th->openupval == NULL || isintwups(th)); 636| 30| for (; o < th->top.p; o++) /* mark live elements in the stack */ ------------------ | Branch (636:10): [True: 24, False: 6] ------------------ 637| 24| markvalue(g, s2v(o)); ------------------ | | 94| 30|#define markvalue(g,o) { checkliveness(g->mainthread,o); \ | | ------------------ | | | | 107| 24| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 24|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 24| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | 95| 30| if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 83| 24|#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 300| 48|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 24|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 24|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 18, False: 6] | | | | | | ------------------ | | | | ------------------ | | | | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 87| 18|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 18|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 9, False: 9] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 305| 9|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 115| 9|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 638| 6| for (uv = th->openupval; uv != NULL; uv = uv->u.open.next) ------------------ | Branch (638:28): [True: 0, False: 6] ------------------ 639| 0| markobject(g, uv); /* open upvalues cannot be collected */ ------------------ | | 99| 6|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | ------------------ | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 640| 6| if (g->gcstate == GCSatomic) { /* final traversal? */ ------------------ | | 33| 6|#define GCSatomic 2 ------------------ | Branch (640:7): [True: 3, False: 3] ------------------ 641| 126| for (; o < th->stack_last.p + EXTRA_STACK; o++) ------------------ | | 142| 126|#define EXTRA_STACK 5 ------------------ | Branch (641:12): [True: 123, False: 3] ------------------ 642| 123| setnilvalue(s2v(o)); /* clear dead stack slice */ ------------------ | | 200| 123|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 123|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 643| | /* 'remarkupvals' may have removed thread from 'twups' list */ 644| 3| if (!isintwups(th) && th->openupval != NULL) { ------------------ | | 22| 6|#define isintwups(L) (L->twups != L) ------------------ | Branch (644:9): [True: 3, False: 0] | Branch (644:27): [True: 0, False: 3] ------------------ 645| 0| th->twups = g->twups; /* link it back to the list */ 646| 0| g->twups = th; 647| 0| } 648| 3| } 649| 3| else if (!g->gcemergency) ------------------ | Branch (649:12): [True: 3, False: 0] ------------------ 650| 3| luaD_shrinkstack(th); /* do not change stack in emergency cycle */ 651| 6| return 1 + stacksize(th); ------------------ | | 147| 6|#define stacksize(th) cast_int((th)->stack_last.p - (th)->stack.p) | | ------------------ | | | | 141| 6|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 6|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 652| 6|} lgc.c:remarkupvals: 367| 3|static int remarkupvals (global_State *g) { 368| 3| lua_State *thread; 369| 3| lua_State **p = &g->twups; 370| 3| int work = 0; /* estimate of how much work was done here */ 371| 3| while ((thread = *p) != NULL) { ------------------ | Branch (371:10): [True: 0, False: 3] ------------------ 372| 0| work++; 373| 0| if (!iswhite(thread) && thread->openupval != NULL) ------------------ | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | ------------------ | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | ------------------ ------------------ | Branch (373:9): [True: 0, False: 0] | Branch (373:29): [True: 0, False: 0] ------------------ 374| 0| p = &thread->twups; /* keep marked thread with upvalues in the list */ 375| 0| else { /* thread is not marked or without upvalues */ 376| 0| UpVal *uv; 377| 0| lua_assert(!isold(thread) || thread->openupval == NULL); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 378| 0| *p = thread->twups; /* remove thread from the list */ 379| 0| thread->twups = thread; /* mark that it is out of list */ 380| 0| for (uv = thread->openupval; uv != NULL; uv = uv->u.open.next) { ------------------ | Branch (380:36): [True: 0, False: 0] ------------------ 381| 0| lua_assert(getage(uv) <= getage(thread)); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 382| 0| work++; 383| 0| if (!iswhite(uv)) { /* upvalue already visited? */ ------------------ | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | ------------------ | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | ------------------ ------------------ | Branch (383:13): [True: 0, False: 0] ------------------ 384| 0| lua_assert(upisopen(uv) && isgray(uv)); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 385| 0| markvalue(g, uv->v.p); /* mark its value */ ------------------ | | 94| 0|#define markvalue(g,o) { checkliveness(g->mainthread,o); \ | | ------------------ | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | 95| 0| if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 83| 0|#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 300| 0|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 0|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 305| 0|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 386| 0| } 387| 0| } 388| 0| } 389| 0| } 390| 3| return work; 391| 3|} lgc.c:convergeephemerons: 689| 6|static void convergeephemerons (global_State *g) { 690| 6| int changed; 691| 6| int dir = 0; 692| 6| do { 693| 6| GCObject *w; 694| 6| GCObject *next = g->ephemeron; /* get ephemeron list */ 695| 6| g->ephemeron = NULL; /* tables may return to this list when traversed */ 696| 6| changed = 0; 697| 6| while ((w = next) != NULL) { /* for each ephemeron table */ ------------------ | Branch (697:12): [True: 0, False: 6] ------------------ 698| 0| Table *h = gco2t(w); ------------------ | | 380| 0|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 699| 0| next = h->gclist; /* list is rebuilt during loop */ 700| 0| nw2black(h); /* out of the list (for now) */ ------------------ | | 100| 0| check_exp(!iswhite(x), l_setbit((x)->marked, BLACKBIT)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 701| 0| if (traverseephemeron(g, h, dir)) { /* marked some value? */ ------------------ | Branch (701:11): [True: 0, False: 0] ------------------ 702| 0| propagateall(g); /* propagate changes */ 703| 0| changed = 1; /* will have to revisit all ephemeron tables */ 704| 0| } 705| 0| } 706| 6| dir = !dir; /* invert direction next time */ 707| 6| } while (changed); /* repeat until no more changes */ ------------------ | Branch (707:12): [True: 0, False: 6] ------------------ 708| 6|} lgc.c:clearbyvalues: 742| 12|static void clearbyvalues (global_State *g, GCObject *l, GCObject *f) { 743| 12| for (; l != f; l = gco2t(l)->gclist) { ------------------ | | 380| 0|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (743:10): [True: 0, False: 12] ------------------ 744| 0| Table *h = gco2t(l); ------------------ | | 380| 0|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 745| 0| Node *n, *limit = gnodelast(h); ------------------ | | 122| 0|#define gnodelast(h) gnode(h, cast_sizet(sizenode(h))) | | ------------------ | | | | 13| 0|#define gnode(t,i) (&(t)->node[i]) | | ------------------ ------------------ 746| 0| unsigned int i; 747| 0| unsigned int asize = luaH_realasize(h); 748| 0| for (i = 0; i < asize; i++) { ------------------ | Branch (748:17): [True: 0, False: 0] ------------------ 749| 0| TValue *o = &h->array[i]; 750| 0| if (iscleared(g, gcvalueN(o))) /* value was collected? */ ------------------ | | 91| 0|#define gcvalueN(o) (iscollectable(o) ? gcvalue(o) : NULL) | | ------------------ | | | | 300| 0|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 298| 0|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (300:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define gcvalueN(o) (iscollectable(o) ? gcvalue(o) : NULL) | | ------------------ | | | | 305| 0|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ | Branch (750:11): [True: 0, False: 0] ------------------ 751| 0| setempty(o); /* remove entry */ ------------------ | | 225| 0|#define setempty(v) settt_(v, LUA_VEMPTY) | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 752| 0| } 753| 0| for (n = gnode(h, 0); n < limit; n++) { ------------------ | | 13| 0|#define gnode(t,i) (&(t)->node[i]) ------------------ | Branch (753:27): [True: 0, False: 0] ------------------ 754| 0| if (iscleared(g, gcvalueN(gval(n)))) /* unmarked value? */ ------------------ | | 91| 0|#define gcvalueN(o) (iscollectable(o) ? gcvalue(o) : NULL) | | ------------------ | | | | 300| 0|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 298| 0|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (300:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define gcvalueN(o) (iscollectable(o) ? gcvalue(o) : NULL) | | ------------------ | | | | 305| 0|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ | Branch (754:11): [True: 0, False: 0] ------------------ 755| 0| setempty(gval(n)); /* remove entry */ ------------------ | | 225| 0|#define setempty(v) settt_(v, LUA_VEMPTY) | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 756| 0| if (isempty(gval(n))) /* is entry empty? */ ------------------ | | 217| 0|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 0|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 0|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 0|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 0|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 757| 0| clearkey(n); /* clear its key */ 758| 0| } 759| 0| } 760| 12|} lgc.c:markbeingfnz: 345| 6|static lu_mem markbeingfnz (global_State *g) { 346| 6| GCObject *o; 347| 6| lu_mem count = 0; 348| 6| for (o = g->tobefnz; o != NULL; o = o->next) { ------------------ | Branch (348:24): [True: 0, False: 6] ------------------ 349| 0| count++; 350| 0| markobject(g, o); ------------------ | | 99| 0|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | ------------------ | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 351| 0| } 352| 6| return count; 353| 6|} lgc.c:clearbykeys: 723| 6|static void clearbykeys (global_State *g, GCObject *l) { 724| 6| for (; l; l = gco2t(l)->gclist) { ------------------ | | 380| 0|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (724:10): [True: 0, False: 6] ------------------ 725| 0| Table *h = gco2t(l); ------------------ | | 380| 0|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 726| 0| Node *limit = gnodelast(h); ------------------ | | 122| 0|#define gnodelast(h) gnode(h, cast_sizet(sizenode(h))) | | ------------------ | | | | 13| 0|#define gnode(t,i) (&(t)->node[i]) | | ------------------ ------------------ 727| 0| Node *n; 728| 0| for (n = gnode(h, 0); n < limit; n++) { ------------------ | | 13| 0|#define gnode(t,i) (&(t)->node[i]) ------------------ | Branch (728:27): [True: 0, False: 0] ------------------ 729| 0| if (iscleared(g, gckeyN(n))) /* unmarked key? */ ------------------ | | 769| 0|#define gckeyN(n) (keyiscollectable(n) ? gckey(n) : NULL) | | ------------------ | | | | 766| 0|#define keyiscollectable(n) (keytt(n) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 755| 0|#define keytt(node) ((node)->u.key_tt) | | | | ------------------ | | | | #define keyiscollectable(n) (keytt(n) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 298| 0|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (766:29): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define gckeyN(n) (keyiscollectable(n) ? gckey(n) : NULL) | | ------------------ | | | | 768| 0|#define gckey(n) (keyval(n).gc) | | | | ------------------ | | | | | | 756| 0|#define keyval(node) ((node)->u.key_val) | | | | ------------------ | | ------------------ ------------------ | Branch (729:11): [True: 0, False: 0] ------------------ 730| 0| setempty(gval(n)); /* remove entry */ ------------------ | | 225| 0|#define setempty(v) settt_(v, LUA_VEMPTY) | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 731| 0| if (isempty(gval(n))) /* is entry empty? */ ------------------ | | 217| 0|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 0|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 0|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 0|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 0|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 732| 0| clearkey(n); /* clear its key */ 733| 0| } 734| 0| } 735| 6|} lgc.c:cleargraylists: 394| 3|static void cleargraylists (global_State *g) { 395| 3| g->gray = g->grayagain = NULL; 396| 3| g->weak = g->allweak = g->ephemeron = NULL; 397| 3|} lgc.c:checkSizes: 869| 3|static void checkSizes (lua_State *L, global_State *g) { 870| 3| if (!g->gcemergency) { ------------------ | Branch (870:7): [True: 3, False: 0] ------------------ 871| 3| if (g->strt.nuse < g->strt.size / 4) { /* string table too big? */ ------------------ | Branch (871:9): [True: 0, False: 3] ------------------ 872| 0| l_mem olddebt = g->GCdebt; 873| 0| luaS_resize(L, g->strt.size / 2); 874| 0| g->GCestimate += g->GCdebt - olddebt; /* correct estimate */ 875| 0| } 876| 3| } 877| 3|} lgc.c:separatetobefnz: 972| 9|static void separatetobefnz (global_State *g, int all) { 973| 9| GCObject *curr; 974| 9| GCObject **p = &g->finobj; 975| 9| GCObject **lastnext = findlast(&g->tobefnz); 976| 9| while ((curr = *p) != g->finobjold1) { /* traverse all finalizable objects */ ------------------ | Branch (976:10): [True: 0, False: 9] ------------------ 977| 0| lua_assert(tofinalize(curr)); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 978| 0| if (!(iswhite(curr) || all)) /* not being collected? */ ------------------ | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | ------------------ | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | ------------------ | | | | | Branch (62:24): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (978:28): [True: 0, False: 0] ------------------ 979| 0| p = &curr->next; /* don't bother with it */ 980| 0| else { 981| 0| if (curr == g->finobjsur) /* removing 'finobjsur'? */ ------------------ | Branch (981:11): [True: 0, False: 0] ------------------ 982| 0| g->finobjsur = curr->next; /* correct it */ 983| 0| *p = curr->next; /* remove 'curr' from 'finobj' list */ 984| 0| curr->next = *lastnext; /* link at the end of 'tobefnz' list */ 985| 0| *lastnext = curr; 986| 0| lastnext = &curr->next; 987| 0| } 988| 0| } 989| 9|} lgc.c:findlast: 958| 9|static GCObject **findlast (GCObject **p) { 959| 9| while (*p != NULL) ------------------ | Branch (959:10): [True: 0, False: 9] ------------------ 960| 0| p = &(*p)->next; 961| 9| return p; 962| 9|} lgc.c:callallpendingfinalizers: 948| 6|static void callallpendingfinalizers (lua_State *L) { 949| 6| global_State *g = G(L); ------------------ | | 335| 6|#define G(L) (L->l_G) ------------------ 950| 6| while (g->tobefnz) ------------------ | Branch (950:10): [True: 0, False: 6] ------------------ 951| 0| GCTM(L); 952| 6|} lgc.c:deletelist: 1496| 12|static void deletelist (lua_State *L, GCObject *p, GCObject *limit) { 1497| 362| while (p != limit) { ------------------ | Branch (1497:10): [True: 350, False: 12] ------------------ 1498| 350| GCObject *next = p->next; 1499| 350| freeobj(L, p); 1500| 350| p = next; 1501| 350| } 1502| 12|} lgc.c:singlestep: 1583| 51|static lu_mem singlestep (lua_State *L) { 1584| 51| global_State *g = G(L); ------------------ | | 335| 51|#define G(L) (L->l_G) ------------------ 1585| 51| lu_mem work; 1586| 51| lua_assert(!g->gcstopem); /* collector is not reentrant */ ------------------ | | 114| 51|#define lua_assert(c) ((void)0) ------------------ 1587| 51| g->gcstopem = 1; /* no emergency collections while collecting */ 1588| 51| switch (g->gcstate) { 1589| 3| case GCSpause: { ------------------ | | 39| 3|#define GCSpause 8 ------------------ | Branch (1589:5): [True: 3, False: 48] ------------------ 1590| 3| restartcollection(g); 1591| 3| g->gcstate = GCSpropagate; ------------------ | | 31| 3|#define GCSpropagate 0 ------------------ 1592| 3| work = 1; 1593| 3| break; 1594| 0| } 1595| 21| case GCSpropagate: { ------------------ | | 31| 21|#define GCSpropagate 0 ------------------ | Branch (1595:5): [True: 21, False: 30] ------------------ 1596| 21| if (g->gray == NULL) { /* no more gray objects? */ ------------------ | Branch (1596:11): [True: 3, False: 18] ------------------ 1597| 3| g->gcstate = GCSenteratomic; /* finish propagate phase */ ------------------ | | 32| 3|#define GCSenteratomic 1 ------------------ 1598| 3| work = 0; 1599| 3| } 1600| 18| else 1601| 18| work = propagatemark(g); /* traverse one gray object */ 1602| 21| break; 1603| 0| } 1604| 3| case GCSenteratomic: { ------------------ | | 32| 3|#define GCSenteratomic 1 ------------------ | Branch (1604:5): [True: 3, False: 48] ------------------ 1605| 3| work = atomic(L); /* work is what was traversed by 'atomic' */ 1606| 3| entersweep(L); 1607| 3| g->GCestimate = gettotalbytes(g); /* first estimate */; ------------------ | | 394| 3|#define gettotalbytes(g) cast(lu_mem, (g)->totalbytes + (g)->GCdebt) | | ------------------ | | | | 136| 3|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1608| 3| break; 1609| 0| } 1610| 6| case GCSswpallgc: { /* sweep "regular" objects */ ------------------ | | 34| 6|#define GCSswpallgc 3 ------------------ | Branch (1610:5): [True: 6, False: 45] ------------------ 1611| 6| work = sweepstep(L, g, GCSswpfinobj, &g->finobj); ------------------ | | 35| 6|#define GCSswpfinobj 4 ------------------ 1612| 6| break; 1613| 0| } 1614| 6| case GCSswpfinobj: { /* sweep objects with finalizers */ ------------------ | | 35| 6|#define GCSswpfinobj 4 ------------------ | Branch (1614:5): [True: 6, False: 45] ------------------ 1615| 6| work = sweepstep(L, g, GCSswptobefnz, &g->tobefnz); ------------------ | | 36| 6|#define GCSswptobefnz 5 ------------------ 1616| 6| break; 1617| 0| } 1618| 6| case GCSswptobefnz: { /* sweep objects to be finalized */ ------------------ | | 36| 6|#define GCSswptobefnz 5 ------------------ | Branch (1618:5): [True: 6, False: 45] ------------------ 1619| 6| work = sweepstep(L, g, GCSswpend, NULL); ------------------ | | 37| 6|#define GCSswpend 6 ------------------ 1620| 6| break; 1621| 0| } 1622| 3| case GCSswpend: { /* finish sweeps */ ------------------ | | 37| 3|#define GCSswpend 6 ------------------ | Branch (1622:5): [True: 3, False: 48] ------------------ 1623| 3| checkSizes(L, g); 1624| 3| g->gcstate = GCScallfin; ------------------ | | 38| 3|#define GCScallfin 7 ------------------ 1625| 3| work = 0; 1626| 3| break; 1627| 0| } 1628| 3| case GCScallfin: { /* call remaining finalizers */ ------------------ | | 38| 3|#define GCScallfin 7 ------------------ | Branch (1628:5): [True: 3, False: 48] ------------------ 1629| 3| if (g->tobefnz && !g->gcemergency) { ------------------ | Branch (1629:11): [True: 0, False: 3] | Branch (1629:25): [True: 0, False: 0] ------------------ 1630| 0| g->gcstopem = 0; /* ok collections during finalizers */ 1631| 0| work = runafewfinalizers(L, GCFINMAX) * GCFINALIZECOST; ------------------ | | 40| 0|#define GCFINMAX 10 ------------------ work = runafewfinalizers(L, GCFINMAX) * GCFINALIZECOST; ------------------ | | 46| 0|#define GCFINALIZECOST 50 ------------------ 1632| 0| } 1633| 3| else { /* emergency mode or no more finalizers */ 1634| 3| g->gcstate = GCSpause; /* finish collection */ ------------------ | | 39| 3|#define GCSpause 8 ------------------ 1635| 3| work = 0; 1636| 3| } 1637| 3| break; 1638| 0| } 1639| 0| default: lua_assert(0); return 0; ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ | Branch (1639:5): [True: 0, False: 51] ------------------ 1640| 51| } 1641| 51| g->gcstopem = 0; 1642| 51| return work; 1643| 51|} lgc.c:restartcollection: 403| 3|static void restartcollection (global_State *g) { 404| 3| cleargraylists(g); 405| 3| markobject(g, g->mainthread); ------------------ | | 99| 3|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | ------------------ | | | | 87| 3|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 62| 3|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (62:24): [True: 3, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | ------------------ | | | | 390| 3|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 3|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 406| 3| markvalue(g, &g->l_registry); ------------------ | | 94| 3|#define markvalue(g,o) { checkliveness(g->mainthread,o); \ | | ------------------ | | | | 107| 3| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 3|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 3| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | 95| 3| if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 83| 3|#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 300| 6|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 3|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 3|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 3, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 87| 3|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 3|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 3, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 305| 3|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 115| 3|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 407| 3| markmt(g); 408| 3| markbeingfnz(g); /* mark any finalizing object left from previous cycle */ 409| 3|} lgc.c:entersweep: 1484| 3|static void entersweep (lua_State *L) { 1485| 3| global_State *g = G(L); ------------------ | | 335| 3|#define G(L) (L->l_G) ------------------ 1486| 3| g->gcstate = GCSswpallgc; ------------------ | | 34| 3|#define GCSswpallgc 3 ------------------ 1487| 3| lua_assert(g->sweepgc == NULL); ------------------ | | 114| 3|#define lua_assert(c) ((void)0) ------------------ 1488| 3| g->sweepgc = sweeptolive(L, &g->allgc); 1489| 3|} lgc.c:sweepstep: 1567| 18| int nextstate, GCObject **nextlist) { 1568| 18| if (g->sweepgc) { ------------------ | Branch (1568:7): [True: 9, False: 9] ------------------ 1569| 9| l_mem olddebt = g->GCdebt; 1570| 9| int count; 1571| 9| g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX, &count); ------------------ | | 35| 9|#define GCSWEEPMAX 100 ------------------ 1572| 9| g->GCestimate += g->GCdebt - olddebt; /* update estimate */ 1573| 9| return count; 1574| 9| } 1575| 9| else { /* enter next state */ 1576| 9| g->gcstate = nextstate; 1577| 9| g->sweepgc = nextlist; 1578| 9| return 0; /* no work done */ 1579| 9| } 1580| 18|} lgc.c:setpause: 1057| 3|static void setpause (global_State *g) { 1058| 3| l_mem threshold, debt; 1059| 3| int pause = getgcparam(g->gcpause); ------------------ | | 135| 3|#define getgcparam(p) ((p) * 4) ------------------ 1060| 3| l_mem estimate = g->GCestimate / PAUSEADJ; /* adjust 'estimate' */ ------------------ | | 60| 3|#define PAUSEADJ 100 ------------------ 1061| 3| lua_assert(estimate > 0); ------------------ | | 114| 3|#define lua_assert(c) ((void)0) ------------------ 1062| 3| threshold = (pause < MAX_LMEM / estimate) /* overflow? */ ------------------ | | 50| 3|#define MAX_LMEM ((l_mem)(MAX_LUMEM >> 1)) | | ------------------ | | | | 48| 3|#define MAX_LUMEM ((lu_mem)(~(lu_mem)0)) | | ------------------ ------------------ | Branch (1062:15): [True: 3, False: 0] ------------------ 1063| 3| ? estimate * pause /* no overflow */ 1064| 3| : MAX_LMEM; /* overflow; truncate to maximum */ ------------------ | | 50| 3|#define MAX_LMEM ((l_mem)(MAX_LUMEM >> 1)) | | ------------------ | | | | 48| 0|#define MAX_LUMEM ((lu_mem)(~(lu_mem)0)) | | ------------------ ------------------ 1065| 3| debt = gettotalbytes(g) - threshold; ------------------ | | 394| 3|#define gettotalbytes(g) cast(lu_mem, (g)->totalbytes + (g)->GCdebt) | | ------------------ | | | | 136| 3|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1066| 3| if (debt > 0) debt = 0; ------------------ | Branch (1066:7): [True: 0, False: 3] ------------------ 1067| 3| luaE_setdebt(g, debt); 1068| 3|} lgc.c:incstep: 1665| 3|static void incstep (lua_State *L, global_State *g) { 1666| 3| int stepmul = (getgcparam(g->gcstepmul) | 1); /* avoid division by 0 */ ------------------ | | 135| 3|#define getgcparam(p) ((p) * 4) ------------------ 1667| 3| l_mem debt = (g->GCdebt / WORK2MEM) * stepmul; ------------------ | | 53| 3|#define WORK2MEM sizeof(TValue) ------------------ 1668| 3| l_mem stepsize = (g->gcstepsize <= log2maxs(l_mem)) ------------------ | | 60| 3|#define log2maxs(t) (sizeof(t) * 8 - 2) ------------------ | Branch (1668:20): [True: 3, False: 0] ------------------ 1669| 3| ? ((cast(l_mem, 1) << g->gcstepsize) / WORK2MEM) * stepmul ------------------ | | 136| 3|#define cast(t, exp) ((t)(exp)) ------------------ ? ((cast(l_mem, 1) << g->gcstepsize) / WORK2MEM) * stepmul ------------------ | | 53| 3|#define WORK2MEM sizeof(TValue) ------------------ 1670| 3| : MAX_LMEM; /* overflow; keep maximum value */ ------------------ | | 50| 3|#define MAX_LMEM ((l_mem)(MAX_LUMEM >> 1)) | | ------------------ | | | | 48| 0|#define MAX_LUMEM ((lu_mem)(~(lu_mem)0)) | | ------------------ ------------------ 1671| 51| do { /* repeat until pause or enough "credit" (negative debt) */ 1672| 51| lu_mem work = singlestep(L); /* perform one single step */ 1673| 51| debt -= work; 1674| 51| } while (debt > -stepsize && g->gcstate != GCSpause); ------------------ | | 39| 51|#define GCSpause 8 ------------------ | Branch (1674:12): [True: 51, False: 0] | Branch (1674:32): [True: 48, False: 3] ------------------ 1675| 3| if (g->gcstate == GCSpause) ------------------ | | 39| 3|#define GCSpause 8 ------------------ | Branch (1675:7): [True: 3, False: 0] ------------------ 1676| 3| setpause(g); /* pause until next cycle */ 1677| 0| else { 1678| 0| debt = (debt / stepmul) * WORK2MEM; /* convert 'work units' to bytes */ ------------------ | | 53| 0|#define WORK2MEM sizeof(TValue) ------------------ 1679| 0| luaE_setdebt(g, debt); 1680| 0| } 1681| 3|} luaX_init: 70| 6|void luaX_init (lua_State *L) { 71| 6| int i; 72| 6| TString *e = luaS_newliteral(L, LUA_ENV); /* create env name */ ------------------ | | 28| 6|#define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \ | | 29| 6| (sizeof(s)/sizeof(char))-1)) ------------------ 73| 6| luaC_fix(L, obj2gco(e)); /* never collect this name */ ------------------ | | 390| 6|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | ------------------ | | | | 115| 6|#define check_exp(c,e) (e) | | ------------------ ------------------ 74| 138| for (i=0; itt >= LUA_TSTRING, &(cast_u(v)->gc)) | | ------------------ | | | | 115| 132|#define check_exp(c,e) (e) | | ------------------ ------------------ 77| 132| ts->extra = cast_byte(i+1); /* reserved word */ ------------------ | | 143| 132|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 132|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 78| 132| } 79| 6|} luaX_token2str: 82| 5|const char *luaX_token2str (LexState *ls, int token) { 83| 5| if (token < FIRST_RESERVED) { /* single-byte symbols? */ ------------------ | | 20| 5|#define FIRST_RESERVED (UCHAR_MAX + 1) ------------------ | Branch (83:7): [True: 4, False: 1] ------------------ 84| 4| if (lisprint(token)) ------------------ | | 61| 4|#define lisprint(c) testprop(c, MASK(PRINTBIT)) | | ------------------ | | | | 52| 4|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | | | ------------------ | | | | | Branch (52:23): [True: 0, False: 4] | | | | ------------------ | | ------------------ ------------------ 85| 0| return luaO_pushfstring(ls->L, "'%c'", token); 86| 4| else /* control character */ 87| 4| return luaO_pushfstring(ls->L, "'<\\%d>'", token); 88| 4| } 89| 1| else { 90| 1| const char *s = luaX_tokens[token - FIRST_RESERVED]; ------------------ | | 20| 1|#define FIRST_RESERVED (UCHAR_MAX + 1) ------------------ 91| 1| if (token < TK_EOS) /* fixed format (symbols and reserved words)? */ ------------------ | Branch (91:9): [True: 0, False: 1] ------------------ 92| 0| return luaO_pushfstring(ls->L, "'%s'", s); 93| 1| else /* names, strings, and numerals */ 94| 1| return s; 95| 1| } 96| 5|} luaX_syntaxerror: 119| 6|l_noret luaX_syntaxerror (LexState *ls, const char *msg) { 120| 6| lexerror(ls, msg, ls->t.token); 121| 6|} luaX_newstring: 134| 3|TString *luaX_newstring (LexState *ls, const char *str, size_t l) { 135| 3| lua_State *L = ls->L; 136| 3| TString *ts = luaS_newlstr(L, str, l); /* create new string */ 137| 3| const TValue *o = luaH_getstr(ls->h, ts); 138| 3| if (!ttisnil(o)) /* string already present? */ ------------------ | | 193| 3|#define ttisnil(v) checktype((v), LUA_TNIL) | | ------------------ | | | | 92| 3|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 3|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 3|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (138:7): [True: 0, False: 3] ------------------ 139| 0| ts = keystrval(nodefromval(o)); /* get saved copy */ ------------------ | | 762| 0|#define keystrval(node) (gco2ts(keyval(node).gc)) | | ------------------ | | | | 374| 0| check_exp(novariant((o)->tt) == LUA_TSTRING, &((cast_u(o))->ts)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 140| 3| else { /* not in use yet */ 141| 3| TValue *stv = s2v(L->top.p++); /* reserve stack space for string */ ------------------ | | 172| 3|#define s2v(o) (&(o)->val) ------------------ 142| 3| setsvalue(L, stv, ts); /* temporarily anchor the string */ ------------------ | | 372| 3| { TValue *io = (obj); TString *x_ = (x); \ | | 373| 3| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 72| 3|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 390| 3|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 3|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 114| 3|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 374| 3| checkliveness(L,io); } | | ------------------ | | | | 107| 3| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 3|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 3| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 143| 3| luaH_finishset(L, ls->h, stv, o, stv); /* t[string] = string */ 144| | /* table is not a metatable, so it does not need to invalidate cache */ 145| 3| luaC_checkGC(L); ------------------ | | 172| 3|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 168| 3| { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 335| 3|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (168:8): [True: 3, False: 0] | | | | ------------------ | | | | 169| 3| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 374| 3|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 146| 3| L->top.p--; /* remove string from stack */ 147| 3| } 148| 3| return ts; 149| 3|} luaX_setinput: 168| 6| int firstchar) { 169| 6| ls->t.token = 0; 170| 6| ls->L = L; 171| 6| ls->current = firstchar; 172| 6| ls->lookahead.token = TK_EOS; /* no look-ahead token */ 173| 6| ls->z = z; 174| 6| ls->fs = NULL; 175| 6| ls->linenumber = 1; 176| 6| ls->lastline = 1; 177| 6| ls->source = source; 178| 6| ls->envn = luaS_newliteral(L, LUA_ENV); /* get env name */ ------------------ | | 28| 6|#define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \ | | 29| 6| (sizeof(s)/sizeof(char))-1)) ------------------ 179| 6| luaZ_resizebuffer(ls->L, ls->buff, LUA_MINBUFFER); /* initialize buffer */ ------------------ | | 40| 6| ((buff)->buffer = luaM_reallocvchar(L, (buff)->buffer, \ | | ------------------ | | | | 53| 6| cast_charp(luaM_saferealloc_(L, (b), (on)*sizeof(char), (n)*sizeof(char))) | | | | ------------------ | | | | | | 146| 6|#define cast_charp(i) cast(char *, (i)) | | | | | | ------------------ | | | | | | | | 136| 6|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 41| 6| (buff)->buffsize, size), \ | | 42| 6| (buff)->buffsize = size) ------------------ 180| 6|} luaX_next: 565| 9|void luaX_next (LexState *ls) { 566| 9| ls->lastline = ls->linenumber; 567| 9| if (ls->lookahead.token != TK_EOS) { /* is there a look-ahead token? */ ------------------ | Branch (567:7): [True: 0, False: 9] ------------------ 568| 0| ls->t = ls->lookahead; /* use this one */ 569| 0| ls->lookahead.token = TK_EOS; /* and discharge it */ 570| 0| } 571| 9| else 572| 9| ls->t.token = llex(ls, &ls->t.seminfo); /* read next token */ 573| 9|} llex.c:lexerror: 111| 6|static l_noret lexerror (LexState *ls, const char *msg, int token) { 112| 6| msg = luaG_addinfo(ls->L, msg, ls->source, ls->linenumber); 113| 6| if (token) ------------------ | Branch (113:7): [True: 6, False: 0] ------------------ 114| 6| luaO_pushfstring(ls->L, "%s near %s", msg, txtToken(ls, token)); 115| 6| luaD_throw(ls->L, LUA_ERRSYNTAX); ------------------ | | 52| 6|#define LUA_ERRSYNTAX 3 ------------------ 116| 6|} llex.c:txtToken: 99| 6|static const char *txtToken (LexState *ls, int token) { 100| 6| switch (token) { 101| 0| case TK_NAME: case TK_STRING: ------------------ | Branch (101:5): [True: 0, False: 6] | Branch (101:19): [True: 0, False: 6] ------------------ 102| 1| case TK_FLT: case TK_INT: ------------------ | Branch (102:5): [True: 0, False: 6] | Branch (102:18): [True: 1, False: 5] ------------------ 103| 1| save(ls, '\0'); 104| 1| return luaO_pushfstring(ls->L, "'%s'", luaZ_buffer(ls->buff)); ------------------ | | 31| 1|#define luaZ_buffer(buff) ((buff)->buffer) ------------------ 105| 5| default: ------------------ | Branch (105:5): [True: 5, False: 1] ------------------ 106| 5| return luaX_token2str(ls, token); 107| 6| } 108| 6|} llex.c:save: 57| 1.04M|static void save (LexState *ls, int c) { 58| 1.04M| Mbuffer *b = ls->buff; 59| 1.04M| if (luaZ_bufflen(b) + 1 > luaZ_sizebuffer(b)) { ------------------ | | 33| 1.04M|#define luaZ_bufflen(buff) ((buff)->n) ------------------ if (luaZ_bufflen(b) + 1 > luaZ_sizebuffer(b)) { ------------------ | | 32| 1.04M|#define luaZ_sizebuffer(buff) ((buff)->buffsize) ------------------ | Branch (59:7): [True: 15, False: 1.04M] ------------------ 60| 15| size_t newsize; 61| 15| if (luaZ_sizebuffer(b) >= MAX_SIZE/2) ------------------ | | 32| 15|#define luaZ_sizebuffer(buff) ((buff)->buffsize) ------------------ if (luaZ_sizebuffer(b) >= MAX_SIZE/2) ------------------ | | 44| 15|#define MAX_SIZE (sizeof(size_t) < sizeof(lua_Integer) ? MAX_SIZET \ | | ------------------ | | | | 41| 0|#define MAX_SIZET ((size_t)(~(size_t)0)) | | ------------------ | | | Branch (44:19): [Folded - Ignored] | | ------------------ | | 45| 15| : (size_t)(LUA_MAXINTEGER)) | | ------------------ | | | | 545| 15|#define LUA_MAXINTEGER LLONG_MAX | | ------------------ ------------------ | Branch (61:9): [True: 0, False: 15] ------------------ 62| 0| lexerror(ls, "lexical element too long", 0); 63| 15| newsize = luaZ_sizebuffer(b) * 2; ------------------ | | 32| 15|#define luaZ_sizebuffer(buff) ((buff)->buffsize) ------------------ 64| 15| luaZ_resizebuffer(ls->L, b, newsize); ------------------ | | 40| 15| ((buff)->buffer = luaM_reallocvchar(L, (buff)->buffer, \ | | ------------------ | | | | 53| 15| cast_charp(luaM_saferealloc_(L, (b), (on)*sizeof(char), (n)*sizeof(char))) | | | | ------------------ | | | | | | 146| 15|#define cast_charp(i) cast(char *, (i)) | | | | | | ------------------ | | | | | | | | 136| 15|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 41| 15| (buff)->buffsize, size), \ | | 42| 15| (buff)->buffsize = size) ------------------ 65| 15| } 66| 1.04M| b->buffer[luaZ_bufflen(b)++] = cast_char(c); ------------------ | | 33| 1.04M|#define luaZ_bufflen(buff) ((buff)->n) ------------------ b->buffer[luaZ_bufflen(b)++] = cast_char(c); ------------------ | | 145| 1.04M|#define cast_char(i) cast(char, (i)) | | ------------------ | | | | 136| 1.04M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 67| 1.04M|} llex.c:llex: 445| 9|static int llex (LexState *ls, SemInfo *seminfo) { 446| 9| luaZ_resetbuffer(ls->buff); ------------------ | | 36| 9|#define luaZ_resetbuffer(buff) ((buff)->n = 0) ------------------ 447| 9| for (;;) { 448| 9| switch (ls->current) { 449| 0| case '\n': case '\r': { /* line breaks */ ------------------ | Branch (449:7): [True: 0, False: 9] | Branch (449:18): [True: 0, False: 9] ------------------ 450| 0| inclinenumber(ls); 451| 0| break; 452| 0| } 453| 0| case ' ': case '\f': case '\t': case '\v': { /* spaces */ ------------------ | Branch (453:7): [True: 0, False: 9] | Branch (453:17): [True: 0, False: 9] | Branch (453:28): [True: 0, False: 9] | Branch (453:39): [True: 0, False: 9] ------------------ 454| 0| next(ls); ------------------ | | 32| 0|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 0|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 0|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 455| 0| break; 456| 0| } 457| 0| case '-': { /* '-' or '--' (comment) */ ------------------ | Branch (457:7): [True: 0, False: 9] ------------------ 458| 0| next(ls); ------------------ | | 32| 0|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 0|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 0|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 459| 0| if (ls->current != '-') return '-'; ------------------ | Branch (459:13): [True: 0, False: 0] ------------------ 460| | /* else is a comment */ 461| 0| next(ls); ------------------ | | 32| 0|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 0|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 0|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 462| 0| if (ls->current == '[') { /* long comment? */ ------------------ | Branch (462:13): [True: 0, False: 0] ------------------ 463| 0| size_t sep = skip_sep(ls); 464| 0| luaZ_resetbuffer(ls->buff); /* 'skip_sep' may dirty the buffer */ ------------------ | | 36| 0|#define luaZ_resetbuffer(buff) ((buff)->n = 0) ------------------ 465| 0| if (sep >= 2) { ------------------ | Branch (465:15): [True: 0, False: 0] ------------------ 466| 0| read_long_string(ls, NULL, sep); /* skip long comment */ 467| 0| luaZ_resetbuffer(ls->buff); /* previous call may dirty the buff. */ ------------------ | | 36| 0|#define luaZ_resetbuffer(buff) ((buff)->n = 0) ------------------ 468| 0| break; 469| 0| } 470| 0| } 471| | /* else short comment */ 472| 0| while (!currIsNewline(ls) && ls->current != EOZ) ------------------ | | 36| 0|#define currIsNewline(ls) (ls->current == '\n' || ls->current == '\r') | | ------------------ | | | Branch (36:28): [True: 0, False: 0] | | | Branch (36:51): [True: 0, False: 0] | | ------------------ ------------------ while (!currIsNewline(ls) && ls->current != EOZ) ------------------ | | 16| 0|#define EOZ (-1) /* end of stream */ ------------------ | Branch (472:38): [True: 0, False: 0] ------------------ 473| 0| next(ls); /* skip until end of line (or end of file) */ ------------------ | | 32| 0|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 0|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 0|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 474| 0| break; 475| 0| } 476| 0| case '[': { /* long string or simply '[' */ ------------------ | Branch (476:7): [True: 0, False: 9] ------------------ 477| 0| size_t sep = skip_sep(ls); 478| 0| if (sep >= 2) { ------------------ | Branch (478:13): [True: 0, False: 0] ------------------ 479| 0| read_long_string(ls, seminfo, sep); 480| 0| return TK_STRING; 481| 0| } 482| 0| else if (sep == 0) /* '[=...' missing second bracket? */ ------------------ | Branch (482:18): [True: 0, False: 0] ------------------ 483| 0| lexerror(ls, "invalid long string delimiter", TK_STRING); 484| 0| return '['; 485| 0| } 486| 0| case '=': { ------------------ | Branch (486:7): [True: 0, False: 9] ------------------ 487| 0| next(ls); ------------------ | | 32| 0|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 0|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 0|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 488| 0| if (check_next1(ls, '=')) return TK_EQ; /* '==' */ ------------------ | Branch (488:13): [True: 0, False: 0] ------------------ 489| 0| else return '='; 490| 0| } 491| 0| case '<': { ------------------ | Branch (491:7): [True: 0, False: 9] ------------------ 492| 0| next(ls); ------------------ | | 32| 0|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 0|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 0|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 493| 0| if (check_next1(ls, '=')) return TK_LE; /* '<=' */ ------------------ | Branch (493:13): [True: 0, False: 0] ------------------ 494| 0| else if (check_next1(ls, '<')) return TK_SHL; /* '<<' */ ------------------ | Branch (494:18): [True: 0, False: 0] ------------------ 495| 0| else return '<'; 496| 0| } 497| 0| case '>': { ------------------ | Branch (497:7): [True: 0, False: 9] ------------------ 498| 0| next(ls); ------------------ | | 32| 0|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 0|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 0|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 499| 0| if (check_next1(ls, '=')) return TK_GE; /* '>=' */ ------------------ | Branch (499:13): [True: 0, False: 0] ------------------ 500| 0| else if (check_next1(ls, '>')) return TK_SHR; /* '>>' */ ------------------ | Branch (500:18): [True: 0, False: 0] ------------------ 501| 0| else return '>'; 502| 0| } 503| 0| case '/': { ------------------ | Branch (503:7): [True: 0, False: 9] ------------------ 504| 0| next(ls); ------------------ | | 32| 0|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 0|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 0|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 505| 0| if (check_next1(ls, '/')) return TK_IDIV; /* '//' */ ------------------ | Branch (505:13): [True: 0, False: 0] ------------------ 506| 0| else return '/'; 507| 0| } 508| 0| case '~': { ------------------ | Branch (508:7): [True: 0, False: 9] ------------------ 509| 0| next(ls); ------------------ | | 32| 0|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 0|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 0|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 510| 0| if (check_next1(ls, '=')) return TK_NE; /* '~=' */ ------------------ | Branch (510:13): [True: 0, False: 0] ------------------ 511| 0| else return '~'; 512| 0| } 513| 0| case ':': { ------------------ | Branch (513:7): [True: 0, False: 9] ------------------ 514| 0| next(ls); ------------------ | | 32| 0|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 0|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 0|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 515| 0| if (check_next1(ls, ':')) return TK_DBCOLON; /* '::' */ ------------------ | Branch (515:13): [True: 0, False: 0] ------------------ 516| 0| else return ':'; 517| 0| } 518| 0| case '"': case '\'': { /* short literal strings */ ------------------ | Branch (518:7): [True: 0, False: 9] | Branch (518:17): [True: 0, False: 9] ------------------ 519| 0| read_string(ls, ls->current, seminfo); 520| 0| return TK_STRING; 521| 0| } 522| 0| case '.': { /* '.', '..', '...', or number */ ------------------ | Branch (522:7): [True: 0, False: 9] ------------------ 523| 0| save_and_next(ls); ------------------ | | 51| 0|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 0|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 0|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 0|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 524| 0| if (check_next1(ls, '.')) { ------------------ | Branch (524:13): [True: 0, False: 0] ------------------ 525| 0| if (check_next1(ls, '.')) ------------------ | Branch (525:15): [True: 0, False: 0] ------------------ 526| 0| return TK_DOTS; /* '...' */ 527| 0| else return TK_CONCAT; /* '..' */ 528| 0| } 529| 0| else if (!lisdigit(ls->current)) return '.'; ------------------ | | 59| 0|#define lisdigit(c) testprop(c, MASK(DIGITBIT)) | | ------------------ | | | | 52| 0|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | ------------------ ------------------ | Branch (529:18): [True: 0, False: 0] ------------------ 530| 0| else return read_numeral(ls, seminfo); 531| 0| } 532| 1| case '0': case '1': case '2': case '3': case '4': ------------------ | Branch (532:7): [True: 1, False: 8] | Branch (532:17): [True: 0, False: 9] | Branch (532:27): [True: 0, False: 9] | Branch (532:37): [True: 0, False: 9] | Branch (532:47): [True: 0, False: 9] ------------------ 533| 1| case '5': case '6': case '7': case '8': case '9': { ------------------ | Branch (533:7): [True: 0, False: 9] | Branch (533:17): [True: 0, False: 9] | Branch (533:27): [True: 0, False: 9] | Branch (533:37): [True: 0, False: 9] | Branch (533:47): [True: 0, False: 9] ------------------ 534| 1| return read_numeral(ls, seminfo); 535| 1| } 536| 1| case EOZ: { ------------------ | | 16| 1|#define EOZ (-1) /* end of stream */ ------------------ | Branch (536:7): [True: 1, False: 8] ------------------ 537| 1| return TK_EOS; 538| 1| } 539| 7| default: { ------------------ | Branch (539:7): [True: 7, False: 2] ------------------ 540| 7| if (lislalpha(ls->current)) { /* identifier or reserved word? */ ------------------ | | 57| 7|#define lislalpha(c) testprop(c, MASK(ALPHABIT)) | | ------------------ | | | | 52| 7|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | | | ------------------ | | | | | Branch (52:23): [True: 3, False: 4] | | | | ------------------ | | ------------------ ------------------ 541| 3| TString *ts; 542| 1.04M| do { 543| 1.04M| save_and_next(ls); ------------------ | | 51| 1.04M|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 1.04M|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 1.04M|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 1.04M|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 1.04M|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 1.04M, False: 1] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 544| 1.04M| } while (lislalnum(ls->current)); ------------------ | | 58| 1.04M|#define lislalnum(c) testprop(c, (MASK(ALPHABIT) | MASK(DIGITBIT))) | | ------------------ | | | | 52| 1.04M|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | | | ------------------ | | | | | Branch (52:23): [True: 1.04M, False: 3] | | | | ------------------ | | ------------------ ------------------ 545| 3| ts = luaX_newstring(ls, luaZ_buffer(ls->buff), ------------------ | | 31| 3|#define luaZ_buffer(buff) ((buff)->buffer) ------------------ 546| 3| luaZ_bufflen(ls->buff)); ------------------ | | 33| 3|#define luaZ_bufflen(buff) ((buff)->n) ------------------ 547| 3| seminfo->ts = ts; 548| 3| if (isreserved(ts)) /* reserved word? */ ------------------ | | 35| 3|#define isreserved(s) ((s)->tt == LUA_VSHRSTR && (s)->extra > 0) | | ------------------ | | | | 360| 3|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | | | ------------------ | | | | | | 42| 6|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | ------------------ | | ------------------ | | | Branch (35:24): [True: 2, False: 1] | | | Branch (35:50): [True: 0, False: 2] | | ------------------ ------------------ 549| 0| return ts->extra - 1 + FIRST_RESERVED; ------------------ | | 20| 0|#define FIRST_RESERVED (UCHAR_MAX + 1) ------------------ 550| 3| else { 551| 3| return TK_NAME; 552| 3| } 553| 3| } 554| 4| else { /* single-char tokens ('+', '*', '%', '{', '}', ...) */ 555| 4| int c = ls->current; 556| 4| next(ls); ------------------ | | 32| 4|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 4|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 4|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 4|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 4, False: 0] | | | | ------------------ | | ------------------ ------------------ 557| 4| return c; 558| 4| } 559| 7| } 560| 9| } 561| 9| } 562| 9|} llex.c:read_numeral: 227| 1|static int read_numeral (LexState *ls, SemInfo *seminfo) { 228| 1| TValue obj; 229| 1| const char *expo = "Ee"; 230| 1| int first = ls->current; 231| 1| lua_assert(lisdigit(ls->current)); ------------------ | | 114| 1|#define lua_assert(c) ((void)0) ------------------ 232| 1| save_and_next(ls); ------------------ | | 51| 1|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 1|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 1|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 1|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 1|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 1, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 233| 1| if (first == '0' && check_next2(ls, "xX")) /* hexadecimal? */ ------------------ | Branch (233:7): [True: 1, False: 0] | Branch (233:23): [True: 0, False: 1] ------------------ 234| 0| expo = "Pp"; 235| 1| for (;;) { 236| 1| if (check_next2(ls, expo)) /* exponent mark? */ ------------------ | Branch (236:9): [True: 0, False: 1] ------------------ 237| 0| check_next2(ls, "-+"); /* optional exponent sign */ 238| 1| else if (lisxdigit(ls->current) || ls->current == '.') /* '%x|%.' */ ------------------ | | 62| 1|#define lisxdigit(c) testprop(c, MASK(XDIGITBIT)) | | ------------------ | | | | 52| 2|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | | | ------------------ | | | | | Branch (52:23): [True: 0, False: 1] | | | | ------------------ | | ------------------ ------------------ | Branch (238:40): [True: 0, False: 1] ------------------ 239| 0| save_and_next(ls); ------------------ | | 51| 0|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 0|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 0|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 0|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 240| 1| else break; 241| 1| } 242| 1| if (lislalpha(ls->current)) /* is numeral touching a letter? */ ------------------ | | 57| 1|#define lislalpha(c) testprop(c, MASK(ALPHABIT)) | | ------------------ | | | | 52| 1|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | | | ------------------ | | | | | Branch (52:23): [True: 0, False: 1] | | | | ------------------ | | ------------------ ------------------ 243| 0| save_and_next(ls); /* force an error */ ------------------ | | 51| 0|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 0|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 0|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 0|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 244| 1| save(ls, '\0'); 245| 1| if (luaO_str2num(luaZ_buffer(ls->buff), &obj) == 0) /* format error? */ ------------------ | | 31| 1|#define luaZ_buffer(buff) ((buff)->buffer) ------------------ | Branch (245:7): [True: 0, False: 1] ------------------ 246| 0| lexerror(ls, "malformed number", TK_FLT); 247| 1| if (ttisinteger(&obj)) { ------------------ | | 328| 1|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 1|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 1|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ ------------------ 248| 1| seminfo->i = ivalue(&obj); ------------------ | | 333| 1|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 1|#define check_exp(c,e) (e) | | ------------------ ------------------ 249| 1| return TK_INT; 250| 1| } 251| 0| else { 252| 0| lua_assert(ttisfloat(&obj)); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 253| 0| seminfo->r = fltvalue(&obj); ------------------ | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 254| 0| return TK_FLT; 255| 0| } 256| 1|} llex.c:check_next2: 204| 2|static int check_next2 (LexState *ls, const char *set) { 205| 2| lua_assert(set[2] == '\0'); ------------------ | | 114| 2|#define lua_assert(c) ((void)0) ------------------ 206| 2| if (ls->current == set[0] || ls->current == set[1]) { ------------------ | Branch (206:7): [True: 0, False: 2] | Branch (206:32): [True: 0, False: 2] ------------------ 207| 0| save_and_next(ls); ------------------ | | 51| 0|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 0|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 0|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 0|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 208| 0| return 1; 209| 0| } 210| 2| else return 0; 211| 2|} luaM_growaux_: 98| 25| int size_elems, int limit, const char *what) { 99| 25| void *newblock; 100| 25| int size = *psize; 101| 25| if (nelems + 1 <= size) /* does one extra element still fit? */ ------------------ | Branch (101:7): [True: 4, False: 21] ------------------ 102| 4| return block; /* nothing to be done */ 103| 21| if (size >= limit / 2) { /* cannot double it? */ ------------------ | Branch (103:7): [True: 0, False: 21] ------------------ 104| 0| if (l_unlikely(size >= limit)) /* cannot grow even a little? */ ------------------ | | 688| 0|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 105| 0| luaG_runerror(L, "too many %s (limit is %d)", what, limit); 106| 0| size = limit; /* still have at least one free place */ 107| 0| } 108| 21| else { 109| 21| size *= 2; 110| 21| if (size < MINSIZEARRAY) ------------------ | | 94| 21|#define MINSIZEARRAY 4 ------------------ | Branch (110:9): [True: 21, False: 0] ------------------ 111| 21| size = MINSIZEARRAY; /* minimum size */ ------------------ | | 94| 21|#define MINSIZEARRAY 4 ------------------ 112| 21| } 113| 21| lua_assert(nelems + 1 <= size && size <= limit); ------------------ | | 114| 21|#define lua_assert(c) ((void)0) ------------------ 114| | /* 'limit' ensures that multiplication will not overflow */ 115| 21| newblock = luaM_saferealloc_(L, block, cast_sizet(*psize) * size_elems, ------------------ | | 147| 21|#define cast_sizet(i) cast(size_t, (i)) | | ------------------ | | | | 136| 21|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 116| 21| cast_sizet(size) * size_elems); ------------------ | | 147| 21|#define cast_sizet(i) cast(size_t, (i)) | | ------------------ | | | | 136| 21|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 117| 21| *psize = size; /* update only when everything else is OK */ 118| 21| return newblock; 119| 21|} luaM_free_: 150| 443|void luaM_free_ (lua_State *L, void *block, size_t osize) { 151| 443| global_State *g = G(L); ------------------ | | 335| 443|#define G(L) (L->l_G) ------------------ 152| 443| lua_assert((osize == 0) == (block == NULL)); ------------------ | | 114| 443|#define lua_assert(c) ((void)0) ------------------ 153| 443| callfrealloc(g, block, osize, 0); ------------------ | | 47| 443|#define callfrealloc(g,block,os,ns) ((*g->frealloc)(g->ud, block, os, ns)) ------------------ 154| 443| g->GCdebt -= osize; 155| 443|} luaM_realloc_: 176| 57|void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) { 177| 57| void *newblock; 178| 57| global_State *g = G(L); ------------------ | | 335| 57|#define G(L) (L->l_G) ------------------ 179| 57| lua_assert((osize == 0) == (block == NULL)); ------------------ | | 114| 57|#define lua_assert(c) ((void)0) ------------------ 180| 57| newblock = firsttry(g, block, osize, nsize); ------------------ | | 76| 57|#define firsttry(g,block,os,ns) callfrealloc(g, block, os, ns) | | ------------------ | | | | 47| 57|#define callfrealloc(g,block,os,ns) ((*g->frealloc)(g->ud, block, os, ns)) | | ------------------ ------------------ 181| 57| if (l_unlikely(newblock == NULL && nsize > 0)) { ------------------ | | 688| 57|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 66|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 57] | | | | | Branch (676:46): [True: 9, False: 48] | | | | | Branch (676:46): [True: 0, False: 9] | | | | ------------------ | | ------------------ ------------------ 182| 0| newblock = tryagain(L, block, osize, nsize); 183| 0| if (newblock == NULL) /* still no memory? */ ------------------ | Branch (183:9): [True: 0, False: 0] ------------------ 184| 0| return NULL; /* do not update 'GCdebt' */ 185| 0| } 186| 57| lua_assert((nsize == 0) == (newblock == NULL)); ------------------ | | 114| 57|#define lua_assert(c) ((void)0) ------------------ 187| 57| g->GCdebt = (g->GCdebt + nsize) - osize; 188| 57| return newblock; 189| 57|} luaM_saferealloc_: 193| 48| size_t nsize) { 194| 48| void *newblock = luaM_realloc_(L, block, osize, nsize); 195| 48| if (l_unlikely(newblock == NULL && nsize > 0)) /* allocation failed? */ ------------------ | | 688| 48|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 54|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 48] | | | | | Branch (676:46): [True: 6, False: 42] | | | | | Branch (676:46): [True: 0, False: 6] | | | | ------------------ | | ------------------ ------------------ 196| 0| luaM_error(L); ------------------ | | 17| 0|#define luaM_error(L) luaD_throw(L, LUA_ERRMEM) | | ------------------ | | | | 53| 0|#define LUA_ERRMEM 4 | | ------------------ ------------------ 197| 48| return newblock; 198| 48|} luaM_malloc_: 201| 365|void *luaM_malloc_ (lua_State *L, size_t size, int tag) { 202| 365| if (size == 0) ------------------ | Branch (202:7): [True: 0, False: 365] ------------------ 203| 0| return NULL; /* that's all */ 204| 365| else { 205| 365| global_State *g = G(L); ------------------ | | 335| 365|#define G(L) (L->l_G) ------------------ 206| 365| void *newblock = firsttry(g, NULL, tag, size); ------------------ | | 76| 365|#define firsttry(g,block,os,ns) callfrealloc(g, block, os, ns) | | ------------------ | | | | 47| 365|#define callfrealloc(g,block,os,ns) ((*g->frealloc)(g->ud, block, os, ns)) | | ------------------ ------------------ 207| 365| if (l_unlikely(newblock == NULL)) { ------------------ | | 688| 365|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 365|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 365] | | | | ------------------ | | ------------------ ------------------ 208| 0| newblock = tryagain(L, NULL, tag, size); 209| 0| if (newblock == NULL) ------------------ | Branch (209:11): [True: 0, False: 0] ------------------ 210| 0| luaM_error(L); ------------------ | | 17| 0|#define luaM_error(L) luaD_throw(L, LUA_ERRMEM) | | ------------------ | | | | 53| 0|#define LUA_ERRMEM 4 | | ------------------ ------------------ 211| 0| } 212| 365| g->GCdebt += size; 213| 365| return newblock; 214| 365| } 215| 365|} luaO_ceillog2: 35| 3|int luaO_ceillog2 (unsigned int x) { 36| 3| static const lu_byte log_2[256] = { /* log_2[i] = ceil(log2(i - 1)) */ 37| 3| 0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5, 38| 3| 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6, 39| 3| 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 40| 3| 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 41| 3| 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 42| 3| 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 43| 3| 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 44| 3| 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8 45| 3| }; 46| 3| int l = 0; 47| 3| x--; 48| 3| while (x >= 256) { l += 8; x >>= 8; } ------------------ | Branch (48:10): [True: 0, False: 3] ------------------ 49| 3| return l + log_2[x]; 50| 3|} luaO_str2num: 308| 1|size_t luaO_str2num (const char *s, TValue *o) { 309| 1| lua_Integer i; lua_Number n; 310| 1| const char *e; 311| 1| if ((e = l_str2int(s, &i)) != NULL) { /* try as an integer */ ------------------ | Branch (311:7): [True: 1, False: 0] ------------------ 312| 1| setivalue(o, i); ------------------ | | 345| 1| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 1|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 1|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 313| 1| } 314| 0| else if ((e = l_str2d(s, &n)) != NULL) { /* else try as a float */ ------------------ | Branch (314:12): [True: 0, False: 0] ------------------ 315| 0| setfltvalue(o, n); ------------------ | | 339| 0| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 0|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 316| 0| } 317| 0| else 318| 0| return 0; /* conversion failed */ 319| 1| return (e - s) + 1; /* success; return string size */ 320| 1|} luaO_pushvfstring: 480| 17|const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) { 481| 17| BuffFS buff; /* holds last part of the result */ 482| 17| const char *e; /* points to next '%' */ 483| 17| buff.pushed = buff.blen = 0; 484| 17| buff.L = L; 485| 52| while ((e = strchr(fmt, '%')) != NULL) { ------------------ | Branch (485:10): [True: 35, False: 17] ------------------ 486| 35| addstr2buff(&buff, fmt, e - fmt); /* add 'fmt' up to '%' */ 487| 35| switch (*(e + 1)) { /* conversion specifier */ 488| 25| case 's': { /* zero-terminated string */ ------------------ | Branch (488:7): [True: 25, False: 10] ------------------ 489| 25| const char *s = va_arg(argp, char *); 490| 25| if (s == NULL) s = "(null)"; ------------------ | Branch (490:13): [True: 0, False: 25] ------------------ 491| 25| addstr2buff(&buff, s, strlen(s)); 492| 25| break; 493| 0| } 494| 0| case 'c': { /* an 'int' as a character */ ------------------ | Branch (494:7): [True: 0, False: 35] ------------------ 495| 0| char c = cast_uchar(va_arg(argp, int)); ------------------ | | 144| 0|#define cast_uchar(i) cast(unsigned char, (i)) | | ------------------ | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 496| 0| addstr2buff(&buff, &c, sizeof(char)); 497| 0| break; 498| 0| } 499| 10| case 'd': { /* an 'int' */ ------------------ | Branch (499:7): [True: 10, False: 25] ------------------ 500| 10| TValue num; 501| 10| setivalue(&num, va_arg(argp, int)); ------------------ | | 345| 10| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 10|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 10|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 502| 10| addnum2buff(&buff, &num); 503| 10| break; 504| 0| } 505| 0| case 'I': { /* a 'lua_Integer' */ ------------------ | Branch (505:7): [True: 0, False: 35] ------------------ 506| 0| TValue num; 507| 0| setivalue(&num, cast(lua_Integer, va_arg(argp, l_uacInt))); ------------------ | | 345| 0| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 0|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 508| 0| addnum2buff(&buff, &num); 509| 0| break; 510| 0| } 511| 0| case 'f': { /* a 'lua_Number' */ ------------------ | Branch (511:7): [True: 0, False: 35] ------------------ 512| 0| TValue num; 513| 0| setfltvalue(&num, cast_num(va_arg(argp, l_uacNumber))); ------------------ | | 339| 0| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 0|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 514| 0| addnum2buff(&buff, &num); 515| 0| break; 516| 0| } 517| 0| case 'p': { /* a pointer */ ------------------ | Branch (517:7): [True: 0, False: 35] ------------------ 518| 0| const int sz = 3 * sizeof(void*) + 8; /* enough space for '%p' */ 519| 0| char *bf = getbuff(&buff, sz); 520| 0| void *p = va_arg(argp, void *); 521| 0| int len = lua_pointer2str(bf, sz, p); ------------------ | | 609| 0|#define lua_pointer2str(buff,sz,p) l_sprintf(buff,sz,"%p",p) | | ------------------ | | | | 588| 0|#define l_sprintf(s,sz,f,i) snprintf(s,sz,f,i) | | ------------------ ------------------ 522| 0| addsize(&buff, len); ------------------ | | 446| 0|#define addsize(b,sz) ((b)->blen += (sz)) ------------------ 523| 0| break; 524| 0| } 525| 0| case 'U': { /* a 'long' as a UTF-8 sequence */ ------------------ | Branch (525:7): [True: 0, False: 35] ------------------ 526| 0| char bf[UTF8BUFFSZ]; 527| 0| int len = luaO_utf8esc(bf, va_arg(argp, long)); 528| 0| addstr2buff(&buff, bf + UTF8BUFFSZ - len, len); ------------------ | | 797| 0|#define UTF8BUFFSZ 8 ------------------ 529| 0| break; 530| 0| } 531| 0| case '%': { ------------------ | Branch (531:7): [True: 0, False: 35] ------------------ 532| 0| addstr2buff(&buff, "%", 1); 533| 0| break; 534| 0| } 535| 0| default: { ------------------ | Branch (535:7): [True: 0, False: 35] ------------------ 536| 0| luaG_runerror(L, "invalid option '%%%c' to 'lua_pushfstring'", 537| 0| *(e + 1)); 538| 0| } 539| 35| } 540| 35| fmt = e + 2; /* skip '%' and the specifier */ 541| 35| } 542| 17| addstr2buff(&buff, fmt, strlen(fmt)); /* rest of 'fmt' */ 543| 17| clearbuff(&buff); /* empty buffer into the stack */ 544| 17| lua_assert(buff.pushed == 1); ------------------ | | 114| 17|#define lua_assert(c) ((void)0) ------------------ 545| 17| return svalue(s2v(L->top.p - 1)); ------------------ | | 407| 17|#define svalue(o) getstr(tsvalue(o)) | | ------------------ | | | | 403| 17|#define getstr(ts) ((ts)->contents) | | ------------------ ------------------ 546| 17|} luaO_pushfstring: 549| 17|const char *luaO_pushfstring (lua_State *L, const char *fmt, ...) { 550| 17| const char *msg; 551| 17| va_list argp; 552| 17| va_start(argp, fmt); 553| 17| msg = luaO_pushvfstring(L, fmt, argp); 554| 17| va_end(argp); 555| 17| return msg; 556| 17|} luaO_chunkid: 567| 6|void luaO_chunkid (char *out, const char *source, size_t srclen) { 568| 6| size_t bufflen = LUA_IDSIZE; /* free space in buffer */ ------------------ | | 759| 6|#define LUA_IDSIZE 60 ------------------ 569| 6| if (*source == '=') { /* 'literal' source */ ------------------ | Branch (569:7): [True: 0, False: 6] ------------------ 570| 0| if (srclen <= bufflen) /* small enough? */ ------------------ | Branch (570:9): [True: 0, False: 0] ------------------ 571| 0| memcpy(out, source + 1, srclen * sizeof(char)); 572| 0| else { /* truncate it */ 573| 0| addstr(out, source + 1, bufflen - 1); ------------------ | | 565| 0|#define addstr(a,b,l) ( memcpy(a,b,(l) * sizeof(char)), a += (l) ) ------------------ 574| 0| *out = '\0'; 575| 0| } 576| 0| } 577| 6| else if (*source == '@') { /* file name */ ------------------ | Branch (577:12): [True: 0, False: 6] ------------------ 578| 0| if (srclen <= bufflen) /* small enough? */ ------------------ | Branch (578:9): [True: 0, False: 0] ------------------ 579| 0| memcpy(out, source + 1, srclen * sizeof(char)); 580| 0| else { /* add '...' before rest of name */ 581| 0| addstr(out, RETS, LL(RETS)); ------------------ | | 565| 0|#define addstr(a,b,l) ( memcpy(a,b,(l) * sizeof(char)), a += (l) ) ------------------ 582| 0| bufflen -= LL(RETS); ------------------ | | 70| 0|#define LL(x) (sizeof(x)/sizeof(char) - 1) ------------------ 583| 0| memcpy(out, source + 1 + srclen - bufflen, bufflen * sizeof(char)); 584| 0| } 585| 0| } 586| 6| else { /* string; format as [string "source"] */ 587| 6| const char *nl = strchr(source, '\n'); /* find first new line (if any) */ 588| 6| addstr(out, PRE, LL(PRE)); /* add prefix */ ------------------ | | 565| 6|#define addstr(a,b,l) ( memcpy(a,b,(l) * sizeof(char)), a += (l) ) ------------------ 589| 6| bufflen -= LL(PRE RETS POS) + 1; /* save space for prefix+suffix+'\0' */ ------------------ | | 70| 6|#define LL(x) (sizeof(x)/sizeof(char) - 1) ------------------ 590| 6| if (srclen < bufflen && nl == NULL) { /* small one-line source? */ ------------------ | Branch (590:9): [True: 6, False: 0] | Branch (590:29): [True: 6, False: 0] ------------------ 591| 6| addstr(out, source, srclen); /* keep it */ ------------------ | | 565| 6|#define addstr(a,b,l) ( memcpy(a,b,(l) * sizeof(char)), a += (l) ) ------------------ 592| 6| } 593| 0| else { 594| 0| if (nl != NULL) srclen = nl - source; /* stop at first newline */ ------------------ | Branch (594:11): [True: 0, False: 0] ------------------ 595| 0| if (srclen > bufflen) srclen = bufflen; ------------------ | Branch (595:11): [True: 0, False: 0] ------------------ 596| 0| addstr(out, source, srclen); ------------------ | | 565| 0|#define addstr(a,b,l) ( memcpy(a,b,(l) * sizeof(char)), a += (l) ) ------------------ 597| 0| addstr(out, RETS, LL(RETS)); ------------------ | | 565| 0|#define addstr(a,b,l) ( memcpy(a,b,(l) * sizeof(char)), a += (l) ) ------------------ 598| 0| } 599| 6| memcpy(out, POS, (LL(POS) + 1) * sizeof(char)); ------------------ | | 563| 6|#define POS "\"]" ------------------ memcpy(out, POS, (LL(POS) + 1) * sizeof(char)); ------------------ | | 70| 6|#define LL(x) (sizeof(x)/sizeof(char) - 1) ------------------ 600| 6| } 601| 6|} lobject.c:l_str2int: 276| 1|static const char *l_str2int (const char *s, lua_Integer *result) { 277| 1| lua_Unsigned a = 0; 278| 1| int empty = 1; 279| 1| int neg; 280| 1| while (lisspace(cast_uchar(*s))) s++; /* skip initial spaces */ 281| 1| neg = isneg(&s); 282| 1| if (s[0] == '0' && ------------------ | Branch (282:7): [True: 1, False: 0] ------------------ 283| 1| (s[1] == 'x' || s[1] == 'X')) { /* hex? */ ------------------ | Branch (283:8): [True: 0, False: 1] | Branch (283:23): [True: 0, False: 1] ------------------ 284| 0| s += 2; /* skip '0x' */ 285| 0| for (; lisxdigit(cast_uchar(*s)); s++) { 286| 0| a = a * 16 + luaO_hexavalue(*s); 287| 0| empty = 0; 288| 0| } 289| 0| } 290| 1| else { /* decimal */ 291| 1| for (; lisdigit(cast_uchar(*s)); s++) { 292| 1| int d = *s - '0'; 293| 1| if (a >= MAXBY10 && (a > MAXBY10 || d > MAXLASTD + neg)) /* overflow? */ ------------------ | | 273| 1|#define MAXBY10 cast(lua_Unsigned, LUA_MAXINTEGER / 10) | | ------------------ | | | | 136| 2|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ if (a >= MAXBY10 && (a > MAXBY10 || d > MAXLASTD + neg)) /* overflow? */ ------------------ | | 273| 0|#define MAXBY10 cast(lua_Unsigned, LUA_MAXINTEGER / 10) | | ------------------ | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ if (a >= MAXBY10 && (a > MAXBY10 || d > MAXLASTD + neg)) /* overflow? */ ------------------ | | 274| 0|#define MAXLASTD cast_int(LUA_MAXINTEGER % 10) | | ------------------ | | | | 141| 0|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ | Branch (293:11): [True: 0, False: 1] | Branch (293:28): [True: 0, False: 0] | Branch (293:43): [True: 0, False: 0] ------------------ 294| 0| return NULL; /* do not accept it (as integer) */ 295| 1| a = a * 10 + d; 296| 1| empty = 0; 297| 1| } 298| 1| } 299| 1| while (lisspace(cast_uchar(*s))) s++; /* skip trailing spaces */ 300| 1| if (empty || *s != '\0') return NULL; /* something wrong in the numeral */ ------------------ | Branch (300:7): [True: 0, False: 1] | Branch (300:16): [True: 0, False: 1] ------------------ 301| 1| else { 302| 1| *result = l_castU2S((neg) ? 0u - a : a); ------------------ | | 161| 2|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ | | | Branch (161:37): [True: 0, False: 1] | | ------------------ ------------------ 303| 1| return s; 304| 1| } 305| 1|} lobject.c:isneg: 141| 1|static int isneg (const char **s) { 142| 1| if (**s == '-') { (*s)++; return 1; } ------------------ | Branch (142:7): [True: 0, False: 1] ------------------ 143| 1| else if (**s == '+') (*s)++; ------------------ | Branch (143:12): [True: 0, False: 1] ------------------ 144| 1| return 0; 145| 1|} lobject.c:tostringbuff: 355| 10|static int tostringbuff (TValue *obj, char *buff) { 356| 10| int len; 357| 10| lua_assert(ttisnumber(obj)); ------------------ | | 114| 10|#define lua_assert(c) ((void)0) ------------------ 358| 10| if (ttisinteger(obj)) ------------------ | | 328| 10|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 10|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 10|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 10, False: 0] | | | | ------------------ | | ------------------ ------------------ 359| 10| len = lua_integer2str(buff, MAXNUMBER2STR, ivalue(obj)); ------------------ | | 505| 10| l_sprintf((s), sz, LUA_INTEGER_FMT, (LUAI_UACINT)(n)) | | ------------------ | | | | 588| 10|#define l_sprintf(s,sz,f,i) snprintf(s,sz,f,i) | | ------------------ ------------------ 360| 0| else { 361| 0| len = lua_number2str(buff, MAXNUMBER2STR, fltvalue(obj)); ------------------ | | 412| 0| l_sprintf((s), sz, LUA_NUMBER_FMT, (LUAI_UACNUMBER)(n)) | | ------------------ | | | | 588| 0|#define l_sprintf(s,sz,f,i) snprintf(s,sz,f,i) | | ------------------ ------------------ 362| 0| if (buff[strspn(buff, "-0123456789")] == '\0') { /* looks like an int? */ ------------------ | Branch (362:9): [True: 0, False: 0] ------------------ 363| 0| buff[len++] = lua_getlocaledecpoint(); ------------------ | | 662| 0|#define lua_getlocaledecpoint() (localeconv()->decimal_point[0]) ------------------ 364| 0| buff[len++] = '0'; /* adds '.0' to result */ 365| 0| } 366| 0| } 367| 10| return len; 368| 10|} lobject.c:addstr2buff: 453| 77|static void addstr2buff (BuffFS *buff, const char *str, size_t slen) { 454| 77| if (slen <= BUFVFS) { /* does string fit into buffer? */ ------------------ | | 394| 77|#define BUFVFS (LUA_IDSIZE + MAXNUMBER2STR + 95) | | ------------------ | | | | 759| 77|#define LUA_IDSIZE 60 | | ------------------ | | #define BUFVFS (LUA_IDSIZE + MAXNUMBER2STR + 95) | | ------------------ | | | | 349| 77|#define MAXNUMBER2STR 44 | | ------------------ ------------------ | Branch (454:7): [True: 77, False: 0] ------------------ 455| 77| char *bf = getbuff(buff, cast_int(slen)); ------------------ | | 141| 77|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 77|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 456| 77| memcpy(bf, str, slen); /* add string to buffer */ 457| 77| addsize(buff, cast_int(slen)); ------------------ | | 446| 77|#define addsize(b,sz) ((b)->blen += (sz)) ------------------ 458| 77| } 459| 0| else { /* string larger than buffer */ 460| 0| clearbuff(buff); /* string comes after buffer's content */ 461| 0| pushstr(buff, str, slen); /* push string */ 462| 0| } 463| 77|} lobject.c:pushstr: 414| 17|static void pushstr (BuffFS *buff, const char *str, size_t lstr) { 415| 17| lua_State *L = buff->L; 416| 17| setsvalue2s(L, L->top.p, luaS_newlstr(L, str, lstr)); ------------------ | | 377| 17|#define setsvalue2s(L,o,s) setsvalue(L,s2v(o),s) | | ------------------ | | | | 372| 17| { TValue *io = (obj); TString *x_ = (x); \ | | | | 373| 17| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 72| 17|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 390| 17|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 17|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 114| 17|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 374| 17| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 17| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 17|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 17| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 417| 17| L->top.p++; /* may use one slot from EXTRA_STACK */ 418| 17| if (!buff->pushed) /* no previous string on the stack? */ ------------------ | Branch (418:7): [True: 17, False: 0] ------------------ 419| 17| buff->pushed = 1; /* now there is one */ 420| 0| else /* join previous string with new one */ 421| 0| luaV_concat(L, 2); 422| 17|} lobject.c:addnum2buff: 469| 10|static void addnum2buff (BuffFS *buff, TValue *num) { 470| 10| char *numbuff = getbuff(buff, MAXNUMBER2STR); ------------------ | | 349| 10|#define MAXNUMBER2STR 44 ------------------ 471| 10| int len = tostringbuff(num, numbuff); /* format number into 'numbuff' */ 472| 10| addsize(buff, len); ------------------ | | 446| 10|#define addsize(b,sz) ((b)->blen += (sz)) ------------------ 473| 10|} lobject.c:getbuff: 438| 87|static char *getbuff (BuffFS *buff, int sz) { 439| 87| lua_assert(buff->blen <= BUFVFS); lua_assert(sz <= BUFVFS); ------------------ | | 114| 87|#define lua_assert(c) ((void)0) ------------------ lua_assert(buff->blen <= BUFVFS); lua_assert(sz <= BUFVFS); ------------------ | | 114| 87|#define lua_assert(c) ((void)0) ------------------ 440| 87| if (sz > BUFVFS - buff->blen) /* not enough space? */ ------------------ | | 394| 87|#define BUFVFS (LUA_IDSIZE + MAXNUMBER2STR + 95) | | ------------------ | | | | 759| 87|#define LUA_IDSIZE 60 | | ------------------ | | #define BUFVFS (LUA_IDSIZE + MAXNUMBER2STR + 95) | | ------------------ | | | | 349| 87|#define MAXNUMBER2STR 44 | | ------------------ ------------------ | Branch (440:7): [True: 0, False: 87] ------------------ 441| 0| clearbuff(buff); 442| 87| return buff->space + buff->blen; 443| 87|} lobject.c:clearbuff: 428| 17|static void clearbuff (BuffFS *buff) { 429| 17| pushstr(buff, buff->space, buff->blen); /* push buffer contents */ 430| 17| buff->blen = 0; /* space now is empty */ 431| 17|} luaY_parser: 1943| 6| Dyndata *dyd, const char *name, int firstchar) { 1944| 6| LexState lexstate; 1945| 6| FuncState funcstate; 1946| 6| LClosure *cl = luaF_newLclosure(L, 1); /* create main closure */ 1947| 6| setclLvalue2s(L, L->top.p, cl); /* anchor it (to avoid being collected) */ ------------------ | | 615| 6|#define setclLvalue2s(L,o,cl) setclLvalue(L,s2v(o),cl) | | ------------------ | | | | 611| 6| { TValue *io = (obj); LClosure *x_ = (x); \ | | | | 612| 6| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VLCL)); \ | | | | ------------------ | | | | | | 72| 6|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VLCL)); \ | | | | ------------------ | | | | | | 390| 6|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 6|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VLCL)); \ | | | | ------------------ | | | | | | 114| 6|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 613| 6| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 6| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 6|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 6| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 1948| 6| luaD_inctop(L); 1949| 6| lexstate.h = luaH_new(L); /* create table for scanner */ 1950| 6| sethvalue2s(L, L->top.p, lexstate.h); /* anchor it */ ------------------ | | 691| 6|#define sethvalue2s(L,o,h) sethvalue(L,s2v(o),h) | | ------------------ | | | | 687| 6| { TValue *io = (obj); Table *x_ = (x); \ | | | | 688| 6| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 72| 6|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 390| 6|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 6|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 114| 6|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 689| 6| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 6| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 6|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 6| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 1951| 6| luaD_inctop(L); 1952| 6| funcstate.f = cl->p = luaF_newproto(L); 1953| 6| luaC_objbarrier(L, cl, cl->p); ------------------ | | 175| 6|#define luaC_objbarrier(L,p,o) ( \ | | 176| 6| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 88| 6|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 67| 6|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 62| 12|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 6] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 177| 6| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 138| 6|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 6|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1954| 6| funcstate.f->source = luaS_new(L, name); /* create and anchor TString */ 1955| 6| luaC_objbarrier(L, funcstate.f, funcstate.f->source); ------------------ | | 175| 6|#define luaC_objbarrier(L,p,o) ( \ | | 176| 6| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 88| 6|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 67| 6|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 62| 12|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 6] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 177| 6| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 138| 6|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 6|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1956| 6| lexstate.buff = buff; 1957| 6| lexstate.dyd = dyd; 1958| 6| dyd->actvar.n = dyd->gt.n = dyd->label.n = 0; 1959| 6| luaX_setinput(L, &lexstate, z, funcstate.f->source, firstchar); 1960| 6| mainfunc(&lexstate, &funcstate); 1961| 6| lua_assert(!funcstate.prev && funcstate.nups == 1 && !lexstate.fs); ------------------ | | 114| 6|#define lua_assert(c) ((void)0) ------------------ 1962| | /* all scopes should be correctly finished */ 1963| 6| lua_assert(dyd->actvar.n == 0 && dyd->gt.n == 0 && dyd->label.n == 0); ------------------ | | 114| 6|#define lua_assert(c) ((void)0) ------------------ 1964| 6| L->top.p--; /* remove scanner's table */ 1965| 6| return cl; /* closure is on the stack, too */ 1966| 6|} lparser.c:mainfunc: 1924| 6|static void mainfunc (LexState *ls, FuncState *fs) { 1925| 6| BlockCnt bl; 1926| 6| Upvaldesc *env; 1927| 6| open_func(ls, fs, &bl); 1928| 6| setvararg(fs, 0); /* main function is always declared vararg */ 1929| 6| env = allocupvalue(fs); /* ...set environment upvalue */ 1930| 6| env->instack = 1; 1931| 6| env->idx = 0; 1932| 6| env->kind = VDKREG; ------------------ | | 90| 6|#define VDKREG 0 /* regular */ ------------------ 1933| 6| env->name = ls->envn; 1934| 6| luaC_objbarrier(ls->L, fs->f, env->name); ------------------ | | 175| 6|#define luaC_objbarrier(L,p,o) ( \ | | 176| 6| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 88| 6|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 67| 6|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 62| 12|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 6] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 177| 6| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 138| 6|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 6|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1935| 6| luaX_next(ls); /* read first token */ 1936| 6| statlist(ls); /* parse main body */ 1937| 6| check(ls, TK_EOS); 1938| 6| close_func(ls); 1939| 6|} lparser.c:open_func: 729| 6|static void open_func (LexState *ls, FuncState *fs, BlockCnt *bl) { 730| 6| Proto *f = fs->f; 731| 6| fs->prev = ls->fs; /* linked list of funcstates */ 732| 6| fs->ls = ls; 733| 6| ls->fs = fs; 734| 6| fs->pc = 0; 735| 6| fs->previousline = f->linedefined; 736| 6| fs->iwthabs = 0; 737| 6| fs->lasttarget = 0; 738| 6| fs->freereg = 0; 739| 6| fs->nk = 0; 740| 6| fs->nabslineinfo = 0; 741| 6| fs->np = 0; 742| 6| fs->nups = 0; 743| 6| fs->ndebugvars = 0; 744| 6| fs->nactvar = 0; 745| 6| fs->needclose = 0; 746| 6| fs->firstlocal = ls->dyd->actvar.n; 747| 6| fs->firstlabel = ls->dyd->label.n; 748| 6| fs->bl = NULL; 749| 6| f->source = ls->source; 750| 6| luaC_objbarrier(ls->L, f, f->source); ------------------ | | 175| 6|#define luaC_objbarrier(L,p,o) ( \ | | 176| 6| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 88| 6|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 67| 6|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 62| 12|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 6] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 177| 6| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 138| 6|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 6|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 751| 6| f->maxstacksize = 2; /* registers 0/1 are always valid */ 752| 6| enterblock(fs, bl, 0); 753| 6|} lparser.c:enterblock: 642| 6|static void enterblock (FuncState *fs, BlockCnt *bl, lu_byte isloop) { 643| 6| bl->isloop = isloop; 644| 6| bl->nactvar = fs->nactvar; 645| 6| bl->firstlabel = fs->ls->dyd->label.n; 646| 6| bl->firstgoto = fs->ls->dyd->gt.n; 647| 6| bl->upval = 0; 648| 6| bl->insidetbc = (fs->bl != NULL && fs->bl->insidetbc); ------------------ | Branch (648:20): [True: 0, False: 6] | Branch (648:38): [True: 0, False: 0] ------------------ 649| 6| bl->previous = fs->bl; 650| 6| fs->bl = bl; 651| 6| lua_assert(fs->freereg == luaY_nvarstack(fs)); ------------------ | | 114| 6|#define lua_assert(c) ((void)0) ------------------ 652| 6|} lparser.c:setvararg: 953| 6|static void setvararg (FuncState *fs, int nparams) { 954| 6| fs->f->is_vararg = 1; 955| 6| luaK_codeABC(fs, OP_VARARGPREP, nparams, 0, 0); ------------------ | | 48| 6|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 956| 6|} lparser.c:allocupvalue: 352| 6|static Upvaldesc *allocupvalue (FuncState *fs) { 353| 6| Proto *f = fs->f; 354| 6| int oldsize = f->sizeupvalues; 355| 6| checklimit(fs, fs->nups + 1, MAXUPVAL, "upvalues"); ------------------ | | 29| 6|#define MAXUPVAL 255 ------------------ 356| 6| luaM_growvector(fs->ls->L, f->upvalues, fs->nups, f->sizeupvalues, ------------------ | | 67| 6| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 136| 12|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 68| 6| luaM_limitN(limit,t),e))) ------------------ 357| 6| Upvaldesc, MAXUPVAL, "upvalues"); 358| 30| while (oldsize < f->sizeupvalues) ------------------ | Branch (358:10): [True: 24, False: 6] ------------------ 359| 24| f->upvalues[oldsize++].name = NULL; 360| 6| return &f->upvalues[fs->nups++]; 361| 6|} lparser.c:checklimit: 87| 6|static void checklimit (FuncState *fs, int v, int l, const char *what) { 88| 6| if (v > l) errorlimit(fs, l, what); ------------------ | Branch (88:7): [True: 0, False: 6] ------------------ 89| 6|} lparser.c:statlist: 799| 6|static void statlist (LexState *ls) { 800| | /* statlist -> { stat [';'] } */ 801| 12| while (!block_follow(ls, 1)) { ------------------ | Branch (801:10): [True: 6, False: 6] ------------------ 802| 6| if (ls->t.token == TK_RETURN) { ------------------ | Branch (802:9): [True: 0, False: 6] ------------------ 803| 0| statement(ls); 804| 0| return; /* 'return' must be last statement */ 805| 0| } 806| 6| statement(ls); 807| 6| } 808| 6|} lparser.c:block_follow: 788| 6|static int block_follow (LexState *ls, int withuntil) { 789| 6| switch (ls->t.token) { 790| 0| case TK_ELSE: case TK_ELSEIF: ------------------ | Branch (790:5): [True: 0, False: 6] | Branch (790:19): [True: 0, False: 6] ------------------ 791| 0| case TK_END: case TK_EOS: ------------------ | Branch (791:5): [True: 0, False: 6] | Branch (791:18): [True: 0, False: 6] ------------------ 792| 0| return 1; 793| 0| case TK_UNTIL: return withuntil; ------------------ | Branch (793:5): [True: 0, False: 6] ------------------ 794| 6| default: return 0; ------------------ | Branch (794:5): [True: 6, False: 0] ------------------ 795| 6| } 796| 6|} lparser.c:statement: 1845| 6|static void statement (LexState *ls) { 1846| 6| int line = ls->linenumber; /* may be needed for error messages */ 1847| 6| enterlevel(ls); ------------------ | | 504| 6|#define enterlevel(ls) luaE_incCstack(ls->L) ------------------ 1848| 6| switch (ls->t.token) { 1849| 0| case ';': { /* stat -> ';' (empty statement) */ ------------------ | Branch (1849:5): [True: 0, False: 6] ------------------ 1850| 0| luaX_next(ls); /* skip ';' */ 1851| 0| break; 1852| 0| } 1853| 0| case TK_IF: { /* stat -> ifstat */ ------------------ | Branch (1853:5): [True: 0, False: 6] ------------------ 1854| 0| ifstat(ls, line); 1855| 0| break; 1856| 0| } 1857| 0| case TK_WHILE: { /* stat -> whilestat */ ------------------ | Branch (1857:5): [True: 0, False: 6] ------------------ 1858| 0| whilestat(ls, line); 1859| 0| break; 1860| 0| } 1861| 0| case TK_DO: { /* stat -> DO block END */ ------------------ | Branch (1861:5): [True: 0, False: 6] ------------------ 1862| 0| luaX_next(ls); /* skip DO */ 1863| 0| block(ls); 1864| 0| check_match(ls, TK_END, TK_DO, line); 1865| 0| break; 1866| 0| } 1867| 0| case TK_FOR: { /* stat -> forstat */ ------------------ | Branch (1867:5): [True: 0, False: 6] ------------------ 1868| 0| forstat(ls, line); 1869| 0| break; 1870| 0| } 1871| 0| case TK_REPEAT: { /* stat -> repeatstat */ ------------------ | Branch (1871:5): [True: 0, False: 6] ------------------ 1872| 0| repeatstat(ls, line); 1873| 0| break; 1874| 0| } 1875| 0| case TK_FUNCTION: { /* stat -> funcstat */ ------------------ | Branch (1875:5): [True: 0, False: 6] ------------------ 1876| 0| funcstat(ls, line); 1877| 0| break; 1878| 0| } 1879| 0| case TK_LOCAL: { /* stat -> localstat */ ------------------ | Branch (1879:5): [True: 0, False: 6] ------------------ 1880| 0| luaX_next(ls); /* skip LOCAL */ 1881| 0| if (testnext(ls, TK_FUNCTION)) /* local function? */ ------------------ | Branch (1881:11): [True: 0, False: 0] ------------------ 1882| 0| localfunc(ls); 1883| 0| else 1884| 0| localstat(ls); 1885| 0| break; 1886| 0| } 1887| 0| case TK_DBCOLON: { /* stat -> label */ ------------------ | Branch (1887:5): [True: 0, False: 6] ------------------ 1888| 0| luaX_next(ls); /* skip double colon */ 1889| 0| labelstat(ls, str_checkname(ls), line); 1890| 0| break; 1891| 0| } 1892| 0| case TK_RETURN: { /* stat -> retstat */ ------------------ | Branch (1892:5): [True: 0, False: 6] ------------------ 1893| 0| luaX_next(ls); /* skip RETURN */ 1894| 0| retstat(ls); 1895| 0| break; 1896| 0| } 1897| 0| case TK_BREAK: { /* stat -> breakstat */ ------------------ | Branch (1897:5): [True: 0, False: 6] ------------------ 1898| 0| breakstat(ls); 1899| 0| break; 1900| 0| } 1901| 0| case TK_GOTO: { /* stat -> 'goto' NAME */ ------------------ | Branch (1901:5): [True: 0, False: 6] ------------------ 1902| 0| luaX_next(ls); /* skip 'goto' */ 1903| 0| gotostat(ls); 1904| 0| break; 1905| 0| } 1906| 6| default: { /* stat -> func | assignment */ ------------------ | Branch (1906:5): [True: 6, False: 0] ------------------ 1907| 6| exprstat(ls); 1908| 6| break; 1909| 0| } 1910| 6| } 1911| 0| lua_assert(ls->fs->f->maxstacksize >= ls->fs->freereg && ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 1912| 0| ls->fs->freereg >= luaY_nvarstack(ls->fs)); 1913| 0| ls->fs->freereg = luaY_nvarstack(ls->fs); /* free registers */ 1914| 0| leavelevel(ls); ------------------ | | 507| 0|#define leavelevel(ls) ((ls)->L->nCcalls--) ------------------ 1915| 0|} lparser.c:init_exp: 152| 6|static void init_exp (expdesc *e, expkind k, int i) { 153| 6| e->f = e->t = NO_JUMP; ------------------ | | 20| 6|#define NO_JUMP (-1) ------------------ 154| 6| e->k = k; 155| 6| e->u.info = i; 156| 6|} lparser.c:codestring: 159| 3|static void codestring (expdesc *e, TString *s) { 160| 3| e->f = e->t = NO_JUMP; ------------------ | | 20| 3|#define NO_JUMP (-1) ------------------ 161| 3| e->k = VKSTR; 162| 3| e->u.strval = s; 163| 3|} lparser.c:suffixedexp: 1102| 6|static void suffixedexp (LexState *ls, expdesc *v) { 1103| | /* suffixedexp -> 1104| | primaryexp { '.' NAME | '[' exp ']' | ':' NAME funcargs | funcargs } */ 1105| 6| FuncState *fs = ls->fs; 1106| 6| int line = ls->linenumber; 1107| 6| primaryexp(ls, v); 1108| 6| for (;;) { 1109| 3| switch (ls->t.token) { 1110| 0| case '.': { /* fieldsel */ ------------------ | Branch (1110:7): [True: 0, False: 3] ------------------ 1111| 0| fieldsel(ls, v); 1112| 0| break; 1113| 0| } 1114| 0| case '[': { /* '[' exp ']' */ ------------------ | Branch (1114:7): [True: 0, False: 3] ------------------ 1115| 0| expdesc key; 1116| 0| luaK_exp2anyregup(fs, v); 1117| 0| yindex(ls, &key); 1118| 0| luaK_indexed(fs, v, &key); 1119| 0| break; 1120| 0| } 1121| 0| case ':': { /* ':' NAME funcargs */ ------------------ | Branch (1121:7): [True: 0, False: 3] ------------------ 1122| 0| expdesc key; 1123| 0| luaX_next(ls); 1124| 0| codename(ls, &key); 1125| 0| luaK_self(fs, v, &key); 1126| 0| funcargs(ls, v, line); 1127| 0| break; 1128| 0| } 1129| 0| case '(': case TK_STRING: case '{': { /* funcargs */ ------------------ | Branch (1129:7): [True: 0, False: 3] | Branch (1129:17): [True: 0, False: 3] | Branch (1129:33): [True: 0, False: 3] ------------------ 1130| 0| luaK_exp2nextreg(fs, v); 1131| 0| funcargs(ls, v, line); 1132| 0| break; 1133| 0| } 1134| 3| default: return; ------------------ | Branch (1134:7): [True: 3, False: 0] ------------------ 1135| 3| } 1136| 3| } 1137| 6|} lparser.c:primaryexp: 1080| 6|static void primaryexp (LexState *ls, expdesc *v) { 1081| | /* primaryexp -> NAME | '(' expr ')' */ 1082| 6| switch (ls->t.token) { 1083| 0| case '(': { ------------------ | Branch (1083:5): [True: 0, False: 6] ------------------ 1084| 0| int line = ls->linenumber; 1085| 0| luaX_next(ls); 1086| 0| expr(ls, v); 1087| 0| check_match(ls, ')', '(', line); 1088| 0| luaK_dischargevars(ls->fs, v); 1089| 0| return; 1090| 0| } 1091| 3| case TK_NAME: { ------------------ | Branch (1091:5): [True: 3, False: 3] ------------------ 1092| 3| singlevar(ls, v); 1093| 3| return; 1094| 0| } 1095| 3| default: { ------------------ | Branch (1095:5): [True: 3, False: 3] ------------------ 1096| 3| luaX_syntaxerror(ls, "unexpected symbol"); 1097| 0| } 1098| 6| } 1099| 6|} lparser.c:singlevar: 463| 3|static void singlevar (LexState *ls, expdesc *var) { 464| 3| TString *varname = str_checkname(ls); 465| 3| FuncState *fs = ls->fs; 466| 3| singlevaraux(fs, varname, var, 1); 467| 3| if (var->k == VVOID) { /* global name? */ ------------------ | Branch (467:7): [True: 3, False: 0] ------------------ 468| 3| expdesc key; 469| 3| singlevaraux(fs, ls->envn, var, 1); /* get environment variable */ 470| 3| lua_assert(var->k != VVOID); /* this one must exist */ ------------------ | | 114| 3|#define lua_assert(c) ((void)0) ------------------ 471| 3| luaK_exp2anyregup(fs, var); /* but could be a constant */ 472| 3| codestring(&key, varname); /* key is variable name */ 473| 3| luaK_indexed(fs, var, &key); /* env[varname] */ 474| 3| } 475| 3|} lparser.c:singlevaraux: 435| 9|static void singlevaraux (FuncState *fs, TString *n, expdesc *var, int base) { 436| 9| if (fs == NULL) /* no more levels? */ ------------------ | Branch (436:7): [True: 3, False: 6] ------------------ 437| 3| init_exp(var, VVOID, 0); /* default is global */ 438| 6| else { 439| 6| int v = searchvar(fs, n, var); /* look up locals at current level */ 440| 6| if (v >= 0) { /* found? */ ------------------ | Branch (440:9): [True: 0, False: 6] ------------------ 441| 0| if (v == VLOCAL && !base) ------------------ | Branch (441:11): [True: 0, False: 0] | Branch (441:26): [True: 0, False: 0] ------------------ 442| 0| markupval(fs, var->u.var.vidx); /* local will be used as an upval */ 443| 0| } 444| 6| else { /* not found as local at current level; try upvalues */ 445| 6| int idx = searchupvalue(fs, n); /* try existing upvalues */ 446| 6| if (idx < 0) { /* not found? */ ------------------ | Branch (446:11): [True: 3, False: 3] ------------------ 447| 3| singlevaraux(fs->prev, n, var, 0); /* try upper levels */ 448| 3| if (var->k == VLOCAL || var->k == VUPVAL) /* local or upvalue? */ ------------------ | Branch (448:13): [True: 0, False: 3] | Branch (448:33): [True: 0, False: 3] ------------------ 449| 0| idx = newupvalue(fs, n, var); /* will be a new upvalue */ 450| 3| else /* it is a global or a constant */ 451| 3| return; /* don't need to do anything at this level */ 452| 3| } 453| 3| init_exp(var, VUPVAL, idx); /* new or old upvalue */ 454| 3| } 455| 6| } 456| 9|} lparser.c:searchvar: 390| 6|static int searchvar (FuncState *fs, TString *n, expdesc *var) { 391| 6| int i; 392| 6| for (i = cast_int(fs->nactvar) - 1; i >= 0; i--) { ------------------ | | 141| 6|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 6|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (392:39): [True: 0, False: 6] ------------------ 393| 0| Vardesc *vd = getlocalvardesc(fs, i); 394| 0| if (eqstr(n, vd->vd.name)) { /* found? */ ------------------ | | 43| 0|#define eqstr(a,b) ((a) == (b)) | | ------------------ | | | Branch (43:20): [True: 0, False: 0] | | ------------------ ------------------ 395| 0| if (vd->vd.kind == RDKCTC) /* compile-time constant? */ ------------------ | | 93| 0|#define RDKCTC 3 /* compile-time constant */ ------------------ | Branch (395:11): [True: 0, False: 0] ------------------ 396| 0| init_exp(var, VCONST, fs->firstlocal + i); 397| 0| else /* real variable */ 398| 0| init_var(fs, var, i); 399| 0| return var->k; 400| 0| } 401| 0| } 402| 6| return -1; /* not found */ 403| 6|} lparser.c:searchupvalue: 342| 6|static int searchupvalue (FuncState *fs, TString *name) { 343| 6| int i; 344| 6| Upvaldesc *up = fs->f->upvalues; 345| 9| for (i = 0; i < fs->nups; i++) { ------------------ | Branch (345:15): [True: 6, False: 3] ------------------ 346| 6| if (eqstr(up[i].name, name)) return i; ------------------ | | 43| 6|#define eqstr(a,b) ((a) == (b)) | | ------------------ | | | Branch (43:20): [True: 3, False: 3] | | ------------------ ------------------ 347| 6| } 348| 3| return -1; /* not found */ 349| 6|} lparser.c:str_checkname: 143| 3|static TString *str_checkname (LexState *ls) { 144| 3| TString *ts; 145| 3| check(ls, TK_NAME); 146| 3| ts = ls->t.seminfo.ts; 147| 3| luaX_next(ls); 148| 3| return ts; 149| 3|} lparser.c:exprstat: 1795| 6|static void exprstat (LexState *ls) { 1796| | /* stat -> func | assignment */ 1797| 6| FuncState *fs = ls->fs; 1798| 6| struct LHS_assign v; 1799| 6| suffixedexp(ls, &v.v); 1800| 6| if (ls->t.token == '=' || ls->t.token == ',') { /* stat -> assignment ? */ ------------------ | Branch (1800:7): [True: 3, False: 3] | Branch (1800:29): [True: 0, False: 3] ------------------ 1801| 0| v.prev = NULL; 1802| 0| restassign(ls, &v, 1); 1803| 0| } 1804| 6| else { /* stat -> func */ 1805| 6| Instruction *inst; 1806| 6| check_condition(ls, v.v.k == VCALL, "syntax error"); ------------------ | | 122| 6|#define check_condition(ls,c,msg) { if (!(c)) luaX_syntaxerror(ls, msg); } | | ------------------ | | | Branch (122:41): [True: 3, False: 3] | | ------------------ ------------------ 1807| 3| inst = &getinstruction(fs, &v.v); ------------------ | | 55| 3|#define getinstruction(fs,e) ((fs)->f->code[(e)->u.info]) ------------------ 1808| 3| SETARG_C(*inst, 1); /* call statement uses no results */ ------------------ | | 134| 3|#define SETARG_C(i,v) setarg(i, v, POS_C, SIZE_C) | | ------------------ | | | | 122| 3|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 3|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 3|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 3| ((cast(Instruction, v)<t.token != c) ------------------ | Branch (108:7): [True: 0, False: 3] ------------------ 109| 0| error_expected(ls, c); 110| 3|} luaE_setdebt: 89| 3|void luaE_setdebt (global_State *g, l_mem debt) { 90| 3| l_mem tb = gettotalbytes(g); ------------------ | | 394| 3|#define gettotalbytes(g) cast(lu_mem, (g)->totalbytes + (g)->GCdebt) | | ------------------ | | | | 136| 3|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 91| 3| lua_assert(tb > 0); ------------------ | | 114| 3|#define lua_assert(c) ((void)0) ------------------ 92| 3| if (debt < tb - MAX_LMEM) ------------------ | | 50| 3|#define MAX_LMEM ((l_mem)(MAX_LUMEM >> 1)) | | ------------------ | | | | 48| 3|#define MAX_LUMEM ((lu_mem)(~(lu_mem)0)) | | ------------------ ------------------ | Branch (92:7): [True: 0, False: 3] ------------------ 93| 0| debt = tb - MAX_LMEM; /* will make 'totalbytes == MAX_LMEM' */ ------------------ | | 50| 0|#define MAX_LMEM ((l_mem)(MAX_LUMEM >> 1)) | | ------------------ | | | | 48| 0|#define MAX_LUMEM ((lu_mem)(~(lu_mem)0)) | | ------------------ ------------------ 94| 3| g->totalbytes = tb - debt; 95| 3| g->GCdebt = debt; 96| 3|} luaE_freeCI: 122| 6|void luaE_freeCI (lua_State *L) { 123| 6| CallInfo *ci = L->ci; 124| 6| CallInfo *next = ci->next; 125| 6| ci->next = NULL; 126| 6| while ((ci = next) != NULL) { ------------------ | Branch (126:10): [True: 0, False: 6] ------------------ 127| 0| next = ci->next; 128| 0| luaM_free(L, ci); ------------------ | | 56| 0|#define luaM_free(L, b) luaM_free_(L, (b), sizeof(*(b))) ------------------ 129| 0| L->nci--; 130| 0| } 131| 6|} luaE_shrinkCI: 138| 9|void luaE_shrinkCI (lua_State *L) { 139| 9| CallInfo *ci = L->ci->next; /* first free CallInfo */ 140| 9| CallInfo *next; 141| 9| if (ci == NULL) ------------------ | Branch (141:7): [True: 9, False: 0] ------------------ 142| 9| return; /* no extra elements */ 143| 0| while ((next = ci->next) != NULL) { /* two extra elements? */ ------------------ | Branch (143:10): [True: 0, False: 0] ------------------ 144| 0| CallInfo *next2 = next->next; /* next's next */ 145| 0| ci->next = next2; /* remove next from the list */ 146| 0| L->nci--; 147| 0| luaM_free(L, next); /* free next */ ------------------ | | 56| 0|#define luaM_free(L, b) luaM_free_(L, (b), sizeof(*(b))) ------------------ 148| 0| if (next2 == NULL) ------------------ | Branch (148:9): [True: 0, False: 0] ------------------ 149| 0| break; /* no more elements */ 150| 0| else { 151| 0| next2->previous = ci; 152| 0| ci = next2; /* continue */ 153| 0| } 154| 0| } 155| 0|} luaE_incCstack: 173| 6|LUAI_FUNC void luaE_incCstack (lua_State *L) { 174| 6| L->nCcalls++; 175| 6| if (l_unlikely(getCcalls(L) >= LUAI_MAXCCALLS)) ------------------ | | 688| 6|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 6|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 6] | | | | ------------------ | | ------------------ ------------------ 176| 0| luaE_checkcstack(L); 177| 6|} lua_newstate: 352| 6|LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) { 353| 6| int i; 354| 6| lua_State *L; 355| 6| global_State *g; 356| 6| LG *l = cast(LG *, (*f)(ud, NULL, LUA_TTHREAD, sizeof(LG))); ------------------ | | 136| 6|#define cast(t, exp) ((t)(exp)) ------------------ 357| 6| if (l == NULL) return NULL; ------------------ | Branch (357:7): [True: 0, False: 6] ------------------ 358| 6| L = &l->l.l; 359| 6| g = &l->g; 360| 6| L->tt = LUA_VTHREAD; ------------------ | | 262| 6|#define LUA_VTHREAD makevariant(LUA_TTHREAD, 0) | | ------------------ | | | | 42| 6|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ 361| 6| g->currentwhite = bitmask(WHITE0BIT); ------------------ | | 63| 6|#define bitmask(b) (1<<(b)) ------------------ 362| 6| L->marked = luaC_white(g); ------------------ | | 102| 6|#define luaC_white(g) cast_byte((g)->currentwhite & WHITEBITS) | | ------------------ | | | | 143| 6|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 136| 6|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 363| 6| preinit_thread(L, g); 364| 6| g->allgc = obj2gco(L); /* by now, only object is the main thread */ ------------------ | | 390| 6|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | ------------------ | | | | 115| 6|#define check_exp(c,e) (e) | | ------------------ ------------------ 365| 6| L->next = NULL; 366| 6| incnny(L); /* main thread is always non yieldable */ ------------------ | | 111| 6|#define incnny(L) ((L)->nCcalls += 0x10000) ------------------ 367| 6| g->frealloc = f; 368| 6| g->ud = ud; 369| 6| g->warnf = NULL; 370| 6| g->ud_warn = NULL; 371| 6| g->mainthread = L; 372| 6| g->seed = luai_makeseed(L); 373| 6| g->gcstp = GCSTPGC; /* no GC while building state */ ------------------ | | 156| 6|#define GCSTPGC 2 /* bit true when GC stopped by itself */ ------------------ 374| 6| g->strt.size = g->strt.nuse = 0; 375| 6| g->strt.hash = NULL; 376| 6| setnilvalue(&g->l_registry); ------------------ | | 200| 6|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 6|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 377| 6| g->panic = NULL; 378| 6| g->gcstate = GCSpause; ------------------ | | 39| 6|#define GCSpause 8 ------------------ 379| 6| g->gckind = KGC_INC; ------------------ | | 151| 6|#define KGC_INC 0 /* incremental gc */ ------------------ 380| 6| g->gcstopem = 0; 381| 6| g->gcemergency = 0; 382| 6| g->finobj = g->tobefnz = g->fixedgc = NULL; 383| 6| g->firstold1 = g->survival = g->old1 = g->reallyold = NULL; 384| 6| g->finobjsur = g->finobjold1 = g->finobjrold = NULL; 385| 6| g->sweepgc = NULL; 386| 6| g->gray = g->grayagain = NULL; 387| 6| g->weak = g->ephemeron = g->allweak = NULL; 388| 6| g->twups = NULL; 389| 6| g->totalbytes = sizeof(LG); 390| 6| g->GCdebt = 0; 391| 6| g->lastatomic = 0; 392| 6| setivalue(&g->nilvalue, 0); /* to signal that state is not yet built */ ------------------ | | 345| 6| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 6|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 6|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 393| 6| setgcparam(g->gcpause, LUAI_GCPAUSE); ------------------ | | 136| 6|#define setgcparam(p,v) ((p) = (v) / 4) ------------------ 394| 6| setgcparam(g->gcstepmul, LUAI_GCMUL); ------------------ | | 136| 6|#define setgcparam(p,v) ((p) = (v) / 4) ------------------ 395| 6| g->gcstepsize = LUAI_GCSTEPSIZE; ------------------ | | 141| 6|#define LUAI_GCSTEPSIZE 13 /* 8 KB */ ------------------ 396| 6| setgcparam(g->genmajormul, LUAI_GENMAJORMUL); ------------------ | | 136| 6|#define setgcparam(p,v) ((p) = (v) / 4) ------------------ 397| 6| g->genminormul = LUAI_GENMINORMUL; ------------------ | | 126| 6|#define LUAI_GENMINORMUL 20 ------------------ 398| 60| for (i=0; i < LUA_NUMTAGS; i++) g->mt[i] = NULL; ------------------ | | 426| 60|#define LUA_NUMTAGS LUA_NUMTYPES | | ------------------ | | | | 75| 60|#define LUA_NUMTYPES 9 | | ------------------ ------------------ | Branch (398:13): [True: 54, False: 6] ------------------ 399| 6| if (luaD_rawrunprotected(L, f_luaopen, NULL) != LUA_OK) { ------------------ | | 49| 6|#define LUA_OK 0 ------------------ | Branch (399:7): [True: 0, False: 6] ------------------ 400| | /* memory allocation error: free partial state */ 401| 0| close_state(L); 402| 0| L = NULL; 403| 0| } 404| 6| return L; 405| 6|} lua_close: 408| 6|LUA_API void lua_close (lua_State *L) { 409| 6| lua_lock(L); ------------------ | | 264| 6|#define lua_lock(L) ((void) 0) ------------------ 410| 6| L = G(L)->mainthread; /* only the main thread can be closed */ ------------------ | | 335| 6|#define G(L) (L->l_G) ------------------ 411| 6| close_state(L); 412| 6|} lstate.c:preinit_thread: 249| 6|static void preinit_thread (lua_State *L, global_State *g) { 250| 6| G(L) = g; ------------------ | | 335| 6|#define G(L) (L->l_G) ------------------ 251| 6| L->stack.p = NULL; 252| 6| L->ci = NULL; 253| 6| L->nci = 0; 254| 6| L->twups = L; /* thread has no upvalues */ 255| 6| L->nCcalls = 0; 256| 6| L->errorJmp = NULL; 257| 6| L->hook = NULL; 258| 6| L->hookmask = 0; 259| 6| L->basehookcount = 0; 260| 6| L->allowhook = 1; 261| 6| resethookcount(L); ------------------ | | 21| 6|#define resethookcount(L) (L->hookcount = L->basehookcount) ------------------ 262| 6| L->openupval = NULL; 263| 6| L->status = LUA_OK; ------------------ | | 49| 6|#define LUA_OK 0 ------------------ 264| 6| L->errfunc = 0; 265| 6| L->oldpc = 0; 266| 6|} lstate.c:stack_init: 180| 6|static void stack_init (lua_State *L1, lua_State *L) { 181| 6| int i; CallInfo *ci; 182| | /* initialize stack array */ 183| 6| L1->stack.p = luaM_newvector(L, BASIC_STACK_SIZE + EXTRA_STACK, StackValue); ------------------ | | 60| 6|#define luaM_newvector(L,n,t) cast(t*, luaM_malloc_(L, (n)*sizeof(t), 0)) | | ------------------ | | | | 136| 6|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 184| 6| L1->tbclist.p = L1->stack.p; 185| 276| for (i = 0; i < BASIC_STACK_SIZE + EXTRA_STACK; i++) ------------------ | | 145| 276|#define BASIC_STACK_SIZE (2*LUA_MINSTACK) | | ------------------ | | | | 80| 276|#define LUA_MINSTACK 20 | | ------------------ ------------------ for (i = 0; i < BASIC_STACK_SIZE + EXTRA_STACK; i++) ------------------ | | 142| 276|#define EXTRA_STACK 5 ------------------ | Branch (185:15): [True: 270, False: 6] ------------------ 186| 270| setnilvalue(s2v(L1->stack.p + i)); /* erase new stack */ ------------------ | | 200| 270|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 270|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 187| 6| L1->top.p = L1->stack.p; 188| 6| L1->stack_last.p = L1->stack.p + BASIC_STACK_SIZE; ------------------ | | 145| 6|#define BASIC_STACK_SIZE (2*LUA_MINSTACK) | | ------------------ | | | | 80| 6|#define LUA_MINSTACK 20 | | ------------------ ------------------ 189| | /* initialize first ci */ 190| 6| ci = &L1->base_ci; 191| 6| ci->next = ci->previous = NULL; 192| 6| ci->callstatus = CIST_C; ------------------ | | 211| 6|#define CIST_C (1<<1) /* call is running a C function */ ------------------ 193| 6| ci->func.p = L1->top.p; 194| 6| ci->u.c.k = NULL; 195| 6| ci->nresults = 0; 196| 6| setnilvalue(s2v(L1->top.p)); /* 'function' entry for this 'ci' */ ------------------ | | 200| 6|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 6|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 197| 6| L1->top.p++; 198| 6| ci->top.p = L1->top.p + LUA_MINSTACK; ------------------ | | 80| 6|#define LUA_MINSTACK 20 ------------------ 199| 6| L1->ci = ci; 200| 6|} lstate.c:freestack: 203| 6|static void freestack (lua_State *L) { 204| 6| if (L->stack.p == NULL) ------------------ | Branch (204:7): [True: 0, False: 6] ------------------ 205| 0| return; /* stack not completely built yet */ 206| 6| L->ci = &L->base_ci; /* free the entire 'ci' list */ 207| 6| luaE_freeCI(L); 208| 6| lua_assert(L->nci == 0); ------------------ | | 114| 6|#define lua_assert(c) ((void)0) ------------------ 209| 6| luaM_freearray(L, L->stack.p, stacksize(L) + EXTRA_STACK); /* free stack */ ------------------ | | 57| 6|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 210| 6|} lstate.c:luai_makeseed: 71| 6|static unsigned int luai_makeseed (lua_State *L) { 72| 6| char buff[3 * sizeof(size_t)]; 73| 6| unsigned int h = cast_uint(time(NULL)); ------------------ | | 142| 6|#define cast_uint(i) cast(unsigned int, (i)) | | ------------------ | | | | 136| 6|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 74| 6| int p = 0; 75| 6| addbuff(buff, p, L); /* heap variable */ ------------------ | | 68| 6| { size_t t = cast_sizet(e); \ | | ------------------ | | | | 147| 6|#define cast_sizet(i) cast(size_t, (i)) | | | | ------------------ | | | | | | 136| 6|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | 69| 6| memcpy(b + p, &t, sizeof(t)); p += sizeof(t); } ------------------ 76| 6| addbuff(buff, p, &h); /* local variable */ ------------------ | | 68| 6| { size_t t = cast_sizet(e); \ | | ------------------ | | | | 147| 6|#define cast_sizet(i) cast(size_t, (i)) | | | | ------------------ | | | | | | 136| 6|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | 69| 6| memcpy(b + p, &t, sizeof(t)); p += sizeof(t); } ------------------ 77| 6| addbuff(buff, p, &lua_newstate); /* public function */ ------------------ | | 68| 6| { size_t t = cast_sizet(e); \ | | ------------------ | | | | 147| 6|#define cast_sizet(i) cast(size_t, (i)) | | | | ------------------ | | | | | | 136| 6|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | 69| 6| memcpy(b + p, &t, sizeof(t)); p += sizeof(t); } ------------------ 78| 6| lua_assert(p == sizeof(buff)); ------------------ | | 114| 6|#define lua_assert(c) ((void)0) ------------------ 79| 6| return luaS_hash(buff, p, h); 80| 6|} lstate.c:f_luaopen: 231| 6|static void f_luaopen (lua_State *L, void *ud) { 232| 6| global_State *g = G(L); ------------------ | | 335| 6|#define G(L) (L->l_G) ------------------ 233| 6| UNUSED(ud); ------------------ | | 131| 6|#define UNUSED(x) ((void)(x)) ------------------ 234| 6| stack_init(L, L); /* init stack */ 235| 6| init_registry(L, g); 236| 6| luaS_init(L); 237| 6| luaT_init(L); 238| 6| luaX_init(L); 239| 6| g->gcstp = 0; /* allow gc */ 240| 6| setnilvalue(&g->nilvalue); /* now state is complete */ ------------------ | | 200| 6|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 6|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 241| 6| luai_userstateopen(L); ------------------ | | 282| 6|#define luai_userstateopen(L) ((void)L) ------------------ 242| 6|} lstate.c:init_registry: 216| 6|static void init_registry (lua_State *L, global_State *g) { 217| | /* create registry */ 218| 6| Table *registry = luaH_new(L); 219| 6| sethvalue(L, &g->l_registry, registry); ------------------ | | 687| 6| { TValue *io = (obj); Table *x_ = (x); \ | | 688| 6| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 72| 6|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 390| 6|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 6|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 114| 6|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 689| 6| checkliveness(L,io); } | | ------------------ | | | | 107| 6| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 6|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 6| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 220| 6| luaH_resize(L, registry, LUA_RIDX_LAST, 0); ------------------ | | 86| 6|#define LUA_RIDX_LAST LUA_RIDX_GLOBALS | | ------------------ | | | | 85| 6|#define LUA_RIDX_GLOBALS 2 | | ------------------ ------------------ 221| | /* registry[LUA_RIDX_MAINTHREAD] = L */ 222| 6| setthvalue(L, ®istry->array[LUA_RIDX_MAINTHREAD - 1], L); ------------------ | | 269| 6| { TValue *io = (obj); lua_State *x_ = (x); \ | | 270| 6| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTHREAD)); \ | | ------------------ | | | | 72| 6|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTHREAD)); \ | | ------------------ | | | | 390| 6|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 6|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTHREAD)); \ | | ------------------ | | | | 114| 6|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 271| 6| checkliveness(L,io); } | | ------------------ | | | | 107| 6| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 6|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 6| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 223| | /* registry[LUA_RIDX_GLOBALS] = new table (table of globals) */ 224| 6| sethvalue(L, ®istry->array[LUA_RIDX_GLOBALS - 1], luaH_new(L)); ------------------ | | 687| 6| { TValue *io = (obj); Table *x_ = (x); \ | | 688| 6| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 72| 6|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 390| 6|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 6|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 114| 6|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 689| 6| checkliveness(L,io); } | | ------------------ | | | | 107| 6| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 6|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 6| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 225| 6|} lstate.c:close_state: 269| 6|static void close_state (lua_State *L) { 270| 6| global_State *g = G(L); ------------------ | | 335| 6|#define G(L) (L->l_G) ------------------ 271| 6| if (!completestate(g)) /* closing a partially built state? */ ------------------ | | 341| 6|#define completestate(g) ttisnil(&g->nilvalue) | | ------------------ | | | | 193| 6|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 6|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 6|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 6|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (271:7): [True: 0, False: 6] ------------------ 272| 0| luaC_freeallobjects(L); /* just collect its objects */ 273| 6| else { /* closing a fully built state */ 274| 6| L->ci = &L->base_ci; /* unwind CallInfo list */ 275| 6| luaD_closeprotected(L, 1, LUA_OK); /* close all upvalues */ ------------------ | | 49| 6|#define LUA_OK 0 ------------------ 276| 6| luaC_freeallobjects(L); /* collect all objects */ 277| 6| luai_userstateclose(L); ------------------ | | 286| 6|#define luai_userstateclose(L) ((void)L) ------------------ 278| 6| } 279| 6| luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size); ------------------ | | 57| 6|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 280| 6| freestack(L); 281| 6| lua_assert(gettotalbytes(g) == sizeof(LG)); ------------------ | | 114| 6|#define lua_assert(c) ((void)0) ------------------ 282| 6| (*g->frealloc)(g->ud, fromstate(L), sizeof(LG), 0); /* free main block */ ------------------ | | 51| 6|#define fromstate(L) (cast(LX *, cast(lu_byte *, (L)) - offsetof(LX, l))) | | ------------------ | | | | 136| 6|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 283| 6|} luaS_eqlngstr: 34| 1|int luaS_eqlngstr (TString *a, TString *b) { 35| 1| size_t len = a->u.lnglen; 36| 1| lua_assert(a->tt == LUA_VLNGSTR && b->tt == LUA_VLNGSTR); ------------------ | | 114| 1|#define lua_assert(c) ((void)0) ------------------ 37| 1| return (a == b) || /* same instance or... */ ------------------ | Branch (37:10): [True: 1, False: 0] ------------------ 38| 1| ((len == b->u.lnglen) && /* equal length and ... */ ------------------ | Branch (38:6): [True: 0, False: 0] ------------------ 39| 0| (memcmp(getstr(a), getstr(b), len) == 0)); /* equal contents */ ------------------ | | 403| 0|#define getstr(ts) ((ts)->contents) ------------------ (memcmp(getstr(a), getstr(b), len) == 0)); /* equal contents */ ------------------ | | 403| 0|#define getstr(ts) ((ts)->contents) ------------------ | Branch (39:6): [True: 0, False: 0] ------------------ 40| 1|} luaS_hash: 43| 326|unsigned int luaS_hash (const char *str, size_t l, unsigned int seed) { 44| 326| unsigned int h = seed ^ cast_uint(l); ------------------ | | 142| 326|#define cast_uint(i) cast(unsigned int, (i)) | | ------------------ | | | | 136| 326|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 45| 1.05M| for (; l > 0; l--) ------------------ | Branch (45:10): [True: 1.05M, False: 326] ------------------ 46| 1.05M| h ^= ((h<<5) + (h>>2) + cast_byte(str[l - 1])); ------------------ | | 143| 1.05M|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 1.05M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 47| 326| return h; 48| 326|} luaS_hashlongstr: 51| 5|unsigned int luaS_hashlongstr (TString *ts) { 52| 5| lua_assert(ts->tt == LUA_VLNGSTR); ------------------ | | 114| 5|#define lua_assert(c) ((void)0) ------------------ 53| 5| if (ts->extra == 0) { /* no hash? */ ------------------ | Branch (53:7): [True: 1, False: 4] ------------------ 54| 1| size_t len = ts->u.lnglen; 55| 1| ts->hash = luaS_hash(getstr(ts), len, ts->hash); ------------------ | | 403| 1|#define getstr(ts) ((ts)->contents) ------------------ 56| 1| ts->extra = 1; /* now it has its hash */ 57| 1| } 58| 5| return ts->hash; 59| 5|} luaS_clearcache: 110| 3|void luaS_clearcache (global_State *g) { 111| 3| int i, j; 112| 162| for (i = 0; i < STRCACHE_N; i++) ------------------ | | 237| 162|#define STRCACHE_N 53 ------------------ | Branch (112:15): [True: 159, False: 3] ------------------ 113| 477| for (j = 0; j < STRCACHE_M; j++) { ------------------ | | 238| 477|#define STRCACHE_M 2 ------------------ | Branch (113:17): [True: 318, False: 159] ------------------ 114| 318| if (iswhite(g->strcache[i][j])) /* will entry be collected? */ ------------------ | | 87| 318|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | ------------------ | | | | 62| 318|#define testbits(x,m) ((x) & (m)) | | | | ------------------ | | | | | Branch (62:24): [True: 0, False: 318] | | | | ------------------ | | ------------------ ------------------ 115| 0| g->strcache[i][j] = g->memerrmsg; /* replace it with something fixed */ 116| 318| } 117| 3|} luaS_init: 123| 6|void luaS_init (lua_State *L) { 124| 6| global_State *g = G(L); ------------------ | | 335| 6|#define G(L) (L->l_G) ------------------ 125| 6| int i, j; 126| 6| stringtable *tb = &G(L)->strt; ------------------ | | 335| 6|#define G(L) (L->l_G) ------------------ 127| 6| tb->hash = luaM_newvector(L, MINSTRTABSIZE, TString*); ------------------ | | 60| 6|#define luaM_newvector(L,n,t) cast(t*, luaM_malloc_(L, (n)*sizeof(t), 0)) | | ------------------ | | | | 136| 6|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 128| 6| tablerehash(tb->hash, 0, MINSTRTABSIZE); /* clear array */ ------------------ | | 227| 6|#define MINSTRTABSIZE 128 ------------------ 129| 6| tb->size = MINSTRTABSIZE; ------------------ | | 227| 6|#define MINSTRTABSIZE 128 ------------------ 130| | /* pre-create memory-error message */ 131| 6| g->memerrmsg = luaS_newliteral(L, MEMERRMSG); ------------------ | | 28| 6|#define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \ | | 29| 6| (sizeof(s)/sizeof(char))-1)) ------------------ 132| 6| luaC_fix(L, obj2gco(g->memerrmsg)); /* it should never be collected */ ------------------ | | 390| 6|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | ------------------ | | | | 115| 6|#define check_exp(c,e) (e) | | ------------------ ------------------ 133| 324| for (i = 0; i < STRCACHE_N; i++) /* fill cache with valid strings */ ------------------ | | 237| 324|#define STRCACHE_N 53 ------------------ | Branch (133:15): [True: 318, False: 6] ------------------ 134| 954| for (j = 0; j < STRCACHE_M; j++) ------------------ | | 238| 954|#define STRCACHE_M 2 ------------------ | Branch (134:17): [True: 636, False: 318] ------------------ 135| 636| g->strcache[i][j] = g->memerrmsg; 136| 6|} luaS_createlngstrobj: 157| 7|TString *luaS_createlngstrobj (lua_State *L, size_t l) { 158| 7| TString *ts = createstrobj(L, l, LUA_VLNGSTR, G(L)->seed); ------------------ | | 361| 7|#define LUA_VLNGSTR makevariant(LUA_TSTRING, 1) /* long strings */ | | ------------------ | | | | 42| 7|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ TString *ts = createstrobj(L, l, LUA_VLNGSTR, G(L)->seed); ------------------ | | 335| 7|#define G(L) (L->l_G) ------------------ 159| 7| ts->u.lnglen = l; 160| 7| return ts; 161| 7|} luaS_remove: 164| 313|void luaS_remove (lua_State *L, TString *ts) { 165| 313| stringtable *tb = &G(L)->strt; ------------------ | | 335| 313|#define G(L) (L->l_G) ------------------ 166| 313| TString **p = &tb->hash[lmod(ts->hash, tb->size)]; ------------------ | | 789| 313| (check_exp((size&(size-1))==0, (cast_int((s) & ((size)-1))))) | | ------------------ | | | | 115| 313|#define check_exp(c,e) (e) | | ------------------ ------------------ 167| 313| while (*p != ts) /* find previous element */ ------------------ | Branch (167:10): [True: 0, False: 313] ------------------ 168| 0| p = &(*p)->u.hnext; 169| 313| *p = (*p)->u.hnext; /* remove element from its list */ 170| 313| tb->nuse--; 171| 313|} luaS_newlstr: 221| 326|TString *luaS_newlstr (lua_State *L, const char *str, size_t l) { 222| 326| if (l <= LUAI_MAXSHORTLEN) /* short string? */ ------------------ | | 216| 326|#define LUAI_MAXSHORTLEN 40 ------------------ | Branch (222:7): [True: 319, False: 7] ------------------ 223| 319| return internshrstr(L, str, l); 224| 7| else { 225| 7| TString *ts; 226| 7| if (l_unlikely(l >= (MAX_SIZE - sizeof(TString))/sizeof(char))) ------------------ | | 688| 7|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 14|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 7] | | | | | Branch (676:46): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 227| 0| luaM_toobig(L); 228| 7| ts = luaS_createlngstrobj(L, l); 229| 7| memcpy(getstr(ts), str, l * sizeof(char)); ------------------ | | 403| 7|#define getstr(ts) ((ts)->contents) ------------------ 230| 7| return ts; 231| 7| } 232| 326|} luaS_new: 241| 288|TString *luaS_new (lua_State *L, const char *str) { 242| 288| unsigned int i = point2uint(str) % STRCACHE_N; /* hash */ ------------------ | | 91| 288|#define point2uint(p) ((unsigned int)((L_P2I)(p) & UINT_MAX)) ------------------ unsigned int i = point2uint(str) % STRCACHE_N; /* hash */ ------------------ | | 237| 288|#define STRCACHE_N 53 ------------------ 243| 288| int j; 244| 288| TString **p = G(L)->strcache[i]; ------------------ | | 335| 288|#define G(L) (L->l_G) ------------------ 245| 864| for (j = 0; j < STRCACHE_M; j++) { ------------------ | | 238| 864|#define STRCACHE_M 2 ------------------ | Branch (245:15): [True: 576, False: 288] ------------------ 246| 576| if (strcmp(str, getstr(p[j])) == 0) /* hit? */ ------------------ | | 403| 576|#define getstr(ts) ((ts)->contents) ------------------ | Branch (246:9): [True: 0, False: 576] ------------------ 247| 0| return p[j]; /* that is it */ 248| 576| } 249| | /* normal route */ 250| 576| for (j = STRCACHE_M - 1; j > 0; j--) ------------------ | | 238| 288|#define STRCACHE_M 2 ------------------ | Branch (250:28): [True: 288, False: 288] ------------------ 251| 288| p[j] = p[j - 1]; /* move out last element */ 252| | /* new element is first in the list */ 253| 288| p[0] = luaS_newlstr(L, str, strlen(str)); 254| 288| return p[0]; 255| 288|} lstring.c:tablerehash: 62| 6|static void tablerehash (TString **vect, int osize, int nsize) { 63| 6| int i; 64| 774| for (i = osize; i < nsize; i++) /* clear new elements */ ------------------ | Branch (64:19): [True: 768, False: 6] ------------------ 65| 768| vect[i] = NULL; 66| 6| for (i = 0; i < osize; i++) { /* rehash old part of the array */ ------------------ | Branch (66:15): [True: 0, False: 6] ------------------ 67| 0| TString *p = vect[i]; 68| 0| vect[i] = NULL; 69| 0| while (p) { /* for each string in the list */ ------------------ | Branch (69:12): [True: 0, False: 0] ------------------ 70| 0| TString *hnext = p->u.hnext; /* save next */ 71| 0| unsigned int h = lmod(p->hash, nsize); /* new position */ ------------------ | | 789| 0| (check_exp((size&(size-1))==0, (cast_int((s) & ((size)-1))))) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 72| 0| p->u.hnext = vect[h]; /* chain it into array */ 73| 0| vect[h] = p; 74| 0| p = hnext; 75| 0| } 76| 0| } 77| 6|} lstring.c:createstrobj: 143| 320|static TString *createstrobj (lua_State *L, size_t l, int tag, unsigned int h) { 144| 320| TString *ts; 145| 320| GCObject *o; 146| 320| size_t totalsize; /* total size of TString object */ 147| 320| totalsize = sizelstring(l); ------------------ | | 26| 320|#define sizelstring(l) (offsetof(TString, contents) + ((l) + 1) * sizeof(char)) ------------------ 148| 320| o = luaC_newobj(L, tag, totalsize); 149| 320| ts = gco2ts(o); ------------------ | | 374| 320| check_exp(novariant((o)->tt) == LUA_TSTRING, &((cast_u(o))->ts)) | | ------------------ | | | | 115| 320|#define check_exp(c,e) (e) | | ------------------ ------------------ 150| 320| ts->hash = h; 151| 320| ts->extra = 0; 152| 320| getstr(ts)[l] = '\0'; /* ending 0 */ ------------------ | | 403| 320|#define getstr(ts) ((ts)->contents) ------------------ 153| 320| return ts; 154| 320|} lstring.c:internshrstr: 188| 319|static TString *internshrstr (lua_State *L, const char *str, size_t l) { 189| 319| TString *ts; 190| 319| global_State *g = G(L); ------------------ | | 335| 319|#define G(L) (L->l_G) ------------------ 191| 319| stringtable *tb = &g->strt; 192| 319| unsigned int h = luaS_hash(str, l, g->seed); 193| 319| TString **list = &tb->hash[lmod(h, tb->size)]; ------------------ | | 789| 319| (check_exp((size&(size-1))==0, (cast_int((s) & ((size)-1))))) | | ------------------ | | | | 115| 319|#define check_exp(c,e) (e) | | ------------------ ------------------ 194| 319| lua_assert(str != NULL); /* otherwise 'memcmp'/'memcpy' are undefined */ ------------------ | | 114| 319|#define lua_assert(c) ((void)0) ------------------ 195| 357| for (ts = *list; ts != NULL; ts = ts->u.hnext) { ------------------ | Branch (195:20): [True: 44, False: 313] ------------------ 196| 44| if (l == ts->shrlen && (memcmp(str, getstr(ts), l * sizeof(char)) == 0)) { ------------------ | | 403| 12|#define getstr(ts) ((ts)->contents) ------------------ | Branch (196:9): [True: 12, False: 32] | Branch (196:28): [True: 6, False: 6] ------------------ 197| | /* found! */ 198| 6| if (isdead(g, ts)) /* dead (but not collected yet)? */ ------------------ | | 96| 6|#define isdead(g,v) isdeadm(otherwhite(g), (v)->marked) | | ------------------ | | | | 95| 6|#define isdeadm(ow,m) ((m) & (ow)) | | | | ------------------ | | | | | Branch (95:23): [True: 0, False: 6] | | | | ------------------ | | ------------------ ------------------ 199| 0| changewhite(ts); /* resurrect it */ ------------------ | | 98| 0|#define changewhite(x) ((x)->marked ^= WHITEBITS) | | ------------------ | | | | 84| 0|#define WHITEBITS bit2mask(WHITE0BIT, WHITE1BIT) | | | | ------------------ | | | | | | 64| 0|#define bit2mask(b1,b2) (bitmask(b1) | bitmask(b2)) | | | | | | ------------------ | | | | | | | | 63| 0|#define bitmask(b) (1<<(b)) | | | | | | ------------------ | | | | | | #define bit2mask(b1,b2) (bitmask(b1) | bitmask(b2)) | | | | | | ------------------ | | | | | | | | 63| 0|#define bitmask(b) (1<<(b)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 200| 6| return ts; 201| 6| } 202| 44| } 203| | /* else must create a new string */ 204| 313| if (tb->nuse >= tb->size) { /* need to grow string table? */ ------------------ | Branch (204:7): [True: 0, False: 313] ------------------ 205| 0| growstrtab(L, tb); 206| 0| list = &tb->hash[lmod(h, tb->size)]; /* rehash with new size */ ------------------ | | 789| 0| (check_exp((size&(size-1))==0, (cast_int((s) & ((size)-1))))) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 207| 0| } 208| 313| ts = createstrobj(L, l, LUA_VSHRSTR, h); ------------------ | | 360| 313|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 313|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ 209| 313| memcpy(getstr(ts), str, l * sizeof(char)); ------------------ | | 403| 313|#define getstr(ts) ((ts)->contents) ------------------ 210| 313| ts->shrlen = cast_byte(l); ------------------ | | 143| 313|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 313|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 211| 313| ts->u.hnext = *list; 212| 313| *list = ts; 213| 313| tb->nuse++; 214| 313| return ts; 215| 319|} luaH_realasize: 250| 39|LUAI_FUNC unsigned int luaH_realasize (const Table *t) { 251| 39| if (limitequalsasize(t)) ------------------ | | 244| 39|#define limitequalsasize(t) (isrealasize(t) || ispow2((t)->alimit)) | | ------------------ | | | | 734| 78|#define isrealasize(t) (!((t)->flags & BITRAS)) | | | | ------------------ | | | | | | 733| 39|#define BITRAS (1 << 7) | | | | ------------------ | | | | | Branch (734:25): [True: 39, False: 0] | | | | ------------------ | | ------------------ | | #define limitequalsasize(t) (isrealasize(t) || ispow2((t)->alimit)) | | ------------------ | | | | 66| 0|#define ispow2(x) (((x) & ((x) - 1)) == 0) | | | | ------------------ | | | | | Branch (66:19): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 252| 39| return t->alimit; /* this is the size */ 253| 0| else { 254| 0| unsigned int size = t->alimit; 255| | /* compute the smallest power of 2 not smaller than 'n' */ 256| 0| size |= (size >> 1); 257| 0| size |= (size >> 2); 258| 0| size |= (size >> 4); 259| 0| size |= (size >> 8); 260| 0|#if (UINT_MAX >> 14) > 3 /* unsigned int has more than 16 bits */ 261| 0| size |= (size >> 16); 262| |#if (UINT_MAX >> 30) > 3 263| | size |= (size >> 32); /* unsigned int has more than 32 bits */ 264| |#endif 265| 0|#endif 266| 0| size++; 267| 0| lua_assert(ispow2(size) && size/2 < t->alimit && t->alimit < size); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 268| 0| return size; 269| 0| } 270| 39|} luaH_resize: 554| 9| unsigned int nhsize) { 555| 9| unsigned int i; 556| 9| Table newt; /* to keep the new hash part */ 557| 9| unsigned int oldasize = setlimittosize(t); 558| 9| TValue *newarray; 559| | /* create new hash part with appropriate size into 'newt' */ 560| 9| setnodevector(L, &newt, nhsize); 561| 9| if (newasize < oldasize) { /* will array shrink? */ ------------------ | Branch (561:7): [True: 0, False: 9] ------------------ 562| 0| t->alimit = newasize; /* pretend array has new size... */ 563| 0| exchangehashpart(t, &newt); /* and new hash */ 564| | /* re-insert into the new hash the elements from vanishing slice */ 565| 0| for (i = newasize; i < oldasize; i++) { ------------------ | Branch (565:24): [True: 0, False: 0] ------------------ 566| 0| if (!isempty(&t->array[i])) ------------------ | | 217| 0|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 0|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 0|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 0|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 0|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (566:11): [True: 0, False: 0] ------------------ 567| 0| luaH_setint(L, t, i + 1, &t->array[i]); 568| 0| } 569| 0| t->alimit = oldasize; /* restore current size... */ 570| 0| exchangehashpart(t, &newt); /* and hash (in case of errors) */ 571| 0| } 572| | /* allocate new array */ 573| 9| newarray = luaM_reallocvector(L, t->array, oldasize, newasize, TValue); ------------------ | | 71| 9| (cast(t *, luaM_realloc_(L, v, cast_sizet(oldn) * sizeof(t), \ | | ------------------ | | | | 136| 9|#define cast(t, exp) ((t)(exp)) | | ------------------ | | 72| 9| cast_sizet(n) * sizeof(t)))) ------------------ 574| 9| if (l_unlikely(newarray == NULL && newasize > 0)) { /* allocation failed? */ ------------------ | | 688| 9|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 12|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 9] | | | | | Branch (676:46): [True: 3, False: 6] | | | | | Branch (676:46): [True: 0, False: 3] | | | | ------------------ | | ------------------ ------------------ 575| 0| freehash(L, &newt); /* release new hash part */ 576| 0| luaM_error(L); /* raise error (with array unchanged) */ ------------------ | | 17| 0|#define luaM_error(L) luaD_throw(L, LUA_ERRMEM) | | ------------------ | | | | 53| 0|#define LUA_ERRMEM 4 | | ------------------ ------------------ 577| 0| } 578| | /* allocation ok; initialize new part of the array */ 579| 9| exchangehashpart(t, &newt); /* 't' has the new hash ('newt' has the old) */ 580| 9| t->array = newarray; /* set new array part */ 581| 9| t->alimit = newasize; 582| 21| for (i = oldasize; i < newasize; i++) /* clear new slice of the array */ ------------------ | Branch (582:22): [True: 12, False: 9] ------------------ 583| 12| setempty(&t->array[i]); ------------------ | | 225| 12|#define setempty(v) settt_(v, LUA_VEMPTY) | | ------------------ | | | | 114| 21|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 584| | /* re-insert elements from old hash part into new parts */ 585| 9| reinsert(L, &newt, t); /* 'newt' now has the old hash */ 586| 9| freehash(L, &newt); /* free old hash part */ 587| 9|} luaH_new: 626| 18|Table *luaH_new (lua_State *L) { 627| 18| GCObject *o = luaC_newobj(L, LUA_VTABLE, sizeof(Table)); ------------------ | | 680| 18|#define LUA_VTABLE makevariant(LUA_TTABLE, 0) | | ------------------ | | | | 42| 18|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ 628| 18| Table *t = gco2t(o); ------------------ | | 380| 18|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 115| 18|#define check_exp(c,e) (e) | | ------------------ ------------------ 629| 18| t->metatable = NULL; 630| 18| t->flags = cast_byte(maskflags); /* table has no metamethod fields */ ------------------ | | 143| 18|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 18|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 631| 18| t->array = NULL; 632| 18| t->alimit = 0; 633| 18| setnodevector(L, t, 0); 634| 18| return t; 635| 18|} luaH_free: 638| 18|void luaH_free (lua_State *L, Table *t) { 639| 18| freehash(L, t); 640| 18| luaM_freearray(L, t->array, luaH_realasize(t)); ------------------ | | 57| 18|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 641| 18| luaM_free(L, t); ------------------ | | 56| 18|#define luaM_free(L, b) luaM_free_(L, (b), sizeof(*(b))) ------------------ 642| 18|} luaH_newkey: 665| 6|void luaH_newkey (lua_State *L, Table *t, const TValue *key, TValue *value) { 666| 6| Node *mp; 667| 6| TValue aux; 668| 6| if (l_unlikely(ttisnil(key))) ------------------ | | 688| 6|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 6|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 6] | | | | ------------------ | | ------------------ ------------------ 669| 0| luaG_runerror(L, "table index is nil"); 670| 6| else if (ttisfloat(key)) { ------------------ | | 327| 6|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | ------------------ | | | | 91| 6|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 6|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 0, False: 6] | | | | ------------------ | | ------------------ ------------------ 671| 0| lua_Number f = fltvalue(key); ------------------ | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 672| 0| lua_Integer k; 673| 0| if (luaV_flttointeger(f, &k, F2Ieq)) { /* does key fit in an integer? */ ------------------ | Branch (673:9): [True: 0, False: 0] ------------------ 674| 0| setivalue(&aux, k); ------------------ | | 345| 0| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 0|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 675| 0| key = &aux; /* insert it as an integer */ 676| 0| } 677| 0| else if (l_unlikely(luai_numisnan(f))) ------------------ | | 688| 0|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 678| 0| luaG_runerror(L, "table index is NaN"); 679| 0| } 680| 6| if (ttisnil(value)) ------------------ | | 193| 6|#define ttisnil(v) checktype((v), LUA_TNIL) | | ------------------ | | | | 92| 6|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 6|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 6|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 0, False: 6] | | | | ------------------ | | ------------------ ------------------ 681| 0| return; /* do not insert nil values */ 682| 6| mp = mainpositionTV(t, key); 683| 6| if (!isempty(gval(mp)) || isdummy(t)) { /* main position is taken? */ ------------------ | | 217| 6|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 6|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 12|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 6|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 6|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (!isempty(gval(mp)) || isdummy(t)) { /* main position is taken? */ ------------------ | | 27| 6|#define isdummy(t) ((t)->lastfree == NULL) | | ------------------ | | | Branch (27:21): [True: 3, False: 3] | | ------------------ ------------------ | Branch (683:7): [True: 0, False: 6] ------------------ 684| 3| Node *othern; 685| 3| Node *f = getfreepos(t); /* get a free place */ 686| 3| if (f == NULL) { /* cannot find a free place? */ ------------------ | Branch (686:9): [True: 3, False: 0] ------------------ 687| 3| rehash(L, t, key); /* grow table */ 688| | /* whatever called 'newkey' takes care of TM cache */ 689| 3| luaH_set(L, t, key, value); /* insert key into grown table */ 690| 3| return; 691| 3| } 692| 0| lua_assert(!isdummy(t)); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 693| 0| othern = mainpositionfromnode(t, mp); 694| 0| if (othern != mp) { /* is colliding node out of its main position? */ ------------------ | Branch (694:9): [True: 0, False: 0] ------------------ 695| | /* yes; move colliding node into free position */ 696| 0| while (othern + gnext(othern) != mp) /* find previous */ ------------------ | | 15| 0|#define gnext(n) ((n)->u.next) ------------------ | Branch (696:14): [True: 0, False: 0] ------------------ 697| 0| othern += gnext(othern); ------------------ | | 15| 0|#define gnext(n) ((n)->u.next) ------------------ 698| 0| gnext(othern) = cast_int(f - othern); /* rechain to point to 'f' */ ------------------ | | 15| 0|#define gnext(n) ((n)->u.next) ------------------ gnext(othern) = cast_int(f - othern); /* rechain to point to 'f' */ ------------------ | | 141| 0|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 699| 0| *f = *mp; /* copy colliding node into free pos. (mp->next also goes) */ 700| 0| if (gnext(mp) != 0) { ------------------ | | 15| 0|#define gnext(n) ((n)->u.next) ------------------ | Branch (700:11): [True: 0, False: 0] ------------------ 701| 0| gnext(f) += cast_int(mp - f); /* correct 'next' */ ------------------ | | 15| 0|#define gnext(n) ((n)->u.next) ------------------ gnext(f) += cast_int(mp - f); /* correct 'next' */ ------------------ | | 141| 0|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 702| 0| gnext(mp) = 0; /* now 'mp' is free */ ------------------ | | 15| 0|#define gnext(n) ((n)->u.next) ------------------ 703| 0| } 704| 0| setempty(gval(mp)); ------------------ | | 225| 0|#define setempty(v) settt_(v, LUA_VEMPTY) | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 705| 0| } 706| 0| else { /* colliding node is in its own main position */ 707| | /* new node will go into free position */ 708| 0| if (gnext(mp) != 0) ------------------ | | 15| 0|#define gnext(n) ((n)->u.next) ------------------ | Branch (708:11): [True: 0, False: 0] ------------------ 709| 0| gnext(f) = cast_int((mp + gnext(mp)) - f); /* chain new position */ ------------------ | | 15| 0|#define gnext(n) ((n)->u.next) ------------------ gnext(f) = cast_int((mp + gnext(mp)) - f); /* chain new position */ ------------------ | | 141| 0|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 710| 0| else lua_assert(gnext(f) == 0); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 711| 0| gnext(mp) = cast_int(f - mp); ------------------ | | 15| 0|#define gnext(n) ((n)->u.next) ------------------ gnext(mp) = cast_int(f - mp); ------------------ | | 141| 0|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 712| 0| mp = f; 713| 0| } 714| 0| } 715| 3| setnodekey(L, mp, key); ------------------ | | 714| 3| { Node *n_=(node); const TValue *io_=(obj); \ | | 715| 3| n_->u.key_val = io_->value_; n_->u.key_tt = io_->tt_; \ | | 716| 3| checkliveness(L,io_); } | | ------------------ | | | | 107| 3| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 3|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 3| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 716| 3| luaC_barrierback(L, obj2gco(t), key); ------------------ | | 185| 3|#define luaC_barrierback(L,p,v) ( \ | | 186| 3| iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 300| 3|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 77| 3|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 298| 3|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (300:26): [True: 3, False: 0] | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 182| 3|#define luaC_objbarrierback(L,p,o) ( \ | | | | 183| 3| (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | ------------------ | | | | | | 88| 3|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | ------------------ | | | | | | | | 67| 3|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | ------------------ | | | | | | | | | | 62| 6|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (62:24): [True: 0, False: 3] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | ------------------ | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | ------------------ | | | | | | 138| 3|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 3|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 138| 0|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 717| 3| lua_assert(isempty(gval(mp))); ------------------ | | 114| 3|#define lua_assert(c) ((void)0) ------------------ 718| 3| setobj2t(L, gval(mp), value); ------------------ | | 137| 3|#define setobj2t setobj | | ------------------ | | | | 119| 3| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 3| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 3|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 3| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 3| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 3|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 3| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 3|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 719| 3|} luaH_getshortstr: 758| 6|const TValue *luaH_getshortstr (Table *t, TString *key) { 759| 6| Node *n = hashstr(t, key); ------------------ | | 84| 6|#define hashstr(t,str) hashpow2(t, (str)->hash) | | ------------------ | | | | 75| 6|#define hashpow2(t,n) (gnode(t, lmod((n), sizenode(t)))) | | | | ------------------ | | | | | | 13| 6|#define gnode(t,i) (&(t)->node[i]) | | | | ------------------ | | ------------------ ------------------ 760| 6| lua_assert(key->tt == LUA_VSHRSTR); ------------------ | | 114| 6|#define lua_assert(c) ((void)0) ------------------ 761| 6| for (;;) { /* check whether 'key' is somewhere in the chain */ 762| 6| if (keyisshrstr(n) && eqshrstr(keystrval(n), key)) ------------------ | | 761| 12|#define keyisshrstr(node) (keytt(node) == ctb(LUA_VSHRSTR)) | | ------------------ | | | | 755| 6|#define keytt(node) ((node)->u.key_tt) | | ------------------ | | #define keyisshrstr(node) (keytt(node) == ctb(LUA_VSHRSTR)) | | ------------------ | | | | 303| 6|#define ctb(t) ((t) | BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 298| 6|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | ------------------ | | | Branch (761:27): [True: 2, False: 4] | | ------------------ ------------------ if (keyisshrstr(n) && eqshrstr(keystrval(n), key)) ------------------ | | 41| 2|#define eqshrstr(a,b) check_exp((a)->tt == LUA_VSHRSTR, (a) == (b)) | | ------------------ | | | | 115| 2|#define check_exp(c,e) (e) | | | | ------------------ | | | | | Branch (115:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ ------------------ 763| 2| return gval(n); /* that's it */ ------------------ | | 14| 2|#define gval(n) (&(n)->i_val) ------------------ 764| 4| else { 765| 4| int nx = gnext(n); ------------------ | | 15| 4|#define gnext(n) ((n)->u.next) ------------------ 766| 4| if (nx == 0) ------------------ | Branch (766:11): [True: 4, False: 0] ------------------ 767| 4| return &absentkey; /* not found */ 768| 0| n += nx; 769| 0| } 770| 6| } 771| 6|} luaH_getstr: 774| 3|const TValue *luaH_getstr (Table *t, TString *key) { 775| 3| if (key->tt == LUA_VSHRSTR) ------------------ | | 360| 3|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 3|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (775:7): [True: 2, False: 1] ------------------ 776| 2| return luaH_getshortstr(t, key); 777| 1| else { /* for long strings, use generic case */ 778| 1| TValue ko; 779| 1| setsvalue(cast(lua_State *, NULL), &ko, key); ------------------ | | 372| 1| { TValue *io = (obj); TString *x_ = (x); \ | | 373| 1| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 72| 1|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 390| 1|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 1|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 114| 1|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 374| 1| checkliveness(L,io); } | | ------------------ | | | | 107| 1| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 1|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 1| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 780| 1| return getgeneric(t, &ko, 0); 781| 1| } 782| 3|} luaH_get: 788| 6|const TValue *luaH_get (Table *t, const TValue *key) { 789| 6| switch (ttypetag(key)) { ------------------ | | 84| 6|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 6|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ 790| 4| case LUA_VSHRSTR: return luaH_getshortstr(t, tsvalue(key)); ------------------ | | 360| 4|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 4|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VSHRSTR: return luaH_getshortstr(t, tsvalue(key)); ------------------ | | 369| 4|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 115| 4|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (790:5): [True: 4, False: 2] ------------------ 791| 0| case LUA_VNUMINT: return luaH_getint(t, ivalue(key)); ------------------ | | 323| 0|#define LUA_VNUMINT makevariant(LUA_TNUMBER, 0) /* integer numbers */ | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VNUMINT: return luaH_getint(t, ivalue(key)); ------------------ | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (791:5): [True: 0, False: 6] ------------------ 792| 0| case LUA_VNIL: return &absentkey; ------------------ | | 183| 0|#define LUA_VNIL makevariant(LUA_TNIL, 0) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (792:5): [True: 0, False: 6] ------------------ 793| 0| case LUA_VNUMFLT: { ------------------ | | 324| 0|#define LUA_VNUMFLT makevariant(LUA_TNUMBER, 1) /* float numbers */ | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (793:5): [True: 0, False: 6] ------------------ 794| 0| lua_Integer k; 795| 0| if (luaV_flttointeger(fltvalue(key), &k, F2Ieq)) /* integral index? */ ------------------ | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (795:11): [True: 0, False: 0] ------------------ 796| 0| return luaH_getint(t, k); /* use specialized version */ 797| | /* else... */ 798| 0| } /* FALLTHROUGH */ 799| 2| default: ------------------ | Branch (799:5): [True: 2, False: 4] ------------------ 800| 2| return getgeneric(t, key, 0); 801| 6| } 802| 6|} luaH_finishset: 812| 9| const TValue *slot, TValue *value) { 813| 9| if (isabstkey(slot)) ------------------ | | 203| 9|#define isabstkey(v) checktag((v), LUA_VABSTKEY) | | ------------------ | | | | 91| 9|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 9|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 6, False: 3] | | | | ------------------ | | ------------------ ------------------ 814| 6| luaH_newkey(L, t, key, value); 815| 3| else 816| 3| setobj2t(L, cast(TValue *, slot), value); ------------------ | | 137| 3|#define setobj2t setobj | | ------------------ | | | | 119| 3| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 3| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 3|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 3| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 3| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 3|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 3| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 3|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 817| 9|} luaH_set: 824| 3|void luaH_set (lua_State *L, Table *t, const TValue *key, TValue *value) { 825| 3| const TValue *slot = luaH_get(t, key); 826| 3| luaH_finishset(L, t, key, slot, value); 827| 3|} ltable.c:setlimittosize: 283| 12|static unsigned int setlimittosize (Table *t) { 284| 12| t->alimit = luaH_realasize(t); 285| 12| setrealasize(t); ------------------ | | 735| 12|#define setrealasize(t) ((t)->flags &= cast_byte(~BITRAS)) | | ------------------ | | | | 143| 12|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 136| 12|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 286| 12| return t->alimit; 287| 12|} ltable.c:setnodevector: 480| 27|static void setnodevector (lua_State *L, Table *t, unsigned int size) { 481| 27| if (size == 0) { /* no elements to hash part? */ ------------------ | Branch (481:7): [True: 24, False: 3] ------------------ 482| 24| t->node = cast(Node *, dummynode); /* use common 'dummynode' */ ------------------ | | 136| 24|#define cast(t, exp) ((t)(exp)) ------------------ 483| 24| t->lsizenode = 0; 484| 24| t->lastfree = NULL; /* signal that it is using dummy node */ 485| 24| } 486| 3| else { 487| 3| int i; 488| 3| int lsize = luaO_ceillog2(size); 489| 3| if (lsize > MAXHBITS || (1u << lsize) > MAXHSIZE) ------------------ | | 60| 6|#define MAXHBITS (MAXABITS - 1) | | ------------------ | | | | 46| 3|#define MAXABITS cast_int(sizeof(int) * CHAR_BIT - 1) | | | | ------------------ | | | | | | 141| 3|#define cast_int(i) cast(int, (i)) | | | | | | ------------------ | | | | | | | | 136| 3|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (lsize > MAXHBITS || (1u << lsize) > MAXHSIZE) ------------------ | | 68| 3|#define MAXHSIZE luaM_limitN(1u << MAXHBITS, Node) | | ------------------ | | | | 45| 3| ((cast_sizet(n) <= MAX_SIZET/sizeof(t)) ? (n) : \ | | | | ------------------ | | | | | | 147| 3|#define cast_sizet(i) cast(size_t, (i)) | | | | | | ------------------ | | | | | | | | 136| 3|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | ((cast_sizet(n) <= MAX_SIZET/sizeof(t)) ? (n) : \ | | | | ------------------ | | | | | | 41| 3|#define MAX_SIZET ((size_t)(~(size_t)0)) | | | | ------------------ | | | | | Branch (45:4): [Folded - Ignored] | | | | ------------------ | | | | 46| 3| cast_uint((MAX_SIZET/sizeof(t)))) | | | | ------------------ | | | | | | 142| 0|#define cast_uint(i) cast(unsigned int, (i)) | | | | | | ------------------ | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (489:9): [True: 0, False: 3] | Branch (489:29): [True: 0, False: 3] ------------------ 490| 0| luaG_runerror(L, "table overflow"); 491| 3| size = twoto(lsize); ------------------ | | 792| 3|#define twoto(x) (1<<(x)) ------------------ 492| 3| t->node = luaM_newvector(L, size, Node); ------------------ | | 60| 3|#define luaM_newvector(L,n,t) cast(t*, luaM_malloc_(L, (n)*sizeof(t), 0)) | | ------------------ | | | | 136| 3|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 493| 6| for (i = 0; i < cast_int(size); i++) { ------------------ | | 141| 6|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 6|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (493:17): [True: 3, False: 3] ------------------ 494| 3| Node *n = gnode(t, i); ------------------ | | 13| 3|#define gnode(t,i) (&(t)->node[i]) ------------------ 495| 3| gnext(n) = 0; ------------------ | | 15| 3|#define gnext(n) ((n)->u.next) ------------------ 496| 3| setnilkey(n); ------------------ | | 764| 3|#define setnilkey(node) (keytt(node) = LUA_TNIL) | | ------------------ | | | | 755| 3|#define keytt(node) ((node)->u.key_tt) | | ------------------ | | #define setnilkey(node) (keytt(node) = LUA_TNIL) | | ------------------ | | | | 65| 3|#define LUA_TNIL 0 | | ------------------ ------------------ 497| 3| setempty(gval(n)); ------------------ | | 225| 3|#define setempty(v) settt_(v, LUA_VEMPTY) | | ------------------ | | | | 114| 3|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 498| 3| } 499| 3| t->lsizenode = cast_byte(lsize); ------------------ | | 143| 3|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 3|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 500| 3| t->lastfree = gnode(t, size); /* all positions are free */ ------------------ | | 13| 3|#define gnode(t,i) (&(t)->node[i]) ------------------ 501| 3| } 502| 27|} ltable.c:exchangehashpart: 527| 9|static void exchangehashpart (Table *t1, Table *t2) { 528| 9| lu_byte lsizenode = t1->lsizenode; 529| 9| Node *node = t1->node; 530| 9| Node *lastfree = t1->lastfree; 531| 9| t1->lsizenode = t2->lsizenode; 532| 9| t1->node = t2->node; 533| 9| t1->lastfree = t2->lastfree; 534| 9| t2->lsizenode = lsizenode; 535| 9| t2->node = node; 536| 9| t2->lastfree = lastfree; 537| 9|} ltable.c:freehash: 371| 27|static void freehash (lua_State *L, Table *t) { 372| 27| if (!isdummy(t)) ------------------ | | 27| 27|#define isdummy(t) ((t)->lastfree == NULL) ------------------ | Branch (372:7): [True: 3, False: 24] ------------------ 373| 3| luaM_freearray(L, t->node, cast_sizet(sizenode(t))); ------------------ | | 57| 3|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 374| 27|} ltable.c:reinsert: 508| 9|static void reinsert (lua_State *L, Table *ot, Table *t) { 509| 9| int j; 510| 9| int size = sizenode(ot); ------------------ | | 793| 9|#define sizenode(t) (twoto((t)->lsizenode)) | | ------------------ | | | | 792| 9|#define twoto(x) (1<<(x)) | | ------------------ ------------------ 511| 18| for (j = 0; j < size; j++) { ------------------ | Branch (511:15): [True: 9, False: 9] ------------------ 512| 9| Node *old = gnode(ot, j); ------------------ | | 13| 9|#define gnode(t,i) (&(t)->node[i]) ------------------ 513| 9| if (!isempty(gval(old))) { ------------------ | | 217| 9|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 9|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 9|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 9|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 9|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (513:9): [True: 0, False: 9] ------------------ 514| | /* doesn't need barrier/invalidate cache, as entry was 515| | already present in the table */ 516| 0| TValue k; 517| 0| getnodekey(L, &k, old); ------------------ | | 721| 0| { TValue *io_=(obj); const Node *n_=(node); \ | | 722| 0| io_->value_ = n_->u.key_val; io_->tt_ = n_->u.key_tt; \ | | 723| 0| checkliveness(L,io_); } | | ------------------ | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 518| 0| luaH_set(L, t, &k, gval(old)); ------------------ | | 14| 0|#define gval(n) (&(n)->i_val) ------------------ 519| 0| } 520| 9| } 521| 9|} ltable.c:mainpositionTV: 151| 9|static Node *mainpositionTV (const Table *t, const TValue *key) { 152| 9| switch (ttypetag(key)) { ------------------ | | 84| 9|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 9|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ 153| 0| case LUA_VNUMINT: { ------------------ | | 323| 0|#define LUA_VNUMINT makevariant(LUA_TNUMBER, 0) /* integer numbers */ | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (153:5): [True: 0, False: 9] ------------------ 154| 0| lua_Integer i = ivalue(key); ------------------ | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 155| 0| return hashint(t, i); 156| 0| } 157| 0| case LUA_VNUMFLT: { ------------------ | | 324| 0|#define LUA_VNUMFLT makevariant(LUA_TNUMBER, 1) /* float numbers */ | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (157:5): [True: 0, False: 9] ------------------ 158| 0| lua_Number n = fltvalue(key); ------------------ | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 159| 0| return hashmod(t, l_hashfloat(n)); ------------------ | | 81| 0|#define hashmod(t,n) (gnode(t, ((n) % ((sizenode(t)-1)|1)))) | | ------------------ | | | | 13| 0|#define gnode(t,i) (&(t)->node[i]) | | ------------------ ------------------ 160| 0| } 161| 4| case LUA_VSHRSTR: { ------------------ | | 360| 4|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 4|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (161:5): [True: 4, False: 5] ------------------ 162| 4| TString *ts = tsvalue(key); ------------------ | | 369| 4|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 115| 4|#define check_exp(c,e) (e) | | ------------------ ------------------ 163| 4| return hashstr(t, ts); ------------------ | | 84| 4|#define hashstr(t,str) hashpow2(t, (str)->hash) | | ------------------ | | | | 75| 4|#define hashpow2(t,n) (gnode(t, lmod((n), sizenode(t)))) | | | | ------------------ | | | | | | 13| 4|#define gnode(t,i) (&(t)->node[i]) | | | | ------------------ | | ------------------ ------------------ 164| 0| } 165| 5| case LUA_VLNGSTR: { ------------------ | | 361| 5|#define LUA_VLNGSTR makevariant(LUA_TSTRING, 1) /* long strings */ | | ------------------ | | | | 42| 5|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (165:5): [True: 5, False: 4] ------------------ 166| 5| TString *ts = tsvalue(key); ------------------ | | 369| 5|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 115| 5|#define check_exp(c,e) (e) | | ------------------ ------------------ 167| 5| return hashpow2(t, luaS_hashlongstr(ts)); ------------------ | | 75| 5|#define hashpow2(t,n) (gnode(t, lmod((n), sizenode(t)))) | | ------------------ | | | | 13| 5|#define gnode(t,i) (&(t)->node[i]) | | ------------------ ------------------ 168| 0| } 169| 0| case LUA_VFALSE: ------------------ | | 239| 0|#define LUA_VFALSE makevariant(LUA_TBOOLEAN, 0) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (169:5): [True: 0, False: 9] ------------------ 170| 0| return hashboolean(t, 0); ------------------ | | 85| 0|#define hashboolean(t,p) hashpow2(t, p) | | ------------------ | | | | 75| 0|#define hashpow2(t,n) (gnode(t, lmod((n), sizenode(t)))) | | | | ------------------ | | | | | | 13| 0|#define gnode(t,i) (&(t)->node[i]) | | | | ------------------ | | ------------------ ------------------ 171| 0| case LUA_VTRUE: ------------------ | | 240| 0|#define LUA_VTRUE makevariant(LUA_TBOOLEAN, 1) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (171:5): [True: 0, False: 9] ------------------ 172| 0| return hashboolean(t, 1); ------------------ | | 85| 0|#define hashboolean(t,p) hashpow2(t, p) | | ------------------ | | | | 75| 0|#define hashpow2(t,n) (gnode(t, lmod((n), sizenode(t)))) | | | | ------------------ | | | | | | 13| 0|#define gnode(t,i) (&(t)->node[i]) | | | | ------------------ | | ------------------ ------------------ 173| 0| case LUA_VLIGHTUSERDATA: { ------------------ | | 429| 0|#define LUA_VLIGHTUSERDATA makevariant(LUA_TLIGHTUSERDATA, 0) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (173:5): [True: 0, False: 9] ------------------ 174| 0| void *p = pvalue(key); ------------------ | | 436| 0|#define pvalue(o) check_exp(ttislightuserdata(o), val_(o).p) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 175| 0| return hashpointer(t, p); ------------------ | | 88| 0|#define hashpointer(t,p) hashmod(t, point2uint(p)) | | ------------------ | | | | 81| 0|#define hashmod(t,n) (gnode(t, ((n) % ((sizenode(t)-1)|1)))) | | | | ------------------ | | | | | | 13| 0|#define gnode(t,i) (&(t)->node[i]) | | | | ------------------ | | ------------------ ------------------ 176| 0| } 177| 0| case LUA_VLCF: { ------------------ | | 591| 0|#define LUA_VLCF makevariant(LUA_TFUNCTION, 1) /* light C function */ | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (177:5): [True: 0, False: 9] ------------------ 178| 0| lua_CFunction f = fvalue(key); ------------------ | | 605| 0|#define fvalue(o) check_exp(ttislcf(o), val_(o).f) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 179| 0| return hashpointer(t, f); ------------------ | | 88| 0|#define hashpointer(t,p) hashmod(t, point2uint(p)) | | ------------------ | | | | 81| 0|#define hashmod(t,n) (gnode(t, ((n) % ((sizenode(t)-1)|1)))) | | | | ------------------ | | | | | | 13| 0|#define gnode(t,i) (&(t)->node[i]) | | | | ------------------ | | ------------------ ------------------ 180| 0| } 181| 0| default: { ------------------ | Branch (181:5): [True: 0, False: 9] ------------------ 182| 0| GCObject *o = gcvalue(key); ------------------ | | 305| 0|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 183| 0| return hashpointer(t, o); ------------------ | | 88| 0|#define hashpointer(t,p) hashmod(t, point2uint(p)) | | ------------------ | | | | 81| 0|#define hashmod(t,n) (gnode(t, ((n) % ((sizenode(t)-1)|1)))) | | | | ------------------ | | | | | | 13| 0|#define gnode(t,i) (&(t)->node[i]) | | | | ------------------ | | ------------------ ------------------ 184| 0| } 185| 9| } 186| 9|} ltable.c:getfreepos: 645| 3|static Node *getfreepos (Table *t) { 646| 3| if (!isdummy(t)) { ------------------ | | 27| 3|#define isdummy(t) ((t)->lastfree == NULL) ------------------ | Branch (646:7): [True: 0, False: 3] ------------------ 647| 0| while (t->lastfree > t->node) { ------------------ | Branch (647:12): [True: 0, False: 0] ------------------ 648| 0| t->lastfree--; 649| 0| if (keyisnil(t->lastfree)) ------------------ | | 758| 0|#define keyisnil(node) (keytt(node) == LUA_TNIL) | | ------------------ | | | | 755| 0|#define keytt(node) ((node)->u.key_tt) | | ------------------ | | #define keyisnil(node) (keytt(node) == LUA_TNIL) | | ------------------ | | | | 65| 0|#define LUA_TNIL 0 | | ------------------ | | | Branch (758:25): [True: 0, False: 0] | | ------------------ ------------------ 650| 0| return t->lastfree; 651| 0| } 652| 0| } 653| 3| return NULL; /* could not find a free place */ 654| 3|} ltable.c:rehash: 598| 3|static void rehash (lua_State *L, Table *t, const TValue *ek) { 599| 3| unsigned int asize; /* optimal size for array part */ 600| 3| unsigned int na; /* number of keys in the array part */ 601| 3| unsigned int nums[MAXABITS + 1]; 602| 3| int i; 603| 3| int totaluse; 604| 99| for (i = 0; i <= MAXABITS; i++) nums[i] = 0; /* reset counts */ ------------------ | | 46| 99|#define MAXABITS cast_int(sizeof(int) * CHAR_BIT - 1) | | ------------------ | | | | 141| 99|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 99|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ | Branch (604:15): [True: 96, False: 3] ------------------ 605| 3| setlimittosize(t); 606| 3| na = numusearray(t, nums); /* count keys in array part */ 607| 3| totaluse = na; /* all those keys are integer keys */ 608| 3| totaluse += numusehash(t, nums, &na); /* count keys in hash part */ 609| | /* count extra key */ 610| 3| if (ttisinteger(ek)) ------------------ | | 328| 3|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 3|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 3|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 0, False: 3] | | | | ------------------ | | ------------------ ------------------ 611| 0| na += countint(ivalue(ek), nums); ------------------ | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 612| 3| totaluse++; 613| | /* compute new size for array part */ 614| 3| asize = computesizes(nums, &na); 615| | /* resize the table to new computed sizes */ 616| 3| luaH_resize(L, t, asize, totaluse - na); 617| 3|} ltable.c:numusearray: 429| 3|static unsigned int numusearray (const Table *t, unsigned int *nums) { 430| 3| int lg; 431| 3| unsigned int ttlg; /* 2^lg */ 432| 3| unsigned int ause = 0; /* summation of 'nums' */ 433| 3| unsigned int i = 1; /* count to traverse all array keys */ 434| 3| unsigned int asize = limitasasize(t); /* real array size */ ------------------ | | 290| 3|#define limitasasize(t) check_exp(isrealasize(t), t->alimit) | | ------------------ | | | | 115| 3|#define check_exp(c,e) (e) | | ------------------ ------------------ 435| | /* traverse each slice */ 436| 3| for (lg = 0, ttlg = 1; lg <= MAXABITS; lg++, ttlg *= 2) { ------------------ | | 46| 3|#define MAXABITS cast_int(sizeof(int) * CHAR_BIT - 1) | | ------------------ | | | | 141| 3|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 3|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ | Branch (436:26): [True: 3, False: 0] ------------------ 437| 3| unsigned int lc = 0; /* counter */ 438| 3| unsigned int lim = ttlg; 439| 3| if (lim > asize) { ------------------ | Branch (439:9): [True: 3, False: 0] ------------------ 440| 3| lim = asize; /* adjust upper limit */ 441| 3| if (i > lim) ------------------ | Branch (441:11): [True: 3, False: 0] ------------------ 442| 3| break; /* no more elements to count */ 443| 3| } 444| | /* count elements in range (2^(lg - 1), 2^lg] */ 445| 0| for (; i <= lim; i++) { ------------------ | Branch (445:12): [True: 0, False: 0] ------------------ 446| 0| if (!isempty(&t->array[i-1])) ------------------ | | 217| 0|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 0|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 0|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 0|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 0|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (446:11): [True: 0, False: 0] ------------------ 447| 0| lc++; 448| 0| } 449| 0| nums[lg] += lc; 450| 0| ause += lc; 451| 0| } 452| 3| return ause; 453| 3|} ltable.c:numusehash: 456| 3|static int numusehash (const Table *t, unsigned int *nums, unsigned int *pna) { 457| 3| int totaluse = 0; /* total number of elements */ 458| 3| int ause = 0; /* elements added to 'nums' (can go to array part) */ 459| 3| int i = sizenode(t); ------------------ | | 793| 3|#define sizenode(t) (twoto((t)->lsizenode)) | | ------------------ | | | | 792| 3|#define twoto(x) (1<<(x)) | | ------------------ ------------------ 460| 6| while (i--) { ------------------ | Branch (460:10): [True: 3, False: 3] ------------------ 461| 3| Node *n = &t->node[i]; 462| 3| if (!isempty(gval(n))) { ------------------ | | 217| 3|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 3|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 3|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 3|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 3|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (462:9): [True: 0, False: 3] ------------------ 463| 0| if (keyisinteger(n)) ------------------ | | 759| 0|#define keyisinteger(node) (keytt(node) == LUA_VNUMINT) | | ------------------ | | | | 755| 0|#define keytt(node) ((node)->u.key_tt) | | ------------------ | | #define keyisinteger(node) (keytt(node) == LUA_VNUMINT) | | ------------------ | | | | 323| 0|#define LUA_VNUMINT makevariant(LUA_TNUMBER, 0) /* integer numbers */ | | | | ------------------ | | | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | ------------------ | | ------------------ | | | Branch (759:28): [True: 0, False: 0] | | ------------------ ------------------ 464| 0| ause += countint(keyival(n), nums); ------------------ | | 760| 0|#define keyival(node) (keyval(node).i) | | ------------------ | | | | 756| 0|#define keyval(node) ((node)->u.key_val) | | ------------------ ------------------ 465| 0| totaluse++; 466| 0| } 467| 3| } 468| 3| *pna += ause; 469| 3| return totaluse; 470| 3|} ltable.c:computesizes: 391| 3|static unsigned int computesizes (unsigned int nums[], unsigned int *pna) { 392| 3| int i; 393| 3| unsigned int twotoi; /* 2^i (candidate for optimal size) */ 394| 3| unsigned int a = 0; /* number of elements smaller than 2^i */ 395| 3| unsigned int na = 0; /* number of elements to go to array part */ 396| 3| unsigned int optimal = 0; /* optimal size for array part */ 397| | /* loop while keys can fill more than half of total size */ 398| 3| for (i = 0, twotoi = 1; 399| 3| twotoi > 0 && *pna > twotoi / 2; ------------------ | Branch (399:8): [True: 3, False: 0] | Branch (399:22): [True: 0, False: 3] ------------------ 400| 3| i++, twotoi *= 2) { 401| 0| a += nums[i]; 402| 0| if (a > twotoi/2) { /* more than half elements present? */ ------------------ | Branch (402:9): [True: 0, False: 0] ------------------ 403| 0| optimal = twotoi; /* optimal size (till now) */ 404| 0| na = a; /* all elements up to 'optimal' will go to array part */ 405| 0| } 406| 0| } 407| 3| lua_assert((optimal == 0 || optimal / 2 < na) && na <= optimal); ------------------ | | 114| 3|#define lua_assert(c) ((void)0) ------------------ 408| 3| *pna = na; 409| 3| return optimal; 410| 3|} ltable.c:getgeneric: 299| 3|static const TValue *getgeneric (Table *t, const TValue *key, int deadok) { 300| 3| Node *n = mainpositionTV(t, key); 301| 3| for (;;) { /* check whether 'key' is somewhere in the chain */ 302| 3| if (equalkey(key, n, deadok)) ------------------ | Branch (302:9): [True: 1, False: 2] ------------------ 303| 1| return gval(n); /* that's it */ ------------------ | | 14| 1|#define gval(n) (&(n)->i_val) ------------------ 304| 2| else { 305| 2| int nx = gnext(n); ------------------ | | 15| 2|#define gnext(n) ((n)->u.next) ------------------ 306| 2| if (nx == 0) ------------------ | Branch (306:11): [True: 2, False: 0] ------------------ 307| 2| return &absentkey; /* not found */ 308| 0| n += nx; 309| 0| } 310| 3| } 311| 3|} ltable.c:equalkey: 216| 3|static int equalkey (const TValue *k1, const Node *n2, int deadok) { 217| 3| if ((rawtt(k1) != keytt(n2)) && /* not the same variants? */ ------------------ | | 77| 3|#define rawtt(o) ((o)->tt_) ------------------ if ((rawtt(k1) != keytt(n2)) && /* not the same variants? */ ------------------ | | 755| 3|#define keytt(node) ((node)->u.key_tt) ------------------ | Branch (217:7): [True: 2, False: 1] ------------------ 218| 3| !(deadok && keyisdead(n2) && iscollectable(k1))) ------------------ | | 779| 2|#define keyisdead(node) (keytt(node) == LUA_TDEADKEY) | | ------------------ | | | | 755| 0|#define keytt(node) ((node)->u.key_tt) | | ------------------ | | #define keyisdead(node) (keytt(node) == LUA_TDEADKEY) | | ------------------ | | | | 24| 0|#define LUA_TDEADKEY (LUA_NUMTYPES+2) /* removed keys in tables */ | | | | ------------------ | | | | | | 75| 0|#define LUA_NUMTYPES 9 | | | | ------------------ | | ------------------ | | | Branch (779:26): [True: 0, False: 0] | | ------------------ ------------------ !(deadok && keyisdead(n2) && iscollectable(k1))) ------------------ | | 300| 0|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | ------------------ | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | ------------------ | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | ------------------ | | | | 298| 0|#define BIT_ISCOLLECTABLE (1 << 6) | | ------------------ | | | Branch (300:26): [True: 0, False: 0] | | ------------------ ------------------ | Branch (218:10): [True: 0, False: 2] ------------------ 219| 2| return 0; /* cannot be same key */ 220| 1| switch (keytt(n2)) { ------------------ | | 755| 1|#define keytt(node) ((node)->u.key_tt) ------------------ 221| 0| case LUA_VNIL: case LUA_VFALSE: case LUA_VTRUE: ------------------ | | 183| 0|#define LUA_VNIL makevariant(LUA_TNIL, 0) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VNIL: case LUA_VFALSE: case LUA_VTRUE: ------------------ | | 239| 0|#define LUA_VFALSE makevariant(LUA_TBOOLEAN, 0) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VNIL: case LUA_VFALSE: case LUA_VTRUE: ------------------ | | 240| 0|#define LUA_VTRUE makevariant(LUA_TBOOLEAN, 1) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (221:5): [True: 0, False: 1] | Branch (221:20): [True: 0, False: 1] | Branch (221:37): [True: 0, False: 1] ------------------ 222| 0| return 1; 223| 0| case LUA_VNUMINT: ------------------ | | 323| 0|#define LUA_VNUMINT makevariant(LUA_TNUMBER, 0) /* integer numbers */ | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (223:5): [True: 0, False: 1] ------------------ 224| 0| return (ivalue(k1) == keyival(n2)); ------------------ | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ return (ivalue(k1) == keyival(n2)); ------------------ | | 760| 0|#define keyival(node) (keyval(node).i) | | ------------------ | | | | 756| 0|#define keyval(node) ((node)->u.key_val) | | ------------------ ------------------ 225| 0| case LUA_VNUMFLT: ------------------ | | 324| 0|#define LUA_VNUMFLT makevariant(LUA_TNUMBER, 1) /* float numbers */ | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (225:5): [True: 0, False: 1] ------------------ 226| 0| return luai_numeq(fltvalue(k1), fltvalueraw(keyval(n2))); ------------------ | | 350| 0|#define luai_numeq(a,b) ((a)==(b)) ------------------ 227| 0| case LUA_VLIGHTUSERDATA: ------------------ | | 429| 0|#define LUA_VLIGHTUSERDATA makevariant(LUA_TLIGHTUSERDATA, 0) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (227:5): [True: 0, False: 1] ------------------ 228| 0| return pvalue(k1) == pvalueraw(keyval(n2)); ------------------ | | 436| 0|#define pvalue(o) check_exp(ttislightuserdata(o), val_(o).p) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ return pvalue(k1) == pvalueraw(keyval(n2)); ------------------ | | 439| 0|#define pvalueraw(v) ((v).p) ------------------ 229| 0| case LUA_VLCF: ------------------ | | 591| 0|#define LUA_VLCF makevariant(LUA_TFUNCTION, 1) /* light C function */ | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (229:5): [True: 0, False: 1] ------------------ 230| 0| return fvalue(k1) == fvalueraw(keyval(n2)); ------------------ | | 605| 0|#define fvalue(o) check_exp(ttislcf(o), val_(o).f) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ return fvalue(k1) == fvalueraw(keyval(n2)); ------------------ | | 608| 0|#define fvalueraw(v) ((v).f) ------------------ 231| 1| case ctb(LUA_VLNGSTR): ------------------ | | 303| 1|#define ctb(t) ((t) | BIT_ISCOLLECTABLE) | | ------------------ | | | | 298| 1|#define BIT_ISCOLLECTABLE (1 << 6) | | ------------------ ------------------ | Branch (231:5): [True: 1, False: 0] ------------------ 232| 1| return luaS_eqlngstr(tsvalue(k1), keystrval(n2)); ------------------ | | 369| 1|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 115| 1|#define check_exp(c,e) (e) | | ------------------ ------------------ return luaS_eqlngstr(tsvalue(k1), keystrval(n2)); ------------------ | | 762| 1|#define keystrval(node) (gco2ts(keyval(node).gc)) | | ------------------ | | | | 374| 1| check_exp(novariant((o)->tt) == LUA_TSTRING, &((cast_u(o))->ts)) | | | | ------------------ | | | | | | 115| 1|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 233| 0| default: ------------------ | Branch (233:5): [True: 0, False: 1] ------------------ 234| 0| return gcvalue(k1) == gcvalueraw(keyval(n2)); ------------------ | | 305| 0|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ return gcvalue(k1) == gcvalueraw(keyval(n2)); ------------------ | | 307| 0|#define gcvalueraw(v) ((v).gc) ------------------ 235| 1| } 236| 1|} luaT_init: 38| 6|void luaT_init (lua_State *L) { 39| 6| static const char *const luaT_eventname[] = { /* ORDER TM */ 40| 6| "__index", "__newindex", 41| 6| "__gc", "__mode", "__len", "__eq", 42| 6| "__add", "__sub", "__mul", "__mod", "__pow", 43| 6| "__div", "__idiv", 44| 6| "__band", "__bor", "__bxor", "__shl", "__shr", 45| 6| "__unm", "__bnot", "__lt", "__le", 46| 6| "__concat", "__call", "__close" 47| 6| }; 48| 6| int i; 49| 156| for (i=0; itmname[i] = luaS_new(L, luaT_eventname[i]); ------------------ | | 335| 150|#define G(L) (L->l_G) ------------------ 51| 150| luaC_fix(L, obj2gco(G(L)->tmname[i])); /* never collect these names */ ------------------ | | 390| 150|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | ------------------ | | | | 115| 150|#define check_exp(c,e) (e) | | ------------------ ------------------ 52| 150| } 53| 6|} luaZ_fill: 23| 7|int luaZ_fill (ZIO *z) { 24| 7| size_t size; 25| 7| lua_State *L = z->L; 26| 7| const char *buff; 27| 7| lua_unlock(L); ------------------ | | 265| 7|#define lua_unlock(L) ((void) 0) ------------------ 28| 7| buff = z->reader(L, z->data, &size); 29| 7| lua_lock(L); ------------------ | | 264| 7|#define lua_lock(L) ((void) 0) ------------------ 30| 7| if (buff == NULL || size == 0) ------------------ | Branch (30:7): [True: 1, False: 6] | Branch (30:23): [True: 0, False: 6] ------------------ 31| 1| return EOZ; ------------------ | | 16| 1|#define EOZ (-1) /* end of stream */ ------------------ 32| 6| z->n = size - 1; /* discount char being returned */ 33| 6| z->p = buff; 34| 6| return cast_uchar(*(z->p++)); ------------------ | | 144| 6|#define cast_uchar(i) cast(unsigned char, (i)) | | ------------------ | | | | 136| 6|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 35| 7|} luaZ_init: 38| 6|void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader, void *data) { 39| 6| z->L = L; 40| 6| z->reader = reader; 41| 6| z->data = data; 42| 6| z->n = 0; 43| 6| z->p = NULL; 44| 6|}