103 lines
3.2 KiB
Ruby
103 lines
3.2 KiB
Ruby
module Risc
|
|
|
|
class Builder
|
|
|
|
attr_reader :built
|
|
|
|
def initialize(compiler)
|
|
@compiler = compiler
|
|
@names = {}
|
|
end
|
|
|
|
def method_missing(*args)
|
|
super if args.length != 1
|
|
name = args[0]
|
|
return @names[name] if @names.has_key?(name)
|
|
if name == :message
|
|
reg = Risc.message_reg
|
|
else
|
|
type = Risc.resolve_type(name , @compiler) #checking
|
|
reg = @compiler.use_reg( type.object_class.name )
|
|
end
|
|
@names[name] = reg
|
|
reg.builder = self
|
|
reg
|
|
end
|
|
|
|
def build(&block)
|
|
instance_eval(&block)
|
|
return built
|
|
end
|
|
def add_instruction(ins)
|
|
if(@built)
|
|
@built << ins
|
|
else
|
|
@built = ins
|
|
end
|
|
end
|
|
end
|
|
|
|
def self.build(compiler, &block)
|
|
Builder.new(compiler).build( &block )
|
|
end
|
|
|
|
# if a symbol is given, it may be the message or the new_message.
|
|
# These are mapped to register references.
|
|
# The valid symbols (:message,:new_message) are the same that are returned
|
|
# by the slots. All data (at any time) is in one of the instance variables of these two
|
|
# objects. Risc defines module methods with the same names (and _reg)
|
|
def self.resolve_to_register( reference )
|
|
return reference if reference.is_a?(RiscValue)
|
|
case reference
|
|
when :message
|
|
return message_reg
|
|
when :new_message
|
|
return new_message_reg
|
|
else
|
|
raise "not recognized register reference #{reference} #{reference.class}"
|
|
end
|
|
end
|
|
|
|
# The first arg is a class name (possibly lowercase) and the second an instance variable name.
|
|
def self.resolve_type( object , compiler )
|
|
object = object.type if object.is_a?(RiscValue)
|
|
case object
|
|
when :name
|
|
type = Parfait.object_space.get_class_by_name( :Word ).instance_type
|
|
when :frame
|
|
type = compiler.method.frame_type
|
|
when :message , :next_message , :caller
|
|
type = Parfait.object_space.get_class_by_name(:Message).instance_type
|
|
when :arguments
|
|
type = compiler.method.arguments_type
|
|
when :receiver
|
|
type = compiler.method.for_type
|
|
when Parfait::Object
|
|
type = Parfait.object_space.get_class_by_name( object.class.name.split("::").last.to_sym).instance_type
|
|
when Symbol
|
|
object = object.camelize
|
|
clazz = Parfait.object_space.get_class_by_name(object)
|
|
raise "Not implemented/found object #{object}:#{object.class}" unless clazz
|
|
type = clazz.instance_type
|
|
else
|
|
raise "Not implemented/found object #{object}:#{object.class}"
|
|
end
|
|
return type
|
|
end
|
|
|
|
# The first arg is a class name (possibly lowercase) and the second an instance variable name.
|
|
# By looking up the class and the type for that class, we can resolve the instance
|
|
# variable name to an index.
|
|
# The class can be mapped to a register, and so we get a memory address (reg+index)
|
|
# Third arg, compiler, is only needed to resolve receiver/arguments/frame
|
|
def self.resolve_to_index(object , variable_name ,compiler = nil)
|
|
return variable_name if variable_name.is_a?(Integer) or variable_name.is_a?(RiscValue)
|
|
type = resolve_type(object , compiler)
|
|
index = type.variable_index(variable_name)
|
|
raise "Index not found for #{variable_name} in #{object} of type #{type}" unless index
|
|
return index
|
|
end
|
|
|
|
|
|
end
|