compiler_core.nula

// bootstrap/compiler_core.nula — Stage 8: stdin REPL, comparisons, booleans
// Return: (value << 16) | pos.  Entry: (hash << 32) + value.
// Closure encoding (32-bit): flag(bit30) | (ph<<23) | (bs<<16) | (cap_h<<8) | cap_v
// flag = 1 << 30 = 1073741824. Position is clean source pos.
// Env: e0..e3 with elen 0..4. let pushes to next slot. Closures capture most recent.

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
    }
}

// 4-slot environment lookup: search e3, e2, e1, e0 (most-recent first).
fn env_lookup(e0: Int, e1: Int, e2: Int, e3: Int, elen: Int, h: Int) -> Int {
    if elen <= 0 then 0
    else {
        // Check most recent slot first
        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 4 else if c == 45 then 4
    else if c == 42 then 5 else if c == 47 then 5
    else 0
}

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 == 60 then {
            if p + 1 < len then {
                let c2 = perform String.charAt(src, p + 1);
                if c2 == 61 then (3 << 16) + (5 << 8) + 2
                else (3 << 16) + (3 << 8) + 1
            } else (3 << 16) + (3 << 8) + 1
        } else if c == 62 then {
            if p + 1 < len then {
                let c2 = perform String.charAt(src, p + 1);
                if c2 == 61 then (3 << 16) + (6 << 8) + 2
                else (3 << 16) + (4 << 8) + 1
            } else (3 << 16) + (4 << 8) + 1
        } else if c == 61 then {
            if p + 1 < len then {
                let c2 = perform String.charAt(src, p + 1);
                if c2 == 61 then (3 << 16) + (1 << 8) + 2
                else 0
            } else 0
        } else if c == 33 then {
            if p + 1 < len then {
                let c2 = perform String.charAt(src, p + 1);
                if c2 == 61 then (3 << 16) + (2 << 8) + 2
                else 0
            } else 0
        } else 0
    }
}

fn cmp_op(op: Int, a: Int, b: Int) -> Int {
    if op == 1 then if a == b then 1 else 0
    else if op == 2 then if a != b then 1 else 0
    else if op == 3 then if a < b then 1 else 0
    else if op == 4 then if a > b then 1 else 0
    else if op == 5 then if a <= b then 1 else 0
    else if op == 6 then if a >= b then 1 else 0
    else 0
}


fn parse_pratt(src: String, pos: Int, len: Int, left: Int, min_prec: Int, e0: Int, e1: Int, e2: Int, e3: Int, elen: Int) -> Int {
    let no_left = 1 << 40;
    let pair = if left == no_left then {
        let p = skip_ws(src, pos, len);
        if p >= len then (0 << 16) + p
        else {
            let c = perform String.charAt(src, p);
            if is_digit(c) then read_int(src, p, len, 0)
            else if c == 40 then {
                let inner = parse_pratt(src, p + 1, len, no_left, 0, e0, e1, e2, e3, elen);
                let v = inner >> 16;
                let q = inner & 0xFFFF;
                let q2 = skip_ws(src, q, len);
                if q2 < len then {
                    let c2 = perform String.charAt(src, q2);
                    if c2 == 41 then (v << 16) + (q2 + 1)
                    else (v << 16) + q2
                } else (v << 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 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 = parse_pratt(src, q4 + 1, len, no_left, 0, e0, e1, e2, e3, elen);
                            let bv = bound >> 16;
                            let bp = bound & 0xFFFF;
                            let bp2 = skip_ws(src, bp, len);
                            if bp2 + 1 < len then {
                                let ci = perform String.charAt(src, bp2);
                                let cn = perform String.charAt(src, bp2 + 1);
                                if ci == 105 and cn == 110 then {
                                    let entry = (vh << 32) + bv;
                                    if elen == 0 then {
                                        parse_pratt(src, bp2 + 2, len, no_left, 0, entry, 0, 0, 0, 1)
                                    } else if elen == 1 then {
                                        parse_pratt(src, bp2 + 2, len, no_left, 0, e0, entry, 0, 0, 2)
                                    } else if elen == 2 then {
                                        parse_pratt(src, bp2 + 2, len, no_left, 0, e0, e1, entry, 0, 3)
                                    } else {
                                        parse_pratt(src, bp2 + 2, len, no_left, 0, e0, e1, e2, entry, 4)
                                    }
                                } else (bv << 16) + bp2
                            } else (bv << 16) + bp2
                        } else {
                            let v = env_lookup(e0, e1, e2, e3, elen, h);
                            (v << 16) + q
                        }
                    } else {
                        let v = env_lookup(e0, e1, e2, e3, elen, h);
                        (v << 16) + q
                    }
                } else if h == 620 then {
                    // "fn" keyword
                    let q2 = skip_ws(src, q, len);
                    if q2 < len then {
                        let c1 = perform String.charAt(src, q2);
                        if c1 == 40 then {
                            let q3 = skip_ws(src, q2 + 1, len);
                            let param_id = read_ident(src, q3, len, 0);
                            let ph = param_id >> 16;
                            let q4 = param_id & 0xFFFF;
                            let q5 = skip_ws(src, q4, len);
                            if q5 < len then {
                                let c2 = perform String.charAt(src, q5);
                                if c2 == 41 then {
                                    let q6 = skip_ws(src, q5 + 1, len);
                                    if q6 + 1 < len then {
                                        let c3 = perform String.charAt(src, q6);
                                        let c4 = perform String.charAt(src, q6 + 1);
                                        if c3 == 61 and c4 == 62 then {
                                            let body_start = q6 + 2;
                                            let body_parsed = parse_pratt(src, body_start, len, no_left, 0, e0, e1, e2, e3, elen);
                                            let body_end = body_parsed & 0xFFFF;
                                            let flag = 1 << 30;
                                            let enc = flag + (ph << 23) + (((body_start & 0x7F) << 16));
                                            let cap_data = if elen > 0 then {
                                                let cap_e = if elen >= 4 then e3
                                                else if elen >= 3 then e2
                                                else if elen >= 2 then e1
                                                else e0;
                                                let cap_h = (cap_e >> 32) & 0xFF;
                                                let cap_v = cap_e & 0xFFFF;
                                                (cap_h << 16) + cap_v
                                            } else { 0 };
                                            let cap_h = cap_data >> 16;
                                            let cap_v = cap_data & 0xFFFF;
                                            let enc2 = enc + (cap_h << 8) + (cap_v & 0xFF);
                                            (enc2 << 16) + body_end
                                        } else (0 << 16) + p
                                    } else (0 << 16) + p
                                } else (0 << 16) + p
                            } else (0 << 16) + p
                        } else (0 << 16) + p
                    } else (0 << 16) + p
                } else if h == 627 then {
                    // "if" keyword: if <cond> then <then> else <else>
                    let cond = parse_pratt(src, q, len, no_left, 0, e0, e1, e2, e3, elen);
                    let cv = cond >> 16;
                    let cp = cond & 0xFFFF;
                    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 {
                        let then_body = parse_pratt(src, tp, len, no_left, 0, e0, e1, e2, e3, elen);
                        let tv = then_body >> 16;
                        let tbp = then_body & 0xFFFF;
                        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 = parse_pratt(src, ep, len, no_left, 0, e0, e1, e2, e3, elen);
                            let ev = else_body >> 16;
                            let ebp = else_body & 0xFFFF;
                            let result = if cv != 0 then tv else ev;
                            (result << 16) + ebp
                        } else (0 << 16) + p
                    } else (0 << 16) + p
                } else if h == 18036 then {
                    (1 << 16) + q
                } else if h == 79251 then {
                    (0 << 16) + q
                } else if h == 3421 then {
                    let inner = parse_pratt(src, q, len, no_left, 0, e0, e1, e2, e3, elen);
                    let iv = inner >> 16;
                    let ip = inner & 0xFFFF;
                    let result = if iv == 0 then 1 else 0;
                    (result << 16) + ip
                } else {
                    let v = env_lookup(e0, e1, e2, e3, elen, h);
                    (v << 16) + q
                }
            } else (0 << 16) + p
        }
    } else (left << 16) + pos;

    let lv = pair >> 16;
    let lp = pair & 0xFFFF;
    let flag = 1 << 30;

    let p = skip_ws(src, lp, len);
    if p >= len then pair
    else {
        let c = perform String.charAt(src, p);
        if c == 40 then {
            let arg = parse_pratt(src, p + 1, len, no_left, 0, e0, e1, e2, e3, elen);
            let av = arg >> 16;
            let ap = arg & 0xFFFF;
            let ap2 = skip_ws(src, ap, len);
            if ap2 < len then {
                let c2 = perform String.charAt(src, ap2);
                if c2 == 41 then {
                    let result = if lv >= flag then {
                        let ph = (lv >> 23) & 0x7F;
                        let bs = (lv >> 16) & 0x7F;
                        let cap_h = (lv >> 8) & 0xFF;
                        let cap_v = lv & 0xFF;
                        let entry_param = (ph << 32) + av;
                        if cap_h == 0 then {
                            parse_pratt(src, bs, len, no_left, 0, entry_param, 0, 0, 0, 1)
                        } else {
                            let entry_cap = (cap_h << 32) + cap_v;
                            parse_pratt(src, bs, len, no_left, 0, entry_cap, entry_param, 0, 0, 2)
                        }
                    } else {
                        (lv << 16) + ap2
                    };
                    let rv = result >> 16;
                    parse_pratt(src, ap2 + 1, len, rv, min_prec, e0, e1, e2, e3, elen)
                } else pair
            } else pair
        } 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 {
                if 1 < min_prec then pair
                else {
                    let rhs = parse_pratt(src, q, len, no_left, 1, e0, e1, e2, e3, elen);
                    let rv = rhs >> 16;
                    let rp = rhs & 0xFFFF;
                    let result = if lv != 0 then if rv != 0 then 1 else 0 else 0;
                    parse_pratt(src, rp, len, result, min_prec, e0, e1, e2, e3, elen)
                }
            } else if kw == 669 then {
                if 0 < min_prec then pair
                else {
                    let rhs = parse_pratt(src, q, len, no_left, 0, e0, e1, e2, e3, elen);
                    let rv = rhs >> 16;
                    let rp = rhs & 0xFFFF;
                    let result = if lv != 0 then 1 else if rv != 0 then 1 else 0;
                    parse_pratt(src, rp, len, result, min_prec, e0, e1, e2, e3, elen)
                }
            } else pair
        } else 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 prec = cmp >> 16;
                if prec < min_prec then pair
                else {
                    let op = (cmp >> 8) & 0xFF;
                    let clen = cmp & 0xFF;
                    let rhs = parse_pratt(src, p + clen, len, no_left, prec, e0, e1, e2, e3, elen);
                    let rv = rhs >> 16;
                    let rp = rhs & 0xFFFF;
                    let result = cmp_op(op, lv, rv);
                    parse_pratt(src, rp, len, result, min_prec, e0, e1, e2, e3, elen)
                }
            }
        } else {
            let prec = prec_of(c);
            if prec == 0 or prec < min_prec then pair
            else {
                let rhs = parse_pratt(src, p + 1, len, no_left, prec, e0, e1, e2, e3, elen);
                let rv = rhs >> 16;
                let rp = rhs & 0xFFFF;
                let result = if c == 43 then lv + rv
                else if c == 45 then lv - rv
                else if c == 42 then lv * rv
                else if c == 47 then {
                    if rv == 0 then lv else lv / rv
                } else lv;
                parse_pratt(src, rp, len, result, min_prec, e0, e1, e2, e3, elen)
            }
        }
    }
}

fn parse(src: String) -> Int {
    let len = perform String.length(src);
    let result = parse_pratt(src, 0, len, 1 << 40, 0, 0, 0, 0, 0, 0);
    result >> 16
}

fn main() {
    let input = perform IO.read();
    if input == "" then {
        perform IO.print(parse("42"));
        perform IO.print(parse("1 + 2 * 3"));
        perform IO.print(parse("(1 + 2) * 3"));
        perform IO.print(parse("let x = 42 in x + 1"))
    } else {
        perform IO.print(parse(input))
    }
}