move interpreter to register

seems more where it belongs, since it interprets the register machine
instructions

lib/register/eventable.rb

@@ -0,0 +1,37 @@
+# A simple event registering/triggering module to mix into classes.
+# Events are stored in the `@events` ivar.
+module Eventable
+
+  # Register a handler for the given event name.
+  # The event name is the method name called on the handler object
+  #
+  #   obj.on(:foo , some_object_that_implements foo( whateverargs)
+  #
+  # @param [String, Symbol] name event name
+  # @param [Object] object handling the event, ie implement the function name
+  # @return handler
+  def register_event(name, handler)
+    event_table[name] << handler
+    handler
+  end
+
+  def unregister_event(name, handler)
+    event_table[name].delete handler
+  end
+
+  def event_table
+    return @event_table if @event_table
+    @event_table = Hash.new { |hash, key| hash[key] = [] }
+  end
+
+  # Trigger the given event name and passes all args to each handler
+  # for this event.
+  #
+  #   obj.trigger(:foo)
+  #   obj.trigger(:foo, 1, 2, 3)
+  #
+  # @param [String, Symbol] name event name to trigger
+  def trigger(name, *args)
+    event_table[name].each { |handler| handler.send( name.to_sym , *args) }
+  end
+end

lib/register/interpreter.rb

@@ -0,0 +1,232 @@
+
+require_relative "eventable"
+
+module Register
+  class Interpreter
+    # fire events for changed pc and register contents
+    include Eventable
+    include Logging
+    log_level :info
+
+    attr_reader :instruction     # current instruction or pc
+    attr_reader :clock    # current instruction or pc
+
+    attr_reader :registers     # the registers, 16 (a hash, sym -> contents)
+    attr_reader :stdout     # collect the output
+    attr_reader :state # running etc
+    attr_reader :flags  # somewhat like the lags on a cpu, hash  sym => bool (zero .. . )
+
+    def initialize
+      @state = :stopped
+      @stdout = ""
+      @registers = {}
+      @flags = {  :zero => false , :plus => false ,
+                  :minus => false , :overflow => false }
+      @clock = 0
+      (0...12).each do |r|
+        set_register "r#{r}".to_sym , "r#{r}:unknown"
+      end
+    end
+
+    def start instruction
+      initialize
+      set_state(:running)
+      set_instruction instruction
+    end
+
+    def set_state state
+      old = @state
+      return if state == old
+      @state = state
+      trigger(:state_changed , old , state )
+    end
+
+    def set_instruction i
+      return if @instruction == i
+      old = @instruction
+      @instruction = i
+      trigger(:instruction_changed, old , i)
+      set_state( :exited) unless i
+    end
+
+    def get_register( reg )
+      reg = reg.symbol if reg.is_a? Register::RegisterValue
+      raise "Not a register #{reg}" unless Register::RegisterValue.look_like_reg(reg)
+      @registers[reg]
+    end
+
+    def set_register reg , val
+      old = get_register( reg ) # also ensures format
+      if val.is_a? Fixnum
+        @flags[:zero] = (val == 0)
+        @flags[:plus] = (val >= 0)
+        @flags[:minus] = (val < 0)
+        log.debug "Set_flags #{val}  :#{@flags.inspect}"
+      else
+        @flags[:zero] =  @flags[:plus] = true
+        @flags[:minus] = false
+      end
+      return if old === val
+      reg = reg.symbol if reg.is_a? Register::RegisterValue
+      @registers[reg] = val
+      trigger(:register_changed, reg ,  old , val)
+    end
+
+    def tick
+      return unless @instruction
+      @clock += 1
+      name = @instruction.class.name.split("::").last
+      log.debug "#{@clock.to_s}: #{@instruction.to_s}"
+      fetch = send "execute_#{name}"
+      return unless fetch
+      set_instruction @instruction.next
+    end
+
+    # Label is a noop.
+    def execute_Label
+      true
+    end
+    # Instruction interpretation starts here
+    def execute_Branch
+      label = @instruction.label
+      set_instruction label
+      false
+    end
+
+    def execute_IsZero
+       @flags[:zero] ?  execute_Branch : true
+    end
+    def execute_IsNotzero
+       @flags[:zero] ? true : execute_Branch
+    end
+    def execute_IsPlus
+       @flags[:plus] ?  execute_Branch : true
+    end
+    def execute_IsMinus
+       @flags[:minus] ?  execute_Branch : true
+    end
+
+    def execute_LoadConstant
+      to = @instruction.register
+      value = @instruction.constant
+      #value = value.object_id unless value.is_a?(Fixnum)
+      set_register( to , value )
+      true
+    end
+
+    def execute_GetSlot
+      object = get_register( @instruction.array )
+      if( @instruction.index.is_a?(Numeric) )
+        index = @instruction.index
+      else
+        index = get_register(@instruction.index)
+      end
+      if object.is_a?(Symbol)
+        if( index == 2 )
+          value = object.to_s.length
+        else
+          raise "Unsupported action, must convert symbol to word:#{object}"
+        end
+      else
+        value = object.get_internal( index )
+      end
+      #value = value.object_id unless value.is_a? Fixnum
+      set_register( @instruction.register , value )
+      true
+    end
+
+    def execute_SetSlot
+      value = get_register( @instruction.register )
+      object = get_register( @instruction.array )
+      if( @instruction.index.is_a?(Numeric) )
+        index = @instruction.index
+      else
+        index = get_register(@instruction.index)
+      end
+      object.set_internal( index , value )
+      trigger(:object_changed, @instruction.array , index)
+      true
+    end
+
+    def execute_RegisterTransfer
+      value = get_register @instruction.from
+      set_register @instruction.to , value
+      true
+    end
+
+    def execute_FunctionCall
+      set_instruction @instruction.method.instructions
+      false
+    end
+
+    def execute_FunctionReturn
+      object = get_register( @instruction.register )
+      link = object.get_internal( @instruction.index )
+      @instruction = link
+      # we jump back to the call instruction. so it is as if the call never happened and we continue
+      true
+    end
+
+    def execute_Syscall
+      name = @instruction.name
+      ret_value = 0
+      case name
+      when :putstring
+        str = get_register( :r1 ) # should test length, ie r2
+        case str
+        when Symbol
+          @stdout += str.to_s
+          ret_value = str.to_s.length
+        when Parfait::Word
+          @stdout += str.to_string
+          ret_value = str.char_length
+        else
+          raise "NO string for putstring #{str.class}:#{str.object_id}" unless str.is_a?(Symbol)
+        end
+      when :exit
+        set_instruction(nil)
+        return false
+      else
+        raise "un-implemented syscall #{name}"
+      end
+      set_register( :r0 , ret_value ) # syscalls return into r0 , usually some int
+      true
+    end
+
+    def execute_OperatorInstruction
+      left = get_register(@instruction.left) || 0
+      rr = @instruction.right
+      right = get_register(rr) || 0
+      @flags[:overflow] = false
+      case @instruction.operator.to_s
+      when "+"
+        result = left + right
+      when "-"
+        result = left - right
+      when ">>"
+        result = left / (2**right)
+      when "<<"
+        result = left * (2**right)
+      when "*"
+        result = left * right
+      when "&"
+        result = left & right
+      when "|"
+        result = left | right
+      when "=="
+        result = (left == right) ? 1 : 0
+      else
+        raise "unimplemented  '#{@instruction.operator}' #{@instruction}"
+      end
+      if( result > 2**32 )
+        @flags[:overflow] = true
+        result = result % 2**32
+      else
+        result = result.to_i
+      end
+      log.debug "#{@instruction} == #{result}(#{result.class})   (#{left}|#{right})"
+      right = set_register(@instruction.left , result)
+      true
+    end
+  end
+end