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
129
130
131
132
133
use crate::value::*;
#[cfg(feature = "serde_borsh")]
use borsh::{maybestd::io::Result, maybestd::io::Write, BorshDeserialize, BorshSerialize};
#[cfg(feature = "serde_borsh")]
use go_parser::PiggyVecKey;
use go_parser::{piggy_key_type, PiggyVec};
#[cfg(feature = "serde_borsh")]
macro_rules! impl_borsh_for_key {
($key:ident) => {
impl BorshSerialize for $key {
fn serialize<W: Write>(&self, writer: &mut W) -> Result<()> {
self.as_usize().serialize(writer)
}
}
impl BorshDeserialize for $key {
fn deserialize(buf: &mut &[u8]) -> Result<Self> {
let i: usize = usize::deserialize(buf)?;
Ok(i.into())
}
}
};
}
piggy_key_type! {
pub struct MetadataKey;
pub struct FunctionKey;
pub struct PackageKey;
}
#[cfg(feature = "serde_borsh")]
impl_borsh_for_key!(MetadataKey);
#[cfg(feature = "serde_borsh")]
impl_borsh_for_key!(FunctionKey);
#[cfg(feature = "serde_borsh")]
impl_borsh_for_key!(PackageKey);
pub type MetadataObjs = PiggyVec<MetadataKey, MetadataType>;
pub type FunctionObjs = PiggyVec<FunctionKey, FunctionObj>;
pub type PackageObjs = PiggyVec<PackageKey, PackageObj>;
pub struct VMObjects {
pub metas: MetadataObjs,
pub functions: FunctionObjs,
pub packages: PackageObjs,
pub prim_meta: PrimitiveMeta,
pub(crate) arr_slice_caller: Box<ArrCaller>,
}
impl VMObjects {
pub fn new() -> VMObjects {
const CAP: usize = 16;
let mut metas = PiggyVec::with_capacity(CAP);
let prim_meta = PrimitiveMeta::new(&mut metas);
VMObjects {
metas,
functions: PiggyVec::with_capacity(CAP),
packages: PiggyVec::with_capacity(CAP),
prim_meta,
arr_slice_caller: Box::new(ArrCaller::new()),
}
}
}
#[cfg(feature = "serde_borsh")]
impl BorshSerialize for VMObjects {
fn serialize<W: Write>(&self, writer: &mut W) -> Result<()> {
self.metas.vec().serialize(writer)?;
self.functions.vec().serialize(writer)?;
self.packages.vec().serialize(writer)
}
}
#[cfg(feature = "serde_borsh")]
impl BorshDeserialize for VMObjects {
fn deserialize(buf: &mut &[u8]) -> Result<Self> {
let mut metas = Vec::<MetadataType>::deserialize(buf)?.into();
let functions = Vec::<FunctionObj>::deserialize(buf)?.into();
let packages = Vec::<PackageObj>::deserialize(buf)?.into();
let prim_meta = PrimitiveMeta::new(&mut metas);
Ok(VMObjects {
metas,
functions,
packages,
prim_meta,
arr_slice_caller: Box::new(ArrCaller::new()),
})
}
}
#[cfg_attr(feature = "serde_borsh", derive(BorshDeserialize, BorshSerialize))]
pub struct Bytecode {
pub objects: VMObjects,
pub consts: Vec<GosValue>,
pub ifaces: Vec<(Meta, Vec<Binding4Runtime>)>,
pub indices: Vec<Vec<OpIndex>>,
pub entry: FunctionKey,
pub main_pkg: PackageKey,
}
impl Bytecode {
pub fn new(
objects: VMObjects,
consts: Vec<GosValue>,
ifaces: Vec<(Meta, Vec<IfaceBinding>)>,
indices: Vec<Vec<OpIndex>>,
entry: FunctionKey,
main_pkg: PackageKey,
) -> Bytecode {
let ifaces = ifaces
.into_iter()
.map(|(ms, binding)| {
let binding = binding.into_iter().map(|x| x.into()).collect();
(ms, binding)
})
.collect();
Bytecode {
objects,
consts,
ifaces,
indices,
entry,
main_pkg,
}
}
}