opal-webassembly 0.1.0

data/lib/opal/webassembly/version.rb

@@ -0,0 +1,5 @@
+module Opal
+  module WebAssembly
+    VERSION = "0.1.0"
+  end
+end

data/opal-webassembly.gemspec

@@ -0,0 +1,31 @@
+require_relative 'lib/opal/webassembly/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "opal-webassembly"
+  spec.version       = Opal::WebAssembly::VERSION
+  spec.authors       = ["Ribose Inc."]
+  spec.email         = ["open.source@ribose.com"]
+
+  spec.summary       = %q{Opal with WebAssembly support}
+  #spec.description   = %q{TODO: Write a longer description or delete this line.}
+  spec.homepage      = "https://github.com/interscript/opal-webassembly"
+  spec.license       = "BSD-2-Clause"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  #spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/interscript/opal-webassembly"
+  spec.metadata["changelog_uri"] = "https://github.com/interscript/opal-webassembly/commits/master"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "opal"
+end

data/opal/ffi.rb

@@ -0,0 +1,22 @@
+require 'webassembly'
+
+# An API trying to be compatible with Ruby-FFI.
+module FFI
+  def self.contexts
+    (@contexts ||= [])
+  end
+
+  def self.context
+    (@contexts ||= []).last.tap do |lib|
+      unless lib
+        raise RuntimeError, "This call needs to be done in a FFI::Library#context "+
+                            "block (Opal-WebAssembly limitation)."
+      end
+    end
+  end
+end
+
+require 'ffi/types'
+require 'ffi/pointer'
+require 'ffi/struct'
+require 'ffi/library'

data/opal/ffi/library.rb

@@ -0,0 +1,67 @@
+module FFI
+  module Library
+    def self.extended(mod)
+      raise RuntimeError.new("must only be extended by module") unless mod.kind_of?(Module)
+    end
+
+    def ffi_lib(*names)
+      # Expect the library (first one) to be already loaded in "Opal.WebAssembly.modules"
+      @ffi_lib = WebAssembly.libs[names.first]
+      raise LoadError, "Library #{names.first} not loaded" if !@ffi_lib
+
+      begin
+        attach_function :malloc, [:long], :pointer
+        attach_function :free, [:pointer], :void
+        attach_function :realloc, [:pointer, :long], :pointer
+      rescue LoadError
+        # It's ok, a library doesn't really need to provide memory functions.
+        # But we will need those.
+      end
+    end
+
+    def library
+      @ffi_lib
+    end
+
+    def attach_function(name, func, args = nil, returns = nil, **options)
+      if func.is_a? Array # Don't rename a function
+        func, args, returns = name, func, args
+      end
+
+      raise LoadError, "No library responds to #{func}" unless @ffi_lib.exports.has_key?(func)
+      fun = @ffi_lib.exports[func]
+
+      self.define_singleton_method name do |*as|
+        if as.count != args.count # :varargs?
+          raise ArgumentError, "Provided #{as.count} arguments, expected #{args.count}"
+        end
+
+        as = as.each_with_index.map do |a,ind|
+          type = Type[args[ind]]
+          if type.respond_to? :to_native_mem
+            type.to_native_mem(a, @ffi_lib.memory)
+          else
+            type.to_native(a)
+          end
+        end
+
+        ret = fun.call(*as)
+        type = Type[returns]
+        if type.respond_to? :from_native_mem
+          type.from_native_mem(ret, @ffi_lib.memory)
+        else
+          type.from_native(ret)
+        end
+      end
+    end
+
+    # Launch a block in a current context. Needed for memory management.
+    # Think: segmented memory.
+    def context &block
+      FFI.contexts.push self
+      out = yield
+      FFI.contexts.pop
+      out
+    end
+  end
+end

data/opal/ffi/pointer.rb

@@ -0,0 +1,289 @@
+# Large portions of this file are adapted from
+# https://github.com/ffi/ffi/blob/master/lib/ffi/pointer.rb
+
+module FFI
+  class Pointer
+    SIZE = 4
+
+    # Return the size of a pointer on the current platform, in bytes
+    # @return [Numeric]
+    def self.size
+      SIZE
+    end
+
+    # @param [nil,Numeric] len length of string to return
+    # @return [String]
+    # Read pointer's contents as a string, or the first +len+ bytes of the
+    # equivalent string if +len+ is not +nil+.
+    def read_string(len=nil)
+      if len
+        return ''.b if len == 0
+        get_bytes(0, len)
+      else
+        get_string(0)
+      end
+    end
+
+    # @param [Numeric] len length of string to return
+    # @return [String]
+    # Read the first +len+ bytes of pointer's contents as a string.
+    #
+    # Same as:
+    #  ptr.read_string(len)  # with len not nil
+    def read_string_length(len)
+      get_bytes(0, len)
+    end
+
+    # @return [String]
+    # Read pointer's contents as a string.
+    #
+    # Same as:
+    #  ptr.read_string  # with no len
+    def read_string_to_null
+      get_string(0)
+    end
+
+    # @param [String] str string to write
+    # @param [Numeric] len length of string to return
+    # @return [self]
+    # Write +len+ first bytes of +str+ in pointer's contents.
+    #
+    # Same as:
+    #  ptr.write_string(str, len)   # with len not nil
+    def write_string_length(str, len)
+      put_bytes(0, str, 0, len)
+    end
+
+    # @param [String] str string to write
+    # @param [Numeric] len length of string to return
+    # @return [self]
+    # Write +str+ in pointer's contents, or first +len+ bytes if
+    # +len+ is not +nil+.
+    def write_string(str, len=nil)
+      #len = str.bytesize unless len
+      # Write the string data without NUL termination
+      put_bytes(0, str, 0, len)
+    end
+
+    # @param [Type] type type of data to read from pointer's contents
+    # @param [Symbol] reader method to send to +self+ to read +type+
+    # @param [Numeric] length
+    # @return [Array]
+    # Read an array of +type+ of length +length+.
+    # @example
+    #  ptr.read_array_of_type(TYPE_UINT8, :read_uint8, 4) # -> [1, 2, 3, 4]
+    def read_array_of_type(type, reader, length)
+      ary = []
+      size = FFI.type_size(type)
+      tmp = self
+      length.times { |j|
+        ary << tmp.send(reader)
+        tmp += size unless j == length-1 # avoid OOB
+      }
+      ary
+    end
+
+    # @param [Type] type type of data to write to pointer's contents
+    # @param [Symbol] writer method to send to +self+ to write +type+
+    # @param [Array] ary
+    # @return [self]
+    # Write +ary+ in pointer's contents as +type+.
+    # @example
+    #  ptr.write_array_of_type(TYPE_UINT8, :put_uint8, [1, 2, 3 ,4])
+    def write_array_of_type(type, writer, ary)
+      size = FFI.type_size(type)
+      ary.each_with_index { |val, i|
+        break unless i < self.size
+        self.send(writer, i * size, val)
+      }
+      self
+    end
+
+    # @return [self]
+    def to_ptr
+      self
+    end
+
+    def pointer
+      self
+    end
+
+    # @param [Symbol,Type] type of data to read
+    # @return [Object]
+    # Read pointer's contents as +type+
+    #
+    # Same as:
+    #  ptr.get(type, 0)
+    def read(type)
+      get(type, 0)
+    end
+
+    # @param [Symbol,Type] type of data to read
+    # @param [Object] value to write
+    # @return [nil]
+    # Write +value+ of type +type+ to pointer's content
+    #
+    # Same as:
+    #  ptr.put(type, 0)
+    def write(type, value)
+      put(type, 0, value)
+    end
+
+    def get_bytes(pos, len)
+      ary = @memory.buffer.to_a
+
+      out = []
+      i = 0
+      while i < len
+        out << ary[@address + pos + i]
+        i += 1
+      end
+
+      # We expect a binary string as an output of this function.
+      out.pack("c*").b # TODO upstream: #bytes is wrong!
+    end
+
+    def put_bytes(pos, src, src_pos=0, len=nil)
+      if src.respond_to? :bytes
+        src = if src.encoding == Encoding::BINARY
+          src.chars.map(&:ord)
+        else
+          src.bytes
+        end
+      end
+      len ||= src.length - src_pos
+
+      ary = @memory.buffer.to_a
+      i = 0
+      while i < len
+        ary[@address + i + pos] = src[src_pos + i]
+        i += 1
+      end
+    end
+
+    def get(type, pos)
+      type = FFI::Type[type]
+      bytes = get_bytes(pos, type.size)
+      if type.respond_to? :from_native_mem
+        type.from_native_mem(type.unpack(bytes), @memory)
+      else
+        type.from_native(type.unpack(bytes))
+      end
+    end
+
+    def put(type, pos, value)
+      type = FFI::Type[type]
+      value = if type.respond_to? :to_native_mem
+        type.to_native_mem(value, @memory)
+      else
+        type.to_native(value)
+      end
+      value = type.pack(value)
+      put_bytes(pos, value)
+    end
+
+    def get_string(pos)
+      out = []
+      ary = @memory.buffer.to_a
+      pos += @address
+      loop do
+        byte = ary[pos]
+        break if byte == 0
+        out << byte
+        pos += 1
+      end
+      out.pack("c*").b
+    end
+
+    def put_string(pos, string)
+      put_bytes(pos, string)
+    end
+
+    def self.from_string src
+      bs = if src.encoding == Encoding::BINARY
+        src.chars.map(&:ord)
+      else
+        src.bytes
+      end
+      bs = bs + [0, 0]
+      out = new(:uint8, bs.count)
+      out.put_bytes(0, bs)
+      out
+    end
+
+    def self.alloc_out size, count, smh=false
+      new(:uint8, size*count)
+    end
+
+    def self.alloc_in size, count, smh=false
+      new(:uint8, size*count)
+    end
+
+    def method_missing method, *args
+      method = method.to_s
+      super
+    end
+
+    # Pointer in our case is more complex than a regular one: it's
+    # [WebAssembly::Memory instance, uint32 address] since WebAssembly
+    # "processes" run in separate address spaces.
+    #
+    # Alternatively, memory can be deduced from wrapping inside
+    # Library#context.
+    def initialize(address, type=nil, size=nil)
+      if address.respond_to? :address
+        if address.respond_to? :memory
+          @memory = address.memory || FFI.context.library.memory
+        else
+          @memory = FFI.context.library.memory
+        end
+        @address = address.address
+      elsif address.respond_to?(:to_sym) || address.is_a?(Type) || address.is_a?(Class) # Allocation call
+        type, count = address, type
+        @memory = FFI.context.library.memory
+        @address = FFI.context.malloc(FFI::Type[type].size * (count || 1)).address
+      elsif address.respond_to? :to_ary
+        @memory, @address = address.to_ary
+        @size = size
+      elsif address.respond_to? :to_int
+        @memory = FFI.context.library.memory
+        @address = address.to_int
+        @size = size
+      else
+        raise TypeError, "Address has an invalid type"
+      end
+      @type = type ? FFI::Type[type] : FFI::Type[:uint8]
+    end
+
+    attr_accessor :memory, :address, :type
+
+    def == other
+      (self.address == other.address) &&
+      (self.address == 0 || (self.memory == other.memory))
+    end
+
+    def + offset
+      self.dup.tap { |i| i.address += offset * type.size }
+    end
+
+    def [] offset
+      self.get(type, offset * type.size)
+    end
+
+    def []= offset, value
+      self.put(type, offset * type.size, value)
+    end
+
+    def resize(new_size)
+      self.address = FFI.context.realloc(self, new_size).address
+    end
+
+    def inspect
+      out = "#<#{self.class.name}:#{"0x%08x" % self.address} of #{self.type.inspect}>"
+    end
+
+    NULL = new([nil, 0])
+  end
+
+  AutoPointer = MemoryPointer = Buffer = Pointer
+end

data/opal/ffi/struct.rb

@@ -0,0 +1,125 @@
+module FFI
+  class Struct
+    def self.size
+      @size || 4
+    end
+
+    def self.alignment
+      @alignment ||= @layout&.values&.map(&:type)&.map(&:alignment)&.max || 4
+    end
+
+    def self.by_value; self; end
+    def self.by_ptr; FFI::Type::WrappedStruct.new(self); end
+
+    def self.pack x; raise ArgumentError, "Packing Struct directly is forbidden"; end
+    def self.unpack x; raise ArgumentError, "Unpacking Struct directly is forbidden"; end
+
+    def from_native_mem(x, memory)
+      new(FFI::Pointer.new([memory, x], self))
+    end
+
+    def to_native(x)
+      x.pointer.address
+    end
+
+    def self.ptr; by_ptr; end
+
+    def self.layout *fs, **fields
+      if fs.length > 0
+        while (z = fs.shift(2)).length == 2
+          k, v = z
+          fields[k] = v
+        end
+      end
+
+      offset = 0
+      @layout = {}
+      fields.each do |name, type|
+        count = nil
+        if type.is_a? Array
+          type, count = type
+        end
+        type = FFI::Type[type, :struct]
+
+        offset += 1 until (offset % type.alignment) == 0
+        @layout[name] = Field.new(self, name, type, offset, count)
+
+        if count
+          offset += type.size * count
+        else
+          offset += type.size
+        end
+      end
+      @size = offset
+    end
+
+    def self.members; @layout; end
+    def members; self.class.members; end
+
+    def [] field
+      members[field].get(self)
+    end
+
+    def []= field, value
+      members[field].set(self, value)
+    end
+
+    def offset_of field
+      members[field].offset
+    end
+
+    attr_reader :pointer
+
+    def address
+      pointer.address
+    end
+
+    def initialize pointer=nil
+      if pointer
+        @pointer = pointer
+      else
+        @pointer = FFI.context.malloc(self.class.size)
+        @pointer.type = FFI::Type[self.class]
+        @pointer
+      end
+    end
+
+    def inspect
+      out = ["#<#{self.class.name}:#{"0x%08x" % self.address}: "]
+      out << self.members.keys.map do |key|
+        ":#{key} => #{self.[](key).inspect}"
+      end.join(", ")
+      out << ">"
+      out.join
+    end
+  end
+
+  class Field
+    attr_accessor :struct, :name, :type, :offset, :count
+    def initialize struct, name, type, offset, count
+      @struct, @name, @type, @offset, @count = struct, name, type, offset, count
+    end
+
+    def get from
+      if count
+        FFI::Pointer.new([from.pointer.memory, from.address + offset], type)
+      elsif type.is_a?(Class) && type <= FFI::Struct
+        type.new(FFI::Pointer.new([from.pointer.memory, from.address + offset], type))
+      else
+        from.pointer.get(type, offset)
+      end
+    end
+
+    def set from, value
+      if count
+        raise ArgumentError, "Can't set an array #{name} of #{struct}."
+      elsif type.is_a?(Class) && type <= FFI::Struct
+        raise ArgumentError, "Can't set a nested struct #{name}."
+      else
+        from.pointer.put(type, offset, value)
+      end
+    end
+  end
+
+  ManagedStruct = Struct
+end