use fake memory

fix integer offset bug
(which only didn’t cause errors as fixnums are still an order too big
and the famous +1 error hit the empty space)

lib/parfait/binary_code.rb

@@ -8,10 +8,13 @@ module Parfait
   #
   class BinaryCode < Data16
     attr_reader :next
-    def self.offset
-      2 * 4 # size of type (2, type+next) * word_size (4)
-    end
 
+    def self.type_length
+      2 #type + next (could get from space, maybe later)
+    end
+    def self.byte_offset
+      self.type_length * 4 # size of type * word_size (4)
+    end
     #16 - 2 -1 , two instance variables and one for the jump
     def self.data_length
       13
@@ -45,7 +48,7 @@ module Parfait
 
     def each_block( &block )
       block.call( self )
-      @next.each( &block ) if @next
+      @next.each_block( &block ) if @next
     end
 
     def to_s
@@ -68,8 +71,9 @@ module Parfait
         #raise "invalid index #{index}" unless @next
         extend_to( index )
         @next.set_word( index - data_length , word)
+      else
+        set_internal_word(index + 2 , word)
       end
-      set_internal_word(index + 2 , word)
     end
     def set_last(word)
       set_word( data_length , word)

lib/parfait/data_object.rb

@@ -24,6 +24,9 @@ module Parfait
     def initialize
       super
     end
+    def self.integer_index
+      type_length
+    end
     def data_length
       raise "called #{self}"
     end

lib/parfait/integer.rb

@@ -19,8 +19,12 @@ module Parfait
     def value
       get_internal_word(Integer.integer_index)
     end
+
+    def self.type_length
+      2    # 0 type, 1 next_i
+    end
     def self.integer_index
-      3 # 1 type, 2 next_i
+      type_length
     end
 
     # :integer?, :odd?, :even?, :upto, :downto, :times, :succ, :next, :pred, :chr, :ord, :to_i, :to_int, :floor,
@@ -42,17 +46,26 @@ module Parfait
     def initialize
       super
     end
+    def self.type_length
+      1    # 0 type
+    end
   end
   class TrueClass < Data4
     #FIXME: this is "just" for compilation
     def initialize
       super
     end
+    def self.type_length
+      1    # 0 type
+    end
   end
   class NilClass < Data4
     #FIXME: this is "just" for compilation
     def initialize
       super
     end
+    def self.type_length
+      1    # 0 type
+    end
   end
 end

lib/parfait/word.rb

@@ -19,6 +19,9 @@ module Parfait
     def self.get_length_index
       2 # 2 is the amount of attributes, type and char_length. the offset after which chars start
     end
+    def self.type_length
+      2    # 0 type , 1 char_length
+    end
     def self.get_indexed( i )
       i + get_length_index * 4
     end

lib/risc/fake_memory.rb

@@ -34,7 +34,7 @@ module Risc
 
     def range_check(index)
       raise "index too low #{index} < #{min}" if index < min
-      raise "index too big #{index} < #{min}" if index >= size
+      raise "index too big #{index} >= #{size}" if index >= size
     end
   end
 end

lib/risc/interpreter.rb

@@ -51,7 +51,7 @@ module Risc
       raise "No position #{pos.to_s(16)}" unless position
       if position.is_a?(Position::CodePosition)
         raise "Setting Code #{clock}-#{position}, #{position.method}"
-        #return set_pc(position.at + Parfait::BinaryCode.offset)
+        #return set_pc(position.at + Parfait::BinaryCode.byte_offset)
       end
       log.debug "Setting Position #{clock}-#{position}, #{position.binary}"
       raise "not instruction position #{position}-#{position.class}-#{position.object.class}" unless position.is_a?(Position::InstructionPosition)
@@ -120,7 +120,7 @@ module Risc
     def execute_Branch
       label = @instruction.label
       pos = Position.get(label).at
-      pos += Parfait::BinaryCode.offset if label.is_a?(Parfait::BinaryCode)
+      pos += Parfait::BinaryCode.byte_offset if label.is_a?(Parfait::BinaryCode)
       set_pc pos
       false
     end
@@ -218,7 +218,7 @@ module Risc
       meth = @instruction.method
       at = Position.get(meth.binary).at
       log.debug "Call to #{meth.name} at:#{at}"
-      set_pc(at + Parfait::BinaryCode.offset)
+      set_pc(at + Parfait::BinaryCode.byte_offset)
       #set_instruction @instruction.method.risc_instructions
       false
     end

lib/risc/machine.rb

@@ -106,9 +106,9 @@ module Risc
       first_method = Parfait.object_space.types.values.first.methods
       before = at
       Position.set( first_method.binary , at , first_method)
-      Position.set( first_method.cpu_instructions, at + Parfait::BinaryCode.offset , first_method.binary)
+      Position.set( first_method.cpu_instructions, at + Parfait::BinaryCode.byte_offset , first_method.binary)
       log.debug "Method #{first_method.name}:#{before.to_s(16)} len: #{(at - before).to_s(16)}"
-      log.debug "Instructions #{first_method.cpu_instructions.object_id.to_s(16)}:#{(before+Parfait::BinaryCode.offset).to_s(16)}"
+      log.debug "Instructions #{first_method.cpu_instructions.object_id.to_s(16)}:#{(before+Parfait::BinaryCode.byte_offset).to_s(16)}"
       at
     end
 

lib/risc/parfait_adapter.rb

@@ -5,8 +5,7 @@ module Parfait
 
     def self.allocate
       r = super
-      puts "#{self.memory_size}"
-      r.instance_variable_set(:@memory , [])
+      r.instance_variable_set(:@memory , Risc::FakeMemory.new(self.type_length , self.memory_size))
       r
     end
 

lib/risc/position/code_position.rb

@@ -28,7 +28,7 @@ module Risc
           next_meth = next_method
           return unless next_meth
           Position.set( next_meth.binary , next_pos , next_meth)
-          next_cpu_pos = next_pos + Parfait::BinaryCode.offset
+          next_cpu_pos = next_pos + Parfait::BinaryCode.byte_offset
           Position.set( next_meth.cpu_instructions, next_cpu_pos , next_meth.binary)
         end
       end

lib/risc/position/instruction_position.rb

@@ -36,7 +36,7 @@ module Risc
           next_binary.extend_one unless next_binary.next
           next_binary = next_binary.next
           raise "end of line " unless next_binary
-          nekst = Position.get(next_binary).at + Parfait::BinaryCode.offset
+          nekst = Position.get(next_binary).at + Parfait::BinaryCode.byte_offset
           Position.log.debug "Jump to: #{nekst.to_s(16)}"
         end
         Position.set(@instruction.next, nekst , next_binary)