truegrf 2.1.0

TrueGRF YAML to GRF compiler
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

mod assign;
mod call;
mod compare;
mod identifier;
mod lookup;
mod range;
mod r#loop;
mod math;


use std::mem;

use super::engine::{
    Engine,
    Function,
    FunctionResult,
};
use super::token::{
    BodyType,
    LineTokenIterator,
    Operator,
    Token,
};
use super::stack::{
    Chain,
    Stack,
    stack_to_lhs,
};

pub fn handle_tokens(engine: &mut Engine, tokens: &mut LineTokenIterator) -> Result<(), String> {
    if engine.stack.is_empty() {
        return Err("Unexpected keyword before 'def{{'.".to_string());
    }
    let name = engine.stack.pop().unwrap();
    let name = if let Stack::Function(name) = name {
        if engine.functions.contains_key(&name) {
            return Err(format!("Function name '{}' already exists.", name));
        }
        Ok(name)
    } else {
        Err("Unexpected keyword before 'def{{'.".to_string())
    }?;

    /* Create a new stack/result for this function. */
    let main_stack = mem::take(&mut engine.stack);
    let main_result = mem::replace(&mut engine.result, FunctionResult::new());

    /* Look through all tokens till we find a CloseBody token. */
    while let Some(token) = tokens.next() {
        match &token {
            Token::BodyClose => break,

            Token::Number(number) => engine.stack.push(Stack::Number(*number)),
            Token::Identifier(identifier) => identifier::handle_token(engine, identifier)?,
            Token::Range(range) => range::handle_token(engine, range)?,

            Token::Operator(Operator::Math(math)) => math::handle_token(engine, math)?,
            Token::Operator(Operator::Compare(compare)) => compare::handle_token(engine, compare)?,
            Token::Operator(Operator::Assign) => assign::handle_token(engine)?,
            Token::Operator(Operator::Lookup) => lookup::handle_token(engine)?,
            Token::Operator(Operator::Call) => call::handle_token(engine)?,

            Token::BodyOpen(BodyType::Loop) => r#loop::handle_tokens(engine, tokens)?,

            Token::BodyOpen(BodyType::Def) => return Err("Cannot define a function inside a function".to_string()),
            Token::BodyOpen(BodyType::Type) => return Err("Cannot define a type inside a function".to_string()),

            Token::Type(_) => return Err("Unexpected keyword".to_string()),
            Token::Scope(_) => return Err("Unexpected keyword".to_string()),
            Token::Comment(_) => return Err("Unexpected keyword".to_string()),
        }
    }

    /* Restore the original stack and result. */
    let func_stack = mem::replace(&mut engine.stack, main_stack);
    let func_result = mem::replace(&mut engine.result, main_result);

    /* Convert everything on the stack to a single chain. */
    let mut chain = Chain::new();
    for stack in func_stack {
        chain.extend(stack_to_lhs(stack)?);
    }
    if !chain.switch.is_empty() {
        return Err("Switch statements are not supported in functions".to_string());
    }

    /* Create the function result. */
    let function = Function {
        result: func_result,
        chain,
    };
    engine.functions.insert(name, function);

    Ok(())
}