81 lines
2.3 KiB
Ruby
81 lines
2.3 KiB
Ruby
require "parser/current"
|
|
require "ast"
|
|
|
|
module SlotLanguage
|
|
class SlotCompiler < AST::Processor
|
|
|
|
def self.compile(input)
|
|
ast = Parser::CurrentRuby.parse( input )
|
|
self.new.process(ast)
|
|
end
|
|
def not_implemented(node)
|
|
raise "Not implemented #{node.type}"
|
|
end
|
|
# default to error, so non implemented stuff shows early
|
|
def handler_missing(node)
|
|
not_implemented(node)
|
|
end
|
|
def on_send(statement)
|
|
#puts "Send #{statement}"
|
|
kids = statement.children.dup
|
|
receiver = process(kids.shift) || MessageSlot.new
|
|
name = kids.shift
|
|
return label(name) if(name.to_s.end_with?("_label"))
|
|
return goto(name,kids) if(name == :goto)
|
|
return check(name,receiver, kids) if(name == :==)
|
|
return assign(receiver, name , kids) if(name.to_s.end_with?("="))
|
|
SlotMaker.new( name , receiver )
|
|
end
|
|
def on_lvar(lvar)
|
|
SlotMaker.new(lvar.children.first , nil)
|
|
end
|
|
def on_lvasgn expression
|
|
name = expression.children[0]
|
|
value = process(expression.children[1])
|
|
LoadMaker.new(SlotMaker.new(name,nil),value)
|
|
end
|
|
def on_if(expression)
|
|
condition = process(expression.children[0])
|
|
condition.set_goto( process(expression.children[1]) )
|
|
condition
|
|
end
|
|
def on_begin(exp)
|
|
process(exp.first)
|
|
end
|
|
def on_ivar expression
|
|
SlotMaker.new(instance_name(expression.children.first),nil)
|
|
end
|
|
|
|
private
|
|
def instance_name(sym)
|
|
sym.to_s[1 .. -1].to_sym
|
|
end
|
|
def label(name)
|
|
SlotMachine::Label.new(name.to_s , name)
|
|
end
|
|
def goto(name , args)
|
|
# error handling would not hurt
|
|
label = process(args.first)
|
|
SlotMachine::Jump.new( label )
|
|
end
|
|
def check(name , receiver , kids)
|
|
raise "Only ==, not #{name}" unless name == :==
|
|
raise "Familiy too large #{kids}" if kids.length > 1
|
|
#puts "Kids " + kids.to_s
|
|
right = process(kids.first)
|
|
CheckMaker.new(name , receiver , right)
|
|
end
|
|
def assign(receiver , name , kids)
|
|
name = name.to_s[0...-1].to_sym
|
|
receiver.add_slot_name(name)
|
|
right = process kids.first
|
|
LoadMaker.new(receiver,right)
|
|
end
|
|
end
|
|
end
|
|
require_relative "named_slot"
|
|
require_relative "message_slot"
|
|
require_relative "slot_maker"
|
|
require_relative "load_maker"
|
|
require_relative "check_maker"
|