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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

//! Sum type for every LIR element

use std::borrow::Cow;

use crate::value::{Value, ValueType};
use crate::var::Variable;

use super::{Label, Operator, Scope};

/// Sum type for every LIR element.
#[derive(Clone, Debug)]
pub enum LirElement<'hir> {
    Call {
        argn: u8,
        ident: &'hir Variable,
    },
    Conv {
        tyid: ValueType,
    },
    Entry {
        ident: &'hir Variable,
    },
    // Jmp(u16), Jt(u16), Jf(u16)
    Jump {
        condition: Option<bool>,
        label: Label,
    },
    Label(Label),
    // Add, Sub, Mul, Div, Pow, Rem, And, Or, Not, Eq, Ne, Ge, Gt, Le, Lt
    Operation(Operator),
    // CPush(u16)
    PushConstant {
        value: Cow<'hir, Value>,
    },
    // LPush(u16), GPush(u16),
    PushDynamic {
        ident: &'hir Variable,
        scope: Scope,
    },
    // LMove(u16), GMove(u16)
    StoreDynamic {
        ident: &'hir Variable,
        scope: Scope,
    },
    Import {
        namespaced: bool,
    },

    Box,
    Drop,
    Duplicate,
    Get,
    RGet,
    Interrupt(u16),
    Ret,
    Set,
    Slice,

    IterCreate,
    IterCreateRanged,
    IterHasNext,
    IterNext,
    IterReverse,
}

impl<'hir> LirElement<'hir> {
    pub fn call(ident: &'hir Variable, argn: u8) -> Self {
        Self::Call { argn, ident }
    }

    pub fn conv(tyid: ValueType) -> Self {
        Self::Conv { tyid }
    }

    pub fn entry(ident: &'hir Variable) -> Self {
        Self::Entry { ident }
    }

    pub fn jump(label: Label) -> Self {
        Self::Jump {
            condition: None,
            label,
        }
    }

    pub fn jump_conditional(cond: bool, label: Label) -> Self {
        Self::Jump {
            condition: Some(cond),
            label,
        }
    }

    pub fn push_constant(value: &'hir Value) -> Self {
        Self::PushConstant {
            value: Cow::Borrowed(value),
        }
    }

    pub fn push_constant_owned(value: Value) -> Self {
        Self::PushConstant {
            value: Cow::Owned(value),
        }
    }

    pub fn push_dynamic(scope: Scope, ident: &'hir Variable) -> Self {
        Self::PushDynamic { ident, scope }
    }

    pub fn operation<T>(op: T) -> Self
    where
        T: Into<Operator>,
    {
        Self::Operation(op.into())
    }

    pub fn store(scope: Scope, ident: &'hir Variable) -> Self {
        Self::StoreDynamic { ident, scope }
    }
}

impl std::fmt::Display for LirElement<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            Self::Call { argn, ident } => write!(f, "\tCall({}, {})", ident, argn),
            Self::Conv { tyid } => write!(f, "\tConv({:?})", tyid),
            Self::Entry { ident } => write!(f, "{}:", ident),
            Self::Jump { condition, label } => match condition {
                Some(true) => write!(f, "\tJumpIfTrue(.{})", label),
                Some(false) => write!(f, "\tJumpIfFalse(.{})", label),
                _ => write!(f, "\tJump(.{})", label),
            },
            Self::Label(label) => write!(f, ".{}:", label),
            Self::Operation(operator) => write!(f, "\t{:?}", operator),
            Self::PushConstant { value } => write!(f, "\tCPush({})", value),
            Self::PushDynamic { ident, scope } => write!(f, "\tPush{:?}({})", scope, ident),
            Self::StoreDynamic { ident, scope } => write!(f, "\tStore{:?}({})", scope, ident),
            Self::Interrupt(n) => write!(f, "\tInterrupt({})", n),
            _ => write!(f, "\t{:?}", self),
        }
    }
}