package structabi_test;

// Float-bearing struct-ABI byte-id + register-class gate. Port of the
// retired native carriers test/wcc/946_structparam_run.c (#165, the
// struct-PARAM SysV net) and test/wcc/946_structret_run.c (#171a, the
// struct-RETURN twin); every assertion preserved.
//
// For a pure internal ww call both ends ride the same (possibly
// wrong) registers, so runtime values AND cs==ww byte-id are
// necessary-not-sufficient: the genuine defect is SysV register-CLASS
// conformance, observable only in the emitted asm. Each row therefore
// compiles its inline source directly through w6c and w6c_ww
// (`-o out.s src.ww`), byte-ids the two .s (rule 10), and scans the
// cstage .s (byte-id makes the wwstage scan redundant, as in the C)
// for the SSE markers, PRESENT or ABSENT per row:
//
//   param rows — callee receive marker "MOVSD\tX0, -" scoped to the
//     TEXT main.use block. Scoping is load-bearing: main's own
//     float-literal init also emits MOVSD X0, -off(BP), so a
//     whole-file grep would not discriminate.
//   ret rows — producer marker "(BP), X0" scoped to TEXT main.mk
//     (its literal fills load via (SP), X0, never (BP)) plus consumer
//     marker "MOVSD\tX0, -" scoped to TEXT main,; SEND and RECV
//     presence must AGREE before comparing against the row polarity.
//
// The ABSENT rows prove the classification gate: pure-INT structs
// stay on the GP transport, and struct{f32,f32} (two f32 packing into
// ONE SSE eightbyte — deferred #165b/#171b) falls back to GP instead
// of wrongly riding two SSE regs.
//
// No runtime leg existed in the carriers (the sources embed value
// checks but were only ever compiled to .s; end-to-end values live in
// the r946_structparam_* / r946_structret_* fixtures) and none is
// invented here. Dropped machinery, not assertions: the hard
// w6c_ww-missing precondition (the Make target declares both tools; a
// missing driver still fails loudly in runcommand), getpid tmpdirs +
// rm/mkdir accounting (testenv.fresh/clean), and the 256KiB scan-
// buffer refusal (testenv.readfile is unbounded).

import os;
import os.exec;
import strings;
import testenv;
import time;

fn fail(label: str, why: str) void = {
	let m: str = strings.concat("structabi FAIL: ", label, " -- ", why,
		"\n");
	os.write(2, m.ptr, m.len: u64);
	assert(false);
};

fn tmo() time.duration = {
	return (180i64 * (time.second: i64)): time.duration;
};

fn emitstage(td: str, label: str, stage: str, drv: str,
	outname: str) void = {
	let av: []str = [];
	append(av, drv);
	append(av, "-o");
	append(av, outname);
	append(av, "src.ww");
	let co: testenv.commandout;
	testenv.runcommand(td, td, stage, av, tmo(), &co);
	let ok: bool = co.termination == exec.termination.EXIT && co.code == 0;
	if (!ok) { fail(label, strings.concat(stage, " compile failed")); };
};

// One function's TEXT block: [first `head` .. next "\nTEXT " after
// it), to EOF when it is the last block. A missing head is a scan
// error, never a silent ABSENT verdict.
fn textblock(label: str, s: str, head: str) str = {
	let hp: i32 = testenv.pos(s, head);
	if (hp < 0) {
		fail(label, strings.concat("cannot scan .s: no ", head));
	};
	let tail: str = strings.sub(s, hp, s.len);
	let rest: str = strings.sub(tail, 1, tail.len);
	let ep: i32 = testenv.pos(rest, "\nTEXT ");
	if (ep < 0) { return tail; };
	return strings.sub(tail, 0, ep + 1);
};

// Compile both stages and gate rule-10 byte identity; returns the
// cstage .s body for the marker scan.
fn buildpair(label: str, src: str, td: str) str = {
	testenv.writefile(strings.concat(td, "/src.ww"), src);
	emitstage(td, label, "cstage", testenv.driver("w6c"), "cs.s");
	emitstage(td, label, "wwstage", testenv.driver("w6c_ww"), "ws.s");
	let cs: str = testenv.readfile(strings.concat(td, "/cs.s"));
	let ws: str = testenv.readfile(strings.concat(td, "/ws.s"));
	if (!testenv.same(cs, ws)) {
		fail(label, "cstage/wwstage .s DIFFER (rule-10 byte-id violation)");
	};
	return cs;
};

fn paramrow(label: str, src: str, wantsse: i32) void = {
	let td: str = testenv.fresh();
	let cs: str = buildpair(label, src, td);
	let callee: str = textblock(label, cs, "TEXT main.use");
	let sse: i32 = 0;
	if (testenv.has(callee, "MOVSD\tX0, -")) { sse = 1; };
	if (sse != wantsse) {
		fail(label,
			"callee SSE receive polarity wrong (register-class discriminator)");
	};
	testenv.clean(td);
};

fn retrow(label: str, src: str, wantsse: i32) void = {
	let td: str = testenv.fresh();
	let cs: str = buildpair(label, src, td);
	let mk: str = textblock(label, cs, "TEXT main.mk");
	let mn: str = textblock(label, cs, "TEXT main,");
	let send: i32 = 0;
	if (testenv.has(mk, "(BP), X0")) { send = 1; };
	let recv: i32 = 0;
	if (testenv.has(mn, "MOVSD\tX0, -")) { recv = 1; };
	if (send != recv) {
		fail(label, "SEND and RECV SSE markers disagree");
	};
	if (send != wantsse) {
		fail(label,
			"struct return SSE polarity wrong (register-class discriminator)");
	};
	testenv.clean(td);
};

// #165 param rows: lone-f64 eightbytes ride X0/X1 on independent
// cursors; pure-INT and the f32f32 fallback stay GP-routed.
@test fn structparam() void = {
	paramrow("f64f64_arg", strings.concat(
		"package main;\n",
		"type pff = struct { a: f64, b: f64 };\n",
		"fn use(s: pff) f64 = { return s.a + s.b; };\n",
		"export fn main() i32 = {\n",
		"\tlet s: pff = pff { a = 3.0, b = 5.0 };\n",
		"\tif (use(s) != 8.0) { return 1; };\n",
		"\treturn 0;\n",
		"};\n"), 1);
	paramrow("f64i64_arg", strings.concat(
		"package main;\n",
		"type pfi = struct { a: f64, b: i64 };\n",
		"fn use(s: pfi) i64 = { return (s.a: i64) + s.b; };\n",
		"export fn main() i32 = {\n",
		"\tlet s: pfi = pfi { a = 3.0, b = 5 };\n",
		"\tif (use(s) != 8) { return 1; };\n",
		"\treturn 0;\n",
		"};\n"), 1);
	paramrow("i64f64_arg", strings.concat(
		"package main;\n",
		"type pif = struct { a: i64, b: f64 };\n",
		"fn use(s: pif) i64 = { return s.a + (s.b: i64); };\n",
		"export fn main() i32 = {\n",
		"\tlet s: pif = pif { a = 3, b = 5.0 };\n",
		"\tif (use(s) != 8) { return 1; };\n",
		"\treturn 0;\n",
		"};\n"), 1);
	paramrow("i64i64_arg", strings.concat(
		"package main;\n",
		"type pii = struct { a: i64, b: i64 };\n",
		"fn use(s: pii) i64 = { return s.a + s.b; };\n",
		"export fn main() i32 = {\n",
		"\tlet s: pii = pii { a = 3, b = 5 };\n",
		"\tif (use(s) != 8) { return 1; };\n",
		"\treturn 0;\n",
		"};\n"), 0);
	paramrow("f32f32_arg_fallback", strings.concat(
		"package main;\n",
		"type pf32 = struct { a: f32, b: f32 };\n",
		"fn use(s: pf32) i64 = { return (s.a: i64) + (s.b: i64); };\n",
		"export fn main() i32 = {\n",
		"\tlet s: pf32 = pf32 { a = 3.0f32, b = 5.0f32 };\n",
		"\tif (use(s) != 8) { return 1; };\n",
		"\treturn 0;\n",
		"};\n"), 0);
	paramrow("scalar_plus_f64f64", strings.concat(
		"package main;\n",
		"type pff = struct { a: f64, b: f64 };\n",
		"fn use(n: i64, s: pff) i64 = {\n",
		"\treturn n + (s.a: i64) + (s.b: i64);\n",
		"};\n",
		"export fn main() i32 = {\n",
		"\tlet s: pff = pff { a = 3.0, b = 5.0 };\n",
		"\tif (use(2, s) != 10) { return 1; };\n",
		"\treturn 0;\n",
		"};\n"), 1);
};

// #171a return rows: the return twin — lone-f64 eightbytes ride the
// SSE return cursor, GP cursor independent (f64i32's i32 rides AX).
@test fn structret() void = {
	retrow("f64f64_ret", strings.concat(
		"package main;\n",
		"type pff = struct { a: f64, b: f64 };\n",
		"fn mk() pff = { return pff { a = 3.0, b = 5.0 }; };\n",
		"export fn main() i32 = {\n",
		"\tlet s: pff = mk();\n",
		"\tif ((s.a: i64) + (s.b: i64) != 8) { return 1; };\n",
		"\treturn 0;\n",
		"};\n"), 1);
	retrow("f64i32_ret", strings.concat(
		"package main;\n",
		"type pfi = struct { a: f64, b: i32 };\n",
		"fn mk() pfi = { return pfi { a = 3.0, b = 5 }; };\n",
		"export fn main() i32 = {\n",
		"\tlet s: pfi = mk();\n",
		"\tif ((s.a: i64) + (s.b: i64) != 8) { return 1; };\n",
		"\treturn 0;\n",
		"};\n"), 1);
	retrow("i64f64_ret", strings.concat(
		"package main;\n",
		"type pif = struct { a: i64, b: f64 };\n",
		"fn mk() pif = { return pif { a = 3, b = 5.0 }; };\n",
		"export fn main() i32 = {\n",
		"\tlet s: pif = mk();\n",
		"\tif (s.a + (s.b: i64) != 8) { return 1; };\n",
		"\treturn 0;\n",
		"};\n"), 1);
	retrow("i64i64_ret", strings.concat(
		"package main;\n",
		"type pii = struct { a: i64, b: i64 };\n",
		"fn mk() pii = { return pii { a = 3, b = 5 }; };\n",
		"export fn main() i32 = {\n",
		"\tlet s: pii = mk();\n",
		"\tif (s.a + s.b != 8) { return 1; };\n",
		"\treturn 0;\n",
		"};\n"), 0);
	retrow("f32f32_ret_fallback", strings.concat(
		"package main;\n",
		"type pf32 = struct { a: f32, b: f32 };\n",
		"fn mk() pf32 = { return pf32 { a = 3.0f32, b = 5.0f32 }; };\n",
		"export fn main() i32 = {\n",
		"\tlet s: pf32 = mk();\n",
		"\tif ((s.a: i64) + (s.b: i64) != 8) { return 1; };\n",
		"\treturn 0;\n",
		"};\n"), 0);
};