more splitting of slot code

now constants, still wip

lib/slot_machine/instruction/constant_definition.rb

@@ -0,0 +1,49 @@
+module SlotMachine
+  class ConstantDefinition < SlotDefinition
+    # get the right definition, depending on the object
+    def self.for(object , slots)
+      case object
+      when :message
+        MessageDefinition.new(slots)
+      when Constant
+        ConstantDefinition.new(object , slots)
+      else
+        SlotDefinition.new(object,slots)
+      end
+    end
+
+    def initialize( object , slots)
+      super(object, slots)
+    end
+
+
+    def known_name
+      known_object.class.short_name
+    end
+
+    # load the slots into a register
+    # the code is added to compiler
+    # the register returned
+    def to_register(compiler, source)
+      if known_object.respond_to?(:ct_type)
+        type = known_object.ct_type
+      else
+        type = :Object
+      end
+      right = compiler.use_reg( type )
+      case known_object
+      when Constant
+        parfait = known_object.to_parfait(compiler)
+        const = Risc.load_constant(source, parfait , right)
+        compiler.add_code const
+        if slots.length == 1
+          raise "only type allowed for constants, not #{slots[0]}" unless slots[0] == :type
+          compiler.add_code Risc::SlotToReg.new( source , right , Parfait::TYPE_INDEX, right)
+        end
+        raise "Can't have slots into Constants #{slots}" if slots.length > 1
+      end
+        return const.register
+    end
+
+  end
+end

lib/slot_machine/instruction/message_definition.rb

@@ -6,7 +6,7 @@ module SlotMachine
     end
 
     def known_name
-      known_object
+      :message
     end
 
     # load the slots into a register

lib/slot_machine/instruction/slot_definition.rb

@@ -20,6 +20,8 @@ module SlotMachine
       case object
       when :message
         MessageDefinition.new(slots)
+      when Constant
+        ConstantDefinition.new(object , slots)
       else
         SlotDefinition.new(object,slots)
       end
@@ -45,7 +47,7 @@ module SlotMachine
 
     def known_name
       case known_object
-      when Constant , Parfait::Object
+      when Parfait::Object
         known_object.class.short_name
       when Risc::Label
         known_object.to_s
@@ -58,24 +60,13 @@ module SlotMachine
     # the code is added to compiler
     # the register returned
     def to_register(compiler, source)
-      if known_object.respond_to?(:ct_type)
-        type = known_object.ct_type
-      elsif(known_object.respond_to?(:get_type))
+      if(known_object.respond_to?(:get_type))
         type = known_object.get_type
       else
         type = :Object
       end
       right = compiler.use_reg( type )
       case known_object
-      when Constant
-        parfait = known_object.to_parfait(compiler)
-        const = Risc.load_constant(source, parfait , right)
-        compiler.add_code const
-        if slots.length == 1
-          raise "only type allowed for constants, not #{slots[0]}" unless slots[0] == :type
-          compiler.add_code Risc::SlotToReg.new( source , right , Parfait::TYPE_INDEX, right)
-        end
-        raise "Can't have slots into Constants #{slots}" if slots.length > 1
       when Parfait::Object , Risc::Label
         const = Risc.load_constant(source, known_object , right)
         compiler.add_code const

lib/slot_machine/instruction/slot_load.rb

@@ -82,3 +82,4 @@ module SlotMachine
 end
 require_relative "slot_definition"
 require_relative "message_definition"
+require_relative "constant_definition"