sci2-ts 0.0.0-stage → 0.2.2

package/packages/sci/src/script/compiler.js

@@ -0,0 +1,993 @@
+import { read, show, ReadError } from "./sexpr.js";
+export class CompileError extends Error {
+    file;
+    line;
+    constructor(message, file, line) {
+        super(`${file}:${line}: ${message}`);
+        this.file = file;
+        this.line = line;
+    }
+}
+/** The object header slots, in order; every class and instance begins with them. */
+export const OBJECT_HEADER = ["-objID-", "-size-", "-propDict-", "-methDict-", "-classScript-", "-species-", "-super-", "-info-", "name"];
+const BUILTIN_DEFINES = { TRUE: 1, FALSE: 0, NULL: 0 };
+export function compileScripts(sources, ctx) {
+    const units = sources.map((s) => declare(s, ctx));
+    const byNumber = new Map();
+    for (const u of units) {
+        const other = byNumber.get(u.number);
+        if (other)
+            throw new CompileError(`script ${u.number} is also ${other.file}`, u.file, 1);
+        byNumber.set(u.number, u);
+    }
+    // Classes: numbered superclasses first, then in script order, skipping numbers used
+    // elsewhere (so a root class like Obj gets 0).
+    const classes = new Map();
+    for (const u of [...units].sort((a, b) => a.number - b.number)) {
+        for (const o of u.objects) {
+            if (o.kind !== "class")
+                continue;
+            if (classes.has(o.name) || ctx.externalClass?.(o.name))
+                throw new CompileError(`class ${o.name} is defined twice`, u.file, o.line);
+            classes.set(o.name, { obj: o, unit: u });
+        }
+    }
+    const taken = new Set(ctx.takenSpecies ?? []);
+    let nextSpecies = 0;
+    const number = (c, seen) => {
+        if (c.obj.species !== 0xffff)
+            return;
+        if (seen.has(c.obj.name))
+            throw new CompileError(`class ${c.obj.name} is its own superclass`, c.unit.file, c.obj.line);
+        seen.add(c.obj.name);
+        const sup = c.obj.superName ? classes.get(c.obj.superName) : undefined;
+        if (sup)
+            number(sup, seen);
+        while (taken.has(nextSpecies))
+            nextSpecies++;
+        c.obj.species = nextSpecies;
+        taken.add(nextSpecies);
+    };
+    for (const c of classes.values())
+        number(c, new Set());
+    // Globals: script 0's variables, then those other scripts declare with (global ...), in
+    // script order; they all live in script 0.
+    const globals = new Map();
+    const zero = byNumber.get(0);
+    const declared = [...units].sort((a, b) => a.number - b.number).flatMap((u) => u.globals.map((v) => ({ v, u })));
+    if (declared.length && !zero) {
+        throw new CompileError("(global ...) needs script 0 to be compiled with it (globals live there)", declared[0].u.file, declared[0].v.line);
+    }
+    for (const { v, u } of declared) {
+        const other = zero.locals.find((x) => x.name === v.name);
+        if (other)
+            throw new CompileError(`global ${v.name} is declared twice`, u.file, v.line);
+        zero.locals.push(v);
+    }
+    if (zero) {
+        let i = 0;
+        for (const v of zero.locals)
+            (globals.set(v.name, { index: i, size: v.size }), (i += v.size));
+    }
+    // Procedures other scripts can call.
+    const publicProcs = new Map();
+    for (const u of units) {
+        for (const p of u.publics)
+            if (u.procedures.some((f) => f.name === p.name))
+                publicProcs.set(p.name, { script: u.number, index: p.index });
+    }
+    const project = { ctx, classes, globals, publicProcs, layouts: new Map(), sent: [] };
+    const compiled = units.map((u) => ({
+        file: u.file,
+        number: u.number,
+        assembly: new ScriptCompiler(u, project).compile(),
+        classes: new Map(u.objects.filter((o) => o.kind === "class").map((o) => [o.name, o.species])),
+        variables: u.locals.flatMap((v) => (v.size === 1 ? [v.name] : Array.from({ length: v.size }, (_, i) => `${v.name}[${i}]`))),
+    }));
+    // Selectors sent that nothing here defines: probably misspelt.
+    if (ctx.onWarning) {
+        const defined = new Set(OBJECT_HEADER);
+        for (const u of units) {
+            for (const o of u.objects) {
+                for (const p of o.props)
+                    defined.add(p.name);
+                for (const m of o.methods)
+                    defined.add(m.name);
+            }
+        }
+        const reported = new Set();
+        for (const s of project.sent) {
+            if (defined.has(s.name) || reported.has(s.name))
+                continue;
+            reported.add(s.name);
+            ctx.onWarning({ message: `nothing defines ${s.name} (no class or object has a property or method by that name)`, file: s.file, line: s.line });
+        }
+    }
+    return compiled;
+}
+/** Reads a source file's top-level forms into declarations. */
+function declare(src, ctx) {
+    const unit = { file: src.file, number: -1, defines: new Map(), locals: [], globals: [], publics: [], externs: new Map(), objects: [], procedures: [] };
+    const fail = (msg, line, file = src.file) => {
+        throw new CompileError(msg, file, line);
+    };
+    const parse = (text, file) => {
+        try {
+            return read(text);
+        }
+        catch (e) {
+            if (e instanceof ReadError)
+                fail(e.message.replace(/^line \d+: /, ""), e.line, file);
+            throw e;
+        }
+    };
+    const topLevel = (forms, file, included) => {
+        for (const form of forms) {
+            if (form.kind !== "list" || form.items[0]?.kind !== "sym")
+                fail(`expected a declaration like (script ...), got ${show(form)}`, form.line, file);
+            const [head, ...rest] = form.items;
+            const line = form.line;
+            const sym = (n, what) => (n?.kind === "sym" ? n.name : fail(`expected ${what}`, n?.line ?? line, file));
+            const num = (n, what) => (n?.kind === "num" ? n.value : fail(`expected ${what}`, n?.line ?? line, file));
+            const onlyInScript = () => included && fail(`(${head.name}) can't be in an included file`, line, file);
+            switch (head.name) {
+                case "script":
+                    onlyInScript();
+                    if (unit.number >= 0)
+                        fail("a second (script N)", line);
+                    unit.number = num(rest[0], "the script's number");
+                    break;
+                case "include": {
+                    const name = rest[0]?.kind === "str" ? rest[0].value : sym(rest[0], "a file name");
+                    const text = ctx.include?.(name, file);
+                    if (text === undefined)
+                        fail(`can't find ${name} to include`, line, file);
+                    topLevel(parse(text, name), name, true);
+                    break;
+                }
+                case "define":
+                    unit.defines.set(sym(rest[0], "a name"), rest[1] ?? fail("(define NAME value)", line, file));
+                    break;
+                case "enum": {
+                    // (enum [start] A B (= C 10) D): A = start (0 by default), B = A + 1, ...
+                    let i = 0;
+                    let names = rest;
+                    if (names[0]?.kind === "num")
+                        (i = names[0].value), (names = names.slice(1));
+                    for (const n of names) {
+                        if (n.kind === "list" && n.items[0]?.kind === "sym" && n.items[0].name === "=") {
+                            i = constValue(n.items[2], unit.defines, (m) => fail(m, n.line, file));
+                            unit.defines.set(sym(n.items[1], "a name"), { kind: "num", value: i++, line: n.line });
+                        }
+                        else
+                            unit.defines.set(sym(n, "a name"), { kind: "num", value: i++, line: n.line });
+                    }
+                    break;
+                }
+                case "extern":
+                    for (let i = 0; i < rest.length; i += 3) {
+                        unit.externs.set(sym(rest[i], "a procedure name"), { script: num(rest[i + 1], "a script number"), index: num(rest[i + 2], "an export index") });
+                    }
+                    break;
+                case "public":
+                    onlyInScript();
+                    for (let i = 0; i < rest.length; i += 2) {
+                        unit.publics.push({ name: sym(rest[i], "a name"), index: num(rest[i + 1], "an export index"), line: rest[i].line });
+                    }
+                    break;
+                case "local":
+                    onlyInScript();
+                    unit.locals.push(...variables(rest, (m, l) => fail(m, l)));
+                    break;
+                case "global":
+                    onlyInScript();
+                    unit.globals.push(...variables(rest, (m, l) => fail(m, l)));
+                    break;
+                case "class":
+                case "instance":
+                    onlyInScript();
+                    unit.objects.push(object(head.name, rest, line, (m, l) => fail(m, l)));
+                    break;
+                case "procedure": {
+                    onlyInScript();
+                    const sig = rest[0];
+                    if (sig?.kind === "sym")
+                        break; // a forward declaration
+                    unit.procedures.push(func(sig, rest.slice(1), line, (m, l) => fail(m, l)));
+                    break;
+                }
+                default:
+                    fail(`unknown declaration (${head.name} ...)`, line, file);
+            }
+        }
+    };
+    topLevel(parse(src.text, src.file), src.file, false);
+    if (unit.number < 0)
+        fail("missing (script N)", 1);
+    return unit;
+}
+/** `a [b 4] (= c 5) [d 2] = (1 2)`: names, array sizes, initial values. */
+function variables(nodes, fail) {
+    const out = [];
+    for (let i = 0; i < nodes.length; i++) {
+        const n = nodes[i];
+        if (n.kind === "sym" && n.name !== "=") {
+            const v = { name: n.name, size: 1, init: [], line: n.line };
+            if (nodes[i + 1]?.kind === "sym" && nodes[i + 1].name === "=") {
+                v.init = [nodes[i + 2] ?? fail("= needs a value", n.line)];
+                i += 2;
+            }
+            out.push(v);
+        }
+        else if (n.kind === "index") {
+            const [name, size] = n.items;
+            if (name?.kind !== "sym" || size?.kind !== "num")
+                fail("an array is [name size]", n.line);
+            const v = { name: name.name, size: size.value, init: [], line: n.line };
+            if (nodes[i + 1]?.kind === "sym" && nodes[i + 1].name === "=") {
+                const values = nodes[i + 2];
+                v.init = values?.kind === "list" || values?.kind === "index" ? values.items : [values ?? fail("= needs values", n.line)];
+                if (v.init.length > v.size)
+                    fail(`${v.name} has ${v.size} elements, but ${v.init.length} values`, n.line);
+                i += 2;
+            }
+            out.push(v);
+        }
+        else if (n.kind === "list" && n.items[0]?.kind === "sym" && n.items[0].name === "=" && n.items[1]?.kind === "sym") {
+            out.push({ name: n.items[1].name, size: 1, init: [n.items[2] ?? fail("(= name value)", n.line)], line: n.line });
+        }
+        else
+            fail(`expected a variable name, got ${show(n)}`, n.line);
+    }
+    return out;
+}
+/** `(name a b &tmp t [buf 4])` and a body. */
+function func(sig, body, line, fail) {
+    if (sig?.kind !== "list" || sig.items[0]?.kind !== "sym")
+        return fail("expected (name params...)", sig?.line ?? line);
+    const [name, ...rest] = sig.items;
+    const tmp = rest.findIndex((n) => n.kind === "sym" && n.name === "&tmp");
+    const params = (tmp < 0 ? rest : rest.slice(0, tmp)).map((n) => (n.kind === "sym" ? n.name : fail(`expected a parameter name, got ${show(n)}`, n.line)));
+    const temps = tmp < 0 ? [] : variables(rest.slice(tmp + 1), fail);
+    for (const t of temps)
+        if (t.init.length)
+            fail("temporaries can't have initial values", t.line);
+    return { name: name.name, params, temps, body, line: sig.line };
+}
+function object(kind, rest, line, fail) {
+    const [name, ...more] = rest;
+    if (name?.kind !== "sym")
+        return fail(`expected (${kind} Name of Class ...)`, line);
+    const o = { kind: kind, name: name.name, props: [], methods: [], line, species: 0xffff };
+    let i = 0;
+    if (more[0]?.kind === "sym" && (more[0].name === "of" || more[0].name === "kindof")) {
+        if (more[1]?.kind !== "sym")
+            fail(`${o.name}: expected a class name after ${more[0].name}`, line);
+        o.superName = more[1].name;
+        i = 2;
+    }
+    else if (kind === "instance")
+        fail(`instance ${o.name} needs "of Class"`, line);
+    for (const n of more.slice(i)) {
+        if (n.kind !== "list" || n.items[0]?.kind !== "sym")
+            fail(`${o.name}: expected (properties ...) or (method ...), got ${show(n)}`, n.line);
+        const [head, ...body] = n.items;
+        if (head.name === "properties") {
+            for (let k = 0; k < body.length; k += 2) {
+                const p = body[k];
+                if (p.kind !== "sym")
+                    fail(`expected a property name, got ${show(p)}`, p.line);
+                o.props.push({ name: p.name, value: body[k + 1] ?? fail(`property ${p.name} needs a value`, p.line), line: p.line });
+            }
+        }
+        else if (head.name === "method") {
+            const m = func(body[0], body.slice(1), n.line, fail);
+            if (o.methods.some((x) => x.name === m.name))
+                fail(`${o.name} has two ${m.name} methods`, n.line);
+            o.methods.push(m);
+        }
+        else
+            fail(`${o.name}: expected (properties ...) or (method ...), got (${head.name} ...)`, n.line);
+    }
+    return o;
+}
+/** A constant expression: numbers, defines and arithmetic on them. */
+function constValue(n, defines, fail, depth = 0) {
+    if (depth > 50)
+        fail("a define refers to itself");
+    if (n.kind === "num")
+        return n.value;
+    if (n.kind === "sym") {
+        if (n.name in BUILTIN_DEFINES)
+            return BUILTIN_DEFINES[n.name];
+        const d = defines.get(n.name);
+        if (!d)
+            return fail(`${n.name} isn't a constant`);
+        return constValue(d, defines, fail, depth + 1);
+    }
+    if (n.kind === "list" && n.items[0]?.kind === "sym") {
+        const op = n.items[0].name;
+        const args = n.items.slice(1).map((a) => constValue(a, defines, fail, depth + 1));
+        const fold = (f) => args.reduce(f);
+        switch (op) {
+            case "+": return fold((a, b) => a + b);
+            case "-": return args.length === 1 ? -args[0] : fold((a, b) => a - b);
+            case "*": return fold((a, b) => a * b);
+            case "/": return fold((a, b) => Math.trunc(a / b));
+            case "|": return fold((a, b) => a | b);
+            case "&": return fold((a, b) => a & b);
+            case "^": return fold((a, b) => a ^ b);
+            case "<<": return fold((a, b) => a << b);
+            case ">>": return fold((a, b) => a >> b);
+            case "~": return ~args[0] & 0xffff;
+        }
+    }
+    return fail(`${show(n)} isn't a constant`);
+}
+const SEND_SELECTOR = /^([A-Za-z_-][\w-]*)[:?]$/;
+/** A message in a send starts with a selector (`x:`, `x?`) or `[expr]`, a selector computed at run time. */
+const isMessageHead = (n) => (n?.kind === "sym" && SEND_SELECTOR.test(n.name)) || (n?.kind === "index" && n.items.length === 1);
+const BINARY = {
+    "+": "add", "-": "sub", "*": "mul", "/": "div", mod: "mod", "<<": "shl", ">>": "shr", "&": "and", "|": "or", "^": "xor",
+};
+const COMPARE = {
+    "==": "eq?", "!=": "ne?", "<": "lt?", ">": "gt?", "<=": "le?", ">=": "ge?", "u<": "ult?", "u>": "ugt?", "u<=": "ule?", "u>=": "uge?",
+};
+const COMPOUND = { "+=": "+", "-=": "-", "*=": "*", "/=": "/", "|=": "|", "&=": "&", "^=": "^", "<<=": "<<", ">>=": ">>" };
+class ScriptCompiler {
+    unit;
+    project;
+    out = [];
+    strings = new Map();
+    labels = 0;
+    fn;
+    locals = new Map();
+    procedures;
+    objects;
+    constructor(unit, project) {
+        this.unit = unit;
+        this.project = project;
+        let i = 0;
+        for (const v of unit.locals) {
+            if (this.locals.has(v.name))
+                this.fail(`variable ${v.name} is declared twice`, v.line);
+            this.locals.set(v.name, { index: i, size: v.size });
+            i += v.size;
+        }
+        this.procedures = new Set(unit.procedures.map((p) => p.name));
+        this.objects = new Map(unit.objects.map((o) => [o.name, o]));
+    }
+    fail(message, line) {
+        throw new CompileError(message, this.unit.file, line);
+    }
+    compile() {
+        const u = this.unit;
+        const head = [`; compiled from ${u.file}`, `script ${u.number}`];
+        // Locals: initial values (numbers, strings, objects in this script).
+        const localValues = [];
+        for (const v of u.locals) {
+            for (let k = 0; k < v.size; k++)
+                localValues.push(v.init[k] ? this.initValue(v.init[k]) : "0");
+        }
+        if (localValues.length)
+            head.push(`locals ${localValues.join(" ")}`);
+        // Exports.
+        const exports = [];
+        for (const p of u.publics) {
+            if (!this.procedures.has(p.name) && !this.objects.has(p.name))
+                this.fail(`public ${p.name} is neither a procedure nor an object here`, p.line);
+            if (exports[p.index] !== undefined)
+                this.fail(`export ${p.index} is used twice`, p.line);
+            exports[p.index] = p.name;
+        }
+        if (exports.length)
+            head.push("exports", ...Array.from(exports, (e) => `  ${e ?? 0}`));
+        // Objects.
+        const body = [];
+        for (const o of u.objects)
+            body.push(...this.objectLines(o));
+        // Code.
+        const code = [];
+        for (const o of u.objects) {
+            const owner = this.ownerOf(o);
+            for (const m of o.methods)
+                code.push(...this.function(m, `${o.name}::${m.name}`, owner));
+        }
+        for (const p of u.procedures)
+            code.push(...this.function(p, p.name, undefined));
+        const strings = [...this.strings].map(([text, label]) => `  ${label} ${quote(text)}`);
+        return [...head, ...body, ...(strings.length ? ["strings", ...strings] : []), "code", ...code, ""].join("\n");
+    }
+    /** A class's layout: inherited properties first, then its own. */
+    layout(name, line) {
+        const cached = this.project.layouts.get(name);
+        if (cached)
+            return cached;
+        const local = this.project.classes.get(name);
+        let layout;
+        if (local) {
+            const { obj } = local;
+            const props = obj.superName ? this.layout(obj.superName, obj.line).props.map((p) => ({ ...p })) : [];
+            for (const p of obj.props) {
+                if (OBJECT_HEADER.includes(p.name))
+                    continue;
+                const inherited = props.find((x) => x.name === p.name);
+                if (inherited)
+                    inherited.value = p.value;
+                else
+                    props.push({ name: p.name, value: p.value });
+            }
+            layout = { species: obj.species, props };
+        }
+        else {
+            const ext = this.project.ctx.externalClass?.(name);
+            if (!ext)
+                this.fail(`unknown class ${name}`, line);
+            layout = { species: ext.species, props: ext.properties.map((p) => ({ ...p })) };
+        }
+        this.project.layouts.set(name, layout);
+        return layout;
+    }
+    ownerOf(o) {
+        const layout = this.objectLayout(o);
+        const superSpecies = o.kind === "instance" ? this.layout(o.superName, o.line).species : o.superName ? this.layout(o.superName, o.line).species : undefined;
+        return { obj: o, layout: [...OBJECT_HEADER, ...layout.map((p) => p.name)], superSpecies };
+    }
+    /** An object's properties after the header, with the values it gives them. */
+    objectLayout(o) {
+        if (o.kind === "class")
+            return this.layout(o.name, o.line).props;
+        const props = this.layout(o.superName, o.line).props.map((p) => ({ ...p }));
+        for (const p of o.props) {
+            if (p.name === "name")
+                continue;
+            const slot = props.find((x) => x.name === p.name);
+            if (!slot)
+                this.fail(`${o.name}: ${o.superName} has no property ${p.name}`, p.line);
+            slot.value = p.value;
+        }
+        return props;
+    }
+    objectLines(o) {
+        const lines = [""];
+        const own = o.props.find((p) => p.name === "name");
+        const name = own ? this.initValue(own.value) : `@${this.string(o.name)}`;
+        if (o.kind === "class") {
+            const sup = o.superName ? `$${this.layout(o.superName, o.line).species.toString(16)}` : "-";
+            lines.push(`class ${o.name} of ${sup} species ${o.species}${o.superName ? ` ; ${o.superName}` : ""}`);
+            lines.push(`  header ${OBJECT_HEADER.join(" ")}`, `  name ${name}`);
+            for (const p of this.objectLayout(o))
+                lines.push(`  prop ${p.name} ${this.propValue(p.value)}`);
+        }
+        else {
+            const layout = this.objectLayout(o);
+            lines.push(`instance ${o.name} of $${this.layout(o.superName, o.line).species.toString(16)} ; ${o.superName}`);
+            lines.push(`  layout ${[...OBJECT_HEADER, ...layout.map((p) => p.name)].join(" ")}`, `  name ${name}`);
+            for (const p of layout)
+                lines.push(`  ${p.name} ${this.propValue(p.value)}`);
+        }
+        for (const m of o.methods)
+            lines.push(`  method ${m.name} ${o.name}::${m.name}`);
+        return lines;
+    }
+    propValue(v) {
+        return typeof v === "number" ? String(toWord(v)) : this.initValue(v);
+    }
+    /** A value fixed when the script loads: a number, a string, a selector, or an object in this script. */
+    initValue(n) {
+        if (n.kind === "str")
+            return `@${this.string(n.value)}`;
+        if (n.kind === "sel") {
+            this.project.sent.push({ name: n.name, file: this.unit.file, line: n.line });
+            return `#${n.name}`;
+        }
+        if (n.kind === "sym" && this.objects.has(n.name) && this.objects.get(n.name).kind === "instance")
+            return `@${n.name}`;
+        return String(toWord(constValue(n, this.unit.defines, (m) => this.fail(m, n.line))));
+    }
+    string(text) {
+        let label = this.strings.get(text);
+        if (!label)
+            this.strings.set(text, (label = `s_${this.strings.size}`));
+        return label;
+    }
+    label() {
+        return `.L${++this.labels}`;
+    }
+    // --- Functions ---
+    function(f, label, owner) {
+        this.out.length = 0;
+        const params = new Map(f.params.map((p, i) => [p, i + 1]));
+        const temps = new Map();
+        let size = 0;
+        for (const t of f.temps)
+            (temps.set(t.name, { index: size, size: t.size }), (size += t.size));
+        this.fn = { func: f, owner, params, temps, loops: [], switches: 0 };
+        this.emit(`${label}:`);
+        if (size)
+            this.emit(`  link ${size}`);
+        this.body(f.body);
+        this.emit("  ret");
+        this.fn = undefined;
+        return ["", ...this.out];
+    }
+    emit(line) {
+        this.out.push(line);
+    }
+    op(line) {
+        this.out.push(`  ${line}`);
+    }
+    body(nodes) {
+        for (const n of nodes)
+            this.expr(n);
+    }
+    /** What a name means here: variables first, then properties, then everything else. */
+    resolve(name, line) {
+        const fn = this.fn;
+        const temp = fn.temps.get(name);
+        if (temp)
+            return { kind: "var", type: "t", index: temp.index, size: temp.size };
+        const param = fn.params.get(name);
+        if (param !== undefined)
+            return { kind: "var", type: "p", index: param, size: 1 };
+        if (fn.owner?.layout.includes(name))
+            return { kind: "prop", name };
+        const local = this.locals.get(name);
+        if (local)
+            return { kind: "var", type: this.unit.number === 0 ? "g" : "l", ...local };
+        const global = this.project.globals.get(name);
+        if (global)
+            return { kind: "var", type: "g", ...global };
+        if (name === "self")
+            return { kind: "self" };
+        if (name === "argc")
+            return { kind: "argc" };
+        const define = this.unit.defines.get(name);
+        if (define)
+            return { kind: "const", node: define };
+        if (name in BUILTIN_DEFINES)
+            return { kind: "const", node: { kind: "num", value: BUILTIN_DEFINES[name], line } };
+        const obj = this.objects.get(name);
+        if (obj?.kind === "instance")
+            return { kind: "object", label: name };
+        if (obj?.kind === "class" || this.project.classes.has(name) || this.project.ctx.externalClass?.(name)) {
+            return { kind: "class", species: this.layout(name, line).species, name };
+        }
+        return this.fail(`unknown name ${name}`, line);
+    }
+    varOp(action, stack, ref, indexed = false) {
+        // Script 0's own variables are the globals; elsewhere, its locals.
+        const type = ref.type === "g" && this.unit.number === 0 ? "l" : ref.type;
+        return `${action}${stack ? "s" : "a"}${type}${indexed ? "i" : ""} ${ref.index}`;
+    }
+    /** Evaluates into acc. */
+    expr(n) {
+        switch (n.kind) {
+            case "num": return this.op(`ldi ${toSigned(n.value)}`);
+            case "str": return this.op(`lofsa @${this.string(n.value)}`);
+            case "sel":
+                this.project.sent.push({ name: n.name, file: this.unit.file, line: n.line });
+                return this.op(`ldi #${n.name}`);
+            case "addr": return this.address(n.name, n.index, n.line);
+            case "index": {
+                const [arr, i] = n.items;
+                if (arr?.kind !== "sym" || !i || n.items.length !== 2)
+                    this.fail("an array element is [name index]", n.line);
+                const ref = this.arrayRef(arr.name, n.line);
+                this.expr(i);
+                return this.op(this.varOp("l", false, ref, true));
+            }
+            case "sym": {
+                if (n.name === "&rest" || SEND_SELECTOR.test(n.name))
+                    this.fail(`${n.name} only makes sense in a call or send`, n.line);
+                const ref = this.resolve(n.name, n.line);
+                switch (ref.kind) {
+                    case "var": return this.op(this.varOp("l", false, ref));
+                    case "prop": return this.op(`pToa ${ref.name}`);
+                    case "const": return this.op(`ldi ${toSigned(constValue(ref.node, this.unit.defines, (m) => this.fail(m, n.line)))}`);
+                    case "object": return this.op(`lofsa @${ref.label}`);
+                    case "class": return this.op(`class $${ref.species.toString(16)}`);
+                    case "self": return this.op("selfID");
+                    case "argc": return this.op("lap 0");
+                }
+                return;
+            }
+            case "list": return this.form(n);
+        }
+    }
+    /** Pushes a value, in one instruction where there is one. */
+    push(n) {
+        if (n.kind === "num" || (n.kind === "sym" && this.isConst(n.name))) {
+            const v = n.kind === "num" ? n.value : constValue({ ...n }, this.unit.defines, (m) => this.fail(m, n.line));
+            const w = toWord(v);
+            return this.op(w === 0 ? "push0" : w === 1 ? "push1" : w === 2 ? "push2" : `pushi ${toSigned(w)}`);
+        }
+        if (n.kind === "sel") {
+            this.project.sent.push({ name: n.name, file: this.unit.file, line: n.line });
+            return this.op(`pushi #${n.name}`);
+        }
+        if (n.kind === "str")
+            return this.op(`lofss @${this.string(n.value)}`);
+        if (n.kind === "sym") {
+            const ref = this.resolve(n.name, n.line);
+            if (ref.kind === "var")
+                return this.op(this.varOp("l", true, ref));
+            if (ref.kind === "prop")
+                return this.op(`pTos ${ref.name}`);
+            if (ref.kind === "object")
+                return this.op(`lofss @${ref.label}`);
+            if (ref.kind === "self")
+                return this.op("pushSelf");
+        }
+        this.expr(n);
+        this.op("push");
+    }
+    isConst(name) {
+        if (!this.fn)
+            return true;
+        const ref = (() => {
+            try {
+                return this.resolve(name, 0);
+            }
+            catch {
+                return undefined;
+            }
+        })();
+        return ref?.kind === "const";
+    }
+    arrayRef(name, line) {
+        const ref = this.resolve(name, line);
+        if (ref.kind !== "var")
+            this.fail(`${name} isn't a variable, so it can't be indexed`, line);
+        return ref;
+    }
+    /** @name or @[name i]: the address of a variable, for kernels that write into it. */
+    address(name, index, line) {
+        const ref = this.arrayRef(name, line);
+        const kind = { g: 0, l: 1, t: 2, p: 3 }[ref.type === "g" && this.unit.number === 0 ? "l" : ref.type];
+        if (index)
+            this.expr(index);
+        this.op(`lea ${(kind | (index ? 8 : 0)) << 1} ${ref.index}`);
+    }
+    form(n) {
+        const [head, ...args] = n.items;
+        if (!head)
+            this.fail("() is empty", n.line);
+        // A send: (target sel: ...), or (target [s] ...) with the selector in s.
+        if (isMessageHead(args[0]))
+            return this.send(head, args, n.line);
+        if (head.kind !== "sym") {
+            if (head.kind === "list" || head.kind === "index")
+                this.fail(`expected a selector after ${show(head)} (a send)`, n.line);
+            this.fail(`can't call ${show(head)}`, n.line);
+        }
+        const name = head.name;
+        const arity = (min, max = min) => {
+            if (args.length < min || args.length > max)
+                this.fail(`(${name} ...) takes ${min === max ? min : `${min} to ${max === Infinity ? "any number of" : max}`} argument(s)`, n.line);
+        };
+        switch (name) {
+            case "send": {
+                if (!args[0])
+                    this.fail("(send target sel: ...)", n.line);
+                return this.send(args[0], args.slice(1), n.line);
+            }
+            case "=":
+                arity(2);
+                return this.assign(args[0], args[1], n.line);
+            case "++":
+            case "--":
+                arity(1);
+                return this.increment(args[0], name === "++" ? "+" : "-", n.line);
+            case "not":
+                arity(1);
+                this.expr(args[0]);
+                return this.op("not");
+            case "~":
+                arity(1);
+                this.expr(args[0]);
+                return this.op("bnot");
+            case "and":
+            case "or": {
+                arity(1, Infinity);
+                const end = this.label();
+                args.forEach((a, i) => {
+                    this.expr(a);
+                    if (i < args.length - 1)
+                        this.op(`${name === "and" ? "bnt" : "bt"} ${end}`);
+                });
+                return this.emit(`${end}:`);
+            }
+            case "if": return this.ifForm(args, n.line);
+            case "cond": return this.cond(args, n.line);
+            case "switch": return this.switchForm(args, n.line);
+            case "switchto": {
+                // (switchto value (body for 0...) (body for 1...) ...): cases by position.
+                if (!args.length)
+                    this.fail("(switchto value (body...)...)", n.line);
+                const cases = args.slice(1).map((c, i) => {
+                    if (c.kind !== "list")
+                        this.fail("a switchto case is (body...)", c.line);
+                    return { kind: "list", items: [{ kind: "num", value: i, line: c.line }, ...c.items], line: c.line };
+                });
+                return this.switchForm([args[0], ...cases], n.line);
+            }
+            case "while": {
+                arity(1, Infinity);
+                const top = this.label(), end = this.label();
+                this.emit(`${top}:`);
+                this.expr(args[0]);
+                this.op(`bnt ${end}`);
+                this.loop(top, end, () => this.body(args.slice(1)));
+                this.op(`jmp ${top}`);
+                return this.emit(`${end}:`);
+            }
+            case "repeat": {
+                const top = this.label(), end = this.label();
+                this.emit(`${top}:`);
+                this.loop(top, end, () => this.body(args));
+                this.op(`jmp ${top}`);
+                return this.emit(`${end}:`);
+            }
+            case "for": {
+                arity(3, Infinity);
+                const [init, test, step] = args;
+                const list = (x) => (x.kind === "list" && (x.items.length === 0 || x.items[0].kind === "list") ? x.items : [x]);
+                this.body(list(init));
+                const top = this.label(), next = this.label(), end = this.label();
+                this.emit(`${top}:`);
+                this.expr(test);
+                this.op(`bnt ${end}`);
+                this.loop(next, end, () => this.body(args.slice(3)));
+                this.emit(`${next}:`);
+                this.body(list(step));
+                this.op(`jmp ${top}`);
+                return this.emit(`${end}:`);
+            }
+            case "break":
+            case "continue": {
+                arity(0);
+                const loop = this.fn.loops[this.fn.loops.length - 1];
+                if (!loop)
+                    this.fail(`(${name}) outside a loop`, n.line);
+                // Leave the values of switches entered since the loop began.
+                for (let i = loop.switches; i < this.fn.switches; i++)
+                    this.op("toss");
+                return this.op(`jmp ${name === "break" ? loop.brk : loop.cont}`);
+            }
+            case "return":
+                arity(0, 1);
+                if (args[0])
+                    this.expr(args[0]);
+                return this.op("ret");
+        }
+        if (name in COMPOUND) {
+            arity(2);
+            const [target, value] = args;
+            return this.assign(target, { kind: "list", items: [{ kind: "sym", name: COMPOUND[name], line: n.line }, target, value], line: n.line }, n.line);
+        }
+        if (name in BINARY) {
+            if (name === "-" && args.length === 1) {
+                this.expr(args[0]);
+                return this.op("neg");
+            }
+            arity(2, name === "-" || name === "/" || name === "mod" || name === "<<" || name === ">>" ? 2 : Infinity);
+            this.expr(args[0]);
+            for (const a of args.slice(1)) {
+                this.op("push");
+                this.expr(a);
+                this.op(BINARY[name]);
+            }
+            return;
+        }
+        if (name in COMPARE) {
+            arity(2);
+            this.push(args[0]);
+            this.expr(args[1]);
+            return this.op(COMPARE[name]);
+        }
+        return this.call(name, args, n.line);
+    }
+    loop(cont, brk, body) {
+        this.fn.loops.push({ brk, cont, switches: this.fn.switches });
+        body();
+        this.fn.loops.pop();
+    }
+    ifForm(args, line) {
+        if (!args.length)
+            this.fail("(if condition ...)", line);
+        const split = args.findIndex((a) => a.kind === "sym" && a.name === "else");
+        const then = split < 0 ? args.slice(1) : args.slice(1, split);
+        const otherwise = split < 0 ? undefined : args.slice(split + 1);
+        const elseLabel = this.label(), end = this.label();
+        this.expr(args[0]);
+        this.op(`bnt ${otherwise ? elseLabel : end}`);
+        this.body(then);
+        if (otherwise) {
+            this.op(`jmp ${end}`);
+            this.emit(`${elseLabel}:`);
+            this.body(otherwise);
+        }
+        this.emit(`${end}:`);
+    }
+    cond(clauses, line) {
+        const end = this.label();
+        for (const c of clauses) {
+            if (c.kind !== "list" || !c.items.length)
+                this.fail("a cond clause is (condition body...)", c.line ?? line);
+            const [test, ...body] = c.items;
+            if (test.kind === "sym" && test.name === "else") {
+                this.body(body);
+                break;
+            }
+            const next = this.label();
+            this.expr(test);
+            this.op(`bnt ${next}`);
+            this.body(body);
+            this.op(`jmp ${end}`);
+            this.emit(`${next}:`);
+        }
+        this.emit(`${end}:`);
+    }
+    switchForm(args, line) {
+        if (!args.length)
+            this.fail("(switch value (case body...)...)", line);
+        const end = this.label();
+        this.expr(args[0]);
+        this.op("push");
+        this.fn.switches++;
+        for (const c of args.slice(1)) {
+            if (c.kind !== "list" || !c.items.length)
+                this.fail("a switch case is (value body...)", c.line ?? line);
+            const [value, ...body] = c.items;
+            if (value.kind === "sym" && value.name === "else") {
+                this.body(body);
+                break;
+            }
+            const next = this.label();
+            this.op("dup");
+            this.expr(value);
+            this.op("eq?");
+            this.op(`bnt ${next}`);
+            this.body(body);
+            this.op(`jmp ${end}`);
+            this.emit(`${next}:`);
+        }
+        this.fn.switches--;
+        this.emit(`${end}:`);
+        this.op("toss");
+    }
+    assign(target, value, line) {
+        if (target.kind === "index") {
+            const [arr, i] = target.items;
+            if (arr?.kind !== "sym" || !i)
+                this.fail("an array element is [name index]", line);
+            const ref = this.arrayRef(arr.name, line);
+            this.push(value);
+            this.expr(i);
+            return this.op(this.varOp("s", false, ref, true));
+        }
+        if (target.kind !== "sym")
+            this.fail(`can't assign to ${show(target)}`, line);
+        const ref = this.resolve(target.name, line);
+        this.expr(value);
+        if (ref.kind === "var")
+            return this.op(this.varOp("s", false, ref));
+        if (ref.kind === "prop")
+            return this.op(`aTop ${ref.name}`);
+        this.fail(`can't assign to ${target.name}`, line);
+    }
+    increment(target, dir, line) {
+        if (target.kind === "index") {
+            const [arr, i] = target.items;
+            if (arr?.kind !== "sym" || !i)
+                this.fail("an array element is [name index]", line);
+            const ref = this.arrayRef(arr.name, line);
+            this.expr(i);
+            return this.op(this.varOp(dir, false, ref, true));
+        }
+        if (target.kind !== "sym")
+            this.fail(`can't change ${show(target)}`, line);
+        const ref = this.resolve(target.name, line);
+        if (ref.kind === "var")
+            return this.op(this.varOp(dir, false, ref));
+        if (ref.kind === "prop")
+            return this.op(`${dir === "+" ? "ipToa" : "dpToa"} ${ref.name}`);
+        this.fail(`can't change ${target.name}`, line);
+    }
+    /**
+     * Splits arguments from a trailing `&rest` (the caller's arguments after its named ones) or
+     * `&rest param` (from that parameter on).
+     */
+    restSplit(args, line) {
+        const at = args.findIndex((a) => a.kind === "sym" && a.name === "&rest");
+        if (at < 0)
+            return { explicit: args };
+        const from = args[at + 1];
+        const fromParam = from?.kind === "sym" ? this.fn.params.get(from.name) : undefined;
+        if (args.length > at + (fromParam === undefined ? 1 : 2))
+            this.fail("&rest goes last", line);
+        return { explicit: args.slice(0, at), rest: fromParam ?? this.fn.func.params.length + 1 };
+    }
+    /** Pushes arguments; returns the frame size in bytes (what &rest adds is counted at run time). */
+    pushArgs(args) {
+        for (const a of args.explicit)
+            this.push(a);
+        if (args.rest !== undefined)
+            this.op(`&rest ${args.rest}`);
+        return args.explicit.length * 2;
+    }
+    send(target, messages, line) {
+        let frame = 0;
+        for (let i = 0; i < messages.length;) {
+            const sel = messages[i];
+            if (!isMessageHead(sel))
+                this.fail(`expected a selector like x: or init:, got ${show(sel)}`, sel.line);
+            let j = i + 1;
+            while (j < messages.length && !isMessageHead(messages[j]))
+                j++;
+            const args = this.restSplit(messages.slice(i + 1, j), sel.line);
+            if (sel.kind === "sym") {
+                const name = SEND_SELECTOR.exec(sel.name)[1];
+                this.project.sent.push({ name, file: this.unit.file, line: sel.line });
+                this.op(`pushi #${name}`);
+            }
+            else
+                this.push(sel.items[0]);
+            this.push({ kind: "num", value: args.explicit.length, line });
+            frame += 4 + this.pushArgs(args);
+            i = j;
+        }
+        if (!messages.length)
+            this.fail("a send needs at least one selector", line);
+        if (target.kind === "sym" && target.name === "self")
+            return this.op(`self ${frame}`);
+        if (target.kind === "sym" && target.name === "super") {
+            const sup = this.fn.owner?.superSpecies;
+            if (sup === undefined)
+                this.fail("super: this object has no superclass", line);
+            return this.op(`super $${sup.toString(16)} ${frame}`);
+        }
+        this.expr(target);
+        this.op(`send ${frame}`);
+    }
+    call(name, args, line) {
+        const local = this.procedures.has(name);
+        const ext = local ? undefined : this.unit.externs.get(name) ?? this.project.publicProcs.get(name);
+        const kernel = local || ext ? -1 : this.project.ctx.kernelNames.indexOf(name);
+        if (!local && !ext && kernel < 0) {
+            if (this.objects.has(name) || this.project.classes.has(name))
+                this.fail(`${name} is an object: send it a message, like (${name} init:)`, line);
+            this.fail(`unknown procedure or kernel ${name}`, line);
+        }
+        const split = this.restSplit(args, line);
+        this.push({ kind: "num", value: split.explicit.length, line });
+        const frame = this.pushArgs(split);
+        if (local)
+            this.op(`call ${name} ${frame}`);
+        else if (ext)
+            this.op(ext.script === 0 ? `callb ${ext.index} ${frame}` : `calle ${ext.script} ${ext.index} ${frame}`);
+        else
+            this.op(`callk ${name} ${frame}`);
+    }
+}
+const toWord = (v) => ((v % 0x10000) + 0x10000) % 0x10000;
+const toSigned = (v) => {
+    const w = toWord(v);
+    return w >= 0x8000 ? w - 0x10000 : w;
+};
+function quote(text) {
+    let s = '"';
+    for (const ch of text) {
+        const c = ch.charCodeAt(0);
+        if (ch === '"' || ch === "\\")
+            s += `\\${ch}`;
+        else if (ch === "\n")
+            s += "\\n";
+        else if (c >= 0x20 && c < 0x7f)
+            s += ch;
+        else
+            s += `\\x${(c & 0xff).toString(16).padStart(2, "0")}`;
+    }
+    return `${s}"`;
+}