wardite 0.4.3 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1960efc493205587db2fbb0e21504247d120831417b081dc169c0b7c10fccaf
-  data.tar.gz: cbdbf5e122fe118ccee7a615b184be2032b6000a043b3642a9b5336f6b0fbe19
+  metadata.gz: 89b6c42e1a3f16c39c214eb127c5b87966c0d2933257a1da7fdc96236c6a0f9b
+  data.tar.gz: 321d62cdddc61c8a342b966b3e4d7b6c01ffbbcb5788a6787fd3490ba96b1430
 SHA512:
-  metadata.gz: 207a1cd23ab5f25fdf9dd421ab42c70528be1987e57f41d656f47e205ee78ba321b9553364f988f6f039f87a77878e040075e690b00b97ace0bf91e35c07431f
-  data.tar.gz: 944b8112be80c9c3b78dd7cdec01ac3c72f7e4e077196a315bfaa14ffeb4dfa6cdb868570ae0bc55fb4f07da858f968807fee8bb50d5846fa763dd7b82359f98
+  metadata.gz: 4b8b67989d47775828aca0908794f6b02abdea5ed653d794fa308d437f2d1735997a91dee341cdfa51aa5829aa097ca61dd262dba8479e805d1bbfd540f90ff5
+  data.tar.gz: 26face977ed4d76232bdee62f64208a22ec824314cb3d479979705fee327a1c9ce72ee960055a0c26db591f932c598b591651170fedf31b36533c52774f05fbe

data/examples/grayscale.rb

@@ -0,0 +1,64 @@
+#
+# Usage:
+#     $ bundle exec ruby --yjit examples/grayscale.rb \
+#         --wasm-file path/to/grayscale.wasm \
+#         --source tmp/source.png \
+#         --dest tmp/result.png \
+#         --width 660 --height 495
+#
+require "wardite"
+require "base64"
+require "optparse"
+require "ostruct"
+
+$options = OpenStruct.new
+
+opt = OptionParser.new
+opt.on('--wasm-file [FILE]') {|v| $options.wasm_file = v }
+opt.on('--source [IMAGE]') {|v| $options.source = v }
+opt.on('--dest [IMAGE]') {|v| $options.dest = v }
+opt.on('--width [W]') {|v| $options.width = v.to_i }
+opt.on('--height [H]') {|v| $options.height = v.to_i }
+opt.parse!
+
+#require 'ruby-prof'
+#profile = RubyProf::Profile.new
+
+f = File.open($options.wasm_file)
+data = IO.read($options.source)
+orig = Base64.encode64(data).gsub(/(\r|\n)/, "")
+data_url = "data:image/png;base64," + orig
+instance = Wardite::BinaryLoader::load_from_buffer(f);
+instance.store.memories[0].grow(data_url.size / (64*1024) + 1)
+
+start = instance.exports.__heap_base.value.value
+instance.store.memories[0].data[start...(start+data_url.size)] = data_url
+
+offset = 0
+result = nil
+begin
+  # pub fn grayscale(width: i32, height: i32, memory_offset: i32, length: i32) -> *const u8
+  #profile.start
+  offset = instance.runtime.grayscale_blob($options.width, $options.height, start, data_url.size)
+  #result = profile.stop
+rescue => e
+  raise "failed to execute grayscale() " + e.message
+end
+
+#printer = RubyProf::GraphPrinter.new(result)
+#printer.print(STDOUT, {})
+
+len = 0
+until instance.store.memories[0].data[offset.value+len] == "\0"
+  len += 1
+end
+
+result_b64 = instance.store.memories[0].data[offset.value...(offset.value+len)]
+result = Base64.decode64(result_b64)
+
+dest = File.open($options.dest, "w")
+dest.write result
+dest.close
+
+puts "created: #{$options.dest}"
+

data/lib/wardite/alu_i32.generated.rb

@@ -311,7 +311,7 @@ module Wardite
         digits = target.memsize
         count = 0
         digits.times do |i|
-          if (target.value & (1 << i)).zero?
+          if (target.value & (1 << i)).nonzero?
             count += 1
           end
         end
@@ -347,7 +347,13 @@ module Wardite
         if !right.is_a?(I32) || !left.is_a?(I32)
           raise EvalError, "maybe empty or invalid stack"
         end
-        runtime.stack.push(I32(left.value_s / right.value_s))
+        result = left.value_s / right.value_s.to_f
+        iresult = (result >= 0 ? result.floor : result.ceil).to_i
+        if iresult >= (1 << (left.memsize - 1))
+          raise IntegerOverflow, "integer overflow"
+        end
+      
+        runtime.stack.push(I32(iresult))
 
 
       when :i32_div_u
@@ -363,7 +369,13 @@ module Wardite
         if !right.is_a?(I32) || !left.is_a?(I32)
           raise EvalError, "maybe empty or invalid stack"
         end
-        runtime.stack.push(I32(left.value_s % right.value_s))
+        result = left.value_s % right.value_s
+        if result > 0 && left.value_s < 0
+          result = result - right.value_s
+        elsif result < 0 && left.value_s > 0
+          result = result - right.value_s
+        end
+        runtime.stack.push(I32(result))
 
 
       when :i32_rem_u
@@ -403,8 +415,8 @@ module Wardite
         if !right.is_a?(I32) || !left.is_a?(I32)
           raise EvalError, "maybe empty or invalid stack"
         end
-        value = left.value << right.value
-        value %= (1 << right.memsize) 
+        value = left.value << (right.value % right.memsize)
+        value %= 1 << right.memsize
       
         runtime.stack.push(I32(value))
 
@@ -414,7 +426,7 @@ module Wardite
         if !right.is_a?(I32) || !left.is_a?(I32)
           raise EvalError, "maybe empty or invalid stack"
         end
-        value = left.value_s >> right.value
+        value = left.value_s >> (right.value % right.memsize)
         runtime.stack.push(I32(value))
 
 
@@ -423,7 +435,7 @@ module Wardite
         if !right.is_a?(I32) || !left.is_a?(I32)
           raise EvalError, "maybe empty or invalid stack"
         end
-        value = left.value >> right.value
+        value = left.value >> (right.value % right.memsize)
         runtime.stack.push(I32(value))
 
 
@@ -432,9 +444,10 @@ module Wardite
         if !right.is_a?(I32) || !left.is_a?(I32)
           raise EvalError, "maybe empty or invalid stack"
         end
-        rotated = left.value << right.value
-        rest = left.value & (I32::I32_MAX << (right.memsize - right.value))
-        value = rotated | (rest >> (right.memsize - right.value))
+        k = (right.value % right.memsize)
+        rotated = left.value << k
+        rest = left.value & (I32::I32_MAX << (right.memsize - k))
+        value = rotated | (rest >> (right.memsize - k))
         runtime.stack.push(I32(value))
 
 
@@ -443,9 +456,10 @@ module Wardite
         if !right.is_a?(I32) || !left.is_a?(I32)
           raise EvalError, "maybe empty or invalid stack"
         end
-        rotated = left.value >> right.value
-        rest = left.value & (I32::I32_MAX >> (right.memsize - right.value))
-        value = rotated | (rest << (right.memsize - right.value))
+        k = (right.value % right.memsize)
+        rotated = left.value >> k
+        rest = left.value & (I32::I32_MAX >> (right.memsize - k))
+        value = rotated | (rest << (right.memsize - k))
         runtime.stack.push(I32(value))
 
 

data/lib/wardite/alu_i64.generated.rb

@@ -368,7 +368,7 @@ module Wardite
         digits = target.memsize
         count = 0
         digits.times do |i|
-          if (target.value & (1 << i)).zero?
+          if (target.value & (1 << i)).nonzero?
             count += 1
           end
         end
@@ -404,7 +404,13 @@ module Wardite
         if !right.is_a?(I64) || !left.is_a?(I64)
           raise EvalError, "maybe empty or invalid stack"
         end
-        runtime.stack.push(I64(left.value_s / right.value_s))
+        result = left.value_s / right.value_s.to_f
+        iresult = (result >= 0 ? result.floor : result.ceil).to_i
+        if iresult >= (1 << (left.memsize - 1))
+          raise IntegerOverflow, "integer overflow"
+        end
+      
+        runtime.stack.push(I64(iresult))
 
 
       when :i64_div_u
@@ -420,7 +426,13 @@ module Wardite
         if !right.is_a?(I64) || !left.is_a?(I64)
           raise EvalError, "maybe empty or invalid stack"
         end
-        runtime.stack.push(I64(left.value_s % right.value_s))
+        result = left.value_s % right.value_s
+        if result > 0 && left.value_s < 0
+          result = result - right.value_s
+        elsif result < 0 && left.value_s > 0
+          result = result - right.value_s
+        end
+        runtime.stack.push(I64(result))
 
 
       when :i64_rem_u
@@ -460,8 +472,8 @@ module Wardite
         if !right.is_a?(I64) || !left.is_a?(I64)
           raise EvalError, "maybe empty or invalid stack"
         end
-        value = left.value << right.value
-        value %= (1 << right.memsize) 
+        value = left.value << (right.value % right.memsize)
+        value %= 1 << right.memsize
       
         runtime.stack.push(I64(value))
 
@@ -471,7 +483,7 @@ module Wardite
         if !right.is_a?(I64) || !left.is_a?(I64)
           raise EvalError, "maybe empty or invalid stack"
         end
-        value = left.value_s >> right.value
+        value = left.value_s >> (right.value % right.memsize)
         runtime.stack.push(I64(value))
 
 
@@ -480,7 +492,7 @@ module Wardite
         if !right.is_a?(I64) || !left.is_a?(I64)
           raise EvalError, "maybe empty or invalid stack"
         end
-        value = left.value >> right.value
+        value = left.value >> (right.value % right.memsize)
         runtime.stack.push(I64(value))
 
 
@@ -489,9 +501,10 @@ module Wardite
         if !right.is_a?(I64) || !left.is_a?(I64)
           raise EvalError, "maybe empty or invalid stack"
         end
-        rotated = left.value << right.value
-        rest = left.value & (I64::I64_MAX << (right.memsize - right.value))
-        value = rotated | (rest >> (right.memsize - right.value))
+        k = (right.value % right.memsize)
+        rotated = left.value << k
+        rest = left.value & (I64::I64_MAX << (right.memsize - k))
+        value = rotated | (rest >> (right.memsize - k))
         runtime.stack.push(I64(value))
 
 
@@ -500,9 +513,10 @@ module Wardite
         if !right.is_a?(I64) || !left.is_a?(I64)
           raise EvalError, "maybe empty or invalid stack"
         end
-        rotated = left.value >> right.value
-        rest = left.value & (I64::I64_MAX >> (right.memsize - right.value))
-        value = rotated | (rest << (right.memsize - right.value))
+        k = (right.value % right.memsize)
+        rotated = left.value >> k
+        rest = left.value & (I64::I64_MAX >> (right.memsize - k))
+        value = rotated | (rest << (right.memsize - k))
         runtime.stack.push(I64(value))
 
 

data/lib/wardite/errors.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+module Wardite
+  # basic error class.
+  class WebAssemblyError < StandardError    
+  end
+
+  class IntegerOverflow < WebAssemblyError; end
+end

data/lib/wardite/instruction.rb

@@ -78,6 +78,8 @@ module Wardite
     # TODO: add types of potential operands
     attr_accessor :operand #: Array[operandItem]
 
+    attr_accessor :meta #: Hash[Symbol, Integer]
+
     # @rbs namespace: Symbol
     # @rbs code: Symbol
     # @rbs operand: Array[operandItem]
@@ -85,6 +87,7 @@ module Wardite
       @namespace = namespace      
       @code = code
       @operand = operand
+      @meta = {}
     end
 
     # @rbs chr: String

data/lib/wardite/load.rb

@@ -1,4 +1,6 @@
 # rbs_inline: enabled
+require "wardite/revisitor"
+
 module Wardite
   class Section
     attr_accessor :name #: String
@@ -593,10 +595,13 @@ module Wardite
           locals_type << Op.i2type(value_type || -1)
         end
         body = code_body(cbuf)
+        revisitor = Revisitor.new(body)
+        revisitor.revisit!
+        
         dest.func_codes << CodeSection::CodeBody.new do |b|
           b.locals_count = locals_count
           b.locals_type = locals_type
-          b.body = body
+          b.body = revisitor.ops
         end
       end
       dest

data/lib/wardite/revisitor.rb

@@ -0,0 +1,92 @@
+# rbs_inline: enabled
+module Wardite
+  class Revisitor
+    attr_accessor :ops #: Array[Op]
+    
+    # @rbs ops: Array[Op]
+    # @rbs return: void
+    def initialize(ops)
+      @ops = ops
+    end
+
+    # @rbs return: void
+    def revisit!
+      @ops.each_with_index do |op, idx|
+        case op.code
+        when :block
+          next_pc = fetch_ops_while_end(idx)
+          op.meta[:end_pos] = next_pc
+  
+        when :loop
+          next_pc = fetch_ops_while_end(idx)
+          op.meta[:end_pos] = next_pc
+  
+        when :if
+          next_pc = fetch_ops_while_end(idx)
+          else_pc = fetch_ops_while_else_or_end(idx)
+          op.meta[:end_pos] = next_pc
+          op.meta[:else_pos] = else_pc
+        end
+      end
+    end
+
+    # @rbs pc_start: Integer
+    # @rbs return: Integer
+    # @rbs return: void
+    def fetch_ops_while_else_or_end(pc_start)
+      cursor = pc_start
+      depth = 0
+      loop {
+        cursor += 1
+        inst = @ops[cursor]
+        case inst&.code
+        when nil
+          raise EvalError, "end op not found"
+        when :if
+          depth += 1
+        when :else
+          if depth == 0
+            return cursor
+          end
+          # do not touch depth
+        when :end
+          if depth == 0
+            return cursor
+          else
+            depth -= 1
+          end
+        else
+          # nop
+        end
+      }
+      raise "not found corresponding end"
+    end
+
+    # @rbs pc_start: Integer
+    # @rbs return: Integer
+    # @rbs return: void
+    def fetch_ops_while_end(pc_start)
+      cursor = pc_start
+      depth = 0
+      loop {
+        cursor += 1
+        inst = @ops[cursor]
+        case inst&.code
+        when nil
+          raise EvalError, "end op not found"
+        when :if, :block, :loop
+          depth += 1
+        when :end
+          if depth == 0
+            return cursor
+          else
+            depth -= 1
+          end
+        else
+          # nop
+        end
+      }
+      raise "not found corresponding end"
+    end
+  end
+end

data/lib/wardite/version.rb

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

data/lib/wardite.rb

@@ -7,6 +7,7 @@ require_relative "wardite/const"
 require_relative "wardite/instruction"
 require_relative "wardite/value"
 require_relative "wardite/load"
+require_relative "wardite/errors"
 
 module Wardite
   module Evaluator
@@ -472,7 +473,7 @@ module Wardite
       when :block
         block = insn.operand[0]
         raise EvalError, "block op without block" if !block.is_a?(Block)
-        next_pc = fetch_ops_while_end(frame.body, frame.pc)
+        next_pc = insn.meta[:end_pos]
         label = Label.new(:block, next_pc, stack.size, block.result_size)
         frame.labels.push(label)
 
@@ -480,19 +481,19 @@ module Wardite
         block = insn.operand[0]
         raise EvalError, "loop op without block" if !block.is_a?(Block)
         start = frame.pc
-        end_pc = fetch_ops_while_end(frame.body, frame.pc)
-        label = Label.new(:loop, end_pc, stack.size, block.result_size, start)
+        next_pc = insn.meta[:end_pos]
+        label = Label.new(:loop, next_pc, stack.size, block.result_size, start)
         frame.labels.push(label)
 
       when :if
         block = insn.operand[0]
         raise EvalError, "if op without block" if !block.is_a?(Block)
-        cond = stack.pop 
+        cond = stack.pop
         raise EvalError, "cond not found" if !cond.is_a?(I32)
-        next_pc = fetch_ops_while_end(frame.body, frame.pc)
+        next_pc = insn.meta[:end_pos]
 
         if cond.value.zero?
-          frame.pc = fetch_ops_while_else_or_end(frame.body, frame.pc)
+          frame.pc = insn.meta[:else_pos]
         end
 
         if frame.pc == next_pc
@@ -739,38 +740,6 @@ module Wardite
       raise e
     end
 
-    # @rbs ops: Array[Op]
-    # @rbs pc_start: Integer
-    # @rbs return: Integer
-    def fetch_ops_while_else_or_end(ops, pc_start)
-      cursor = pc_start
-      depth = 0
-      loop {
-        cursor += 1
-        inst = ops[cursor]
-        case inst&.code
-        when nil
-          raise EvalError, "end op not found"
-        when :if
-          depth += 1
-        when :else
-          if depth == 0
-            return cursor
-          end
-          # do not touch depth
-        when :end
-          if depth == 0
-            return cursor
-          else
-            depth -= 1
-          end
-        else
-          # nop
-        end
-      }
-      raise "[BUG] unreachable"
-    end
-
     # @rbs labels: Array[Label]
     # @rbs stack: Array[wasmValue]
     # @rbs level: Integer
@@ -796,33 +765,6 @@ module Wardite
       pc
     end
 
-    # @rbs ops: Array[Op]
-    # @rbs pc_start: Integer
-    # @rbs return: Integer
-    def fetch_ops_while_end(ops, pc_start)
-      cursor = pc_start
-      depth = 0
-      loop {
-        cursor += 1
-        inst = ops[cursor]
-        case inst&.code
-        when nil
-          raise EvalError, "end op not found"
-        when :if, :block, :loop
-          depth += 1
-        when :end
-          if depth == 0
-            return cursor
-          else
-            depth -= 1
-          end
-        else
-          # nop
-        end
-      }
-      raise "[BUG] unreachable"
-    end
-
     # unwind the stack and put return value if exists
     # @rbs sp: Integer
     # @rbs arity: Integer
@@ -1119,6 +1061,7 @@ module Wardite
       end
       
       @data += String.new("\0" * (delta * 64 * 1024))
+      self.current = newsize
       prev
     end
 

data/scripts/gen_alu.rb

@@ -480,7 +480,7 @@ module GenAlu
         digits = target.memsize
         count = 0
         digits.times do |i|
-          if (target.value & (1 << i)).zero?
+          if (target.value & (1 << i)).nonzero?
             count += 1
           end
         end
@@ -520,7 +520,13 @@ module GenAlu
         if !right.is_a?(${CLASS}) || !left.is_a?(${CLASS})
           raise EvalError, "maybe empty or invalid stack"
         end
-        runtime.stack.push(${CLASS}(left.value_s / right.value_s))
+        result = left.value_s / right.value_s.to_f
+        iresult = (result >= 0 ? result.floor : result.ceil).to_i
+        if iresult >= (1 << (left.memsize - 1))
+          raise IntegerOverflow, "integer overflow"
+        end
+
+        runtime.stack.push(${CLASS}(iresult))
     RUBY
 
     div_u: <<~RUBY,
@@ -547,7 +553,13 @@ module GenAlu
         if !right.is_a?(${CLASS}) || !left.is_a?(${CLASS})
           raise EvalError, "maybe empty or invalid stack"
         end
-        runtime.stack.push(${CLASS}(left.value_s % right.value_s))
+        result = left.value_s % right.value_s
+        if result > 0 && left.value_s < 0
+          result = result - right.value_s
+        elsif result < 0 && left.value_s > 0
+          result = result - right.value_s
+        end
+        runtime.stack.push(${CLASS}(result))
     RUBY
 
     rem_u: <<~RUBY,
@@ -592,8 +604,8 @@ module GenAlu
         if !right.is_a?(${CLASS}) || !left.is_a?(${CLASS})
           raise EvalError, "maybe empty or invalid stack"
         end
-        value = left.value << right.value
-        value %= (1 << right.memsize) 
+        value = left.value << (right.value % right.memsize)
+        value %= 1 << right.memsize
 
         runtime.stack.push(${CLASS}(value))
     RUBY
@@ -604,7 +616,7 @@ module GenAlu
         if !right.is_a?(${CLASS}) || !left.is_a?(${CLASS})
           raise EvalError, "maybe empty or invalid stack"
         end
-        value = left.value_s >> right.value
+        value = left.value_s >> (right.value % right.memsize)
         runtime.stack.push(${CLASS}(value))
     RUBY
 
@@ -614,7 +626,7 @@ module GenAlu
         if !right.is_a?(${CLASS}) || !left.is_a?(${CLASS})
           raise EvalError, "maybe empty or invalid stack"
         end
-        value = left.value >> right.value
+        value = left.value >> (right.value % right.memsize)
         runtime.stack.push(${CLASS}(value))
     RUBY
 
@@ -624,9 +636,10 @@ module GenAlu
         if !right.is_a?(${CLASS}) || !left.is_a?(${CLASS})
           raise EvalError, "maybe empty or invalid stack"
         end
-        rotated = left.value << right.value
-        rest = left.value & (${CLASS}::${CLASS}_MAX << (right.memsize - right.value))
-        value = rotated | (rest >> (right.memsize - right.value))
+        k = (right.value % right.memsize)
+        rotated = left.value << k
+        rest = left.value & (${CLASS}::${CLASS}_MAX << (right.memsize - k))
+        value = rotated | (rest >> (right.memsize - k))
         runtime.stack.push(${CLASS}(value))
     RUBY
 
@@ -636,9 +649,10 @@ module GenAlu
         if !right.is_a?(${CLASS}) || !left.is_a?(${CLASS})
           raise EvalError, "maybe empty or invalid stack"
         end
-        rotated = left.value >> right.value
-        rest = left.value & (${CLASS}::${CLASS}_MAX >> (right.memsize - right.value))
-        value = rotated | (rest << (right.memsize - right.value))
+        k = (right.value % right.memsize)
+        rotated = left.value >> k
+        rest = left.value & (${CLASS}::${CLASS}_MAX >> (right.memsize - k))
+        value = rotated | (rest << (right.memsize - k))
         runtime.stack.push(${CLASS}(value))
     RUBY
 

data/sig/generated/wardite/errors.rbs

@@ -0,0 +1,12 @@
+# Generated from lib/wardite/errors.rb with RBS::Inline
+
+# frozen_string_literal: true
+# rbs_inline: enabled
+module Wardite
+  # basic error class.
+  class WebAssemblyError < StandardError
+  end
+
+  class IntegerOverflow < WebAssemblyError
+  end
+end

data/sig/generated/wardite/instruction.rbs

@@ -22,6 +22,8 @@ module Wardite
     # TODO: add types of potential operands
     attr_accessor operand: Array[operandItem]
 
+    attr_accessor meta: Hash[Symbol, Integer]
+
     # @rbs namespace: Symbol
     # @rbs code: Symbol
     # @rbs operand: Array[operandItem]

data/sig/generated/wardite/load.rbs

@@ -1,6 +1,5 @@
 # Generated from lib/wardite/load.rb with RBS::Inline
 
-# rbs_inline: enabled
 module Wardite
   class Section
     attr_accessor name: String

data/sig/generated/wardite/revisitor.rbs

@@ -0,0 +1,25 @@
+# Generated from lib/wardite/revisitor.rb with RBS::Inline
+
+# rbs_inline: enabled
+module Wardite
+  class Revisitor
+    attr_accessor ops: Array[Op]
+
+    # @rbs ops: Array[Op]
+    # @rbs return: void
+    def initialize: (Array[Op] ops) -> void
+
+    # @rbs return: void
+    def revisit!: () -> void
+
+    # @rbs pc_start: Integer
+    # @rbs return: Integer
+    # @rbs return: void
+    def fetch_ops_while_else_or_end: (Integer pc_start) -> Integer
+
+    # @rbs pc_start: Integer
+    # @rbs return: Integer
+    # @rbs return: void
+    def fetch_ops_while_end: (Integer pc_start) -> Integer
+  end
+end

data/sig/generated/wardite.rbs

@@ -115,22 +115,12 @@ module Wardite
     # @rbs return: void
     def eval_insn: (Frame frame, Op insn) -> void
 
-    # @rbs ops: Array[Op]
-    # @rbs pc_start: Integer
-    # @rbs return: Integer
-    def fetch_ops_while_else_or_end: (Array[Op] ops, Integer pc_start) -> Integer
-
     # @rbs labels: Array[Label]
     # @rbs stack: Array[wasmValue]
     # @rbs level: Integer
     # @rbs return: Integer
     def do_branch: (Array[Label] labels, Array[wasmValue] stack, Integer level) -> Integer
 
-    # @rbs ops: Array[Op]
-    # @rbs pc_start: Integer
-    # @rbs return: Integer
-    def fetch_ops_while_end: (Array[Op] ops, Integer pc_start) -> Integer
-
     # unwind the stack and put return value if exists
     # @rbs sp: Integer
     # @rbs arity: Integer

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wardite
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.5.1
 platform: ruby
 authors:
 - Uchio Kondo
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-17 00:00:00.000000000 Z
+date: 2024-11-24 00:00:00.000000000 Z
 dependencies: []
 description: A pure-ruby webassembly runtime
 email:
@@ -31,6 +31,7 @@ files:
 - examples/fib.wat
 - examples/fib2.wat
 - examples/global.wat
+- examples/grayscale.rb
 - examples/helloworld.wat
 - examples/i32_const.wat
 - examples/i32_store.wat
@@ -49,9 +50,11 @@ files:
 - lib/wardite/alu_i64.generated.rb
 - lib/wardite/const.rb
 - lib/wardite/convert.generated.rb
+- lib/wardite/errors.rb
 - lib/wardite/instruction.rb
 - lib/wardite/leb128.rb
 - lib/wardite/load.rb
+- lib/wardite/revisitor.rb
 - lib/wardite/value.rb
 - lib/wardite/version.rb
 - lib/wardite/wasi.rb
@@ -66,9 +69,11 @@ files:
 - sig/generated/wardite/alu_i64.generated.rbs
 - sig/generated/wardite/const.rbs
 - sig/generated/wardite/convert.generated.rbs
+- sig/generated/wardite/errors.rbs
 - sig/generated/wardite/instruction.rbs
 - sig/generated/wardite/leb128.rbs
 - sig/generated/wardite/load.rbs
+- sig/generated/wardite/revisitor.rbs
 - sig/generated/wardite/value.rbs
 - sig/generated/wardite/version.rbs
 - sig/generated/wardite/wasi.rbs