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
use crate::{
global::Global, instance::InstanceInner, memory::Memory, module::ExportIndex,
module::ModuleInner, table::Table, types::FuncSig, vm,
};
use indexmap::map::Iter as IndexMapIter;
use std::{ptr::NonNull, sync::Arc};
#[derive(Debug, Copy, Clone)]
pub enum Context {
External(*mut vm::Ctx),
ExternalWithEnv(*mut vm::Ctx, Option<NonNull<vm::FuncEnv>>),
Internal,
}
unsafe impl Send for Context {}
#[derive(Debug, Clone)]
pub enum Export {
Function {
func: FuncPointer,
ctx: Context,
signature: Arc<FuncSig>,
},
Memory(Memory),
Table(Table),
Global(Global),
}
#[derive(Debug, Clone)]
pub struct FuncPointer(*const vm::Func);
unsafe impl Send for FuncPointer {}
impl FuncPointer {
pub unsafe fn new(f: *const vm::Func) -> Self {
FuncPointer(f)
}
pub(crate) fn inner(&self) -> *const vm::Func {
self.0
}
}
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.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),
))
}
}