codegen.aelys

// codegen module
// this just parses tokens and generates llvm ir in one pass

needs std.string
needs std.convert
needs words
needs parser

// mutable state, stored in vecs for mutability
let ssa = Vec[0]
let lbl = Vec[0]
let on_stage = Vec["_"]
let cur_speaker = Vec[""]
let cur_act = Vec[1]
let char_names = Vec["_"]

fn init_stage() {
    on_stage.pop()
}

fn next_reg() {
    let r = "%t" + to_string(ssa[0])
    ssa[0] = ssa[0] + 1
    return r
}

fn next_label(prefix) {
    let l = prefix + "_" + to_string(lbl[0])
    lbl[0] = lbl[0] + 1
    return l
}

// capitalize each word and join with underscores for valid llvm identifiers
fn capitalize(name) {
    if len(name) == 0 { return name }

    let mut result = ""
    let mut i = 0
    let n = len(name)
    let mut word_start = true

    while i < n {
        let c = substr(name, i, 1)
        if c == " " {
            result = result + "_"
            word_start = true
        } else if word_start {
            result = result + to_upper(c)
            word_start = false
        } else {
            result = result + c
            word_start = false
        }
        i = i + 1
    }
    return result
}

fn get_addressee() {
    let speaker = cur_speaker[0]
    let mut i = 0
    while i < on_stage.len() {
        if on_stage[i] != speaker {
            return on_stage[i]
        }
        i = i + 1
    }
    if on_stage.len() > 0 {
        return on_stage[0]
    }
    return "unknown"
}

fn stage_enter(name) {
    let mut found = false
    let mut i = 0
    while i < on_stage.len() {
        if on_stage[i] == name {
            found = true
            break
        }
        i = i + 1
    }
    if not found {
        on_stage.push(name)
    }
}

fn stage_exit(name) {
    let keep = Vec["_"]
    keep.pop()
    let mut i = 0
    while i < on_stage.len() {
        if on_stage[i] != name {
            keep.push(on_stage[i])
        }
        i = i + 1
    }
    while on_stage.len() > 0 { on_stage.pop() }
    let mut j = 0
    while j < keep.len() {
        on_stage.push(keep[j])
        j = j + 1
    }
}

fn stage_clear() {
    while on_stage.len() > 0 { on_stage.pop() }
}

fn gen_char_globals(name) {
    let cap = capitalize(name)
    let mut ir = "@" + cap + " = global i64 0\n"
    ir = ir + "@" + cap + "_stack = global [256 x i64] zeroinitializer\n"
    ir = ir + "@" + cap + "_sp = global i64 0\n"
    return ir
}

// !!
// this is the messy part, this generates llvm ir for a v alue expression from words
// returns [ir_code, result_register] as an array, wds is a vec of word strings, and wi is vec[int] for positions
fn gen_value(wds, wi) {
    if wi[0] >= wds.len() {
        let r = next_reg()
        return ["  " + r + " = add i64 0, 0\n", r]
    }

    // skip "as [adj] as" pattern (for exampel "thou art as fair as [value]")
    if wi[0] + 2 < wds.len() and wds[wi[0]] == "as" {
        wi[0] = wi[0] + 1
        // skip adjectives
        while wi[0] < wds.len() and words.is_adjective(wds[wi[0]]) {
            wi[0] = wi[0] + 1
        }
        // skip second "as"
        if wi[0] < wds.len() and wds[wi[0]] == "as" {
            wi[0] = wi[0] + 1
        }
        return gen_value(wds, wi)
    }

    let w = wds[wi[0]]

    // nothing / zero
    if words.is_nothing(w) {
        wi[0] = wi[0] + 1
        let r = next_reg()
        return ["  " + r + " = add i64 0, 0\n", r]
    }

    // first person (speaker)
    if words.is_first_person(w) {
        wi[0] = wi[0] + 1
        let spk = capitalize(cur_speaker[0])
        let r = next_reg()
        return ["  " + r + " = load i64, i64* @" + spk + "\n", r]
    }

    // Second person (addresse), but check if it's a possessive followed by a noun (like thy cat)
    if words.is_second_person(w) {
        let is_possessive = (w == "thy" or w == "your" or w == "thine")
        let mut followed_by_noun = false

        if is_possessive and wi[0] + 1 < wds.len() {
            // if the next word is a noun
            let mut check_i = wi[0] + 1
            while check_i < wds.len() and words.is_adjective(wds[check_i]) {
                check_i = check_i + 1
            }
            if check_i < wds.len() and words.is_noun(wds[check_i]) {
                followed_by_noun = true
            }
        }

        if not followed_by_noun {
            // it's a pronoun, so we load addressee
            wi[0] = wi[0] + 1
            let addr = capitalize(get_addressee())
            let r = next_reg()
            return ["  " + r + " = load i64, i64* @" + addr + "\n", r]
        }
        // else: it's possessive article
    }

    // character name reference (single word or multi-word)
    let mut ci = 0
    while ci < char_names.len() {
        let cname = char_names[ci]
        // if current position matches this character name
        let cname_words = parser.split_to_vec(cname, " ")
        let mut match_found = true
        let mut cw = 0
        while cw < cname_words.len() {
            if wi[0] + cw >= wds.len() or wds[wi[0] + cw] != cname_words[cw] {
                match_found = false
                break
            }
            cw = cw + 1
        }
        if match_found {
            wi[0] = wi[0] + cname_words.len()
            let char_cap = capitalize(cname)
            let r = next_reg()
            return ["  " + r + " = load i64, i64* @" + char_cap + "\n", r]
        }
        ci = ci + 1
    }

    if parser.words_match3(wds, wi[0], "the", "sum", "of") {
        wi[0] = wi[0] + 3
        let v1 = gen_value(wds, wi)
        if wi[0] < wds.len() and wds[wi[0]] == "and" { wi[0] = wi[0] + 1 }
        let v2 = gen_value(wds, wi)
        let r = next_reg()
        return [v1[0] + v2[0] + "  " + r + " = add i64 " + v1[1] + ", " + v2[1] + "\n", r]
    }

    if parser.words_match3(wds, wi[0], "the", "difference", "between") {
        wi[0] = wi[0] + 3
        let v1 = gen_value(wds, wi)
        if wi[0] < wds.len() and wds[wi[0]] == "and" { wi[0] = wi[0] + 1 }
        let v2 = gen_value(wds, wi)
        let r = next_reg()
        return [v1[0] + v2[0] + "  " + r + " = sub i64 " + v1[1] + ", " + v2[1] + "\n", r]
    }

    if parser.words_match3(wds, wi[0], "the", "product", "of") {
        wi[0] = wi[0] + 3
        let v1 = gen_value(wds, wi)
        if wi[0] < wds.len() and wds[wi[0]] == "and" { wi[0] = wi[0] + 1 }
        let v2 = gen_value(wds, wi)
        let r = next_reg()
        return [v1[0] + v2[0] + "  " + r + " = mul i64 " + v1[1] + ", " + v2[1] + "\n", r]
    }

    if parser.words_match3(wds, wi[0], "the", "quotient", "between") {
        wi[0] = wi[0] + 3
        let v1 = gen_value(wds, wi)
        if wi[0] < wds.len() and wds[wi[0]] == "and" { wi[0] = wi[0] + 1 }
        let v2 = gen_value(wds, wi)
        let r = next_reg()
        return [v1[0] + v2[0] + "  " + r + " = sdiv i64 " + v1[1] + ", " + v2[1] + "\n", r]
    }

    if parser.words_match4(wds, wi[0], "the", "remainder", "of", "the") {
        wi[0] = wi[0] + 4
        if wi[0] < wds.len() and wds[wi[0]] == "quotient" { wi[0] = wi[0] + 1 }
        if wi[0] < wds.len() and wds[wi[0]] == "between" { wi[0] = wi[0] + 1 }
        let v1 = gen_value(wds, wi)
        if wi[0] < wds.len() and wds[wi[0]] == "and" { wi[0] = wi[0] + 1 }
        let v2 = gen_value(wds, wi)
        let r = next_reg()
        return [v1[0] + v2[0] + "  " + r + " = srem i64 " + v1[1] + ", " + v2[1] + "\n", r]
    }

    if w == "twice" {
        wi[0] = wi[0] + 1
        let v = gen_value(wds, wi)
        let r = next_reg()
        return [v[0] + "  " + r + " = mul i64 " + v[1] + ", 2\n", r]
    }

    if parser.words_match3(wds, wi[0], "the", "square", "of") {
        wi[0] = wi[0] + 3
        let v = gen_value(wds, wi)
        let r = next_reg()
        return [v[0] + "  " + r + " = mul i64 " + v[1] + ", " + v[1] + "\n", r]
    }

    if parser.words_match3(wds, wi[0], "the", "cube", "of") {
        wi[0] = wi[0] + 3
        let v = gen_value(wds, wi)
        let r1 = next_reg()
        let r2 = next_reg()
        let mut ir = v[0] + "  " + r1 + " = mul i64 " + v[1] + ", " + v[1] + "\n"
        ir = ir + "  " + r2 + " = mul i64 " + r1 + ", " + v[1] + "\n"
        return [ir, r2]
    }

    if parser.words_match4(wds, wi[0], "the", "square", "root", "of") {
        wi[0] = wi[0] + 4
        let v = gen_value(wds, wi)
        let r = next_reg()
        return [v[0] + "  " + r + " = call i64 @spl_sqrt(i64 " + v[1] + ")\n", r]
    }

    if parser.words_match3(wds, wi[0], "the", "factorial", "of") {
        wi[0] = wi[0] + 3
        let v = gen_value(wds, wi)
        let r = next_reg()
        return [v[0] + "  " + r + " = call i64 @spl_factorial(i64 " + v[1] + ")\n", r]
    }

    // noun phrase (article/adjective/noun)
    if words.is_article(w) or words.is_adjective(w) or words.is_noun(w) {
        let val = parser.eval_noun_phrase(wds, wi)
        let r = next_reg()
        return ["  " + r + " = add i64 0, " + to_string(val) + "\n", r]
    }

    // skip unknown word & try again
    wi[0] = wi[0] + 1
    if wi[0] < wds.len() {
        return gen_value(wds, wi)
    }
    let r = next_reg()
    return ["  " + r + " = add i64 0, 0\n", r]
}


// generate llvm ir for a sentence
fn gen_sentence(wds) {
    if wds.len() == 0 {
        return ""
    }

    let addr = capitalize(get_addressee())

    // "you/thou <adj>* <noun>!" -> simple assignment without verb
    if wds.len() >= 2 {
        if (parser.words_match(wds, 0, "you") or parser.words_match(wds, 0, "thou")) {
            // check it's not "you are/thou art/thou be" (handled below)
            if not (parser.words_match(wds, 1, "art") or parser.words_match(wds, 1, "are") or parser.words_match(wds, 1, "be")) {
                // parse value starting AFTER "you/thou" (word 1) to avoid pronoun handling
                let wi = Vec[1]
                let old_i = wi[0]
                let val = gen_value(wds, wi)
                // if we consumed at least one word and found a value, it's an assignment
                if wi[0] > old_i {
                    return val[0] + "  store i64 " + val[1] + ", i64* @" + addr + "\n"
                }
            }
        }
    }

    // "thou art" "you are" thou be" -> assignment
    if wds.len() >= 2 {
        if parser.words_match2(wds, 0, "thou", "art") or parser.words_match2(wds, 0, "you", "are") or parser.words_match2(wds, 0, "thou", "be") {
            let wi = Vec[2]
            let val = gen_value(wds, wi)
            return val[0] + "  store i64 " + val[1] + ", i64* @" + addr + "\n"
        }
    }

    // "speak your/thy mind" , output char
    if wds.len() >= 3 {
        if parser.words_match(wds, 0, "speak") and (parser.words_match(wds, 1, "your") or parser.words_match(wds, 1, "thy")) and parser.words_match(wds, 2, "mind") {
            let r1 = next_reg()
            let r2 = next_reg()
            let r3 = next_reg()
            let mut ir = "  " + r1 + " = load i64, i64* @" + addr + "\n"
            ir = ir + "  " + r2 + " = trunc i64 " + r1 + " to i32\n"
            ir = ir + "  " + r3 + " = call i32 @putchar(i32 " + r2 + ")\n"
            return ir
        }
    }

    // "open your/thy heart", output num
    if wds.len() >= 3 {
        if parser.words_match(wds, 0, "open") and (parser.words_match(wds, 1, "your") or parser.words_match(wds, 1, "thy")) and parser.words_match(wds, 2, "heart") {
            let r1 = next_reg()
            let r2 = next_reg()
            let mut ir = "  " + r1 + " = load i64, i64* @" + addr + "\n"
            ir = ir + "  " + r2 + " = call i32 (i8*, ...) @printf(i8* getelementptr ([5 x i8], [5 x i8]* @fmt_int, i64 0, i64 0), i64 " + r1 + ")\n"
            return ir

        }
    }

    // "open your/thy mind" -> input char
    if wds.len() >= 3 {
        if parser.words_match(wds, 0, "open") and (parser.words_match(wds, 1, "your") or parser.words_match(wds, 1, "thy")) and parser.words_match(wds, 2, "mind") {
            let r1 = next_reg()
            let r2 = next_reg()
            let mut ir = "  " + r1 + " = call i32 @getchar()\n"
            ir = ir + "  " + r2 + " = sext i32 " + r1 + " to i64\n"
            ir = ir + "  store i64 " + r2 + ", i64* @" + addr + "\n"
            return ir
        }
    }

    // "listen to your/thy heart" -> input num
    if wds.len() >= 4 {
        if parser.words_match(wds, 0, "listen") and parser.words_match(wds, 1, "to") and (parser.words_match(wds, 2, "your") or parser.words_match(wds, 2, "thy")) and parser.words_match(wds, 3, "heart") {
            let r1 = next_reg()
            let r2 = next_reg()
            let r3 = next_reg()
            let mut ir = "  " + r1 + " = alloca i64\n"
            ir = ir + "  " + r2 + " = call i32 (i8*, ...) @scanf(i8* getelementptr ([5 x i8], [5 x i8]* @fmt_scan, i64 0, i64 0), i64* " + r1 + ")\n"
            ir = ir + "  " + r3 + " = load i64, i64* " + r1 + "\n"
            ir = ir + "  store i64 " + r3 + ", i64* @" + addr + "\n"
            return ir
        }
    }

    // "remember" -> push
    if parser.words_match(wds, 0, "remember") {
        let wi = Vec[1]
        let val = gen_value(wds, wi)
        let sp = next_reg()
        let ptr = next_reg()
        let sp_new = next_reg()
        let mut ir = val[0]

        ir = ir + "  " + sp + " = load i64, i64* @" + addr + "_sp\n"
        ir = ir + "  " + ptr + " = getelementptr [256 x i64], [256 x i64]* @" + addr + "_stack, i64 0, i64 " + sp + "\n"
        ir = ir + "  store i64 " + val[1] + ", i64* " + ptr + "\n"
        ir = ir + "  " + sp_new + " = add i64 " + sp + ", 1\n"
        ir = ir + "  store i64 " + sp_new + ", i64* @" + addr + "_sp\n"
        return ir
    }

    // "recall" -> pop with bounds check if sp==0 use index 0 and don't decrement
    if parser.words_match(wds, 0, "recall") {
        let sp = next_reg()
        let sp_clamped = next_reg()
        let sp_new = next_reg()
        let ptr = next_reg()
        let val = next_reg()
        let cmp_zero = next_reg()
        let zero = next_reg()

        let mut ir = "  " + sp + " = load i64, i64* @" + addr + "_sp\n"
        // clamp sp to minimum 1 before subtracting otherwise good luck
        ir = ir + "  " + cmp_zero + " = icmp eq i64 " + sp + ", 0\n"
        ir = ir + "  " + zero + " = add i64 0, 1\n"
        ir = ir + "  " + sp_clamped + " = select i1 " + cmp_zero + ", i64 " + zero + ", i64 " + sp + "\n"
        ir = ir + "  " + sp_new + " = sub i64 " + sp_clamped + ", 1\n"
        ir = ir + "  store i64 " + sp_new + ", i64* @" + addr + "_sp\n"
        ir = ir + "  " + ptr + " = getelementptr [256 x i64], [256 x i64]* @" + addr + "_stack, i64 0, i64 " + sp_new + "\n"
        ir = ir + "  " + val + " = load i64, i64* " + ptr + "\n"
        ir = ir + "  store i64 " + val + ", i64* @" + addr + "\n"
        return ir
    }

    // "let us" "we shall" "we must" is a goto
    if wds.len() >= 2 {
        if parser.words_match2(wds, 0, "let", "us") or parser.words_match2(wds, 0, "we", "shall") or parser.words_match2(wds, 0, "we", "must") {
            let mut si = 2
            while si < wds.len() {
                if wds[si] == "scene" {
                    si = si + 1
                    let mut roman = ""
                    while si < wds.len() {
                        roman = roman + wds[si]
                        si = si + 1
                    }
                    let scene_num = parser.parse_roman(roman)
                    let label = "act" + to_string(cur_act[0]) + "_scene" + to_string(scene_num)
                    return "  br label %" + label + "\n"
                }
                si = si + 1
            }
            return ""
        }
    }

    // QUESTIONS STUFF
    // we just need to look for comparison patterns, like :
    // "better"/"worse"
    // "more [adj] than" (positive adj -> sgt, negative adj -> slt)
    // "as [adj] as"equality
    // "not" before the comparison keyword negate the result

    // "art thou" pattern (question with addressee as subject)
    let is_art_thou = wds.len() >= 2 and parser.words_match2(wds, 0, "art", "thou")
    let is_am_i = wds.len() >= 2 and parser.words_match2(wds, 0, "am", "i")
    let is_is_remainder = wds.len() >= 2 and parser.words_match2(wds, 0, "is", "the")

    // "as [adj] as" equality pattern
    let mut eq_qi = 0
    let mut found_eq = false
    let mut eq_after = 0
    while eq_qi + 2 < wds.len() {
        if wds[eq_qi] == "as" and wds[eq_qi + 2] == "as" and words.is_adjective(wds[eq_qi + 1]) {
            found_eq = true
            eq_after = eq_qi + 3
            break
        }
        eq_qi = eq_qi + 1
    }

    if found_eq {
        // LHS == RHS

        // "am i as X as Y" → subject is speaker (i)
        // "art thou as X as Y" → subject is addressee (thou)
        // "is X as Y as Z" → subject is X
        let mut v1_ir = ""
        let mut v1_reg = ""

        if is_am_i {
            let spk = capitalize(cur_speaker[0])
            let r = next_reg()
            v1_ir = "  " + r + " = load i64, i64* @" + spk + "\n"
            v1_reg = r
        } else if is_art_thou {
            let addr = capitalize(get_addressee())
            let r = next_reg()
            v1_ir = "  " + r + " = load i64, i64* @" + addr + "\n"
            v1_reg = r
        } else {
            // parse subject from beginning of sentence
            let wi1 = Vec[0]
            let v1 = gen_value(wds, wi1)
            v1_ir = v1[0]
            v1_reg = v1[1]
        }

        let wi2 = Vec[eq_after]
        let v2 = gen_value(wds, wi2)
        let cmp_reg = next_reg()
        let mut ir = v1_ir + v2[0]
        ir = ir + "  " + cmp_reg + " = icmp eq i64 " + v1_reg + ", " + v2[1] + "\n"
        ir = ir + "  store i1 " + cmp_reg + ", i1* @global_bool\n"
        return ir
    }

    let mut qi = 0
    let mut found_cmp = false
    let mut cmp_op = ""
    let mut has_not = false
    let mut cmp_after = 0

    while qi < wds.len() {
        if wds[qi] == "not" {
            has_not = true
            qi = qi + 1
            continue
        }
        if wds[qi] == "better" {
            found_cmp = true
            cmp_op = "sgt"
            cmp_after = qi + 1
            break
        }
        if wds[qi] == "worse" {
            found_cmp = true
            cmp_op = "slt"
            cmp_after = qi + 1
            break
        }
        if wds[qi] == "more" and qi + 1 < wds.len() and words.is_adjective(wds[qi + 1]) {
            found_cmp = true
            if words.is_positive_adj(wds[qi + 1]) or words.is_neutral_adj(wds[qi + 1]) {
                cmp_op = "sgt"
            } else {
                cmp_op = "slt"
            }
            cmp_after = qi + 2
            break
        }
        qi = qi + 1
    }

    if has_not and found_cmp {
        if cmp_op == "sgt" {
            cmp_op = "sle"
        } else if cmp_op == "slt" {
            cmp_op = "sge"
        }
    }

    if found_cmp {
        // justt to determine the subject of the comparison
        // "am i X than Y" → subject is speaker (i)
        // "art thou X than Y" → subject is addressee (thou)
        // "is X Y than Z" → subject is X
        let mut v1_ir = ""
        let mut v1_reg = ""

        if is_am_i {
            let spk = capitalize(cur_speaker[0])
            let r = next_reg()
            v1_ir = "  " + r + " = load i64, i64* @" + spk + "\n"
            v1_reg = r
        } else if is_art_thou {
            let addr = capitalize(get_addressee())
            let r = next_reg()
            v1_ir = "  " + r + " = load i64, i64* @" + addr + "\n"
            v1_reg = r
        } else {
            let wi1 = Vec[0]
            let v1 = gen_value(wds, wi1)
            v1_ir = v1[0]
            v1_reg = v1[1]
        }

        let mut ti = cmp_after
        if ti < wds.len() and wds[ti] == "than" { ti = ti + 1 }
        let wi2 = Vec[ti]
        let v2 = gen_value(wds, wi2)
        let cmp_reg = next_reg()
        let mut ir = v1_ir + v2[0]
        ir = ir + "  " + cmp_reg + " = icmp " + cmp_op + " i64 " + v1_reg + ", " + v2[1] + "\n"
        ir = ir + "  store i1 " + cmp_reg + ", i1* @global_bool\n"
        return ir
    }

    // "if so" conditional
    if wds.len() >= 2 and parser.words_match2(wds, 0, "if", "so") {
        let inner_wds = Vec["_"]
        inner_wds.pop()
        let mut iw = 2
        while iw < wds.len() {
            inner_wds.push(wds[iw])
            iw = iw + 1
        }
        let inner_ir = gen_sentence(inner_wds)
        if len(inner_ir) > 0 {
            let bool_reg = next_reg()
            let then_lbl = next_label("if_then")
            let end_lbl = next_label("if_end")
            let mut ir = "  " + bool_reg + " = load i1, i1* @global_bool\n"
            ir = ir + "  br i1 " + bool_reg + ", label %" + then_lbl + ", label %" + end_lbl + "\n"
            ir = ir + then_lbl + ":\n"
            ir = ir + inner_ir
            if not contains(inner_ir, "br label %") {
                ir = ir + "  br label %" + end_lbl + "\n"
            }
            ir = ir + end_lbl + ":\n"
            return ir
        }
    }

    // "if not" conditional but negated
    if wds.len() >= 2 and parser.words_match2(wds, 0, "if", "not") {
        let inner_wds = Vec["_"]
        inner_wds.pop()
        let mut iw = 2
        while iw < wds.len() {
            inner_wds.push(wds[iw])
            iw = iw + 1
        }
        let inner_ir = gen_sentence(inner_wds)
        if len(inner_ir) > 0 {
            let bool_reg = next_reg()
            let then_lbl = next_label("if_then")
            let end_lbl = next_label("if_end")
            let mut ir = "  " + bool_reg + " = load i1, i1* @global_bool\n"
            ir = ir + "  br i1 " + bool_reg + ", label %" + end_lbl + ", label %" + then_lbl + "\n"
            ir = ir + then_lbl + ":\n"
            ir = ir + inner_ir
            if not contains(inner_ir, "br label %") {
                ir = ir + "  br label %" + end_lbl + "\n"
            }
            ir = ir + end_lbl + ":\n"
            return ir
        }
    }

    return ""
}

fn scene_label(act_num, scene_num) {
    return "act" + to_string(act_num) + "_scene" + to_string(scene_num)
}


fn gen_preamble(char_names) {
    let mut ir = "; SPL -> LLVM IR (compiled by Aelys SPL compiler)\n\n"

    ir = ir + "; --- Character globals ---\n"
    let mut i = 0
    while i < char_names.len() {
        ir = ir + gen_char_globals(char_names[i])
        i = i + 1
    }
    ir = ir + "\n"

    ir = ir + "@global_bool = global i1 false\n\n"

    ir = ir + "; --- Format strings ---\n"
    ir = ir + "@fmt_int = private constant [5 x i8] c\"%lld\\00\"\n"
    ir = ir + "@fmt_scan = private constant [5 x i8] c\"%lld\\00\"\n\n"

    ir = ir + "; --- External declarations ---\n"
    ir = ir + "declare i32 @putchar(i32)\n"
    ir = ir + "declare i32 @getchar()\n"
    ir = ir + "declare i32 @printf(i8*, ...)\n"
    ir = ir + "declare i32 @scanf(i8*, ...)\n"
    ir = ir + "declare double @llvm.sqrt.f64(double)\n\n"

    ir = ir + "; --- Helper functions ---\n"
    ir = ir + "define i64 @spl_sqrt(i64 %n) {{\n"
    ir = ir + "  %f = sitofp i64 %n to double\n"
    ir = ir + "  %s = call double @llvm.sqrt.f64(double %f)\n"
    ir = ir + "  %r = fptosi double %s to i64\n"
    ir = ir + "  ret i64 %r\n"
    ir = ir + "}}\n\n"

    ir = ir + "define i64 @spl_factorial(i64 %n) {{\n"
    ir = ir + "entry:\n"
    ir = ir + "  %cmp = icmp sle i64 %n, 1\n"
    ir = ir + "  br i1 %cmp, label %base, label %recurse\n"
    ir = ir + "base:\n"
    ir = ir + "  ret i64 1\n"
    ir = ir + "recurse:\n"
    ir = ir + "  %n1 = sub i64 %n, 1\n"
    ir = ir + "  %f = call i64 @spl_factorial(i64 %n1)\n"
    ir = ir + "  %r = mul i64 %n, %f\n"
    ir = ir + "  ret i64 %r\n"
    ir = ir + "}}\n\n"

    return ir
}


// this is where tokens vec -> llvm ir basically the main entry point
pub fn generate(tokens) {
    // reset the state
    ssa[0] = 0
    lbl[0] = 0
    stage_clear()
    cur_speaker[0] = ""
    cur_act[0] = 1
    while char_names.len() > 0 { char_names.pop() }

    let pos = Vec[0]

    // first of all : parse title
    if parser.tok_type(tokens, pos[0]) == "title" {
        pos[0] = pos[0] + 1
    }

    // then:  parse character declarations
    while parser.tok_type(tokens, pos[0]) == "char_decl" {
        char_names.push(parser.tok_val(tokens, pos[0]))
        pos[0] = pos[0] + 1
    }

    // look scene structure collect acT/scene numbers
    let scene_info = Vec["_"]
    scene_info.pop()
    let mut scan_pos = pos[0]
    let mut scan_act = 1
    while scan_pos < tokens.len() {
        let st = parser.tok_type(tokens, scan_pos)
        if st == "act" {
            scan_act = parse_int(parser.tok_val(tokens, scan_pos))
        }
        if st == "scene" {
            let sn = parse_int(parser.tok_val(tokens, scan_pos))
            scene_info.push(to_string(scan_act) + ":" + to_string(sn))
        }
        scan_pos = scan_pos + 1
    }

    // preamble
    let mut ir = gen_preamble(char_names)

    // the main function
    ir = ir + "; --- Main ---\n"
    ir = ir + "define i32 @main() {{\n"
    ir = ir + "entry:\n"

    // branch to first scene
    if scene_info.len() > 0 {
        let first = scene_info[0]
        let colon = find(first, ":")
        let fa = substr(first, 0, colon)
        let fs = substr(first, colon + 1, len(first) - colon - 1)
        ir = ir + "  br label %" + scene_label(parse_int(fa), parse_int(fs)) + "\n\n"
    } else {
        ir = ir + "  br label %program_end\n\n"
    }

    let mut current_act_num = 0
    let mut current_scene_num = 0
    let mut scene_idx = 0
    let mut need_scene_branch = false

    while pos[0] < tokens.len() {
        let tt = parser.tok_type(tokens, pos[0])

        if tt == "eof" {
            break
        }

        if tt == "act" {
            current_act_num = parse_int(parser.tok_val(tokens, pos[0]))
            cur_act[0] = current_act_num
            ir = ir + "; === Act " + to_string(current_act_num) + " ===\n"
            pos[0] = pos[0] + 1
            continue
        }

        if tt == "scene" {
            if need_scene_branch {
                ir = ir + "  br label %" + scene_label(current_act_num, parse_int(parser.tok_val(tokens, pos[0]))) + "\n\n"
            }

            current_scene_num = parse_int(parser.tok_val(tokens, pos[0]))
            ir = ir + scene_label(current_act_num, current_scene_num) + ":\n"
            scene_idx = scene_idx + 1
            need_scene_branch = true
            pos[0] = pos[0] + 1
            continue
        }

        if tt == "enter" {
            let names_str = parser.tok_val(tokens, pos[0])
            let cleaned = replace(names_str, " and ", ",")
            let parts = parser.split_to_vec(cleaned, ",")
            let mut ni = 0
            while ni < parts.len() {
                let name = trim(parts[ni])
                if len(name) > 0 {
                    stage_enter(name)
                }
                ni = ni + 1
            }
            ir = ir + "  ; enter\n"
            pos[0] = pos[0] + 1
            continue
        }

        if tt == "exit" {
            let name = trim(parser.tok_val(tokens, pos[0]))
            stage_exit(name)
            ir = ir + "  ; exit " + name + "\n"
            pos[0] = pos[0] + 1
            continue
        }

        if tt == "exeunt" {
            let names_str = parser.tok_val(tokens, pos[0])
            if len(trim(names_str)) == 0 {
                stage_clear()
            } else {
                let cleaned = replace(names_str, " and ", ",")
                let parts = parser.split_to_vec(cleaned, ",")
                let mut ni = 0
                while ni < parts.len() {
                    let name = trim(parts[ni])
                    if len(name) > 0 {
                        stage_exit(name)
                    }
                    ni = ni + 1
                }
            }
            ir = ir + "  ; exeunt\n"
            pos[0] = pos[0] + 1
            continue
        }

        if tt == "speaker" {
            let speaker = parser.tok_val(tokens, pos[0])
            cur_speaker[0] = speaker
            ir = ir + "  ; " + speaker + " speaks\n"
            pos[0] = pos[0] + 1

            // process dialogue sentences
            while pos[0] < tokens.len() {
                let st = parser.tok_type(tokens, pos[0])
                if st == "act" or st == "scene" or st == "enter" or st == "exit" or st == "exeunt" or st == "speaker" or st == "eof" {
                    break
                }
                if st == "word" or st == "comma" {
                    let sentence_words = parser.collect_sentence_words(tokens, pos)
                    if sentence_words.len() > 0 {
                        let sent_ir = gen_sentence(sentence_words)
                        ir = ir + sent_ir
                        if contains(sent_ir, "br label %act") and not contains(sent_ir, "if_then") {
                            need_scene_branch = false
                        }
                    }
                } else {
                    pos[0] = pos[0] + 1
                }
            }
            continue
        }

        pos[0] = pos[0] + 1
    }

    if need_scene_branch {
        ir = ir + "  br label %program_end\n\n"
    }

    ir = ir + "program_end:\n"
    ir = ir + "  ret i32 0\n"
    ir = ir + "}}\n"

    return ir
} // my god.