| use std::borrow::Cow; |
| |
| use parity_wasm::elements::{ |
| FunctionType, ValueType as EValueType, GlobalType, TableType, MemoryType}; |
| |
| /// 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 |
| /// [function]: struct.FuncInstance.html |
| #[derive(Debug, Clone, PartialEq, Eq)] |
| pub struct Signature { |
| params: Cow<'static, [ValueType]>, |
| return_type: Option<ValueType>, |
| } |
| |
| impl Signature { |
| /// Creates new signature with givens |
| /// parameter types and optional return type. |
| pub fn new<C: Into<Cow<'static, [ValueType]>>>( |
| params: C, |
| return_type: Option<ValueType> |
| ) -> Signature { |
| Signature { |
| params: params.into(), |
| return_type: return_type, |
| } |
| } |
| |
| /// Returns parameter types of this signature. |
| pub fn params(&self) -> &[ValueType] { |
| &self.params.as_ref() |
| } |
| |
| /// Returns return type of this signature. |
| pub fn return_type(&self) -> Option<ValueType> { |
| self.return_type |
| } |
| |
| pub(crate) fn from_elements(func_type: &FunctionType) -> Signature { |
| Signature { |
| params: func_type.params().iter().cloned().map(ValueType::from_elements).collect(), |
| return_type: func_type.return_type().map(ValueType::from_elements), |
| } |
| } |
| } |
| |
| /// Type of a value. |
| /// |
| /// See [`RuntimeValue`] for details. |
| /// |
| /// [`RuntimeValue`]: enum.RuntimeValue.html |
| #[derive(Copy, Clone, Debug, PartialEq, Eq)] |
| pub enum ValueType { |
| /// 32-bit signed or unsigned integer. |
| I32, |
| /// 64-bit signed or unsigned integer. |
| I64, |
| /// 32-bit IEEE 754-2008 floating point number. |
| F32, |
| /// 64-bit IEEE 754-2008 floating point number. |
| F64, |
| } |
| |
| 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, |
| } |
| } |
| } |
| |
| /// Description of a global variable. |
| /// |
| /// Primarly used to describe imports of global variables. |
| /// See [`ImportResolver`] for details. |
| /// |
| /// [`ImportResolver`]: trait.ImportResolver.html |
| pub struct GlobalDescriptor { |
| value_type: ValueType, |
| mutable: bool, |
| } |
| |
| impl GlobalDescriptor { |
| pub(crate) fn from_elements(global_type: &GlobalType) -> GlobalDescriptor { |
| GlobalDescriptor { |
| value_type: ValueType::from_elements(global_type.content_type()), |
| mutable: global_type.is_mutable(), |
| } |
| } |
| |
| /// Returns [`ValueType`] of the requested global. |
| /// |
| /// [`ValueType`]: enum.ValueType.html |
| pub fn value_type(&self) -> ValueType { |
| self.value_type |
| } |
| |
| /// Returns whether the requested global mutable. |
| pub fn is_mutable(&self) -> bool { |
| self.mutable |
| } |
| } |
| |
| /// Description of a table. |
| /// |
| /// Primarly used to describe imports of tables. |
| /// See [`ImportResolver`] for details. |
| /// |
| /// [`ImportResolver`]: trait.ImportResolver.html |
| 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(), |
| } |
| } |
| |
| /// Returns initial size of the requested table. |
| pub fn initial(&self) -> u32 { |
| self.initial |
| } |
| |
| /// Returns maximum size of the requested table. |
| pub fn maximum(&self) -> Option<u32> { |
| self.maximum |
| } |
| } |
| |
| /// Description of a linear memory. |
| /// |
| /// Primarly used to describe imports of linear memories. |
| /// See [`ImportResolver`] for details. |
| /// |
| /// [`ImportResolver`]: trait.ImportResolver.html |
| 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(), |
| } |
| } |
| |
| /// Returns initial size (in pages) of the requested memory. |
| pub fn initial(&self) -> u32 { |
| self.initial |
| } |
| |
| /// Returns maximum size (in pages) of the requested memory. |
| pub fn maximum(&self) -> Option<u32> { |
| self.maximum |
| } |
| } |