wasmer 0.1.1 → 1.0.0

data/src/lib.rs

@@ -1,98 +0,0 @@
-#![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

@@ -1,120 +0,0 @@
-//! 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

@@ -1,127 +0,0 @@
-//! 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

@@ -1,28 +0,0 @@
-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)
-        }
-    }
-);