wasi_virt_layer 0.1.3

A virtual layer for WASI modules
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

use crate::__private::wasip1;
use crate::__private::wasip1::Size;

#[allow(unused_imports)]
use crate::memory::WasmAccess;
use crate::transporter::Wasip1Transporter;

pub struct DefaultStdIO;

impl StdIO for DefaultStdIO {
    fn read(buf: &mut [u8]) -> Result<Size, wasip1::Errno> {
        Wasip1Transporter::read_from_stdin(buf)
    }

    #[cfg(not(feature = "multi_memory"))]
    fn read_direct<Wasm: WasmAccess>(buf: *mut u8, len: usize) -> Result<Size, wasip1::Errno> {
        use crate::transporter::Wasip1Transporter;

        Wasip1Transporter::read_from_stdin_direct::<Wasm>(buf, len)
    }

    fn write(buf: &[u8]) -> Result<Size, wasip1::Errno> {
        Wasip1Transporter::write_to_stdout(buf)
    }

    #[cfg(not(feature = "multi_memory"))]
    fn write_direct<Wasm: WasmAccess>(buf: *const u8, len: usize) -> Result<Size, wasip1::Errno> {
        Wasip1Transporter::write_to_stdout_direct::<Wasm>(buf, len)
    }

    fn ewrite(buf: &[u8]) -> Result<Size, wasip1::Errno> {
        Wasip1Transporter::write_to_stderr(buf)
    }

    #[cfg(not(feature = "multi_memory"))]
    fn ewrite_direct<Wasm: WasmAccess>(buf: *const u8, len: usize) -> Result<Size, wasip1::Errno> {
        Wasip1Transporter::write_to_stderr_direct::<Wasm>(buf, len)
    }
}

pub trait StdIO {
    #[allow(unused_variables)]
    fn read(buf: &mut [u8]) -> Result<Size, wasip1::Errno> {
        Err(wasip1::ERRNO_NOSYS)
    }

    #[cfg(not(feature = "multi_memory"))]
    #[allow(unused_variables)]
    fn read_direct<Wasm: WasmAccess>(buf: *mut u8, len: usize) -> Result<Size, wasip1::Errno> {
        #[cfg(feature = "alloc")]
        {
            use crate::utils::alloc_buff;

            let (_, size) = unsafe {
                alloc_buff(len, |b| {
                    let size = Self::read(b)?;
                    Wasm::memcpy(buf, &b[..size]);
                    Ok(size)
                })
            };
            size
        }

        #[cfg(not(feature = "alloc"))]
        {
            // Stub implementation for non-std environments
            Err(wasip1::ERRNO_NOSYS)
        }
    }

    /// This function is called when the alloc feature is ON
    /// and write_direct is not implemented.
    /// If you are not familiar with Wasm memory, etc.,
    /// it is better to use this.
    #[allow(unused_variables)]
    fn write(buf: &[u8]) -> Result<Size, wasip1::Errno> {
        Err(wasip1::ERRNO_NOSYS)
    }

    /// This function is called,
    /// but if the write function is implemented
    /// and the alloc feature is ON,
    /// this function is automatically implemented.
    #[cfg(not(feature = "multi_memory"))]
    #[allow(unused_variables)]
    fn write_direct<Wasm: WasmAccess>(buf: *const u8, len: usize) -> Result<Size, wasip1::Errno> {
        #[cfg(feature = "alloc")]
        {
            Self::write(&Wasm::get_array(buf, len))
        }

        #[cfg(not(feature = "alloc"))]
        {
            // Stub implementation for non-std environments
            Err(wasip1::ERRNO_NOSYS)
        }
    }

    /// This function is called when the alloc feature is ON
    /// and ewrite_direct is not implemented.
    /// If you are not familiar with Wasm memory, etc.,
    /// it is better to use this.
    #[allow(unused_variables)]
    fn ewrite(buf: &[u8]) -> Result<Size, wasip1::Errno> {
        Err(wasip1::ERRNO_NOSYS)
    }

    /// This function is called,
    /// but if the ewrite function is implemented
    /// and the alloc feature is ON,
    /// this function is automatically implemented.
    #[cfg(not(feature = "multi_memory"))]
    #[allow(unused_variables)]
    fn ewrite_direct<Wasm: WasmAccess>(buf: *const u8, len: usize) -> Result<Size, wasip1::Errno> {
        #[cfg(feature = "alloc")]
        {
            Self::ewrite(&Wasm::get_array(buf, len))
        }

        #[cfg(not(feature = "alloc"))]
        {
            // Stub implementation for non-std environments
            Err(wasip1::ERRNO_NOSYS)
        }
    }
}