wasmtime 0.2.0-x86_64-linux → 0.3.0-x86_64-linux

data/Cargo.toml

@@ -1,14 +0,0 @@
-[package]
-name = "wasmtime-ruby"
-version = "0.1.0"
-authors = ["David Cristofaro <david@dtcristo.com>"]
-edition = "2018"
-publish = false
-
-[lib]
-crate-type = ["cdylib"]
-
-[dependencies]
-lazy_static = "1.4.0"
-rutie = "0.7.0"
-wasmtime = "0.16.0"

data/ext/wasmtime/Makefile

@@ -1,5 +0,0 @@
-clean:
-	rake clean
-
-install:
-	rake compile

data/ext/wasmtime/Rakefile

@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-
-import '../../lib/tasks/compile.rake'

data/ext/wasmtime/extconf.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-unless system('rustup --version')
-  abort 'Building native extention requires Rust with rustup (https://rustup.rs/).'
-end

data/lib/tasks/compile.rake

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require 'rbconfig'
-
-SOEXT = RbConfig::CONFIG['SOEXT']
-DLEXT = RbConfig::CONFIG['DLEXT']
-
-SO = File.expand_path("../../target/release/libwasmtime_ruby.#{SOEXT}", __dir__)
-DL = File.expand_path("../wasmtime/native.#{DLEXT}", __dir__)
-
-desc 'Remove compile artifacts'
-task :clean do
-  sh 'cargo clean'
-  rm_rf SO
-  rm_rf DL
-end
-
-desc 'Compile native extension'
-task :compile do
-  unless `rustup target list`.include?('wasm32-unknown-unknown (installed)')
-    sh 'rustup target add wasm32-unknown-unknown'
-  end
-
-  ENV['NO_LINK_RUTIE'] = '1'
-  sh 'cargo build --release'
-  cp SO, DL
-end

data/lib/wasmtime/refinements.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Wasmtime
-  module Refinements
-    refine String do
-      def camelize(uppercase_first_letter = true)
-        string = self
-        if uppercase_first_letter
-          string = string.sub(/^[a-z\d]*/, &:capitalize)
-        else
-          string = string.sub(/^(?:(?=\b|[A-Z_])|\w)/, &:downcase)
-        end
-        string.gsub(%r{(?:_|(\/))([a-z\d]*)}) { "#{$1}#{$2.capitalize}" }.gsub(
-          '/',
-          '::'
-        )
-      end
-    end
-  end
-end

data/lib/wasmtime/require.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-require 'wasmtime'
-
-using Wasmtime::Refinements
-
-module Kernel
-  unless defined?(wasmtime_original_require)
-    alias_method :wasmtime_original_require, :require
-    private :wasmtime_original_require
-  end
-
-  def require(path)
-    wasmtime_original_require(path)
-  rescue LoadError => load_error
-    try_load =
-      Proc.new do |path, extention|
-        path_with_extention =
-          path.end_with?(".#{extention}") ? path : "#{path}.#{extention}"
-
-        if path_with_extention.start_with?('.', '/', '~')
-          absolute_path = File.expand_path(path_with_extention)
-          return Wasmtime.load(absolute_path) if File.file?(absolute_path)
-        end
-        $LOAD_PATH.each do |load_dir|
-          absolute_path = File.expand_path(path_with_extention, load_dir)
-          return Wasmtime.load(absolute_path) if File.file?(absolute_path)
-        end
-      end
-
-    try_load.call(path, 'wasm')
-    try_load.call(path, 'wat')
-
-    raise load_error
-  end
-
-  unless defined?(wasmtime_original_require_relative)
-    alias_method :wasmtime_original_require_relative, :require_relative
-    private :wasmtime_original_require_relative
-  end
-
-  def require_relative(path)
-    absolute_path =
-      File.expand_path(path, File.dirname(caller_locations[0].absolute_path))
-    require(absolute_path)
-  end
-end
-
-module Wasmtime
-  module_function
-
-  def load(absolute_path)
-    return false if $LOADED_FEATURES.include?(absolute_path)
-    filename = absolute_path.split(File::SEPARATOR).last
-    module_name =
-      if filename.end_with?('.wasm')
-        filename.delete_suffix('.wasm')
-      else
-        filename.delete_suffix('.wat')
-      end
-    mod = Object.const_set(module_name.camelize, Module.new)
-    instance = Wasmtime::Instance.new(absolute_path)
-    instance.exports.each do |name, export|
-      case export
-      when Wasmtime::Func
-        mod.define_singleton_method(name) { |*args| export.call(*args) }
-      end
-    end
-    $LOADED_FEATURES << absolute_path
-    true
-  end
-end

data/src/export.rs

@@ -1,19 +0,0 @@
-use rutie::{AnyObject, Object};
-use wasmtime as w;
-
-use crate::func::{Func, RubyFunc};
-use crate::memory::RubyMemory;
-
-pub enum Export {
-    Func(Func),
-    Memory(w::Memory),
-}
-
-impl From<Export> for AnyObject {
-    fn from(export: Export) -> Self {
-        match export {
-            Export::Func(func) => RubyFunc::from(func).value().into(),
-            Export::Memory(memory) => RubyMemory::from(memory).value().into(),
-        }
-    }
-}

data/src/func.rs

@@ -1,175 +0,0 @@
-use lazy_static::lazy_static;
-use rutie as r;
-use rutie::rubysys;
-use rutie::{
-    class, methods, wrappable_struct, AnyObject, Array, Float, Hash, Integer, Module, NilClass,
-    Object, RString, Symbol,
-};
-use std::mem;
-use wasmtime as w;
-
-use crate::ruby_type::RubyType;
-use crate::vm::raise;
-
-pub struct Func {
-    func: w::Func,
-}
-
-impl Func {
-    pub fn new(func: w::Func) -> Self {
-        Func { func }
-    }
-
-    pub fn call(&mut self, args: &[w::Val]) -> Vec<w::Val> {
-        self.func.call(args).expect("failed to call func").to_vec()
-    }
-
-    fn parse_param_types(&self) -> Vec<RubyType> {
-        self.func
-            .ty()
-            .params()
-            .iter()
-            .map(|val_type| val_type.into())
-            .collect()
-    }
-
-    fn parse_result_type(&self) -> RubyType {
-        match self.func.ty().results().len() {
-            0 => RubyType::NilClass,
-            1 => self.func.ty().results().first().unwrap().into(),
-            _ => raise("StandardError", "multiple return values are not supported"),
-        }
-    }
-}
-
-fn translate_incoming(args: Array, param_types: &[RubyType]) -> Vec<w::Val> {
-    if args.length() != param_types.len() {
-        raise(
-            "ArgumentError",
-            &format!(
-                "wrong number of arguments (given {}, expected {})",
-                args.length(),
-                param_types.len()
-            ),
-        )
-    }
-    args.into_iter()
-        .zip(param_types)
-        .map(|(arg, param_type)| match param_type {
-            RubyType::Integer32 => w::Val::I32(
-                arg.try_convert_to::<Integer>()
-                    .expect("failed to convert integer")
-                    .to_i32(),
-            ),
-            RubyType::Integer64 => w::Val::I64(
-                arg.try_convert_to::<Integer>()
-                    .expect("failed to convert integer")
-                    .to_i64(),
-            ),
-            RubyType::Float32 => w::Val::F32(
-                (arg.try_convert_to::<Float>()
-                    .expect("failed to convert float")
-                    .to_f64() as f32)
-                    .to_bits(),
-            ),
-            RubyType::Float64 => w::Val::F64(
-                arg.try_convert_to::<Float>()
-                    .expect("failed to convert float")
-                    .to_f64()
-                    .to_bits(),
-            ),
-            RubyType::NilClass | RubyType::Unsupported => raise(
-                "StandardError",
-                &format!("unsupported arg type: {:?}", param_type),
-            ),
-        })
-        .collect()
-}
-
-fn translate_outgoing(native_results: Vec<w::Val>) -> AnyObject {
-    let results: Vec<AnyObject> = native_results
-        .into_iter()
-        .map(|r| match r {
-            w::Val::I32(v) => Integer::new(v.into()).into(),
-            w::Val::I64(v) => Integer::new(v).into(),
-            w::Val::F32(v) => Float::new(f32::from_bits(v).into()).into(),
-            w::Val::F64(v) => Float::new(f64::from_bits(v)).into(),
-            _ => raise("StandardError", &format!("unsupported value: {:?}", r)),
-        })
-        .collect();
-
-    match results.len() {
-        0 => NilClass::new().into(),
-        1 => results.first().unwrap().into(),
-        _ => raise("StandardError", "multiple return values are not supported"),
-    }
-}
-
-wrappable_struct!(Func, FuncWrapper, FUNC_WRAPPER);
-class!(RubyFunc);
-
-impl From<Func> for RubyFunc {
-    fn from(func: Func) -> Self {
-        Module::from_existing("Wasmtime")
-            .get_nested_class("Func")
-            .wrap_data(func, &*FUNC_WRAPPER)
-    }
-}
-
-#[rustfmt::skip]
-methods!(
-    RubyFunc,
-    itself,
-
-    fn ruby_func_signature() -> Hash {
-        let func = itself.get_data(&*FUNC_WRAPPER);
-
-        let mut param_types = Array::new();
-        for param_type in func.parse_param_types().iter() {
-            param_types.push(RString::new_utf8(&format!("{:?}", param_type)));
-        }
-
-        let result_type: AnyObject = func.parse_result_type().into();
-
-        let mut signature = Hash::new();
-        signature.store(Symbol::new("params"), param_types);
-        signature.store(Symbol::new("result"), result_type);
-
-        signature
-    }
-);
-
-pub extern "C" fn ruby_func_call(
-    argc: r::types::Argc,
-    argv: *const AnyObject,
-    mut itself: AnyObject,
-) -> AnyObject {
-    // TODO: Remove this section when rutie `methods!` macro has support for variadic functions
-    // https://github.com/danielpclark/rutie/blob/1c951b59e00944d305ca425267c54115c8c1bb86/README.md#variadic-functions--splat-operator
-    let args_raw = r::types::Value::from(0);
-    unsafe {
-        let p_argv: *const r::types::Value = mem::transmute(argv);
-        rubysys::class::rb_scan_args(
-            argc,
-            p_argv,
-            r::util::str_to_cstring("*").as_ptr(),
-            &args_raw,
-        )
-    };
-    let args = Array::from(args_raw);
-    // ---
-    let func = itself.get_data_mut(&*FUNC_WRAPPER);
-
-    let args_native = translate_incoming(args, &func.parse_param_types());
-    let results_native = func.call(&args_native[..]);
-    translate_outgoing(results_native)
-}
-
-pub fn ruby_init() {
-    Module::from_existing("Wasmtime").define(|module| {
-        module.define_nested_class("Func", None).define(|class| {
-            class.def("signature", ruby_func_signature);
-            class.def("call", ruby_func_call);
-        });
-    });
-}

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 {}
-}