wasmer 0.4.0 → 0.5.0

data/src/instance/globals.rs

@@ -1,234 +0,0 @@
-//! The `ExportedGlobals` WebAssembly class.
-
-use crate::error::unwrap_or_raise;
-use lazy_static::lazy_static;
-use rutie::{
-    class, methods,
-    rubysys::class,
-    types::{Argc, Value},
-    util::str_to_cstring,
-    wrappable_struct, AnyException, AnyObject, Array, Boolean, Exception, Fixnum, Float, Module,
-    NilClass, Object, Symbol,
-};
-use std::rc::Rc;
-use wasmer_runtime::{
-    self as runtime, types::Type as WasmType, Export, Global, Value as WasmValue,
-};
-
-/// The `ExportedGlobals` Ruby class.
-pub struct ExportedGlobals {
-    /// The WebAssembly runtime.
-    instance: Rc<runtime::Instance>,
-}
-
-impl ExportedGlobals {
-    /// Create a new instance of the `ExportedGlobals` Ruby class.
-    pub fn new(instance: Rc<runtime::Instance>) -> Self {
-        Self { instance }
-    }
-
-    /// Check that an exported function exists.
-    pub fn respond_to_missing(&self, method_name: &str) -> bool {
-        self.instance
-            .exports()
-            .any(|(export_name, export)| match export {
-                Export::Global(_) if export_name == method_name => true,
-                _ => false,
-            })
-    }
-
-    /// Call an exported function on the given WebAssembly instance.
-    pub fn method_missing(
-        &self,
-        method_name: &str,
-        _arguments: Array,
-    ) -> Result<ExportedGlobal, AnyException> {
-        let global = self
-            .instance
-            .exports()
-            .find_map(|(export_name, export)| match export {
-                Export::Global(global) if export_name == method_name => Some(global),
-                _ => None,
-            })
-            .ok_or_else(|| {
-                AnyException::new(
-                    "RuntimeError",
-                    Some(&format!("Global `{}` does not exist.", method_name)),
-                )
-            })?;
-
-        Ok(ExportedGlobal {
-            global_name: method_name.to_string(),
-            global: Rc::new(global),
-        })
-    }
-}
-
-wrappable_struct!(
-    ExportedGlobals,
-    ExportedGlobalsWrapper,
-    EXPORTED_GLOBALS_WRAPPER
-);
-
-class!(RubyExportedGlobals);
-
-#[rustfmt::skip]
-methods!(
-    RubyExportedGlobals,
-    itself,
-
-    // Glue code to call the `Exportedglobals.respond_to` method.
-    fn ruby_exported_globals_method_exists(symbol: Symbol, _include_private: Boolean) -> Boolean {
-        unwrap_or_raise(|| {
-            let symbol = symbol?;
-            let exported_globals = itself.get_data(&*EXPORTED_GLOBALS_WRAPPER);
-
-            Ok(Boolean::new(exported_globals.respond_to_missing(symbol.to_str())))
-        })
-    }
-);
-
-/// Glue code to call the `ExportedGlobals.method_missing` method.
-pub extern "C" fn ruby_exported_globals_method_missing(
-    argc: Argc,
-    argv: *const AnyObject,
-    itself: RubyExportedGlobals,
-) -> RubyExportedGlobal {
-    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 mut arguments = Array::from(arguments);
-        let method_name = unsafe { arguments.shift().to::<Symbol>() };
-        let method_name = method_name.to_str();
-
-        Ok(Module::from_existing("Wasmer")
-            .get_nested_class("ExportedGlobal")
-            .wrap_data(
-                itself
-                    .get_data(&*EXPORTED_GLOBALS_WRAPPER)
-                    .method_missing(method_name, arguments)?,
-                &*EXPORTED_GLOBAL_WRAPPER,
-            ))
-    })
-}
-
-#[allow(unused)]
-/// The `ExportedGlobal` Ruby class.
-pub struct ExportedGlobal {
-    /// The exported global name from the WebAssembly instance.
-    global_name: String,
-
-    /// The exported global from the WebAssembly instance.
-    global: Rc<Global>,
-}
-
-impl ExportedGlobal {
-    pub fn get_value(&self) -> WasmValue {
-        self.global.get()
-    }
-
-    pub fn set_value(&self, value: WasmValue) {
-        self.global.set(value);
-    }
-
-    pub fn mutable(&self) -> bool {
-        self.global.descriptor().mutable
-    }
-
-    fn ty(&self) -> WasmType {
-        self.global.descriptor().ty
-    }
-}
-
-wrappable_struct!(
-    ExportedGlobal,
-    ExportedGlobalWrapper,
-    EXPORTED_GLOBAL_WRAPPER
-);
-
-class!(RubyExportedGlobal);
-
-#[rustfmt::skip]
-methods!(
-    RubyExportedGlobal,
-    itself,
-
-    // Glue code to call the `ExportedGlobal.get_value` method.
-    fn ruby_exported_global_get_value() -> AnyObject {
-        unwrap_or_raise(|| {
-            let exported_global = itself.get_data(&*EXPORTED_GLOBAL_WRAPPER);
-
-            Ok(match exported_global.get_value() {
-                WasmValue::I32(result) => Fixnum::new(result as i64).to_any_object(),
-                WasmValue::I64(result) => Fixnum::new(result).to_any_object(),
-                WasmValue::F32(result) => Float::new(result as f64).to_any_object(),
-                WasmValue::F64(result) => Float::new(result).to_any_object(),
-                WasmValue::V128(_result) => {
-                    return Err(AnyException::new(
-                        "RuntimeError",
-                        Some("Type `V128` isn't supported yet."),
-                    ))
-                }
-            })
-        })
-    }
-
-    // Glue code to call the `ExportedGlobal.set_value` method.
-    fn ruby_exported_global_set_value(value: AnyObject) -> NilClass {
-        unwrap_or_raise(|| {
-            let exported_global = itself.get_data(&*EXPORTED_GLOBAL_WRAPPER);
-
-            if !exported_global.mutable() {
-                return Err(AnyException::new(
-                    "RuntimeError",
-                    Some(&format!(
-                        "The global variable `{}` is not mutable, cannot set a new value.",
-                        exported_global.global_name
-                    )),
-                ));
-            }
-
-            let value = value?;
-
-            let wasm_type = exported_global.ty();
-            let wasm_value = match wasm_type {
-                WasmType::I32 if value.is_fixnum() => {
-                    WasmValue::I32(unsafe { value.to::<Fixnum>().to_i32() })
-                }
-                WasmType::I64 if value.is_fixnum() => {
-                    WasmValue::I64(unsafe { value.to::<Fixnum>().to_i64() })
-                }
-                WasmType::F32 if value.is_flonum() => {
-                    WasmValue::F32(unsafe { value.to::<Float>().to_f64() as f32 })
-                }
-                WasmType::F64 if value.is_flonum() => {
-                    WasmValue::F64(unsafe { value.to::<Float>().to_f64() })
-                }
-                _ => {
-                    return Err(AnyException::new(
-                        "TypeError",
-                        Some(&format!(
-                            "Failed to set `{:?}` to the global `{}` (with type `{}`).",
-                            value, exported_global.global_name, wasm_type
-                        )),
-                    ))
-                }
-            };
-
-            exported_global.set_value(wasm_value);
-
-            Ok(NilClass::new())
-        })
-    }
-
-    // Glue code to call the `ExportedGlobal.mutable` getter.
-    fn ruby_exported_global_mutable() -> Boolean {
-        Boolean::new(itself.get_data(&*EXPORTED_GLOBAL_WRAPPER).mutable())
-    }
-);

data/src/instance/mod.rs

@@ -1,141 +0,0 @@
-//! The `Instance` WebAssembly class.
-
-pub mod exports;
-pub mod globals;
-
-use crate::{
-    error::unwrap_or_raise,
-    instance::{
-        exports::{ExportedFunctions, RubyExportedFunctions, EXPORTED_FUNCTIONS_WRAPPER},
-        globals::{ExportedGlobals, RubyExportedGlobals, EXPORTED_GLOBALS_WRAPPER},
-    },
-    memory::{Memory, RubyMemory, MEMORY_WRAPPER},
-};
-use lazy_static::lazy_static;
-use rutie::{
-    class, methods, wrappable_struct, AnyException, AnyObject, Exception, Module, NilClass, Object,
-    RString,
-};
-use std::rc::Rc;
-use wasmer_runtime::{self as runtime, imports, Export};
-
-/// The `Instance` Ruby class.
-pub struct Instance {
-    /// The WebAssembly instance.
-    instance: Rc<runtime::Instance>,
-}
-
-impl Instance {
-    /// Create a new instance of the `Instance` Ruby class.
-    /// The constructor receives bytes from a string.
-    pub fn new(bytes: &[u8]) -> Result<Self, AnyException> {
-        let import_object = imports! {};
-
-        Ok(Self {
-            instance: Rc::new(runtime::instantiate(bytes, &import_object).map_err(|e| {
-                AnyException::new(
-                    "RuntimeError",
-                    Some(&format!("Failed to instantiate the module:\n    {}", e)),
-                )
-            })?),
-        })
-    }
-}
-
-wrappable_struct!(Instance, InstanceWrapper, INSTANCE_WRAPPER);
-
-class!(RubyInstance);
-
-#[rustfmt::skip]
-methods!(
-    RubyInstance,
-    _itself,
-
-    // Glue code to call the `Instance.new` method.
-    fn ruby_instance_new(bytes: RString) -> AnyObject {
-        unwrap_or_raise(|| {
-            let instance = Instance::new(
-                bytes
-                    .map_err(|_| {
-                        AnyException::new(
-                            "ArgumentError",
-                            Some("WebAssembly module must be represented by Ruby bytes only."),
-                        )
-                    })?
-                    .to_bytes_unchecked(),
-            )?;
-            let exported_functions = ExportedFunctions::new(instance.instance.clone());
-            let exported_globals = ExportedGlobals::new(instance.instance.clone());
-            let exported_memory =
-                instance
-                    .instance
-                    .exports()
-                    .find_map(|(_, export)| match export {
-                        Export::Memory(memory) => Some(Memory::new(Rc::new(memory))),
-                        _ => None,
-                    });
-
-            let wasmer_module = Module::from_existing("Wasmer");
-
-            let mut ruby_instance: AnyObject = wasmer_module
-                .get_nested_class("Instance")
-                .wrap_data(instance, &*INSTANCE_WRAPPER);
-
-            let ruby_exported_functions: RubyExportedFunctions = wasmer_module
-                .get_nested_class("ExportedFunctions")
-                .wrap_data(exported_functions, &*EXPORTED_FUNCTIONS_WRAPPER);
-
-            let ruby_exported_globals: RubyExportedGlobals = wasmer_module
-                .get_nested_class("ExportedGlobals")
-                .wrap_data(exported_globals, &*EXPORTED_GLOBALS_WRAPPER);
-
-            ruby_instance.instance_variable_set("@exports", ruby_exported_functions);
-            ruby_instance.instance_variable_set("@globals", ruby_exported_globals);
-
-            if let Some(exported_memory) = exported_memory {
-                let ruby_exported_memory: RubyMemory = wasmer_module
-                    .get_nested_class("Memory")
-                    .wrap_data(exported_memory, &*MEMORY_WRAPPER);
-                ruby_instance.instance_variable_set("@memory", ruby_exported_memory);
-            } else {
-                ruby_instance.instance_variable_set("@memory", NilClass::new());
-            }
-
-            Ok(ruby_instance)
-        })
-    }
-
-    // Glue code to call the `Instance.exports` getter method.
-    fn ruby_instance_exported_functions() -> RubyExportedFunctions {
-        unsafe {
-            _itself
-                .instance_variable_get("@exports")
-                .to::<RubyExportedFunctions>()
-        }
-    }
-
-    // Glue code to call the `Instance.globals` getter method.
-    fn ruby_instance_exported_globals() -> RubyExportedGlobals {
-        unsafe {
-            _itself
-                .instance_variable_get("@globals")
-                .to::<RubyExportedGlobals>()
-        }
-    }
-
-    // Glue code to call the `Instance.memory` getter method.
-    fn ruby_instance_memory() -> RubyMemory {
-        unwrap_or_raise(|| {
-            let memory = _itself.instance_variable_get("@memory");
-
-            if !memory.is_nil() {
-                Ok(unsafe { memory.to::<RubyMemory>() })
-            } else {
-                Err(AnyException::new(
-                    "RuntimeError",
-                    Some("The WebAssembly module has no exported memory."),
-                ))
-            }
-        })
-    }
-);

data/src/lib.rs

@@ -1,162 +0,0 @@
-#![deny(warnings)]
-
-use rutie::{Class, Module, Object};
-
-pub mod error;
-pub mod instance;
-pub mod memory;
-pub mod module;
-
-#[allow(non_snake_case)]
-#[no_mangle]
-pub extern "C" fn Init_wasmer() {
-    let mut wasmer_module = Module::from_existing("Wasmer");
-
-    let instance_data_class = Class::from_existing("Object");
-
-    // Declare the `Instance` Ruby class.
-    wasmer_module
-        .define_nested_class("Instance", Some(&instance_data_class))
-        .define(|itself| {
-            // Declare the `self.new` method.
-            itself.def_self("new", instance::ruby_instance_new);
-
-            // Declare the `exports` getter method.
-            itself.def("exports", instance::ruby_instance_exported_functions);
-
-            // Declare the `globals` getter method.
-            itself.def("globals", instance::ruby_instance_exported_globals);
-
-            // Declare the `memory` getter method.
-            itself.def("memory", instance::ruby_instance_memory);
-        });
-
-    let exported_functions_data_class = Class::from_existing("Object");
-
-    // Declare the `ExportedFunctions` Ruby class.
-    wasmer_module
-        .define_nested_class("ExportedFunctions", Some(&exported_functions_data_class))
-        .define(|itself| {
-            // Declare the `respond_to_missing?` method.
-            itself.def(
-                "respond_to_missing?",
-                instance::exports::ruby_exported_functions_method_exists,
-            );
-
-            // Declare the `method_missing` method.
-            itself.def(
-                "method_missing",
-                instance::exports::ruby_exported_functions_method_missing,
-            );
-        });
-
-    let exported_globals_data_class = Class::from_existing("Object");
-
-    // Declare the `ExportedGlobals` Ruby class.
-    wasmer_module
-        .define_nested_class("ExportedGlobals", Some(&exported_globals_data_class))
-        .define(|itself| {
-            // Declare the `respond_to_missing?` method.
-            itself.def(
-                "respond_to_missing?",
-                instance::globals::ruby_exported_globals_method_exists,
-            );
-
-            // Declare the `method_missing` method.
-            itself.def(
-                "method_missing",
-                instance::globals::ruby_exported_globals_method_missing,
-            );
-        });
-
-    let exported_global_data_class = Class::from_existing("Object");
-
-    // Declare the `ExportedGlobal` Ruby class.
-    wasmer_module
-        .define_nested_class("ExportedGlobal", Some(&exported_global_data_class))
-        .define(|itself| {
-            // Declare the `value` getter.
-            itself.def("value", instance::globals::ruby_exported_global_get_value);
-
-            // Declare the `value` setter.
-            itself.def("value=", instance::globals::ruby_exported_global_set_value);
-
-            // Declare the `mutable` getter.
-            itself.def("mutable", instance::globals::ruby_exported_global_mutable);
-        });
-
-    let module_data_class = Class::from_existing("Object");
-
-    // Declare the `Module` Ruby class.
-    wasmer_module
-        .define_nested_class("Module", Some(&module_data_class))
-        .define(|itself| {
-            // Declare the `self.validate` method.
-            itself.def_self("validate", module::ruby_module_validate);
-        });
-
-    let memory_data_class = Class::from_existing("Object");
-
-    // Declare the `Memory` Ruby class.
-    wasmer_module
-        .define_nested_class("Memory", Some(&memory_data_class))
-        .define(|itself| {
-            // Declare the `grow` method.
-            itself.def("grow", memory::ruby_memory_grow);
-
-            // Declare the `view` method.
-            itself.def("uint8_view", memory::ruby_memory_uint8array);
-
-            // Declare the `view` method.
-            itself.def("int8_view", memory::ruby_memory_int8array);
-
-            // Declare the `view` method.
-            itself.def("uint16_view", memory::ruby_memory_uint16array);
-
-            // Declare the `view` method.
-            itself.def("int16_view", memory::ruby_memory_int16array);
-
-            // Declare the `view` method.
-            itself.def("uint32_view", memory::ruby_memory_uint32array);
-
-            // Declare the `view` method.
-            itself.def("int32_view", memory::ruby_memory_int32array);
-        });
-
-    macro_rules! memory_view {
-        ($class_name:ident in $mod_name:ident) => {
-            let uint8array_data_class = Class::from_existing("Object");
-
-            // Declare the `MemoryView` Ruby class.
-            wasmer_module
-                .define_nested_class(stringify!($class_name), Some(&uint8array_data_class))
-                .define(|itself| {
-                    // Declare the `bytes_per_element` getter method.
-                    itself.def(
-                        "bytes_per_element",
-                        memory::view::$mod_name::ruby_memory_view_bytes_per_element,
-                    );
-
-                    // Declare the `length` method.
-                    itself.def("length", memory::view::$mod_name::ruby_memory_view_length);
-
-                    // Declare the `[]=` (set) method.
-                    itself.def("[]=", memory::view::$mod_name::ruby_memory_view_set);
-
-                    // Declare the `[]` (get) method.
-                    itself.def("[]", memory::view::$mod_name::ruby_memory_view_get);
-
-                    // Declare the `each` method.
-                    itself.def("each", memory::view::$mod_name::ruby_memory_view_each);
-                })
-                .include("Enumerable");
-        };
-    }
-
-    memory_view!(Uint8Array in uint8array);
-    memory_view!(Int8Array in int8array);
-    memory_view!(Uint16Array in uint16array);
-    memory_view!(Int16Array in int16array);
-    memory_view!(Uint32Array in uint32array);
-    memory_view!(Int32Array in int32array);
-}