wasmer 0.4.0 → 0.5.0

data/src/memory/mod.rs

@@ -1,158 +0,0 @@
-//! The `Memory` WebAssembly class.
-
-pub mod view;
-
-use crate::{
-    error::unwrap_or_raise,
-    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, AnyException, Exception, Integer, Module, Object};
-use std::rc::Rc;
-use wasmer_runtime::{self as runtime, units::Pages};
-
-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)
-    }
-
-    pub fn grow(&self, number_of_pages: u32) -> Result<u32, AnyException> {
-        self.memory
-            .grow(Pages(number_of_pages))
-            .map(|previous_pages| previous_pages.0)
-            .map_err(|err| {
-                AnyException::new(
-                    "RuntimeError",
-                    Some(&format!("Failed to grow the memory: {}.", err)),
-                )
-            })
-    }
-}
-
-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);
-
-        let wasmer_module = Module::from_existing("Wasmer");
-        wasmer_module
-            .get_nested_class("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);
-
-        let wasmer_module = Module::from_existing("Wasmer");
-        wasmer_module
-            .get_nested_class("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);
-
-        let wasmer_module = Module::from_existing("Wasmer");
-        wasmer_module
-            .get_nested_class("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);
-
-        let wasmer_module = Module::from_existing("Wasmer");
-        wasmer_module
-            .get_nested_class("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);
-
-        let wasmer_module = Module::from_existing("Wasmer");
-        wasmer_module
-            .get_nested_class("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);
-
-        let wasmer_module = Module::from_existing("Wasmer");
-        wasmer_module
-            .get_nested_class("Int32Array")
-            .wrap_data(memory_view, &*INT32ARRAY_WRAPPER)
-    }
-
-    // Glue code to call the `Memory.grow` method.
-    fn ruby_memory_grow(number_of_pages: Integer) -> Integer {
-        let number_of_pages = number_of_pages
-            .map(|number_of_pages| number_of_pages.to_i32() as u32)
-            .unwrap_or(1);
-
-        unwrap_or_raise(|| {
-            itself
-                .get_data(&*MEMORY_WRAPPER)
-                .grow(number_of_pages)
-                .map(|previous_number_of_pages| Integer::new(previous_number_of_pages as i64))
-        })
-    }
-);

data/src/memory/view.rs

@@ -1,145 +0,0 @@
-//! The `TypedArray`/`MemoryView` WebAssembly classes.
-
-#[rustfmt::skip]
-
-macro_rules! memory_view {
-    ($mod_name:ident over $wasm_type:ty | $bytes_per_element:expr) => {
-        pub mod $mod_name {
-            use crate::error::unwrap_or_raise;
-            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())
-                    }
-                }
-
-                pub fn each(&self) {
-                    let view = self.memory.view::<$wasm_type>();
-
-                    for nth in self.offset..view.len() {
-                        let value = view[nth].get() as i64;
-                        VM::yield_object(Integer::from(value));
-                    }
-                }
-            }
-
-            wrappable_struct!(MemoryView, MemoryViewWrapper, MEMORY_VIEW_WRAPPER);
-
-            class!(RubyMemoryView);
-
-            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 {
-                    unwrap_or_raise(|| {
-                        let memory_view = _itself.get_data(&*MEMORY_VIEW_WRAPPER);
-
-                        memory_view
-                            .set(index?.to_i32() as isize, value?.to_i32() as $wasm_type)
-                            .map_err(|e| AnyException::new("ArgumentError", Some(&e)))?;
-
-                        Ok(NilClass::new())
-                    })
-                }
-
-                // Glue code to call the `TypedArray.get` method.
-                fn ruby_memory_view_get(index: Integer) -> Fixnum {
-                    unwrap_or_raise(|| {
-                        let memory_view = _itself.get_data(&*MEMORY_VIEW_WRAPPER);
-
-                        Ok(Fixnum::new(
-                            memory_view
-                                .get(index?.to_i32() as isize)
-                                .map_err(|e| AnyException::new("ArgumentError", Some(&e)))?
-                                as i64,
-                        ))
-                    })
-                }
-
-                fn ruby_memory_view_each() -> RubyMemoryView {
-                    let memory_view = _itself.get_data(&*MEMORY_VIEW_WRAPPER);
-                    memory_view.each();
-                    _itself
-                }
-            );
-        }
-    };
-}
-
-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)
-        }
-    }
-);