Codebergdnkl

foot

master
ply5 git calls507 ms30 KiB3 cachedprotocol v2
432 lines9.2 KiBRaw
1#include "char32.h"
3#include <stdlib.h>
4#include <string.h>
5#include <locale.h>
7#include <wctype.h>
8#include <wchar.h>
10#if defined __has_include
11 #if __has_include (<stdc-predef.h>)
12 #include <stdc-predef.h>
13 #endif
14#endif
16#define LOG_MODULE "char32"
17#define LOG_ENABLE_DBG 0
18#include "log.h"
19#include "debug.h"
20#include "macros.h"
21#include "xmalloc.h"
23/*
24 * For now, assume we can map directly to the corresponding wchar_t
25 * functions. This is true if:
26 *
27 * - both data types have the same size
28 * - both use the same encoding (though we require that encoding to be UTF-32)
29 */
31_Static_assert(
32 sizeof(wchar_t) == sizeof(char32_t), "wchar_t vs. char32_t size mismatch");
34#if !defined(__STDC_UTF_32__) || !__STDC_UTF_32__
35 #error "char32_t does not use UTF-32"
36#endif
37#if (!defined(__STDC_ISO_10646__) || !__STDC_ISO_10646__) && !defined(__FreeBSD__) && !defined(__OpenBSD__)
38 #error "wchar_t does not use UTF-32"
39#endif
41UNITTEST
43 xassert(c32len(U"") == 0);
44 xassert(c32len(U"foobar") == 6);
47UNITTEST
49 xassert(c32cmp(U"foobar", U"foobar") == 0);
50 xassert(c32cmp(U"foo", U"foobar") < 0);
51 xassert(c32cmp(U"foobar", U"foo") > 0);
52 xassert(c32cmp(U"a", U"b") < 0);
53 xassert(c32cmp(U"b", U"a") > 0);
56UNITTEST
58 xassert(c32ncmp(U"foo", U"foot", 3) == 0);
59 xassert(c32ncmp(U"foot", U"FOOT", 4) > 0);
60 xassert(c32ncmp(U"a", U"b", 1) < 0);
61 xassert(c32ncmp(U"bb", U"aa", 2) > 0);
64UNITTEST
66 char32_t copy[16];
67 char32_t *ret = c32ncpy(copy, U"foobar", 16);
69 xassert(ret == copy);
70 xassert(copy[0] == U'f');
71 xassert(copy[1] == U'o');
72 xassert(copy[2] == U'o');
73 xassert(copy[3] == U'b');
74 xassert(copy[4] == U'a');
75 xassert(copy[5] == U'r');
77 unsigned char zeroes[(16 - 6) * sizeof(copy[0])] = {0};
78 xassert(memcmp(&copy[6], zeroes, sizeof(zeroes)) == 0);
81UNITTEST
83 char32_t copy[16];
84 memset(copy, 0x55, sizeof(copy));
86 char32_t *ret = c32cpy(copy, U"foobar");
88 xassert(ret == copy);
89 xassert(copy[0] == U'f');
90 xassert(copy[1] == U'o');
91 xassert(copy[2] == U'o');
92 xassert(copy[3] == U'b');
93 xassert(copy[4] == U'a');
94 xassert(copy[5] == U'r');
95 xassert(copy[6] == U'\0');
97 unsigned char fives[(16 - 6 - 1) * sizeof(copy[0])];
98 memset(fives, 0x55, sizeof(fives));
99 xassert(memcmp(&copy[7], fives, sizeof(fives)) == 0);
102UNITTEST
104 xassert(c32casecmp(U"foobar", U"FOOBAR") == 0);
105 xassert(c32casecmp(U"foo", U"FOOO") < 0);
106 xassert(c32casecmp(U"FOOO", U"foo") > 0);
107 xassert(c32casecmp(U"a", U"B") < 0);
108 xassert(c32casecmp(U"B", U"a") > 0);
111UNITTEST
113 xassert(c32ncasecmp(U"foo", U"FOObar", 3) == 0);
114 xassert(c32ncasecmp(U"foo", U"FOOO", 4) < 0);
115 xassert(c32ncasecmp(U"FOOO", U"foo", 4) > 0);
116 xassert(c32ncasecmp(U"a", U"BB", 1) < 0);
117 xassert(c32ncasecmp(U"BB", U"a", 1) > 0);
120UNITTEST
122 char32_t dst[32] = U"foobar";
123 char32_t *ret = c32ncat(dst, U"12345678XXXXXXXXX", 8);
125 xassert(ret == dst);
126 xassert(c32cmp(dst, U"foobar12345678") == 0);
129UNITTEST
131 char32_t dst[32] = U"foobar";
132 char32_t *ret = c32cat(dst, U"12345678");
134 xassert(ret == dst);
135 xassert(c32cmp(dst, U"foobar12345678") == 0);
138UNITTEST
140 xassert(!isc32upper(U'a'));
141 xassert(isc32upper(U'A'));
142 xassert(!isc32upper(U'a'));
145UNITTEST
147 xassert(hasc32upper(U"abc1A"));
148 xassert(!hasc32upper(U"abc1_aaa"));
149 xassert(!hasc32upper(U""));
152UNITTEST
154 char32_t *c = xc32dup(U"foobar");
155 xassert(c32cmp(c, U"foobar") == 0);
156 free(c);
158 c = xc32dup(U"");
159 xassert(c32cmp(c, U"") == 0);
160 free(c);
163size_t
164mbsntoc32(char32_t *dst, const char *src, size_t nms, size_t len)
166 mbstate_t ps = {0};
168 char32_t *out = dst;
169 const char *in = src;
171 size_t consumed = 0;
172 size_t chars = 0;
173 size_t rc;
175 while ((out == NULL || chars < len) &&
176 consumed < nms &&
177 (rc = mbrtoc32(out, in, nms - consumed, &ps)) != 0)
178 {
179 switch (rc) {
180 case 0:
181 goto done;
183 case (size_t)-1:
184 case (size_t)-2:
185 case (size_t)-3:
186 goto err;
187 }
189 in += rc;
190 consumed += rc;
191 chars++;
193 if (out != NULL)
194 out++;
195 }
197done:
198 return chars;
200err:
201 return (size_t)-1;
204UNITTEST
206 const char input[] = "foobarzoo";
207 char32_t c32[32];
209 size_t ret = mbsntoc32(NULL, input, sizeof(input), 0);
210 xassert(ret == 9);
212 memset(c32, 0x55, sizeof(c32));
213 ret = mbsntoc32(c32, input, sizeof(input), 32);
215 xassert(ret == 9);
216 xassert(c32[0] == U'f');
217 xassert(c32[1] == U'o');
218 xassert(c32[2] == U'o');
219 xassert(c32[3] == U'b');
220 xassert(c32[4] == U'a');
221 xassert(c32[5] == U'r');
222 xassert(c32[6] == U'z');
223 xassert(c32[7] == U'o');
224 xassert(c32[8] == U'o');
225 xassert(c32[9] == U'\0');
226 xassert(c32[10] == 0x55555555);
228 memset(c32, 0x55, sizeof(c32));
229 ret = mbsntoc32(c32, input, 1, 32);
231 xassert(ret == 1);
232 xassert(c32[0] == U'f');
233 xassert(c32[1] == 0x55555555);
235 memset(c32, 0x55, sizeof(c32));
236 ret = mbsntoc32(c32, input, sizeof(input), 1);
238 xassert(ret == 1);
239 xassert(c32[0] == U'f');
240 xassert(c32[1] == 0x55555555);
243UNITTEST
245 const char input[] = "foobarzoo";
246 char32_t c32[32];
248 size_t ret = mbstoc32(NULL, input, 0);
249 xassert(ret == 9);
251 memset(c32, 0x55, sizeof(c32));
252 ret = mbstoc32(c32, input, 32);
254 xassert(ret == 9);
255 xassert(c32[0] == U'f');
256 xassert(c32[1] == U'o');
257 xassert(c32[2] == U'o');
258 xassert(c32[3] == U'b');
259 xassert(c32[4] == U'a');
260 xassert(c32[5] == U'r');
261 xassert(c32[6] == U'z');
262 xassert(c32[7] == U'o');
263 xassert(c32[8] == U'o');
264 xassert(c32[9] == U'\0');
265 xassert(c32[10] == 0x55555555);
267 memset(c32, 0x55, sizeof(c32));
268 ret = mbstoc32(c32, input, 1);
270 xassert(ret == 1);
271 xassert(c32[0] == U'f');
272 xassert(c32[1] == 0x55555555);
276char32_t *
277ambstoc32(const char *src)
279 if (src == NULL)
280 return NULL;
282 const size_t src_len = strlen(src);
284 char32_t *ret = xmalloc((src_len + 1) * sizeof(ret[0]));
285 mbstate_t ps = {0};
287 char32_t *out = ret;
288 const char *in = src;
289 const char *const end = src + src_len + 1;
291 size_t chars = 0;
292 size_t rc;
294 while ((rc = mbrtoc32(out, in, end - in, &ps)) != 0) {
295 switch (rc) {
296 case (size_t)-1:
297 case (size_t)-2:
298 case (size_t)-3:
299 goto err;
300 }
302 in += rc;
303 out++;
304 chars++;
305 }
307 *out = U'\0';
309 ret = xrealloc(ret, (chars + 1) * sizeof(ret[0]));
310 return ret;
312err:
313 free(ret);
314 return NULL;
317UNITTEST
319 const char* locale = setlocale(LC_CTYPE, "en_US.UTF-8");
320 if (!locale)
321 locale = setlocale(LC_CTYPE, "C.UTF-8");
322 if (!locale)
323 return;
325 char32_t *hello = ambstoc32(u8"hello");
326 xassert(hello != NULL);
327 xassert(hello[0] == U'h');
328 xassert(hello[1] == U'e');
329 xassert(hello[2] == U'l');
330 xassert(hello[3] == U'l');
331 xassert(hello[4] == U'o');
332 xassert(hello[5] == U'\0');
333 free(hello);
335 char32_t *swedish = ambstoc32(u8"åäö");
336 xassert(swedish != NULL);
337 xassert(swedish[0] == U'å');
338 xassert(swedish[1] == U'ä');
339 xassert(swedish[2] == U'ö');
340 xassert(swedish[3] == U'\0');
341 free(swedish);
343 char32_t *emoji = ambstoc32(u8"👨‍👩‍👧‍👦");
344 xassert(emoji != NULL);
345 xassert(emoji[0] == U'👨');
346 xassert(emoji[1] == U'‍');
347 xassert(emoji[2] == U'👩');
348 xassert(emoji[3] == U'‍');
349 xassert(emoji[4] == U'👧');
350 xassert(emoji[5] == U'‍');
351 xassert(emoji[6] == U'👦');
352 xassert(emoji[7] == U'\0');
353 free(emoji);
355 xassert(ambstoc32(NULL) == NULL);
356 xassert(setlocale(LC_CTYPE, "C") != NULL);
359char *
360ac32tombs(const char32_t *src)
362 if (src == NULL)
363 return NULL;
365 const size_t src_len = c32len(src);
367 size_t allocated = src_len + 1;
368 char *ret = xmalloc(allocated);
369 mbstate_t ps = {0};
371 char *out = ret;
372 const char32_t *const end = src + src_len + 1;
374 size_t bytes = 0;
376 char mb[MB_CUR_MAX];
378 for (const char32_t *in = src; in < end; in++) {
379 size_t rc = c32rtomb(mb, *in, &ps);
381 switch (rc) {
382 case (size_t)-1:
383 goto err;
384 }
386 if (bytes + rc > allocated) {
387 allocated *= 2;
388 ret = xrealloc(ret, allocated);
389 out = &ret[bytes];
390 }
392 for (size_t i = 0; i < rc; i++, out++)
393 *out = mb[i];
395 bytes += rc;
396 }
398 xassert(ret[bytes - 1] == '\0');
399 ret = xrealloc(ret, bytes);
400 return ret;
402err:
403 free(ret);
404 return NULL;
407UNITTEST
409 const char* locale = setlocale(LC_CTYPE, "en_US.UTF-8");
410 if (!locale)
411 locale = setlocale(LC_CTYPE, "C.UTF-8");
412 if (!locale)
413 return;
415 char *s = ac32tombs(U"foobar");
416 xassert(s != NULL);
417 xassert(strcmp(s, "foobar") == 0);
418 free(s);
420 s = ac32tombs(U"åäö");
421 xassert(s != NULL);
422 xassert(strcmp(s, u8"åäö") == 0);
423 free(s);
425 s = ac32tombs(U"👨‍👩‍👧‍👦");
426 xassert(s != NULL);
427 xassert(strcmp(s, u8"👨‍👩‍👧‍👦") == 0);
428 free(s);
430 xassert(ac32tombs(NULL) == NULL);
431 xassert(setlocale(LC_CTYPE, "C") != NULL);
Diagnostics5 git calls · 507 ms
CallStatusSizeTime0507 ms
discover200178 B3 ms
git.upload-pack discover
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=3
git.response.bytes=178
git.server.agent=git/2.56.1-Linux
git.server.object_format=sha1
git.server.caps=agent ls-refs fetch server-option object-format
git.server.fetch=shallow wait-for-done filter
git.protocol.version=2
git.pkt.frames=9
git.pkt.data=7
git.pkt.flush=2
git.pkt.delim=0
git.pkt.bytes=178
git.pkt.payload.max=35
ls-refs20010 KiB455 ms
git.upload-pack ls-refs
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=393
git.response.bytes=10322
git.response.cache=EXPIRED
git.response.duration_ms=455
git.protocol.version=2
git.pkt.frames=108
git.pkt.data=107
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=10322
git.pkt.payload.max=106
git.ls_refs.count=107
git.ls_refs.head=refs/heads/master
fetchtree:0 · deepen 102009.3 KiB · hit3 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=3
git.response.bytes=9489
git.response.cache=HIT
git.response.duration_ms=3
git.fetch.filter=tree:0
git.fetch.wants=c0d2c3e95d74cb60526ff28aec9f34ee3df545e0
git.fetch.haves.count=0
git.fetch.deepen=10
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=7
git.pkt.data=5
git.pkt.flush=1
git.pkt.delim=1
git.pkt.bytes=9489
git.pkt.payload.max=9389
git.sideband.band1.bytes=9389
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=10
git.pack.bytes=9389
git.pack.ofs_delta=0
git.pack.ref_delta=0
git.pack.chain.max=0
git.pack.trailer=de930681b6073ba5b599a0f956bfbd114762ad5a
git.pack.full=10
Open pack map
fetchcombine:blob:none+tree:2 · deepen 12008.6 KiB · hit4 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=4
git.response.bytes=8830
git.response.cache=HIT
git.response.duration_ms=4
git.fetch.filter=combine:blob:none+tree:2
git.fetch.wants=c0d2c3e95d74cb60526ff28aec9f34ee3df545e0
git.fetch.haves.count=0
git.fetch.deepen=1
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=7
git.pkt.data=5
git.pkt.flush=1
git.pkt.delim=1
git.pkt.bytes=8830
git.pkt.payload.max=8730
git.sideband.band1.bytes=8730
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=14
git.pack.bytes=8730
git.fetch.wide.objects=14
git.fetch.wide.extra_bytes=9909
git.fetch.wide.blobs=0
fetch2002.1 KiB · hit48 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=48
git.response.bytes=2168
git.response.cache=HIT
git.response.duration_ms=48
git.fetch.wants=be5bf229bf3f6cb555b39c3fae9577fe2061ec18
git.fetch.haves.count=0
git.fetch.deepen=0
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=4
git.pkt.data=3
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=2168
git.pkt.payload.max=2141
git.sideband.band1.bytes=2141
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0

Each row is one HTTP round trip ply made to the git server for this page, on one timeline. discover asks what the server speaks, ls-refs lists branch tips, fetch brings objects by id. A hit was served by Workers Cache. Tap a row for its wire details.

Remote
https://codeberg.org/dnkl/foot
Ref
refs/heads/master
Commit
c0d2c3e95d74cb60526ff28aec9f34ee3df545e0
cf-ray
a5e154df3dbd90ce
Request
20b90bba…
Protocol
v2 · sha1
Agent
git/2.56.1-Linux
Filter
advertised
Fetch
shallow wait-for-done filter
Capabilities
agent ls-refs fetch server-option object-format