108 lines
3.5 KiB
Ruby
108 lines
3.5 KiB
Ruby
require_relative "object"
|
|
|
|
module Virtual
|
|
|
|
# Instruction is an abstract for all the code of the object-machine.
|
|
# Derived classes make up the actual functionality of the machine.
|
|
# All functions on the machine are captured as instances of instructions
|
|
#
|
|
# It is actually the point of the virtual machine layer to express oo functionality in the set of instructions,
|
|
# thus defining a minimal set of instructions needed to implement oo.
|
|
|
|
# This is partly because jumping over this layer and doing in straight in assember was too big a step
|
|
class Instruction < Virtual::Object
|
|
|
|
# simple thought: don't recurse for Blocks, just check their names
|
|
def == other
|
|
return false unless other.class == self.class
|
|
Sof::Util.attributes(self).each do |a|
|
|
begin
|
|
left = send(a)
|
|
rescue NoMethodError
|
|
next # not using instance variables that are not defined as attr_readers for equality
|
|
end
|
|
begin
|
|
right = other.send(a)
|
|
rescue NoMethodError
|
|
return false
|
|
end
|
|
return false unless left.class == right.class
|
|
if( left.is_a? Block)
|
|
return false unless left.name == right.name
|
|
else
|
|
return false unless left == right
|
|
end
|
|
end
|
|
return true
|
|
end
|
|
end
|
|
|
|
# the first instruction we need is to stop. Off course in a real machine this would be a syscall, but that is just
|
|
# an implementation (in a programm it would be a function). But in a virtual machine, not only do we need this instruction,
|
|
# it is indeed the first instruction as just this instruction is the smallest possible programm for the machine.
|
|
# As such it is the next instruction for any first instruction that we generate.
|
|
class Halt < Instruction
|
|
end
|
|
|
|
# following classes are stubs. currently in brainstorming mode, so anything may change anytime
|
|
class MethodEnter < Instruction
|
|
end
|
|
class MethodReturn < Instruction
|
|
end
|
|
|
|
# a branch must branch to a block. This is an abstract class, names indicate the actual test
|
|
class Branch < Instruction
|
|
def initialize to
|
|
@to = to
|
|
end
|
|
attr_reader :to
|
|
end
|
|
|
|
# implicit means there is no explcit test involved.
|
|
# normal ruby rules are false and nil are false, EVERYTHING else is true (and that includes 0)
|
|
class ImplicitBranch < Branch
|
|
end
|
|
|
|
class UnconditionalBranch < Branch
|
|
end
|
|
|
|
class MessageSend < Instruction
|
|
def initialize name , me , args = []
|
|
@name = name.to_sym
|
|
@me = me
|
|
@args = args
|
|
end
|
|
attr_reader :name , :me , :args
|
|
end
|
|
|
|
class FunctionCall < Instruction
|
|
def initialize method
|
|
@method = method
|
|
end
|
|
attr_reader :method
|
|
end
|
|
|
|
# class for Set instructions, A set is basically a mem move.
|
|
# to and from are indexes into the known objects(frame,message,self and new_message), these are represented as slots
|
|
# (see there)
|
|
# from may be a Constant (Object,Integer,String,Class)
|
|
class Set < Instruction
|
|
def initialize to , from
|
|
@to = to
|
|
# hard to find afterwards where it came from, so ensure it doesn't happen
|
|
raise "From must be slot or constant, not symbol #{from}" if from.is_a? Symbol
|
|
@from = from
|
|
end
|
|
attr_reader :to , :from
|
|
end
|
|
|
|
# Get a instance variable by _name_ . So we have to resolve the name to an index to trnsform into a Slot
|
|
# The slot may the be used in a set on left or right hand. The transformation is done by GetImplementation
|
|
class InstanceGet < Instruction
|
|
def initialize name
|
|
@name = name.to_sym
|
|
end
|
|
attr_reader :name
|
|
end
|
|
end
|