MSize             501 lib_base.c         MSize len;
MSize             593 lib_base.c       lj_state_growstack(co, (MSize)(L->top - L->base));
MSize             438 lib_ffi.c          MSize slot = lj_ccallback_ptr2slot(cts, *(void **)cdataptr(cd));
MSize             511 lib_ffi.c      		   o, (MSize)(L->top - o));  /* Initialize cdata. */
MSize             147 lib_io.c         MSize m = LUAL_BUFFERSIZE, n = 0, ok = 0;
MSize             152 lib_io.c           n += (MSize)strlen(buf+n);
MSize             164 lib_io.c         MSize m, n;
MSize             167 lib_io.c           n += (MSize)fread(buf+n, 1, m-n, fp);
MSize             180 lib_io.c           MSize n = (MSize)fread(buf, 1, m, fp);
MSize             216 lib_io.c       	ok = io_file_readlen(L, fp, (MSize)lj_lib_checkint(L, n+1));
MSize             234 lib_io.c           MSize len;
MSize             260 lib_io.c           lj_state_checkstack(L, (MSize)n);
MSize             366 lib_jit.c          MSize n, nent = snap->nent;
MSize             208 lib_os.c           MSize sz = 0;
MSize              58 lib_string.c     lj_state_checkstack(L, (MSize)n);
MSize              68 lib_string.c     char *buf = lj_buf_tmp(L, (MSize)nargs);
MSize             118 lib_string.c     lj_buf_putmem((SBuf *)sb, p, (MSize)size);
MSize             455 lib_string.c     MSize st;
MSize             458 lib_string.c     st = (MSize)start;
MSize             275 lib_table.c      MSize i, n = (uint32_t)(L->top - base);
MSize              91 lj_api.c           lj_state_checkstack(L, (MSize)size);
MSize             108 lj_api.c         lj_state_checkstack(to, (MSize)n);
MSize             135 lj_api.c       	lj_state_growstack(L, (MSize)idx - (MSize)(L->top - L->base));
MSize             681 lj_api.c         fn = lj_func_newC(L, (MSize)n, getcurrenv(L));
MSize             749 lj_api.c         ud = lj_udata_new(L, (MSize)size, getcurrenv(L));
MSize            1264 lj_api.c           g->gc.pause = (MSize)data;
MSize            1268 lj_api.c           g->gc.stepmul = (MSize)data;
MSize             935 lj_asm.c         MSize n, nent = snap->nent;
MSize             960 lj_asm.c         MSize n, nent = snap->nent;
MSize            1931 lj_asm.c         MSize n;
MSize            2397 lj_asm.c         T->mcloop = as->mcloop ? (MSize)((char *)as->mcloop - (char *)as->mcp) : 0;
MSize            2400 lj_asm.c         T->szmcode = (MSize)((char *)as->mctop - (char *)as->mcp);
MSize            1968 lj_asm_arm.h     MSize n, nent = snap->nent;
MSize            1787 lj_asm_arm64.h   MSize n, nent = snap->nent;
MSize            2401 lj_asm_mips.h    MSize n, nent = snap->nent;
MSize            2008 lj_asm_ppc.h     MSize n, nent = snap->nent;
MSize            2715 lj_asm_x86.h     MSize n, nent = snap->nent;
MSize            3098 lj_asm_x86.h     MSize len = T->szmcode;
MSize              57 lj_bcread.c        MSize n = (MSize)(ls->pe - ls->p);
MSize              77 lj_bcread.c          n += (MSize)sz;
MSize             160 lj_bcread.c        MSize i, n = pt->sizebc-1;
MSize             175 lj_bcread.c      MSize n = pt->sizeuv;
MSize             183 lj_bcread.c      MSize tp = bcread_uleb128(ls);
MSize             185 lj_bcread.c        MSize len = tp - BCDUMP_KTAB_STR;
MSize             202 lj_bcread.c      MSize narray = bcread_uleb128(ls);
MSize             203 lj_bcread.c      MSize nhash = bcread_uleb128(ls);
MSize             206 lj_bcread.c        MSize i;
MSize             212 lj_bcread.c        MSize i;
MSize             226 lj_bcread.c      MSize i;
MSize             229 lj_bcread.c        MSize tp = bcread_uleb128(ls);
MSize             231 lj_bcread.c          MSize len = tp - BCDUMP_KGC_STR;
MSize             265 lj_bcread.c      MSize i;
MSize             285 lj_bcread.c      bcread_block(ls, bc+1, (sizebc-1)*(MSize)sizeof(BCIns));
MSize             288 lj_bcread.c        MSize i;
MSize             301 lj_bcread.c          MSize i;
MSize             312 lj_bcread.c      MSize framesize, numparams, flags, sizeuv, sizekgc, sizekn, sizebc, sizept;
MSize             313 lj_bcread.c      MSize ofsk, ofsuv, ofsdbg;
MSize             314 lj_bcread.c      MSize sizedbg = 0;
MSize             334 lj_bcread.c      sizept = (MSize)sizeof(GCproto) +
MSize             335 lj_bcread.c    	   sizebc*(MSize)sizeof(BCIns) +
MSize             336 lj_bcread.c    	   sizekgc*(MSize)sizeof(GCRef);
MSize             337 lj_bcread.c      sizept = (sizept + (MSize)sizeof(TValue)-1) & ~((MSize)sizeof(TValue)-1);
MSize             338 lj_bcread.c      ofsk = sizept; sizept += sizekn*(MSize)sizeof(TValue);
MSize             343 lj_bcread.c      pt = (GCproto *)lj_mem_newgco(ls->L, (MSize)sizept);
MSize             374 lj_bcread.c        MSize sizeli = (sizebc-1) << (numline < 256 ? 0 : numline < 65536 ? 1 : 2);
MSize             413 lj_bcread.c        MSize len = bcread_uleb128(ls);
MSize             432 lj_bcread.c        MSize len;
MSize              42 lj_bcwrite.c       MSize len = str->len;
MSize              73 lj_bcwrite.c     MSize narray = 0, nhash = 0;
MSize              80 lj_bcwrite.c       narray = (MSize)(i+1);
MSize              83 lj_bcwrite.c       MSize i, hmask = t->hmask;
MSize              93 lj_bcwrite.c       MSize i;
MSize              99 lj_bcwrite.c       MSize i = nhash;
MSize             113 lj_bcwrite.c     MSize i, sizekgc = pt->sizekgc;
MSize             117 lj_bcwrite.c       MSize tp, need = 1;
MSize             171 lj_bcwrite.c     MSize i, sizekn = pt->sizekn;
MSize             204 lj_bcwrite.c     MSize nbc = pt->sizebc-1;  /* Omit the [JI]FUNC* header. */
MSize             208 lj_bcwrite.c     p = lj_buf_wmem(p, proto_bc(pt)+1, nbc*(MSize)sizeof(BCIns));
MSize             214 lj_bcwrite.c       MSize i;
MSize             236 lj_bcwrite.c     MSize sizedbg = 0;
MSize             252 lj_bcwrite.c   		  5+4+6*5+(pt->sizebc-1)*(MSize)sizeof(BCIns)+pt->sizeuv*2);
MSize             265 lj_bcwrite.c         sizedbg = pt->sizept - (MSize)((char *)proto_lineinfo(pt) - (char *)pt);
MSize             291 lj_bcwrite.c       MSize n = sbuflen(&ctx->sb) - 5;
MSize             292 lj_bcwrite.c       MSize nn = (lj_fls(n)+8)*9 >> 6;
MSize             305 lj_bcwrite.c     MSize len = chunkname->len;
MSize             320 lj_bcwrite.c   			   (MSize)(p - sbufB(&ctx->sb)), ctx->wdata);
MSize              21 lj_buf.c         MSize osz = sbufsz(sb), len = sbuflen(sb), nsz = osz;
MSize              42 lj_buf.c         MSize len = sbuflen(sb);
MSize              53 lj_buf.c         MSize osz = (MSize)(sbufE(sb) - b);
MSize              55 lj_buf.c           MSize n = (MSize)(sbufP(sb) - b);
MSize              90 lj_buf.c         MSize len = s->len;
MSize             101 lj_buf.c         MSize len = s->len;
MSize             112 lj_buf.c         MSize len = s->len;
MSize             130 lj_buf.c         MSize len = s->len;
MSize             148 lj_buf.c         MSize len = s->len;
MSize             154 lj_buf.c           p = lj_buf_more(sb, (MSize)tlen);
MSize             172 lj_buf.c         MSize seplen = sep ? sep->len : 0;
MSize             182 lj_buf.c       	MSize len = strV(o)->len;
MSize             212 lj_buf.c         MSize len1 = s1->len, len2 = s2->len;
MSize              18 lj_buf.h       #define sbufsz(sb)	((MSize)(sbufE((sb)) - sbufB((sb))))
MSize              19 lj_buf.h       #define sbuflen(sb)	((MSize)(sbufP((sb)) - sbufB((sb))))
MSize              20 lj_buf.h       #define sbufleft(sb)	((MSize)(sbufE((sb)) - sbufP((sb))))
MSize              34 lj_carith.c      MSize i;
MSize             671 lj_ccall.c       MSize ngpr = cc->ngpr, nfpr = cc->nfpr;
MSize             696 lj_ccall.c         MSize nsp = cc->nsp, n = rcl[1] ? 2 : 1;
MSize             708 lj_ccall.c       MSize ngpr = 0, nfpr = 0;
MSize             925 lj_ccall.c       MSize maxgpr, ngpr = 0, nsp = 0, narg;
MSize             927 lj_ccall.c       MSize nfpr = 0;
MSize             929 lj_ccall.c       MSize fprodd = 0;
MSize             986 lj_ccall.c         MSize n, isfp = 0, isva = 0;
MSize            1027 lj_ccall.c           MSize align = (1u << ctype_align(d->info-CTALIGN_PTR)) -1;
MSize              43 lj_ccallback.c static MSize CALLBACK_OFS2SLOT(MSize ofs)
MSize              45 lj_ccallback.c   MSize group;
MSize              96 lj_ccallback.c MSize lj_ccallback_ptr2slot(CTState *cts, void *p)
MSize             100 lj_ccallback.c     MSize slot = CALLBACK_OFS2SLOT((MSize)ofs);
MSize             101 lj_ccallback.c     if (CALLBACK_SLOT2OFS(slot) == (MSize)ofs)
MSize             116 lj_ccallback.c   MSize slot;
MSize             153 lj_ccallback.c   MSize slot;
MSize             175 lj_ccallback.c   MSize slot;
MSize             195 lj_ccallback.c   MSize slot;
MSize             215 lj_ccallback.c   MSize slot;
MSize             519 lj_ccallback.c   MSize slot = cts->cb.slot;
MSize             525 lj_ccallback.c   MSize ngpr = 0, nsp = 0, maxgpr = CCALL_NARG_GPR;
MSize             527 lj_ccallback.c   MSize nfpr = 0;
MSize             529 lj_ccallback.c   MSize fprodd = 0;
MSize             581 lj_ccallback.c       MSize n;
MSize             717 lj_ccallback.c static MSize callback_slot_new(CTState *cts, CType *ct)
MSize             721 lj_ccallback.c   MSize top;
MSize             778 lj_ccallback.c     MSize slot = callback_slot_new(cts, ct);
MSize              17 lj_ccallback.h LJ_FUNC MSize lj_ccallback_ptr2slot(CTState *cts, void *p);
MSize             146 lj_cconv.c         MSize i;
MSize             674 lj_cconv.c       MSize i;
MSize             695 lj_cconv.c           MSize i = *ip;
MSize             716 lj_cconv.c       MSize i = 0;
MSize              32 lj_cdata.c       MSize extra = sizeof(GCcdataVar) + sizeof(GCcdata) +
MSize             221 lj_clib.c          MSize i;
MSize             238 lj_clib.c          MSize i;
MSize             148 lj_crecord.c   static MSize crec_copy_struct(CRecMemList *ml, CTState *cts, CType *ct)
MSize             151 lj_crecord.c     MSize mlp = 0;
MSize             181 lj_crecord.c   static MSize crec_copy_unroll(CRecMemList *ml, CTSize len, CTSize step,
MSize             185 lj_crecord.c     MSize mlp = 0;
MSize             208 lj_crecord.c     MSize i, j, rwin = 0;
MSize             232 lj_crecord.c       MSize mlp = 0;
MSize             276 lj_crecord.c   static MSize crec_fill_unroll(CRecMemList *ml, CTSize len, CTSize step)
MSize             279 lj_crecord.c     MSize mlp = 0;
MSize             302 lj_crecord.c     MSize i;
MSize             316 lj_crecord.c       MSize mlp;
MSize            1007 lj_crecord.c         MSize i;
MSize            1026 lj_crecord.c         MSize i = 1;
MSize            1082 lj_crecord.c     MSize i, n;
MSize            1301 lj_crecord.c       MSize i;
MSize            1455 lj_crecord.c     MSize i;
MSize            1780 lj_crecord.c     MSize i;
MSize             437 lj_ctype.c       ctype_prepstr(ctr, t, (MSize)strlen(t));
MSize             168 lj_ctype.h       MSize sizeid;			/* Size of callback type table. */
MSize             169 lj_ctype.h       MSize topid;			/* Highest unused callback type table slot. */
MSize             170 lj_ctype.h       MSize slot;			/* Current callback slot. */
MSize             177 lj_ctype.h       MSize sizetab;	/* Size of C type table. */
MSize             374 lj_debug.c       MSize i, len = name->len;
MSize             508 lj_debug.c     	MSize i, szl = pt->sizebc-1;
MSize             557 lj_debug.c         MSize len = name->len-1;
MSize             579 lj_debug.c       MSize lastlen = 0;
MSize             605 lj_debug.c     	    lj_buf_putmem(sb, name, (MSize)strlen(name));
MSize             457 lj_dispatch.c      lj_state_checkstack(L, (MSize)need);
MSize             816 lj_ffrecord.c    } else if ((MSize)end <= str->len) {
MSize             926 lj_ffrecord.c    if ((MSize)start <= str->len) {
MSize             948 lj_ffrecord.c      if (lj_str_find(strdata(str)+(MSize)start, strdata(pat),
MSize             949 lj_ffrecord.c  		    str->len-(MSize)start, pat->len)) {
MSize             122 lj_func.c        GCfunc *fn = (GCfunc *)lj_mem_newgco(L, sizeLfunc((MSize)pt->sizeuv));
MSize             139 lj_func.c        MSize i, nuv = pt->sizeuv;
MSize             157 lj_func.c        MSize i, nuv;
MSize             183 lj_func.c        MSize size = isluafunc(fn) ? sizeLfunc((MSize)fn->l.nupvalues) :
MSize             184 lj_func.c      			       sizeCfunc((MSize)fn->c.nupvalues);
MSize             190 lj_gc.c            MSize i, asize = t->asize;
MSize             196 lj_gc.c            MSize i, hmask = t->hmask;
MSize             276 lj_gc.c        static MSize gc_traverse_frames(global_State *g, lua_State *th)
MSize             289 lj_gc.c          return (MSize)(top - bot);  /* Return minimum needed stack size. */
MSize             324 lj_gc.c            return isluafunc(fn) ? sizeLfunc((MSize)fn->l.nupvalues) :
MSize             325 lj_gc.c        			   sizeCfunc((MSize)fn->c.nupvalues);
MSize             435 lj_gc.c              MSize i, asize = t->asize;
MSize             445 lj_gc.c              MSize i, hmask = t->hmask;
MSize             559 lj_gc.c          MSize i, strmask;
MSize             845 lj_gc.c          MSize sz = (*szp) << 1;
MSize             127 lj_gc.h          ((p) = (t *)lj_mem_grow(L, (p), &(n), (m), (MSize)sizeof(t)))
MSize             410 lj_gdbjit.c      MSize szmcode;	/* Size of machine code. */
MSize             411 lj_gdbjit.c      MSize spadjp;		/* Stack adjustment for parent trace or interpreter. */
MSize             412 lj_gdbjit.c      MSize spadj;		/* Stack adjustment for trace itself. */
MSize             752 lj_gdbjit.c      MSize sz = (MSize)(sizeof(GDBJITentryobj) - sizeof(GDBJITobj) + ctx->objsize);
MSize             783 lj_gdbjit.c    	       (MSize)(parent ? traceref(J, parent)->spadjust : 0);
MSize              75 lj_ir.c          MSize szins = J->irtoplim - J->irbotlim;
MSize              92 lj_ir.c          MSize szins = J->irtoplim - J->irbotlim;
MSize              97 lj_ir.c            MSize ofs = szins >> 2;
MSize             105 lj_ir.c            MSize ofs = szins >= 256 ? 128 : (szins >> 1);  /* Limit bottom growth. */
MSize             252 lj_jit.h         MSize szmcode;	/* Size of machine code. */
MSize             254 lj_jit.h         MSize mcloop;		/* Offset of loop start in machine code. */
MSize             271 lj_jit.h         check_exp((n)>0 && (MSize)(n)<J->sizetrace, (GCtrace *)gcref(J->trace[(n)]))
MSize             275 lj_jit.h       static LJ_AINLINE MSize snap_nextofs(GCtrace *T, SnapShot *snap)
MSize             415 lj_jit.h         MSize bc_extent;	/* Extent of the range. */
MSize             434 lj_jit.h         MSize sizesnap;	/* Size of temp. snapshot buffer. */
MSize             437 lj_jit.h         MSize sizesnapmap;	/* Size of temp. snapshot map buffer. */
MSize             447 lj_jit.h         MSize sizetrace;	/* Size of trace array. */
MSize             175 lj_lex.c           GCstr *str = lj_parse_keepstr(ls, sbufB(&ls->sb) + (2 + (MSize)sep),
MSize             176 lj_lex.c       				      sbuflen(&ls->sb) - 2*(2 + (MSize)sep));
MSize              71 lj_lex.h         MSize sizevstack;	/* Size of variable stack. */
MSize              72 lj_lex.h         MSize vtop;		/* Top of variable stack. */
MSize              74 lj_lex.h         MSize sizebcstack;	/* Size of bytecode stack. */
MSize              87 lj_lib.c           MSize len = tag & LIBINIT_LENMASK;
MSize              91 lj_lib.c             MSize nuv = (MSize)(L->top - L->base - tpos);
MSize             292 lj_lib.c           MSize len = s->len;
MSize             287 lj_meta.c            lj_buf_more(sb, (MSize)tlen);
MSize             291 lj_meta.c      	  MSize len = s->len;
MSize             295 lj_obj.h         MSize hash;		/* Hash of string. */
MSize             296 lj_obj.h         MSize len;		/* Size of string. */
MSize             313 lj_obj.h         MSize len;		/* Size of payload. */
MSize             341 lj_obj.h         MSize len;		/* Size of payload. */
MSize             360 lj_obj.h         MSize sizebc;		/* Number of bytecode instructions. */
MSize             367 lj_obj.h         MSize sizekgc;	/* Number of collectable constants. */
MSize             368 lj_obj.h         MSize sizekn;		/* Number of lua_Number constants. */
MSize             369 lj_obj.h         MSize sizept;		/* Total size including colocated arrays. */
MSize             580 lj_obj.h         MSize sweepstr;	/* Sweep position in string table. */
MSize             589 lj_obj.h         MSize stepmul;	/* Incremental GC step granularity. */
MSize             590 lj_obj.h         MSize pause;		/* Pause between successive GC cycles. */
MSize             596 lj_obj.h         MSize strmask;	/* String hash mask (size of hash table - 1). */
MSize             597 lj_obj.h         MSize strnum;		/* Number of strings in hash table. */
MSize             662 lj_obj.h         MSize stacksize;	/* True stack size (incl. LJ_STACK_EXTRA). */
MSize              27 lj_opt_dce.c       MSize n, nent = snap->nent;
MSize             499 lj_opt_fold.c    lua_assert((MSize)fright->i <= str->len);
MSize             149 lj_opt_loop.c        MSize n, nent = snap->nent;
MSize             213 lj_opt_loop.c    MSize nmapofs;
MSize             214 lj_opt_loop.c    MSize on, ln, nn, onent = osnap->nent;
MSize             260 lj_opt_loop.c    MSize sizesubst;
MSize             415 lj_opt_loop.c    MSize nsnapmap = J->cur.nsnapmap;
MSize             139 lj_opt_sink.c    MSize n, nent = snap->nent;
MSize             315 lj_opt_split.c   MSize n, nent = snap->nent;
MSize             328 lj_opt_split.c   MSize irlen = nins - nk;
MSize             329 lj_opt_split.c   MSize need = (irlen+1)*(sizeof(IRIns) + sizeof(IRRef1));
MSize             100 lj_parse.c       MSize vstart;			/* Start of block-local variables. */
MSize             138 lj_parse.c       MSize vbase;			/* Base of variable stack for this function. */
MSize            1036 lj_parse.c       MSize vtop = ls->vtop;
MSize            1091 lj_parse.c     static MSize var_lookup_uv(FuncState *fs, MSize vidx, ExpDesc *e)
MSize            1093 lj_parse.c       MSize i, n = fs->nuv;
MSize            1110 lj_parse.c     static MSize var_lookup_(FuncState *fs, GCstr *name, ExpDesc *e, int first)
MSize            1118 lj_parse.c           return (MSize)(e->u.s.aux = (uint32_t)fs->varmap[reg]);
MSize            1120 lj_parse.c           MSize vidx = var_lookup_(fs->prev, name, e, 0);  /* Var in outer func? */
MSize            1131 lj_parse.c       return (MSize)-1;  /* Global. */
MSize            1141 lj_parse.c     static MSize gola_new(LexState *ls, GCstr *name, uint8_t info, BCPos pc)
MSize            1144 lj_parse.c       MSize vtop = ls->vtop;
MSize            1282 lj_parse.c           MSize idx = gola_new(ls, NAME_BREAK, VSTACK_LABEL, fs->pc);
MSize            1311 lj_parse.c       MSize i;
MSize            1324 lj_parse.c       MSize i, n = pt->sizeuv;
MSize            1342 lj_parse.c       MSize i, hmask;
MSize            1410 lj_parse.c       MSize i = 0, n = fs->pc-1;
MSize            1442 lj_parse.c       MSize i, n;
MSize            1448 lj_parse.c         MSize len = s->len+1;
MSize            1465 lj_parse.c     	MSize len = s->len+1;
MSize            1570 lj_parse.c       pt = (GCproto *)lj_mem_newgco(L, (MSize)sizept);
MSize            1572 lj_parse.c       pt->sizept = (MSize)sizept;
MSize            2367 lj_parse.c       MSize idx;
MSize            1301 lj_record.c        if ((MSize)k < LJ_MAX_ASIZE) {  /* Potential array key? */
MSize            1304 lj_record.c          if ((MSize)k < t->asize) {  /* Currently an array key? */
MSize            1340 lj_record.c        MSize hslot = (MSize)((char *)ix->oldv - (char *)&noderef(t->node)[0].val);
MSize            1341 lj_record.c        if (t->hmask > 0 && hslot <= t->hmask*(MSize)sizeof(Node) &&
MSize            1342 lj_record.c    	hslot <= 65535*(MSize)sizeof(Node)) {
MSize            2036 lj_record.c         (MSize)((char *)pc - (char *)J->bc_min) >= J->bc_extent)
MSize            2489 lj_record.c        J->bc_extent = (MSize)(-bc_j(ins))*sizeof(BCIns);
MSize            2496 lj_record.c        J->bc_extent = (MSize)(-bc_j(ins))*sizeof(BCIns);
MSize            2507 lj_record.c          J->bc_extent = (MSize)(-bc_j(ins))*sizeof(BCIns);
MSize            2563 lj_record.c      J->bc_extent = ~(MSize)0;
MSize              40 lj_snap.c        MSize maxsnap = (MSize)J->param[JIT_P_maxsnap];
MSize              63 lj_snap.c      static MSize snapshot_slots(jit_State *J, SnapEntry *map, BCReg nslots)
MSize              67 lj_snap.c        MSize n = 0;
MSize             105 lj_snap.c      static MSize snapshot_framelinks(jit_State *J, SnapEntry *map, uint8_t *topslot)
MSize             116 lj_snap.c        MSize f = 0;
MSize             147 lj_snap.c        lua_assert(f == (MSize)(1 + J->framedepth));
MSize             156 lj_snap.c        MSize nent;
MSize             159 lj_snap.c        lj_snap_grow_map(J, nsnapmap + nslots + (MSize)(LJ_FR2?2:J->framedepth+1));
MSize             174 lj_snap.c        MSize nsnap = J->cur.nsnap;
MSize             175 lj_snap.c        MSize nsnapmap = J->cur.nsnapmap;
MSize             313 lj_snap.c        MSize n, m, nlim, nent = snap->nent;
MSize             364 lj_snap.c        MSize n = 0;
MSize             413 lj_snap.c        MSize j;
MSize             461 lj_snap.c        MSize n, nent = snap->nent;
MSize             835 lj_snap.c        MSize n, nent = snap->nent;
MSize             869 lj_snap.c      	MSize j;
MSize              60 lj_state.c       MSize oldsize = L->stacksize;
MSize              61 lj_state.c       MSize realsize = n + 1 + LJ_STACK_EXTRA;
MSize              63 lj_state.c       lua_assert((MSize)(tvref(L->maxstack)-oldst)==L->stacksize-LJ_STACK_EXTRA-1);
MSize              65 lj_state.c     				(MSize)(oldsize*sizeof(TValue)),
MSize              66 lj_state.c     				(MSize)(realsize*sizeof(TValue)));
MSize             103 lj_state.c       MSize n;
MSize             206 lj_state.c       g->strmask = ~(MSize)0;
MSize              20 lj_str.c         MSize i, n = a->len > b->len ? b->len : a->len;
MSize              43 lj_str.c         MSize i = 0;
MSize              74 lj_str.c       	q++; slen -= (MSize)(q-s); s = q;
MSize             100 lj_str.c         MSize i;
MSize             105 lj_str.c         for (i = g->strmask; i != ~(MSize)0; i--) {  /* Rehash old table. */
MSize             108 lj_str.c             MSize h = gco2str(p)->hash & newmask;
MSize             127 lj_str.c         MSize len = (MSize)lenx;
MSize             128 lj_str.c         MSize a, b, h = len;
MSize              78 lj_strfmt.c    	fs->len = (MSize)(p - (const uint8_t *)fs->str);
MSize              86 lj_strfmt.c      fs->len = (MSize)(p - (const uint8_t *)fs->str);
MSize             132 lj_strfmt.c      MSize i, n = STRFMT_MAXBUF_PTR;
MSize             202 lj_strfmt.c      MSize len = str->len;
MSize             233 lj_strfmt.c      MSize width = STRFMT_WIDTH(sf);
MSize             245 lj_strfmt.c      MSize len = str->len <= STRFMT_PREC(sf) ? str->len : STRFMT_PREC(sf);
MSize             246 lj_strfmt.c      MSize width = STRFMT_WIDTH(sf);
MSize             262 lj_strfmt.c      MSize prefix = 0, len, prec, pprec, width, need;
MSize             299 lj_strfmt.c      len = (MSize)(buf + sizeof(buf) - q);
MSize             323 lj_strfmt.c      lua_assert(need == (MSize)(p - ps));
MSize             355 lj_strfmt.c      MSize len = (MSize)(lj_strfmt_wint(buf, k) - buf);
MSize             390 lj_strfmt.c        p = lj_buf_wmem(p, lj_typename(o), (MSize)strlen(lj_typename(o)));
MSize             422 lj_strfmt.c      lj_strfmt_init(&fs, fmt, (MSize)strlen(fmt));
MSize             440 lj_strfmt.c          lj_buf_putmem(sb, s, (MSize)strlen(s));
MSize              18 lj_strfmt.h      MSize len;		/* Size of literal string. */
MSize              63 lj_strfmt_num.c static MSize ndigits_dec(uint32_t x)
MSize              65 lj_strfmt_num.c   MSize t = ((lj_fls(x | 1) * 77) >> 8) + 1; /* 2^8/77 is roughly log2(10) */
MSize             271 lj_strfmt_num.c   MSize width = STRFMT_WIDTH(sf), prec = STRFMT_PREC(sf), len;
MSize             405 lj_strfmt_num.c       MSize hilen;
MSize             483 lj_strfmt_num.c 	prec -= (MSize)(q - p); p = q; /* Account for digits already emitted. */
MSize             508 lj_strfmt_num.c       if (prec < (MSize)(0x3f & -(int32_t)ndlo) * 9) {
MSize             589 lj_strfmt_num.c   MSize len = (MSize)(lj_strfmt_wfnum(NULL, STRFMT_G14, o->n, buf) - buf);
MSize             620 lj_tab.c       static MSize unbound_search(GCtab *t, MSize j)
MSize             623 lj_tab.c         MSize i = j;  /* i is zero or a present index */
MSize             629 lj_tab.c           if (j > (MSize)(INT_MAX-2)) {  /* overflow? */
MSize             638 lj_tab.c           MSize m = (i+j)/2;
MSize             649 lj_tab.c       MSize LJ_FASTCALL lj_tab_len(GCtab *t)
MSize             651 lj_tab.c         MSize j = (MSize)t->asize;
MSize             653 lj_tab.c           MSize i = 1;
MSize             655 lj_tab.c             MSize m = (i+j)/2;
MSize              63 lj_tab.h       #define inarray(t, key)		((MSize)(key) < (MSize)(t)->asize)
MSize              71 lj_tab.h       LJ_FUNCA MSize LJ_FASTCALL lj_tab_len(GCtab *t);
MSize              62 lj_trace.c       MSize osz, lim;
MSize              69 lj_trace.c       lim = (MSize)J->param[JIT_P_maxtrace] + 1;
MSize             128 lj_trace.c       GCtrace *T2 = lj_mem_newt(L, (MSize)sz, GCtrace);