2018-01-24 11:14:24 +00:00
|
|
|
|
use std::borrow::Cow;
|
|
|
|
|
|
2018-01-22 13:34:32 +00:00
|
|
|
|
use parity_wasm::elements::{
|
|
|
|
|
FunctionType, ValueType as EValueType, GlobalType, TableType, MemoryType};
|
2018-01-18 12:54:31 +00:00
|
|
|
|
|
2018-01-23 16:38:49 +00:00
|
|
|
|
/// Signature of a function.
|
|
|
|
|
///
|
|
|
|
|
/// Signature of a function consists of zero or more parameter [types][type] and zero or one return [type].
|
|
|
|
|
///
|
|
|
|
|
/// Two signatures are considered equal if they have equal list of parameters and equal return types.
|
|
|
|
|
///
|
|
|
|
|
/// [type]: enum.ValueType.html
|
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
2018-01-18 12:54:31 +00:00
|
|
|
|
pub struct Signature {
|
2018-01-24 11:14:24 +00:00
|
|
|
|
params: Cow<'static, [ValueType]>,
|
2018-01-18 13:39:14 +00:00
|
|
|
|
return_type: Option<ValueType>,
|
2018-01-18 12:54:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl Signature {
|
2018-01-24 11:14:24 +00:00
|
|
|
|
pub fn new<C: Into<Cow<'static, [ValueType]>>>(
|
|
|
|
|
params: C,
|
|
|
|
|
return_type: Option<ValueType>
|
|
|
|
|
) -> Signature {
|
2018-01-18 12:54:31 +00:00
|
|
|
|
Signature {
|
2018-01-24 11:14:24 +00:00
|
|
|
|
params: params.into(),
|
2018-01-18 13:39:14 +00:00
|
|
|
|
return_type: return_type,
|
2018-01-18 12:54:31 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub fn params(&self) -> &[ValueType] {
|
2018-01-24 11:14:24 +00:00
|
|
|
|
&self.params.as_ref()
|
2018-01-18 12:54:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub fn return_type(&self) -> Option<ValueType> {
|
2018-01-18 13:39:14 +00:00
|
|
|
|
self.return_type
|
2018-01-18 12:54:31 +00:00
|
|
|
|
}
|
2018-01-18 13:39:14 +00:00
|
|
|
|
|
2018-01-23 15:12:41 +00:00
|
|
|
|
pub(crate) fn from_elements(func_type: &FunctionType) -> Signature {
|
2018-01-18 13:39:14 +00:00
|
|
|
|
Signature {
|
|
|
|
|
params: func_type.params().iter().cloned().map(ValueType::from_elements).collect(),
|
|
|
|
|
return_type: func_type.return_type().map(ValueType::from_elements),
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2018-01-23 16:38:49 +00:00
|
|
|
|
/// Type of a value.
|
|
|
|
|
///
|
|
|
|
|
/// Wasm code manipulate values of the four basic value types:
|
|
|
|
|
/// integers and floating-point (IEEE 754-2008) data of 32 or 64 bit width each, respectively.
|
|
|
|
|
///
|
|
|
|
|
/// There is no distinction between signed and unsigned integer types. Instead, integers are
|
|
|
|
|
/// interpreted by respective operations as either unsigned or signed in two’s complement representation.
|
|
|
|
|
///
|
2018-01-18 13:39:14 +00:00
|
|
|
|
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
|
|
|
|
|
pub enum ValueType {
|
|
|
|
|
I32,
|
|
|
|
|
I64,
|
|
|
|
|
F32,
|
|
|
|
|
F64,
|
2018-01-18 12:54:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2018-01-18 13:39:14 +00:00
|
|
|
|
impl ValueType {
|
|
|
|
|
pub(crate) fn from_elements(value_type: EValueType) -> ValueType {
|
|
|
|
|
match value_type {
|
|
|
|
|
EValueType::I32 => ValueType::I32,
|
|
|
|
|
EValueType::I64 => ValueType::I64,
|
|
|
|
|
EValueType::F32 => ValueType::F32,
|
|
|
|
|
EValueType::F64 => ValueType::F64,
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub(crate) fn into_elements(self) -> EValueType {
|
|
|
|
|
match self {
|
|
|
|
|
ValueType::I32 => EValueType::I32,
|
|
|
|
|
ValueType::I64 => EValueType::I64,
|
|
|
|
|
ValueType::F32 => EValueType::F32,
|
|
|
|
|
ValueType::F64 => EValueType::F64,
|
|
|
|
|
}
|
2018-01-18 12:54:31 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2018-01-22 13:23:07 +00:00
|
|
|
|
|
|
|
|
|
pub struct GlobalDescriptor {
|
|
|
|
|
value_type: ValueType,
|
|
|
|
|
mutable: bool,
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl GlobalDescriptor {
|
2018-01-22 13:30:13 +00:00
|
|
|
|
pub(crate) fn from_elements(global_type: &GlobalType) -> GlobalDescriptor {
|
2018-01-22 13:23:07 +00:00
|
|
|
|
GlobalDescriptor {
|
|
|
|
|
value_type: ValueType::from_elements(global_type.content_type()),
|
|
|
|
|
mutable: global_type.is_mutable(),
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub fn value_type(&self) -> ValueType {
|
|
|
|
|
self.value_type
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub fn is_mutable(&self) -> bool {
|
|
|
|
|
self.mutable
|
|
|
|
|
}
|
2018-01-22 13:30:13 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub struct TableDescriptor {
|
|
|
|
|
initial: u32,
|
|
|
|
|
maximum: Option<u32>,
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl TableDescriptor {
|
|
|
|
|
pub(crate) fn from_elements(table_type: &TableType) -> TableDescriptor {
|
|
|
|
|
TableDescriptor {
|
|
|
|
|
initial: table_type.limits().initial(),
|
|
|
|
|
maximum: table_type.limits().maximum(),
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub fn initial(&self) -> u32 {
|
|
|
|
|
self.initial
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub fn maximum(&self) -> Option<u32> {
|
|
|
|
|
self.maximum
|
|
|
|
|
}
|
|
|
|
|
}
|
2018-01-22 13:34:32 +00:00
|
|
|
|
|
|
|
|
|
pub struct MemoryDescriptor {
|
|
|
|
|
initial: u32,
|
|
|
|
|
maximum: Option<u32>,
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl MemoryDescriptor {
|
|
|
|
|
pub(crate) fn from_elements(memory_type: &MemoryType) -> MemoryDescriptor {
|
|
|
|
|
MemoryDescriptor {
|
|
|
|
|
initial: memory_type.limits().initial(),
|
|
|
|
|
maximum: memory_type.limits().maximum(),
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub fn initial(&self) -> u32 {
|
|
|
|
|
self.initial
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub fn maximum(&self) -> Option<u32> {
|
|
|
|
|
self.maximum
|
2018-01-23 15:12:41 +00:00
|
|
|
|
}
|
2018-01-22 13:34:32 +00:00
|
|
|
|
}
|