Rename SlotDefinition to Slot

And the derived XXDefinitions to XXSlot

Just to be more consistent
And possibly free the Definition for the Language side

lib/slot_machine/instruction/argument_transfer.rb

@@ -25,7 +25,7 @@ module SlotMachine
     def initialize( source , receiver,arguments )
       super(source)
       @receiver , @arguments = receiver , arguments
-      raise "Receiver not SlotDefinition #{@receiver}" unless @receiver.is_a?(SlotDefinition)
+      raise "Receiver not Slot #{@receiver}" unless @receiver.is_a?(Slot)
       @arguments.each{|a| raise "args not SlotLoad #{a}" unless a.is_a?(SlotLoad)}
     end
 

lib/slot_machine/instruction/constant_slot.rb

@@ -1,14 +1,14 @@
 module SlotMachine
-  class ConstantDefinition < SlotDefinition
+  class ConstantSlot < Slot
     # get the right definition, depending on the object
     def self.for(object , slots)
       case object
       when :message
-        MessageDefinition.new(slots)
+        MessageSlot.new(slots)
       when Constant
-        ConstantDefinition.new(object , slots)
+        ConstantSlot.new(object , slots)
       else
-        SlotDefinition.new(object,slots)
+        Slot.new(object,slots)
       end
     end
 

lib/slot_machine/instruction/message_slot.rb

@@ -1,5 +1,5 @@
 module SlotMachine
-  class MessageDefinition < SlotDefinition
+  class MessageSlot < Slot
 
     def initialize(slots)
       super(:message , slots)

lib/slot_machine/instruction/not_same_check.rb

@@ -3,7 +3,7 @@ module SlotMachine
   # SlotMachine internal check, as the name says to see if two values are not the same
   # In other words, we this checks identity, bit-values, pointers
   #
-  # The values that are compared are defined as SlotDefinitions, ie can be anything
+  # The values that are compared are defined as Slots, ie can be anything
   # available to the machine through frame message or self
   #
   # Acording to SlotMachine::Check logic, we jump to the given label is the values are the same

lib/slot_machine/instruction/object_slot.rb

@@ -1,5 +1,5 @@
 module SlotMachine
-  class ObjectDefinition < SlotDefinition
+  class ObjectSlot < Slot
 
     def initialize( object , slots)
       super(object , slots )

lib/slot_machine/instruction/slot.rb

@@ -1,11 +1,11 @@
 module SlotMachine
-  # A SlotDefinition defines a slot. A bit like a variable name but for objects.
+  # A Slot defines a slot. A bit like a variable name but for objects.
   #
   # PS: for the interested: A "development" of Smalltalk was the
   #     prototype based language (read: JavaScript equivalent)
   #     called Self https://en.wikipedia.org/wiki/Self_(programming_language)
   #
-  # SlotDefinitions are the instance names of objects. But since the language is dynamic
+  # Slots are the instance names of objects. But since the language is dynamic
   # what is it that we can say about instance names at runtime?
   # Start with a known object like the Message (in register one), we know all it's
   # variables. But there is a Message in there, and for that we know the instances
@@ -14,16 +14,16 @@ module SlotMachine
   # The definiion is an array of symbols that we can resolve to SlotLoad
   # Instructions. Or in the case of constants to ConstantLoad
   #
-  class SlotDefinition
+  class Slot
     # get the right definition, depending on the object
     def self.for(object , slots)
       case object
       when :message
-        MessageDefinition.new(slots)
+        MessageSlot.new(slots)
       when Constant
-        ConstantDefinition.new(object , slots)
+        ConstantSlot.new(object , slots)
       when Parfait::Object , Risc::Label
-        ObjectDefinition.new(object , slots)
+        ObjectSlot.new(object , slots)
       else
         raise "not supported type #{object}"
       end

lib/slot_machine/instruction/slot_load.rb

@@ -4,9 +4,9 @@ module SlotMachine
   # A Slot is basically an instance variable, but it must be of known type
   #
   # The value loaded (the right hand side) can be a constant (SlotMachine::Constant) or come from
-  #  another Slot (SlotDefinition)
+  #  another Slot (Slot)
   #
-  # The Slot on the left hand side is always a SlotDefinition.
+  # The Slot on the left hand side is always a Slot.
   # The only known object (*) for the left side is the current message, which is a bit like
   # the oo version of a Stack (Stack Register, Frame Pointer, ..)
   # (* off course all class objects are global, and so they are allowed too)
@@ -18,10 +18,10 @@ module SlotMachine
   # From the outside a send is neccessary, both for get and set, (which goes through the method
   # resolution and guarantees the correct method for a type), in other words perfect data hiding.
   #
-  # @left: A SlotDefinition, or an array that can be passed to the constructor of the
-  #        SlotDefinition (see there)
+  # @left: A Slot, or an array that can be passed to the constructor of the
+  #        Slot (see there)
   #
-  # @right: A SlotDefinition with slots or a SlotMachine::Constant
+  # @right: A Slot with slots or a SlotMachine::Constant
   # original_source: optinally another slot_machine instruction that will be passed down
   #                to created  risc instructions. (Because SlotLoad is often used internally)
   class SlotLoad < Instruction
@@ -31,10 +31,10 @@ module SlotMachine
     def initialize(source , left , right, original_source = nil)
       super(source)
       @left , @right = left , right
-      @left = SlotDefinition.for(@left.shift , @left) if @left.is_a? Array
-      @right = SlotDefinition.for(@right.shift , @right) if @right.is_a? Array
-      raise "right not SlotMachine, #{@right.to_s}" unless @right.is_a?( SlotDefinition )
-      raise "left not SlotMachine, #{@left.to_s}" unless @left.is_a?( SlotDefinition )
+      @left = Slot.for(@left.shift , @left) if @left.is_a? Array
+      @right = Slot.for(@right.shift , @right) if @right.is_a? Array
+      raise "right not SlotMachine, #{@right.to_s}" unless @right.is_a?( Slot )
+      raise "left not SlotMachine, #{@left.to_s}" unless @left.is_a?( Slot )
       @original_source = original_source || self
     end
 
@@ -54,7 +54,7 @@ module SlotMachine
   end
 
 end
-require_relative "slot_definition"
-require_relative "message_definition"
-require_relative "constant_definition"
-require_relative "object_definition"
+require_relative "slot"
+require_relative "message_slot"
+require_relative "constant_slot"
+require_relative "object_slot"

lib/slot_machine/instruction/truth_check.rb

@@ -11,7 +11,7 @@ module SlotMachine
     def initialize(condition , false_jump)
       super(false_jump)
       @condition  = condition
-      raise "condition must be slot_definition #{condition}" unless condition.is_a?(SlotDefinition)
+      raise "condition must be slot_definition #{condition}" unless condition.is_a?(Slot)
     end
 
     def to_s