fold last of the virtual into register

lib/register/boot.rb

@@ -0,0 +1,166 @@
+module Register
+
+  # Booting is a complicated, so it is extracted into this file, even it has only one entry point
+
+  class Machine
+
+    # The general idea is that compiling is creating an object graph. Functionally
+    # one tends to think of methods, and that is complicated enough, sure.
+    # But for an object system the graph includes classes and all instance variables
+    #
+    # And so we have a chicken and egg problem. At the end of the boot function we want to have a
+    # working Space object
+    # But that has instance variables (List and Dictionary) and off course a class.
+    # Or more precisely in salama, a Layout, that points to a class.
+    # So we need a Layout, but that has Layout and Class too. hmmm
+    #
+    # The way out is to build empty shell objects and stuff the neccessary data into them
+    #  (not use the normal initialize way)
+    #  (PPS: The "real" solution is to read a sof graph and not do this by hand
+    #    That graph can be programatically built and written (with this to boot that process :-))
+
+    # There are some helpers below, but the roadmap is something like:
+    # - create all the layouts, with thier layouts, but no classes
+    # - create a space by "hand" , using allocate, not new
+    # - create the class objects and assign them to the layouts
+    def boot_parfait!
+      boot_layouts
+      boot_space
+      boot_classes
+
+      @space.late_init
+
+      #puts Sof.write(@space)
+      boot_functions!
+    end
+
+    # layouts is where the snake bites its tail. Every chain end at a layout and then it
+    # goes around (circular references). We create them from the list below and keep them
+    # in an instance variable (that is a smell, because after booting it is not needed)
+    def boot_layouts
+      @layouts = {}
+      layout_names.each do |name , ivars |
+        @layouts[name] = layout_for( name , ivars)
+      end
+      layout_layout = @layouts[:Layout]
+      @layouts.each do |name , layout |
+        layout.set_layout(layout_layout)
+      end
+    end
+
+    # once we have the layouts we can create the space by creating the instance variables
+    # by hand (can't call new yet as that uses the space)
+    def boot_space
+      space_dict = object_with_layout Parfait::Dictionary
+      space_dict.keys = object_with_layout Parfait::List
+      space_dict.values = object_with_layout Parfait::List
+
+      @space = object_with_layout Parfait::Space
+      @space.classes = space_dict
+      Parfait::Space.set_object_space @space
+    end
+
+    # when running code instantiates a class, a layout is created automatically
+    # but even to get our space up, we have already instantiated all layouts
+    # so we have to continue and allocate classes and fill the data by hand
+    # and off cource we can't use space.create_class , but still they need to go there
+    def boot_classes
+      classes = space.classes
+      layout_names.each do |name , vars|
+        cl = object_with_layout Parfait::Class
+        cl.object_layout = @layouts[name]
+        @layouts[name].object_class = cl
+        cl.instance_methods = object_with_layout Parfait::List
+#        puts "instance_methods is #{cl.instance_methods.class}"
+        cl.name = name
+        classes[name] = cl
+      end
+      object_class = classes[:Object]
+      # superclasses other than default object
+      supers = { :BinaryCode => :Word , :Layout => :List , :Class => :Module ,
+                 :Object => :Kernel , :Kernel => :Value, :Integer => :Value }
+      layout_names.each do |classname , ivar|
+        next if classname == :Value  # has no superclass
+        clazz = classes[classname]
+        super_name = supers[classname]
+        if super_name
+          clazz.set_super_class classes[super_name]
+        else
+          clazz.set_super_class object_class
+        end
+      end
+    end
+
+    # helper to create a Layout, name is the parfait name, ie :Layout
+    def layout_for( name , ivars )
+      l = Parfait::Layout.allocate.fake_init
+      l.add_instance_variable :layout
+      ivars.each {|n| l.add_instance_variable n }
+      l
+    end
+
+    # create an object with layout (ie allocate it and assign layout)
+    # meaning the lauouts have to be booted, @layouts filled
+    # here we pass the actual (ruby) class
+    def object_with_layout(cl)
+      o = cl.allocate.fake_init
+      name = cl.name.split("::").last.to_sym
+      o.set_layout @layouts[name]
+      o
+    end
+
+    # the function really just returns a constant (just avoiding the constant)
+    # unfortuantely that constant condenses every detail about the system, class names
+    # and all instance variable names. Really have to find a better way
+    def layout_names
+       {  :Word => [] ,
+          :List => [] ,
+          # Assumtion is that name is the last of message
+          :Message => [:next_message , :receiver , :frame , :return_address , :return_value,
+                        :caller , :name ],
+          :MetaClass => [],
+          :Integer => [],
+          :Object => [],
+          :Kernel => [], #fix, kernel is a class, but should be a module
+          :BinaryCode => [],
+          :Space => [:classes , :first_message ],
+          :Frame => [:next_frame ],
+          :Layout => [:object_class] ,
+          # TODO fix layouts for inherited classes. Currently only :Class and the
+          # instances are copied (shame on you)
+          :Class => [:object_layout , :name , :instance_methods , :super_class , :meta_class],
+          :Dictionary => [:keys , :values ] ,
+          :Method => [:name , :code ,:arguments , :for_class, :locals  ] ,
+          :Variable => [:type , :name , :value ] ,
+          :Module => [:name , :instance_methods , :super_class , :meta_class ]
+        }
+    end
+
+    # classes have booted, now create a minimal set of functions
+    # minimal means only that which can not be coded in ruby
+    # Methods are grabbed from respective modules by sending the method name. This should return the
+    # implementation of the method (ie a method object), not actually try to implement it
+    #                                                     (as that's impossible in ruby)
+    def boot_functions!
+      # very fiddly chicken 'n egg problem. Functions need to be in the right order, and in fact we
+      # 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 = @space.get_class_by_name(:Object)
+      [:main , :_get_instance_variable , :_set_instance_variable].each do |f|
+        obj.add_instance_method Builtin::Object.send(f , nil)
+      end
+      obj = @space.get_class_by_name(:Kernel)
+      # create __init__ main first, __init__ calls it
+      [:exit,:__send , :__init__ ].each do |f|
+        obj.add_instance_method Builtin::Kernel.send(f , nil)
+      end
+
+      @space.get_class_by_name(:Word).add_instance_method Builtin::Word.send(:putstring , nil)
+
+      obj = @space.get_class_by_name(:Integer)
+      [:putint,:fibo , :plus].each do |f|
+        obj.add_instance_method Builtin::Integer.send(f , nil)
+      end
+    end
+  end
+end