rename

lib/ast/basic_expressions.rb

@@ -5,7 +5,7 @@ module Ast
   class IntegerExpression < Expression
 #    attr_reader :value
     def compile context
-      Vm::IntegerConstant.new value
+      Virtual::IntegerConstant.new value
     end
   end
 
@@ -34,7 +34,7 @@ module Ast
   class StringExpression < Expression
 #    attr_reader  :string
     def compile context
-      value = Vm::StringConstant.new(string)
+      value = Virtual::StringConstant.new(string)
       context.object_space.add_object value 
       value
     end

lib/ast/call_site_expression.rb

@@ -20,7 +20,7 @@ module Ast
       elsif receiver.is_a?(NameExpression) 
         if(receiver.name == :self)
           function = context.current_class.resolve_function(name)
-          value_receiver = Vm::Integer.new(Vm::RegisterMachine.instance.receiver_register)
+          value_receiver = Virtual::Integer.new(Virtual::RegisterMachine.instance.receiver_register)
         else
           value_receiver = receiver.compile(context)
           # TODO HACK warning: should determine class dynamically
@@ -35,7 +35,7 @@ module Ast
       end
       raise "No such method error #{inspect}" if (function.nil?)
       raise "No receiver error #{inspect}:#{receiver}" if (value_receiver.nil?)
-      call = Vm::CallSite.new( name ,  value_receiver , params  , function)
+      call = Virtual::CallSite.new( name ,  value_receiver , params  , function)
       current_function = context.function
       into.push([])  unless current_function.nil?
       call.load_args into

lib/ast/expression_list.rb

@@ -0,0 +1,10 @@
+module Ast
+  class ExpressionList < Expression
+#    attr_reader  :expressions
+    def compile binding
+      expressions.each do |part|
+        expr    = part.compile( binding )
+      end
+    end
+  end
+end

lib/ast/function_expression.rb

@@ -6,13 +6,13 @@ module Ast
       locals = {}
       params.each_with_index do |param , index|
         arg = param.name
-        register = Vm::RegisterReference.new(Vm::RegisterMachine.instance.receiver_register).next_reg_use(index + 1)
-        arg_value = Vm::Integer.new(register)
+        register = Virtual::RegisterReference.new(Virtual::RegisterMachine.instance.receiver_register).next_reg_use(index + 1)
+        arg_value = Virtual::Integer.new(register)
         locals[arg] = arg_value
         args << arg_value
       end
       # class depends on receiver
-      me = Vm::Integer.new( Vm::RegisterMachine.instance.receiver_register )
+      me = Virtual::Integer.new( Virtual::RegisterMachine.instance.receiver_register )
       if receiver.nil? 
         clazz = context.current_class
       else
@@ -20,7 +20,7 @@ module Ast
         clazz = c.meta_class
       end
 
-      function = Vm::Function.new(name , me , args )
+      function = Virtual::Function.new(name , me , args )
       clazz.add_function function 
 
       parent_locals = context.locals
@@ -32,11 +32,11 @@ module Ast
       body.each do |b|
         puts "compiling in function #{b}"
         last_compiled = b.compile(context)
-        raise "alarm #{last_compiled} \n #{b}" unless last_compiled.is_a? Vm::Word
+        raise "alarm #{last_compiled} \n #{b}" unless last_compiled.is_a? Virtual::Word
       end
       
-      return_reg = Vm::Integer.new(Vm::RegisterMachine.instance.return_register)
-      if last_compiled.is_a?(Vm::IntegerConstant) or last_compiled.is_a?(Vm::ObjectConstant)
+      return_reg = Virtual::Integer.new(Virtual::RegisterMachine.instance.return_register)
+      if last_compiled.is_a?(Virtual::IntegerConstant) or last_compiled.is_a?(Virtual::ObjectConstant)
         return_reg.load function , last_compiled if last_compiled.register_symbol != return_reg.register_symbol
       else
         return_reg.move( function, last_compiled ) if last_compiled.register_symbol != return_reg.register_symbol

lib/ast/if_expression.rb

@@ -11,7 +11,7 @@ module Ast
 
       puts "compiling if condition #{cond}"
       cond_val = cond.compile(context)
-      unless cond_val.is_a? Vm::BranchCondition
+      unless cond_val.is_a? Virtual::BranchCondition
         cond_val = cond_val.is_true? f
       end
       f.b true_block , condition_code: cond_val.operator

lib/ast/return_expression.rb

@@ -7,8 +7,8 @@ module Ast
       expression_value = expression.compile(context)
       # copied from function expression: TODO make function
 
-      return_reg = Vm::Integer.new(Vm::RegisterMachine.instance.return_register)
-      if expression_value.is_a?(Vm::IntegerConstant) or expression_value.is_a?(Vm::ObjectConstant)
+      return_reg = Virtual::Integer.new(Virtual::RegisterMachine.instance.return_register)
+      if expression_value.is_a?(Virtual::IntegerConstant) or expression_value.is_a?(Virtual::ObjectConstant)
         return_reg.load into , expression_value 
       else
         return_reg.move( into, expression_value ) if expression_value.register_symbol != return_reg.register_symbol