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

lib/fmt: port V-side modifier formatting (#94 fold-e6)

Browse Source 
V's vfprintf parsed mods via scanmods but dropped them after parse —
vformatfield routed straight to vwriteone (no width / alignment / pad
/ sign / base / prec honoured). Port the OLD modifier path (fmt.ww:
443-641 rawlen* / formatraw / formatone) into vstream.ww as the v*
twins, widen vformatfield to take *mods, and pass &m through vfprintf
at the call site.

The v* helpers mirror OLD verbatim (compute body identical; vputbytes
+ (size | io.error) routing replacing putbytes + (i32 | io.closed));
shared compute helpers (signof / digitsu64 / basenum) and modifier
enums (neg / alignment / mods) are reused directly from fmt.ww via
package scope. fmt.ww UNCHANGED — fold-eFinal (#50) collapses both
surfaces and dedupes the rawlen-family.

drew NaN/Inf signoff: strconv.f64tos / f32tos already render
"nan"/"infinity" with no leading '-', so the sign-peel in vrawlenf64
+ vformatraw f64 arm is a no-op on those views (same OLD path at
fmt.ww:520-562).

ken cs==ww mechanical: both stages compile the new V-side identically;
990-997 byte-id gates + combined_ww_fresh stay green (fmt is not
embedded in any selfhost main.combined.ww — grep verified pre-impl).

test/wcc/780_fmt_vstream_mods_run.c (cstage-only per #209): 5 rows
covering width / precision / base_hex / sign_plus / zero_pad. STAGE_WW
blocked by #209 (wwstage formattable match-arm bail), same carve-out
as 777_fmt_vstream_run.
This commit is contained in:
Hojun-Cho
2026-05-29 11:50:55 +09:00
parent d87ee01cdf
commit a3f3153943
3 changed files with 604 additions and 13 deletions
Download Patch File Download Diff File Expand all files Collapse all files

254
lib/fmt/vstream.ww
View File

@@ -39,7 +39,15 @@
// because the OLD versions take `*io.stream` (the legacy struct) and
// fmt.ww must stay UNCHANGED this fold. Shared bits — `i64dec`,
// `modsinit`, `scandigits`, `scanmods`, `formattable`, `field`,
// `mods`, `fmtabort` — are reused directly from fmt.ww (same package).
// `mods`, `fmtabort`, `signof`, `digitsu64`, `basenum`, the modifier
// enums (`neg`, `alignment`) — are reused directly from fmt.ww (same
// package). The v* modifier-formatting helpers (vrawleni64 / vrawlenstr
// / vrawlenf64 / vrawlen / vformatraw / vformatone) mirror the OLD
// rawlen* / formatraw / formatone verbatim (compute body identical;
// vputbytes + (size | io.error) routing instead of putbytes +
// (i32 | io.closed)) — #94 fold-e6 ports them V-side so V's printf
// honours modifiers (fold-e3 dropped them after parse). eFinal (#50)
// collapses both surfaces.
//
// Sibling tasks parked here (filed, NOT fixed):
//
@@ -136,33 +144,253 @@ fn vwriteone(vs: io.vstream, a: formattable) (size | io.error) = {
return 0: size;
};
// vformatfield — field→formattable inline-per-arm dispatch. The
// for-loop call site in vfprintf would trip task #18 (silent
// miscompile of 24B return-by-value in for-loop context) if widened
// via a helper; inline-per-arm sidesteps it — same shape OLD
// ---- V-side modifier formatting (port of OLD rawlen*/formatraw/
// formatone from fmt.ww:443-641). Project #94 fold-e6.
//
// V-side mirror of the OLD modifier-formatting machinery so the V
// printf path honours width / alignment / pad / sign / base / prec
// instead of dropping mods after parse. Drew-signoff: NaN/Inf safe
// — strconv.f64tos / f32tos render "nan"/"infinity" with no leading
// '-', so the sign-peel in vrawlenf64 / vformatraw f64 arm is a
// no-op on those views (sibling of OLD rawlenf64's same path). Ken-
// signoff: cs==ww mechanical — both stages compile the new V-side
// identically; eFinal (#50) graduates the V-side over the OLD.
//
// Helpers mirror fmt.ww verbatim (compute-only, no I/O) rather than
// reusing OLD by call — fold-eFinal (#50) atomically deletes the OLD
// surface AND collapses these v* names back, so the duplication is
// transient. Mirror sites:
//
// vrawleni64 fmt.ww:443 rawleni64
// vrawlenstr fmt.ww:457 rawlenstr
// vrawlenf64 fmt.ww:569 rawlenf64
// vrawlen fmt.ww:585 rawlen
// vformatraw fmt.ww:465 formatraw
// vformatone fmt.ww:598 formatone
// vrawleni64 — bytes the raw render of `v` under `m` would emit; the
// signof / digitsu64 / basenum helpers are read from fmt.ww (same
// package). Mirror fmt.ww:443.
fn vrawleni64(v: i64, m: *mods) i32 = {
let neg_flag: bool = v < 0;
let u: u64 = v: u64;
if (neg_flag) { u = (-v): u64; };
let signlen: i32 = 0;
if (signof(neg_flag, m) != 0u8) { signlen = 1; };
let dlen: i32 = digitsu64(u, basenum(m.base));
let inner: i32 = dlen;
if (m.prec > signlen + dlen) { inner = m.prec - signlen; };
return signlen + inner;
};
// vrawlenstr — bytes the raw render of `s` would emit (after `prec`
// truncation). Mirror fmt.ww:457.
fn vrawlenstr(s: str, m: *mods) i32 = {
if (m.prec > 0 && m.prec < s.len) { return m.prec; };
return s.len;
};
// vrawlenf64 — bytes the raw render of `v` under `m` would emit; the
// strconv.f64tos static-buffer view is consumed by reading view.len
// + view.ptr[0] before the sign byte is folded into signof. Mirror
// fmt.ww:569; drew NaN/Inf safe (strconv emits no leading '-' on
// nan/inf, so the peel is a no-op on those views).
fn vrawlenf64(v: f64, m: *mods) i32 = {
let view: str = strconv.f64tos(v);
let body: i32 = view.len;
let had_neg: bool = false;
if (body > 0 && view.ptr[0] == 45u8) {
had_neg = true;
body -= 1;
};
let signlen: i32 = 0;
if (signof(had_neg, m) != 0u8) { signlen = 1; };
return signlen + body;
};
// vrawlen — dispatch the rawlen sum over formattable. Mirror fmt.ww:585.
fn vrawlen(arg: formattable, m: *mods) i32 = {
match (arg) {
case let v: i64 => return vrawleni64(v, m);
case let v: str => return vrawlenstr(v, m);
case let b: bool => { if (b) { return 4; }; return 5; };
case let r: rune => return 1;
case let v: f64 => return vrawlenf64(v, m);
};
return 0; // unreachable — match is exhaustive
};
// vformatraw — write the bare value (no width padding) to `vs`. Mirror
// fmt.ww:465 formatraw, vputbytes-routed and (size | io.error)-typed.
// `prec` ignored on f64 (strconv.f64tos is shortest-G with no precision
// knob); base ignored on f64 (Hare too — base is int-only). Drew-
// signoff: NaN/Inf strings emitted unchanged via vputbytes.
fn vformatraw(vs: io.vstream, arg: formattable, m: *mods) (size | io.error) = {
match (arg) {
case let v: i64 => {
let neg_flag: bool = v < 0;
let u: u64 = v: u64;
if (neg_flag) { u = (-v): u64; };
let sb: u8 = signof(neg_flag, m);
let total: size = 0;
if (sb != 0u8) {
let buf: [1]u8;
buf[0] = sb;
let r: (size | io.error) = vputbytes(vs, &buf[0], 1);
match (r) {
case let n: size => { total += n; };
case let e: io.error => return e;
};
};
let dlen: i32 = digitsu64(u, basenum(m.base));
let signlen: i32 = 0;
if (sb != 0u8) { signlen = 1; };
let pad0: i32 = 0;
if (m.prec > signlen + dlen) { pad0 = m.prec - signlen - dlen; };
let pi: i32 = 0;
for (pi < pad0) {
let buf: [1]u8;
buf[0] = 48u8; // '0'
let r: (size | io.error) = vputbytes(vs, &buf[0], 1);
match (r) {
case let n: size => { total += n; };
case let e: io.error => return e;
};
pi += 1;
};
let view: str = strconv.u64tos(u, m.base);
let r: (size | io.error) = vputbytes(vs, view.ptr, view.len);
match (r) {
case let n: size => { total += n; };
case let e: io.error => return e;
};
return total;
};
case let v: str => {
let n: i32 = vrawlenstr(v, m);
return vputbytes(vs, v.ptr, n);
};
case let b: bool => {
let v: str = "false";
if (b) { v = "true"; };
return vputbytes(vs, v.ptr, v.len);
};
case let r: rune => {
let buf: [4]u8;
buf[0] = r: u8;
return vputbytes(vs, &buf[0], 1);
};
case let v: f64 => {
// strconv.f64tos prepends '-' for negative values; peel
// here so signof folds neg/plus/space mods uniformly with
// the i64 arm. Drew NaN/Inf signoff: nan/infinity views
// have no leading '-', so this peel is a no-op for them
// (sign-mod on a nan emits e.g. "+nan" — a fmt-layer edge,
// not strconv's; same OLD behaviour at fmt.ww:520-562).
let view: str = strconv.f64tos(v);
let neg_flag: bool = false;
if (view.len > 0 && view.ptr[0] == 45u8) { // '-'
neg_flag = true;
view.ptr = view.ptr + 1u64;
view.len -= 1;
};
let sb: u8 = signof(neg_flag, m);
let total: size = 0;
if (sb != 0u8) {
let buf: [1]u8;
buf[0] = sb;
let r: (size | io.error) = vputbytes(vs, &buf[0], 1);
match (r) {
case let n: size => { total += n; };
case let e: io.error => return e;
};
};
let r: (size | io.error) = vputbytes(vs, view.ptr, view.len);
match (r) {
case let n: size => { total += n; };
case let e: io.error => return e;
};
return total;
};
};
let z: size = 0; return z; // unreachable — match is exhaustive
};
// vformatone — render `arg` to `vs` with `m`'s width / alignment / pad
// applied. Mirror fmt.ww:598 formatone; the tail-pad loop drives on
// a counter (mirrors OLD) because vputbytes over memio.fixed reports
// a full buffer as a 0-byte partial write, not io.error — looping on
// `total < m.width` would spin on bsprintf_v when the sink runs out.
fn vformatone(vs: io.vstream, arg: formattable, m: *mods) (size | io.error) = {
let start: i32 = 0;
if (m.width > 0 && m.alignment != alignment.LEFT) {
let raw: i32 = vrawlen(arg, m);
let pad: i32 = 0;
if (raw < m.width) { pad = m.width - raw; };
if (m.alignment == alignment.CENTER) { start = (pad + 1) / 2; }
else { start = pad; };
};
let total: size = 0;
let i: i32 = 0;
let padb: [1]u8;
padb[0] = m.pad: u8;
for (i < start) {
let r: (size | io.error) = vputbytes(vs, &padb[0], 1);
match (r) {
case let n: size => { total += n; };
case let e: io.error => return e;
};
i += 1;
};
let r1: (size | io.error) = vformatraw(vs, arg, m);
match (r1) {
case let n: size => { total += n; };
case let e: io.error => return e;
};
let need: i32 = 0;
let twidth: size = m.width: size;
if (twidth > total) { need = (twidth - total): i32; };
let j: i32 = 0;
for (j < need) {
let r: (size | io.error) = vputbytes(vs, &padb[0], 1);
match (r) {
case let n: size => { total += n; };
case let e: io.error => return e;
};
j += 1;
};
return total;
};
// vformatfield — field→formattable inline-per-arm dispatch through
// vformatone. The for-loop call site in vfprintf would trip task #18
// (silent miscompile of 24B return-by-value in for-loop context) if
// widened via a helper; inline-per-arm sidesteps it — same shape OLD
// formatfield uses at fmt.ww:648. `*mods` arm aborts (parametric '%'
// form not implemented; OLD fprintf aborts identically).
fn vformatfield(vs: io.vstream, f: field) (size | io.error) = {
// form not implemented; OLD fprintf aborts identically). #94 fold-e6
// widens the signature with `*mods` so the V path honours modifiers
// (fold-e3 dropped them after parse).
fn vformatfield(vs: io.vstream, f: field, m: *mods) (size | io.error) = {
match (f) {
case let v: i64 => {
let a: formattable = v;
return vwriteone(vs, a);
return vformatone(vs, a, m);
};
case let v: str => {
let a: formattable = v;
return vwriteone(vs, a);
return vformatone(vs, a, m);
};
case let b: bool => {
let a: formattable = b;
return vwriteone(vs, a);
return vformatone(vs, a, m);
};
case let r: rune => {
let a: formattable = r;
return vwriteone(vs, a);
return vformatone(vs, a, m);
};
case let v: f64 => {
let a: formattable = v;
return vwriteone(vs, a);
return vformatone(vs, a, m);
};
case let p: *mods => { fmtabort(); let z: size = 0; return z; };
};
@@ -236,7 +464,7 @@ export fn vfprintf(vs: io.vstream, fmt: str, args: field...) (size | io.error) =
if (i >= fmt.len || fmt[i] != 125u8) { fmtabort(); };
i += 1;
if (idx >= args.len) { fmtabort(); };
let r: (size | io.error) = vformatfield(vs, args[idx]);
let r: (size | io.error) = vformatfield(vs, args[idx], &m);
match (r) {
case let n: size => { total += n; };
case let e: io.error => return e;