ww: rename toolchain to w-prefix + hare-style build/run/test driver
Plan 9-style w-prefix on the per-arch tools, disambiguating from the
real Plan 9 6c/6a/6l in ref/plan9front/:
cmd/wwc/ → cmd/wcc/ libwwc.a → libwcc.a
cmd/6{c,a,l} → cmd/w6{c,a,l} binary names too
test/wwc/ → test/wcc/ 6 test files w/ w6 prefix
selfhost/cmd mirror in lockstep
bootstrap/amd64/{w6c,w6a,w6l} snapshot binaries (gitignored)
WW_6{C,A,L} → WW_W6{C,A,L} env-var overrides
Plan 9 source-tree refs ("Plan 9 6c shape", ref/plan9front/, etc.)
preserved. Hare-style driver, both C and ww sides:
ww test [path] discover *_test.ww in a directory module, run
each; single-file mode for `ww test foo.ww`
Module-by-name `ww build foo` resolves to foo.ww or foo/foo.ww
via search path (cwd : -I dirs : $WW_LIB)
Default-to-cwd `ww build` / `ww test` build the cwd module
Run pass-through `ww run path arg1 arg2` reaches the program
lib/os: getcwd (79) and getdents64 (217) syscalls power `.` resolution
and directory enumeration on the ww side.
Makefile: wwstage tool deps now include lib/os/os.ww (+ lib/strconv
for wwdump_ww) so lib/* edits force their rebuild instead of leaving
stale binaries — surfaced when test 995 first failed against a stale
w6c_ww built before the lib/os additions.
Test 993 byte-identical parity gate (C-side ww vs ww-side ww_ww on a
build corpus) stays green; all 19 tests pass.
This commit is contained in:
394
selfhost/cmd/wcc/tok.ww
Normal file
394
selfhost/cmd/wcc/tok.ww
Normal file
@@ -0,0 +1,394 @@
|
||||
// selfhost/cmd/wcc/tok.ww — port of cmd/wcc/tok.c plus the Tkind /
|
||||
// Tok / Pos shapes from cmd/wcc/ww.h.
|
||||
//
|
||||
// Token kind values must stay numerically equal to the C side: the
|
||||
// 990_selfhost test diffs ww-side wwdump output against C-side
|
||||
// wwdump output, byte-for-byte. Reordering this list shifts the
|
||||
// integers and breaks the diff.
|
||||
//
|
||||
// Bottom of file: tokprint, which emits one token per line in a
|
||||
// format identical to cmd/wcc/tok.c:tokprint().
|
||||
|
||||
use os;
|
||||
use strconv;
|
||||
|
||||
// ---- Tkind ------------------------------------------------------------
|
||||
// Mirror of the C enum in cmd/wcc/ww.h. Don't reorder.
|
||||
|
||||
def TK_NONE: i32 = 0;
|
||||
def TK_EOF: i32 = 1;
|
||||
def TK_ERR: i32 = 2;
|
||||
def TK_IDENT: i32 = 3;
|
||||
def TK_INT: i32 = 4;
|
||||
def TK_FLOAT: i32 = 5;
|
||||
def TK_RUNE: i32 = 6;
|
||||
def TK_STR: i32 = 7;
|
||||
|
||||
def TK_FN: i32 = 8;
|
||||
def TK_LET: i32 = 9;
|
||||
def TK_DEF: i32 = 10;
|
||||
def TK_IF: i32 = 11;
|
||||
def TK_ELSE: i32 = 12;
|
||||
def TK_FOR: i32 = 13;
|
||||
def TK_SWITCH: i32 = 14;
|
||||
def TK_CASE: i32 = 15;
|
||||
def TK_RETURN: i32 = 16;
|
||||
def TK_USE: i32 = 17;
|
||||
def TK_TYPE: i32 = 18;
|
||||
def TK_STRUCT: i32 = 19;
|
||||
def TK_DEFER: i32 = 20;
|
||||
def TK_BREAK: i32 = 21;
|
||||
def TK_CONTINUE: i32 = 22;
|
||||
def TK_EXPORT: i32 = 23;
|
||||
def TK_PROC: i32 = 24;
|
||||
def TK_CHAN: i32 = 25;
|
||||
def TK_NIL: i32 = 26;
|
||||
def TK_TRUE: i32 = 27;
|
||||
def TK_FALSE: i32 = 28;
|
||||
def TK_AS: i32 = 29;
|
||||
def TK_STATIC: i32 = 30;
|
||||
def TK_MATCH: i32 = 31;
|
||||
|
||||
def TK_LPAREN: i32 = 32;
|
||||
def TK_RPAREN: i32 = 33;
|
||||
def TK_LBRACE: i32 = 34;
|
||||
def TK_RBRACE: i32 = 35;
|
||||
def TK_LBRACK: i32 = 36;
|
||||
def TK_RBRACK: i32 = 37;
|
||||
def TK_COMMA: i32 = 38;
|
||||
def TK_SEMI: i32 = 39;
|
||||
def TK_COLON: i32 = 40;
|
||||
def TK_DOT: i32 = 41;
|
||||
def TK_ELLIPSIS: i32 = 42;
|
||||
def TK_DOTDOT: i32 = 43;
|
||||
def TK_AT: i32 = 44;
|
||||
def TK_QUESTION: i32 = 45;
|
||||
|
||||
def TK_ASSIGN: i32 = 46;
|
||||
def TK_PLUSEQ: i32 = 47;
|
||||
def TK_MINUSEQ: i32 = 48;
|
||||
def TK_STAREQ: i32 = 49;
|
||||
def TK_SLASHEQ: i32 = 50;
|
||||
def TK_PERCENTEQ: i32 = 51;
|
||||
def TK_AMPEQ: i32 = 52;
|
||||
def TK_PIPEEQ: i32 = 53;
|
||||
def TK_CARETEQ: i32 = 54;
|
||||
def TK_LSHIFTEQ: i32 = 55;
|
||||
def TK_RSHIFTEQ: i32 = 56;
|
||||
|
||||
def TK_PLUS: i32 = 57;
|
||||
def TK_MINUS: i32 = 58;
|
||||
def TK_STAR: i32 = 59;
|
||||
def TK_SLASH: i32 = 60;
|
||||
def TK_PERCENT: i32 = 61;
|
||||
def TK_AMP: i32 = 62;
|
||||
def TK_PIPE: i32 = 63;
|
||||
def TK_CARET: i32 = 64;
|
||||
def TK_TILDE: i32 = 65;
|
||||
def TK_LSHIFT: i32 = 66;
|
||||
def TK_RSHIFT: i32 = 67;
|
||||
|
||||
def TK_EQ: i32 = 68;
|
||||
def TK_NEQ: i32 = 69;
|
||||
def TK_LT: i32 = 70;
|
||||
def TK_LE: i32 = 71;
|
||||
def TK_GT: i32 = 72;
|
||||
def TK_GE: i32 = 73;
|
||||
|
||||
def TK_AND: i32 = 74;
|
||||
def TK_OR: i32 = 75;
|
||||
def TK_NOT: i32 = 76;
|
||||
|
||||
def TK_LARROW: i32 = 77;
|
||||
def TK_ARROW: i32 = 78;
|
||||
def TK_FATARROW: i32 = 79;
|
||||
|
||||
def TK_LAST: i32 = 80;
|
||||
|
||||
// ---- Pos / Tok --------------------------------------------------------
|
||||
//
|
||||
// `pos` is used at error-reporting boundaries; we always pass it via
|
||||
// *pos so the value never gets struct-copied (w6c can't yet copy a
|
||||
// 24-byte struct).
|
||||
//
|
||||
// `tok` is flat — file/line/col live directly on the token rather than
|
||||
// nested inside a `pos` field. Same reason: nested struct field
|
||||
// assignment isn't supported, and flat primitives are.
|
||||
|
||||
type pos = struct {
|
||||
file: str,
|
||||
line: i32,
|
||||
col: i32,
|
||||
};
|
||||
|
||||
type tok = struct {
|
||||
kind: i32,
|
||||
file: str, // path of the source the token came from
|
||||
line: i32,
|
||||
col: i32,
|
||||
text: str, // arena-owned token text (TK_IDENT, TK_STR, TK_ERR)
|
||||
uval: u64, // TK_INT, TK_RUNE
|
||||
fval: f64, // TK_FLOAT
|
||||
tsuffix: str, // typed numeric literal suffix or empty
|
||||
};
|
||||
|
||||
// ---- keyword lookup ---------------------------------------------------
|
||||
|
||||
fn streq_n(a: *u8, b: str, n: i32) bool = {
|
||||
if (b.len != n) { return false; };
|
||||
let i: i32 = 0;
|
||||
for (i < n) {
|
||||
if (a[i] != b[i]) { return false; };
|
||||
i += 1;
|
||||
};
|
||||
return true;
|
||||
};
|
||||
|
||||
// kwlookup — returns the matching TK_* keyword kind for a byte run,
|
||||
// or TK_NONE if it's an ordinary identifier. Linear search over a
|
||||
// small alphabetised list, matching cmd/wcc/tok.c.
|
||||
export fn kwlookup(p: *u8, n: i32) i32 = {
|
||||
if (streq_n(p, "as", n)) { return TK_AS; };
|
||||
if (streq_n(p, "break", n)) { return TK_BREAK; };
|
||||
if (streq_n(p, "case", n)) { return TK_CASE; };
|
||||
if (streq_n(p, "chan", n)) { return TK_CHAN; };
|
||||
if (streq_n(p, "continue", n)) { return TK_CONTINUE; };
|
||||
if (streq_n(p, "def", n)) { return TK_DEF; };
|
||||
if (streq_n(p, "defer", n)) { return TK_DEFER; };
|
||||
if (streq_n(p, "else", n)) { return TK_ELSE; };
|
||||
if (streq_n(p, "export", n)) { return TK_EXPORT; };
|
||||
if (streq_n(p, "false", n)) { return TK_FALSE; };
|
||||
if (streq_n(p, "fn", n)) { return TK_FN; };
|
||||
if (streq_n(p, "for", n)) { return TK_FOR; };
|
||||
if (streq_n(p, "if", n)) { return TK_IF; };
|
||||
if (streq_n(p, "let", n)) { return TK_LET; };
|
||||
if (streq_n(p, "match", n)) { return TK_MATCH; };
|
||||
if (streq_n(p, "nil", n)) { return TK_NIL; };
|
||||
if (streq_n(p, "proc", n)) { return TK_PROC; };
|
||||
if (streq_n(p, "return", n)) { return TK_RETURN; };
|
||||
if (streq_n(p, "static", n)) { return TK_STATIC; };
|
||||
if (streq_n(p, "struct", n)) { return TK_STRUCT; };
|
||||
if (streq_n(p, "switch", n)) { return TK_SWITCH; };
|
||||
if (streq_n(p, "true", n)) { return TK_TRUE; };
|
||||
if (streq_n(p, "type", n)) { return TK_TYPE; };
|
||||
if (streq_n(p, "use", n)) { return TK_USE; };
|
||||
return TK_NONE;
|
||||
};
|
||||
|
||||
// ---- tokname ----------------------------------------------------------
|
||||
//
|
||||
// Returns the canonical printable spelling for a token kind. Matches
|
||||
// the C tokname()'s output exactly so wwdump output diffs cleanly.
|
||||
|
||||
export fn tokname(k: i32) str = {
|
||||
if (k == TK_NONE) { return "<none>"; };
|
||||
if (k == TK_EOF) { return "EOF"; };
|
||||
if (k == TK_ERR) { return "ERR"; };
|
||||
if (k == TK_IDENT) { return "IDENT"; };
|
||||
if (k == TK_INT) { return "INT"; };
|
||||
if (k == TK_FLOAT) { return "FLOAT"; };
|
||||
if (k == TK_RUNE) { return "RUNE"; };
|
||||
if (k == TK_STR) { return "STR"; };
|
||||
|
||||
if (k == TK_FN) { return "fn"; };
|
||||
if (k == TK_LET) { return "let"; };
|
||||
if (k == TK_DEF) { return "def"; };
|
||||
if (k == TK_IF) { return "if"; };
|
||||
if (k == TK_ELSE) { return "else"; };
|
||||
if (k == TK_FOR) { return "for"; };
|
||||
if (k == TK_SWITCH) { return "switch"; };
|
||||
if (k == TK_CASE) { return "case"; };
|
||||
if (k == TK_RETURN) { return "return"; };
|
||||
if (k == TK_USE) { return "use"; };
|
||||
if (k == TK_TYPE) { return "type"; };
|
||||
if (k == TK_STRUCT) { return "struct"; };
|
||||
if (k == TK_DEFER) { return "defer"; };
|
||||
if (k == TK_BREAK) { return "break"; };
|
||||
if (k == TK_CONTINUE) { return "continue"; };
|
||||
if (k == TK_EXPORT) { return "export"; };
|
||||
if (k == TK_PROC) { return "proc"; };
|
||||
if (k == TK_CHAN) { return "chan"; };
|
||||
if (k == TK_NIL) { return "nil"; };
|
||||
if (k == TK_TRUE) { return "true"; };
|
||||
if (k == TK_FALSE) { return "false"; };
|
||||
if (k == TK_AS) { return "as"; };
|
||||
if (k == TK_STATIC) { return "static"; };
|
||||
if (k == TK_MATCH) { return "match"; };
|
||||
|
||||
if (k == TK_LPAREN) { return "("; };
|
||||
if (k == TK_RPAREN) { return ")"; };
|
||||
if (k == TK_LBRACE) { return "{"; };
|
||||
if (k == TK_RBRACE) { return "}"; };
|
||||
if (k == TK_LBRACK) { return "["; };
|
||||
if (k == TK_RBRACK) { return "]"; };
|
||||
if (k == TK_COMMA) { return ","; };
|
||||
if (k == TK_SEMI) { return ";"; };
|
||||
if (k == TK_COLON) { return ":"; };
|
||||
if (k == TK_DOT) { return "."; };
|
||||
if (k == TK_ELLIPSIS) { return "..."; };
|
||||
if (k == TK_DOTDOT) { return ".."; };
|
||||
if (k == TK_AT) { return "@"; };
|
||||
if (k == TK_QUESTION) { return "?"; };
|
||||
|
||||
if (k == TK_ASSIGN) { return "="; };
|
||||
if (k == TK_PLUSEQ) { return "+="; };
|
||||
if (k == TK_MINUSEQ) { return "-="; };
|
||||
if (k == TK_STAREQ) { return "*="; };
|
||||
if (k == TK_SLASHEQ) { return "/="; };
|
||||
if (k == TK_PERCENTEQ) { return "%="; };
|
||||
if (k == TK_AMPEQ) { return "&="; };
|
||||
if (k == TK_PIPEEQ) { return "|="; };
|
||||
if (k == TK_CARETEQ) { return "^="; };
|
||||
if (k == TK_LSHIFTEQ) { return "<<="; };
|
||||
if (k == TK_RSHIFTEQ) { return ">>="; };
|
||||
|
||||
if (k == TK_PLUS) { return "+"; };
|
||||
if (k == TK_MINUS) { return "-"; };
|
||||
if (k == TK_STAR) { return "*"; };
|
||||
if (k == TK_SLASH) { return "/"; };
|
||||
if (k == TK_PERCENT) { return "%"; };
|
||||
if (k == TK_AMP) { return "&"; };
|
||||
if (k == TK_PIPE) { return "|"; };
|
||||
if (k == TK_CARET) { return "^"; };
|
||||
if (k == TK_TILDE) { return "~"; };
|
||||
if (k == TK_LSHIFT) { return "<<"; };
|
||||
if (k == TK_RSHIFT) { return ">>"; };
|
||||
|
||||
if (k == TK_EQ) { return "=="; };
|
||||
if (k == TK_NEQ) { return "!="; };
|
||||
if (k == TK_LT) { return "<"; };
|
||||
if (k == TK_LE) { return "<="; };
|
||||
if (k == TK_GT) { return ">"; };
|
||||
if (k == TK_GE) { return ">="; };
|
||||
|
||||
if (k == TK_AND) { return "&&"; };
|
||||
if (k == TK_OR) { return "||"; };
|
||||
if (k == TK_NOT) { return "!"; };
|
||||
|
||||
if (k == TK_LARROW) { return "<-"; };
|
||||
if (k == TK_ARROW) { return "->"; };
|
||||
if (k == TK_FATARROW) { return "=>"; };
|
||||
|
||||
if (k == TK_LAST) { return "<last>"; };
|
||||
return "<?>";
|
||||
};
|
||||
|
||||
// ---- writer for tokprint ----------------------------------------------
|
||||
//
|
||||
// fputq mirrors cmd/wcc/tok.c:fputq — quote the string with C-style
|
||||
// escapes for \, ", \n, \t, \r and \xNN for other non-printables.
|
||||
|
||||
fn fputc_byte(fd: i32, b: u8) void = {
|
||||
let buf: [1]u8;
|
||||
buf[0] = b;
|
||||
os.write(fd, buf.ptr, 1u64);
|
||||
};
|
||||
|
||||
fn fputs_str(fd: i32, s: str) void = {
|
||||
os.write(fd, s.ptr, s.len: u64);
|
||||
};
|
||||
|
||||
fn hexchar(n: u8) u8 = {
|
||||
if (n < 10u8) { return n + 48u8; }; // '0'..'9'
|
||||
return (n - 10u8) + 97u8; // 'a'..'f'
|
||||
};
|
||||
|
||||
fn fputhex2(fd: i32, b: u8) void = {
|
||||
let out: [4]u8;
|
||||
out[0] = 92u8; // '\\'
|
||||
out[1] = 120u8; // 'x'
|
||||
out[2] = hexchar(b >> 4u8);
|
||||
out[3] = hexchar(b & 15u8);
|
||||
os.write(fd, out.ptr, 4u64);
|
||||
};
|
||||
|
||||
fn fputq(fd: i32, p: *u8, n: i32) void = {
|
||||
fputc_byte(fd, 34u8); // '"'
|
||||
let i: i32 = 0;
|
||||
for (i < n) {
|
||||
let c: u8 = p[i];
|
||||
if (c == 92u8) { // '\\'
|
||||
fputs_str(fd, "\\\\");
|
||||
} else {
|
||||
if (c == 34u8) { // '"'
|
||||
fputs_str(fd, "\\\"");
|
||||
} else {
|
||||
if (c == 10u8) { // '\n'
|
||||
fputs_str(fd, "\\n");
|
||||
} else {
|
||||
if (c == 9u8) { // '\t'
|
||||
fputs_str(fd, "\\t");
|
||||
} else {
|
||||
if (c == 13u8) { // '\r'
|
||||
fputs_str(fd, "\\r");
|
||||
} else {
|
||||
if (c < 32u8) {
|
||||
fputhex2(fd, c);
|
||||
} else {
|
||||
if (c == 127u8) {
|
||||
fputhex2(fd, c);
|
||||
} else {
|
||||
fputc_byte(fd, c);
|
||||
};
|
||||
};
|
||||
};
|
||||
};
|
||||
};
|
||||
};
|
||||
};
|
||||
i += 1;
|
||||
};
|
||||
fputc_byte(fd, 34u8);
|
||||
};
|
||||
|
||||
// tokprint — write one token line to fd. Format must match
|
||||
// cmd/wcc/tok.c:tokprint() byte-for-byte: that's the diff anchor.
|
||||
// "<file>:<line>:<col> <kindname>[ <value>]\n"
|
||||
//
|
||||
// Takes `t` by pointer because w6c can't yet pass a >16-byte struct
|
||||
// by value; the C version takes Tok by value.
|
||||
export fn tokprint(fd: i32, t: *tok) void = {
|
||||
// Chained-dot field reads (`t.x.y`) on str sub-fields aren't yet
|
||||
// reduced by w6c — `t.x.y` returns the whole str. Lift the str
|
||||
// fields into locals so we can use the str pseudo-field path.
|
||||
let tfile: str = t.file;
|
||||
let ttext: str = t.text;
|
||||
if (tfile.len > 0) {
|
||||
fputs_str(fd, tfile);
|
||||
} else {
|
||||
fputs_str(fd, "<none>");
|
||||
};
|
||||
fputc_byte(fd, 58u8); // ':'
|
||||
let buf: [32]u8;
|
||||
let n: i32 = strconv.i64toa(buf[0:32], t.line: i64);
|
||||
os.write(fd, buf.ptr, n: u64);
|
||||
fputc_byte(fd, 58u8);
|
||||
n = strconv.i64toa(buf[0:32], t.col: i64);
|
||||
os.write(fd, buf.ptr, n: u64);
|
||||
fputc_byte(fd, 32u8); // ' '
|
||||
fputs_str(fd, tokname(t.kind));
|
||||
|
||||
if (t.kind == TK_IDENT) {
|
||||
fputc_byte(fd, 32u8);
|
||||
fputq(fd, ttext.ptr, ttext.len);
|
||||
} else { if (t.kind == TK_STR) {
|
||||
fputc_byte(fd, 32u8);
|
||||
fputq(fd, ttext.ptr, ttext.len);
|
||||
} else { if (t.kind == TK_ERR) {
|
||||
fputc_byte(fd, 32u8);
|
||||
fputq(fd, ttext.ptr, ttext.len);
|
||||
} else { if (t.kind == TK_INT) {
|
||||
fputc_byte(fd, 32u8);
|
||||
n = strconv.u64toa(buf[0:32], t.uval);
|
||||
os.write(fd, buf.ptr, n: u64);
|
||||
} else { if (t.kind == TK_RUNE) {
|
||||
fputc_byte(fd, 32u8);
|
||||
n = strconv.u64toa(buf[0:32], t.uval);
|
||||
os.write(fd, buf.ptr, n: u64);
|
||||
};};};};};
|
||||
// TK_FLOAT is intentionally not handled here — %g formatting
|
||||
// won't byte-match across implementations. Diff fixtures must
|
||||
// be float-free until we implement a stable float formatter.
|
||||
|
||||
fputc_byte(fd, 10u8); // '\n'
|
||||
};
|
||||
Reference in New Issue
Block a user