wasmi/src/types.rs

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.
///
/// 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.
///
#[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.
	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
	}
}