Hojun-Cho/ww
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ww: reject case-fold package and source collisions

Browse Source
This commit is contained in:
Hojun-Cho
2026-08-15 15:47:56 +09:00
parent 6d2319e14c
commit 265be3f796
2 changed files with 1612 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

775
cmd/ww/main.c
View File

@@ -836,6 +836,401 @@ struct sepchildren {
int n, cap;
};
struct sepfoldrange {
u32 lo, hi;
int stride, delta;
};
/* Unicode 15.0 simple-fold minima generated from Go 1.26.5's byte-pinned
* unicode tables. This is a collision key only; exact spellings remain the
* sole package, action, symbol, export, and artifact identities. */
static const struct sepfoldrange sep_fold_ranges[] = {
{ 0x000041, 0x00005a, 1, 32 },
{ 0x0000e0, 0x0000f6, 1, -32 },
{ 0x0000f8, 0x0000fe, 1, -32 },
{ 0x000101, 0x00012f, 2, -1 },
{ 0x000133, 0x000137, 2, -1 },
{ 0x00013a, 0x000148, 2, -1 },
{ 0x00014b, 0x000177, 2, -1 },
{ 0x000178, 0x000178, 1, -121 },
{ 0x00017a, 0x00017e, 2, -1 },
{ 0x00017f, 0x00017f, 1, -268 },
{ 0x000183, 0x000185, 2, -1 },
{ 0x000188, 0x000188, 1, -1 },
{ 0x00018c, 0x00018c, 1, -1 },
{ 0x000192, 0x000192, 1, -1 },
{ 0x000199, 0x000199, 1, -1 },
{ 0x0001a1, 0x0001a5, 2, -1 },
{ 0x0001a8, 0x0001a8, 1, -1 },
{ 0x0001ad, 0x0001ad, 1, -1 },
{ 0x0001b0, 0x0001b0, 1, -1 },
{ 0x0001b4, 0x0001b6, 2, -1 },
{ 0x0001b9, 0x0001b9, 1, -1 },
{ 0x0001bd, 0x0001bd, 1, -1 },
{ 0x0001c5, 0x0001c5, 1, -1 },
{ 0x0001c6, 0x0001c6, 1, -2 },
{ 0x0001c8, 0x0001c8, 1, -1 },
{ 0x0001c9, 0x0001c9, 1, -2 },
{ 0x0001cb, 0x0001cb, 1, -1 },
{ 0x0001cc, 0x0001cc, 1, -2 },
{ 0x0001ce, 0x0001dc, 2, -1 },
{ 0x0001dd, 0x0001dd, 1, -79 },
{ 0x0001df, 0x0001ef, 2, -1 },
{ 0x0001f2, 0x0001f2, 1, -1 },
{ 0x0001f3, 0x0001f3, 1, -2 },
{ 0x0001f5, 0x0001f5, 1, -1 },
{ 0x0001f6, 0x0001f6, 1, -97 },
{ 0x0001f7, 0x0001f7, 1, -56 },
{ 0x0001f9, 0x00021f, 2, -1 },
{ 0x000220, 0x000220, 1, -130 },
{ 0x000223, 0x000233, 2, -1 },
{ 0x00023c, 0x00023c, 1, -1 },
{ 0x00023d, 0x00023d, 1, -163 },
{ 0x000242, 0x000242, 1, -1 },
{ 0x000243, 0x000243, 1, -195 },
{ 0x000247, 0x00024f, 2, -1 },
{ 0x000253, 0x000253, 1, -210 },
{ 0x000254, 0x000254, 1, -206 },
{ 0x000256, 0x000257, 1, -205 },
{ 0x000259, 0x000259, 1, -202 },
{ 0x00025b, 0x00025b, 1, -203 },
{ 0x000260, 0x000260, 1, -205 },
{ 0x000263, 0x000263, 1, -207 },
{ 0x000268, 0x000268, 1, -209 },
{ 0x000269, 0x000269, 1, -211 },
{ 0x00026f, 0x00026f, 1, -211 },
{ 0x000272, 0x000272, 1, -213 },
{ 0x000275, 0x000275, 1, -214 },
{ 0x000280, 0x000280, 1, -218 },
{ 0x000283, 0x000283, 1, -218 },
{ 0x000288, 0x000288, 1, -218 },
{ 0x000289, 0x000289, 1, -69 },
{ 0x00028a, 0x00028b, 1, -217 },
{ 0x00028c, 0x00028c, 1, -71 },
{ 0x000292, 0x000292, 1, -219 },
{ 0x000371, 0x000373, 2, -1 },
{ 0x000377, 0x000377, 1, -1 },
{ 0x000399, 0x000399, 1, -84 },
{ 0x00039c, 0x00039c, 1, -743 },
{ 0x0003ac, 0x0003ac, 1, -38 },
{ 0x0003ad, 0x0003af, 1, -37 },
{ 0x0003b1, 0x0003b8, 1, -32 },
{ 0x0003b9, 0x0003b9, 1, -116 },
{ 0x0003ba, 0x0003bb, 1, -32 },
{ 0x0003bc, 0x0003bc, 1, -775 },
{ 0x0003bd, 0x0003c1, 1, -32 },
{ 0x0003c2, 0x0003c2, 1, -31 },
{ 0x0003c3, 0x0003cb, 1, -32 },
{ 0x0003cc, 0x0003cc, 1, -64 },
{ 0x0003cd, 0x0003ce, 1, -63 },
{ 0x0003d0, 0x0003d0, 1, -62 },
{ 0x0003d1, 0x0003d1, 1, -57 },
{ 0x0003d5, 0x0003d5, 1, -47 },
{ 0x0003d6, 0x0003d6, 1, -54 },
{ 0x0003d7, 0x0003d7, 1, -8 },
{ 0x0003d9, 0x0003ef, 2, -1 },
{ 0x0003f0, 0x0003f0, 1, -86 },
{ 0x0003f1, 0x0003f1, 1, -80 },
{ 0x0003f3, 0x0003f3, 1, -116 },
{ 0x0003f4, 0x0003f4, 1, -92 },
{ 0x0003f5, 0x0003f5, 1, -96 },
{ 0x0003f8, 0x0003f8, 1, -1 },
{ 0x0003f9, 0x0003f9, 1, -7 },
{ 0x0003fb, 0x0003fb, 1, -1 },
{ 0x0003fd, 0x0003ff, 1, -130 },
{ 0x000430, 0x00044f, 1, -32 },
{ 0x000450, 0x00045f, 1, -80 },
{ 0x000461, 0x000481, 2, -1 },
{ 0x00048b, 0x0004bf, 2, -1 },
{ 0x0004c2, 0x0004ce, 2, -1 },
{ 0x0004cf, 0x0004cf, 1, -15 },
{ 0x0004d1, 0x00052f, 2, -1 },
{ 0x000561, 0x000586, 1, -48 },
{ 0x0013f8, 0x0013fd, 1, -8 },
{ 0x001c80, 0x001c80, 1, -6254 },
{ 0x001c81, 0x001c81, 1, -6253 },
{ 0x001c82, 0x001c82, 1, -6244 },
{ 0x001c83, 0x001c84, 1, -6242 },
{ 0x001c85, 0x001c85, 1, -6243 },
{ 0x001c86, 0x001c86, 1, -6236 },
{ 0x001c87, 0x001c87, 1, -6181 },
{ 0x001c90, 0x001cba, 1, -3008 },
{ 0x001cbd, 0x001cbf, 1, -3008 },
{ 0x001e01, 0x001e95, 2, -1 },
{ 0x001e9b, 0x001e9b, 1, -59 },
{ 0x001e9e, 0x001e9e, 1, -7615 },
{ 0x001ea1, 0x001eff, 2, -1 },
{ 0x001f08, 0x001f0f, 1, -8 },
{ 0x001f18, 0x001f1d, 1, -8 },
{ 0x001f28, 0x001f2f, 1, -8 },
{ 0x001f38, 0x001f3f, 1, -8 },
{ 0x001f48, 0x001f4d, 1, -8 },
{ 0x001f59, 0x001f5f, 2, -8 },
{ 0x001f68, 0x001f6f, 1, -8 },
{ 0x001f88, 0x001f8f, 1, -8 },
{ 0x001f98, 0x001f9f, 1, -8 },
{ 0x001fa8, 0x001faf, 1, -8 },
{ 0x001fb8, 0x001fb9, 1, -8 },
{ 0x001fba, 0x001fbb, 1, -74 },
{ 0x001fbc, 0x001fbc, 1, -9 },
{ 0x001fbe, 0x001fbe, 1, -7289 },
{ 0x001fc8, 0x001fcb, 1, -86 },
{ 0x001fcc, 0x001fcc, 1, -9 },
{ 0x001fd8, 0x001fd9, 1, -8 },
{ 0x001fda, 0x001fdb, 1, -100 },
{ 0x001fe8, 0x001fe9, 1, -8 },
{ 0x001fea, 0x001feb, 1, -112 },
{ 0x001fec, 0x001fec, 1, -7 },
{ 0x001ff8, 0x001ff9, 1, -128 },
{ 0x001ffa, 0x001ffb, 1, -126 },
{ 0x001ffc, 0x001ffc, 1, -9 },
{ 0x002126, 0x002126, 1, -7549 },
{ 0x00212a, 0x00212a, 1, -8383 },
{ 0x00212b, 0x00212b, 1, -8294 },
{ 0x00214e, 0x00214e, 1, -28 },
{ 0x002170, 0x00217f, 1, -16 },
{ 0x002184, 0x002184, 1, -1 },
{ 0x0024d0, 0x0024e9, 1, -26 },
{ 0x002c30, 0x002c5f, 1, -48 },
{ 0x002c61, 0x002c61, 1, -1 },
{ 0x002c62, 0x002c62, 1, -10743 },
{ 0x002c63, 0x002c63, 1, -3814 },
{ 0x002c64, 0x002c64, 1, -10727 },
{ 0x002c65, 0x002c65, 1, -10795 },
{ 0x002c66, 0x002c66, 1, -10792 },
{ 0x002c68, 0x002c6c, 2, -1 },
{ 0x002c6d, 0x002c6d, 1, -10780 },
{ 0x002c6e, 0x002c6e, 1, -10749 },
{ 0x002c6f, 0x002c6f, 1, -10783 },
{ 0x002c70, 0x002c70, 1, -10782 },
{ 0x002c73, 0x002c73, 1, -1 },
{ 0x002c76, 0x002c76, 1, -1 },
{ 0x002c7e, 0x002c7f, 1, -10815 },
{ 0x002c81, 0x002ce3, 2, -1 },
{ 0x002cec, 0x002cee, 2, -1 },
{ 0x002cf3, 0x002cf3, 1, -1 },
{ 0x002d00, 0x002d25, 1, -7264 },
{ 0x002d27, 0x002d27, 1, -7264 },
{ 0x002d2d, 0x002d2d, 1, -7264 },
{ 0x00a641, 0x00a649, 2, -1 },
{ 0x00a64a, 0x00a64a, 1, -35266 },
{ 0x00a64b, 0x00a64b, 1, -35267 },
{ 0x00a64d, 0x00a66d, 2, -1 },
{ 0x00a681, 0x00a69b, 2, -1 },
{ 0x00a723, 0x00a72f, 2, -1 },
{ 0x00a733, 0x00a76f, 2, -1 },
{ 0x00a77a, 0x00a77c, 2, -1 },
{ 0x00a77d, 0x00a77d, 1, -35332 },
{ 0x00a77f, 0x00a787, 2, -1 },
{ 0x00a78c, 0x00a78c, 1, -1 },
{ 0x00a78d, 0x00a78d, 1, -42280 },
{ 0x00a791, 0x00a793, 2, -1 },
{ 0x00a797, 0x00a7a9, 2, -1 },
{ 0x00a7aa, 0x00a7aa, 1, -42308 },
{ 0x00a7ab, 0x00a7ab, 1, -42319 },
{ 0x00a7ac, 0x00a7ac, 1, -42315 },
{ 0x00a7ad, 0x00a7ad, 1, -42305 },
{ 0x00a7ae, 0x00a7ae, 1, -42308 },
{ 0x00a7b0, 0x00a7b0, 1, -42258 },
{ 0x00a7b1, 0x00a7b1, 1, -42282 },
{ 0x00a7b2, 0x00a7b2, 1, -42261 },
{ 0x00a7b5, 0x00a7c3, 2, -1 },
{ 0x00a7c4, 0x00a7c4, 1, -48 },
{ 0x00a7c5, 0x00a7c5, 1, -42307 },
{ 0x00a7c6, 0x00a7c6, 1, -35384 },
{ 0x00a7c8, 0x00a7ca, 2, -1 },
{ 0x00a7d1, 0x00a7d1, 1, -1 },
{ 0x00a7d7, 0x00a7d9, 2, -1 },
{ 0x00a7f6, 0x00a7f6, 1, -1 },
{ 0x00ab53, 0x00ab53, 1, -928 },
{ 0x00ab70, 0x00abbf, 1, -38864 },
{ 0x00ff41, 0x00ff5a, 1, -32 },
{ 0x010428, 0x01044f, 1, -40 },
{ 0x0104d8, 0x0104fb, 1, -40 },
{ 0x010597, 0x0105a1, 1, -39 },
{ 0x0105a3, 0x0105b1, 1, -39 },
{ 0x0105b3, 0x0105b9, 1, -39 },
{ 0x0105bb, 0x0105bc, 1, -39 },
{ 0x010cc0, 0x010cf2, 1, -64 },
{ 0x0118c0, 0x0118df, 1, -32 },
{ 0x016e60, 0x016e7f, 1, -32 },
{ 0x01e922, 0x01e943, 1, -34 },
};
/* Go 1.26.5 strconv.IsPrint tables keep %q-style collision diagnostics
* byte-stable for printable Unicode and arbitrary filesystem bytes. */
static const u16 sep_print16[424] = {
0x0020, 0x007e, 0x00a1, 0x0377, 0x037a, 0x037f, 0x0384, 0x0556,
0x0559, 0x058a, 0x058d, 0x05c7, 0x05d0, 0x05ea, 0x05ef, 0x05f4,
0x0606, 0x070d, 0x0710, 0x074a, 0x074d, 0x07b1, 0x07c0, 0x07fa,
0x07fd, 0x082d, 0x0830, 0x085b, 0x085e, 0x086a, 0x0870, 0x088e,
0x0898, 0x098c, 0x098f, 0x0990, 0x0993, 0x09b2, 0x09b6, 0x09b9,
0x09bc, 0x09c4, 0x09c7, 0x09c8, 0x09cb, 0x09ce, 0x09d7, 0x09d7,
0x09dc, 0x09e3, 0x09e6, 0x09fe, 0x0a01, 0x0a0a, 0x0a0f, 0x0a10,
0x0a13, 0x0a39, 0x0a3c, 0x0a42, 0x0a47, 0x0a48, 0x0a4b, 0x0a4d,
0x0a51, 0x0a51, 0x0a59, 0x0a5e, 0x0a66, 0x0a76, 0x0a81, 0x0ab9,
0x0abc, 0x0acd, 0x0ad0, 0x0ad0, 0x0ae0, 0x0ae3, 0x0ae6, 0x0af1,
0x0af9, 0x0b0c, 0x0b0f, 0x0b10, 0x0b13, 0x0b39, 0x0b3c, 0x0b44,
0x0b47, 0x0b48, 0x0b4b, 0x0b4d, 0x0b55, 0x0b57, 0x0b5c, 0x0b63,
0x0b66, 0x0b77, 0x0b82, 0x0b8a, 0x0b8e, 0x0b95, 0x0b99, 0x0b9f,
0x0ba3, 0x0ba4, 0x0ba8, 0x0baa, 0x0bae, 0x0bb9, 0x0bbe, 0x0bc2,
0x0bc6, 0x0bcd, 0x0bd0, 0x0bd0, 0x0bd7, 0x0bd7, 0x0be6, 0x0bfa,
0x0c00, 0x0c39, 0x0c3c, 0x0c4d, 0x0c55, 0x0c5a, 0x0c5d, 0x0c5d,
0x0c60, 0x0c63, 0x0c66, 0x0c6f, 0x0c77, 0x0cb9, 0x0cbc, 0x0ccd,
0x0cd5, 0x0cd6, 0x0cdd, 0x0ce3, 0x0ce6, 0x0cf3, 0x0d00, 0x0d4f,
0x0d54, 0x0d63, 0x0d66, 0x0d96, 0x0d9a, 0x0dbd, 0x0dc0, 0x0dc6,
0x0dca, 0x0dca, 0x0dcf, 0x0ddf, 0x0de6, 0x0def, 0x0df2, 0x0df4,
0x0e01, 0x0e3a, 0x0e3f, 0x0e5b, 0x0e81, 0x0ebd, 0x0ec0, 0x0ed9,
0x0edc, 0x0edf, 0x0f00, 0x0f6c, 0x0f71, 0x0fda, 0x1000, 0x10c7,
0x10cd, 0x10cd, 0x10d0, 0x124d, 0x1250, 0x125d, 0x1260, 0x128d,
0x1290, 0x12b5, 0x12b8, 0x12c5, 0x12c8, 0x1315, 0x1318, 0x135a,
0x135d, 0x137c, 0x1380, 0x1399, 0x13a0, 0x13f5, 0x13f8, 0x13fd,
0x1400, 0x169c, 0x16a0, 0x16f8, 0x1700, 0x1715, 0x171f, 0x1736,
0x1740, 0x1753, 0x1760, 0x1773, 0x1780, 0x17dd, 0x17e0, 0x17e9,
0x17f0, 0x17f9, 0x1800, 0x1819, 0x1820, 0x1878, 0x1880, 0x18aa,
0x18b0, 0x18f5, 0x1900, 0x192b, 0x1930, 0x193b, 0x1940, 0x1940,
0x1944, 0x196d, 0x1970, 0x1974, 0x1980, 0x19ab, 0x19b0, 0x19c9,
0x19d0, 0x19da, 0x19de, 0x1a1b, 0x1a1e, 0x1a7c, 0x1a7f, 0x1a89,
0x1a90, 0x1a99, 0x1aa0, 0x1aad, 0x1ab0, 0x1ace, 0x1b00, 0x1b4c,
0x1b50, 0x1bf3, 0x1bfc, 0x1c37, 0x1c3b, 0x1c49, 0x1c4d, 0x1c88,
0x1c90, 0x1cba, 0x1cbd, 0x1cc7, 0x1cd0, 0x1cfa, 0x1d00, 0x1f15,
0x1f18, 0x1f1d, 0x1f20, 0x1f45, 0x1f48, 0x1f4d, 0x1f50, 0x1f7d,
0x1f80, 0x1fd3, 0x1fd6, 0x1fef, 0x1ff2, 0x1ffe, 0x2010, 0x2027,
0x2030, 0x205e, 0x2070, 0x2071, 0x2074, 0x209c, 0x20a0, 0x20c0,
0x20d0, 0x20f0, 0x2100, 0x218b, 0x2190, 0x2426, 0x2440, 0x244a,
0x2460, 0x2b73, 0x2b76, 0x2cf3, 0x2cf9, 0x2d27, 0x2d2d, 0x2d2d,
0x2d30, 0x2d67, 0x2d6f, 0x2d70, 0x2d7f, 0x2d96, 0x2da0, 0x2e5d,
0x2e80, 0x2ef3, 0x2f00, 0x2fd5, 0x2ff0, 0x2ffb, 0x3001, 0x3096,
0x3099, 0x30ff, 0x3105, 0x31e3, 0x31f0, 0xa48c, 0xa490, 0xa4c6,
0xa4d0, 0xa62b, 0xa640, 0xa6f7, 0xa700, 0xa7ca, 0xa7d0, 0xa7d9,
0xa7f2, 0xa82c, 0xa830, 0xa839, 0xa840, 0xa877, 0xa880, 0xa8c5,
0xa8ce, 0xa8d9, 0xa8e0, 0xa953, 0xa95f, 0xa97c, 0xa980, 0xa9d9,
0xa9de, 0xaa36, 0xaa40, 0xaa4d, 0xaa50, 0xaa59, 0xaa5c, 0xaac2,
0xaadb, 0xaaf6, 0xab01, 0xab06, 0xab09, 0xab0e, 0xab11, 0xab16,
0xab20, 0xab6b, 0xab70, 0xabed, 0xabf0, 0xabf9, 0xac00, 0xd7a3,
0xd7b0, 0xd7c6, 0xd7cb, 0xd7fb, 0xf900, 0xfa6d, 0xfa70, 0xfad9,
0xfb00, 0xfb06, 0xfb13, 0xfb17, 0xfb1d, 0xfbc2, 0xfbd3, 0xfd8f,
0xfd92, 0xfdc7, 0xfdcf, 0xfdcf, 0xfdf0, 0xfe19, 0xfe20, 0xfe6b,
0xfe70, 0xfefc, 0xff01, 0xffbe, 0xffc2, 0xffc7, 0xffca, 0xffcf,
0xffd2, 0xffd7, 0xffda, 0xffdc, 0xffe0, 0xffee, 0xfffc, 0xfffd,
};
static const u16 sep_not_print16[133] = {
0x00ad, 0x038b, 0x038d, 0x03a2, 0x0530, 0x0590, 0x061c, 0x06dd,
0x083f, 0x085f, 0x08e2, 0x0984, 0x09a9, 0x09b1, 0x09de, 0x0a04,
0x0a29, 0x0a31, 0x0a34, 0x0a37, 0x0a3d, 0x0a5d, 0x0a84, 0x0a8e,
0x0a92, 0x0aa9, 0x0ab1, 0x0ab4, 0x0ac6, 0x0aca, 0x0b00, 0x0b04,
0x0b29, 0x0b31, 0x0b34, 0x0b5e, 0x0b84, 0x0b91, 0x0b9b, 0x0b9d,
0x0bc9, 0x0c0d, 0x0c11, 0x0c29, 0x0c45, 0x0c49, 0x0c57, 0x0c8d,
0x0c91, 0x0ca9, 0x0cb4, 0x0cc5, 0x0cc9, 0x0cdf, 0x0cf0, 0x0d0d,
0x0d11, 0x0d45, 0x0d49, 0x0d80, 0x0d84, 0x0db2, 0x0dbc, 0x0dd5,
0x0dd7, 0x0e83, 0x0e85, 0x0e8b, 0x0ea4, 0x0ea6, 0x0ec5, 0x0ec7,
0x0ecf, 0x0f48, 0x0f98, 0x0fbd, 0x0fcd, 0x10c6, 0x1249, 0x1257,
0x1259, 0x1289, 0x12b1, 0x12bf, 0x12c1, 0x12d7, 0x1311, 0x1680,
0x176d, 0x1771, 0x180e, 0x191f, 0x1a5f, 0x1b7f, 0x1f58, 0x1f5a,
0x1f5c, 0x1f5e, 0x1fb5, 0x1fc5, 0x1fdc, 0x1ff5, 0x208f, 0x2b96,
0x2d26, 0x2da7, 0x2daf, 0x2db7, 0x2dbf, 0x2dc7, 0x2dcf, 0x2dd7,
0x2ddf, 0x2e9a, 0x3040, 0x3130, 0x318f, 0x321f, 0xa7d2, 0xa7d4,
0xa9ce, 0xa9ff, 0xab27, 0xab2f, 0xfb37, 0xfb3d, 0xfb3f, 0xfb42,
0xfb45, 0xfe53, 0xfe67, 0xfe75, 0xffe7,
};
static const u32 sep_print32[508] = {
0x010000, 0x01004d, 0x010050, 0x01005d, 0x010080, 0x0100fa, 0x010100, 0x010102,
0x010107, 0x010133, 0x010137, 0x01019c, 0x0101a0, 0x0101a0, 0x0101d0, 0x0101fd,
0x010280, 0x01029c, 0x0102a0, 0x0102d0, 0x0102e0, 0x0102fb, 0x010300, 0x010323,
0x01032d, 0x01034a, 0x010350, 0x01037a, 0x010380, 0x0103c3, 0x0103c8, 0x0103d5,
0x010400, 0x01049d, 0x0104a0, 0x0104a9, 0x0104b0, 0x0104d3, 0x0104d8, 0x0104fb,
0x010500, 0x010527, 0x010530, 0x010563, 0x01056f, 0x0105bc, 0x010600, 0x010736,
0x010740, 0x010755, 0x010760, 0x010767, 0x010780, 0x0107ba, 0x010800, 0x010805,
0x010808, 0x010838, 0x01083c, 0x01083c, 0x01083f, 0x01089e, 0x0108a7, 0x0108af,
0x0108e0, 0x0108f5, 0x0108fb, 0x01091b, 0x01091f, 0x010939, 0x01093f, 0x01093f,
0x010980, 0x0109b7, 0x0109bc, 0x0109cf, 0x0109d2, 0x010a06, 0x010a0c, 0x010a35,
0x010a38, 0x010a3a, 0x010a3f, 0x010a48, 0x010a50, 0x010a58, 0x010a60, 0x010a9f,
0x010ac0, 0x010ae6, 0x010aeb, 0x010af6, 0x010b00, 0x010b35, 0x010b39, 0x010b55,
0x010b58, 0x010b72, 0x010b78, 0x010b91, 0x010b99, 0x010b9c, 0x010ba9, 0x010baf,
0x010c00, 0x010c48, 0x010c80, 0x010cb2, 0x010cc0, 0x010cf2, 0x010cfa, 0x010d27,
0x010d30, 0x010d39, 0x010e60, 0x010ead, 0x010eb0, 0x010eb1, 0x010efd, 0x010f27,
0x010f30, 0x010f59, 0x010f70, 0x010f89, 0x010fb0, 0x010fcb, 0x010fe0, 0x010ff6,
0x011000, 0x01104d, 0x011052, 0x011075, 0x01107f, 0x0110c2, 0x0110d0, 0x0110e8,
0x0110f0, 0x0110f9, 0x011100, 0x011147, 0x011150, 0x011176, 0x011180, 0x0111f4,
0x011200, 0x011241, 0x011280, 0x0112a9, 0x0112b0, 0x0112ea, 0x0112f0, 0x0112f9,
0x011300, 0x01130c, 0x01130f, 0x011310, 0x011313, 0x011344, 0x011347, 0x011348,
0x01134b, 0x01134d, 0x011350, 0x011350, 0x011357, 0x011357, 0x01135d, 0x011363,
0x011366, 0x01136c, 0x011370, 0x011374, 0x011400, 0x011461, 0x011480, 0x0114c7,
0x0114d0, 0x0114d9, 0x011580, 0x0115b5, 0x0115b8, 0x0115dd, 0x011600, 0x011644,
0x011650, 0x011659, 0x011660, 0x01166c, 0x011680, 0x0116b9, 0x0116c0, 0x0116c9,
0x011700, 0x01171a, 0x01171d, 0x01172b, 0x011730, 0x011746, 0x011800, 0x01183b,
0x0118a0, 0x0118f2, 0x0118ff, 0x011906, 0x011909, 0x011909, 0x01190c, 0x011938,
0x01193b, 0x011946, 0x011950, 0x011959, 0x0119a0, 0x0119a7, 0x0119aa, 0x0119d7,
0x0119da, 0x0119e4, 0x011a00, 0x011a47, 0x011a50, 0x011aa2, 0x011ab0, 0x011af8,
0x011b00, 0x011b09, 0x011c00, 0x011c45, 0x011c50, 0x011c6c, 0x011c70, 0x011c8f,
0x011c92, 0x011cb6, 0x011d00, 0x011d36, 0x011d3a, 0x011d47, 0x011d50, 0x011d59,
0x011d60, 0x011d98, 0x011da0, 0x011da9, 0x011ee0, 0x011ef8, 0x011f00, 0x011f3a,
0x011f3e, 0x011f59, 0x011fb0, 0x011fb0, 0x011fc0, 0x011ff1, 0x011fff, 0x012399,
0x012400, 0x012474, 0x012480, 0x012543, 0x012f90, 0x012ff2, 0x013000, 0x01342f,
0x013440, 0x013455, 0x014400, 0x014646, 0x016800, 0x016a38, 0x016a40, 0x016a69,
0x016a6e, 0x016ac9, 0x016ad0, 0x016aed, 0x016af0, 0x016af5, 0x016b00, 0x016b45,
0x016b50, 0x016b77, 0x016b7d, 0x016b8f, 0x016e40, 0x016e9a, 0x016f00, 0x016f4a,
0x016f4f, 0x016f87, 0x016f8f, 0x016f9f, 0x016fe0, 0x016fe4, 0x016ff0, 0x016ff1,
0x017000, 0x0187f7, 0x018800, 0x018cd5, 0x018d00, 0x018d08, 0x01aff0, 0x01b122,
0x01b132, 0x01b132, 0x01b150, 0x01b152, 0x01b155, 0x01b155, 0x01b164, 0x01b167,
0x01b170, 0x01b2fb, 0x01bc00, 0x01bc6a, 0x01bc70, 0x01bc7c, 0x01bc80, 0x01bc88,
0x01bc90, 0x01bc99, 0x01bc9c, 0x01bc9f, 0x01cf00, 0x01cf2d, 0x01cf30, 0x01cf46,
0x01cf50, 0x01cfc3, 0x01d000, 0x01d0f5, 0x01d100, 0x01d126, 0x01d129, 0x01d172,
0x01d17b, 0x01d1ea, 0x01d200, 0x01d245, 0x01d2c0, 0x01d2d3, 0x01d2e0, 0x01d2f3,
0x01d300, 0x01d356, 0x01d360, 0x01d378, 0x01d400, 0x01d49f, 0x01d4a2, 0x01d4a2,
0x01d4a5, 0x01d4a6, 0x01d4a9, 0x01d50a, 0x01d50d, 0x01d546, 0x01d54a, 0x01d6a5,
0x01d6a8, 0x01d7cb, 0x01d7ce, 0x01da8b, 0x01da9b, 0x01daaf, 0x01df00, 0x01df1e,
0x01df25, 0x01df2a, 0x01e000, 0x01e018, 0x01e01b, 0x01e02a, 0x01e030, 0x01e06d,
0x01e08f, 0x01e08f, 0x01e100, 0x01e12c, 0x01e130, 0x01e13d, 0x01e140, 0x01e149,
0x01e14e, 0x01e14f, 0x01e290, 0x01e2ae, 0x01e2c0, 0x01e2f9, 0x01e2ff, 0x01e2ff,
0x01e4d0, 0x01e4f9, 0x01e7e0, 0x01e8c4, 0x01e8c7, 0x01e8d6, 0x01e900, 0x01e94b,
0x01e950, 0x01e959, 0x01e95e, 0x01e95f, 0x01ec71, 0x01ecb4, 0x01ed01, 0x01ed3d,
0x01ee00, 0x01ee24, 0x01ee27, 0x01ee3b, 0x01ee42, 0x01ee42, 0x01ee47, 0x01ee54,
0x01ee57, 0x01ee64, 0x01ee67, 0x01ee9b, 0x01eea1, 0x01eebb, 0x01eef0, 0x01eef1,
0x01f000, 0x01f02b, 0x01f030, 0x01f093, 0x01f0a0, 0x01f0ae, 0x01f0b1, 0x01f0f5,
0x01f100, 0x01f1ad, 0x01f1e6, 0x01f202, 0x01f210, 0x01f23b, 0x01f240, 0x01f248,
0x01f250, 0x01f251, 0x01f260, 0x01f265, 0x01f300, 0x01f6d7, 0x01f6dc, 0x01f6ec,
0x01f6f0, 0x01f6fc, 0x01f700, 0x01f776, 0x01f77b, 0x01f7d9, 0x01f7e0, 0x01f7eb,
0x01f7f0, 0x01f7f0, 0x01f800, 0x01f80b, 0x01f810, 0x01f847, 0x01f850, 0x01f859,
0x01f860, 0x01f887, 0x01f890, 0x01f8ad, 0x01f8b0, 0x01f8b1, 0x01f900, 0x01fa53,
0x01fa60, 0x01fa6d, 0x01fa70, 0x01fa7c, 0x01fa80, 0x01fa88, 0x01fa90, 0x01fac5,
0x01face, 0x01fadb, 0x01fae0, 0x01fae8, 0x01faf0, 0x01faf8, 0x01fb00, 0x01fbca,
0x01fbf0, 0x01fbf9, 0x020000, 0x02a6df, 0x02a700, 0x02b739, 0x02b740, 0x02b81d,
0x02b820, 0x02cea1, 0x02ceb0, 0x02ebe0, 0x02f800, 0x02fa1d, 0x030000, 0x03134a,
0x031350, 0x0323af, 0x0e0100, 0x0e01ef,
};
static const u16 sep_not_print32[112] = {
0x000c, 0x0027, 0x003b, 0x003e, 0x018f, 0x039e, 0x057b,
0x058b, 0x0593, 0x0596, 0x05a2, 0x05b2, 0x05ba, 0x0786, 0x07b1,
0x0809, 0x0836, 0x0856, 0x08f3, 0x0a04, 0x0a14, 0x0a18, 0x0e7f,
0x0eaa, 0x10bd, 0x1135, 0x11e0, 0x1212, 0x1287, 0x1289, 0x128e,
0x129e, 0x1304, 0x1329, 0x1331, 0x1334, 0x133a, 0x145c, 0x1914,
0x1917, 0x1936, 0x1c09, 0x1c37, 0x1ca8, 0x1d07, 0x1d0a, 0x1d3b,
0x1d3e, 0x1d66, 0x1d69, 0x1d8f, 0x1d92, 0x1f11, 0x246f, 0x6a5f,
0x6abf, 0x6b5a, 0x6b62, 0xaff4, 0xaffc, 0xafff, 0xd455, 0xd49d,
0xd4ad, 0xd4ba, 0xd4bc, 0xd4c4, 0xd506, 0xd515, 0xd51d, 0xd53a,
0xd53f, 0xd545, 0xd551, 0xdaa0, 0xe007, 0xe022, 0xe025, 0xe7e7,
0xe7ec, 0xe7ef, 0xe7ff, 0xee04, 0xee20, 0xee23, 0xee28, 0xee33,
0xee38, 0xee3a, 0xee48, 0xee4a, 0xee4c, 0xee50, 0xee53, 0xee58,
0xee5a, 0xee5c, 0xee5e, 0xee60, 0xee63, 0xee6b, 0xee73, 0xee78,
0xee7d, 0xee7f, 0xee8a, 0xeea4, 0xeeaa, 0xf0c0, 0xf0d0, 0xfabe,
0xfb93,
};
struct sepfoldentry {
char *scope; /* canonical directory; NULL for package identities */
char *key; /* request-only Go simple-fold key */
char *exact; /* exact canonical identity or selected basename */
};
struct sepfoldset {
struct sepfoldentry *v;
int n, cap;
};
struct seppkg {
char *path; /* complete compiler/import identity */
char *import_base; /* complete canonical ordinary import identity */
@@ -892,6 +1287,8 @@ struct sepgraph {
int contextcap;
int support_context;
int identity_failed; /* command-global canonical identity collision */
struct sepfoldset package_folds;
struct sepfoldset file_folds;
};
struct sepproduct {
@@ -929,6 +1326,358 @@ sep_reserve_packages(struct sepgraph *g, int need)
sizeof *g->pkg);
}
static int
sep_reserve_folds(struct sepfoldset *set, int need)
{
return sep_reserve((void **)&set->v, &set->cap, need,
sizeof *set->v);
}
static int
sep_utf8_width(const char *value, size_t len, size_t index)
{
const unsigned char *s = (const unsigned char *)value;
unsigned char c = s[index];
if (c < 0x80) return 1;
if (c >= 0xc2 && c <= 0xdf && index + 1 < len
&& s[index + 1] >= 0x80 && s[index + 1] <= 0xbf)
return 2;
if (index + 2 < len && s[index + 2] >= 0x80
&& s[index + 2] <= 0xbf) {
unsigned char c1 = s[index + 1];
if ((c == 0xe0 && c1 >= 0xa0 && c1 <= 0xbf)
|| (c >= 0xe1 && c <= 0xec && c1 >= 0x80 && c1 <= 0xbf)
|| (c == 0xed && c1 >= 0x80 && c1 <= 0x9f)
|| (c >= 0xee && c <= 0xef && c1 >= 0x80 && c1 <= 0xbf))
return 3;
}
if (index + 3 < len && s[index + 2] >= 0x80
&& s[index + 2] <= 0xbf && s[index + 3] >= 0x80
&& s[index + 3] <= 0xbf) {
unsigned char c1 = s[index + 1];
if ((c == 0xf0 && c1 >= 0x90 && c1 <= 0xbf)
|| (c >= 0xf1 && c <= 0xf3 && c1 >= 0x80 && c1 <= 0xbf)
|| (c == 0xf4 && c1 >= 0x80 && c1 <= 0x8f))
return 4;
}
return 1;
}
static u32
sep_utf8_rune(const char *value, size_t index, int width)
{
const unsigned char *s = (const unsigned char *)value;
u32 c0 = s[index];
if (width == 1) return c0 >= 0x80 ? 0xfffd : c0;
u32 c1 = s[index + 1];
if (width == 2) return ((c0 & 0x1f) << 6) | (c1 & 0x3f);
u32 c2 = s[index + 2];
if (width == 3)
return ((c0 & 0x0f) << 12) | ((c1 & 0x3f) << 6)
| (c2 & 0x3f);
u32 c3 = s[index + 3];
return ((c0 & 0x07) << 18) | ((c1 & 0x3f) << 12)
| ((c2 & 0x3f) << 6) | (c3 & 0x3f);
}
static u32
sep_fold_rune(u32 r)
{
int lo = 0;
int hi = (int)(sizeof sep_fold_ranges / sizeof sep_fold_ranges[0]);
while (lo < hi) {
int middle = lo + (hi - lo) / 2;
if (sep_fold_ranges[middle].lo <= r) lo = middle + 1;
else hi = middle;
}
if (lo > 0) {
const struct sepfoldrange *range = &sep_fold_ranges[lo - 1];
if (r <= range->hi && (r - range->lo) % (u32)range->stride == 0)
return (u32)((long)r + range->delta);
}
return r;
}
static int
sep_utf8_encoded_width(u32 r)
{
if (r <= 0x7f) return 1;
if (r <= 0x7ff) return 2;
if (r <= 0xffff) return 3;
return 4;
}
static size_t
sep_utf8_encode(char *out, size_t offset, u32 r)
{
if (r <= 0x7f) {
out[offset++] = (char)r;
} else if (r <= 0x7ff) {
out[offset++] = (char)(0xc0 | (r >> 6));
out[offset++] = (char)(0x80 | (r & 0x3f));
} else if (r <= 0xffff) {
out[offset++] = (char)(0xe0 | (r >> 12));
out[offset++] = (char)(0x80 | ((r >> 6) & 0x3f));
out[offset++] = (char)(0x80 | (r & 0x3f));
} else {
out[offset++] = (char)(0xf0 | (r >> 18));
out[offset++] = (char)(0x80 | ((r >> 12) & 0x3f));
out[offset++] = (char)(0x80 | ((r >> 6) & 0x3f));
out[offset++] = (char)(0x80 | (r & 0x3f));
}
return offset;
}
static char *
sep_to_fold(const char *value)
{
size_t len = strlen(value);
size_t total = 0;
for (size_t i = 0; i < len;) {
int width = sep_utf8_width(value, len, i);
u32 r = sep_fold_rune(sep_utf8_rune(value, i, width));
int encoded = sep_utf8_encoded_width(r);
if (total > (size_t)-1 - (size_t)encoded - 1) {
sep_fail_size();
return NULL;
}
total += (size_t)encoded;
i += (size_t)width;
}
char *out = malloc(total + 1);
if (out == NULL) {
sep_fail_nomem();
return NULL;
}
size_t offset = 0;
for (size_t i = 0; i < len;) {
int width = sep_utf8_width(value, len, i);
u32 r = sep_fold_rune(sep_utf8_rune(value, i, width));
offset = sep_utf8_encode(out, offset, r);
i += (size_t)width;
}
out[offset] = '\0';
return out;
}
static int
sep_bsearch16(const u16 *values, int n, u16 target)
{
int lo = 0, hi = n;
while (lo < hi) {
int middle = lo + (hi - lo) / 2;
if (values[middle] < target) lo = middle + 1;
else hi = middle;
}
return lo;
}
static int
sep_bsearch32(const u32 *values, int n, u32 target)
{
int lo = 0, hi = n;
while (lo < hi) {
int middle = lo + (hi - lo) / 2;
if (values[middle] < target) lo = middle + 1;
else hi = middle;
}
return lo;
}
static int
sep_is_print(u32 r)
{
if (r <= 0xff) {
if (r >= 0x20 && r <= 0x7e) return 1;
if (r >= 0xa1) return r != 0xad;
return 0;
}
if (r < 0x10000) {
u16 rr = (u16)r;
int nprint = (int)(sizeof sep_print16 / sizeof sep_print16[0]);
int i = sep_bsearch16(sep_print16, nprint, rr);
if (i >= nprint) return 0;
int start = i;
if (start % 2 != 0) start--;
if (start + 1 >= nprint || rr < sep_print16[start]
|| sep_print16[start + 1] < rr) return 0;
int nexcluded = (int)(sizeof sep_not_print16
/ sizeof sep_not_print16[0]);
int excluded = sep_bsearch16(sep_not_print16, nexcluded, rr);
return excluded >= nexcluded || sep_not_print16[excluded] != rr;
}
int nprint = (int)(sizeof sep_print32 / sizeof sep_print32[0]);
int i = sep_bsearch32(sep_print32, nprint, r);
if (i >= nprint) return 0;
int start = i;
if (start % 2 != 0) start--;
if (start + 1 >= nprint || r < sep_print32[start]
|| sep_print32[start + 1] < r) return 0;
if (r >= 0x20000) return 1;
u16 rr = (u16)(r - 0x10000);
int nexcluded = (int)(sizeof sep_not_print32
/ sizeof sep_not_print32[0]);
int excluded = sep_bsearch16(sep_not_print32, nexcluded, rr);
return excluded >= nexcluded || sep_not_print32[excluded] != rr;
}
static void
sep_put_quoted(const char *value)
{
static const char hex[] = "0123456789abcdef";
size_t len = strlen(value);
fputc('"', stderr);
for (size_t i = 0; i < len;) {
unsigned char c = (unsigned char)value[i];
int width = sep_utf8_width(value, len, i);
if (c >= 0x80 && width == 1) {
fputs("\\x", stderr);
fputc(hex[c >> 4], stderr);
fputc(hex[c & 0x0f], stderr);
i++;
continue;
}
if (width > 1) {
u32 r = sep_utf8_rune(value, i, width);
if (sep_is_print(r)) fwrite(value + i, 1, (size_t)width, stderr);
else if (r < 0x10000) fprintf(stderr, "\\u%04x", r);
else fprintf(stderr, "\\U%08x", r);
i += (size_t)width;
continue;
}
switch (c) {
case '"': fputs("\\\"", stderr); break;
case '\\': fputs("\\\\", stderr); break;
case '\a': fputs("\\a", stderr); break;
case '\b': fputs("\\b", stderr); break;
case '\f': fputs("\\f", stderr); break;
case '\n': fputs("\\n", stderr); break;
case '\r': fputs("\\r", stderr); break;
case '\t': fputs("\\t", stderr); break;
case '\v': fputs("\\v", stderr); break;
default:
if (c < 0x20 || c == 0x7f) {
fputs("\\x", stderr);
fputc(hex[c >> 4], stderr);
fputc(hex[c & 0x0f], stderr);
} else fputc(c, stderr);
}
i++;
}
fputc('"', stderr);
}
static void
sep_diag_fold_collision(const char *kind, const char *left, const char *right)
{
if (strcmp(left, right) > 0) {
const char *swap = left;
left = right;
right = swap;
}
fprintf(stderr, "ww: case-insensitive %s collision: ", kind);
sep_put_quoted(left);
fputs(" and ", stderr);
sep_put_quoted(right);
fputc('\n', stderr);
}
static int
sep_register_package_fold(struct sepgraph *g, const char *exact)
{
char *key = sep_to_fold(exact);
if (key == NULL) return -1;
struct sepfoldset *set = &g->package_folds;
int lo = 0, hi = set->n;
while (lo < hi) {
int middle = lo + (hi - lo) / 2;
int cmp = strcmp(set->v[middle].key, key);
if (cmp < 0) lo = middle + 1;
else hi = middle;
}
if (lo < set->n && strcmp(set->v[lo].key, key) == 0) {
free(key);
if (strcmp(set->v[lo].exact, exact) == 0) return 0;
g->identity_failed = 1;
sep_diag_fold_collision("import", set->v[lo].exact, exact);
return -1;
}
char *spelling = strdup(exact);
if (spelling == NULL) {
free(key);
return sep_fail_nomem();
}
if (set->n == INT_MAX || sep_reserve_folds(set, set->n + 1) < 0) {
if (set->n == INT_MAX) sep_fail_size();
free(key);
free(spelling);
return -1;
}
memmove(&set->v[lo + 1], &set->v[lo],
(size_t)(set->n - lo) * sizeof set->v[0]);
set->v[lo].scope = NULL;
set->v[lo].key = key;
set->v[lo].exact = spelling;
set->n++;
return 0;
}
static int
sep_file_fold_cmp(const struct sepfoldentry *entry, const char *scope,
const char *key)
{
int cmp = strcmp(entry->scope, scope);
if (cmp != 0) return cmp;
return strcmp(entry->key, key);
}
static int
sep_register_file_fold(struct sepgraph *g, const char *scope,
const char *source)
{
const char *slash = strrchr(source, '/');
const char *exact = slash == NULL ? source : slash + 1;
char *key = sep_to_fold(exact);
if (key == NULL) return -1;
struct sepfoldset *set = &g->file_folds;
int lo = 0, hi = set->n;
while (lo < hi) {
int middle = lo + (hi - lo) / 2;
int cmp = sep_file_fold_cmp(&set->v[middle], scope, key);
if (cmp < 0) lo = middle + 1;
else hi = middle;
}
if (lo < set->n && sep_file_fold_cmp(&set->v[lo], scope, key) == 0) {
free(key);
if (strcmp(set->v[lo].exact, exact) == 0) return 0;
g->identity_failed = 1;
sep_diag_fold_collision("file name", set->v[lo].exact, exact);
return -1;
}
char *owned_scope = strdup(scope);
char *spelling = strdup(exact);
if (owned_scope == NULL || spelling == NULL) {
free(key);
free(owned_scope);
free(spelling);
return sep_fail_nomem();
}
if (set->n == INT_MAX || sep_reserve_folds(set, set->n + 1) < 0) {
if (set->n == INT_MAX) sep_fail_size();
free(key);
free(owned_scope);
free(spelling);
return -1;
}
memmove(&set->v[lo + 1], &set->v[lo],
(size_t)(set->n - lo) * sizeof set->v[0]);
set->v[lo].scope = owned_scope;
set->v[lo].key = key;
set->v[lo].exact = spelling;
set->n++;
return 0;
}
static int
sep_reserve_contexts(struct sepgraph *g, int need)
{
@@ -1409,10 +2158,14 @@ sep_bind_import_base(struct sepgraph *g, int pi, const char *base)
}
if (p->import_base != NULL) {
if (strcmp(p->import_base, base) == 0) return 0;
if (p->role != SEP_ROLE_TEST_SUPPORT
&& sep_register_package_fold(g, base) < 0) return -1;
g->identity_failed = 1;
sep_diag_directory_identities(p->entry, p->import_base, base);
return -1;
}
if (p->role != SEP_ROLE_TEST_SUPPORT
&& sep_register_package_fold(g, base) < 0) return -1;
char *path = sep_variant_path(p->variant, base);
if (path == NULL) return -1;
for (int i = 0; i < g->n; i++) {
@@ -1486,6 +2239,12 @@ sep_find_or_add_variant(struct sepgraph *g, const char *path,
return -1;
}
const char *base = path ? path : "";
if (is_dir && base[0] != '\0' && role != SEP_ROLE_TEST_SUPPORT
&& (reserved_import_path(base) || sep_import_base_valid(base))
&& sep_register_package_fold(g, base) < 0) {
free(canon);
return -1;
}
char *incoming_path = NULL;
if (is_dir && base[0] != '\0') {
incoming_path = sep_variant_path(variant, base);
@@ -1704,12 +2463,24 @@ sep_graph_free(struct sepgraph *g)
{
if (g == NULL) return;
for (int i = 0; i < g->n; i++) sep_pkg_free_fields(&g->pkg[i]);
for (int i = 0; i < g->package_folds.n; i++) {
free(g->package_folds.v[i].scope);
free(g->package_folds.v[i].key);
free(g->package_folds.v[i].exact);
}
for (int i = 0; i < g->file_folds.n; i++) {
free(g->file_folds.v[i].scope);
free(g->file_folds.v[i].key);
free(g->file_folds.v[i].exact);
}
for (int i = 0; i < g->ncontext; i++) {
free(g->context[i].root);
free(g->context[i].searchpath);
free(g->context[i].route);
free(g->context[i].source_root);
}
free(g->package_folds.v);
free(g->file_folds.v);
free(g->context);
free(g->pkg);
free(g);
@@ -3200,6 +3971,9 @@ sep_prepare_pkg_context(struct sepgraph *g, int pi, int context,
g->pkg[pi].entry);
rc = -1;
}
for (int i = 0; i < g->pkg[pi].nsources && rc == 0; i++)
rc = sep_register_file_fold(g, g->pkg[pi].canon,
g->pkg[pi].sources[i]);
}
}
if (g->pkg[pi].is_dir) {
@@ -5037,6 +5811,7 @@ build_one_sep_impl(const char *src, int entry_is_dir,
}
}
}
if (g->identity_failed) return 1;
if (have_runnable_tests) {
for (int i = 0; i < nproducts; i++) {
if (products[i].no_tests) continue;

837
selfhost/cmd/ww/main.ww
View File

@@ -1052,6 +1052,396 @@ type sepchild = struct {
context: i32,
};
type sepfoldrange = struct {
lo: u32,
hi: u32,
stride: u32,
delta: i32,
};
// Unicode 15.0 simple-fold minima generated from Go 1.26.5's byte-pinned
// tables. The folded spelling is request-only collision state.
let sepfoldranges: [210]sepfoldrange = [
sepfoldrange { lo = 0x000041u32, hi = 0x00005au32, stride = 1u32, delta = 32i32 },
sepfoldrange { lo = 0x0000e0u32, hi = 0x0000f6u32, stride = 1u32, delta = -32i32 },
sepfoldrange { lo = 0x0000f8u32, hi = 0x0000feu32, stride = 1u32, delta = -32i32 },
sepfoldrange { lo = 0x000101u32, hi = 0x00012fu32, stride = 2u32, delta = -1i32 },
sepfoldrange { lo = 0x000133u32, hi = 0x000137u32, stride = 2u32, delta = -1i32 },
sepfoldrange { lo = 0x00013au32, hi = 0x000148u32, stride = 2u32, delta = -1i32 },
sepfoldrange { lo = 0x00014bu32, hi = 0x000177u32, stride = 2u32, delta = -1i32 },
sepfoldrange { lo = 0x000178u32, hi = 0x000178u32, stride = 1u32, delta = -121i32 },
sepfoldrange { lo = 0x00017au32, hi = 0x00017eu32, stride = 2u32, delta = -1i32 },
sepfoldrange { lo = 0x00017fu32, hi = 0x00017fu32, stride = 1u32, delta = -268i32 },
sepfoldrange { lo = 0x000183u32, hi = 0x000185u32, stride = 2u32, delta = -1i32 },
sepfoldrange { lo = 0x000188u32, hi = 0x000188u32, stride = 1u32, delta = -1i32 },
sepfoldrange { lo = 0x00018cu32, hi = 0x00018cu32, stride = 1u32, delta = -1i32 },
sepfoldrange { lo = 0x000192u32, hi = 0x000192u32, stride = 1u32, delta = -1i32 },
sepfoldrange { lo = 0x000199u32, hi = 0x000199u32, stride = 1u32, delta = -1i32 },
sepfoldrange { lo = 0x0001a1u32, hi = 0x0001a5u32, stride = 2u32, delta = -1i32 },
sepfoldrange { lo = 0x0001a8u32, hi = 0x0001a8u32, stride = 1u32, delta = -1i32 },
sepfoldrange { lo = 0x0001adu32, hi = 0x0001adu32, stride = 1u32, delta = -1i32 },
sepfoldrange { lo = 0x0001b0u32, hi = 0x0001b0u32, stride = 1u32, delta = -1i32 },
sepfoldrange { lo = 0x0001b4u32, hi = 0x0001b6u32, stride = 2u32, delta = -1i32 },
sepfoldrange { lo = 0x0001b9u32, hi = 0x0001b9u32, stride = 1u32, delta = -1i32 },
sepfoldrange { lo = 0x0001bdu32, hi = 0x0001bdu32, stride = 1u32, delta = -1i32 },
sepfoldrange { lo = 0x0001c5u32, hi = 0x0001c5u32, stride = 1u32, delta = -1i32 },
sepfoldrange { lo = 0x0001c6u32, hi = 0x0001c6u32, stride = 1u32, delta = -2i32 },
sepfoldrange { lo = 0x0001c8u32, hi = 0x0001c8u32, stride = 1u32, delta = -1i32 },
sepfoldrange { lo = 0x0001c9u32, hi = 0x0001c9u32, stride = 1u32, delta = -2i32 },
sepfoldrange { lo = 0x0001cbu32, hi = 0x0001cbu32, stride = 1u32, delta = -1i32 },
sepfoldrange { lo = 0x0001ccu32, hi = 0x0001ccu32, stride = 1u32, delta = -2i32 },
sepfoldrange { lo = 0x0001ceu32, hi = 0x0001dcu32, stride = 2u32, delta = -1i32 },
sepfoldrange { lo = 0x0001ddu32, hi = 0x0001ddu32, stride = 1u32, delta = -79i32 },
sepfoldrange { lo = 0x0001dfu32, hi = 0x0001efu32, stride = 2u32, delta = -1i32 },
sepfoldrange { lo = 0x0001f2u32, hi = 0x0001f2u32, stride = 1u32, delta = -1i32 },
sepfoldrange { lo = 0x0001f3u32, hi = 0x0001f3u32, stride = 1u32, delta = -2i32 },
sepfoldrange { lo = 0x0001f5u32, hi = 0x0001f5u32, stride = 1u32, delta = -1i32 },
sepfoldrange { lo = 0x0001f6u32, hi = 0x0001f6u32, stride = 1u32, delta = -97i32 },
sepfoldrange { lo = 0x0001f7u32, hi = 0x0001f7u32, stride = 1u32, delta = -56i32 },
sepfoldrange { lo = 0x0001f9u32, hi = 0x00021fu32, stride = 2u32, delta = -1i32 },
sepfoldrange { lo = 0x000220u32, hi = 0x000220u32, stride = 1u32, delta = -130i32 },
sepfoldrange { lo = 0x000223u32, hi = 0x000233u32, stride = 2u32, delta = -1i32 },
sepfoldrange { lo = 0x00023cu32, hi = 0x00023cu32, stride = 1u32, delta = -1i32 },
sepfoldrange { lo = 0x00023du32, hi = 0x00023du32, stride = 1u32, delta = -163i32 },
sepfoldrange { lo = 0x000242u32, hi = 0x000242u32, stride = 1u32, delta = -1i32 },
sepfoldrange { lo = 0x000243u32, hi = 0x000243u32, stride = 1u32, delta = -195i32 },
sepfoldrange { lo = 0x000247u32, hi = 0x00024fu32, stride = 2u32, delta = -1i32 },
sepfoldrange { lo = 0x000253u32, hi = 0x000253u32, stride = 1u32, delta = -210i32 },
sepfoldrange { lo = 0x000254u32, hi = 0x000254u32, stride = 1u32, delta = -206i32 },
sepfoldrange { lo = 0x000256u32, hi = 0x000257u32, stride = 1u32, delta = -205i32 },
sepfoldrange { lo = 0x000259u32, hi = 0x000259u32, stride = 1u32, delta = -202i32 },
sepfoldrange { lo = 0x00025bu32, hi = 0x00025bu32, stride = 1u32, delta = -203i32 },
sepfoldrange { lo = 0x000260u32, hi = 0x000260u32, stride = 1u32, delta = -205i32 },
sepfoldrange { lo = 0x000263u32, hi = 0x000263u32, stride = 1u32, delta = -207i32 },
sepfoldrange { lo = 0x000268u32, hi = 0x000268u32, stride = 1u32, delta = -209i32 },
sepfoldrange { lo = 0x000269u32, hi = 0x000269u32, stride = 1u32, delta = -211i32 },
sepfoldrange { lo = 0x00026fu32, hi = 0x00026fu32, stride = 1u32, delta = -211i32 },
sepfoldrange { lo = 0x000272u32, hi = 0x000272u32, stride = 1u32, delta = -213i32 },
sepfoldrange { lo = 0x000275u32, hi = 0x000275u32, stride = 1u32, delta = -214i32 },
sepfoldrange { lo = 0x000280u32, hi = 0x000280u32, stride = 1u32, delta = -218i32 },
sepfoldrange { lo = 0x000283u32, hi = 0x000283u32, stride = 1u32, delta = -218i32 },
sepfoldrange { lo = 0x000288u32, hi = 0x000288u32, stride = 1u32, delta = -218i32 },
sepfoldrange { lo = 0x000289u32, hi = 0x000289u32, stride = 1u32, delta = -69i32 },
sepfoldrange { lo = 0x00028au32, hi = 0x00028bu32, stride = 1u32, delta = -217i32 },
sepfoldrange { lo = 0x00028cu32, hi = 0x00028cu32, stride = 1u32, delta = -71i32 },
sepfoldrange { lo = 0x000292u32, hi = 0x000292u32, stride = 1u32, delta = -219i32 },
sepfoldrange { lo = 0x000371u32, hi = 0x000373u32, stride = 2u32, delta = -1i32 },
sepfoldrange { lo = 0x000377u32, hi = 0x000377u32, stride = 1u32, delta = -1i32 },
sepfoldrange { lo = 0x000399u32, hi = 0x000399u32, stride = 1u32, delta = -84i32 },
sepfoldrange { lo = 0x00039cu32, hi = 0x00039cu32, stride = 1u32, delta = -743i32 },
sepfoldrange { lo = 0x0003acu32, hi = 0x0003acu32, stride = 1u32, delta = -38i32 },
sepfoldrange { lo = 0x0003adu32, hi = 0x0003afu32, stride = 1u32, delta = -37i32 },
sepfoldrange { lo = 0x0003b1u32, hi = 0x0003b8u32, stride = 1u32, delta = -32i32 },
sepfoldrange { lo = 0x0003b9u32, hi = 0x0003b9u32, stride = 1u32, delta = -116i32 },
sepfoldrange { lo = 0x0003bau32, hi = 0x0003bbu32, stride = 1u32, delta = -32i32 },
sepfoldrange { lo = 0x0003bcu32, hi = 0x0003bcu32, stride = 1u32, delta = -775i32 },
sepfoldrange { lo = 0x0003bdu32, hi = 0x0003c1u32, stride = 1u32, delta = -32i32 },
sepfoldrange { lo = 0x0003c2u32, hi = 0x0003c2u32, stride = 1u32, delta = -31i32 },
sepfoldrange { lo = 0x0003c3u32, hi = 0x0003cbu32, stride = 1u32, delta = -32i32 },
sepfoldrange { lo = 0x0003ccu32, hi = 0x0003ccu32, stride = 1u32, delta = -64i32 },
sepfoldrange { lo = 0x0003cdu32, hi = 0x0003ceu32, stride = 1u32, delta = -63i32 },
sepfoldrange { lo = 0x0003d0u32, hi = 0x0003d0u32, stride = 1u32, delta = -62i32 },
sepfoldrange { lo = 0x0003d1u32, hi = 0x0003d1u32, stride = 1u32, delta = -57i32 },
sepfoldrange { lo = 0x0003d5u32, hi = 0x0003d5u32, stride = 1u32, delta = -47i32 },
sepfoldrange { lo = 0x0003d6u32, hi = 0x0003d6u32, stride = 1u32, delta = -54i32 },
sepfoldrange { lo = 0x0003d7u32, hi = 0x0003d7u32, stride = 1u32, delta = -8i32 },
sepfoldrange { lo = 0x0003d9u32, hi = 0x0003efu32, stride = 2u32, delta = -1i32 },
sepfoldrange { lo = 0x0003f0u32, hi = 0x0003f0u32, stride = 1u32, delta = -86i32 },
sepfoldrange { lo = 0x0003f1u32, hi = 0x0003f1u32, stride = 1u32, delta = -80i32 },
sepfoldrange { lo = 0x0003f3u32, hi = 0x0003f3u32, stride = 1u32, delta = -116i32 },
sepfoldrange { lo = 0x0003f4u32, hi = 0x0003f4u32, stride = 1u32, delta = -92i32 },
sepfoldrange { lo = 0x0003f5u32, hi = 0x0003f5u32, stride = 1u32, delta = -96i32 },
sepfoldrange { lo = 0x0003f8u32, hi = 0x0003f8u32, stride = 1u32, delta = -1i32 },
sepfoldrange { lo = 0x0003f9u32, hi = 0x0003f9u32, stride = 1u32, delta = -7i32 },
sepfoldrange { lo = 0x0003fbu32, hi = 0x0003fbu32, stride = 1u32, delta = -1i32 },
sepfoldrange { lo = 0x0003fdu32, hi = 0x0003ffu32, stride = 1u32, delta = -130i32 },
sepfoldrange { lo = 0x000430u32, hi = 0x00044fu32, stride = 1u32, delta = -32i32 },
sepfoldrange { lo = 0x000450u32, hi = 0x00045fu32, stride = 1u32, delta = -80i32 },
sepfoldrange { lo = 0x000461u32, hi = 0x000481u32, stride = 2u32, delta = -1i32 },
sepfoldrange { lo = 0x00048bu32, hi = 0x0004bfu32, stride = 2u32, delta = -1i32 },
sepfoldrange { lo = 0x0004c2u32, hi = 0x0004ceu32, stride = 2u32, delta = -1i32 },
sepfoldrange { lo = 0x0004cfu32, hi = 0x0004cfu32, stride = 1u32, delta = -15i32 },
sepfoldrange { lo = 0x0004d1u32, hi = 0x00052fu32, stride = 2u32, delta = -1i32 },
sepfoldrange { lo = 0x000561u32, hi = 0x000586u32, stride = 1u32, delta = -48i32 },
sepfoldrange { lo = 0x0013f8u32, hi = 0x0013fdu32, stride = 1u32, delta = -8i32 },
sepfoldrange { lo = 0x001c80u32, hi = 0x001c80u32, stride = 1u32, delta = -6254i32 },
sepfoldrange { lo = 0x001c81u32, hi = 0x001c81u32, stride = 1u32, delta = -6253i32 },
sepfoldrange { lo = 0x001c82u32, hi = 0x001c82u32, stride = 1u32, delta = -6244i32 },
sepfoldrange { lo = 0x001c83u32, hi = 0x001c84u32, stride = 1u32, delta = -6242i32 },
sepfoldrange { lo = 0x001c85u32, hi = 0x001c85u32, stride = 1u32, delta = -6243i32 },
sepfoldrange { lo = 0x001c86u32, hi = 0x001c86u32, stride = 1u32, delta = -6236i32 },
sepfoldrange { lo = 0x001c87u32, hi = 0x001c87u32, stride = 1u32, delta = -6181i32 },
sepfoldrange { lo = 0x001c90u32, hi = 0x001cbau32, stride = 1u32, delta = -3008i32 },
sepfoldrange { lo = 0x001cbdu32, hi = 0x001cbfu32, stride = 1u32, delta = -3008i32 },
sepfoldrange { lo = 0x001e01u32, hi = 0x001e95u32, stride = 2u32, delta = -1i32 },
sepfoldrange { lo = 0x001e9bu32, hi = 0x001e9bu32, stride = 1u32, delta = -59i32 },
sepfoldrange { lo = 0x001e9eu32, hi = 0x001e9eu32, stride = 1u32, delta = -7615i32 },
sepfoldrange { lo = 0x001ea1u32, hi = 0x001effu32, stride = 2u32, delta = -1i32 },
sepfoldrange { lo = 0x001f08u32, hi = 0x001f0fu32, stride = 1u32, delta = -8i32 },
sepfoldrange { lo = 0x001f18u32, hi = 0x001f1du32, stride = 1u32, delta = -8i32 },
sepfoldrange { lo = 0x001f28u32, hi = 0x001f2fu32, stride = 1u32, delta = -8i32 },
sepfoldrange { lo = 0x001f38u32, hi = 0x001f3fu32, stride = 1u32, delta = -8i32 },
sepfoldrange { lo = 0x001f48u32, hi = 0x001f4du32, stride = 1u32, delta = -8i32 },
sepfoldrange { lo = 0x001f59u32, hi = 0x001f5fu32, stride = 2u32, delta = -8i32 },
sepfoldrange { lo = 0x001f68u32, hi = 0x001f6fu32, stride = 1u32, delta = -8i32 },
sepfoldrange { lo = 0x001f88u32, hi = 0x001f8fu32, stride = 1u32, delta = -8i32 },
sepfoldrange { lo = 0x001f98u32, hi = 0x001f9fu32, stride = 1u32, delta = -8i32 },
sepfoldrange { lo = 0x001fa8u32, hi = 0x001fafu32, stride = 1u32, delta = -8i32 },
sepfoldrange { lo = 0x001fb8u32, hi = 0x001fb9u32, stride = 1u32, delta = -8i32 },
sepfoldrange { lo = 0x001fbau32, hi = 0x001fbbu32, stride = 1u32, delta = -74i32 },
sepfoldrange { lo = 0x001fbcu32, hi = 0x001fbcu32, stride = 1u32, delta = -9i32 },
sepfoldrange { lo = 0x001fbeu32, hi = 0x001fbeu32, stride = 1u32, delta = -7289i32 },
sepfoldrange { lo = 0x001fc8u32, hi = 0x001fcbu32, stride = 1u32, delta = -86i32 },
sepfoldrange { lo = 0x001fccu32, hi = 0x001fccu32, stride = 1u32, delta = -9i32 },
sepfoldrange { lo = 0x001fd8u32, hi = 0x001fd9u32, stride = 1u32, delta = -8i32 },
sepfoldrange { lo = 0x001fdau32, hi = 0x001fdbu32, stride = 1u32, delta = -100i32 },
sepfoldrange { lo = 0x001fe8u32, hi = 0x001fe9u32, stride = 1u32, delta = -8i32 },
sepfoldrange { lo = 0x001feau32, hi = 0x001febu32, stride = 1u32, delta = -112i32 },
sepfoldrange { lo = 0x001fecu32, hi = 0x001fecu32, stride = 1u32, delta = -7i32 },
sepfoldrange { lo = 0x001ff8u32, hi = 0x001ff9u32, stride = 1u32, delta = -128i32 },
sepfoldrange { lo = 0x001ffau32, hi = 0x001ffbu32, stride = 1u32, delta = -126i32 },
sepfoldrange { lo = 0x001ffcu32, hi = 0x001ffcu32, stride = 1u32, delta = -9i32 },
sepfoldrange { lo = 0x002126u32, hi = 0x002126u32, stride = 1u32, delta = -7549i32 },
sepfoldrange { lo = 0x00212au32, hi = 0x00212au32, stride = 1u32, delta = -8383i32 },
sepfoldrange { lo = 0x00212bu32, hi = 0x00212bu32, stride = 1u32, delta = -8294i32 },
sepfoldrange { lo = 0x00214eu32, hi = 0x00214eu32, stride = 1u32, delta = -28i32 },
sepfoldrange { lo = 0x002170u32, hi = 0x00217fu32, stride = 1u32, delta = -16i32 },
sepfoldrange { lo = 0x002184u32, hi = 0x002184u32, stride = 1u32, delta = -1i32 },
sepfoldrange { lo = 0x0024d0u32, hi = 0x0024e9u32, stride = 1u32, delta = -26i32 },
sepfoldrange { lo = 0x002c30u32, hi = 0x002c5fu32, stride = 1u32, delta = -48i32 },
sepfoldrange { lo = 0x002c61u32, hi = 0x002c61u32, stride = 1u32, delta = -1i32 },
sepfoldrange { lo = 0x002c62u32, hi = 0x002c62u32, stride = 1u32, delta = -10743i32 },
sepfoldrange { lo = 0x002c63u32, hi = 0x002c63u32, stride = 1u32, delta = -3814i32 },
sepfoldrange { lo = 0x002c64u32, hi = 0x002c64u32, stride = 1u32, delta = -10727i32 },
sepfoldrange { lo = 0x002c65u32, hi = 0x002c65u32, stride = 1u32, delta = -10795i32 },
sepfoldrange { lo = 0x002c66u32, hi = 0x002c66u32, stride = 1u32, delta = -10792i32 },
sepfoldrange { lo = 0x002c68u32, hi = 0x002c6cu32, stride = 2u32, delta = -1i32 },
sepfoldrange { lo = 0x002c6du32, hi = 0x002c6du32, stride = 1u32, delta = -10780i32 },
sepfoldrange { lo = 0x002c6eu32, hi = 0x002c6eu32, stride = 1u32, delta = -10749i32 },
sepfoldrange { lo = 0x002c6fu32, hi = 0x002c6fu32, stride = 1u32, delta = -10783i32 },
sepfoldrange { lo = 0x002c70u32, hi = 0x002c70u32, stride = 1u32, delta = -10782i32 },
sepfoldrange { lo = 0x002c73u32, hi = 0x002c73u32, stride = 1u32, delta = -1i32 },
sepfoldrange { lo = 0x002c76u32, hi = 0x002c76u32, stride = 1u32, delta = -1i32 },
sepfoldrange { lo = 0x002c7eu32, hi = 0x002c7fu32, stride = 1u32, delta = -10815i32 },
sepfoldrange { lo = 0x002c81u32, hi = 0x002ce3u32, stride = 2u32, delta = -1i32 },
sepfoldrange { lo = 0x002cecu32, hi = 0x002ceeu32, stride = 2u32, delta = -1i32 },
sepfoldrange { lo = 0x002cf3u32, hi = 0x002cf3u32, stride = 1u32, delta = -1i32 },
sepfoldrange { lo = 0x002d00u32, hi = 0x002d25u32, stride = 1u32, delta = -7264i32 },
sepfoldrange { lo = 0x002d27u32, hi = 0x002d27u32, stride = 1u32, delta = -7264i32 },
sepfoldrange { lo = 0x002d2du32, hi = 0x002d2du32, stride = 1u32, delta = -7264i32 },
sepfoldrange { lo = 0x00a641u32, hi = 0x00a649u32, stride = 2u32, delta = -1i32 },
sepfoldrange { lo = 0x00a64au32, hi = 0x00a64au32, stride = 1u32, delta = -35266i32 },
sepfoldrange { lo = 0x00a64bu32, hi = 0x00a64bu32, stride = 1u32, delta = -35267i32 },
sepfoldrange { lo = 0x00a64du32, hi = 0x00a66du32, stride = 2u32, delta = -1i32 },
sepfoldrange { lo = 0x00a681u32, hi = 0x00a69bu32, stride = 2u32, delta = -1i32 },
sepfoldrange { lo = 0x00a723u32, hi = 0x00a72fu32, stride = 2u32, delta = -1i32 },
sepfoldrange { lo = 0x00a733u32, hi = 0x00a76fu32, stride = 2u32, delta = -1i32 },
sepfoldrange { lo = 0x00a77au32, hi = 0x00a77cu32, stride = 2u32, delta = -1i32 },
sepfoldrange { lo = 0x00a77du32, hi = 0x00a77du32, stride = 1u32, delta = -35332i32 },
sepfoldrange { lo = 0x00a77fu32, hi = 0x00a787u32, stride = 2u32, delta = -1i32 },
sepfoldrange { lo = 0x00a78cu32, hi = 0x00a78cu32, stride = 1u32, delta = -1i32 },
sepfoldrange { lo = 0x00a78du32, hi = 0x00a78du32, stride = 1u32, delta = -42280i32 },
sepfoldrange { lo = 0x00a791u32, hi = 0x00a793u32, stride = 2u32, delta = -1i32 },
sepfoldrange { lo = 0x00a797u32, hi = 0x00a7a9u32, stride = 2u32, delta = -1i32 },
sepfoldrange { lo = 0x00a7aau32, hi = 0x00a7aau32, stride = 1u32, delta = -42308i32 },
sepfoldrange { lo = 0x00a7abu32, hi = 0x00a7abu32, stride = 1u32, delta = -42319i32 },
sepfoldrange { lo = 0x00a7acu32, hi = 0x00a7acu32, stride = 1u32, delta = -42315i32 },
sepfoldrange { lo = 0x00a7adu32, hi = 0x00a7adu32, stride = 1u32, delta = -42305i32 },
sepfoldrange { lo = 0x00a7aeu32, hi = 0x00a7aeu32, stride = 1u32, delta = -42308i32 },
sepfoldrange { lo = 0x00a7b0u32, hi = 0x00a7b0u32, stride = 1u32, delta = -42258i32 },
sepfoldrange { lo = 0x00a7b1u32, hi = 0x00a7b1u32, stride = 1u32, delta = -42282i32 },
sepfoldrange { lo = 0x00a7b2u32, hi = 0x00a7b2u32, stride = 1u32, delta = -42261i32 },
sepfoldrange { lo = 0x00a7b5u32, hi = 0x00a7c3u32, stride = 2u32, delta = -1i32 },
sepfoldrange { lo = 0x00a7c4u32, hi = 0x00a7c4u32, stride = 1u32, delta = -48i32 },
sepfoldrange { lo = 0x00a7c5u32, hi = 0x00a7c5u32, stride = 1u32, delta = -42307i32 },
sepfoldrange { lo = 0x00a7c6u32, hi = 0x00a7c6u32, stride = 1u32, delta = -35384i32 },
sepfoldrange { lo = 0x00a7c8u32, hi = 0x00a7cau32, stride = 2u32, delta = -1i32 },
sepfoldrange { lo = 0x00a7d1u32, hi = 0x00a7d1u32, stride = 1u32, delta = -1i32 },
sepfoldrange { lo = 0x00a7d7u32, hi = 0x00a7d9u32, stride = 2u32, delta = -1i32 },
sepfoldrange { lo = 0x00a7f6u32, hi = 0x00a7f6u32, stride = 1u32, delta = -1i32 },
sepfoldrange { lo = 0x00ab53u32, hi = 0x00ab53u32, stride = 1u32, delta = -928i32 },
sepfoldrange { lo = 0x00ab70u32, hi = 0x00abbfu32, stride = 1u32, delta = -38864i32 },
sepfoldrange { lo = 0x00ff41u32, hi = 0x00ff5au32, stride = 1u32, delta = -32i32 },
sepfoldrange { lo = 0x010428u32, hi = 0x01044fu32, stride = 1u32, delta = -40i32 },
sepfoldrange { lo = 0x0104d8u32, hi = 0x0104fbu32, stride = 1u32, delta = -40i32 },
sepfoldrange { lo = 0x010597u32, hi = 0x0105a1u32, stride = 1u32, delta = -39i32 },
sepfoldrange { lo = 0x0105a3u32, hi = 0x0105b1u32, stride = 1u32, delta = -39i32 },
sepfoldrange { lo = 0x0105b3u32, hi = 0x0105b9u32, stride = 1u32, delta = -39i32 },
sepfoldrange { lo = 0x0105bbu32, hi = 0x0105bcu32, stride = 1u32, delta = -39i32 },
sepfoldrange { lo = 0x010cc0u32, hi = 0x010cf2u32, stride = 1u32, delta = -64i32 },
sepfoldrange { lo = 0x0118c0u32, hi = 0x0118dfu32, stride = 1u32, delta = -32i32 },
sepfoldrange { lo = 0x016e60u32, hi = 0x016e7fu32, stride = 1u32, delta = -32i32 },
sepfoldrange { lo = 0x01e922u32, hi = 0x01e943u32, stride = 1u32, delta = -34i32 },
];
// Go 1.26.5 strconv.IsPrint tables for byte-stable %q-style diagnostics.
let sepprint16: [424]u16 = [
0x0020u16, 0x007eu16, 0x00a1u16, 0x0377u16, 0x037au16, 0x037fu16, 0x0384u16, 0x0556u16,
0x0559u16, 0x058au16, 0x058du16, 0x05c7u16, 0x05d0u16, 0x05eau16, 0x05efu16, 0x05f4u16,
0x0606u16, 0x070du16, 0x0710u16, 0x074au16, 0x074du16, 0x07b1u16, 0x07c0u16, 0x07fau16,
0x07fdu16, 0x082du16, 0x0830u16, 0x085bu16, 0x085eu16, 0x086au16, 0x0870u16, 0x088eu16,
0x0898u16, 0x098cu16, 0x098fu16, 0x0990u16, 0x0993u16, 0x09b2u16, 0x09b6u16, 0x09b9u16,
0x09bcu16, 0x09c4u16, 0x09c7u16, 0x09c8u16, 0x09cbu16, 0x09ceu16, 0x09d7u16, 0x09d7u16,
0x09dcu16, 0x09e3u16, 0x09e6u16, 0x09feu16, 0x0a01u16, 0x0a0au16, 0x0a0fu16, 0x0a10u16,
0x0a13u16, 0x0a39u16, 0x0a3cu16, 0x0a42u16, 0x0a47u16, 0x0a48u16, 0x0a4bu16, 0x0a4du16,
0x0a51u16, 0x0a51u16, 0x0a59u16, 0x0a5eu16, 0x0a66u16, 0x0a76u16, 0x0a81u16, 0x0ab9u16,
0x0abcu16, 0x0acdu16, 0x0ad0u16, 0x0ad0u16, 0x0ae0u16, 0x0ae3u16, 0x0ae6u16, 0x0af1u16,
0x0af9u16, 0x0b0cu16, 0x0b0fu16, 0x0b10u16, 0x0b13u16, 0x0b39u16, 0x0b3cu16, 0x0b44u16,
0x0b47u16, 0x0b48u16, 0x0b4bu16, 0x0b4du16, 0x0b55u16, 0x0b57u16, 0x0b5cu16, 0x0b63u16,
0x0b66u16, 0x0b77u16, 0x0b82u16, 0x0b8au16, 0x0b8eu16, 0x0b95u16, 0x0b99u16, 0x0b9fu16,
0x0ba3u16, 0x0ba4u16, 0x0ba8u16, 0x0baau16, 0x0baeu16, 0x0bb9u16, 0x0bbeu16, 0x0bc2u16,
0x0bc6u16, 0x0bcdu16, 0x0bd0u16, 0x0bd0u16, 0x0bd7u16, 0x0bd7u16, 0x0be6u16, 0x0bfau16,
0x0c00u16, 0x0c39u16, 0x0c3cu16, 0x0c4du16, 0x0c55u16, 0x0c5au16, 0x0c5du16, 0x0c5du16,
0x0c60u16, 0x0c63u16, 0x0c66u16, 0x0c6fu16, 0x0c77u16, 0x0cb9u16, 0x0cbcu16, 0x0ccdu16,
0x0cd5u16, 0x0cd6u16, 0x0cddu16, 0x0ce3u16, 0x0ce6u16, 0x0cf3u16, 0x0d00u16, 0x0d4fu16,
0x0d54u16, 0x0d63u16, 0x0d66u16, 0x0d96u16, 0x0d9au16, 0x0dbdu16, 0x0dc0u16, 0x0dc6u16,
0x0dcau16, 0x0dcau16, 0x0dcfu16, 0x0ddfu16, 0x0de6u16, 0x0defu16, 0x0df2u16, 0x0df4u16,
0x0e01u16, 0x0e3au16, 0x0e3fu16, 0x0e5bu16, 0x0e81u16, 0x0ebdu16, 0x0ec0u16, 0x0ed9u16,
0x0edcu16, 0x0edfu16, 0x0f00u16, 0x0f6cu16, 0x0f71u16, 0x0fdau16, 0x1000u16, 0x10c7u16,
0x10cdu16, 0x10cdu16, 0x10d0u16, 0x124du16, 0x1250u16, 0x125du16, 0x1260u16, 0x128du16,
0x1290u16, 0x12b5u16, 0x12b8u16, 0x12c5u16, 0x12c8u16, 0x1315u16, 0x1318u16, 0x135au16,
0x135du16, 0x137cu16, 0x1380u16, 0x1399u16, 0x13a0u16, 0x13f5u16, 0x13f8u16, 0x13fdu16,
0x1400u16, 0x169cu16, 0x16a0u16, 0x16f8u16, 0x1700u16, 0x1715u16, 0x171fu16, 0x1736u16,
0x1740u16, 0x1753u16, 0x1760u16, 0x1773u16, 0x1780u16, 0x17ddu16, 0x17e0u16, 0x17e9u16,
0x17f0u16, 0x17f9u16, 0x1800u16, 0x1819u16, 0x1820u16, 0x1878u16, 0x1880u16, 0x18aau16,
0x18b0u16, 0x18f5u16, 0x1900u16, 0x192bu16, 0x1930u16, 0x193bu16, 0x1940u16, 0x1940u16,
0x1944u16, 0x196du16, 0x1970u16, 0x1974u16, 0x1980u16, 0x19abu16, 0x19b0u16, 0x19c9u16,
0x19d0u16, 0x19dau16, 0x19deu16, 0x1a1bu16, 0x1a1eu16, 0x1a7cu16, 0x1a7fu16, 0x1a89u16,
0x1a90u16, 0x1a99u16, 0x1aa0u16, 0x1aadu16, 0x1ab0u16, 0x1aceu16, 0x1b00u16, 0x1b4cu16,
0x1b50u16, 0x1bf3u16, 0x1bfcu16, 0x1c37u16, 0x1c3bu16, 0x1c49u16, 0x1c4du16, 0x1c88u16,
0x1c90u16, 0x1cbau16, 0x1cbdu16, 0x1cc7u16, 0x1cd0u16, 0x1cfau16, 0x1d00u16, 0x1f15u16,
0x1f18u16, 0x1f1du16, 0x1f20u16, 0x1f45u16, 0x1f48u16, 0x1f4du16, 0x1f50u16, 0x1f7du16,
0x1f80u16, 0x1fd3u16, 0x1fd6u16, 0x1fefu16, 0x1ff2u16, 0x1ffeu16, 0x2010u16, 0x2027u16,
0x2030u16, 0x205eu16, 0x2070u16, 0x2071u16, 0x2074u16, 0x209cu16, 0x20a0u16, 0x20c0u16,
0x20d0u16, 0x20f0u16, 0x2100u16, 0x218bu16, 0x2190u16, 0x2426u16, 0x2440u16, 0x244au16,
0x2460u16, 0x2b73u16, 0x2b76u16, 0x2cf3u16, 0x2cf9u16, 0x2d27u16, 0x2d2du16, 0x2d2du16,
0x2d30u16, 0x2d67u16, 0x2d6fu16, 0x2d70u16, 0x2d7fu16, 0x2d96u16, 0x2da0u16, 0x2e5du16,
0x2e80u16, 0x2ef3u16, 0x2f00u16, 0x2fd5u16, 0x2ff0u16, 0x2ffbu16, 0x3001u16, 0x3096u16,
0x3099u16, 0x30ffu16, 0x3105u16, 0x31e3u16, 0x31f0u16, 0xa48cu16, 0xa490u16, 0xa4c6u16,
0xa4d0u16, 0xa62bu16, 0xa640u16, 0xa6f7u16, 0xa700u16, 0xa7cau16, 0xa7d0u16, 0xa7d9u16,
0xa7f2u16, 0xa82cu16, 0xa830u16, 0xa839u16, 0xa840u16, 0xa877u16, 0xa880u16, 0xa8c5u16,
0xa8ceu16, 0xa8d9u16, 0xa8e0u16, 0xa953u16, 0xa95fu16, 0xa97cu16, 0xa980u16, 0xa9d9u16,
0xa9deu16, 0xaa36u16, 0xaa40u16, 0xaa4du16, 0xaa50u16, 0xaa59u16, 0xaa5cu16, 0xaac2u16,
0xaadbu16, 0xaaf6u16, 0xab01u16, 0xab06u16, 0xab09u16, 0xab0eu16, 0xab11u16, 0xab16u16,
0xab20u16, 0xab6bu16, 0xab70u16, 0xabedu16, 0xabf0u16, 0xabf9u16, 0xac00u16, 0xd7a3u16,
0xd7b0u16, 0xd7c6u16, 0xd7cbu16, 0xd7fbu16, 0xf900u16, 0xfa6du16, 0xfa70u16, 0xfad9u16,
0xfb00u16, 0xfb06u16, 0xfb13u16, 0xfb17u16, 0xfb1du16, 0xfbc2u16, 0xfbd3u16, 0xfd8fu16,
0xfd92u16, 0xfdc7u16, 0xfdcfu16, 0xfdcfu16, 0xfdf0u16, 0xfe19u16, 0xfe20u16, 0xfe6bu16,
0xfe70u16, 0xfefcu16, 0xff01u16, 0xffbeu16, 0xffc2u16, 0xffc7u16, 0xffcau16, 0xffcfu16,
0xffd2u16, 0xffd7u16, 0xffdau16, 0xffdcu16, 0xffe0u16, 0xffeeu16, 0xfffcu16, 0xfffdu16,
];
let sepnotprint16: [133]u16 = [
0x00adu16, 0x038bu16, 0x038du16, 0x03a2u16, 0x0530u16, 0x0590u16, 0x061cu16, 0x06ddu16,
0x083fu16, 0x085fu16, 0x08e2u16, 0x0984u16, 0x09a9u16, 0x09b1u16, 0x09deu16, 0x0a04u16,
0x0a29u16, 0x0a31u16, 0x0a34u16, 0x0a37u16, 0x0a3du16, 0x0a5du16, 0x0a84u16, 0x0a8eu16,
0x0a92u16, 0x0aa9u16, 0x0ab1u16, 0x0ab4u16, 0x0ac6u16, 0x0acau16, 0x0b00u16, 0x0b04u16,
0x0b29u16, 0x0b31u16, 0x0b34u16, 0x0b5eu16, 0x0b84u16, 0x0b91u16, 0x0b9bu16, 0x0b9du16,
0x0bc9u16, 0x0c0du16, 0x0c11u16, 0x0c29u16, 0x0c45u16, 0x0c49u16, 0x0c57u16, 0x0c8du16,
0x0c91u16, 0x0ca9u16, 0x0cb4u16, 0x0cc5u16, 0x0cc9u16, 0x0cdfu16, 0x0cf0u16, 0x0d0du16,
0x0d11u16, 0x0d45u16, 0x0d49u16, 0x0d80u16, 0x0d84u16, 0x0db2u16, 0x0dbcu16, 0x0dd5u16,
0x0dd7u16, 0x0e83u16, 0x0e85u16, 0x0e8bu16, 0x0ea4u16, 0x0ea6u16, 0x0ec5u16, 0x0ec7u16,
0x0ecfu16, 0x0f48u16, 0x0f98u16, 0x0fbdu16, 0x0fcdu16, 0x10c6u16, 0x1249u16, 0x1257u16,
0x1259u16, 0x1289u16, 0x12b1u16, 0x12bfu16, 0x12c1u16, 0x12d7u16, 0x1311u16, 0x1680u16,
0x176du16, 0x1771u16, 0x180eu16, 0x191fu16, 0x1a5fu16, 0x1b7fu16, 0x1f58u16, 0x1f5au16,
0x1f5cu16, 0x1f5eu16, 0x1fb5u16, 0x1fc5u16, 0x1fdcu16, 0x1ff5u16, 0x208fu16, 0x2b96u16,
0x2d26u16, 0x2da7u16, 0x2dafu16, 0x2db7u16, 0x2dbfu16, 0x2dc7u16, 0x2dcfu16, 0x2dd7u16,
0x2ddfu16, 0x2e9au16, 0x3040u16, 0x3130u16, 0x318fu16, 0x321fu16, 0xa7d2u16, 0xa7d4u16,
0xa9ceu16, 0xa9ffu16, 0xab27u16, 0xab2fu16, 0xfb37u16, 0xfb3du16, 0xfb3fu16, 0xfb42u16,
0xfb45u16, 0xfe53u16, 0xfe67u16, 0xfe75u16, 0xffe7u16,
];
let sepprint32: [508]u32 = [
0x010000u32, 0x01004du32, 0x010050u32, 0x01005du32, 0x010080u32, 0x0100fau32, 0x010100u32, 0x010102u32,
0x010107u32, 0x010133u32, 0x010137u32, 0x01019cu32, 0x0101a0u32, 0x0101a0u32, 0x0101d0u32, 0x0101fdu32,
0x010280u32, 0x01029cu32, 0x0102a0u32, 0x0102d0u32, 0x0102e0u32, 0x0102fbu32, 0x010300u32, 0x010323u32,
0x01032du32, 0x01034au32, 0x010350u32, 0x01037au32, 0x010380u32, 0x0103c3u32, 0x0103c8u32, 0x0103d5u32,
0x010400u32, 0x01049du32, 0x0104a0u32, 0x0104a9u32, 0x0104b0u32, 0x0104d3u32, 0x0104d8u32, 0x0104fbu32,
0x010500u32, 0x010527u32, 0x010530u32, 0x010563u32, 0x01056fu32, 0x0105bcu32, 0x010600u32, 0x010736u32,
0x010740u32, 0x010755u32, 0x010760u32, 0x010767u32, 0x010780u32, 0x0107bau32, 0x010800u32, 0x010805u32,
0x010808u32, 0x010838u32, 0x01083cu32, 0x01083cu32, 0x01083fu32, 0x01089eu32, 0x0108a7u32, 0x0108afu32,
0x0108e0u32, 0x0108f5u32, 0x0108fbu32, 0x01091bu32, 0x01091fu32, 0x010939u32, 0x01093fu32, 0x01093fu32,
0x010980u32, 0x0109b7u32, 0x0109bcu32, 0x0109cfu32, 0x0109d2u32, 0x010a06u32, 0x010a0cu32, 0x010a35u32,
0x010a38u32, 0x010a3au32, 0x010a3fu32, 0x010a48u32, 0x010a50u32, 0x010a58u32, 0x010a60u32, 0x010a9fu32,
0x010ac0u32, 0x010ae6u32, 0x010aebu32, 0x010af6u32, 0x010b00u32, 0x010b35u32, 0x010b39u32, 0x010b55u32,
0x010b58u32, 0x010b72u32, 0x010b78u32, 0x010b91u32, 0x010b99u32, 0x010b9cu32, 0x010ba9u32, 0x010bafu32,
0x010c00u32, 0x010c48u32, 0x010c80u32, 0x010cb2u32, 0x010cc0u32, 0x010cf2u32, 0x010cfau32, 0x010d27u32,
0x010d30u32, 0x010d39u32, 0x010e60u32, 0x010eadu32, 0x010eb0u32, 0x010eb1u32, 0x010efdu32, 0x010f27u32,
0x010f30u32, 0x010f59u32, 0x010f70u32, 0x010f89u32, 0x010fb0u32, 0x010fcbu32, 0x010fe0u32, 0x010ff6u32,
0x011000u32, 0x01104du32, 0x011052u32, 0x011075u32, 0x01107fu32, 0x0110c2u32, 0x0110d0u32, 0x0110e8u32,
0x0110f0u32, 0x0110f9u32, 0x011100u32, 0x011147u32, 0x011150u32, 0x011176u32, 0x011180u32, 0x0111f4u32,
0x011200u32, 0x011241u32, 0x011280u32, 0x0112a9u32, 0x0112b0u32, 0x0112eau32, 0x0112f0u32, 0x0112f9u32,
0x011300u32, 0x01130cu32, 0x01130fu32, 0x011310u32, 0x011313u32, 0x011344u32, 0x011347u32, 0x011348u32,
0x01134bu32, 0x01134du32, 0x011350u32, 0x011350u32, 0x011357u32, 0x011357u32, 0x01135du32, 0x011363u32,
0x011366u32, 0x01136cu32, 0x011370u32, 0x011374u32, 0x011400u32, 0x011461u32, 0x011480u32, 0x0114c7u32,
0x0114d0u32, 0x0114d9u32, 0x011580u32, 0x0115b5u32, 0x0115b8u32, 0x0115ddu32, 0x011600u32, 0x011644u32,
0x011650u32, 0x011659u32, 0x011660u32, 0x01166cu32, 0x011680u32, 0x0116b9u32, 0x0116c0u32, 0x0116c9u32,
0x011700u32, 0x01171au32, 0x01171du32, 0x01172bu32, 0x011730u32, 0x011746u32, 0x011800u32, 0x01183bu32,
0x0118a0u32, 0x0118f2u32, 0x0118ffu32, 0x011906u32, 0x011909u32, 0x011909u32, 0x01190cu32, 0x011938u32,
0x01193bu32, 0x011946u32, 0x011950u32, 0x011959u32, 0x0119a0u32, 0x0119a7u32, 0x0119aau32, 0x0119d7u32,
0x0119dau32, 0x0119e4u32, 0x011a00u32, 0x011a47u32, 0x011a50u32, 0x011aa2u32, 0x011ab0u32, 0x011af8u32,
0x011b00u32, 0x011b09u32, 0x011c00u32, 0x011c45u32, 0x011c50u32, 0x011c6cu32, 0x011c70u32, 0x011c8fu32,
0x011c92u32, 0x011cb6u32, 0x011d00u32, 0x011d36u32, 0x011d3au32, 0x011d47u32, 0x011d50u32, 0x011d59u32,
0x011d60u32, 0x011d98u32, 0x011da0u32, 0x011da9u32, 0x011ee0u32, 0x011ef8u32, 0x011f00u32, 0x011f3au32,
0x011f3eu32, 0x011f59u32, 0x011fb0u32, 0x011fb0u32, 0x011fc0u32, 0x011ff1u32, 0x011fffu32, 0x012399u32,
0x012400u32, 0x012474u32, 0x012480u32, 0x012543u32, 0x012f90u32, 0x012ff2u32, 0x013000u32, 0x01342fu32,
0x013440u32, 0x013455u32, 0x014400u32, 0x014646u32, 0x016800u32, 0x016a38u32, 0x016a40u32, 0x016a69u32,
0x016a6eu32, 0x016ac9u32, 0x016ad0u32, 0x016aedu32, 0x016af0u32, 0x016af5u32, 0x016b00u32, 0x016b45u32,
0x016b50u32, 0x016b77u32, 0x016b7du32, 0x016b8fu32, 0x016e40u32, 0x016e9au32, 0x016f00u32, 0x016f4au32,
0x016f4fu32, 0x016f87u32, 0x016f8fu32, 0x016f9fu32, 0x016fe0u32, 0x016fe4u32, 0x016ff0u32, 0x016ff1u32,
0x017000u32, 0x0187f7u32, 0x018800u32, 0x018cd5u32, 0x018d00u32, 0x018d08u32, 0x01aff0u32, 0x01b122u32,
0x01b132u32, 0x01b132u32, 0x01b150u32, 0x01b152u32, 0x01b155u32, 0x01b155u32, 0x01b164u32, 0x01b167u32,
0x01b170u32, 0x01b2fbu32, 0x01bc00u32, 0x01bc6au32, 0x01bc70u32, 0x01bc7cu32, 0x01bc80u32, 0x01bc88u32,
0x01bc90u32, 0x01bc99u32, 0x01bc9cu32, 0x01bc9fu32, 0x01cf00u32, 0x01cf2du32, 0x01cf30u32, 0x01cf46u32,
0x01cf50u32, 0x01cfc3u32, 0x01d000u32, 0x01d0f5u32, 0x01d100u32, 0x01d126u32, 0x01d129u32, 0x01d172u32,
0x01d17bu32, 0x01d1eau32, 0x01d200u32, 0x01d245u32, 0x01d2c0u32, 0x01d2d3u32, 0x01d2e0u32, 0x01d2f3u32,
0x01d300u32, 0x01d356u32, 0x01d360u32, 0x01d378u32, 0x01d400u32, 0x01d49fu32, 0x01d4a2u32, 0x01d4a2u32,
0x01d4a5u32, 0x01d4a6u32, 0x01d4a9u32, 0x01d50au32, 0x01d50du32, 0x01d546u32, 0x01d54au32, 0x01d6a5u32,
0x01d6a8u32, 0x01d7cbu32, 0x01d7ceu32, 0x01da8bu32, 0x01da9bu32, 0x01daafu32, 0x01df00u32, 0x01df1eu32,
0x01df25u32, 0x01df2au32, 0x01e000u32, 0x01e018u32, 0x01e01bu32, 0x01e02au32, 0x01e030u32, 0x01e06du32,
0x01e08fu32, 0x01e08fu32, 0x01e100u32, 0x01e12cu32, 0x01e130u32, 0x01e13du32, 0x01e140u32, 0x01e149u32,
0x01e14eu32, 0x01e14fu32, 0x01e290u32, 0x01e2aeu32, 0x01e2c0u32, 0x01e2f9u32, 0x01e2ffu32, 0x01e2ffu32,
0x01e4d0u32, 0x01e4f9u32, 0x01e7e0u32, 0x01e8c4u32, 0x01e8c7u32, 0x01e8d6u32, 0x01e900u32, 0x01e94bu32,
0x01e950u32, 0x01e959u32, 0x01e95eu32, 0x01e95fu32, 0x01ec71u32, 0x01ecb4u32, 0x01ed01u32, 0x01ed3du32,
0x01ee00u32, 0x01ee24u32, 0x01ee27u32, 0x01ee3bu32, 0x01ee42u32, 0x01ee42u32, 0x01ee47u32, 0x01ee54u32,
0x01ee57u32, 0x01ee64u32, 0x01ee67u32, 0x01ee9bu32, 0x01eea1u32, 0x01eebbu32, 0x01eef0u32, 0x01eef1u32,
0x01f000u32, 0x01f02bu32, 0x01f030u32, 0x01f093u32, 0x01f0a0u32, 0x01f0aeu32, 0x01f0b1u32, 0x01f0f5u32,
0x01f100u32, 0x01f1adu32, 0x01f1e6u32, 0x01f202u32, 0x01f210u32, 0x01f23bu32, 0x01f240u32, 0x01f248u32,
0x01f250u32, 0x01f251u32, 0x01f260u32, 0x01f265u32, 0x01f300u32, 0x01f6d7u32, 0x01f6dcu32, 0x01f6ecu32,
0x01f6f0u32, 0x01f6fcu32, 0x01f700u32, 0x01f776u32, 0x01f77bu32, 0x01f7d9u32, 0x01f7e0u32, 0x01f7ebu32,
0x01f7f0u32, 0x01f7f0u32, 0x01f800u32, 0x01f80bu32, 0x01f810u32, 0x01f847u32, 0x01f850u32, 0x01f859u32,
0x01f860u32, 0x01f887u32, 0x01f890u32, 0x01f8adu32, 0x01f8b0u32, 0x01f8b1u32, 0x01f900u32, 0x01fa53u32,
0x01fa60u32, 0x01fa6du32, 0x01fa70u32, 0x01fa7cu32, 0x01fa80u32, 0x01fa88u32, 0x01fa90u32, 0x01fac5u32,
0x01faceu32, 0x01fadbu32, 0x01fae0u32, 0x01fae8u32, 0x01faf0u32, 0x01faf8u32, 0x01fb00u32, 0x01fbcau32,
0x01fbf0u32, 0x01fbf9u32, 0x020000u32, 0x02a6dfu32, 0x02a700u32, 0x02b739u32, 0x02b740u32, 0x02b81du32,
0x02b820u32, 0x02cea1u32, 0x02ceb0u32, 0x02ebe0u32, 0x02f800u32, 0x02fa1du32, 0x030000u32, 0x03134au32,
0x031350u32, 0x0323afu32, 0x0e0100u32, 0x0e01efu32,
];
let sepnotprint32: [112]u16 = [
0x000cu16, 0x0027u16, 0x003bu16, 0x003eu16, 0x018fu16, 0x039eu16, 0x057bu16,
0x058bu16, 0x0593u16, 0x0596u16, 0x05a2u16, 0x05b2u16, 0x05bau16, 0x0786u16, 0x07b1u16,
0x0809u16, 0x0836u16, 0x0856u16, 0x08f3u16, 0x0a04u16, 0x0a14u16, 0x0a18u16, 0x0e7fu16,
0x0eaau16, 0x10bdu16, 0x1135u16, 0x11e0u16, 0x1212u16, 0x1287u16, 0x1289u16, 0x128eu16,
0x129eu16, 0x1304u16, 0x1329u16, 0x1331u16, 0x1334u16, 0x133au16, 0x145cu16, 0x1914u16,
0x1917u16, 0x1936u16, 0x1c09u16, 0x1c37u16, 0x1ca8u16, 0x1d07u16, 0x1d0au16, 0x1d3bu16,
0x1d3eu16, 0x1d66u16, 0x1d69u16, 0x1d8fu16, 0x1d92u16, 0x1f11u16, 0x246fu16, 0x6a5fu16,
0x6abfu16, 0x6b5au16, 0x6b62u16, 0xaff4u16, 0xaffcu16, 0xafffu16, 0xd455u16, 0xd49du16,
0xd4adu16, 0xd4bau16, 0xd4bcu16, 0xd4c4u16, 0xd506u16, 0xd515u16, 0xd51du16, 0xd53au16,
0xd53fu16, 0xd545u16, 0xd551u16, 0xdaa0u16, 0xe007u16, 0xe022u16, 0xe025u16, 0xe7e7u16,
0xe7ecu16, 0xe7efu16, 0xe7ffu16, 0xee04u16, 0xee20u16, 0xee23u16, 0xee28u16, 0xee33u16,
0xee38u16, 0xee3au16, 0xee48u16, 0xee4au16, 0xee4cu16, 0xee50u16, 0xee53u16, 0xee58u16,
0xee5au16, 0xee5cu16, 0xee5eu16, 0xee60u16, 0xee63u16, 0xee6bu16, 0xee73u16, 0xee78u16,
0xee7du16, 0xee7fu16, 0xee8au16, 0xeea4u16, 0xeeaau16, 0xf0c0u16, 0xf0d0u16, 0xfabeu16,
0xfb93u16,
];
type sepfoldentry = struct {
scope: *u8, // canonical directory; nil for package identities
key: *u8, // request-only Go simple-fold key
exact: *u8, // exact canonical identity or selected basename
};
type seppkg = struct {
path: *u8, // compiler/import identity derived from importbase
importbase: *u8, // canonical ordinary directory import identity
@@ -1103,6 +1493,10 @@ type sepgraph = struct {
ncontext: i32,
supportcontext: i32,
identityfailed: bool,
packagefolds: []sepfoldentry,
npackagefolds: i32,
filefolds: []sepfoldentry,
nfilefolds: i32,
};
type sepproduct = struct {
@@ -1187,6 +1581,11 @@ fn sepallocchildren(cap: i32) ([]sepchild | nomem) = {
return value;
};
fn sepallocfoldentries(cap: i32) ([]sepfoldentry | nomem) = {
let value: []sepfoldentry = alloc([], cap: u64)?;
return value;
};
fn sepdupstr(s: str) (str | nomem) = {
let out: str;
out.ptr = nil;
@@ -1229,6 +1628,7 @@ fn sepallocptrs(cap: i32) ([]*u8 | nomem) = {
};
fn sepallocgraph(pkg: []seppkg, context: []sepcontext) (*sepgraph | nomem) = {
let emptyfolds: []sepfoldentry;
let value: *sepgraph = alloc(sepgraph{
pkg = pkg,
n = 0,
@@ -1236,6 +1636,10 @@ fn sepallocgraph(pkg: []seppkg, context: []sepcontext) (*sepgraph | nomem) = {
ncontext = 0,
supportcontext = -1,
identityfailed = false,
packagefolds = emptyfolds,
npackagefolds = 0,
filefolds = emptyfolds,
nfilefolds = 0,
})?;
return value;
};
@@ -1295,6 +1699,28 @@ fn sepreservepackages(g: *sepgraph, need: i32) bool = {
return true;
};
fn sepreservefoldentries(entries: *[]sepfoldentry, used: i32,
need: i32) bool = {
if (need <= entries.len) { return true; };
let cap: i32 = sepgrowcap(entries.len, need);
if (cap < 0) { return false; };
let allocation: ([]sepfoldentry | nomem) = sepallocfoldentries(cap);
let next: []sepfoldentry;
match (allocation) {
case let value: []sepfoldentry => next = value;
case nomem => { sepfailnomem(); return false; };
};
next.len = cap;
let i: i32 = 0;
for (i < used) { next[i] = (*entries)[i]; i += 1; };
if (entries.ptr != nil) {
os.free(entries.ptr: *void,
(entries.cap: u64) * (size(sepfoldentry): u64));
};
*entries = next;
return true;
};
fn sepreservecontexts(g: *sepgraph, need: i32) bool = {
if (need <= g.context.len) { return true; };
let cap: i32 = sepgrowcap(g.context.len, need);
@@ -1571,6 +1997,369 @@ fn sepdupcstr(src: *u8, n: u64) *u8 = {
return out.ptr;
};
// Decode filesystem-name bytes exactly like Go's UTF-8 range operation.
// Each malformed byte is one U+FFFD rune, while diagnostics retain the
// original byte spelling and quote malformed bytes as \xNN.
fn seputf8width(value: *u8, len: u64, index: u64) i32 = {
let c: u8 = value[index];
if (c < 128u8) { return 1; };
if (c >= 194u8 && c <= 223u8 && index + 1u64 < len
&& value[index + 1u64] >= 128u8
&& value[index + 1u64] <= 191u8) {
return 2;
};
if (index + 2u64 < len && value[index + 2u64] >= 128u8
&& value[index + 2u64] <= 191u8) {
let c1: u8 = value[index + 1u64];
if ((c == 224u8 && c1 >= 160u8 && c1 <= 191u8)
|| (c >= 225u8 && c <= 236u8
&& c1 >= 128u8 && c1 <= 191u8)
|| (c == 237u8 && c1 >= 128u8 && c1 <= 159u8)
|| (c >= 238u8 && c <= 239u8
&& c1 >= 128u8 && c1 <= 191u8)) {
return 3;
};
};
if (index + 3u64 < len && value[index + 2u64] >= 128u8
&& value[index + 2u64] <= 191u8
&& value[index + 3u64] >= 128u8
&& value[index + 3u64] <= 191u8) {
let c1: u8 = value[index + 1u64];
if ((c == 240u8 && c1 >= 144u8 && c1 <= 191u8)
|| (c >= 241u8 && c <= 243u8
&& c1 >= 128u8 && c1 <= 191u8)
|| (c == 244u8 && c1 >= 128u8 && c1 <= 143u8)) {
return 4;
};
};
return 1;
};
fn seputf8rune(value: *u8, index: u64, width: i32) u32 = {
let c0: u32 = value[index]: u32;
if (width == 1) {
if (c0 >= 128u32) { return 0xfffdu32; };
return c0;
};
let c1: u32 = value[index + 1u64]: u32;
if (width == 2) {
return ((c0 & 31u32) << 6u32) | (c1 & 63u32);
};
let c2: u32 = value[index + 2u64]: u32;
if (width == 3) {
return ((c0 & 15u32) << 12u32)
| ((c1 & 63u32) << 6u32) | (c2 & 63u32);
};
let c3: u32 = value[index + 3u64]: u32;
return ((c0 & 7u32) << 18u32) | ((c1 & 63u32) << 12u32)
| ((c2 & 63u32) << 6u32) | (c3 & 63u32);
};
fn sepfoldrune(r: u32) u32 = {
let low: i32 = 0;
let high: i32 = sepfoldranges.len;
for (low < high) {
let middle: i32 = low + (high - low) / 2;
if (sepfoldranges[middle].lo <= r) { low = middle + 1; }
else { high = middle; };
};
if (low > 0) {
let range: *sepfoldrange = &sepfoldranges[low - 1];
if (r <= range.hi && (r - range.lo) % range.stride == 0u32) {
if (range.delta < 0) { return r - ((-range.delta): u32); };
return r + (range.delta: u32);
};
};
return r;
};
fn seputf8encodedwidth(r: u32) i32 = {
if (r <= 0x7fu32) { return 1; };
if (r <= 0x7ffu32) { return 2; };
if (r <= 0xffffu32) { return 3; };
return 4;
};
fn seputf8encode(out: *u8, offset: u64, r: u32) u64 = {
if (r <= 0x7fu32) {
out[offset] = r: u8;
offset += 1u64;
} else { if (r <= 0x7ffu32) {
out[offset] = (0xc0u32 | (r >> 6u32)): u8;
out[offset + 1u64] = (0x80u32 | (r & 0x3fu32)): u8;
offset += 2u64;
} else { if (r <= 0xffffu32) {
out[offset] = (0xe0u32 | (r >> 12u32)): u8;
out[offset + 1u64] = (0x80u32 | ((r >> 6u32) & 0x3fu32)): u8;
out[offset + 2u64] = (0x80u32 | (r & 0x3fu32)): u8;
offset += 3u64;
} else {
out[offset] = (0xf0u32 | (r >> 18u32)): u8;
out[offset + 1u64] = (0x80u32 | ((r >> 12u32) & 0x3fu32)): u8;
out[offset + 2u64] = (0x80u32 | ((r >> 6u32) & 0x3fu32)): u8;
out[offset + 3u64] = (0x80u32 | (r & 0x3fu32)): u8;
offset += 4u64;
}; }; };
return offset;
};
fn septofold(value: *u8) *u8 = {
let len: u64 = cstrlen(value);
let total: u64 = 0u64;
let i: u64 = 0u64;
for (i < len) {
let width: i32 = seputf8width(value, len, i);
let r: u32 = sepfoldrune(seputf8rune(value, i, width));
if (!sepaddbytes(&total, seputf8encodedwidth(r): u64)) {
return nil;
};
i += width: u64;
};
if (!sepaddbytes(&total, 1u64)) { return nil; };
let bytes: []u8;
if (!sepmakebytes(total, &bytes)) { return nil; };
let offset: u64 = 0u64;
i = 0u64;
for (i < len) {
let width: i32 = seputf8width(value, len, i);
let r: u32 = sepfoldrune(seputf8rune(value, i, width));
offset = seputf8encode(bytes.ptr, offset, r);
i += width: u64;
};
bytes[offset] = 0u8;
return bytes.ptr;
};
fn sepbsearch16(values: []u16, target: u16) i32 = {
let low: i32 = 0;
let high: i32 = values.len;
for (low < high) {
let middle: i32 = low + (high - low) / 2;
if (values[middle] < target) { low = middle + 1; }
else { high = middle; };
};
return low;
};
fn sepbsearch32(values: []u32, target: u32) i32 = {
let low: i32 = 0;
let high: i32 = values.len;
for (low < high) {
let middle: i32 = low + (high - low) / 2;
if (values[middle] < target) { low = middle + 1; }
else { high = middle; };
};
return low;
};
fn sepisprint(r: u32) bool = {
if (r <= 0xffu32) {
if (r >= 0x20u32 && r <= 0x7eu32) { return true; };
if (r >= 0xa1u32 && r <= 0xffu32) { return r != 0xadu32; };
return false;
};
if (r < 0x10000u32) {
let rr: u16 = r: u16;
let i: i32 = sepbsearch16(sepprint16, rr);
if (i >= sepprint16.len) { return false; };
let start: i32 = i;
if (start % 2 != 0) { start -= 1; };
if (start + 1 >= sepprint16.len || rr < sepprint16[start]
|| sepprint16[start + 1] < rr) { return false; };
let excluded: i32 = sepbsearch16(sepnotprint16, rr);
return excluded >= sepnotprint16.len
|| sepnotprint16[excluded] != rr;
};
let i: i32 = sepbsearch32(sepprint32, r);
if (i >= sepprint32.len) { return false; };
let start: i32 = i;
if (start % 2 != 0) { start -= 1; };
if (start + 1 >= sepprint32.len || r < sepprint32[start]
|| sepprint32[start + 1] < r) { return false; };
if (r >= 0x20000u32) { return true; };
let rr: u16 = (r - 0x10000u32): u16;
let excluded: i32 = sepbsearch16(sepnotprint32, rr);
return excluded >= sepnotprint32.len || sepnotprint32[excluded] != rr;
};
fn sepputhexbyte(value: u8) void = {
let digits: str = "0123456789abcdef";
let encoded: [2]u8;
let high: i32 = (value / 16u8): i32;
let low: i32 = (value % 16u8): i32;
encoded[0] = digits[high];
encoded[1] = digits[low];
os.write(2, &encoded[0], 2u64);
};
fn sepputhexrune(value: u32, digits: i32) void = {
let alphabet: str = "0123456789abcdef";
let encoded: [8]u8;
let i: i32 = digits - 1;
for (i >= 0) {
let shift: u32 = (i: u32) * 4u32;
let digit: i32 = ((value >> shift) & 15u32): i32;
encoded[digits - 1 - i] = alphabet[digit];
i -= 1;
};
os.write(2, &encoded[0], digits: u64);
};
fn sepputquoted(value: *u8) void = {
cerr("\"");
let len: u64 = cstrlen(value);
let i: u64 = 0u64;
for (i < len) {
let c: u8 = value[i];
let width: i32 = seputf8width(value, len, i);
if (c >= 128u8 && width == 1) {
cerr("\\x"); sepputhexbyte(c); i += 1u64; continue;
};
if (width > 1) {
let r: u32 = seputf8rune(value, i, width);
if (sepisprint(r)) {
os.write(2, value + i, width: u64);
} else { if (r < 0x10000u32) {
cerr("\\u"); sepputhexrune(r, 4);
} else {
cerr("\\U"); sepputhexrune(r, 8);
}; };
i += width: u64;
continue;
};
if (c == '"') { cerr("\\\""); }
else { if (c == '\\') { cerr("\\\\"); }
else { if (c == 7u8) { cerr("\\a"); }
else { if (c == 8u8) { cerr("\\b"); }
else { if (c == 12u8) { cerr("\\f"); }
else { if (c == '\n') { cerr("\\n"); }
else { if (c == '\r') { cerr("\\r"); }
else { if (c == '\t') { cerr("\\t"); }
else { if (c == 11u8) { cerr("\\v"); }
else { if (c < 32u8 || c == 127u8) {
cerr("\\x"); sepputhexbyte(c);
} else { os.write(2, value + i, 1u64); };
};};};};};};};};};
i += 1u64;
};
cerr("\"");
};
fn sepdiagfoldcollision(kind: str, a: *u8, b: *u8) void = {
let first: *u8 = a;
let second: *u8 = b;
if (strings.compare(pathstr(first), pathstr(second)) > 0) {
first = b; second = a;
};
cerr("ww: case-insensitive "); cerr(kind); cerr(" collision: ");
sepputquoted(first); cerr(" and "); sepputquoted(second); cerr("\n");
};
fn sepregisterpackagefold(g: *sepgraph, exact: *u8) bool = {
let key: *u8 = septofold(exact);
if (key == nil) { return false; };
let low: i32 = 0;
let high: i32 = g.npackagefolds;
for (low < high) {
let middle: i32 = low + (high - low) / 2;
let cmp: i32 = strings.compare(pathstr(g.packagefolds[middle].key),
pathstr(key)): i32;
if (cmp < 0) { low = middle + 1; } else { high = middle; };
};
if (low < g.npackagefolds
&& cstreq(g.packagefolds[low].key, key)) {
os.free(key: *void, cstrlen(key) + 1u64);
if (cstreq(g.packagefolds[low].exact, exact)) { return true; };
g.identityfailed = true;
sepdiagfoldcollision("import", g.packagefolds[low].exact, exact);
return false;
};
let spelling: *u8 = sepdupcstr(exact, cstrlen(exact));
if (spelling == nil) {
os.free(key: *void, cstrlen(key) + 1u64);
return false;
};
if (g.npackagefolds == SEP_COUNT_MAX
|| !sepreservefoldentries(&g.packagefolds, g.npackagefolds,
g.npackagefolds + 1)) {
if (g.npackagefolds == SEP_COUNT_MAX) { sepfailsize(); };
os.free(key: *void, cstrlen(key) + 1u64);
os.free(spelling: *void, cstrlen(spelling) + 1u64);
return false;
};
let i: i32 = g.npackagefolds;
for (i > low) {
g.packagefolds[i] = g.packagefolds[i - 1];
i -= 1;
};
g.packagefolds[low].scope = nil;
g.packagefolds[low].key = key;
g.packagefolds[low].exact = spelling;
g.npackagefolds += 1;
return true;
};
fn sepfilefoldcmp(entry: *sepfoldentry, scope: *u8, key: *u8) i32 = {
let cmp: i32 = strings.compare(pathstr(entry.scope), pathstr(scope)): i32;
if (cmp != 0) { return cmp; };
return strings.compare(pathstr(entry.key), pathstr(key)): i32;
};
fn sepregisterfilefold(g: *sepgraph, scope: *u8, source: *u8) bool = {
let total: u64 = cstrlen(source);
let base: u64 = total;
for (base > 0u64 && source[base - 1u64] != '/': u8) { base -= 1u64; };
let exact: *u8 = source + base;
let key: *u8 = septofold(exact);
if (key == nil) { return false; };
let low: i32 = 0;
let high: i32 = g.nfilefolds;
for (low < high) {
let middle: i32 = low + (high - low) / 2;
let cmp: i32 = sepfilefoldcmp(&g.filefolds[middle], scope, key);
if (cmp < 0) { low = middle + 1; } else { high = middle; };
};
if (low < g.nfilefolds
&& sepfilefoldcmp(&g.filefolds[low], scope, key) == 0) {
os.free(key: *void, cstrlen(key) + 1u64);
if (cstreq(g.filefolds[low].exact, exact)) { return true; };
g.identityfailed = true;
sepdiagfoldcollision("file name", g.filefolds[low].exact, exact);
return false;
};
let ownedscope: *u8 = sepdupcstr(scope, cstrlen(scope));
let spelling: *u8 = sepdupcstr(exact, cstrlen(exact));
if (ownedscope == nil || spelling == nil) {
os.free(key: *void, cstrlen(key) + 1u64);
if (ownedscope != nil) {
os.free(ownedscope: *void, cstrlen(ownedscope) + 1u64);
};
if (spelling != nil) {
os.free(spelling: *void, cstrlen(spelling) + 1u64);
};
return false;
};
if (g.nfilefolds == SEP_COUNT_MAX
|| !sepreservefoldentries(&g.filefolds, g.nfilefolds,
g.nfilefolds + 1)) {
if (g.nfilefolds == SEP_COUNT_MAX) { sepfailsize(); };
os.free(key: *void, cstrlen(key) + 1u64);
os.free(ownedscope: *void, cstrlen(ownedscope) + 1u64);
os.free(spelling: *void, cstrlen(spelling) + 1u64);
return false;
};
let i: i32 = g.nfilefolds;
for (i > low) {
g.filefolds[i] = g.filefolds[i - 1];
i -= 1;
};
g.filefolds[low].scope = ownedscope;
g.filefolds[low].key = key;
g.filefolds[low].exact = spelling;
g.nfilefolds += 1;
return true;
};
fn sepappendlit(stem: *u8, suffix: str) *u8 = {
let need: u64 = 0u64;
if (!sepaddbytes(&need, cstrlen(stem))
@@ -1974,10 +2763,14 @@ fn sepbindimportbase(g: *sepgraph, pi: i32, base: *u8) i32 = {
let p: *seppkg = &g.pkg[pi];
if (p.importbase != nil) {
if (cstreq(p.importbase, base)) { return 0; };
if (p.role != SEP_ROLE_TEST_SUPPORT
&& !sepregisterpackagefold(g, base)) { return -1; };
g.identityfailed = true;
sepdiagdiridentities(p.entry, p.importbase, base);
return -1;
};
if (p.role != SEP_ROLE_TEST_SUPPORT
&& !sepregisterpackagefold(g, base)) { return -1; };
let candidate: *u8 = sepvariantpath(p.variant, base);
if (candidate == nil) { return -1; };
let i: i32 = 0;
@@ -2042,6 +2835,13 @@ fn sepfindoraddvariant(g: *sepgraph, path: *u8, entry: *u8,
cerr(pathstr(entry)); cerr("\n");
return -1;
};
if (isdir != 0 && path[0u64] != 0u8
&& role != SEP_ROLE_TEST_SUPPORT
&& (reservedimportpath(path) || sepimportbasevalid(path))
&& !sepregisterpackagefold(g, path)) {
os.free(canon: *void, cstrlen(canon) + 1u64);
return -1;
};
let incoming: *u8 = nil;
if (isdir != 0 && path[0u64] != 0u8) {
incoming = sepvariantpath(variant, path);
@@ -2291,6 +3091,36 @@ fn sepgraphfree(g: *sepgraph) void = {
(g.pkg.cap: u64) * (size(seppkg): u64));
};
i = 0;
for (i < g.npackagefolds) {
if (g.packagefolds[i].scope != nil) {
os.free(g.packagefolds[i].scope: *void,
cstrlen(g.packagefolds[i].scope) + 1u64);
};
os.free(g.packagefolds[i].key: *void,
cstrlen(g.packagefolds[i].key) + 1u64);
os.free(g.packagefolds[i].exact: *void,
cstrlen(g.packagefolds[i].exact) + 1u64);
i += 1;
};
if (g.packagefolds.ptr != nil) {
os.free(g.packagefolds.ptr: *void,
(g.packagefolds.cap: u64) * (size(sepfoldentry): u64));
};
i = 0;
for (i < g.nfilefolds) {
os.free(g.filefolds[i].scope: *void,
cstrlen(g.filefolds[i].scope) + 1u64);
os.free(g.filefolds[i].key: *void,
cstrlen(g.filefolds[i].key) + 1u64);
os.free(g.filefolds[i].exact: *void,
cstrlen(g.filefolds[i].exact) + 1u64);
i += 1;
};
if (g.filefolds.ptr != nil) {
os.free(g.filefolds.ptr: *void,
(g.filefolds.cap: u64) * (size(sepfoldentry): u64));
};
i = 0;
for (i < g.ncontext) {
if (g.context[i].root != nil) {
os.free(g.context[i].root: *void,
@@ -3840,6 +4670,12 @@ fn seppreparepkgcontext(g: *sepgraph, pi: i32, context: i32,
cerr(": directory contains no WW package sources\n");
rc = -1;
}; }; };
let i: i32 = 0;
for (i < g.pkg[pi].nsources && rc == 0) {
if (!sepregisterfilefold(g, g.pkg[pi].canon,
g.pkg[pi].sources[i])) { rc = -1; };
i += 1;
};
};
};
if (g.pkg[pi].isdir != 0) {
@@ -6517,6 +7353,7 @@ fn buildonesepimpl(selfdir: *u8, src: *u8, entryisdir: i32,
};
producti += 1;
};
if (g.identityfailed) { return 1; };
if (haverunnabletests) {
producti = 0;
for (producti < nproducts) {