lib: collapse the parallel vstream scaffold onto the single Hare io surface (#94 fold-eFinal)
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:
935
lib/fmt/fmt.ww
935
lib/fmt/fmt.ww
File diff suppressed because it is too large
Load Diff
@@ -30,168 +30,161 @@ fn streq(a: str, b: str) bool = {
|
||||
return true;
|
||||
};
|
||||
|
||||
// ---- A write-always-closed stream for the io.closed surfacing test ----
|
||||
// ---- an error-returning stream for the io.error surfacing test --------
|
||||
//
|
||||
// Replaces the OLD io.closed source. errvt is module-static; its
|
||||
// reader/writer return a nomem-widened io.error.
|
||||
let errvt: io.vtable;
|
||||
|
||||
fn closedread(s: *io.stream, buf: []u8) (i32 | io.eof | io.closed) = {
|
||||
let e: io.closed; return e;
|
||||
fn errread(s: io.stream, buf: []u8) (size | io.eof | io.error) = {
|
||||
let nm: nomem; let e: io.error = nm; return e;
|
||||
};
|
||||
fn closedwrite(s: *io.stream, buf: []u8) (i32 | io.closed) = {
|
||||
let e: io.closed; return e;
|
||||
fn errwrite(s: io.stream, buf: []u8) (size | io.error) = {
|
||||
let nm: nomem; let e: io.error = nm; return e;
|
||||
};
|
||||
fn closedclose(s: *io.stream) (void | io.closed) = { return; };
|
||||
|
||||
fn closedstream(s: *io.stream) void = {
|
||||
s.ctx = nil;
|
||||
s.read = closedread;
|
||||
s.write = closedwrite;
|
||||
s.close = closedclose;
|
||||
fn errsource() io.stream = {
|
||||
errvt.reader = (&errread): *io.reader;
|
||||
errvt.writer = (&errwrite): *io.writer;
|
||||
return &errvt;
|
||||
};
|
||||
|
||||
// ---- fprint: bare str --------------------------------------------------
|
||||
|
||||
@test fn fprintbarestr() void = {
|
||||
let mem: memio.state;
|
||||
let s: io.stream;
|
||||
memio.dynamic(&mem, &s);
|
||||
let mem: memio.stream = memio.dynamic();
|
||||
let s: io.stream = &mem.vt;
|
||||
|
||||
let r: (i32 | io.closed) = fmt.fprint(&s, "hello");
|
||||
let r: (size | io.error) = fmt.fprint(s, "hello");
|
||||
match (r) {
|
||||
case let n: i32 => { if (n != 5) { fail(); }; };
|
||||
case io.closed => fail();
|
||||
case let n: size => { if (n: i32 != 5) { fail(); }; };
|
||||
case let eioe: io.error => fail();
|
||||
};
|
||||
if (!streq(memio.string(&mem), "hello")) { fail(); };
|
||||
|
||||
let c: (void | io.closed) = io.close(&s);
|
||||
match (c) { case void => {}; case io.closed => fail(); };
|
||||
let c: (void | io.error) = io.close(s);
|
||||
match (c) { case void => {}; case let eioe: io.error => fail(); };
|
||||
};
|
||||
|
||||
// ---- fprint: int + str mix, space-separated ----------------------------
|
||||
|
||||
@test fn fprintintstr() void = {
|
||||
let mem: memio.state;
|
||||
let s: io.stream;
|
||||
memio.dynamic(&mem, &s);
|
||||
let mem: memio.stream = memio.dynamic();
|
||||
let s: io.stream = &mem.vt;
|
||||
|
||||
let r: (i32 | io.closed) = fmt.fprint(&s, 42i64, "x");
|
||||
let r: (size | io.error) = fmt.fprint(s, 42i64, "x");
|
||||
match (r) {
|
||||
case let n: i32 => { if (n != 4) { fail(); }; }; // "42 x"
|
||||
case io.closed => fail();
|
||||
case let n: size => { if (n: i32 != 4) { fail(); }; }; // "42 x"
|
||||
case let eioe: io.error => fail();
|
||||
};
|
||||
if (!streq(memio.string(&mem), "42 x")) { fail(); };
|
||||
|
||||
let c: (void | io.closed) = io.close(&s);
|
||||
match (c) { case void => {}; case io.closed => fail(); };
|
||||
let c: (void | io.error) = io.close(s);
|
||||
match (c) { case void => {}; case let eioe: io.error => fail(); };
|
||||
};
|
||||
|
||||
// ---- fprint: bool + rune renders as "true A" --------------------------
|
||||
|
||||
@test fn fprintboolrune() void = {
|
||||
let mem: memio.state;
|
||||
let s: io.stream;
|
||||
memio.dynamic(&mem, &s);
|
||||
let mem: memio.stream = memio.dynamic();
|
||||
let s: io.stream = &mem.vt;
|
||||
|
||||
let r: (i32 | io.closed) = fmt.fprint(&s, true, 'A': rune);
|
||||
let r: (size | io.error) = fmt.fprint(s, true, 'A': rune);
|
||||
match (r) {
|
||||
case let n: i32 => { if (n != 6) { fail(); }; }; // "true A"
|
||||
case io.closed => fail();
|
||||
case let n: size => { if (n: i32 != 6) { fail(); }; }; // "true A"
|
||||
case let eioe: io.error => fail();
|
||||
};
|
||||
if (!streq(memio.string(&mem), "true A")) { fail(); };
|
||||
|
||||
let c: (void | io.closed) = io.close(&s);
|
||||
match (c) { case void => {}; case io.closed => fail(); };
|
||||
let c: (void | io.error) = io.close(s);
|
||||
match (c) { case void => {}; case let eioe: io.error => fail(); };
|
||||
};
|
||||
|
||||
// ---- fprint: zero args returns 0, no bytes written --------------------
|
||||
|
||||
@test fn fprintempty() void = {
|
||||
let mem: memio.state;
|
||||
let s: io.stream;
|
||||
memio.dynamic(&mem, &s);
|
||||
let mem: memio.stream = memio.dynamic();
|
||||
let s: io.stream = &mem.vt;
|
||||
|
||||
let r: (i32 | io.closed) = fmt.fprint(&s);
|
||||
let r: (size | io.error) = fmt.fprint(s);
|
||||
match (r) {
|
||||
case let n: i32 => { if (n != 0) { fail(); }; };
|
||||
case io.closed => fail();
|
||||
case let n: size => { if (n: i32 != 0) { fail(); }; };
|
||||
case let eioe: io.error => fail();
|
||||
};
|
||||
if (memio.string(&mem).len != 0) { fail(); };
|
||||
|
||||
let c: (void | io.closed) = io.close(&s);
|
||||
match (c) { case void => {}; case io.closed => fail(); };
|
||||
let c: (void | io.error) = io.close(s);
|
||||
match (c) { case void => {}; case let eioe: io.error => fail(); };
|
||||
};
|
||||
|
||||
// ---- fprintln: multi-arg, trailing '\n' --------------------------------
|
||||
|
||||
@test fn fprintlnmulti() void = {
|
||||
let mem: memio.state;
|
||||
let s: io.stream;
|
||||
memio.dynamic(&mem, &s);
|
||||
let mem: memio.stream = memio.dynamic();
|
||||
let s: io.stream = &mem.vt;
|
||||
|
||||
let r: (i32 | io.closed) = fmt.fprintln(&s, "a", 1i64, false);
|
||||
let r: (size | io.error) = fmt.fprintln(s, "a", 1i64, false);
|
||||
match (r) {
|
||||
case let n: i32 => { if (n != 10) { fail(); }; }; // "a 1 false\n"
|
||||
case io.closed => fail();
|
||||
case let n: size => { if (n: i32 != 10) { fail(); }; }; // "a 1 false\n"
|
||||
case let eioe: io.error => fail();
|
||||
};
|
||||
if (!streq(memio.string(&mem), "a 1 false\n")) { fail(); };
|
||||
|
||||
let c: (void | io.closed) = io.close(&s);
|
||||
match (c) { case void => {}; case io.closed => fail(); };
|
||||
let c: (void | io.error) = io.close(s);
|
||||
match (c) { case void => {}; case let eioe: io.error => fail(); };
|
||||
};
|
||||
|
||||
// ---- fprintln: zero args writes just the newline ----------------------
|
||||
|
||||
@test fn fprintlnempty() void = {
|
||||
let mem: memio.state;
|
||||
let s: io.stream;
|
||||
memio.dynamic(&mem, &s);
|
||||
let mem: memio.stream = memio.dynamic();
|
||||
let s: io.stream = &mem.vt;
|
||||
|
||||
let r: (i32 | io.closed) = fmt.fprintln(&s);
|
||||
let r: (size | io.error) = fmt.fprintln(s);
|
||||
match (r) {
|
||||
case let n: i32 => { if (n != 1) { fail(); }; };
|
||||
case io.closed => fail();
|
||||
case let n: size => { if (n: i32 != 1) { fail(); }; };
|
||||
case let eioe: io.error => fail();
|
||||
};
|
||||
if (!streq(memio.string(&mem), "\n")) { fail(); };
|
||||
|
||||
let c: (void | io.closed) = io.close(&s);
|
||||
match (c) { case void => {}; case io.closed => fail(); };
|
||||
let c: (void | io.error) = io.close(s);
|
||||
match (c) { case void => {}; case let eioe: io.error => fail(); };
|
||||
};
|
||||
|
||||
// ---- fprint over a fixed stream: short writes return partial count ----
|
||||
// memio.fixedwrite caps each call at the remaining buffer space and
|
||||
// never closes the stream, so fprint sees a short i32 result, not
|
||||
// io.closed. Verifies the inner-loop arithmetic adds the actual byte
|
||||
// io.error. Verifies the inner-loop arithmetic adds the actual byte
|
||||
// count rather than the requested length.
|
||||
|
||||
@test fn fprintfixedshort() void = {
|
||||
let buf: [3]u8;
|
||||
let mem: memio.state;
|
||||
let s: io.stream;
|
||||
memio.fixed(&mem, &s, buf[0:3]);
|
||||
let mem: memio.stream = memio.fixed(buf[0:3]);
|
||||
let s: io.stream = &mem.vt;
|
||||
|
||||
let r: (i32 | io.closed) = fmt.fprint(&s, "hello");
|
||||
let r: (size | io.error) = fmt.fprint(s, "hello");
|
||||
match (r) {
|
||||
case let n: i32 => { if (n != 3) { fail(); }; };
|
||||
case io.closed => fail();
|
||||
case let n: size => { if (n: i32 != 3) { fail(); }; };
|
||||
case let eioe: io.error => fail();
|
||||
};
|
||||
if (!streq(memio.string(&mem), "hel")) { fail(); };
|
||||
|
||||
let c: (void | io.closed) = io.close(&s);
|
||||
match (c) { case void => {}; case io.closed => fail(); };
|
||||
let c: (void | io.error) = io.close(s);
|
||||
match (c) { case void => {}; case let eioe: io.error => fail(); };
|
||||
};
|
||||
|
||||
// ---- fprint over a closed stream surfaces io.closed -------------------
|
||||
// ---- fprint over a closed stream surfaces io.error -------------------
|
||||
// Exercises the early-return arm in fprint's inner match — distinct from
|
||||
// the short-write path above, which keeps returning i32 from a partial
|
||||
// accept. Single arm is enough: every formattable case routes errors
|
||||
// through the same putbytes / io.write wiring.
|
||||
|
||||
@test fn fprintclosed() void = {
|
||||
let s: io.stream;
|
||||
closedstream(&s);
|
||||
let s: io.stream = errsource();
|
||||
|
||||
let r: (i32 | io.closed) = fmt.fprint(&s, "x");
|
||||
let r: (size | io.error) = fmt.fprint(s, "x");
|
||||
match (r) {
|
||||
case let n: i32 => fail();
|
||||
case io.closed => {};
|
||||
case let n: size => fail();
|
||||
case let eioe: io.error => {};
|
||||
};
|
||||
};
|
||||
|
||||
@@ -201,203 +194,189 @@ fn closedstream(s: *io.stream) void = {
|
||||
// see the file header.
|
||||
|
||||
@test fn fprintf_implicit() void = {
|
||||
let mem: memio.state;
|
||||
let s: io.stream;
|
||||
memio.dynamic(&mem, &s);
|
||||
let r: (i32 | io.closed) = fmt.fprintf(&s, "hello {} {}", "world", 42i64);
|
||||
let mem: memio.stream = memio.dynamic();
|
||||
let s: io.stream = &mem.vt;
|
||||
let r: (size | io.error) = fmt.fprintf(s, "hello {} {}", "world", 42i64);
|
||||
match (r) {
|
||||
case let n: i32 => { if (n != 14) { fail(); }; };
|
||||
case io.closed => fail();
|
||||
case let n: size => { if (n: i32 != 14) { fail(); }; };
|
||||
case let eioe: io.error => fail();
|
||||
};
|
||||
if (!streq(memio.string(&mem), "hello world 42")) { fail(); };
|
||||
let c: (void | io.closed) = io.close(&s);
|
||||
match (c) { case void => {}; case io.closed => fail(); };
|
||||
let c: (void | io.error) = io.close(s);
|
||||
match (c) { case void => {}; case let eioe: io.error => fail(); };
|
||||
};
|
||||
|
||||
@test fn fprintf_indexed() void = {
|
||||
let mem: memio.state;
|
||||
let s: io.stream;
|
||||
memio.dynamic(&mem, &s);
|
||||
let r: (i32 | io.closed) = fmt.fprintf(&s, "{1} {0} {1}", "hello", "world");
|
||||
let mem: memio.stream = memio.dynamic();
|
||||
let s: io.stream = &mem.vt;
|
||||
let r: (size | io.error) = fmt.fprintf(s, "{1} {0} {1}", "hello", "world");
|
||||
match (r) {
|
||||
case let n: i32 => { if (n != 17) { fail(); }; };
|
||||
case io.closed => fail();
|
||||
case let n: size => { if (n: i32 != 17) { fail(); }; };
|
||||
case let eioe: io.error => fail();
|
||||
};
|
||||
if (!streq(memio.string(&mem), "world hello world")) { fail(); };
|
||||
let c: (void | io.closed) = io.close(&s);
|
||||
match (c) { case void => {}; case io.closed => fail(); };
|
||||
let c: (void | io.error) = io.close(s);
|
||||
match (c) { case void => {}; case let eioe: io.error => fail(); };
|
||||
};
|
||||
|
||||
@test fn fprintf_literal_braces() void = {
|
||||
let mem: memio.state;
|
||||
let s: io.stream;
|
||||
memio.dynamic(&mem, &s);
|
||||
let r: (i32 | io.closed) = fmt.fprintf(&s, "{{ {} }}", 1i64);
|
||||
let mem: memio.stream = memio.dynamic();
|
||||
let s: io.stream = &mem.vt;
|
||||
let r: (size | io.error) = fmt.fprintf(s, "{{ {} }}", 1i64);
|
||||
match (r) {
|
||||
case let n: i32 => { if (n != 5) { fail(); }; };
|
||||
case io.closed => fail();
|
||||
case let n: size => { if (n: i32 != 5) { fail(); }; };
|
||||
case let eioe: io.error => fail();
|
||||
};
|
||||
if (!streq(memio.string(&mem), "{ 1 }")) { fail(); };
|
||||
let c: (void | io.closed) = io.close(&s);
|
||||
match (c) { case void => {}; case io.closed => fail(); };
|
||||
let c: (void | io.error) = io.close(s);
|
||||
match (c) { case void => {}; case let eioe: io.error => fail(); };
|
||||
};
|
||||
|
||||
@test fn fprintf_width_right() void = {
|
||||
let mem: memio.state;
|
||||
let s: io.stream;
|
||||
memio.dynamic(&mem, &s);
|
||||
let r: (i32 | io.closed) = fmt.fprintf(&s, "{:5}", 42i64);
|
||||
let mem: memio.stream = memio.dynamic();
|
||||
let s: io.stream = &mem.vt;
|
||||
let r: (size | io.error) = fmt.fprintf(s, "{:5}", 42i64);
|
||||
match (r) {
|
||||
case let n: i32 => { if (n != 5) { fail(); }; };
|
||||
case io.closed => fail();
|
||||
case let n: size => { if (n: i32 != 5) { fail(); }; };
|
||||
case let eioe: io.error => fail();
|
||||
};
|
||||
if (!streq(memio.string(&mem), " 42")) { fail(); };
|
||||
let c: (void | io.closed) = io.close(&s);
|
||||
match (c) { case void => {}; case io.closed => fail(); };
|
||||
let c: (void | io.error) = io.close(s);
|
||||
match (c) { case void => {}; case let eioe: io.error => fail(); };
|
||||
};
|
||||
|
||||
@test fn fprintf_width_left() void = {
|
||||
let mem: memio.state;
|
||||
let s: io.stream;
|
||||
memio.dynamic(&mem, &s);
|
||||
let r: (i32 | io.closed) = fmt.fprintf(&s, "{:-5}", 42i64);
|
||||
let mem: memio.stream = memio.dynamic();
|
||||
let s: io.stream = &mem.vt;
|
||||
let r: (size | io.error) = fmt.fprintf(s, "{:-5}", 42i64);
|
||||
match (r) {
|
||||
case let n: i32 => { if (n != 5) { fail(); }; };
|
||||
case io.closed => fail();
|
||||
case let n: size => { if (n: i32 != 5) { fail(); }; };
|
||||
case let eioe: io.error => fail();
|
||||
};
|
||||
if (!streq(memio.string(&mem), "42 ")) { fail(); };
|
||||
let c: (void | io.closed) = io.close(&s);
|
||||
match (c) { case void => {}; case io.closed => fail(); };
|
||||
let c: (void | io.error) = io.close(s);
|
||||
match (c) { case void => {}; case let eioe: io.error => fail(); };
|
||||
};
|
||||
|
||||
@test fn fprintf_width_center() void = {
|
||||
let mem: memio.state;
|
||||
let s: io.stream;
|
||||
memio.dynamic(&mem, &s);
|
||||
let r: (i32 | io.closed) = fmt.fprintf(&s, "{:=5}", "hi");
|
||||
let mem: memio.stream = memio.dynamic();
|
||||
let s: io.stream = &mem.vt;
|
||||
let r: (size | io.error) = fmt.fprintf(s, "{:=5}", "hi");
|
||||
match (r) {
|
||||
case let n: i32 => { if (n != 5) { fail(); }; };
|
||||
case io.closed => fail();
|
||||
case let n: size => { if (n: i32 != 5) { fail(); }; };
|
||||
case let eioe: io.error => fail();
|
||||
};
|
||||
if (!streq(memio.string(&mem), " hi ")) { fail(); };
|
||||
let c: (void | io.closed) = io.close(&s);
|
||||
match (c) { case void => {}; case io.closed => fail(); };
|
||||
let c: (void | io.error) = io.close(s);
|
||||
match (c) { case void => {}; case let eioe: io.error => fail(); };
|
||||
};
|
||||
|
||||
@test fn fprintf_pad_underscore() void = {
|
||||
let mem: memio.state;
|
||||
let s: io.stream;
|
||||
memio.dynamic(&mem, &s);
|
||||
let r: (i32 | io.closed) = fmt.fprintf(&s, "{:_05}", "hi");
|
||||
let mem: memio.stream = memio.dynamic();
|
||||
let s: io.stream = &mem.vt;
|
||||
let r: (size | io.error) = fmt.fprintf(s, "{:_05}", "hi");
|
||||
match (r) {
|
||||
case let n: i32 => { if (n != 5) { fail(); }; };
|
||||
case io.closed => fail();
|
||||
case let n: size => { if (n: i32 != 5) { fail(); }; };
|
||||
case let eioe: io.error => fail();
|
||||
};
|
||||
if (!streq(memio.string(&mem), "000hi")) { fail(); };
|
||||
let c: (void | io.closed) = io.close(&s);
|
||||
match (c) { case void => {}; case io.closed => fail(); };
|
||||
let c: (void | io.error) = io.close(s);
|
||||
match (c) { case void => {}; case let eioe: io.error => fail(); };
|
||||
};
|
||||
|
||||
@test fn fprintf_base_hex() void = {
|
||||
let mem: memio.state;
|
||||
let s: io.stream;
|
||||
memio.dynamic(&mem, &s);
|
||||
let r: (i32 | io.closed) = fmt.fprintf(&s, "{:x} {:X}", 48879i64, 61453i64);
|
||||
let mem: memio.stream = memio.dynamic();
|
||||
let s: io.stream = &mem.vt;
|
||||
let r: (size | io.error) = fmt.fprintf(s, "{:x} {:X}", 48879i64, 61453i64);
|
||||
match (r) {
|
||||
case let n: i32 => { if (n != 9) { fail(); }; };
|
||||
case io.closed => fail();
|
||||
case let n: size => { if (n: i32 != 9) { fail(); }; };
|
||||
case let eioe: io.error => fail();
|
||||
};
|
||||
if (!streq(memio.string(&mem), "beef F00D")) { fail(); };
|
||||
let c: (void | io.closed) = io.close(&s);
|
||||
match (c) { case void => {}; case io.closed => fail(); };
|
||||
let c: (void | io.error) = io.close(s);
|
||||
match (c) { case void => {}; case let eioe: io.error => fail(); };
|
||||
};
|
||||
|
||||
@test fn fprintf_base_oct_bin() void = {
|
||||
let mem: memio.state;
|
||||
let s: io.stream;
|
||||
memio.dynamic(&mem, &s);
|
||||
let r: (i32 | io.closed) = fmt.fprintf(&s, "{:o} {:b}", 493i64, 27i64);
|
||||
let mem: memio.stream = memio.dynamic();
|
||||
let s: io.stream = &mem.vt;
|
||||
let r: (size | io.error) = fmt.fprintf(s, "{:o} {:b}", 493i64, 27i64);
|
||||
match (r) {
|
||||
case let n: i32 => { if (n != 9) { fail(); }; }; // "755 11011"
|
||||
case io.closed => fail();
|
||||
case let n: size => { if (n: i32 != 9) { fail(); }; }; // "755 11011"
|
||||
case let eioe: io.error => fail();
|
||||
};
|
||||
if (!streq(memio.string(&mem), "755 11011")) { fail(); };
|
||||
let c: (void | io.closed) = io.close(&s);
|
||||
match (c) { case void => {}; case io.closed => fail(); };
|
||||
let c: (void | io.error) = io.close(s);
|
||||
match (c) { case void => {}; case let eioe: io.error => fail(); };
|
||||
};
|
||||
|
||||
@test fn fprintf_prec_int() void = {
|
||||
let mem: memio.state;
|
||||
let s: io.stream;
|
||||
memio.dynamic(&mem, &s);
|
||||
let r: (i32 | io.closed) = fmt.fprintf(&s, "{:.5}", 42i64);
|
||||
let mem: memio.stream = memio.dynamic();
|
||||
let s: io.stream = &mem.vt;
|
||||
let r: (size | io.error) = fmt.fprintf(s, "{:.5}", 42i64);
|
||||
match (r) {
|
||||
case let n: i32 => { if (n != 5) { fail(); }; };
|
||||
case io.closed => fail();
|
||||
case let n: size => { if (n: i32 != 5) { fail(); }; };
|
||||
case let eioe: io.error => fail();
|
||||
};
|
||||
if (!streq(memio.string(&mem), "00042")) { fail(); };
|
||||
let c: (void | io.closed) = io.close(&s);
|
||||
match (c) { case void => {}; case io.closed => fail(); };
|
||||
let c: (void | io.error) = io.close(s);
|
||||
match (c) { case void => {}; case let eioe: io.error => fail(); };
|
||||
};
|
||||
|
||||
@test fn fprintf_prec_str_trunc() void = {
|
||||
let mem: memio.state;
|
||||
let s: io.stream;
|
||||
memio.dynamic(&mem, &s);
|
||||
let r: (i32 | io.closed) = fmt.fprintf(&s, "{:.3}", "hello");
|
||||
let mem: memio.stream = memio.dynamic();
|
||||
let s: io.stream = &mem.vt;
|
||||
let r: (size | io.error) = fmt.fprintf(s, "{:.3}", "hello");
|
||||
match (r) {
|
||||
case let n: i32 => { if (n != 3) { fail(); }; };
|
||||
case io.closed => fail();
|
||||
case let n: size => { if (n: i32 != 3) { fail(); }; };
|
||||
case let eioe: io.error => fail();
|
||||
};
|
||||
if (!streq(memio.string(&mem), "hel")) { fail(); };
|
||||
let c: (void | io.closed) = io.close(&s);
|
||||
match (c) { case void => {}; case io.closed => fail(); };
|
||||
let c: (void | io.error) = io.close(s);
|
||||
match (c) { case void => {}; case let eioe: io.error => fail(); };
|
||||
};
|
||||
|
||||
@test fn fprintf_sign_neg() void = {
|
||||
let mem: memio.state;
|
||||
let s: io.stream;
|
||||
memio.dynamic(&mem, &s);
|
||||
let r: (i32 | io.closed) = fmt.fprintf(&s, "{} {:+} {: }", -7i64, 7i64, 7i64);
|
||||
let mem: memio.stream = memio.dynamic();
|
||||
let s: io.stream = &mem.vt;
|
||||
let r: (size | io.error) = fmt.fprintf(s, "{} {:+} {: }", -7i64, 7i64, 7i64);
|
||||
match (r) {
|
||||
case let n: i32 => { if (n != 8) { fail(); }; }; // "-7 +7 7"
|
||||
case io.closed => fail();
|
||||
case let n: size => { if (n: i32 != 8) { fail(); }; }; // "-7 +7 7"
|
||||
case let eioe: io.error => fail();
|
||||
};
|
||||
if (!streq(memio.string(&mem), "-7 +7 7")) { fail(); };
|
||||
let c: (void | io.closed) = io.close(&s);
|
||||
match (c) { case void => {}; case io.closed => fail(); };
|
||||
let c: (void | io.error) = io.close(s);
|
||||
match (c) { case void => {}; case let eioe: io.error => fail(); };
|
||||
};
|
||||
|
||||
@test fn fprintfln_basic() void = {
|
||||
let mem: memio.state;
|
||||
let s: io.stream;
|
||||
memio.dynamic(&mem, &s);
|
||||
let r: (i32 | io.closed) = fmt.fprintfln(&s, "x={}", 9i64);
|
||||
let mem: memio.stream = memio.dynamic();
|
||||
let s: io.stream = &mem.vt;
|
||||
let r: (size | io.error) = fmt.fprintfln(s, "x={}", 9i64);
|
||||
match (r) {
|
||||
case let n: i32 => { if (n != 4) { fail(); }; }; // "x=9\n"
|
||||
case io.closed => fail();
|
||||
case let n: size => { if (n: i32 != 4) { fail(); }; }; // "x=9\n"
|
||||
case let eioe: io.error => fail();
|
||||
};
|
||||
if (!streq(memio.string(&mem), "x=9\n")) { fail(); };
|
||||
let c: (void | io.closed) = io.close(&s);
|
||||
match (c) { case void => {}; case io.closed => fail(); };
|
||||
let c: (void | io.error) = io.close(s);
|
||||
match (c) { case void => {}; case let eioe: io.error => fail(); };
|
||||
};
|
||||
|
||||
@test fn fprintf_closed() void = {
|
||||
let s: io.stream;
|
||||
closedstream(&s);
|
||||
let r: (i32 | io.closed) = fmt.fprintf(&s, "hello {}", 1i64);
|
||||
let s: io.stream = errsource();
|
||||
let r: (size | io.error) = fmt.fprintf(s, "hello {}", 1i64);
|
||||
match (r) {
|
||||
case let n: i32 => fail();
|
||||
case io.closed => {};
|
||||
case let n: size => fail();
|
||||
case let eioe: io.error => {};
|
||||
};
|
||||
};
|
||||
|
||||
@test fn bsprintf_basic() void = {
|
||||
let buf: [16]u8;
|
||||
let r: (str | io.closed) = fmt.bsprintf(buf[0:16], "{} {}", "hi", 42i64);
|
||||
let r: (str | io.error) = fmt.bsprintf(buf[0:16], "{} {}", "hi", 42i64);
|
||||
match (r) {
|
||||
case let s: str => { if (!streq(s, "hi 42")) { fail(); }; };
|
||||
case io.closed => fail();
|
||||
case let eioe: io.error => fail();
|
||||
};
|
||||
};
|
||||
|
||||
@@ -407,29 +386,28 @@ fn closedstream(s: *io.stream) void = {
|
||||
// tagged arms so a future task-#18 fix that re-introduces the 24B
|
||||
// widen-by-value cannot regress silently.
|
||||
@test fn fprintf_bool_rune() void = {
|
||||
let mem: memio.state;
|
||||
let s: io.stream;
|
||||
memio.dynamic(&mem, &s);
|
||||
let r: (i32 | io.closed) = fmt.fprintf(&s, "{} {}", true, 'A': rune);
|
||||
let mem: memio.stream = memio.dynamic();
|
||||
let s: io.stream = &mem.vt;
|
||||
let r: (size | io.error) = fmt.fprintf(s, "{} {}", true, 'A': rune);
|
||||
match (r) {
|
||||
case let n: i32 => { if (n != 6) { fail(); }; }; // "true A"
|
||||
case io.closed => fail();
|
||||
case let n: size => { if (n: i32 != 6) { fail(); }; }; // "true A"
|
||||
case let eioe: io.error => fail();
|
||||
};
|
||||
if (!streq(memio.string(&mem), "true A")) { fail(); };
|
||||
let c: (void | io.closed) = io.close(&s);
|
||||
match (c) { case void => {}; case io.closed => fail(); };
|
||||
let c: (void | io.error) = io.close(s);
|
||||
match (c) { case void => {}; case let eioe: io.error => fail(); };
|
||||
};
|
||||
|
||||
// Verifies bsprintf's documented truncation contract — short writes
|
||||
// return the prefix that fit (memio.fixedwrite returns 0 once full,
|
||||
// not io.closed). Pairs with fprintfixedshort above which covers the
|
||||
// not io.error). Pairs with fprintfixedshort above which covers the
|
||||
// underlying fprint path.
|
||||
@test fn bsprintf_trunc() void = {
|
||||
let buf: [3]u8;
|
||||
let r: (str | io.closed) = fmt.bsprintf(buf[0:3], "{} {}", "hi", 42i64);
|
||||
let r: (str | io.error) = fmt.bsprintf(buf[0:3], "{} {}", "hi", 42i64);
|
||||
match (r) {
|
||||
case let s: str => { if (!streq(s, "hi ")) { fail(); }; };
|
||||
case io.closed => fail();
|
||||
case let eioe: io.error => fail();
|
||||
};
|
||||
};
|
||||
|
||||
@@ -440,10 +418,10 @@ fn closedstream(s: *io.stream) void = {
|
||||
// formatraw + tail-pad both write 0 — must terminate.
|
||||
@test fn bsprintf_width_trunc() void = {
|
||||
let buf: [3]u8;
|
||||
let r: (str | io.closed) = fmt.bsprintf(buf[0:3], "{:5}", 42i64);
|
||||
let r: (str | io.error) = fmt.bsprintf(buf[0:3], "{:5}", 42i64);
|
||||
match (r) {
|
||||
case let s: str => { if (!streq(s, " ")) { fail(); }; };
|
||||
case io.closed => fail();
|
||||
case let eioe: io.error => fail();
|
||||
};
|
||||
};
|
||||
|
||||
@@ -494,173 +472,162 @@ fn closedstream(s: *io.stream) void = {
|
||||
// `prec` and `base` ignored — graduate when strconv grows ffmt/fflags.
|
||||
|
||||
@test fn fprintf_f64_basic() void = {
|
||||
let mem: memio.state;
|
||||
let s: io.stream;
|
||||
memio.dynamic(&mem, &s);
|
||||
let r: (i32 | io.closed) = fmt.fprintf(&s, "{}", 1.5);
|
||||
let mem: memio.stream = memio.dynamic();
|
||||
let s: io.stream = &mem.vt;
|
||||
let r: (size | io.error) = fmt.fprintf(s, "{}", 1.5);
|
||||
match (r) {
|
||||
case let n: i32 => { if (n != 3) { fail(); }; };
|
||||
case io.closed => fail();
|
||||
case let n: size => { if (n: i32 != 3) { fail(); }; };
|
||||
case let eioe: io.error => fail();
|
||||
};
|
||||
if (!streq(memio.string(&mem), "1.5")) { fail(); };
|
||||
let c: (void | io.closed) = io.close(&s);
|
||||
match (c) { case void => {}; case io.closed => fail(); };
|
||||
let c: (void | io.error) = io.close(s);
|
||||
match (c) { case void => {}; case let eioe: io.error => fail(); };
|
||||
};
|
||||
|
||||
@test fn fprintf_f64_int_valued() void = {
|
||||
let mem: memio.state;
|
||||
let s: io.stream;
|
||||
memio.dynamic(&mem, &s);
|
||||
let r: (i32 | io.closed) = fmt.fprintf(&s, "{}", 1.0);
|
||||
let mem: memio.stream = memio.dynamic();
|
||||
let s: io.stream = &mem.vt;
|
||||
let r: (size | io.error) = fmt.fprintf(s, "{}", 1.0);
|
||||
match (r) {
|
||||
case let n: i32 => { if (n != 1) { fail(); }; };
|
||||
case io.closed => fail();
|
||||
case let n: size => { if (n: i32 != 1) { fail(); }; };
|
||||
case let eioe: io.error => fail();
|
||||
};
|
||||
if (!streq(memio.string(&mem), "1")) { fail(); };
|
||||
let c: (void | io.closed) = io.close(&s);
|
||||
match (c) { case void => {}; case io.closed => fail(); };
|
||||
let c: (void | io.error) = io.close(s);
|
||||
match (c) { case void => {}; case let eioe: io.error => fail(); };
|
||||
};
|
||||
|
||||
@test fn fprintf_f64_neg() void = {
|
||||
let mem: memio.state;
|
||||
let s: io.stream;
|
||||
memio.dynamic(&mem, &s);
|
||||
let r: (i32 | io.closed) = fmt.fprintf(&s, "{}", -2.5);
|
||||
let mem: memio.stream = memio.dynamic();
|
||||
let s: io.stream = &mem.vt;
|
||||
let r: (size | io.error) = fmt.fprintf(s, "{}", -2.5);
|
||||
match (r) {
|
||||
case let n: i32 => { if (n != 4) { fail(); }; };
|
||||
case io.closed => fail();
|
||||
case let n: size => { if (n: i32 != 4) { fail(); }; };
|
||||
case let eioe: io.error => fail();
|
||||
};
|
||||
if (!streq(memio.string(&mem), "-2.5")) { fail(); };
|
||||
let c: (void | io.closed) = io.close(&s);
|
||||
match (c) { case void => {}; case io.closed => fail(); };
|
||||
let c: (void | io.error) = io.close(s);
|
||||
match (c) { case void => {}; case let eioe: io.error => fail(); };
|
||||
};
|
||||
|
||||
@test fn fprintf_f64_zero() void = {
|
||||
let mem: memio.state;
|
||||
let s: io.stream;
|
||||
memio.dynamic(&mem, &s);
|
||||
let r: (i32 | io.closed) = fmt.fprintf(&s, "{}", 0.0);
|
||||
let mem: memio.stream = memio.dynamic();
|
||||
let s: io.stream = &mem.vt;
|
||||
let r: (size | io.error) = fmt.fprintf(s, "{}", 0.0);
|
||||
match (r) {
|
||||
case let n: i32 => { if (n != 1) { fail(); }; };
|
||||
case io.closed => fail();
|
||||
case let n: size => { if (n: i32 != 1) { fail(); }; };
|
||||
case let eioe: io.error => fail();
|
||||
};
|
||||
if (!streq(memio.string(&mem), "0")) { fail(); };
|
||||
let c: (void | io.closed) = io.close(&s);
|
||||
match (c) { case void => {}; case io.closed => fail(); };
|
||||
let c: (void | io.error) = io.close(s);
|
||||
match (c) { case void => {}; case let eioe: io.error => fail(); };
|
||||
};
|
||||
|
||||
@test fn fprintf_f64_small_frac() void = {
|
||||
let mem: memio.state;
|
||||
let s: io.stream;
|
||||
memio.dynamic(&mem, &s);
|
||||
let r: (i32 | io.closed) = fmt.fprintf(&s, "{}", 0.05);
|
||||
let mem: memio.stream = memio.dynamic();
|
||||
let s: io.stream = &mem.vt;
|
||||
let r: (size | io.error) = fmt.fprintf(s, "{}", 0.05);
|
||||
match (r) {
|
||||
case let n: i32 => { if (n != 4) { fail(); }; };
|
||||
case io.closed => fail();
|
||||
case let n: size => { if (n: i32 != 4) { fail(); }; };
|
||||
case let eioe: io.error => fail();
|
||||
};
|
||||
if (!streq(memio.string(&mem), "0.05")) { fail(); };
|
||||
let c: (void | io.closed) = io.close(&s);
|
||||
match (c) { case void => {}; case io.closed => fail(); };
|
||||
let c: (void | io.error) = io.close(s);
|
||||
match (c) { case void => {}; case let eioe: io.error => fail(); };
|
||||
};
|
||||
|
||||
// Pins a large magnitude through the fmt dispatch — post-Ryū-graduation
|
||||
// (fold-5) this is scientific notation, not the old lossy "huge" fallback.
|
||||
// Catches any regression where mods accidentally pre-truncate the view.
|
||||
@test fn fprintf_f64_huge() void = {
|
||||
let mem: memio.state;
|
||||
let s: io.stream;
|
||||
memio.dynamic(&mem, &s);
|
||||
let r: (i32 | io.closed) = fmt.fprintf(&s, "{}", 9.5e18);
|
||||
let mem: memio.stream = memio.dynamic();
|
||||
let s: io.stream = &mem.vt;
|
||||
let r: (size | io.error) = fmt.fprintf(s, "{}", 9.5e18);
|
||||
match (r) {
|
||||
case let n: i32 => { if (n != 6) { fail(); }; }; // "9.5e18"
|
||||
case io.closed => fail();
|
||||
case let n: size => { if (n: i32 != 6) { fail(); }; }; // "9.5e18"
|
||||
case let eioe: io.error => fail();
|
||||
};
|
||||
if (!streq(memio.string(&mem), "9.5e18")) { fail(); };
|
||||
let c: (void | io.closed) = io.close(&s);
|
||||
match (c) { case void => {}; case io.closed => fail(); };
|
||||
let c: (void | io.error) = io.close(s);
|
||||
match (c) { case void => {}; case let eioe: io.error => fail(); };
|
||||
};
|
||||
|
||||
// Sign-mod fold: '+' on positive, '-' still wins on negative (the
|
||||
// natural '-' from strconv is peeled and signof reapplies).
|
||||
@test fn fprintf_f64_sign_plus() void = {
|
||||
let mem: memio.state;
|
||||
let s: io.stream;
|
||||
memio.dynamic(&mem, &s);
|
||||
let r: (i32 | io.closed) = fmt.fprintf(&s, "{:+} {:+}", 1.5, -1.5);
|
||||
let mem: memio.stream = memio.dynamic();
|
||||
let s: io.stream = &mem.vt;
|
||||
let r: (size | io.error) = fmt.fprintf(s, "{:+} {:+}", 1.5, -1.5);
|
||||
match (r) {
|
||||
case let n: i32 => { if (n != 9) { fail(); }; }; // "+1.5 -1.5"
|
||||
case io.closed => fail();
|
||||
case let n: size => { if (n: i32 != 9) { fail(); }; }; // "+1.5 -1.5"
|
||||
case let eioe: io.error => fail();
|
||||
};
|
||||
if (!streq(memio.string(&mem), "+1.5 -1.5")) { fail(); };
|
||||
let c: (void | io.closed) = io.close(&s);
|
||||
match (c) { case void => {}; case io.closed => fail(); };
|
||||
let c: (void | io.error) = io.close(s);
|
||||
match (c) { case void => {}; case let eioe: io.error => fail(); };
|
||||
};
|
||||
|
||||
@test fn fprintf_f64_sign_space() void = {
|
||||
let mem: memio.state;
|
||||
let s: io.stream;
|
||||
memio.dynamic(&mem, &s);
|
||||
let r: (i32 | io.closed) = fmt.fprintf(&s, "{: }", 1.5);
|
||||
let mem: memio.stream = memio.dynamic();
|
||||
let s: io.stream = &mem.vt;
|
||||
let r: (size | io.error) = fmt.fprintf(s, "{: }", 1.5);
|
||||
match (r) {
|
||||
case let n: i32 => { if (n != 4) { fail(); }; };
|
||||
case io.closed => fail();
|
||||
case let n: size => { if (n: i32 != 4) { fail(); }; };
|
||||
case let eioe: io.error => fail();
|
||||
};
|
||||
if (!streq(memio.string(&mem), " 1.5")) { fail(); };
|
||||
let c: (void | io.closed) = io.close(&s);
|
||||
match (c) { case void => {}; case io.closed => fail(); };
|
||||
let c: (void | io.error) = io.close(s);
|
||||
match (c) { case void => {}; case let eioe: io.error => fail(); };
|
||||
};
|
||||
|
||||
// Width + alignment round-trip through rawlenf64 (sign-aware len count).
|
||||
@test fn fprintf_f64_width_right() void = {
|
||||
let mem: memio.state;
|
||||
let s: io.stream;
|
||||
memio.dynamic(&mem, &s);
|
||||
let r: (i32 | io.closed) = fmt.fprintf(&s, "{:8}", 1.5);
|
||||
let mem: memio.stream = memio.dynamic();
|
||||
let s: io.stream = &mem.vt;
|
||||
let r: (size | io.error) = fmt.fprintf(s, "{:8}", 1.5);
|
||||
match (r) {
|
||||
case let n: i32 => { if (n != 8) { fail(); }; };
|
||||
case io.closed => fail();
|
||||
case let n: size => { if (n: i32 != 8) { fail(); }; };
|
||||
case let eioe: io.error => fail();
|
||||
};
|
||||
if (!streq(memio.string(&mem), " 1.5")) { fail(); };
|
||||
let c: (void | io.closed) = io.close(&s);
|
||||
match (c) { case void => {}; case io.closed => fail(); };
|
||||
let c: (void | io.error) = io.close(s);
|
||||
match (c) { case void => {}; case let eioe: io.error => fail(); };
|
||||
};
|
||||
|
||||
@test fn fprintf_f64_width_left() void = {
|
||||
let mem: memio.state;
|
||||
let s: io.stream;
|
||||
memio.dynamic(&mem, &s);
|
||||
let r: (i32 | io.closed) = fmt.fprintf(&s, "{:-8}", 1.5);
|
||||
let mem: memio.stream = memio.dynamic();
|
||||
let s: io.stream = &mem.vt;
|
||||
let r: (size | io.error) = fmt.fprintf(s, "{:-8}", 1.5);
|
||||
match (r) {
|
||||
case let n: i32 => { if (n != 8) { fail(); }; };
|
||||
case io.closed => fail();
|
||||
case let n: size => { if (n: i32 != 8) { fail(); }; };
|
||||
case let eioe: io.error => fail();
|
||||
};
|
||||
if (!streq(memio.string(&mem), "1.5 ")) { fail(); };
|
||||
let c: (void | io.closed) = io.close(&s);
|
||||
match (c) { case void => {}; case io.closed => fail(); };
|
||||
let c: (void | io.error) = io.close(s);
|
||||
match (c) { case void => {}; case let eioe: io.error => fail(); };
|
||||
};
|
||||
|
||||
// Legacy fprint variadic — covers the non-printf surface arm (where
|
||||
// formatraw isn't reached because there's no mods parser).
|
||||
@test fn fprint_f64_variadic() void = {
|
||||
let mem: memio.state;
|
||||
let s: io.stream;
|
||||
memio.dynamic(&mem, &s);
|
||||
let r: (i32 | io.closed) = fmt.fprint(&s, 1.5, "x");
|
||||
let mem: memio.stream = memio.dynamic();
|
||||
let s: io.stream = &mem.vt;
|
||||
let r: (size | io.error) = fmt.fprint(s, 1.5, "x");
|
||||
match (r) {
|
||||
case let n: i32 => { if (n != 5) { fail(); }; }; // "1.5 x"
|
||||
case io.closed => fail();
|
||||
case let n: size => { if (n: i32 != 5) { fail(); }; }; // "1.5 x"
|
||||
case let eioe: io.error => fail();
|
||||
};
|
||||
if (!streq(memio.string(&mem), "1.5 x")) { fail(); };
|
||||
let c: (void | io.closed) = io.close(&s);
|
||||
match (c) { case void => {}; case io.closed => fail(); };
|
||||
let c: (void | io.error) = io.close(s);
|
||||
match (c) { case void => {}; case let eioe: io.error => fail(); };
|
||||
};
|
||||
|
||||
@test fn bsprintf_f64() void = {
|
||||
let buf: [16]u8;
|
||||
let r: (str | io.closed) = fmt.bsprintf(buf[0:16], "x={}", 1.5);
|
||||
let r: (str | io.error) = fmt.bsprintf(buf[0:16], "x={}", 1.5);
|
||||
match (r) {
|
||||
case let s: str => { if (!streq(s, "x=1.5")) { fail(); }; };
|
||||
case io.closed => fail();
|
||||
case let eioe: io.error => fail();
|
||||
};
|
||||
};
|
||||
|
||||
|
||||
@@ -1,667 +0,0 @@
|
||||
// vstream — Hare-shaped vtable wrappers over an fd sink. Project #94
|
||||
// fold-e3 (Option C, parallel API for lib/fmt).
|
||||
//
|
||||
// Adds four wrappers that take a raw fd and dispatch through an
|
||||
// [[io.vstream]] (= `*io.vtable`, the Hare-shape from
|
||||
// lib/io/stream.ww) alongside the pre-vtable fdprint / fdprintln /
|
||||
// fdprintf / fdprintfln in fmt.ww. The OLD surface stays untouched
|
||||
// here — fold-eFinal (task #50) atomically flips the package shape:
|
||||
// deletes the OLD wrappers + callbacks, renames `_v` suffix off, and
|
||||
// migrates the few callers.
|
||||
//
|
||||
// Hare routes fmt's fd sinks through `io::handle = (io::file | int)`
|
||||
// (ref/hare/fmt/wrappers.ha:9-25); ww doesn't have the handle sum yet
|
||||
// so the pure-vstream sink — drew-deferred per fold-d/fold-e3 —
|
||||
// stands in until io fold-2 lands the handle port. fd_ctx is the
|
||||
// minimum carrier: one tagged field (vt) + one i32 (fd). Single-
|
||||
// tagged-field shape lets direct struct-lit init through (sibling
|
||||
// task #207 only bites multi-tagged-field copies); ken's escape-risk
|
||||
// discipline holds — every wrapper stack-allocates fd_ctx inside its
|
||||
// own frame, gets `vs = &c.vt` from the same frame, and dispatches
|
||||
// without returning &c outside it.
|
||||
//
|
||||
// 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
|
||||
// uses (2 cast tokens here at the vtable wire-up site; both drop out
|
||||
// wholesale once #206 closes).
|
||||
//
|
||||
// Dispatch chain (per wrapper):
|
||||
// fd{print,println,printf,printfln}_v
|
||||
// → vfprint / vfprintf (internal vstream-side formatter)
|
||||
// → io.st_write(vs, buf)
|
||||
// → vs.writer (= fdsinkwrite_v after the cast)
|
||||
// → os.write(c.fd, ...)
|
||||
//
|
||||
// The internal vfprint/vfprintf duplicate the per-arg and {n}-
|
||||
// placeholder loops from fmt.ww (fprint at line 177, fprintf at 676)
|
||||
// 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`, `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):
|
||||
//
|
||||
// - io fold-2 (handle port): drew-deferred. Hare's
|
||||
// ref/hare/fmt/wrappers.ha:9-25 routes through io::handle;
|
||||
// fdNNN_v collapses into bare fNNN_v once handle = (file | int)
|
||||
// lands and the V API graduates over the OLD per-fd surface.
|
||||
// - #206 (bare &fn → (*alias|void)): 2 cast sites here; drops
|
||||
// out wholesale on close.
|
||||
// - #173 (TRY-on-tagged-return both-stages broken): fdsinkwrite_v
|
||||
// constructs nomem and widens to io.error explicitly rather
|
||||
// than using `os.trywrite(...)?`; same shape memio.vstream.ww
|
||||
// adopted at line 71-74.
|
||||
|
||||
package fmt;
|
||||
|
||||
import io;
|
||||
import memio;
|
||||
import os;
|
||||
import strconv;
|
||||
import strings;
|
||||
|
||||
// fd_ctx — vt at offset 0 for the intrusive vstream→*fd_ctx cast.
|
||||
// Mirrors lib/memio.fixed_ctx (memio/vstream.ww:48); single tagged
|
||||
// field (vt) means the multi-tagged-field drop in #207 doesn't bite.
|
||||
export type fd_ctx = struct {
|
||||
vt: io.vtable,
|
||||
fd: i32,
|
||||
};
|
||||
|
||||
// fdsinkread_v — eof-only sink; the fd half of fmt is write-only.
|
||||
// Mirrors OLD fdsinkread (fmt.ww:765). The unused-`buf` parameter
|
||||
// matches io.reader's signature.
|
||||
fn fdsinkread_v(s: io.vstream, buf: []u8) (size | io.eof | io.error) = {
|
||||
let e: io.eof;
|
||||
return e;
|
||||
};
|
||||
|
||||
// fdsinkwrite_v — recover fd via intrusive cast, dispatch one
|
||||
// os.write. -errno collapses to a nomem-widened io.error: the OLD
|
||||
// fdsinkwrite (fmt.ww:768) flattens this to io.closed; we keep the
|
||||
// Hare-shape error here because the V surface returns io.error
|
||||
// directly. Construction-then-widen (vs `os.trywrite(...)?`)
|
||||
// sidesteps #173 same as memio.vstream.ww (line 71-74 note).
|
||||
fn fdsinkwrite_v(s: io.vstream, buf: []u8) (size | io.error) = {
|
||||
let c: *fd_ctx = s: *fd_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;
|
||||
};
|
||||
|
||||
// ---- internal vstream-side formatters -------------------------------
|
||||
|
||||
// vputbytes — io.st_write(vs, [ptr..ptr+n)). Internal helper; the
|
||||
// inline `let v` slice synthesis mirrors fmt.putbytes (fmt.ww:160)
|
||||
// for the legacy *io.stream sink.
|
||||
fn vputbytes(vs: io.vstream, p: *u8, n: i32) (size | io.error) = {
|
||||
let v: []u8;
|
||||
v.ptr = p;
|
||||
v.len = n;
|
||||
return io.st_write(vs, v);
|
||||
};
|
||||
|
||||
// vwriteone — emit one formattable through io.st_write. Mirror of
|
||||
// the per-arm dispatch in fmt.fdprint (fmt.ww:103-138) and fmt.fprint
|
||||
// (fmt.ww:188-234); shape matches OLD modulo the (size | io.error)
|
||||
// return instead of i64 / (i32 | io.closed).
|
||||
fn vwriteone(vs: io.vstream, a: formattable) (size | io.error) = {
|
||||
match (a) {
|
||||
case let n: i64 => {
|
||||
let s: str = i64dec(n);
|
||||
return vputbytes(vs, s.ptr, s.len);
|
||||
};
|
||||
case let s: str => return vputbytes(vs, s.ptr, s.len);
|
||||
case let b: bool => {
|
||||
let s: str = "false";
|
||||
if (b) { s = "true"; };
|
||||
return vputbytes(vs, s.ptr, s.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 static-buffer view consumed before next
|
||||
// strconv call — same shape as fmt.fdprint (fmt.ww:130).
|
||||
let s: str = strconv.f64tos(v);
|
||||
return vputbytes(vs, s.ptr, s.len);
|
||||
};
|
||||
};
|
||||
return 0: size;
|
||||
};
|
||||
|
||||
// ---- 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). #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 vformatone(vs, a, m);
|
||||
};
|
||||
case let v: str => {
|
||||
let a: formattable = v;
|
||||
return vformatone(vs, a, m);
|
||||
};
|
||||
case let b: bool => {
|
||||
let a: formattable = b;
|
||||
return vformatone(vs, a, m);
|
||||
};
|
||||
case let r: rune => {
|
||||
let a: formattable = r;
|
||||
return vformatone(vs, a, m);
|
||||
};
|
||||
case let v: f64 => {
|
||||
let a: formattable = v;
|
||||
return vformatone(vs, a, m);
|
||||
};
|
||||
case let p: *mods => { fmtabort(); let z: size = 0; return z; };
|
||||
};
|
||||
};
|
||||
|
||||
// vfprint — vstream-side fprint. Mirror of fmt.fprint (fmt.ww:177).
|
||||
// Per-arg loop with a space separator; returns total bytes written
|
||||
// or the first io.error. Exported so lib/log's V API (fold-e5) can
|
||||
// dispatch through it; eFinal (#50) collapses fprint over the unified
|
||||
// surface.
|
||||
export fn vfprint(vs: io.vstream, args: formattable...) (size | io.error) = {
|
||||
let total: size = 0;
|
||||
let i: i32 = 0;
|
||||
for (i < args.len) {
|
||||
if (i > 0) {
|
||||
let r: (size | io.error) = vputbytes(vs, " ".ptr, 1);
|
||||
match (r) {
|
||||
case let n: size => { total += n; };
|
||||
case let e: io.error => return e;
|
||||
};
|
||||
};
|
||||
let r: (size | io.error) = vwriteone(vs, args[i]);
|
||||
match (r) {
|
||||
case let n: size => { total += n; };
|
||||
case let e: io.error => return e;
|
||||
};
|
||||
i += 1;
|
||||
};
|
||||
return total;
|
||||
};
|
||||
|
||||
// vfprintf — vstream-side fprintf. Mirror of fmt.fprintf (fmt.ww:676).
|
||||
// {n}-placeholder parser routed through vformatfield + vputbytes
|
||||
// instead of fmt.formatfield + fmt.putbytes; the placeholder language
|
||||
// (incl. `{N:mods}` modifier subset) is identical — scandigits /
|
||||
// scanmods / modsinit reused directly from fmt.ww. Exported (same
|
||||
// rationale as vfprint above) so lib/log's V API dispatches through it.
|
||||
export fn vfprintf(vs: io.vstream, fmt: str, args: field...) (size | io.error) = {
|
||||
let total: size = 0;
|
||||
let i: i32 = 0;
|
||||
let nextimpl: i32 = 0;
|
||||
let checkunused: bool = true;
|
||||
for (i < fmt.len) {
|
||||
let c: u8 = fmt[i];
|
||||
if (c == 123u8) { // '{'
|
||||
i += 1;
|
||||
if (i >= fmt.len) { fmtabort(); };
|
||||
if (fmt[i] == 123u8) { // '{{' literal
|
||||
let r: (size | io.error) = vputbytes(vs, fmt.ptr + i: u64, 1);
|
||||
match (r) {
|
||||
case let n: size => { total += n; };
|
||||
case let e: io.error => return e;
|
||||
};
|
||||
i += 1;
|
||||
} else {
|
||||
let idx: i32 = 0;
|
||||
let d: u8 = fmt[i];
|
||||
if (d >= 48u8 && d <= 57u8) {
|
||||
checkunused = false;
|
||||
idx = scandigits(fmt, &i);
|
||||
} else {
|
||||
idx = nextimpl;
|
||||
nextimpl += 1;
|
||||
};
|
||||
let m: mods;
|
||||
modsinit(&m);
|
||||
if (i < fmt.len && fmt[i] == 58u8) { // ':'
|
||||
i += 1;
|
||||
scanmods(fmt, &i, &m);
|
||||
};
|
||||
if (i >= fmt.len || fmt[i] != 125u8) { fmtabort(); };
|
||||
i += 1;
|
||||
if (idx >= args.len) { fmtabort(); };
|
||||
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;
|
||||
};
|
||||
};
|
||||
} else if (c == 125u8) { // '}'
|
||||
i += 1;
|
||||
if (i >= fmt.len || fmt[i] != 125u8) { fmtabort(); };
|
||||
let r: (size | io.error) = vputbytes(vs, fmt.ptr + i: u64, 1);
|
||||
match (r) {
|
||||
case let n: size => { total += n; };
|
||||
case let e: io.error => return e;
|
||||
};
|
||||
i += 1;
|
||||
} else {
|
||||
let r: (size | io.error) = vputbytes(vs, fmt.ptr + i: u64, 1);
|
||||
match (r) {
|
||||
case let n: size => { total += n; };
|
||||
case let e: io.error => return e;
|
||||
};
|
||||
i += 1;
|
||||
};
|
||||
};
|
||||
if (checkunused && nextimpl != args.len) { fmtabort(); };
|
||||
return total;
|
||||
};
|
||||
|
||||
// ---- public fd-sink wrappers (V API) ---------------------------------
|
||||
|
||||
// fdprint_v — fdprint over io.vstream. Stack-allocates fd_ctx; the
|
||||
// &c.vt vstream pointer never escapes this frame (ken's escape-risk
|
||||
// discipline). Mirrors fmt.fdprint (fmt.ww:94).
|
||||
export fn fdprint_v(fd: i32, args: formattable...) (size | io.error) = {
|
||||
let c: fd_ctx;
|
||||
c.fd = fd;
|
||||
c.vt.reader = (&fdsinkread_v): *io.reader;
|
||||
c.vt.writer = (&fdsinkwrite_v): *io.writer;
|
||||
let vs: io.vstream = &c.vt;
|
||||
return vfprint(vs, args...);
|
||||
};
|
||||
|
||||
// fdprintln_v — fdprint_v + trailing newline. Mirrors fmt.fdprintln
|
||||
// (fmt.ww:145).
|
||||
export fn fdprintln_v(fd: i32, args: formattable...) (size | io.error) = {
|
||||
let c: fd_ctx;
|
||||
c.fd = fd;
|
||||
c.vt.reader = (&fdsinkread_v): *io.reader;
|
||||
c.vt.writer = (&fdsinkwrite_v): *io.writer;
|
||||
let vs: io.vstream = &c.vt;
|
||||
let total: size = 0;
|
||||
match (vfprint(vs, args...)) {
|
||||
case let n: size => { total = n; };
|
||||
case let e: io.error => return e;
|
||||
};
|
||||
match (vputbytes(vs, "\n".ptr, 1)) {
|
||||
case let n: size => { total += n; };
|
||||
case let e: io.error => return e;
|
||||
};
|
||||
return total;
|
||||
};
|
||||
|
||||
// fdprintf_v — fdprintf over io.vstream. Mirrors fmt.fdprintf
|
||||
// (fmt.ww:786).
|
||||
export fn fdprintf_v(fd: i32, fmt: str, args: field...) (size | io.error) = {
|
||||
let c: fd_ctx;
|
||||
c.fd = fd;
|
||||
c.vt.reader = (&fdsinkread_v): *io.reader;
|
||||
c.vt.writer = (&fdsinkwrite_v): *io.writer;
|
||||
let vs: io.vstream = &c.vt;
|
||||
return vfprintf(vs, fmt, args...);
|
||||
};
|
||||
|
||||
// fdprintfln_v — fdprintf_v + trailing newline. Mirrors
|
||||
// fmt.fdprintfln (fmt.ww:797) and Hare's wrappers.ha:69.
|
||||
export fn fdprintfln_v(fd: i32, fmt: str, args: field...) (size | io.error) = {
|
||||
let c: fd_ctx;
|
||||
c.fd = fd;
|
||||
c.vt.reader = (&fdsinkread_v): *io.reader;
|
||||
c.vt.writer = (&fdsinkwrite_v): *io.writer;
|
||||
let vs: io.vstream = &c.vt;
|
||||
let total: size = 0;
|
||||
match (vfprintf(vs, fmt, args...)) {
|
||||
case let n: size => { total = n; };
|
||||
case let e: io.error => return e;
|
||||
};
|
||||
match (vputbytes(vs, "\n".ptr, 1)) {
|
||||
case let n: size => { total += n; };
|
||||
case let e: io.error => return e;
|
||||
};
|
||||
return total;
|
||||
};
|
||||
|
||||
// ---- V-side compositions over the vfprint / vfprintf primitives.
|
||||
// Project #94 fold-e7. drew-approved bundle (memio.string_v is the
|
||||
// collapsed single accessor over the common `stream` header — direct
|
||||
// enabler, not churn — feedback_refactor_routing_same_class_drops);
|
||||
// ken cs==ww mechanical
|
||||
// (additive only). eFinal (#50) collapses both surfaces and renames
|
||||
// `v` suffix off.
|
||||
//
|
||||
// Mirror sites:
|
||||
// vfprintln fmt.ww:240 fprintln ref/hare/fmt/wrappers.ha:48
|
||||
// vfprintfln fmt.ww:740 fprintfln ref/hare/fmt/wrappers.ha:69
|
||||
// vbsprintf fmt.ww:839 bsprintf ref/hare/fmt/wrappers.ha:42
|
||||
// vasprintf fmt.ww:873 asprintf ref/hare/fmt/wrappers.ha:29
|
||||
|
||||
// vfprintln — vfprint + trailing newline. Mirror fmt.fprintln
|
||||
// (fmt.ww:240); vputbytes + (size | io.error) routing.
|
||||
export fn vfprintln(vs: io.vstream, args: formattable...) (size | io.error) = {
|
||||
let total: size = 0;
|
||||
match (vfprint(vs, args...)) {
|
||||
case let n: size => { total = n; };
|
||||
case let e: io.error => return e;
|
||||
};
|
||||
match (vputbytes(vs, "\n".ptr, 1)) {
|
||||
case let n: size => { total += n; };
|
||||
case let e: io.error => return e;
|
||||
};
|
||||
return total;
|
||||
};
|
||||
|
||||
// vfprintfln — vfprintf + trailing newline. Mirror fmt.fprintfln
|
||||
// (fmt.ww:740).
|
||||
export fn vfprintfln(vs: io.vstream, fmt: str, args: field...) (size | io.error) = {
|
||||
let total: size = 0;
|
||||
match (vfprintf(vs, fmt, args...)) {
|
||||
case let n: size => { total = n; };
|
||||
case let e: io.error => return e;
|
||||
};
|
||||
match (vputbytes(vs, "\n".ptr, 1)) {
|
||||
case let n: size => { total += n; };
|
||||
case let e: io.error => return e;
|
||||
};
|
||||
return total;
|
||||
};
|
||||
|
||||
// vbsprintf — render into `buf` through memio.fixed_vstream; return
|
||||
// the str view of bytes actually written. Mirror fmt.bsprintf
|
||||
// (fmt.ww:839). memio.fixed_vstream now returns the `stream` BY VALUE
|
||||
// (fold-eFinal PREP, ref/hare/memio/stream.ha:46) — no alloc, no
|
||||
// `nomem` arm. The stream lives in this frame; `&st.vt` is the
|
||||
// io.vstream and `&st` the accessor handle. Hare wrappers.ha:42 returns
|
||||
// `(const str | nomem)`; ww collapses to (str | io.error) so the
|
||||
// vfprintf path's io.error arm stays uniform. Short writes surface as a
|
||||
// prefix (memio.fixed contract, vstream.ww fixedwrite note).
|
||||
export fn vbsprintf(buf: []u8, fmt: str, args: field...) (str | io.error) = {
|
||||
let st: memio.stream = memio.fixed_vstream(buf);
|
||||
let vs: io.vstream = &st.vt;
|
||||
match (vfprintf(vs, fmt, args...)) {
|
||||
case let n: size => { return memio.string_v(&st); };
|
||||
case let e: io.error => return e;
|
||||
};
|
||||
};
|
||||
|
||||
// vasprintf — render `fmt`/`args` into a heap-allocated str through
|
||||
// memio.dynamic_vstream, shrink-copy to a tight allocation, close the
|
||||
// dynamic backing. Mirror fmt.asprintf (fmt.ww:873) modulo: bare `str`
|
||||
// return (Hare returns `(str | nomem)`; ww has no `nomem` variant on
|
||||
// the public surface — os.alloc faults on OOM per lib/os.ww). Caller
|
||||
// frees with `os.free(r.ptr, r.len: u64)` when r.len > 0; r.len == 0
|
||||
// is a no-op free (same shape strings.dup uses at strings.ww:70).
|
||||
// Shrink-to-fit rationale: memio.dynamic_vstream's cap doubles past
|
||||
// pos during growth (memio dynamicgrow_v); io.st_close frees the
|
||||
// cap-sized mapping. Returning memio.string_v directly would
|
||||
// leak the cap-vs-len slack (skip close) or dangle the view (close
|
||||
// first); the copy lets the caller free with r.len.
|
||||
export fn vasprintf(fmt: str, args: field...) str = {
|
||||
let out: str;
|
||||
out.ptr = nil;
|
||||
out.len = 0;
|
||||
// memio.dynamic_vstream returns the `stream` BY VALUE (fold-eFinal
|
||||
// PREP, ref/hare/memio/stream.ha:58) — no alloc, no `nomem` arm.
|
||||
// The stream lives in this frame across the vfprintf + close; the
|
||||
// heap-grown backing (st.ptr) is freed by io.st_close.
|
||||
let st: memio.stream = memio.dynamic_vstream();
|
||||
let vs: io.vstream = &st.vt;
|
||||
let wres: (size | io.error) = vfprintf(vs, fmt, args...);
|
||||
match (wres) {
|
||||
case let n: size => {};
|
||||
case let e: io.error => {};
|
||||
};
|
||||
let view: str = memio.string_v(&st);
|
||||
if (view.len == 0) {
|
||||
let cres: (void | io.error) = io.st_close(vs);
|
||||
match (cres) { case void => {}; case let e: io.error => {}; };
|
||||
return out;
|
||||
};
|
||||
let tight: []u8 = alloc([], view.len: u64)!;
|
||||
let i: i32 = 0;
|
||||
for (i < view.len) {
|
||||
tight[i] = view.ptr[i];
|
||||
i += 1;
|
||||
};
|
||||
let cres: (void | io.error) = io.st_close(vs);
|
||||
match (cres) { case void => {}; case let e: io.error => {}; };
|
||||
tight.len = view.len;
|
||||
return strings.frombytes(tight);
|
||||
};
|
||||
Reference in New Issue
Block a user