MSize             607 lib_base.c       lj_state_growstack(co, (MSize)(L->top - L->base));
MSize             437 lib_ffi.c          MSize slot = lj_ccallback_ptr2slot(cts, *(void **)cdataptr(cd));
MSize             513 lib_ffi.c      		   o, (MSize)(L->top - o));  /* Initialize cdata. */
MSize             145 lib_io.c         MSize m = LUAL_BUFFERSIZE, n = 0, ok = 0;
MSize             150 lib_io.c           n += (MSize)strlen(buf+n);
MSize             162 lib_io.c         MSize m, n;
MSize             165 lib_io.c           n += (MSize)fread(buf+n, 1, m-n, fp);
MSize             178 lib_io.c           MSize n = (MSize)fread(buf, 1, m, fp);
MSize             215 lib_io.c       	ok = io_file_readlen(L, fp, (MSize)lj_lib_checkint(L, n+1));
MSize             234 lib_io.c             MSize len = strV(tv)->len;
MSize             267 lib_io.c           lj_state_checkstack(L, (MSize)n);
MSize             354 lib_jit.c          MSize n, nent = snap->nent;
MSize              57 lib_string.c     lj_state_checkstack(L, (MSize)n);
MSize              67 lib_string.c     char *buf = lj_str_needbuf(L, &G(L)->tmpbuf, (MSize)nargs);
MSize             114 lib_string.c     buf = lj_str_needbuf(L, &g->tmpbuf, (MSize)tlen);
MSize              30 lib_table.c      MSize i, n = lj_tab_len(t);
MSize             149 lib_table.c      MSize seplen = sep ? sep->len : 0;
MSize             274 lib_table.c      MSize i, n = (uint32_t)(L->top - base);
MSize              90 lj_api.c           lj_state_checkstack(L, (MSize)size);
MSize             107 lj_api.c         lj_state_checkstack(to, (MSize)n);
MSize             127 lj_api.c       	lj_state_growstack(L, (MSize)idx - (MSize)(L->top - L->base));
MSize             628 lj_api.c         fn = lj_func_newC(L, (MSize)n, getcurrenv(L));
MSize             698 lj_api.c         ud = lj_udata_new(L, (MSize)size, getcurrenv(L));
MSize            1164 lj_api.c           MSize a = (MSize)data << 10;
MSize            1175 lj_api.c           g->gc.pause = (MSize)data;
MSize            1179 lj_api.c           g->gc.stepmul = (MSize)data;
MSize             885 lj_asm.c         MSize n, nent = snap->nent;
MSize             910 lj_asm.c         MSize n, nent = snap->nent;
MSize            1535 lj_asm.c         MSize n;
MSize            1911 lj_asm.c         T->mcloop = as->mcloop ? (MSize)((char *)as->mcloop - (char *)as->mcp) : 0;
MSize            1914 lj_asm.c         T->szmcode = (MSize)((char *)as->mctop - (char *)as->mcp);
MSize            1988 lj_asm_arm.h     MSize n, nent = snap->nent;
MSize            1631 lj_asm_mips.h    MSize n, nent = snap->nent;
MSize            1818 lj_asm_ppc.h     MSize n, nent = snap->nent;
MSize            2377 lj_asm_x86.h     MSize n, nent = snap->nent;
MSize            2883 lj_asm_x86.h     MSize len = T->szmcode;
MSize              49 lj_bcread.c        MSize sz = ls->sb.sz * 2;
MSize              84 lj_bcread.c          MSize n = ls->sb.n + (MSize)size;
MSize              90 lj_bcread.c          ls->n = (MSize)size;
MSize             180 lj_bcread.c        MSize i, n = pt->sizebc-1;
MSize             195 lj_bcread.c      MSize n = pt->sizeuv;
MSize             203 lj_bcread.c      MSize tp = bcread_uleb128(ls);
MSize             205 lj_bcread.c        MSize len = tp - BCDUMP_KTAB_STR;
MSize             222 lj_bcread.c      MSize narray = bcread_uleb128(ls);
MSize             223 lj_bcread.c      MSize nhash = bcread_uleb128(ls);
MSize             226 lj_bcread.c        MSize i;
MSize             232 lj_bcread.c        MSize i;
MSize             246 lj_bcread.c      MSize i;
MSize             249 lj_bcread.c        MSize tp = bcread_uleb128(ls);
MSize             251 lj_bcread.c          MSize len = tp - BCDUMP_KGC_STR;
MSize             285 lj_bcread.c      MSize i;
MSize             305 lj_bcread.c      bcread_block(ls, bc+1, (sizebc-1)*(MSize)sizeof(BCIns));
MSize             308 lj_bcread.c        MSize i;
MSize             321 lj_bcread.c          MSize i;
MSize             332 lj_bcread.c      MSize framesize, numparams, flags, sizeuv, sizekgc, sizekn, sizebc, sizept;
MSize             333 lj_bcread.c      MSize ofsk, ofsuv, ofsdbg;
MSize             334 lj_bcread.c      MSize sizedbg = 0;
MSize             336 lj_bcread.c      MSize len, startn;
MSize             366 lj_bcread.c      sizept = (MSize)sizeof(GCproto) +
MSize             367 lj_bcread.c    	   sizebc*(MSize)sizeof(BCIns) +
MSize             368 lj_bcread.c    	   sizekgc*(MSize)sizeof(GCRef);
MSize             369 lj_bcread.c      sizept = (sizept + (MSize)sizeof(TValue)-1) & ~((MSize)sizeof(TValue)-1);
MSize             370 lj_bcread.c      ofsk = sizept; sizept += sizekn*(MSize)sizeof(TValue);
MSize             375 lj_bcread.c      pt = (GCproto *)lj_mem_newgco(ls->L, (MSize)sizept);
MSize             406 lj_bcread.c        MSize sizeli = (sizebc-1) << (numline < 256 ? 0 : numline < 65536 ? 1 : 2);
MSize             447 lj_bcread.c        MSize len = bcread_uleb128(ls);
MSize              39 lj_bcwrite.c     MSize sz = ctx->sb.sz * 2;
MSize              55 lj_bcwrite.c     MSize i;
MSize              69 lj_bcwrite.c     MSize n = ctx->sb.n;
MSize              85 lj_bcwrite.c       MSize len = str->len;
MSize             114 lj_bcwrite.c     MSize narray = 0, nhash = 0;
MSize             121 lj_bcwrite.c       narray = (MSize)(i+1);
MSize             124 lj_bcwrite.c       MSize i, hmask = t->hmask;
MSize             133 lj_bcwrite.c       MSize i;
MSize             139 lj_bcwrite.c       MSize i = nhash;
MSize             153 lj_bcwrite.c     MSize i, sizekgc = pt->sizekgc;
MSize             157 lj_bcwrite.c       MSize tp, need = 1;
MSize             208 lj_bcwrite.c     MSize i, sizekn = pt->sizekn;
MSize             244 lj_bcwrite.c     MSize nbc = pt->sizebc-1;  /* Omit the [JI]FUNC* header. */
MSize             248 lj_bcwrite.c     bcwrite_block(ctx, proto_bc(pt)+1, nbc*(MSize)sizeof(BCIns));
MSize             253 lj_bcwrite.c       MSize i;
MSize             274 lj_bcwrite.c     MSize sizedbg = 0;
MSize             290 lj_bcwrite.c     bcwrite_need(ctx, 4+6*5+(pt->sizebc-1)*(MSize)sizeof(BCIns)+pt->sizeuv*2);
MSize             302 lj_bcwrite.c         sizedbg = pt->sizept - (MSize)((char *)proto_lineinfo(pt) - (char *)pt);
MSize             326 lj_bcwrite.c       MSize n = ctx->sb.n - 5;
MSize             327 lj_bcwrite.c       MSize nn = (lj_fls(n)+8)*9 >> 6;
MSize             340 lj_bcwrite.c     MSize len = chunkname->len;
MSize              32 lj_carith.c      MSize i;
MSize             527 lj_ccall.c       MSize ngpr = cc->ngpr, nfpr = cc->nfpr;
MSize             552 lj_ccall.c         MSize nsp = cc->nsp, n = rcl[1] ? 2 : 1;
MSize             564 lj_ccall.c       MSize ngpr = 0, nfpr = 0;
MSize             662 lj_ccall.c       MSize maxgpr, ngpr = 0, nsp = 0, narg;
MSize             664 lj_ccall.c       MSize nfpr = 0;
MSize             666 lj_ccall.c       MSize fprodd = 0;
MSize             723 lj_ccall.c         MSize n, isfp = 0, isva = 0;
MSize             764 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              91 lj_ccallback.c MSize lj_ccallback_ptr2slot(CTState *cts, void *p)
MSize              95 lj_ccallback.c     MSize slot = CALLBACK_OFS2SLOT((MSize)ofs);
MSize              96 lj_ccallback.c     if (CALLBACK_SLOT2OFS(slot) == (MSize)ofs)
MSize             111 lj_ccallback.c   MSize slot;
MSize             143 lj_ccallback.c   MSize slot;
MSize             165 lj_ccallback.c   MSize slot;
MSize             184 lj_ccallback.c   MSize slot;
MSize             409 lj_ccallback.c   MSize slot = cts->cb.slot;
MSize             414 lj_ccallback.c   MSize ngpr = 0, nsp = 0, maxgpr = CCALL_NARG_GPR;
MSize             416 lj_ccallback.c   MSize nfpr = 0;
MSize             418 lj_ccallback.c   MSize fprodd = 0;
MSize             461 lj_ccallback.c       MSize n;
MSize             574 lj_ccallback.c static MSize callback_slot_new(CTState *cts, CType *ct)
MSize             578 lj_ccallback.c   MSize top;
MSize             635 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             672 lj_cconv.c       MSize i;
MSize             693 lj_cconv.c           MSize i = *ip;
MSize             714 lj_cconv.c       MSize i = 0;
MSize              33 lj_cdata.c       MSize extra = sizeof(GCcdataVar) + sizeof(GCcdata) +
MSize             212 lj_clib.c          MSize i;
MSize             229 lj_clib.c          MSize i;
MSize              91 lj_cparse.c      MSize newsize;
MSize             147 lj_crecord.c   static MSize crec_copy_struct(CRecMemList *ml, CTState *cts, CType *ct)
MSize             150 lj_crecord.c     MSize mlp = 0;
MSize             180 lj_crecord.c   static MSize crec_copy_unroll(CRecMemList *ml, CTSize len, CTSize step,
MSize             184 lj_crecord.c     MSize mlp = 0;
MSize             207 lj_crecord.c     MSize i, j, rwin = 0;
MSize             231 lj_crecord.c       MSize mlp = 0;
MSize             275 lj_crecord.c   static MSize crec_fill_unroll(CRecMemList *ml, CTSize len, CTSize step)
MSize             278 lj_crecord.c     MSize mlp = 0;
MSize             301 lj_crecord.c     MSize i;
MSize             315 lj_crecord.c       MSize mlp;
MSize             919 lj_crecord.c         MSize i;
MSize             937 lj_crecord.c         MSize i = 1;
MSize             992 lj_crecord.c     MSize i, n;
MSize            1212 lj_crecord.c       MSize i;
MSize            1368 lj_crecord.c     MSize i;
MSize             433 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             387 lj_debug.c       MSize i, len = name->len;
MSize             519 lj_debug.c     	MSize i, szl = pt->sizebc-1;
MSize             432 lj_dispatch.c      lj_state_checkstack(L, (MSize)need);
MSize             679 lj_ffrecord.c    } else if ((MSize)end <= str->len) {
MSize             754 lj_ffrecord.c        MSize len = lj_tab_len(t);
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             189 lj_gc.c            MSize i, asize = t->asize;
MSize             195 lj_gc.c            MSize i, hmask = t->hmask;
MSize             273 lj_gc.c        static MSize gc_traverse_frames(global_State *g, lua_State *th)
MSize             286 lj_gc.c          return (MSize)(top - bot);  /* Return minimum needed stack size. */
MSize             321 lj_gc.c            return isluafunc(fn) ? sizeLfunc((MSize)fn->l.nupvalues) :
MSize             322 lj_gc.c        			   sizeCfunc((MSize)fn->c.nupvalues);
MSize             441 lj_gc.c              MSize i, asize = t->asize;
MSize             451 lj_gc.c              MSize i, hmask = t->hmask;
MSize             470 lj_gc.c          MSize oldt = g->gc.threshold;
MSize             564 lj_gc.c          MSize i, strmask;
MSize             606 lj_gc.c          g->gc.estimate = g->gc.total - (MSize)udsize;  /* Initial estimate. */
MSize             630 lj_gc.c            MSize old = g->gc.total;
MSize             639 lj_gc.c            MSize old = g->gc.total;
MSize             682 lj_gc.c          MSize lim;
MSize             691 lj_gc.c            lim -= (MSize)gc_onestep(L);
MSize             847 lj_gc.c          MSize sz = (*szp) << 1;
MSize             119 lj_gc.h          g->gc.total -= (MSize)osize;
MSize             123 lj_gc.h        #define lj_mem_newvec(L, n, t)	((t *)lj_mem_new(L, (MSize)((n)*sizeof(t))))
MSize             125 lj_gc.h          ((p) = (t *)lj_mem_realloc(L, p, (on)*sizeof(t), (MSize)((n)*sizeof(t))))
MSize             127 lj_gc.h          ((p) = (t *)lj_mem_grow(L, (p), &(n), (m), (MSize)sizeof(t)))
MSize             403 lj_gdbjit.c      MSize szmcode;	/* Size of machine code. */
MSize             404 lj_gdbjit.c      MSize spadjp;		/* Stack adjustment for parent trace or interpreter. */
MSize             405 lj_gdbjit.c      MSize spadj;		/* Stack adjustment for trace itself. */
MSize             734 lj_gdbjit.c      MSize sz = (MSize)(sizeof(GDBJITentryobj) - sizeof(GDBJITobj) + ctx->objsize);
MSize             763 lj_gdbjit.c    	       (MSize)(parent ? traceref(J, parent)->spadjust : 0);
MSize              73 lj_ir.c          MSize szins = J->irtoplim - J->irbotlim;
MSize              90 lj_ir.c          MSize szins = J->irtoplim - J->irbotlim;
MSize              95 lj_ir.c            MSize ofs = szins >> 2;
MSize             103 lj_ir.c            MSize ofs = szins >= 256 ? 128 : (szins >> 1);  /* Limit bottom growth. */
MSize             197 lj_ir.c          MSize numk;			/* Number of used elements in this array. */
MSize             217 lj_ir.c          MSize idx;
MSize             233 lj_jit.h         MSize szmcode;	/* Size of machine code. */
MSize             235 lj_jit.h         MSize mcloop;		/* Offset of loop start in machine code. */
MSize             252 lj_jit.h         check_exp((n)>0 && (MSize)(n)<J->sizetrace, (GCtrace *)gcref(J->trace[(n)]))
MSize             256 lj_jit.h       static LJ_AINLINE MSize snap_nextofs(GCtrace *T, SnapShot *snap)
MSize             346 lj_jit.h         MSize bc_extent;	/* Extent of the range. */
MSize             364 lj_jit.h         MSize sizesnap;	/* Size of temp. snapshot buffer. */
MSize             367 lj_jit.h         MSize sizesnapmap;	/* Size of temp. snapshot map buffer. */
MSize             376 lj_jit.h         MSize sizetrace;	/* Size of trace array. */
MSize              52 lj_lex.c         ls->n = (MSize)sz - 1;
MSize              59 lj_lex.c         MSize newsize;
MSize             179 lj_lex.c           GCstr *str = lj_parse_keepstr(ls, ls->sb.buf + (2 + (MSize)sep),
MSize             180 lj_lex.c       				      ls->sb.n - 2*(2 + (MSize)sep));
MSize              59 lj_lex.h         MSize n;		/* Bytes left in input buffer. */
MSize              70 lj_lex.h         MSize sizevstack;	/* Size of variable stack. */
MSize              71 lj_lex.h         MSize vtop;		/* Top of variable stack. */
MSize              73 lj_lex.h         MSize sizebcstack;	/* Size of bytecode stack. */
MSize              62 lj_lib.c           MSize len = tag & LIBINIT_LENMASK;
MSize              66 lj_lib.c             MSize nuv = (MSize)(L->top - L->base - tpos);
MSize             247 lj_lib.c           MSize len = s->len;
MSize             284 lj_meta.c            MSize tlen = strV(top)->len;
MSize             288 lj_meta.c      	MSize len = strV(top-n)->len;
MSize             297 lj_meta.c      	MSize len = strV(top-i)->len;
MSize             125 lj_obj.h         MSize n;		/* String buffer length. */
MSize             126 lj_obj.h         MSize sz;		/* String buffer size. */
MSize             228 lj_obj.h         MSize hash;		/* Hash of string. */
MSize             229 lj_obj.h         MSize len;		/* Size of string. */
MSize             246 lj_obj.h         MSize len;		/* Size of payload. */
MSize             274 lj_obj.h         MSize len;		/* Size of payload. */
MSize             293 lj_obj.h         MSize sizebc;		/* Number of bytecode instructions. */
MSize             297 lj_obj.h         MSize sizekgc;	/* Number of collectable constants. */
MSize             298 lj_obj.h         MSize sizekn;		/* Number of lua_Number constants. */
MSize             299 lj_obj.h         MSize sizept;		/* Total size including colocated arrays. */
MSize             492 lj_obj.h         MSize total;		/* Memory currently allocated. */
MSize             493 lj_obj.h         MSize threshold;	/* Memory threshold. */
MSize             498 lj_obj.h         MSize sweepstr;	/* Sweep position in string table. */
MSize             505 lj_obj.h         MSize stepmul;	/* Incremental GC step granularity. */
MSize             506 lj_obj.h         MSize debt;		/* Debt (how much GC is behind schedule). */
MSize             507 lj_obj.h         MSize estimate;	/* Estimate of memory actually in use. */
MSize             508 lj_obj.h         MSize pause;		/* Pause between successive GC cycles. */
MSize             514 lj_obj.h         MSize strmask;	/* String hash mask (size of hash table - 1). */
MSize             515 lj_obj.h         MSize strnum;		/* Number of strings in hash table. */
MSize             579 lj_obj.h         MSize stacksize;	/* True stack size (incl. LJ_STACK_EXTRA). */
MSize              27 lj_opt_dce.c       MSize n, nent = snap->nent;
MSize             495 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             408 lj_opt_loop.c    MSize nsnapmap = J->cur.nsnapmap;
MSize             139 lj_opt_sink.c    MSize n, nent = snap->nent;
MSize             202 lj_opt_split.c   MSize n, nent = snap->nent;
MSize             215 lj_opt_split.c   MSize irlen = nins - nk;
MSize             216 lj_opt_split.c   MSize need = (irlen+1)*(sizeof(IRIns) + sizeof(IRRef1));
MSize              98 lj_parse.c       MSize vstart;			/* Start of block-local variables. */
MSize             136 lj_parse.c       MSize vbase;			/* Base of variable stack for this function. */
MSize            1034 lj_parse.c       MSize vtop = ls->vtop;
MSize            1089 lj_parse.c     static MSize var_lookup_uv(FuncState *fs, MSize vidx, ExpDesc *e)
MSize            1091 lj_parse.c       MSize i, n = fs->nuv;
MSize            1108 lj_parse.c     static MSize var_lookup_(FuncState *fs, GCstr *name, ExpDesc *e, int first)
MSize            1116 lj_parse.c           return (MSize)(e->u.s.aux = (uint32_t)fs->varmap[reg]);
MSize            1118 lj_parse.c           MSize vidx = var_lookup_(fs->prev, name, e, 0);  /* Var in outer func? */
MSize            1129 lj_parse.c       return (MSize)-1;  /* Global. */
MSize            1139 lj_parse.c     static MSize gola_new(LexState *ls, GCstr *name, uint8_t info, BCPos pc)
MSize            1142 lj_parse.c       MSize vtop = ls->vtop;
MSize            1280 lj_parse.c           MSize idx = gola_new(ls, NAME_BREAK, VSTACK_LABEL, fs->pc);
MSize            1309 lj_parse.c       MSize i;
MSize            1322 lj_parse.c       MSize i, n = pt->sizeuv;
MSize            1340 lj_parse.c       MSize i, hmask;
MSize            1408 lj_parse.c       MSize i = 0, n = fs->pc-1;
MSize            1439 lj_parse.c       MSize sz = ls->sb.sz * 2;
MSize            1454 lj_parse.c       MSize i;
MSize            1462 lj_parse.c       MSize n = ls->sb.n;
MSize            1474 lj_parse.c       MSize i, n;
MSize            1480 lj_parse.c         MSize len = s->len+1;
MSize            1495 lj_parse.c     	MSize len = s->len+1;
MSize            1600 lj_parse.c       pt = (GCproto *)lj_mem_newgco(L, (MSize)sizept);
MSize            1602 lj_parse.c       pt->sizept = (MSize)sizept;
MSize            2397 lj_parse.c       MSize idx;
MSize            1095 lj_record.c        if ((MSize)k < LJ_MAX_ASIZE) {  /* Potential array key? */
MSize            1098 lj_record.c          if ((MSize)k < t->asize) {  /* Currently an array key? */
MSize            1134 lj_record.c        MSize hslot = (MSize)((char *)ix->oldv - (char *)&noderef(t->node)[0].val);
MSize            1135 lj_record.c        if (t->hmask > 0 && hslot <= t->hmask*(MSize)sizeof(Node) &&
MSize            1136 lj_record.c    	hslot <= 65535*(MSize)sizeof(Node)) {
MSize            1715 lj_record.c         (MSize)((char *)pc - (char *)J->bc_min) >= J->bc_extent)
MSize            2119 lj_record.c        J->bc_extent = (MSize)(-bc_j(ins))*sizeof(BCIns);
MSize            2126 lj_record.c        J->bc_extent = (MSize)(-bc_j(ins))*sizeof(BCIns);
MSize            2137 lj_record.c          J->bc_extent = (MSize)(-bc_j(ins))*sizeof(BCIns);
MSize            2184 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              98 lj_snap.c        MSize f = 0;
MSize             117 lj_snap.c        lua_assert(f == (MSize)(1 + J->framedepth));
MSize             125 lj_snap.c        MSize nent;
MSize             128 lj_snap.c        lj_snap_grow_map(J, nsnapmap + nslots + (MSize)J->framedepth+1);
MSize             143 lj_snap.c        MSize nsnap = J->cur.nsnap;
MSize             144 lj_snap.c        MSize nsnapmap = J->cur.nsnapmap;
MSize             281 lj_snap.c        MSize n, m, nlim, nent = snap->nent;
MSize             332 lj_snap.c        MSize n = 0;
MSize             381 lj_snap.c        MSize j;
MSize             429 lj_snap.c        MSize n, nent = snap->nent;
MSize             792 lj_snap.c        MSize n, nent = snap->nent;
MSize             820 lj_snap.c      	MSize j;
MSize              57 lj_state.c       MSize oldsize = L->stacksize;
MSize              58 lj_state.c       MSize realsize = n + 1 + LJ_STACK_EXTRA;
MSize              60 lj_state.c       lua_assert((MSize)(tvref(L->maxstack)-oldst)==L->stacksize-LJ_STACK_EXTRA-1);
MSize              62 lj_state.c     				(MSize)(L->stacksize*sizeof(TValue)),
MSize              63 lj_state.c     				(MSize)(realsize*sizeof(TValue)));
MSize              99 lj_state.c       MSize n;
MSize             201 lj_state.c       g->strmask = ~(MSize)0;
MSize              26 lj_str.c         MSize i, n = a->len > b->len ? b->len : a->len;
MSize              49 lj_str.c         MSize i = 0;
MSize              72 lj_str.c         MSize i;
MSize              77 lj_str.c         for (i = g->strmask; i != ~(MSize)0; i--) {  /* Rehash old table. */
MSize              80 lj_str.c             MSize h = gco2str(p)->hash & newmask;
MSize              99 lj_str.c         MSize len = (MSize)lenx;
MSize             100 lj_str.c         MSize a, b, h = len;
MSize             226 lj_str.c         MSize i;
MSize             228 lj_str.c           MSize sz = sb->sz * 2;
MSize             240 lj_str.c           MSize sz = sb->sz * 2;
MSize             250 lj_str.c         lj_str_needbuf(L, sb, (MSize)strlen(fmt));
MSize             255 lj_str.c           addstr(L, sb, fmt, (MSize)(e-fmt));
MSize             261 lj_str.c             addstr(L, sb, s, (MSize)strlen(s));
MSize             270 lj_str.c             addstr(L, sb, p, (MSize)(buf+LJ_STR_INTBUF-p));
MSize             276 lj_str.c             MSize len;
MSize             278 lj_str.c             len = (MSize)lj_str_bufnum(buf, &tv);
MSize             299 lj_str.c             addstr(L, sb, buf, (MSize)lasti);
MSize             312 lj_str.c         addstr(L, sb, fmt, (MSize)strlen(fmt));
MSize             586 lj_tab.c       static MSize unbound_search(GCtab *t, MSize j)
MSize             589 lj_tab.c         MSize i = j;  /* i is zero or a present index */
MSize             595 lj_tab.c           if (j > (MSize)(INT_MAX-2)) {  /* overflow? */
MSize             604 lj_tab.c           MSize m = (i+j)/2;
MSize             615 lj_tab.c       MSize LJ_FASTCALL lj_tab_len(GCtab *t)
MSize             617 lj_tab.c         MSize j = (MSize)t->asize;
MSize             619 lj_tab.c           MSize i = 1;
MSize             621 lj_tab.c             MSize m = (i+j)/2;
MSize              60 lj_tab.h       #define inarray(t, key)		((MSize)(key) < (MSize)(t)->asize)
MSize              68 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       return lj_mem_newt(J->L, (MSize)sz, GCtrace);