/* * 778_bufio_vstream_run — project #94 fold-e4 sentinel. Pins the * additive lib/bufio/vstream.ww Option C parallel API: heap-alloc'd * bufio_ctx with `vt: io.vtable` as the first field for the intrusive * vstream cast, the bufio_vstream constructor that returns * `(io.vstream | nomem)` wrapping an underlying *io.stream (OLD * API; bufio_vstream's `src` parameter type stays OLD until io * fold-2 lands `handle = (file | int)`), and isbuffered_v as the * fn-ptr-equality discriminator over the new `_v` callback symbols. * Coexists with the pre-vtable bufio.init / bufio.isbuffered surface * in bufio.ww (fold-eFinal, task #50, retires the latter once io * fold-2 ports `handle = (file | int)`). * * Each row imports os + bufio + memio + io (NOT fmt — bufio doesn't * transitively pull fmt, so #209's formattable-match bail doesn't * propagate; both stages run on every row). * * row | what it pins * --------------------------+-------------------------------------- * stream_write_flush | bufio_vstream init + io.st_write * | through bwrite_v + bufio.flush_v via * | io.st_close. Asserts the data * | reaches the underlying memio buffer * | after close drains wbuf. Full chain: * | alloc bufio_ctx → return &c.vt → * | dispatcher recovers via *bufio_ctx → * | flush_v → io.write(b.src, ...). * stream_read_unread | bufio_vstream read path: io.st_read * | refills rbuf from src, serves first * | N bytes. Pins bread_v's read path * | through the intrusive cast. unread_v * | not exposed yet (no bufio.unread * | equivalent on the V API surface * | until eFinal); this row exercises * | the base read path instead. * isbuffered_v_discriminate | isbuffered_v on a fresh bufio_vstream * | returns true; isbuffered_v on a * | plain memio.fixed_vstream (no bufio * | wrap) returns false. Pins the * | fn-ptr-equality discriminator * | (ref/hare/bufio/stream.ha:179) over * | the new `_v` callback symbols. * isbuffered_v_boundary | NEW isbuffered_v on bufio_vstream * | returns true AND OLD bufio.isbuffered * | on a bytewise-cast view of the same * | vstream returns false. Boundary * | check: the OLD discriminator reads * | (s.read == bread) but the bytes at * | &bufio_ctx.vt are vt.reader (tagged * | union) — the cast reinterprets vt's * | tag+ptr layout as the OLD stream's * | ctx/read/write/close 4-fnptr layout, * | and the OLD `bread` symbol address * | is distinct from the NEW `bread_v`, * | so the OLD discriminator returns * | false. Proves the OLD + NEW worlds * | use independent fn symbols. * branched_bufio_vstream | branched callee per #105: two * | distinct underlying *io.stream's * | runtime-selected; bufio_vstream * | wraps the picked one. st_read * | returns the matching source's * | content. Catches a constant-fold * | mistake in the dispatch path * | (mirror of 775's branched_readers * | for the bufio-wrap side). * * SIBLINGS (filed inline, NOT fixed here — fold-e4 is purely * additive over fold-e1/e2/e3's frozen io.* + memio.* + fmt.* * surface): * * - io fold-2 (handle port): drew-deferred. Hare's * ref/hare/bufio/stream.ha:69 takes `src: io::handle`; once * handle = (file | int) lands, bufio_vstream's src parameter * collapses accordingly. eFinal (#50) graduates. * * - #206 (bare &fn → (*alias|void)): 5 cast sites in vstream.ww * (3 vtable wire-up + 2 in isbuffered_v); drop out wholesale * on close. * * - #173 (TRY-on-tagged-return both-stages broken): flush_v * constructs nomem and widens to io.error explicitly rather * than using `io.write(...)?`; same memio.vstream.ww + * fmt.vstream.ww shape. * * - #207 (struct-lit multi-tagged-field copy drops past first): * alloc-zero-chain pattern (`vt = zero` + post-alloc * `c.vt.X = ...`) sidesteps; only 1 tagged field in bufio_ctx * so the workaround is overkill, but stays for idiom * consistency with memio/vstream.ww. * * BOOTSTRAP-EMBED CHECK: bufio is NOT embedded in any selfhost * combined.ww (grep confirmed). Adding lib/bufio/vstream.ww does * NOT require a Makefile regen (#110); only lib/bufio/ test paths * see the new module. 990-997 byte-id gates stay green by virtue * of bufio being test-only. * * GATE POLARITY: must stay GREEN. A red here means vstream.ww * regressed, the alloc-struct-? path miscompiled, the intrusive * vstream→*bufio_ctx cast miscomputed offsets, the io.vtable * first-field embed lost its offset-0 invariant, or the fn-ptr- * equality discriminator in isbuffered_v stopped resolving. */ #include #include #include #include #include static int runwait(const char *cmd) { int rc = system(cmd); if (rc == -1) return -1; if (WIFEXITED(rc)) return WEXITSTATUS(rc); return -1; } #define STAGE_CS 1 #define STAGE_WW 2 struct row { const char *label; const char *src; int want_exit; int stage_mask; int byte_id; }; static const struct row rows[] = { { "stream_write_flush", "package main;\n" "import os;\n" "import bufio;\n" "import memio;\n" "import io;\n" "export fn main() i32 = {\n" " let raw: [16]u8;\n" " let mem: memio.state;\n" " let m: io.stream;\n" " memio.fixed(&mem, &m, raw[0:16]);\n" " let rbuf: [8]u8;\n" " let wbuf: [8]u8;\n" " let r = bufio.bufio_vstream(&m, rbuf[0:8], wbuf[0:8]);\n" " let vs: io.vstream = nil: *io.vtable;\n" " match (r) {\n" " case let v: io.vstream => { vs = v; };\n" " case nomem => { return 50; };\n" " };\n" " let payload: [5]u8;\n" " payload[0] = 104u8; payload[1] = 105u8;\n" " payload[2] = 33u8; payload[3] = 98u8; payload[4] = 121u8;\n" " let wr = io.st_write(vs, payload[0:5]);\n" " let nw: size = 0;\n" " if (wr is size) { nw = wr as size; };\n" " if (mem.pos != 0) { return 91; };\n" " let cl = io.st_close(vs);\n" " if (cl is io.error) { return 92; };\n" " if (mem.pos != 5) { return 93; };\n" " if (nw != 5: size) { return 94; };\n" " if (raw[0] != 104u8 || raw[4] != 121u8) { return 95; };\n" " return 46;\n" "};\n", 46, STAGE_CS | STAGE_WW, 1 }, { "stream_read_unread", "package main;\n" "import os;\n" "import bufio;\n" "import memio;\n" "import io;\n" "export fn main() i32 = {\n" " let raw: [8]u8;\n" " raw[0] = 65u8; raw[1] = 66u8; raw[2] = 67u8; raw[3] = 68u8;\n" " raw[4] = 69u8; raw[5] = 70u8; raw[6] = 71u8; raw[7] = 72u8;\n" " let mem: memio.state;\n" " let m: io.stream;\n" " memio.fixed(&mem, &m, raw[0:8]);\n" " let rbuf: [8]u8;\n" " let wbuf: [4]u8;\n" " let r = bufio.bufio_vstream(&m, rbuf[0:8], wbuf[0:4]);\n" " let vs: io.vstream = nil: *io.vtable;\n" " match (r) {\n" " case let v: io.vstream => { vs = v; };\n" " case nomem => { return 50; };\n" " };\n" " let out: [4]u8;\n" " let rd1 = io.st_read(vs, out[0:3]);\n" " let n1: size = 0;\n" " if (rd1 is size) { n1 = rd1 as size; };\n" " if (n1 != 3: size) { return 91; };\n" " if (out[0] != 65u8 || out[2] != 67u8) { return 92; };\n" " let rd2 = io.st_read(vs, out[0:4]);\n" " let n2: size = 0;\n" " if (rd2 is size) { n2 = rd2 as size; };\n" " if (n2 != 4: size) { return 93; };\n" " if (out[0] != 68u8 || out[3] != 71u8) { return 94; };\n" " return 47;\n" "};\n", 47, STAGE_CS | STAGE_WW, 1 }, { "isbuffered_v_discriminate", "package main;\n" "import os;\n" "import bufio;\n" "import memio;\n" "import io;\n" "export fn main() i32 = {\n" " let raw: [8]u8;\n" " let mem: memio.state;\n" " let m: io.stream;\n" " memio.fixed(&mem, &m, raw[0:8]);\n" " let rbuf: [4]u8;\n" " let wbuf: [4]u8;\n" " let r = bufio.bufio_vstream(&m, rbuf[0:4], wbuf[0:4]);\n" " let vsbuf: io.vstream = nil: *io.vtable;\n" " match (r) {\n" " case let v: io.vstream => { vsbuf = v; };\n" " case nomem => { return 50; };\n" " };\n" " let buf2: [4]u8;\n" " let r2 = memio.fixed_vstream(buf2[0:4]);\n" " let vsplain: io.vstream = nil: *io.vtable;\n" " match (r2) {\n" " case let v: io.vstream => { vsplain = v; };\n" " case nomem => { return 51; };\n" " };\n" " if (!bufio.isbuffered_v(vsbuf)) { return 91; };\n" " if (bufio.isbuffered_v(vsplain)) { return 92; };\n" " return 48;\n" "};\n", 48, STAGE_CS | STAGE_WW, 1 }, { "isbuffered_v_boundary", "package main;\n" "import os;\n" "import bufio;\n" "import memio;\n" "import io;\n" "export fn main() i32 = {\n" " let raw: [8]u8;\n" " let mem: memio.state;\n" " let m: io.stream;\n" " memio.fixed(&mem, &m, raw[0:8]);\n" " let rbuf: [4]u8;\n" " let wbuf: [4]u8;\n" " let r = bufio.bufio_vstream(&m, rbuf[0:4], wbuf[0:4]);\n" " let vs: io.vstream = nil: *io.vtable;\n" " match (r) {\n" " case let v: io.vstream => { vs = v; };\n" " case nomem => { return 50; };\n" " };\n" " if (!bufio.isbuffered_v(vs)) { return 91; };\n" " let raw2: u64 = vs: u64;\n" " let asold: *io.stream = raw2: *io.stream;\n" " if (bufio.isbuffered(asold)) { return 92; };\n" " let b: bufio.stream;\n" " let rb: [4]u8;\n" " let wb: [4]u8;\n" " let raw3: [8]u8;\n" " let mem3: memio.state;\n" " let m3: io.stream;\n" " memio.fixed(&mem3, &m3, raw3[0:8]);\n" " bufio.init(&b, &m3, rb[0:4], wb[0:4]);\n" " if (!bufio.isbuffered(&b.vtable)) { return 93; };\n" " return 49;\n" "};\n", 49, STAGE_CS | STAGE_WW, 1 }, { "branched_bufio_vstream", "package main;\n" "import os;\n" "import bufio;\n" "import memio;\n" "import io;\n" "export fn main() i32 = {\n" " let raA: [4]u8;\n" " raA[0] = 10u8; raA[1] = 11u8; raA[2] = 12u8; raA[3] = 13u8;\n" " let raB: [4]u8;\n" " raB[0] = 20u8; raB[1] = 21u8; raB[2] = 22u8; raB[3] = 23u8;\n" " let memA: memio.state;\n" " let memB: memio.state;\n" " let mA: io.stream;\n" " let mB: io.stream;\n" " memio.fixed(&memA, &mA, raA[0:4]);\n" " memio.fixed(&memB, &mB, raB[0:4]);\n" " let sel: i32 = 1;\n" " let src: *io.stream = &mA;\n" " if (sel == 0) { src = &mB; };\n" " let rbuf: [4]u8;\n" " let wbuf: [4]u8;\n" " let r = bufio.bufio_vstream(src, rbuf[0:4], wbuf[0:4]);\n" " let vs: io.vstream = nil: *io.vtable;\n" " match (r) {\n" " case let v: io.vstream => { vs = v; };\n" " case nomem => { return 50; };\n" " };\n" " let out: [4]u8;\n" " let rd = io.st_read(vs, out[0:4]);\n" " let n: size = 0;\n" " if (rd is size) { n = rd as size; };\n" " if (n != 4: size) { return 91; };\n" " if (out[0] != 10u8 || out[3] != 13u8) { return 92; };\n" " return 51;\n" "};\n", 51, STAGE_CS | STAGE_WW, 1 }, }; static int write_source(const char *path, const char *src) { FILE *f = fopen(path, "wb"); if (!f) return -1; fputs(src, f); fclose(f); return 0; } /* Per-row tmpdir cleanup. ww_ww writes intermediates next to the * source (filed task #15), so each row's build leaves * .{combined.ww,s,o} + bare exe alongside. Sweep all then * rmdir. Mirror of 776's/777's cleanup_tmp. */ static void cleanup_tmp(const char *tmpdir, const char *base) { char p[640]; snprintf(p, sizeof p, "%s/%s.ww", tmpdir, base); unlink(p); snprintf(p, sizeof p, "%s/%s.s", tmpdir, base); unlink(p); snprintf(p, sizeof p, "%s/%s.o", tmpdir, base); unlink(p); snprintf(p, sizeof p, "%s/%s.combined.ww", tmpdir, base); unlink(p); snprintf(p, sizeof p, "%s/%s", tmpdir, base); unlink(p); rmdir(tmpdir); } static int build_via_driver(const char *driver, const char *tmpdir, const char *cwd, const char *src) { char cmd[2048]; snprintf(cmd, sizeof cmd, "cd %s && timeout 180 %s build -I %s/lib %s 2>/dev/null", tmpdir, driver, cwd, src); return runwait(cmd); } static int run_row(const char *driver, const char *cwd, const struct row *r, int seq) { char tmpdir[256], src[512], base[64], outbin[768]; snprintf(tmpdir, sizeof tmpdir, "/tmp/bvs_%d_d_%d", getpid(), seq); snprintf(base, sizeof base, "main778"); snprintf(src, sizeof src, "%s/%s.ww", tmpdir, base); mkdir(tmpdir, 0755); if (write_source(src, r->src) != 0) { cleanup_tmp(tmpdir, base); return -1; } int rc; int br = build_via_driver(driver, tmpdir, cwd, src); if (br == 0) { snprintf(outbin, sizeof outbin, "%s/%s", tmpdir, base); rc = runwait(outbin); } else { rc = -1; } cleanup_tmp(tmpdir, base); return rc; } /* asm_byte_identical — diff cstage vs wwstage .s. Parallel trees so * ww_ww writing intermediates next to the source doesn't clobber the * cstage .s (CLAUDE.md rule 14 phase split). Mirror of 776's/777's. */ static int asm_byte_identical(const char *cdrv, const char *wdrv, const char *cwd, const struct row *r, int seq) { char src[512], tdc[256], tdw[256], base[64], cs[512], ws[512]; snprintf(tdc, sizeof tdc, "/tmp/bvs_%d_c_%d", getpid(), seq); snprintf(tdw, sizeof tdw, "/tmp/bvs_%d_w_%d", getpid(), seq); snprintf(base, sizeof base, "main778"); mkdir(tdc, 0755); mkdir(tdw, 0755); snprintf(src, sizeof src, "%s/%s.ww", tdc, base); if (write_source(src, r->src) != 0) { cleanup_tmp(tdc, base); cleanup_tmp(tdw, base); return -1; } int rc = -1; if (build_via_driver(cdrv, tdc, cwd, src) != 0) goto out; snprintf(cs, sizeof cs, "%s/%s.s", tdc, base); snprintf(src, sizeof src, "%s/%s.ww", tdw, base); if (write_source(src, r->src) != 0) goto out; if (build_via_driver(wdrv, tdw, cwd, src) != 0) goto out; snprintf(ws, sizeof ws, "%s/%s.s", tdw, base); FILE *fc = fopen(cs, "rb"); FILE *fw = fopen(ws, "rb"); if (fc && fw) { rc = 0; for (;;) { int a = fgetc(fc); int b = fgetc(fw); if (a != b) { rc = -1; break; } if (a == EOF) break; } } if (fc) fclose(fc); if (fw) fclose(fw); out: cleanup_tmp(tdc, base); cleanup_tmp(tdw, base); return rc; } int main(void) { const char *bin = getenv("BIN"); if (!bin) bin = "out/bin"; char cwd[256]; if (getcwd(cwd, sizeof cwd) == NULL) return 1; char absbin[512]; if (bin[0] != '/') { snprintf(absbin, sizeof absbin, "%s/%s", cwd, bin); bin = absbin; } char cdrv[640], wdrv[640]; snprintf(cdrv, sizeof cdrv, "%s/ww", bin); snprintf(wdrv, sizeof wdrv, "%s/ww_ww", bin); int n = (int)(sizeof rows / sizeof rows[0]); int total = 0, fail = 0; int wwpresent = (access(wdrv, X_OK) == 0); int seq = 0; for (int i = 0; i < n; i++) { if (rows[i].stage_mask & STAGE_CS) { total++; int got = run_row(cdrv, cwd, &rows[i], seq++); if (got != rows[i].want_exit) { fprintf(stderr, "bufio_vstream_run[cs][%s]: exit=%d want=%d\n", rows[i].label, got, rows[i].want_exit); fail++; } } if (wwpresent && (rows[i].stage_mask & STAGE_WW)) { total++; int got = run_row(wdrv, cwd, &rows[i], seq++); if (got != rows[i].want_exit) { fprintf(stderr, "bufio_vstream_run[ww][%s]: exit=%d want=%d\n", rows[i].label, got, rows[i].want_exit); fail++; } if (rows[i].byte_id) { total++; if (asm_byte_identical(cdrv, wdrv, cwd, &rows[i], seq++) != 0) { fprintf(stderr, "bufio_vstream_run[byte-id][%s]: cstage vs wwstage asm differs\n", rows[i].label); fail++; } } } } if (!wwpresent) fprintf(stderr, "bufio_vstream_run: skip wwstage (no %s)\n", wdrv); if (fail) { fprintf(stderr, "bufio_vstream_run: %d/%d fixtures failed\n", fail, total); return 1; } printf("bufio_vstream_run: %d/%d ok\n", total, total); return 0; }