LuaJIT
/
LuaJIT
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

String buffers, part 2a: internal SBuf reorg. Use full pointers. 

Sponsored by fmad.io.
master
Mike Pall 2021-06-01 00:45:06 +02:00
parent b5dafe5891
commit 394fb6267a
24 changed files with 153 additions and 160 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
src/lib_buffer.c
View File

@ -38,15 +38,14 @@ LJLIB_CF(buffer_encode)
LJLIB_CF(buffer_decode)
{
GCstr *str = lj_lib_checkstr(L, 1);
const char *p = strdata(str);
char *p = (char *)strdata(str);
SBuf sb;
StrBuf sbuf;
setsbufL(&sb, L);
setmref(sb.b, p);
setmref(sb.p, p + str->len);
setmref(sb.e, p + str->len);
sb.b = p;
sb.w = sb.e = p + str->len;
sbuf.sb = &sb;
sbuf.r = (char *)p;
sbuf.r = p;
setnilV(L->top++);
lj_serialize_get(&sbuf, L->top-1);
lj_gc_check(L);

2
src/lib_table.c
View File

@ -159,7 +159,7 @@ LJLIB_CF(table_concat) LJLIB_REC(.)
SBuf *sb = lj_buf_tmp_(L);
SBuf *sbx = lj_buf_puttab(sb, t, sep, i, e);
if (LJ_UNLIKELY(!sbx)) { /* Error: bad element type. */
int32_t idx = (int32_t)(intptr_t)sbufP(sb);
int32_t idx = (int32_t)(intptr_t)sb->w;
cTValue *o = lj_tab_getint(t, idx);
lj_err_callerv(L, LJ_ERR_TABCAT,
lj_obj_itypename[o ? itypemap(o) : ~LJ_TNIL], idx);

2
src/lj_asm.c
View File

@ -1163,7 +1163,7 @@ static void asm_bufhdr(ASMState *as, IRIns *ir)
} else {
Reg tmp = ra_scratch(as, rset_exclude(RSET_GPR, sb));
/* Passing ir isn't strictly correct, but it's an IRT_PGC, too. */
emit_storeofs(as, ir, tmp, sb, offsetof(SBuf, p));
emit_storeofs(as, ir, tmp, sb, offsetof(SBuf, w));
emit_loadofs(as, ir, tmp, sb, offsetof(SBuf, b));
}
#if LJ_TARGET_X86ORX64

10
src/lj_bcread.c
View File

@ -53,11 +53,11 @@ static LJ_NOINLINE void bcread_fill(LexState *ls, MSize len, int need)
do {
const char *buf;
size_t sz;
char *p = sbufB(&ls->sb);
char *p = ls->sb.b;
MSize n = (MSize)(ls->pe - ls->p);
if (n) { /* Copy remainder to buffer. */
if (sbuflen(&ls->sb)) { /* Move down in buffer. */
lj_assertLS(ls->pe == sbufP(&ls->sb), "bad buffer pointer");
lj_assertLS(ls->pe == ls->sb.w, "bad buffer pointer");
if (ls->p != p) memmove(p, ls->p, n);
} else { /* Copy from buffer provided by reader. */
p = lj_buf_need(&ls->sb, len);
@ -66,7 +66,7 @@ static LJ_NOINLINE void bcread_fill(LexState *ls, MSize len, int need)
ls->p = p;
ls->pe = p + n;
}
setsbufP(&ls->sb, p + n);
ls->sb.w = p + n;
buf = ls->rfunc(ls->L, ls->rdata, &sz); /* Get more data from reader. */
if (buf == NULL || sz == 0) { /* EOF? */
if (need) bcread_error(ls, LJ_ERR_BCBAD);
@ -77,8 +77,8 @@ static LJ_NOINLINE void bcread_fill(LexState *ls, MSize len, int need)
if (n) { /* Append to buffer. */
n += (MSize)sz;
p = lj_buf_need(&ls->sb, n < len ? len : n);
memcpy(sbufP(&ls->sb), buf, sz);
setsbufP(&ls->sb, p + n);
memcpy(ls->sb.w, buf, sz);
ls->sb.w = p + n;
ls->p = p;
ls->pe = p + n;
} else { /* Return buffer provided by reader. */

22
src/lj_bcwrite.c
View File

@ -62,7 +62,7 @@ static void bcwrite_ktabk(BCWriteCtx *ctx, cTValue *o, int narrow)
if (num == (lua_Number)k) { /* -0 is never a constant. */
*p++ = BCDUMP_KTAB_INT;
p = lj_strfmt_wuleb128(p, k);
setsbufP(&ctx->sb, p);
ctx->sb.w = p;
return;
}
}
@ -73,7 +73,7 @@ static void bcwrite_ktabk(BCWriteCtx *ctx, cTValue *o, int narrow)
lj_assertBCW(tvispri(o), "unhandled type %d", itype(o));
*p++ = BCDUMP_KTAB_NIL+~itype(o);
}
setsbufP(&ctx->sb, p);
ctx->sb.w = p;
}
/* Write a template table. */
@ -97,7 +97,7 @@ static void bcwrite_ktab(BCWriteCtx *ctx, char *p, const GCtab *t)
/* Write number of array slots and hash slots. */
p = lj_strfmt_wuleb128(p, narray);
p = lj_strfmt_wuleb128(p, nhash);
setsbufP(&ctx->sb, p);
ctx->sb.w = p;
if (narray) { /* Write array entries (may contain nil). */
MSize i;
TValue *o = tvref(t->array);
@ -172,7 +172,7 @@ static void bcwrite_kgc(BCWriteCtx *ctx, GCproto *pt)
}
#endif
}
setsbufP(&ctx->sb, p);
ctx->sb.w = p;
}
}
@ -206,7 +206,7 @@ static void bcwrite_knum(BCWriteCtx *ctx, GCproto *pt)
p = lj_strfmt_wuleb128(p, o->u32.hi);
}
}
setsbufP(&ctx->sb, p);
ctx->sb.w = p;
}
/* Write bytecode instructions. */
@ -281,7 +281,7 @@ static void bcwrite_proto(BCWriteCtx *ctx, GCproto *pt)
/* Write bytecode instructions and upvalue refs. */
p = bcwrite_bytecode(ctx, p, pt);
p = lj_buf_wmem(p, proto_uv(pt), pt->sizeuv*2);
setsbufP(&ctx->sb, p);
ctx->sb.w = p;
/* Write constants. */
bcwrite_kgc(ctx, pt);
@ -291,16 +291,16 @@ static void bcwrite_proto(BCWriteCtx *ctx, GCproto *pt)
if (sizedbg) {
p = lj_buf_more(&ctx->sb, sizedbg);
p = lj_buf_wmem(p, proto_lineinfo(pt), sizedbg);
setsbufP(&ctx->sb, p);
ctx->sb.w = p;
}
/* Pass buffer to writer function. */
if (ctx->status == 0) {
MSize n = sbuflen(&ctx->sb) - 5;
MSize nn = (lj_fls(n)+8)*9 >> 6;
char *q = sbufB(&ctx->sb) + (5 - nn);
char *q = ctx->sb.b + (5 - nn);
p = lj_strfmt_wuleb128(q, n); /* Fill in final size. */
lj_assertBCW(p == sbufB(&ctx->sb) + 5, "bad ULEB128 write");
lj_assertBCW(p == ctx->sb.b + 5, "bad ULEB128 write");
ctx->status = ctx->wfunc(sbufL(&ctx->sb), q, nn+n, ctx->wdata);
}
}
@ -324,8 +324,8 @@ static void bcwrite_header(BCWriteCtx *ctx)
p = lj_strfmt_wuleb128(p, len);
p = lj_buf_wmem(p, name, len);
}
ctx->status = ctx->wfunc(sbufL(&ctx->sb), sbufB(&ctx->sb),
(MSize)(p - sbufB(&ctx->sb)), ctx->wdata);
ctx->status = ctx->wfunc(sbufL(&ctx->sb), ctx->sb.b,
(MSize)(p - ctx->sb.b), ctx->wdata);
}
/* Write footer of bytecode dump. */

106
src/lj_buf.c
View File

@ -22,10 +22,10 @@ static void buf_grow(SBuf *sb, MSize sz)
char *b;
if (nsz < LJ_MIN_SBUF) nsz = LJ_MIN_SBUF;
while (nsz < sz) nsz += nsz;
b = (char *)lj_mem_realloc(sbufL(sb), sbufB(sb), osz, nsz);
setmref(sb->b, b);
setmref(sb->p, b + len);
setmref(sb->e, b + nsz);
b = (char *)lj_mem_realloc(sbufL(sb), sb->b, osz, nsz);
sb->b = b;
sb->w = b + len;
sb->e = b + nsz;
}
LJ_NOINLINE char *LJ_FASTCALL lj_buf_need2(SBuf *sb, MSize sz)
@ -34,7 +34,7 @@ LJ_NOINLINE char *LJ_FASTCALL lj_buf_need2(SBuf *sb, MSize sz)
if (LJ_UNLIKELY(sz > LJ_MAX_BUF))
lj_err_mem(sbufL(sb));
buf_grow(sb, sz);
return sbufB(sb);
return sb->b;
}
LJ_NOINLINE char *LJ_FASTCALL lj_buf_more2(SBuf *sb, MSize sz)
@ -44,19 +44,19 @@ LJ_NOINLINE char *LJ_FASTCALL lj_buf_more2(SBuf *sb, MSize sz)
if (LJ_UNLIKELY(sz > LJ_MAX_BUF || len + sz > LJ_MAX_BUF))
lj_err_mem(sbufL(sb));
buf_grow(sb, len + sz);
return sbufP(sb);
return sb->w;
}
void LJ_FASTCALL lj_buf_shrink(lua_State *L, SBuf *sb)
{
char *b = sbufB(sb);
MSize osz = (MSize)(sbufE(sb) - b);
char *b = sb->b;
MSize osz = (MSize)(sb->e - b);
if (osz > 2*LJ_MIN_SBUF) {
MSize n = (MSize)(sbufP(sb) - b);
MSize n = (MSize)(sb->w - b);
b = lj_mem_realloc(L, b, osz, (osz >> 1));
setmref(sb->b, b);
setmref(sb->p, b + n);
setmref(sb->e, b + (osz >> 1));
sb->b = b;
sb->w = b + n;
sb->e = b + (osz >> 1);
}
}
@ -71,26 +71,26 @@ char * LJ_FASTCALL lj_buf_tmp(lua_State *L, MSize sz)
SBuf *lj_buf_putmem(SBuf *sb, const void *q, MSize len)
{
char *p = lj_buf_more(sb, len);
p = lj_buf_wmem(p, q, len);
setsbufP(sb, p);
char *w = lj_buf_more(sb, len);
w = lj_buf_wmem(w, q, len);
sb->w = w;
return sb;
}
SBuf * LJ_FASTCALL lj_buf_putchar(SBuf *sb, int c)
{
char *p = lj_buf_more(sb, 1);
*p++ = (char)c;
setsbufP(sb, p);
char *w = lj_buf_more(sb, 1);
*w++ = (char)c;
sb->w = w;
return sb;
}
SBuf * LJ_FASTCALL lj_buf_putstr(SBuf *sb, GCstr *s)
{
MSize len = s->len;
char *p = lj_buf_more(sb, len);
p = lj_buf_wmem(p, strdata(s), len);
setsbufP(sb, p);
char *w = lj_buf_more(sb, len);
w = lj_buf_wmem(w, strdata(s), len);
sb->w = w;
return sb;
}
@ -99,47 +99,47 @@ SBuf * LJ_FASTCALL lj_buf_putstr(SBuf *sb, GCstr *s)
SBuf * LJ_FASTCALL lj_buf_putstr_reverse(SBuf *sb, GCstr *s)
{
MSize len = s->len;
char *p = lj_buf_more(sb, len), *e = p+len;
char *w = lj_buf_more(sb, len), *e = w+len;
const char *q = strdata(s)+len-1;
while (p < e)
*p++ = *q--;
setsbufP(sb, p);
while (w < e)
*w++ = *q--;
sb->w = w;
return sb;
}
SBuf * LJ_FASTCALL lj_buf_putstr_lower(SBuf *sb, GCstr *s)
{
MSize len = s->len;
char *p = lj_buf_more(sb, len), *e = p+len;
char *w = lj_buf_more(sb, len), *e = w+len;
const char *q = strdata(s);
for (; p < e; p++, q++) {
for (; w < e; w++, q++) {
uint32_t c = *(unsigned char *)q;
#if LJ_TARGET_PPC
*p = c + ((c >= 'A' && c <= 'Z') << 5);
*w = c + ((c >= 'A' && c <= 'Z') << 5);
#else
if (c >= 'A' && c <= 'Z') c += 0x20;
*p = c;
*w = c;
#endif
}
setsbufP(sb, p);
sb->w = w;
return sb;
}
SBuf * LJ_FASTCALL lj_buf_putstr_upper(SBuf *sb, GCstr *s)
{
MSize len = s->len;
char *p = lj_buf_more(sb, len), *e = p+len;
char *w = lj_buf_more(sb, len), *e = w+len;
const char *q = strdata(s);
for (; p < e; p++, q++) {
for (; w < e; w++, q++) {
uint32_t c = *(unsigned char *)q;
#if LJ_TARGET_PPC
*p = c - ((c >= 'a' && c <= 'z') << 5);
*w = c - ((c >= 'a' && c <= 'z') << 5);
#else
if (c >= 'a' && c <= 'z') c -= 0x20;
*p = c;
*w = c;
#endif
}
setsbufP(sb, p);
sb->w = w;
return sb;
}
@ -148,21 +148,21 @@ SBuf *lj_buf_putstr_rep(SBuf *sb, GCstr *s, int32_t rep)
MSize len = s->len;
if (rep > 0 && len) {
uint64_t tlen = (uint64_t)rep * len;
char *p;
char *w;
if (LJ_UNLIKELY(tlen > LJ_MAX_STR))
lj_err_mem(sbufL(sb));
p = lj_buf_more(sb, (MSize)tlen);
w = lj_buf_more(sb, (MSize)tlen);
if (len == 1) { /* Optimize a common case. */
uint32_t c = strdata(s)[0];
do { *p++ = c; } while (--rep > 0);
do { *w++ = c; } while (--rep > 0);
} else {
const char *e = strdata(s) + len;
do {
const char *q = strdata(s);
do { *p++ = *q++; } while (q < e);
do { *w++ = *q++; } while (q < e);
} while (--rep > 0);
}
setsbufP(sb, p);
sb->w = w;
}
return sb;
}
@ -173,27 +173,27 @@ SBuf *lj_buf_puttab(SBuf *sb, GCtab *t, GCstr *sep, int32_t i, int32_t e)
if (i <= e) {
for (;;) {
cTValue *o = lj_tab_getint(t, i);
char *p;
char *w;
if (!o) {
badtype: /* Error: bad element type. */
setsbufP(sb, (void *)(intptr_t)i); /* Store failing index. */
sb->w = (char *)(intptr_t)i; /* Store failing index. */
return NULL;
} else if (tvisstr(o)) {
MSize len = strV(o)->len;
p = lj_buf_wmem(lj_buf_more(sb, len + seplen), strVdata(o), len);
w = lj_buf_wmem(lj_buf_more(sb, len + seplen), strVdata(o), len);
} else if (tvisint(o)) {
p = lj_strfmt_wint(lj_buf_more(sb, STRFMT_MAXBUF_INT+seplen), intV(o));
w = lj_strfmt_wint(lj_buf_more(sb, STRFMT_MAXBUF_INT+seplen), intV(o));
} else if (tvisnum(o)) {
p = lj_buf_more(lj_strfmt_putfnum(sb, STRFMT_G14, numV(o)), seplen);
w = lj_buf_more(lj_strfmt_putfnum(sb, STRFMT_G14, numV(o)), seplen);
} else {
goto badtype;
}
if (i++ == e) {
setsbufP(sb, p);
sb->w = w;
break;
}
if (seplen) p = lj_buf_wmem(p, strdata(sep), seplen);
setsbufP(sb, p);
if (seplen) w = lj_buf_wmem(w, strdata(sep), seplen);
sb->w = w;
}
}
return sb;
@ -203,7 +203,7 @@ SBuf *lj_buf_puttab(SBuf *sb, GCtab *t, GCstr *sep, int32_t i, int32_t e)
GCstr * LJ_FASTCALL lj_buf_tostr(SBuf *sb)
{
return lj_str_new(sbufL(sb), sbufB(sb), sbuflen(sb));
return lj_str_new(sbufL(sb), sb->b, sbuflen(sb));
}
/* Concatenate two strings. */
@ -219,14 +219,14 @@ GCstr *lj_buf_cat2str(lua_State *L, GCstr *s1, GCstr *s2)
/* Read ULEB128 from buffer. */
uint32_t LJ_FASTCALL lj_buf_ruleb128(const char **pp)
{
const uint8_t *p = (const uint8_t *)*pp;
uint32_t v = *p++;
const uint8_t *w = (const uint8_t *)*pp;
uint32_t v = *w++;
if (LJ_UNLIKELY(v >= 0x80)) {
int sh = 0;
v &= 0x7f;
do { v |= ((*p & 0x7f) << (sh += 7)); } while (*p++ >= 0x80);
do { v |= ((*w & 0x7f) << (sh += 7)); } while (*w++ >= 0x80);
}
*pp = (const char *)p;
*pp = (const char *)w;
return v;
}

29
src/lj_buf.h
View File

@ -11,14 +11,11 @@
#include "lj_str.h"
/* Resizable string buffers. SBuf struct definition in lj_obj.h. */
#define sbufB(sb) (mref((sb)->b, char))
#define sbufP(sb) (mref((sb)->p, char))
#define sbufE(sb) (mref((sb)->e, char))
#define sbufsz(sb) ((MSize)((sb)->e - (sb)->b))
#define sbuflen(sb) ((MSize)((sb)->w - (sb)->b))
#define sbufleft(sb) ((MSize)((sb)->e - (sb)->w))
#define sbufL(sb) (mref((sb)->L, lua_State))
#define sbufsz(sb) ((MSize)(sbufE((sb)) - sbufB((sb))))
#define sbuflen(sb) ((MSize)(sbufP((sb)) - sbufB((sb))))
#define sbufleft(sb) ((MSize)(sbufE((sb)) - sbufP((sb))))
#define setsbufP(sb, q) (setmref((sb)->p, (q)))
#define setsbufL(sb, l) (setmref((sb)->L, (l)))
/* Buffer management */
@ -30,12 +27,12 @@ LJ_FUNC char * LJ_FASTCALL lj_buf_tmp(lua_State *L, MSize sz);
static LJ_AINLINE void lj_buf_init(lua_State *L, SBuf *sb)
{
setsbufL(sb, L);
setmref(sb->p, NULL); setmref(sb->e, NULL); setmref(sb->b, NULL);
sb->w = sb->e = sb->b = NULL;
}
static LJ_AINLINE void lj_buf_reset(SBuf *sb)
{
setmrefr(sb->p, sb->b);
sb->w = sb->b;
}
static LJ_AINLINE SBuf *lj_buf_tmp_(lua_State *L)
@ -48,21 +45,21 @@ static LJ_AINLINE SBuf *lj_buf_tmp_(lua_State *L)
static LJ_AINLINE void lj_buf_free(global_State *g, SBuf *sb)
{
lj_mem_free(g, sbufB(sb), sbufsz(sb));
lj_mem_free(g, sb->b, sbufsz(sb));
}
static LJ_AINLINE char *lj_buf_need(SBuf *sb, MSize sz)
{
if (LJ_UNLIKELY(sz > sbufsz(sb)))
return lj_buf_need2(sb, sz);
return sbufB(sb);
return sb->b;
}
static LJ_AINLINE char *lj_buf_more(SBuf *sb, MSize sz)
{
if (LJ_UNLIKELY(sz > sbufleft(sb)))
return lj_buf_more2(sb, sz);
return sbufP(sb);
return sb->w;
}
/* Low-level buffer put operations */
@ -77,9 +74,9 @@ static LJ_AINLINE char *lj_buf_wmem(char *p, const void *q, MSize len)
static LJ_AINLINE void lj_buf_putb(SBuf *sb, int c)
{
char *p = lj_buf_more(sb, 1);
*p++ = (char)c;
setsbufP(sb, p);
char *w = lj_buf_more(sb, 1);
*w++ = (char)c;
sb->w = w;
}
/* High-level buffer put operations */
@ -97,7 +94,7 @@ LJ_FUNC uint32_t LJ_FASTCALL lj_buf_ruleb128(const char **pp);
static LJ_AINLINE GCstr *lj_buf_str(lua_State *L, SBuf *sb)
{
return lj_str_new(L, sbufB(sb), sbuflen(sb));
return lj_str_new(L, sb->b, sbuflen(sb));
}
/* Interim user-accessible string buffer. */

8
src/lj_cparse.c
View File

@ -133,9 +133,9 @@ LJ_NORET static void cp_errmsg(CPState *cp, CPToken tok, ErrMsg em, ...)
tokstr = NULL;
} else if (tok == CTOK_IDENT || tok == CTOK_INTEGER || tok == CTOK_STRING ||
tok >= CTOK_FIRSTDECL) {
if (sbufP(&cp->sb) == sbufB(&cp->sb)) cp_save(cp, '$');
if (cp->sb.w == cp->sb.b) cp_save(cp, '$');
cp_save(cp, '\0');
tokstr = sbufB(&cp->sb);
tokstr = cp->sb.b;
} else {
tokstr = cp_tok2str(cp, tok);
}
@ -175,7 +175,7 @@ static CPToken cp_number(CPState *cp)
TValue o;
do { cp_save(cp, cp->c); } while (lj_char_isident(cp_get(cp)));
cp_save(cp, '\0');
fmt = lj_strscan_scan((const uint8_t *)sbufB(&cp->sb), sbuflen(&cp->sb)-1,
fmt = lj_strscan_scan((const uint8_t *)(cp->sb.b), sbuflen(&cp->sb)-1,
&o, STRSCAN_OPT_C);
if (fmt == STRSCAN_INT) cp->val.id = CTID_INT32;
else if (fmt == STRSCAN_U32) cp->val.id = CTID_UINT32;
@ -279,7 +279,7 @@ static CPToken cp_string(CPState *cp)
return CTOK_STRING;
} else {
if (sbuflen(&cp->sb) != 1) cp_err_token(cp, '\'');
cp->val.i32 = (int32_t)(char)*sbufB(&cp->sb);
cp->val.i32 = (int32_t)(char)*cp->sb.b;
cp->val.id = CTID_INT32;
return CTOK_INTEGER;
}

2
src/lj_ctype.c
View File

@ -583,7 +583,7 @@ GCstr *lj_ctype_repr_complex(lua_State *L, void *sp, CTSize size)
lj_strfmt_putfnum(sb, STRFMT_G14, re.n);
if (!(im.u32.hi & 0x80000000u) || im.n != im.n) lj_buf_putchar(sb, '+');
lj_strfmt_putfnum(sb, STRFMT_G14, im.n);
lj_buf_putchar(sb, sbufP(sb)[-1] >= 'a' ? 'I' : 'i');
lj_buf_putchar(sb, sb->w[-1] >= 'a' ? 'I' : 'i');
return lj_buf_str(L, sb);
}

2
src/lj_debug.c
View File

@ -648,7 +648,7 @@ void lj_debug_dumpstack(lua_State *L, SBuf *sb, const char *fmt, int depth)
level += dir;
}
if (lastlen)
setsbufP(sb, sbufB(sb) + lastlen); /* Zap trailing separator. */
sb->w = sb->b + lastlen; /* Zap trailing separator. */
}
#endif

10
src/lj_lex.c
View File

@ -105,7 +105,7 @@ static void lex_number(LexState *ls, TValue *tv)
lex_savenext(ls);
}
lex_save(ls, '\0');
fmt = lj_strscan_scan((const uint8_t *)sbufB(&ls->sb), sbuflen(&ls->sb)-1, tv,
fmt = lj_strscan_scan((const uint8_t *)ls->sb.b, sbuflen(&ls->sb)-1, tv,
(LJ_DUALNUM ? STRSCAN_OPT_TOINT : STRSCAN_OPT_TONUM) |
(LJ_HASFFI ? (STRSCAN_OPT_LL|STRSCAN_OPT_IMAG) : 0));
if (LJ_DUALNUM && fmt == STRSCAN_INT) {
@ -180,7 +180,7 @@ static void lex_longstring(LexState *ls, TValue *tv, int sep)
}
} endloop:
if (tv) {
GCstr *str = lj_parse_keepstr(ls, sbufB(&ls->sb) + (2 + (MSize)sep),
GCstr *str = lj_parse_keepstr(ls, ls->sb.b + (2 + (MSize)sep),
sbuflen(&ls->sb) - 2*(2 + (MSize)sep));
setstrV(ls->L, tv, str);
}
@ -286,7 +286,7 @@ static void lex_string(LexState *ls, TValue *tv)
}
lex_savenext(ls); /* Skip trailing delimiter. */
setstrV(ls->L, tv,
lj_parse_keepstr(ls, sbufB(&ls->sb)+1, sbuflen(&ls->sb)-2));
lj_parse_keepstr(ls, ls->sb.b+1, sbuflen(&ls->sb)-2));
}
/* -- Main lexical scanner ------------------------------------------------ */
@ -306,7 +306,7 @@ static LexToken lex_scan(LexState *ls, TValue *tv)
do {
lex_savenext(ls);
} while (lj_char_isident(ls->c));
s = lj_parse_keepstr(ls, sbufB(&ls->sb), sbuflen(&ls->sb));
s = lj_parse_keepstr(ls, ls->sb.b, sbuflen(&ls->sb));
setstrV(ls->L, tv, s);
if (s->reserved > 0) /* Reserved word? */
return TK_OFS + s->reserved;
@ -496,7 +496,7 @@ void lj_lex_error(LexState *ls, LexToken tok, ErrMsg em, ...)
tokstr = NULL;
} else if (tok == TK_name || tok == TK_string || tok == TK_number) {
lex_save(ls, '\0');
tokstr = sbufB(&ls->sb);
tokstr = ls->sb.b;
} else {
tokstr = lj_lex_token2str(ls, tok);
}

6
src/lj_obj.h
View File

@ -153,11 +153,9 @@ typedef int32_t BCLine; /* Bytecode line number. */
typedef void (*ASMFunction)(void);
/* Resizable string buffer. Need this here, details in lj_buf.h. */
#define SBufHeader char *w, *e, *b; MRef L
typedef struct SBuf {
MRef p; /* String buffer pointer. */
MRef e; /* String buffer end pointer. */
MRef b; /* String buffer base. */
MRef L; /* lua_State, used for buffer resizing. */
SBufHeader;
} SBuf;
/* -- Tags and values ----------------------------------------------------- */

6
src/lj_parse.c
View File

@ -1465,7 +1465,7 @@ static size_t fs_prep_var(LexState *ls, FuncState *fs, size_t *ofsvar)
MSize len = s->len+1;
char *p = lj_buf_more(&ls->sb, len);
p = lj_buf_wmem(p, strdata(s), len);
setsbufP(&ls->sb, p);
ls->sb.w = p;
}
*ofsvar = sbuflen(&ls->sb);
lastpc = 0;
@ -1486,7 +1486,7 @@ static size_t fs_prep_var(LexState *ls, FuncState *fs, size_t *ofsvar)
startpc = vs->startpc;
p = lj_strfmt_wuleb128(p, startpc-lastpc);
p = lj_strfmt_wuleb128(p, vs->endpc-startpc);
setsbufP(&ls->sb, p);
ls->sb.w = p;
lastpc = startpc;
}
}
@ -1499,7 +1499,7 @@ static void fs_fixup_var(LexState *ls, GCproto *pt, uint8_t *p, size_t ofsvar)
{
setmref(pt->uvinfo, p);
setmref(pt->varinfo, (char *)p + ofsvar);
memcpy(p, sbufB(&ls->sb), sbuflen(&ls->sb)); /* Copy from temp. buffer. */
memcpy(p, ls->sb.b, sbuflen(&ls->sb)); /* Copy from temp. buffer. */
}
#else

5
src/lj_profile.c
View File

@ -346,8 +346,7 @@ LUA_API void luaJIT_profile_stop(lua_State *L)
lj_trace_flushall(L);
#endif
lj_buf_free(g, &ps->sb);
setmref(ps->sb.b, NULL);
setmref(ps->sb.e, NULL);
ps->sb.w = ps->sb.e = NULL;
ps->g = NULL;
}
}
@ -362,7 +361,7 @@ LUA_API const char *luaJIT_profile_dumpstack(lua_State *L, const char *fmt,
lj_buf_reset(sb);
lj_debug_dumpstack(L, sb, fmt, depth);
*len = (size_t)sbuflen(sb);
return sbufB(sb);
return sb->b;
}
#endif

10
src/lj_serialize.c
View File

@ -57,8 +57,8 @@ LJ_STATIC_ASSERT((SER_TAG_TAB & 7) == 0);
static LJ_AINLINE char *serialize_more(char *w, StrBuf *sbuf, MSize sz)
{
if (LJ_UNLIKELY(sz > (MSize)(sbufE(sbuf->sb) - w))) {
setsbufP(sbuf->sb, w);
if (LJ_UNLIKELY(sz > (MSize)(sbuf->sb->e - w))) {
sbuf->sb->w = w;
w = lj_buf_more2(sbuf->sb, sz);
}
return w;
@ -245,7 +245,7 @@ static char *serialize_put(char *w, StrBuf *sbuf, cTValue *o)
/* Get serialized object from buffer. */
static char *serialize_get(char *r, StrBuf *sbuf, TValue *o)
{
char *e = sbufE(sbuf->sb);
char *e = sbuf->sb->e;
uint32_t tp;
r = serialize_ru124(r, e, &tp); if (LJ_UNLIKELY(!r)) goto eob;
if (LJ_LIKELY(tp >= SER_TAG_STR)) {
@ -340,14 +340,14 @@ eob:
StrBuf * LJ_FASTCALL lj_serialize_put(StrBuf *sbuf, cTValue *o)
{
sbuf->depth = LJ_SERIALIZE_DEPTH;
setsbufP(sbuf->sb, serialize_put(sbufP(sbuf->sb), sbuf, o));
sbuf->sb->w = serialize_put(sbuf->sb->w, sbuf, o);
return sbuf;
}
StrBuf * LJ_FASTCALL lj_serialize_get(StrBuf *sbuf, TValue *o)
{
char *r = serialize_get(sbuf->r, sbuf, o);
if (r != sbufP(sbuf->sb))
if (r != sbuf->sb->w)
lj_err_caller(sbufL(sbuf->sb), LJ_ERR_BUFFER_LEFTOV);
sbuf->r = r;
return sbuf;

66
src/lj_strfmt.c
View File

@ -169,7 +169,7 @@ const char *lj_strfmt_wstrnum(lua_State *L, cTValue *o, MSize *lenp)
return NULL;
}
*lenp = sbuflen(sb);
return sbufB(sb);
return sb->b;
}
/* -- Unformatted conversions to buffer ----------------------------------- */
@ -177,7 +177,7 @@ const char *lj_strfmt_wstrnum(lua_State *L, cTValue *o, MSize *lenp)
/* Add integer to buffer. */
SBuf * LJ_FASTCALL lj_strfmt_putint(SBuf *sb, int32_t k)
{
setsbufP(sb, lj_strfmt_wint(lj_buf_more(sb, STRFMT_MAXBUF_INT), k));
sb->w = lj_strfmt_wint(lj_buf_more(sb, STRFMT_MAXBUF_INT), k);
return sb;
}
@ -191,7 +191,7 @@ SBuf * LJ_FASTCALL lj_strfmt_putnum(SBuf *sb, cTValue *o)
SBuf * LJ_FASTCALL lj_strfmt_putptr(SBuf *sb, const void *v)
{
setsbufP(sb, lj_strfmt_wptr(lj_buf_more(sb, STRFMT_MAXBUF_PTR), v));
sb->w = lj_strfmt_wptr(lj_buf_more(sb, STRFMT_MAXBUF_PTR), v);
return sb;
}
@ -203,23 +203,23 @@ SBuf * LJ_FASTCALL lj_strfmt_putquoted(SBuf *sb, GCstr *str)
lj_buf_putb(sb, '"');
while (len--) {
uint32_t c = (uint32_t)(uint8_t)*s++;
char *p = lj_buf_more(sb, 4);
char *w = lj_buf_more(sb, 4);
if (c == '"' || c == '\\' || c == '\n') {
*p++ = '\\';
*w++ = '\\';
} else if (lj_char_iscntrl(c)) { /* This can only be 0-31 or 127. */
uint32_t d;
*p++ = '\\';
*w++ = '\\';
if (c >= 100 || lj_char_isdigit((uint8_t)*s)) {
*p++ = (char)('0'+(c >= 100)); if (c >= 100) c -= 100;
*w++ = (char)('0'+(c >= 100)); if (c >= 100) c -= 100;
goto tens;
} else if (c >= 10) {
tens:
d = (c * 205) >> 11; c -= d * 10; *p++ = (char)('0'+d);
d = (c * 205) >> 11; c -= d * 10; *w++ = (char)('0'+d);
}
c += '0';
}
*p++ = (char)c;
setsbufP(sb, p);
*w++ = (char)c;
sb->w = w;
}
lj_buf_putb(sb, '"');
return sb;
@ -231,11 +231,11 @@ SBuf * LJ_FASTCALL lj_strfmt_putquoted(SBuf *sb, GCstr *str)
SBuf *lj_strfmt_putfchar(SBuf *sb, SFormat sf, int32_t c)
{
MSize width = STRFMT_WIDTH(sf);
char *p = lj_buf_more(sb, width > 1 ? width : 1);
if ((sf & STRFMT_F_LEFT)) *p++ = (char)c;
while (width-- > 1) *p++ = ' ';
if (!(sf & STRFMT_F_LEFT)) *p++ = (char)c;
setsbufP(sb, p);
char *w = lj_buf_more(sb, width > 1 ? width : 1);
if ((sf & STRFMT_F_LEFT)) *w++ = (char)c;
while (width-- > 1) *w++ = ' ';
if (!(sf & STRFMT_F_LEFT)) *w++ = (char)c;
sb->w = w;
return sb;
}
@ -244,20 +244,20 @@ SBuf *lj_strfmt_putfstr(SBuf *sb, SFormat sf, GCstr *str)
{
MSize len = str->len <= STRFMT_PREC(sf) ? str->len : STRFMT_PREC(sf);
MSize width = STRFMT_WIDTH(sf);
char *p = lj_buf_more(sb, width > len ? width : len);
if ((sf & STRFMT_F_LEFT)) p = lj_buf_wmem(p, strdata(str), len);
while (width-- > len) *p++ = ' ';
if (!(sf & STRFMT_F_LEFT)) p = lj_buf_wmem(p, strdata(str), len);
setsbufP(sb, p);
char *w = lj_buf_more(sb, width > len ? width : len);
if ((sf & STRFMT_F_LEFT)) w = lj_buf_wmem(w, strdata(str), len);
while (width-- > len) *w++ = ' ';
if (!(sf & STRFMT_F_LEFT)) w = lj_buf_wmem(w, strdata(str), len);
sb->w = w;
return sb;
}
/* Add formatted signed/unsigned integer to buffer. */
SBuf *lj_strfmt_putfxint(SBuf *sb, SFormat sf, uint64_t k)
{
char buf[STRFMT_MAXBUF_XINT], *q = buf + sizeof(buf), *p;
char buf[STRFMT_MAXBUF_XINT], *q = buf + sizeof(buf), *w;
#ifdef LUA_USE_ASSERT
char *ps;
char *ws;
#endif
MSize prefix = 0, len, prec, pprec, width, need;
@ -301,27 +301,27 @@ SBuf *lj_strfmt_putfxint(SBuf *sb, SFormat sf, uint64_t k)
width = STRFMT_WIDTH(sf);
pprec = prec + (prefix >> 8);
need = width > pprec ? width : pprec;
p = lj_buf_more(sb, need);
w = lj_buf_more(sb, need);
#ifdef LUA_USE_ASSERT
ps = p;
ws = w;
#endif
/* Format number with leading/trailing whitespace and zeros. */
if ((sf & (STRFMT_F_LEFT|STRFMT_F_ZERO)) == 0)
while (width-- > pprec) *p++ = ' ';
while (width-- > pprec) *w++ = ' ';
if (prefix) {
if ((char)prefix >= 'X') *p++ = '0';
*p++ = (char)prefix;
if ((char)prefix >= 'X') *w++ = '0';
*w++ = (char)prefix;
}
if ((sf & (STRFMT_F_LEFT|STRFMT_F_ZERO)) == STRFMT_F_ZERO)
while (width-- > pprec) *p++ = '0';
while (prec-- > len) *p++ = '0';
while (q < buf + sizeof(buf)) *p++ = *q++; /* Add number itself. */
while (width-- > pprec) *w++ = '0';
while (prec-- > len) *w++ = '0';
while (q < buf + sizeof(buf)) *w++ = *q++; /* Add number itself. */
if ((sf & STRFMT_F_LEFT))
while (width-- > pprec) *p++ = ' ';
while (width-- > pprec) *w++ = ' ';
lj_assertX(need == (MSize)(p - ps), "miscalculated format size");
setsbufP(sb, p);
lj_assertX(need == (MSize)(w - ws), "miscalculated format size");
sb->w = w;
return sb;
}

2
src/lj_strfmt_num.c
View File

@ -576,7 +576,7 @@ static char *lj_strfmt_wfnum(SBuf *sb, SFormat sf, lua_Number n, char *p)
/* Add formatted floating-point number to buffer. */
SBuf *lj_strfmt_putfnum(SBuf *sb, SFormat sf, lua_Number n)
{
setsbufP(sb, lj_strfmt_wfnum(sb, sf, n, NULL));
sb->w = lj_strfmt_wfnum(sb, sf, n, NULL);
return sb;
}

2
src/vm_arm.dasc
View File

@ -1810,7 +1810,7 @@ static void build_subroutines(BuildCtx *ctx)
| str BASE, L->base
| str PC, SAVE_PC
| str L, SBUF:CARG1->L
| str CARG4, SBUF:CARG1->p
| str CARG4, SBUF:CARG1->w
| bl extern lj_buf_putstr_ .. name
| bl extern lj_buf_tostr
| b ->fff_resstr

2
src/vm_arm64.dasc
View File

@ -1589,7 +1589,7 @@ static void build_subroutines(BuildCtx *ctx)
| str BASE, L->base
| str PC, SAVE_PC
| str L, GL->tmpbuf.L
| str TMP0, GL->tmpbuf.p
| str TMP0, GL->tmpbuf.w
| bl extern lj_buf_putstr_ .. name
| bl extern lj_buf_tostr
| b ->fff_resstr

2
src/vm_mips.dasc
View File

@ -1971,7 +1971,7 @@ static void build_subroutines(BuildCtx *ctx)
| lw TMP0, SBUF:CARG1->b
| sw L, SBUF:CARG1->L
| sw BASE, L->base
| sw TMP0, SBUF:CARG1->p
| sw TMP0, SBUF:CARG1->w
| call_intern extern lj_buf_putstr_ .. name
|. sw PC, SAVE_PC
| load_got lj_buf_tostr

2
src/vm_mips64.dasc
View File

@ -2041,7 +2041,7 @@ static void build_subroutines(BuildCtx *ctx)
| ld TMP0, SBUF:CARG1->b
| sd L, SBUF:CARG1->L
| sd BASE, L->base
| sd TMP0, SBUF:CARG1->p
| sd TMP0, SBUF:CARG1->w
| call_intern extern lj_buf_putstr_ .. name
|. sd PC, SAVE_PC
| load_got lj_buf_tostr

2
src/vm_ppc.dasc
View File

@ -2516,7 +2516,7 @@ static void build_subroutines(BuildCtx *ctx)
| stw L, SBUF:CARG1->L
| stp BASE, L->base
| stw PC, SAVE_PC
| stw TMP0, SBUF:CARG1->p
| stw TMP0, SBUF:CARG1->w
| bl extern lj_buf_putstr_ .. name
| bl extern lj_buf_tostr
| b ->fff_resstr

2
src/vm_x64.dasc
View File

@ -2011,7 +2011,7 @@ static void build_subroutines(BuildCtx *ctx)
|.endif
| mov RC, SBUF:CARG1->b
| mov SBUF:CARG1->L, L:RB
| mov SBUF:CARG1->p, RC
| mov SBUF:CARG1->w, RC
| mov SAVE_PC, PC
| call extern lj_buf_putstr_ .. name
| mov CARG1, rax

4
src/vm_x86.dasc
View File

@ -2423,9 +2423,9 @@ static void build_subroutines(BuildCtx *ctx)
| lea SBUF:FCARG1, [DISPATCH+DISPATCH_GL(tmpbuf)]
| mov L:RB->base, BASE
| mov STR:FCARG2, [BASE] // Caveat: FCARG2 == BASE
| mov RC, SBUF:FCARG1->b
| mov RCa, SBUF:FCARG1->b
| mov SBUF:FCARG1->L, L:RB
| mov SBUF:FCARG1->p, RC
| mov SBUF:FCARG1->w, RCa
| mov SAVE_PC, PC
| call extern lj_buf_putstr_ .. name .. @8
| mov FCARG1, eax