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

//! Sum type for every HIR element

use super::*;

/// Sum type for every HIR element
#[derive(Clone)]
pub enum HirElement {
    Assign(Assign),
    Branch(Branch),
    Break(Break),
    Call(Call),
    Continue(Continue),
    Include(Include),
    Interrupt(Interrupt),
    Repeat(Repeat),
    Return(Return),
}

impl HirLowering for HirElement {
    fn lower<'hir, 'lir>(&'hir self, runtime: &mut HirLoweringRuntime<'lir>)
    where
        'hir: 'lir,
    {
        match self {
            HirElement::Assign(assign) => assign.lower(runtime),
            HirElement::Branch(branch) => branch.lower(runtime),
            HirElement::Break(cmd) => cmd.lower(runtime),
            HirElement::Call(call) => call.lower(runtime),
            HirElement::Continue(cmd) => cmd.lower(runtime),
            HirElement::Include(include) => include.lower(runtime),
            HirElement::Interrupt(interrupt) => interrupt.lower(runtime),
            HirElement::Repeat(repeat) => repeat.lower(runtime),
            HirElement::Return(ret) => ret.lower(runtime),
        }
    }
}

impl From<Assign> for HirElement {
    fn from(assign: Assign) -> Self {
        HirElement::Assign(assign)
    }
}

impl From<Branch> for HirElement {
    fn from(branch: Branch) -> Self {
        HirElement::Branch(branch)
    }
}

impl From<Break> for HirElement {
    fn from(cmd: Break) -> Self {
        HirElement::Break(cmd)
    }
}

impl From<Call> for HirElement {
    fn from(call: Call) -> Self {
        HirElement::Call(call)
    }
}

impl From<Continue> for HirElement {
    fn from(cmd: Continue) -> Self {
        HirElement::Continue(cmd)
    }
}

impl From<Include> for HirElement {
    fn from(include: Include) -> Self {
        HirElement::Include(include)
    }
}

impl From<Interrupt> for HirElement {
    fn from(interrupt: Interrupt) -> Self {
        HirElement::Interrupt(interrupt)
    }
}

impl From<Repeat> for HirElement {
    fn from(repeat: Repeat) -> Self {
        HirElement::Repeat(repeat)
    }
}

impl From<&mut Repeat> for HirElement {
    fn from(repeat: &mut Repeat) -> Self {
        HirElement::Repeat(repeat.clone())
    }
}

impl From<Return> for HirElement {
    fn from(ret: Return) -> Self {
        HirElement::Return(ret)
    }
}