gsm 1.3.0

A very simple generic stack machine crate
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

use crate::{
    AppIO,
    Instruction,
    Script,
    Stack
};
use semver::{
    Version,
    VersionReq
};
use std::convert::From;

pub struct MachineBuilder<I: Clone>
{
    s: Script<I>,
    v: VersionReq
}

impl<I: Clone + Instruction<I>> MachineBuilder<I> {
    pub fn new() -> Self {
        Self {
            s: Script::from(Vec::new()),
            v: VersionReq::any()
        }
    }

    pub fn script(&mut self, s: &Script<I>) -> &mut Self {
        self.s = s.clone();
        self
    }

    pub fn version_req(&mut self, v: &VersionReq) -> &mut Self {
        self.v = v.clone();
        self
    }

    pub fn build(&self) -> Machine<I> {
        Machine::new(&self.s, &self.v)
    }
}

pub struct Machine<I: Clone>
{
    v: VersionReq,
    d: Stack<I>,
    r: Stack<usize>,
    s: Script<I>
}

impl<I: Clone + Instruction<I>> Machine<I>
{
    fn new(s: &Script<I>, v: &VersionReq) -> Self {
        Self {
            v: v.clone(),
            d: Stack::<I>::new(),
            r: Stack::from(vec![0]),
            s: s.clone()
        }
    }

    pub fn push(&mut self, i: I) {
        self.d.push(i);
    }

    pub fn pop(&mut self) -> Option<I> {
        self.d.pop()
    }

    pub fn pushr(&mut self, i: usize) {
        self.r.push(i);
    }

    pub fn popr(&mut self) -> Option<usize> {
        self.r.pop()
    }

    pub fn geti(&self, i: usize) -> Option<I> {
        self.s.get(i)
    }

    pub fn version_check(&self, v: &Version) -> bool {
        self.v.matches(v)
    }

    pub fn reset(&mut self) {
        self.d = Stack::<I>::new();
        self.r = Stack::<usize>::new();
        self.pushr(0);
    }

    pub fn execute(&mut self, io: &dyn AppIO<I>) -> Option<Stack<I>>
    {
        loop {
            if let Some(ip) = self.popr() {
                if let Some(instr) = self.geti(ip) {
                    instr.execute(ip, self, io);
                } else {
                    // end of script
                    return Some(self.d.clone());
                }
            } else {
                return None;
            }
        }
    }
}

impl<I: Clone> From<Script<I>> for Machine<I> {
    fn from(s: Script<I>) -> Self {
        Machine {
            v: VersionReq::any(),
            d: Stack::<I>::new(),
            r: Stack::from(vec![0]),
            s: s
        }
    }
}