len               224 host/buildvm.c     int len = (int)strlen(gl);
len               230 host/buildvm.c     if (!(len >= 2 && gl[len-2] == '_' && gl[len-1] == 'Z'))
len               197 host/buildvm_lib.c 	int len = libbc_map[i+1].ofs - ofs;
len               201 host/buildvm_lib.c 	memcpy(optr, libbc_code + ofs, len);
len               203 host/buildvm_lib.c 	optr += len;
len               266 host/buildvm_lib.c     int len = (int)strlen(p);
len               268 host/buildvm_lib.c       if (len > 1 && p[len-1] == '"') {
len               269 host/buildvm_lib.c 	p[len-1] = '\0';
len               293 host/buildvm_lib.c     } else if (len > 4 && !strncmp(p, "top-", 4)) {
len               404 host/buildvm_lib.c 	  size_t n, len = strlen(ldh->suffix);
len               405 host/buildvm_lib.c 	  if (!strncmp(p, ldh->suffix, len)) {
len               406 host/buildvm_lib.c 	    p += len;
len               134 host/buildvm_peobj.c   size_t len = strlen(name);
len               136 host/buildvm_peobj.c     if (len > 8) strtabofs += len+1;
len               139 host/buildvm_peobj.c   if (len <= 8) {
len               140 host/buildvm_peobj.c     memcpy(sym.n.name, name, len);
len               141 host/buildvm_peobj.c     memset(sym.n.name+len, 0, 8-len);
len               145 host/buildvm_peobj.c     memcpy(strtab + strtabofs, name, len);
len               146 host/buildvm_peobj.c     strtab[strtabofs+len] = 0;
len               147 host/buildvm_peobj.c     strtabofs += len+1;
len               277 host/minilua.c size_t len;
len               288 host/minilua.c size_t len;
len               590 host/minilua.c #define sizestring(s)(sizeof(union TString)+((s)->len+1)*sizeof(char))
len               591 host/minilua.c #define sizeudata(u)(sizeof(union Udata)+(u)->len)
len               750 host/minilua.c size_t len=strcspn(source,"\n\r");
len               752 host/minilua.c if(len>bufflen)len=bufflen;
len               754 host/minilua.c if(source[len]!='\0'){
len               755 host/minilua.c strncat(out,source,len);
len              1290 host/minilua.c ts->tsv.len=l;
len              1317 host/minilua.c if(ts->tsv.len==l&&(memcmp(str,getstr(ts),l)==0)){
len              1331 host/minilua.c u->uv.len=s;
len              3670 host/minilua.c luaX_newstring(ls,getstr(ts),ts->tsv.len);
len              4816 host/minilua.c size_t ll=ls->tsv.len;
len              4818 host/minilua.c size_t lr=rs->tsv.len;
len              4823 host/minilua.c size_t len=strlen(l);
len              4824 host/minilua.c if(len==lr)
len              4825 host/minilua.c return(len==ll)?0:1;
len              4826 host/minilua.c else if(len==ll)
len              4828 host/minilua.c len++;
len              4829 host/minilua.c l+=len;ll-=len;r+=len;lr-=len;
len              4890 host/minilua.c }else if(tsvalue(top-1)->len==0)
len              4893 host/minilua.c size_t tl=tsvalue(top-1)->len;
len              4897 host/minilua.c size_t l=tsvalue(top-n-1)->len;
len              4904 host/minilua.c size_t l=tsvalue(top-i)->len;
len              5072 host/minilua.c setnvalue(ra,cast_num(tsvalue(rb)->len));
len              5484 host/minilua.c if(len!=NULL)*len=0;
len              5490 host/minilua.c if(len!=NULL)*len=tsvalue(o)->len;
len              5496 host/minilua.c case 4:return tsvalue(o)->len;
len              5497 host/minilua.c case 7:return uvalue(o)->len;
len              5501 host/minilua.c l=(luaV_tostring(L,o)?tsvalue(o)->len:0);
len              5533 host/minilua.c setsvalue(L,L->top,luaS_newlstr(L,s,len));
len              5952 host/minilua.c const char*s=lua_tolstring(L,narg,len);
len              5959 host/minilua.c if(len)
len              5960 host/minilua.c *len=(def?strlen(def):0);
len              5963 host/minilua.c else return luaL_checklstring(L,narg,len);
len              6999 host/minilua.c if(pos<0)pos+=(ptrdiff_t)len+1;
len              7084 host/minilua.c ptrdiff_t len;
len              7089 host/minilua.c if(l<0||l>=ms->level||ms->capture[l].len==(-1))
len              7096 host/minilua.c if(ms->capture[level].len==(-1))return level;
len              7215 host/minilua.c ms->capture[level].len=what;
len              7225 host/minilua.c ms->capture[l].len=s-ms->capture[l].init;
len              7227 host/minilua.c ms->capture[l].len=(-1);
len              7231 host/minilua.c size_t len;
len              7233 host/minilua.c len=ms->capture[l].len;
len              7234 host/minilua.c if((size_t)(ms->src_end-s)>=len&&
len              7235 host/minilua.c memcmp(ms->capture[l].init,s,len)==0)
len              7236 host/minilua.c return s+len;
len              7344 host/minilua.c ptrdiff_t l=ms->capture[i].len;
len               211 lib_base.c       int32_t len;
len               213 lib_base.c         len = (int32_t)strV(o)->len;
len               215 lib_base.c         len = (int32_t)lj_tab_len(lj_lib_checktab(L, 1));
len               216 lib_base.c       setintV(L->top-1, len);
len               401 lib_base.c         status = luaL_loadbufferx(L, strdata(s), s->len, strdata(name ? name : s),
len               501 lib_base.c         MSize len;
len               502 lib_base.c         if (shortcut && (str = lj_strfmt_wstrnum(L, o, &len)) != NULL) {
len               503 lib_base.c           size = len;
len               683 lib_ffi.c        size_t len;
len               685 lib_ffi.c          len = (size_t)ffi_checkint(L, 2);
len               691 lib_ffi.c          len = strlen(p);
len               694 lib_ffi.c        setstrV(L, o, lj_str_new(L, p, len));
len               704 lib_ffi.c        CTSize len;
len               706 lib_ffi.c          len = strV(o)->len+1;  /* Copy Lua string including trailing '\0'. */
len               708 lib_ffi.c          len = (CTSize)ffi_checkint(L, 3);
len               709 lib_ffi.c        memcpy(dp, sp, len);
len               716 lib_ffi.c        CTSize len = (CTSize)ffi_checkint(L, 2);
len               719 lib_ffi.c        memset(dp, fill, len);
len               234 lib_io.c           MSize len;
len               235 lib_io.c           const char *p = lj_strfmt_wstrnum(L, tv, &len);
len               238 lib_io.c           status = status && (fwrite(p, 1, len, fp) == len);
len               126 lib_jit.c          uint32_t h = s->len;
len               475 lib_jit.c          size_t len = *(const uint8_t *)lst;
len               476 lib_jit.c          if (len == 0)
len               478 lib_jit.c          if (strncmp(str, lst+1, len) == 0 && str[len] == '\0') {
len               482 lib_jit.c          lst += 1+len;
len               493 lib_jit.c          size_t len = *(const uint8_t *)lst;
len               494 lib_jit.c          lua_assert(len != 0);
len               495 lib_jit.c          if (strncmp(str, lst+1, len) == 0 && str[len] == '=') {
len               497 lib_jit.c            const char *p = &str[len+1];
len               506 lib_jit.c          lst += 1+len;
len               608 lib_jit.c        size_t len;
len               618 lib_jit.c        p = luaJIT_profile_dumpstack(L2, strdata(fmt), depth, &len);
len               619 lib_jit.c        lua_pushlstring(L, p, len);
len               215 lib_os.c             size_t len = strftime(buf, sbufsz(sb), s, stm);
len               216 lib_os.c             if (len) {
len               217 lib_os.c       	setstrV(L, L->top++, lj_str_new(L, buf, len));
len                44 lib_string.c     int32_t len = (int32_t)s->len;
len                49 lib_string.c     if (stop < 0) stop += len+1;
len                50 lib_string.c     if (start < 0) start += len+1;
len                52 lib_string.c     if (stop > len) stop = len;
len               152 lib_string.c       ptrdiff_t len;
len               161 lib_string.c     if (l < 0 || l >= ms->level || ms->capture[l].len == CAP_UNFINISHED)
len               170 lib_string.c       if (ms->capture[level].len == CAP_UNFINISHED) return level;
len               308 lib_string.c     ms->capture[level].len = what;
len               320 lib_string.c     ms->capture[l].len = s - ms->capture[l].init;  /* close capture */
len               322 lib_string.c       ms->capture[l].len = CAP_UNFINISHED;  /* undo capture */
len               328 lib_string.c     size_t len;
len               330 lib_string.c     len = (size_t)ms->capture[l].len;
len               331 lib_string.c     if ((size_t)(ms->src_end-s) >= len &&
len               332 lib_string.c         memcmp(ms->capture[l].init, s, len) == 0)
len               333 lib_string.c       return s+len;
len               431 lib_string.c       ptrdiff_t l = ms->capture[i].len;
len               456 lib_string.c     if (start < 0) start += (int32_t)s->len; else start--;
len               459 lib_string.c     if (st > s->len) {
len               464 lib_string.c       st = s->len;
len               469 lib_string.c       const char *q = lj_str_find(strdata(s)+st, strdata(p), s->len-st, p->len);
len               472 lib_string.c         setintV(L->top-1, (int32_t)(q-strdata(s)) + (int32_t)p->len);
len               483 lib_string.c       ms.src_end = strdata(s) + s->len;
len               523 lib_string.c     ms.src_end = s + str->len;
len               673 lib_string.c     lj_strfmt_init(&fs, strdata(fmt), fmt->len);
len               676 lib_string.c         lj_buf_putmem(sb, fs.str, fs.len);
len               678 lib_string.c         lj_err_callerv(L, LJ_ERR_STRFMT, strdata(lj_str_new(L, fs.str, fs.len)));
len               503 lj_api.c           if (len != NULL) *len = 0;
len               506 lj_api.c         if (len != NULL) *len = s->len;
len               524 lj_api.c         if (len != NULL) *len = s->len;
len               536 lj_api.c           if (len != NULL) *len = def ? strlen(def) : 0;
len               546 lj_api.c         if (len != NULL) *len = s->len;
len               567 lj_api.c           return strV(o)->len;
len               571 lj_api.c           return udataV(o)->len;
len               575 lj_api.c           return s->len;
len               640 lj_api.c         s = lj_str_new(L, str, len);
len              1129 lj_asm.c           if (s->len == 1) {  /* Optimize put of single-char string constant. */
len              3098 lj_asm_x86.h     MSize len = T->szmcode;
len              3100 lj_asm_x86.h     MCode *pe = p+len-6;
len              3106 lj_asm_x86.h     if (len > 5 && p[len-5] == XI_JMP && p+len-6 + *(int32_t *)(p+len-4) == px)
len              3107 lj_asm_x86.h       *(int32_t *)(p+len-4) = jmprel(p+len, target);
len                99 lj_bc.h          _(LEN,	dst,	___,	var,	len) \
len                50 lj_bcread.c      lua_assert(len != 0);
len                51 lj_bcread.c      if (len > LJ_MAX_BUF || ls->c < 0)
len                63 lj_bcread.c    	p = lj_buf_need(&ls->sb, len);
len                78 lj_bcread.c          p = lj_buf_need(&ls->sb, n < len ? len : n);
len                87 lj_bcread.c      } while (ls->p + len > ls->pe);
len                93 lj_bcread.c      if (LJ_UNLIKELY(ls->p + len > ls->pe))
len                94 lj_bcread.c        bcread_fill(ls, len, 1);
len               100 lj_bcread.c      if (LJ_UNLIKELY(ls->p + len > ls->pe))
len               101 lj_bcread.c        bcread_fill(ls, len, 0);
len               108 lj_bcread.c      ls->p += len;
len               116 lj_bcread.c      memcpy(q, bcread_mem(ls, len), len);
len               185 lj_bcread.c        MSize len = tp - BCDUMP_KTAB_STR;
len               186 lj_bcread.c        const char *p = (const char *)bcread_mem(ls, len);
len               187 lj_bcread.c        setstrV(ls->L, o, lj_str_new(ls->L, p, len));
len               231 lj_bcread.c          MSize len = tp - BCDUMP_KGC_STR;
len               232 lj_bcread.c          const char *p = (const char *)bcread_mem(ls, len);
len               233 lj_bcread.c          setgcref(*kr, obj2gco(lj_str_new(ls->L, p, len)));
len               413 lj_bcread.c        MSize len = bcread_uleb128(ls);
len               414 lj_bcread.c        bcread_need(ls, len);
len               415 lj_bcread.c        ls->chunkname = lj_str_new(ls->L, (const char *)bcread_mem(ls, len), len);
len               432 lj_bcread.c        MSize len;
len               440 lj_bcread.c        len = bcread_uleb128(ls);
len               441 lj_bcread.c        if (!len) break;  /* EOF */
len               442 lj_bcread.c        bcread_need(ls, len);
len               445 lj_bcread.c        if (ls->p != startp + len)
len                42 lj_bcwrite.c       MSize len = str->len;
len                43 lj_bcwrite.c       p = lj_buf_more(&ctx->sb, 5+len);
len                44 lj_bcwrite.c       p = lj_strfmt_wuleb128(p, BCDUMP_KTAB_STR+len);
len                45 lj_bcwrite.c       p = lj_buf_wmem(p, strdata(str), len);
len               121 lj_bcwrite.c         tp = BCDUMP_KGC_STR + gco2str(o)->len;
len               122 lj_bcwrite.c         need = 5+gco2str(o)->len;
len               149 lj_bcwrite.c         p = lj_buf_wmem(p, strdata(gco2str(o)), gco2str(o)->len);
len               305 lj_bcwrite.c     MSize len = chunkname->len;
len               306 lj_bcwrite.c     char *p = lj_buf_need(&ctx->sb, 5+5+len);
len               316 lj_bcwrite.c       p = lj_strfmt_wuleb128(p, len);
len               317 lj_bcwrite.c       p = lj_buf_wmem(p, name, len);
len                21 lj_buf.c         MSize osz = sbufsz(sb), len = sbuflen(sb), nsz = osz;
len                27 lj_buf.c         setmref(sb->p, b + len);
len                42 lj_buf.c         MSize len = sbuflen(sb);
len                44 lj_buf.c         if (LJ_UNLIKELY(sz > LJ_MAX_BUF || len + sz > LJ_MAX_BUF))
len                46 lj_buf.c         buf_grow(sb, len + sz);
len                74 lj_buf.c         char *p = lj_buf_more(sb, len);
len                75 lj_buf.c         p = lj_buf_wmem(p, q, len);
len                90 lj_buf.c         MSize len = s->len;
len                91 lj_buf.c         char *p = lj_buf_more(sb, len);
len                92 lj_buf.c         p = lj_buf_wmem(p, strdata(s), len);
len               101 lj_buf.c         MSize len = s->len;
len               102 lj_buf.c         char *p = lj_buf_more(sb, len), *e = p+len;
len               103 lj_buf.c         const char *q = strdata(s)+len-1;
len               112 lj_buf.c         MSize len = s->len;
len               113 lj_buf.c         char *p = lj_buf_more(sb, len), *e = p+len;
len               130 lj_buf.c         MSize len = s->len;
len               131 lj_buf.c         char *p = lj_buf_more(sb, len), *e = p+len;
len               148 lj_buf.c         MSize len = s->len;
len               149 lj_buf.c         if (rep > 0 && len) {
len               150 lj_buf.c           uint64_t tlen = (uint64_t)rep * len;
len               155 lj_buf.c           if (len == 1) {  /* Optimize a common case. */
len               159 lj_buf.c             const char *e = strdata(s) + len;
len               172 lj_buf.c         MSize seplen = sep ? sep->len : 0;
len               182 lj_buf.c       	MSize len = strV(o)->len;
len               183 lj_buf.c       	p = lj_buf_wmem(lj_buf_more(sb, len + seplen), strVdata(o), len);
len               212 lj_buf.c         MSize len1 = s1->len, len2 = s2->len;
len                75 lj_buf.h         return (char *)memcpy(p, q, len) + len;
len               579 lj_cconv.c           CTSize sz = str->len+1;
len               675 lj_cconv.c       if (len*esize > sz)
len               677 lj_cconv.c       for (i = 0, ofs = 0; i < len; i++, ofs += esize)
len               697 lj_cconv.c           if (i >= len) break;
len               706 lj_cconv.c     			   dp+df->size, o, len, ip);
len               718 lj_cconv.c       cconv_substruct_init(cts, d, dp, o, len, &i);
len               719 lj_cconv.c       if (i < len)
len               742 lj_cconv.c       if (len == 0)
len               744 lj_cconv.c       else if (len == 1 && !lj_cconv_multi_init(cts, d, o))
len               747 lj_cconv.c         cconv_array_init(cts, d, sz, dp, o, len);
len               749 lj_cconv.c         cconv_struct_init(cts, d, sz, dp, o, len);
len                41 lj_cdata.c       cdatav(cd)->len = sz;
len               174 lj_cdata.c           if (name->len == 2) {
len               508 lj_cparse.c        CTSize sz = cp->str->len;
len               510 lj_cparse.c          sz += cp->str->len;
len               188 lj_crecord.c       while (ofs + step <= len) {
len               197 lj_crecord.c     } while (ofs < len);
len               233 lj_crecord.c       CTSize step = 1, len = (CTSize)IR(tref_ref(trlen))->i;
len               236 lj_crecord.c       if (len == 0) return;  /* Shortcut. */
len               237 lj_crecord.c       if (len > CREC_COPY_MAXLEN) goto fallback;
len               246 lj_crecord.c   	lua_assert((len & (step-1)) == 0);
len               260 lj_crecord.c       mlp = crec_copy_unroll(ml, len, step, tp);
len               282 lj_crecord.c       while (ofs + step <= len) {
len               291 lj_crecord.c     } while (ofs < len);
len               317 lj_crecord.c       CTSize len = (CTSize)IR(tref_ref(trlen))->i;
len               318 lj_crecord.c       if (len == 0) return;  /* Shortcut. */
len               321 lj_crecord.c       if (step * CREC_FILL_MAXUNROLL < len) goto fallback;
len               322 lj_crecord.c       mlp = crec_fill_unroll(ml, len, step);
len               892 lj_crecord.c         if (name->len == 2 &&
len               373 lj_ctype.c       if (ctr->buf + len+1 > p) { ctr->ok = 0; return; }
len               376 lj_ctype.c       p -= len;
len               377 lj_ctype.c       while (len-- > 0) p[len] = str[len];
len               431 lj_ctype.c         ctype_prepstr(ctr, strdata(str), str->len);
len               548 lj_ctype.c       if (name) ctype_prepstr(&ctr, strdata(name), name->len);
len               610 lj_ctype.c           size_t len = strlen(name);
len               611 lj_ctype.c           GCstr *str = lj_str_new(L, name, len);
len               613 lj_ctype.c           name += len+1;
len               326 lj_debug.c         size_t len = str->len-1;
len               328 lj_debug.c         if (len >= LUA_IDSIZE) {
len               329 lj_debug.c           src += len-(LUA_IDSIZE-4);  /* Get last part of file name. */
len               334 lj_debug.c         size_t len;  /* Length, up to first control char. */
len               335 lj_debug.c         for (len = 0; len < LUA_IDSIZE-12; len++)
len               336 lj_debug.c           if (((const unsigned char *)src)[len] < ' ') break;
len               338 lj_debug.c         if (src[len] != '\0') {  /* Must truncate? */
len               339 lj_debug.c           if (len > LUA_IDSIZE-15) len = LUA_IDSIZE-15;
len               340 lj_debug.c           strncpy(out, src, len); out += len;
len               343 lj_debug.c           strcpy(out, src); out += len;
len               374 lj_debug.c       MSize i, len = name->len;
len               379 lj_debug.c         s++; len--;
len               380 lj_debug.c         for (i = len; i > 0; i--)
len               386 lj_debug.c       } else if (len > 40) {
len               557 lj_debug.c         MSize len = name->len-1;
len               561 lj_debug.c           for (i = len-1; i >= 0; i--)
len               563 lj_debug.c     	  len -= i+1;
len               568 lj_debug.c         lj_buf_putmem(sb, p, len);
len               294 lj_ffrecord.c      if (strV(tv)->len == 1) {
len               757 lj_ffrecord.c      start = start + (int32_t)s->len;
len               815 lj_ffrecord.c      end = end+(int32_t)str->len+1;
len               816 lj_ffrecord.c    } else if ((MSize)end <= str->len) {
len               820 lj_ffrecord.c      end = (int32_t)str->len;
len               836 lj_ffrecord.c      ptrdiff_t i, len = end - start;
len               837 lj_ffrecord.c      if (len > 0) {
len               839 lj_ffrecord.c        emitir(IRTGI(IR_EQ), trslen, lj_ir_kint(J, (int32_t)len));
len               840 lj_ffrecord.c        if (J->baseslot + len > LJ_MAX_JSLOTS)
len               842 lj_ffrecord.c        rd->nres = len;
len               843 lj_ffrecord.c        for (i = 0; i < len; i++) {
len               926 lj_ffrecord.c    if ((MSize)start <= str->len) {
len               935 lj_ffrecord.c      start = str->len;
len               949 lj_ffrecord.c  		    str->len-(MSize)start, pat->len)) {
len               977 lj_ffrecord.c    lj_strfmt_init(&fs, strdata(fmt), fmt->len);
len               985 lj_ffrecord.c  		  lj_ir_kstr(J, lj_str_new(J->L, fs.str, fs.len)));
len              1146 lj_ffrecord.c      TRef len = emitir(IRTI(IR_FLOAD), str, IRFL_STR_LEN);
len              1147 lj_ffrecord.c      if (tref_isk(len) && IR(tref_ref(len))->i == 1) {
len              1156 lj_ffrecord.c        TRef tr = lj_ir_call(J, IRCALL_fwrite, buf, one, len, fp);
len              1158 lj_ffrecord.c  	emitir(IRTGI(IR_EQ), tr, len);
len               194 lj_ir.h          _(STR_LEN,	offsetof(GCstr, len)) \
len               129 lj_jit.h       #define JIT_PARAMSTR(len, name, value)	#len #name
len                51 lj_lib.c         int len = *p++;
len                52 lj_lib.c         GCstr *name = lj_str_new(L, (const char *)p, len);
len                58 lj_lib.c         ls.p = (const char *)(p+len);
len                87 lj_lib.c           MSize len = tag & LIBINIT_LENMASK;
len                99 lj_lib.c             p += len;
len               108 lj_lib.c             if (len) {
len               110 lj_lib.c       	setfuncV(L, lj_tab_setstr(L, tab, lj_str_new(L, name, len)), fn);
len               114 lj_lib.c             switch (tag | len) {
len               120 lj_lib.c       	if (tvisstr(L->top+1) && strV(L->top+1)->len == 0)
len               143 lj_lib.c       	setstrV(L, L->top++, lj_str_new(L, (const char *)p, len));
len               144 lj_lib.c       	p += len;
len               292 lj_lib.c           MSize len = s->len;
len               295 lj_lib.c             if (*(const uint8_t *)lst == len && memcmp(opt, lst+1, len) == 0)
len               280 lj_meta.c            uint64_t tlen = tvisstr(o) ? strV(o)->len : STRFMT_MAXBUF_NUM;
len               283 lj_meta.c      	o--; tlen += tvisstr(o) ? strV(o)->len : STRFMT_MAXBUF_NUM;
len               291 lj_meta.c      	  MSize len = s->len;
len               292 lj_meta.c      	  lj_buf_putmem(sb, strdata(s), len);
len               296 lj_obj.h         MSize len;		/* Size of string. */
len               303 lj_obj.h       #define sizestring(s)	(sizeof(struct GCstr)+(s)->len+1)
len               313 lj_obj.h         MSize len;		/* Size of payload. */
len               327 lj_obj.h       #define sizeudata(u)	(sizeof(struct GCudata)+(u)->len)
len               341 lj_obj.h         MSize len;		/* Size of payload. */
len               347 lj_obj.h       #define cdatavlen(cd)	check_exp(cdataisv(cd), cdatav(cd)->len)
len               541 lj_obj.h         _(index) _(newindex) _(gc) _(mode) _(eq) _(len) \
len               499 lj_opt_fold.c    lua_assert((MSize)fright->i <= str->len);
len               576 lj_opt_fold.c      if (s2->len == 0) {  /* Empty string? */
len              2042 lj_opt_fold.c    int32_t len = (int32_t)kstr->len;
len              2054 lj_opt_fold.c    if (len <= FOLD_SNEW_MAX_LEN) {
len              2060 lj_opt_fold.c        emitir(IRTGI(IR_EQ), fleft->op2, lj_ir_kint(J, len));
len              2066 lj_opt_fold.c        if (IR(fleft->op2)->i != len)
len              2069 lj_opt_fold.c      if (len > 0) {
len              2071 lj_opt_fold.c        uint16_t ot = (uint16_t)(len == 1 ? IRT(IR_XLOAD, FOLD_SNEW_TYPE8) :
len              2072 lj_opt_fold.c  			       len == 2 ? IRT(IR_XLOAD, IRT_U16) :
len              2075 lj_opt_fold.c  			IRXLOAD_READONLY | (len > 1 ? IRXLOAD_UNALIGNED : 0));
len              2077 lj_opt_fold.c        if (len == 3)
len              2229 lj_opt_fold.c      return INTFOLD((int32_t)ir_kstr(fleft)->len);
len               237 lj_parse.c       GCstr *s = lj_str_new(L, str, len);
len              1448 lj_parse.c         MSize len = s->len+1;
len              1449 lj_parse.c         char *p = lj_buf_more(&ls->sb, len);
len              1450 lj_parse.c         p = lj_buf_wmem(p, strdata(s), len);
len              1465 lj_parse.c     	MSize len = s->len+1;
len              1466 lj_parse.c     	p = lj_buf_more(&ls->sb, len + 2*5);
len              1467 lj_parse.c     	p = lj_buf_wmem(p, strdata(s), len);
len              2519 lj_parse.c       return (name->len == 5 && !strcmp(strdata(name), "pairs")) ||
len              2520 lj_parse.c     	 (name->len == 4 && !strcmp(strdata(name), "next"));
len               364 lj_profile.c     *len = (size_t)sbuflen(sb);
len                20 lj_str.c         MSize i, n = a->len > b->len ? b->len : a->len;
len                37 lj_str.c         return (int32_t)(a->len - b->len);
len                44 lj_str.c         lua_assert(len > 0);
len                45 lj_str.c         lua_assert((((uintptr_t)a+len-1) & (LJ_PAGESIZE-1)) <= LJ_PAGESIZE-4);
len                49 lj_str.c             i -= len;
len                57 lj_str.c         } while (i < len);
len                84 lj_str.c         const char *p = strdata(s), *q = p + s->len;
len               127 lj_str.c         MSize len = (MSize)lenx;
len               128 lj_str.c         MSize a, b, h = len;
len               133 lj_str.c         if (len >= 4) {  /* Caveat: unaligned access! */
len               135 lj_str.c           h ^= lj_getu32(str+len-4);
len               136 lj_str.c           b = lj_getu32(str+(len>>1)-2);
len               138 lj_str.c           b += lj_getu32(str+(len>>2)-1);
len               139 lj_str.c         } else if (len > 0) {
len               141 lj_str.c           h ^= *(const uint8_t *)(str+len-1);
len               142 lj_str.c           b = *(const uint8_t *)(str+(len>>1));
len               152 lj_str.c         if (LJ_LIKELY((((uintptr_t)str+len-1) & (LJ_PAGESIZE-1)) <= LJ_PAGESIZE-4)) {
len               155 lj_str.c             if (sx->len == len && str_fastcmp(str, strdata(sx), len) == 0) {
len               165 lj_str.c             if (sx->len == len && memcmp(str, strdata(sx), len) == 0) {
len               174 lj_str.c         s = lj_mem_newt(L, sizeof(GCstr)+len+1, GCstr);
len               177 lj_str.c         s->len = len;
len               180 lj_str.c         memcpy(strdatawr(s), str, len);
len               181 lj_str.c         strdatawr(s)[len] = '\0';  /* Zero-terminate string. */
len                78 lj_strfmt.c    	fs->len = (MSize)(p - (const uint8_t *)fs->str);
len                86 lj_strfmt.c      fs->len = (MSize)(p - (const uint8_t *)fs->str);
len                87 lj_strfmt.c      return fs->len ? STRFMT_LIT : STRFMT_EOF;
len               162 lj_strfmt.c        *lenp = strV(o)->len;
len               202 lj_strfmt.c      MSize len = str->len;
len               204 lj_strfmt.c      while (len--) {
len               245 lj_strfmt.c      MSize len = str->len <= STRFMT_PREC(sf) ? str->len : STRFMT_PREC(sf);
len               247 lj_strfmt.c      char *p = lj_buf_more(sb, width > len ? width : len);
len               248 lj_strfmt.c      if ((sf & STRFMT_F_LEFT)) p = lj_buf_wmem(p, strdata(str), len);
len               249 lj_strfmt.c      while (width-- > len) *p++ = ' ';
len               250 lj_strfmt.c      if (!(sf & STRFMT_F_LEFT)) p = lj_buf_wmem(p, strdata(str), len);
len               262 lj_strfmt.c      MSize prefix = 0, len, prec, pprec, width, need;
len               299 lj_strfmt.c      len = (MSize)(buf + sizeof(buf) - q);
len               300 lj_strfmt.c      if ((int32_t)len >= (int32_t)prec) prec = len;
len               318 lj_strfmt.c      while (prec-- > len) *p++ = '0';
len               355 lj_strfmt.c      MSize len = (MSize)(lj_strfmt_wint(buf, k) - buf);
len               356 lj_strfmt.c      return lj_str_new(L, buf, len);
len               426 lj_strfmt.c          lj_buf_putmem(sb, fs.str, fs.len);
len                18 lj_strfmt.h      MSize len;		/* Size of literal string. */
len                81 lj_strfmt.h      fs->e = (const uint8_t *)p + len;
len               271 lj_strfmt_num.c   MSize width = STRFMT_WIDTH(sf), prec = STRFMT_PREC(sf), len;
len               286 lj_strfmt_num.c     len = 3 + (prefix != 0);
len               287 lj_strfmt_num.c     if (!p) p = lj_buf_more(sb, width > len ? width : len);
len               288 lj_strfmt_num.c     if (!(sf & STRFMT_F_LEFT)) while (width-- > len) *p++ = ' ';
len               323 lj_strfmt_num.c     len = 5 + ndigits_dec((uint32_t)e) + prec + (prefix != 0)
len               325 lj_strfmt_num.c     if (!p) p = lj_buf_more(sb, width > len ? width : len);
len               327 lj_strfmt_num.c       while (width-- > len) *p++ = ' ';
len               333 lj_strfmt_num.c       while (width-- > len) *p++ = '0';
len               468 lj_strfmt_num.c       len = 3 + prec + (prefix != 0) + ndigits_dec((uint32_t)nde) + (nde < 10)
len               470 lj_strfmt_num.c       if (!p) p = lj_buf_more(sb, (width > len ? width : len) + 5);
len               472 lj_strfmt_num.c 	while (width-- > len) *p++ = ' ';
len               476 lj_strfmt_num.c 	while (width-- > len) *p++ = '0';
len               536 lj_strfmt_num.c       len = ndhi * 9 + ndigits_dec(nd[ndhi]) + prec + (prefix != 0)
len               538 lj_strfmt_num.c       if (!p) p = lj_buf_more(sb, (width > len ? width : len) + 8);
len               540 lj_strfmt_num.c 	while (width-- > len) *p++ = ' ';
len               544 lj_strfmt_num.c 	while (width-- > len) *p++ = '0';
len               572 lj_strfmt_num.c   if ((sf & STRFMT_F_LEFT)) while (width-- > len) *p++ = ' ';
len               589 lj_strfmt_num.c   MSize len = (MSize)(lj_strfmt_wfnum(NULL, STRFMT_G14, o->n, buf) - buf);
len               590 lj_strfmt_num.c   return lj_str_new(L, buf, len);
len                20 lj_udata.c       ud->len = sz;
len               150 lua.h          LUA_API const char     *(lua_tolstring) (lua_State *L, int idx, size_t *len);
len               215 luajit.c           size_t len = strlen(buf);
len               216 luajit.c           if (len > 0 && buf[len-1] == '\n')
len               217 luajit.c             buf[len-1] = '\0';