2015-07-18 13:33:09 +02:00
|
|
|
require 'parslet/convenience'
|
2015-10-18 18:27:02 +02:00
|
|
|
require_relative "collector"
|
2014-06-26 16:48:33 +02:00
|
|
|
module Virtual
|
2015-06-20 22:49:30 +02:00
|
|
|
# The Virtual Machine is a object based virtual machine in which ruby is implemented.
|
2014-06-25 15:00:24 +02:00
|
|
|
#
|
2014-06-25 01:33:44 +02:00
|
|
|
# It is minimal and realistic and low level
|
2015-05-30 11:20:39 +02:00
|
|
|
# - minimal means that if one thing can be implemented by another, it is left out. This is quite
|
|
|
|
# the opposite from ruby, which has several loops, many redundant if forms and the like.
|
|
|
|
# - realistic means it is easy to implement on a 32 bit machine (arm) and possibly 64 bit.
|
|
|
|
# Memory access,some registers of same size are the underlying hardware. (not ie byte machine)
|
|
|
|
# - low level means it's basic instructions are realively easily implemented in a register machine.
|
2015-06-20 22:49:30 +02:00
|
|
|
# Low level means low level in oo terms though, so basic instruction to implement oo
|
|
|
|
# #
|
|
|
|
# The ast is transformed to virtual-machine objects, some of which represent code, some data.
|
2014-06-25 01:33:44 +02:00
|
|
|
#
|
2015-06-20 22:49:30 +02:00
|
|
|
# The next step transforms to the register machine layer, which is quite close to what actually
|
|
|
|
# executes. The step after transforms to Arm, which creates executables.
|
2014-06-25 01:33:44 +02:00
|
|
|
#
|
2015-05-30 11:20:39 +02:00
|
|
|
# More concretely, a virtual machine is a sort of oo turing machine, it has a current instruction,
|
|
|
|
# executes the instructions, fetches the next one and so on.
|
2014-06-25 01:33:44 +02:00
|
|
|
# Off course the instructions are not soo simple, but in oo terms quite so.
|
2015-05-04 10:10:40 +02:00
|
|
|
#
|
|
|
|
# The machine is virtual in the sense that it is completely modeled in software,
|
2014-07-25 10:48:06 +02:00
|
|
|
# it's complete state explicitly available (not implicitly by walking stacks or something)
|
2014-06-25 15:00:24 +02:00
|
|
|
|
2015-06-20 22:49:30 +02:00
|
|
|
# The machine has a no register, but objects that represent it's state. There are four
|
|
|
|
# - message : the currently executing message (See Parfait::Message)
|
|
|
|
# - receiver : or self. This is actually an instance of Message, but "hoisted" out
|
|
|
|
# - frame : A pssible frame for temporary data. Also part of the message and "hoisted" out
|
|
|
|
# - next_message: A message object that the current activation wants to send.
|
2015-05-04 10:10:40 +02:00
|
|
|
#
|
2015-06-20 22:49:30 +02:00
|
|
|
# Messages form a linked list (not a stack) and the Space is responsible for storing
|
|
|
|
# and handing out empty messages
|
|
|
|
#
|
|
|
|
# The "machine" is not part of the run-time (Parfait)
|
|
|
|
|
2014-06-25 15:00:24 +02:00
|
|
|
class Machine
|
2015-10-18 18:27:02 +02:00
|
|
|
include Collector
|
2015-07-18 10:53:04 +02:00
|
|
|
|
2014-06-25 15:00:24 +02:00
|
|
|
def initialize
|
2014-07-30 20:07:48 +02:00
|
|
|
@parser = Parser::Salama.new
|
2015-10-18 18:27:02 +02:00
|
|
|
@passes = [ ]
|
2015-07-21 14:40:25 +02:00
|
|
|
@objects = {}
|
2015-06-01 07:40:17 +02:00
|
|
|
@booted = false
|
2014-06-25 15:00:24 +02:00
|
|
|
end
|
2015-07-02 10:09:23 +02:00
|
|
|
attr_reader :passes , :space , :class_mappings , :init , :objects , :booted
|
2015-05-12 14:36:44 +02:00
|
|
|
|
2015-06-12 17:52:06 +02:00
|
|
|
# run all passes before the pass given
|
|
|
|
# also collect the block to run the passes on and
|
|
|
|
# runs housekeeping Minimizer and Collector
|
|
|
|
# Has to be called before run_after
|
|
|
|
def run_before stop_at
|
|
|
|
@blocks = [@init]
|
|
|
|
@space.classes.values.each do |c|
|
|
|
|
c.instance_methods.each do |f|
|
2015-07-03 19:13:03 +02:00
|
|
|
nb = f.source.blocks
|
2015-06-12 17:52:06 +02:00
|
|
|
@blocks += nb
|
2015-05-12 14:36:44 +02:00
|
|
|
end
|
2015-06-12 17:52:06 +02:00
|
|
|
end
|
|
|
|
@passes.each do |pass_class|
|
2015-07-25 08:30:58 +02:00
|
|
|
#puts "running #{pass_class}"
|
2015-06-12 17:52:06 +02:00
|
|
|
run_blocks_for pass_class
|
|
|
|
return if stop_at == pass_class
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
# run all passes after the pass given
|
|
|
|
# run_before MUST be called first.
|
|
|
|
# the two are meant as a poor mans breakoint
|
|
|
|
def run_after start_at
|
|
|
|
run = false
|
|
|
|
@passes.each do |pass_class|
|
|
|
|
if run
|
2015-07-25 08:30:58 +02:00
|
|
|
#puts "running #{pass_class}"
|
2015-06-12 17:52:06 +02:00
|
|
|
run_blocks_for pass_class
|
|
|
|
else
|
|
|
|
run = true if start_at == pass_class
|
2015-05-12 14:36:44 +02:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2015-06-12 17:52:06 +02:00
|
|
|
# as before, run all passes that are registered
|
|
|
|
# (but now finer control with before/after versions)
|
|
|
|
def run_passes
|
2015-10-18 18:27:02 +02:00
|
|
|
return if @passes.empty?
|
|
|
|
run_before @passes.first
|
|
|
|
run_after @passes.first
|
2015-06-12 17:52:06 +02:00
|
|
|
end
|
|
|
|
|
2015-05-31 12:02:29 +02:00
|
|
|
# Objects are data and get assembled after functions
|
|
|
|
def add_object o
|
2015-07-21 14:40:25 +02:00
|
|
|
return false if @objects[o.object_id]
|
2015-09-27 15:06:48 +02:00
|
|
|
return if o.is_a? Fixnum
|
2015-07-21 18:41:30 +02:00
|
|
|
raise "adding non parfait #{o.class}" unless o.is_a? Parfait::Object or o.is_a? Symbol
|
2015-07-21 14:40:25 +02:00
|
|
|
@objects[o.object_id] = o
|
2015-05-31 12:02:29 +02:00
|
|
|
true
|
|
|
|
end
|
|
|
|
|
2015-05-12 14:36:44 +02:00
|
|
|
# Passes may be added to by anyone who wants
|
|
|
|
# This is intentionally quite flexible, though one sometimes has to watch the order of them
|
|
|
|
# most ordering is achieved by ordering the requires and using add_pass
|
|
|
|
# but more precise control is possible with the _after and _before versions
|
|
|
|
|
|
|
|
def add_pass pass
|
|
|
|
@passes << pass
|
|
|
|
end
|
|
|
|
def add_pass_after( pass , after)
|
|
|
|
index = @passes.index(after)
|
|
|
|
raise "No such pass (#{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
|
2014-07-01 17:58:25 +02:00
|
|
|
|
2015-06-12 17:52:06 +02:00
|
|
|
def boot
|
|
|
|
boot_parfait!
|
2015-07-28 15:18:32 +02:00
|
|
|
@init = Block.new("init", :__init__ )
|
2015-10-19 15:08:00 +02:00
|
|
|
branch = Register::Branch.new( "__init__" , self.space.get_init.source.blocks.first )
|
2015-10-10 10:14:31 +02:00
|
|
|
@init.add_code branch
|
2015-06-12 17:52:06 +02:00
|
|
|
@booted = true
|
2015-07-18 10:53:04 +02:00
|
|
|
self
|
2015-06-12 17:52:06 +02:00
|
|
|
end
|
|
|
|
|
2015-10-05 23:27:13 +02:00
|
|
|
def parse_and_compile bytes
|
2014-07-30 20:43:12 +02:00
|
|
|
syntax = @parser.parse_with_debug(bytes)
|
|
|
|
parts = Parser::Transform.new.apply(syntax)
|
2015-09-27 21:39:10 +02:00
|
|
|
#puts parts.inspect
|
2015-10-07 14:22:47 +02:00
|
|
|
Phisol::Compiler.compile( parts )
|
2014-07-30 20:07:48 +02:00
|
|
|
end
|
2015-06-12 17:52:06 +02:00
|
|
|
|
|
|
|
private
|
|
|
|
def run_blocks_for pass_class
|
2015-07-17 10:39:20 +02:00
|
|
|
parts = pass_class.split("::")
|
|
|
|
pass = Object.const_get(parts[0]).const_get parts[1]
|
2015-06-12 17:52:06 +02:00
|
|
|
raise "no such pass-class as #{pass_class}" unless pass
|
|
|
|
@blocks.each do |block|
|
|
|
|
raise "nil block " unless block
|
|
|
|
pass.new.run(block)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2014-06-25 01:33:44 +02:00
|
|
|
end
|
2015-06-01 07:40:17 +02:00
|
|
|
|
2015-06-12 17:52:06 +02:00
|
|
|
# Module function to retrieve singleton
|
2015-06-01 07:40:17 +02:00
|
|
|
def self.machine
|
|
|
|
unless defined?(@machine)
|
|
|
|
@machine = Machine.new
|
|
|
|
end
|
|
|
|
@machine
|
|
|
|
end
|
2015-06-12 17:52:06 +02:00
|
|
|
|
2015-05-08 14:10:30 +02:00
|
|
|
end
|
2015-05-19 19:29:33 +02:00
|
|
|
|
2015-07-18 15:12:50 +02:00
|
|
|
Parfait::Method.class_eval do
|
|
|
|
# for testing we need to reuse the main function (or do we?)
|
|
|
|
# so remove the code that is there
|
|
|
|
def clear_source
|
|
|
|
self.source.send :initialize , self
|
|
|
|
end
|
|
|
|
|
|
|
|
end
|
|
|
|
|
2015-05-19 19:29:33 +02:00
|
|
|
require_relative "boot"
|