lovm2_core 0.4.8

a lightweight virtual machine with a focus on simplicity and extendability.
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

//! Implementation of primitive inplace operations on `Value`

use super::Value::*;
use super::*;

impl Value {
    pub fn add_inplace(&mut self, other: Value) -> Lovm2Result<()> {
        match (self, other) {
            (Int(ref mut a), Int(b)) => *a += b,
            (Float(ref mut a), Float(b)) => *a += b,
            (Str(ref mut a), Str(b)) => *a = format!("{}{}", a, b),
            (Float(ref mut a), b @ Int(_)) => *a += b.as_float_inner()?,
            (a @ Int(_), b @ Float(_)) => *a = (a.clone() + b)?,
            _ => err_not_supported()?,
        }
        Ok(())
    }

    pub fn sub_inplace(&mut self, other: Value) -> Lovm2Result<()> {
        match (self, other) {
            (Int(ref mut a), Int(b)) => *a -= b,
            (Float(ref mut a), Float(b)) => *a -= b,
            (Float(ref mut a), b @ Int(_)) => *a -= b.as_float_inner()?,
            (a @ Int(_), b @ Float(_)) => *a = (a.clone() - b)?,
            _ => err_not_supported()?,
        }
        Ok(())
    }

    pub fn mul_inplace(&mut self, other: Value) -> Lovm2Result<()> {
        match (self, other) {
            (Int(ref mut a), Int(b)) => *a *= b,
            (Float(ref mut a), Float(b)) => *a *= b,
            (Float(ref mut a), b @ Int(_)) => *a *= b.as_float_inner()?,
            (a @ Int(_), b @ Float(_)) => *a = (a.clone() * b)?,
            _ => err_not_supported()?,
        }
        Ok(())
    }

    pub fn div_inplace(&mut self, other: Value) -> Lovm2Result<()> {
        match (self, other) {
            (Int(ref mut a), Int(b)) => *a /= b,
            (Float(ref mut a), Float(b)) => *a /= b,
            (Float(ref mut a), b @ Int(_)) => *a /= b.as_float_inner()?,
            (a @ Int(_), b @ Float(_)) => *a = (a.clone() / b)?,
            _ => err_not_supported()?,
        }
        Ok(())
    }

    pub fn rem_inplace(&mut self, other: Value) -> Lovm2Result<()> {
        match (self, other) {
            (Int(ref mut a), Int(b)) => *a %= b,
            (Float(ref mut a), Float(b)) => *a %= b,
            (Float(ref mut a), b @ Int(_)) => *a %= b.as_float_inner()?,
            (a @ Int(_), b @ Float(_)) => *a = (a.clone() % b)?,
            _ => err_not_supported()?,
        }
        Ok(())
    }

    pub fn shl_inplace(&mut self, other: Value) -> Lovm2Result<()> {
        match (self, other) {
            (Int(ref mut a), Int(b)) => *a <<= b,
            _ => err_not_supported()?,
        }
        Ok(())
    }

    pub fn shr_inplace(&mut self, other: Value) -> Lovm2Result<()> {
        match (self, other) {
            (Int(ref mut a), Int(b)) => *a >>= b,
            _ => err_not_supported()?,
        }
        Ok(())
    }

    pub fn pow_inplace(&mut self, exp: Value) -> Lovm2Result<()> {
        let exp = exp.as_integer_inner()?;
        match self {
            Int(ref mut base) => *base = base.pow(exp as u32),
            Float(ref mut base) => *base = base.powi(exp as i32),
            _ => err_not_supported()?,
        };
        Ok(())
    }

    pub fn and_inplace(&mut self, other: Value) -> Lovm2Result<()> {
        match (self, other) {
            (Bool(a), Bool(b)) => *a &= b,
            (Int(a), Int(b)) => *a &= b,
            _ => err_not_supported()?,
        }
        Ok(())
    }

    pub fn or_inplace(&mut self, other: Value) -> Lovm2Result<()> {
        match (self, other) {
            (Bool(a), Bool(b)) => *a |= b,
            (Int(a), Int(b)) => *a |= b,
            _ => err_not_supported()?,
        }
        Ok(())
    }

    pub fn xor_inplace(&mut self, other: Value) -> Lovm2Result<()> {
        match (self, other) {
            (Bool(a), Bool(b)) => *a ^= b,
            (Int(a), Int(b)) => *a ^= b,
            _ => err_not_supported()?,
        }
        Ok(())
    }

    pub fn not_inplace(&mut self) -> Lovm2Result<()> {
        match self {
            Bool(ref mut a) => *a = !*a,
            Int(ref mut a) => *a = !*a,
            _ => err_not_supported()?,
        }
        Ok(())
    }
}