rubyx/lib/risc/parfait_boot.rb
Torsten Ruger 114dc95b60 move parfait boot into parfait
and out of risc
2018-06-29 14:36:11 +03:00

160 lines
5.9 KiB
Ruby

module Boot
# Booting is complicated, so it is extracted into this file, even it has only one entry point
# a ruby object as a placeholder for the parfait Space during boot
class Space
attr_reader :classes
def initialize
@classes = {}
end
def get_class_by_name(name)
cl = @classes[name]
raise "No class for #{name}" unless cl
cl
end
end
# another ruby object to shadow the parfait, just during booting.
# all it needs is the type, which we make the Parfait type
class Class
attr_reader :instance_type
def initialize( type)
@instance_type = type
end
end
end
module Parfait
# 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 rubyx, a Type, that points to a class.
# So we need a Type, but that has Type 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 rx-file 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 Type instances, with their basic types, but no classes
# - create a BootSpace that has BootClasses , used only during booting
# - create the Class objects and assign them to the types
# - flesh out the types , create the real space
# - and finally load the methods
def self.boot!
Parfait.set_object_space( nil )
types = boot_types
boot_boot_space( types )
classes = boot_classes( types )
fix_types( types , classes )
space = Space.new( classes )
Parfait.set_object_space( space )
end
# types is where the snake bites its tail. Every chain ends at a type and then it
# goes around (circular references). We create them from the list below, just as empty
# shells, that we pass back, for the BootSpace to be created
def self.boot_types
types = {}
type_names.each do |name , ivars |
types[name] = Type.allocate
end
type_type = types[:Type]
types.each do |name , type |
type.set_type(type_type)
end
types
end
# The BootSpace is an object that holds fake classes, that hold _real_ types
# Once we plug it in we can use .new
# then we need to create the parfait classes and fix the types before creating a Space
def self.boot_boot_space(types)
boot_space = Boot::Space.new
types.each do |name , type|
clazz = Boot::Class.new(type)
boot_space.classes[name] = clazz
end
Parfait.set_object_space( boot_space )
end
# when running code instantiates a class, a type is created automatically
# but even to get our space up, we have already instantiated all types
# 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 self.boot_classes(types)
classes = Dictionary.new
type_names.each do |name , vars|
super_c = super_class_names[name] || :Object
clazz = Class.new(name , super_c , types[name] )
classes[name] = clazz
end
classes
end
# Types are hollow shells before this, so we need to set the object_class
# and initialize the list variables (which we now can with .new)
def self.fix_types(types , classes)
type_names.each do |name , ivars |
type = types[name]
clazz = classes[name]
type.set_object_class( clazz )
type.init_lists({type: :Type }.merge(ivars))
end
end
# superclasses other than default object
def self.super_class_names
{ Data4: :DataObject , Data8: :DataObject ,Data16: :DataObject ,
BinaryCode: :Data16 , Integer: :Data4 , Word: :Data8 ,
Object: :BasicObject , List: :Data16 , ReturnAddress: :Integer}
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 self.type_names
{ Word: {char_length: :Integer} ,
List: {indexed_length: :Integer} ,
Message: { next_message: :Message, receiver: :Object, frame: :NamedList ,
return_address: :Integer, return_value: :Object,
caller: :Message , name: :Word , arguments: :NamedList },
Integer: {next_integer: :Integer},
ReturnAddress: {next_integer: :Integer},
DataObject: {},
Data4: {},
Data8: {},
TrueClass: {},
FalseClass: {},
NilClass: {},
Object: {},
BinaryCode: {next: :BinaryCode} ,
Space: {classes: :Dictionary , types: :Dictionary ,
first_message: :Message , next_integer: :Integer ,
true_object: :TrueClass,
false_object: :FalseClass , nil_object: :NilClass},
NamedList: {},
Type: {names: :List , types: :List ,
object_class: :Class, methods: :TypedMethod } ,
Class: {instance_methods: :List, instance_type: :Type, name: :Word,
super_class_name: :Word , instance_names: :List },
Dictionary: {keys: :List , values: :List } ,
CacheEntry: {cached_type: :Type , cached_method: :TypedMethod } ,
TypedMethod: {name: :Word, risc_instructions: :Object,
cpu_instructions: :Object, binary: :BinaryCode,
arguments_type: :Type , for_type: :Type, frame_type: :Type ,
next_method: :TypedMethod} ,
}
end
end