osiris-process 0.3.1

A processor implementation.
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

use osiris_data::data::atomic::Word;

#[derive(Copy, Clone, Eq, PartialEq)]
pub enum Compare {
    LT,
    LE,
    NE,
    EQ,
    GE,
    GT,
}

impl Compare {

    /// Parses a `u16` to create a [Compare] value.
    ///
    /// Returns [None] if `target_arg > 5`.
    pub fn from(target_arg: u16) -> Option<Self> {
        match target_arg {
            0 => Some(Compare::LT),
            1 => Some(Compare::LE),
            2 => Some(Compare::NE),
            3 => Some(Compare::EQ),
            4 => Some(Compare::GE),
            5 => Some(Compare::GT),
            _ => None
        }
    }

    pub fn to_u16(&self) -> u16 {
        match self {
            Compare::LT => 0,
            Compare::LE => 1,
            Compare::NE => 2,
            Compare::EQ => 3,
            Compare::GE => 4,
            Compare::GT => 5,
        }
    }

    pub fn cmp(a: Word, b: Word) -> i64 {
        match a {
            a if a > b => 1,
            a if a < b => -1,
            _ => 0
        }
    }

    pub fn is(&self, cmp: i64) -> bool {
        match self {
            Compare::EQ => matches!(cmp, 0),
            Compare::LT => matches!(cmp, -1),
            Compare::GT => matches!(cmp, 1),
            Compare::LE => matches!(cmp, -1 | 0),
            Compare::NE => matches!(cmp, -1 | 1),
            Compare::GE => matches!(cmp, 0 | 1),
        }
    }

    pub fn check(&self, a: Word, b: Word) -> bool { self.is(Self::cmp(a, b)) }
}