Hojun-Cho
a3f3153943
V's vfprintf parsed mods via scanmods but dropped them after parse — vformatfield routed straight to vwriteone (no width / alignment / pad / sign / base / prec honoured). Port the OLD modifier path (fmt.ww: 443-641 rawlen* / formatraw / formatone) into vstream.ww as the v* twins, widen vformatfield to take *mods, and pass &m through vfprintf at the call site. The v* helpers mirror OLD verbatim (compute body identical; vputbytes + (size | io.error) routing replacing putbytes + (i32 | io.closed)); shared compute helpers (signof / digitsu64 / basenum) and modifier enums (neg / alignment / mods) are reused directly from fmt.ww via package scope. fmt.ww UNCHANGED — fold-eFinal (#50) collapses both surfaces and dedupes the rawlen-family. drew NaN/Inf signoff: strconv.f64tos / f32tos already render "nan"/"infinity" with no leading '-', so the sign-peel in vrawlenf64 + vformatraw f64 arm is a no-op on those views (same OLD path at fmt.ww:520-562). ken cs==ww mechanical: both stages compile the new V-side identically; 990-997 byte-id gates + combined_ww_fresh stay green (fmt is not embedded in any selfhost main.combined.ww — grep verified pre-impl). test/wcc/780_fmt_vstream_mods_run.c (cstage-only per #209): 5 rows covering width / precision / base_hex / sign_plus / zero_pad. STAGE_WW blocked by #209 (wwstage formattable match-arm bail), same carve-out as 777_fmt_vstream_run.
356 lines
12 KiB
C
356 lines
12 KiB
C
/*
|
|
* 780_fmt_vstream_mods_run — project #94 fold-e6 sentinel. Pins the
|
|
* V-side modifier-formatting machinery (vrawleni64 / vrawlenstr /
|
|
* vrawlenf64 / vrawlen / vformatraw / vformatone) in lib/fmt/
|
|
* vstream.ww. Before fold-e6, the V printf path parsed mods via
|
|
* scanmods but dropped them after parse: vformatfield routed straight
|
|
* to vwriteone (no width / alignment / pad / sign / base / prec
|
|
* honoured). fold-e6 widens vformatfield to take `*mods` and routes
|
|
* through vformatone — same dispatch shape as OLD formatfield at
|
|
* fmt.ww:648. Coexists with the OLD modifier path at fmt.ww:443-641
|
|
* (fmt.ww UNCHANGED this fold); fold-eFinal (task #50) collapses both
|
|
* surfaces.
|
|
*
|
|
* Each row imports fmt + os + io, opens a per-process /tmp output
|
|
* file, calls fdprintf_v with a {:mods} format string + one arg, and
|
|
* asserts the exact byte content read back.
|
|
*
|
|
* Cstage-only per row — pre-existing wwstage bug #209 (sibling of
|
|
* #190): the wwstage checker bails on fmt.formattable match-arms
|
|
* whenever a downstream probe `import fmt;`s the package. Identical
|
|
* carve-out to 777_fmt_vstream_run (cited there at line 18-33).
|
|
* Byte-id graduates with #209 close.
|
|
*
|
|
* row | format | arg | expect | exit
|
|
* -----------------+------------+--------------+-----------+-----
|
|
* width | "{:5}" | 42i64 | " 42" | 50
|
|
* precision | "{:.3}" | "hello" | "hel" | 51
|
|
* base_hex | "{:x}" | 255i64 | "ff" | 52
|
|
* sign_plus | "{:+}" | 7i64 | "+7" | 53
|
|
* zero_pad | "{:_05}" | 42i64 | "00042" | 54
|
|
*
|
|
* Modifier surface exercised (subset of scanmods at fmt.ww:376-405):
|
|
*
|
|
* width digits 1..9 — RIGHT-align pad to N chars
|
|
* prec '.' + digits — str truncation / int min-digits
|
|
* base 'x' — strconv.base.HEX_LOWER
|
|
* neg '+' — emit '+' on non-negative
|
|
* pad '_<rune>' — pad rune override (default space when ':')
|
|
*
|
|
* Drew NaN/Inf signoff (carry from task #58): f64 arm not exercised
|
|
* here (rows pin i64+str+bool fastpaths); follow-on fold can add f64
|
|
* once Drew's strconv.f64tos shortest-G stays static. The fold-e6
|
|
* implementation honours the sign-peel in vformatraw f64 arm; an
|
|
* end-to-end test lands when a NaN/Inf-aware probe joins the corpus.
|
|
*
|
|
* IMPORT-ORDER WORKAROUND (sibling task #208, pre-existing): every
|
|
* row places `import os;` FIRST for the same reason 776/777 document
|
|
* (wwstage checker ordering-sensitivity on os.tryread/trywrite/
|
|
* tryopen's bare `return r;` over a tagged return type).
|
|
*
|
|
* SIBLINGS (filed inline, NOT fixed here — fold-e6 is purely additive
|
|
* over fold-e1/e2/e3/e4/e5's frozen io.* + memio.* + fmt.* + bufio.*
|
|
* + log.* surface):
|
|
*
|
|
* - #209 (wwstage formattable match-arm bail): blocks STAGE_WW
|
|
* here, same as 777_fmt_vstream_run. Cstage-only until close.
|
|
* - eFinal (#50): collapses V + OLD surfaces; the `v*` names rename
|
|
* off and the OLD rawlen* / formatraw / formatone delete. The v*
|
|
* duplication of the rawlen-family today is transient — eFinal
|
|
* dedupes.
|
|
*
|
|
* BOOTSTRAP-EMBED CHECK: fmt is NOT embedded in any selfhost
|
|
* combined.ww (grep confirmed pre-impl). Adding modifier formatting
|
|
* to lib/fmt/vstream.ww does NOT require a Makefile regen (#110);
|
|
* only test paths see the new machinery. 990-997 byte-id gates stay
|
|
* green by virtue of fmt being test-only on the bootstrap surface.
|
|
*
|
|
* GATE POLARITY: must stay GREEN. A red here means vformatone /
|
|
* vformatraw / vrawlen miscomputed bytes, vformatfield regressed its
|
|
* *mods route, scanmods/modsinit (shared from fmt.ww) drifted, or
|
|
* the strconv.u64tos base path miscompiled under fdprintf_v's
|
|
* intrusive vstream→*fd_ctx dispatch.
|
|
*/
|
|
#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[] = {
|
|
{ "width",
|
|
"package main;\n"
|
|
"import os;\n"
|
|
"import fmt;\n"
|
|
"import io;\n"
|
|
"export fn main() i32 = {\n"
|
|
" let path: str = \"/tmp/wwfmtv_780_a\";\n"
|
|
" let fd: i32 = os.open(path, os.flag.RDWR | os.flag.CREATE | os.flag.TRUNC, 0o644: i32);\n"
|
|
" if (fd < 0) { return 90; };\n"
|
|
" let wr = fmt.fdprintf_v(fd, \"{:5}\", 42i64);\n"
|
|
" let nw: size = 0;\n"
|
|
" match (wr) {\n"
|
|
" case let n: size => { nw = n; };\n"
|
|
" case io.error => { return 91; };\n"
|
|
" };\n"
|
|
" os.close(fd);\n"
|
|
" let rd: i32 = os.open(path, os.flag.RDONLY, 0i32);\n"
|
|
" if (rd < 0) { return 92; };\n"
|
|
" let buf: [16]u8;\n"
|
|
" let n: i64 = os.read(rd, &buf[0], 16u64);\n"
|
|
" os.close(rd);\n"
|
|
" if (n != 5i64) { return 93; };\n"
|
|
" if (nw != 5: size) { return 94; };\n"
|
|
" if (buf[0] != 32u8 || buf[1] != 32u8 || buf[2] != 32u8 || buf[3] != 52u8 || buf[4] != 50u8) { return 95; };\n"
|
|
" return 50;\n"
|
|
"};\n",
|
|
50,
|
|
STAGE_CS, 0 },
|
|
{ "precision",
|
|
"package main;\n"
|
|
"import os;\n"
|
|
"import fmt;\n"
|
|
"import io;\n"
|
|
"export fn main() i32 = {\n"
|
|
" let path: str = \"/tmp/wwfmtv_780_b\";\n"
|
|
" let fd: i32 = os.open(path, os.flag.RDWR | os.flag.CREATE | os.flag.TRUNC, 0o644: i32);\n"
|
|
" if (fd < 0) { return 90; };\n"
|
|
" let wr = fmt.fdprintf_v(fd, \"{:.3}\", \"hello\");\n"
|
|
" let nw: size = 0;\n"
|
|
" match (wr) {\n"
|
|
" case let n: size => { nw = n; };\n"
|
|
" case io.error => { return 91; };\n"
|
|
" };\n"
|
|
" os.close(fd);\n"
|
|
" let rd: i32 = os.open(path, os.flag.RDONLY, 0i32);\n"
|
|
" if (rd < 0) { return 92; };\n"
|
|
" let buf: [16]u8;\n"
|
|
" let n: i64 = os.read(rd, &buf[0], 16u64);\n"
|
|
" os.close(rd);\n"
|
|
" if (n != 3i64) { return 93; };\n"
|
|
" if (nw != 3: size) { return 94; };\n"
|
|
" if (buf[0] != 104u8 || buf[1] != 101u8 || buf[2] != 108u8) { return 95; };\n"
|
|
" return 51;\n"
|
|
"};\n",
|
|
51,
|
|
STAGE_CS, 0 },
|
|
{ "base_hex",
|
|
"package main;\n"
|
|
"import os;\n"
|
|
"import fmt;\n"
|
|
"import io;\n"
|
|
"export fn main() i32 = {\n"
|
|
" let path: str = \"/tmp/wwfmtv_780_c\";\n"
|
|
" let fd: i32 = os.open(path, os.flag.RDWR | os.flag.CREATE | os.flag.TRUNC, 0o644: i32);\n"
|
|
" if (fd < 0) { return 90; };\n"
|
|
" let wr = fmt.fdprintf_v(fd, \"{:x}\", 255i64);\n"
|
|
" let nw: size = 0;\n"
|
|
" match (wr) {\n"
|
|
" case let n: size => { nw = n; };\n"
|
|
" case io.error => { return 91; };\n"
|
|
" };\n"
|
|
" os.close(fd);\n"
|
|
" let rd: i32 = os.open(path, os.flag.RDONLY, 0i32);\n"
|
|
" if (rd < 0) { return 92; };\n"
|
|
" let buf: [16]u8;\n"
|
|
" let n: i64 = os.read(rd, &buf[0], 16u64);\n"
|
|
" os.close(rd);\n"
|
|
" if (n != 2i64) { return 93; };\n"
|
|
" if (nw != 2: size) { return 94; };\n"
|
|
" if (buf[0] != 102u8 || buf[1] != 102u8) { return 95; };\n"
|
|
" return 52;\n"
|
|
"};\n",
|
|
52,
|
|
STAGE_CS, 0 },
|
|
{ "sign_plus",
|
|
"package main;\n"
|
|
"import os;\n"
|
|
"import fmt;\n"
|
|
"import io;\n"
|
|
"export fn main() i32 = {\n"
|
|
" let path: str = \"/tmp/wwfmtv_780_d\";\n"
|
|
" let fd: i32 = os.open(path, os.flag.RDWR | os.flag.CREATE | os.flag.TRUNC, 0o644: i32);\n"
|
|
" if (fd < 0) { return 90; };\n"
|
|
" let wr = fmt.fdprintf_v(fd, \"{:+}\", 7i64);\n"
|
|
" let nw: size = 0;\n"
|
|
" match (wr) {\n"
|
|
" case let n: size => { nw = n; };\n"
|
|
" case io.error => { return 91; };\n"
|
|
" };\n"
|
|
" os.close(fd);\n"
|
|
" let rd: i32 = os.open(path, os.flag.RDONLY, 0i32);\n"
|
|
" if (rd < 0) { return 92; };\n"
|
|
" let buf: [16]u8;\n"
|
|
" let n: i64 = os.read(rd, &buf[0], 16u64);\n"
|
|
" os.close(rd);\n"
|
|
" if (n != 2i64) { return 93; };\n"
|
|
" if (nw != 2: size) { return 94; };\n"
|
|
" if (buf[0] != 43u8 || buf[1] != 55u8) { return 95; };\n"
|
|
" return 53;\n"
|
|
"};\n",
|
|
53,
|
|
STAGE_CS, 0 },
|
|
{ "zero_pad",
|
|
"package main;\n"
|
|
"import os;\n"
|
|
"import fmt;\n"
|
|
"import io;\n"
|
|
"export fn main() i32 = {\n"
|
|
" let path: str = \"/tmp/wwfmtv_780_e\";\n"
|
|
" let fd: i32 = os.open(path, os.flag.RDWR | os.flag.CREATE | os.flag.TRUNC, 0o644: i32);\n"
|
|
" if (fd < 0) { return 90; };\n"
|
|
" let wr = fmt.fdprintf_v(fd, \"{:_05}\", 42i64);\n"
|
|
" let nw: size = 0;\n"
|
|
" match (wr) {\n"
|
|
" case let n: size => { nw = n; };\n"
|
|
" case io.error => { return 91; };\n"
|
|
" };\n"
|
|
" os.close(fd);\n"
|
|
" let rd: i32 = os.open(path, os.flag.RDONLY, 0i32);\n"
|
|
" if (rd < 0) { return 92; };\n"
|
|
" let buf: [16]u8;\n"
|
|
" let n: i64 = os.read(rd, &buf[0], 16u64);\n"
|
|
" os.close(rd);\n"
|
|
" if (n != 5i64) { return 93; };\n"
|
|
" if (nw != 5: size) { return 94; };\n"
|
|
" if (buf[0] != 48u8 || buf[1] != 48u8 || buf[2] != 48u8 || buf[3] != 52u8 || buf[4] != 50u8) { return 95; };\n"
|
|
" return 54;\n"
|
|
"};\n",
|
|
54,
|
|
STAGE_CS, 0 },
|
|
};
|
|
|
|
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. Mirror of 777's. */
|
|
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/fvm_%d_d_%d", getpid(), seq);
|
|
snprintf(base, sizeof base, "main780");
|
|
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;
|
|
}
|
|
|
|
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,
|
|
"fmt_vstream_mods_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,
|
|
"fmt_vstream_mods_run[ww][%s]: exit=%d want=%d\n",
|
|
rows[i].label, got, rows[i].want_exit);
|
|
fail++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!wwpresent)
|
|
fprintf(stderr, "fmt_vstream_mods_run: skip wwstage (no %s)\n", wdrv);
|
|
|
|
if (fail) {
|
|
fprintf(stderr, "fmt_vstream_mods_run: %d/%d fixtures failed\n",
|
|
fail, total);
|
|
return 1;
|
|
}
|
|
printf("fmt_vstream_mods_run: %d/%d ok\n", total, total);
|
|
return 0;
|
|
}
|