ww: import toolchain — C bootstrap + ww-side self-host (phases 0-10)
C bootstrap (phases 0-9):
cmd/wwc, cmd/6c, cmd/6a, cmd/6l, cmd/ww, rt, lib/*.
ww-side self-host (phase 10):
selfhost/cmd/wwc — ww-cgen frontend; bootstrap fixed point.
selfhost/cmd/6a — assembler; byte-identical to C 6a (test 991).
selfhost/cmd/6l — linker w/ archive (.a) support; byte-identical
to C 6l (test 992).
selfhost/cmd/ww — driver (build/run/version); byte-identical to
C ww (test 993).
make test: 15/15. make bootstrap: ww2.s == ww3.s, ww2.o == ww3.o,
ww2 == ww3 byte-identical, with the full ww-tooled chain.
This commit is contained in:
960
selfhost/cmd/wwc/parse.ww
Normal file
960
selfhost/cmd/wwc/parse.ww
Normal file
@@ -0,0 +1,960 @@
|
||||
// selfhost/cmd/wwc/parse.ww — port of cmd/wwc/parse.c.
|
||||
//
|
||||
// Status: GROWING stub. Currently handles top-level `use IDENT;`,
|
||||
// `def NAME: TYPE = LIT;`, `type NAME = TYPE;`, and `fn NAME(params)
|
||||
// RET;` (header-only — bodies are recovered past). Unknown decls are
|
||||
// chewed token-by-token until the next ';' so the diff probe can
|
||||
// still anchor on partial fixtures.
|
||||
//
|
||||
// The full port is multi-session work — parse.c is 1,183 lines of
|
||||
// hand-rolled recursive descent + Pratt expression parser. Each
|
||||
// surface form lands here gradually so the AST diff in 990_selfhost
|
||||
// grows toward whole-language coverage one increment at a time.
|
||||
//
|
||||
// Calling-convention shim: 6c can't yet pass a sub-struct field
|
||||
// (e.g. p.cur.line where p.cur is a `tok` of size 76). The parser
|
||||
// stores the current token as flat primitive fields rather than a
|
||||
// nested `tok` struct; `refill` copies a freshly lexed token in.
|
||||
|
||||
use os;
|
||||
use mem;
|
||||
use tok;
|
||||
|
||||
type parser = struct {
|
||||
l: *lex,
|
||||
a: *arena,
|
||||
errs: i32,
|
||||
// nocast: while inside `[...]` we treat ':' as the slice
|
||||
// separator, not the cast operator. Mirrors parse.c's flag.
|
||||
nocast: i32,
|
||||
cur_kind: i32,
|
||||
cur_file: str,
|
||||
cur_line: i32,
|
||||
cur_col: i32,
|
||||
cur_text: str,
|
||||
cur_uval: u64,
|
||||
};
|
||||
|
||||
fn refill(p: *parser) void = {
|
||||
let t: tok;
|
||||
lexnext(p.l, &t);
|
||||
p.cur_kind = t.kind;
|
||||
p.cur_file = t.file;
|
||||
p.cur_line = t.line;
|
||||
p.cur_col = t.col;
|
||||
p.cur_text = t.text;
|
||||
p.cur_uval = t.uval;
|
||||
};
|
||||
|
||||
export fn parserinit(p: *parser, a: *arena, l: *lex) void = {
|
||||
p.l = l;
|
||||
p.a = a;
|
||||
p.errs = 0;
|
||||
p.nocast = 0;
|
||||
refill(p);
|
||||
};
|
||||
|
||||
fn advance(p: *parser) void = { refill(p); };
|
||||
|
||||
fn accept_tok(p: *parser, k: i32) bool = {
|
||||
if (p.cur_kind == k) { advance(p); return true; };
|
||||
return false;
|
||||
};
|
||||
|
||||
fn err_msg(p: *parser, msg: str) void = {
|
||||
let pre: str = "parse: ";
|
||||
os.write(2, pre.ptr, pre.len: u64);
|
||||
os.write(2, msg.ptr, msg.len: u64);
|
||||
os.write(2, "\n".ptr, 1u64);
|
||||
p.errs += 1;
|
||||
};
|
||||
|
||||
fn expect_tok(p: *parser, k: i32, what: str) bool = {
|
||||
if (p.cur_kind == k) { advance(p); return true; };
|
||||
err_msg(p, what);
|
||||
return false;
|
||||
};
|
||||
|
||||
// expectident — consume the current 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.cur_kind != TK_IDENT) {
|
||||
err_msg(p, "expected identifier");
|
||||
advance(p);
|
||||
return false;
|
||||
};
|
||||
*into = p.cur_text;
|
||||
advance(p);
|
||||
return true;
|
||||
};
|
||||
|
||||
// ---- type expressions ------------------------------------------------
|
||||
//
|
||||
// Currently: TNAME (single ident, no dotted path yet) and TPTR (`*T`).
|
||||
// Other forms (slice, array, struct, fn, chan, tuple, tagged) will
|
||||
// land in subsequent commits.
|
||||
|
||||
fn parsetype(p: *parser) *node = {
|
||||
let pf: str = p.cur_file;
|
||||
let pl: i32 = p.cur_line;
|
||||
let pc: i32 = p.cur_col;
|
||||
|
||||
if (p.cur_kind == TK_STAR) {
|
||||
advance(p);
|
||||
let n: *node = newnode(p.a, N_TPTR, pf, pl, pc);
|
||||
n.lhs = parsetype(p);
|
||||
return n;
|
||||
};
|
||||
|
||||
if (p.cur_kind == TK_LBRACK) {
|
||||
advance(p);
|
||||
if (p.cur_kind == TK_RBRACK) {
|
||||
advance(p);
|
||||
let n: *node = newnode(p.a, N_TSLICE, pf, pl, pc);
|
||||
n.lhs = parsetype(p);
|
||||
return n;
|
||||
};
|
||||
let n: *node = newnode(p.a, N_TARRAY, pf, pl, pc);
|
||||
n.rhs = parseexpr(p);
|
||||
expect_tok(p, TK_RBRACK, "expected ']' in array type");
|
||||
n.lhs = parsetype(p);
|
||||
return n;
|
||||
};
|
||||
|
||||
if (p.cur_kind == TK_STRUCT) {
|
||||
advance(p);
|
||||
expect_tok(p, 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.cur_kind != TK_RBRACE) {
|
||||
if (p.cur_kind == TK_EOF) { break; };
|
||||
let fpf: str = p.cur_file;
|
||||
let fpl: i32 = p.cur_line;
|
||||
let fpc: i32 = p.cur_col;
|
||||
let f: *node = newnode(p.a, N_TFIELD, fpf, fpl, fpc);
|
||||
let fid: str;
|
||||
expectident(p, &fid);
|
||||
f.str = fid;
|
||||
expect_tok(p, TK_COLON, "expected ':' in field");
|
||||
f.lhs = parsetype(p);
|
||||
if (fhead == nil) { fhead = f; ftail = f; }
|
||||
else { ftail.next = f; ftail = f; };
|
||||
if (!accept_tok(p, TK_COMMA)) { break; };
|
||||
};
|
||||
expect_tok(p, TK_RBRACE, "expected '}' after struct fields");
|
||||
n.list = fhead;
|
||||
return n;
|
||||
};
|
||||
|
||||
if (p.cur_kind == TK_IDENT) {
|
||||
let n: *node = newnode(p.a, N_TNAME, pf, pl, pc);
|
||||
n.str = p.cur_text;
|
||||
advance(p);
|
||||
// Dotted path collapse (pkg.Type) deferred — fixtures don't
|
||||
// need it yet.
|
||||
return n;
|
||||
};
|
||||
|
||||
if (p.cur_kind == TK_LPAREN) {
|
||||
// (T) or (T, T, ...) or (T | T | ...)
|
||||
advance(p);
|
||||
let first: *node = parsetype(p);
|
||||
if (accept_tok(p, TK_PIPE)) {
|
||||
let n: *node = newnode(p.a, N_TTAGGED, pf, pl, pc);
|
||||
let head: *node = first;
|
||||
let tail: *node = first;
|
||||
for (true) {
|
||||
let e: *node = parsetype(p);
|
||||
tail.next = e;
|
||||
tail = e;
|
||||
if (!accept_tok(p, TK_PIPE)) { break; };
|
||||
};
|
||||
expect_tok(p, TK_RPAREN, "expected ')' in tagged-union type");
|
||||
n.list = head;
|
||||
return n;
|
||||
};
|
||||
if (!accept_tok(p, TK_COMMA)) {
|
||||
expect_tok(p, TK_RPAREN, "expected ')' after parenthesised type");
|
||||
return first;
|
||||
};
|
||||
let n: *node = newnode(p.a, N_TTUPLE, pf, pl, pc);
|
||||
let head: *node = first;
|
||||
let tail: *node = first;
|
||||
for (true) {
|
||||
let e: *node = parsetype(p);
|
||||
tail.next = e;
|
||||
tail = e;
|
||||
if (!accept_tok(p, TK_COMMA)) { break; };
|
||||
if (p.cur_kind == TK_RPAREN) { break; };
|
||||
};
|
||||
expect_tok(p, TK_RPAREN, "expected ')' in tuple type");
|
||||
n.list = head;
|
||||
return n;
|
||||
};
|
||||
|
||||
if (p.cur_kind == TK_FN) {
|
||||
advance(p);
|
||||
expect_tok(p, 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);
|
||||
expect_tok(p, TK_RPAREN, "expected ')' after fn type params");
|
||||
n.lhs = parsetype(p);
|
||||
return n;
|
||||
};
|
||||
|
||||
err_msg(p, "expected type");
|
||||
advance(p);
|
||||
return newnode(p.a, N_TNAME, pf, pl, pc);
|
||||
};
|
||||
|
||||
// ---- expressions (Pratt) ---------------------------------------------
|
||||
//
|
||||
// Forwards: parseexpr → parsebin → parseunary → parsepostfix(parseprimary).
|
||||
// Tuple literals, match expressions, struct literals, slice [lo:hi],
|
||||
// and the ?/! try operators are not yet wired — they'll arrive as the
|
||||
// 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; };
|
||||
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; };
|
||||
return false;
|
||||
};
|
||||
|
||||
// Forward references between parseunary/parseexpr/parsebin/parsepostfix
|
||||
// are resolved by the two-pass checker — no body-less prototypes needed.
|
||||
|
||||
fn parseprimary(p: *parser) *node = {
|
||||
let pf: str = p.cur_file;
|
||||
let pl: i32 = p.cur_line;
|
||||
let pc: i32 = p.cur_col;
|
||||
|
||||
if (p.cur_kind == TK_INT) {
|
||||
let n: *node = newnode(p.a, N_INTLIT, pf, pl, pc);
|
||||
n.uval = p.cur_uval;
|
||||
n.str = p.cur_text;
|
||||
advance(p);
|
||||
return n;
|
||||
};
|
||||
if (p.cur_kind == TK_STR) {
|
||||
let n: *node = newnode(p.a, N_STRLIT, pf, pl, pc);
|
||||
n.str = p.cur_text;
|
||||
advance(p);
|
||||
return n;
|
||||
};
|
||||
if (p.cur_kind == TK_RUNE) {
|
||||
let n: *node = newnode(p.a, N_RUNELIT, pf, pl, pc);
|
||||
n.uval = p.cur_uval;
|
||||
advance(p);
|
||||
return n;
|
||||
};
|
||||
if (p.cur_kind == TK_TRUE) {
|
||||
advance(p);
|
||||
return newnode(p.a, N_TRUE, pf, pl, pc);
|
||||
};
|
||||
if (p.cur_kind == TK_FALSE) {
|
||||
advance(p);
|
||||
return newnode(p.a, N_FALSE, pf, pl, pc);
|
||||
};
|
||||
if (p.cur_kind == TK_NIL) {
|
||||
advance(p);
|
||||
return newnode(p.a, N_NIL, pf, pl, pc);
|
||||
};
|
||||
if (p.cur_kind == TK_LPAREN) {
|
||||
advance(p);
|
||||
let e: *node = parseexpr(p);
|
||||
// Tuple literal: (a, b, ...)
|
||||
if (accept_tok(p, TK_COMMA)) {
|
||||
let t: *node = newnode(p.a, N_TUPLE, pf, pl, pc);
|
||||
t.list = e;
|
||||
let tail: *node = e;
|
||||
for (true) {
|
||||
if (p.cur_kind == TK_RPAREN) { break; };
|
||||
let en: *node = parseexpr(p);
|
||||
tail.next = en;
|
||||
tail = en;
|
||||
if (!accept_tok(p, TK_COMMA)) { break; };
|
||||
};
|
||||
expect_tok(p, TK_RPAREN, "expected ')' in tuple");
|
||||
return t;
|
||||
};
|
||||
expect_tok(p, TK_RPAREN, "expected ')'");
|
||||
return e;
|
||||
};
|
||||
if (p.cur_kind == TK_IDENT) {
|
||||
let n: *node = newnode(p.a, N_IDENT, pf, pl, pc);
|
||||
n.str = p.cur_text;
|
||||
advance(p);
|
||||
// `IDENT {` — struct literal. Disambiguate: only consume as a
|
||||
// struct lit when we're not in a context where '{' starts a
|
||||
// block (e.g. `if (cond) {`). The parser is called from
|
||||
// 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.cur_kind == 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.cur_kind != TK_RBRACE) {
|
||||
if (p.cur_kind == TK_EOF) { break; };
|
||||
let fpf: str = p.cur_file;
|
||||
let fpl: i32 = p.cur_line;
|
||||
let fpc: i32 = p.cur_col;
|
||||
let id: str;
|
||||
expectident(p, &id);
|
||||
expect_tok(p, 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 (!accept_tok(p, TK_COMMA)) { break; };
|
||||
};
|
||||
expect_tok(p, TK_RBRACE, "expected '}' after struct literal");
|
||||
s.list = head;
|
||||
return s;
|
||||
};
|
||||
return n;
|
||||
};
|
||||
if (p.cur_kind == TK_MATCH) {
|
||||
// match (e) { case let v: T => stmt; case T => stmt; case => stmt; };
|
||||
advance(p);
|
||||
expect_tok(p, TK_LPAREN, "expected '(' after match");
|
||||
let m: *node = newnode(p.a, N_MATCH, pf, pl, pc);
|
||||
m.lhs = parseexpr(p);
|
||||
expect_tok(p, TK_RPAREN, "expected ')' after match scrutinee");
|
||||
expect_tok(p, TK_LBRACE, "expected '{' to open match body");
|
||||
let head: *node = nil;
|
||||
let tail: *node = nil;
|
||||
for (p.cur_kind == TK_CASE) {
|
||||
let cf: str = p.cur_file;
|
||||
let cl: i32 = p.cur_line;
|
||||
let cc: i32 = p.cur_col;
|
||||
advance(p); // past `case`
|
||||
let mc: *node = newnode(p.a, N_MCASE, cf, cl, cc);
|
||||
if (p.cur_kind == TK_LET) {
|
||||
advance(p);
|
||||
let id: str;
|
||||
expectident(p, &id);
|
||||
mc.str = id;
|
||||
expect_tok(p, TK_COLON, "expected ':' after match binding");
|
||||
mc.lhs = parsetype(p);
|
||||
} else { if (p.cur_kind != TK_FATARROW) {
|
||||
mc.lhs = parsetype(p);
|
||||
};};
|
||||
expect_tok(p, TK_FATARROW, "expected '=>' in match arm");
|
||||
mc.body = parsestmt(p);
|
||||
if (head == nil) { head = mc; tail = mc; }
|
||||
else { tail.next = mc; tail = mc; };
|
||||
};
|
||||
expect_tok(p, TK_RBRACE, "expected '}' after match body");
|
||||
m.list = head;
|
||||
return m;
|
||||
};
|
||||
err_msg(p, "expected expression");
|
||||
advance(p);
|
||||
return newnode(p.a, N_NONE, pf, pl, pc);
|
||||
};
|
||||
|
||||
fn parsearglist(p: *parser, close_kind: i32, head_out: **node) void = {
|
||||
*head_out = nil;
|
||||
if (p.cur_kind == close_kind) { return; };
|
||||
let head: *node = nil;
|
||||
let tail: *node = nil;
|
||||
for (true) {
|
||||
let e: *node = parseexpr(p);
|
||||
if (head == nil) { head = e; tail = e; }
|
||||
else { tail.next = e; tail = e; };
|
||||
if (!accept_tok(p, TK_COMMA)) { break; };
|
||||
if (p.cur_kind == close_kind) { break; };
|
||||
};
|
||||
*head_out = head;
|
||||
};
|
||||
|
||||
fn parsepostfix(p: *parser, lhs: *node) *node = {
|
||||
let cur: *node = lhs;
|
||||
for (true) {
|
||||
let pf: str = p.cur_file;
|
||||
let pl: i32 = p.cur_line;
|
||||
let pc: i32 = p.cur_col;
|
||||
if (p.cur_kind == TK_LPAREN) {
|
||||
advance(p);
|
||||
let n: *node = newnode(p.a, N_CALL, pf, pl, pc);
|
||||
n.lhs = cur;
|
||||
let arghead: *node = nil;
|
||||
parsearglist(p, TK_RPAREN, &arghead);
|
||||
n.list = arghead;
|
||||
expect_tok(p, TK_RPAREN, "expected ')' after args");
|
||||
cur = n;
|
||||
continue;
|
||||
};
|
||||
if (p.cur_kind == TK_LBRACK) {
|
||||
advance(p);
|
||||
// `[ : hi ]` — slice with implicit lo = 0.
|
||||
if (p.cur_kind == TK_COLON) {
|
||||
advance(p);
|
||||
let n: *node = newnode(p.a, N_SLICE, pf, pl, pc);
|
||||
n.lhs = cur;
|
||||
if (p.cur_kind != TK_RBRACK) {
|
||||
n.cond = parseexpr(p);
|
||||
};
|
||||
expect_tok(p, TK_RBRACK, "expected ']' in slice");
|
||||
cur = n;
|
||||
continue;
|
||||
};
|
||||
// Suppress cast inside `[...]` so ':' parses as slice
|
||||
// separator rather than the postfix cast operator.
|
||||
let prev: i32 = p.nocast;
|
||||
p.nocast = 1;
|
||||
let e: *node = parseexpr(p);
|
||||
p.nocast = prev;
|
||||
if (p.cur_kind == TK_COLON) {
|
||||
advance(p);
|
||||
let n: *node = newnode(p.a, N_SLICE, pf, pl, pc);
|
||||
n.lhs = cur;
|
||||
n.rhs = e;
|
||||
if (p.cur_kind != TK_RBRACK) {
|
||||
n.cond = parseexpr(p);
|
||||
};
|
||||
expect_tok(p, 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;
|
||||
expect_tok(p, TK_RBRACK, "expected ']' after index");
|
||||
cur = n;
|
||||
continue;
|
||||
};
|
||||
if (p.cur_kind == TK_DOT) {
|
||||
advance(p);
|
||||
let n: *node = newnode(p.a, N_DOT, pf, pl, pc);
|
||||
n.lhs = cur;
|
||||
let id: str;
|
||||
expectident(p, &id);
|
||||
n.str = id;
|
||||
cur = n;
|
||||
continue;
|
||||
};
|
||||
if (p.cur_kind == TK_COLON) {
|
||||
if (p.nocast != 0) {
|
||||
return cur;
|
||||
};
|
||||
advance(p);
|
||||
let n: *node = newnode(p.a, N_CAST, pf, pl, pc);
|
||||
n.lhs = cur;
|
||||
n.rhs = parsetype(p);
|
||||
cur = n;
|
||||
continue;
|
||||
};
|
||||
break;
|
||||
};
|
||||
return cur;
|
||||
};
|
||||
|
||||
fn parseunary(p: *parser) *node = {
|
||||
let pf: str = p.cur_file;
|
||||
let pl: i32 = p.cur_line;
|
||||
let pc: i32 = p.cur_col;
|
||||
let k: i32 = p.cur_kind;
|
||||
if (k == TK_MINUS) {
|
||||
advance(p);
|
||||
let n: *node = newnode(p.a, N_UN, pf, pl, pc);
|
||||
n.op = TK_MINUS; n.lhs = parseunary(p);
|
||||
return n;
|
||||
};
|
||||
if (k == TK_PLUS) {
|
||||
advance(p);
|
||||
let n: *node = newnode(p.a, N_UN, pf, pl, pc);
|
||||
n.op = TK_PLUS; n.lhs = parseunary(p);
|
||||
return n;
|
||||
};
|
||||
if (k == TK_NOT) {
|
||||
advance(p);
|
||||
let n: *node = newnode(p.a, N_UN, pf, pl, pc);
|
||||
n.op = TK_NOT; n.lhs = parseunary(p);
|
||||
return n;
|
||||
};
|
||||
if (k == TK_TILDE) {
|
||||
advance(p);
|
||||
let n: *node = newnode(p.a, N_UN, pf, pl, pc);
|
||||
n.op = TK_TILDE; n.lhs = parseunary(p);
|
||||
return n;
|
||||
};
|
||||
if (k == TK_STAR) {
|
||||
advance(p);
|
||||
let n: *node = newnode(p.a, N_UN, pf, pl, pc);
|
||||
n.op = TK_STAR; n.lhs = parseunary(p);
|
||||
return n;
|
||||
};
|
||||
if (k == TK_AMP) {
|
||||
advance(p);
|
||||
let n: *node = newnode(p.a, N_UN, pf, pl, pc);
|
||||
n.op = TK_AMP; n.lhs = parseunary(p);
|
||||
return n;
|
||||
};
|
||||
return parsepostfix(p, parseprimary(p));
|
||||
};
|
||||
|
||||
fn parsebin(p: *parser, lhs: *node, minp: i32) *node = {
|
||||
let cur: *node = lhs;
|
||||
for (true) {
|
||||
let op: i32 = p.cur_kind;
|
||||
let pr: i32 = bprec(op);
|
||||
if (pr == 0) { return cur; };
|
||||
if (pr < minp) { return cur; };
|
||||
let pf: str = p.cur_file;
|
||||
let pl: i32 = p.cur_line;
|
||||
let pc: i32 = p.cur_col;
|
||||
advance(p);
|
||||
let rhs: *node = parseunary(p);
|
||||
for (true) {
|
||||
let np: i32 = bprec(p.cur_kind);
|
||||
if (np <= pr) { break; };
|
||||
rhs = parsebin(p, rhs, np);
|
||||
};
|
||||
let n: *node = newnode(p.a, N_BIN, pf, pl, pc);
|
||||
n.op = op; n.lhs = cur; n.rhs = rhs;
|
||||
cur = n;
|
||||
};
|
||||
return cur;
|
||||
};
|
||||
|
||||
fn parseexpr(p: *parser) *node = {
|
||||
let e: *node = parsebin(p, parseunary(p), 1);
|
||||
if (isassignop(p.cur_kind)) {
|
||||
let pf: str = p.cur_file;
|
||||
let pl: i32 = p.cur_line;
|
||||
let pc: i32 = p.cur_col;
|
||||
let op: i32 = p.cur_kind;
|
||||
advance(p);
|
||||
let n: *node = newnode(p.a, N_ASSIGN, pf, pl, pc);
|
||||
n.op = op;
|
||||
n.lhs = e;
|
||||
n.rhs = parseexpr(p); // right-associative
|
||||
return n;
|
||||
};
|
||||
return e;
|
||||
};
|
||||
|
||||
// ---- statements ------------------------------------------------------
|
||||
//
|
||||
// Subset wired today: block, let, return, if (no else-if chain), for
|
||||
// (single-cond C-style), expr-stmt, defer, break, continue. Switch
|
||||
// and match arms are not yet wired; tuple-let / multi-let neither.
|
||||
|
||||
fn parselet_local(p: *parser) *node = {
|
||||
let pf: str = p.cur_file;
|
||||
let pl: i32 = p.cur_line;
|
||||
let pc: i32 = p.cur_col;
|
||||
advance(p); // past `let`
|
||||
let n: *node = newnode(p.a, N_LET, pf, pl, pc);
|
||||
let id: str;
|
||||
expectident(p, &id);
|
||||
n.str = id;
|
||||
if (accept_tok(p, TK_COLON)) {
|
||||
n.lhs = parsetype(p);
|
||||
};
|
||||
if (accept_tok(p, TK_ASSIGN)) {
|
||||
n.rhs = parseexpr(p);
|
||||
};
|
||||
expect_tok(p, TK_SEMI, "expected ';' after let");
|
||||
return n;
|
||||
};
|
||||
|
||||
fn parseblock(p: *parser) *node = {
|
||||
let pf: str = p.cur_file;
|
||||
let pl: i32 = p.cur_line;
|
||||
let pc: i32 = p.cur_col;
|
||||
expect_tok(p, 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.cur_kind != TK_RBRACE) {
|
||||
if (p.cur_kind == TK_EOF) { break; };
|
||||
let s: *node = parsestmt(p);
|
||||
if (s != nil) {
|
||||
if (head == nil) { head = s; tail = s; }
|
||||
else { tail.next = s; tail = s; };
|
||||
};
|
||||
};
|
||||
expect_tok(p, TK_RBRACE, "expected '}' to close block");
|
||||
blk.list = head;
|
||||
return blk;
|
||||
};
|
||||
|
||||
fn parseif(p: *parser) *node = {
|
||||
let pf: str = p.cur_file;
|
||||
let pl: i32 = p.cur_line;
|
||||
let pc: i32 = p.cur_col;
|
||||
advance(p); // past `if`
|
||||
expect_tok(p, TK_LPAREN, "expected '(' after if");
|
||||
let n: *node = newnode(p.a, N_IF, pf, pl, pc);
|
||||
n.cond = parseexpr(p);
|
||||
expect_tok(p, TK_RPAREN, "expected ')' after if condition");
|
||||
n.body = parseblock(p);
|
||||
if (accept_tok(p, TK_ELSE)) {
|
||||
if (p.cur_kind == TK_IF) {
|
||||
n.els = parseif(p);
|
||||
} else {
|
||||
n.els = parseblock(p);
|
||||
};
|
||||
};
|
||||
return n;
|
||||
};
|
||||
|
||||
fn parsefor(p: *parser) *node = {
|
||||
let pf: str = p.cur_file;
|
||||
let pl: i32 = p.cur_line;
|
||||
let pc: i32 = p.cur_col;
|
||||
advance(p); // past `for`
|
||||
expect_tok(p, 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
|
||||
// for (init; cond; post) — full
|
||||
// for (true) — infinite (cond is N_TRUE)
|
||||
// Distinguish by counting ';'. Look at first chunk: if it's a
|
||||
// `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.cur_kind == TK_LET) {
|
||||
n.lhs = parselet_local(p); // init (consumes its own ';')
|
||||
n.cond = parseexpr(p);
|
||||
expect_tok(p, 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 (accept_tok(p, TK_SEMI)) {
|
||||
// cond ; post
|
||||
n.cond = first;
|
||||
n.rhs = parseexpr(p);
|
||||
} else {
|
||||
// just (cond)
|
||||
n.cond = first;
|
||||
};
|
||||
};
|
||||
expect_tok(p, TK_RPAREN, "expected ')' after for");
|
||||
n.body = parseblock(p);
|
||||
return n;
|
||||
};
|
||||
|
||||
fn parsestmt(p: *parser) *node = {
|
||||
let pf: str = p.cur_file;
|
||||
let pl: i32 = p.cur_line;
|
||||
let pc: i32 = p.cur_col;
|
||||
|
||||
// `static` is allowed on local lets per Hare; we accept and skip
|
||||
// it (it doesn't change the AST shape).
|
||||
if (p.cur_kind == TK_STATIC) { advance(p); };
|
||||
|
||||
if (p.cur_kind == TK_LBRACE) {
|
||||
let b: *node = parseblock(p);
|
||||
expect_tok(p, TK_SEMI, "expected ';' after block");
|
||||
return b;
|
||||
};
|
||||
if (p.cur_kind == TK_LET) { return parselet_local(p); };
|
||||
if (p.cur_kind == TK_IF) {
|
||||
let n: *node = parseif(p);
|
||||
expect_tok(p, TK_SEMI, "expected ';' after if");
|
||||
return n;
|
||||
};
|
||||
if (p.cur_kind == TK_FOR) {
|
||||
let n: *node = parsefor(p);
|
||||
expect_tok(p, TK_SEMI, "expected ';' after for");
|
||||
return n;
|
||||
};
|
||||
if (p.cur_kind == TK_RETURN) {
|
||||
advance(p);
|
||||
let n: *node = newnode(p.a, N_RETURN, pf, pl, pc);
|
||||
if (p.cur_kind != 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.cur_kind == TK_COMMA) {
|
||||
let t: *node = newnode(p.a, N_TUPLE, pf, pl, pc);
|
||||
t.list = first;
|
||||
let tail: *node = first;
|
||||
for (accept_tok(p, TK_COMMA)) {
|
||||
let e: *node = parseexpr(p);
|
||||
tail.next = e;
|
||||
tail = e;
|
||||
};
|
||||
n.lhs = t;
|
||||
} else {
|
||||
n.lhs = first;
|
||||
};
|
||||
};
|
||||
expect_tok(p, TK_SEMI, "expected ';' after return");
|
||||
return n;
|
||||
};
|
||||
if (p.cur_kind == TK_DEFER) {
|
||||
advance(p);
|
||||
let n: *node = newnode(p.a, N_DEFER, pf, pl, pc);
|
||||
n.lhs = parseexpr(p);
|
||||
expect_tok(p, TK_SEMI, "expected ';' after defer");
|
||||
return n;
|
||||
};
|
||||
if (p.cur_kind == TK_BREAK) {
|
||||
advance(p);
|
||||
expect_tok(p, TK_SEMI, "expected ';' after break");
|
||||
return newnode(p.a, N_BREAK, pf, pl, pc);
|
||||
};
|
||||
if (p.cur_kind == TK_CONTINUE) {
|
||||
advance(p);
|
||||
expect_tok(p, TK_SEMI, "expected ';' after continue");
|
||||
return newnode(p.a, N_CONTINUE, pf, pl, pc);
|
||||
};
|
||||
// expression statement
|
||||
let n: *node = newnode(p.a, N_EXPRSTMT, pf, pl, pc);
|
||||
n.lhs = parseexpr(p);
|
||||
expect_tok(p, TK_SEMI, "expected ';' after expression statement");
|
||||
return n;
|
||||
};
|
||||
|
||||
// ---- top-level decl parsers ------------------------------------------
|
||||
|
||||
fn parseuse(p: *parser) *node = {
|
||||
let pf: str = p.cur_file;
|
||||
let pl: i32 = p.cur_line;
|
||||
let pc: i32 = p.cur_col;
|
||||
advance(p); // past `use`
|
||||
let n: *node = newnode(p.a, N_USE, pf, pl, pc);
|
||||
let id: str;
|
||||
expectident(p, &id);
|
||||
n.str = id;
|
||||
expect_tok(p, TK_SEMI, "expected ';' after use");
|
||||
return n;
|
||||
};
|
||||
|
||||
fn parsedef(p: *parser, exported: i32) *node = {
|
||||
let pf: str = p.cur_file;
|
||||
let pl: i32 = p.cur_line;
|
||||
let pc: i32 = p.cur_col;
|
||||
advance(p); // past `def`
|
||||
let n: *node = newnode(p.a, N_DEF, pf, pl, pc);
|
||||
let id: str;
|
||||
expectident(p, &id);
|
||||
n.str = id;
|
||||
expect_tok(p, TK_COLON, "expected ':' in def");
|
||||
n.lhs = parsetype(p);
|
||||
expect_tok(p, TK_ASSIGN, "expected '=' in def");
|
||||
n.rhs = parseexpr(p);
|
||||
expect_tok(p, TK_SEMI, "expected ';' after def");
|
||||
n.exported = exported;
|
||||
return n;
|
||||
};
|
||||
|
||||
fn parselet(p: *parser, exported: i32) *node = {
|
||||
let pf: str = p.cur_file;
|
||||
let pl: i32 = p.cur_line;
|
||||
let pc: i32 = p.cur_col;
|
||||
advance(p); // past `let`
|
||||
let n: *node = newnode(p.a, N_LET, pf, pl, pc);
|
||||
let id: str;
|
||||
expectident(p, &id);
|
||||
n.str = id;
|
||||
if (accept_tok(p, TK_COLON)) {
|
||||
n.lhs = parsetype(p);
|
||||
};
|
||||
if (accept_tok(p, TK_ASSIGN)) {
|
||||
n.rhs = parseexpr(p);
|
||||
};
|
||||
expect_tok(p, TK_SEMI, "expected ';' after let");
|
||||
n.exported = exported;
|
||||
return n;
|
||||
};
|
||||
|
||||
fn parseattrs(p: *parser) *node = {
|
||||
let head: *node = nil;
|
||||
let tail: *node = nil;
|
||||
for (p.cur_kind == TK_AT) {
|
||||
let pf: str = p.cur_file;
|
||||
let pl: i32 = p.cur_line;
|
||||
let pc: i32 = p.cur_col;
|
||||
advance(p);
|
||||
let a: *node = newnode(p.a, N_ATTR, pf, pl, pc);
|
||||
let id: str;
|
||||
expectident(p, &id);
|
||||
a.str = id;
|
||||
expect_tok(p, TK_LPAREN, "expected '(' after attribute name");
|
||||
let arghead: *node = nil;
|
||||
parsearglist(p, TK_RPAREN, &arghead);
|
||||
a.list = arghead;
|
||||
expect_tok(p, TK_RPAREN, "expected ')' after attribute args");
|
||||
if (head == nil) { head = a; tail = a; }
|
||||
else { tail.next = a; tail = a; };
|
||||
};
|
||||
return head;
|
||||
};
|
||||
|
||||
fn parseparams(p: *parser) *node = {
|
||||
if (p.cur_kind == TK_RPAREN) { return nil; };
|
||||
let head: *node = nil;
|
||||
let tail: *node = nil;
|
||||
for (true) {
|
||||
let pf: str = p.cur_file;
|
||||
let pl: i32 = p.cur_line;
|
||||
let pc: i32 = p.cur_col;
|
||||
let n: *node = newnode(p.a, N_PARAM, pf, pl, pc);
|
||||
// Param form: IDENT ':' type. Anonymous-type-only params (used
|
||||
// in fn type expressions) aren't yet wired here.
|
||||
let id: str;
|
||||
expectident(p, &id);
|
||||
n.str = id;
|
||||
expect_tok(p, TK_COLON, "expected ':' in parameter");
|
||||
n.lhs = parsetype(p);
|
||||
if (head == nil) { head = n; tail = n; }
|
||||
else { tail.next = n; tail = n; };
|
||||
if (!accept_tok(p, TK_COMMA)) { break; };
|
||||
if (p.cur_kind == TK_RPAREN) { break; };
|
||||
};
|
||||
return head;
|
||||
};
|
||||
|
||||
fn parsefn(p: *parser, exported: i32, attrs: *node) *node = {
|
||||
let pf: str = p.cur_file;
|
||||
let pl: i32 = p.cur_line;
|
||||
let pc: i32 = p.cur_col;
|
||||
advance(p); // past `fn`
|
||||
let n: *node = newnode(p.a, N_FNDECL, pf, pl, pc);
|
||||
let id: str;
|
||||
expectident(p, &id);
|
||||
n.str = id;
|
||||
expect_tok(p, TK_LPAREN, "expected '(' after fn name");
|
||||
n.list = parseparams(p);
|
||||
expect_tok(p, TK_RPAREN, "expected ')' after params");
|
||||
if (p.cur_kind != TK_ASSIGN) {
|
||||
if (p.cur_kind != TK_SEMI) {
|
||||
n.lhs = parsetype(p);
|
||||
};
|
||||
};
|
||||
if (accept_tok(p, TK_ASSIGN)) {
|
||||
n.body = parseblock(p);
|
||||
expect_tok(p, TK_SEMI, "expected ';' after fn body");
|
||||
} else {
|
||||
// Body-less fn: FFI declaration (`fn name(args) ret;`).
|
||||
expect_tok(p, TK_SEMI, "expected ';' after fn header");
|
||||
};
|
||||
n.exported = exported;
|
||||
n.attr = attrs;
|
||||
return n;
|
||||
};
|
||||
|
||||
fn parsetypedecl(p: *parser, exported: i32) *node = {
|
||||
let pf: str = p.cur_file;
|
||||
let pl: i32 = p.cur_line;
|
||||
let pc: i32 = p.cur_col;
|
||||
advance(p); // past `type`
|
||||
let n: *node = newnode(p.a, N_TYPEDECL, pf, pl, pc);
|
||||
let id: str;
|
||||
expectident(p, &id);
|
||||
n.str = id;
|
||||
expect_tok(p, TK_ASSIGN, "expected '=' in type decl");
|
||||
n.lhs = parsetype(p);
|
||||
expect_tok(p, TK_SEMI, "expected ';' after type decl");
|
||||
n.exported = exported;
|
||||
return n;
|
||||
};
|
||||
|
||||
// ---- file-level loop -------------------------------------------------
|
||||
|
||||
export fn parsefile(p: *parser) *node = {
|
||||
let f: *node = newnode(p.a, N_FILE, p.cur_file, p.cur_line, p.cur_col);
|
||||
let head: *node = nil;
|
||||
let tail: *node = nil;
|
||||
|
||||
for (p.cur_kind != TK_EOF) {
|
||||
let attrs: *node = parseattrs(p);
|
||||
let exported: i32 = 0;
|
||||
if (p.cur_kind == TK_EXPORT) { exported = 1; advance(p); };
|
||||
|
||||
let d: *node = nil;
|
||||
if (p.cur_kind == TK_USE) {
|
||||
d = parseuse(p);
|
||||
} else { if (p.cur_kind == TK_DEF) {
|
||||
d = parsedef(p, exported);
|
||||
} else { if (p.cur_kind == TK_TYPE) {
|
||||
d = parsetypedecl(p, exported);
|
||||
} else { if (p.cur_kind == TK_LET) {
|
||||
d = parselet(p, exported);
|
||||
} else { if (p.cur_kind == 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.cur_kind != TK_SEMI) {
|
||||
if (p.cur_kind == TK_EOF) { break; };
|
||||
if (p.cur_kind == TK_LBRACE) {
|
||||
let depth: i32 = 0;
|
||||
for (true) {
|
||||
if (p.cur_kind == TK_EOF) { break; };
|
||||
if (p.cur_kind == TK_LBRACE) { depth += 1; advance(p); continue; };
|
||||
if (p.cur_kind == TK_RBRACE) {
|
||||
depth -= 1;
|
||||
advance(p);
|
||||
if (depth == 0) { break; };
|
||||
continue;
|
||||
};
|
||||
advance(p);
|
||||
};
|
||||
continue;
|
||||
};
|
||||
advance(p);
|
||||
};
|
||||
if (p.cur_kind == TK_SEMI) { advance(p); };
|
||||
};};};};};
|
||||
|
||||
if (d != nil) {
|
||||
if (head == nil) {
|
||||
head = d;
|
||||
tail = d;
|
||||
} else {
|
||||
tail.next = d;
|
||||
tail = d;
|
||||
};
|
||||
};
|
||||
};
|
||||
f.list = head;
|
||||
return f;
|
||||
};
|
||||
Reference in New Issue
Block a user