Hojun-Cho
c62e8e5560
Adds bufio_vstream + isbuffered_v alongside the pre-vtable bufio.init / bufio.isbuffered surface, mirroring fold-e2's lib/memio and fold-e3's lib/fmt parallel-API shape. The OLD bufio.ww surface stays untouched; fold-eFinal (#50) atomically flips the package shape, drops the `_v` suffix, and retires the legacy callbacks. bufio_ctx wraps an underlying *io.stream (OLD API) — bufio_vstream src parameter type stays *io.stream until io fold-2 lands `handle = (file | int)` (drew-deferred). vt is the first field for the intrusive vstream→*bufio_ctx cast, same shape as memio/fmt vstream wrappers. Sibling task filed: #210 struct-lit slice-typed field silently drops under alloc(T{slice = val})?. Parallel to #207 for slice fields; scalar/ptr fields in the same alloc-struct-lit populate correctly. Workaround: post-alloc field-assign c.slicefield = val. Documented inline; drops out on close. Other deferrals retained inline: #206 cast wrappers (3 vtable wire-up + 2 isbuffered_v comparand), #173 nomem-widen for the io.closed → io.error boundary, #207 alloc-zero-chain for vt. bufio is not embedded in any selfhost combined.ww (test-only); no Makefile regen needed (#110-blind safe). test/wcc/778_bufio_vstream_run pins the 5-row scenario set: write+flush, read+refill, isbuffered_v discriminator, OLD/NEW boundary check, and a branched-callee #105 row. cs+ww+byte-id green on all 5 rows. make test: 211 passed (was 210).
476 lines
17 KiB
C
476 lines
17 KiB
C
/*
|
|
* 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 <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/wait.h>
|
|
|
|
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
|
|
* <src>.{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;
|
|
}
|