Hojun-Cho/ww
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ww+wcc: graduate selfhost TK_* defs to tkind enum

Browse Source 
`type tkind = enum i32 { TK_NONE = 0, TK_EOF = 1, ... TK_LAST = 86 }`
replaces the 87-line `def TK_*: i32 = N` cluster in lib/ww/lex/tok.ww.
Numeric values explicit so 990_selfhost's byte-diff against the C-side
`Tkind` enum still passes.

All ~270 reference sites in lib/ww and selfhost/cmd/{wcc,wwdump}
sed-renamed `TK_X` → `tkind.TK_X`. Struct fields (`tok.kind`,
`parser.curkind`) intentionally kept as `i32` — making them `tkind`
shifted some byte-positions in the cgen output and broke 990/993/995
byte-identity probes without an obvious win.

To make the rename non-cascading on every signature, type_assignable
and unify_arith in cmd/wcc/check+type relax to allow enum ↔ int
mixing when storage matches (a `tkind` value flows into an `i32`
slot and vice versa, no explicit cast). This deviates from Hare's
strict enum semantics; doc'd as an explicit pragmatic relaxation
for the compiler's internal enum-shaped kinds. External user code
can still get the type-safety benefit if they declare their
parameters with the enum type.

combined.ww files regenerated by ww build.
This commit is contained in:
Hojun-Cho
2026-05-12 04:50:36 +09:00
parent fc49da44d8
commit 408ea2a322
14 changed files with 1806 additions and 1771 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
cmd/wcc/check.c
View File

@@ -531,6 +531,17 @@ unify_arith(Checker *c, Pos p, Type *a, Type *b)
if (type_isuntyped(a) && type_assignable(b, a)) return b;
if (type_isuntyped(b) && type_assignable(a, b)) return a;
if (type_eq(a, b)) return a;
/* Enum ↔ integer storage: pair `(tkind, i32)` operands unify to
* the storage int. Mirrors the same relaxation in type_assignable;
* lets `cur.kind == TK_FN` typecheck without a cast on either side. */
{
Type *au = (a->kind == TY_NAMED) ? a->under : a;
Type *bu = (b->kind == TY_NAMED) ? b->under : b;
if (au && au->kind == TY_ENUM && type_isint(b) &&
type_eq(au->sub, b)) return b;
if (bu && bu->kind == TY_ENUM && type_isint(a) &&
type_eq(a, bu->sub)) return a;
}
return err(c, p, "operands have differing types %s and %s",
type_name(c->a, a), type_name(c->a, b));
}

15
cmd/wcc/type.c
View File

@@ -295,6 +295,21 @@ type_assignable(Type *dst, Type *src)
if (dst->kind == TY_NAMED && type_eq(dst->under, src)) return 1;
if (src->kind == TY_NAMED && type_eq(dst, src->under)) return 1;
/* Enum ↔ integer storage: bare i32 flows into a `tkind` slot and
* vice-versa as long as the storage type matches. Hare-strict
* would require an explicit cast, but the ww frontend's tkind /
* nkind enums have hundreds of `let k: i32 = expr` sites we'd
* otherwise have to migrate in lockstep — the relaxation is
* explicit and limited to int-typed enums. */
{
Type *du = (dst->kind == TY_NAMED) ? dst->under : dst;
Type *su = (src->kind == TY_NAMED) ? src->under : src;
if (du && du->kind == TY_ENUM && type_isint(src) &&
type_eq(du->sub, src)) return 1;
if (su && su->kind == TY_ENUM && type_isint(dst) &&
type_eq(dst, su->sub)) return 1;
}
/* Tuple-to-tuple: element-wise assignable. */
if (dst->kind == TY_TUPLE && src->kind == TY_TUPLE) {
Tparam *pa = dst->params, *pb = src->params;

126
lib/ww/lex/lex.ww
View File

@@ -316,7 +316,7 @@ fn scanexp(l: *lex) void = {
};
fn lexnum(l: *lex, start: *pos, out: *tok) void = {
out.kind = TK_INT;
out.kind = tkind.TK_INT;
out.file = start.file;
out.line = start.line;
out.col = start.col;
@@ -375,9 +375,9 @@ fn lexnum(l: *lex, start: *pos, out: *tok) void = {
if (isfloat) {
// out.fval is already 0 from the top-of-lexnext clear.
// We don't strtod the literal yet — the diff fixtures we
// care about are float-free; any TK_FLOAT seen in source
// care about are float-free; any tkind.TK_FLOAT seen in source
// gets a placeholder value until we wire a real parser.
out.kind = TK_FLOAT;
out.kind = tkind.TK_FLOAT;
} else {
let digs: *u8 = l.src + begin;
let dn: u64 = n;
@@ -389,7 +389,7 @@ fn lexnum(l: *lex, start: *pos, out: *tok) void = {
out.uval = parseint(digs, dn, base, &ok);
if (!ok) {
errat(l, start, "bad integer literal");
out.kind = TK_ERR;
out.kind = tkind.TK_ERR;
};
};
@@ -455,16 +455,16 @@ fn lexident(l: *lex, start: *pos, out: *tok) void = {
// Bare '_' is the discard marker. `_x`, `_1` are normal idents.
if (n == 1u64) {
if (p[0] == 95u8) {
out.kind = TK_UNDER;
out.kind = tkind.TK_UNDER;
out.text = astrndup(l.a, p, n);
return;
};
};
let k: i32 = kwlookup(p, n: i32);
if (k != TK_NONE) {
if (k != tkind.TK_NONE) {
out.kind = k;
} else {
out.kind = TK_IDENT;
out.kind = tkind.TK_IDENT;
};
out.text = astrndup(l.a, p, n);
};
@@ -477,7 +477,7 @@ fn lexstr(l: *lex, start: *pos, out: *tok) void = {
let c: i32 = lpeek(l, 0u64);
if (c < 0) {
errat(l, start, "unterminated string");
out.kind = TK_ERR;
out.kind = tkind.TK_ERR;
out.file = start.file;
out.line = start.line;
out.col = start.col;
@@ -508,7 +508,7 @@ fn lexstr(l: *lex, start: *pos, out: *tok) void = {
buf[nbi] = ch: u8;
nb += 1u64;
};
out.kind = TK_STR;
out.kind = tkind.TK_STR;
out.file = start.file;
out.line = start.line;
out.col = start.col;
@@ -522,7 +522,7 @@ fn lexrune(l: *lex, start: *pos, out: *tok) void = {
let c: i32 = lpeek(l, 0u64);
if (c < 0) {
errat(l, start, "unterminated rune");
out.kind = TK_ERR;
out.kind = tkind.TK_ERR;
out.file = start.file;
out.line = start.line;
out.col = start.col;
@@ -538,7 +538,7 @@ fn lexrune(l: *lex, start: *pos, out: *tok) void = {
};
if (lpeek(l, 0u64) != 39) {
errat(l, start, "rune literal missing closing '");
out.kind = TK_ERR;
out.kind = tkind.TK_ERR;
out.file = start.file;
out.line = start.line;
out.col = start.col;
@@ -546,7 +546,7 @@ fn lexrune(l: *lex, start: *pos, out: *tok) void = {
return;
};
lget(l);
out.kind = TK_RUNE;
out.kind = tkind.TK_RUNE;
out.file = start.file;
out.line = start.line;
out.col = start.col;
@@ -572,7 +572,7 @@ export fn lexnext(l: *lex, out: *tok) void = {
// Reset the out token so callers can rely on stale fields being
// cleared (they only inspect kind, pos, text, uval, fval, tsuffix
// per kind).
out.kind = TK_NONE;
out.kind = tkind.TK_NONE;
out.uval = 0u64;
// out.fval starts cleared by the caller's stack-local init (lex.ww
// allocates the tok with `let t: tok;` which zeroes). We avoid
@@ -586,7 +586,7 @@ export fn lexnext(l: *lex, out: *tok) void = {
if (!skipws(l)) {
let p: pos; curpos(l, &p);
emitsimple(&p, TK_EOF, out);
emitsimple(&p, tkind.TK_EOF, out);
return;
};
let start: pos; curpos(l, &start);
@@ -602,97 +602,97 @@ export fn lexnext(l: *lex, out: *tok) void = {
lget(l);
if (c == 40) { emitsimple(&start, TK_LPAREN, out); return; };
if (c == 41) { emitsimple(&start, TK_RPAREN, out); return; };
if (c == 123) { emitsimple(&start, TK_LBRACE, out); return; };
if (c == 125) { emitsimple(&start, TK_RBRACE, out); return; };
if (c == 91) { emitsimple(&start, TK_LBRACK, out); return; };
if (c == 93) { emitsimple(&start, TK_RBRACK, out); return; };
if (c == 44) { emitsimple(&start, TK_COMMA, out); return; };
if (c == 59) { emitsimple(&start, TK_SEMI, out); return; };
if (c == 58) { emitsimple(&start, TK_COLON, out); return; };
if (c == 64) { emitsimple(&start, TK_AT, out); return; };
if (c == 63) { emitsimple(&start, TK_QUESTION, out); return; };
if (c == 126) { emitsimple(&start, TK_TILDE, out); return; };
if (c == 40) { emitsimple(&start, tkind.TK_LPAREN, out); return; };
if (c == 41) { emitsimple(&start, tkind.TK_RPAREN, out); return; };
if (c == 123) { emitsimple(&start, tkind.TK_LBRACE, out); return; };
if (c == 125) { emitsimple(&start, tkind.TK_RBRACE, out); return; };
if (c == 91) { emitsimple(&start, tkind.TK_LBRACK, out); return; };
if (c == 93) { emitsimple(&start, tkind.TK_RBRACK, out); return; };
if (c == 44) { emitsimple(&start, tkind.TK_COMMA, out); return; };
if (c == 59) { emitsimple(&start, tkind.TK_SEMI, out); return; };
if (c == 58) { emitsimple(&start, tkind.TK_COLON, out); return; };
if (c == 64) { emitsimple(&start, tkind.TK_AT, out); return; };
if (c == 63) { emitsimple(&start, tkind.TK_QUESTION, out); return; };
if (c == 126) { emitsimple(&start, tkind.TK_TILDE, out); return; };
if (c == 46) { // '.'
if (lpeek(l, 0u64) == 46) {
if (lpeek(l, 1u64) == 46) {
lget(l); lget(l);
emitsimple(&start, TK_ELLIPSIS, out); return;
emitsimple(&start, tkind.TK_ELLIPSIS, out); return;
};
lget(l);
emitsimple(&start, TK_DOTDOT, out); return;
emitsimple(&start, tkind.TK_DOTDOT, out); return;
};
emitsimple(&start, TK_DOT, out); return;
emitsimple(&start, tkind.TK_DOT, out); return;
};
if (c == 43) {
if (lpeek(l, 0u64) == 61) { lget(l); emitsimple(&start, TK_PLUSEQ, out); return; };
emitsimple(&start, TK_PLUS, out); return;
if (lpeek(l, 0u64) == 61) { lget(l); emitsimple(&start, tkind.TK_PLUSEQ, out); return; };
emitsimple(&start, tkind.TK_PLUS, out); return;
};
if (c == 45) {
if (lpeek(l, 0u64) == 61) { lget(l); emitsimple(&start, TK_MINUSEQ, out); return; };
if (lpeek(l, 0u64) == 62) { lget(l); emitsimple(&start, TK_ARROW, out); return; };
emitsimple(&start, TK_MINUS, out); return;
if (lpeek(l, 0u64) == 61) { lget(l); emitsimple(&start, tkind.TK_MINUSEQ, out); return; };
if (lpeek(l, 0u64) == 62) { lget(l); emitsimple(&start, tkind.TK_ARROW, out); return; };
emitsimple(&start, tkind.TK_MINUS, out); return;
};
if (c == 42) {
if (lpeek(l, 0u64) == 61) { lget(l); emitsimple(&start, TK_STAREQ, out); return; };
emitsimple(&start, TK_STAR, out); return;
if (lpeek(l, 0u64) == 61) { lget(l); emitsimple(&start, tkind.TK_STAREQ, out); return; };
emitsimple(&start, tkind.TK_STAR, out); return;
};
if (c == 47) {
if (lpeek(l, 0u64) == 61) { lget(l); emitsimple(&start, TK_SLASHEQ, out); return; };
emitsimple(&start, TK_SLASH, out); return;
if (lpeek(l, 0u64) == 61) { lget(l); emitsimple(&start, tkind.TK_SLASHEQ, out); return; };
emitsimple(&start, tkind.TK_SLASH, out); return;
};
if (c == 37) {
if (lpeek(l, 0u64) == 61) { lget(l); emitsimple(&start, TK_PERCENTEQ, out); return; };
emitsimple(&start, TK_PERCENT, out); return;
if (lpeek(l, 0u64) == 61) { lget(l); emitsimple(&start, tkind.TK_PERCENTEQ, out); return; };
emitsimple(&start, tkind.TK_PERCENT, out); return;
};
if (c == 38) {
if (lpeek(l, 0u64) == 38) { lget(l); emitsimple(&start, TK_AND, out); return; };
if (lpeek(l, 0u64) == 61) { lget(l); emitsimple(&start, TK_AMPEQ, out); return; };
emitsimple(&start, TK_AMP, out); return;
if (lpeek(l, 0u64) == 38) { lget(l); emitsimple(&start, tkind.TK_AND, out); return; };
if (lpeek(l, 0u64) == 61) { lget(l); emitsimple(&start, tkind.TK_AMPEQ, out); return; };
emitsimple(&start, tkind.TK_AMP, out); return;
};
if (c == 124) {
if (lpeek(l, 0u64) == 124) { lget(l); emitsimple(&start, TK_OR, out); return; };
if (lpeek(l, 0u64) == 61) { lget(l); emitsimple(&start, TK_PIPEEQ, out); return; };
emitsimple(&start, TK_PIPE, out); return;
if (lpeek(l, 0u64) == 124) { lget(l); emitsimple(&start, tkind.TK_OR, out); return; };
if (lpeek(l, 0u64) == 61) { lget(l); emitsimple(&start, tkind.TK_PIPEEQ, out); return; };
emitsimple(&start, tkind.TK_PIPE, out); return;
};
if (c == 94) {
if (lpeek(l, 0u64) == 61) { lget(l); emitsimple(&start, TK_CARETEQ, out); return; };
emitsimple(&start, TK_CARET, out); return;
if (lpeek(l, 0u64) == 61) { lget(l); emitsimple(&start, tkind.TK_CARETEQ, out); return; };
emitsimple(&start, tkind.TK_CARET, out); return;
};
if (c == 61) {
if (lpeek(l, 0u64) == 61) { lget(l); emitsimple(&start, TK_EQ, out); return; };
if (lpeek(l, 0u64) == 62) { lget(l); emitsimple(&start, TK_FATARROW, out); return; };
emitsimple(&start, TK_ASSIGN, out); return;
if (lpeek(l, 0u64) == 61) { lget(l); emitsimple(&start, tkind.TK_EQ, out); return; };
if (lpeek(l, 0u64) == 62) { lget(l); emitsimple(&start, tkind.TK_FATARROW, out); return; };
emitsimple(&start, tkind.TK_ASSIGN, out); return;
};
if (c == 33) {
if (lpeek(l, 0u64) == 61) { lget(l); emitsimple(&start, TK_NEQ, out); return; };
emitsimple(&start, TK_NOT, out); return;
if (lpeek(l, 0u64) == 61) { lget(l); emitsimple(&start, tkind.TK_NEQ, out); return; };
emitsimple(&start, tkind.TK_NOT, out); return;
};
if (c == 60) {
if (lpeek(l, 0u64) == 60) {
lget(l);
if (lpeek(l, 0u64) == 61) { lget(l); emitsimple(&start, TK_LSHIFTEQ, out); return; };
emitsimple(&start, TK_LSHIFT, out); return;
if (lpeek(l, 0u64) == 61) { lget(l); emitsimple(&start, tkind.TK_LSHIFTEQ, out); return; };
emitsimple(&start, tkind.TK_LSHIFT, out); return;
};
if (lpeek(l, 0u64) == 61) { lget(l); emitsimple(&start, TK_LE, out); return; };
if (lpeek(l, 0u64) == 45) { lget(l); emitsimple(&start, TK_LARROW, out); return; };
emitsimple(&start, TK_LT, out); return;
if (lpeek(l, 0u64) == 61) { lget(l); emitsimple(&start, tkind.TK_LE, out); return; };
if (lpeek(l, 0u64) == 45) { lget(l); emitsimple(&start, tkind.TK_LARROW, out); return; };
emitsimple(&start, tkind.TK_LT, out); return;
};
if (c == 62) {
if (lpeek(l, 0u64) == 62) {
lget(l);
if (lpeek(l, 0u64) == 61) { lget(l); emitsimple(&start, TK_RSHIFTEQ, out); return; };
emitsimple(&start, TK_RSHIFT, out); return;
if (lpeek(l, 0u64) == 61) { lget(l); emitsimple(&start, tkind.TK_RSHIFTEQ, out); return; };
emitsimple(&start, tkind.TK_RSHIFT, out); return;
};
if (lpeek(l, 0u64) == 61) { lget(l); emitsimple(&start, TK_GE, out); return; };
emitsimple(&start, TK_GT, out); return;
if (lpeek(l, 0u64) == 61) { lget(l); emitsimple(&start, tkind.TK_GE, out); return; };
emitsimple(&start, tkind.TK_GT, out); return;
};
errat(l, &start, "unexpected character");
out.kind = TK_ERR;
out.kind = tkind.TK_ERR;
setposfrom(out, &start);
let one: [1]u8;
one[0] = c: u8;

445
lib/ww/lex/tok.ww
View File

@@ -12,108 +12,110 @@
use os;
use strconv;
// ---- Tkind ------------------------------------------------------------
// Mirror of the C enum in cmd/wcc/ww.h. Don't reorder.
// ---- tkind ------------------------------------------------------------
// Mirror of the C `Tkind` enum in cmd/wcc/ww.h. Numeric values are
// explicit and must stay in sync — the 990_selfhost test diffs wwdump
// output against the C side, byte for byte.
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;
type tkind = enum i32 {
TK_NONE = 0,
TK_EOF = 1,
TK_ERR = 2,
TK_IDENT = 3,
TK_INT = 4,
TK_FLOAT = 5,
TK_RUNE = 6,
TK_STR = 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_CONST: i32 = 32;
def TK_UNDER: i32 = 33;
TK_FN = 8,
TK_LET = 9,
TK_DEF = 10,
TK_IF = 11,
TK_ELSE = 12,
TK_FOR = 13,
TK_SWITCH = 14,
TK_CASE = 15,
TK_RETURN = 16,
TK_USE = 17,
TK_TYPE = 18,
TK_STRUCT = 19,
TK_DEFER = 20,
TK_BREAK = 21,
TK_CONTINUE = 22,
TK_EXPORT = 23,
TK_PROC = 24,
TK_CHAN = 25,
TK_NIL = 26,
TK_TRUE = 27,
TK_FALSE = 28,
TK_AS = 29,
TK_STATIC = 30,
TK_MATCH = 31,
TK_CONST = 32,
TK_UNDER = 33,
def TK_LPAREN: i32 = 34;
def TK_RPAREN: i32 = 35;
def TK_LBRACE: i32 = 36;
def TK_RBRACE: i32 = 37;
def TK_LBRACK: i32 = 38;
def TK_RBRACK: i32 = 39;
def TK_COMMA: i32 = 40;
def TK_SEMI: i32 = 41;
def TK_COLON: i32 = 42;
def TK_DOT: i32 = 43;
def TK_ELLIPSIS: i32 = 44;
def TK_DOTDOT: i32 = 45;
def TK_AT: i32 = 46;
def TK_QUESTION: i32 = 47;
TK_LPAREN = 34,
TK_RPAREN = 35,
TK_LBRACE = 36,
TK_RBRACE = 37,
TK_LBRACK = 38,
TK_RBRACK = 39,
TK_COMMA = 40,
TK_SEMI = 41,
TK_COLON = 42,
TK_DOT = 43,
TK_ELLIPSIS = 44,
TK_DOTDOT = 45,
TK_AT = 46,
TK_QUESTION = 47,
def TK_ASSIGN: i32 = 48;
def TK_PLUSEQ: i32 = 49;
def TK_MINUSEQ: i32 = 50;
def TK_STAREQ: i32 = 51;
def TK_SLASHEQ: i32 = 52;
def TK_PERCENTEQ: i32 = 53;
def TK_AMPEQ: i32 = 54;
def TK_PIPEEQ: i32 = 55;
def TK_CARETEQ: i32 = 56;
def TK_LSHIFTEQ: i32 = 57;
def TK_RSHIFTEQ: i32 = 58;
TK_ASSIGN = 48,
TK_PLUSEQ = 49,
TK_MINUSEQ = 50,
TK_STAREQ = 51,
TK_SLASHEQ = 52,
TK_PERCENTEQ = 53,
TK_AMPEQ = 54,
TK_PIPEEQ = 55,
TK_CARETEQ = 56,
TK_LSHIFTEQ = 57,
TK_RSHIFTEQ = 58,
def TK_PLUS: i32 = 59;
def TK_MINUS: i32 = 60;
def TK_STAR: i32 = 61;
def TK_SLASH: i32 = 62;
def TK_PERCENT: i32 = 63;
def TK_AMP: i32 = 64;
def TK_PIPE: i32 = 65;
def TK_CARET: i32 = 66;
def TK_TILDE: i32 = 67;
def TK_LSHIFT: i32 = 68;
def TK_RSHIFT: i32 = 69;
TK_PLUS = 59,
TK_MINUS = 60,
TK_STAR = 61,
TK_SLASH = 62,
TK_PERCENT = 63,
TK_AMP = 64,
TK_PIPE = 65,
TK_CARET = 66,
TK_TILDE = 67,
TK_LSHIFT = 68,
TK_RSHIFT = 69,
def TK_EQ: i32 = 70;
def TK_NEQ: i32 = 71;
def TK_LT: i32 = 72;
def TK_LE: i32 = 73;
def TK_GT: i32 = 74;
def TK_GE: i32 = 75;
TK_EQ = 70,
TK_NEQ = 71,
TK_LT = 72,
TK_LE = 73,
TK_GT = 74,
TK_GE = 75,
def TK_AND: i32 = 76;
def TK_OR: i32 = 77;
def TK_NOT: i32 = 78;
TK_AND = 76,
TK_OR = 77,
TK_NOT = 78,
def TK_LARROW: i32 = 79;
def TK_ARROW: i32 = 80;
def TK_FATARROW: i32 = 81;
TK_LARROW = 79,
TK_ARROW = 80,
TK_FATARROW = 81,
// Appended at the tail (not grouped with the keyword block) so every
// pre-existing TK_* value stays unchanged — the 990_selfhost test
// diffs wwdump output against the C side, byte for byte.
def TK_IS: i32 = 82;
def TK_VOID: i32 = 83;
def TK_YIELD: i32 = 84;
def TK_ENUM: i32 = 85;
def TK_LAST: i32 = 86;
// Tail-appended values — keeps every prior TK_* numeric value
// stable for the 990_selfhost byte-diff against the C side.
TK_IS = 82,
TK_VOID = 83,
TK_YIELD = 84,
TK_ENUM = 85,
TK_LAST = 86,
};
// ---- Pos / Tok --------------------------------------------------------
//
@@ -132,13 +134,14 @@ type pos = struct {
};
type tok = struct {
kind: i32,
kind: i32, // holds a `tkind` value; bare i32 so the cgen's
// fixed 8B/struct-field layout matches the C side
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
text: str, // arena-owned token text (tkind.TK_IDENT, tkind.TK_STR, tkind.TK_ERR)
uval: u64, // tkind.TK_INT, tkind.TK_RUNE
fval: f64, // tkind.TK_FLOAT
tsuffix: str, // typed numeric literal suffix or empty
};
@@ -155,39 +158,39 @@ fn streqn(a: *u8, b: str, n: i32) bool = {
};
// kwlookup — returns the matching TK_* keyword kind for a byte run,
// or TK_NONE if it's an ordinary identifier. Linear search over a
// or tkind.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 (streqn(p, "as", n)) { return TK_AS; };
if (streqn(p, "break", n)) { return TK_BREAK; };
if (streqn(p, "case", n)) { return TK_CASE; };
if (streqn(p, "chan", n)) { return TK_CHAN; };
if (streqn(p, "const", n)) { return TK_CONST; };
if (streqn(p, "continue", n)) { return TK_CONTINUE; };
if (streqn(p, "def", n)) { return TK_DEF; };
if (streqn(p, "defer", n)) { return TK_DEFER; };
if (streqn(p, "else", n)) { return TK_ELSE; };
if (streqn(p, "enum", n)) { return TK_ENUM; };
if (streqn(p, "export", n)) { return TK_EXPORT; };
if (streqn(p, "false", n)) { return TK_FALSE; };
if (streqn(p, "fn", n)) { return TK_FN; };
if (streqn(p, "for", n)) { return TK_FOR; };
if (streqn(p, "if", n)) { return TK_IF; };
if (streqn(p, "is", n)) { return TK_IS; };
if (streqn(p, "let", n)) { return TK_LET; };
if (streqn(p, "match", n)) { return TK_MATCH; };
if (streqn(p, "nil", n)) { return TK_NIL; };
if (streqn(p, "proc", n)) { return TK_PROC; };
if (streqn(p, "return", n)) { return TK_RETURN; };
if (streqn(p, "static", n)) { return TK_STATIC; };
if (streqn(p, "struct", n)) { return TK_STRUCT; };
if (streqn(p, "switch", n)) { return TK_SWITCH; };
if (streqn(p, "true", n)) { return TK_TRUE; };
if (streqn(p, "type", n)) { return TK_TYPE; };
if (streqn(p, "use", n)) { return TK_USE; };
if (streqn(p, "void", n)) { return TK_VOID; };
if (streqn(p, "yield", n)) { return TK_YIELD; };
return TK_NONE;
if (streqn(p, "as", n)) { return tkind.TK_AS; };
if (streqn(p, "break", n)) { return tkind.TK_BREAK; };
if (streqn(p, "case", n)) { return tkind.TK_CASE; };
if (streqn(p, "chan", n)) { return tkind.TK_CHAN; };
if (streqn(p, "const", n)) { return tkind.TK_CONST; };
if (streqn(p, "continue", n)) { return tkind.TK_CONTINUE; };
if (streqn(p, "def", n)) { return tkind.TK_DEF; };
if (streqn(p, "defer", n)) { return tkind.TK_DEFER; };
if (streqn(p, "else", n)) { return tkind.TK_ELSE; };
if (streqn(p, "enum", n)) { return tkind.TK_ENUM; };
if (streqn(p, "export", n)) { return tkind.TK_EXPORT; };
if (streqn(p, "false", n)) { return tkind.TK_FALSE; };
if (streqn(p, "fn", n)) { return tkind.TK_FN; };
if (streqn(p, "for", n)) { return tkind.TK_FOR; };
if (streqn(p, "if", n)) { return tkind.TK_IF; };
if (streqn(p, "is", n)) { return tkind.TK_IS; };
if (streqn(p, "let", n)) { return tkind.TK_LET; };
if (streqn(p, "match", n)) { return tkind.TK_MATCH; };
if (streqn(p, "nil", n)) { return tkind.TK_NIL; };
if (streqn(p, "proc", n)) { return tkind.TK_PROC; };
if (streqn(p, "return", n)) { return tkind.TK_RETURN; };
if (streqn(p, "static", n)) { return tkind.TK_STATIC; };
if (streqn(p, "struct", n)) { return tkind.TK_STRUCT; };
if (streqn(p, "switch", n)) { return tkind.TK_SWITCH; };
if (streqn(p, "true", n)) { return tkind.TK_TRUE; };
if (streqn(p, "type", n)) { return tkind.TK_TYPE; };
if (streqn(p, "use", n)) { return tkind.TK_USE; };
if (streqn(p, "void", n)) { return tkind.TK_VOID; };
if (streqn(p, "yield", n)) { return tkind.TK_YIELD; };
return tkind.TK_NONE;
};
// ---- tokname ----------------------------------------------------------
@@ -196,101 +199,101 @@ export fn kwlookup(p: *u8, n: i32) i32 = {
// 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 == tkind.TK_NONE) { return "<none>"; };
if (k == tkind.TK_EOF) { return "EOF"; };
if (k == tkind.TK_ERR) { return "ERR"; };
if (k == tkind.TK_IDENT) { return "IDENT"; };
if (k == tkind.TK_INT) { return "INT"; };
if (k == tkind.TK_FLOAT) { return "FLOAT"; };
if (k == tkind.TK_RUNE) { return "RUNE"; };
if (k == tkind.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_IS) { return "is"; };
if (k == TK_VOID) { return "void"; };
if (k == TK_YIELD) { return "yield"; };
if (k == TK_STATIC) { return "static"; };
if (k == TK_MATCH) { return "match"; };
if (k == TK_CONST) { return "const"; };
if (k == TK_UNDER) { return "_"; };
if (k == TK_ENUM) { return "enum"; };
if (k == tkind.TK_FN) { return "fn"; };
if (k == tkind.TK_LET) { return "let"; };
if (k == tkind.TK_DEF) { return "def"; };
if (k == tkind.TK_IF) { return "if"; };
if (k == tkind.TK_ELSE) { return "else"; };
if (k == tkind.TK_FOR) { return "for"; };
if (k == tkind.TK_SWITCH) { return "switch"; };
if (k == tkind.TK_CASE) { return "case"; };
if (k == tkind.TK_RETURN) { return "return"; };
if (k == tkind.TK_USE) { return "use"; };
if (k == tkind.TK_TYPE) { return "type"; };
if (k == tkind.TK_STRUCT) { return "struct"; };
if (k == tkind.TK_DEFER) { return "defer"; };
if (k == tkind.TK_BREAK) { return "break"; };
if (k == tkind.TK_CONTINUE) { return "continue"; };
if (k == tkind.TK_EXPORT) { return "export"; };
if (k == tkind.TK_PROC) { return "proc"; };
if (k == tkind.TK_CHAN) { return "chan"; };
if (k == tkind.TK_NIL) { return "nil"; };
if (k == tkind.TK_TRUE) { return "true"; };
if (k == tkind.TK_FALSE) { return "false"; };
if (k == tkind.TK_AS) { return "as"; };
if (k == tkind.TK_IS) { return "is"; };
if (k == tkind.TK_VOID) { return "void"; };
if (k == tkind.TK_YIELD) { return "yield"; };
if (k == tkind.TK_STATIC) { return "static"; };
if (k == tkind.TK_MATCH) { return "match"; };
if (k == tkind.TK_CONST) { return "const"; };
if (k == tkind.TK_UNDER) { return "_"; };
if (k == tkind.TK_ENUM) { return "enum"; };
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 == tkind.TK_LPAREN) { return "("; };
if (k == tkind.TK_RPAREN) { return ")"; };
if (k == tkind.TK_LBRACE) { return "{"; };
if (k == tkind.TK_RBRACE) { return "}"; };
if (k == tkind.TK_LBRACK) { return "["; };
if (k == tkind.TK_RBRACK) { return "]"; };
if (k == tkind.TK_COMMA) { return ","; };
if (k == tkind.TK_SEMI) { return ";"; };
if (k == tkind.TK_COLON) { return ":"; };
if (k == tkind.TK_DOT) { return "."; };
if (k == tkind.TK_ELLIPSIS) { return "..."; };
if (k == tkind.TK_DOTDOT) { return ".."; };
if (k == tkind.TK_AT) { return "@"; };
if (k == tkind.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 == tkind.TK_ASSIGN) { return "="; };
if (k == tkind.TK_PLUSEQ) { return "+="; };
if (k == tkind.TK_MINUSEQ) { return "-="; };
if (k == tkind.TK_STAREQ) { return "*="; };
if (k == tkind.TK_SLASHEQ) { return "/="; };
if (k == tkind.TK_PERCENTEQ) { return "%="; };
if (k == tkind.TK_AMPEQ) { return "&="; };
if (k == tkind.TK_PIPEEQ) { return "|="; };
if (k == tkind.TK_CARETEQ) { return "^="; };
if (k == tkind.TK_LSHIFTEQ) { return "<<="; };
if (k == tkind.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 == tkind.TK_PLUS) { return "+"; };
if (k == tkind.TK_MINUS) { return "-"; };
if (k == tkind.TK_STAR) { return "*"; };
if (k == tkind.TK_SLASH) { return "/"; };
if (k == tkind.TK_PERCENT) { return "%"; };
if (k == tkind.TK_AMP) { return "&"; };
if (k == tkind.TK_PIPE) { return "|"; };
if (k == tkind.TK_CARET) { return "^"; };
if (k == tkind.TK_TILDE) { return "~"; };
if (k == tkind.TK_LSHIFT) { return "<<"; };
if (k == tkind.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 == tkind.TK_EQ) { return "=="; };
if (k == tkind.TK_NEQ) { return "!="; };
if (k == tkind.TK_LT) { return "<"; };
if (k == tkind.TK_LE) { return "<="; };
if (k == tkind.TK_GT) { return ">"; };
if (k == tkind.TK_GE) { return ">="; };
if (k == TK_AND) { return "&&"; };
if (k == TK_OR) { return "||"; };
if (k == TK_NOT) { return "!"; };
if (k == tkind.TK_AND) { return "&&"; };
if (k == tkind.TK_OR) { return "||"; };
if (k == tkind.TK_NOT) { return "!"; };
if (k == TK_LARROW) { return "<-"; };
if (k == TK_ARROW) { return "->"; };
if (k == TK_FATARROW) { return "=>"; };
if (k == tkind.TK_LARROW) { return "<-"; };
if (k == tkind.TK_ARROW) { return "->"; };
if (k == tkind.TK_FATARROW) { return "=>"; };
if (k == TK_LAST) { return "<last>"; };
if (k == tkind.TK_LAST) { return "<last>"; };
return "<?>";
};
@@ -389,25 +392,25 @@ export fn tokprint(fd: i32, t: *tok) void = {
fputcbyte(fd, 32u8); // ' '
fputsstr(fd, tokname(t.kind));
if (t.kind == TK_IDENT) {
if (t.kind == tkind.TK_IDENT) {
fputcbyte(fd, 32u8);
fputq(fd, ttext.ptr, ttext.len);
} else { if (t.kind == TK_STR) {
} else { if (t.kind == tkind.TK_STR) {
fputcbyte(fd, 32u8);
fputq(fd, ttext.ptr, ttext.len);
} else { if (t.kind == TK_ERR) {
} else { if (t.kind == tkind.TK_ERR) {
fputcbyte(fd, 32u8);
fputq(fd, ttext.ptr, ttext.len);
} else { if (t.kind == TK_INT) {
} else { if (t.kind == tkind.TK_INT) {
fputcbyte(fd, 32u8);
n = strconv.u64tos(buf[0:32], t.uval);
os.write(fd, buf.ptr, n: u64);
} else { if (t.kind == TK_RUNE) {
} else { if (t.kind == tkind.TK_RUNE) {
fputcbyte(fd, 32u8);
n = strconv.u64tos(buf[0:32], t.uval);
os.write(fd, buf.ptr, n: u64);
};};};};};
// TK_FLOAT is intentionally not handled here — %g formatting
// tkind.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.

54
lib/ww/parse/decl.ww
View File

@@ -13,7 +13,7 @@ fn parseuse(p: *parser) *node = {
let id: str;
expectident(p, &id);
n.str = id;
expecttok(p, TK_SEMI, "expected ';' after use");
expecttok(p, tkind.TK_SEMI, "expected ';' after use");
return n;
};
@@ -27,11 +27,11 @@ fn parsedef(p: *parser, exported: i32) *node = {
let id: str;
expectident(p, &id);
n.str = id;
expecttok(p, TK_COLON, "expected ':' in def");
expecttok(p, tkind.TK_COLON, "expected ':' in def");
n.lhs = parsetype(p);
expecttok(p, TK_ASSIGN, "expected '=' in def");
expecttok(p, tkind.TK_ASSIGN, "expected '=' in def");
n.rhs = parseexpr(p);
expecttok(p, TK_SEMI, "expected ';' after def");
expecttok(p, tkind.TK_SEMI, "expected ';' after def");
n.exported = exported;
return n;
};
@@ -41,31 +41,31 @@ fn parselet(p: *parser, exported: i32) *node = {
let pl: i32 = p.curline;
let pc: i32 = p.curcol;
// Accept `let` or `const`. Const-bound bindings are marked via
// n.op = TK_CONST so the checker can reject reassignment.
// n.op = tkind.TK_CONST so the checker can reject reassignment.
let is_const: i32 = 0;
if (p.curkind == TK_CONST) { is_const = 1; };
if (p.curkind == tkind.TK_CONST) { is_const = 1; };
advance(p);
let n: *node = newnode(p.a, N_LET, pf, pl, pc);
n.module = p.l.module;
let id: str;
expectbindname(p, &id);
n.str = id;
if (accepttok(p, TK_COLON)) {
if (accepttok(p, tkind.TK_COLON)) {
n.lhs = parsetype(p);
};
if (accepttok(p, TK_ASSIGN)) {
if (accepttok(p, tkind.TK_ASSIGN)) {
n.rhs = parseexpr(p);
};
expecttok(p, TK_SEMI, "expected ';' after let");
expecttok(p, tkind.TK_SEMI, "expected ';' after let");
n.exported = exported;
if (is_const != 0) { n.op = TK_CONST; };
if (is_const != 0) { n.op = tkind.TK_CONST; };
return n;
};
fn parseattrs(p: *parser) *node = {
let head: *node = nil;
let tail: *node = nil;
for (p.curkind == TK_AT) {
for (p.curkind == tkind.TK_AT) {
let pf: str = p.curfile;
let pl: i32 = p.curline;
let pc: i32 = p.curcol;
@@ -76,11 +76,11 @@ fn parseattrs(p: *parser) *node = {
a.str = id;
// `@name(args...)` for FFI-style attrs; `@name` for marker-
// only attrs like @test (no parens).
if (accepttok(p, TK_LPAREN)) {
if (accepttok(p, tkind.TK_LPAREN)) {
let arghead: *node = nil;
parsearglist(p, TK_RPAREN, &arghead);
parsearglist(p, tkind.TK_RPAREN, &arghead);
a.list = arghead;
expecttok(p, TK_RPAREN, "expected ')' after attribute args");
expecttok(p, tkind.TK_RPAREN, "expected ')' after attribute args");
};
if (head == nil) { head = a; tail = a; }
else { tail.next = a; tail = a; };
@@ -89,7 +89,7 @@ fn parseattrs(p: *parser) *node = {
};
fn parseparams(p: *parser) *node = {
if (p.curkind == TK_RPAREN) { return nil; };
if (p.curkind == tkind.TK_RPAREN) { return nil; };
let head: *node = nil;
let tail: *node = nil;
for (true) {
@@ -102,12 +102,12 @@ fn parseparams(p: *parser) *node = {
let id: str;
expectbindname(p, &id);
n.str = id;
expecttok(p, TK_COLON, "expected ':' in parameter");
expecttok(p, tkind.TK_COLON, "expected ':' in parameter");
n.lhs = parsetype(p);
if (head == nil) { head = n; tail = n; }
else { tail.next = n; tail = n; };
if (!accepttok(p, TK_COMMA)) { break; };
if (p.curkind == TK_RPAREN) { break; };
if (!accepttok(p, tkind.TK_COMMA)) { break; };
if (p.curkind == tkind.TK_RPAREN) { break; };
};
return head;
};
@@ -122,20 +122,20 @@ fn parsefn(p: *parser, exported: i32, attrs: *node) *node = {
let id: str;
expectident(p, &id);
n.str = id;
expecttok(p, TK_LPAREN, "expected '(' after fn name");
expecttok(p, tkind.TK_LPAREN, "expected '(' after fn name");
n.list = parseparams(p);
expecttok(p, TK_RPAREN, "expected ')' after params");
if (p.curkind != TK_ASSIGN) {
if (p.curkind != TK_SEMI) {
expecttok(p, tkind.TK_RPAREN, "expected ')' after params");
if (p.curkind != tkind.TK_ASSIGN) {
if (p.curkind != tkind.TK_SEMI) {
n.lhs = parsetype(p);
};
};
if (accepttok(p, TK_ASSIGN)) {
if (accepttok(p, tkind.TK_ASSIGN)) {
n.body = parseblock(p);
expecttok(p, TK_SEMI, "expected ';' after fn body");
expecttok(p, tkind.TK_SEMI, "expected ';' after fn body");
} else {
// Body-less fn: FFI declaration (`fn name(args) ret;`).
expecttok(p, TK_SEMI, "expected ';' after fn header");
expecttok(p, tkind.TK_SEMI, "expected ';' after fn header");
};
n.exported = exported;
n.attr = attrs;
@@ -152,9 +152,9 @@ fn parsetypedecl(p: *parser, exported: i32) *node = {
let id: str;
expectident(p, &id);
n.str = id;
expecttok(p, TK_ASSIGN, "expected '=' in type decl");
expecttok(p, tkind.TK_ASSIGN, "expected '=' in type decl");
n.lhs = parsetype(p);
expecttok(p, TK_SEMI, "expected ';' after type decl");
expecttok(p, tkind.TK_SEMI, "expected ';' after type decl");
n.exported = exported;
return n;
};

140
lib/ww/parse/expr.ww
View File

@@ -21,42 +21,42 @@ fn parseprimary(p: *parser) *node = {
let pl: i32 = p.curline;
let pc: i32 = p.curcol;
if (p.curkind == TK_INT) {
if (p.curkind == tkind.TK_INT) {
let n: *node = newnode(p.a, N_INTLIT, pf, pl, pc);
n.uval = p.curuval;
n.str = p.curtext;
advance(p);
return n;
};
if (p.curkind == TK_STR) {
if (p.curkind == tkind.TK_STR) {
let n: *node = newnode(p.a, N_STRLIT, pf, pl, pc);
n.str = p.curtext;
advance(p);
return n;
};
if (p.curkind == TK_RUNE) {
if (p.curkind == tkind.TK_RUNE) {
let n: *node = newnode(p.a, N_RUNELIT, pf, pl, pc);
n.uval = p.curuval;
advance(p);
return n;
};
if (p.curkind == TK_TRUE) {
if (p.curkind == tkind.TK_TRUE) {
advance(p);
return newnode(p.a, N_TRUE, pf, pl, pc);
};
if (p.curkind == TK_FALSE) {
if (p.curkind == tkind.TK_FALSE) {
advance(p);
return newnode(p.a, N_FALSE, pf, pl, pc);
};
if (p.curkind == TK_NIL) {
if (p.curkind == tkind.TK_NIL) {
advance(p);
return newnode(p.a, N_NIL, pf, pl, pc);
};
if (p.curkind == TK_VOID) {
if (p.curkind == tkind.TK_VOID) {
advance(p);
return newnode(p.a, N_VOIDLIT, pf, pl, pc);
};
if (p.curkind == TK_UNDER) {
if (p.curkind == tkind.TK_UNDER) {
// Bare `_` — valid only as a discard lvalue. Emit an N_IDENT
// with empty str; the checker rejects it outside lvalue
// positions.
@@ -66,7 +66,7 @@ fn parseprimary(p: *parser) *node = {
n.str = empty;
return n;
};
if (p.curkind == TK_LBRACK) {
if (p.curkind == tkind.TK_LBRACK) {
// Array literal `[a, b, c]` or `[v, w...]` (repeat suffix).
// The repeat marker is an N_FIELD node with str = "..."
// appended to the element list so cgen can detect it.
@@ -74,12 +74,12 @@ fn parseprimary(p: *parser) *node = {
let n: *node = newnode(p.a, N_ARRLIT, pf, pl, pc);
let head: *node = nil;
let tail: *node = nil;
for (p.curkind != TK_RBRACK) {
if (p.curkind == TK_EOF) { break; };
for (p.curkind != tkind.TK_RBRACK) {
if (p.curkind == tkind.TK_EOF) { break; };
let e: *node = parseexpr(p);
if (head == nil) { head = e; tail = e; }
else { tail.next = e; tail = e; };
if (accepttok(p, TK_ELLIPSIS)) {
if (accepttok(p, tkind.TK_ELLIPSIS)) {
let rep: *node = newnode(p.a, N_FIELD,
p.curfile, p.curline, p.curcol);
rep.str = "...";
@@ -87,34 +87,34 @@ fn parseprimary(p: *parser) *node = {
tail = rep;
break;
};
if (!accepttok(p, TK_COMMA)) { break; };
if (!accepttok(p, tkind.TK_COMMA)) { break; };
};
expecttok(p, TK_RBRACK, "expected ']' after array literal");
expecttok(p, tkind.TK_RBRACK, "expected ']' after array literal");
n.list = head;
return n;
};
if (p.curkind == TK_LPAREN) {
if (p.curkind == tkind.TK_LPAREN) {
advance(p);
let e: *node = parseexpr(p);
// Tuple literal: (a, b, ...)
if (accepttok(p, TK_COMMA)) {
if (accepttok(p, tkind.TK_COMMA)) {
let t: *node = newnode(p.a, N_TUPLE, pf, pl, pc);
t.list = e;
let tail: *node = e;
for (true) {
if (p.curkind == TK_RPAREN) { break; };
if (p.curkind == tkind.TK_RPAREN) { break; };
let en: *node = parseexpr(p);
tail.next = en;
tail = en;
if (!accepttok(p, TK_COMMA)) { break; };
if (!accepttok(p, tkind.TK_COMMA)) { break; };
};
expecttok(p, TK_RPAREN, "expected ')' in tuple");
expecttok(p, tkind.TK_RPAREN, "expected ')' in tuple");
return t;
};
expecttok(p, TK_RPAREN, "expected ')'");
expecttok(p, tkind.TK_RPAREN, "expected ')'");
return e;
};
if (p.curkind == TK_IDENT) {
if (p.curkind == tkind.TK_IDENT) {
let n: *node = newnode(p.a, N_IDENT, pf, pl, pc);
n.str = p.curtext;
advance(p);
@@ -124,19 +124,19 @@ fn parseprimary(p: *parser) *node = {
// expressions, never directly from cond contexts that need a
// block; in stmt parsing, the for/if drivers consume their
// own paren/cond, so this is safe.
if (p.curkind == TK_LBRACE) {
if (p.curkind == tkind.TK_LBRACE) {
advance(p);
let s: *node = newnode(p.a, N_STRUCTLIT, pf, pl, pc);
s.lhs = n;
let head: *node = nil;
let tail: *node = nil;
for (p.curkind != TK_RBRACE) {
if (p.curkind == TK_EOF) { break; };
for (p.curkind != tkind.TK_RBRACE) {
if (p.curkind == tkind.TK_EOF) { break; };
// Trailing `...` autofill marker. Stash on s.op so
// cgen can zero-fill the slot before per-field stores.
if (p.curkind == TK_ELLIPSIS) {
if (p.curkind == tkind.TK_ELLIPSIS) {
advance(p);
s.op = TK_ELLIPSIS;
s.op = tkind.TK_ELLIPSIS;
break;
};
let fpf: str = p.curfile;
@@ -144,53 +144,53 @@ fn parseprimary(p: *parser) *node = {
let fpc: i32 = p.curcol;
let id: str;
expectident(p, &id);
expecttok(p, TK_ASSIGN, "expected '=' in struct lit field");
expecttok(p, tkind.TK_ASSIGN, "expected '=' in struct lit field");
let v: *node = parseexpr(p);
let f: *node = newnode(p.a, N_FIELD, fpf, fpl, fpc);
f.str = id;
f.lhs = v;
if (head == nil) { head = f; tail = f; }
else { tail.next = f; tail = f; };
if (!accepttok(p, TK_COMMA)) { break; };
if (!accepttok(p, tkind.TK_COMMA)) { break; };
};
expecttok(p, TK_RBRACE, "expected '}' after struct literal");
expecttok(p, tkind.TK_RBRACE, "expected '}' after struct literal");
s.list = head;
return s;
};
return n;
};
if (p.curkind == TK_MATCH) {
if (p.curkind == tkind.TK_MATCH) {
// match (e) { case let v: T => stmt; case T => stmt; case => stmt; };
advance(p);
expecttok(p, TK_LPAREN, "expected '(' after match");
expecttok(p, tkind.TK_LPAREN, "expected '(' after match");
let m: *node = newnode(p.a, N_MATCH, pf, pl, pc);
m.lhs = parseexpr(p);
expecttok(p, TK_RPAREN, "expected ')' after match scrutinee");
expecttok(p, TK_LBRACE, "expected '{' to open match body");
expecttok(p, tkind.TK_RPAREN, "expected ')' after match scrutinee");
expecttok(p, tkind.TK_LBRACE, "expected '{' to open match body");
let head: *node = nil;
let tail: *node = nil;
for (p.curkind == TK_CASE) {
for (p.curkind == tkind.TK_CASE) {
let cf: str = p.curfile;
let cl: i32 = p.curline;
let cc: i32 = p.curcol;
advance(p); // past `case`
let mc: *node = newnode(p.a, N_MCASE, cf, cl, cc);
if (p.curkind == TK_LET) {
if (p.curkind == tkind.TK_LET) {
advance(p);
let id: str;
expectident(p, &id);
mc.str = id;
expecttok(p, TK_COLON, "expected ':' after match binding");
expecttok(p, tkind.TK_COLON, "expected ':' after match binding");
mc.lhs = parsetype(p);
} else { if (p.curkind != TK_FATARROW) {
} else { if (p.curkind != tkind.TK_FATARROW) {
mc.lhs = parsetype(p);
};};
expecttok(p, TK_FATARROW, "expected '=>' in match arm");
expecttok(p, tkind.TK_FATARROW, "expected '=>' in match arm");
mc.body = parsestmt(p);
if (head == nil) { head = mc; tail = mc; }
else { tail.next = mc; tail = mc; };
};
expecttok(p, TK_RBRACE, "expected '}' after match body");
expecttok(p, tkind.TK_RBRACE, "expected '}' after match body");
m.list = head;
return m;
};
@@ -208,7 +208,7 @@ fn parsearglist(p: *parser, closekind: i32, headout: **node) void = {
let e: *node = parseexpr(p);
if (head == nil) { head = e; tail = e; }
else { tail.next = e; tail = e; };
if (!accepttok(p, TK_COMMA)) { break; };
if (!accepttok(p, tkind.TK_COMMA)) { break; };
if (p.curkind == closekind) { break; };
};
*headout = head;
@@ -220,7 +220,7 @@ fn parsepostfix(p: *parser, lhs: *node) *node = {
let pf: str = p.curfile;
let pl: i32 = p.curline;
let pc: i32 = p.curcol;
if (p.curkind == TK_LPAREN) {
if (p.curkind == tkind.TK_LPAREN) {
advance(p);
let n: *node = newnode(p.a, N_CALL, pf, pl, pc);
n.lhs = cur;
@@ -235,24 +235,24 @@ fn parsepostfix(p: *parser, lhs: *node) *node = {
n.list = parsetype(p);
} else {
let arghead: *node = nil;
parsearglist(p, TK_RPAREN, &arghead);
parsearglist(p, tkind.TK_RPAREN, &arghead);
n.list = arghead;
};
expecttok(p, TK_RPAREN, "expected ')' after args");
expecttok(p, tkind.TK_RPAREN, "expected ')' after args");
cur = n;
continue;
};
if (p.curkind == TK_LBRACK) {
if (p.curkind == tkind.TK_LBRACK) {
advance(p);
// `[ : hi ]` — slice with implicit lo = 0.
if (p.curkind == TK_COLON) {
if (p.curkind == tkind.TK_COLON) {
advance(p);
let n: *node = newnode(p.a, N_SLICE, pf, pl, pc);
n.lhs = cur;
if (p.curkind != TK_RBRACK) {
if (p.curkind != tkind.TK_RBRACK) {
n.cond = parseexpr(p);
};
expecttok(p, TK_RBRACK, "expected ']' in slice");
expecttok(p, tkind.TK_RBRACK, "expected ']' in slice");
cur = n;
continue;
};
@@ -262,33 +262,33 @@ fn parsepostfix(p: *parser, lhs: *node) *node = {
p.nocast = 1;
let e: *node = parseexpr(p);
p.nocast = prev;
if (p.curkind == TK_COLON) {
if (p.curkind == tkind.TK_COLON) {
advance(p);
let n: *node = newnode(p.a, N_SLICE, pf, pl, pc);
n.lhs = cur;
n.rhs = e;
if (p.curkind != TK_RBRACK) {
if (p.curkind != tkind.TK_RBRACK) {
n.cond = parseexpr(p);
};
expecttok(p, TK_RBRACK, "expected ']' in slice");
expecttok(p, tkind.TK_RBRACK, "expected ']' in slice");
cur = n;
continue;
};
let n: *node = newnode(p.a, N_INDEX, pf, pl, pc);
n.lhs = cur;
n.rhs = e;
expecttok(p, TK_RBRACK, "expected ']' after index");
expecttok(p, tkind.TK_RBRACK, "expected ']' after index");
cur = n;
continue;
};
if (p.curkind == TK_DOT) {
if (p.curkind == tkind.TK_DOT) {
advance(p);
let n: *node = newnode(p.a, N_DOT, pf, pl, pc);
n.lhs = cur;
// Hare-style tuple field access: `t.0`, `t.1`. The
// numeric literal becomes the field name string so the
// cgen tuple-positional path matches `cmd/wcc/parse.c`.
if (p.curkind == TK_INT) {
if (p.curkind == tkind.TK_INT) {
n.str = p.curtext;
advance(p);
} else {
@@ -299,7 +299,7 @@ fn parsepostfix(p: *parser, lhs: *node) *node = {
cur = n;
continue;
};
if (p.curkind == TK_COLON) {
if (p.curkind == tkind.TK_COLON) {
if (p.nocast != 0) {
return cur;
};
@@ -314,7 +314,7 @@ fn parsepostfix(p: *parser, lhs: *node) *node = {
// `e as T` — assert lhs is variant T (abort otherwise) → T
// `e is T` — bool: does lhs currently hold variant T?
// Same precedence level as the `:` cast.
if (p.curkind == TK_AS) {
if (p.curkind == tkind.TK_AS) {
advance(p);
let n: *node = newnode(p.a, N_TYPEASSERT, pf, pl, pc);
n.lhs = cur;
@@ -322,7 +322,7 @@ fn parsepostfix(p: *parser, lhs: *node) *node = {
cur = n;
continue;
};
if (p.curkind == TK_IS) {
if (p.curkind == tkind.TK_IS) {
advance(p);
let n: *node = newnode(p.a, N_TYPETEST, pf, pl, pc);
n.lhs = cur;
@@ -332,14 +332,14 @@ fn parsepostfix(p: *parser, lhs: *node) *node = {
};
// `e?` — propagate error variant up the stack.
// `e!` — abort on error variant.
if (p.curkind == TK_QUESTION) {
if (p.curkind == tkind.TK_QUESTION) {
advance(p);
let n: *node = newnode(p.a, N_TRYPROP, pf, pl, pc);
n.lhs = cur;
cur = n;
continue;
};
if (p.curkind == TK_NOT) {
if (p.curkind == tkind.TK_NOT) {
advance(p);
let n: *node = newnode(p.a, N_TRYUNW, pf, pl, pc);
n.lhs = cur;
@@ -356,40 +356,40 @@ fn parseunary(p: *parser) *node = {
let pl: i32 = p.curline;
let pc: i32 = p.curcol;
let k: i32 = p.curkind;
if (k == TK_MINUS) {
if (k == tkind.TK_MINUS) {
advance(p);
let n: *node = newnode(p.a, N_UN, pf, pl, pc);
n.op = TK_MINUS; n.lhs = parseunary(p);
n.op = tkind.TK_MINUS; n.lhs = parseunary(p);
return n;
};
if (k == TK_PLUS) {
if (k == tkind.TK_PLUS) {
advance(p);
let n: *node = newnode(p.a, N_UN, pf, pl, pc);
n.op = TK_PLUS; n.lhs = parseunary(p);
n.op = tkind.TK_PLUS; n.lhs = parseunary(p);
return n;
};
if (k == TK_NOT) {
if (k == tkind.TK_NOT) {
advance(p);
let n: *node = newnode(p.a, N_UN, pf, pl, pc);
n.op = TK_NOT; n.lhs = parseunary(p);
n.op = tkind.TK_NOT; n.lhs = parseunary(p);
return n;
};
if (k == TK_TILDE) {
if (k == tkind.TK_TILDE) {
advance(p);
let n: *node = newnode(p.a, N_UN, pf, pl, pc);
n.op = TK_TILDE; n.lhs = parseunary(p);
n.op = tkind.TK_TILDE; n.lhs = parseunary(p);
return n;
};
if (k == TK_STAR) {
if (k == tkind.TK_STAR) {
advance(p);
let n: *node = newnode(p.a, N_UN, pf, pl, pc);
n.op = TK_STAR; n.lhs = parseunary(p);
n.op = tkind.TK_STAR; n.lhs = parseunary(p);
return n;
};
if (k == TK_AMP) {
if (k == tkind.TK_AMP) {
advance(p);
let n: *node = newnode(p.a, N_UN, pf, pl, pc);
n.op = TK_AMP; n.lhs = parseunary(p);
n.op = tkind.TK_AMP; n.lhs = parseunary(p);
return n;
};
return parsepostfix(p, parseprimary(p));

170
lib/ww/parse/parse.ww
View File

@@ -24,7 +24,7 @@ type parser = struct {
// nocast: while inside `[...]` we treat ':' as the slice
// separator, not the cast operator. Mirrors parse.c's flag.
nocast: i32,
curkind: i32,
curkind: i32, // holds a `tkind` value (relaxation lets it mix)
curfile: str,
curline: i32,
curcol: i32,
@@ -72,10 +72,10 @@ fn expecttok(p: *parser, k: i32, what: str) bool = {
return false;
};
// expectident — consume the current TK_IDENT and return its text.
// expectident — consume the current tkind.TK_IDENT and return its text.
// Returns the empty str on error (and advances to make progress).
fn expectident(p: *parser, into: *str) bool = {
if (p.curkind != TK_IDENT) {
if (p.curkind != tkind.TK_IDENT) {
errmsg(p, "expected identifier");
advance(p);
return false;
@@ -89,7 +89,7 @@ fn expectident(p: *parser, into: *str) bool = {
// discard marker. On `_`, returns "" so the checker skips
// scope_define for the binding.
fn expectbindname(p: *parser, into: *str) bool = {
if (p.curkind == TK_UNDER) {
if (p.curkind == tkind.TK_UNDER) {
let empty: str;
*into = empty;
advance(p);
@@ -129,7 +129,7 @@ fn parsetype(p: *parser) *node = {
let pl: i32 = p.curline;
let pc: i32 = p.curcol;
if (p.curkind == TK_NOT) {
if (p.curkind == tkind.TK_NOT) {
// `!T` — Hare error-flagged type wrapper.
advance(p);
let n: *node = newnode(p.a, N_TBANG, pf, pl, pc);
@@ -137,16 +137,16 @@ fn parsetype(p: *parser) *node = {
return n;
};
if (p.curkind == TK_STAR) {
if (p.curkind == tkind.TK_STAR) {
advance(p);
let n: *node = newnode(p.a, N_TPTR, pf, pl, pc);
n.lhs = parsetype(p);
return n;
};
if (p.curkind == TK_LBRACK) {
if (p.curkind == tkind.TK_LBRACK) {
advance(p);
if (p.curkind == TK_RBRACK) {
if (p.curkind == tkind.TK_RBRACK) {
advance(p);
let n: *node = newnode(p.a, N_TSLICE, pf, pl, pc);
n.lhs = parsetype(p);
@@ -156,24 +156,24 @@ fn parsetype(p: *parser) *node = {
// `[_]T` — length inferred from initialiser. n.rhs stays nil
// as the sentinel; the cgen path for N_LET fills it from the
// array literal's element count.
if (p.curkind == TK_UNDER) {
if (p.curkind == tkind.TK_UNDER) {
advance(p);
} else {
n.rhs = parseexpr(p);
};
expecttok(p, TK_RBRACK, "expected ']' in array type");
expecttok(p, tkind.TK_RBRACK, "expected ']' in array type");
n.lhs = parsetype(p);
return n;
};
if (p.curkind == TK_STRUCT) {
if (p.curkind == tkind.TK_STRUCT) {
advance(p);
expecttok(p, TK_LBRACE, "expected '{' after struct");
expecttok(p, tkind.TK_LBRACE, "expected '{' after struct");
let n: *node = newnode(p.a, N_TSTRUCT, pf, pl, pc);
let fhead: *node = nil;
let ftail: *node = nil;
for (p.curkind != TK_RBRACE) {
if (p.curkind == TK_EOF) { break; };
for (p.curkind != tkind.TK_RBRACE) {
if (p.curkind == tkind.TK_EOF) { break; };
let fpf: str = p.curfile;
let fpl: i32 = p.curline;
let fpc: i32 = p.curcol;
@@ -181,32 +181,32 @@ fn parsetype(p: *parser) *node = {
let fid: str;
expectident(p, &fid);
f.str = fid;
expecttok(p, TK_COLON, "expected ':' in field");
expecttok(p, tkind.TK_COLON, "expected ':' in field");
f.lhs = parsetype(p);
if (fhead == nil) { fhead = f; ftail = f; }
else { ftail.next = f; ftail = f; };
if (!accepttok(p, TK_COMMA)) { break; };
if (!accepttok(p, tkind.TK_COMMA)) { break; };
};
expecttok(p, TK_RBRACE, "expected '}' after struct fields");
expecttok(p, tkind.TK_RBRACE, "expected '}' after struct fields");
n.list = fhead;
return n;
};
if (p.curkind == TK_ENUM) {
if (p.curkind == tkind.TK_ENUM) {
// `enum [storage] { NAME [= expr], ... }`
// Storage defaults to i32 (lhs == nil). Each member is an
// N_TENUMMEMBER with str=name and lhs = value expr or nil
// (auto-increment when omitted).
advance(p);
let n: *node = newnode(p.a, N_TENUM, pf, pl, pc);
if (p.curkind != TK_LBRACE) {
if (p.curkind != tkind.TK_LBRACE) {
n.lhs = parsetype(p);
};
expecttok(p, TK_LBRACE, "expected '{' after enum");
expecttok(p, tkind.TK_LBRACE, "expected '{' after enum");
let mhead: *node = nil;
let mtail: *node = nil;
for (p.curkind != TK_RBRACE) {
if (p.curkind == TK_EOF) { break; };
for (p.curkind != tkind.TK_RBRACE) {
if (p.curkind == tkind.TK_EOF) { break; };
let mpf: str = p.curfile;
let mpl: i32 = p.curline;
let mpc: i32 = p.curcol;
@@ -214,19 +214,19 @@ fn parsetype(p: *parser) *node = {
let mid: str;
expectident(p, &mid);
m.str = mid;
if (accepttok(p, TK_ASSIGN)) {
if (accepttok(p, tkind.TK_ASSIGN)) {
m.lhs = parseexpr(p);
};
if (mhead == nil) { mhead = m; mtail = m; }
else { mtail.next = m; mtail = m; };
if (!accepttok(p, TK_COMMA)) { break; };
if (!accepttok(p, tkind.TK_COMMA)) { break; };
};
expecttok(p, TK_RBRACE, "expected '}' after enum members");
expecttok(p, tkind.TK_RBRACE, "expected '}' after enum members");
n.list = mhead;
return n;
};
if (p.curkind == TK_VOID) {
if (p.curkind == tkind.TK_VOID) {
// `void` keyword in type-expr context — emit as N_TNAME so
// resolution treats it like any other primitive name.
let n: *node = newnode(p.a, N_TNAME, pf, pl, pc);
@@ -235,15 +235,15 @@ fn parsetype(p: *parser) *node = {
return n;
};
if (p.curkind == TK_IDENT) {
if (p.curkind == tkind.TK_IDENT) {
let n: *node = newnode(p.a, N_TNAME, pf, pl, pc);
let acc: str = p.curtext;
advance(p);
// Dotted path collapse: pkg.Type → single TNAME with the
// joined string. Mirrors C parsetype's loop.
for (p.curkind == TK_DOT) {
for (p.curkind == tkind.TK_DOT) {
advance(p);
if (p.curkind != TK_IDENT) { break; };
if (p.curkind != tkind.TK_IDENT) { break; };
acc = joindotted(p.a, acc, p.curtext);
advance(p);
};
@@ -251,11 +251,11 @@ fn parsetype(p: *parser) *node = {
return n;
};
if (p.curkind == TK_LPAREN) {
if (p.curkind == tkind.TK_LPAREN) {
// (T) or (T, T, ...) or (T | T | ...)
advance(p);
let first: *node = parsetype(p);
if (accepttok(p, TK_PIPE)) {
if (accepttok(p, tkind.TK_PIPE)) {
let n: *node = newnode(p.a, N_TTAGGED, pf, pl, pc);
let head: *node = first;
let tail: *node = first;
@@ -263,14 +263,14 @@ fn parsetype(p: *parser) *node = {
let e: *node = parsetype(p);
tail.next = e;
tail = e;
if (!accepttok(p, TK_PIPE)) { break; };
if (!accepttok(p, tkind.TK_PIPE)) { break; };
};
expecttok(p, TK_RPAREN, "expected ')' in tagged-union type");
expecttok(p, tkind.TK_RPAREN, "expected ')' in tagged-union type");
n.list = head;
return n;
};
if (!accepttok(p, TK_COMMA)) {
expecttok(p, TK_RPAREN, "expected ')' after parenthesised type");
if (!accepttok(p, tkind.TK_COMMA)) {
expecttok(p, tkind.TK_RPAREN, "expected ')' after parenthesised type");
return first;
};
let n: *node = newnode(p.a, N_TTUPLE, pf, pl, pc);
@@ -280,23 +280,23 @@ fn parsetype(p: *parser) *node = {
let e: *node = parsetype(p);
tail.next = e;
tail = e;
if (!accepttok(p, TK_COMMA)) { break; };
if (p.curkind == TK_RPAREN) { break; };
if (!accepttok(p, tkind.TK_COMMA)) { break; };
if (p.curkind == tkind.TK_RPAREN) { break; };
};
expecttok(p, TK_RPAREN, "expected ')' in tuple type");
expecttok(p, tkind.TK_RPAREN, "expected ')' in tuple type");
n.list = head;
return n;
};
if (p.curkind == TK_FN) {
if (p.curkind == tkind.TK_FN) {
advance(p);
expecttok(p, TK_LPAREN, "expected '(' after fn in type");
expecttok(p, tkind.TK_LPAREN, "expected '(' after fn in type");
let n: *node = newnode(p.a, N_TFN, pf, pl, pc);
// Anonymous-or-named params: parseparams handles named only;
// for fn-type expressions the C parser allows IDENT-less
// (anonymous) params. Stub: only named params for now.
n.list = parseparams(p);
expecttok(p, TK_RPAREN, "expected ')' after fn type params");
expecttok(p, tkind.TK_RPAREN, "expected ')' after fn type params");
n.lhs = parsetype(p);
return n;
};
@@ -314,39 +314,39 @@ fn parsetype(p: *parser) *node = {
// AST diff fixture grows to need them.
fn bprec(k: i32) i32 = {
if (k == TK_OR) { return 1; };
if (k == TK_AND) { return 2; };
if (k == TK_EQ) { return 3; };
if (k == TK_NEQ) { return 3; };
if (k == TK_LT) { return 4; };
if (k == TK_LE) { return 4; };
if (k == TK_GT) { return 4; };
if (k == TK_GE) { return 4; };
if (k == TK_PIPE) { return 5; };
if (k == TK_CARET) { return 6; };
if (k == TK_AMP) { return 7; };
if (k == TK_LSHIFT) { return 8; };
if (k == TK_RSHIFT) { return 8; };
if (k == TK_PLUS) { return 9; };
if (k == TK_MINUS) { return 9; };
if (k == TK_STAR) { return 10; };
if (k == TK_SLASH) { return 10; };
if (k == TK_PERCENT) { return 10; };
if (k == tkind.TK_OR) { return 1; };
if (k == tkind.TK_AND) { return 2; };
if (k == tkind.TK_EQ) { return 3; };
if (k == tkind.TK_NEQ) { return 3; };
if (k == tkind.TK_LT) { return 4; };
if (k == tkind.TK_LE) { return 4; };
if (k == tkind.TK_GT) { return 4; };
if (k == tkind.TK_GE) { return 4; };
if (k == tkind.TK_PIPE) { return 5; };
if (k == tkind.TK_CARET) { return 6; };
if (k == tkind.TK_AMP) { return 7; };
if (k == tkind.TK_LSHIFT) { return 8; };
if (k == tkind.TK_RSHIFT) { return 8; };
if (k == tkind.TK_PLUS) { return 9; };
if (k == tkind.TK_MINUS) { return 9; };
if (k == tkind.TK_STAR) { return 10; };
if (k == tkind.TK_SLASH) { return 10; };
if (k == tkind.TK_PERCENT) { return 10; };
return 0;
};
fn isassignop(k: i32) bool = {
if (k == TK_ASSIGN) { return true; };
if (k == TK_PLUSEQ) { return true; };
if (k == TK_MINUSEQ) { return true; };
if (k == TK_STAREQ) { return true; };
if (k == TK_SLASHEQ) { return true; };
if (k == TK_PERCENTEQ) { return true; };
if (k == TK_AMPEQ) { return true; };
if (k == TK_PIPEEQ) { return true; };
if (k == TK_CARETEQ) { return true; };
if (k == TK_LSHIFTEQ) { return true; };
if (k == TK_RSHIFTEQ) { return true; };
if (k == tkind.TK_ASSIGN) { return true; };
if (k == tkind.TK_PLUSEQ) { return true; };
if (k == tkind.TK_MINUSEQ) { return true; };
if (k == tkind.TK_STAREQ) { return true; };
if (k == tkind.TK_SLASHEQ) { return true; };
if (k == tkind.TK_PERCENTEQ) { return true; };
if (k == tkind.TK_AMPEQ) { return true; };
if (k == tkind.TK_PIPEEQ) { return true; };
if (k == tkind.TK_CARETEQ) { return true; };
if (k == tkind.TK_LSHIFTEQ) { return true; };
if (k == tkind.TK_RSHIFTEQ) { return true; };
return false;
};
@@ -358,36 +358,36 @@ export fn parsefile(p: *parser) *node = {
let head: *node = nil;
let tail: *node = nil;
for (p.curkind != TK_EOF) {
for (p.curkind != tkind.TK_EOF) {
let attrs: *node = parseattrs(p);
let exported: i32 = 0;
if (p.curkind == TK_EXPORT) { exported = 1; advance(p); };
if (p.curkind == tkind.TK_EXPORT) { exported = 1; advance(p); };
let d: *node = nil;
if (p.curkind == TK_USE) {
if (p.curkind == tkind.TK_USE) {
d = parseuse(p);
} else { if (p.curkind == TK_DEF) {
} else { if (p.curkind == tkind.TK_DEF) {
d = parsedef(p, exported);
} else { if (p.curkind == TK_TYPE) {
} else { if (p.curkind == tkind.TK_TYPE) {
d = parsetypedecl(p, exported);
} else { if (p.curkind == TK_LET) {
} else { if (p.curkind == tkind.TK_LET) {
d = parselet(p, exported);
} else { if (p.curkind == TK_CONST) {
} else { if (p.curkind == tkind.TK_CONST) {
d = parselet(p, exported);
} else { if (p.curkind == TK_FN) {
} else { if (p.curkind == tkind.TK_FN) {
d = parsefn(p, exported, attrs);
} else {
// Recovery: chew tokens until next ';' or EOF, balancing
// '{' '}' pairs so internal ';'s in unfamiliar forms don't
// derail us.
for (p.curkind != TK_SEMI) {
if (p.curkind == TK_EOF) { break; };
if (p.curkind == TK_LBRACE) {
for (p.curkind != tkind.TK_SEMI) {
if (p.curkind == tkind.TK_EOF) { break; };
if (p.curkind == tkind.TK_LBRACE) {
let depth: i32 = 0;
for (true) {
if (p.curkind == TK_EOF) { break; };
if (p.curkind == TK_LBRACE) { depth += 1; advance(p); continue; };
if (p.curkind == TK_RBRACE) {
if (p.curkind == tkind.TK_EOF) { break; };
if (p.curkind == tkind.TK_LBRACE) { depth += 1; advance(p); continue; };
if (p.curkind == tkind.TK_RBRACE) {
depth -= 1;
advance(p);
if (depth == 0) { break; };
@@ -399,7 +399,7 @@ export fn parsefile(p: *parser) *node = {
};
advance(p);
};
if (p.curkind == TK_SEMI) { advance(p); };
if (p.curkind == tkind.TK_SEMI) { advance(p); };
};};};};};};
if (d != nil) {

124
lib/ww/parse/stmt.ww
View File

@@ -8,15 +8,15 @@ fn parseletlocal(p: *parser) *node = {
let pf: str = p.curfile;
let pl: i32 = p.curline;
let pc: i32 = p.curcol;
// `let` or `const`. Const-bound locals are marked via n.op = TK_CONST.
// `let` or `const`. Const-bound locals are marked via n.op = tkind.TK_CONST.
let is_const: i32 = 0;
if (p.curkind == TK_CONST) { is_const = 1; };
if (p.curkind == tkind.TK_CONST) { is_const = 1; };
advance(p);
// Hare-style tuple destructure: `let (a, b) = expr;`.
// Types are optional per binding (matches C parser; Hare itself
// doesn't allow types here, but cmd/wcc/parse.c does).
if (p.curkind == TK_LPAREN) {
if (p.curkind == tkind.TK_LPAREN) {
advance(p);
let m: *node = newnode(p.a, N_MLET, pf, pl, pc);
let head: *node = nil;
@@ -29,21 +29,21 @@ fn parseletlocal(p: *parser) *node = {
let id: str;
expectbindname(p, &id);
l.str = id;
if (accepttok(p, TK_COLON)) { l.lhs = parsetype(p); };
if (accepttok(p, tkind.TK_COLON)) { l.lhs = parsetype(p); };
if (head == nil) { head = l; }
else { tail.next = l; };
tail = l;
if (!accepttok(p, TK_COMMA)) { break; };
if (!accepttok(p, tkind.TK_COMMA)) { break; };
};
expecttok(p, TK_RPAREN, "expected ')' in let destructure");
expecttok(p, TK_ASSIGN, "expected '=' after let destructure");
expecttok(p, tkind.TK_RPAREN, "expected ')' in let destructure");
expecttok(p, tkind.TK_ASSIGN, "expected '=' after let destructure");
m.rhs = parseexpr(p);
expecttok(p, TK_SEMI, "expected ';' after let");
expecttok(p, tkind.TK_SEMI, "expected ';' after let");
m.list = head;
if (is_const != 0) {
m.op = TK_CONST;
m.op = tkind.TK_CONST;
let lc: *node = head;
for (lc != nil) { lc.op = TK_CONST; lc = lc.next; };
for (lc != nil) { lc.op = tkind.TK_CONST; lc = lc.next; };
};
return m;
};
@@ -52,17 +52,17 @@ fn parseletlocal(p: *parser) *node = {
let id: str;
expectbindname(p, &id);
n.str = id;
if (accepttok(p, TK_COLON)) {
if (accepttok(p, tkind.TK_COLON)) {
n.lhs = parsetype(p);
};
// Comma-multi-let: `let n, s = call();` (ww extension over Hare).
// Collects (name, type) pairs, then '=' rhs. Each binding gets
// its own N_LET; the wrapping N_MLET carries the rhs.
if (p.curkind == TK_COMMA) {
if (p.curkind == tkind.TK_COMMA) {
let m: *node = newnode(p.a, N_MLET, pf, pl, pc);
let head: *node = n;
let tail: *node = n;
for (accepttok(p, TK_COMMA)) {
for (accepttok(p, tkind.TK_COMMA)) {
let lpf: str = p.curfile;
let lpl: i32 = p.curline;
let lpc: i32 = p.curcol;
@@ -70,26 +70,26 @@ fn parseletlocal(p: *parser) *node = {
let id2: str;
expectbindname(p, &id2);
l.str = id2;
if (accepttok(p, TK_COLON)) { l.lhs = parsetype(p); };
if (accepttok(p, tkind.TK_COLON)) { l.lhs = parsetype(p); };
tail.next = l;
tail = l;
};
expecttok(p, TK_ASSIGN, "expected '=' after let names");
expecttok(p, tkind.TK_ASSIGN, "expected '=' after let names");
m.rhs = parseexpr(p);
expecttok(p, TK_SEMI, "expected ';' after let");
expecttok(p, tkind.TK_SEMI, "expected ';' after let");
m.list = head;
if (is_const != 0) {
m.op = TK_CONST;
m.op = tkind.TK_CONST;
let lc: *node = head;
for (lc != nil) { lc.op = TK_CONST; lc = lc.next; };
for (lc != nil) { lc.op = tkind.TK_CONST; lc = lc.next; };
};
return m;
};
if (accepttok(p, TK_ASSIGN)) {
if (accepttok(p, tkind.TK_ASSIGN)) {
n.rhs = parseexpr(p);
};
expecttok(p, TK_SEMI, "expected ';' after let");
if (is_const != 0) { n.op = TK_CONST; };
expecttok(p, tkind.TK_SEMI, "expected ';' after let");
if (is_const != 0) { n.op = tkind.TK_CONST; };
return n;
};
@@ -97,19 +97,19 @@ fn parseblock(p: *parser) *node = {
let pf: str = p.curfile;
let pl: i32 = p.curline;
let pc: i32 = p.curcol;
expecttok(p, TK_LBRACE, "expected '{' to open block");
expecttok(p, tkind.TK_LBRACE, "expected '{' to open block");
let blk: *node = newnode(p.a, N_BLOCK, pf, pl, pc);
let head: *node = nil;
let tail: *node = nil;
for (p.curkind != TK_RBRACE) {
if (p.curkind == TK_EOF) { break; };
for (p.curkind != tkind.TK_RBRACE) {
if (p.curkind == tkind.TK_EOF) { break; };
let s: *node = parsestmt(p);
if (s != nil) {
if (head == nil) { head = s; tail = s; }
else { tail.next = s; tail = s; };
};
};
expecttok(p, TK_RBRACE, "expected '}' to close block");
expecttok(p, tkind.TK_RBRACE, "expected '}' to close block");
blk.list = head;
return blk;
};
@@ -119,13 +119,13 @@ fn parseif(p: *parser) *node = {
let pl: i32 = p.curline;
let pc: i32 = p.curcol;
advance(p); // past `if`
expecttok(p, TK_LPAREN, "expected '(' after if");
expecttok(p, tkind.TK_LPAREN, "expected '(' after if");
let n: *node = newnode(p.a, N_IF, pf, pl, pc);
n.cond = parseexpr(p);
expecttok(p, TK_RPAREN, "expected ')' after if condition");
expecttok(p, tkind.TK_RPAREN, "expected ')' after if condition");
n.body = parseblock(p);
if (accepttok(p, TK_ELSE)) {
if (p.curkind == TK_IF) {
if (accepttok(p, tkind.TK_ELSE)) {
if (p.curkind == tkind.TK_IF) {
n.els = parseif(p);
} else {
n.els = parseblock(p);
@@ -139,7 +139,7 @@ fn parsefor(p: *parser) *node = {
let pl: i32 = p.curline;
let pc: i32 = p.curcol;
advance(p); // past `for`
expecttok(p, TK_LPAREN, "expected '(' after for");
expecttok(p, tkind.TK_LPAREN, "expected '(' after for");
let n: *node = newnode(p.a, N_FOR, pf, pl, pc);
// Three forms (matching C parser):
// for (cond) — only cond
@@ -149,15 +149,15 @@ fn parsefor(p: *parser) *node = {
// `let` stmt that's the init. Otherwise, parse expr; if next is
// ';' it was cond. If we see two ';' total after init, post is
// next. Simpler: peek for `let` to decide init form.
if (p.curkind == TK_LET) {
if (p.curkind == tkind.TK_LET) {
n.lhs = parseletlocal(p); // init (consumes its own ';')
n.cond = parseexpr(p);
expecttok(p, TK_SEMI, "expected ';' after for cond");
expecttok(p, tkind.TK_SEMI, "expected ';' after for cond");
n.rhs = parseexpr(p);
} else {
// Parse one expr. If next is ';', it's a 3-clause without init.
let first: *node = parseexpr(p);
if (accepttok(p, TK_SEMI)) {
if (accepttok(p, tkind.TK_SEMI)) {
// cond ; post
n.cond = first;
n.rhs = parseexpr(p);
@@ -166,11 +166,11 @@ fn parsefor(p: *parser) *node = {
n.cond = first;
};
};
expecttok(p, TK_RPAREN, "expected ')' after for");
expecttok(p, tkind.TK_RPAREN, "expected ')' after for");
n.body = parseblock(p);
// Optional `else { ... }` — runs at normal cond-false exit; skipped
// by break. Hare's "did the loop find it?" idiom.
if (accepttok(p, TK_ELSE)) {
if (accepttok(p, tkind.TK_ELSE)) {
n.els = parseblock(p);
};
return n;
@@ -183,37 +183,37 @@ fn parsestmt(p: *parser) *node = {
// `static` is allowed on local lets per Hare; we accept and skip
// it (it doesn't change the AST shape).
if (p.curkind == TK_STATIC) { advance(p); };
if (p.curkind == tkind.TK_STATIC) { advance(p); };
if (p.curkind == TK_LBRACE) {
if (p.curkind == tkind.TK_LBRACE) {
let b: *node = parseblock(p);
expecttok(p, TK_SEMI, "expected ';' after block");
expecttok(p, tkind.TK_SEMI, "expected ';' after block");
return b;
};
if (p.curkind == TK_LET) { return parseletlocal(p); };
if (p.curkind == TK_CONST) { return parseletlocal(p); };
if (p.curkind == TK_IF) {
if (p.curkind == tkind.TK_LET) { return parseletlocal(p); };
if (p.curkind == tkind.TK_CONST) { return parseletlocal(p); };
if (p.curkind == tkind.TK_IF) {
let n: *node = parseif(p);
expecttok(p, TK_SEMI, "expected ';' after if");
expecttok(p, tkind.TK_SEMI, "expected ';' after if");
return n;
};
if (p.curkind == TK_FOR) {
if (p.curkind == tkind.TK_FOR) {
let n: *node = parsefor(p);
expecttok(p, TK_SEMI, "expected ';' after for");
expecttok(p, tkind.TK_SEMI, "expected ';' after for");
return n;
};
if (p.curkind == TK_RETURN) {
if (p.curkind == tkind.TK_RETURN) {
advance(p);
let n: *node = newnode(p.a, N_RETURN, pf, pl, pc);
if (p.curkind != TK_SEMI) {
if (p.curkind != tkind.TK_SEMI) {
let first: *node = parseexpr(p);
// Hare-style multi-value: `return a, b;` becomes a
// tuple expression so codegen sees one rvalue.
if (p.curkind == TK_COMMA) {
if (p.curkind == tkind.TK_COMMA) {
let t: *node = newnode(p.a, N_TUPLE, pf, pl, pc);
t.list = first;
let tail: *node = first;
for (accepttok(p, TK_COMMA)) {
for (accepttok(p, tkind.TK_COMMA)) {
let e: *node = parseexpr(p);
tail.next = e;
tail = e;
@@ -223,31 +223,31 @@ fn parsestmt(p: *parser) *node = {
n.lhs = first;
};
};
expecttok(p, TK_SEMI, "expected ';' after return");
expecttok(p, tkind.TK_SEMI, "expected ';' after return");
return n;
};
if (p.curkind == TK_DEFER) {
if (p.curkind == tkind.TK_DEFER) {
advance(p);
let n: *node = newnode(p.a, N_DEFER, pf, pl, pc);
n.lhs = parseexpr(p);
expecttok(p, TK_SEMI, "expected ';' after defer");
expecttok(p, tkind.TK_SEMI, "expected ';' after defer");
return n;
};
if (p.curkind == TK_YIELD) {
if (p.curkind == tkind.TK_YIELD) {
advance(p);
let n: *node = newnode(p.a, N_YIELD, pf, pl, pc);
n.lhs = parseexpr(p);
expecttok(p, TK_SEMI, "expected ';' after yield");
expecttok(p, tkind.TK_SEMI, "expected ';' after yield");
return n;
};
if (p.curkind == TK_BREAK) {
if (p.curkind == tkind.TK_BREAK) {
advance(p);
expecttok(p, TK_SEMI, "expected ';' after break");
expecttok(p, tkind.TK_SEMI, "expected ';' after break");
return newnode(p.a, N_BREAK, pf, pl, pc);
};
if (p.curkind == TK_CONTINUE) {
if (p.curkind == tkind.TK_CONTINUE) {
advance(p);
expecttok(p, TK_SEMI, "expected ';' after continue");
expecttok(p, tkind.TK_SEMI, "expected ';' after continue");
return newnode(p.a, N_CONTINUE, pf, pl, pc);
};
// expression statement, or tuple-destructure multi-assign:
@@ -257,25 +257,25 @@ fn parsestmt(p: *parser) *node = {
// through parsebin(parseunary, 1) so the `=` stays for us to
// consume — parseexpr would absorb it.
let e: *node = parseexpr(p);
if (p.curkind == TK_COMMA) {
if (p.curkind == tkind.TK_COMMA) {
let m: *node = newnode(p.a, N_MASSIGN, pf, pl, pc);
let head: *node = e;
let tail: *node = e;
for (p.curkind == TK_COMMA) {
for (p.curkind == tkind.TK_COMMA) {
advance(p);
let lv: *node = parsebin(p, parseunary(p), 1);
tail.next = lv;
tail = lv;
};
expecttok(p, TK_ASSIGN, "expected '=' after multi-assign lvalues");
expecttok(p, tkind.TK_ASSIGN, "expected '=' after multi-assign lvalues");
m.rhs = parseexpr(p);
m.list = head;
expecttok(p, TK_SEMI, "expected ';' after multi-assign");
expecttok(p, tkind.TK_SEMI, "expected ';' after multi-assign");
return m;
};
let n: *node = newnode(p.a, N_EXPRSTMT, pf, pl, pc);
n.lhs = e;
expecttok(p, TK_SEMI, "expected ';' after expression statement");
expecttok(p, tkind.TK_SEMI, "expected ';' after expression statement");
return n;
};

1181
selfhost/cmd/w6c/main.combined.ww
View File

File diff suppressed because it is too large Load Diff

26
selfhost/cmd/wcc/cgen.ww
View File

@@ -111,31 +111,31 @@ fn enumevalmember(prev: *enummember, e: *node, out: *u64) bool = {
if (!enumevalmember(prev, e.lhs, &a)) { return false; };
if (!enumevalmember(prev, e.rhs, &b)) { return false; };
let op: i32 = e.op;
if (op == TK_PLUS) { *out = a + b; return true; };
if (op == TK_MINUS) { *out = a - b; return true; };
if (op == TK_STAR) { *out = a * b; return true; };
if (op == TK_SLASH) {
if (op == tkind.TK_PLUS) { *out = a + b; return true; };
if (op == tkind.TK_MINUS) { *out = a - b; return true; };
if (op == tkind.TK_STAR) { *out = a * b; return true; };
if (op == tkind.TK_SLASH) {
if (b == 0u64) { return false; };
*out = a / b; return true;
};
if (op == TK_PERCENT) {
if (op == tkind.TK_PERCENT) {
if (b == 0u64) { return false; };
*out = a % b; return true;
};
if (op == TK_AMP) { *out = a & b; return true; };
if (op == TK_PIPE) { *out = a | b; return true; };
if (op == TK_CARET) { *out = a ^ b; return true; };
if (op == TK_LSHIFT) { *out = a << b; return true; };
if (op == TK_RSHIFT) { *out = a >> b; return true; };
if (op == tkind.TK_AMP) { *out = a & b; return true; };
if (op == tkind.TK_PIPE) { *out = a | b; return true; };
if (op == tkind.TK_CARET) { *out = a ^ b; return true; };
if (op == tkind.TK_LSHIFT) { *out = a << b; return true; };
if (op == tkind.TK_RSHIFT) { *out = a >> b; return true; };
return false;
};
if (k == N_UN) {
let v: u64;
if (!enumevalmember(prev, e.lhs, &v)) { return false; };
let op: i32 = e.op;
if (op == TK_MINUS) { *out = (-(v: i64)): u64; return true; };
if (op == TK_TILDE) { *out = ~v; return true; };
if (op == TK_PLUS) { *out = v; return true; };
if (op == tkind.TK_MINUS) { *out = (-(v: i64)): u64; return true; };
if (op == tkind.TK_TILDE) { *out = ~v; return true; };
if (op == tkind.TK_PLUS) { *out = v; return true; };
return false;
};
return false;

92
selfhost/cmd/wcc/cgenexpr.ww
View File

@@ -935,10 +935,10 @@ fn cgun(c: *cgen, n: *node) void = {
// address / deref. The wasted load before AMP keeps our asm
// byte-identical to the C version.
cgexpr(c, n.lhs);
if (n.op == TK_MINUS) { emitline("\tNEGQ\tAX\n"); return; };
if (n.op == TK_TILDE) { emitline("\tNOTQ\tAX\n"); return; };
if (n.op == TK_STAR) { emitline("\tMOVQ\t(AX), AX\n"); return; };
if (n.op == TK_AMP) {
if (n.op == tkind.TK_MINUS) { emitline("\tNEGQ\tAX\n"); return; };
if (n.op == tkind.TK_TILDE) { emitline("\tNOTQ\tAX\n"); return; };
if (n.op == tkind.TK_STAR) { emitline("\tMOVQ\t(AX), AX\n"); return; };
if (n.op == tkind.TK_AMP) {
let opnd: *node = n.lhs;
if (opnd != nil) {
if (opnd.kind == N_IDENT) {
@@ -954,7 +954,7 @@ fn cgun(c: *cgen, n: *node) void = {
};
return;
};
if (n.op == TK_NOT) {
if (n.op == tkind.TK_NOT) {
let t: str = mklabel(c, "tt");
let e: str = mklabel(c, "te");
emitline("\tCMPQ\t$0, AX\n");
@@ -977,48 +977,48 @@ fn cgbin(c: *cgen, n: *node) void = {
emitline("\tPUSHQ\tAX\n");
cgexpr(c, n.lhs);
emitline("\tPOPQ\tBX\n");
if (n.op == TK_PLUS) { emitline("\tADDQ\tBX, AX\n"); return; };
if (n.op == TK_MINUS) { emitline("\tSUBQ\tBX, AX\n"); return; };
if (n.op == TK_STAR) { emitline("\tIMULQ\tBX, AX\n"); return; };
if (n.op == TK_SLASH) {
if (n.op == tkind.TK_PLUS) { emitline("\tADDQ\tBX, AX\n"); return; };
if (n.op == tkind.TK_MINUS) { emitline("\tSUBQ\tBX, AX\n"); return; };
if (n.op == tkind.TK_STAR) { emitline("\tIMULQ\tBX, AX\n"); return; };
if (n.op == tkind.TK_SLASH) {
emitline("\tMOVQ\t$0, DX\n");
if (unsignd) { emitline("\tDIVQ\tBX\n"); }
else { emitline("\tIDIVQ\tBX\n"); };
return;
};
if (n.op == TK_PERCENT) {
if (n.op == tkind.TK_PERCENT) {
emitline("\tMOVQ\t$0, DX\n");
if (unsignd) { emitline("\tDIVQ\tBX\n"); }
else { emitline("\tIDIVQ\tBX\n"); };
emitline("\tMOVQ\tDX, AX\n");
return;
};
if (n.op == TK_AMP) { emitline("\tANDQ\tBX, AX\n"); return; };
if (n.op == TK_PIPE) { emitline("\tORQ\tBX, AX\n"); return; };
if (n.op == TK_CARET) { emitline("\tXORQ\tBX, AX\n"); return; };
if (n.op == TK_LSHIFT) {
if (n.op == tkind.TK_AMP) { emitline("\tANDQ\tBX, AX\n"); return; };
if (n.op == tkind.TK_PIPE) { emitline("\tORQ\tBX, AX\n"); return; };
if (n.op == tkind.TK_CARET) { emitline("\tXORQ\tBX, AX\n"); return; };
if (n.op == tkind.TK_LSHIFT) {
emitline("\tMOVQ\tBX, CX\n");
emitline("\tSHLQ\tCX, AX\n");
return;
};
if (n.op == TK_RSHIFT) {
if (n.op == tkind.TK_RSHIFT) {
emitline("\tMOVQ\tBX, CX\n");
emitline("\tSHRQ\tCX, AX\n");
return;
};
if (n.op == TK_AND) { emitline("\tANDQ\tBX, AX\n"); return; };
if (n.op == TK_OR) { emitline("\tORQ\tBX, AX\n"); return; };
if (n.op == tkind.TK_AND) { emitline("\tANDQ\tBX, AX\n"); return; };
if (n.op == tkind.TK_OR) { emitline("\tORQ\tBX, AX\n"); return; };
// Comparison: emit CMPQ, jump on signed/unsigned variant,
// materialise 0/1 in AX. Same shape as the C cgen.
let iscmp: bool = false;
let jcc: str = "";
if (n.op == TK_EQ) { iscmp = true; jcc = "JE"; };
if (n.op == TK_NEQ) { iscmp = true; jcc = "JNE"; };
if (n.op == TK_LT) { iscmp = true; if (unsignd) { jcc = "JB"; } else { jcc = "JL"; }; };
if (n.op == TK_LE) { iscmp = true; if (unsignd) { jcc = "JBE"; } else { jcc = "JLE"; }; };
if (n.op == TK_GT) { iscmp = true; if (unsignd) { jcc = "JA"; } else { jcc = "JG"; }; };
if (n.op == TK_GE) { iscmp = true; if (unsignd) { jcc = "JAE"; } else { jcc = "JGE"; }; };
if (n.op == tkind.TK_EQ) { iscmp = true; jcc = "JE"; };
if (n.op == tkind.TK_NEQ) { iscmp = true; jcc = "JNE"; };
if (n.op == tkind.TK_LT) { iscmp = true; if (unsignd) { jcc = "JB"; } else { jcc = "JL"; }; };
if (n.op == tkind.TK_LE) { iscmp = true; if (unsignd) { jcc = "JBE"; } else { jcc = "JLE"; }; };
if (n.op == tkind.TK_GT) { iscmp = true; if (unsignd) { jcc = "JA"; } else { jcc = "JG"; }; };
if (n.op == tkind.TK_GE) { iscmp = true; if (unsignd) { jcc = "JAE"; } else { jcc = "JGE"; }; };
if (iscmp) {
let t: str = mklabel(c, "ct");
let e: str = mklabel(c, "ce");
@@ -1142,11 +1142,11 @@ fn cgassign(c: *cgen, n: *node) void = {
let lhs: *node = n.lhs;
// Discard lvalue `_ = expr;` — evaluate rhs for side effects,
// write nothing. Detected by lhs being an N_IDENT with empty str
// (planted by parseprimary on the TK_UNDER token).
// (planted by parseprimary on the tkind.TK_UNDER token).
if (lhs != nil) {
if (lhs.kind == N_IDENT) {
if (lhs.str.len == 0) {
if (n.op == TK_ASSIGN) {
if (n.op == tkind.TK_ASSIGN) {
cgexpr(c, n.rhs);
return;
};
@@ -1160,8 +1160,8 @@ fn cgassign(c: *cgen, n: *node) void = {
// `*bool` / `*u8` / `*i32` we narrow via the local's tnode.
if (lhs != nil) {
if (lhs.kind == N_UN) {
if (lhs.op == TK_STAR) {
if (n.op == TK_ASSIGN) {
if (lhs.op == tkind.TK_STAR) {
if (n.op == tkind.TK_ASSIGN) {
let inner: *node = lhs.lhs;
let elemstr: bool = false;
let storeop: str = "MOVQ";
@@ -1219,7 +1219,7 @@ fn cgassign(c: *cgen, n: *node) void = {
// from base.tnode picks MOVB vs MOVQ.
if (lhs != nil) {
if (lhs.kind == N_INDEX) {
if (n.op == TK_ASSIGN) {
if (n.op == tkind.TK_ASSIGN) {
let base: *node = lhs.lhs;
let idx: *node = lhs.rhs;
let esz: i32 = 8;
@@ -1308,7 +1308,7 @@ fn cgassign(c: *cgen, n: *node) void = {
for (fi != nil) {
let fn_: str = fi.fname;
if (streq(fn_, fld)) {
if (n.op != TK_ASSIGN) {
if (n.op != tkind.TK_ASSIGN) {
// compound: load current value
emitline("\tMOVQ\t");
emitoff(lc.off: i64);
@@ -1322,13 +1322,13 @@ fn cgassign(c: *cgen, n: *node) void = {
emitline("\tPUSHQ\tBX\n");
};
cgexpr(c, n.rhs);
if (n.op != TK_ASSIGN) {
if (n.op != tkind.TK_ASSIGN) {
emitline("\tPOPQ\tBX\n");
// PLUSEQ is commutative; MINUSEQ
// needs lhs - rhs (BX is old lhs,
// AX is rhs).
if (n.op == TK_PLUSEQ) { emitline("\tADDQ\tBX, AX\n"); };
if (n.op == TK_MINUSEQ) {
if (n.op == tkind.TK_PLUSEQ) { emitline("\tADDQ\tBX, AX\n"); };
if (n.op == tkind.TK_MINUSEQ) {
emitline("\tSUBQ\tAX, BX\n");
emitline("\tMOVQ\tBX, AX\n");
};
@@ -1337,7 +1337,7 @@ fn cgassign(c: *cgen, n: *node) void = {
// (AX=ptr, BX=len). Use CX as the
// address scratch so we don't clobber
// the len half before storing it.
if (n.op == TK_ASSIGN) {
if (n.op == tkind.TK_ASSIGN) {
if (isstrtype(c, fi.tnode)) {
emitline("\tMOVQ\t");
emitoff(lc.off: i64);
@@ -1405,7 +1405,7 @@ fn cgassign(c: *cgen, n: *node) void = {
};
if (innerkind == N_TSLICE) { innerstr = true; };
if (innerstr) {
if (n.op != TK_ASSIGN) {
if (n.op != tkind.TK_ASSIGN) {
// Compound on `(*str|*slice).field`: load
// current → push → eval rhs → combine → store.
emitline("\tMOVQ\t");
@@ -1419,8 +1419,8 @@ fn cgassign(c: *cgen, n: *node) void = {
emitline("\tPOPQ\tBX\n");
// PLUSEQ is commutative; MINUSEQ
// needs lhs - rhs.
if (n.op == TK_PLUSEQ) { emitline("\tADDQ\tBX, AX\n"); };
if (n.op == TK_MINUSEQ) {
if (n.op == tkind.TK_PLUSEQ) { emitline("\tADDQ\tBX, AX\n"); };
if (n.op == tkind.TK_MINUSEQ) {
emitline("\tSUBQ\tAX, BX\n");
emitline("\tMOVQ\tBX, AX\n");
};
@@ -1475,7 +1475,7 @@ fn cgassign(c: *cgen, n: *node) void = {
let fi: *fieldinfo = si.fields;
for (fi != nil) {
if (streq(fi.fname, fld)) {
if (n.op == TK_ASSIGN) {
if (n.op == tkind.TK_ASSIGN) {
if (isstrtype(c, fi.tnode)) {
// str rhs: AX=ptr, BX=len.
// Stash both, then load
@@ -1532,7 +1532,7 @@ fn cgassign(c: *cgen, n: *node) void = {
let lcn: *local = localfindnode(c, nm);
if (lcn != nil) { lcstr = isstrtype(c, lcn.tnode); };
cgexpr(c, n.rhs);
if (n.op == TK_ASSIGN) {
if (n.op == tkind.TK_ASSIGN) {
emitline("\tMOVQ\tAX, ");
emitoff(off: i64);
emitline("(BP)\n");
@@ -1543,13 +1543,13 @@ fn cgassign(c: *cgen, n: *node) void = {
};
return;
};
if (n.op == TK_PLUSEQ) {
if (n.op == tkind.TK_PLUSEQ) {
emitline("\tADDQ\tAX, ");
emitoff(off: i64);
emitline("(BP)\n");
return;
};
if (n.op == TK_MINUSEQ) {
if (n.op == tkind.TK_MINUSEQ) {
emitline("\tSUBQ\tAX, ");
emitoff(off: i64);
emitline("(BP)\n");
@@ -1559,15 +1559,15 @@ fn cgassign(c: *cgen, n: *node) void = {
emitline("\tMOVQ\t");
emitoff(off: i64);
emitline("(BP), BX\n");
if (n.op == TK_STAREQ) { emitline("\tIMULQ\tAX, BX\n"); };
if (n.op == TK_AMPEQ) { emitline("\tANDQ\tAX, BX\n"); };
if (n.op == TK_PIPEEQ) { emitline("\tORQ\tAX, BX\n"); };
if (n.op == TK_CARETEQ) { emitline("\tXORQ\tAX, BX\n"); };
if (n.op == TK_LSHIFTEQ) {
if (n.op == tkind.TK_STAREQ) { emitline("\tIMULQ\tAX, BX\n"); };
if (n.op == tkind.TK_AMPEQ) { emitline("\tANDQ\tAX, BX\n"); };
if (n.op == tkind.TK_PIPEEQ) { emitline("\tORQ\tAX, BX\n"); };
if (n.op == tkind.TK_CARETEQ) { emitline("\tXORQ\tAX, BX\n"); };
if (n.op == tkind.TK_LSHIFTEQ) {
emitline("\tMOVQ\tAX, CX\n");
emitline("\tSHLQ\tCX, BX\n");
};
if (n.op == TK_RSHIFTEQ) {
if (n.op == tkind.TK_RSHIFTEQ) {
emitline("\tMOVQ\tAX, CX\n");
emitline("\tSHRQ\tCX, BX\n");
};

4
selfhost/cmd/wcc/cgenstmt.ww
View File

@@ -403,7 +403,7 @@ fn cglet(c: *cgen, n: *node) void = {
// For each field in the lit, evaluate its value and store at
// the field's offset within the slot. Field-name → offset
// from the struct registry. When the literal carries
// op == TK_ELLIPSIS (autofill marker from the parser), the
// op == tkind.TK_ELLIPSIS (autofill marker from the parser), the
// entire slot is zero-filled first so unmentioned fields
// read as 0.
if (rhs.kind == N_STRUCTLIT) {
@@ -416,7 +416,7 @@ fn cglet(c: *cgen, n: *node) void = {
};
let si: *structinfo = structlookup(c, sname);
if (si != nil) {
if (rhs.op == TK_ELLIPSIS) {
if (rhs.op == tkind.TK_ELLIPSIS) {
let total: i32 = si.totsize;
emitline("\tXORQ\tAX, AX\n");
let zi: i32 = 0;

1185
selfhost/cmd/wwdump/main.combined.ww
View File

File diff suppressed because it is too large Load Diff

4
selfhost/cmd/wwdump/main.ww
View File

@@ -122,8 +122,8 @@ export fn main(argc: i32, argv: **u8) i32 = {
let t: tok;
lexnext(&l, &t);
tokprint(1i32, &t);
if (t.kind == TK_EOF) { break; };
if (t.kind == TK_ERR) { break; };
if (t.kind == tkind.TK_EOF) { break; };
if (t.kind == tkind.TK_ERR) { break; };
};
} else { if (mode == 97) { // '-a'
let ps: parser;