wasmer 0.1.1 → 1.0.0

data/crates/wasmer/src/error.rs

@@ -0,0 +1,55 @@
+//! Functions to handle error or exception correctly.
+
+use rutie::{AnyException, Exception, VM};
+
+pub type RubyResult<T> = Result<T, AnyException>;
+
+#[allow(unused)]
+pub(crate) fn unwrap_or_raise<Output, Function>(f: Function) -> Output
+where
+    Function: FnOnce() -> Result<Output, AnyException>,
+{
+    match f() {
+        Ok(x) => x,
+        Err(e) => {
+            VM::raise_ex(e);
+            unreachable!()
+        }
+    }
+}
+
+pub trait ErrorType {
+    fn name() -> &'static str;
+}
+
+macro_rules! declare_error {
+    ($name:ident) => {
+        pub struct $name;
+
+        impl ErrorType for $name {
+            fn name() -> &'static str {
+                stringify!($name)
+            }
+        }
+    };
+
+    ( $( $name:ident ),+ $(,)? ) => {
+        $( declare_error!($name); )*
+    }
+}
+
+declare_error!(
+    ArgumentError,
+    IndexError,
+    NameError,
+    RuntimeError,
+    TypeError,
+);
+
+pub fn to_ruby_err<Type, Error>(error: Error) -> AnyException
+where
+    Type: ErrorType,
+    Error: ToString,
+{
+    AnyException::new(Type::name(), Some(error.to_string().as_ref()))
+}

data/crates/wasmer/src/exports.rs

@@ -0,0 +1,107 @@
+use crate::{
+    error::{to_ruby_err, RuntimeError},
+    prelude::*,
+};
+use rutie::{Boolean, Fixnum, Symbol};
+use std::convert::TryInto;
+
+#[rubyclass(module = "Wasmer")]
+pub struct Exports {
+    inner: wasmer::Exports,
+}
+
+impl Exports {
+    pub fn new(inner: wasmer::Exports) -> Self {
+        Self { inner }
+    }
+
+    pub(crate) fn inner(&self) -> &wasmer::Exports {
+        &self.inner
+    }
+}
+
+#[rubymethods]
+impl Exports {
+    pub fn respond_to_missing(
+        &self,
+        symbol: &Symbol,
+        _include_private: &Boolean,
+    ) -> RubyResult<Boolean> {
+        Ok(Boolean::new(self.inner().contains(symbol.to_str())))
+    }
+
+    pub fn length(&self) -> RubyResult<Fixnum> {
+        Ok(Fixnum::new(
+            self.inner()
+                .len()
+                .try_into()
+                .map_err(to_ruby_err::<RuntimeError, _>)?,
+        ))
+    }
+}
+
+pub(crate) mod ruby_exports_extra {
+    use crate::{
+        error::{to_ruby_err, unwrap_or_raise, ArgumentError, NameError},
+        externals::{Function, Global, Memory, Table},
+    };
+    use rutie::{
+        rubysys::class,
+        types::{Argc, Value},
+        util::str_to_cstring,
+        AnyObject, Array, Object, Symbol,
+    };
+    use rutie_derive::UpcastRubyClass;
+
+    #[allow(improper_ctypes_definitions)] // No choice, that's how `rutie` is designed.
+    pub extern "C" fn method_missing(
+        argc: Argc,
+        argv: *const AnyObject,
+        itself: super::RubyExports,
+    ) -> AnyObject {
+        unwrap_or_raise(|| {
+            let arguments = Value::from(0);
+
+            unsafe {
+                let argv_pointer = argv as *const Value;
+
+                class::rb_scan_args(argc, argv_pointer, str_to_cstring("*").as_ptr(), &arguments)
+            };
+
+            let exports = itself.upcast();
+            let mut arguments = Array::from(arguments);
+
+            let extern_name = arguments.shift().try_convert_to::<Symbol>()?;
+            let extern_name = extern_name.to_str();
+
+            if arguments.length() > 1 {
+                return Err(to_ruby_err::<ArgumentError, _>(format!(
+                    "`Export::method_missing` has been called with more than one argument (`{name}` plus {number_of_arguments} extra argument(s)). If you are trying to call an exported WebAssembly function, use the following form: `exports.{name}.(arguments…)`",
+                    name = extern_name,
+                    number_of_arguments = arguments.length(),
+                )));
+            }
+
+            Ok(match exports.inner().get_extern(extern_name) {
+                Some(wasmer::Extern::Function(function)) => {
+                    Function::ruby_new(Function::raw_new(function.clone())).to_any_object()
+                }
+                Some(wasmer::Extern::Memory(memory)) => {
+                    Memory::ruby_new(Memory::raw_new(memory.clone())).to_any_object()
+                }
+                Some(wasmer::Extern::Global(global)) => {
+                    Global::ruby_new(Global::raw_new(global.clone())).to_any_object()
+                }
+                Some(wasmer::Extern::Table(table)) => {
+                    Table::ruby_new(Table::raw_new(table.clone())).to_any_object()
+                }
+                None => {
+                    return Err(to_ruby_err::<NameError, _>(format!(
+                        "Export `{}` does not exist",
+                        extern_name
+                    )))
+                }
+            })
+        })
+    }
+}

data/crates/wasmer/src/externals/function.rs

@@ -0,0 +1,159 @@
+use crate::{
+    error::{to_ruby_err, TypeError},
+    prelude::*,
+    store::Store,
+    types::FunctionType,
+    values::{to_ruby_object, to_wasm_value},
+};
+use rutie::{util::is_method, AnyObject, Array, Object, Proc, Symbol};
+use std::sync::Arc;
+
+#[derive(Clone)]
+struct Callable(Arc<dyn Fn(&[AnyObject]) -> AnyObject>);
+
+unsafe impl Send for Callable {}
+unsafe impl Sync for Callable {}
+
+#[rubyclass(module = "Wasmer")]
+pub struct Function {
+    inner: wasmer::Function,
+}
+
+impl Function {
+    pub fn raw_new(inner: wasmer::Function) -> Self {
+        Self { inner }
+    }
+
+    pub(crate) fn inner(&self) -> &wasmer::Function {
+        &self.inner
+    }
+}
+
+#[rubymethods]
+impl Function {
+    pub fn new(
+        store: &Store,
+        function: &AnyObject,
+        function_type: &FunctionType,
+    ) -> RubyResult<AnyObject> {
+        let function = Callable(if let Ok(symbol) = function.try_convert_to::<Symbol>() {
+            Arc::new(move |arguments| symbol.to_proc().call(arguments))
+        } else if let Ok(proc) = function.try_convert_to::<Proc>() {
+            Arc::new(move |arguments| proc.call(arguments))
+        } else if is_method(*function.as_ref()) {
+            let function = function.clone();
+
+            Arc::new(move |arguments| unsafe { function.send("call", arguments) })
+        } else {
+            return Err(to_ruby_err::<TypeError, _>(
+                "Argument #1 of `Function.new` must be either a `Symbol`, a `Proc`, or a `Method`",
+            ));
+        });
+
+        let function_type: wasmer::FunctionType = function_type.into();
+
+        #[derive(wasmer::WasmerEnv, Clone)]
+        struct Environment {
+            ruby_callable: Callable,
+            result_types: Vec<wasmer::Type>,
+        }
+
+        let environment = Environment {
+            ruby_callable: function,
+            result_types: function_type.results().to_vec(),
+        };
+
+        let host_function = wasmer::Function::new_with_env(
+            store.inner(),
+            function_type,
+            environment,
+            |environment,
+             arguments: &[wasmer::Value]|
+             -> Result<Vec<wasmer::Value>, wasmer::RuntimeError> {
+                let arguments = arguments.iter().map(to_ruby_object).collect::<Vec<_>>();
+
+                let ruby_callable = &environment.ruby_callable.0;
+                let results = ruby_callable(&arguments);
+
+                let result_types = &environment.result_types;
+                let has_result_types = !result_types.is_empty();
+
+                Ok(if let Ok(results) = results.try_convert_to::<Array>() {
+                    results
+                        .into_iter()
+                        .zip(result_types)
+                        .map(|(value, ty)| to_wasm_value((&value, *ty)))
+                        .collect::<RubyResult<_>>()
+                        .map_err(|error| wasmer::RuntimeError::new(error.to_string()))?
+                } else if !results.is_nil() && has_result_types {
+                    vec![to_wasm_value((&results, result_types[0]))
+                        .map_err(|error| wasmer::RuntimeError::new(error.to_string()))?]
+                } else {
+                    Vec::new()
+                })
+            },
+        );
+
+        Ok(Function::ruby_new(Function {
+            inner: host_function,
+        }))
+    }
+
+    pub fn r#type(&self) -> RubyResult<AnyObject> {
+        Ok(FunctionType::ruby_new(self.inner().ty().into()))
+    }
+}
+
+pub(crate) mod ruby_function_extra {
+    use crate::{
+        error::{to_ruby_err, unwrap_or_raise, RubyResult, RuntimeError},
+        values::{to_ruby_object, to_wasm_value},
+    };
+    use rutie::{
+        rubysys::class,
+        types::{Argc, Value},
+        util::str_to_cstring,
+        AnyObject, Array, NilClass, Object,
+    };
+    use rutie_derive::UpcastRubyClass;
+
+    #[allow(improper_ctypes_definitions)] // No choice, that's how `rutie` is designed.
+    pub extern "C" fn call(
+        argc: Argc,
+        argv: *const AnyObject,
+        itself: super::RubyFunction,
+    ) -> AnyObject {
+        unwrap_or_raise(|| {
+            let arguments = Value::from(0);
+
+            unsafe {
+                let argv_pointer = argv as *const Value;
+
+                class::rb_scan_args(argc, argv_pointer, str_to_cstring("*").as_ptr(), &arguments)
+            };
+
+            let function = itself.upcast();
+            let arguments: Vec<wasmer::Value> = Array::from(arguments)
+                .into_iter()
+                .zip(function.inner().ty().params())
+                .map(|(value, ty)| to_wasm_value((&value, *ty)))
+                .collect::<RubyResult<_>>()?;
+
+            let results = function
+                .inner()
+                .call(&arguments)
+                .map(<[_]>::into_vec)
+                .map_err(to_ruby_err::<RuntimeError, _>)?;
+
+            Ok(match results.len() {
+                0 => NilClass::new().to_any_object(),
+                1 => to_ruby_object(&results[0]),
+                _ => results
+                    .iter()
+                    .map(to_ruby_object)
+                    .collect::<Array>()
+                    .to_any_object(),
+            })
+        })
+    }
+}

data/crates/wasmer/src/externals/global.rs

@@ -0,0 +1,62 @@
+use crate::{
+    error::{to_ruby_err, RuntimeError},
+    prelude::*,
+    store::Store,
+    types::GlobalType,
+    values::{to_ruby_object, to_wasm_value, Value},
+};
+use rutie::{AnyObject, Boolean, NilClass};
+
+#[rubyclass(module = "Wasmer")]
+pub struct Global {
+    inner: wasmer::Global,
+}
+
+impl Global {
+    pub fn raw_new(inner: wasmer::Global) -> Self {
+        Self { inner }
+    }
+
+    pub(crate) fn inner(&self) -> &wasmer::Global {
+        &self.inner
+    }
+}
+
+#[rubymethods]
+impl Global {
+    pub fn new(store: &Store, value: &Value, mutable: &Boolean) -> RubyResult<AnyObject> {
+        Ok(Global::ruby_new(Global::raw_new(if mutable.to_bool() {
+            wasmer::Global::new_mut(store.inner(), value.inner().clone())
+        } else {
+            wasmer::Global::new(store.inner(), value.inner().clone())
+        })))
+    }
+
+    pub fn mutable(&self) -> RubyResult<Boolean> {
+        Ok(Boolean::new(self.inner().ty().mutability.is_mutable()))
+    }
+
+    pub fn get_value(&self) -> RubyResult<AnyObject> {
+        Ok(to_ruby_object(&self.inner.get()))
+    }
+
+    pub fn set_value(&self, value: &AnyObject) -> RubyResult<NilClass> {
+        let ty = self.inner().ty();
+
+        if !ty.mutability.is_mutable() {
+            return Err(to_ruby_err::<RuntimeError, _>(
+                "The global variable is not mutable, cannot set a new value",
+            ));
+        }
+
+        self.inner()
+            .set(to_wasm_value((value, ty.ty))?)
+            .map_err(to_ruby_err::<RuntimeError, _>)?;
+
+        Ok(NilClass::new())
+    }
+
+    pub fn r#type(&self) -> RubyResult<AnyObject> {
+        Ok(GlobalType::ruby_new(self.inner().ty().into()))
+    }
+}

data/crates/wasmer/src/externals/memory.rs

@@ -0,0 +1,117 @@
+use crate::{
+    error::{to_ruby_err, ArgumentError, RuntimeError},
+    memory::views::{Int16Array, Int32Array, Int8Array, Uint16Array, Uint32Array, Uint8Array},
+    prelude::*,
+    store::Store,
+    types::MemoryType,
+};
+use rutie::{AnyObject, Fixnum, Integer, Object};
+use std::convert::{TryFrom, TryInto};
+
+#[rubyclass(module = "Wasmer")]
+pub struct Memory {
+    inner: wasmer::Memory,
+}
+
+impl Memory {
+    pub fn raw_new(inner: wasmer::Memory) -> Self {
+        Self { inner }
+    }
+
+    pub(crate) fn inner(&self) -> &wasmer::Memory {
+        &self.inner
+    }
+}
+
+fn unwrap_offset(offset: &AnyObject) -> RubyResult<usize> {
+    Ok(if offset.is_nil() {
+        0
+    } else {
+        offset
+            .try_convert_to::<Integer>()?
+            .to_u64()
+            .try_into()
+            .map_err(to_ruby_err::<ArgumentError, _>)?
+    })
+}
+
+#[rubymethods]
+impl Memory {
+    pub fn new(store: &Store, memory_type: &MemoryType) -> RubyResult<AnyObject> {
+        Ok(Memory::ruby_new(Memory::raw_new(
+            wasmer::Memory::new(store.inner(), memory_type.into())
+                .map_err(to_ruby_err::<RuntimeError, _>)?,
+        )))
+    }
+
+    pub fn r#type(&self) -> RubyResult<AnyObject> {
+        Ok(MemoryType::ruby_new(self.inner().ty().into()))
+    }
+
+    pub fn size(&self) -> RubyResult<Fixnum> {
+        Ok(Fixnum::new(self.inner().size().0.into()))
+    }
+
+    pub fn data_size(&self) -> RubyResult<Fixnum> {
+        Ok(Fixnum::new(
+            self.inner()
+                .data_size()
+                .try_into()
+                .map_err(to_ruby_err::<RuntimeError, _>)?,
+        ))
+    }
+
+    pub fn grow(&self, number_of_pages: &Fixnum) -> RubyResult<Fixnum> {
+        Ok(Fixnum::new(
+            self.inner()
+                .grow(
+                    u32::try_from(number_of_pages.to_u64())
+                        .map_err(to_ruby_err::<RuntimeError, _>)?,
+                )
+                .map_err(to_ruby_err::<RuntimeError, _>)
+                .and_then(|pages| pages.0.try_into().map_err(to_ruby_err::<RuntimeError, _>))?,
+        ))
+    }
+
+    pub fn uint8_view(&self, offset: &AnyObject) -> RubyResult<AnyObject> {
+        Ok(Uint8Array::ruby_new(Uint8Array::new(
+            self.inner().clone(),
+            unwrap_offset(offset)?,
+        )))
+    }
+
+    pub fn int8_view(&self, offset: &AnyObject) -> RubyResult<AnyObject> {
+        Ok(Int8Array::ruby_new(Int8Array::new(
+            self.inner().clone(),
+            unwrap_offset(offset)?,
+        )))
+    }
+
+    pub fn uint16_view(&self, offset: &AnyObject) -> RubyResult<AnyObject> {
+        Ok(Uint16Array::ruby_new(Uint16Array::new(
+            self.inner().clone(),
+            unwrap_offset(offset)?,
+        )))
+    }
+
+    pub fn int16_view(&self, offset: &AnyObject) -> RubyResult<AnyObject> {
+        Ok(Int16Array::ruby_new(Int16Array::new(
+            self.inner().clone(),
+            unwrap_offset(offset)?,
+        )))
+    }
+
+    pub fn uint32_view(&self, offset: &AnyObject) -> RubyResult<AnyObject> {
+        Ok(Uint32Array::ruby_new(Uint32Array::new(
+            self.inner().clone(),
+            unwrap_offset(offset)?,
+        )))
+    }
+
+    pub fn int32_view(&self, offset: &AnyObject) -> RubyResult<AnyObject> {
+        Ok(Int32Array::ruby_new(Int32Array::new(
+            self.inner().clone(),
+            unwrap_offset(offset)?,
+        )))
+    }
+}