compile_arith.nula

// bootstrap/compile_arith.nula — Compile expressions to VM bytecode text.
// Single-function compiler. Supports arithmetic, if/then/else, let bindings.
// Run: echo "let x = 5 in x + 1" | nulang bootstrap/compile_arith.nula

fn is_digit(c: Int) -> Bool { c >= 48 and c <= 57 }
fn is_alpha(c: Int) -> Bool { (c >= 65 and c <= 90) or (c >= 97 and c <= 122) }
fn is_alphanum(c: Int) -> Bool { is_alpha(c) or is_digit(c) or c == 95 }
fn is_space(c: Int) -> Bool { c == 32 or c == 10 or c == 13 or c == 9 }

fn skip_ws(src: String, pos: Int, len: Int) -> Int {
    if pos >= len then pos
    else if is_space(perform String.charAt(src, pos)) then skip_ws(src, pos + 1, len)
    else pos
}

fn read_int(src: String, pos: Int, len: Int, acc: Int) -> Int {
    if pos >= len then (acc << 16) + pos
    else {
        let c = perform String.charAt(src, pos);
        if is_digit(c) then read_int(src, pos + 1, len, acc * 10 + (c - 48))
        else (acc << 16) + pos
    }
}

fn read_ident(src: String, pos: Int, len: Int, h: Int) -> Int {
    if pos >= len then (h << 16) + pos
    else {
        let c = perform String.charAt(src, pos);
        if is_alphanum(c) then {
            let nh = h * 5 + c;
            read_ident(src, pos + 1, len, nh)
        } else (h << 16) + pos
    }
}

// Env entry: (hash << 32) | reg. Lookup returns register, or 0 if not found.
fn env_lookup(e0: Int, e1: Int, e2: Int, e3: Int, elen: Int, h: Int) -> Int {
    if elen <= 0 then 0
    else {
        let slot = if elen >= 4 then e3
        else if elen >= 3 then e2
        else if elen >= 2 then e1
        else e0;
        let sh = slot >> 32;
        if sh == h then slot & 0xFFFFFFFF
        else env_lookup(e0, e1, e2, 0, elen - 1, h)
    }
}

fn prec_of(c: Int) -> Int {
    if c == 43 then 2 else if c == 45 then 2
    else if c == 42 then 3 else if c == 47 then 3
    else 0
}

fn opcode_of(c: Int) -> Int {
    if c == 43 then 0x20 else if c == 45 then 0x21
    else if c == 42 then 0x22 else if c == 47 then 0x23
    else 0
}

fn op_name(op: Int) -> String {
    if op == 0x20 then "IAdd" else if op == 0x21 then "ISub"
    else if op == 0x22 then "IMul" else if op == 0x23 then "IDiv"
    else if op == 0x01 then "Halt" else "Const"
}

// Parse comparison operator. Returns (prec<<16)|(opcode<<8)|len or 0.
// Opcodes: ICmpEq=0x40, ICmpNe=0x41, ICmpLt=0x42, ICmpGt=0x43, ICmpLe=0x44, ICmpGe=0x45
fn parse_cmp(src: String, p: Int, len: Int) -> Int {
    if p >= len then 0
    else {
        let c = perform String.charAt(src, p);
        if c == 61 and p + 1 < len then {
            let c2 = perform String.charAt(src, p + 1);
            if c2 == 61 then (1 << 16) + (0x40 << 8) + 2 else 0
        } else if c == 33 and p + 1 < len then {
            let c2 = perform String.charAt(src, p + 1);
            if c2 == 61 then (1 << 16) + (0x41 << 8) + 2 else 0
        } else if c == 60 then {
            if p + 1 < len then {
                let c2 = perform String.charAt(src, p + 1);
                if c2 == 61 then (1 << 16) + (0x44 << 8) + 2
                else (1 << 16) + (0x42 << 8) + 1
            } else (1 << 16) + (0x42 << 8) + 1
        } else if c == 62 then {
            if p + 1 < len then {
                let c2 = perform String.charAt(src, p + 1);
                if c2 == 61 then (1 << 16) + (0x45 << 8) + 2
                else (1 << 16) + (0x43 << 8) + 1
            } else (1 << 16) + (0x43 << 8) + 1
        } else 0
    }
}

fn cmp_name(op: Int) -> String {
    if op == 0x40 then "ICmpEq" else if op == 0x41 then "ICmpNe"
    else if op == 0x42 then "ICmpLt" else if op == 0x43 then "ICmpGt"
    else if op == 0x44 then "ICmpLe" else if op == 0x45 then "ICmpGe"
    else "???"
}

fn emit_const(num: Int, reg: Int) {
    if num == 0 then perform IO.print("  Const0 r" + perform Int.to_string(reg))
    else if num == 1 then perform IO.print("  Const1 r" + perform Int.to_string(reg))
    else if num == 2 then perform IO.print("  Const2 r" + perform Int.to_string(reg))
    else if num == -1 then perform IO.print("  ConstM1 r" + perform Int.to_string(reg))
    else perform IO.print("  ConstU r" + perform Int.to_string(reg) + " # " + perform Int.to_string(num))
}

fn emit_binop(opcode: Int, lr: Int, rr: Int, dr: Int) {
    let name = op_name(opcode);
    perform IO.print("  " + name + " r" + perform Int.to_string(lr) + " r" + perform Int.to_string(rr) + " r" + perform Int.to_string(dr))
}

fn emit_copy(src_reg: Int, dst_reg: Int) {
    perform IO.print("  Move r" + perform Int.to_string(src_reg) + " r" + perform Int.to_string(dst_reg))
}

// Returns (result_reg << 16) | pos.
fn comp(src: String, pos: Int, len: Int, left: Int, min_prec: Int, nr: Int, e0: Int, e1: Int, e2: Int, e3: Int, elen: Int) {
    let no_left = 1 << 40;
    let pair = if left == no_left then {
        let p = skip_ws(src, pos, len);
        if p >= len then (nr << 16) + p
        else {
            let c = perform String.charAt(src, p);
            if is_digit(c) then {
                let packed = read_int(src, p, len, 0);
                let num = packed >> 16;
                let q = packed & 0xFFFF;
                emit_const(num, nr);
                (nr << 16) + q
            } else if c == 40 then {
                let inner = comp(src, p + 1, len, no_left, -1, nr, e0, e1, e2, e3, elen);
                let rv = inner >> 16;
                let rp = inner & 0xFFFF;
                let q2 = skip_ws(src, rp, len);
                if q2 < len then {
                    let c2 = perform String.charAt(src, q2);
                    if c2 == 41 then (rv << 16) + (q2 + 1)
                    else (rv << 16) + q2
                } else (rv << 16) + q2
            } else if is_alpha(c) then {
                let ident = read_ident(src, p, len, 0);
                let h = ident >> 16;
                let q = ident & 0xFFFF;
                if h == 3321 then {
                    // "let" keyword: let <var> = <value> in <body>
                    let q2 = skip_ws(src, q, len);
                    let var_id = read_ident(src, q2, len, 0);
                    let vh = var_id >> 16;
                    let q3 = var_id & 0xFFFF;
                    let q4 = skip_ws(src, q3, len);
                    if q4 < len then {
                        let c3 = perform String.charAt(src, q4);
                        if c3 == 61 then {
                            let bound = comp(src, q4 + 1, len, no_left, -1, nr, e0, e1, e2, e3, elen);
                            let vr = bound >> 16;
                            let vp = bound & 0xFFFF;
                            let vp2 = skip_ws(src, vp, len);
                            if vp2 + 1 < len then {
                                let ci = perform String.charAt(src, vp2);
                                let cn = perform String.charAt(src, vp2 + 1);
                                if ci == 105 and cn == 110 then {
                                    let entry = (vh << 32) + vr;
                                    let nxt = nr + 1;
                                    if elen == 0 then comp(src, vp2 + 2, len, no_left, 0, nxt, entry, 0, 0, 0, 1)
                                    else if elen == 1 then comp(src, vp2 + 2, len, no_left, 0, nxt, e0, entry, 0, 0, 2)
                                    else if elen == 2 then comp(src, vp2 + 2, len, no_left, 0, nxt, e0, e1, entry, 0, 3)
                                    else comp(src, vp2 + 2, len, no_left, 0, nxt, e0, e1, e2, entry, 4)
                                } else (vr << 16) + vp2
                            } else (vr << 16) + vp2
                        } else (nr << 16) + p
                    } else (nr << 16) + p
                } else if h == 627 then {
                    // "if" keyword
                    let cond = comp(src, q, len, no_left, -1, nr, e0, e1, e2, e3, elen);
                    let cr = cond >> 16;
                    let cp = cond & 0xFFFF;
                    let cnext = nr + 1;
                    let cp2 = skip_ws(src, cp, len);
                    let then_id = read_ident(src, cp2, len, 0);
                    let th = then_id >> 16;
                    let tp = then_id & 0xFFFF;
                    if th == 17715 then {
                        perform IO.print("  JmpF r" + perform Int.to_string(cr) + " L" + perform Int.to_string(p) + "e");
                        let then_body = comp(src, tp, len, no_left, -1, cnext, e0, e1, e2, e3, elen);
                        let tr = then_body >> 16;
                        let tbp = then_body & 0xFFFF;
                        perform IO.print("  Jmp L" + perform Int.to_string(p) + "x");
                        perform IO.print("L" + perform Int.to_string(p) + "e:");
                        let tbp2 = skip_ws(src, tbp, len);
                        let else_id = read_ident(src, tbp2, len, 0);
                        let eh = else_id >> 16;
                        let ep = else_id & 0xFFFF;
                        if eh == 16001 then {
                            let else_body = comp(src, ep, len, no_left, -1, cnext, e0, e1, e2, e3, elen);
                            let er = else_body >> 16;
                            let ebp = else_body & 0xFFFF;
                            perform IO.print("L" + perform Int.to_string(p) + "x:");
                            (er << 16) + ebp
                        } else (nr << 16) + p
                    } else (nr << 16) + p
                } else if h == 18036 then {
                    // "true" literal
                    emit_const(1, nr);
                    (nr << 16) + q
                } else if h == 79251 then {
                    // "false" literal
                    emit_const(0, nr);
                    (nr << 16) + q
                } else if h == 3421 then {
                    // "not" prefix: ICmpEq arg, 0, result
                    let inner = comp(src, q, len, no_left, -1, nr, e0, e1, e2, e3, elen);
                    let iv = inner >> 16;
                    let ip = inner & 0xFFFF;
                    let dr = nr + 1;
                    emit_const(0, dr);
                    let dr2 = nr + 2;
                    perform IO.print("  ICmpEq r" + perform Int.to_string(iv) + " r" + perform Int.to_string(dr) + " r" + perform Int.to_string(dr2));
                    (dr2 << 16) + ip
                } else {
                    // Variable reference: look up in env, copy to current register
                    let reg = env_lookup(e0, e1, e2, e3, elen, h);
                    if reg == 0 then (nr << 16) + p
                    else {
                        emit_copy(reg, nr);
                        (nr << 16) + q
                    }
                }
            } else {
                (nr << 16) + p
            }
        }
    } else (left << 16) + pos;

    let lr = pair >> 16;
    let lp = pair & 0xFFFF;

    let p = skip_ws(src, lp, len);
    if p >= len then pair
    else {
        let c = perform String.charAt(src, p);
        if c == 61 or c == 33 or c == 60 or c == 62 then {
            let cmp = parse_cmp(src, p, len);
            if cmp == 0 then pair
            else {
                let cprec = cmp >> 16;
                let cop = (cmp >> 8) & 0xFF;
                let clen = cmp & 0xFF;
                if cprec < min_prec then pair
                else {
                    let rhs = comp(src, p + clen, len, no_left, cprec, nr + 1, e0, e1, e2, e3, elen);
                    let rr = rhs >> 16;
                    let rp = rhs & 0xFFFF;
                    let dr = nr + 2;
                    let cname = cmp_name(cop);
                    perform IO.print("  " + cname + " r" + perform Int.to_string(lr) + " r" + perform Int.to_string(rr) + " r" + perform Int.to_string(dr));
                    comp(src, rp, len, dr, min_prec, dr + 1, e0, e1, e2, e3, elen)
                }
            }
        } else if is_alpha(c) then {
            let ident = read_ident(src, p, len, 0);
            let kw = ident >> 16;
            let q = ident & 0xFFFF;
            if kw == 3075 then {
                // "and" — precedence 0, short-circuit
                if 0 < min_prec then pair
                else {
                    perform IO.print("  JmpF r" + perform Int.to_string(lr) + " L" + perform Int.to_string(p) + "a");
                    let rhs = comp(src, q, len, no_left, 0, nr + 1, e0, e1, e2, e3, elen);
                    let rr = rhs >> 16;
                    let rp = rhs & 0xFFFF;
                    perform IO.print("L" + perform Int.to_string(p) + "a:");
                    comp(src, rp, len, rr, min_prec, rr + 1, e0, e1, e2, e3, elen)
                }
            } else if kw == 669 then {
                // "or" — precedence 0, short-circuit
                if 0 < min_prec then pair
                else {
                    perform IO.print("  JmpF r" + perform Int.to_string(lr) + " L" + perform Int.to_string(p) + "o");
                    let dr = nr + 1;
                    emit_const(1, dr);
                    perform IO.print("  Jmp L" + perform Int.to_string(p) + "x");
                    perform IO.print("L" + perform Int.to_string(p) + "o:");
                    let rhs = comp(src, q, len, no_left, 0, dr + 1, e0, e1, e2, e3, elen);
                    let rr = rhs >> 16;
                    let rp = rhs & 0xFFFF;
                    perform IO.print("L" + perform Int.to_string(p) + "x:");
                    comp(src, rp, len, rr, min_prec, rr + 1, e0, e1, e2, e3, elen)
                }
            } else pair
        } else {
            let prec = prec_of(c);
            if prec == 0 or prec < min_prec then pair
            else {
            let rhs = comp(src, p + 1, len, no_left, prec, nr + 1, e0, e1, e2, e3, elen);
            let rr = rhs >> 16;
            let rp = rhs & 0xFFFF;
            let dr = nr + 2;
            let opcode = opcode_of(c);
            emit_binop(opcode, lr, rr, dr);
            comp(src, rp, len, dr, min_prec, dr + 1, e0, e1, e2, e3, elen)
            }
        }
    }
}

fn compile(src: String) {
    let len = perform String.length(src);
    perform IO.print("; " + src);
    let result = comp(src, 0, len, 1 << 40, -1, 8, 0, 0, 0, 0, 0);
    perform IO.print("  Halt");
    let reg = result >> 16;
    perform IO.print("; result in r" + perform Int.to_string(reg))
}

fn main() {
    let input = perform IO.read();
    if input == "" then {
        compile("not (1 == 2)")
    } else {
        compile(input)
    }
}