opal-webassembly 0.1.0

data/opal/ffi/types.rb

@@ -0,0 +1,226 @@
+module FFI
+  TypeDefs = {}
+
+  # TODO: clean me up
+  class Type
+    def self.alignment; size; end
+
+    class Numeric < self
+      def self.signed; false; end
+      def self.pack(x)
+        [x].pack(packformat).b
+      end
+      def self.unpack(x)
+        x.unpack(packformat.b).first
+      end
+    end
+
+    class Integer < Numeric
+      def self.from_native(x); x.to_i; end
+      def self.to_native(x); x.to_i; end
+
+      def self.packformat
+        case self.size
+        when 1
+          signed ? "c" : "C"
+        when 2
+          signed ? "s<" : "S<"
+        when 4
+          signed ? "l<" : "L<"
+        when 8
+          signed ? "q<" : "Q<"
+        end
+      end
+    end
+
+    class Float < Numeric
+      def self.from_native(x); x.to_f; end
+      def self.to_native(x); x.to_f; end
+
+      # Unfortunately, that is not supported by Opal. TODO: Upstream fix
+      def self.packformat
+        case self.size
+        when 2
+          "e"
+        when 4
+          "E"
+        when 8
+          raise TypeError, "We can't pack/unpack a long double unfortunately."
+        end
+      end
+    end
+
+    class VOID < self
+      def self.size; 1; end
+      def self.from_native(x); nil; end
+      def self.to_native(x); raise TypeError, "Can't convert VOID to a native value"; end
+      def self.pack(x); ""; end
+      def self.unpack(x); nil; end
+    end
+
+    class BOOL < self
+      def self.size; 1; end
+      def self.from_native(x); !!x; end
+      def self.to_native(x); x ? 1 : 0; end
+      def self.pack(x); x ? "\1" : "\0"; end
+      def self.unpack(x); x != "\0"; end
+    end
+
+    class POINTER < Integer
+      def self.size; 4; end
+
+      def self.from_native_mem(x, memory)
+        Pointer.new([memory, x])
+      end
+
+      def self.to_native(x)
+        if !x
+          0
+        elsif x.respond_to? :value # WebAssembly::Global?
+          x.value
+        elsif x.respond_to? :address # Struct? Pointer?
+          x.address
+        elsif x.respond_to? :to_int # Integer?
+          x.to_int
+        elsif x.respond_to? :to_str # String? It leaks though.
+          FFI::Pointer.from_string(x.to_str).address
+        else
+          raise ArgumentError, "Wrong argument #{x} can't be coerced to a pointer."
+        end
+      end
+    end
+
+    # TODO: Implement DataConverter
+    class WrappedStruct < self
+      def alignment; FFI::Type::POINTER.alignment; end
+      def size; FFI::Type::POINTER.size; end
+      def pack x; FFI::Type::POINTER.pack(x); end
+      def unpack x; FFI::Type::POINTER.unpack(x); end
+
+      def initialize x
+        @struct = x
+      end
+
+      def from_native_mem(x, memory)
+        @struct.new(FFI::Pointer.new([memory, x], @struct))
+      end
+
+      def to_native(x)
+        x.pointer.address
+      end
+    end
+
+    class STRING < self
+      def self.size; 4; end
+
+      def self.from_native_mem(x, memory)
+        FFI::Pointer.new([memory, x]).read_string
+      end
+
+      # WARNING: it leaks!
+      def self.to_native x
+        FFI::Pointer.from_string(x).address
+      end
+
+      def self.pack x; x.to_s; end
+      def self.unpack x; x.to_s; end
+    end
+
+    class CHAR < Integer; def self.size; 1; end; def self.signed; true; end; end
+    class UCHAR < Integer; def self.size; 1; end; end
+    class SHORT < Integer; def self.size; 2; end; def self.signed; true; end; end
+    class USHORT < Integer; def self.size; 2; end; end
+    class INT < Integer; def self.size; 4; end; def self.signed; true; end; end
+    class UINT < Integer; def self.size; 4; end; end
+    class LONG < INT; end
+    class ULONG < INT; end
+    class LONG_LONG < Integer; def self.size; 8; end; def self.signed; true; end; end
+    class ULONG_LONG < Integer; def self.size; 8; end; end
+    class FLOAT < Float; def self.size; 4; end; end
+    class DOUBLE < Float; def self.size; 8; end; end
+    class LONG_DOUBLE < Float; def self.size; 16; end; end
+
+    class INT8 < CHAR; end
+    class UINT8 < CHAR; end
+    class INT16 < SHORT; end
+    class UINT16 < USHORT; end
+    class INT32 < INT; end
+    class UINT32 < UINT; end
+    class INT64 < LONG_LONG; end
+    class UINT64 < ULONG_LONG; end
+
+    def self.[] name, purpose = nil
+      FFI.find_type name, purpose: purpose
+    end
+  end
+
+  def self.typedef old, new
+    TypeDefs[new] = find_type(old)
+  end
+
+  def self.add_typedef(old, new); typedef old, new; end
+
+  def self.find_type name, type_map = nil, purpose: nil
+    if name.is_a?(FFI::Type) || (name.is_a?(Class) && name <= FFI::Type)
+      name
+    elsif type_map && type_map.has_key?(name)
+      type_map[name]
+    elsif TypeDefs.has_key?(name)
+      TypeDefs[name]
+    elsif name.is_a?(Class) && name <= FFI::Struct
+      if purpose == nil
+        Type::WrappedStruct.new(name)
+      elsif purpose == :struct
+        name
+      else
+        raise ArgumentError, "Wrong purpose provided. Can't resolve type '#{name}'."
+      end
+    else
+      raise TypeError, "unable to resolve type '#{name}'"
+    end
+  end
+
+  def self.type_size name
+    find_type(name).size
+  end
+
+  typedef Type::VOID, nil
+
+  typedef Type::VOID, :void
+  typedef Type::BOOL, :bool
+  typedef Type::CHAR, :char
+  typedef Type::UCHAR, :uchar
+  typedef Type::SHORT, :short
+  typedef Type::USHORT, :ushort
+  typedef Type::INT, :int
+  typedef Type::UINT, :uint
+  typedef Type::LONG, :long
+  typedef Type::ULONG, :ulong
+  typedef Type::LONG_LONG, :long_long
+  typedef Type::ULONG_LONG, :ulong_long
+  typedef Type::FLOAT, :float
+  typedef Type::DOUBLE, :double
+  typedef Type::LONG_DOUBLE, :long_double
+
+  typedef Type::INT8, :int8
+  typedef Type::UINT8, :uint8
+  typedef Type::INT16, :int16
+  typedef Type::UINT16, :uint16
+  typedef Type::INT32, :int32
+  typedef Type::UINT32, :uint32
+  typedef Type::INT64, :int64
+  typedef Type::UINT64, :uint64
+
+  typedef Type::POINTER, :pointer
+  typedef Type::STRING, :string
+
+  typedef :uint8, :byte
+  typedef :long, :size_t
+
+  typedef :pointer, :buffer_in
+  typedef :pointer, :buffer_out
+  typedef :pointer, :buffer_inout
+
+  # varargs and strptr are not currently supported
+  # same with enums.
+end

data/opal/webassembly.rb

@@ -0,0 +1,68 @@
+require 'native'
+
+require 'webassembly/instance'
+require 'webassembly/module'
+require 'webassembly/table'
+require 'webassembly/memory'
+require 'webassembly/global'
+
+module WebAssembly
+  @libs = {}
+
+  def self.libs
+    @libs
+  end
+
+  def self.load_from_buffer(buffer, name)
+    mod = Module.new(buffer)
+    @libs[name] = Instance.new(mod)
+  end
+
+  %x{
+    // Taken from https://github.com/niklasvh/base64-arraybuffer/blob/master/lib/base64-arraybuffer.js
+    var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+    // Use a lookup table to find the index.
+    var lookup = new Uint8Array(256);
+    for (var i = 0; i < chars.length; i++) {
+      lookup[chars.charCodeAt(i)] = i;
+    }
+
+    function base64_to_arraybuffer(base64) {
+      var bufferLength = base64.length * 0.75,
+      len = base64.length, i, p = 0,
+      encoded1, encoded2, encoded3, encoded4;
+
+      if (base64[base64.length - 1] === "=") {
+        bufferLength--;
+        if (base64[base64.length - 2] === "=") {
+          bufferLength--;
+        }
+      }
+
+      var arraybuffer = new ArrayBuffer(bufferLength),
+      bytes = new Uint8Array(arraybuffer);
+
+      for (i = 0; i < len; i+=4) {
+        encoded1 = lookup[base64.charCodeAt(i)];
+        encoded2 = lookup[base64.charCodeAt(i+1)];
+        encoded3 = lookup[base64.charCodeAt(i+2)];
+        encoded4 = lookup[base64.charCodeAt(i+3)];
+
+        bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);
+        bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);
+        bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);
+      }
+
+      return arraybuffer;
+    }
+  }
+
+  def self.load_from_base64(base64, name)
+    self.load_from_buffer(`base64_to_arraybuffer(#{base64})`, name)
+  end
+
+  def self.[](name)
+    self.libs[name]
+  end
+end

data/opal/webassembly/global.rb

@@ -0,0 +1,15 @@
+module WebAssembly
+  class Global < `WebAssembly.Global`
+    def self.new(value, type="i32", mutable=true)
+      `new WebAssembly.Global({value: #{type}, mutable: #{mutable}}, #{value})`
+    end
+
+    def value
+      self.JS[:value]
+    end
+
+    def value= new_val
+      self.JS[:value] = new_val
+    end
+  end
+end

data/opal/webassembly/instance.rb

@@ -0,0 +1,44 @@
+require 'native'
+
+module WebAssembly
+  class Instance < `WebAssembly.Instance`
+    include Enumerable
+
+    def self.new(mod, imports={})
+      `new WebAssembly.Instance(#{mod}, #{imports.to_n})`
+    end
+
+    def exports
+      @exports_cache ||= {}.tap do |hash|
+        %x{
+          var hasOwnProperty = Object.prototype.hasOwnProperty.bind(#{self}.exports);
+          for (var key in #{self}.exports) {
+            if (hasOwnProperty(key)) {
+              #{hash[`key`] = `#{self}.exports[key]`}
+            }
+          }
+        }
+      end
+    end
+
+    def method_missing meth, *args
+      exports[meth].call(*args)
+    end
+
+    def [] export
+      exports[export]
+    end
+
+    def to_h
+      exports
+    end
+
+    def memory
+      exports[:memory]
+    end
+
+    def each(&block)
+      exports.each(&block)
+    end
+  end
+end

data/opal/webassembly/memory.rb

@@ -0,0 +1,18 @@
+require 'buffer'
+
+module WebAssembly
+  class Memory < `WebAssembly.Memory`
+    # 64kB pages
+    def self.new(initial=1, maximum=100, shared=false)
+      `new WebAssembly.Memory({initial: #{initial}, maximum: #{maximum}, shared: #{shared}})`
+    end
+
+    def grow(by)
+      self.JS.grow(by)
+    end
+
+    def buffer
+      Buffer.new(self.JS[:buffer])
+    end
+  end
+end

data/opal/webassembly/module.rb

@@ -0,0 +1,10 @@
+require 'native'
+
+module WebAssembly
+  class Module < `WebAssembly.Module`
+    def self.new(buffer)
+      buffer = buffer.to_n unless native? buffer
+      `new WebAssembly.Module(#{buffer})`
+    end
+  end
+end

data/opal/webassembly/table.rb

@@ -0,0 +1,35 @@
+module WebAssembly
+  class Table < `WebAssembly.Table`
+    include Enumerable
+
+    def self.new(initial=1, maximum=100)
+      `new WebAssembly.Table({initial: #{initial}, maximum: #{maximum}, element: "anyfunc"})`
+    end
+
+    def to_a
+      Array(self)
+    end
+
+    def each(&block)
+      self.to_a.each(&block)
+    end
+
+    def get(i)
+      self.JS.get(i)
+    end
+    alias [] get
+
+    def set(i, val)
+      self.JS.set(i, val)
+    end
+    alias []= set
+
+    def grow(by)
+      self.JS.grow(by)
+    end
+
+    def length
+      self.JS[:length]
+    end
+  end
+end

data/spec-opal/ffi_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+require 'experiment'
+
+RSpec.describe FFI do
+  it "has correct assumptions about types (wasm32)" do
+    expect(Experiment.longsize).to eq FFI::Type[:long].size
+    expect(Experiment.longlongsize).to eq FFI::Type[:long_long].size
+    expect(Experiment.ptrsize).to eq FFI::Type[:pointer].size
+    expect(Experiment.floatsize).to eq FFI::Type[:float].size
+    expect(Experiment.doublesize).to eq FFI::Type[:double].size
+    expect(Experiment.longdoublesize).to eq FFI::Type[:long_double].size
+  end
+
+  it "has correct assumptions about struct alignment" do
+    expect(Experiment.structalignld).to eq FFI::Type[:long_double].alignment
+    expect(Experiment.structalignll).to eq FFI::Type[:long_long].alignment
+    expect(Experiment.structaligni).to eq FFI::Type[:int].alignment
+    expect(Experiment.structalignp).to eq FFI::Type[:pointer].alignment
+  end
+
+  it "passes pointers correctly" do
+    ptr = Experiment.retpointer(FFI::Pointer.new([nil, 0x1133dd]))
+    expect(ptr.address).to eq(0x1133dd)
+    expect(ptr.memory).to eq(Experiment.library.memory)
+  end
+
+  it "passes floats correctly" do
+    expect(Experiment.retfloat(0.11)).to be_within(0.00001).of(-0.22)
+    expect(Experiment.retdouble(0.33)).to be_within(0.00000001).of(-0.66)
+  end
+
+  it "passes strings correctly" do
+    require 'corelib/array/pack'
+    Experiment.context do
+      expect(Experiment.retstring("hello world!".b)).to be("lmo!world!")
+    end
+  end
+
+  it "packs and unpacks values correctly" do
+    require 'corelib/array/pack'
+    require 'corelib/string/unpack'
+    for type in %i[uint8 int8 uint16 int16 int32 uint32 pointer]
+      type = FFI::Type[type]
+      expect(type.unpack(type.pack(123))).to eq(123)
+    end
+    type = FFI::Type[:string]
+    expect(type.unpack(type.pack(123))).to eq("123")
+  end
+
+  it "supports structs" do
+    require 'corelib/array/pack'
+    require 'corelib/string/unpack'
+
+    class MyStr < FFI::Struct
+      layout :a, :char,
+             :b, :int,
+             :c, [:int, 20]
+    end
+
+    Experiment.context do
+      expect(MyStr.members[:a].offset).to eq(0)
+      expect(MyStr.members[:b].offset).to eq(4)
+      expect(MyStr.members[:c].offset).to eq(8)
+
+      str = MyStr.new
+
+      expect(str[:c]).to be_a(FFI::Pointer)
+      expect(str[:a]).to be_a(Integer)
+
+      str[:a] = 10
+      str[:c][4] = 2000000
+
+      expect(str[:a]).to eq(10)
+      expect(str[:c][4]).to eq(2000000)
+
+      expect(MyStr.size).to eq(22 * 4)
+    end
+  end
+
+  it "supports nested pointer structs" do
+    require 'corelib/array/pack'
+    require 'corelib/string/unpack'
+
+    class Struct2 < FFI::Struct
+      layout :age, :int,
+             :a, :int,
+             :b, :int,
+             :c, :int
+    end
+
+    class Struct1 < FFI::Struct
+      layout :id, :int,
+             :data, Struct2.ptr
+    end
+
+    Experiment.context do
+      expect(Struct2.size).to eq(16)
+      expect(Struct1.size).to eq(8)
+
+      struct = Struct1.new
+      struct2 = Struct2.new
+      struct[:data] = struct2
+      struct[:data][:age] = 27
+
+      expect(struct).to be_a(Struct1)
+      expect(struct[:data]).to be_a(Struct2)
+      expect(struct[:data][:age]).to eq(27)
+    end
+  end
+
+  it "supports nested structs" do
+    require 'corelib/array/pack'
+    require 'corelib/string/unpack'
+
+    class Struct4 < FFI::Struct
+      layout :age, :int,
+             :a, :int,
+             :b, :int,
+             :c, :int
+    end
+
+    class Struct3 < FFI::Struct
+      layout :id, :int,
+             :data, Struct4
+    end
+
+    Experiment.context do
+      expect(Struct4.size).to eq(16)
+      expect(Struct3.size).to eq(20)
+
+      struct = Struct3.new
+      struct[:data][:age] = 27
+
+      expect(struct).to be_a(Struct3)
+      expect(struct[:data]).to be_a(Struct4)
+      expect(struct[:data][:age]).to eq(27)
+    end
+  end
+end