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
//! This module contains types to manipulate and access a Wasm module's exports
//! including memories, tables, globals, and functions.
use crate::{
error,
global::Global,
instance::{Exports, InstanceInner},
memory::Memory,
module::ExportIndex,
module::ModuleInner,
table::Table,
types::FuncSig,
vm,
};
use indexmap::map::Iter as IndexMapIter;
use std::{ptr::NonNull, sync::Arc};
/// A kind of Context.
#[derive(Debug, Copy, Clone)]
pub enum Context {
/// External context include a mutable pointer to `Ctx`.
External(*mut vm::Ctx),
/// External context with an environment include a mutable pointer
/// to `Ctx` and an optional non-null pointer to `FuncEnv`.
ExternalWithEnv(*mut vm::Ctx, Option<NonNull<vm::FuncEnv>>),
/// Internal context.
Internal,
}
// Manually implemented because context contains a raw pointer to Ctx
unsafe impl Send for Context {}
/// Kind of WebAssembly export.
#[derive(Debug, Clone)]
pub enum Export {
/// Function export.
Function {
/// A pointer to a function.
func: FuncPointer,
/// A kind of context.
ctx: Context,
/// The signature of the function.
signature: Arc<FuncSig>,
},
/// Memory export.
Memory(Memory),
/// Table export.
Table(Table),
/// Global export.
Global(Global),
}
/// Const pointer to a `Func`.
#[derive(Debug, Clone)]
pub struct FuncPointer(*const vm::Func);
// Manually implemented because FuncPointer contains a raw pointer to Ctx
unsafe impl Send for FuncPointer {}
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
}
}
/// An iterator to an instance's exports.
pub struct ExportIter<'a> {
inner: &'a InstanceInner,
iter: IndexMapIter<'a, String, ExportIndex>,
module: &'a ModuleInner,
}
impl<'a> ExportIter<'a> {
pub(crate) fn new(module: &'a ModuleInner, inner: &'a InstanceInner) -> Self {
Self {
inner,
iter: module.info.exports.map.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),
))
}
}
/// This trait is used to mark types as gettable from an [`Instance`].
pub trait Exportable<'a>: Sized {
/// Implementation of how to get the export corresponding to the implementing type
/// from an [`Instance`] by name.
fn get_self(exports: &'a Exports, name: &str) -> error::ResolveResult<Self>;
}