Hojun-Cho
954badd28f
wwstage named variadic-gather slots with mkvarargname off a separate varargseq counter, never bumping the shared labelseq that names match labels. cstage names them via mklabel (cmd/w6c/cgen.c:5427,5431), which advances labelseq twice per gather. So by the time main.main reached its `match (wr)`, wwstage's match-label counter ran two behind cstage's (_4/_5/_6 vs _6/_7/_8) — a pure label-numbering divergence that kept fmt cs/ww byte-id failing. Drop varargseq and the mkvarargname helper; call the existing mklabel for the two gather slots, matching cstage's order (vararg_d only when nvar>0, vararg_sl always). The slot names are locals-table keys only — they resolve to BP offsets and never reach the asm — so only the labelseq advance is observable, which is exactly what realigns the downstream match labels. cstage untouched (align wwstage up). This was the match-label half of fmt's divergence; with the earlier compound-assign fix it completes fmt byte-identity. Graduate 777/780/781 to STAGE_CS|STAGE_WW with byte_id, and drop the now-stale (void)asm_byte_identical guard in 777.
346 lines
11 KiB
C
346 lines
11 KiB
C
/*
|
|
* 780_fmt_mods_run — io fold-2 (#5) commit-2 sentinel. Pins the
|
|
* modifier-formatting machinery (rawleni64 / rawlenstr / rawlenf64 /
|
|
* rawlen / formatraw / formatone) in lib/fmt/fmt.ww: formatfield takes
|
|
* `*mods` and routes through formatone so the {:mods} placeholder
|
|
* honours width / alignment / pad / sign / base / prec. #5 graduated
|
|
* fprintf's sink io.stream -> io.handle; these rows drive it over the
|
|
* FILE arm (`fd: io.file` widens to io.handle).
|
|
*
|
|
* Each row imports fmt + os + io, opens a per-process /tmp output file,
|
|
* calls fprintf with a {:mods} format string + one arg, and asserts the
|
|
* exact byte content read back.
|
|
*
|
|
* Cstage-only per row. #209 (the wwstage checker bail on fmt's
|
|
* spread-union match-arms) is now CLOSED; the residual blocker is the
|
|
* pre-existing cgen cluster #226 (io.read error-remap nominal-identity)
|
|
* + #227 (spread-union widen/return-ABI). Identical carve-out to
|
|
* 777_fmt_handle_run (cited there). Byte-id graduates when #226 (+#227)
|
|
* land.
|
|
*
|
|
* 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):
|
|
*
|
|
* 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.
|
|
*
|
|
* 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).
|
|
*
|
|
* DEFERRALS / RELATED (NOT addressed by these rows):
|
|
*
|
|
* - #226 (io.read error-remap nominal-identity) + #227 (spread-union
|
|
* widen/return-ABI): block STAGE_WW here, same as 777_fmt_handle_run.
|
|
* #209 (the checker bail) is closed; these cgen folds are the
|
|
* residual. Cstage-only until they land.
|
|
*
|
|
* BOOTSTRAP-EMBED CHECK: fmt is NOT embedded in any selfhost
|
|
* combined.ww (grep confirmed), so the #5 fmt graduation does NOT
|
|
* require a Makefile regen (#110); only test paths see the 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 formatone /
|
|
* formatraw / rawlen miscomputed bytes, formatfield regressed its
|
|
* *mods route, scanmods/modsinit drifted, or the strconv.u64tos base
|
|
* path miscompiled under fprintf over the io.handle file arm.
|
|
*/
|
|
#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/wwfmtm_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.fprintf(fd: io.file, \"{: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 | STAGE_WW, 1 },
|
|
{ "precision",
|
|
"package main;\n"
|
|
"import os;\n"
|
|
"import fmt;\n"
|
|
"import io;\n"
|
|
"export fn main() i32 = {\n"
|
|
" let path: str = \"/tmp/wwfmtm_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.fprintf(fd: io.file, \"{:.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 | STAGE_WW, 1 },
|
|
{ "base_hex",
|
|
"package main;\n"
|
|
"import os;\n"
|
|
"import fmt;\n"
|
|
"import io;\n"
|
|
"export fn main() i32 = {\n"
|
|
" let path: str = \"/tmp/wwfmtm_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.fprintf(fd: io.file, \"{: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 | STAGE_WW, 1 },
|
|
{ "sign_plus",
|
|
"package main;\n"
|
|
"import os;\n"
|
|
"import fmt;\n"
|
|
"import io;\n"
|
|
"export fn main() i32 = {\n"
|
|
" let path: str = \"/tmp/wwfmtm_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.fprintf(fd: io.file, \"{:+}\", 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 | STAGE_WW, 1 },
|
|
{ "zero_pad",
|
|
"package main;\n"
|
|
"import os;\n"
|
|
"import fmt;\n"
|
|
"import io;\n"
|
|
"export fn main() i32 = {\n"
|
|
" let path: str = \"/tmp/wwfmtm_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.fprintf(fd: io.file, \"{:_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 | 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. 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/fhm_%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_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_mods_run[ww][%s]: exit=%d want=%d\n",
|
|
rows[i].label, got, rows[i].want_exit);
|
|
fail++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!wwpresent)
|
|
fprintf(stderr, "fmt_mods_run: skip wwstage (no %s)\n", wdrv);
|
|
|
|
if (fail) {
|
|
fprintf(stderr, "fmt_mods_run: %d/%d fixtures failed\n",
|
|
fail, total);
|
|
return 1;
|
|
}
|
|
printf("fmt_mods_run: %d/%d ok\n", total, total);
|
|
return 0;
|
|
}
|