commit 29815a3
default
·
2023-05-02 04:41:45 +0000 UTC
parent f1756a5
Backport from xs.
3 files changed,
+220,
-15
M
xs.h
+8,
-4
1@@ -65,8 +65,10 @@ xs_str *xs_str_new(const char *str);
2 xs_str *xs_str_wrap_i(const char *prefix, xs_str *str, const char *suffix);
3 #define xs_str_prepend_i(str, prefix) xs_str_wrap_i(prefix, str, NULL)
4 #define xs_str_cat(str, suffix) xs_str_wrap_i(NULL, str, suffix)
5-xs_str *xs_replace_i(xs_str *str, const char *sfrom, const char *sto);
6-#define xs_replace(str, sfrom, sto) xs_replace_i(xs_dup(str), sfrom, sto)
7+xs_str *xs_replace_in(xs_str *str, const char *sfrom, const char *sto, int times);
8+#define xs_replace_i(str, sfrom, sto) xs_replace_in(str, sfrom, sto, XS_ALL)
9+#define xs_replace(str, sfrom, sto) xs_replace_in(xs_dup(str), sfrom, sto, XS_ALL)
10+#define xs_replace_n(str, sfrom, sto, times) xs_replace_in(xs_dup(str), sfrom, sto, times)
11 xs_str *xs_fmt(const char *fmt, ...);
12 int xs_str_in(const char *haystack, const char *needle);
13 int _xs_startsorends(const char *str, const char *xfix, int ends);
14@@ -416,7 +418,7 @@ xs_str *xs_str_wrap_i(const char *prefix, xs_str *str, const char *suffix)
15 }
16
17
18-xs_str *xs_replace_i(xs_str *str, const char *sfrom, const char *sto)
19+xs_str *xs_replace_in(xs_str *str, const char *sfrom, const char *sto, int times)
20 /* replaces inline all sfrom with sto */
21 {
22 XS_ASSERT_TYPE(str, XSTYPE_STRING);
23@@ -426,7 +428,7 @@ xs_str *xs_replace_i(xs_str *str, const char *sfrom, const char *sto)
24 char *ss;
25 int offset = 0;
26
27- while ((ss = strstr(str + offset, sfrom)) != NULL) {
28+ while (times > 0 && (ss = strstr(str + offset, sfrom)) != NULL) {
29 int n_offset = ss - str;
30
31 str = xs_collapse(str, n_offset, sfsz);
32@@ -434,6 +436,8 @@ xs_str *xs_replace_i(xs_str *str, const char *sfrom, const char *sto)
33 memcpy(str + n_offset, sto, stsz);
34
35 offset = n_offset + stsz;
36+
37+ times--;
38 }
39
40 return str;
+211,
-10
1@@ -7,13 +7,20 @@
2 xs_str *xs_hex_enc(const xs_val *data, int size);
3 xs_val *xs_hex_dec(const xs_str *hex, int *size);
4 int xs_is_hex(const char *str);
5+ xs_str *xs_base32_enc(const xs_val *data, int sz);
6+ xs_str *xs_base32hex_enc(const xs_val *data, int sz);
7+ xs_val *xs_base32_dec(const xs_str *data, int *size);
8+ xs_val *xs_base32hex_dec(const xs_str *data, int *size);
9 xs_str *xs_base64_enc(const xs_val *data, int sz);
10 xs_val *xs_base64_dec(const xs_str *data, int *size);
11+ int xs_is_base64(const char *str);
12 xs_str *xs_utf8_enc(xs_str *str, unsigned int cpoint);
13
14
15 #ifdef XS_IMPLEMENTATION
16
17+/** hex **/
18+
19 xs_str *xs_hex_enc(const xs_val *data, int size)
20 /* returns an hexdump of data */
21 {
22@@ -78,16 +85,178 @@ int xs_is_hex(const char *str)
23 }
24
25
26-xs_str *xs_base64_enc(const xs_val *data, int sz)
27-/* encodes data to base64 */
28+/** base32 */
29+
30+static char *xs_b32_tbl = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
31+ "234567=";
32+
33+static char *xs_b32hex_tbl = "0123456789"
34+ "ABCDEFGHIJKLMNOPQRSTUV=";
35+
36+/*
37+ 00000|00011|11111|12222|22223|33333|33444|44444
38+*/
39+
40+xs_str *xs_base32_enc_tbl(const xs_val *data, int sz, const char *b32_tbl)
41+/* encodes data to base32 using a table */
42+{
43+ xs_str *s = xs_str_new(NULL);
44+ unsigned char *p;
45+ int n;
46+
47+ p = (unsigned char *)data;
48+
49+ for (n = 0; n < sz; n += 5) {
50+ int l = sz - n;
51+ char enc[9] = "========";
52+
53+ enc[0] = b32_tbl[(p[n] >> 3) & 0x1f];
54+
55+ if (l > 1) {
56+ enc[1] = b32_tbl[(p[n] << 2 | p[n + 1] >> 6) & 0x1f];
57+ enc[2] = b32_tbl[(p[n + 1] >> 1) & 0x1f];
58+
59+ if (l > 2) {
60+ enc[3] = b32_tbl[(p[n + 1] << 4 | p[n + 2] >> 4) & 0x1f];
61+
62+ if (l > 3) {
63+ enc[4] = b32_tbl[(p[n + 2] << 1 | p[n + 3] >> 7) & 0x1f];
64+ enc[5] = b32_tbl[(p[n + 3] >> 2) & 0x1f];
65+
66+ if (l > 4) {
67+ enc[6] = b32_tbl[(p[n + 3] << 3 | p[n + 4] >> 5) & 0x1f];
68+ enc[7] = b32_tbl[(p[n + 4]) & 0x1f];
69+ }
70+ else
71+ enc[6] = b32_tbl[(p[n + 3] << 3) & 0x1f];
72+ }
73+ else
74+ enc[4] = b32_tbl[(p[n + 2] << 1) & 0x1f];
75+ }
76+ else
77+ enc[3] = b32_tbl[(p[n + 1] << 4) & 0x1f];
78+ }
79+ else
80+ enc[1] = b32_tbl[(p[n] << 2) & 0x1f];
81+
82+ s = xs_str_cat(s, enc);
83+ }
84+
85+ return s;
86+}
87+
88+
89+xs_str *xs_base32_enc(const xs_val *data, int sz)
90+/* encodes data to base32 */
91+{
92+ return xs_base32_enc_tbl(data, sz, xs_b32_tbl);
93+}
94+
95+
96+xs_str *xs_base32hex_enc(const xs_val *data, int sz)
97+/* encodes data to base32 with HEX alphabet (RFC4648) */
98+{
99+ return xs_base32_enc_tbl(data, sz, xs_b32hex_tbl);
100+}
101+
102+
103+xs_val *xs_base32_dec_tbl(const xs_str *data, int *size, const char *b32_tbl)
104+/* decodes data from base32 using a table */
105+{
106+ xs_val *s = NULL;
107+ int sz = 0;
108+ char *p;
109+
110+ p = (char *)data;
111+
112+ /* size of data must be a multiple of 8 */
113+ if (strlen(p) % 8)
114+ return NULL;
115+
116+ for (p = (char *)data; *p; p += 8) {
117+ int cs[8];
118+ int n;
119+ unsigned char tmp[5];
120+
121+ for (n = 0; n < 8; n++) {
122+ char *ss = strchr(b32_tbl, p[n]);
123+
124+ if (ss == NULL) {
125+ /* not a base32 char */
126+ return xs_free(s);
127+ }
128+
129+ cs[n] = ss - b32_tbl;
130+ }
131+
132+ n = 0;
133+
134+ /* #0 byte */
135+ tmp[n++] = cs[0] << 3 | cs[1] >> 2;
136+
137+ if (cs[2] != 32) {
138+ /* #1 byte */
139+ tmp[n++] = (cs[1] & 0x3) << 6 | cs[2] << 1 | (cs[3] & 0x10) >> 4;
140+
141+ if (cs[4] != 32) {
142+ /* #2 byte */
143+ tmp[n++] = (cs[3] & 0xf) << 4 | cs[4] >> 1;
144+
145+ if (cs[5] != 32) {
146+ /* #3 byte */
147+ tmp[n++] = (cs[4] & 0x1) << 7 | cs[5] << 2 | cs[6] >> 3;
148+
149+ if (cs[7] != 32) {
150+ /* #4 byte */
151+ tmp[n++] = (cs[6] & 0x7) << 5 | cs[7];
152+ }
153+ }
154+ }
155+ }
156+
157+ /* must be done manually because data can be pure binary */
158+ s = xs_realloc(s, _xs_blk_size(sz + n));
159+ memcpy(s + sz, tmp, n);
160+ sz += n;
161+ }
162+
163+ /* asciiz it to use it as a string */
164+ s = xs_realloc(s, _xs_blk_size(sz + 1));
165+ s[sz] = '\0';
166+
167+ *size = sz;
168+
169+ return s;
170+}
171+
172+
173+xs_val *xs_base32_dec(const xs_str *data, int *size)
174+/* decodes data from base32 */
175+{
176+ return xs_base32_dec_tbl(data, size, xs_b32_tbl);
177+}
178+
179+
180+xs_val *xs_base32hex_dec(const xs_str *data, int *size)
181+/* decodes data from base32 with HEX alphabet (RFC4648) */
182+{
183+ return xs_base32_dec_tbl(data, size, xs_b32hex_tbl);
184+}
185+
186+
187+/** base64 */
188+
189+static char *xs_b64_tbl = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
190+ "abcdefghijklmnopqrstuvwxyz"
191+ "0123456789+/=";
192+
193+xs_str *xs_base64_enc_tbl(const xs_val *data, int sz, const char *b64_tbl)
194+/* encodes data to base64 using a table */
195 {
196 xs_str *s;
197 unsigned char *p;
198 char *i;
199 int bsz, n;
200- static char *b64_tbl = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
201- "abcdefghijklmnopqrstuvwxyz"
202- "0123456789+/";
203
204 bsz = ((sz + 3 - 1) / 3) * 4;
205 i = s = xs_realloc(NULL, _xs_blk_size(bsz + 1));
206@@ -123,15 +292,19 @@ xs_str *xs_base64_enc(const xs_val *data, int sz)
207 }
208
209
210-xs_val *xs_base64_dec(const xs_str *data, int *size)
211-/* decodes data from base64 */
212+xs_str *xs_base64_enc(const xs_val *data, int sz)
213+/* encodes data to base64 */
214+{
215+ return xs_base64_enc_tbl(data, sz, xs_b64_tbl);
216+}
217+
218+
219+xs_val *xs_base64_dec_tbl(const xs_str *data, int *size, const char *b64_tbl)
220+/* decodes data from base64 using a table */
221 {
222 xs_val *s = NULL;
223 int sz = 0;
224 char *p;
225- static char *b64_tbl = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
226- "abcdefghijklmnopqrstuvwxyz"
227- "0123456789+/=";
228
229 p = (char *)data;
230
231@@ -184,6 +357,34 @@ xs_val *xs_base64_dec(const xs_str *data, int *size)
232 }
233
234
235+xs_val *xs_base64_dec(const xs_str *data, int *size)
236+/* decodes data from base64 */
237+{
238+ return xs_base64_dec_tbl(data, size, xs_b64_tbl);
239+}
240+
241+
242+int xs_is_base64_tbl(const char *str, const char *b64_tbl)
243+/* returns 1 if str is a base64 string, with table */
244+{
245+ while (*str) {
246+ if (strchr(b64_tbl, *str++) == NULL)
247+ return 0;
248+ }
249+
250+ return 1;
251+}
252+
253+
254+int xs_is_base64(const char *str)
255+/* returns 1 if str is a base64 string */
256+{
257+ return xs_is_base64_tbl(str, xs_b64_tbl);
258+}
259+
260+
261+/** utf-8 **/
262+
263 xs_str *xs_utf8_enc(xs_str *str, unsigned int cpoint)
264 /* encodes an Unicode codepoint to utf8 */
265 {
+1,
-1
1@@ -1 +1 @@
2-/* a885c7cc4c8e6384ae23125ed05f434471ccc6fb */
3+/* dfdd729248d7169b80cb6a7462fe6c0ba6efeb16 */