wasmer 0.3.0 → 0.4.0

data/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 publish = false
 name = "ruby-ext-wasm"
-version = "0.3.0"
+version = "0.4.0"
 authors = ["Ivan Enderlin <ivan.enderlin@hoa-project.net>"]
 edition = "2018"
 description = "Ruby extension to run WebAssembly binaries"
@@ -15,7 +15,6 @@ name = "wasmer"
 crate-type = ["dylib"]
 
 [dependencies]
-wasmer-runtime = "0.5.5"
-wasmer-runtime-core = "0.5.5"
-rutie = "0.6.0"
-lazy_static = "1.3.0"
+wasmer-runtime = "0.14"
+rutie = "0.7"
+lazy_static = "1.4"

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019-present Wasmer, Inc. and its affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -1,6 +1,6 @@
 <p align="center">
-  <a href="https://wasmer.io" target="_blank" rel="noopener noreferrer">
-    <img width="400" src="https://raw.githubusercontent.com/wasmerio/wasmer/master/logo.png" alt="Wasmer logo">
+  <a href="https://wasmer.io" target="_blank" rel="noopener">
+    <img width="300" src="https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/logo.png" alt="Wasmer logo">
   </a>
 </p>
 
@@ -76,7 +76,8 @@ $ ruby simple.rb
 
 ## The `Instance` class
 
-Instantiates a WebAssembly module represented by bytes, and calls exported functions on it:
+Instantiates a WebAssembly module represented by bytes, and calls
+exported functions on it:
 
 ```ruby
 require "wasmer"
@@ -93,10 +94,14 @@ result = instance.exports.sum 1, 2
 puts result # 3
 ```
 
+### Exported functions
+
 All exported functions are accessible on the `exports`
 getter. Arguments of these functions are automatically casted to
 WebAssembly values.
 
+### Exported memory
+
 The `memory` getter exposes the `Memory` class representing the memory
 of that particular instance, e.g.:
 
@@ -104,8 +109,30 @@ of that particular instance, e.g.:
 view = instance.memory.uint8_view
 ```
 
+`Instance.memory` throws an exception if no memory is exported.
+
 See below for more information.
 
+### Exported globals
+
+The `globals` getter exposes the `ExportedGlobal` class represented an
+exported global variable, e.g.:
+
+```ruby
+# Get the `x` global.
+x = instance.globals.x
+
+# Check whether the global is mutable.
+assert x.mutable
+assert_equal x.value, 7
+
+# Update its value.
+x.value = 42
+
+# Tada!
+assert_equal x.value, 42
+```
+
 ## The `Memory` class
 
 A WebAssembly instance has its own memory, represented by the `Memory`

data/bors.toml

@@ -1,4 +1,6 @@
-status = [ "ci/circleci: build-and-test" ]
+status = [
+    "Test (ubuntu-latest)",
+]
 required_approvals = 0
 timeout_sec = 900
 delete_merged_branches = true 

data/lib/wasmer/version.rb

@@ -1,3 +1,3 @@
 module Wasmer
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/src/{instance.rs → instance/exports.rs}

@@ -1,21 +1,17 @@
-//! The `Instance` WebAssembly class.
+//! The `ExportedFunctions` WebAssembly class.
 
-use crate::{
-    error::unwrap_or_raise,
-    memory::{Memory, RubyMemory, MEMORY_WRAPPER},
-};
+use crate::error::unwrap_or_raise;
 use lazy_static::lazy_static;
 use rutie::{
     class, methods,
     rubysys::{class, value::ValueType},
     types::{Argc, Value},
     util::str_to_cstring,
-    wrappable_struct, AnyException, AnyObject, Array, Boolean, Exception, Fixnum, Float, Module,
-    NilClass, Object, RString, Symbol,
+    wrappable_struct, AnyException, AnyObject, Array, Boolean, Exception, Fixnum, Float, NilClass,
+    Object, Symbol,
 };
-use std::{mem, rc::Rc};
-use wasmer_runtime::{self as runtime, imports, Export};
-use wasmer_runtime_core::types::Type;
+use std::rc::Rc;
+use wasmer_runtime::{self as runtime, types::Type};
 
 /// The `ExportedFunctions` Ruby class.
 pub struct ExportedFunctions {
@@ -150,12 +146,18 @@ impl ExportedFunctions {
             .call(function_arguments.as_slice())
             .map_err(|e| AnyException::new("RuntimeError", Some(&format!("{}", e))))?;
 
-        if results.len() > 0 {
+        if !results.is_empty() {
             Ok(match results[0] {
                 runtime::Value::I32(result) => Fixnum::new(result as i64).into(),
                 runtime::Value::I64(result) => Fixnum::new(result).into(),
                 runtime::Value::F32(result) => Float::new(result as f64).into(),
                 runtime::Value::F64(result) => Float::new(result).into(),
+                runtime::Value::V128(_result) => {
+                    return Err(AnyException::new(
+                        "RuntimeError",
+                        Some("Type `V128` isn't supported yet."),
+                    ))
+                }
             })
         } else {
             Ok(NilClass::new().into())
@@ -180,9 +182,9 @@ methods!(
     fn ruby_exported_functions_method_exists(symbol: Symbol, _include_private: Boolean) -> Boolean {
         unwrap_or_raise(|| {
             let symbol = symbol?;
-            let instance = itself.get_data(&*EXPORTED_FUNCTIONS_WRAPPER);
+            let exported_functions = itself.get_data(&*EXPORTED_FUNCTIONS_WRAPPER);
 
-            Ok(Boolean::new(instance.respond_to_missing(symbol.to_str())))
+            Ok(Boolean::new(exported_functions.respond_to_missing(symbol.to_str())))
         })
     }
 );
@@ -197,7 +199,7 @@ pub extern "C" fn ruby_exported_functions_method_missing(
         let arguments = Value::from(0);
 
         unsafe {
-            let argv_pointer: *const Value = mem::transmute(argv);
+            let argv_pointer = argv as *const Value;
 
             class::rb_scan_args(argc, argv_pointer, str_to_cstring("*").as_ptr(), &arguments)
         };
@@ -211,101 +213,3 @@ pub extern "C" fn ruby_exported_functions_method_missing(
             .method_missing(method_name, arguments)
     })
 }
-
-/// 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 memory = instance
-                .instance
-                .exports()
-                .find_map(|(_, export)| match export {
-                    Export::Memory(memory) => Some(Memory::new(Rc::new(memory))),
-                    _ => None,
-                })
-                .ok_or_else(|| {
-                    AnyException::new(
-                        "RuntimeError",
-                        Some("The WebAssembly module has no exported memory."),
-                    )
-                })?;
-
-            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);
-
-            ruby_instance.instance_variable_set("@exports", ruby_exported_functions);
-
-            let ruby_memory: RubyMemory = wasmer_module
-                .get_nested_class("Memory")
-                .wrap_data(memory, &*MEMORY_WRAPPER);
-
-            ruby_instance.instance_variable_set("@memory", ruby_memory);
-
-            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.memory` getter method.
-    fn ruby_instance_memory() -> RubyMemory {
-        unsafe { _itself.instance_variable_get("@memory").to::<RubyMemory>() }
-    }
-);

data/src/instance/globals.rs

@@ -0,0 +1,234 @@
+//! 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())
+    }
+);