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

lib/strconv: stoi/stou/stoz machine-word int parse (strconv-int fold-1 C2)

Browse Source 
Add the int/uint/size entry points (ref/hare/strconv/stoi.ha:53,
stou.ha:107,113). Hare clamps to types::INT_MIN/MAX, UINT_MAX, SIZE_MAX
via stoiminmax/stoumax; ww's int/uint/size are 8B machine words
(INT/UINT/SIZE limits == I64/U64 per lib/types/types.ww:30-37), so the
clamp is a no-op — the full i64/u64 range parses with no spurious
overflow. Documented at-site (the bound consts are package-private, so
inlining them would just re-encode I64/U64_MAX).

Tests: extend inttest.ww with test_stoi_stou_stoz — value path, sign,
overflow pass-through, and the no-clamp fidelity (I64_MAX/U64_MAX parse
without overflow) plus hex/bin bases through the shared parseint core.

combined.ww regen: w6c + wwdump main.combined.ww.
This commit is contained in:
Hojun-Cho
2026-06-01 22:07:04 +09:00
parent 6a5cdbd779
commit a11785273a
5 changed files with 250 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

70
lib/strconv/test/inttest.ww
View File

@@ -99,6 +99,51 @@ fn cki32(id: i32, s: str, b: base, want: i32) void = {
};
};
fn ck_int(id: i32, s: str, b: base, want: int) void = {
signalled = id;
match (stoi(s, b)) {
case let v: int => if (v != want) { fail(); };
case let e: invalid => fail();
case let e: overflow => fail();
};
};
fn ck_uint(id: i32, s: str, b: base, want: uint) void = {
signalled = id;
match (stou(s, b)) {
case let v: uint => if (v != want) { fail(); };
case let e: invalid => fail();
case let e: overflow => fail();
};
};
fn ck_size(id: i32, s: str, b: base, want: size) void = {
signalled = id;
match (stoz(s, b)) {
case let v: size => if (v != want) { fail(); };
case let e: invalid => fail();
case let e: overflow => fail();
};
};
fn ck_int_ovf(id: i32, s: str, b: base) void = {
signalled = id;
match (stoi(s, b)) {
case let v: int => fail();
case let e: invalid => fail();
case let e: overflow => { };
};
};
fn ck_uint_ovf(id: i32, s: str, b: base) void = {
signalled = id;
match (stou(s, b)) {
case let v: uint => fail();
case let e: invalid => fail();
case let e: overflow => { };
};
};
// ref/hare/strconv/stoi.ha:56-79.
@test fn test_stoi64() void = {
cki_inv(1, "", base.DEC, 0);
@@ -164,10 +209,35 @@ fn cki32(id: i32, s: str, b: base, want: i32) void = {
cku(45, "110101", base.BIN, 53u64); // 0b110101
};
// stoi / stou / stoz — int/uint/size machine-word wrappers
// (ref/hare/strconv/stoi.ha:53, stou.ha:107,113). ww's int/uint/size are
// 8B, so the iN/uN clamp is a no-op: the full i64/u64 range parses with
// no spurious overflow. That no-clamp fidelity is what these check.
@test fn test_stoi_stou_stoz() void = {
ck_int(50, "0", base.DEC, 0);
ck_int(51, "-1", base.DEC, -1);
ck_int(52, "9223372036854775807", base.DEC, 9223372036854775807i64: int); // I64_MAX fits int
ck_int_ovf(53, "9223372036854775808", base.DEC);
ck_int_ovf(54, "-9223372036854775809", base.DEC);
ck_uint(55, "0", base.DEC, 0u64: uint);
ck_uint(56, "18446744073709551615", base.DEC, 18446744073709551615u64: uint); // U64_MAX fits uint
ck_uint_ovf(57, "18446744073709551616", base.DEC);
ck_uint_ovf(58, "-1", base.DEC);
ck_size(59, "0", base.DEC, 0u64: size);
ck_size(60, "18446744073709551615", base.DEC, 18446744073709551615u64: size); // U64_MAX fits size
// bases route through the same parseint core.
ck_int(61, "-7f", base.HEX, -127i64: int); // -0x7f
ck_uint(62, "110101", base.BIN, 53u64: uint); // 0b110101
};
export fn main() i32 = {
test_stoi64();
test_stoi64_bases();
test_stou64();
test_stou64_bases();
test_stoi_stou_stoz();
return 0;
};