finish typing variables

lib/bosl/compiler/class_field.rb

@@ -2,12 +2,12 @@ module Bosl
   Compiler.class_eval do
 
     def on_class_field expression
-      puts expression.inspect
+      #puts expression.inspect
       type , name , value = *expression
 
       for_class = self.method.for_class
       index = for_class.object_layout.variable_index(name)
-      raise "class field already defined:#{name} for class #{for_class.name}" if index
+      #raise "class field already defined:#{name} for class #{for_class.name}" if index
       puts "Define field #{name} on class #{for_class.name}"
       index = for_class.object_layout.add_instance_variable( name ) #TODO need typing
 

lib/bosl/compiler/field_def.rb

@@ -2,16 +2,16 @@ module Bosl
   Compiler.class_eval do
 
     def on_field_def expression
-#      puts expression.inspect
+      #puts expression.inspect
       type , name , value = *expression
 
-      index = method.ensure_local( name )
+      index = method.ensure_local( name , type )
 
       if value
         value = process( value  )
       end
 
-      Virtual::Return.new( value )
+      Virtual::Return.new( type , value )
     end
   end
 end

lib/bosl/compiler/function_expression.rb

@@ -2,12 +2,12 @@ module Bosl
   Compiler.class_eval do
 #    function attr_reader  :name, :params, :body , :receiver
     def on_function  expression
-#      puts expression.inspect
+      #puts expression.inspect
       return_type , name , parameters, kids , receiver = *expression
       name =  name.to_a.first
       args = parameters.to_a.collect do |p|
         raise "error, argument must be a identifier, not #{p}" unless p.type == :parameter
-        Parfait::Variable.new( p.first , p[1])
+        Parfait::Variable.new( *p)
       end
 
       if receiver

lib/bosl/compiler/name_expression.rb

@@ -13,8 +13,12 @@ module Bosl
         if( index = method.has_arg(name))
           method.source.add_code Virtual::Set.new( Virtual::ArgSlot.new(index,:int ) , ret)
         else # or a local so it is in the frame
-          index = method.ensure_local( name )
-          method.source.add_code Virtual::Set.new(Virtual::FrameSlot.new(index,:int ) , ret )
+          index = method.has_local( name )
+          if(index)
+            method.source.add_code Virtual::Set.new(Virtual::FrameSlot.new(index,:int ) , ret )
+          else
+            raise "must define variable #{name} before using it"
+          end
         end
         return ret
       end

lib/bosl/compiler/operator_expressions.rb

@@ -10,8 +10,17 @@ module Bosl
       name , value = *expression
       name = name.to_a.first
       v = process(value)
-      index = method.ensure_local( name )
-      method.source.add_code Virtual::Set.new(Virtual::FrameSlot.new(:int,index ) , v )
+      index = method.has_local( name )
+      if(index)
+        method.source.add_code Virtual::Set.new(Virtual::FrameSlot.new(:int,index ) , v )
+      else
+        index = method.has_arg( name )
+        if(index)
+          method.source.add_code Virtual::Set.new(Virtual::ArgSlot.new(:int,index ) , v )
+        else
+          raise "must define variable #{name} before using it in #{@method.inspect}"
+        end
+      end
     end
 
   end

lib/parfait/method.rb

@@ -34,46 +34,48 @@ module Parfait
     attributes [:name , :arguments , :for_class , :code , :locals ]
 
 
-    # determine whether this method has a variable by the given name
-    # variables are locals and and arguments
-    # used to determine if a send must be issued
-    # return index of the name into the message if so
-    def has_var name
-      raise "has_var #{name}.#{name.class}" unless name.is_a? Symbol
-      index = has_arg(name)
-      return index if index
-      has_local(name)
-    end
-
     # determine whether this method has an argument by the name
     def has_arg name
       raise "has_arg #{name}.#{name.class}" unless name.is_a? Symbol
-      self.arguments.index_of name
+      max = self.arguments.get_length
+      counter = 1
+      while( counter <= max )
+        if( self.arguments.get(counter).name == name)
+          return counter
+        end
+        counter = counter + 1
+      end
+      return nil
     end
 
     # determine if method has a local variable or tmp (anonymous local) by given name
     def has_local name
       raise "has_local #{name}.#{name.class}" unless name.is_a? Symbol
-      index = self.locals.index_of(name)
-      index
+      max = self.locals.get_length
+      counter = 1
+      while( counter <= max )
+        if( self.locals.get(counter).name == name)
+          return counter
+        end
+        counter = counter + 1
+      end
+      return nil
     end
 
-    def ensure_local name
+    def ensure_local name , type
       index = has_local name
       return index if index
-      self.locals.push name
+      var = Variable.new( type , name)
+      self.locals.push var
       self.locals.get_length
     end
 
-    def get_var name
-      var = has_var name
-      raise "no var #{name} in method #{self.name} , #{self.locals} #{self.arguments}" unless var
-      var
-    end
-
     def sof_reference_name
       self.name
     end
 
+    def inspect
+      "#{self.for_class.name}:#{name}(#{arguments.inspect})"
+    end
   end
 end

lib/virtual/machine.rb

@@ -93,6 +93,7 @@ module Virtual
     # Objects are data and get assembled after functions
     def add_object o
       return false if @objects[o.object_id]
+      return if o.is_a? Fixnum
       raise "adding non parfait #{o.class}" unless o.is_a? Parfait::Object or o.is_a? Symbol
       @objects[o.object_id] = o
       true

test/compiler/test_basic.rb

@@ -34,8 +34,8 @@ class TestBasic < MiniTest::Test
     check
   end
 
-  def test_name
-    @string_input    = 'foo '
+  def test_var
+    @string_input    = 'int foo '
     @output = "- Virtual::Return(:type => :int)"
     check
   end

test/compiler/test_field_access.rb

@@ -5,7 +5,7 @@ module Virtual
   class TestFoo < MiniTest::Test
     include CodeChecker
 
-    def test_foo2
+    def test_foo3
       @string_input = <<HERE
 field int a
 int foo(int x)

test/fragments/test_recursive_fibo.rb

@@ -6,17 +6,18 @@ class TestRecursinveFibo < MiniTest::Test
   def test_recursive_fibo
     @string_input = <<HERE
 int fib_print(int n)
-  fib = fibonaccir( n )
+  int fib = fibonaccir( n )
   fib.putint()
 end
 int fibonaccir( int n )
   if( n <= 1 )
     return n
   else
-    int tmp = n - 1
-    a = fibonaccir( tmp )
+    int tmp
+    tmp = n - 1
+    int a = fibonaccir( tmp )
     tmp = n - 2
-    b = fibonaccir( tmp )
+    int b = fibonaccir( tmp )
     return a + b
   end
 end

test/parfait/test_all.rb

@@ -3,3 +3,4 @@ require_relative "test_object"
 require_relative "test_list"
 require_relative "test_word"
 require_relative "test_dictionary"
+require_relative "test_method"

test/parfait/test_method.rb

@@ -0,0 +1,23 @@
+require_relative "../helper"
+
+class TestMethod < MiniTest::Test
+
+  def setup
+    obj = Virtual.machine.boot.space.get_class_by_name(:Object)
+    args = Virtual.new_list [ Parfait::Variable.new(:int , :bar )]
+    @method = ::Parfait::Method.new obj , :foo , args
+  end
+
+  def test_method_name
+    assert_equal :foo , @method.name
+  end
+
+  def test_arg1
+    assert_equal 1 , @method.arguments.get_length
+    assert_equal Parfait::Variable , @method.arguments.first.class
+    assert_equal :bar , @method.arguments.first.name
+  end
+  def test_has_arg
+    assert_equal 1 , @method.has_arg(:bar) 
+  end
+end