use factory functions consistently to create instructions

lib/register/instructions/byte_to_reg.rb

@@ -12,9 +12,9 @@ module Register
   # Produce a ByteToReg instruction.
   # from and to are translated (from symbol to register if neccessary)
   # but index is left as is.
-  # def self.byte_to_reg source , array , index , to
-  #   from = resolve_to_register from
-  #   to = resolve_to_register to
-  #   ByteToReg.new( source , array , index , to)
-  # end
+  def self.byte_to_reg( source , array , index , to)
+     array = resolve_to_register( array)
+     to = resolve_to_register( to)
+     ByteToReg.new( source , array , index , to)
+  end
 end

lib/register/instructions/function_call.rb

@@ -4,7 +4,7 @@ module Register
   # assembly takes care of the rest (ie getting the address)
 
   class FunctionCall < Instruction
-    def initialize source , method
+    def initialize( source , method )
       super(source)
       @method = method
     end
@@ -15,13 +15,17 @@ module Register
     end
   end
 
+  def self.function_call( source , method )
+    Register::FunctionCall.new( source , method )
+  end
+
   def self.issue_call( compiler , callee )
-    return_label = Label.new("_return_label #{callee.name}" , "#{compiler.type.object_class.name}.#{compiler.method.name}" )
+    return_label = Register.label("_return_label #{callee.name}" , "#{compiler.type.object_class.name}.#{compiler.method.name}" )
     ret_tmp = compiler.use_reg(:Label)
     compiler.add_code Register.load_constant("#{callee.name} load ret", return_label , ret_tmp)
     compiler.add_code Register.reg_to_slot("#{callee.name} store ret", ret_tmp , :new_message , :return_address)
     compiler.add_code Register.transfer("#{callee.name} move new message", Register.new_message_reg , Register.message_reg )
-    compiler.add_code FunctionCall.new( "#{callee.name} call" , callee )
+    compiler.add_code Register.function_call( "#{callee.name} call" , callee )
     compiler.add_code return_label
     compiler.add_code Register.transfer("#{callee.name} remove new message", Register.message_reg , Register.new_message_reg )
     compiler.add_code Register.slot_to_reg("#{callee.name} restore message" , :new_message , :caller , :message )

lib/register/instructions/function_return.rb

@@ -4,7 +4,7 @@ module Register
   # register and index specify where the return address is stored
 
   class FunctionReturn < Instruction
-    def initialize source , register , index
+    def initialize( source , register , index)
       super(source)
       @register = register
       @index = index
@@ -14,6 +14,9 @@ module Register
     def to_s
       "FunctionReturn: #{register} [#{index}]"
     end
+  end
 
+  def self.function_return( source , register , index)
+    FunctionReturn.new( source , register , index)
   end
 end

lib/register/instructions/label.rb

@@ -8,7 +8,7 @@ module Register
   #
 
   class Label < Instruction
-    def initialize source , name , nekst = nil
+    def initialize( source , name , nekst = nil)
       super(source , nekst)
       @name = name
     end
@@ -77,4 +77,8 @@ module Register
       super
     end
   end
+
+  def self.label( source , name , nekst = nil)
+    Label.new( source , name , nekst = nil)
+  end
 end

lib/register/instructions/reg_to_byte.rb

@@ -11,11 +11,11 @@ module Register
   # Produce a RegToByte instruction.
   # from and to are translated (from symbol to register if neccessary)
   # but index is left as is.
-  # def self.reg_to_byte source , from , to , index
-  #   from = resolve_to_register from
-  #   index = resolve_to_index( to , index)
-  #   to = resolve_to_register to
-  #   RegToByte.new( source, from , to , index)
-  # end
+  def self.reg_to_byte( source , from , to , index)
+    from = resolve_to_register from
+    index = resolve_to_index( to , index)
+    to = resolve_to_register to
+    RegToByte.new( source, from , to , index)
+  end
 
 end