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

lib: collapse the parallel vstream scaffold onto the single Hare io surface (#94 fold-eFinal)

Browse Source 
The Option-C parallel _v vstream API was scaffolding to bring the io stack up alongside the old surface; carrying both permanently is a rule-9 divergence from ref/hare, which has exactly one io surface. Collapse onto that surface (stream = *vtable, ref/hare/io/stream.ha) and rename the _v symbols to their Hare names (io vstream->stream, fmt vfprint->fprint, bufio/memio/log surfaces, log.new). Deletes the 4 lib/*/vstream.ww scaffold files; regenerates w6c/wwdump combined.ww. cstage and wwstage stay byte-identical and combined_ww_fresh holds; all 220 tests pass.
This commit is contained in:
Hojun-Cho
2026-05-30 03:24:23 +09:00
parent 80184a3acf
commit 7d39f6d623
31 changed files with 2371 additions and 4834 deletions
Download Patch File Download Diff File Expand all files Collapse all files

240
lib/log/log.ww
View File

@@ -1,11 +1,12 @@
// log — process logger over a [[io.stream]] sink. Subset of Hare's
// lib/log (ref/hare/log/{logger,funcs,global,silent}.ha).
// log — process logger over an [[io.stream]] (= `*io.vtable`) sink.
// Subset of Hare's lib/log (ref/hare/log/{logger,funcs,global,silent}.ha).
// Project #94 fold-eFinal.
//
// Surface today:
// Surface:
//
// log.logger — vtable with `println` + `printfln` slots
// log.stdlogger — first-field embed of logger + a `*io.stream` sink
// log.new (sl: *stdlogger, sink: *io.stream) void
// log.stdlogger — first-field embed of logger + an io.stream sink
// log.new (sink: io.stream) stdlogger
// log.silent *logger — a logger that discards every record
// log.default *logger — a stdlogger writing to stderr
// log.global *logger — the dispatch target for [[println]] / [[fatal]]
@@ -19,57 +20,43 @@
// log.lfatalf (log: *logger, format: str, fields: fmt.field...) never
// log.setlogger (log: *logger) void
//
// VALUE-RETURN (Hare ref/hare/log/logger.ha:20): [[new]] builds a
// stdlogger in a local and `return r;` (proven field-by-field sret).
// stdlogger is 24B (two fn-ptrs + sink), returned via the SysV memory
// class; the caller owns the returned logger (stack ownership, no-GC)
// and passes `&sl.logger` to the dispatch fns.
//
// Divergences from Hare:
//
// • Hare returns the stdlogger from `new` by value; ww cgen can't
// return wide structs, so [[new]] is out-parameter shaped. Same
// workaround as memio.fixed / bufio.init.
// • silent / default / _default initialised via a lazy [[ensureinit]]
// (lib/temp's `rnginit==0` pattern) rather than module-scope struct-
// literal lets: cstage `emit_lets` only constexprs primitive /
// str-literal / array-literal lets. The public *logger globals are
// zero initially and become non-nil after the first lib/log call;
// callers that read globals directly must call some lib/log fn first
// so init runs. Graduates if static-init lands.
//
// • Hare initialises silent / default / _default via module-scope
// struct literal lets. cstage `emit_lets` (cmd/w6c/cgen.c:6176)
// only constexprs primitive / str-literal / array-literal lets —
// struct- and pointer-literal init aren't reachable. ww drops to
// a lazy [[ensureinit]] (lib/temp's `rnginit==0` pattern) called
// from every exported fn. The public *logger globals are zero
// initially and become non-nil after the first lib/log call;
// callers that read globals directly (rather than going through
// [[println]] / [[lprintln]] / [[setlogger]] / etc.) must call
// some lib/log fn first so init runs.
// • Param name divergence: the format-string parameter is `format`
// (Hare's is `fmt`). Permanent — #19 refuses any let/param shadowing
// an imported module name; `use fmt; fn x(fmt: T)` is structurally
// ambiguous under ww's `.`-for-both rule.
//
// • Param name divergence from Hare: the format-string parameter is
// `format` (Hare's is `fmt`). Permanent — #19 refuses any
// let/param that shadows an imported module name, regardless of
// body usage. ww chose `.` for both module-access and field-
// access, so `use fmt; fn x(fmt: T)` is structurally ambiguous;
// the resolver refuses it at decl.
// Sink today is an [[io.stream]] only — lib/io has no fd-backed handle
// yet (Hare's `io::handle = file | int`, io fold-2 #5). The default
// logger writes to stderr via a private fd_ctx whose write callback
// forwards to [[os.write]] on fd 2.
//
// Sink today is [[io.stream]] only — lib/io has no fd-backed stream
// yet (Hare's `io::handle = file | int` collapses to one variant).
// The default logger writes to stderr via a private io.stream whose
// write callback forwards to [[os.write]] on fd 2.
// Cast workaround per #206-payoff (ken: KEEP the explicit casts; they
// are cgen-neutral and sidestep the #214 over-acceptance surface). The
// `(&fn_name): *io.<role>` cast at the stderrsink_ctx_g vt wire-up; the
// #206 cast-drop is gated on #214. stderrwrite constructs nomem and
// widens to io.error explicitly rather than `os.trywrite(...)?` for the
// no-handle interim.
//
// Compiler note: wwstage cgen's variadic dispatch is name-based
// (`fnparamslookup(callee.str)`), which would conflate the
// `logger.println` vtable field with the top-level [[println]] fn
// if both stages compiled this module. cstage uses type-driven
// dispatch via the call-node's lhs type and handles fn-pointer
// variadic calls correctly. Today lib/log is consumed only by tests
// routed through `ww run` (cstage), so this is a latent issue
// covered by #11 (wwstage checkfile pass).
//
// let buf: [128]u8;
// let mem: memio.state;
// let s: io.stream;
// memio.fixed(&mem, &s, buf[0:128]);
//
// let sl: log.stdlogger;
// log.new(&sl, &s);
// let sl: log.stdlogger = log.new(&s.vt);
// log.lprintln(&sl.logger, "hello", 42i64);
// // mem now holds "hello 42\n"
//
// log.setlogger(&sl.logger);
// log.println("through global");
//
// log.setlogger(log.silent);
// log.println("dropped");
@@ -87,53 +74,55 @@ export type logger = struct {
printfln: fn(l: *logger, format: str, fields: fmt.field...) void,
};
// stdlogger — concrete logger forwarding to a `*io.stream` sink.
// First-field embed: `&sl.logger` yields a `*logger` (same shape as
// bufio.stream over its embedded io.stream vtable). The vtable
// callback recovers the outer stdlogger by casting the dispatch arg
// back to `*stdlogger`.
// stdlogger — concrete logger forwarding to an io.stream sink.
// First-field embed: `&sl.logger` yields a `*logger` (intrusive
// outer→inner cast); the vtable callback recovers the outer via
// `*stdlogger` cast. Mirrors ref/hare/log/logger.ha:18.
export type stdlogger = struct {
logger: logger,
sink: *io.stream,
sink: io.stream,
};
// stderrsink — private io.stream wired through fd 2 via [[os.write]].
// Used as [[default]]'s sink. Independent of lib/io's future fd-backed
// stream — when that lands, this collapses to a thin wrapper and
// graduates in one go.
let stderrsink: io.stream;
// stderrsink_ctx — module-static state for the default logger's stderr
// sink. vt FIRST field for the intrusive io.stream→*stderrsink_ctx cast
// in stderrwrite. Mirrors fmt.fd_ctx; only scalars/ptrs beyond vt.
type stderrsink_ctx = struct {
vt: io.vtable,
fd: i32,
};
// _silent — backing storage for the [[silent]] global.
let _silent: logger;
// Zero-init at link time per #129 A.2/A.3 SSoT; ensureinit wires
// vt.reader / vt.writer + fd lazily on first dispatch.
let stderrsink_ctx_g: stderrsink_ctx;
// _default — backing storage for the [[default]] global. Its sink
// points at [[stderrsink]] after [[ensureinit]] runs.
// _silent / _default — backing storage for the silent / default
// *logger globals. Zero-init at link time; ensureinit fills the
// println / printfln slots.
let _silent: logger;
let _default: stdlogger;
// silent / default / global — Hare-style *logger globals. Zero-init
// at link time; lazily wired by [[ensureinit]] on the first call to
// any exported fn. See the file header for the divergence rationale.
// silent / default / global — Hare-style *logger globals. Zero-init at
// link time; lazily wired by [[ensureinit]] on the first call to any
// exported fn. See the file header for the divergence rationale.
export let silent: *logger;
export let default: *logger;
export let global: *logger;
// initdone — guards [[ensureinit]] so the one-shot wiring runs once.
// Mirrors lib/temp's `rnginit` pattern.
let initdone: i32 = 0;
fn ensureinit() void = {
if (initdone != 0) { return; };
stderrsink.ctx = nil;
stderrsink.read = stderrread;
stderrsink.write = stderrwrite;
stderrsink.close = stderrclose;
stderrsink_ctx_g.fd = 2;
stderrsink_ctx_g.vt.reader = (&stderrread): *io.reader;
stderrsink_ctx_g.vt.writer = (&stderrwrite): *io.writer;
_silent.println = silentprintln;
_silent.printfln = silentprintfln;
_default.logger.println = stdprintln;
_default.logger.printfln = stdprintfln;
_default.sink = &stderrsink;
_default.sink = &stderrsink_ctx_g.vt;
silent = &_silent;
default = &_default.logger;
@@ -141,120 +130,127 @@ fn ensureinit() void = {
initdone = 1;
};
// stderrread / stderrwrite / stderrclose — io.stream callbacks for
// the private stderr sink. Read is a no-op returning io.eof; close
// is a no-op (the process owns fd 2). Write forwards to write(2)
// and translates a negative-errno into io.closed.
fn stderrread(s: *io.stream, buf: []u8) (i32 | io.eof | io.closed) = {
// stderrread / stderrwrite — vtable callbacks for the private stderr
// sink. Read is eof-only — lib/log writes; never reads. -errno collapses
// to a nomem-widened io.error.
fn stderrread(s: io.stream, buf: []u8) (size | io.eof | io.error) = {
let e: io.eof;
return e;
};
fn stderrwrite(s: *io.stream, buf: []u8) (i32 | io.closed) = {
let r: i64 = os.write(2, buf.ptr, buf.len: u64);
fn stderrwrite(s: io.stream, buf: []u8) (size | io.error) = {
let c: *stderrsink_ctx = s: *stderrsink_ctx;
let r: i64 = os.write(c.fd, buf.ptr, buf.len: u64);
if (r < 0) {
let e: io.closed;
let nm: nomem;
let e: io.error = nm;
return e;
};
return r: i32;
return r: size;
};
fn stderrclose(s: *io.stream) (void | io.closed) = { return; };
// stdprintln — vtable callback for stdlogger. Forwards to
// [[fmt.fprintln]] on the sink; the (i32 | io.closed) result is
// dropped — lib/log's surface is `void` (matches Hare).
// stdprintln / stdprintfln — vtable callbacks for stdlogger. Forwards
// to fmt.fprint / fprintf on the sink + appends the trailing newline
// via io.write. Hare's fmt.fprintln emits the newline inside one
// wrapper (ref/hare/fmt/wrappers.ha:60-68); we inline that split at the
// log site because fmt.fprint is the bare (no-newline) primitive. The
// (size | io.error) results are dropped — lib/log's surface is `void`.
fn stdprintln(l: *logger, args: fmt.formattable...) void = {
let sl: *stdlogger = l: *stdlogger;
fmt.fprintln(sl.sink, args...);
fmt.fprint(sl.sink, args...);
let nl: [1]u8;
nl[0] = 10u8;
let v: []u8 = nl[0:1];
io.write(sl.sink, v);
};
// stdprintfln — vtable callback for stdlogger's format-string slot.
// Mirrors ref/hare/log/logger.ha:38 log_printfln. `format` (not
// Hare's `fmt`) per the param-name divergence noted in the header.
fn stdprintfln(l: *logger, format: str, fields: fmt.field...) void = {
let sl: *stdlogger = l: *stdlogger;
fmt.fprintfln(sl.sink, format, fields...);
fmt.fprintf(sl.sink, format, fields...);
let nl: [1]u8;
nl[0] = 10u8;
let v: []u8 = nl[0:1];
io.write(sl.sink, v);
};
// silentprintln — vtable callback for the silent logger. Discards
// every record without dispatching through fmt; keeps silent truly
// silent if fmt ever gets stateful.
// silentprintln / silentprintfln — vtable callbacks for the silent
// logger. Discard every record without dispatching through fmt; keeps
// silent truly silent if fmt ever gets stateful. Mirror
// ref/hare/log/silent.ha:15.
fn silentprintln(l: *logger, args: fmt.formattable...) void = { };
// silentprintfln — format-string sibling of [[silentprintln]].
// Mirrors ref/hare/log/silent.ha:15.
fn silentprintfln(l: *logger, format: str, fields: fmt.field...) void = { };
// new — wire `sl` as a stdlogger over `sink`. Hare returns by value
// (ref/hare/log/logger.ha:20); ww cgen can't return wide structs,
// so we take an out-parameter pointer (same shape as memio.fixed,
// bufio.init).
export fn new(sl: *stdlogger, sink: *io.stream) void = {
// ---- public API ----------------------------------------------------------
// new — build a stdlogger over `sink`, returned BY VALUE. Mirrors
// ref/hare/log/logger.ha:20.
export fn new(sink: io.stream) stdlogger = {
ensureinit();
sl.logger.println = stdprintln;
sl.logger.printfln = stdprintfln;
sl.sink = sink;
let r: stdlogger;
r.logger.println = stdprintln;
r.logger.printfln = stdprintfln;
r.sink = sink;
return r;
};
// lprintln — dispatch `args` through `log`. Hare's lib/log/funcs.ha
// counterpart at line 8.
// lprintln — dispatch `args` through `log`. Mirrors ref/hare/log/funcs.ha:8.
export fn lprintln(log: *logger, args: fmt.formattable...) void = {
ensureinit();
log.println(log, args...);
};
// println — dispatch through the [[global]] logger.
// println — dispatch through the [[global]] logger. Mirrors
// ref/hare/log/funcs.ha:18.
export fn println(args: fmt.formattable...) void = {
ensureinit();
lprintln(global, args...);
};
// lfatal — lprintln to `log` then exit(255). `never` return marks
// the bottom type so flow-control checks treat callers as terminated.
// Hare's lib/log/funcs.ha counterpart at line 28.
// lfatal — lprintln to `log` then exit(255). `never` return marks the
// bottom type so flow-control checks treat callers as terminated.
// Mirrors ref/hare/log/funcs.ha:28.
export fn lfatal(log: *logger, args: fmt.formattable...) never = {
lprintln(log, args...);
os.exit(255);
};
// fatal — lprintln to [[global]] then exit(255). Hare's lib/log/
// funcs.ha counterpart at line 45.
// fatal — lprintln to [[global]] then exit(255). Mirrors
// ref/hare/log/funcs.ha:45.
export fn fatal(args: fmt.formattable...) never = {
println(args...);
os.exit(255);
};
// setlogger — install `log` as the [[global]] logger. Hare's
// lib/log/global.ha counterpart at line 20.
// setlogger — install `log` as the [[global]] logger. Mirrors
// ref/hare/log/global.ha:20.
export fn setlogger(log: *logger) void = {
ensureinit();
global = log;
};
// lprintfln — dispatch a format-string record through `log`. Hare's
// lib/log/funcs.ha counterpart at line 13.
// lprintfln — dispatch a format-string record through `log`. Mirrors
// ref/hare/log/funcs.ha:13.
export fn lprintfln(log: *logger, format: str, fields: fmt.field...) void = {
ensureinit();
log.printfln(log, format, fields...);
};
// printfln — dispatch through the [[global]] logger. Hare's
// lib/log/funcs.ha counterpart at line 23.
// printfln — dispatch through the [[global]] logger. Mirrors
// ref/hare/log/funcs.ha:23.
export fn printfln(format: str, fields: fmt.field...) void = {
ensureinit();
lprintfln(global, format, fields...);
};
// lfatalf — lprintfln to `log` then exit(255). Hare's
// lib/log/funcs.ha counterpart at line 35.
// lfatalf — lprintfln to `log` then exit(255). Mirrors
// ref/hare/log/funcs.ha:35.
export fn lfatalf(log: *logger, format: str, fields: fmt.field...) never = {
lprintfln(log, format, fields...);
os.exit(255);
};
// fatalf — lprintfln to [[global]] then exit(255). Hare's
// lib/log/funcs.ha counterpart at line 52.
// fatalf — lprintfln to [[global]] then exit(255). Mirrors
// ref/hare/log/funcs.ha:52.
export fn fatalf(format: str, fields: fmt.field...) never = {
printfln(format, fields...);
os.exit(255);

104
lib/log/logtest.ww
View File

@@ -44,11 +44,9 @@ fn streq(a: str, b: str) bool = {
// scenario must run before [[setloggerswap]].
@test fn defaultwiredtoglobal() void = {
let buf: [4]u8;
let mem: memio.state;
let s: io.stream;
memio.fixed(&mem, &s, buf[0:4]);
let sl: log.stdlogger;
log.new(&sl, &s); // triggers ensureinit
let mem: memio.stream = memio.fixed(buf[0:4]);
let s: io.stream = &mem.vt;
let sl: log.stdlogger = log.new(s); // triggers ensureinit
if (log.silent == nil) { fail(); };
if (log.default == nil) { fail(); };
@@ -60,12 +58,10 @@ fn streq(a: str, b: str) bool = {
@test fn lprintlnbasic() void = {
let buf: [32]u8;
let mem: memio.state;
let s: io.stream;
memio.fixed(&mem, &s, buf[0:32]);
let mem: memio.stream = memio.fixed(buf[0:32]);
let s: io.stream = &mem.vt;
let sl: log.stdlogger;
log.new(&sl, &s);
let sl: log.stdlogger = log.new(s);
log.lprintln(&sl.logger, "hello", 42i64);
@@ -76,12 +72,10 @@ fn streq(a: str, b: str) bool = {
@test fn lprintlnsingle() void = {
let buf: [16]u8;
let mem: memio.state;
let s: io.stream;
memio.fixed(&mem, &s, buf[0:16]);
let mem: memio.stream = memio.fixed(buf[0:16]);
let s: io.stream = &mem.vt;
let sl: log.stdlogger;
log.new(&sl, &s);
let sl: log.stdlogger = log.new(s);
log.lprintln(&sl.logger, "only");
@@ -92,12 +86,10 @@ fn streq(a: str, b: str) bool = {
@test fn lprintlnempty() void = {
let buf: [4]u8;
let mem: memio.state;
let s: io.stream;
memio.fixed(&mem, &s, buf[0:4]);
let mem: memio.stream = memio.fixed(buf[0:4]);
let s: io.stream = &mem.vt;
let sl: log.stdlogger;
log.new(&sl, &s);
let sl: log.stdlogger = log.new(s);
log.lprintln(&sl.logger);
@@ -114,12 +106,10 @@ fn streq(a: str, b: str) bool = {
// empty (silent has no path to it anyway).
@test fn silentwritesnothing() void = {
let buf: [16]u8;
let mem: memio.state;
let s: io.stream;
memio.fixed(&mem, &s, buf[0:16]);
let mem: memio.stream = memio.fixed(buf[0:16]);
let s: io.stream = &mem.vt;
let sl: log.stdlogger;
log.new(&sl, &s); // triggers log.ensureinit; populates log.silent
let sl: log.stdlogger = log.new(s); // triggers log.ensureinit; populates log.silent
if (log.silent == nil) { fail(); };
@@ -136,18 +126,14 @@ fn streq(a: str, b: str) bool = {
// the swap semantics.
@test fn setloggerswap() void = {
let buf1: [32]u8;
let mem1: memio.state;
let s1: io.stream;
memio.fixed(&mem1, &s1, buf1[0:32]);
let sl1: log.stdlogger;
log.new(&sl1, &s1);
let mem1: memio.stream = memio.fixed(buf1[0:32]);
let s1: io.stream = &mem1.vt;
let sl1: log.stdlogger = log.new(s1);
let buf2: [32]u8;
let mem2: memio.state;
let s2: io.stream;
memio.fixed(&mem2, &s2, buf2[0:32]);
let sl2: log.stdlogger;
log.new(&sl2, &s2);
let mem2: memio.stream = memio.fixed(buf2[0:32]);
let s2: io.stream = &mem2.vt;
let sl2: log.stdlogger = log.new(s2);
log.setlogger(&sl1.logger);
log.println("first");
@@ -171,12 +157,10 @@ fn streq(a: str, b: str) bool = {
@test fn lprintflnbasic() void = {
let buf: [32]u8;
let mem: memio.state;
let s: io.stream;
memio.fixed(&mem, &s, buf[0:32]);
let mem: memio.stream = memio.fixed(buf[0:32]);
let s: io.stream = &mem.vt;
let sl: log.stdlogger;
log.new(&sl, &s);
let sl: log.stdlogger = log.new(s);
log.lprintfln(&sl.logger, "x={} y={}", 42i64, "hi");
@@ -189,18 +173,14 @@ fn streq(a: str, b: str) bool = {
// install sl1 as global, printfln writes there; mem2 stays empty.
@test fn printflnglobal() void = {
let buf1: [32]u8;
let mem1: memio.state;
let s1: io.stream;
memio.fixed(&mem1, &s1, buf1[0:32]);
let sl1: log.stdlogger;
log.new(&sl1, &s1);
let mem1: memio.stream = memio.fixed(buf1[0:32]);
let s1: io.stream = &mem1.vt;
let sl1: log.stdlogger = log.new(s1);
let buf2: [32]u8;
let mem2: memio.state;
let s2: io.stream;
memio.fixed(&mem2, &s2, buf2[0:32]);
let sl2: log.stdlogger;
log.new(&sl2, &s2);
let mem2: memio.stream = memio.fixed(buf2[0:32]);
let s2: io.stream = &mem2.vt;
let sl2: log.stdlogger = log.new(s2);
log.setlogger(&sl1.logger);
log.printfln("v={}", 7i64);
@@ -215,12 +195,10 @@ fn streq(a: str, b: str) bool = {
// bare-args path.
@test fn silentignoresprintfln() void = {
let buf: [16]u8;
let mem: memio.state;
let s: io.stream;
memio.fixed(&mem, &s, buf[0:16]);
let mem: memio.stream = memio.fixed(buf[0:16]);
let s: io.stream = &mem.vt;
let sl: log.stdlogger;
log.new(&sl, &s); // triggers log.ensureinit; populates log.silent
let sl: log.stdlogger = log.new(s); // triggers log.ensureinit; populates log.silent
if (log.silent == nil) { fail(); };
@@ -236,12 +214,10 @@ fn streq(a: str, b: str) bool = {
// resolve correctly.
@test fn lprintflnindexed() void = {
let buf: [16]u8;
let mem: memio.state;
let s: io.stream;
memio.fixed(&mem, &s, buf[0:16]);
let mem: memio.stream = memio.fixed(buf[0:16]);
let s: io.stream = &mem.vt;
let sl: log.stdlogger;
log.new(&sl, &s);
let sl: log.stdlogger = log.new(s);
log.lprintfln(&sl.logger, "{1} {0}", "a", "b");
@@ -254,12 +230,10 @@ fn streq(a: str, b: str) bool = {
// intact (parser proper covered in fmttest).
@test fn lprintflnmods() void = {
let buf: [16]u8;
let mem: memio.state;
let s: io.stream;
memio.fixed(&mem, &s, buf[0:16]);
let mem: memio.stream = memio.fixed(buf[0:16]);
let s: io.stream = &mem.vt;
let sl: log.stdlogger;
log.new(&sl, &s);
let sl: log.stdlogger = log.new(s);
log.lprintfln(&sl.logger, "{:5}", 42i64);

303
lib/log/vstream.ww
View File

@@ -1,303 +0,0 @@
// vstream — Hare-shaped vtable wrappers over the logger surface.
// Project #94 fold-e5 (Option C, parallel API for lib/log). Last
// per-caller migration before fold-eFinal (task #50).
//
// Adds the ten _v variants of OLD log.ww's surface — new_v /
// lprintln_v / println_v / lprintfln_v / printfln_v / lfatal_v /
// fatal_v / lfatalf_v / fatalf_v / setlogger_v — alongside a vlogger
// vtable + vstdlogger over an io.vstream sink. The OLD surface stays
// untouched here — fold-eFinal (task #50) atomically flips the
// package shape: deletes the OLD logger / stdlogger / globals + the
// pre-vtable stderrsink + ensureinit, renames the `_v` suffix off
// (drops to bare `new` / `println` / etc. per Hare's
// ref/hare/log/{logger,funcs,global,silent}.ha), and migrates the
// few callers (lib/log/logtest.ww plus any downstream).
//
// drew acks (3/3):
// - module-static stderrsink_ctx (zero-init per #129 A.2/A.3 SSoT)
// - vt FIRST field intrusive cast (matches fmt/memio/bufio fold-e
// ctxs)
// - all 10 OLD fns get _v variants (Option-C consistency)
//
// ken mandates honored:
// - bootstrap byte-id mechanical pre==post: log is NOT embedded
// in any selfhost/cmd/*/main.combined.ww (grep-confirmed
// pre-impl), so adding vstream.ww + minimal export bumps in
// lib/fmt does not perturb the embedded surfaces. 990-997
// gates stay green by virtue of log being test-only.
// - module-static ctx via #129 A.2/A.3 (cs == ww symmetric)
// - ctx shape simple scalars/ptrs (vt is the established intrusive
// first-field idiom; the only other field is `fd: i32`. No f32
// per #165b; no nested aggregate beyond vt per #18).
//
// Hare reference: ref/hare/log/{logger.ha,funcs.ha,global.ha,silent.ha}
// + ref/hare/log/log.ha (re-export hub).
//
// Cast workaround per #206: bare `&fn_name` does not type-check as
// a `(*<alias> | void)` field-init / let-binding. Explicit
// `(&fn_name): *io.<role>` cast at each store site is the Hare-
// faithful minimum-touch route — same workaround memio/vstream.ww
// + fmt/vstream.ww + bufio/vstream.ww use. 2 cast tokens here at
// the stderrsink_ctx_g vt wire-up (reader + writer; no closer —
// the process owns fd 2, same divergence as OLD stderrclose at
// log.ww:162). Both casts drop out wholesale once #206 closes.
//
// Chained-N_DOT-on-module-static field-assign per OLD log.ww:134-140
// (`_default.logger.println = stdprintln;`) — proven-working spine.
// stderrsink_ctx_g.vt.X writes pattern through same shape; the
// tagged-union assign with widening cast composes via #199 α
// (concrete *fn → NAMED variant of (*reader | void) parent).
//
// Newline emission: vfprint / vfprintf are bare (no trailing \n);
// Hare's ref/hare/fmt/wrappers.ha:60-68 appends the newline at the
// fprintln site (after fprint). ww mirrors: stdprintln_v / stdprintfln_v
// call fmt.vfprint / fmt.vfprintf then io.st_write a one-byte slice
// `[10u8]` for the LF. Same shape OLD log.stdprintln uses via
// fmt.fprintln (log.ww:169).
//
// Sibling tasks parked here (filed, NOT fixed):
//
// - eFinal (#50): atomic flip + delete OLD log surface + drop the
// `_v` suffix wholesale (graduates to Hare's bare names).
//
// - #206 (bare &fn → (*alias|void)): 2 cast sites at ensureinit_v;
// drop out wholesale on close.
//
// - #173 (TRY-on-tagged-return both-stages broken): stderrwrite_v
// constructs nomem and widens to io.error explicitly rather than
// using `os.trywrite(...)?`; same shape memio.vstream.ww +
// fmt.vstream.ww + bufio.vstream.ww adopt.
//
// - #207 (struct-lit multi-tagged-field copy drops past first):
// not bitten here — module-static stderrsink_ctx_g is zero-init
// at link time per #129; vt fields wired via post-decl chained
// assigns rather than struct-lit, sidestepping #207 wholesale.
// The pattern is the module-static analogue of memio.vstream.ww's
// alloc-zero-chain.
//
// - #209 (wwstage formattable match-arm bail when fmt imported):
// log imports fmt transitively (via the formattable / field
// types in vlogger's vtable + fmt.vfprint / vfprintf calls in
// the std callbacks). All probe rows in test/wcc/779 run
// STAGE_CS-only; eFinal closes the wwstage half when #209 lands.
package log;
import fmt;
import io;
import os;
// stderrsink_ctx — module-static state for the default vlogger's
// stderr sink. vt FIRST field for the intrusive vstream→*stderrsink_ctx
// cast in stderrwrite_v. Mirrors fmt.fd_ctx (fmt/vstream.ww:66) +
// memio.fixed_ctx (memio/vstream.ww:48); only scalars/ptrs beyond
// vt per ken's mandate.
type stderrsink_ctx = struct {
vt: io.vtable,
fd: i32,
};
// Zero-init at link time per #129 A.2/A.3 SSoT; ensureinit_v wires
// vt.reader / vt.writer + fd lazily on first dispatch. Same shape
// OLD log.ww uses for the pre-vtable stderrsink (log.ww:104).
let stderrsink_ctx_g: stderrsink_ctx;
// vlogger — V-side counterpart to OLD logger (log.ww:85). Same shape
// modulo the `_v` field-suffix (collapses on #50). Dispatchers route
// through io.vstream rather than *io.stream.
//
// Mirrors ref/hare/log/logger.ha:9.
export type vlogger = struct {
println_v: fn(l: *vlogger, args: fmt.formattable...) void,
printfln_v: fn(l: *vlogger, format: str, fields: fmt.field...) void,
};
// vstdlogger — concrete vlogger forwarding to an io.vstream sink.
// First-field embed: `&sl.logger` yields a `*vlogger` (intrusive
// outer→inner cast); the vtable callback recovers the outer via
// `*vstdlogger` cast.
//
// Mirrors ref/hare/log/logger.ha:18 (stdlogger).
export type vstdlogger = struct {
logger: vlogger,
sink: io.vstream,
};
// _silent_v / _default_v — backing storage for the silent_v /
// default_v *vlogger globals. Zero-init at link time; ensureinit_v
// fills the println_v / printfln_v slots.
let _silent_v: vlogger;
let _default_v: vstdlogger;
// silent_v / default_v / global_v — Hare-style *vlogger globals.
// Zero-init at link time; lazily wired by ensureinit_v on the first
// call to any exported fn. Same divergence as OLD log.ww:116-118
// (header rationale for the lazy-init route applies wholesale: ww
// cstage emit_lets only constexprs primitive / str-literal /
// array-literal lets — struct- and pointer-literal init aren't
// reachable). #50 / eFinal graduates if static-init lands.
export let silent_v: *vlogger;
export let default_v: *vlogger;
export let global_v: *vlogger;
// initdone_v — guards ensureinit_v so the one-shot wiring runs once.
// Mirrors OLD initdone (log.ww:122) + lib/temp's rnginit pattern.
let initdone_v: i32 = 0;
fn ensureinit_v() void = {
if (initdone_v != 0) { return; };
stderrsink_ctx_g.fd = 2;
stderrsink_ctx_g.vt.reader = (&stderrread_v): *io.reader;
stderrsink_ctx_g.vt.writer = (&stderrwrite_v): *io.writer;
_silent_v.println_v = silentprintln_v;
_silent_v.printfln_v = silentprintfln_v;
_default_v.logger.println_v = stdprintln_v;
_default_v.logger.printfln_v = stdprintfln_v;
_default_v.sink = &stderrsink_ctx_g.vt;
silent_v = &_silent_v;
default_v = &_default_v.logger;
global_v = default_v;
initdone_v = 1;
};
// stderrread_v / stderrwrite_v — vtable callbacks for the private
// stderr sink. Read is eof-only — lib/log writes; never reads.
// Mirror of OLD stderrread / stderrwrite (log.ww:148-160) modulo the
// (size | io.eof | io.error) / (size | io.error) return surface;
// -errno collapses to a nomem-widened io.error per the
// fmt.fdsinkwrite_v precedent (fmt/vstream.ww:88-92).
fn stderrread_v(s: io.vstream, buf: []u8) (size | io.eof | io.error) = {
let e: io.eof;
return e;
};
fn stderrwrite_v(s: io.vstream, buf: []u8) (size | io.error) = {
let c: *stderrsink_ctx = s: *stderrsink_ctx;
let r: i64 = os.write(c.fd, buf.ptr, buf.len: u64);
if (r < 0) {
let nm: nomem;
let e: io.error = nm;
return e;
};
return r: size;
};
// stdprintln_v / stdprintfln_v — vtable callbacks for vstdlogger.
// Forwards to fmt.vfprint / vfprintf on the sink + appends the
// trailing newline via io.st_write. Hare's fmt.fprintln emits the
// newline inside one wrapper (ref/hare/fmt/wrappers.ha:60-68); we
// inline that split at the log site because fmt.vfprint is the bare
// (no-newline) primitive. The (size | io.error) results are dropped
// — lib/log's surface is `void` (matches Hare + OLD stdprintln at
// log.ww:167).
fn stdprintln_v(l: *vlogger, args: fmt.formattable...) void = {
let sl: *vstdlogger = l: *vstdlogger;
fmt.vfprint(sl.sink, args...);
let nl: [1]u8;
nl[0] = 10u8;
let v: []u8 = nl[0:1];
io.st_write(sl.sink, v);
};
fn stdprintfln_v(l: *vlogger, format: str, fields: fmt.field...) void = {
let sl: *vstdlogger = l: *vstdlogger;
fmt.vfprintf(sl.sink, format, fields...);
let nl: [1]u8;
nl[0] = 10u8;
let v: []u8 = nl[0:1];
io.st_write(sl.sink, v);
};
// silentprintln_v / silentprintfln_v — vtable callbacks for the
// silent vlogger. Discard every record without dispatching through
// fmt; keeps silent truly silent if fmt ever gets stateful. Mirror
// of OLD silentprintln / silentprintfln (log.ww:183-187).
fn silentprintln_v(l: *vlogger, args: fmt.formattable...) void = { };
fn silentprintfln_v(l: *vlogger, format: str, fields: fmt.field...) void = { };
// ---- public API (10 _v variants) -----------------------------------------
// new_v — build a vstdlogger over `sink`, returned BY VALUE (fold-eFinal
// PREP). Hare returns the stdlogger by value (ref/hare/log/logger.ha:20);
// the OLD out-parameter shape existed only because wide-struct sret was
// unimplemented — it now round-trips (test/wcc/925), so the constructor
// builds in a local and `return r;` (proven field-by-field sret form).
// vstdlogger is 24B (two fn-ptrs + sink), returned via the SysV memory
// class; the caller owns the returned logger (stack ownership, no-GC)
// and passes `&sl.logger` to the dispatch fns.
export fn new_v(sink: io.vstream) vstdlogger = {
ensureinit_v();
let r: vstdlogger;
r.logger.println_v = stdprintln_v;
r.logger.printfln_v = stdprintfln_v;
r.sink = sink;
return r;
};
// lprintln_v — dispatch `args` through `log`. Mirrors OLD lprintln
// (log.ww:202) + ref/hare/log/funcs.ha:8.
export fn lprintln_v(log: *vlogger, args: fmt.formattable...) void = {
ensureinit_v();
log.println_v(log, args...);
};
// println_v — dispatch through the [[global_v]] vlogger. Mirrors
// OLD println (log.ww:208) + ref/hare/log/funcs.ha:18.
export fn println_v(args: fmt.formattable...) void = {
ensureinit_v();
lprintln_v(global_v, args...);
};
// lfatal_v — lprintln_v to `log` then exit(255). `never` return
// marks the bottom type so flow-control checks treat callers as
// terminated. Mirrors OLD lfatal (log.ww:216) +
// ref/hare/log/funcs.ha:28.
export fn lfatal_v(log: *vlogger, args: fmt.formattable...) never = {
lprintln_v(log, args...);
os.exit(255);
};
// fatal_v — lprintln_v to [[global_v]] then exit(255). Mirrors OLD
// fatal (log.ww:223) + ref/hare/log/funcs.ha:45.
export fn fatal_v(args: fmt.formattable...) never = {
println_v(args...);
os.exit(255);
};
// setlogger_v — install `log` as the [[global_v]] vlogger. Mirrors
// OLD setlogger (log.ww:230) + ref/hare/log/global.ha:20.
export fn setlogger_v(log: *vlogger) void = {
ensureinit_v();
global_v = log;
};
// lprintfln_v — dispatch a format-string record through `log`.
// Mirrors OLD lprintfln (log.ww:237) + ref/hare/log/funcs.ha:13.
export fn lprintfln_v(log: *vlogger, format: str, fields: fmt.field...) void = {
ensureinit_v();
log.printfln_v(log, format, fields...);
};
// printfln_v — dispatch through the [[global_v]] vlogger. Mirrors
// OLD printfln (log.ww:244) + ref/hare/log/funcs.ha:23.
export fn printfln_v(format: str, fields: fmt.field...) void = {
ensureinit_v();
lprintfln_v(global_v, format, fields...);
};
// lfatalf_v — lprintfln_v to `log` then exit(255). Mirrors OLD
// lfatalf (log.ww:251) + ref/hare/log/funcs.ha:35.
export fn lfatalf_v(log: *vlogger, format: str, fields: fmt.field...) never = {
lprintfln_v(log, format, fields...);
os.exit(255);
};
// fatalf_v — lprintfln_v to [[global_v]] then exit(255). Mirrors
// OLD fatalf (log.ww:258) + ref/hare/log/funcs.ha:52.
export fn fatalf_v(format: str, fields: fmt.field...) never = {
printfln_v(format, fields...);
os.exit(255);
};