wasmer 0.1.1

data/src/lib.rs

@@ -0,0 +1,98 @@
+#![deny(warnings)]
+
+use rutie::{Class, Object};
+
+pub mod instance;
+pub mod memory;
+pub mod module;
+
+#[allow(non_snake_case)]
+#[no_mangle]
+pub extern "C" fn Init_wasmer() {
+    let instance_data_class = Class::from_existing("Object");
+
+    // Declare the `Instance` Ruby class.
+    Class::new("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 `memory` getter method.
+        itself.def("memory", instance::ruby_instance_memory);
+    });
+
+    let exported_functions_data_class = Class::from_existing("Object");
+
+    // Declare the `ExportedFunctions` Ruby class.
+    Class::new("ExportedFunctions", Some(&exported_functions_data_class)).define(|itself| {
+        // Declare the `method_missing` method.
+        itself.def(
+            "method_missing",
+            instance::ruby_exported_functions_method_missing,
+        );
+    });
+
+    let module_data_class = Class::from_existing("Object");
+
+    // Declare the `Module` Ruby class.
+    Class::new("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.
+    Class::new("Memory", Some(&memory_data_class)).define(|itself| {
+        // 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.
+            Class::new(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);
+            });
+        };
+    }
+
+    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);
+}

data/src/memory/mod.rs

@@ -0,0 +1,120 @@
+//! The `Memory` WebAssembly class.
+
+pub mod view;
+
+use crate::memory::view::{
+    int16array::{RubyMemoryView as RubyInt16Array, MEMORY_VIEW_WRAPPER as INT16ARRAY_WRAPPER},
+    int32array::{RubyMemoryView as RubyInt32Array, MEMORY_VIEW_WRAPPER as INT32ARRAY_WRAPPER},
+    int8array::{RubyMemoryView as RubyInt8Array, MEMORY_VIEW_WRAPPER as INT8ARRAY_WRAPPER},
+    uint16array::{RubyMemoryView as RubyUint16Array, MEMORY_VIEW_WRAPPER as UINT16ARRAY_WRAPPER},
+    uint32array::{RubyMemoryView as RubyUint32Array, MEMORY_VIEW_WRAPPER as UINT32ARRAY_WRAPPER},
+    uint8array::{RubyMemoryView as RubyUint8Array, MEMORY_VIEW_WRAPPER as UINT8ARRAY_WRAPPER},
+};
+use lazy_static::lazy_static;
+use rutie::{class, methods, wrappable_struct, Class, Integer, Object};
+use std::rc::Rc;
+use wasmer_runtime as runtime;
+
+pub struct Memory {
+    memory: Rc<runtime::Memory>,
+}
+
+impl Memory {
+    pub fn new(memory: Rc<runtime::Memory>) -> Self {
+        Self { memory }
+    }
+
+    pub fn uint8_view(&self, offset: usize) -> view::uint8array::MemoryView {
+        view::uint8array::MemoryView::new(self.memory.clone(), offset)
+    }
+
+    pub fn int8_view(&self, offset: usize) -> view::int8array::MemoryView {
+        view::int8array::MemoryView::new(self.memory.clone(), offset)
+    }
+
+    pub fn uint16_view(&self, offset: usize) -> view::uint16array::MemoryView {
+        view::uint16array::MemoryView::new(self.memory.clone(), offset)
+    }
+
+    pub fn int16_view(&self, offset: usize) -> view::int16array::MemoryView {
+        view::int16array::MemoryView::new(self.memory.clone(), offset)
+    }
+
+    pub fn uint32_view(&self, offset: usize) -> view::uint32array::MemoryView {
+        view::uint32array::MemoryView::new(self.memory.clone(), offset)
+    }
+
+    pub fn int32_view(&self, offset: usize) -> view::int32array::MemoryView {
+        view::int32array::MemoryView::new(self.memory.clone(), offset)
+    }
+}
+
+wrappable_struct!(Memory, MemoryWrapper, MEMORY_WRAPPER);
+
+class!(RubyMemory);
+
+#[rustfmt::skip]
+methods!(
+    RubyMemory,
+    itself,
+
+    // Glue code to call the `Memory.uint8_view` method.
+    fn ruby_memory_uint8array(offset: Integer) -> RubyUint8Array {
+        let offset = offset
+            .map(|offset| offset.to_i64() as usize)
+            .unwrap_or(0);
+        let memory_view = itself.get_data(&*MEMORY_WRAPPER).uint8_view(offset);
+
+        Class::from_existing("Uint8Array").wrap_data(memory_view, &*UINT8ARRAY_WRAPPER)
+    }
+
+    // Glue code to call the `Memory.int8_view` method.
+    fn ruby_memory_int8array(offset: Integer) -> RubyInt8Array {
+        let offset = offset
+            .map(|offset| offset.to_i64() as usize)
+            .unwrap_or(0);
+        let memory_view = itself.get_data(&*MEMORY_WRAPPER).int8_view(offset);
+
+        Class::from_existing("Int8Array").wrap_data(memory_view, &*INT8ARRAY_WRAPPER)
+    }
+
+    // Glue code to call the `Memory.uint16_view` method.
+    fn ruby_memory_uint16array(offset: Integer) -> RubyUint16Array {
+        let offset = offset
+            .map(|offset| offset.to_i64() as usize)
+            .unwrap_or(0);
+        let memory_view = itself.get_data(&*MEMORY_WRAPPER).uint16_view(offset);
+
+        Class::from_existing("Uint16Array").wrap_data(memory_view, &*UINT16ARRAY_WRAPPER)
+    }
+
+    // Glue code to call the `Memory.int16_view` method.
+    fn ruby_memory_int16array(offset: Integer) -> RubyInt16Array {
+        let offset = offset
+            .map(|offset| offset.to_i64() as usize)
+            .unwrap_or(0);
+        let memory_view = itself.get_data(&*MEMORY_WRAPPER).int16_view(offset);
+
+        Class::from_existing("Int16Array").wrap_data(memory_view, &*INT16ARRAY_WRAPPER)
+    }
+
+    // Glue code to call the `Memory.uint32_view` method.
+    fn ruby_memory_uint32array(offset: Integer) -> RubyUint32Array {
+        let offset = offset
+            .map(|offset| offset.to_i64() as usize)
+            .unwrap_or(0);
+        let memory_view = itself.get_data(&*MEMORY_WRAPPER).uint32_view(offset);
+
+        Class::from_existing("Uint32Array").wrap_data(memory_view, &*UINT32ARRAY_WRAPPER)
+    }
+
+    // Glue code to call the `Memory.int32_view` method.
+    fn ruby_memory_int32array(offset: Integer) -> RubyInt32Array {
+        let offset = offset
+            .map(|offset| offset.to_i64() as usize)
+            .unwrap_or(0);
+        let memory_view = itself.get_data(&*MEMORY_WRAPPER).int32_view(offset);
+
+        Class::from_existing("Int32Array").wrap_data(memory_view, &*INT32ARRAY_WRAPPER)
+    }
+);

data/src/memory/view.rs

@@ -0,0 +1,127 @@
+//! The `TypedArray`/`MemoryView` WebAssembly classes.
+
+macro_rules! memory_view {
+    ($mod_name:ident over $wasm_type:ty | $bytes_per_element:expr) => {
+        pub mod $mod_name {
+            use lazy_static::lazy_static;
+            use rutie::{
+                class, methods, wrappable_struct, AnyException, Exception, Fixnum, Integer,
+                NilClass, Object, VM,
+            };
+            use std::{mem::size_of, rc::Rc};
+            use wasmer_runtime as runtime;
+
+            pub struct MemoryView {
+                memory: Rc<runtime::memory::Memory>,
+                offset: usize,
+            }
+
+            impl MemoryView {
+                pub fn new(memory: Rc<runtime::Memory>, offset: usize) -> Self {
+                    Self { memory, offset }
+                }
+
+                pub fn len(&self) -> usize {
+                    self.memory.view::<$wasm_type>()[self.offset..].len() / size_of::<$wasm_type>()
+                }
+
+                pub fn set(&self, index: isize, value: $wasm_type) -> Result<(), String> {
+                    let offset = self.offset;
+                    let view = self.memory.view::<$wasm_type>();
+
+                    if index < 0 {
+                        return Err("Out of bound: Index cannot be negative.".into());
+                    }
+
+                    let index = index as usize;
+
+                    if view.len() <= offset + index {
+                        Err(format!(
+                            "Out of bound: Maximum index {} is larger than the memory size {}.",
+                            offset + index,
+                            view.len()
+                        ))
+                    } else {
+                        view[offset + index].set(value);
+
+                        Ok(())
+                    }
+                }
+
+                pub fn get(&self, index: isize) -> Result<$wasm_type, String> {
+                    let offset = self.offset;
+                    let view = self.memory.view::<$wasm_type>();
+
+                    if index < 0 {
+                        return Err("Out of bound: Index cannot be negative.".into());
+                    }
+
+                    let index = index as usize;
+
+                    if view.len() <= offset + index {
+                        Err(format!(
+                            "Out of bound: Maximum index {} is larger than the memory size {}.",
+                            offset + index,
+                            view.len()
+                        ))
+                    } else {
+                        Ok(view[offset + index].get())
+                    }
+                }
+            }
+
+            wrappable_struct!(MemoryView, MemoryViewWrapper, MEMORY_VIEW_WRAPPER);
+
+            class!(RubyMemoryView);
+
+            #[rustfmt::skip]
+            methods!(
+                RubyMemoryView,
+                _itself,
+
+                // The `TypedArray.bytes_per_element` method.
+                fn ruby_memory_view_bytes_per_element() -> Fixnum {
+                    Fixnum::new($bytes_per_element)
+                }
+
+                // Glue code to call the `TypedArray.length` method.
+                fn ruby_memory_view_length() -> Fixnum {
+                    Fixnum::new(_itself.get_data(&*MEMORY_VIEW_WRAPPER).len() as i64)
+                }
+
+                // Glue code to call the `TypedArray.set` method.
+                fn ruby_memory_view_set(index: Integer, value: Integer) -> NilClass {
+                    let memory_view = _itself.get_data(&*MEMORY_VIEW_WRAPPER);
+                    memory_view
+                        .set(
+                            index.map_err(|e| VM::raise_ex(e)).unwrap().to_i32() as isize,
+                            value.map_err(|e| VM::raise_ex(e)).unwrap().to_i32() as $wasm_type,
+                        )
+                        .map_err(|e| VM::raise_ex(AnyException::new("ArgumentError", Some(&e))))
+                        .unwrap();
+
+                    NilClass::new()
+                }
+
+                // Glue code to call the `TypedArray.get` method.
+                fn ruby_memory_view_get(index: Integer) -> Fixnum {
+                    let memory_view = _itself.get_data(&*MEMORY_VIEW_WRAPPER);
+
+                    Fixnum::new(
+                        memory_view
+                            .get(index.map_err(|e| VM::raise_ex(e)).unwrap().to_i32() as isize)
+                            .map_err(|e| VM::raise_ex(AnyException::new("ArgumentError", Some(&e))))
+                            .unwrap() as i64,
+                    )
+                }
+            );
+        }
+    };
+}
+
+memory_view!(uint8array over u8|1);
+memory_view!(int8array over i8|1);
+memory_view!(uint16array over u16|2);
+memory_view!(int16array over i16|2);
+memory_view!(uint32array over u32|4);
+memory_view!(int32array over i32|4);

data/src/module.rs

@@ -0,0 +1,28 @@
+use rutie::{class, methods, rubysys::value::ValueType, AnyObject, Boolean, Object, RString};
+use wasmer_runtime::validate;
+
+class!(Module);
+
+methods!(
+    Module,
+    _itself,
+    fn ruby_module_validate(bytes: AnyObject) -> Boolean {
+        if let Ok(bytes) = bytes {
+            match bytes.ty() {
+                ValueType::RString => bytes.try_convert_to::<RString>().ok().map_or_else(
+                    || Boolean::new(false),
+                    |string| {
+                        if validate(string.to_bytes_unchecked()) {
+                            Boolean::new(true)
+                        } else {
+                            Boolean::new(false)
+                        }
+                    },
+                ),
+                _ => Boolean::new(false),
+            }
+        } else {
+            Boolean::new(false)
+        }
+    }
+);

data/wasmer.gemspec

@@ -0,0 +1,29 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require "wasmer/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "wasmer"
+  spec.version       = Wasmer::VERSION
+  spec.authors       = ["Ivan Enderlin"]
+  spec.email         = ["ivan.enderlin@hoa-project.net"]
+
+  spec.summary       = "Run WebAssembly binaries."
+  spec.description   = "Wasmer is a Ruby extension to run WebAssembly binaries."
+  spec.homepage      = "https://github.com/wasmerio/ruby-ext-wasm"
+  spec.license       = "BSD-3-Clause"
+
+  spec.extensions    = %w(Rakefile)
+
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(examples|tests)/}) }
+  end
+
+  spec.require_paths = %w(lib)
+
+  spec.add_dependency "rutie", "~> 0.0.3"
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: wasmer
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Ivan Enderlin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-05-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rutie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: Wasmer is a Ruby extension to run WebAssembly binaries.
+email:
+- ivan.enderlin@hoa-project.net
+executables: []
+extensions:
+- Rakefile
+extra_rdoc_files: []
+files:
+- ".cargo/config"
+- ".circleci/config.yml"
+- ".github/ISSUE_TEMPLATE/---bug-report.md"
+- ".github/ISSUE_TEMPLATE/---feature-request.md"
+- ".github/ISSUE_TEMPLATE/--question.md"
+- ".gitignore"
+- Cargo.lock
+- Cargo.toml
+- Gemfile
+- README.md
+- Rakefile
+- justfile
+- lib/wasmer.rb
+- lib/wasmer/version.rb
+- src/instance.rs
+- src/lib.rs
+- src/memory/mod.rs
+- src/memory/view.rs
+- src/module.rs
+- wasmer.gemspec
+homepage: https://github.com/wasmerio/ruby-ext-wasm
+licenses:
+- BSD-3-Clause
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Run WebAssembly binaries.
+test_files: []