embive 0.7.1

Embive is an interpreter/virtual-machine that leverages RISC-V bytecode, enabling sandboxed code execution on tiny devices (e.g. microcontrollers).
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

//! Embive Instruction Macro module.

/// Macro for Embive Instruction
macro_rules! instruction {
    ($name:ident, $opcode:expr, $format:ty, {$($cty:ty: {$($cname:ident = $cvalue:expr);* $(;)?}),* $(,)?}) => {
        impl $name {
            $(
                $(
                    /// Instruction Constant Value
                    pub const $cname: $cty = $cvalue;
                )*
            )*
        }
        crate::instruction::embive_macro::instruction!($name, $opcode, $format);
    };
    ($name:ident, $opcode:expr, $format:ty) => {
        /// Embive Instruction
        #[derive(Debug, Clone, Copy, PartialEq)]
        pub struct $name (pub $format);

        impl crate::instruction::embive::InstructionImpl for $name {
            /// Instruction Opcode
            #[inline(always)]
            fn opcode() -> u8 {
                $opcode
            }

            /// Instruction size
            #[inline(always)]
            fn size() -> crate::format::Size {
                <$format>::SIZE
            }

            /// Encode instruction to u32 (Embive Format)
            #[inline(always)]
            fn encode(&self) -> u32 {
                self.0.to_embive()
            }

            /// Decode instruction from u32 (Embive Format)
            #[inline(always)]
            fn decode(inst: u32) -> Self {
                Self(<$format>::from_embive(inst))
            }
        }

        impl From<$format> for $name {
            fn from(format: $format) -> Self {
                Self(format)
            }
        }
    };
}

/// Macro for Embive Instructions
macro_rules! instructions {
    {$($opcode:expr => $name:ident: $format:ty = $consts:tt);* $(;)?} => {
        $(
            crate::instruction::embive_macro::instruction!($name, $opcode, $format, $consts);
        )*

        /// Embive Instruction Decoding Macro
        macro_rules! decode_instruction {
            ($inst:expr, $method:tt, $params:tt) => {
                {
                    use crate::instruction::embive::InstructionImpl;
                    let inst = u32::from($inst);

                    match (inst & 0x1F) {
                        $(
                            $opcode => Some(crate::instruction::embive::$name::decode(inst).$method$params),
                        )*
                        _ => None,
                    }
                }
            };
        }

        pub(crate) use decode_instruction;
    };
}

pub(super) use instruction;
pub(super) use instructions;