diff --git a/Makefile b/Makefile index b8873594..dc2becd4 100644 --- a/Makefile +++ b/Makefile @@ -467,6 +467,7 @@ TESTS = $(BIN)/test_smoke $(BIN)/test_lex $(BIN)/test_parse $(BIN)/test_check \ $(BIN)/test_dotbase_arr_run \ $(BIN)/test_dotbase_addr_slice_run \ $(BIN)/test_structlit_arrfield_run \ + $(BIN)/test_defdim_struct_run \ $(BIN)/test_arraytoslice_run \ $(BIN)/test_arrlit_slice_run \ $(BIN)/test_valstruct_subsize_run \ @@ -2133,6 +2134,11 @@ $(BIN)/test_structlit_arrfield_run: test/wcc/949_structlit_arrfield_run.c \ $(LIB)/libwwrt.a | $(BIN) $(CC) $(CFLAGS) -o $@ $< +$(BIN)/test_defdim_struct_run: test/wcc/951_defdim_struct_run.c \ + $(BIN)/ww $(BIN)/w6c $(BIN)/w6c_ww $(BIN)/w6a $(BIN)/w6l \ + $(LIB)/libwwrt.a | $(BIN) + $(CC) $(CFLAGS) -o $@ $< + $(BIN)/test_arraytoslice_run: test/wcc/953_arraytoslice_run.c \ $(BIN)/ww $(BIN)/w6c $(BIN)/w6c_ww $(BIN)/w6a $(BIN)/w6l \ $(LIB)/libwwrt.a | $(BIN) diff --git a/cmd/wcc/check.c b/cmd/wcc/check.c index ce55fc35..a760fa13 100644 --- a/cmd/wcc/check.c +++ b/cmd/wcc/check.c @@ -653,13 +653,19 @@ resolve_type(Checker *c, Node *n) case N_TSLICE: return type_slice(c->a, resolve_type(c, n->lhs)); case N_TARRAY: { - u64 len = 0; + u64 len = 0, v; if (n->rhs == NULL) { /* `[_]T` — length inferred at the use site (currently * only `let x: [_]T = arrlit;`). Leave alen=0 as a * sentinel; clet patches it from the initialiser. */ } else if (n->rhs->kind == N_INTLIT) { len = n->rhs->uval; + } else if (eval_def_const(c, n->rhs, &v, 0)) { + /* #141: a def-dimensioned `[MAX]u8`; fold the + * const-expr dimension (the same machinery #133's + * let-init fold uses). The err below stays for a + * genuinely non-const rhs. */ + len = v; } else { err(c, n->pos, "array length must be an integer literal"); } @@ -2716,6 +2722,29 @@ check_file(Checker *c, Node *file) } d->type = named; } + /* #141: bind def NAMES before resolving type bodies, so a struct + * field `[MAX]u8` whose dimension is a def-ref folds via + * eval_def_const (which reads decl->rhs) when resolve_typedecl + * walks the body below. The def's type is resolved in the + * decl loop further down; only the name->decl binding is needed + * here. A foldable stub carries type NULL until then. A duplicate + * (prev already bound non-USE) is left for that loop to diagnose. */ + c->cur_mod = NULL; + for (Node *d = file->list; d; d = d->next) { + if (d->kind != N_DEF) continue; + c->cur_mod = decl_mod(file, d); + const char *mod = decl_mod(file, d); + Sym *prev = scope_lookup_local(c->cur, d->str); + if (prev && prev->kind == SK_USE) { + prev->kind = SK_DEF; prev->decl = d; + prev->use_alias = 1; + if (mod && prev->mod == NULL) prev->mod = mod; + } else if (prev == NULL) { + scope_define_in_module(c->cur, d->str, mod, + SK_DEF, NULL, d); + } + } + c->cur_mod = NULL; for (Node *d = file->list; d; d = d->next) { if (d->kind != N_TYPEDECL) continue; resolve_typedecl(c, d); @@ -2733,7 +2762,11 @@ check_file(Checker *c, Node *file) d->type = t; Sym *prev = scope_lookup_local(c->cur, d->str); const char *mod = decl_mod(file, d); - if (prev && prev->kind == SK_USE) { + if (prev && prev->kind == SK_DEF && prev->decl == d) { + /* #141: the foldable stub bound before type-body + * resolution; fill in its now-resolved type. */ + prev->type = t; + } else if (prev && prev->kind == SK_USE) { /* `use mod; ... def mod = ...;` — promote the * SK_USE to the def symbol but remember it was * also a module name so dotted qualifiers diff --git a/selfhost/cmd/w6c/main.combined.ww b/selfhost/cmd/w6c/main.combined.ww index a80bf960..90527e11 100644 --- a/selfhost/cmd/w6c/main.combined.ww +++ b/selfhost/cmd/w6c/main.combined.ww @@ -11387,10 +11387,10 @@ fn astsize(c: *checker, t: *node) i64 = { if (k == nkind.N_TCHAN) { return 8i64; }; if (k == nkind.N_TFN) { return 8i64; }; if (k == nkind.N_TARRAY) { - let elen: i64 = 0i64; - if (t.rhs != nil) { - if (t.rhs.kind == nkind.N_INTLIT) { elen = t.rhs.uval: i64; }; - }; + // #141: a def-dimensioned field array sized to 0 here, so the + // struct loop (off += astsize(field)) overlapped the next + // field; arrayelen folds the def. + let elen: i64 = arrayelen(c, t.rhs): i64; return astsize(c, t.lhs) * elen; }; if (k == nkind.N_TTUPLE) { @@ -11823,6 +11823,23 @@ fn stampintlit(n: *node, v: u64) void = { // n.type_ left intact (the type exprtype inferred for the rhs). }; +// arrayelen — an array type's dimension as an element count. An +// N_INTLIT yields its uval; a def-ref or const-expr dim (`[MAX]u8`, +// MAX a def) folds through evaldefconst (#141, ken oracle); a nil +// child (the `[_]T` inferred-length sentinel) or non-const rhs gives +// 0. cstage carries the folded length in the resolved Type, but +// wwstage computes size lazily on independent paths (no AST-stamp +// SSoT), so every N_TARRAY length reader routes here to fold the dim +// identically — astsize (struct layout), tinfofornode (canonical +// tinfo), checkarrlitfits (count gate). +fn arrayelen(c: *checker, rhs: *node) u64 = { + if (rhs == nil) { return 0u64; }; + if (rhs.kind == nkind.N_INTLIT) { return rhs.uval; }; + let v: u64 = 0u64; + if (evaldefconst(c, rhs, &v, 0)) { return v; }; + return 0u64; +}; + // enumvalfold — fold an enum member's value expression to a u64 // constant. The Hare-fidelity set: literal leaves, unary +/-/~, // binary arithmetic (+ - * / %), bitwise (& | ^), shifts (<< >>), @@ -12159,10 +12176,7 @@ fn tinfofornode(c: *checker, n: *node) *tinfo = { // Reverts A.4's r.size override (which conflated stride with // natural size); the slot-padded stride now lives in slotsize // where cgenutil's fast-path reads it. - let elen: u64 = 0u64; - if (n.rhs != nil) { - if (n.rhs.kind == nkind.N_INTLIT) { elen = n.rhs.uval; }; - }; + let elen: u64 = arrayelen(c, n.rhs); // #141: fold def-dim let sub: *tinfo = tinfofornode(c, n.lhs); // #62/#69: `type a = [2]a` value cycle — loud, cstage twin. if (circularnamed(c, sub, n)) { sub = c.tc.tyerr; }; @@ -14466,12 +14480,13 @@ fn checkarrlitfits(c: *checker, arrtn: *node, rhs: *node) void = { // A nil or zero length child stays exempt: nil is the un-inferred // [_] sentinel in def/struct-field contexts and 0 doubles as both // [0] and the cstage [_] sentinel (conflation: task #11); the let - // paths stamp the real length before reaching here. A non-INTLIT - // length child (def-named [N]) is also exempt — task #13. + // paths stamp the real length before reaching here. #141: a def-dim + // child (`[MAX]u8`) now folds via arrayelen and is count-checked + // like a literal (closes #13's def-dim exemption). // Under-long (count < N, no `...`) stays accepted as before; Hare // rejects it — task #10. - if (arrtn.rhs != nil && arrtn.rhs.kind == nkind.N_INTLIT - && arrtn.rhs.uval > 0u64) { + let declen: u64 = arrayelen(c, arrtn.rhs); + if (declen > 0u64) { let cnt: u64 = 0u64; let ce: *node = rhs.list; for (ce != nil) { @@ -14482,11 +14497,11 @@ fn checkarrlitfits(c: *checker, arrtn: *node, rhs: *node) void = { if (!cskip) { cnt += 1u64; }; ce = ce.next; }; - if (cnt > arrtn.rhs.uval) { + if (cnt > declen) { cerr("array literal has "); cerr(strconv.u64tos(cnt, strconv.base.DEC)); cerr(" elements but declared array holds "); - cerr(strconv.u64tos(arrtn.rhs.uval, strconv.base.DEC)); + cerr(strconv.u64tos(declen, strconv.base.DEC)); cerr("\n"); c.errs += 1; return; diff --git a/selfhost/cmd/wcc/check.ww b/selfhost/cmd/wcc/check.ww index 82a9a007..b37bf5b6 100644 --- a/selfhost/cmd/wcc/check.ww +++ b/selfhost/cmd/wcc/check.ww @@ -1106,10 +1106,10 @@ fn astsize(c: *checker, t: *node) i64 = { if (k == nkind.N_TCHAN) { return 8i64; }; if (k == nkind.N_TFN) { return 8i64; }; if (k == nkind.N_TARRAY) { - let elen: i64 = 0i64; - if (t.rhs != nil) { - if (t.rhs.kind == nkind.N_INTLIT) { elen = t.rhs.uval: i64; }; - }; + // #141: a def-dimensioned field array sized to 0 here, so the + // struct loop (off += astsize(field)) overlapped the next + // field; arrayelen folds the def. + let elen: i64 = arrayelen(c, t.rhs): i64; return astsize(c, t.lhs) * elen; }; if (k == nkind.N_TTUPLE) { @@ -1542,6 +1542,23 @@ fn stampintlit(n: *node, v: u64) void = { // n.type_ left intact (the type exprtype inferred for the rhs). }; +// arrayelen — an array type's dimension as an element count. An +// N_INTLIT yields its uval; a def-ref or const-expr dim (`[MAX]u8`, +// MAX a def) folds through evaldefconst (#141, ken oracle); a nil +// child (the `[_]T` inferred-length sentinel) or non-const rhs gives +// 0. cstage carries the folded length in the resolved Type, but +// wwstage computes size lazily on independent paths (no AST-stamp +// SSoT), so every N_TARRAY length reader routes here to fold the dim +// identically — astsize (struct layout), tinfofornode (canonical +// tinfo), checkarrlitfits (count gate). +fn arrayelen(c: *checker, rhs: *node) u64 = { + if (rhs == nil) { return 0u64; }; + if (rhs.kind == nkind.N_INTLIT) { return rhs.uval; }; + let v: u64 = 0u64; + if (evaldefconst(c, rhs, &v, 0)) { return v; }; + return 0u64; +}; + // enumvalfold — fold an enum member's value expression to a u64 // constant. The Hare-fidelity set: literal leaves, unary +/-/~, // binary arithmetic (+ - * / %), bitwise (& | ^), shifts (<< >>), @@ -1878,10 +1895,7 @@ fn tinfofornode(c: *checker, n: *node) *tinfo = { // Reverts A.4's r.size override (which conflated stride with // natural size); the slot-padded stride now lives in slotsize // where cgenutil's fast-path reads it. - let elen: u64 = 0u64; - if (n.rhs != nil) { - if (n.rhs.kind == nkind.N_INTLIT) { elen = n.rhs.uval; }; - }; + let elen: u64 = arrayelen(c, n.rhs); // #141: fold def-dim let sub: *tinfo = tinfofornode(c, n.lhs); // #62/#69: `type a = [2]a` value cycle — loud, cstage twin. if (circularnamed(c, sub, n)) { sub = c.tc.tyerr; }; @@ -4185,12 +4199,13 @@ fn checkarrlitfits(c: *checker, arrtn: *node, rhs: *node) void = { // A nil or zero length child stays exempt: nil is the un-inferred // [_] sentinel in def/struct-field contexts and 0 doubles as both // [0] and the cstage [_] sentinel (conflation: task #11); the let - // paths stamp the real length before reaching here. A non-INTLIT - // length child (def-named [N]) is also exempt — task #13. + // paths stamp the real length before reaching here. #141: a def-dim + // child (`[MAX]u8`) now folds via arrayelen and is count-checked + // like a literal (closes #13's def-dim exemption). // Under-long (count < N, no `...`) stays accepted as before; Hare // rejects it — task #10. - if (arrtn.rhs != nil && arrtn.rhs.kind == nkind.N_INTLIT - && arrtn.rhs.uval > 0u64) { + let declen: u64 = arrayelen(c, arrtn.rhs); + if (declen > 0u64) { let cnt: u64 = 0u64; let ce: *node = rhs.list; for (ce != nil) { @@ -4201,11 +4216,11 @@ fn checkarrlitfits(c: *checker, arrtn: *node, rhs: *node) void = { if (!cskip) { cnt += 1u64; }; ce = ce.next; }; - if (cnt > arrtn.rhs.uval) { + if (cnt > declen) { cerr("array literal has "); cerr(strconv.u64tos(cnt, strconv.base.DEC)); cerr(" elements but declared array holds "); - cerr(strconv.u64tos(arrtn.rhs.uval, strconv.base.DEC)); + cerr(strconv.u64tos(declen, strconv.base.DEC)); cerr("\n"); c.errs += 1; return; diff --git a/selfhost/cmd/wwdump/main.combined.ww b/selfhost/cmd/wwdump/main.combined.ww index 82bbd86e..26a60ac8 100644 --- a/selfhost/cmd/wwdump/main.combined.ww +++ b/selfhost/cmd/wwdump/main.combined.ww @@ -11387,10 +11387,10 @@ fn astsize(c: *checker, t: *node) i64 = { if (k == nkind.N_TCHAN) { return 8i64; }; if (k == nkind.N_TFN) { return 8i64; }; if (k == nkind.N_TARRAY) { - let elen: i64 = 0i64; - if (t.rhs != nil) { - if (t.rhs.kind == nkind.N_INTLIT) { elen = t.rhs.uval: i64; }; - }; + // #141: a def-dimensioned field array sized to 0 here, so the + // struct loop (off += astsize(field)) overlapped the next + // field; arrayelen folds the def. + let elen: i64 = arrayelen(c, t.rhs): i64; return astsize(c, t.lhs) * elen; }; if (k == nkind.N_TTUPLE) { @@ -11823,6 +11823,23 @@ fn stampintlit(n: *node, v: u64) void = { // n.type_ left intact (the type exprtype inferred for the rhs). }; +// arrayelen — an array type's dimension as an element count. An +// N_INTLIT yields its uval; a def-ref or const-expr dim (`[MAX]u8`, +// MAX a def) folds through evaldefconst (#141, ken oracle); a nil +// child (the `[_]T` inferred-length sentinel) or non-const rhs gives +// 0. cstage carries the folded length in the resolved Type, but +// wwstage computes size lazily on independent paths (no AST-stamp +// SSoT), so every N_TARRAY length reader routes here to fold the dim +// identically — astsize (struct layout), tinfofornode (canonical +// tinfo), checkarrlitfits (count gate). +fn arrayelen(c: *checker, rhs: *node) u64 = { + if (rhs == nil) { return 0u64; }; + if (rhs.kind == nkind.N_INTLIT) { return rhs.uval; }; + let v: u64 = 0u64; + if (evaldefconst(c, rhs, &v, 0)) { return v; }; + return 0u64; +}; + // enumvalfold — fold an enum member's value expression to a u64 // constant. The Hare-fidelity set: literal leaves, unary +/-/~, // binary arithmetic (+ - * / %), bitwise (& | ^), shifts (<< >>), @@ -12159,10 +12176,7 @@ fn tinfofornode(c: *checker, n: *node) *tinfo = { // Reverts A.4's r.size override (which conflated stride with // natural size); the slot-padded stride now lives in slotsize // where cgenutil's fast-path reads it. - let elen: u64 = 0u64; - if (n.rhs != nil) { - if (n.rhs.kind == nkind.N_INTLIT) { elen = n.rhs.uval; }; - }; + let elen: u64 = arrayelen(c, n.rhs); // #141: fold def-dim let sub: *tinfo = tinfofornode(c, n.lhs); // #62/#69: `type a = [2]a` value cycle — loud, cstage twin. if (circularnamed(c, sub, n)) { sub = c.tc.tyerr; }; @@ -14466,12 +14480,13 @@ fn checkarrlitfits(c: *checker, arrtn: *node, rhs: *node) void = { // A nil or zero length child stays exempt: nil is the un-inferred // [_] sentinel in def/struct-field contexts and 0 doubles as both // [0] and the cstage [_] sentinel (conflation: task #11); the let - // paths stamp the real length before reaching here. A non-INTLIT - // length child (def-named [N]) is also exempt — task #13. + // paths stamp the real length before reaching here. #141: a def-dim + // child (`[MAX]u8`) now folds via arrayelen and is count-checked + // like a literal (closes #13's def-dim exemption). // Under-long (count < N, no `...`) stays accepted as before; Hare // rejects it — task #10. - if (arrtn.rhs != nil && arrtn.rhs.kind == nkind.N_INTLIT - && arrtn.rhs.uval > 0u64) { + let declen: u64 = arrayelen(c, arrtn.rhs); + if (declen > 0u64) { let cnt: u64 = 0u64; let ce: *node = rhs.list; for (ce != nil) { @@ -14482,11 +14497,11 @@ fn checkarrlitfits(c: *checker, arrtn: *node, rhs: *node) void = { if (!cskip) { cnt += 1u64; }; ce = ce.next; }; - if (cnt > arrtn.rhs.uval) { + if (cnt > declen) { cerr("array literal has "); cerr(strconv.u64tos(cnt, strconv.base.DEC)); cerr(" elements but declared array holds "); - cerr(strconv.u64tos(arrtn.rhs.uval, strconv.base.DEC)); + cerr(strconv.u64tos(declen, strconv.base.DEC)); cerr("\n"); c.errs += 1; return; diff --git a/test/wcc/951_defdim_struct_run.c b/test/wcc/951_defdim_struct_run.c new file mode 100644 index 00000000..51e40203 --- /dev/null +++ b/test/wcc/951_defdim_struct_run.c @@ -0,0 +1,254 @@ +/* + * 951_defdim_struct_run — runtime + byte-id net for #141: a struct + * field whose array dimension is a `def` (`[MAX]u8`, MAX a same-module + * def), not an integer literal. BOTH stages were wrong, oppositely: + * + * cstage LOUD-rejected ("array length must be an integer literal"). + * resolve_type's N_TARRAY arm folded only N_INTLIT dims; a def-ref + * fell through to the err. Root was a phase-ordering trap: def names + * weren't bound in scope when resolve_typedecl walked the struct + * body, so eval_def_const couldn't see MAX. Fix binds def-name stubs + * before type-body resolution, then folds the dim via eval_def_const. + * + * wwstage SILENTLY mis-laid-out the struct. astsize sized the def-dim + * field to 0 (only N_INTLIT dims were read), so the N_TSTRUCT + * `off += astsize(field)` loop gave the NEXT field the array's offset + * — the trailing scalar overlapped the array, reading/writing the + * wrong bytes (ken pdefM4: end != written). Fix routes every N_TARRAY + * length reader through a shared arrayelen() that folds the def. + * + * The TEETH row is the trailing scalar after the def-dim array: pre-fix + * ww read a corrupted `end`; post-fix it round-trips and cs==ww byte-id. + * Closes #13's def-dim half (the slice-repeat clause stays open). + * + * cstage `ww build` + run for exit code; w6c vs w6c_ww `.s` cmp for the + * rule-10 byte-id gate. The byte-id leg compiles the `ww build`-produced + * .combined.ww, not the raw src: w6c does no import resolution, so the + * cross-module row (C1, `import os`) only folds once concatenated, and a + * same-module row combines to itself. The last row is the ACTUAL + * path::buffer shape — a cross-module `os.PATH_MAX` def dimension (the + * N_DOT fold arm). u8 array elements + i32 trailing scalars only (the + * i32 return is MOVL/MOVSXD byte-id; see 949_dotbase_arr_run). + */ +#include +#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; +} + +struct row { const char *label; const char *src; int want_exit; }; + +static const struct row rows[] = { + /* TEETH: def-dim array FOLLOWED by a scalar; write both, read the + * scalar back. Pre-fix ww laid `end` at the array's offset (array + * sized 0) → end read garbage. Post-fix end at offset 4 → 42. */ + { "m4_end", + "package main;\n" + "def M: i32 = 4;\n" + "type t = struct { b: [M]u8, end: i32 };\n" + "export fn main() i32 = {\n" + " let s: t;\n" + " s.b[3] = 9u8;\n" + " s.end = 42;\n" + " return s.end;\n" + "};\n", 42 }, + /* the array element itself must survive too — read the last byte + * (pre-fix the overlapping `end` write would clobber it). */ + { "m4_belem", + "package main;\n" + "def M: i32 = 4;\n" + "type t = struct { b: [M]u8, end: i32 };\n" + "export fn main() i32 = {\n" + " let s: t;\n" + " s.b[3] = 200u8;\n" + " s.end = 7;\n" + " return s.b[3]: i32;\n" + "};\n", 200 }, + /* the ~4KB path::buffer shape — def MAX=4095, read the trailing + * scalar after a 4095-byte array. */ + { "m4095_end", + "package main;\n" + "def MAX: i32 = 4095;\n" + "type t = struct { b: [MAX]u8, end: i32 };\n" + "export fn main() i32 = {\n" + " let s: t;\n" + " s.b[4094] = 5u8;\n" + " s.end = 99;\n" + " return s.end;\n" + "};\n", 99 }, + /* two scalars after the def-dim array — pins the cumulative offset + * (a+c read their written values: 11+22=33). */ + { "twoafter", + "package main;\n" + "def M: i32 = 4;\n" + "type t = struct { b: [M]u8, a: i32, c: i32 };\n" + "export fn main() i32 = {\n" + " let s: t;\n" + " s.a = 11;\n" + " s.c = 22;\n" + " return s.a + s.c;\n" + "};\n", 33 }, + /* C1 (rob-mandatory): the ACTUAL path::buffer shape — a CROSS- + * MODULE def dimension. `def MAX = os.PATH_MAX - 1` folds an N_DOT + * (os.PATH_MAX) const-ref through eval_def_const's cross-module arm, + * which the same-module rows don't exercise. os.PATH_MAX is 4096, so + * MAX is 4095. Byte-id runs on the ww-build combined.ww (w6c alone + * does no import resolution, so it can't compile the raw `import os` + * source). */ + { "xmod_pathmax", + "package main;\n" + "import os;\n" + "def MAX: i32 = os.PATH_MAX - 1;\n" + "type t = struct { b: [MAX]u8, end: i32 };\n" + "export fn main() i32 = {\n" + " let s: t;\n" + " s.b[4094] = 7u8;\n" + " s.end = 77;\n" + " return s.end;\n" + "};\n", 77 }, + { NULL, NULL, 0 } +}; + +static int +slurp_eq(const char *a, const char *b) +{ + FILE *fa = fopen(a, "rb"); + FILE *fb = fopen(b, "rb"); + if (!fa || !fb) { if (fa) fclose(fa); if (fb) fclose(fb); return -1; } + int rc = 0; + for (;;) { + int ca = fgetc(fa); + int cb = fgetc(fb); + if (ca != cb) { rc = -1; break; } + if (ca == EOF) break; + } + fclose(fa); fclose(fb); + return rc; +} + +int +main(void) +{ + const char *bin = getenv("BIN"); + if (!bin) bin = "out/bin"; + char absbin[1024]; + if (bin[0] != '/') { + char cwd[1024]; + if (getcwd(cwd, sizeof cwd) == NULL) return 1; + snprintf(absbin, sizeof absbin, "%s/%s", cwd, bin); + bin = absbin; + } + + char w6c[1100], w6c_ww[1100]; + snprintf(w6c, sizeof w6c, "%s/w6c", bin); + snprintf(w6c_ww, sizeof w6c_ww, "%s/w6c_ww", bin); + if (access(w6c_ww, X_OK) != 0) { + fprintf(stderr, "defdim_struct: w6c_ww missing — cannot run " + "the cs==ww byte-id gate (the whole point of this test)\n"); + return 1; + } + + int n = 0, fail = 0; + for (int i = 0; rows[i].src; i++, n++) { + char src[64]; + snprintf(src, sizeof src, "/tmp/wwdds_%d_%d.ww", getpid(), i); + FILE *f = fopen(src, "wb"); + if (f == NULL) { fail++; continue; } + fputs(rows[i].src, f); + fclose(f); + + char tmpdir[64]; + snprintf(tmpdir, sizeof tmpdir, "/tmp/wwdds_%d_d_%d", + getpid(), i); + mkdir(tmpdir, 0755); + + char cmd[2048]; + snprintf(cmd, sizeof cmd, "cd %s && %s/ww build %s", + tmpdir, bin, src); + if (runwait(cmd) != 0) { + fprintf(stderr, "row[%s]: cstage build failed\n", + rows[i].label); + fail++; + unlink(src); rmdir(tmpdir); + continue; + } + + char base[64]; + const char *b = strrchr(src, '/'); + b = b ? b + 1 : src; + snprintf(base, sizeof base, "%s", b); + char *dot = strrchr(base, '.'); + if (dot && strcmp(dot, ".ww") == 0) *dot = '\0'; + + char outbin[160], combined[96], arto[96], arts[96]; + /* `ww build` writes the runnable binary into the build cwd + * (tmpdir) but its intermediates — the concatenated module + * source .combined.ww, plus .o/.s — next to the SOURCE. The + * byte-id leg compiles that combined form, not the raw src: + * w6c does no import resolution, so the cross-module row's + * `import os` only folds once concatenated. A same-module row + * combines to itself, so the one path serves every row. */ + snprintf(outbin, sizeof outbin, "%s/%s", tmpdir, base); + snprintf(combined, sizeof combined, + "/tmp/wwdds_%d_%d.combined.ww", getpid(), i); + snprintf(arto, sizeof arto, "/tmp/wwdds_%d_%d.o", getpid(), i); + snprintf(arts, sizeof arts, "/tmp/wwdds_%d_%d.s", getpid(), i); + + int got = runwait(outbin); + if (got != rows[i].want_exit) { + fprintf(stderr, "row[%s]: cstage exit %d, want %d\n", + rows[i].label, got, rows[i].want_exit); + fail++; + } + + char cs_s[64], ws_s[64]; + snprintf(cs_s, sizeof cs_s, "/tmp/wwdds_%d_%d_cs.s", + getpid(), i); + snprintf(ws_s, sizeof ws_s, "/tmp/wwdds_%d_%d_ww.s", + getpid(), i); + + snprintf(cmd, sizeof cmd, "%s -o %s %s 2>/dev/null", + w6c, cs_s, combined); + if (runwait(cmd) != 0) { + fprintf(stderr, "row[%s]: w6c failed\n", rows[i].label); + fail++; + } else { + snprintf(cmd, sizeof cmd, "%s -o %s %s 2>/dev/null", + w6c_ww, ws_s, combined); + if (runwait(cmd) != 0) { + fprintf(stderr, "row[%s]: w6c_ww failed\n", + rows[i].label); + fail++; + } else if (slurp_eq(cs_s, ws_s) != 0) { + fprintf(stderr, + "row[%s]: cstage/wwstage .s DIFFER " + "(rule-10 byte-id violation)\n", + rows[i].label); + fail++; + } + } + + unlink(outbin); rmdir(tmpdir); + unlink(combined); unlink(arto); unlink(arts); + unlink(src); unlink(cs_s); unlink(ws_s); + } + + if (fail) { + fprintf(stderr, "%d/%d defdim-struct tests failed\n", + fail, n); + return 1; + } + printf("defdim_struct: %d/%d ok (cstage run + cs==ww byte-id)\n", + n, n); + return 0; +}