Mercurial

comparison third_party/luajit/src/lj_buf.h @ 178:94705b5986b3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[ThirdParty] Added WRK and luajit for load testing.
author MrJuneJune <me@mrjunejune.com>
date Thu, 22 Jan 2026 20:10:30 -0800
parents
children
comparison
equal deleted inserted replaced
177:24fe8ff94056 178:94705b5986b3
1 /*
2 ** Buffer handling.
3 ** Copyright (C) 2005-2023 Mike Pall. See Copyright Notice in luajit.h
4 */
5
6 #ifndef _LJ_BUF_H
7 #define _LJ_BUF_H
8
9 #include "lj_obj.h"
10 #include "lj_gc.h"
11 #include "lj_str.h"
12
13 /* Resizable string buffers. */
14
15 /* The SBuf struct definition is in lj_obj.h:
16 ** char *w; Write pointer.
17 ** char *e; End pointer.
18 ** char *b; Base pointer.
19 ** MRef L; lua_State, used for buffer resizing. Extension bits in 3 LSB.
20 */
21
22 /* Extended string buffer. */
23 typedef struct SBufExt {
24 SBufHeader;
25 union {
26 GCRef cowref; /* Copy-on-write object reference. */
27 MRef bsb; /* Borrowed string buffer. */
28 };
29 char *r; /* Read pointer. */
30 GCRef dict_str; /* Serialization string dictionary table. */
31 GCRef dict_mt; /* Serialization metatable dictionary table. */
32 int depth; /* Remaining recursion depth. */
33 } SBufExt;
34
35 #define sbufsz(sb) ((MSize)((sb)->e - (sb)->b))
36 #define sbuflen(sb) ((MSize)((sb)->w - (sb)->b))
37 #define sbufleft(sb) ((MSize)((sb)->e - (sb)->w))
38 #define sbufxlen(sbx) ((MSize)((sbx)->w - (sbx)->r))
39 #define sbufxslack(sbx) ((MSize)((sbx)->r - (sbx)->b))
40
41 #define SBUF_MASK_FLAG (7)
42 #define SBUF_MASK_L (~(GCSize)SBUF_MASK_FLAG)
43 #define SBUF_FLAG_EXT 1 /* Extended string buffer. */
44 #define SBUF_FLAG_COW 2 /* Copy-on-write buffer. */
45 #define SBUF_FLAG_BORROW 4 /* Borrowed string buffer. */
46
47 #define sbufL(sb) \
48 ((lua_State *)(void *)(uintptr_t)(mrefu((sb)->L) & SBUF_MASK_L))
49 #define setsbufL(sb, l) (setmref((sb)->L, (l)))
50 #define setsbufXL(sb, l, flag) \
51 (setmrefu((sb)->L, (GCSize)(uintptr_t)(void *)(l) + (flag)))
52 #define setsbufXL_(sb, l) \
53 (setmrefu((sb)->L, (GCSize)(uintptr_t)(void *)(l) | (mrefu((sb)->L) & SBUF_MASK_FLAG)))
54
55 #define sbufflag(sb) (mrefu((sb)->L))
56 #define sbufisext(sb) (sbufflag((sb)) & SBUF_FLAG_EXT)
57 #define sbufiscow(sb) (sbufflag((sb)) & SBUF_FLAG_COW)
58 #define sbufisborrow(sb) (sbufflag((sb)) & SBUF_FLAG_BORROW)
59 #define sbufiscoworborrow(sb) (sbufflag((sb)) & (SBUF_FLAG_COW|SBUF_FLAG_BORROW))
60 #define sbufX(sb) \
61 (lj_assertG_(G(sbufL(sb)), sbufisext(sb), "not an SBufExt"), (SBufExt *)(sb))
62 #define setsbufflag(sb, flag) (setmrefu((sb)->L, (flag)))
63
64 #define tvisbuf(o) \
65 (LJ_HASBUFFER && tvisudata(o) && udataV(o)->udtype == UDTYPE_BUFFER)
66 #define bufV(o) check_exp(tvisbuf(o), ((SBufExt *)uddata(udataV(o))))
67
68 /* Buffer management */
69 LJ_FUNC char *LJ_FASTCALL lj_buf_need2(SBuf *sb, MSize sz);
70 LJ_FUNC char *LJ_FASTCALL lj_buf_more2(SBuf *sb, MSize sz);
71 LJ_FUNC void LJ_FASTCALL lj_buf_shrink(lua_State *L, SBuf *sb);
72 LJ_FUNC char * LJ_FASTCALL lj_buf_tmp(lua_State *L, MSize sz);
73
74 static LJ_AINLINE void lj_buf_init(lua_State *L, SBuf *sb)
75 {
76 setsbufL(sb, L);
77 sb->w = sb->e = sb->b = NULL;
78 }
79
80 static LJ_AINLINE void lj_buf_reset(SBuf *sb)
81 {
82 sb->w = sb->b;
83 }
84
85 static LJ_AINLINE SBuf *lj_buf_tmp_(lua_State *L)
86 {
87 SBuf *sb = &G(L)->tmpbuf;
88 setsbufL(sb, L);
89 lj_buf_reset(sb);
90 return sb;
91 }
92
93 static LJ_AINLINE void lj_buf_free(global_State *g, SBuf *sb)
94 {
95 lj_assertG(!sbufisext(sb), "bad free of SBufExt");
96 lj_mem_free(g, sb->b, sbufsz(sb));
97 }
98
99 static LJ_AINLINE char *lj_buf_need(SBuf *sb, MSize sz)
100 {
101 if (LJ_UNLIKELY(sz > sbufsz(sb)))
102 return lj_buf_need2(sb, sz);
103 return sb->b;
104 }
105
106 static LJ_AINLINE char *lj_buf_more(SBuf *sb, MSize sz)
107 {
108 if (LJ_UNLIKELY(sz > sbufleft(sb)))
109 return lj_buf_more2(sb, sz);
110 return sb->w;
111 }
112
113 /* Extended buffer management */
114 static LJ_AINLINE void lj_bufx_init(lua_State *L, SBufExt *sbx)
115 {
116 memset(sbx, 0, sizeof(SBufExt));
117 setsbufXL(sbx, L, SBUF_FLAG_EXT);
118 }
119
120 static LJ_AINLINE void lj_bufx_set_borrow(lua_State *L, SBufExt *sbx, SBuf *sb)
121 {
122 setsbufXL(sbx, L, SBUF_FLAG_EXT | SBUF_FLAG_BORROW);
123 setmref(sbx->bsb, sb);
124 sbx->r = sbx->w = sbx->b = sb->b;
125 sbx->e = sb->e;
126 }
127
128 static LJ_AINLINE void lj_bufx_set_cow(lua_State *L, SBufExt *sbx,
129 const char *p, MSize len)
130 {
131 setsbufXL(sbx, L, SBUF_FLAG_EXT | SBUF_FLAG_COW);
132 sbx->r = sbx->b = (char *)p;
133 sbx->w = sbx->e = (char *)p + len;
134 }
135
136 static LJ_AINLINE void lj_bufx_reset(SBufExt *sbx)
137 {
138 if (sbufiscow(sbx)) {
139 setmrefu(sbx->L, (mrefu(sbx->L) & ~(GCSize)SBUF_FLAG_COW));
140 setgcrefnull(sbx->cowref);
141 sbx->b = sbx->e = NULL;
142 }
143 sbx->r = sbx->w = sbx->b;
144 }
145
146 static LJ_AINLINE void lj_bufx_free(lua_State *L, SBufExt *sbx)
147 {
148 if (!sbufiscoworborrow(sbx)) lj_mem_free(G(L), sbx->b, sbufsz(sbx));
149 setsbufXL(sbx, L, SBUF_FLAG_EXT);
150 setgcrefnull(sbx->cowref);
151 sbx->r = sbx->w = sbx->b = sbx->e = NULL;
152 }
153
154 #if LJ_HASBUFFER && LJ_HASJIT
155 LJ_FUNC void lj_bufx_set(SBufExt *sbx, const char *p, MSize len, GCobj *o);
156 #if LJ_HASFFI
157 LJ_FUNC MSize LJ_FASTCALL lj_bufx_more(SBufExt *sbx, MSize sz);
158 #endif
159 #endif
160
161 /* Low-level buffer put operations */
162 LJ_FUNC SBuf *lj_buf_putmem(SBuf *sb, const void *q, MSize len);
163 #if LJ_HASJIT || LJ_HASFFI
164 LJ_FUNC SBuf * LJ_FASTCALL lj_buf_putchar(SBuf *sb, int c);
165 #endif
166 LJ_FUNC SBuf * LJ_FASTCALL lj_buf_putstr(SBuf *sb, GCstr *s);
167
168 static LJ_AINLINE char *lj_buf_wmem(char *p, const void *q, MSize len)
169 {
170 return (char *)memcpy(p, q, len) + len;
171 }
172
173 static LJ_AINLINE void lj_buf_putb(SBuf *sb, int c)
174 {
175 char *w = lj_buf_more(sb, 1);
176 *w++ = (char)c;
177 sb->w = w;
178 }
179
180 /* High-level buffer put operations */
181 LJ_FUNCA SBuf * LJ_FASTCALL lj_buf_putstr_reverse(SBuf *sb, GCstr *s);
182 LJ_FUNCA SBuf * LJ_FASTCALL lj_buf_putstr_lower(SBuf *sb, GCstr *s);
183 LJ_FUNCA SBuf * LJ_FASTCALL lj_buf_putstr_upper(SBuf *sb, GCstr *s);
184 LJ_FUNC SBuf *lj_buf_putstr_rep(SBuf *sb, GCstr *s, int32_t rep);
185 LJ_FUNC SBuf *lj_buf_puttab(SBuf *sb, GCtab *t, GCstr *sep,
186 int32_t i, int32_t e);
187
188 /* Miscellaneous buffer operations */
189 LJ_FUNCA GCstr * LJ_FASTCALL lj_buf_tostr(SBuf *sb);
190 LJ_FUNC GCstr *lj_buf_cat2str(lua_State *L, GCstr *s1, GCstr *s2);
191 LJ_FUNC uint32_t LJ_FASTCALL lj_buf_ruleb128(const char **pp);
192
193 static LJ_AINLINE GCstr *lj_buf_str(lua_State *L, SBuf *sb)
194 {
195 return lj_str_new(L, sb->b, sbuflen(sb));
196 }
197
198 #endif