parser.aelys

// i'm stupid and haven't got struct properly working on aelys.. the actual parsing is done inline during the codegen.
// those are just parsing utilities used by the codegen

needs std.string as str
needs std.convert as convert
needs words

// tokens is a Vec of ["type", "value"] arrays
pub fn tok_type(tokens, idx) {
    if idx >= tokens.len() {
        return "eof"
    }
    return tokens[idx][0]
}

pub fn tok_val(tokens, idx) {
    if idx >= tokens.len() {
        return ""
    }
    return tokens[idx][1]
}

pub fn split_to_vec(s, delim) {
    let result = Vec["_"]
    result.pop()
    let dlen = str.len(delim)
    let slen = str.len(s)
    if slen == 0 {
        return result
    }
    let mut start = 0
    let mut i = 0
    while i <= slen - dlen {
        if str.substr(s, i, dlen) == delim {
            result.push(str.substr(s, start, i - start))
            start = i + dlen
            i = start
        } else {
            i = i + 1
        }
    }
    result.push(str.substr(s, start, slen - start))
    return result
}

// collect sentence words from token returns a vec of words string
pub fn collect_sentence_words(tokens, pos) {
    let wds = Vec["_"]
    wds.pop()
    while pos[0] < tokens.len() {
        let t = tok_type(tokens, pos[0])
        if t == "word" {
            wds.push(tok_val(tokens, pos[0]))
            pos[0] = pos[0] + 1
        } else if t == "comma" {
            pos[0] = pos[0] + 1
        } else if t == "period" or t == "exclamation" or t == "question" {
            pos[0] = pos[0] + 1
            break
        } else {
            break
        }
    }
    return wds
}

// noun phrase eval, starting at wds[wi[0]] and returns the int value + modifies wi[0]
pub fn eval_noun_phrase(wds, wi) {
    let mut adj_count = 0

    // skip articles
    while wi[0] < wds.len() {
        if words.is_article(wds[wi[0]]) {
            wi[0] = wi[0] + 1
        } else {
            break
        }
    }

    // adjectives
    while wi[0] < wds.len() {
        if words.is_adjective(wds[wi[0]]) {
            adj_count = adj_count + 1
            wi[0] = wi[0] + 1
        } else {
            break
        }
    }

    // noun
    let mut base = 1
    if wi[0] < wds.len() {
        if words.is_noun(wds[wi[0]]) {
            base = words.noun_value(wds[wi[0]])
            wi[0] = wi[0] + 1
        } else if words.is_nothing(wds[wi[0]]) {
            wi[0] = wi[0] + 1
            return 0
        }
    }

    // calculate base * 2^adj_count
    let mut value = base
    let mut j = 0
    while j < adj_count {
        value = value * 2
        j = j + 1
    }

    return value
}

// roman numeral parser for goto scene numbers
pub fn parse_roman(s) {
    let mut result = 0
    let mut i = 0
    let n = str.len(s)
    while i < n {
        let c = str.substr(s, i, 1)
        if c == "i" {
            if i + 1 < n and str.substr(s, i + 1, 1) == "v" {
                result = result + 4
                i = i + 2
            } else if i + 1 < n and str.substr(s, i + 1, 1) == "x" {
                result = result + 9
                i = i + 2
            } else {
                result = result + 1
                i = i + 1
            }
        } else if c == "v" {
            result = result + 5
            i = i + 1
        } else if c == "x" {
            result = result + 10
            i = i + 1
        } else {
            i = i + 1
        }
    }
    if result == 0 { result = 1 }
    return result
}

pub fn words_match(wds, i, w1) {
    if i >= wds.len() { return false }
    return wds[i] == w1
}

pub fn words_match2(wds, i, w1, w2) {
    if i + 1 >= wds.len() { return false }
    return wds[i] == w1 and wds[i + 1] == w2
}

pub fn words_match3(wds, i, w1, w2, w3) {
    if i + 2 >= wds.len() { return false }
    return wds[i] == w1 and wds[i + 1] == w2 and wds[i + 2] == w3
}

pub fn words_match4(wds, i, w1, w2, w3, w4) {
    if i + 3 >= wds.len() { return false }
    return wds[i] == w1 and wds[i + 1] == w2 and wds[i + 2] == w3 and wds[i + 3] == w4
}