Externalise register allocation into own class

On the way to the register allocation

lib/risc/allocator.rb

@@ -0,0 +1,62 @@
+module Risc
+  # just moved compilers register related stuff here
+  #
+  # Allocator keeps a list of registers and passes them out
+  # upon request. they must be returned in order
+  class Allocator
+
+    def initialize()
+      @regs = []
+      reset_regs
+    end
+    attr_reader :regs
+
+    def regs_empty?
+      @regs.empty?
+    end
+    def add_reg(reg)
+      raise "not reg #{reg.class}" unless reg.is_a?(RegisterValue)
+      @regs << reg
+    end
+    def pop
+      @regs.pop
+    end
+    def clear_regs
+      @regs.clear
+    end
+
+    # require a (temporary) register. code must give this back with release_reg
+    # Second extra parameter may give extra info about the value, see RegisterValue
+    def use_reg( type , extra = {} )
+      raise "Not type #{type.inspect}:#{type.class}" unless type.is_a?(Symbol) or type.is_a?(Parfait::Type)
+      if @regs.empty?
+        reg = Risc.tmp_reg(type , extra)
+      else
+        reg = @regs.last.next_reg_use(type , extra)
+      end
+      @regs << reg
+      return reg
+    end
+
+    def copy( reg , source )
+      copied = use_reg reg.type
+      add_code Register.transfer( source , reg , copied )
+      copied
+    end
+
+    # releasing a register (accuired by use_reg) makes it available for use again
+    # thus avoiding possibly using too many registers
+    def release_reg( reg )
+      last = @regs.pop
+      raise "released register in wrong order, expect #{last} but was #{reg}" if reg != last
+    end
+
+    # reset the registers to be used. Start at r4 for next usage.
+    # Every statement starts with this, meaning each statement may use all registers, but none
+    # get saved. Statements have affect on objects.
+    def reset_regs
+      @regs.clear
+    end
+
+  end
+end

lib/risc/callable_compiler.rb

@@ -18,10 +18,10 @@ module Risc
     def initialize( callable  , slot_label)
       raise "No method" unless callable
       @callable = callable
-      @regs = []
+      @allocator = Allocator.new
       @constants = []
       @current = @risc_instructions = slot_label.risc_label(self)
-      reset_regs
+      @allocator.reset_regs
     end
     attr_reader :risc_instructions , :constants , :callable , :current
 
@@ -54,14 +54,7 @@ module Risc
     # require a (temporary) register. code must give this back with release_reg
     # Second extra parameter may give extra info about the value, see RegisterValue
     def use_reg( type , extra = {} )
-      raise "Not type #{type.inspect}" unless type.is_a?(Symbol) or type.is_a?(Parfait::Type)
-      if @regs.empty?
-        reg = Risc.tmp_reg(type , extra)
-      else
-        reg = @regs.last.next_reg_use(type , extra)
-      end
-      @regs << reg
-      return reg
+      @allocator.use_reg(type, extra)
     end
 
     # resolve the type of the slot, by inferring from it's name, using the type
@@ -106,7 +99,7 @@ module Risc
     # releasing a register (accuired by use_reg) makes it available for use again
     # thus avoiding possibly using too many registers
     def release_reg( reg )
-      last = @regs.pop
+      last = @allocator.pop
       raise "released register in wrong order, expect #{last} but was #{reg}" if reg != last
     end
 
@@ -114,7 +107,7 @@ module Risc
     # Every statement starts with this, meaning each statement may use all registers, but none
     # get saved. Statements have affect on objects.
     def reset_regs
-      @regs.clear
+      @allocator.clear_regs
     end
 
     # Build with builder (see there), adding the created instructions
@@ -150,3 +143,4 @@ module Risc
 
   end
 end
+require_relative "allocator"