diff --git a/.document b/.document deleted file mode 100644 index 3d618dd8..00000000 --- a/.document +++ /dev/null @@ -1,5 +0,0 @@ -lib/**/*.rb -bin/* -- -features/**/*.feature -LICENSE.txt diff --git a/lib/arm/arm_machine.rb b/lib/arm/arm_machine.rb index f3d69a91..91559834 100644 --- a/lib/arm/arm_machine.rb +++ b/lib/arm/arm_machine.rb @@ -1,24 +1,24 @@ require_relative "instruction" module Arm - - # A Machines main responsibility in the framework is to instantiate Instruction + + # A Machines main responsibility in the framework is to instantiate Instructions # Value functions are mapped to machines by concatenating the values class name + the methd name # Example: IntegerValue.plus( value ) -> Machine.signed_plus (value ) - + # Also, shortcuts are created to easily instantiate Instruction objects. # Example: pop -> StackInstruction.new( {:opcode => :pop}.merge(options) ) # Instructions work with options, so you can pass anything in, and the only thing the functions does # is save you typing the clazz.new. It passes the function name as the :opcode - + class ArmMachine - + # conditions specify all the possibilities for branches. Branches are b + condition - # Example: beq means brach if equal. + # Example: beq means brach if equal. # :al means always, so bal is an unconditional branch (but b() also works) CONDITIONS = [ :al , :eq , :ne , :lt , :le, :ge, :gt , :cs , :mi , :hi , :cc , :pl, :ls , :vc , :vs ] - + # here we create the shortcuts for the "standard" instructions, see above # Derived machines may use own instructions and define functions for them if so desired def self.init @@ -40,7 +40,7 @@ module Arm [:b, :call , :swi].each do |inst| define_instruction_one(inst , CallInstruction) end - # create all possible brach instructions, but the CallInstruction demangles the + # create all possible brach instructions, but the CallInstruction demangles the # code, and has opcode set to :b and :condition_code set to the condition CONDITIONS.each do |suffix| define_instruction_one("b#{suffix}".to_sym , CallInstruction) @@ -53,7 +53,6 @@ module Arm end def self.class_for clazz - c_name = clazz.name my_module = self.class.name.split("::").first clazz_name = clazz.name.split("::").last if(my_module != Register ) @@ -65,13 +64,13 @@ module Arm #defining the instruction (opcode, symbol) as an given class. # the class is a Register::Instruction derived base class and to create machine specific function - # an actual machine must create derived classes (from this base class) + # an actual machine must create derived classes (from this base class) # These instruction classes must follow a naming pattern and take a hash in the contructor # Example, a mov() opcode instantiates a Register::MoveInstruction # for an Arm machine, a class Arm::MoveInstruction < Register::MoveInstruction exists, and it will - # be used to define the mov on an arm machine. - # This methods picks up that derived class and calls a define_instruction methods that can - # be overriden in subclasses + # be used to define the mov on an arm machine. + # This methods picks up that derived class and calls a define_instruction methods that can + # be overriden in subclasses def self.define_instruction_one(inst , clazz , defaults = {} ) clazz = class_for(clazz) create_method(inst) do |first , options = nil| diff --git a/lib/compiler.rb b/lib/compiler.rb index 109ed501..ce186997 100644 --- a/lib/compiler.rb +++ b/lib/compiler.rb @@ -1,9 +1,9 @@ module Compiler def self.compile expression , method , message - exp_name = expression.class.split("::").last.sub("Expression","").downcase + exp_name = expression.class.name.split("::").last.sub("Expression","").downcase puts "Expression #{exp_name}" - self.send exp_name.to_sym , method , message + self.send "compile_#{exp_name}".to_sym , expression, method , message end end diff --git a/lib/compiler/basic_expressions.rb b/lib/compiler/basic_expressions.rb index 303bdc45..c5ed1a7a 100644 --- a/lib/compiler/basic_expressions.rb +++ b/lib/compiler/basic_expressions.rb @@ -11,28 +11,28 @@ module Compiler # But in the future (in the one that holds great things) we optimize those unneccesay moves away # attr_reader :value - def compile_integer expession , method , message + def self.compile_integer expession , method , message int = Virtual::IntegerConstant.new(value) to = Virtual::NewReturn.new(Virtual::Integer , int) method.add_code Virtual::Set.new( to , int) to end - def compile_true expession , method , message + def self.compile_true expession , method , message value = Virtual::TrueConstant.new to = Virtual::Return.new(Virtual::Reference , value) method.add_code Virtual::Set.new( to , value ) to end - def compile_false expession , method , message + def self.compile_false expession , method , message value = Virtual::FalseConstant.new to = Virtual::Return.new(Virtual::Reference , value) method.add_code Virtual::Set.new( to , value ) to end - def compile_nil expession , method , message + def self.compile_nil expession , method , message value = Virtual::NilConstant.new to = Virtual::Return.new(Virtual::Reference , value) method.add_code Virtual::Set.new( to , value ) @@ -43,7 +43,7 @@ module Compiler # compiling name needs to check if it's a variable and if so resolve it # otherwise it's a method without args and a send is ussued. # this makes the namespace static, ie when eval and co are implemented method needs recompilation - def compile_name expession , method , message + def self.compile_name expession , method , message return Virtual::Self.new( Virtual::Mystery ) if expession.name == :self if method.has_var(expession.name) message.compile_get(method , expession.name ) @@ -54,7 +54,7 @@ module Compiler end - def compile_module expession , method , message + def self.compile_module expession , method , message clazz = Virtual::BootSpace.space.get_or_create_class name raise "uups #{clazz}.#{name}" unless clazz to = Virtual::Return.new(Virtual::Reference , clazz ) @@ -63,7 +63,7 @@ module Compiler end # attr_reader :string - def compile_string expession , method , message + def self.compile_string expession , method , message value = Virtual::StringConstant.new(expession.string) to = Virtual::Return.new(Virtual::Reference , value) Virtual::BootSpace.space.add_object value @@ -72,14 +72,14 @@ module Compiler end #attr_reader :left, :right - def compile_assignment expession , method , message + def self.compile_assignment expession , method , message raise "must assign to NameExpression , not #{expession.left}" unless expession.left.instance_of? NameExpression r = right.compile(method,message) raise "oh noo, nil from where #{expession.right.inspect}" unless r message.compile_set( method , expession.left.name , r ) end - def compile_variable expession, method , message + def self.compile_variable expession, method , message method.add_code Virtual::InstanceGet.new(expession.name) Virtual::NewReturn.new( Virtual::Mystery ) end diff --git a/lib/compiler/call_site_expression.rb b/lib/compiler/call_site_expression.rb index a10c3abc..f2deb1d6 100644 --- a/lib/compiler/call_site_expression.rb +++ b/lib/compiler/call_site_expression.rb @@ -3,7 +3,7 @@ module Compiler # call_site - attr_reader :name, :args , :receiver - def compile_call_site expession , method , message + def self.compile_call_site expession , method , message me = expession.receiver.compile( method, message ) method.add_code Virtual::NewMessage.new method.add_code Virtual::Set.new(Virtual::NewSelf.new(me.type), me) diff --git a/lib/compiler/compound_expressions.rb b/lib/compiler/compound_expressions.rb index 145ff5b5..02c6f147 100644 --- a/lib/compiler/compound_expressions.rb +++ b/lib/compiler/compound_expressions.rb @@ -1,14 +1,14 @@ module Compiler # attr_reader :values - def compile_array expession, context + def self.compile_array expession, context to.do end # attr_reader :key , :value - def compile_association context + def self.compile_association context to.do end - def compile_hash context + def self.compile_hash context to.do end end diff --git a/lib/compiler/expression_list.rb b/lib/compiler/expression_list.rb index e4c5f613..590dd7ae 100644 --- a/lib/compiler/expression_list.rb +++ b/lib/compiler/expression_list.rb @@ -1,6 +1,8 @@ module Compiler # list - attr_reader :expressions - def compile_list expession , method , message - expession.expressions.collect { |part| part.compile( method, message ) } + def self.compile_list expession , method , message + expession.expressions.collect do |part| + Compiler.compile( part , method, message ) + end end end diff --git a/lib/compiler/function_expression.rb b/lib/compiler/function_expression.rb index d7487c45..2b9e0d94 100644 --- a/lib/compiler/function_expression.rb +++ b/lib/compiler/function_expression.rb @@ -1,6 +1,6 @@ module Compiler # function attr_reader :name, :params, :body , :receiver - def compile_function expression, method , message + def self.compile_function expression, method , message args = expession.params.collect do |p| raise "error, argument must be a identifier, not #{p}" unless p.is_a? NameExpression p.name diff --git a/lib/compiler/if_expression.rb b/lib/compiler/if_expression.rb index 57bef3a8..cf20b985 100644 --- a/lib/compiler/if_expression.rb +++ b/lib/compiler/if_expression.rb @@ -1,7 +1,7 @@ module Compiler # if - attr_reader :cond, :if_true, :if_false - def compile_if expression , method , message + def self.compile_if expression , method , message # to execute the logic as the if states it, the blocks are the other way around # so we can the jump over the else if true ,and the else joins unconditionally after the true_block merge_block = method.new_block "if_merge" # last one, created first diff --git a/lib/compiler/module_expression.rb b/lib/compiler/module_expression.rb index ff4a40d6..a3c2cd69 100644 --- a/lib/compiler/module_expression.rb +++ b/lib/compiler/module_expression.rb @@ -1,10 +1,10 @@ module Compiler # module attr_reader :name ,:expressions - def compile_module expression , context + def self.compile_module expression , context return clazz end - def compile_class expression , method , message + def self.compile_class expression , method , message clazz = ::Virtual::BootSpace.space.get_or_create_class name puts "Created class #{clazz.name.inspect}" expression.expressions.each do |expr| diff --git a/lib/compiler/operator_expressions.rb b/lib/compiler/operator_expressions.rb index 825e5c05..781eb341 100644 --- a/lib/compiler/operator_expressions.rb +++ b/lib/compiler/operator_expressions.rb @@ -1,6 +1,6 @@ module Compiler # operator attr_reader :operator, :left, :right - def compile_operator expression, method , message + def self.compile_operator expression, method , message call = CallSiteExpression.new( operator , [right] , left ) call.compile(method,message) end diff --git a/lib/compiler/return_expression.rb b/lib/compiler/return_expression.rb index 3fe9370b..f2dc8627 100644 --- a/lib/compiler/return_expression.rb +++ b/lib/compiler/return_expression.rb @@ -1,7 +1,7 @@ module Compiler # return attr_reader :expression - def compile_return expression, scope ,method + def self.compile_return expression, scope ,method Virtual::Reference.new end def old diff --git a/lib/compiler/while_expression.rb b/lib/compiler/while_expression.rb index 383dc558..115dd7db 100644 --- a/lib/compiler/while_expression.rb +++ b/lib/compiler/while_expression.rb @@ -1,7 +1,7 @@ module Compiler # while- attr_reader :condition, :body - def compile_while expression, method , message + def self.compile_while expression, method , message start = Virtual::Label.new("while_start") method.add_code start is = expression.condition.compile(method,message) diff --git a/lib/register/builtin/object.rb b/lib/register/builtin/object.rb index 7c9691f2..63a60927 100644 --- a/lib/register/builtin/object.rb +++ b/lib/register/builtin/object.rb @@ -1,9 +1,9 @@ module Builtin class Object module ClassMethods - - # return the index of the variable. Now "normal" code can't really do anything with that, but - # set/get instance variable use it. + + # return the index of the variable. Now "normal" code can't really do anything with that, but + # set/get instance variable use it. # This is just a placeholder, as we code this in ruby, but the instance methods need the definition before. def index_of context , name = Virtual::Integer index_function = Virtual::CompiledMethod.new(:index_of , Virtual::Reference , [Virtual::Reference] , Virtual::Integer ) @@ -16,15 +16,15 @@ module Builtin layout_function end - # in ruby, how this goes is + # in ruby, how this goes is # def _get_instance_variable var # i = self.index_of(var) # return at_index(i) - # end + # end # The at_index is just "below" the api, something we need but don't want to expose, so we can't code the above in ruby def _get_instance_variable context , name = Virtual::Integer get_function = Virtual::CompiledMethod.new(:_get_instance_variable , [ Virtual::Reference ] , Virtual::Reference ,Virtual::Mystery ) -# return get_function + return get_function me = get_function.receiver var_name = get_function.args.first return_to = get_function.return_type @@ -32,13 +32,13 @@ module Builtin index_function = ::Virtual::BootSpace.space.get_or_create_class(:Object).resolve_method(:index_of) # get_function.push( [me] ) # index = get_function.call( index_function ) - + after_body = get_function.new_block("after_index") get_function.current after_body - + # get_function.pop([me]) # return_to.at_index( get_function , me , return_to ) - + # get_function.set_return return_to return get_function end @@ -54,14 +54,14 @@ module Builtin set_function.push( [me] ) set_function.call( index_function ) after_body = set_function.new_block("after_index") - + set_function.current after_body set_function.pop([me]) return_to.at_index( set_function , me , return_to ) set_function.set_return return_to return set_function end - + def _get_singleton_method(context , name ) raise name end diff --git a/lib/virtual/compiled_method.rb b/lib/virtual/compiled_method.rb index 7ddec668..932f13d4 100644 --- a/lib/virtual/compiled_method.rb +++ b/lib/virtual/compiled_method.rb @@ -14,20 +14,20 @@ module Virtual # Methods also have arguments and a return. These are typed by subclass instances of Value - # They also have local variables. + # They also have local variables. # Code-wise Methods are made up from a list of Blocks, in a similar way blocks are made up of Instructions # The function starts with one block, and that has a start and end (return) - + # Blocks can be linked in two ways: # -linear: flow continues from one to the next as they are sequential both logically and - # "physically" use the block set_next for this. + # "physically" use the block set_next for this. # This "straight line", there must be a continuous sequence from body to return # Linear blocks may be created from an existing block with new_block # - branched: You create new blocks using function.new_block which gets added "after" return - # These (eg if/while) blocks may themselves have linear blocks ,but the last of these + # These (eg if/while) blocks may themselves have linear blocks ,but the last of these # MUST have an uncoditional branch. And remember, all roads lead to return. - + class CompiledMethod < Virtual::Object #return the main function (the top level) into which code is compiled def CompiledMethod.main @@ -63,10 +63,10 @@ module Virtual def locals_at l_block used =[] # call assigns the return register, but as it is in l_block, it is not asked. - assigned = [ RegisterReference.new(Register::RegisterMachine.instance.return_register) ] + assigned = [ RegisterReference.new(Virtual::RegisterMachine.instance.return_register) ] l_block.reachable.each do |b| b.uses.each {|u| - (used << u) unless assigned.include?(u) + (used << u) unless assigned.include?(u) } assigned += b.assigns end @@ -77,15 +77,15 @@ module Virtual # So when creating a new block (with new_block), it is only added to the list, but instructions # still go to the current one # With this function one can change the current block, to actually code it. - # This juggling is (unfortunately) neccessary, as all compile functions just keep puring their code into the + # This juggling is (unfortunately) neccessary, as all compile functions just keep puring their code into the # method and don't care what other compiles (like if's) do. # Example: while, needs 2 extra blocks # 1 condition code, must be its own blockas we jump back to it # - the body, can actually be after the condition as we don't need to jump there - # 2 after while block. Condition jumps here + # 2 after while block. Condition jumps here # After block 2, the function is linear again and the calling code does not need to know what happened - + # But subsequent statements are still using the original block (self) to add code to # So the while expression creates the extra blocks, adds them and the code and then "moves" the insertion point along def current block @@ -93,8 +93,8 @@ module Virtual self end - # create a new linear block after the current insertion block. - # Linear means there is no brach needed from that one to the new one. + # create a new linear block after the current insertion block. + # Linear means there is no brach needed from that one to the new one. # Usually the new one just serves as jump address for a control statement # In code generation , the new_block is written after this one, ie zero runtime cost # This does _not_ change the insertion point, that has do be done with insert_at(block) @@ -109,7 +109,7 @@ module Virtual # determine whether this method has a variable by the given name # variables are locals and and arguments - # used to determine if a send must be issued + # used to determine if a send must be issued def has_var name name = name.to_sym var = @arg_names.find {|a| a.name == name } @@ -151,23 +151,23 @@ module Virtual def layout Virtual::Object.layout end - # sugar to create instructions easily. + # sugar to create instructions easily. # any method will be passed on to the RegisterMachine and the result added to the insertion block - # With this trick we can write what looks like assembler, + # With this trick we can write what looks like assembler, # Example func.instance_eval # mov( r1 , r2 ) # add( r1 , r2 , 4) # end - # mov and add will be called on Machine and generate Inststuction that are then added + # mov and add will be called on Machine and generate Instructions that are then added # to the current block # also symbols are supported and wrapped as register usages (for bare metal programming) def method_missing(meth, *arg_names, &block) - add_code ::Register::RegisterMachine.instance.send(meth , *arg_names) + add_code ::Arm::ArmMachine.send(meth , *arg_names) end def mem_length l = @blocks.inject(0) { |c , block| c += block.mem_length } - padded(l) + padded(l) end # position of the function is the position of the entry block, is where we call def set_position at diff --git a/lib/virtual/machine.rb b/lib/virtual/machine.rb index 641bfb53..6d206416 100644 --- a/lib/virtual/machine.rb +++ b/lib/virtual/machine.rb @@ -50,7 +50,8 @@ module Virtual # read all the files needed for a minimal system at compile classes = ["object"] classes.each do |clazz| - bytes = File.read(File.join( File.dirname( __FILE__ ) , ".." , "parfait" , "#{clazz}.rb") ) + bytes = File.read(File.join( File.dirname( __FILE__ ) , ".." , "parfait" , "#{clazz}.rb") ) + bytes = 0 #shuts up my atom linter # expression = compile_main(bytes) end end @@ -59,7 +60,7 @@ module Virtual syntax = @parser.parse_with_debug(bytes) parts = Parser::Transform.new.apply(syntax) main = Virtual::CompiledMethod.main - parts.compile( main , self.message ) + Compiler.compile( parts , main , self.message ) end end diff --git a/test/fragments/test_while_fibo.rb b/test/fragments/test_while_fibo.rb index 5363dd08..5c43a459 100644 --- a/test/fragments/test_while_fibo.rb +++ b/test/fragments/test_while_fibo.rb @@ -30,12 +30,12 @@ HERE # a hand coded version of the fibonachi numbers (moved to kernel to be able to call it) # not my hand off course, found in the net from a basic introduction def test_kernel_fibo - int = Register::Integer.new(Register::RegisterMachine.instance.receiver_register) + int = Register::Integer.new(Virtual::RegisterMachine.instance.receiver_register) fibo = @object_space.get_or_create_class(:Object).resolve_method(:fibo) main = @object_space.main main.mov int , 10 main.call( fibo ) - main.mov( Register::RegisterMachine.instance.receiver_register , Register::RegisterMachine.instance.return_register ) + main.mov( Virtual::RegisterMachine.instance.receiver_register , Virtual::RegisterMachine.instance.return_register ) putint = @object_space.get_or_create_class(:Object).resolve_method(:putint) main.call( putint ) @should = [0x0,0x40,0x2d,0xe9,0x1,0x0,0x52,0xe3,0x2,0x0,0xa0,0xd1,0x7,0x0,0x0,0xda,0x1,0x30,0xa0,0xe3,0x0,0x40,0xa0,0xe3,0x4,0x30,0x83,0xe0,0x4,0x40,0x43,0xe0,0x1,0x20,0x42,0xe2,0x1,0x0,0x52,0xe3,0xfa,0xff,0xff,0x1a,0x3,0x0,0xa0,0xe1,0x0,0x80,0xbd,0xe8]