wardite 0.8.2 → 0.9.0

data/lib/wardite/load.rb

@@ -1,5 +1,4 @@
 # rbs_inline: enabled
-require "wardite/revisitor"
 
 module Wardite
   class Section
@@ -128,7 +127,7 @@ module Wardite
 
       attr_accessor :locals_type #: Array[Symbol]
 
-      attr_accessor :body #: Array[Op]
+      attr_accessor :body #: Array[[Symbol, Symbol, Array[operandItem], Integer?, Integer?]]
 
       # @rbs &blk: (CodeBody) -> void
       # @rbs return: void
@@ -603,25 +602,25 @@ 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 = revisitor.ops
+          b.body = body
         end
       end
       dest
     end
 
     # @rbs buf: StringIO
-    # @rbs return: Array[::Wardite::Op]
+    # @rbs return: Array[[Symbol, Symbol, Array[operandItem], Integer?, Integer?]]
     def self.code_body(buf)
-      dest = [] #: Array[Op]
+      dest = [] #: Array[[Symbol, Symbol, Array[operandItem], Integer?, Integer?]]
+      # HINT: [symname, index of op, index of else, index of end]
+      branching_stack = [] #: Array[[Symbol, Integer, Integer, Integer]]
+      fixed_stack = [] #: Array[[Symbol, Integer, Integer, Integer]]
       while c = buf.read(1)
-        namespace, code = resolve_code(c, buf)
-        operand_types = Op.operand_of(code)
+        namespace, code, operand_types = resolve_code(c, buf)
         operand = [] #: Array[operandItem]
         operand_types.each do |typ|
           case typ
@@ -676,9 +675,42 @@ module Wardite
           end         
         end
 
-        dest << Op.new(namespace, code, operand)
+        # HINT: [namespace, code, operand, else_pos, end_pos]
+        dest << [namespace, code, operand, nil, nil]
+        if code == :block || code == :loop || code == :if
+          branching_stack << [code, dest.size - 1, -1, -1]
+        elsif code == :else
+          if branching_stack.empty?
+            raise "broken sequence: unmatched else"
+          else
+            last = branching_stack.pop || raise("[BUG] empty pop")
+            if last[0] != :if
+              raise "broken sequence: else without if"
+            end
+            branching_stack << [last[0], last[1], dest.size - 1, -1]
+          end
+        elsif code == :end
+          unless branching_stack.empty?
+            last = branching_stack.pop || raise("[BUG] empty pop")
+            fixed_stack << [last[0], last[1], last[2], dest.size - 1]
+          end
+        end
       end
 
+      fixed_stack.each do |(sym, begin_idx, else_idx, end_idx)|
+        if end_idx == -1
+          raise "broken sequence: branching without end"
+        end
+        case sym
+        when :block, :loop
+          dest[begin_idx][-1] = end_idx
+        when :if
+          dest[begin_idx][-2] = else_idx == -1 ? end_idx : else_idx
+          dest[begin_idx][-1] = end_idx
+        else
+          raise "[BUG] unknown sym #{sym.inspect}"
+        end
+      end
       dest
     rescue => e
       require "pp"
@@ -690,14 +722,18 @@ module Wardite
 
     # @rbs c: String
     # @rbs buf: StringIO
-    # @rbs return: [Symbol, Symbol]
+    # @rbs return: [Symbol, Symbol, Array[Symbol]]
     def self.resolve_code(c, buf)
-      namespace, code = Op.to_sym(c)
-      if namespace == :fc
+      ord = c.ord
+      code = Op::SYMS[ord]
+      if code == :fc
         lower = fetch_uleb128(buf)
-        return Op.resolve_fc_sym(lower) #: [Symbol, Symbol]
+        sym = Op::FC_SYMS[lower]
+        namespace = Op::FC_OPERANDS[lower] || :default
+        return [namespace, sym, Op.operand_of(sym)]
       end
-      return [namespace, code] #: [Symbol, Symbol]
+      namespace = Op::NAMESPACES[ord] || raise("unsupported code: #{ord}")
+      return [namespace, code, Op::OPERANDS[ord]]
     end
 
     # @rbs return: DataSection
@@ -774,7 +810,7 @@ module Wardite
       code
     end
 
-    # @rbs ops: Array[Op]
+    # @rbs ops: Array[[Symbol, Symbol, Array[operandItem], Integer?, Integer?]]
     # @rbs return: Integer
     def self.decode_expr(ops)
       # sees first opcode
@@ -782,19 +818,19 @@ module Wardite
       if !op
         raise LoadError, "empty opcodes"
       end
-      case op.code
+      case op[1]
       when :i32_const
-        arg = op.operand[0]
+        arg = op[2][0]
         if !arg.is_a?(Integer)
           raise "Invalid definition of operand"
         end
         return arg
       else
-        raise "Unimplemented offset op: #{op.code.inspect}"
+        raise "Unimplemented offset op: #{op.inspect}"
       end
     end
 
-    # @rbs ops: Array[Op]
+    # @rbs ops: Array[[Symbol, Symbol, Array[operandItem], Integer?, Integer?]]
     # @rbs return: wasmValue
     def self.decode_global_expr(ops)
       # sees first opcode
@@ -802,33 +838,33 @@ module Wardite
       if !op
         raise LoadError, "empty opcodes"
       end
-      case op.code
+      case op[1]
       when :i32_const
-        arg = op.operand[0]
+        arg = op[2][0]
         if !arg.is_a?(Integer)
           raise "Invalid definition of operand"
         end
         return I32(arg)
       when :i64_const
-        arg = op.operand[0]
+        arg = op[2][0]
         if !arg.is_a?(Integer)
           raise "Invalid definition of operand"
         end
         return I64(arg)
       when :f32_const
-        arg = op.operand[0]
+        arg = op[2][0]
         if !arg.is_a?(Float)
           raise "Invalid definition of operand"
         end
         return F32(arg)
       when :f64_const
-        arg = op.operand[0]
+        arg = op[2][0]
         if !arg.is_a?(Float)
           raise "Invalid definition of operand"
         end
         return F64(arg)
       else
-        raise "Unimplemented offset op: #{op.code.inspect}"
+        raise "Unimplemented offset op: #{op.inspect}"
       end
     end
 

data/lib/wardite/revisitor.rb

@@ -15,17 +15,25 @@ module Wardite
         case op.code
         when :block
           next_pc = fetch_ops_while_end(idx)
-          op.meta[:end_pos] = next_pc
+          if op.meta[:end_pos] != next_pc
+            raise "mismatched end_pos for block at #{op}: #{op.meta[:end_pos]} vs #{next_pc}"
+          end
   
         when :loop
           next_pc = fetch_ops_while_end(idx)
-          op.meta[:end_pos] = next_pc
+          if op.meta[:end_pos] != next_pc
+            raise "mismatched end_pos for loop at #{op}: #{op.meta[:end_pos]} vs #{next_pc}"
+          end
   
         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
+          if op.meta[:end_pos] != next_pc
+            raise "mismatched end_pos for if at #{op}: #{op.meta[:end_pos]} vs #{next_pc}"
+          end
+          if op.meta[:else_pos] != else_pc
+            raise "mismatched else_pos for if at #{op}: #{op.meta[:else_pos]} vs #{else_pc}"
+          end
         end
       end
     end

data/lib/wardite/version.rb

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

data/lib/wardite.rb

@@ -425,7 +425,7 @@ module Wardite
           break
         end
         cur_frame.pc += 1
-        insn = cur_frame.body[cur_frame.pc] #: Op
+        insn = cur_frame.body[cur_frame.pc]
         if !insn
           break
         end
@@ -434,37 +434,38 @@ module Wardite
     end
 
     # @rbs frame: Frame
-    # @rbs insn: Op
+    # @rbs insn: [Symbol, Symbol, Array[operandItem], Integer?, Integer?]
     # @rbs return: void
     def eval_insn(frame, insn)
-      case insn.namespace
+      namespace, code, operand, else_pos, end_pos = *insn
+      case namespace
       when :convert
-        return Evaluator.convert_eval_insn(self, frame, insn)
+        return Evaluator.convert_eval_insn(self, frame, code, operand)
       when :i32
-        return Evaluator.i32_eval_insn(self, frame, insn)
+        return Evaluator.i32_eval_insn(self, frame, code, operand)
       when :i64
-        return Evaluator.i64_eval_insn(self, frame, insn)
+        return Evaluator.i64_eval_insn(self, frame, code, operand)
       when :f32
-        return Evaluator.f32_eval_insn(self, frame, insn)
+        return Evaluator.f32_eval_insn(self, frame, code, operand)
       when :f64
-        return Evaluator.f64_eval_insn(self, frame, insn)
+        return Evaluator.f64_eval_insn(self, frame, code, operand)
       end
 
       # unmached namespace...
-      case insn.code
+      case code
       when :unreachable
         raise Unreachable, "unreachable op"
       when :nop
         return
 
       when :br
-        level = insn.operand[0]
+        level = operand[0]
         raise EvalError, "br op without level" if !level.is_a?(Integer)
         pc = do_branch(frame.labels, stack, level)
         frame.pc = pc
 
       when :br_if
-        level = insn.operand[0]
+        level = operand[0]
         raise EvalError, "br op without level" if !level.is_a?(Integer)
         cond = stack.pop 
         raise EvalError, "cond not found" if !cond.is_a?(I32)
@@ -475,9 +476,9 @@ module Wardite
         frame.pc = pc
 
       when :br_table
-        level_vec = insn.operand[0]
+        level_vec = operand[0]
         raise EvalError, "no level vector" if !level_vec.is_a?(Array)
-        default = insn.operand[1]
+        default = operand[1]
         raise EvalError, "no default specified" if !default.is_a?(Integer)
         idx = stack.pop 
         raise EvalError, "idx not found" if !idx.is_a?(I32)
@@ -490,29 +491,29 @@ module Wardite
         frame.pc = pc
 
       when :block
-        block = insn.operand[0]
+        block = operand[0]
         raise EvalError, "block op without block" if !block.is_a?(Block)
-        next_pc = insn.meta[:end_pos]
+        next_pc = end_pos || -1
         label = Label.new(:block, next_pc, stack.size, block.result_size)
         frame.labels.push(label)
 
       when :loop
-        block = insn.operand[0]
+        block = operand[0]
         raise EvalError, "loop op without block" if !block.is_a?(Block)
         start = frame.pc
-        next_pc = insn.meta[:end_pos]
+        next_pc = end_pos || -1
         label = Label.new(:loop, next_pc, stack.size, block.result_size, start)
         frame.labels.push(label)
 
       when :if
-        block = insn.operand[0]
+        block = 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?(I32)
-        next_pc = insn.meta[:end_pos]
+        next_pc = end_pos || -1
 
         if cond.value.zero?
-          frame.pc = insn.meta[:else_pos]
+          frame.pc = else_pos || -1
         end
 
         if frame.pc == next_pc
@@ -532,7 +533,7 @@ module Wardite
         end
 
       when :call
-        idx = insn.operand[0]
+        idx = operand[0]
         raise EvalError, "[BUG] local operand not found" if !idx.is_a?(Integer)
         fn = self.instance.store.funcs[idx]
         case fn
@@ -548,9 +549,9 @@ module Wardite
       when :call_indirect
         table = self.instance.store.tables[0]
         raise EvalError, "table required but not found" if !table
-        type_idx = insn.operand[0]
+        type_idx = operand[0]
         raise EvalError, "[BUG] index operand invalid" if !type_idx.is_a?(Integer)
-        nullbyte = insn.operand[1]
+        nullbyte = operand[1]
         raise EvalError, "[BUG] invalid bytearray of call_indirect" if nullbyte != 0x0
         table_idx = stack.pop
         raise EvalError, "[BUG] index stack invalid" if !table_idx.is_a?(I32)
@@ -618,7 +619,7 @@ module Wardite
         stack.push(cond.value != 0 ? left : right)
 
       when :local_get
-        idx = insn.operand[0]
+        idx = operand[0]
         if !idx.is_a?(Integer)
           raise EvalError, "[BUG] invalid type of operand"
         end
@@ -630,7 +631,7 @@ module Wardite
         stack.push(local)
 
       when :local_set
-        idx = insn.operand[0]
+        idx = operand[0]
         if !idx.is_a?(Integer)
           raise EvalError, "[BUG] invalid type of operand"
         end
@@ -641,7 +642,7 @@ module Wardite
         frame.locals[idx] = value
 
       when :local_tee
-        idx = insn.operand[0]
+        idx = operand[0]
         if !idx.is_a?(Integer)
           raise EvalError, "[BUG] invalid type of operand"
         end
@@ -653,7 +654,7 @@ module Wardite
         stack.push value
 
       when :global_get
-        idx = insn.operand[0]
+        idx = operand[0]
         if !idx.is_a?(Integer)
           raise EvalError, "[BUG] invalid type of operand"
         end
@@ -664,7 +665,7 @@ module Wardite
         stack.push(global.value)
 
       when :global_set
-        idx = insn.operand[0]
+        idx = operand[0]
         if !idx.is_a?(Integer)
           raise EvalError, "[BUG] invalid type of operand"
         end
@@ -695,11 +696,11 @@ module Wardite
         stack.push(I32(memory.grow(delta.value)))
 
       when :memory_init
-        idx = insn.operand[0]
+        idx = operand[0]
         if !idx.is_a?(Integer)
           raise EvalError, "[BUG] invalid type of operand"
         end
-        if insn.operand[1] != 0x0
+        if operand[1] != 0x0
           $stderr.puts "warning: :memory_init is not ending with 0x00"
         end
         data_sec = instance.data_section
@@ -721,7 +722,7 @@ module Wardite
         memory.data[dest_offset.value...(dest_offset.value+length.value)] = source
 
       when :memory_copy
-        if insn.operand[0] != 0x0 || insn.operand[1] != 0x0
+        if operand[0] != 0x0 || operand[1] != 0x0
           $stderr.puts "warning: :memory_copy is not ending with 0x00"
         end
         length, src_offset, dest_offset = stack.pop, stack.pop, stack.pop
@@ -734,7 +735,7 @@ module Wardite
         memory.data[dest_offset.value...(dest_offset.value+length.value)] = source
 
       when :memory_fill
-        if insn.operand[0] != 0x0
+        if operand[0] != 0x0
           $stderr.puts "warning: :memory_fill is not ending with 0x00"
         end
         length, byte, dest_offset = stack.pop, stack.pop, stack.pop
@@ -857,7 +858,7 @@ module Wardite
     attr_accessor :pc #: Integer
     attr_accessor :sp #: Integer
 
-    attr_accessor :body #: Array[Op]
+    attr_accessor :body #: Array[[Symbol, Symbol, Array[Wardite::operandItem], Integer?, Integer?]]
 
     attr_accessor :arity #: Integer
 
@@ -869,7 +870,7 @@ module Wardite
 
     # @rbs pc: Integer
     # @rbs sp: Integer
-    # @rbs body: Array[Op]
+    # @rbs body: Array[[Symbol, Symbol, Array[Wardite::operandItem], Integer?, Integer?]]
     # @rbs arity: Integer
     # @rbs locals: Array[wasmValue]
     # @rbs returb: void
@@ -1263,7 +1264,7 @@ module Wardite
       @default_locals = construct_default_locals
     end
 
-    # @rbs return: Array[Op]
+    # @rbs return: Array[[Symbol, Symbol, Array[operandItem], Integer?, Integer?]]
     def body
       code_body.body
     end
@@ -1271,7 +1272,7 @@ module Wardite
     # @rbs return: Array[Symbol]
     def locals_type
       code_body.locals_type
-    end    
+    end
 
     # @rbs return: Array[Integer]
     def locals_count

data/scripts/gen_alu.rb

@@ -49,8 +49,8 @@ module GenAlu
   DEFS = { #: Hash[Symbol, String]
     load: <<~RUBY,
       when :${PREFIX}_load
-        _align = insn.operand[0] # TODO: alignment support?
-        offset = insn.operand[1]
+        _align = operand[0] # TODO: alignment support?
+        offset = operand[1]
         raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
 
         addr = runtime.stack.pop
@@ -70,8 +70,8 @@ module GenAlu
 
     load8_s: <<~RUBY,
       when :${PREFIX}_load8_s
-        _align = insn.operand[0] # TODO: alignment support?
-        offset = insn.operand[1]
+        _align = operand[0] # TODO: alignment support?
+        offset = operand[1]
         raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
 
         addr = runtime.stack.pop
@@ -91,8 +91,8 @@ module GenAlu
 
     load8_u: <<~RUBY,
       when :${PREFIX}_load8_u
-        _align = insn.operand[0] # TODO: alignment support?
-        offset = insn.operand[1]
+        _align = operand[0] # TODO: alignment support?
+        offset = operand[1]
         raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
 
         addr = runtime.stack.pop
@@ -112,8 +112,8 @@ module GenAlu
 
     load16_s: <<~RUBY,
       when :${PREFIX}_load16_s
-        _align = insn.operand[0] # TODO: alignment support?
-        offset = insn.operand[1]
+        _align = operand[0] # TODO: alignment support?
+        offset = operand[1]
         raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
 
         addr = runtime.stack.pop
@@ -133,8 +133,8 @@ module GenAlu
 
     load16_u: <<~RUBY,
       when :${PREFIX}_load16_u
-        _align = insn.operand[0] # TODO: alignment support?
-        offset = insn.operand[1]
+        _align = operand[0] # TODO: alignment support?
+        offset = operand[1]
         raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
 
         addr = runtime.stack.pop
@@ -154,8 +154,8 @@ module GenAlu
 
     load32_s: <<~RUBY,
       when :${PREFIX}_load32_s
-        _align = insn.operand[0] # TODO: alignment support?
-        offset = insn.operand[1]
+        _align = operand[0] # TODO: alignment support?
+        offset = operand[1]
         raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
 
         addr = runtime.stack.pop
@@ -175,8 +175,8 @@ module GenAlu
 
     load32_u: <<~RUBY,
       when :${PREFIX}_load32_u
-        _align = insn.operand[0] # TODO: alignment support?
-        offset = insn.operand[1]
+        _align = operand[0] # TODO: alignment support?
+        offset = operand[1]
         raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
 
         addr = runtime.stack.pop
@@ -196,8 +196,8 @@ module GenAlu
 
     store: <<~RUBY,
       when :${PREFIX}_store
-        _align = insn.operand[0] # TODO: alignment support?
-        offset = insn.operand[1]
+        _align = operand[0] # TODO: alignment support?
+        offset = operand[1]
         raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
 
         value = runtime.stack.pop
@@ -214,8 +214,8 @@ module GenAlu
 
     store8: <<~RUBY,
       when :${PREFIX}_store8
-        _align = insn.operand[0] # TODO: alignment support?
-        offset = insn.operand[1]
+        _align = operand[0] # TODO: alignment support?
+        offset = operand[1]
         raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
 
         value = runtime.stack.pop
@@ -232,8 +232,8 @@ module GenAlu
 
     store16: <<~RUBY,
       when :${PREFIX}_store16
-        _align = insn.operand[0] # TODO: alignment support?
-        offset = insn.operand[1]
+        _align = operand[0] # TODO: alignment support?
+        offset = operand[1]
         raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
 
         value = runtime.stack.pop
@@ -250,8 +250,8 @@ module GenAlu
 
     store32: <<~RUBY,
       when :${PREFIX}_store32
-        _align = insn.operand[0] # TODO: alignment support?
-        offset = insn.operand[1]
+        _align = operand[0] # TODO: alignment support?
+        offset = operand[1]
         raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
 
         value = runtime.stack.pop
@@ -268,7 +268,7 @@ module GenAlu
 
     const: <<~RUBY,
       when :${PREFIX}_const
-        const = insn.operand[0]
+        const = operand[0]
         if !const.is_a?(Integer)
           raise EvalError, "invalid type of operand"
         end
@@ -277,7 +277,7 @@ module GenAlu
 
     const__f: <<~RUBY,
       when :${PREFIX}_const
-        const = insn.operand[0]
+        const = operand[0]
         if !const.is_a?(Float)
           raise EvalError, "invalid type of operand"
         end

data/scripts/templates/alu_module.rb.tmpl

@@ -5,14 +5,16 @@ 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
+    # @rbs code: Symbol
+    # @rbs operand: Array[operandItem]
+    # @rbs return: bool?
+    def self.${PREFIX}_eval_insn(runtime, frame, code, operand)
+      case code
 ${DEFS}
       else
-        raise "Unknown opcode for namespace #{insn.namespace}: #{insn.code}"
+        return
       end
+      return true
     end
   end
 end

data/scripts/templates/conv_module.rb.tmpl

@@ -5,14 +5,16 @@ module Wardite
   module Evaluator
     # @rbs runtime: Runtime
     # @rbs frame: Frame
-    # @rbs insn: Op
-    # @rbs return: void 
-    def self.convert_eval_insn(runtime, frame, insn)
-      case insn.code
+    # @rbs code: Symbol
+    # @rbs operand: Array[operandItem]
+    # @rbs return: bool?
+    def self.convert_eval_insn(runtime, frame, code, operand)
+      case code
 ${DEFS}
       else
-        raise "Unknown opcode for namespace #{insn.namespace}: #{insn.code}"
+        return
       end
+      return true
     end
   end
 end

data/sig/generated/wardite/alu_f32.generated.rbs

@@ -4,8 +4,9 @@ module Wardite
   module Evaluator
     # @rbs runtime: Runtime
     # @rbs frame: Frame
-    # @rbs insn: Op
-    # @rbs return: void 
-    def self.f32_eval_insn: (Runtime runtime, Frame frame, Op insn) -> void
+    # @rbs code: Symbol
+    # @rbs operand: Array[operandItem]
+    # @rbs return: bool?
+    def self.f32_eval_insn: (Runtime runtime, Frame frame, Symbol code, Array[operandItem] operand) -> bool?
   end
 end

data/sig/generated/wardite/alu_f64.generated.rbs

@@ -4,8 +4,9 @@ module Wardite
   module Evaluator
     # @rbs runtime: Runtime
     # @rbs frame: Frame
-    # @rbs insn: Op
-    # @rbs return: void 
-    def self.f64_eval_insn: (Runtime runtime, Frame frame, Op insn) -> void
+    # @rbs code: Symbol
+    # @rbs operand: Array[operandItem]
+    # @rbs return: bool?
+    def self.f64_eval_insn: (Runtime runtime, Frame frame, Symbol code, Array[operandItem] operand) -> bool?
   end
 end

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

@@ -4,8 +4,9 @@ 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
+    # @rbs code: Symbol
+    # @rbs operand: Array[operandItem]
+    # @rbs return: bool?
+    def self.i32_eval_insn: (Runtime runtime, Frame frame, Symbol code, Array[operandItem] operand) -> bool?
   end
 end