wasmer-runtime-core 0.1.1

Wasmer runtime core library
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

use crate::{
    instance::InstanceInner,
    module::ExportIndex,
    module::ModuleInner,
    types::{FuncSig, GlobalDesc, Memory, Table},
    vm,
};
use hashbrown::hash_map;

#[derive(Debug, Copy, Clone)]
pub enum Context {
    External(*mut vm::Ctx),
    Internal,
}

#[derive(Debug, Clone)]
pub enum Export {
    Function {
        func: FuncPointer,
        ctx: Context,
        signature: FuncSig,
    },
    Memory {
        local: MemoryPointer,
        ctx: Context,
        memory: Memory,
    },
    Table {
        local: TablePointer,
        ctx: Context,
        table: Table,
    },
    Global {
        local: GlobalPointer,
        global: GlobalDesc,
    },
}

#[derive(Debug, Clone)]
pub struct FuncPointer(*const vm::Func);

impl FuncPointer {
    /// This needs to be unsafe because there is
    /// no way to check whether the passed function
    /// is valid and has the right signature.
    pub unsafe fn new(f: *const vm::Func) -> Self {
        FuncPointer(f)
    }

    pub(crate) fn inner(&self) -> *const vm::Func {
        self.0
    }
}

#[derive(Debug, Clone)]
pub struct MemoryPointer(*mut vm::LocalMemory);

impl MemoryPointer {
    /// This needs to be unsafe because there is
    /// no way to check whether the passed function
    /// is valid and has the right signature.
    pub unsafe fn new(f: *mut vm::LocalMemory) -> Self {
        MemoryPointer(f)
    }

    pub(crate) fn inner(&self) -> *mut vm::LocalMemory {
        self.0
    }
}

#[derive(Debug, Clone)]
pub struct TablePointer(*mut vm::LocalTable);

impl TablePointer {
    /// This needs to be unsafe because there is
    /// no way to check whether the passed function
    /// is valid and has the right signature.
    pub unsafe fn new(f: *mut vm::LocalTable) -> Self {
        TablePointer(f)
    }

    pub(crate) fn inner(&self) -> *mut vm::LocalTable {
        self.0
    }
}

#[derive(Debug, Clone)]
pub struct GlobalPointer(*mut vm::LocalGlobal);

impl GlobalPointer {
    /// This needs to be unsafe because there is
    /// no way to check whether the passed function
    /// is valid and has the right signature.
    pub unsafe fn new(f: *mut vm::LocalGlobal) -> Self {
        GlobalPointer(f)
    }

    pub(crate) fn inner(&self) -> *mut vm::LocalGlobal {
        self.0
    }
}

pub struct ExportIter<'a> {
    inner: &'a mut InstanceInner,
    iter: hash_map::Iter<'a, String, ExportIndex>,
    module: &'a ModuleInner,
}

impl<'a> ExportIter<'a> {
    pub(crate) fn new(module: &'a ModuleInner, inner: &'a mut InstanceInner) -> Self {
        Self {
            inner,
            iter: module.exports.iter(),
            module,
        }
    }
}

impl<'a> Iterator for ExportIter<'a> {
    type Item = (String, Export);
    fn next(&mut self) -> Option<(String, Export)> {
        let (name, export_index) = self.iter.next()?;
        Some((
            name.clone(),
            self.inner.get_export_from_index(&self.module, export_index),
        ))
    }
}