move type to phial and add type to reg_ref

lib/phisol/compiler.rb

@@ -29,11 +29,11 @@ module Phisol
     end
 
     # require a (temporary) register. code must give this back with release_reg
-    def use_reg
+    def use_reg type
       if @regs.empty?
-        reg = Register.tmp_reg
+        reg = Register.tmp_reg type
       else
-        reg = @regs.last.next_reg_use
+        reg = @regs.last.next_reg_use type
       end
       @regs << reg
       return reg
@@ -46,6 +46,7 @@ module Phisol
   end
 end
 
+require_relative "type"
 require_relative "ast_helper"
 require_relative "compiler/basic_values"
 require_relative "compiler/call_site"

lib/phisol/compiler/basic_values.rb

@@ -13,25 +13,26 @@ module Phisol
 
     def on_int statement
       int = statement.first
-      to =  Virtual::Return.new(Virtual::Integer , int)
+#      reg =
+      to =  Virtual::Return.new(Phisol::Integer , int)
       @method.source.add_code Virtual::Set.new( int , to )
       to
     end
 
     def on_true statement
-      to = Virtual::Return.new(Virtual::Reference , true )
+      to = Virtual::Return.new(Phisol::Reference , true )
       @method.source.add_code Virtual::Set.new( true , to )
       to
     end
 
     def on_false statement
-      to = Virtual::Return.new(Virtual::Reference , false)
+      to = Virtual::Return.new(Phisol::Reference , false)
       @method.source.add_code Virtual::Set.new( false , to )
       to
     end
 
     def on_nil statement
-      to = Virtual::Return.new(Virtual::Reference , nil)
+      to = Virtual::Return.new(Phisol::Reference , nil)
       @method.source.add_code Virtual::Set.new( nil , to )
       to
     end
@@ -39,7 +40,7 @@ module Phisol
     def on_string statement
       # Clearly a TODO here to implement strings rather than reusing symbols
       value = statement.first.to_sym
-      to = Virtual::Return.new(Virtual::Reference , value)
+      to = Virtual::Return.new(Phisol::Reference , value)
       @method.source.constants << value
       @method.source.add_code Virtual::Set.new( value , to )
       to

lib/phisol/compiler/name_expression.rb

@@ -7,7 +7,7 @@ module Phisol
       # whichever way this goes the result is stored in the return slot (as all compiles)
       def on_name statement
         name = statement.to_a.first
-        return Virtual::Self.new( Virtual::Reference.new(@clazz)) if name == :self
+        return Virtual::Self.new( Phisol::Reference.new(@clazz)) if name == :self
         # either an argument, so it's stored in message
         if( index = @method.has_arg(name))
           type = @method.arguments[index].type

lib/phisol/compiler/operator_value.rb

@@ -8,8 +8,8 @@ module Phisol
       right_slot = process(right_e)
       puts "left #{left_slot}"
       puts "right #{right_slot}"
-      tmp1 = use_reg
-      tmp2 = use_reg
+      tmp1 = use_reg :int
+      tmp2 = use_reg :int
       get = Register.get_slot_to(statement , left_slot , tmp1 )
       get2 = Register.get_slot_to(statement , right_slot , tmp2 )
       puts "GET #{get}"

lib/phisol/type.rb

@@ -0,0 +1,44 @@
+
+module Phisol
+  # Integer and (Object) References are the main derived classes, but float will come.
+
+  class Type
+    def == other
+      return false unless other.class == self.class
+      return true
+    end
+
+    # map from a type sym (currently :int/:ref) to a class of subtype of Type
+    # TODO needs to be made extensible in a defined way.
+    def self.from_sym type
+      return type if type.is_a? Type
+      case type
+      when :int
+        self.int
+      when :ref
+        self.ref
+      else
+        raise "No type maps to:#{type} (#{type.class})"
+      end
+    end
+
+    def self.int
+      return Integer.new
+    end
+    def self.ref
+      return Reference.new
+    end
+  end
+
+  class Integer < Type
+  end
+
+  class Reference < Type
+    # possibly unknown value, but known class (as in methods)
+    def initialize clazz = nil
+      @of_class = clazz
+    end
+    attr_reader :of_class
+  end
+
+end