Hojun-Cho
5abb1e6069
The last frontend-gap pin: wwstage had no Hare struct embedding
(struct { hash.hash, ... }), rejecting lib/crypto/sha256 at parse.
- parse.ww: the three member forms (named / anonymous struct / bare
dotted-ident embed), consume-then-branch since this parser has no
peek; embeds carry f.str == "" and the type in f.lhs.
- check.ww N_TSTRUCT flatten: promote the inner struct's flattened
fields at base+src.offset (check.c:961-990); the embed is one
nested-struct unit in the slot ladder; the resolved inner AST is
planted on the TFIELD rhs for cgen.
- check.ww walkers: astoffset / exprtype N_DOT / #251 struct-lit
field lookups descend embeds through shared helpers; the collision
and non-struct-embed rejects live in validatestructfields (the
once-per-decl diagnostic site).
- cgenutil.ww registerstruct: regfieldrun walks the AST against the
flattened tfield cursor, descending embeds via the planted inner
AST so promoted fieldinfo entries keep the inner field's own name
and type node.
- wwi printers unchanged (both stages already emit nameless fields).
sha256_test compiles byte-identically end to end and its 6 tests
pass; 989_lib_byteid is now 44 id / 0 divergent / 0 wwreject.
Fixtures r5913_* (promoted rw, offset shift, anonymous embed,
two-level embed + promoted fn-ptr callee, three rejects); corpus pin
1485/2970.
99 lines
1.7 KiB
Plaintext
99 lines
1.7 KiB
Plaintext
package wwfixture;
|
|
|
|
def protocolversion: i32 = 1;
|
|
def corpuscount: i32 = 1485;
|
|
def errorcount: i32 = 338;
|
|
def compilecount: i32 = 17;
|
|
def runcount: i32 = 191;
|
|
def runexitcount: i32 = 939;
|
|
def nativecount: i32 = 2970;
|
|
def corpushash: str = "69453e64f903a75b8a3f27c79e336ae766b3fb7ecfaac85d13f5d1f0c0dc4f50";
|
|
|
|
type directive = enum i32 {
|
|
ERROR = 0,
|
|
RUN = 1,
|
|
RUNEXIT = 2,
|
|
COMPILE = 3,
|
|
};
|
|
|
|
type stage = enum i32 {
|
|
C = 0,
|
|
WW = 1,
|
|
};
|
|
|
|
type phase = enum i32 {
|
|
COMPILE = 0,
|
|
BUILD = 1,
|
|
RUN = 2,
|
|
};
|
|
|
|
type verdict = enum i32 {
|
|
PASS = 0,
|
|
FAIL = 1,
|
|
ERROR = 2,
|
|
};
|
|
|
|
type termination = enum i32 {
|
|
EXIT = 0,
|
|
SIGNAL = 1,
|
|
TIMEOUT = 2,
|
|
SETUP = 3,
|
|
};
|
|
|
|
type fixture = struct {
|
|
name: str,
|
|
id: str,
|
|
source: str,
|
|
directive: directive,
|
|
diagnostic: str,
|
|
wwdiagnostic: str,
|
|
exitcode: i32,
|
|
};
|
|
|
|
type corpus = struct {
|
|
root: str,
|
|
fixtures: []fixture,
|
|
};
|
|
|
|
type identity = struct {
|
|
ordinal: i32,
|
|
fixtureindex: i32,
|
|
stage: stage,
|
|
};
|
|
|
|
type cellresult = struct {
|
|
ordinal: i32,
|
|
id: str,
|
|
stage: stage,
|
|
phase: phase,
|
|
verdict: verdict,
|
|
termination: termination,
|
|
code: i32,
|
|
durationns: i64,
|
|
capture: str,
|
|
};
|
|
|
|
fn stageword(s: stage) str = {
|
|
if (s == stage.C) { return "c"; };
|
|
return "ww";
|
|
};
|
|
|
|
fn phaseword(p: phase) str = {
|
|
if (p == phase.COMPILE) { return "compile"; };
|
|
if (p == phase.BUILD) { return "build"; };
|
|
return "run";
|
|
};
|
|
|
|
fn verdictword(v: verdict) str = {
|
|
if (v == verdict.PASS) { return "pass"; };
|
|
if (v == verdict.FAIL) { return "fail"; };
|
|
return "error";
|
|
};
|
|
|
|
fn terminationword(t: termination) str = {
|
|
if (t == termination.EXIT) { return "exit"; };
|
|
if (t == termination.SIGNAL) { return "signal"; };
|
|
if (t == termination.TIMEOUT) { return "timeout"; };
|
|
return "setup";
|
|
};
|