w6c+wcc+selfhost+lib: int-cast truncate + use_alias, 5 new modules
Two cgen/check bugs surfaced by new lib modules, plus the modules
themselves (crc64, siphash, random, base64, base32).
1. `(big_u64): u32` (and `: u16`, `: u8`, `: bool`) didn't truncate.
N_CAST emitted nothing for int↔int; the value stayed in AX with
its upper bits intact and downstream CMPQ/DIVQ misread the slot.
The TK_TILDE path already had clamp logic for the same reason —
N_CAST was the missing case. Both stages now MOVL r,r for u32 and
ANDQ $mask for u8/u16/bool. Signed-narrow (i8/i16/i32) stays
no-op until w6a grows reg-reg MOVSBQ/MOVSWQ/MOVSXD. selfhost
cgcast walks alias chains via aliaslookup before checking
primsize/typenameisunsigned so `(u: random)` where
`type random = u64` still bypasses the clamp.
See cmd/w6c/cgen.c N_CAST and selfhost/cmd/wcc/cgenexpr.ww cgcast.
2. `mod.mod` type refs (`random.random` when the imported module
declares `export type random = u64;`) failed with "unknown type".
The driver concatenates imports into one flat scope, so SK_USE
`random` collided with SK_TYPE `random` and scope_define silently
dropped the use. resolve_typename's leaf lookup required
`kind == SK_USE` and gave up. Adds a `use_alias` flag to Sym; the
pass-1 decl scan now marks colliding syms in both directions
(use-after-type and type-after-use). resolve_typename and the
N_DOT cexpr branch treat `use_alias` like SK_USE for qualified
lookup. selfhost check.ww was already lenient on this path so no
ww-side change was needed; bootstrap fixed point (990-995) holds.
See cmd/wcc/check.c installdecl pass + N_DOT/resolve_typename and
cmd/wcc/ww.h Sym.use_alias.
New modules under lib/, each with @test vectors in *_test.ww and wired
into test/wcc/900_stdlib.c (26 modules → all compile):
- lib/hash/crc64 ECMA, ISO (mirror of crc32 shape)
- lib/hash/siphash SipHash-2-4, buffer-based sum/sum24
- lib/math/random SplitMix64 (init, next, u32n, u64n)
- lib/encoding/base64 RFC 4648 std + url-safe encode/decode + sizes
- lib/encoding/base32 RFC 4648 std + base32hex encode/decode + sizes
This commit is contained in:
155
lib/encoding/base32/base32_test.ww
Normal file
155
lib/encoding/base32/base32_test.ww
Normal file
@@ -0,0 +1,155 @@
|
||||
use base32;
|
||||
|
||||
fn putstr(s: str, into: []u8, off: i32) i32 = {
|
||||
let i: i32 = 0;
|
||||
for (i < s.len) {
|
||||
into[off + i] = s[i];
|
||||
i += 1;
|
||||
};
|
||||
return off + s.len;
|
||||
};
|
||||
|
||||
fn streq(buf: []u8, expect: str) bool = {
|
||||
if (buf.len != expect.len) { return false; };
|
||||
let i: i32 = 0;
|
||||
for (i < buf.len) {
|
||||
if (buf[i] != expect[i]) { return false; };
|
||||
i += 1;
|
||||
};
|
||||
return true;
|
||||
};
|
||||
|
||||
fn encvec(input: str, expect: str) void = {
|
||||
let inbuf: [128]u8;
|
||||
let outbuf: [128]u8;
|
||||
let n: i32 = putstr(input, inbuf[0:128], 0);
|
||||
let m: i32 = base32.encode(outbuf[0:128], inbuf[0:n]);
|
||||
if (m != expect.len) { let _: i32 = 1/0; };
|
||||
if (!streq(outbuf[0:m], expect)) { let _: i32 = 1/0; };
|
||||
};
|
||||
|
||||
@test fn rfc4648_std() void = {
|
||||
// RFC 4648 §10 test vectors.
|
||||
encvec("", "");
|
||||
encvec("f", "MY======");
|
||||
encvec("fo", "MZXQ====");
|
||||
encvec("foo", "MZXW6===");
|
||||
encvec("foob", "MZXW6YQ=");
|
||||
encvec("fooba", "MZXW6YTB");
|
||||
encvec("foobar", "MZXW6YTBOI======");
|
||||
};
|
||||
|
||||
fn decvec(input: str, expect: str) void = {
|
||||
let inbuf: [128]u8;
|
||||
let outbuf: [128]u8;
|
||||
let n: i32 = putstr(input, inbuf[0:128], 0);
|
||||
let r: (i32 | base32.invalid) = base32.decode(outbuf[0:128], inbuf[0:n]);
|
||||
match (r) {
|
||||
case let m: i32 => {
|
||||
if (m != expect.len) { let _: i32 = 1/0; };
|
||||
if (!streq(outbuf[0:m], expect)) { let _: i32 = 1/0; };
|
||||
};
|
||||
case let e: base32.invalid => { let _: i32 = 1/0; };
|
||||
};
|
||||
};
|
||||
|
||||
@test fn rfc4648_decode() void = {
|
||||
decvec("", "");
|
||||
decvec("MY======", "f");
|
||||
decvec("MZXQ====", "fo");
|
||||
decvec("MZXW6===", "foo");
|
||||
decvec("MZXW6YQ=", "foob");
|
||||
decvec("MZXW6YTB", "fooba");
|
||||
decvec("MZXW6YTBOI======", "foobar");
|
||||
};
|
||||
|
||||
fn enchexvec(input: str, expect: str) void = {
|
||||
let inbuf: [128]u8;
|
||||
let outbuf: [128]u8;
|
||||
let n: i32 = putstr(input, inbuf[0:128], 0);
|
||||
let m: i32 = base32.encodehex(outbuf[0:128], inbuf[0:n]);
|
||||
if (m != expect.len) { let _: i32 = 1/0; };
|
||||
if (!streq(outbuf[0:m], expect)) { let _: i32 = 1/0; };
|
||||
};
|
||||
|
||||
@test fn rfc4648_hex() void = {
|
||||
// RFC 4648 §10 base32hex vectors.
|
||||
enchexvec("", "");
|
||||
enchexvec("f", "CO======");
|
||||
enchexvec("fo", "CPNG====");
|
||||
enchexvec("foo", "CPNMU===");
|
||||
enchexvec("foob", "CPNMUOG=");
|
||||
enchexvec("fooba", "CPNMUOJ1");
|
||||
enchexvec("foobar", "CPNMUOJ1E8======");
|
||||
};
|
||||
|
||||
@test fn roundtrip_all_quintets() void = {
|
||||
// Encode then decode every 5-byte combination of a small set.
|
||||
let raw: [5]u8;
|
||||
raw[0] = 0x00u8;
|
||||
raw[1] = 0x55u8;
|
||||
raw[2] = 0xAAu8;
|
||||
raw[3] = 0xFFu8;
|
||||
raw[4] = 0x01u8;
|
||||
let enc: [16]u8;
|
||||
let dec: [5]u8;
|
||||
let m: i32 = base32.encode(enc[0:16], raw[0:5]);
|
||||
if (m != 8) { let _: i32 = 1/0; };
|
||||
let r: (i32 | base32.invalid) = base32.decode(dec[0:5], enc[0:m]);
|
||||
match (r) {
|
||||
case let n: i32 => {
|
||||
if (n != 5) { let _: i32 = 1/0; };
|
||||
let i: i32 = 0;
|
||||
for (i < 5) {
|
||||
if (dec[i] != raw[i]) { let _: i32 = 1/0; };
|
||||
i += 1;
|
||||
};
|
||||
};
|
||||
case let e: base32.invalid => { let _: i32 = 1/0; };
|
||||
};
|
||||
};
|
||||
|
||||
@test fn invalid_inputs() void = {
|
||||
let inbuf: [16]u8;
|
||||
let outbuf: [16]u8;
|
||||
// Length not a multiple of 8.
|
||||
let n: i32 = putstr("ABCD", inbuf[0:16], 0);
|
||||
let r1: (i32 | base32.invalid) = base32.decode(outbuf[0:16], inbuf[0:n]);
|
||||
match (r1) {
|
||||
case let m: i32 => { let _: i32 = 1/0; };
|
||||
case let e: base32.invalid => void;
|
||||
};
|
||||
// Bad pad count (5 '=' is illegal — must be 0,1,3,4,6).
|
||||
let n2: i32 = putstr("MZX=====", inbuf[0:16], 0);
|
||||
let r2: (i32 | base32.invalid) = base32.decode(outbuf[0:16], inbuf[0:n2]);
|
||||
match (r2) {
|
||||
case let m: i32 => { let _: i32 = 1/0; };
|
||||
case let e: base32.invalid => void;
|
||||
};
|
||||
// Bad char ('1' is not in the std alphabet).
|
||||
let n3: i32 = putstr("MZ1W6YTB", inbuf[0:16], 0);
|
||||
let r3: (i32 | base32.invalid) = base32.decode(outbuf[0:16], inbuf[0:n3]);
|
||||
match (r3) {
|
||||
case let m: i32 => { let _: i32 = 1/0; };
|
||||
case let e: base32.invalid => void;
|
||||
};
|
||||
};
|
||||
|
||||
@test fn sizes() void = {
|
||||
if (base32.encodedsize(0) != 0) { let _: i32 = 1/0; };
|
||||
if (base32.encodedsize(1) != 8) { let _: i32 = 1/0; };
|
||||
if (base32.encodedsize(5) != 8) { let _: i32 = 1/0; };
|
||||
if (base32.encodedsize(6) != 16) { let _: i32 = 1/0; };
|
||||
if (base32.decodedsize(8) != 5) { let _: i32 = 1/0; };
|
||||
if (base32.decodedsize(16) != 10) { let _: i32 = 1/0; };
|
||||
};
|
||||
|
||||
export fn main() i32 = {
|
||||
rfc4648_std();
|
||||
rfc4648_decode();
|
||||
rfc4648_hex();
|
||||
roundtrip_all_quintets();
|
||||
invalid_inputs();
|
||||
sizes();
|
||||
return 0;
|
||||
};
|
||||
Reference in New Issue
Block a user