reditribute boot dir evenly. some was parfait, some virtual, some kernel

lib/virtual/boot_space.rb

@@ -0,0 +1,133 @@
+require "parfait/boot_class"
+require "kernel/all"
+
+module Virtual
+  # The BootSpace contains all objects for a program. In functional terms it is a program, but in oo
+  # it is a collection of objects, some of which are data, some classes, some functions
+
+  # The main entry is a function called (of all things) "main", This _must be supplied by the compling
+  # There is a start and exit block that call main, which receives an array of strings
+
+  # While data ususally would live in a .data section, we may also "inline" it into the code
+  # in an oo system all data is represented as objects
+   
+  class BootSpace
+    
+    # Initialize with a string for cpu. Naming conventions are: for Machine XXX there exists a module XXX
+    #  with a XXXMachine in it that derives from Virtual::RegisterMachine
+    def initialize machine = nil
+      super()
+      @classes = {}
+      @main = Virtual::MethodDefinition.new("main" , [] )
+      #global objects (data)
+      @objects = []
+      boot_classes
+      @passes = [ Virtual::SendImplementation ]
+    end
+    attr_reader  :main , :classes , :objects
+
+    def run_passes
+      @passes.each do |pass|
+        puts "Runnning pass #{pass}"
+        all = main.blocks
+        @classes.each_value do |c| 
+          c.instance_methods.each {|f| all += f.blocks  }
+        end
+        all.each do |block|
+          pass.new.run(block)
+        end
+      end
+    end
+
+    # Passes are initiated empty and added to by anyone who want (basically)
+    # Even linking and assembly are passes and so there are quite a few system passes neccesary to result in a 
+    # working binary. Other than that, this is intentionally quite flexible
+    
+    def add_pass_after( pass , after)
+      index = @passes.index(after)
+      raise "No such pass to add after: #{after}" unless index
+      @passes.insert(index+1 , pass)
+    end
+    def add_pass_before( pass , after)
+      index = @passes.index(after)
+      raise "No such pass to add after: #{after}" unless index
+      @passes.insert(index , pass)
+    end
+    # boot the classes, ie create a minimal set of classes with a minimal set of functions
+    # minimal means only that which can not be coded in ruby
+    # MethodDefinitions 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_classes
+      # 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
+      obj = get_or_create_class :Object
+      [:index_of , :_get_instance_variable , :_set_instance_variable].each do |f|
+        #puts "Boot Object::#{f}"
+        obj.add_instance_method Salama::Object.send(f , @context)
+      end
+      [:putstring,:putint,:fibo,:exit].each do |f|
+        #puts "Boot Kernel::#{f}"
+        obj.add_instance_method Salama::Kernel.send(f , @context)
+      end
+      obj = get_or_create_class :String
+      [:get , :set , :puts].each do |f|
+        #puts "Boot String::#{f}"
+        obj.add_instance_method Salama::String.send(f , @context)
+      end
+    end
+
+    # Objects are data and get assembled after functions
+    def add_object o
+      return if @objects.include? o
+#      raise "must be derived from Code #{o.inspect}" unless o.is_a? Virtual::Code
+      @objects << o # TODO check type , no basic values allowed (must be wrapped)
+    end
+
+    # this is the way to instantiate classes (not BootClass.new)
+    # so we get and keep exactly one per name
+    def get_or_create_class name
+      raise "uups #{name}.#{name.class}" unless name.is_a? Symbol
+      c = @classes[name]
+      unless c
+        c = BootClass.new(name)
+        @classes[name] = c
+      end
+      c
+    end
+
+    # linking entry , exit , main , classes , objects
+    def link_at( start , context)
+      super
+      @entry.link_at( start , context )
+      start += @entry.length
+      @exit.link_at( start , context)
+      start += @exit.length
+      @main.link_at( start , context )
+      start += @main.length
+      @classes.values.each do |clazz|
+        clazz.link_at(start , context)
+        start += clazz.length
+      end
+      @objects.each do |o|
+        o.link_at(start , context)
+        start += o.length
+      end
+    end
+
+    # assemble in the same order as linked
+    def assemble( io )
+      link_at( @position , nil) #second link in case of forward declarations
+      @entry.assemble( io )
+      @exit.assemble( io )
+      @main.assemble( io )
+      @classes.values.each do |clazz|
+        clazz.assemble(io)
+      end
+      @objects.each do |o|
+        o.assemble(io)
+      end
+      io
+    end
+
+  end
+end