len               223 host/buildvm.c     int len = (int)strlen(gl);
len               229 host/buildvm.c     if (!(len >= 2 && gl[len-2] == '_' && gl[len-1] == 'Z'))
len               208 host/buildvm_lib.c     int len = (int)strlen(p);
len               210 host/buildvm_lib.c       if (len > 1 && p[len-1] == '"') {
len               211 host/buildvm_lib.c 	p[len-1] = '\0';
len               235 host/buildvm_lib.c     } else if (len > 4 && !strncmp(p, "top-", 4)) {
len               345 host/buildvm_lib.c 	  size_t n, len = strlen(ldh->suffix);
len               346 host/buildvm_lib.c 	  if (!strncmp(p, ldh->suffix, len)) {
len               347 host/buildvm_lib.c 	    p += len;
len               132 host/buildvm_peobj.c   size_t len = strlen(name);
len               134 host/buildvm_peobj.c     if (len > 8) strtabofs += len+1;
len               137 host/buildvm_peobj.c   if (len <= 8) {
len               138 host/buildvm_peobj.c     memcpy(sym.n.name, name, len);
len               139 host/buildvm_peobj.c     memset(sym.n.name+len, 0, 8-len);
len               143 host/buildvm_peobj.c     memcpy(strtab + strtabofs, name, len);
len               144 host/buildvm_peobj.c     strtab[strtabofs+len] = 0;
len               145 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               206 lib_base.c       int32_t len;
len               208 lib_base.c         len = (int32_t)strV(o)->len;
len               210 lib_base.c         len = (int32_t)lj_tab_len(lj_lib_checktab(L, 1));
len               211 lib_base.c       setintV(L->top-1, len);
len               412 lib_base.c         status = luaL_loadbufferx(L, strdata(s), s->len, strdata(name ? name : s),
len               514 lib_base.c           size = strV(o)->len;
len               660 lib_ffi.c        size_t len;
len               662 lib_ffi.c          len = (size_t)ffi_checkint(L, 2);
len               668 lib_ffi.c          len = strlen(p);
len               671 lib_ffi.c        setstrV(L, o, lj_str_new(L, p, len));
len               681 lib_ffi.c        CTSize len;
len               683 lib_ffi.c          len = strV(o)->len+1;  /* Copy Lua string including trailing '\0'. */
len               685 lib_ffi.c          len = (CTSize)ffi_checkint(L, 3);
len               686 lib_ffi.c        memcpy(dp, sp, len);
len               693 lib_ffi.c        CTSize len = (CTSize)ffi_checkint(L, 2);
len               696 lib_ffi.c        memset(dp, fill, len);
len               234 lib_io.c             MSize len = strV(tv)->len;
len               235 lib_io.c             status = status && (fwrite(strVdata(tv), 1, len, fp) == len);
len               239 lib_io.c             size_t len = (size_t)(buf+LJ_STR_INTBUF-p);
len               240 lib_io.c             status = status && (fwrite(p, 1, len, fp) == len);
len               121 lib_jit.c          uint32_t h = s->len;
len               457 lib_jit.c          size_t len = *(const uint8_t *)lst;
len               458 lib_jit.c          if (len == 0)
len               460 lib_jit.c          if (strncmp(str, lst+1, len) == 0 && str[len] == '\0') {
len               464 lib_jit.c          lst += 1+len;
len               475 lib_jit.c          size_t len = *(const uint8_t *)lst;
len               476 lib_jit.c          lua_assert(len != 0);
len               477 lib_jit.c          if (strncmp(str, lst+1, len) == 0 && str[len] == '=') {
len               479 lib_jit.c            const char *p = &str[len+1];
len               488 lib_jit.c          lst += 1+len;
len                43 lib_string.c     int32_t len = (int32_t)s->len;
len                48 lib_string.c     if (stop < 0) stop += len+1;
len                49 lib_string.c     if (start < 0) start += len+1;
len                51 lib_string.c     if (stop > len) stop = len;
len                91 lib_string.c     int32_t len = (int32_t)s->len;
len               102 lib_string.c       tlen = (int64_t)len + sep->len;
len               109 lib_string.c       tlen = (int64_t)k * len;
len               117 lib_string.c       tlen -= sep->len;  /* Ignore trailing separator. */
len               120 lib_string.c         i = 0; while (i < len) *buf++ = src[i++];
len               121 lib_string.c         src = strdata(sep); len = sep->len;
len               122 lib_string.c         i = 0; while (i < len) *buf++ = src[i++];
len               123 lib_string.c         src = g->tmpbuf.buf; len += s->len; k--;  /* Now copy that k-1 times. */
len               128 lib_string.c       do { *buf++ = src[i++]; } while (i < len);
len               137 lib_string.c     lj_str_needbuf(L, &G(L)->tmpbuf, s->len);
len               181 lib_string.c       ptrdiff_t len;
len               191 lib_string.c     if (l < 0 || l >= ms->level || ms->capture[l].len == CAP_UNFINISHED)
len               200 lib_string.c       if (ms->capture[level].len == CAP_UNFINISHED) return level;
len               338 lib_string.c     ms->capture[level].len = what;
len               350 lib_string.c     ms->capture[l].len = s - ms->capture[l].init;  /* close capture */
len               352 lib_string.c       ms->capture[l].len = CAP_UNFINISHED;  /* undo capture */
len               358 lib_string.c     size_t len;
len               360 lib_string.c     len = (size_t)ms->capture[l].len;
len               361 lib_string.c     if ((size_t)(ms->src_end-s) >= len &&
len               362 lib_string.c         memcmp(ms->capture[l].init, s, len) == 0)
len               363 lib_string.c       return s+len;
len               485 lib_string.c       ptrdiff_t l = ms->capture[i].len;
len               507 lib_string.c     if (pos < 0) pos += (ptrdiff_t)len + 1;
len               581 lib_string.c     ms.src_end = s + str->len;
len               714 lib_string.c     int32_t len = (int32_t)str->len;
len               717 lib_string.c     while (len--) {
len               842 lib_string.c     const char *strfrmt_end = strfrmt + fmt->len;
len               874 lib_string.c   	  size_t len = lj_str_bufnum(nbuf, &tv);
len               876 lib_string.c   	    nbuf[len-3] = nbuf[len-3] - 0x20;
len               877 lib_string.c   	    nbuf[len-2] = nbuf[len-2] - 0x20;
len               878 lib_string.c   	    nbuf[len-1] = nbuf[len-1] - 0x20;
len               880 lib_string.c   	  nbuf[len] = '\0';
len               898 lib_string.c   	if (!strchr(form, '.') && str->len >= 100) {
len               149 lib_table.c      MSize seplen = sep ? sep->len : 0;
len               440 lj_api.c           if (len != NULL) *len = 0;
len               443 lj_api.c         if (len != NULL) *len = s->len;
len               461 lj_api.c         if (len != NULL) *len = s->len;
len               473 lj_api.c           if (len != NULL) *len = def ? strlen(def) : 0;
len               483 lj_api.c         if (len != NULL) *len = s->len;
len               504 lj_api.c           return strV(o)->len;
len               508 lj_api.c           return udataV(o)->len;
len               512 lj_api.c           return s->len;
len               587 lj_api.c         s = lj_str_new(L, str, len);
len              2883 lj_asm_x86.h     MSize len = T->szmcode;
len              2885 lj_asm_x86.h     MCode *pe = p+len-6;
len              2887 lj_asm_x86.h     if (len > 5 && p[len-5] == XI_JMP && p+len-6 + *(int32_t *)(p+len-4) == px)
len              2888 lj_asm_x86.h       *(int32_t *)(p+len-4) = jmprel(p+len, target);
len                97 lj_bc.h          _(LEN,	dst,	___,	var,	len) \
len                48 lj_bcread.c      if (ls->sb.sz < len) {
len                50 lj_bcread.c        while (len > sz) sz = sz * 2;
len                59 lj_bcread.c      lua_assert(len != 0);
len                60 lj_bcread.c      if (len > LJ_MAX_MEM || ls->current < 0)
len                71 lj_bcread.c    	bcread_resize(ls, len);
len                85 lj_bcread.c          bcread_resize(ls, n < len ? len : n);
len                93 lj_bcread.c      } while (ls->n < len);
len                99 lj_bcread.c      if (LJ_UNLIKELY(ls->n < len))
len               100 lj_bcread.c        bcread_fill(ls, len, 1);
len               106 lj_bcread.c      if (LJ_UNLIKELY(ls->n < len))
len               107 lj_bcread.c        bcread_fill(ls, len, 0);
len               111 lj_bcread.c    #define bcread_consume(ls, len)	check_exp(ls->n >= (len), ls->n -= (len))
len               117 lj_bcread.c      bcread_consume(ls, len);
len               118 lj_bcread.c      ls->p = (char *)p + len;
len               125 lj_bcread.c      memcpy(q, bcread_mem(ls, len), len);
len               205 lj_bcread.c        MSize len = tp - BCDUMP_KTAB_STR;
len               206 lj_bcread.c        const char *p = (const char *)bcread_mem(ls, len);
len               207 lj_bcread.c        setstrV(ls->L, o, lj_str_new(ls->L, p, len));
len               251 lj_bcread.c          MSize len = tp - BCDUMP_KGC_STR;
len               252 lj_bcread.c          const char *p = (const char *)bcread_mem(ls, len);
len               253 lj_bcread.c          setgcref(*kr, obj2gco(lj_str_new(ls->L, p, len)));
len               336 lj_bcread.c      MSize len, startn;
len               344 lj_bcread.c      len = bcread_uleb128(ls);
len               345 lj_bcread.c      if (!len) return NULL;  /* EOF */
len               346 lj_bcread.c      bcread_need(ls, len);
len               417 lj_bcread.c      if (len != startn - ls->n)
len               447 lj_bcread.c        MSize len = bcread_uleb128(ls);
len               448 lj_bcread.c        bcread_need(ls, len);
len               449 lj_bcread.c        ls->chunkname = lj_str_new(ls->L, (const char *)bcread_mem(ls, len), len);
len                40 lj_bcwrite.c     while (ctx->sb.n + len > sz) sz = sz * 2;
len                47 lj_bcwrite.c     if (LJ_UNLIKELY(ctx->sb.n + len > ctx->sb.sz))
len                48 lj_bcwrite.c       bcwrite_resize(ctx, len);
len                56 lj_bcwrite.c     ctx->sb.n += len;
len                57 lj_bcwrite.c     for (i = 0; i < len; i++) q[i] = ((uint8_t *)p)[i];
len                85 lj_bcwrite.c       MSize len = str->len;
len                86 lj_bcwrite.c       bcwrite_need(ctx, 5+len);
len                87 lj_bcwrite.c       bcwrite_uleb128(ctx, BCDUMP_KTAB_STR+len);
len                88 lj_bcwrite.c       bcwrite_block(ctx, strdata(str), len);
len               160 lj_bcwrite.c         tp = BCDUMP_KGC_STR + gco2str(o)->len;
len               161 lj_bcwrite.c         need = 5+gco2str(o)->len;
len               188 lj_bcwrite.c         bcwrite_block(ctx, strdata(gco2str(o)), gco2str(o)->len);
len               340 lj_bcwrite.c     MSize len = chunkname->len;
len               342 lj_bcwrite.c     bcwrite_need(ctx, 5+5+len);
len               351 lj_bcwrite.c       bcwrite_uleb128(ctx, len);
len               352 lj_bcwrite.c       bcwrite_block(ctx, name, len);
len               577 lj_cconv.c           CTSize sz = str->len+1;
len               673 lj_cconv.c       if (len*esize > sz)
len               675 lj_cconv.c       for (i = 0, ofs = 0; i < len; i++, ofs += esize)
len               695 lj_cconv.c           if (i >= len) break;
len               704 lj_cconv.c     			   dp+df->size, o, len, ip);
len               716 lj_cconv.c       cconv_substruct_init(cts, d, dp, o, len, &i);
len               717 lj_cconv.c       if (i < len)
len               740 lj_cconv.c       if (len == 0)
len               742 lj_cconv.c       else if (len == 1 && !lj_cconv_multi_init(cts, d, o))
len               745 lj_cconv.c         cconv_array_init(cts, d, sz, dp, o, len);
len               747 lj_cconv.c         cconv_struct_init(cts, d, sz, dp, o, len);
len                42 lj_cdata.c       cdatav(cd)->len = sz;
len               160 lj_cdata.c           if (name->len == 2) {
len               522 lj_cparse.c        CTSize sz = cp->str->len;
len               524 lj_cparse.c          sz += cp->str->len;
len               187 lj_crecord.c       while (ofs + step <= len) {
len               196 lj_crecord.c     } while (ofs < len);
len               232 lj_crecord.c       CTSize step = 1, len = (CTSize)IR(tref_ref(trlen))->i;
len               235 lj_crecord.c       if (len == 0) return;  /* Shortcut. */
len               236 lj_crecord.c       if (len > CREC_COPY_MAXLEN) goto fallback;
len               245 lj_crecord.c   	lua_assert((len & (step-1)) == 0);
len               259 lj_crecord.c       mlp = crec_copy_unroll(ml, len, step, tp);
len               281 lj_crecord.c       while (ofs + step <= len) {
len               290 lj_crecord.c     } while (ofs < len);
len               316 lj_crecord.c       CTSize len = (CTSize)IR(tref_ref(trlen))->i;
len               317 lj_crecord.c       if (len == 0) return;  /* Shortcut. */
len               320 lj_crecord.c       if (step * CREC_FILL_MAXUNROLL < len) goto fallback;
len               321 lj_crecord.c       mlp = crec_fill_unroll(ml, len, step);
len               823 lj_crecord.c         if (name->len == 2 &&
len               369 lj_ctype.c       if (ctr->buf + len+1 > p) { ctr->ok = 0; return; }
len               372 lj_ctype.c       p -= len;
len               373 lj_ctype.c       while (len-- > 0) p[len] = str[len];
len               427 lj_ctype.c         ctype_prepstr(ctr, strdata(str), str->len);
len               544 lj_ctype.c       if (name) ctype_prepstr(&ctr, strdata(name), name->len);
len               573 lj_ctype.c       size_t len;
len               579 lj_ctype.c       len = lj_str_bufnum(buf, &re);
len               580 lj_ctype.c       if (!(im.u32.hi & 0x80000000u) || im.n != im.n) buf[len++] = '+';
len               581 lj_ctype.c       len += lj_str_bufnum(buf+len, &im);
len               582 lj_ctype.c       buf[len] = buf[len-1] >= 'a' ? 'I' : 'i';
len               583 lj_ctype.c       return lj_str_new(L, buf, len+1);
len               607 lj_ctype.c           size_t len = strlen(name);
len               608 lj_ctype.c           GCstr *str = lj_str_new(L, name, len);
len               610 lj_ctype.c           name += len+1;
len               340 lj_debug.c         size_t len = str->len-1;
len               342 lj_debug.c         if (len >= LUA_IDSIZE) {
len               343 lj_debug.c           src += len-(LUA_IDSIZE-4);  /* Get last part of file name. */
len               348 lj_debug.c         size_t len;  /* Length, up to first control char. */
len               349 lj_debug.c         for (len = 0; len < LUA_IDSIZE-12; len++)
len               350 lj_debug.c           if (((const unsigned char *)src)[len] < ' ') break;
len               352 lj_debug.c         if (src[len] != '\0') {  /* Must truncate? */
len               353 lj_debug.c           if (len > LUA_IDSIZE-15) len = LUA_IDSIZE-15;
len               354 lj_debug.c           strncpy(out, src, len); out += len;
len               357 lj_debug.c           strcpy(out, src); out += len;
len               387 lj_debug.c       MSize i, len = name->len;
len               390 lj_debug.c         s++; len--;
len               391 lj_debug.c         for (i = len; i > 0; i--)
len               397 lj_debug.c       } else if (len > 40) {
len               233 lj_ffrecord.c      if (strV(tv)->len == 1) {
len               678 lj_ffrecord.c      end = end+(int32_t)str->len+1;
len               679 lj_ffrecord.c    } else if ((MSize)end <= str->len) {
len               683 lj_ffrecord.c      end = (int32_t)str->len;
len               689 lj_ffrecord.c      start = start+(int32_t)str->len;
len               717 lj_ffrecord.c      ptrdiff_t i, len = end - start;
len               718 lj_ffrecord.c      if (len > 0) {
len               720 lj_ffrecord.c        emitir(IRTGI(IR_EQ), trslen, lj_ir_kint(J, (int32_t)len));
len               721 lj_ffrecord.c        if (J->baseslot + len > LJ_MAX_JSLOTS)
len               723 lj_ffrecord.c        rd->nres = len;
len               724 lj_ffrecord.c        for (i = 0; i < len; i++) {
len               754 lj_ffrecord.c        MSize len = lj_tab_len(t);
len               755 lj_ffrecord.c        emitir(IRTGI(len ? IR_NE : IR_EQ), trlen, lj_ir_kint(J, 0));
len               756 lj_ffrecord.c        if (len) {
len               761 lj_ffrecord.c  	setintV(&ix.keyv, len);
len               832 lj_ffrecord.c      TRef len = emitir(IRTI(IR_FLOAD), str, IRFL_STR_LEN);
len               833 lj_ffrecord.c      if (tref_isk(len) && IR(tref_ref(len))->i == 1) {
len               839 lj_ffrecord.c        TRef tr = lj_ir_call(J, IRCALL_fwrite, buf, one, len, fp);
len               841 lj_ffrecord.c  	emitir(IRTGI(IR_EQ), tr, len);
len               186 lj_ir.h          _(STR_LEN,	offsetof(GCstr, len)) \
len               126 lj_jit.h       #define JIT_PARAMSTR(len, name, value)	#len #name
len                62 lj_lib.c           MSize len = tag & LIBINIT_LENMASK;
len                74 lj_lib.c             p += len;
len                83 lj_lib.c             if (len) {
len                85 lj_lib.c       	setfuncV(L, lj_tab_setstr(L, tab, lj_str_new(L, name, len)), fn);
len                89 lj_lib.c             switch (tag | len) {
len                92 lj_lib.c       	if (tvisstr(L->top+1) && strV(L->top+1)->len == 0)
len               115 lj_lib.c       	setstrV(L, L->top++, lj_str_new(L, (const char *)p, len));
len               116 lj_lib.c       	p += len;
len               247 lj_lib.c           MSize len = s->len;
len               250 lj_lib.c             if (*(const uint8_t *)lst == len && memcmp(opt, lst+1, len) == 0)
len               274 lj_meta.c          } else if (strV(top)->len == 0) {  /* Shortcut. */
len               284 lj_meta.c            MSize tlen = strV(top)->len;
len               288 lj_meta.c      	MSize len = strV(top-n)->len;
len               289 lj_meta.c      	if (len >= LJ_MAX_STR - tlen)
len               291 lj_meta.c      	tlen += len;
len               297 lj_meta.c      	MSize len = strV(top-i)->len;
len               298 lj_meta.c      	memcpy(buffer + tlen, strVdata(top-i), len);
len               299 lj_meta.c      	tlen += len;
len               229 lj_obj.h         MSize len;		/* Size of string. */
len               236 lj_obj.h       #define sizestring(s)	(sizeof(struct GCstr)+(s)->len+1)
len               246 lj_obj.h         MSize len;		/* Size of payload. */
len               260 lj_obj.h       #define sizeudata(u)	(sizeof(struct GCudata)+(u)->len)
len               274 lj_obj.h         MSize len;		/* Size of payload. */
len               280 lj_obj.h       #define cdatavlen(cd)	check_exp(cdataisv(cd), cdatav(cd)->len)
len               459 lj_obj.h         _(index) _(newindex) _(gc) _(mode) _(eq) _(len) \
len               495 lj_opt_fold.c    lua_assert((MSize)fright->i <= str->len);
len              1819 lj_opt_fold.c    int32_t len = (int32_t)kstr->len;
len              1831 lj_opt_fold.c    if (len <= FOLD_SNEW_MAX_LEN) {
len              1837 lj_opt_fold.c        emitir(IRTGI(IR_EQ), fleft->op2, lj_ir_kint(J, len));
len              1843 lj_opt_fold.c        if (IR(fleft->op2)->i != len)
len              1846 lj_opt_fold.c      if (len > 0) {
len              1848 lj_opt_fold.c        uint16_t ot = (uint16_t)(len == 1 ? IRT(IR_XLOAD, FOLD_SNEW_TYPE8) :
len              1849 lj_opt_fold.c  			       len == 2 ? IRT(IR_XLOAD, IRT_U16) :
len              1852 lj_opt_fold.c  			IRXLOAD_READONLY | (len > 1 ? IRXLOAD_UNALIGNED : 0));
len              1854 lj_opt_fold.c        if (len == 3)
len              2005 lj_opt_fold.c      return INTFOLD((int32_t)ir_kstr(fleft)->len);
len               235 lj_parse.c       GCstr *s = lj_str_new(L, str, len);
len              1440 lj_parse.c       while (ls->sb.n + len > sz) sz = sz * 2;
len              1446 lj_parse.c       if (LJ_UNLIKELY(ls->sb.n + len > ls->sb.sz))
len              1447 lj_parse.c         fs_buf_resize(ls, len);
len              1455 lj_parse.c       ls->sb.n += len;
len              1456 lj_parse.c       for (i = 0; i < len; i++) p[i] = str[i];
len              1480 lj_parse.c         MSize len = s->len+1;
len              1481 lj_parse.c         fs_buf_need(ls, len);
len              1482 lj_parse.c         fs_buf_str(ls, strdata(s), len);
len              1495 lj_parse.c     	MSize len = s->len+1;
len              1496 lj_parse.c     	fs_buf_need(ls, len + 2*5);
len              1497 lj_parse.c     	fs_buf_str(ls, strdata(s), len);
len              2549 lj_parse.c       return (name->len == 5 && !strcmp(strdata(name), "pairs")) ||
len              2550 lj_parse.c     	 (name->len == 4 && !strcmp(strdata(name), "next"));
len                26 lj_str.c         MSize i, n = a->len > b->len ? b->len : a->len;
len                43 lj_str.c         return (int32_t)(a->len - b->len);
len                50 lj_str.c         lua_assert(len > 0);
len                51 lj_str.c         lua_assert((((uintptr_t)a+len-1) & (LJ_PAGESIZE-1)) <= LJ_PAGESIZE-4);
len                55 lj_str.c             i -= len;
len                63 lj_str.c         } while (i < len);
len                99 lj_str.c         MSize len = (MSize)lenx;
len               100 lj_str.c         MSize a, b, h = len;
len               105 lj_str.c         if (len >= 4) {  /* Caveat: unaligned access! */
len               107 lj_str.c           h ^= lj_getu32(str+len-4);
len               108 lj_str.c           b = lj_getu32(str+(len>>1)-2);
len               110 lj_str.c           b += lj_getu32(str+(len>>2)-1);
len               111 lj_str.c         } else if (len > 0) {
len               113 lj_str.c           h ^= *(const uint8_t *)(str+len-1);
len               114 lj_str.c           b = *(const uint8_t *)(str+(len>>1));
len               124 lj_str.c         if (LJ_LIKELY((((uintptr_t)str+len-1) & (LJ_PAGESIZE-1)) <= LJ_PAGESIZE-4)) {
len               127 lj_str.c             if (sx->len == len && str_fastcmp(str, strdata(sx), len) == 0) {
len               137 lj_str.c             if (sx->len == len && memcmp(str, strdata(sx), len) == 0) {
len               146 lj_str.c         s = lj_mem_newt(L, sizeof(GCstr)+len+1, GCstr);
len               149 lj_str.c         s->len = len;
len               152 lj_str.c         memcpy(strdatawr(s), str, len);
len               153 lj_str.c         strdatawr(s)[len] = '\0';  /* Zero-terminate string. */
len               204 lj_str.c         size_t len = lj_str_bufnum(buf, (TValue *)np);
len               205 lj_str.c         return lj_str_new(L, buf, len);
len               227 lj_str.c         if (sb->n + len > sb->sz) {
len               229 lj_str.c           while (sb->n + len > sz) sz = sz * 2;
len               233 lj_str.c         sb->n += len;
len               234 lj_str.c         for (i = 0; i < len; i++) p[i] = str[i];
len               276 lj_str.c             MSize len;
len               278 lj_str.c             len = (MSize)lj_str_bufnum(buf, &tv);
len               279 lj_str.c             addstr(L, sb, buf, len);
len                20 lj_udata.c       ud->len = sz;
len               149 lua.h          LUA_API const char     *(lua_tolstring) (lua_State *L, int idx, size_t *len);
len               223 luajit.c           size_t len = strlen(buf);
len               224 luajit.c           if (len > 0 && buf[len-1] == '\n')
len               225 luajit.c             buf[len-1] = '\0';