vm_value 0.4.3

Core value trait used by fn_vm, this crate is meant to provide the building blocks to creating pass by value VMs in rust.
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

use small_len::SmallLen;
use var_num::{VarFloat, VarInt, VarNum, VarUInt};
use crate::{length_to_bytes, Logical, VM, VMValue};

#[macro_export]
macro_rules! impl_logical_for_num {
    ($($t:ty),*) => {
        $(
            impl Logical for $t {
                fn bool_and(&self, b: &Self) -> bool {
                    self.is_zero() && b.is_zero()
                }

                fn bool_or(&self, b: &Self) -> bool {
                    self.is_zero() || b.is_zero()
                }

                fn bool_xor(&self, b: &Self) -> bool {
                    self.is_zero() ^ b.is_zero()
                }

                fn bool_not(&self) -> bool {
                    self.is_non_zero()
                }

                fn bitwise_reverse(&self) -> Self {
                    self.reverse()
                }
            }
        )*
    }
}

impl_logical_for_num!(VarUInt, VarInt, VarFloat, VarNum);

macro_rules! impl_vm_value_for_num {
    ($($t:ty),*) => {
        $(
            impl <Op, Val> VMValue<Op, Val, $t> for $t {
                fn create_from_vm_bytes<V: VM<Op, Val, $t>>(vm: &mut V) -> $t {
                    let len = vm.next_len();
                    let bytes = vm.next_n_bytes_vec(len);
                    <$t>::from_bytes(bytes)
                }

                fn to_vm_bytes(&self) -> Vec<u8> {
                    let bytes = self.to_bytes();
                    let mut r = length_to_bytes(&bytes.small_len());
                    r.extend(bytes);
                    r
                }
            }
        )*
    }
}

impl_vm_value_for_num!(VarUInt, VarInt, VarFloat);

impl <Op, Val> VMValue<Op, Val, VarNum> for VarNum {
    fn create_from_vm_bytes<V: VM<Op, Val, VarNum>>(vm: &mut V) -> VarNum {
        let byte = vm.next_byte();
        let len = vm.next_len();
        let bytes = vm.next_n_bytes_vec(len);
        match byte {
            0 => VarNum::Int(VarInt::from_bytes(bytes)),
            1 => VarNum::UInt(VarUInt::from_bytes(bytes)),
            2 => VarNum::Float(VarFloat::from_bytes(bytes)),
            b => panic!("Unsupported byte: {}", b)
        }
    }

    fn to_vm_bytes(&self) -> Vec<u8> {
        let mut r = vec![];
        match self {
            VarNum::Int(i) => {
                r.push(0);
                r.extend(i.to_bytes());
            }
            VarNum::UInt(u) => {
                r.push(1);
                r.extend(u.to_bytes());
            }
            VarNum::Float(f) => {
                r.push(2);
                r.extend(f.to_bytes());
            }
        }
        r
    }
}