wardite 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d27a05a105bd446883460d42c05cbec8502360dc686098368d59b1ae5e6e3e91
-  data.tar.gz: d17f48eade8ac57845bf250583db7eb33dd9a418c315ba1083a7e0f598505298
+  metadata.gz: 8e33fd39e5cc58e9ec6071c4a74d5cbe872d68355657dd1adfdf375d74cf03b9
+  data.tar.gz: cee2e80f2dda3a2366450cf9b2d6656b172faa41b69eba39c03610b8a3c8d38b
 SHA512:
-  metadata.gz: 21de2c67fd7aaaf04d55f028d304588a4f5c7f92b21ab4b7cb40dd7882103067db85401f41efc53b491996a82f109a9b11c05b0efa62e9622ad3971f6e254342
-  data.tar.gz: 90542ce81cf6bf537eac6ddab087abab10842bfb24f153ba88865a7d2b5a0417c3e3fbab116e5ad2bedabc3d665810f34c0c8568a2baa2adbbdda89c681df076
+  metadata.gz: bfabd5ef113b7ebdc5e7aa5059eed7984e5f38a8490e120b4ab4230972f503e62aff24d0bfa5cdcef49bc8dcd082c69ade651f95e5cd0101780acdd389378fda
+  data.tar.gz: eac7e0374494969be1ea08e8fb7344e163a2c122ff3d6b958d47851bc3815104329216c9107612930209ecf0551ff677a5d9f3744792d82746b410b32fe329d4

data/Rakefile

@@ -15,5 +15,20 @@ task :check do
   sh "bundle exec steep check"
 end
 
+desc "Generate codes"
+task :generate do
+  require_relative "scripts/gen_alu"
+  libdir = File.expand_path("../lib", __FILE__)
+
+  GenAlu.execute(libdir + "/wardite/alu_i32.generated.rb", prefix: "i32", defined_ops: [
+    :lts,
+    :leu,
+    :add,
+    :sub,
+    :const,
+    :store,
+  ])
+end
+
 task default: %i[test check]
 

data/lib/wardite/alu_i32.generated.rb

@@ -0,0 +1,77 @@
+# rbs_inline: enabled
+require_relative "value"
+
+module Wardite
+  module Evaluator
+    # @rbs runtime: Runtime
+    # @rbs frame: Frame
+    # @rbs insn: Op
+    # @rbs return: void 
+    def self.i32_eval_insn(runtime, frame, insn)
+      case insn.code
+
+      when :i32_lts
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(I32) || !left.is_a?(I32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        value = (left.value < right.value) ? 1 : 0
+        runtime.stack.push(I32(value))
+
+
+      when :i32_leu
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(I32) || !left.is_a?(I32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        value = (left.value >= right.value) ? 1 : 0
+        runtime.stack.push(I32(value))
+
+
+      when :i32_add
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(I32) || !left.is_a?(I32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        runtime.stack.push(I32(left.value + right.value))
+
+
+      when :i32_sub
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(I32) || !left.is_a?(I32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        runtime.stack.push(I32(left.value - right.value))
+
+
+      when :i32_const
+        const = insn.operand[0]
+        if !const.is_a?(Integer)
+          raise EvalError, "invalid type of operand"
+        end
+        runtime.stack.push(I32(const))
+
+
+      when :i32_store
+        _align = insn.operand[0] # TODO: alignment support?
+        offset = insn.operand[1]
+        raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
+      
+        value = runtime.stack.pop
+        addr = runtime.stack.pop
+        if !value.is_a?(I32) || !addr.is_a?(I32)
+          raise EvalError, "maybe stack too short"
+        end
+      
+        at = addr.value + offset
+        data_end = at + value.packed.size
+        memory = runtime.instance.store.memories[0] || raise("[BUG] no memory")
+        memory.data[at...data_end] = value.packed
+
+
+      else
+        raise "Unknown opcode for namespace #{insn.namespace}: #{insn.code}"
+      end
+    end
+  end
+end

data/lib/wardite/instruction.rb

@@ -1,47 +1,65 @@
 # rbs_inline: enabled
+
 module Wardite
   class Op
+    attr_accessor :namespace #: Symbol
+
     attr_accessor :code #: Symbol
 
-    attr_accessor :operand #: Array[Object]
+    # TODO: add types of potential operands
+    attr_accessor :operand #: Array[Integer|Float|Block]
 
+    # @rbs namespace: Symbol
     # @rbs code: Symbol
-    # @rbs operand: Array[Object]
-    def initialize(code, operand)
+    # @rbs operand: Array[Integer|Float|Block]
+    def initialize(namespace, code, operand)
+      @namespace = namespace      
       @code = code
       @operand = operand
     end
 
     # @rbs chr: String
-    # @rbs return: Symbol
+    # @rbs return: [Symbol, Symbol]
     def self.to_sym(chr)
-      case chr
-      when "\u0004"
-        :if
-      when "\u000b"
-        :end
-      when "\u000f"
-        :return
-      when "\u0010"
-        :call
-      when "\u0020"
-        :local_get
-      when "\u0021"
-        :local_set
-      when "\u0036"
-        :i32_store
-      when "\u0041"
-        :i32_const
-      when "\u0048"
-        :i32_lts
-      when "\u004d"
-        :i32_leu
-      when "\u006a"
-        :i32_add
-      when "\u006b"
-        :i32_sub
+      code = case chr
+        when "\u0004"
+          :if
+        when "\u000b"
+          :end
+        when "\u000f"
+          :return
+        when "\u0010"
+          :call
+        when "\u0020"
+          :local_get
+        when "\u0021"
+          :local_set
+        when "\u0036"
+          :i32_store
+        when "\u0041"
+          :i32_const
+        when "\u0048"
+          :i32_lts
+        when "\u004d"
+          :i32_leu
+        when "\u006a"
+          :i32_add
+        when "\u006b"
+          :i32_sub
+        else
+          raise NotImplementedError, "unimplemented: #{"%04x" % chr.ord}"
+        end
+      # opcodes equal to or larger than are "convert" ops
+      if chr.ord >= 0xa7
+        return [:convert, code]
+      end
+
+      prefix = code.to_s.split("_")[0]
+      case prefix
+      when "i32", "i64", "f32", "f64"
+        [prefix.to_sym, code]
       else
-        raise NotImplementedError, "unimplemented: #{"%04x" % chr.ord}"
+        [:default, code]
       end
     end
 

data/lib/wardite/leb128.rb

@@ -1,6 +1,6 @@
 # rbs_inline: enabled
 module Wardite
-  module Leb128Helpers
+  module Leb128Helper
     # @rbs buf: File|StringIO
     # @rbs return: Integer
     def fetch_uleb128(buf)

data/lib/wardite/value.rb

@@ -0,0 +1,82 @@
+# rbs_inline: enabled
+
+module Wardite
+  class I32
+    attr_accessor :value #: Integer
+
+    # TODO: eliminate use of pack, to support mruby - in this file!
+    # @rbs return: String
+    def packed
+      [self.value].pack("I")
+    end
+
+    def inspect
+      "I32(#{@value})"
+    end
+  end
+
+  class I64
+    attr_accessor :value #: Integer
+
+    # @rbs return: String
+    def packed
+      [self.value].pack("L")
+    end
+
+    def inspect
+      "I64(#{@value})"
+    end
+  end
+
+  class F32
+    attr_accessor :value #: Float    
+
+    # @rbs return: String
+    def packed
+      [self.value].pack("f")
+    end
+
+    def inspect
+      "F32(#{@value})"
+    end
+  end
+
+  class F64
+    attr_accessor :value #: Float    
+
+    # @rbs return: String
+    def packed
+      [self.value].pack("d")
+    end
+
+    def inspect
+      "F64(#{@value})"
+    end
+  end
+
+  module ValueHelper
+    # @rbs value: Integer
+    # @rbs return: I32
+    def I32(value)
+      I32.new.tap{|i| i.value = value }
+    end
+
+    # @rbs value: Integer
+    # @rbs return: I64
+    def I64(value)
+      I64.new.tap{|i| i.value = value }
+    end
+
+    # @rbs value: Float
+    # @rbs return: F32
+    def F32(value)
+      F32.new.tap{|i| i.value = value }
+    end
+
+    # @rbs value: Float
+    # @rbs return: F64
+    def F64(value)
+      F64.new.tap{|i| i.value = value }
+    end
+  end
+end

data/lib/wardite/version.rb

@@ -2,5 +2,5 @@
 # rbs_inline: enabled
 
 module Wardite
-  VERSION = "0.1.2" #: String
+  VERSION = "0.2.0" #: String
 end

data/lib/wardite/wasi.rb

@@ -1,6 +1,8 @@
 # rbs_inline: enabled
 module Wardite
   class WasiSnapshotPreview1
+    include ValueHelper
+
     attr_accessor :fd_table #: Array[IO]
 
     def initialize
@@ -12,12 +14,12 @@ module Wardite
     end
 
     # @rbs store: Store
-    # @rbs args: Array[Object]
+    # @rbs args: Array[I32|I64|F32|F64]
     # @rbs return: Object
     def fd_write(store, args)
       iargs = args.map do |elm|
-        if elm.is_a?(Integer)
-          elm
+        if elm.is_a?(I32)
+          elm.value
         else
           raise Wardite::ArgumentError, "invalid type of args: #{args.inspect}"
         end

data/lib/wardite.rb

@@ -5,6 +5,15 @@ require_relative "wardite/version"
 require_relative "wardite/leb128"
 require_relative "wardite/const"
 require_relative "wardite/instruction"
+require_relative "wardite/value"
+
+module Wardite
+  module Evaluator
+    extend Wardite::ValueHelper
+  end
+end
+require_relative "wardite/alu_i32.generated"
+
 require_relative "wardite/wasi"
 
 require "stringio"
@@ -164,7 +173,8 @@ module Wardite
   end
 
   module BinaryLoader
-    extend Wardite::Leb128Helpers
+    extend Wardite::Leb128Helper
+    extend Wardite::ValueHelper
 
     # @rbs buf: File|StringIO
     # @rbs import_object: Hash[Symbol, Hash[Symbol, Proc]]
@@ -417,9 +427,9 @@ module Wardite
     def self.code_body(buf)
       dest = []
       while c = buf.read(1)
-        code = Op.to_sym(c)
+        namespace, code = Op.to_sym(c)
         operand_types = Op.operand_of(code)
-        operand = [] #: Array[Object]
+        operand = [] #: Array[Integer|Float|Block]
         operand_types.each do |typ|
           case typ
           when :u32
@@ -442,7 +452,7 @@ module Wardite
           end         
         end
 
-        dest << Op.new(code, operand)
+        dest << Op.new(namespace, code, operand)
       end
 
       dest
@@ -675,7 +685,10 @@ module Wardite
   end
 
   class Runtime
-    attr_accessor :stack #: Array[Object]
+    include ValueHelper
+
+    # TODO: add types of class that the stack accomodates
+    attr_accessor :stack #: Array[I32|I64|F32|F64|Block]
 
     attr_accessor :call_stack #: Array[Frame]
 
@@ -708,34 +721,14 @@ module Wardite
       if fn.callsig.size != args.size
         raise ArgumentError, "unmatch arg size"
       end
-      args.each do |arg|
-        stack.push arg
-      end
-
-      case fn
-      when WasmFunction
-        invoke_internal(fn)
-      when ExternalFunction
-        invoke_external(fn)
-      else
-        raise GenericError, "registered pointer is not to a function"
-      end
-    end
-
-    # @rbs idx: Integer
-    # @rbs args: Array[Object]
-    # @rbs return: Object|nil
-    def call_index(idx, args)
-      fn = self.instance.store[idx]
-      if !fn
-        # TODO: own error NoFunctionError
-        raise ::NoMethodError, "func #{idx} not found"
-      end
-      if fn.callsig.size != args.size
-        raise ArgumentError, "unmatch arg size"
-      end
-      args.each do |arg|
-        stack.push arg
+      args.each_with_index do |arg, idx|
+        case fn.callsig[idx]
+        when :i32
+          raise "type mismatch: i32(#{arg})" unless arg.is_a?(Integer)
+          stack.push I32(arg)
+        else
+          raise "TODO: add me"
+        end
       end
 
       case fn
@@ -761,11 +754,12 @@ module Wardite
       wasm_function.locals_type.each_with_index do |typ, i|
         case typ
         when :i32, :u32
-          # locals.push Local::I32(typ, 0)...
-          locals.push 0
+          locals.push I32(0)
+        when :i64, :u64
+          locals.push I64(0)
         else
-          $stderr.puts "warning: unknown type #{typ.inspect}. default to Object"
-          locals.push Object.new
+          $stderr.puts "warning: unknown type #{typ.inspect}. default to I32"
+          locals.push I32(0)
         end
       end
 
@@ -796,7 +790,7 @@ module Wardite
     end
 
     # @rbs external_function: ExternalFunction
-    # @rbs return: Object|nil
+    # @rbs return: I32|I64|F32|F64|nil
     def invoke_external(external_function)
       local_start = stack.size - external_function.callsig.size
       args = stack[local_start..]
@@ -806,7 +800,31 @@ module Wardite
       self.stack = drained_stack(local_start)
 
       proc = external_function.callable
-      proc[self.instance.store, args]
+      val = proc[self.instance.store, args]
+      if !val
+        return
+      end
+
+      case val
+      when I32, I64, F32, F64
+        return val
+      when Integer
+        case external_function.retsig[0]
+        when :i32
+          return I32(val)
+        when :i64
+          return I64(val)
+        end
+      when Float
+        case external_function.retsig[0]
+        when :f32
+          return F32(val)
+        when :f64
+          return F64(val)
+        end
+      end
+
+      raise "invalid type of value returned in proc. val: #{val.inspect}"
     end
 
     # @rbs return: void
@@ -829,14 +847,20 @@ module Wardite
     # @rbs insn: Op
     # @rbs return: void
     def eval_insn(frame, insn)
+      case insn.namespace
+      when :i32
+        return Evaluator.i32_eval_insn(self, frame, insn)
+      end
+
+      # unmached namespace...
       case insn.code
       when :if
         block = insn.operand[0]
         raise EvalError, "if op without block" if !block.is_a?(Block)
         cond = stack.pop 
-        raise EvalError, "cond not found" if !cond.is_a?(Integer)
+        raise EvalError, "cond not found" if !cond.is_a?(I32)
         next_pc = fetch_ops_while_end(frame.body, frame.pc)
-        if cond.zero?
+        if cond.value.zero?
           frame.pc = next_pc
         end
 
@@ -862,55 +886,58 @@ module Wardite
         if !value
           raise EvalError, "value should be pushed"
         end
-        frame.locals[idx] = value
-
-      when :i32_lts
-        right, left = stack.pop, stack.pop
-        if !right.is_a?(Integer) || !left.is_a?(Integer)
-          raise EvalError, "maybe empty stack"
-        end
-        value = (left < right) ? 1 : 0
-        stack.push(value)
-      when :i32_leu
-        right, left = stack.pop, stack.pop
-        if !right.is_a?(Integer) || !left.is_a?(Integer)
-          raise EvalError, "maybe empty stack"
-        end
-        value = (left >= right) ? 1 : 0
-        stack.push(value)
-      when :i32_add
-        right, left = stack.pop, stack.pop
-        if !right.is_a?(Integer) || !left.is_a?(Integer)
-          raise EvalError, "maybe empty stack"
-        end
-        stack.push(left + right)
-      when :i32_sub
-        right, left = stack.pop, stack.pop
-        if !right.is_a?(Integer) || !left.is_a?(Integer)
-          raise EvalError, "maybe empty stack"
-        end
-        stack.push(left - right)
-      when :i32_const
-        const = insn.operand[0]
-        if !const.is_a?(Integer)
-          raise EvalError, "[BUG] invalid type of operand"
-        end
-        stack.push(const)
-      when :i32_store
-        _align = insn.operand[0] # TODO: alignment support?
-        offset = insn.operand[1]
-        raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
-
-        value = stack.pop
-        addr = stack.pop
-        if !value.is_a?(Integer) || !addr.is_a?(Integer)
-          raise EvalError, "maybe stack too short"
+        if value.is_a?(Block)
+          raise EvalError, "block value detected"
         end
+        frame.locals[idx] = value
 
-        at = addr + offset
-        data_end = at + 4 # sizeof(i32)
-        memory = self.instance.store.memories[0] || raise("[BUG] no memory")
-        memory.data[at...data_end] = [value].pack("I")
+      # when :i32_lts
+      #   right, left = stack.pop, stack.pop
+      #   if !right.is_a?(Integer) || !left.is_a?(Integer)
+      #     raise EvalError, "maybe empty stack"
+      #   end
+      #   value = (left < right) ? 1 : 0
+      #   stack.push(value)
+      # when :i32_leu
+      #   right, left = stack.pop, stack.pop
+      #   if !right.is_a?(Integer) || !left.is_a?(Integer)
+      #     raise EvalError, "maybe empty stack"
+      #   end
+      #   value = (left >= right) ? 1 : 0
+      #   stack.push(value)
+      # when :i32_add
+      #   right, left = stack.pop, stack.pop
+      #   if !right.is_a?(Integer) || !left.is_a?(Integer)
+      #     raise EvalError, "maybe empty stack"
+      #   end
+      #   stack.push(left + right)
+      # when :i32_sub
+      #   right, left = stack.pop, stack.pop
+      #   if !right.is_a?(Integer) || !left.is_a?(Integer)
+      #     raise EvalError, "maybe empty stack"
+      #   end
+      #   stack.push(left - right)
+      # when :i32_const
+      #   const = insn.operand[0]
+      #   if !const.is_a?(Integer)
+      #     raise EvalError, "[BUG] invalid type of operand"
+      #   end
+      #   stack.push(const)
+      # when :i32_store
+      #   _align = insn.operand[0] # TODO: alignment support?
+      #   offset = insn.operand[1]
+      #   raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
+
+      #   value = stack.pop
+      #   addr = stack.pop
+      #   if !value.is_a?(Integer) || !addr.is_a?(Integer)
+      #     raise EvalError, "maybe stack too short"
+      #   end
+
+      #   at = addr + offset
+      #   data_end = at + 4 # sizeof(i32)
+      #   memory = self.instance.store.memories[0] || raise("[BUG] no memory")
+      #   memory.data[at...data_end] = [value].pack("I")
 
       when :call
         idx = insn.operand[0]
@@ -996,7 +1023,7 @@ module Wardite
     end
 
     # @rbs finish: Integer
-    # @rbs return: Array[Object]
+    # @rbs return: Array[I32|I64|F32|F64|Block]
     def drained_stack(finish)
       drained = stack[0...finish]
       if ! drained
@@ -1034,7 +1061,7 @@ module Wardite
 
     attr_accessor :labels #: Array[Label]
 
-    attr_accessor :locals #: Array[Object]
+    attr_accessor :locals #: Array[I32|I64|F32|F64]
 
     # @rbs pc: Integer
     # @rbs sp: Integer

data/scripts/gen_alu.rb

@@ -0,0 +1,124 @@
+require "stringio"
+
+module GenAlu
+  def self.execute(path, prefix: "i32", defined_ops: [])
+    parent_dir = File.dirname(path)
+    system "mkdir -p #{parent_dir}"
+
+    basic_module = File.read(
+      File.expand_path("../templates/alu_module.rb.tmpl", __FILE__)
+    )
+    basic_module.gsub!(/\$\{PREFIX\}/, prefix)
+    ope_defs = generate_ops(prefix: prefix, defined_ops: defined_ops)
+    basic_module.gsub!(/\$\{DEFS\}/, ope_defs)
+
+    dest = File.open(path, "w")
+    dest.puts basic_module
+
+    $stderr.puts "generated: #{path}"
+  end
+
+  def self.generate_ops(prefix:, defined_ops:)
+    result = StringIO.new("")
+    defined_ops.each do |op|
+      code = DEFS[op.to_sym]
+      if ! code
+        raise "unsupported code specified!"
+      end
+      code.gsub!(/\$\{PREFIX\}/, prefix)
+      code.gsub!(/\$\{CLASS\}/, to_class(prefix.to_sym))
+      result << "\n"
+      code.each_line do |ln|
+        result << " " * 6 << ln
+      end
+      result << "\n"
+    end
+    result.string
+  end
+
+  def self.to_class(prefix)
+    {
+      i32: "I32",
+      i64: "I64",
+      f32: "F32",
+      f64: "F64",
+    }[prefix]
+  end
+ 
+  # ope_templates
+  DEFS = { #: Hash[Symbol, String]
+    lts: <<~RUBY,
+      when :${PREFIX}_lts
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(${CLASS}) || !left.is_a?(${CLASS})
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        value = (left.value < right.value) ? 1 : 0
+        runtime.stack.push(I32(value))
+    RUBY
+
+    leu: <<~RUBY,
+      when :${PREFIX}_leu
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(${CLASS}) || !left.is_a?(${CLASS})
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        value = (left.value >= right.value) ? 1 : 0
+        runtime.stack.push(I32(value))
+    RUBY
+
+    add: <<~RUBY,
+      when :${PREFIX}_add
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(${CLASS}) || !left.is_a?(${CLASS})
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        runtime.stack.push(${CLASS}(left.value + right.value))
+    RUBY
+
+    sub: <<~RUBY,
+      when :${PREFIX}_sub
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(${CLASS}) || !left.is_a?(${CLASS})
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        runtime.stack.push(${CLASS}(left.value - right.value))
+    RUBY
+
+    const: <<~RUBY,
+      when :${PREFIX}_const
+        const = insn.operand[0]
+        if !const.is_a?(Integer)
+          raise EvalError, "invalid type of operand"
+        end
+        runtime.stack.push(${CLASS}(const))
+    RUBY
+
+    const__f: <<~RUBY,
+      when :${PREFIX}_const
+        const = insn.operand[0]
+        if !const.is_a?(Float)
+          raise EvalError, "invalid type of operand"
+        end
+        runtime.stack.push(${CLASS}(const))
+    RUBY
+
+    store: <<~RUBY,
+      when :${PREFIX}_store
+        _align = insn.operand[0] # TODO: alignment support?
+        offset = insn.operand[1]
+        raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
+
+        value = runtime.stack.pop
+        addr = runtime.stack.pop
+        if !value.is_a?(${CLASS}) || !addr.is_a?(I32)
+          raise EvalError, "maybe stack too short"
+        end
+
+        at = addr.value + offset
+        data_end = at + value.packed.size
+        memory = runtime.instance.store.memories[0] || raise("[BUG] no memory")
+        memory.data[at...data_end] = value.packed
+    RUBY
+  }
+end

data/scripts/templates/alu_module.rb.tmpl

@@ -0,0 +1,18 @@
+# rbs_inline: enabled
+require_relative "value"
+
+module Wardite
+  module Evaluator
+    # @rbs runtime: Runtime
+    # @rbs frame: Frame
+    # @rbs insn: Op
+    # @rbs return: void 
+    def self.${PREFIX}_eval_insn(runtime, frame, insn)
+      case insn.code
+${DEFS}
+      else
+        raise "Unknown opcode for namespace #{insn.namespace}: #{insn.code}"
+      end
+    end
+  end
+end

data/sig/generated/wardite/alu_i32.generated.rbs

@@ -0,0 +1,11 @@
+# Generated from lib/wardite/alu_i32.generated.rb with RBS::Inline
+
+module Wardite
+  module Evaluator
+    # @rbs runtime: Runtime
+    # @rbs frame: Frame
+    # @rbs insn: Op
+    # @rbs return: void 
+    def self.i32_eval_insn: (Runtime runtime, Frame frame, Op insn) -> void
+  end
+end

data/sig/generated/wardite/instruction.rbs

@@ -1,19 +1,22 @@
 # Generated from lib/wardite/instruction.rb with RBS::Inline
 
-# rbs_inline: enabled
 module Wardite
   class Op
+    attr_accessor namespace: Symbol
+
     attr_accessor code: Symbol
 
-    attr_accessor operand: Array[Object]
+    # TODO: add types of potential operands
+    attr_accessor operand: Array[Integer | Float | Block]
 
+    # @rbs namespace: Symbol
     # @rbs code: Symbol
-    # @rbs operand: Array[Object]
-    def initialize: (Symbol code, Array[Object] operand) -> untyped
+    # @rbs operand: Array[Integer|Float|Block]
+    def initialize: (Symbol namespace, Symbol code, Array[Integer | Float | Block] operand) -> untyped
 
     # @rbs chr: String
-    # @rbs return: Symbol
-    def self.to_sym: (String chr) -> Symbol
+    # @rbs return: [Symbol, Symbol]
+    def self.to_sym: (String chr) -> [ Symbol, Symbol ]
 
     # @rbs chr: Symbol
     # @rbs return: Array[Symbol]

data/sig/generated/wardite/leb128.rbs

@@ -2,7 +2,7 @@
 
 # rbs_inline: enabled
 module Wardite
-  module Leb128Helpers
+  module Leb128Helper
     # @rbs buf: File|StringIO
     # @rbs return: Integer
     def fetch_uleb128: (File | StringIO buf) -> Integer

data/sig/generated/wardite/value.rbs

@@ -0,0 +1,58 @@
+# Generated from lib/wardite/value.rb with RBS::Inline
+
+module Wardite
+  class I32
+    attr_accessor value: Integer
+
+    # TODO: eliminate use of pack, to support mruby - in this file!
+    # @rbs return: String
+    def packed: () -> String
+
+    def inspect: () -> untyped
+  end
+
+  class I64
+    attr_accessor value: Integer
+
+    # @rbs return: String
+    def packed: () -> String
+
+    def inspect: () -> untyped
+  end
+
+  class F32
+    attr_accessor value: Float
+
+    # @rbs return: String
+    def packed: () -> String
+
+    def inspect: () -> untyped
+  end
+
+  class F64
+    attr_accessor value: Float
+
+    # @rbs return: String
+    def packed: () -> String
+
+    def inspect: () -> untyped
+  end
+
+  module ValueHelper
+    # @rbs value: Integer
+    # @rbs return: I32
+    def I32: (Integer value) -> I32
+
+    # @rbs value: Integer
+    # @rbs return: I64
+    def I64: (Integer value) -> I64
+
+    # @rbs value: Float
+    # @rbs return: F32
+    def F32: (Float value) -> F32
+
+    # @rbs value: Float
+    # @rbs return: F64
+    def F64: (Float value) -> F64
+  end
+end

data/sig/generated/wardite/wasi.rbs

@@ -3,14 +3,16 @@
 # rbs_inline: enabled
 module Wardite
   class WasiSnapshotPreview1
+    include ValueHelper
+
     attr_accessor fd_table: Array[IO]
 
     def initialize: () -> untyped
 
     # @rbs store: Store
-    # @rbs args: Array[Object]
+    # @rbs args: Array[I32|I64|F32|F64]
     # @rbs return: Object
-    def fd_write: (Store store, Array[Object] args) -> Object
+    def fd_write: (Store store, Array[I32 | I64 | F32 | F64] args) -> Object
 
     # @rbs return: Hash[Symbol, Proc]
     def to_module: () -> Hash[Symbol, Proc]

data/sig/generated/wardite.rbs

@@ -1,5 +1,11 @@
 # Generated from lib/wardite.rb with RBS::Inline
 
+module Wardite
+  module Evaluator
+    extend Wardite::ValueHelper
+  end
+end
+
 module Wardite
   class Section
     attr_accessor name: String
@@ -107,7 +113,9 @@ module Wardite
   end
 
   module BinaryLoader
-    extend Wardite::Leb128Helpers
+    extend Wardite::Leb128Helper
+
+    extend Wardite::ValueHelper
 
     # @rbs buf: File|StringIO
     # @rbs import_object: Hash[Symbol, Hash[Symbol, Proc]]
@@ -204,7 +212,10 @@ module Wardite
   end
 
   class Runtime
-    attr_accessor stack: Array[Object]
+    include ValueHelper
+
+    # TODO: add types of class that the stack accomodates
+    attr_accessor stack: Array[I32 | I64 | F32 | F64 | Block]
 
     attr_accessor call_stack: Array[Frame]
 
@@ -222,11 +233,6 @@ module Wardite
     # @rbs return: Object|nil
     def call: (String | Symbol name, Array[Object] args) -> (Object | nil)
 
-    # @rbs idx: Integer
-    # @rbs args: Array[Object]
-    # @rbs return: Object|nil
-    def call_index: (Integer idx, Array[Object] args) -> (Object | nil)
-
     # @rbs wasm_function: WasmFunction
     # @rbs return: void
     def push_frame: (WasmFunction wasm_function) -> void
@@ -236,8 +242,8 @@ module Wardite
     def invoke_internal: (WasmFunction wasm_function) -> (Object | nil)
 
     # @rbs external_function: ExternalFunction
-    # @rbs return: Object|nil
-    def invoke_external: (ExternalFunction external_function) -> (Object | nil)
+    # @rbs return: I32|I64|F32|F64|nil
+    def invoke_external: (ExternalFunction external_function) -> (I32 | I64 | F32 | F64 | nil)
 
     # @rbs return: void
     def execute!: () -> void
@@ -259,8 +265,8 @@ module Wardite
     def stack_unwind: (Integer sp, Integer arity) -> void
 
     # @rbs finish: Integer
-    # @rbs return: Array[Object]
-    def drained_stack: (Integer finish) -> Array[Object]
+    # @rbs return: Array[I32|I64|F32|F64|Block]
+    def drained_stack: (Integer finish) -> Array[I32 | I64 | F32 | F64 | Block]
 
     # @rbs name: Symbol
     # @rbs args: Array[Object]
@@ -283,7 +289,7 @@ module Wardite
 
     attr_accessor labels: Array[Label]
 
-    attr_accessor locals: Array[Object]
+    attr_accessor locals: Array[I32 | I64 | F32 | F64]
 
     # @rbs pc: Integer
     # @rbs sp: Integer

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wardite
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Uchio Kondo
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-10-28 00:00:00.000000000 Z
+date: 2024-11-02 00:00:00.000000000 Z
 dependencies: []
 description: A pure-ruby webassembly runtime
 email:
@@ -34,15 +34,21 @@ files:
 - examples/memory.wat
 - exe/wardite
 - lib/wardite.rb
+- lib/wardite/alu_i32.generated.rb
 - lib/wardite/const.rb
 - lib/wardite/instruction.rb
 - lib/wardite/leb128.rb
+- lib/wardite/value.rb
 - lib/wardite/version.rb
 - lib/wardite/wasi.rb
+- scripts/gen_alu.rb
+- scripts/templates/alu_module.rb.tmpl
 - sig/generated/wardite.rbs
+- sig/generated/wardite/alu_i32.generated.rbs
 - sig/generated/wardite/const.rbs
 - sig/generated/wardite/instruction.rbs
 - sig/generated/wardite/leb128.rbs
+- sig/generated/wardite/value.rbs
 - sig/generated/wardite/version.rbs
 - sig/generated/wardite/wasi.rbs
 - sig/wardite.rbs