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

use crate::thin::Step;
use crate::thin::Value;

pub mod processor;

use self::processor::Processor;

struct Stack<T>
where
    T: Processor,
{
    items: Vec<T::Tree>,
    processor: T,
}

impl<T> Stack<T>
where
    T: Processor,
{
    fn new(processor: T) -> Stack<T> {
        let items = vec![Default::default(); 1];
        Stack { items, processor }
    }

    fn step(&mut self, value_step: Step) {
        match value_step {
            Step::Rule(rule, start, end) => {
                self.size_stack(end as usize);
                self.items[start as usize] = self.processor.proc_rule(rule, &self.items[start as usize..=end as usize]);
            }
            Step::Token(sym, res, val) => {
                self.size_stack(res as usize);
                self.items[res as usize] = self.processor.proc_token((sym, val).into());
            }
            Step::NullingSymbol(sym, res) => {
                self.size_stack(res as usize);
                self.items[res as usize] = self.processor.proc_null(sym);
            }
            s => panic!("Invalid step: {:?}", s),
        }
    }

    fn size_stack(&mut self, last: usize) {
        let size = last + 1;
        let len = self.items.len();
        if len < size {
            self.items.reserve(size - len);
            for _ in len..size {
                self.items.push(Default::default());
            }
        }
    }

    fn proc_value(&mut self, val: &mut Value) -> &T::Tree {
        for v in val {
            self.step(v);
        }
        &self.items[0]
    }
}

pub fn proc_value<T: Processor>(eng: T, mut val: Value) -> T::Tree {
    let mut stack = Stack::new(eng);
    stack.proc_value(&mut val).clone()
}