wasmtime 0.2.0 → 0.3.0

data/src/instance.rs

@@ -1,93 +0,0 @@
-use lazy_static::lazy_static;
-use rutie::{class, methods, wrappable_struct, AnyObject, Hash, Module, Object, RString};
-use std::collections::HashMap;
-use std::fs;
-use wasmtime as w;
-
-use crate::export::Export;
-use crate::func::Func;
-
-pub struct Instance {
-    instance: w::Instance,
-}
-
-impl Instance {
-    pub fn new(path: String) -> Self {
-        let wasm = fs::read(path).expect("failed to read wasm file");
-
-        let config = w::Config::new();
-        // config.wasm_interface_types(true);
-
-        let engine = w::Engine::new(&config);
-        let store = w::Store::new(&engine);
-        let module = w::Module::new(&store, &wasm).expect("failed to create module");
-        let imports: Vec<w::Extern> = Vec::new();
-        let instance = w::Instance::new(&module, &imports).expect("failed to create instance");
-
-        Instance { instance }
-    }
-
-    fn exports(&self) -> HashMap<String, Export> {
-        let mut exports = HashMap::new();
-
-        for export in self.instance.exports() {
-            match export.ty() {
-                w::ExternType::Func(_) => {
-                    let name = export.name().to_string();
-                    let func = Func::new(export.into_func().unwrap());
-                    exports.insert(name, Export::Func(func));
-                }
-                w::ExternType::Memory(_) => {
-                    let name = export.name().to_string();
-                    let memory = export.into_memory().unwrap();
-                    exports.insert(name, Export::Memory(memory));
-                }
-                _ => {}
-            }
-        }
-
-        exports
-    }
-}
-
-wrappable_struct!(Instance, InstanceWrapper, INSTANCE_WRAPPER);
-class!(RubyInstance);
-
-impl From<Instance> for RubyInstance {
-    fn from(instance: Instance) -> Self {
-        Module::from_existing("Wasmtime")
-            .get_nested_class("Instance")
-            .wrap_data(instance, &*INSTANCE_WRAPPER)
-    }
-}
-
-#[rustfmt::skip]
-methods!(
-    RubyInstance,
-    itself,
-
-    fn ruby_instance_new(path: RString) -> RubyInstance {
-        Instance::new(path.expect("failed read path").to_string()).into()
-    }
-
-    fn ruby_instance_exports() -> Hash {
-        let mut exports = Hash::new();
-
-        for (export_name, export) in itself.get_data(&*INSTANCE_WRAPPER).exports().into_iter() {
-            exports.store::<RString, AnyObject>(RString::new_utf8(&export_name), export.into());
-        }
-
-        exports
-    }
-);
-
-pub fn ruby_init() {
-    Module::from_existing("Wasmtime").define(|module| {
-        module
-            .define_nested_class("Instance", None)
-            .define(|class| {
-                class.def_self("new", ruby_instance_new);
-                class.def("exports", ruby_instance_exports);
-            });
-    });
-}

data/src/lib.rs

@@ -1,22 +0,0 @@
-mod export;
-mod func;
-mod instance;
-mod memory;
-mod ruby_type;
-mod vm;
-
-#[allow(non_snake_case)]
-#[no_mangle]
-pub extern "C" fn Init_native() {
-    std::panic::set_hook(Box::new(|panic_info| {
-        if let Some(s) = panic_info.payload().downcast_ref::<&str>() {
-            vm::raise("StandardError", s)
-        } else {
-            vm::raise("StandardError", &format!("{:?}", panic_info))
-        }
-    }));
-
-    instance::ruby_init();
-    func::ruby_init();
-    memory::ruby_init();
-}

data/src/memory.rs

@@ -1,48 +0,0 @@
-use lazy_static::lazy_static;
-use rutie::{class, methods, wrappable_struct, AnyObject, Integer, Module, NilClass, Object};
-use wasmtime as w;
-
-wrappable_struct!(w::Memory, MemoryWrapper, MEMORY_WRAPPER);
-class!(RubyMemory);
-
-impl From<w::Memory> for RubyMemory {
-    fn from(memory: w::Memory) -> Self {
-        Module::from_existing("Wasmtime")
-            .get_nested_class("Memory")
-            .wrap_data(memory, &*MEMORY_WRAPPER)
-    }
-}
-
-#[rustfmt::skip]
-methods!(
-    RubyMemory,
-    itself,
-
-    fn ruby_instance_data_size() -> Integer {
-        Integer::from(itself.get_data(&*MEMORY_WRAPPER).data_size() as u32)
-    }
-
-    fn ruby_instance_size() -> Integer {
-        Integer::from(itself.get_data(&*MEMORY_WRAPPER).size())
-    }
-
-    fn ruby_instance_grow(delta: Integer) -> AnyObject {
-        let memory = itself.get_data(&*MEMORY_WRAPPER);
-        let delta = delta.unwrap().to_i32();
-        if delta < 0 { return NilClass::new().into() }
-        match memory.grow(delta as u32) {
-            Ok(original) => Integer::from(original).into(),
-            Err(_) => NilClass::new().into()
-        }
-    }
-);
-
-pub fn ruby_init() {
-    Module::from_existing("Wasmtime").define(|module| {
-        module.define_nested_class("Memory", None).define(|class| {
-            class.def("data_size", ruby_instance_data_size);
-            class.def("size", ruby_instance_size);
-            class.def("grow", ruby_instance_grow);
-        });
-    });
-}

data/src/ruby_type.rs

@@ -1,32 +0,0 @@
-use rutie::{AnyObject, RString};
-use wasmtime as w;
-
-#[derive(Debug, Copy, Clone)]
-pub enum RubyType {
-    Integer32,
-    Integer64,
-    Float32,
-    Float64,
-    // String,
-    // Boolean,
-    NilClass,
-    Unsupported,
-}
-
-impl From<RubyType> for AnyObject {
-    fn from(ruby_type: RubyType) -> AnyObject {
-        RString::new_utf8(&format!("{:?}", ruby_type)).into()
-    }
-}
-
-impl From<&w::ValType> for RubyType {
-    fn from(val_type: &w::ValType) -> Self {
-        match val_type {
-            w::ValType::I32 => RubyType::Integer32,
-            w::ValType::I64 => RubyType::Integer64,
-            w::ValType::F32 => RubyType::Float32,
-            w::ValType::F64 => RubyType::Float64,
-            _ => RubyType::Unsupported,
-        }
-    }
-}

data/src/vm.rs

@@ -1,6 +0,0 @@
-use rutie::{Class, VM};
-
-pub fn raise(exception: &str, message: &str) -> ! {
-    VM::raise(Class::from_existing(exception), message);
-    loop {}
-}