Hojun-Cho
3ee1906497
fold-2 chunk C3 (drew's Fam8-13 plan): 8 alias value-row C drivers, 205 rows
re-homed with zero loss -- 177 value -> 8 test/lang/alias_*_test.ww @test
row-tables; 16 reject -> runww //ww:error carriers (both stages reject);
3 cs!=ww value rows -> 2 *_runonly_test.ww (T1, byte-id-excluded, #60/#81);
9 irreducible asymmetric rows -> slim C pins, each ticket-cited and
mutation-proven non-vacuous:
- accept amplen1/2,ampcap2: cs runs / ww rejects 'unsupported address-of
shape' (#96)
- cgen_b5 g73_heapfill: cs!=ww .s + ww link-fails on self-contained alloc;
compile-smoke pin (#24)
- cgen_b6 fsarg2_bound: both reject, different msgs, each vs the correct
stage (#271/#165 cs vs #272/#276/#277 ww)
- emit_b7 slc/slcstr/slctag _2lvl + slc_plain_ctl: slice-literal static-init
divergence (#120/#29-kin, ken-d2-oracle)
4 fully-migrated drivers deleted, 4 slimmed-in-place to hold only the
irreducible pins. LANGBYTEID floor 74->82 (8 new byte-id @test files); test
count 388->384 (4 deleted; 4 slimmed kept). do-not-auto-batch files not in
Fam10.
129 lines
3.7 KiB
C
129 lines
3.7 KiB
C
/*
|
|
* 944_alias_cgen_b6_run — SLIM CARRIER (#5-C3 alias fold-2). The 23 K_RUN value
|
|
* rows migrated to test/lang/alias_cgen_b6_test.ww (@test, cs==ww byte-id); the
|
|
* symmetric K_BUILDERR rejects (fsarg0_loud_ctl, try_loud_38b) to
|
|
* test/wcc/data/alias_{fsarg0_loud,try_loud_38b}/case.ww runww.
|
|
*
|
|
* What survives here is the one IRREDUCIBLE Group-B row: BOTH stages reject the
|
|
* same input but with DIFFERENT diagnostics — a held cs!=ww divergence (a
|
|
* rule-10 smell, tracked not silently merged). A single-substring runww
|
|
* //ww:error would erase the distinction; this carrier asserts EACH stage's own
|
|
* substring. cstage rejects with the #271/#165 SSE-eightbyte-transport reason;
|
|
* wwstage rejects with the #272/#276/#277 aggregate-return scalar-default
|
|
* reason (the float-bearing alias struct arg from a non-ident source).
|
|
*/
|
|
#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;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
/* cstage (w6c) rejects with cserr; wwstage (w6c_ww) rejects with wwerr. */
|
|
static int
|
|
run_row(const char *bin, const char *label, const char *src,
|
|
const char *cserr, const char *wwerr, int i)
|
|
{
|
|
char dir[96], srcf[160], cse[160], wwe[160], ss[160], rm[200], cmd[2048];
|
|
snprintf(dir, sizeof dir, "/tmp/ab6_%d_%d", getpid(), i);
|
|
mkdir(dir, 0755);
|
|
snprintf(srcf, sizeof srcf, "%s/c.ww", dir);
|
|
snprintf(cse, sizeof cse, "%s/cs.err", dir);
|
|
snprintf(wwe, sizeof wwe, "%s/ww.err", dir);
|
|
snprintf(ss, sizeof ss, "%s/o.s", dir);
|
|
snprintf(rm, sizeof rm, "rm -rf %s", dir);
|
|
|
|
FILE *f = fopen(srcf, "wb");
|
|
if (!f) { runwait(rm); return -1; }
|
|
fputs(src, f);
|
|
fclose(f);
|
|
|
|
int ok = 1;
|
|
snprintf(cmd, sizeof cmd, "%s/w6c -o %s %s 2>%s", bin, ss, srcf, cse);
|
|
int crc = runwait(cmd);
|
|
if (!(crc != 0 && errlog_has(cse, cserr))) {
|
|
fprintf(stderr, "row[%s]: cstage expected reject \"%s\" (rc=%d)\n",
|
|
label, cserr, crc);
|
|
ok = 0;
|
|
}
|
|
snprintf(cmd, sizeof cmd, "%s/w6c_ww -o %s %s 2>%s", bin, ss, srcf, wwe);
|
|
int wrc = runwait(cmd);
|
|
if (!(wrc != 0 && errlog_has(wwe, wwerr))) {
|
|
fprintf(stderr, "row[%s]: wwstage expected reject \"%s\" (rc=%d)\n",
|
|
label, wwerr, wrc);
|
|
ok = 0;
|
|
}
|
|
runwait(rm);
|
|
return ok ? 0 : 1;
|
|
}
|
|
|
|
struct row { const char *label; const char *src; const char *cserr;
|
|
const char *wwerr; };
|
|
|
|
static const struct row rows[] = {
|
|
{ "fsarg2_bound",
|
|
"package main;\n"
|
|
"type fs0 = struct { x: f64 };\n"
|
|
"type fs = fs0;\n"
|
|
"fn mk() fs = {\n"
|
|
" let s: fs; s.x = 2.5;\n"
|
|
" return s;\n"
|
|
"};\n"
|
|
"fn g(p: fs) f64 = { return p.x; };\n"
|
|
"export fn main() i32 = {\n"
|
|
" if (g(mk()) != 2.5) { return 1; };\n"
|
|
" return 0;\n"
|
|
"};\n",
|
|
"#271/#165: float-bearing struct arg from a non-ident source",
|
|
"#272/#276/#277: aggregate return reaches scalar default" },
|
|
};
|
|
|
|
int
|
|
main(void)
|
|
{
|
|
const char *bin = getenv("BIN");
|
|
if (!bin) bin = "out/bin";
|
|
char absbin[2080];
|
|
if (bin[0] != '/') {
|
|
char cwd[1024];
|
|
if (getcwd(cwd, sizeof cwd) == NULL) return 1;
|
|
snprintf(absbin, sizeof absbin, "%s/%s", cwd, bin);
|
|
bin = absbin;
|
|
}
|
|
|
|
int n = (int)(sizeof rows / sizeof rows[0]);
|
|
int fail = 0;
|
|
for (int i = 0; i < n; i++)
|
|
if (run_row(bin, rows[i].label, rows[i].src, rows[i].cserr,
|
|
rows[i].wwerr, i) != 0)
|
|
fail++;
|
|
|
|
if (fail) {
|
|
fprintf(stderr, "alias_cgen_b6 (slim): %d/%d rows failed\n", fail, n);
|
|
return 1;
|
|
}
|
|
printf("alias_cgen_b6 (slim): %d/%d ok\n", n, n);
|
|
return 0;
|
|
}
|