move main to object (from kernel)

lib/parfait/space.rb

@@ -67,7 +67,7 @@ module Parfait
     end
 
     def get_main
-      kernel = get_class_by_name "Kernel"
+      kernel = get_class_by_name "Object"
       kernel.get_instance_method "main"
     end
 

lib/register/builtin/kernel.rb

@@ -1,25 +1,17 @@
 module Builtin
   module Kernel
     module ClassMethods
-      # main entry point, ie __init__ calls this
-      # defined here as empty, to be redefined
-      def main context
-        function = Virtual::CompiledMethodInfo.create_method("Kernel","main" , [])
-        function.info.return_type = Virtual::Integer
-        return function
-      end
       # this is the really really first place the machine starts.
       # it isn't really a function, ie it is jumped to (not called), exits and may not return
       # so it is responsible for initial setup (and relocation)
       def __init__ context
         function = Virtual::CompiledMethodInfo.create_method("Kernel","__init__" , [])
         function.info.return_type = Virtual::Integer
-        clazz = Virtual::Machine.instance.class_mappings["Kernel"]
-        method = clazz.resolve_method Virtual::new_word "main"
+        main = Virtual::Machine.instance.space.get_main
         me = Virtual::Self.new(Virtual::Reference)
         code = Virtual::Set.new(Virtual::Self.new(me.type), me)
         function.info.add_code(code)
-        function.info.add_code Virtual::MethodCall.new(method)
+        function.info.add_code Virtual::MethodCall.new(main)
         return function
       end
       def putstring context

lib/register/builtin/object.rb

@@ -2,20 +2,11 @@ module Builtin
   class Object
     module ClassMethods
 
-      # return the index of the variable. Now "normal" code can't really do anything with that, but
-      # set/get instance variable use it.
-      # This is just a placeholder, as we code this in ruby,
-      # but the instance methods need the definition before.
-      def index_of context , name = Virtual::Integer
-        index_function = Virtual::CompiledMethodInfo.create_method("Object" , "index_of" , [Virtual::Reference]  )
-        index_function.info.return_type = Virtual::Integer
-        return index_function
-      end
-
-      def self.layout
-        layout_function = Virtual::Function.new(:layout , [ ] , Virtual::Reference  , Virtual::Reference )
-        layout_function.at_index 2
-        layout_function
+      # main entry point, ie __init__ calls this
+      # defined here as empty, to be redefined
+      def main context
+        function = Virtual::CompiledMethodInfo.create_method("Object","main" , [])
+        return function
       end
 
       # in ruby, how this goes is

lib/virtual/boot.rb

@@ -86,12 +86,12 @@ module Virtual
       # have to define some dummies, just for the other to compile
       # TODO: go through the virtual parfait layer and adjust function names to what they really are
       obj = @class_mappings["Object"]
-      [:index_of , :_get_instance_variable , :_set_instance_variable].each do |f|
+      [:main , :_get_instance_variable , :_set_instance_variable].each do |f|
         obj.add_instance_method Builtin::Object.send(f , nil)
       end
       obj = @class_mappings["Kernel"]
       # create dummy main first, __init__ calls it
-      [:putstring,:exit,:__send , :main ].each do |f|
+      [:putstring,:exit,:__send  ].each do |f|
         obj.add_instance_method Builtin::Kernel.send(f , nil)
       end
       underscore_init = obj.add_instance_method Builtin::Kernel.send(:__init__, nil)

test/virtual/test_hello.rb

@@ -24,10 +24,7 @@ HERE
 
   def test_puts_string
     @string_input    = <<HERE
-def foo()
-  putstring("Hello")
-end
-foo()
+putstring("Hello")
 HERE
     check
   end