adds a mom version of basic values

lib/mom/basic_values.rb

@@ -0,0 +1,55 @@
+module Mom
+  # just name scoping the same stuff to mom
+  # so we know we are on the way down, keeping our layers seperated
+  # and we can put constant adding into the to_risc methods (instead of on vool classes)
+  class Constant
+  end
+
+  class IntegerConstant < Constant
+    attr_reader :value
+    def initialize(value)
+      @value = value
+    end
+    def ct_type
+      Parfait.object_space.get_class_by_name(:Integer).instance_type
+    end
+  end
+  class FloatConstant < Constant
+    attr_reader :value
+    def initialize(value)
+      @value = value
+    end
+    def ct_type
+      true
+    end
+  end
+  class TrueConstant < Constant
+    def ct_type
+      Parfait.object_space.get_class_by_name(:True).instance_type
+    end
+  end
+  class FalseConstant < Constant
+    def ct_type
+      Parfait.object_space.get_class_by_name(:False).instance_type
+    end
+  end
+  class NilConstant < Constant
+    def ct_type
+      Parfait.object_space.get_class_by_name(:Nil).instance_type
+    end
+  end
+  class StringConstant < Constant
+    attr_reader :value
+    def initialize(value)
+      @value = value
+    end
+    def ct_type
+      Parfait.object_space.get_class_by_name(:Word).instance_type
+    end
+  end
+  class SymbolConstant < String
+    def ct_type
+      Parfait.object_space.get_class_by_name(:Word).instance_type
+    end
+  end
+end

lib/mom/instruction.rb

@@ -19,6 +19,7 @@ module Mom
   end
 end
 
+require_relative "basic_values"
 require_relative "simple_call"
 require_relative "dynamic_call"
 require_relative "truth_check"

lib/mom/slot_load.rb

@@ -30,7 +30,8 @@ module Mom
     def initialize(left , right)
       left = SlotDefinition.new(left.shift , left) if left.is_a? Array
       @left , @right = left , right
-      raise "right not SlotDefinition, #{left}" unless left.is_a? SlotDefinition
+      raise "left not SlotDefinition, #{left}" unless left.is_a? SlotDefinition
+#      raise "right not Mom, #{right.to_rxf}" unless right.class.name.include?("Mom")
     end
   end
 
@@ -44,7 +45,7 @@ module Mom
 
     def initialize(left , right)
       super
-      raise "right not constant, #{right}" unless right.is_a? Vool::ConstantStatement
+      raise "right not constant, #{right}" unless right.is_a? Mom::Constant
     end
 
   end

lib/parfait/integer.rb

@@ -1,11 +1,10 @@
 
 # Integer class for representing maths on Integers
-# Integers are Values (not Objects),
+# Integers are Objects, spcifically DataObjects
 # - they have fixed value
 # - they are immutable
-# you can *not* assign instance variables or methods
-
-# TODO how this idea works with Numeric ?
+# (both by implementation, not design.
+# Ie it would be possible to change the value, we just don't support that)
 
 module Parfait
   class Integer

lib/vool/statements/basic_values.rb

@@ -15,6 +15,9 @@ module Vool
     def initialize(value)
       @value = value
     end
+    def to_mom(method)
+      return Mom::IntegerConstant.new(@value)
+    end
     def ct_type
       Parfait.object_space.get_class_by_name(:Integer).instance_type
     end
@@ -45,10 +48,12 @@ module Vool
   end
   class SelfStatement < Statement
     attr_reader :clazz
-
     def set_class(clazz)
       @clazz = clazz
     end
+    def to_mom(in_method)
+      Mom::SlotDefinition.new(:message , [:self])
+    end
     def ct_type
       @clazz.instance_type
     end
@@ -60,6 +65,9 @@ module Vool
     def initialize(value)
       @value = value
     end
+    def to_mom(method)
+      return Mom::StringConstant.new(@value)
+    end
     def ct_type
       Parfait.object_space.get_class_by_name(:Word).instance_type
     end

lib/vool/statements/ivar_statement.rb

@@ -18,7 +18,7 @@ module Vool
     end
 
     def to_mom( method )
-      @value.slot_class.new([:message , :self , @name] , @value)
+      @value.slot_class.new([:message , :self , @name] , @value.to_mom(method))
     end
 
   end

lib/vool/statements/local_statement.rb

@@ -12,7 +12,7 @@ module Vool
       else
         type = :frame
       end
-      @value.slot_class.new(Mom::SlotDefinition.new(:message , [type , @name]) , @value)
+      @value.slot_class.new(Mom::SlotDefinition.new(:message , [type , @name]) , @value.to_mom(method))
     end
   end
 

lib/vool/statements/return_statement.rb

@@ -11,11 +11,11 @@ module Vool
       super
     end
 
-    # To return form a method in mom instructions we need to do three things:
+    # To return form a method in mom instructions we need to do two things:
     # - store the given return value, this is a SlotMove / SlotConstant
     # - activate return sequence (reinstantiate old message and jump to return address)
     def to_mom( method )
-      move = @return_value.slot_class.new( [:message , :return_value] , @return_value)
+      move = @return_value.slot_class.new( [:message , :return_value] , @return_value.to_mom(method))
       Mom::Statements.new [move , Mom::ReturnSequence.new]
     end
 

lib/vool/statements/send_statement.rb

@@ -43,11 +43,11 @@ module Vool
 
     def message_setup(in_method)
       setup  = [Mom::MessageSetup.new(in_method)]
-      receiver = @receiver.slot_class.new([:message , :next_message , :receiver] , @receiver)
+      receiver = @receiver.slot_class.new([:message , :next_message , :receiver] , @receiver.to_mom(in_method))
       arg_target = [:message , :next_message , :arguments]
       args = []
       @arguments.each_with_index do |arg , index|
-        args << arg.slot_class.new( arg_target + [index] , arg)
+        args << arg.slot_class.new( arg_target + [index] , arg.to_mom(in_method))
       end
       setup << Mom::ArgumentTransfer.new( receiver , args )
     end

lib/vool/vool_compiler.rb

@@ -9,8 +9,8 @@ module Vool
       statements
     end
     def self.ruby_to_mom(source)
-      statements = elf.ruby_to_vool(source)
-      statements.to_mom
+      statements = self.ruby_to_vool(source)
+      statements.to_mom(nil)
     end
   end
 end