ardaku 0.1.0

WASM Environment
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

//! Utilities to help parsing data between WASM and host

/// WASM memory writer
pub struct Writer<'a>(&'a mut [u8]);

impl<'a> Writer<'a> {
    /// Make new writer
    pub fn new(bytes: &'a mut [u8]) -> Self {
        Self(bytes)
    }

    /// Send a u8 to the WASM module
    pub fn u8(&mut self, byte: u8) {
        self.0[..1].copy_from_slice(&byte.to_le_bytes());

        // Hack around lifetime issues
        let mut swap: &'a mut [u8] = &mut [];
        core::mem::swap(&mut self.0, &mut swap);
        let mut swap = swap.split_at_mut(1).1;
        core::mem::swap(&mut self.0, &mut swap);
    }

    /// Send a u16 to the WASM module
    pub fn u16(&mut self, half: u16) {
        self.0[..2].copy_from_slice(&half.to_le_bytes());

        // Hack around lifetime issues
        let mut swap: &'a mut [u8] = &mut [];
        core::mem::swap(&mut self.0, &mut swap);
        let mut swap = swap.split_at_mut(2).1;
        core::mem::swap(&mut self.0, &mut swap);
    }

    /// Send a u32 to the WASM module
    pub fn u32(&mut self, word: u32) {
        self.0[..4].copy_from_slice(&word.to_le_bytes());

        // Hack around lifetime issues
        let mut swap: &'a mut [u8] = &mut [];
        core::mem::swap(&mut self.0, &mut swap);
        let mut swap = swap.split_at_mut(4).1;
        core::mem::swap(&mut self.0, &mut swap);
    }

    /// Send a u64 to the WASM module
    pub fn u64(&mut self, long: u64) {
        self.0[..8].copy_from_slice(&long.to_le_bytes());

        // Hack around lifetime issues
        let mut swap: &'a mut [u8] = &mut [];
        core::mem::swap(&mut self.0, &mut swap);
        let mut swap = swap.split_at_mut(8).1;
        core::mem::swap(&mut self.0, &mut swap);
    }

    /// Send a UTF-8 string to the WASM module
    pub fn str(&mut self, utf8: &str) {
        let len = utf8.len();
        self.0[..len].copy_from_slice(utf8.as_bytes());

        // Hack around lifetime issues
        let mut swap: &'a mut [u8] = &mut [];
        core::mem::swap(&mut self.0, &mut swap);
        let mut swap = swap.split_at_mut(len).1;
        core::mem::swap(&mut self.0, &mut swap);
    }
}

/// WASM memory reader
pub struct Reader<'a>(&'a [u8]);

impl<'a> Reader<'a> {
    /// Make new reader
    pub fn new(bytes: &'a [u8]) -> Self {
        Self(bytes)
    }

    /// Receive a u8 from the WASM module
    pub fn u8(&mut self) -> u8 {
        let bytes = self.0[..1].try_into().expect("Out of bounds read");
        self.0 = &self.0[1..];
        u8::from_le_bytes(bytes)
    }

    /// Receive a u16 from the WASM module
    pub fn u16(&mut self) -> u16 {
        let bytes = self.0[..2].try_into().expect("Out of bounds read");
        self.0 = &self.0[2..];
        u16::from_le_bytes(bytes)
    }

    /// Receive a u32 from the WASM module
    pub fn u32(&mut self) -> u32 {
        let bytes = self.0[..4].try_into().expect("Out of bounds read");
        self.0 = &self.0[4..];
        u32::from_le_bytes(bytes)
    }

    /// Receive a u64 from the WASM module
    pub fn u64(&mut self) -> u64 {
        let bytes = self.0[..8].try_into().expect("Out of bounds read");
        self.0 = &self.0[8..];
        u64::from_le_bytes(bytes)
    }

    /// Receive a UTF-8 string from the WASM module
    pub fn str(&mut self) -> Result<&str, core::str::Utf8Error> {
        let bytes = self.0.get(0..).expect("Out of bounds read");
        self.0 = &[];
        core::str::from_utf8(bytes)
    }
}