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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

use std::mem;

use super::{
    assign,
    call,
    compare,
    identifier,
    lookup,
    math,
};

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

pub fn handle_tokens(engine: &mut Engine, tokens: &mut LineTokenIterator) -> Result<(), String> {
    if engine.stack.len() < 2 {
        return Err(format!("Expected two parameters for loop{{, found {}", engine.stack.len()));
    }

    let list = engine.stack.pop().unwrap();
    let variable = engine.stack.pop().unwrap();

    let (keys, is_cargodict) = match list {
        Stack::Variable(StackVariable::CargoDict(list_name)) => {
            if let Some(list) = engine.constants.get(&list_name) {
                let mut keys = Vec::new();
                for key in list.keys() {
                    keys.push(*key);
                }
                (keys, true)
            } else {
                return Err("Can only loop over const list/dict/cargodict".to_string());
            }
        },
        Stack::Variable(StackVariable::List(list_name)) => {
            if let Some(list) = engine.constants.get(&list_name) {
                let mut keys = Vec::new();
                for key in list.keys() {
                    keys.push(*key);
                }
                (keys, false)
            } else {
                return Err("Can only loop over const list/dict/cargodict".to_string());
            }
        },
        Stack::Variable(StackVariable::FixedList(from, to)) => {
            ((from..to).collect::<Vec<i32>>(), false)
        },
        _ => return Err("Can only loop over const list/dict/cargodict".to_string()),
    };

    let iterator = if let Stack::Iterator(iterator) = variable {
        iterator
    } else {
        return Err("Variable for loops has to be of type 'iterator'".to_string());
    };

    /* Create a new stack for this function. */
    let func_stack = mem::take(&mut engine.stack);

    /* Look through all tokens till we find a CloseBody token. */
    let mut loop_tokens = Vec::new();
    while let Some(token) = tokens.next() {
        match &token {
            Token::BodyClose => break,
            _ => loop_tokens.push(token),
        }
    }

    for key in keys {
        for token in &loop_tokens {
            match token {
                Token::BodyClose => break,

                Token::Number(number) => engine.stack.push(Stack::Number(*number)),
                Token::Identifier(identifier) => {
                    if *identifier == iterator {
                        let key = if is_cargodict {
                            if let Some(ctt) = engine.ctt.iter().find(|(_, ctt)| **ctt as i32 == key) {
                                Stack::Ctt(ctt.0.to_string())
                            } else {
                                return Err("Cargo not found in CTT.".to_string());
                            }
                        } else {
                            Stack::Number(key)
                        };
                        engine.stack.push(key)
                    } else {
                        identifier::handle_token(engine, identifier)?
                    }
                },

                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) => return Err("Cannot define a loop inside a loop".to_string()),
                Token::BodyOpen(BodyType::Def) => return Err("Cannot define a function inside a loop".to_string()),
                Token::BodyOpen(BodyType::Type) => return Err("Cannot define a type inside a loop".to_string()),

                Token::Range(_) => return Err("Cannot define a range inside a loop".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()),
            }
        }
    }
    engine.iterators.insert(iterator, None);

    /* Restore the original stack. */
    let loop_stack = mem::replace(&mut engine.stack, func_stack);

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

    engine.stack.push(Stack::Variable(StackVariable::Chain(chain)));

    Ok(())
}