Hojun-Cho
912b9acef6
A BUILD_FAIL row now asserts the expected stderr substring on both stages (the #35 cite on the range form included) — without it a row passes vacuously on any unrelated build failure. The new delete_in_loop row drains [1,2,3,4] to empty via repeated delete(xs[0]) with base-4 positional accumulation, pinning the len bookkeeping under iteration. 38 -> 41 fixtures.
484 lines
15 KiB
C
484 lines
15 KiB
C
/*
|
|
* 804_delete_elem — cstage and wwstage agree, byte-for-byte and at
|
|
* runtime, that `delete(xs[i])` removes element i from a slice: the
|
|
* tail [i+1..len) shifts down one stride, len -= 1, cap unchanged
|
|
* (the delete-half of task #35; insert() stays deferred; regex
|
|
* fold-2b's delete_thread/failed-thread/PC-dedup consumers).
|
|
*
|
|
* Lowering (BOTH stages, converged byte-identical by construction —
|
|
* there was no pre-existing reference side): push i and &hdr, then an
|
|
* ascending word-copy loop moves element j+1 onto element j until
|
|
* j >= len-1, then hdr.len -= 1. The element move is a same-type
|
|
* whole-stride byte copy — src and dst are elements of the SAME
|
|
* slice, so no boxing/coercion exists for any element kind; the rows
|
|
* below prove that across scalar (8B), narrow (4B/1B — the MOVL/MOVB
|
|
* copy tails), str (24B header), struct (16B) and tagged (56B) esz.
|
|
* esz comes off the STAMPED base type (the #34/#48 discipline), so a
|
|
* named-alias element cannot mis-stride.
|
|
*
|
|
* Hare's delete also accepts the range form delete(xs[i..j])
|
|
* (ref/harec/src/check.c:1981-2027 EXPR_SLICE). Out of scope here —
|
|
* checker loud-rejects it (reject_range row); filed on #35.
|
|
*
|
|
* row | shape | want
|
|
* ----------------+----------------------------------------+------
|
|
* i64_first | [7,11,13], delete(xs[0]) | 44
|
|
* i64_middle | [7,11,13], delete(xs[1]) | 40
|
|
* i64_last | [7,11,13], delete(xs[2]) (no copy, | 38
|
|
* | loop body never runs) |
|
|
* i32_narrow | []i32 esz=4 — the MOVL copy tail | 229
|
|
* u8_narrow | []u8 esz=1 — the MOVB copy tail | 28
|
|
* cap_unchanged | manual {ptr,len=3,cap=8} header over a | 91
|
|
* | stack backing; delete middle; cap must |
|
|
* | still read 8, tail value intact |
|
|
* delete_to_empty | 1-element slice, delete(xs[0]), len=0 | 7
|
|
* str_elem | []str esz=24 — 3-qword header moves | 234
|
|
* | whole |
|
|
* tagged_56b | [](s6|bool) esz=56 — 7-qword raw move, | 231
|
|
* | tag+payload survive; match head + |
|
|
* | raw-byte tail readback (#43 caveat) |
|
|
* regex_shape | delete((*threads)[i]) behind *[]thread |
|
|
* | — the fold-2b delete_thread shape | 24
|
|
* | (deref-of-local base, struct element) |
|
|
* delete_in_loop | drain [1,2,3,4] to empty via repeated | 112
|
|
* | delete(xs[0]) — len bookkeeping under |
|
|
* | iteration, base-4 order accumulation |
|
|
* reject_array | delete(t[0]) on [3]i64 — "delete must | BUILD_FAIL
|
|
* | operate on a slice" |
|
|
* reject_nonindex | delete(xs) — operand must be xs[i] | BUILD_FAIL
|
|
* reject_range | delete(xs[0:2]) — range form deferred, | BUILD_FAIL
|
|
* | message must cite task #35 |
|
|
* reject_arity | delete(xs[0], xs[1]) | BUILD_FAIL
|
|
*
|
|
* BUILD_FAIL rows also assert the diagnostic TEXT (stderr substring,
|
|
* both stages) — a build that fails for any other reason (parse error,
|
|
* crash) is a vacuous reject and fails the row.
|
|
*
|
|
* Every non-BUILD_FAIL row also asserts cstage/wwstage asm byte-id,
|
|
* which subsumes the frame canary (TEXT main,$N) and the del_l/del_e
|
|
* label-counter symmetry.
|
|
*/
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.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;
|
|
}
|
|
|
|
/* want == BUILD_FAIL: the row must FAIL to build on both stages AND
|
|
* emit expect_err on stderr (the checker reject set — message text
|
|
* included, esp. the #35 cite on the deferred range form — is part of
|
|
* the contract: rule 7, never a silent acceptance; without the message
|
|
* check a row would pass vacuously on any unrelated build failure). */
|
|
#define BUILD_FAIL (-2147483647 - 1)
|
|
|
|
struct row {
|
|
const char *label;
|
|
const char *src;
|
|
int want;
|
|
const char *expect_err; /* BUILD_FAIL rows: required stderr substring */
|
|
};
|
|
|
|
static const struct row rows[] = {
|
|
{ "i64_first",
|
|
"package main;\n"
|
|
"export fn main() i32 = {\n"
|
|
"\tlet xs: []i64 = [];\n"
|
|
"\tappend(xs, 7);\n"
|
|
"\tappend(xs, 11);\n"
|
|
"\tappend(xs, 13);\n"
|
|
"\tdelete(xs[0]);\n"
|
|
"\treturn (xs[0] + xs[1]): i32 + len(xs)*10;\n"
|
|
"};\n",
|
|
44, NULL },
|
|
|
|
{ "i64_middle",
|
|
"package main;\n"
|
|
"export fn main() i32 = {\n"
|
|
"\tlet xs: []i64 = [];\n"
|
|
"\tappend(xs, 7);\n"
|
|
"\tappend(xs, 11);\n"
|
|
"\tappend(xs, 13);\n"
|
|
"\tdelete(xs[1]);\n"
|
|
"\treturn (xs[0] + xs[1]): i32 + len(xs)*10;\n"
|
|
"};\n",
|
|
40, NULL },
|
|
|
|
{ "i64_last",
|
|
"package main;\n"
|
|
"export fn main() i32 = {\n"
|
|
"\tlet xs: []i64 = [];\n"
|
|
"\tappend(xs, 7);\n"
|
|
"\tappend(xs, 11);\n"
|
|
"\tappend(xs, 13);\n"
|
|
"\tdelete(xs[2]);\n"
|
|
"\treturn (xs[0] + xs[1]): i32 + len(xs)*10;\n"
|
|
"};\n",
|
|
38, NULL },
|
|
|
|
{ "i32_narrow",
|
|
"package main;\n"
|
|
"export fn main() i32 = {\n"
|
|
"\tlet xs: []i32 = [];\n"
|
|
"\tappend(xs, 4i32);\n"
|
|
"\tappend(xs, 9i32);\n"
|
|
"\tappend(xs, 2i32);\n"
|
|
"\tdelete(xs[0]);\n"
|
|
"\treturn xs[0] + xs[1]*10 + len(xs)*100;\n"
|
|
"};\n",
|
|
229, NULL },
|
|
|
|
{ "u8_narrow",
|
|
"package main;\n"
|
|
"export fn main() i32 = {\n"
|
|
"\tlet xs: []u8 = [];\n"
|
|
"\tappend(xs, 5u8);\n"
|
|
"\tappend(xs, 9u8);\n"
|
|
"\tappend(xs, 3u8);\n"
|
|
"\tdelete(xs[1]);\n"
|
|
"\treturn (xs[0] + xs[1]): i32 + len(xs)*10;\n"
|
|
"};\n",
|
|
28, NULL },
|
|
|
|
{ "cap_unchanged",
|
|
"package main;\n"
|
|
"export fn main() i32 = {\n"
|
|
"\tlet hb: [8]u8; hb[0] = 4u8; hb[1] = 6u8; hb[2] = 9u8;\n"
|
|
"\tlet xs: []u8; xs.ptr = &hb[0]; xs.len = 3; xs.cap = 8;\n"
|
|
"\tdelete(xs[1]);\n"
|
|
"\treturn (xs.cap*10 + xs.len): i32 + xs[1]: i32;\n"
|
|
"};\n",
|
|
91, NULL },
|
|
|
|
{ "delete_to_empty",
|
|
"package main;\n"
|
|
"export fn main() i32 = {\n"
|
|
"\tlet xs: []u8 = [];\n"
|
|
"\tappend(xs, 5u8);\n"
|
|
"\tdelete(xs[0]);\n"
|
|
"\treturn len(xs) + 7;\n"
|
|
"};\n",
|
|
7, NULL },
|
|
|
|
{ "str_elem",
|
|
"package main;\n"
|
|
"export fn main() i32 = {\n"
|
|
"\tlet xs: []str = [];\n"
|
|
"\tlet a: str = \"abc\";\n"
|
|
"\tlet b: str = \"de\";\n"
|
|
"\tlet g: str = \"fghi\";\n"
|
|
"\tappend(xs, a);\n"
|
|
"\tappend(xs, b);\n"
|
|
"\tappend(xs, g);\n"
|
|
"\tdelete(xs[1]);\n"
|
|
"\treturn (xs[0].len*10 + xs[1].len): i32 + len(xs)*100;\n"
|
|
"};\n",
|
|
234, NULL },
|
|
|
|
/* 56B element: tag qword + 48B struct payload — seven whole-qword
|
|
* moves; tag AND payload must both survive the raw move (a tagged
|
|
* element at rest is just bytes; no boxing on a same-slice move).
|
|
* Readback is split: match proves tag + head (s.a), and the tail
|
|
* qword (f, element byte 48 -> absolute byte 104 of element 1) is
|
|
* read RAW via a *u8 over xs.ptr — the indexed-match payload
|
|
* cursor itself truncates past 32B (pre-existing, task #43), so a
|
|
* match on s.f would mis-fail regardless of the move. Verified
|
|
* truncation-free against a no-delete control. */
|
|
{ "tagged_56b",
|
|
"package main;\n"
|
|
"type s6 = struct { a: i64, b: i64, c: i64, d: i64, e: i64, f: i64 };\n"
|
|
"type cell = (s6 | bool);\n"
|
|
"export fn main() i32 = {\n"
|
|
"\tlet xs: []cell = [];\n"
|
|
"\tlet p0: s6 = s6 { a = 1, b = 2, c = 3, d = 4, e = 5, f = 6 };\n"
|
|
"\tlet p1: s6 = s6 { a = 7, b = 8, c = 9, d = 10, e = 11, f = 12 };\n"
|
|
"\tlet p2: s6 = s6 { a = 13, b = 14, c = 15, d = 16, e = 17, f = 18 };\n"
|
|
"\tappend(xs, p0);\n"
|
|
"\tappend(xs, p1);\n"
|
|
"\tappend(xs, p2);\n"
|
|
"\tdelete(xs[1]);\n"
|
|
"\tlet r: i32 = 0;\n"
|
|
"\tmatch (xs[1]) {\n"
|
|
"\tcase let s: s6 => r = s.a: i32;\n"
|
|
"\tcase bool => r = 99;\n"
|
|
"\t};\n"
|
|
"\tlet bp: *u8 = xs.ptr: *u8;\n"
|
|
"\tr += bp[104]: i32;\n"
|
|
"\treturn r + len(xs)*100;\n"
|
|
"};\n",
|
|
231, NULL },
|
|
|
|
/* The fold-2b consumer shape: regex.ha:547-551 delete_thread takes
|
|
* threads: *[]thread and deletes through the pointer. ww spells the
|
|
* autoderef explicitly: delete((*threads)[i]). */
|
|
{ "regex_shape",
|
|
"package main;\n"
|
|
"type thread = struct { pc: i64, matched: bool };\n"
|
|
"fn delete_thread(i: i64, threads: *[]thread) void = {\n"
|
|
"\tdelete((*threads)[i]);\n"
|
|
"};\n"
|
|
"export fn main() i32 = {\n"
|
|
"\tlet xs: []thread = [];\n"
|
|
"\tappend(xs, thread { pc = 1, matched = false });\n"
|
|
"\tappend(xs, thread { pc = 2, matched = false });\n"
|
|
"\tappend(xs, thread { pc = 3, matched = false });\n"
|
|
"\tdelete_thread(1, &xs);\n"
|
|
"\tlet r: i32 = (xs[0].pc + xs[1].pc): i32;\n"
|
|
"\treturn r + len(xs)*10;\n"
|
|
"};\n",
|
|
24, NULL },
|
|
|
|
/* Pins the len bookkeeping under iteration: each pass reads the
|
|
* new head then deletes it; base-4 positional accumulation makes
|
|
* any wrong order, double-shift, or stale len visible (a stuck
|
|
* len would never terminate; the row would time out as a wrong
|
|
* exit via the harness). 1,2,3,4 -> ((1*4+2)*4+3)*4+4 = 112. */
|
|
{ "delete_in_loop",
|
|
"package main;\n"
|
|
"export fn main() i32 = {\n"
|
|
"\tlet xs: []i64 = [];\n"
|
|
"\tappend(xs, 1);\n"
|
|
"\tappend(xs, 2);\n"
|
|
"\tappend(xs, 3);\n"
|
|
"\tappend(xs, 4);\n"
|
|
"\tlet acc: i64 = 0;\n"
|
|
"\tfor (len(xs) > 0) {\n"
|
|
"\t\tacc = acc*4 + xs[0];\n"
|
|
"\t\tdelete(xs[0]);\n"
|
|
"\t};\n"
|
|
"\treturn acc: i32 + len(xs)*1000;\n"
|
|
"};\n",
|
|
112, NULL },
|
|
|
|
{ "reject_array",
|
|
"package main;\n"
|
|
"export fn main() i32 = {\n"
|
|
"\tlet t: [3]i64 = [1, 2, 3];\n"
|
|
"\tdelete(t[0]);\n"
|
|
"\treturn 0;\n"
|
|
"};\n",
|
|
BUILD_FAIL, "delete must operate on a slice" },
|
|
|
|
{ "reject_nonindex",
|
|
"package main;\n"
|
|
"export fn main() i32 = {\n"
|
|
"\tlet xs: []u8 = [];\n"
|
|
"\tappend(xs, 5u8);\n"
|
|
"\tdelete(xs);\n"
|
|
"\treturn 0;\n"
|
|
"};\n",
|
|
BUILD_FAIL, "delete: operand must be an indexing expression" },
|
|
|
|
{ "reject_range",
|
|
"package main;\n"
|
|
"export fn main() i32 = {\n"
|
|
"\tlet xs: []u8 = [];\n"
|
|
"\tappend(xs, 5u8);\n"
|
|
"\tappend(xs, 6u8);\n"
|
|
"\tdelete(xs[0:2]);\n"
|
|
"\treturn 0;\n"
|
|
"};\n",
|
|
BUILD_FAIL, "range form delete(xs[i..j]) unimplemented (task #35)" },
|
|
|
|
{ "reject_arity",
|
|
"package main;\n"
|
|
"export fn main() i32 = {\n"
|
|
"\tlet xs: []u8 = [];\n"
|
|
"\tappend(xs, 5u8);\n"
|
|
"\tappend(xs, 6u8);\n"
|
|
"\tdelete(xs[0], xs[1]);\n"
|
|
"\treturn 0;\n"
|
|
"};\n",
|
|
BUILD_FAIL, "delete: takes exactly one argument" },
|
|
};
|
|
|
|
/* errlog_has — the build-failure stderr must carry the row's expected
|
|
* diagnostic; any other failure (parse error, crash) is a vacuous
|
|
* reject and must not pass. */
|
|
static int
|
|
errlog_has(const char *path, const char *needle)
|
|
{
|
|
FILE *f = fopen(path, "rb");
|
|
if (!f) return 0;
|
|
char buf[8192];
|
|
size_t got = fread(buf, 1, sizeof buf - 1, f);
|
|
fclose(f);
|
|
buf[got] = '\0';
|
|
return strstr(buf, needle) != NULL;
|
|
}
|
|
|
|
static int
|
|
run_driver(const char *driver, const struct row *r, int i)
|
|
{
|
|
char src[64], tmpdir[64], errlog[80], cmd[1200];
|
|
snprintf(src, sizeof src, "/tmp/dele_%d_%d.ww", getpid(), i);
|
|
snprintf(tmpdir, sizeof tmpdir, "/tmp/dele_%d_d_%d", getpid(), i);
|
|
snprintf(errlog, sizeof errlog, "%s.err", src);
|
|
|
|
FILE *f = fopen(src, "wb");
|
|
if (!f) return -1;
|
|
fputs(r->src, f);
|
|
fclose(f);
|
|
|
|
mkdir(tmpdir, 0755);
|
|
snprintf(cmd, sizeof cmd, "cd %s && %s build %s 2>%s",
|
|
tmpdir, driver, src, errlog);
|
|
if (runwait(cmd) != 0) {
|
|
int rc = -1;
|
|
if (r->want != BUILD_FAIL) {
|
|
fprintf(stderr, "row[%s]: build via %s failed\n",
|
|
r->label, driver);
|
|
} else if (r->expect_err &&
|
|
!errlog_has(errlog, r->expect_err)) {
|
|
fprintf(stderr, "row[%s]: %s build failed without "
|
|
"expected diagnostic \"%s\"\n",
|
|
r->label, driver, r->expect_err);
|
|
rc = -3; /* failed, but for the wrong reason */
|
|
}
|
|
unlink(src); unlink(errlog); rmdir(tmpdir);
|
|
return rc;
|
|
}
|
|
|
|
const char *base = strrchr(src, '/');
|
|
base = base ? base + 1 : src;
|
|
char outbin[128];
|
|
snprintf(outbin, sizeof outbin, "%s/%s", tmpdir, base);
|
|
char *dot = strrchr(outbin, '.');
|
|
if (dot && strcmp(dot, ".ww") == 0) *dot = '\0';
|
|
int got = runwait(outbin);
|
|
|
|
unlink(src); unlink(errlog); unlink(outbin); rmdir(tmpdir);
|
|
return got;
|
|
}
|
|
|
|
/* asm_byte_identical — generate .s via cstage's w6c and wwstage's
|
|
* w6c_ww and diff. Both delete lowerings are written fresh, so this is
|
|
* the converged-by-construction gate: any drift in the shift loop, the
|
|
* del_l/del_e label sequence, or the esz word-copy shows here. */
|
|
static int
|
|
asm_byte_identical(const char *bin, const struct row *r, int i)
|
|
{
|
|
char src[64], cs[64], ws[64], cmd[1024];
|
|
snprintf(src, sizeof src, "/tmp/dele_asm_%d_%d.ww", getpid(), i);
|
|
snprintf(cs, sizeof cs, "/tmp/dele_asm_%d_%d_c.s", getpid(), i);
|
|
snprintf(ws, sizeof ws, "/tmp/dele_asm_%d_%d_w.s", getpid(), i);
|
|
|
|
FILE *f = fopen(src, "wb");
|
|
if (!f) return -1;
|
|
fputs(r->src, f);
|
|
fclose(f);
|
|
|
|
snprintf(cmd, sizeof cmd, "%s/w6c -o %s %s 2>/dev/null", bin, cs, src);
|
|
if (runwait(cmd) != 0) {
|
|
fprintf(stderr, "row[%s]: w6c errored\n", r->label);
|
|
unlink(src);
|
|
return -1;
|
|
}
|
|
snprintf(cmd, sizeof cmd, "%s/w6c_ww -o %s %s 2>/dev/null",
|
|
bin, ws, src);
|
|
if (runwait(cmd) != 0) {
|
|
fprintf(stderr, "row[%s]: w6c_ww errored\n", r->label);
|
|
unlink(src); unlink(cs);
|
|
return -1;
|
|
}
|
|
|
|
FILE *fc = fopen(cs, "rb");
|
|
FILE *fw = fopen(ws, "rb");
|
|
int rc = 0;
|
|
if (!fc || !fw) {
|
|
rc = -1;
|
|
} else {
|
|
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);
|
|
if (rc != 0)
|
|
fprintf(stderr, "row[%s]: cstage vs wwstage asm differs\n",
|
|
r->label);
|
|
unlink(src); unlink(cs); unlink(ws);
|
|
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 cdrv[1024];
|
|
snprintf(cdrv, sizeof cdrv, "%s/ww", bin);
|
|
char wdrv[1024];
|
|
snprintf(wdrv, sizeof wdrv, "%s/ww_ww", bin);
|
|
|
|
struct { const char *name; const char *path; int gated_on_existence; }
|
|
drivers[] = {
|
|
{ "cstage", cdrv, 0 },
|
|
{ "wwstage", wdrv, 1 },
|
|
{ NULL, NULL, 0 },
|
|
};
|
|
|
|
int n = (int)(sizeof rows / sizeof rows[0]);
|
|
int total = 0, fail = 0;
|
|
|
|
for (int d = 0; drivers[d].name; d++) {
|
|
if (drivers[d].gated_on_existence
|
|
&& access(drivers[d].path, X_OK) != 0) {
|
|
fprintf(stderr, "delete_elem: skip %s (no %s)\n",
|
|
drivers[d].name, drivers[d].path);
|
|
continue;
|
|
}
|
|
for (int i = 0; i < n; i++) {
|
|
int got = run_driver(drivers[d].path, &rows[i], i);
|
|
total++;
|
|
int bad = rows[i].want == BUILD_FAIL
|
|
? (got != -1) : (got != rows[i].want);
|
|
if (bad) {
|
|
fprintf(stderr,
|
|
"delete_elem[%s][%s]: exit=%d want=%d\n",
|
|
drivers[d].name, rows[i].label,
|
|
got, rows[i].want);
|
|
fail++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (access(wdrv, X_OK) == 0) {
|
|
for (int i = 0; i < n; i++) {
|
|
if (rows[i].want == BUILD_FAIL)
|
|
continue;
|
|
total++;
|
|
if (asm_byte_identical(bin, &rows[i], i) != 0)
|
|
fail++;
|
|
}
|
|
}
|
|
|
|
if (fail) {
|
|
fprintf(stderr,
|
|
"delete_elem: %d/%d fixtures failed\n", fail, total);
|
|
return 1;
|
|
}
|
|
printf("delete_elem: %d fixtures passed\n", total);
|
|
return 0;
|
|
}
|