From d1f8733623b74ccb7cfedee137ed757ff06e46a6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Torsten=20R=C3=BCger?= Date: Fri, 4 Oct 2019 00:36:49 +0300 Subject: [PATCH] Rename Vool to Sol Simple is really the descriptive name for the layer Sure, it is "virtual" but that is not as important as the fact that it is simple (or simplified) Also objct (based really) is better, since orientated implies it is a little like that, but only orientated, not really it. Sol only has objects, nothing else Just cause i was renaming anyway --- Guardfile | 4 +- README.md | 17 +++--- lib/parfait.rb | 2 +- lib/parfait/behaviour.rb | 2 +- lib/parfait/callable_method.rb | 6 +- lib/parfait/class.rb | 4 +- lib/parfait/{vool_method.rb => sol_method.rb} | 12 ++-- lib/parfait/space.rb | 2 +- lib/risc/instructions/operator_instruction.rb | 2 +- lib/risc/parfait_boot.rb | 2 +- lib/ruby/README.md | 6 +- lib/ruby/assignment.rb | 12 ++-- lib/ruby/basic_values.rb | 8 +-- lib/ruby/call_statement.rb | 28 ++++----- lib/ruby/class_method_statement.rb | 4 +- lib/ruby/class_statement.rb | 20 +++---- lib/ruby/if_statement.rb | 14 ++--- lib/ruby/logical_statement.rb | 2 +- lib/ruby/method_statement.rb | 4 +- lib/ruby/normalizer.rb | 14 ++--- lib/ruby/return_statement.rb | 8 +-- lib/ruby/ruby_block_statement.rb | 10 ++-- lib/ruby/ruby_compiler.rb | 2 +- lib/ruby/send_statement.rb | 8 +-- lib/ruby/statement.rb | 12 ++-- lib/ruby/statements.rb | 8 +-- lib/ruby/variables.rb | 4 +- lib/ruby/while_statement.rb | 6 +- lib/rubyx.rb | 4 +- lib/rubyx/rubyx_compiler.rb | 60 +++++++++---------- lib/rubyx/rubyxc.rb | 2 +- lib/slot_machine/README.md | 12 ++-- lib/slot_machine/instruction.rb | 4 +- lib/slot_machine/instruction/basic_values.rb | 2 +- lib/slot_machine/instruction/block_yield.rb | 2 +- lib/slot_machine/instruction/dynamic_call.rb | 2 +- .../instruction/resolve_method.rb | 2 +- lib/slot_machine/instruction/return_jump.rb | 2 +- lib/slot_machine/macro/method_missing.rb | 2 +- lib/slot_machine/slot_collection.rb | 4 +- lib/slot_machine/slot_machine.rb | 4 +- lib/{vool => sol}/README.md | 10 ++-- lib/{vool => sol}/assignment.rb | 2 +- lib/{vool => sol}/basic_values.rb | 14 ++--- lib/{vool => sol}/builtin.rb | 2 +- lib/{vool => sol}/call_statement.rb | 2 +- lib/{vool => sol}/class_expression.rb | 4 +- lib/{vool => sol}/class_method_expression.rb | 10 ++-- lib/{vool => sol}/if_statement.rb | 2 +- lib/{vool => sol}/ivar_assignment.rb | 2 +- lib/{vool => sol}/lambda_expression.rb | 2 +- lib/{vool => sol}/local_assignment.rb | 2 +- lib/{vool => sol}/macro_expression.rb | 2 +- lib/{vool => sol}/method_expression.rb | 12 ++-- lib/{vool => sol}/return_statement.rb | 2 +- lib/{vool => sol}/send_statement.rb | 20 +++---- lib/{vool => sol}/statement.rb | 15 +++-- lib/{vool => sol}/statements.rb | 2 +- lib/{vool => sol}/super_statement.rb | 2 +- lib/{vool => sol}/variables.rb | 2 +- lib/{vool => sol}/while_statement.rb | 2 +- lib/{vool => sol}/yield_statement.rb | 2 +- ...test_vool_method.rb => test_sol_method.rb} | 10 ++-- test/parfait/test_space.rb | 2 +- test/ruby/helper.rb | 18 +++--- test/ruby/test_assignment.rb | 20 +++---- test/ruby/test_assignment1.rb | 12 ++-- test/ruby/test_basic_values.rb | 4 +- test/ruby/test_class_method_statement.rb | 14 ++--- test/ruby/test_class_statement.rb | 18 +++--- test/ruby/test_class_statement2.rb | 14 ++--- test/ruby/test_class_statement3.rb | 12 ++-- test/ruby/test_if_statement2.rb | 26 ++++---- test/ruby/test_macro_expression.rb | 20 +++---- test/ruby/test_method_statement2.rb | 46 +++++++------- test/ruby/test_require.rb | 16 ++--- test/ruby/test_return_statement.rb | 20 +++---- test/ruby/test_ruby_block_statement.rb | 8 +-- test/ruby/test_ruby_block_statement1.rb | 14 ++--- test/ruby/test_send_statement1.rb | 50 ++++++++-------- test/ruby/test_send_statement2.rb | 50 ++++++++-------- test/ruby/test_statement.rb | 6 +- test/ruby/test_variables.rb | 26 ++++---- test/ruby/test_while_statement1.rb | 22 +++---- test/ruby/test_yield_statement.rb | 8 +-- test/rubyx/helper.rb | 10 ++-- test/rubyx/parfait/README.md | 4 +- test/rubyx/parfait/test_data_object.rb | 20 +++---- test/rubyx/parfait/test_integer.rb | 30 +++++----- test/rubyx/parfait/test_object.rb | 8 +-- test/rubyx/rt_parfait/test_object.rb | 40 ++++++------- test/rubyx/test_rubyx_compiler.rb | 10 ++-- test/rubyx/test_rubyx_compiler1.rb | 2 +- test/rubyx/test_rubyx_compiler2.rb | 2 +- test/rubyx/test_rubyx_compiler3.rb | 22 +++---- test/slot_machine/test_block_statement.rb | 2 +- test/slot_machine/test_class_statement.rb | 2 +- test/slot_machine/test_method_compiler.rb | 26 ++++---- test/{vool => sol}/class_send/helper.rb | 0 .../class_send/test_class_def.rb | 4 +- .../class_send/test_class_instance.rb | 4 +- .../class_send/test_class_send_inherited.rb | 4 +- .../class_send/test_send_class.rb | 4 +- test/{vool => sol}/helper.rb | 0 test/{vool => sol}/lambdas/helper.rb | 0 test/{vool => sol}/lambdas/test_assign.rb | 10 ++-- .../lambdas/test_class_blocks.rb | 14 ++--- .../lambdas/test_if_condition.rb | 4 +- .../lambdas/test_while_simple.rb | 4 +- test/{vool => sol}/send/helper.rb | 4 +- test/{vool => sol}/send/test_not_found.rb | 4 +- .../{vool => sol}/send/test_send_args_send.rb | 4 +- .../send/test_send_cached_simple.rb | 4 +- test/{vool => sol}/send/test_send_self.rb | 2 +- test/{vool => sol}/send/test_send_simple.rb | 2 +- .../send/test_send_simple_args.rb | 2 +- test/{vool => sol}/test_assignment.rb | 10 ++-- test/{vool => sol}/test_builtin.rb | 28 ++++----- test/{vool => sol}/test_class_expression.rb | 28 ++++----- test/{vool => sol}/test_class_expression2.rb | 4 +- .../test_class_method_expression.rb | 6 +- test/{vool => sol}/test_if_no_else.rb | 4 +- test/{vool => sol}/test_if_no_if.rb | 4 +- test/{vool => sol}/test_if_simple.rb | 4 +- test/{vool => sol}/test_if_statement.rb | 4 +- test/{vool => sol}/test_ivar.rb | 4 +- test/{vool => sol}/test_local_assignment.rb | 6 +- test/{vool => sol}/test_macro_expression.rb | 8 +-- test/{vool => sol}/test_method_expression.rb | 12 ++-- test/{vool => sol}/test_return.rb | 6 +- test/{vool => sol}/test_while_statement.rb | 4 +- test/{vool => sol}/test_while_statement1.rb | 4 +- test/{vool => sol}/test_yield_statement.rb | 6 +- test/support/compiling.rb | 4 +- test/support/preloader.rb | 4 +- 135 files changed, 636 insertions(+), 636 deletions(-) rename lib/parfait/{vool_method.rb => sol_method.rb} (81%) rename lib/{vool => sol}/README.md (78%) rename lib/{vool => sol}/assignment.rb (99%) rename lib/{vool => sol}/basic_values.rb (92%) rename lib/{vool => sol}/builtin.rb (99%) rename lib/{vool => sol}/call_statement.rb (98%) rename lib/{vool => sol}/class_expression.rb (97%) rename lib/{vool => sol}/class_method_expression.rb (85%) rename lib/{vool => sol}/if_statement.rb (99%) rename lib/{vool => sol}/ivar_assignment.rb (97%) rename lib/{vool => sol}/lambda_expression.rb (99%) rename lib/{vool => sol}/local_assignment.rb (98%) rename lib/{vool => sol}/macro_expression.rb (98%) rename lib/{vool => sol}/method_expression.rb (86%) rename lib/{vool => sol}/return_statement.rb (98%) rename lib/{vool => sol}/send_statement.rb (88%) rename lib/{vool => sol}/statement.rb (89%) rename lib/{vool => sol}/statements.rb (99%) rename lib/{vool => sol}/super_statement.rb (80%) rename lib/{vool => sol}/variables.rb (99%) rename lib/{vool => sol}/while_statement.rb (98%) rename lib/{vool => sol}/yield_statement.rb (99%) rename test/parfait/{test_vool_method.rb => test_sol_method.rb} (78%) rename test/{vool => sol}/class_send/helper.rb (100%) rename test/{vool => sol}/class_send/test_class_def.rb (96%) rename test/{vool => sol}/class_send/test_class_instance.rb (98%) rename test/{vool => sol}/class_send/test_class_send_inherited.rb (97%) rename test/{vool => sol}/class_send/test_send_class.rb (98%) rename test/{vool => sol}/helper.rb (100%) rename test/{vool => sol}/lambdas/helper.rb (100%) rename test/{vool => sol}/lambdas/test_assign.rb (94%) rename test/{vool => sol}/lambdas/test_class_blocks.rb (60%) rename test/{vool => sol}/lambdas/test_if_condition.rb (94%) rename test/{vool => sol}/lambdas/test_while_simple.rb (93%) rename test/{vool => sol}/send/helper.rb (97%) rename test/{vool => sol}/send/test_not_found.rb (95%) rename test/{vool => sol}/send/test_send_args_send.rb (95%) rename test/{vool => sol}/send/test_send_cached_simple.rb (96%) rename test/{vool => sol}/send/test_send_self.rb (98%) rename test/{vool => sol}/send/test_send_simple.rb (96%) rename test/{vool => sol}/send/test_send_simple_args.rb (98%) rename test/{vool => sol}/test_assignment.rb (95%) rename test/{vool => sol}/test_builtin.rb (69%) rename test/{vool => sol}/test_class_expression.rb (73%) rename test/{vool => sol}/test_class_expression2.rb (96%) rename test/{vool => sol}/test_class_method_expression.rb (95%) rename test/{vool => sol}/test_if_no_else.rb (95%) rename test/{vool => sol}/test_if_no_if.rb (95%) rename test/{vool => sol}/test_if_simple.rb (95%) rename test/{vool => sol}/test_if_statement.rb (95%) rename test/{vool => sol}/test_ivar.rb (95%) rename test/{vool => sol}/test_local_assignment.rb (96%) rename test/{vool => sol}/test_macro_expression.rb (85%) rename test/{vool => sol}/test_method_expression.rb (87%) rename test/{vool => sol}/test_return.rb (96%) rename test/{vool => sol}/test_while_statement.rb (95%) rename test/{vool => sol}/test_while_statement1.rb (96%) rename test/{vool => sol}/test_yield_statement.rb (98%) diff --git a/Guardfile b/Guardfile index e5600fe7..6529f42d 100644 --- a/Guardfile +++ b/Guardfile @@ -26,8 +26,8 @@ guard :minitest , all_on_start: false do # with Minitest::Unit # ruby compiler tests have a whole directory watch(%r{^lib/ruby/ruby_compiler.rb}) { Dir["test/ruby/test_*.rb"] } - watch(%r{^lib/vool/statements/send_statement.rb}) { - [ Dir["test/vool/send/test_*.rb"] ] } + watch(%r{^lib/sol/statements/send_statement.rb}) { + [ Dir["test/sol/send/test_*.rb"] ] } # message setup watch(%r{^lib/slot_machine/instruction/message_setup.rb}) { Dir["test/slot_machine/send/test_setup*.rb"] } diff --git a/README.md b/README.md index 6dbaa2ec..6c75c1e0 100644 --- a/README.md +++ b/README.md @@ -12,7 +12,7 @@ X can be read as X times faster, or a decade away, depending on mindset. The last rewrite clarified the roles of the different layers of the system, see below. The overhaul is done and rubyx produces working binaries. -Processing goes through layers: Ruby --> Vool --> SlotMachine --> Risc --> Arm --> binary . +Processing goes through layers: Ruby --> Sol --> SlotMachine --> Risc --> Arm --> binary . Currently most basic constructs work to some (usable) degree, ie if, while, assignment, ivars, calling and dynamic dispatch all work. Simple blocks, those @@ -27,14 +27,15 @@ anything, even counting to a million. Ruby is input layer, we use whitequarks parser to parse ruby. The untyped ast is then transformed into a typed version. The classes and fields follow the ast output pretty -much one to one. The we transform to Vool, removing much of ruby's "fluff". +much one to one. The we transform to Sol, removing much of ruby's "fluff". -### Vool +### Sol -Vool is a Virtual Object Oriented Language. Virtual in that is has no own syntax. But -it has semantics, and those are substantially simpler than ruby. +Sol is a Simple Object Language. Simple as in much simpler than ruby. Object (more +based than oriented) as everything is an object. Everything the language "sees". +(Dataprocessing is done at a lower level, partly Slot, partly risc) -Vool is Ruby without the fluff. No unless, no reverse if/while, no splats. Just simple +Sol is Ruby without the fluff. No unless, no reverse if/while, no splats. Just simple oo. (Without this level the step down to the next layer was just too big) @@ -47,13 +48,13 @@ SlotMachine has no concept of memory yet, only objects. Data is transferred dire to object with one of SlotMachine's main instructions, the SlotLoad. Mainly SlotMachine is an easy to understand step on the way down. A mix of oo and machine. In -practise it means that the amount of instructions that need to be generated in vool +practise it means that the amount of instructions that need to be generated in sol is much smaller (easier to understand) and the mapping down to risc is quite straightforward. ### Risc The risc cpu architecture approach was a simplification of the cpu instruction set to a -minimum. Arm, our main target, is a risc architecture, and much like Vool uncrinkles +minimum. Arm, our main target, is a risc architecture, and much like Sol uncrinkles Ruby, the Risc layer simplifies ARM. The Risc layer here abstracts the Arm in a minimal and independent way. It does not model diff --git a/lib/parfait.rb b/lib/parfait.rb index 1e0b9cb7..c7f991a6 100644 --- a/lib/parfait.rb +++ b/lib/parfait.rb @@ -16,7 +16,7 @@ require_relative "parfait/binary_code" require_relative "parfait/callable" require_relative "parfait/block" require_relative "parfait/callable_method" -require_relative "parfait/vool_method" +require_relative "parfait/sol_method" require_relative "parfait/dictionary" require_relative "parfait/type" require_relative "parfait/cache_entry" diff --git a/lib/parfait/behaviour.rb b/lib/parfait/behaviour.rb index eec3cef2..6feab7a5 100644 --- a/lib/parfait/behaviour.rb +++ b/lib/parfait/behaviour.rb @@ -42,7 +42,7 @@ module Parfait def create_instance_method_for(name , type , frame , body ) raise "Method exists #{name}" if get_instance_method(name) - method = Parfait::VoolMethod.new(name , type , frame , body ) + method = Parfait::SolMethod.new(name , type , frame , body ) add_instance_method( method ) end diff --git a/lib/parfait/callable_method.rb b/lib/parfait/callable_method.rb index f0dab840..d58d54d0 100644 --- a/lib/parfait/callable_method.rb +++ b/lib/parfait/callable_method.rb @@ -3,9 +3,9 @@ module Parfait # A CallableMethod is static object that primarily holds the executable code. # It is callable through it's binary code # - # It's relation to the method a ruby programmer knows (called VoolMethod) is many to one, - # meaning one VoolMethod (untyped) has many CallableMethod implementations. - # The VoolMethod only holds vool code, no binary. + # It's relation to the method a ruby programmer knows (called SolMethod) is many to one, + # meaning one SolMethod (untyped) has many CallableMethod implementations. + # The SolMethod only holds sol code, no binary. # # CallableMethods are bound to a known type (self_type) and have known argument # and local variables. All variable resolution inside the method is exact (static), diff --git a/lib/parfait/class.rb b/lib/parfait/class.rb index 4fdc2423..9e504aee 100644 --- a/lib/parfait/class.rb +++ b/lib/parfait/class.rb @@ -1,5 +1,5 @@ # Class is mainly a list of methods with a name. -# The methods are untyped, sis VoolMethod. +# The methods are untyped, sis SolMethod. # The memory layout of an object is determined by the Type (see there). # The class carries the "current" type, ie the type an object would be if you @@ -11,7 +11,7 @@ # An Object carries the data for the instance variables it has. # The Type lists the names of the instance variables -# The Class keeps a list of instance methods, these have a name and (vool) code +# The Class keeps a list of instance methods, these have a name and (sol) code # Each type in turn has a list of CallableMethods that hold binary code module Parfait diff --git a/lib/parfait/vool_method.rb b/lib/parfait/sol_method.rb similarity index 81% rename from lib/parfait/vool_method.rb rename to lib/parfait/sol_method.rb index 3bf3df68..59ed58b7 100644 --- a/lib/parfait/vool_method.rb +++ b/lib/parfait/sol_method.rb @@ -1,16 +1,16 @@ module Parfait - # This represents the method at source code level (sis vool) + # This represents the method at source code level (sis sol) # # Type objects are already created for args and locals, but the main attribute - # is the source, which is a Vool::Statement + # is the source, which is a Sol::Statement # - # Classes store VoolMethods, while Types store Risc::CallableMethod + # Classes store SolMethods, while Types store Risc::CallableMethod # A Type referes to a Class , but a Class (interface) is implemented by many types # as it changes during the course of it's life. Types do not change. Objects have # type, and so only indirectly a class. # - class VoolMethod < Object + class SolMethod < Object attr_reader :name , :args_type , :frame_type attr_reader :source @@ -24,8 +24,8 @@ module Parfait raise "Name must be symbol" unless name.is_a?(Symbol) raise "args_type must be type" unless args_type.is_a?(Parfait::Type) raise "frame_type must be type" unless frame_type.is_a?(Parfait::Type) - raise "source must be vool not#{source.class}" unless source.is_a?(Vool::Statement) - raise "Empty bod" if(@source.is_a?(Vool::Statements) and @source.empty?) + raise "source must be sol not#{source.class}" unless source.is_a?(Sol::Statement) + raise "Empty bod" if(@source.is_a?(Sol::Statements) and @source.empty?) end def create_callable_method_for( type ) diff --git a/lib/parfait/space.rb b/lib/parfait/space.rb index a926771a..8fabaa65 100644 --- a/lib/parfait/space.rb +++ b/lib/parfait/space.rb @@ -111,7 +111,7 @@ module Parfait # The superclass must be known when the class is created, or it raises an error. # The class is initiated with the type of the superclass (hence above) # - # Only Vool::ClassExpression really ever creates classes and "grows" the type + # Only Sol::ClassExpression really ever creates classes and "grows" the type # according to the instances it finds, see there # def create_class( name , superclass = nil ) diff --git a/lib/risc/instructions/operator_instruction.rb b/lib/risc/instructions/operator_instruction.rb index 0afeb7b1..73c4b705 100644 --- a/lib/risc/instructions/operator_instruction.rb +++ b/lib/risc/instructions/operator_instruction.rb @@ -13,7 +13,7 @@ module Risc class OperatorInstruction < Instruction def initialize( source , operator , left , right ) super(source) - operator = operator.value if operator.is_a?(Vool::Constant) + operator = operator.value if operator.is_a?(Sol::Constant) @operator = operator raise "unsuported operator :#{operator}:#{operator.class}:" unless Risc.operators.include?(operator) @left = left diff --git a/lib/risc/parfait_boot.rb b/lib/risc/parfait_boot.rb index 9e3c139b..e8009f71 100644 --- a/lib/risc/parfait_boot.rb +++ b/lib/risc/parfait_boot.rb @@ -141,7 +141,7 @@ module Parfait Type: {names: :List , types: :List , object_class: :Class, methods: :CallableMethod , is_single: :Object} , - VoolMethod: { name: :Word , args_type: :Type , frame_type: :Type } , + SolMethod: { name: :Word , args_type: :Type , frame_type: :Type } , Word: {char_length: :Integer , next_word: :Word} , } end diff --git a/lib/ruby/README.md b/lib/ruby/README.md index 2c4a9b37..4c72d254 100644 --- a/lib/ruby/README.md +++ b/lib/ruby/README.md @@ -17,9 +17,9 @@ what we may loosely call type here, ie the kind of statement. The ruby layer is really all about defining classes for every kind of statement, thus "typing" the syntax tree, and making it concrete. -## to Vool +## to Sol -In our nice layers, we are on the way down to Vool, a simplified version of oo. +In our nice layers, we are on the way down to Sol, a simplified version of oo. It has proven handy to have this layer, so the code for transforming each object is in the class representing that object. (As one does in oo, again imho). @@ -35,4 +35,4 @@ will surely follow. The compilation process ends up creating (parfait) objects to represent things like classes, types and constants. This is not done here yet, but in -the vool layer. +the sol layer. diff --git a/lib/ruby/assignment.rb b/lib/ruby/assignment.rb index ba116eaa..7b3c9dd8 100644 --- a/lib/ruby/assignment.rb +++ b/lib/ruby/assignment.rb @@ -6,11 +6,11 @@ module Ruby @name , @value = name , value end - def to_vool() + def to_sol() raise "not named left #{name.class}" unless name.is_a?(Symbol) case value when Variable , Constant - return self.vool_brother.new(name,@value.to_vool) + return self.sol_brother.new(name,@value.to_sol) when SendStatement , YieldStatement , RubyBlockStatement return normalize_send else @@ -18,12 +18,12 @@ module Ruby end end - # sends may have complex args that get hoisted in vool:ing them + # sends may have complex args that get hoisted in sol:ing them # in which case we have to assign the simplified, otherwise the # plain send def normalize_send - statements = value.to_vool - return assignment( statements ) if statements.is_a?(Vool::CallStatement) + statements = value.to_sol + return assignment( statements ) if statements.is_a?(Sol::CallStatement) # send has hoisted assigns, so we make an assign out of the "pure" send statements << assignment(statements.statements.pop) statements @@ -32,7 +32,7 @@ module Ruby # create same type assignment with the value (a send) def assignment(value) value ||= @value - self.vool_brother.new(name,value) + self.sol_brother.new(name,value) end def to_s(depth = 0) diff --git a/lib/ruby/basic_values.rb b/lib/ruby/basic_values.rb index 79d9aeeb..66f32277 100644 --- a/lib/ruby/basic_values.rb +++ b/lib/ruby/basic_values.rb @@ -1,7 +1,7 @@ module Ruby class Constant < Statement - def to_vool - vool_brother.new + def to_sol + sol_brother.new end end class ValueConstant < Constant @@ -9,8 +9,8 @@ module Ruby def initialize(value) @value = value end - def to_vool - vool_brother.new(@value) + def to_sol + sol_brother.new(@value) end end class IntegerConstant < ValueConstant diff --git a/lib/ruby/call_statement.rb b/lib/ruby/call_statement.rb index cfe187ff..11137e14 100644 --- a/lib/ruby/call_statement.rb +++ b/lib/ruby/call_statement.rb @@ -5,8 +5,8 @@ module Ruby # # A CallStatement has a name, receiver and arguments # - # Using the "vool_brother" we can create the right Vool class for it. - # Arguments in vool must be simple, so any complex expressions get + # Using the "sol_brother" we can create the right Sol class for it. + # Arguments in sol must be simple, so any complex expressions get # hoisted and assigned to temporary variables. # class CallStatement < Statement @@ -18,17 +18,17 @@ module Ruby end # we "normalize" or flatten any complex argument expressions into a list - def to_vool - statements = Vool::Statements.new([]) + def to_sol + statements = Sol::Statements.new([]) receiver = normalize_arg(@receiver , statements) arguments = [] @arguments.each_with_index do |arg , index | arguments << normalize_arg(arg , statements) end if statements.empty? - return vool_brother.new(@name, receiver , arguments) + return sol_brother.new(@name, receiver , arguments) else - statements << vool_brother.new(@name, receiver , arguments) + statements << sol_brother.new(@name, receiver , arguments) return statements end end @@ -38,17 +38,17 @@ module Ruby # the effect is of walking the call tree now, # rather than using a stack to do that at runtime def normalize_arg(arg , statements) - vool_arg = arg.to_vool - return vool_arg if vool_arg.is_a?(Vool::Expression) - if( vool_arg.is_a?(Vool::Statements)) - while(vool_arg.length > 1) - statements << vool_arg.shift + sol_arg = arg.to_sol + return sol_arg if sol_arg.is_a?(Sol::Expression) + if( sol_arg.is_a?(Sol::Statements)) + while(sol_arg.length > 1) + statements << sol_arg.shift end - vool_arg = vool_arg.shift + sol_arg = sol_arg.shift end - assign = Vool::LocalAssignment.new( "tmp_#{arg.object_id}".to_sym, vool_arg) + assign = Sol::LocalAssignment.new( "tmp_#{arg.object_id}".to_sym, sol_arg) statements << assign - return Vool::LocalVariable.new(assign.name) + return Sol::LocalVariable.new(assign.name) end end diff --git a/lib/ruby/class_method_statement.rb b/lib/ruby/class_method_statement.rb index fa4b9ba3..ef27069f 100644 --- a/lib/ruby/class_method_statement.rb +++ b/lib/ruby/class_method_statement.rb @@ -1,9 +1,9 @@ module Ruby class ClassMethodStatement < MethodStatement - def to_vool + def to_sol body = normalized_body - Vool::ClassMethodExpression.new( @name , @args.dup , body.to_vool) + Sol::ClassMethodExpression.new( @name , @args.dup , body.to_sol) end def to_s(depth = 0) diff --git a/lib/ruby/class_statement.rb b/lib/ruby/class_statement.rb index 254b5fd9..a49dd0cc 100644 --- a/lib/ruby/class_statement.rb +++ b/lib/ruby/class_statement.rb @@ -3,7 +3,7 @@ module Ruby attr_reader :name, :super_class_name , :body # init with the class name, super class name and statement body - # body must be Method or Send (See to_vool) or empty/nil (possibly not handled right) + # body must be Method or Send (See to_sol) or empty/nil (possibly not handled right) def initialize( name , supe , body) @name , @super_class_name = name , supe case body @@ -18,23 +18,23 @@ module Ruby end end - # Create equivalent vool objects. Mostly for method statements + # Create equivalent sol objects. Mostly for method statements # For calls, call transform_statement, see there - def to_vool + def to_sol meths = [] body.statements.each do |meth| if( meth.is_a?(MethodStatement)) - meths << meth.to_vool + meths << meth.to_sol else meths += transform_statement(meth) end end - Vool::ClassExpression.new(@name , @super_class_name, Vool::Statements.new(meths) ) + Sol::ClassExpression.new(@name , @super_class_name, Sol::Statements.new(meths) ) end # We rewrite certain send statements (so raise error for all else) # Currently only attributes (ie attr :name) supported, for which the standard getter - # and setter is created and returned as vool + # and setter is created and returned as sol def transform_statement( class_send ) unless class_send.is_a?(SendStatement) raise "Other than methods, only class methods allowed, not #{class_send.class}" @@ -53,21 +53,21 @@ module Ruby end # creates a getter method for the given instance name (sym) - # The Method is created in Ruby, and to_vool is called to transform to Vool + # The Method is created in Ruby, and to_sol is called to transform to Sol # The standard getter obviously only returns the ivar def getter_for(instance_name) return_statement = ReturnStatement.new(InstanceVariable.new(instance_name)) - MethodStatement.new(instance_name , [] , return_statement).to_vool + MethodStatement.new(instance_name , [] , return_statement).to_sol end # creates a setter method (name=) for the given instance name (sym) - # The Method is created in Ruby, and to_vool is called to transform to Vool + # The Method is created in Ruby, and to_sol is called to transform to Sol # The setter method assigns the incoming value and returns the ivar def setter_for(instance_name) assign = IvarAssignment.new(instance_name , LocalVariable.new(:val)) return_statement = ReturnStatement.new(InstanceVariable.new(instance_name)) statements = Statements.new([assign, return_statement]) - MethodStatement.new("#{instance_name}=".to_sym , [:val] , statements).to_vool + MethodStatement.new("#{instance_name}=".to_sym , [:val] , statements).to_sol end def to_s(depth = 0) diff --git a/lib/ruby/if_statement.rb b/lib/ruby/if_statement.rb index 26d4c7b6..d0c7cb11 100644 --- a/lib/ruby/if_statement.rb +++ b/lib/ruby/if_statement.rb @@ -3,11 +3,11 @@ require_relative "normalizer" module Ruby # The if must have condition and a true branch, the false is optional # - # It maps pretty much one to one to a Vool, except for "hoisting" + # It maps pretty much one to one to a Sol, except for "hoisting" # # Ruby may have super complex expressions as the condition, whereas - # Vool may not. Ie of a Statement list all but the last are hoisted to before - # the vool if. This is equivalent, just easier to compile later + # Sol may not. Ie of a Statement list all but the last are hoisted to before + # the sol if. This is equivalent, just easier to compile later # # The hoisintg code is in Normalizer, as it is also useed in return and while class IfStatement < Statement @@ -21,11 +21,11 @@ module Ruby @if_false = if_false end - def to_vool - cond , hoisted = *normalized_vool(@condition) - me = Vool::IfStatement.new(cond , @if_true&.to_vool, @if_false&.to_vool) + def to_sol + cond , hoisted = *normalized_sol(@condition) + me = Sol::IfStatement.new(cond , @if_true&.to_sol, @if_false&.to_sol) return me unless hoisted - Vool::Statements.new( hoisted ) << me + Sol::Statements.new( hoisted ) << me end def has_false? diff --git a/lib/ruby/logical_statement.rb b/lib/ruby/logical_statement.rb index f37596c1..0a923469 100644 --- a/lib/ruby/logical_statement.rb +++ b/lib/ruby/logical_statement.rb @@ -7,7 +7,7 @@ module Ruby # ie: false && non_existant_method # will never call the non_existant_method , but instead evaluate to false # - # Vool has no concept of this, so the Statement is expanded into the if + # Sol has no concept of this, so the Statement is expanded into the if # that it really is class LogicalStatement < Statement attr_reader :name , :left , :right diff --git a/lib/ruby/method_statement.rb b/lib/ruby/method_statement.rb index 900bd585..242d1ccb 100644 --- a/lib/ruby/method_statement.rb +++ b/lib/ruby/method_statement.rb @@ -15,9 +15,9 @@ module Ruby body << replace_return( body.pop ) end - def to_vool + def to_sol body = normalized_body - Vool::MethodExpression.new( @name , @args.dup , body.to_vool) + Sol::MethodExpression.new( @name , @args.dup , body.to_sol) end def replace_return(statement) diff --git a/lib/ruby/normalizer.rb b/lib/ruby/normalizer.rb index 7adf326c..b06afb4d 100644 --- a/lib/ruby/normalizer.rb +++ b/lib/ruby/normalizer.rb @@ -1,9 +1,9 @@ module Ruby module Normalizer - # Normalize ruby to vool by "flattening" structure + # Normalize ruby to sol by "flattening" structure # # This is a common issue for return, if and while , which all need to operate on the - # last value. In ruby the last value is always implicit, in vool not. + # last value. In ruby the last value is always implicit, in sol not. # # A "normalized" structure is first of all not recursive, a list not a tree, # The last expression of the list may be one of three things @@ -13,11 +13,11 @@ module Ruby # # We return the last expression, the one that is returned or tested on, seperately # - def normalized_vool( condition ) - vool_condition = condition.to_vool - return vool_condition unless( vool_condition.is_a?(Vool::Statements) ) - return vool_condition.first if( vool_condition.single?) - return [vool_condition.pop , vool_condition ] + def normalized_sol( condition ) + sol_condition = condition.to_sol + return sol_condition unless( sol_condition.is_a?(Sol::Statements) ) + return sol_condition.first if( sol_condition.single?) + return [sol_condition.pop , sol_condition ] end end end diff --git a/lib/ruby/return_statement.rb b/lib/ruby/return_statement.rb index 1afb85cb..a899866d 100644 --- a/lib/ruby/return_statement.rb +++ b/lib/ruby/return_statement.rb @@ -8,11 +8,11 @@ module Ruby @return_value = value || NilConstant.new end - def to_vool - val , hoisted = *normalized_vool(@return_value) - me = Vool::ReturnStatement.new(val) + def to_sol + val , hoisted = *normalized_sol(@return_value) + me = Sol::ReturnStatement.new(val) return me unless hoisted - Vool::Statements.new( hoisted ) << me + Sol::Statements.new( hoisted ) << me end def to_s(depth = 0) diff --git a/lib/ruby/ruby_block_statement.rb b/lib/ruby/ruby_block_statement.rb index 1cf8f938..d19cb3e5 100644 --- a/lib/ruby/ruby_block_statement.rb +++ b/lib/ruby/ruby_block_statement.rb @@ -13,16 +13,16 @@ module Ruby raise "no bod" unless @body end - # This resolves to a Vool SendStatement, in fact that is mostly what it is. + # This resolves to a Sol SendStatement, in fact that is mostly what it is. # # The implicitly passed block (in ruby) gets converted to the constant it is, and # is passed as the last argument. # - def to_vool + def to_sol #block_name = "implicit_block_#{object_id}".to_sym - lambda = Vool::LambdaExpression.new( @args.dup , @body.to_vool) - ret = @send.to_vool - sendd = ret.is_a?(Vool::Statements) ? ret.last : ret + lambda = Sol::LambdaExpression.new( @args.dup , @body.to_sol) + ret = @send.to_sol + sendd = ret.is_a?(Sol::Statements) ? ret.last : ret sendd.arguments << lambda ret end diff --git a/lib/ruby/ruby_compiler.rb b/lib/ruby/ruby_compiler.rb index 4200bad4..267ef7ab 100644 --- a/lib/ruby/ruby_compiler.rb +++ b/lib/ruby/ruby_compiler.rb @@ -22,7 +22,7 @@ module Ruby # # As a second step, it extracts classes, methods, ivars and locals. # - # The next step is then to go to the vool level, which is + # The next step is then to go to the sol level, which is # simpler, and then finally to compile # to the next level down, SlotMachine (Minimal Object Machine) class RubyCompiler < AST::Processor diff --git a/lib/ruby/send_statement.rb b/lib/ruby/send_statement.rb index bda73ad8..b9f1654d 100644 --- a/lib/ruby/send_statement.rb +++ b/lib/ruby/send_statement.rb @@ -5,10 +5,10 @@ module Ruby # class SendStatement < CallStatement - def to_vool + def to_sol if @receiver.is_a?(ModuleName) and @receiver.name == :X - args = @arguments.collect { |arg| arg.to_vool } - return Vool::MacroExpression.new(name , args) + args = @arguments.collect { |arg| arg.to_sol } + return Sol::MacroExpression.new(name , args) end return require_file if( @name == :require_relative ) return super @@ -25,7 +25,7 @@ module Ruby end path = File.expand_path( "../../../#{file}" , __FILE__) source = File.read(path) - RubyCompiler.compile( source ).to_vool + RubyCompiler.compile( source ).to_sol end end class SuperStatement < SendStatement diff --git a/lib/ruby/statement.rb b/lib/ruby/statement.rb index 2a4e8704..912b6736 100644 --- a/lib/ruby/statement.rb +++ b/lib/ruby/statement.rb @@ -7,16 +7,16 @@ module Ruby # class Statement - # Many statements exist in the vool layer in quite a similar arrangement + # Many statements exist in the sol layer in quite a similar arrangement # Especially for different types of assignment we can abstract the creation - # of the vool, by using the right class to instantiate, the "vool_brother" - # Ie same class_name, but in the Vool module - def vool_brother - eval "Vool::#{class_name}" + # of the sol, by using the right class to instantiate, the "sol_brother" + # Ie same class_name, but in the Sol module + def sol_brother + eval "Sol::#{class_name}" end # return the class name without the module - # used to evaluate the vool_brother + # used to evaluate the sol_brother def class_name self.class.name.split("::").last end diff --git a/lib/ruby/statements.rb b/lib/ruby/statements.rb index 5a914d0c..105799e4 100644 --- a/lib/ruby/statements.rb +++ b/lib/ruby/statements.rb @@ -35,11 +35,11 @@ module Ruby @statements << o self end - def to_vool - return first.to_vool if( single? ) - brother = vool_brother.new(nil) + def to_sol + return first.to_sol if( single? ) + brother = sol_brother.new(nil) @statements.each do |s| - brother << s.to_vool + brother << s.to_sol end brother end diff --git a/lib/ruby/variables.rb b/lib/ruby/variables.rb index efddac64..784a3e8c 100644 --- a/lib/ruby/variables.rb +++ b/lib/ruby/variables.rb @@ -6,8 +6,8 @@ module Ruby @name = name end - def to_vool - vool_brother.new(@name) + def to_sol + sol_brother.new(@name) end def to_s(depth=0) name.to_s diff --git a/lib/ruby/while_statement.rb b/lib/ruby/while_statement.rb index 637bc750..34d08e5b 100644 --- a/lib/ruby/while_statement.rb +++ b/lib/ruby/while_statement.rb @@ -11,9 +11,9 @@ module Ruby @body = body end - def to_vool - cond , hoisted = *normalized_vool(@condition) - Vool::WhileStatement.new(cond , @body.to_vool , hoisted) + def to_sol + cond , hoisted = *normalized_sol(@condition) + Sol::WhileStatement.new(cond , @body.to_sol , hoisted) end def to_s(depth = 0) diff --git a/lib/rubyx.rb b/lib/rubyx.rb index 56d08fd8..d160d88b 100644 --- a/lib/rubyx.rb +++ b/lib/rubyx.rb @@ -6,7 +6,7 @@ require_relative "risc" require_relative "slot_machine/slot_machine" require_relative "arm/arm_machine" require_relative "arm/arm_platform" -require_relative "vool/statement" -require_relative "vool/builtin" +require_relative "sol/statement" +require_relative "sol/builtin" require_relative "ruby" require_relative "rubyx/rubyx_compiler" diff --git a/lib/rubyx/rubyx_compiler.rb b/lib/rubyx/rubyx_compiler.rb index 705d5e4e..18526352 100644 --- a/lib/rubyx/rubyx_compiler.rb +++ b/lib/rubyx/rubyx_compiler.rb @@ -3,7 +3,7 @@ module RubyX # give helper functions to create any intermediate layer. # Layers are: # - ruby , always needed as input, string - # - vool - intermediate language layer + # - sol - intermediate language layer # - slot_machine - intermediate machine layer # - risc - "last" intermediate machine layer # - target - arm or interpreter binary code @@ -13,19 +13,19 @@ module RubyX # There are methods to go from ruby to any of the layers in the system # (mainly for testing). ruby_to_binary creates actual binary code # for a given platform. - # The compiler keeps the vool source as an instance. - # To compile several sources, more vool can be added, ie ruby_to_vool + # The compiler keeps the sol source as an instance. + # To compile several sources, more sol can be added, ie ruby_to_sol # can be called several times. # # All other methods come in pairs, one takes ruby source (those are for testing) - # and the other uses the stored vool source for further processing. + # and the other uses the stored sol source for further processing. # # Only builtin is loaded, so no runtime , but the compiler # can be used to read the runtime and then any other code # class RubyXCompiler - attr_reader :vool , :options + attr_reader :sol , :options # initialize boots Parfait and Risc (ie load Builin) def initialize(options) @@ -35,7 +35,7 @@ module RubyX end # The highest level function creates binary code for the given ruby code - # for the given platform (see Platform). Binary code means that vool/slot_machine/risc + # for the given platform (see Platform). Binary code means that sol/slot_machine/risc # are created and then assembled into BinaryCode objects. # (no executable is generated, only the binary code and objects needed for a binary) # @@ -43,38 +43,38 @@ module RubyX # # The compiling is done by to_binary def ruby_to_binary(ruby , platform) - ruby_to_vool(ruby) + ruby_to_sol(ruby) to_binary(platform) end # ruby_to_target creates Target instructions (but does not link) # - # After creating vool, we call to_target + # After creating sol, we call to_target # Return a Linker def ruby_to_target(ruby , platform) - ruby_to_vool(ruby) + ruby_to_sol(ruby) to_target( platform ) end # ruby_to_risc creates Risc instructions # - # After creating vool, we call to_risc + # After creating sol, we call to_risc # Return a RiscCollection def ruby_to_risc(ruby) - ruby_to_vool(ruby) + ruby_to_sol(ruby) to_risc() end # Transform the incoming ruby source (string) to slot # - # The vool is stored using ruby_to_vool,the to_slot is called + # The sol is stored using ruby_to_sol,the to_slot is called # Return SlotMachine Statement def ruby_to_slot(ruby) - ruby_to_vool(ruby) + ruby_to_sol(ruby) to_slot end - # Process previously stored vool source to binary. + # Process previously stored sol source to binary. # Binary code is generated by calling to_risc, then positioning and calling # create_binary on the linker. The linker may then be used to creat a binary file. # The biary the method name refers to is binary code in memory, or in BinaryCode @@ -86,7 +86,7 @@ module RubyX linker end - # transform stored vool to target code + # transform stored sol to target code # return a linker def to_target(platform) raise "No platform given" unless platform @@ -94,46 +94,46 @@ module RubyX collection.translate(platform) end - # Process previously stored vool source to risc. + # Process previously stored sol source to risc. # return a Risc::RiscCollection , a collection of MethodCompilers def to_risc() slot = to_slot slot.to_risc() end - # return slot_machine for the previously stored vool source. + # return slot_machine for the previously stored sol source. def to_slot - @vool.to_parfait - @vool.to_slot(nil) + @sol.to_parfait + @sol.to_slot(nil) end - # ruby_to_vool compiles the ruby to ast, and then to vool - def ruby_to_vool(ruby_source) + # ruby_to_sol compiles the ruby to ast, and then to sol + def ruby_to_sol(ruby_source) ruby_tree = Ruby::RubyCompiler.compile( ruby_source ) - unless(@vool) - @vool = ruby_tree.to_vool - return @vool + unless(@sol) + @sol = ruby_tree.to_sol + return @sol end # TODO: should check if this works with reopening classes - # or whether we need to unify the vool for a class - unless(@vool.is_a?(Vool::ScopeStatement)) - @vool = Vool::ScopeStatement.new([@vool]) + # or whether we need to unify the sol for a class + unless(@sol.is_a?(Sol::ScopeStatement)) + @sol = Sol::ScopeStatement.new([@sol]) end - @vool << ruby_tree.to_vool + @sol << ruby_tree.to_sol end def load_parfait parfait = ["object"] parfait.each do |file| path = File.expand_path("../../parfait/#{file}.rb",__FILE__) - ruby_to_vool(File.read(path)) + ruby_to_sol(File.read(path)) end end def self.ruby_to_binary( ruby , options) compiler = RubyXCompiler.new(options) compiler.load_parfait if options[:load_parfait] - compiler.ruby_to_vool(ruby) + compiler.ruby_to_sol(ruby) compiler.to_binary(options[:platform]) end end diff --git a/lib/rubyx/rubyxc.rb b/lib/rubyx/rubyxc.rb index 14824af5..8bc30878 100644 --- a/lib/rubyx/rubyxc.rb +++ b/lib/rubyx/rubyxc.rb @@ -18,7 +18,7 @@ class RubyXC < Thor return {parfait: opt } end def get_preload - options[:preload] ? Vool::Builtin.builtin_code : "" + options[:preload] ? Sol::Builtin.builtin_code : "" end end diff --git a/lib/slot_machine/README.md b/lib/slot_machine/README.md index 8f3cecc4..01b630aa 100644 --- a/lib/slot_machine/README.md +++ b/lib/slot_machine/README.md @@ -1,7 +1,7 @@ # SlotMachine -This layer sits between the language layer (vool) and the risc machine layer. -It is meant to make the transition (between vool and risc) easier to understand. +This layer sits between the language layer (sol) and the risc machine layer. +It is meant to make the transition (between sol and risc) easier to understand. Previous efforts were doing the transition without an intermediate layer. But while this was possible, it was more difficult than need be, and so we go to the old saying @@ -13,17 +13,17 @@ A little recap of why the transition was too steep will naturally reveal the des ### Structure -Vool has a tree structure. Risc is a linked list, so essentially flat. +Sol has a tree structure. Risc is a linked list, so essentially flat. ### Memory model -Vool has no memory, it has objects and they just are. Risc on the other hand has only registers +Sol has no memory, it has objects and they just are. Risc on the other hand has only registers and memory. Data can only move to/from/between registers, ie not from memory to memory. While Risc knows about objects, it deals in machine words. ### Execution model -Vool's implicit execution model would be interpretation, ie tree traversal. Vool has high level +Sol's implicit execution model would be interpretation, ie tree traversal. Sol has high level control structures, including send, and no goto, it is a language after all. Risc is close to a cpu, it has a current instruction (pc), registers (8) and a register based @@ -32,7 +32,7 @@ used (stacks are messy, not oo) ## Design -The *essential* step from vool to risc, is the one from a language to a machine. From statements +The *essential* step from sol to risc, is the one from a language to a machine. From statements that hang in the air, to an instruction set. So to put a layer in the middle of those two, SlotMachine will be: diff --git a/lib/slot_machine/instruction.rb b/lib/slot_machine/instruction.rb index 9c2302de..54c09e47 100644 --- a/lib/slot_machine/instruction.rb +++ b/lib/slot_machine/instruction.rb @@ -3,7 +3,7 @@ module SlotMachine # Base class for SlotMachine instructions # At the base class level instructions are a linked list. # - # SlotMachine::Instructions are created by the Vool level as an intermediate step + # SlotMachine::Instructions are created by the Sol level as an intermediate step # towards the next level down, the Risc level. # SlotMachine and Risc are both abstract machines (ie have instructions), so both # share the linked list functionality (In Util::List) @@ -18,7 +18,7 @@ module SlotMachine @next = nekst return unless source unless source.is_a?(String) or - source.is_a?(Vool::Statement) + source.is_a?(Sol::Statement) raise "Source must be string or Instruction, not #{source.class}" end end diff --git a/lib/slot_machine/instruction/basic_values.rb b/lib/slot_machine/instruction/basic_values.rb index ea5da0c5..838d7c7b 100644 --- a/lib/slot_machine/instruction/basic_values.rb +++ b/lib/slot_machine/instruction/basic_values.rb @@ -1,7 +1,7 @@ module SlotMachine # just name scoping the same stuff to slot # so we know we are on the way down, keeping our layers seperated - # and we can put constant adding into the to_risc methods (instead of on vool classes) + # and we can put constant adding into the to_risc methods (instead of on sol classes) class Constant end diff --git a/lib/slot_machine/instruction/block_yield.rb b/lib/slot_machine/instruction/block_yield.rb index a68dc563..66023c1b 100644 --- a/lib/slot_machine/instruction/block_yield.rb +++ b/lib/slot_machine/instruction/block_yield.rb @@ -6,7 +6,7 @@ module SlotMachine class BlockYield < Instruction attr :arg_index - # pass in the source (vool statement) and the index. + # pass in the source (sol statement) and the index. # The index is the argument index of the block that we call def initialize(source , index) super(source) diff --git a/lib/slot_machine/instruction/dynamic_call.rb b/lib/slot_machine/instruction/dynamic_call.rb index 26d82cf9..a45782ca 100644 --- a/lib/slot_machine/instruction/dynamic_call.rb +++ b/lib/slot_machine/instruction/dynamic_call.rb @@ -9,7 +9,7 @@ module SlotMachine # # Setting up the method is not part of this instructions scope. That setup # includes the type check and any necccessay method resolution. - # See vool send statement + # See sol send statement # class DynamicCall < Instruction attr :cache_entry diff --git a/lib/slot_machine/instruction/resolve_method.rb b/lib/slot_machine/instruction/resolve_method.rb index 10077ce1..7f4d743a 100644 --- a/lib/slot_machine/instruction/resolve_method.rb +++ b/lib/slot_machine/instruction/resolve_method.rb @@ -15,7 +15,7 @@ module SlotMachine class ResolveMethod < Instruction attr :cache_entry , :name - # pass in source (VoolStatement) + # pass in source (SolStatement) # name of the method (don't knwow the actaual method) # and the cache_entry def initialize(source , name , cache_entry) diff --git a/lib/slot_machine/instruction/return_jump.rb b/lib/slot_machine/instruction/return_jump.rb index c36d899a..fb3f9d2d 100644 --- a/lib/slot_machine/instruction/return_jump.rb +++ b/lib/slot_machine/instruction/return_jump.rb @@ -9,7 +9,7 @@ module SlotMachine attr_reader :return_label - # pass in the source_name (string/vool_instruction) for accounting purposes + # pass in the source_name (string/sol_instruction) for accounting purposes # and the return_label, where we actually jump to. This is set up by the # method_compiler, so it is easy to find (see return_label in compiler) def initialize( source , label ) diff --git a/lib/slot_machine/macro/method_missing.rb b/lib/slot_machine/macro/method_missing.rb index d9d0f4b5..af2faa37 100644 --- a/lib/slot_machine/macro/method_missing.rb +++ b/lib/slot_machine/macro/method_missing.rb @@ -4,7 +4,7 @@ module SlotMachine def initialize( source , name ) super(source) - name = name.value if name.is_a?(Vool::SymbolConstant) + name = name.value if name.is_a?(Sol::SymbolConstant) raise "No reg #{name.class}" unless name.class == Symbol @name = name end diff --git a/lib/slot_machine/slot_collection.rb b/lib/slot_machine/slot_collection.rb index 905daa4c..3f265292 100644 --- a/lib/slot_machine/slot_collection.rb +++ b/lib/slot_machine/slot_collection.rb @@ -2,8 +2,8 @@ module SlotMachine # The Compiler/Collection for the SlotMachine level is a collection of SlotMachine level Method # compilers These will transform to Risc MethodCompilers on the way down. # - # As RubyCompiler pools source at the vool level, when several classes are compiled - # from vool to slot, several SlotMachineCompilers get instantiated. They must be merged before + # As RubyCompiler pools source at the sol level, when several classes are compiled + # from sol to slot, several SlotMachineCompilers get instantiated. They must be merged before # proceeding with translate. Thus we have a append method. # class SlotCollection diff --git a/lib/slot_machine/slot_machine.rb b/lib/slot_machine/slot_machine.rb index bc9c2f86..22bc0223 100644 --- a/lib/slot_machine/slot_machine.rb +++ b/lib/slot_machine/slot_machine.rb @@ -1,5 +1,5 @@ -# The *essential* step from vool to risc, is the one from a language to a machine. -# From vools statements that hang in the air, to an instruction set. +# The *essential* step from sol to risc, is the one from a language to a machine. +# From sols statements that hang in the air, to an instruction set. # # ### List based: Bit like Risc, just no registers # diff --git a/lib/vool/README.md b/lib/sol/README.md similarity index 78% rename from lib/vool/README.md rename to lib/sol/README.md index 675803b8..19a5d6d9 100644 --- a/lib/vool/README.md +++ b/lib/sol/README.md @@ -1,6 +1,6 @@ -# VOOL +# SOL -Virtual Object Oriented Language +Simple Object Language -------------------------------- in other words, ruby without the fluff. @@ -9,10 +9,10 @@ Possibly later other languages can compile to this level and use rx-file as code ## Syntax tree -Vool is a layer with concrete syntax tree, just like the ruby layer above. -Vool is just simplified, without fluff, see below. +Sol is a layer with concrete syntax tree, just like the ruby layer above. +Sol is just simplified, without fluff, see below. -The next layer down is the SlotMachine, Minimal object Machine, which uses an instruction list. +The next layer down is the SlotMachine, which uses an instruction list. The nodes of the syntax tree are all the things one would expect from a language, if statements and the like. There is no context yet, and actual objects, diff --git a/lib/vool/assignment.rb b/lib/sol/assignment.rb similarity index 99% rename from lib/vool/assignment.rb rename to lib/sol/assignment.rb index c37882a1..ab4081c9 100644 --- a/lib/vool/assignment.rb +++ b/lib/sol/assignment.rb @@ -1,4 +1,4 @@ -module Vool +module Sol # Base class for assignments (local/ivar), works just as you'd expect # Only "quirk" maybe, that arguments are like locals diff --git a/lib/vool/basic_values.rb b/lib/sol/basic_values.rb similarity index 92% rename from lib/vool/basic_values.rb rename to lib/sol/basic_values.rb index 078fc74e..f35a5e36 100644 --- a/lib/vool/basic_values.rb +++ b/lib/sol/basic_values.rb @@ -1,9 +1,9 @@ -module Vool +module Sol #Marker class for different constants class Constant < Expression end - # An integer at the vool level + # An integer at the sol level class IntegerConstant < Constant attr_reader :value def initialize(value) @@ -19,7 +19,7 @@ module Vool value.to_s end end - # An float at the vool level + # An float at the sol level class FloatConstant < Constant attr_reader :value def initialize(value) @@ -32,7 +32,7 @@ module Vool value.to_s end end - # True at the vool level + # True at the sol level class TrueConstant < Constant def ct_type Parfait.object_space.get_type_by_class_name(:True) @@ -44,7 +44,7 @@ module Vool "true" end end - # False at the vool level + # False at the sol level class FalseConstant < Constant def ct_type Parfait.object_space.get_type_by_class_name(:False) @@ -56,7 +56,7 @@ module Vool "false" end end - # Nil at the vool level + # Nil at the sol level class NilConstant < Constant def ct_type Parfait.object_space.get_type_by_class_name(:Nil) @@ -69,7 +69,7 @@ module Vool end end - # Self at the vool level + # Self at the sol level class SelfExpression < Expression attr_reader :my_type def initialize(type = nil) diff --git a/lib/vool/builtin.rb b/lib/sol/builtin.rb similarity index 99% rename from lib/vool/builtin.rb rename to lib/sol/builtin.rb index 1a2fdde6..ee87f6fe 100644 --- a/lib/vool/builtin.rb +++ b/lib/sol/builtin.rb @@ -1,4 +1,4 @@ -module Vool +module Sol module Builtin def self.boot_methods(options) return if options[:boot_methods] == false diff --git a/lib/vool/call_statement.rb b/lib/sol/call_statement.rb similarity index 98% rename from lib/vool/call_statement.rb rename to lib/sol/call_statement.rb index ae1da4d8..5efa99fc 100644 --- a/lib/vool/call_statement.rb +++ b/lib/sol/call_statement.rb @@ -1,4 +1,4 @@ -module Vool +module Sol class CallStatement < Statement attr_reader :name , :receiver , :arguments diff --git a/lib/vool/class_expression.rb b/lib/sol/class_expression.rb similarity index 97% rename from lib/vool/class_expression.rb rename to lib/sol/class_expression.rb index 6f493606..782b0fab 100644 --- a/lib/vool/class_expression.rb +++ b/lib/sol/class_expression.rb @@ -1,5 +1,5 @@ -module Vool - # This represents a class at the vool level. Vool is a syntax tree, +module Sol + # This represents a class at the sol level. Sol is a syntax tree, # so here the only child (or children) is a body. # Body may either be a MethodStatement, or Statements (either empty or # containing MethodStatement) diff --git a/lib/vool/class_method_expression.rb b/lib/sol/class_method_expression.rb similarity index 85% rename from lib/vool/class_method_expression.rb rename to lib/sol/class_method_expression.rb index cc2d805d..86a5bfe1 100644 --- a/lib/vool/class_method_expression.rb +++ b/lib/sol/class_method_expression.rb @@ -1,4 +1,4 @@ -module Vool +module Sol class ClassMethodExpression < Expression attr_reader :name, :args , :body @@ -7,14 +7,14 @@ module Vool raise "no bod" unless @body end - # create the parfait VoolMethod to hold the code for this method + # create the parfait SolMethod to hold the code for this method # # Must pass in the actual Parfait class (default nil is just to conform to api) def to_parfait( clazz = nil ) raise "No class given to class method #{name}" unless clazz - vool_m = clazz.single_class.create_instance_method_for(name , make_arg_type , make_frame , body ) - vool_m.create_callable_method_for(clazz.single_class.instance_type) - vool_m + sol_m = clazz.single_class.create_instance_method_for(name , make_arg_type , make_frame , body ) + sol_m.create_callable_method_for(clazz.single_class.instance_type) + sol_m end def to_slot(clazz) diff --git a/lib/vool/if_statement.rb b/lib/sol/if_statement.rb similarity index 99% rename from lib/vool/if_statement.rb rename to lib/sol/if_statement.rb index 375d2f37..840b5da2 100644 --- a/lib/vool/if_statement.rb +++ b/lib/sol/if_statement.rb @@ -1,5 +1,5 @@ -module Vool +module Sol class IfStatement < Statement attr_reader :condition , :if_true , :if_false diff --git a/lib/vool/ivar_assignment.rb b/lib/sol/ivar_assignment.rb similarity index 97% rename from lib/vool/ivar_assignment.rb rename to lib/sol/ivar_assignment.rb index a7f723c2..cf1a7d2d 100644 --- a/lib/vool/ivar_assignment.rb +++ b/lib/sol/ivar_assignment.rb @@ -1,4 +1,4 @@ -module Vool +module Sol class IvarAssignment < Assignment diff --git a/lib/vool/lambda_expression.rb b/lib/sol/lambda_expression.rb similarity index 99% rename from lib/vool/lambda_expression.rb rename to lib/sol/lambda_expression.rb index 524799b0..3ebf38f9 100644 --- a/lib/vool/lambda_expression.rb +++ b/lib/sol/lambda_expression.rb @@ -1,4 +1,4 @@ -module Vool +module Sol class LambdaExpression < Expression attr_reader :args , :body , :clazz diff --git a/lib/vool/local_assignment.rb b/lib/sol/local_assignment.rb similarity index 98% rename from lib/vool/local_assignment.rb rename to lib/sol/local_assignment.rb index 85019b0a..fa686679 100644 --- a/lib/vool/local_assignment.rb +++ b/lib/sol/local_assignment.rb @@ -1,4 +1,4 @@ -module Vool +module Sol # Local assignment really only differs in where the variable is actually stored, # slot_position defines that diff --git a/lib/vool/macro_expression.rb b/lib/sol/macro_expression.rb similarity index 98% rename from lib/vool/macro_expression.rb rename to lib/sol/macro_expression.rb index ef64f534..d74a2660 100644 --- a/lib/vool/macro_expression.rb +++ b/lib/sol/macro_expression.rb @@ -1,4 +1,4 @@ -module Vool +module Sol class MacroExpression < CallStatement diff --git a/lib/vool/method_expression.rb b/lib/sol/method_expression.rb similarity index 86% rename from lib/vool/method_expression.rb rename to lib/sol/method_expression.rb index 86c36208..ae310c75 100644 --- a/lib/vool/method_expression.rb +++ b/lib/sol/method_expression.rb @@ -1,14 +1,14 @@ -module Vool +module Sol class MethodExpression < Expression attr_reader :name, :args , :body def initialize( name , args , body ) @name , @args , @body = name , args , body raise "no bod" unless @body - raise "Not Vool #{@body}" unless @body.is_a?(Statement) + raise "Not Sol #{@body}" unless @body.is_a?(Statement) end - # create the parfait VoolMethod to hold the code for this method + # create the parfait SolMethod to hold the code for this method # # Must pass in the actual Parfait class (default nil is just to conform to api) def to_parfait( clazz = nil ) @@ -17,9 +17,9 @@ module Vool #FIXME , should check arg_type, and if the same, clear method and ok raise "Redefining #{clazz.name}.#{name} not supported #{method}" end - vool_m = clazz.create_instance_method_for(name , make_arg_type , make_frame , body ) - vool_m.create_callable_method_for(clazz.instance_type) - vool_m + sol_m = clazz.create_instance_method_for(name , make_arg_type , make_frame , body ) + sol_m.create_callable_method_for(clazz.instance_type) + sol_m end # Creates the SlotMachine::MethodCompiler that will do the next step diff --git a/lib/vool/return_statement.rb b/lib/sol/return_statement.rb similarity index 98% rename from lib/vool/return_statement.rb rename to lib/sol/return_statement.rb index 85401795..af06e269 100644 --- a/lib/vool/return_statement.rb +++ b/lib/sol/return_statement.rb @@ -1,4 +1,4 @@ -module Vool +module Sol class ReturnStatement < Statement attr_reader :return_value diff --git a/lib/vool/send_statement.rb b/lib/sol/send_statement.rb similarity index 88% rename from lib/vool/send_statement.rb rename to lib/sol/send_statement.rb index 9bf4cf3a..e81edf92 100644 --- a/lib/vool/send_statement.rb +++ b/lib/sol/send_statement.rb @@ -1,4 +1,4 @@ -module Vool +module Sol # Sending in a dynamic language is off course not as simple as just calling. # The function that needs to be called depends after all on the receiver, # and no guarantees can be made on what that is. @@ -37,8 +37,8 @@ module Vool # # A slight complication occurs for methods defined in superclasses. Since we are # type, not class, based, these are not part of our type. - # So we check, and if find, add the source (vool_method) to the class and start - # compiling the vool for the receiver_type + # So we check, and if find, add the source (sol_method) to the class and start + # compiling the sol for the receiver_type # def to_slot( compiler ) @receiver = SelfExpression.new(compiler.receiver_type) if @receiver.is_a?(SelfExpression) @@ -53,14 +53,14 @@ module Vool # If a method is found in the class (not the type) # we add it to the class that the receiver type represents, and create a compiler - # to compile the vool for the specific type (the receiver) + # to compile the sol for the specific type (the receiver) def create_method_from_source(compiler) - vool_method = @receiver.ct_type.object_class.resolve_method!(@name) - return nil unless vool_method - #puts "#{vool_method.name} , adding to #{@receiver.ct_type.object_class.name}" - @receiver.ct_type.object_class.add_instance_method(vool_method) - vool_method.create_callable_method_for(@receiver.ct_type) - new_compiler = vool_method.compiler_for(@receiver.ct_type) + sol_method = @receiver.ct_type.object_class.resolve_method!(@name) + return nil unless sol_method + #puts "#{sol_method.name} , adding to #{@receiver.ct_type.object_class.name}" + @receiver.ct_type.object_class.add_instance_method(sol_method) + sol_method.create_callable_method_for(@receiver.ct_type) + new_compiler = sol_method.compiler_for(@receiver.ct_type) compiler.add_method_compiler(new_compiler) new_compiler.callable end diff --git a/lib/vool/statement.rb b/lib/sol/statement.rb similarity index 89% rename from lib/vool/statement.rb rename to lib/sol/statement.rb index 8dab4ebb..d68ac84f 100644 --- a/lib/vool/statement.rb +++ b/lib/sol/statement.rb @@ -1,17 +1,16 @@ -# Virtual -# Object Oriented -# Language # -# VOOL is the abstraction of ruby: ruby minus the fluff +# SOL -- Simple Object Language +# +# SOL is the abstraction of ruby: ruby minus the fluff # fluff is generally what makes ruby nice to use, like 3 ways to achieve the same thing # if/unless/ternary , reverse ifs (ie statement if condition), reverse whiles, # implicit blocks, splats and multiple assigns etc # -# Vool has expression and statements, revealing that age old dichotomy of code and +# Sol has expression and statements, revealing that age old dichotomy of code and # data. Statements represent code whereas Expressions resolve to data. # (in ruby there are no pure statements, everthing resolves to data) # -# Vool resolves to SlotMachine in the next step down. But it also the place where we create +# Sol resolves to SlotMachine in the next step down. But it also the place where we create # Parfait representations for the main oo players, ie classes and methods. # The protocol is thus two stage: # - first to_parfait with implicit side-effects of creating parfait objects that @@ -19,13 +18,13 @@ # - second to_slot , which will return a slot version of the statement. This may be code # or a compiler (for methods), or compiler collection (for classes) # -module Vool +module Sol # Base class for all statements in the tree. Derived classes correspond to known language # constructs # # Basically Statements represent code, generally speaking code "does things". - # But Vool distinguishes Expressions (see below), that represent data, and as such + # But Sol distinguishes Expressions (see below), that represent data, and as such # don't do things themselves, rather passively participate in being pushed around class Statement diff --git a/lib/vool/statements.rb b/lib/sol/statements.rb similarity index 99% rename from lib/vool/statements.rb rename to lib/sol/statements.rb index b570d7eb..071219cc 100644 --- a/lib/vool/statements.rb +++ b/lib/sol/statements.rb @@ -1,4 +1,4 @@ -module Vool +module Sol class Statements < Statement attr_reader :statements def initialize(statements) diff --git a/lib/vool/super_statement.rb b/lib/sol/super_statement.rb similarity index 80% rename from lib/vool/super_statement.rb rename to lib/sol/super_statement.rb index 740be26b..5a545da2 100644 --- a/lib/vool/super_statement.rb +++ b/lib/sol/super_statement.rb @@ -1,4 +1,4 @@ -module Vool +module Sol class SuperStatement < SendStatement end diff --git a/lib/vool/variables.rb b/lib/sol/variables.rb similarity index 99% rename from lib/vool/variables.rb rename to lib/sol/variables.rb index 03251818..a93f5c2d 100644 --- a/lib/vool/variables.rb +++ b/lib/sol/variables.rb @@ -1,4 +1,4 @@ -module Vool +module Sol module Named attr_reader :name def initialize name diff --git a/lib/vool/while_statement.rb b/lib/sol/while_statement.rb similarity index 98% rename from lib/vool/while_statement.rb rename to lib/sol/while_statement.rb index 404aa735..dbd5123f 100644 --- a/lib/vool/while_statement.rb +++ b/lib/sol/while_statement.rb @@ -1,5 +1,5 @@ -module Vool +module Sol class WhileStatement < Statement attr_reader :condition , :body , :hoisted diff --git a/lib/vool/yield_statement.rb b/lib/sol/yield_statement.rb similarity index 99% rename from lib/vool/yield_statement.rb rename to lib/sol/yield_statement.rb index be6ce139..74f1c8e8 100644 --- a/lib/vool/yield_statement.rb +++ b/lib/sol/yield_statement.rb @@ -1,4 +1,4 @@ -module Vool +module Sol # A Yield is a lot like a Send, which is why they share the base class CallStatement # That means it has a receiver (self), arguments and an (implicitly assigned) name diff --git a/test/parfait/test_vool_method.rb b/test/parfait/test_sol_method.rb similarity index 78% rename from test/parfait/test_vool_method.rb rename to test/parfait/test_sol_method.rb index 0e3657f0..ca2d165c 100644 --- a/test/parfait/test_vool_method.rb +++ b/test/parfait/test_sol_method.rb @@ -1,13 +1,13 @@ require_relative "helper" -module Vool - class TestVoolMethod < MiniTest::Test - include VoolCompile +module Sol + class TestSolMethod < MiniTest::Test + include SolCompile def setup Parfait.boot!(Parfait.default_test_options) ruby_tree = Ruby::RubyCompiler.compile( as_main("a = 5") ) - @clazz = ruby_tree.to_vool + @clazz = ruby_tree.to_sol end def method @clazz.body.first @@ -22,7 +22,7 @@ module Vool end def test_method clazz = @clazz.to_parfait - assert_equal Parfait::VoolMethod , clazz.get_instance_method(:main).class + assert_equal Parfait::SolMethod , clazz.get_instance_method(:main).class end def test_type_method clazz = @clazz.to_parfait diff --git a/test/parfait/test_space.rb b/test/parfait/test_space.rb index 4be62b87..5a39a562 100644 --- a/test/parfait/test_space.rb +++ b/test/parfait/test_space.rb @@ -7,7 +7,7 @@ module Parfait [:Behaviour ,:BinaryCode,:Block,:CacheEntry,:Callable,:CallableMethod,:Class, :DataObject,:Data4,:Data8,:Data16,:Data32,:Dictionary,:Factory, :Integer,:FalseClass, :List,:Message, :SingletonClass,:NilClass,:Object,:ReturnAddress, - :Space,:TrueClass,:Type,:VoolMethod,:Word] + :Space,:TrueClass,:Type,:SolMethod,:Word] end def test_space_length diff --git a/test/ruby/helper.rb b/test/ruby/helper.rb index eb3425ed..1f694257 100644 --- a/test/ruby/helper.rb +++ b/test/ruby/helper.rb @@ -12,9 +12,9 @@ module Ruby def compile_main(input) RubyCompiler.compile(as_main(input)) end - def compile_main_vool(input) + def compile_main_sol(input) xcompiler = RubyX::RubyXCompiler.new(RubyX.default_test_options) - xcompiler.ruby_to_vool(as_main(input)) + xcompiler.ruby_to_sol(as_main(input)) end def assert_raises_muted &block @@ -28,25 +28,25 @@ module Ruby include RubyTests def setup super - @vool = compile( "class Tryout < Base; #{attr_def};end" ).to_vool + @sol = compile( "class Tryout < Base; #{attr_def};end" ).to_sol end def getter - @vool.body.statements.first + @sol.body.statements.first end def setter - @vool.body.statements.last + @sol.body.statements.last end def test_class - assert_equal Vool::ClassExpression , @vool.class + assert_equal Sol::ClassExpression , @sol.class end def test_body - assert_equal Vool::Statements , @vool.body.class + assert_equal Sol::Statements , @sol.body.class end def test_getter - assert_equal Vool::MethodExpression , getter.class + assert_equal Sol::MethodExpression , getter.class end def test_getter_return - assert_equal Vool::ReturnStatement , getter.body.class + assert_equal Sol::ReturnStatement , getter.body.class end def test_getter_name assert_equal :page , getter.name diff --git a/test/ruby/test_assignment.rb b/test/ruby/test_assignment.rb index ed463ff2..1dfb2c82 100644 --- a/test/ruby/test_assignment.rb +++ b/test/ruby/test_assignment.rb @@ -25,46 +25,46 @@ module Ruby assert_equal IvarAssignment , lst.class end end - class TestAssignmentVoolLocal < MiniTest::Test + class TestAssignmentSolLocal < MiniTest::Test include RubyTests def setup - @lst = compile( "foo = bar").to_vool + @lst = compile( "foo = bar").to_sol end def test_tos assert_equal "foo = self.bar()" , @lst.to_s end def test_local - assert_equal Vool::LocalAssignment , @lst.class + assert_equal Sol::LocalAssignment , @lst.class end def test_bar - assert_equal Vool::SendStatement , @lst.value.class + assert_equal Sol::SendStatement , @lst.value.class end def test_local_name assert_equal :foo , @lst.name end end - class TestAssignmentVoolInst < MiniTest::Test + class TestAssignmentSolInst < MiniTest::Test include RubyTests def setup - @lst = compile( "@foo = bar").to_vool + @lst = compile( "@foo = bar").to_sol end def test_tos assert_equal "@foo = self.bar()" , @lst.to_s end def test_instance - assert_equal Vool::IvarAssignment , @lst.class + assert_equal Sol::IvarAssignment , @lst.class end def test_instance_name assert_equal :foo , @lst.name end end - class TestAssignmentVoolConst < MiniTest::Test + class TestAssignmentSolConst < MiniTest::Test include RubyTests def setup - @lst = compile( "foo = 5").to_vool + @lst = compile( "foo = 5").to_sol end def test_const - assert_equal Vool::IntegerConstant , @lst.value.class + assert_equal Sol::IntegerConstant , @lst.value.class end end end diff --git a/test/ruby/test_assignment1.rb b/test/ruby/test_assignment1.rb index c9ba8f5e..0362858c 100644 --- a/test/ruby/test_assignment1.rb +++ b/test/ruby/test_assignment1.rb @@ -1,30 +1,30 @@ require_relative "helper" module Ruby - class TestVoolCallMulti2 < MiniTest::Test + class TestSolCallMulti2 < MiniTest::Test include RubyTests include RubyTests def setup - @lst = compile( "@foo = a.call(b)").to_vool + @lst = compile( "@foo = a.call(b)").to_sol end def test_class - assert_equal Vool::Statements , @lst.class + assert_equal Sol::Statements , @lst.class end def test_first_class - assert_equal Vool::LocalAssignment , @lst[0].class + assert_equal Sol::LocalAssignment , @lst[0].class end def test_first_name assert @lst[0].name.to_s.start_with?("tmp_") end def test_second_class - assert_equal Vool::LocalAssignment , @lst[1].class + assert_equal Sol::LocalAssignment , @lst[1].class end def test_second_name assert @lst[1].name.to_s.start_with?("tmp_") end def test_last_class - assert_equal Vool::IvarAssignment , @lst[2].class + assert_equal Sol::IvarAssignment , @lst[2].class end def test_second_name assert_equal :foo, @lst[2].name diff --git a/test/ruby/test_basic_values.rb b/test/ruby/test_basic_values.rb index e24ef963..42a427be 100644 --- a/test/ruby/test_basic_values.rb +++ b/test/ruby/test_basic_values.rb @@ -79,7 +79,7 @@ module Ruby assert_equal TrueConstant , compile_const( "true") end end - class TestBasicTypesVool < MiniTest::Test + class TestBasicTypesSol < MiniTest::Test include RubyTests def setup @@ -87,7 +87,7 @@ module Ruby end def compile_const( input ) lst = compile( input ) - lst.to_vool.to_s + lst.to_sol.to_s end def test_integer assert_equal "123" , compile_const( "123") diff --git a/test/ruby/test_class_method_statement.rb b/test/ruby/test_class_method_statement.rb index a05a55bc..4987ed34 100644 --- a/test/ruby/test_class_method_statement.rb +++ b/test/ruby/test_class_method_statement.rb @@ -40,35 +40,35 @@ module Ruby def setup() input = "def self.tryout(arg1, arg2) ; a = arg1 ; end " - @lst = compile( input ).to_vool + @lst = compile( input ).to_sol end def test_method - assert_equal Vool::ClassMethodExpression , @lst.class + assert_equal Sol::ClassMethodExpression , @lst.class end def test_method_args assert_equal [:arg1, :arg2] , @lst.args end def test_body_is_scope_zero_statement - assert_equal Vool::Statements , @lst.body.class + assert_equal Sol::Statements , @lst.body.class end def test_body_is_scope_zero_statement - assert_equal Vool::LocalAssignment , @lst.body.first.class + assert_equal Sol::LocalAssignment , @lst.body.first.class end end class TestClassMethodStatementImplicitReturn < MiniTest::Test include RubyTests def setup() input = "def self.tryout(arg1, arg2) ; arg1 ; end " - @lst = compile( input ).to_vool + @lst = compile( input ).to_sol end def test_method - assert_equal Vool::ClassMethodExpression , @lst.class + assert_equal Sol::ClassMethodExpression , @lst.class end def test_method_args assert_equal [:arg1, :arg2] , @lst.args end def test_body_is_scope_zero_statement - assert_equal Vool::ReturnStatement , @lst.body.class + assert_equal Sol::ReturnStatement , @lst.body.class end end class TestClassMethodStatement < MiniTest::Test diff --git a/test/ruby/test_class_statement.rb b/test/ruby/test_class_statement.rb index 2bbddd6e..75a29f39 100644 --- a/test/ruby/test_class_statement.rb +++ b/test/ruby/test_class_statement.rb @@ -1,24 +1,24 @@ require_relative "helper" module Ruby - class TestClassStatementVool < MiniTest::Test + class TestClassStatementSol < MiniTest::Test include RubyTests def setup input = "class Tryout < Base;def meth; a = 5 ;end; end" - @vool = compile( input ).to_vool + @sol = compile( input ).to_sol end def test_class - assert_equal Vool::ClassExpression , @vool.class + assert_equal Sol::ClassExpression , @sol.class end def test_body - assert_equal Vool::Statements , @vool.body.class + assert_equal Sol::Statements , @sol.body.class end def test_compile_class_name - assert_equal :Tryout , @vool.name + assert_equal :Tryout , @sol.name end def test_compile_class_super - assert_equal :Base , @vool.super_class_name + assert_equal :Base , @sol.super_class_name end end @@ -63,15 +63,15 @@ module Ruby def test_if input = "class Tryout < Base; false if(true) ; end" - assert_raises_muted { compile( input ).to_vool} + assert_raises_muted { compile( input ).to_sol} end def test_instance input = "class Tryout < Base; @var = 5 ; end" - assert_raises_muted { compile( input ).to_vool} + assert_raises_muted { compile( input ).to_sol} end def test_wrong_send input = "class Tryout < Base; hi() ; end" - assert_raises_muted { compile( input ).to_vool} + assert_raises_muted { compile( input ).to_sol} end end end diff --git a/test/ruby/test_class_statement2.rb b/test/ruby/test_class_statement2.rb index 6edcbd89..5dca4e3c 100644 --- a/test/ruby/test_class_statement2.rb +++ b/test/ruby/test_class_statement2.rb @@ -9,18 +9,18 @@ module Ruby end def test_method_len - assert_equal 2 , @vool.body.length , "setter, getter" + assert_equal 2 , @sol.body.length , "setter, getter" end def test_setter - assert_equal Vool::MethodExpression , setter.class + assert_equal Sol::MethodExpression , setter.class end def test_setter_assign - assert_equal Vool::Statements , setter.body.class - assert_equal Vool::IvarAssignment , setter.body.first.class + assert_equal Sol::Statements , setter.body.class + assert_equal Sol::IvarAssignment , setter.body.first.class end def test_setter_return - assert_equal Vool::Statements , setter.body.class - assert_equal Vool::ReturnStatement , setter.body.last.class + assert_equal Sol::Statements , setter.body.class + assert_equal Sol::ReturnStatement , setter.body.last.class end def test_setter_name assert_equal :page= , setter.name @@ -36,7 +36,7 @@ module Ruby "attr_reader :page" end def test_method_len - assert_equal 1 , @vool.body.length , "setter, getter" + assert_equal 1 , @sol.body.length , "setter, getter" end end diff --git a/test/ruby/test_class_statement3.rb b/test/ruby/test_class_statement3.rb index 5e9b2d23..05400a8e 100644 --- a/test/ruby/test_class_statement3.rb +++ b/test/ruby/test_class_statement3.rb @@ -8,18 +8,18 @@ module Ruby "attr :page , :size" end def test_method_len - assert_equal 4 , @vool.body.length , "2 setters, 2 getters" + assert_equal 4 , @sol.body.length , "2 setters, 2 getters" end def test_setter - assert_equal Vool::MethodExpression , setter.class + assert_equal Sol::MethodExpression , setter.class end def test_setter_assign - assert_equal Vool::Statements , setter.body.class - assert_equal Vool::IvarAssignment , setter.body.first.class + assert_equal Sol::Statements , setter.body.class + assert_equal Sol::IvarAssignment , setter.body.first.class end def test_setter_return - assert_equal Vool::Statements , setter.body.class - assert_equal Vool::ReturnStatement , setter.body.last.class + assert_equal Sol::Statements , setter.body.class + assert_equal Sol::ReturnStatement , setter.body.last.class end def test_setter_name assert_equal :size= , setter.name diff --git a/test/ruby/test_if_statement2.rb b/test/ruby/test_if_statement2.rb index 98b13dc1..bc02d93e 100644 --- a/test/ruby/test_if_statement2.rb +++ b/test/ruby/test_if_statement2.rb @@ -1,51 +1,51 @@ require_relative 'helper' module Ruby - class TestIfStatementVool < MiniTest::Test + class TestIfStatementSol < MiniTest::Test include RubyTests def setup - @lst = compile("if(true) ; a = 1 ; else ; a = 2 ; end").to_vool + @lst = compile("if(true) ; a = 1 ; else ; a = 2 ; end").to_sol end def test_class - assert_equal Vool::IfStatement , @lst.class + assert_equal Sol::IfStatement , @lst.class end def test_true - assert_equal Vool::LocalAssignment , @lst.if_true.class + assert_equal Sol::LocalAssignment , @lst.if_true.class assert @lst.has_true? end def test_false - assert_equal Vool::LocalAssignment , @lst.if_false.class + assert_equal Sol::LocalAssignment , @lst.if_false.class assert @lst.has_false? end def test_condition - assert_equal Vool::TrueConstant , @lst.condition.class + assert_equal Sol::TrueConstant , @lst.condition.class end def test_to_s assert_tos "if (true);a = 1;else;a = 2;end" , @lst end end - class TestIfStatementVoolHoisted < MiniTest::Test + class TestIfStatementSolHoisted < MiniTest::Test include RubyTests def setup - @lst = compile("if(foo() == 1) ; a = 1 ; end").to_vool + @lst = compile("if(foo() == 1) ; a = 1 ; end").to_sol end def test_class - assert_equal Vool::Statements , @lst.class + assert_equal Sol::Statements , @lst.class end def test_first_class - assert_equal Vool::LocalAssignment , @lst.first.class + assert_equal Sol::LocalAssignment , @lst.first.class end def test_last_class - assert_equal Vool::IfStatement , @lst.last.class + assert_equal Sol::IfStatement , @lst.last.class end def test_true - assert_equal Vool::LocalAssignment , @lst.last.if_true.class + assert_equal Sol::LocalAssignment , @lst.last.if_true.class end def test_condition - assert_equal Vool::SendStatement , @lst.last.condition.class + assert_equal Sol::SendStatement , @lst.last.condition.class assert_equal :== , @lst.last.condition.name end end diff --git a/test/ruby/test_macro_expression.rb b/test/ruby/test_macro_expression.rb index bdd55cc8..d85d1113 100644 --- a/test/ruby/test_macro_expression.rb +++ b/test/ruby/test_macro_expression.rb @@ -25,13 +25,13 @@ module Ruby class TestPlusEquals < Minitest::Test include RubyTests def setup - @lst = compile( "X.plus_equals(1)").to_vool + @lst = compile( "X.plus_equals(1)").to_sol end def test_class - assert_equal Vool::MacroExpression , @lst.class + assert_equal Sol::MacroExpression , @lst.class end def test_arg1 - assert_equal Vool::IntegerConstant , @lst.arguments.first.class + assert_equal Sol::IntegerConstant , @lst.arguments.first.class end def test_name assert_equal :plus_equals , @lst.name @@ -40,22 +40,22 @@ module Ruby class TestPlusEqualsX < Minitest::Test include RubyTests def setup - @lst = compile_main( "X.plus_equals(arg,1)").to_vool + @lst = compile_main( "X.plus_equals(arg,1)").to_sol end def method_body @lst.body.first.body end def test_class - assert_equal Vool::ClassExpression , @lst.class - assert_equal Vool::MethodExpression , @lst.body.first.class + assert_equal Sol::ClassExpression , @lst.class + assert_equal Sol::MethodExpression , @lst.body.first.class end def test_macro_class - assert_equal Vool::ReturnStatement , method_body.class - assert_equal Vool::MacroExpression , method_body.return_value.class + assert_equal Sol::ReturnStatement , method_body.class + assert_equal Sol::MacroExpression , method_body.return_value.class end def test_args - assert_equal Vool::LocalVariable , method_body.return_value.arguments.first.class - assert_equal Vool::IntegerConstant , method_body.return_value.arguments.last.class + assert_equal Sol::LocalVariable , method_body.return_value.arguments.first.class + assert_equal Sol::IntegerConstant , method_body.return_value.arguments.last.class end def test_name assert_equal :plus_equals , method_body.return_value.name diff --git a/test/ruby/test_method_statement2.rb b/test/ruby/test_method_statement2.rb index b71828e3..cea18971 100644 --- a/test/ruby/test_method_statement2.rb +++ b/test/ruby/test_method_statement2.rb @@ -7,47 +7,47 @@ module Ruby class TestMethodStatementRet < MiniTest::Test include RubyTests def test_single_const - @lst = compile( "def tryout(arg1, arg2) ; true ; end " ).to_vool - assert_equal Vool::ReturnStatement , @lst.body.class + @lst = compile( "def tryout(arg1, arg2) ; true ; end " ).to_sol + assert_equal Sol::ReturnStatement , @lst.body.class end def test_single_instance - @lst = compile( "def tryout(arg1, arg2) ; @a ; end " ).to_vool - assert_equal Vool::ReturnStatement , @lst.body.class + @lst = compile( "def tryout(arg1, arg2) ; @a ; end " ).to_sol + assert_equal Sol::ReturnStatement , @lst.body.class end def test_single_call - @lst = compile( "def tryout(arg1, arg2) ; is_true() ; end " ).to_vool - assert_equal Vool::ReturnStatement , @lst.body.class + @lst = compile( "def tryout(arg1, arg2) ; is_true() ; end " ).to_sol + assert_equal Sol::ReturnStatement , @lst.body.class end def test_multi_const - @lst = compile( "def tryout(arg1, arg2) ; @a = some_call(); true ; end " ).to_vool - assert_equal Vool::ReturnStatement , @lst.body.last.class + @lst = compile( "def tryout(arg1, arg2) ; @a = some_call(); true ; end " ).to_sol + assert_equal Sol::ReturnStatement , @lst.body.last.class end def test_multi_instance - @lst = compile( "def tryout(arg1, arg2) ; @a = some_call(); @a ; end " ).to_vool - assert_equal Vool::ReturnStatement , @lst.body.last.class + @lst = compile( "def tryout(arg1, arg2) ; @a = some_call(); @a ; end " ).to_sol + assert_equal Sol::ReturnStatement , @lst.body.last.class end def test_multi_call - @lst = compile( "def tryout(arg1, arg2) ; is_true() ; some_call() ; end " ).to_vool - assert_equal Vool::ReturnStatement , @lst.body.last.class + @lst = compile( "def tryout(arg1, arg2) ; is_true() ; some_call() ; end " ).to_sol + assert_equal Sol::ReturnStatement , @lst.body.last.class end def test_return - @lst = compile( "def tryout(arg1, arg2) ; return 1 ; end " ).to_vool - assert_equal Vool::ReturnStatement , @lst.body.class - assert_equal Vool::IntegerConstant , @lst.body.return_value.class + @lst = compile( "def tryout(arg1, arg2) ; return 1 ; end " ).to_sol + assert_equal Sol::ReturnStatement , @lst.body.class + assert_equal Sol::IntegerConstant , @lst.body.return_value.class end def test_local_assign - @lst = compile( "def tryout(arg1, arg2) ; a = 1 ; end " ).to_vool - assert_equal Vool::Statements , @lst.body.class - assert_equal Vool::ReturnStatement , @lst.body.last.class - assert_equal Vool::LocalVariable , @lst.body.last.return_value.class + @lst = compile( "def tryout(arg1, arg2) ; a = 1 ; end " ).to_sol + assert_equal Sol::Statements , @lst.body.class + assert_equal Sol::ReturnStatement , @lst.body.last.class + assert_equal Sol::LocalVariable , @lst.body.last.return_value.class end def test_local_assign - @lst = compile( "def tryout(arg1, arg2) ; @a = 1 ; end " ).to_vool - assert_equal Vool::Statements , @lst.body.class - assert_equal Vool::ReturnStatement , @lst.body.last.class - assert_equal Vool::InstanceVariable , @lst.body.last.return_value.class + @lst = compile( "def tryout(arg1, arg2) ; @a = 1 ; end " ).to_sol + assert_equal Sol::Statements , @lst.body.class + assert_equal Sol::ReturnStatement , @lst.body.last.class + assert_equal Sol::InstanceVariable , @lst.body.last.return_value.class end end end diff --git a/test/ruby/test_require.rb b/test/ruby/test_require.rb index 294fa118..4e16d616 100644 --- a/test/ruby/test_require.rb +++ b/test/ruby/test_require.rb @@ -4,30 +4,30 @@ module Ruby class TestSendRequireHelper < MiniTest::Test include RubyTests def setup - @lst = compile( "require_relative 'helper'").to_vool + @lst = compile( "require_relative 'helper'").to_sol end def test_helper_class - assert_equal Vool::ClassExpression , @lst.class + assert_equal Sol::ClassExpression , @lst.class assert_equal :ParfaitTest , @lst.name end def test_methods - assert_equal Vool::Statements , @lst.body.class - assert_equal Vool::MethodExpression , @lst.body.first.class + assert_equal Sol::Statements , @lst.body.class + assert_equal Sol::MethodExpression , @lst.body.first.class assert_equal :setup , @lst.body.first.name end end class TestSendRequireparfait < MiniTest::Test include RubyTests def setup - @lst = compile( "require_relative 'object'").to_vool + @lst = compile( "require_relative 'object'").to_sol end def test_helper_class - assert_equal Vool::ClassExpression , @lst.class + assert_equal Sol::ClassExpression , @lst.class assert_equal :Object , @lst.name end def test_methods - assert_equal Vool::Statements , @lst.body.class - assert_equal Vool::MethodExpression , @lst.body.first.class + assert_equal Sol::Statements , @lst.body.class + assert_equal Sol::MethodExpression , @lst.body.first.class assert_equal :type , @lst.body.first.name end end diff --git a/test/ruby/test_return_statement.rb b/test/ruby/test_return_statement.rb index 37510b3b..84c6e654 100644 --- a/test/ruby/test_return_statement.rb +++ b/test/ruby/test_return_statement.rb @@ -21,30 +21,30 @@ module Ruby end end - class TestReturnStatementVool < MiniTest::Test + class TestReturnStatementSol < MiniTest::Test include RubyTests def test_return_const - lst = compile( "return 1" ).to_vool - assert_equal Vool::ReturnStatement , lst.class + lst = compile( "return 1" ).to_sol + assert_equal Sol::ReturnStatement , lst.class end def test_return_value - lst = compile( "return 1" ).to_vool + lst = compile( "return 1" ).to_sol assert_equal 1 , lst.return_value.value end def test_return_send - lst = compile( "return foo" ).to_vool - assert_equal Vool::ReturnStatement , lst.class + lst = compile( "return foo" ).to_sol + assert_equal Sol::ReturnStatement , lst.class end def test_return_send3 - lst = compile( "return foo.bar.zoo" ).to_vool - assert_equal Vool::LocalAssignment , lst.first.class + lst = compile( "return foo.bar.zoo" ).to_sol + assert_equal Sol::LocalAssignment , lst.first.class assert lst.first.name.to_s.start_with?("tmp_") end def test_return_send4 - lst = compile( "return foo.bar.zoo" ).to_vool - assert_equal Vool::ReturnStatement, lst[2].class + lst = compile( "return foo.bar.zoo" ).to_sol + assert_equal Sol::ReturnStatement, lst[2].class assert_equal :zoo, lst[2].return_value.name end end diff --git a/test/ruby/test_ruby_block_statement.rb b/test/ruby/test_ruby_block_statement.rb index a983f7f1..90b95b68 100644 --- a/test/ruby/test_ruby_block_statement.rb +++ b/test/ruby/test_ruby_block_statement.rb @@ -25,22 +25,22 @@ module Ruby assert_equal 1 , @lst.body.arguments.length end end - class TestBlockStatementVool < MiniTest::Test + class TestBlockStatementSol < MiniTest::Test include RubyTests def setup() input = "plus_one{|arg1| arg1 + 1 } " - @lst = compile( input ).to_vool + @lst = compile( input ).to_sol end def test_block - assert_equal Vool::SendStatement , @lst.class + assert_equal Sol::SendStatement , @lst.class end def test_send_name assert_equal :plus_one , @lst.name end def test_send_block_arg assert_equal 1 , @lst.arguments.length - assert_equal Vool::LambdaExpression , @lst.arguments.first.class + assert_equal Sol::LambdaExpression , @lst.arguments.first.class end def test_block_args assert_equal [:arg1] , @lst.arguments.first.args diff --git a/test/ruby/test_ruby_block_statement1.rb b/test/ruby/test_ruby_block_statement1.rb index fdeb7aa8..881f8a4c 100644 --- a/test/ruby/test_ruby_block_statement1.rb +++ b/test/ruby/test_ruby_block_statement1.rb @@ -24,28 +24,28 @@ module Ruby assert_equal ReturnStatement , @lst.last.class end end - class TestBlockReturnVool < MiniTest::Test + class TestBlockReturnSol < MiniTest::Test include RubyTests def setup() input = "a = plus_one{return 1 } ; return a " - @lst = compile( input ).to_vool + @lst = compile( input ).to_sol end def test_scope - assert_equal Vool::ScopeStatement , @lst.class + assert_equal Sol::ScopeStatement , @lst.class end def test_assign - assert_equal Vool::LocalAssignment , @lst.first.class + assert_equal Sol::LocalAssignment , @lst.first.class assert_equal :a , @lst.first.name end def test_send - assert_equal Vool::SendStatement , @lst.first.value.class + assert_equal Sol::SendStatement , @lst.first.value.class assert_equal :plus_one , @lst.first.value.name end def test_block_arg - assert_equal Vool::LambdaExpression , @lst.first.value.arguments.first.class + assert_equal Sol::LambdaExpression , @lst.first.value.arguments.first.class end def test_ret - assert_equal Vool::ReturnStatement , @lst[1].class + assert_equal Sol::ReturnStatement , @lst[1].class end end end diff --git a/test/ruby/test_send_statement1.rb b/test/ruby/test_send_statement1.rb index affdef5a..7964a5bc 100644 --- a/test/ruby/test_send_statement1.rb +++ b/test/ruby/test_send_statement1.rb @@ -1,69 +1,69 @@ require_relative "helper" module Ruby - class TestSendNoArgVool < MiniTest::Test + class TestSendNoArgSol < MiniTest::Test include RubyTests def setup - @lst = compile( "foo").to_vool + @lst = compile( "foo").to_sol end def test_simple_class - assert_equal Vool::SendStatement , @lst.class + assert_equal Sol::SendStatement , @lst.class end def test_simple_name assert_equal :foo , @lst.name end def test_simple_receiver - assert_equal Vool::SelfExpression , @lst.receiver.class + assert_equal Sol::SelfExpression , @lst.receiver.class end def test_simple_args assert_equal [] , @lst.arguments end end - class TestSendSimpleArgVool < MiniTest::Test + class TestSendSimpleArgSol < MiniTest::Test include RubyTests def setup - @lst = compile( "bar(1)").to_vool + @lst = compile( "bar(1)").to_sol end def test_class - assert_equal Vool::SendStatement , @lst.class + assert_equal Sol::SendStatement , @lst.class end def test_name assert_equal :bar , @lst.name end def test_receiver - assert_equal Vool::SelfExpression , @lst.receiver.class + assert_equal Sol::SelfExpression , @lst.receiver.class end def test_args - assert_equal Vool::IntegerConstant , @lst.arguments.first.class + assert_equal Sol::IntegerConstant , @lst.arguments.first.class end end - class TestSendSuperVool < MiniTest::Test + class TestSendSuperSol < MiniTest::Test include RubyTests def test_super0 - lst = compile( "super").to_vool - assert_equal Vool::SuperStatement , lst.class + lst = compile( "super").to_sol + assert_equal Sol::SuperStatement , lst.class end def test_super0_receiver - lst = compile( "super").to_vool - assert_equal Vool::SelfExpression , lst.receiver.class + lst = compile( "super").to_sol + assert_equal Sol::SelfExpression , lst.receiver.class end end - class TestSendSuperArgsVool < MiniTest::Test + class TestSendSuperArgsSol < MiniTest::Test include RubyTests def setup - @lst = compile( "super(1)").to_vool + @lst = compile( "super(1)").to_sol end def test_super_class - assert_equal Vool::SuperStatement , @lst.class + assert_equal Sol::SuperStatement , @lst.class end def test_super_receiver - assert_equal Vool::SelfExpression , @lst.receiver.class + assert_equal Sol::SelfExpression , @lst.receiver.class end def test_super_name assert_equal :super, @lst.name end end - class TestSendReceiverTypeVool < MiniTest::Test + class TestSendReceiverTypeSol < MiniTest::Test include RubyTests def setup @@ -71,12 +71,12 @@ module Ruby end def test_int_receiver - sent = compile( "5.div4").to_vool + sent = compile( "5.div4").to_sol assert_equal Parfait::Type , sent.receiver.ct_type.class assert_equal "Integer_Type" , sent.receiver.ct_type.name end def test_string_receiver - sent = compile( "'5'.putstring").to_vool + sent = compile( "'5'.putstring").to_sol assert_equal Parfait::Type , sent.receiver.ct_type.class assert_equal "Word_Type" , sent.receiver.ct_type.name end @@ -84,13 +84,13 @@ module Ruby class TestSendReceiver < MiniTest::Test include RubyTests def setup - @lst = compile( "call.once.more").to_vool + @lst = compile( "call.once.more").to_sol end def test_class - assert_equal Vool::Statements , @lst.class + assert_equal Sol::Statements , @lst.class end def test_one - assert_equal Vool::LocalAssignment , @lst.first.class + assert_equal Sol::LocalAssignment , @lst.first.class end def test_one_name assert @lst[0].name.to_s.start_with?("tmp_") @@ -105,7 +105,7 @@ module Ruby assert_equal :once , @lst[1].value.name end def test_three_class - assert_equal Vool::SendStatement, @lst[2].class + assert_equal Sol::SendStatement, @lst[2].class end def test_three_name assert_equal :more , @lst[2].name diff --git a/test/ruby/test_send_statement2.rb b/test/ruby/test_send_statement2.rb index 5e553b1f..a383565d 100644 --- a/test/ruby/test_send_statement2.rb +++ b/test/ruby/test_send_statement2.rb @@ -4,67 +4,67 @@ module Ruby module LastBar include RubyTests def test_last_class - assert_equal Vool::SendStatement , @lst.last.class + assert_equal Sol::SendStatement , @lst.last.class end def test_last_name assert_equal :last , @lst.last.name end def test_last_arg - assert_equal Vool::LocalVariable , @lst.last.arguments.first.class + assert_equal Sol::LocalVariable , @lst.last.arguments.first.class end def test_lst_class - assert_equal Vool::Statements , @lst.class + assert_equal Sol::Statements , @lst.class end def test_lst_no_statements - @lst.statements.each{|st| assert( ! st.is_a?(Vool::Statements) , st.class)} + @lst.statements.each{|st| assert( ! st.is_a?(Sol::Statements) , st.class)} end end - class TestSendSendArgVool < MiniTest::Test + class TestSendSendArgSol < MiniTest::Test include LastBar def setup - @lst = compile( "last(foo(1))").to_vool + @lst = compile( "last(foo(1))").to_sol end def test_classes - assert_equal Vool::Statements , @lst.class - assert_equal Vool::LocalAssignment , @lst.first.class - assert_equal Vool::SendStatement , @lst.last.class + assert_equal Sol::Statements , @lst.class + assert_equal Sol::LocalAssignment , @lst.first.class + assert_equal Sol::SendStatement , @lst.last.class end def test_foo1 - assert_equal Vool::SendStatement , @lst.first.value.class + assert_equal Sol::SendStatement , @lst.first.value.class assert_equal :foo , @lst.first.value.name - assert_equal Vool::IntegerConstant , @lst.first.value.arguments.first.class + assert_equal Sol::IntegerConstant , @lst.first.value.arguments.first.class end end - class Test3SendVool < MiniTest::Test + class Test3SendSol < MiniTest::Test include LastBar def setup - @lst = compile( "last(foo(more(1)))").to_vool + @lst = compile( "last(foo(more(1)))").to_sol end def test_classes - assert_equal Vool::Statements , @lst.class - assert_equal Vool::LocalAssignment , @lst.first.class - assert_equal Vool::SendStatement , @lst.last.class + assert_equal Sol::Statements , @lst.class + assert_equal Sol::LocalAssignment , @lst.first.class + assert_equal Sol::SendStatement , @lst.last.class end def test_foo - assert_equal Vool::SendStatement , @lst.first.value.class + assert_equal Sol::SendStatement , @lst.first.value.class assert_equal :more , @lst.first.value.name - assert_equal Vool::IntegerConstant , @lst.first.value.arguments.first.class + assert_equal Sol::IntegerConstant , @lst.first.value.arguments.first.class end end - class Test5SendVool < MiniTest::Test + class Test5SendSol < MiniTest::Test include LastBar def setup - @lst = compile( "last(foo(more(even_more(1),and_more(with_more))))").to_vool + @lst = compile( "last(foo(more(even_more(1),and_more(with_more))))").to_sol end def test_classes - assert_equal Vool::Statements , @lst.class - assert_equal Vool::LocalAssignment , @lst.first.class - assert_equal Vool::SendStatement , @lst.last.class + assert_equal Sol::Statements , @lst.class + assert_equal Sol::LocalAssignment , @lst.first.class + assert_equal Sol::SendStatement , @lst.last.class end def test_foo - assert_equal Vool::SendStatement , @lst.first.value.class + assert_equal Sol::SendStatement , @lst.first.value.class assert_equal :even_more , @lst.first.value.name - assert_equal Vool::IntegerConstant , @lst.first.value.arguments.first.class + assert_equal Sol::IntegerConstant , @lst.first.value.arguments.first.class end end end diff --git a/test/ruby/test_statement.rb b/test/ruby/test_statement.rb index cfd8d99e..04da3ad0 100644 --- a/test/ruby/test_statement.rb +++ b/test/ruby/test_statement.rb @@ -8,15 +8,15 @@ module Ruby assert_equal "Statement" , Statement.new.class_name end def test_brother - assert_equal Vool::Statement , Statement.new.vool_brother + assert_equal Sol::Statement , Statement.new.sol_brother end def test_yield lst = compile( "yield") - assert_equal Vool::YieldStatement , lst.vool_brother + assert_equal Sol::YieldStatement , lst.sol_brother end def test_assign lst = compile( "a = 4") - assert_equal Vool::LocalAssignment , lst.vool_brother + assert_equal Sol::LocalAssignment , lst.sol_brother end end diff --git a/test/ruby/test_variables.rb b/test/ruby/test_variables.rb index 5faad74d..19162628 100644 --- a/test/ruby/test_variables.rb +++ b/test/ruby/test_variables.rb @@ -52,38 +52,38 @@ module Ruby assert_equal :Module , lst.name end end - class TestVariablesVool < MiniTest::Test + class TestVariablesSol < MiniTest::Test include RubyTests def test_local_basic - lst = compile( "foo = 1 ; return foo").to_vool - assert_equal Vool::LocalVariable , lst.statements[1].return_value.class + lst = compile( "foo = 1 ; return foo").to_sol + assert_equal Sol::LocalVariable , lst.statements[1].return_value.class end def test_instance_basic - lst = compile( "@var" ).to_vool - assert_equal Vool::InstanceVariable , lst.class + lst = compile( "@var" ).to_sol + assert_equal Sol::InstanceVariable , lst.class assert_equal :var , lst.name end def test_instance_return - lst = compile( "return @var" ).to_vool - assert_equal Vool::InstanceVariable , lst.return_value.class + lst = compile( "return @var" ).to_sol + assert_equal Sol::InstanceVariable , lst.return_value.class end def test_class_basic - lst = compile( "@@var" ).to_vool - assert_equal Vool::ClassVariable , lst.class + lst = compile( "@@var" ).to_sol + assert_equal Sol::ClassVariable , lst.class assert_equal :var , lst.name end def test_class_return - lst = compile( "return @@var" ).to_vool - assert_equal Vool::ClassVariable , lst.return_value.class + lst = compile( "return @@var" ).to_sol + assert_equal Sol::ClassVariable , lst.return_value.class end def test_module_basic - lst = compile( "Module" ).to_vool - assert_equal Vool::ModuleName , lst.class + lst = compile( "Module" ).to_sol + assert_equal Sol::ModuleName , lst.class assert_equal :Module , lst.name end diff --git a/test/ruby/test_while_statement1.rb b/test/ruby/test_while_statement1.rb index 2b4d3e55..e9ac12e1 100644 --- a/test/ruby/test_while_statement1.rb +++ b/test/ruby/test_while_statement1.rb @@ -1,19 +1,19 @@ require_relative 'helper' module Ruby - class TestWhileStatementVool < MiniTest::Test + class TestWhileStatementSol < MiniTest::Test include RubyTests def setup - @lst = compile( "while(@arg) ; @arg = 1 ; end" ).to_vool + @lst = compile( "while(@arg) ; @arg = 1 ; end" ).to_sol end def test_class - assert_equal Vool::WhileStatement , @lst.class + assert_equal Sol::WhileStatement , @lst.class end def test_body_class - assert_equal Vool::IvarAssignment , @lst.body.class + assert_equal Sol::IvarAssignment , @lst.body.class end def test_condition_class - assert_equal Vool::InstanceVariable , @lst.condition.class + assert_equal Sol::InstanceVariable , @lst.condition.class end def test_no_hoist assert_nil @lst.hoisted @@ -22,20 +22,20 @@ module Ruby class TestWhileStatementHoist < MiniTest::Test include RubyTests def setup - @lst = compile( "while(call(arg > 1)) ; arg = 1 ; end" ).to_vool + @lst = compile( "while(call(arg > 1)) ; arg = 1 ; end" ).to_sol end def test_class - assert_equal Vool::WhileStatement , @lst.class - assert_equal Vool::LocalAssignment , @lst.body.class + assert_equal Sol::WhileStatement , @lst.class + assert_equal Sol::LocalAssignment , @lst.body.class end def test_condition_class - assert_equal Vool::SendStatement , @lst.condition.class + assert_equal Sol::SendStatement , @lst.condition.class end def test_hoist - assert_equal Vool::Statements , @lst.hoisted.class + assert_equal Sol::Statements , @lst.hoisted.class end def test_hoist_is_assi - assert_equal Vool::LocalAssignment , @lst.hoisted.first.class + assert_equal Sol::LocalAssignment , @lst.hoisted.first.class end end end diff --git a/test/ruby/test_yield_statement.rb b/test/ruby/test_yield_statement.rb index 66dfe800..bae1c6fb 100644 --- a/test/ruby/test_yield_statement.rb +++ b/test/ruby/test_yield_statement.rb @@ -18,18 +18,18 @@ module Ruby assert_equal "yield(0)" , @lst.to_s end end - class TestYieldStatementVool < MiniTest::Test + class TestYieldStatementSol < MiniTest::Test include RubyTests def setup() input = "yield(0)" - @lst = compile( input ).to_vool + @lst = compile( input ).to_sol end def test_block - assert_equal Vool::YieldStatement , @lst.class + assert_equal Sol::YieldStatement , @lst.class end def test_block_args - assert_equal Vool::IntegerConstant , @lst.arguments.first.class + assert_equal Sol::IntegerConstant , @lst.arguments.first.class end end end diff --git a/test/rubyx/helper.rb b/test/rubyx/helper.rb index a969ce2b..fa603d32 100644 --- a/test/rubyx/helper.rb +++ b/test/rubyx/helper.rb @@ -5,18 +5,18 @@ module RubyX module RubyXHelper def setup end - def ruby_to_vool(input, options = {}) + def ruby_to_sol(input, options = {}) options = RubyX.default_test_options.merge(options) - RubyXCompiler.new(options).ruby_to_vool(input) + RubyXCompiler.new(options).ruby_to_sol(input) end def ruby_to_slot(input , options = {}) options = RubyX.default_test_options.merge(options) RubyXCompiler.new(options).ruby_to_slot(input) end def compile_in_test( input , options = {}) - vool = ruby_to_vool(in_Test(input) , options) - vool.to_parfait - vool.to_slot(nil) + sol = ruby_to_sol(in_Test(input) , options) + sol.to_parfait + sol.to_slot(nil) itest = Parfait.object_space.get_class_by_name(:Test) assert itest itest diff --git a/test/rubyx/parfait/README.md b/test/rubyx/parfait/README.md index 833e0413..f62391cb 100644 --- a/test/rubyx/parfait/README.md +++ b/test/rubyx/parfait/README.md @@ -8,10 +8,10 @@ Since we need Parfait in the runtime, we need to parse it and compile it. And since it is early days, we expect errors at every level during this process, which means testing every layer for every file. -Rather than create parfait tests for every layer (ie in the vool/slot_machine/risc directories) +Rather than create parfait tests for every layer (ie in the sol/slot_machine/risc directories) we have one file per parfait file here. Each file tests all layers. -The usual workflow is to start with a new file and create tests for vool, slot_machine, risc,binary +The usual workflow is to start with a new file and create tests for sol, slot_machine, risc,binary in that order. Possibly fixing the compiler on the way. Then adding the file to the RubyXCompiler parfait load list. diff --git a/test/rubyx/parfait/test_data_object.rb b/test/rubyx/parfait/test_data_object.rb index 98626348..99c356f5 100644 --- a/test/rubyx/parfait/test_data_object.rb +++ b/test/rubyx/parfait/test_data_object.rb @@ -8,7 +8,7 @@ module RubyX def setup @compiler = compiler - @compiler.ruby_to_vool load_parfait(:object) + @compiler.ruby_to_sol load_parfait(:object) end def source load_parfait(:data_object) @@ -17,15 +17,15 @@ module RubyX assert source.include?("class DataObject") assert source.length > 1500 , source.length end - def test_vool - vool = @compiler.ruby_to_vool source - assert_equal Vool::ScopeStatement , vool.class - assert_equal Vool::ClassExpression , vool[0].class - assert_equal Vool::ClassExpression , vool[1].class - assert_equal Vool::ClassExpression , vool[2].class - assert_equal :DataObject , vool[1].name - assert_equal :Data4 , vool[2].name - assert_equal :Data8 , vool[3].name + def test_sol + sol = @compiler.ruby_to_sol source + assert_equal Sol::ScopeStatement , sol.class + assert_equal Sol::ClassExpression , sol[0].class + assert_equal Sol::ClassExpression , sol[1].class + assert_equal Sol::ClassExpression , sol[2].class + assert_equal :DataObject , sol[1].name + assert_equal :Data4 , sol[2].name + assert_equal :Data8 , sol[3].name end def test_slot slot = @compiler.ruby_to_slot source diff --git a/test/rubyx/parfait/test_integer.rb b/test/rubyx/parfait/test_integer.rb index dfbb155f..2aa31df6 100644 --- a/test/rubyx/parfait/test_integer.rb +++ b/test/rubyx/parfait/test_integer.rb @@ -5,8 +5,8 @@ module RubyX include ParfaitHelper def setup @compiler = compiler - @compiler.ruby_to_vool load_parfait(:object) - @compiler.ruby_to_vool load_parfait(:data_object) + @compiler.ruby_to_sol load_parfait(:object) + @compiler.ruby_to_sol load_parfait(:data_object) end def source get_preload("Space.main") + load_parfait(:integer) @@ -15,21 +15,21 @@ module RubyX assert source.include?("class Integer") assert source.length > 1500 , source.length end - def test_vool - vool = @compiler.ruby_to_vool source - assert_equal Vool::ScopeStatement , vool.class - assert_equal Vool::ClassExpression , vool[0].class - assert_equal Vool::ClassExpression , vool[1].class - assert_equal Vool::ClassExpression , vool[2].class - assert_equal :DataObject , vool[1].name - assert_equal :Data4 , vool[2].name - assert_equal :Data8 , vool[3].name + def test_sol + sol = @compiler.ruby_to_sol source + assert_equal Sol::ScopeStatement , sol.class + assert_equal Sol::ClassExpression , sol[0].class + assert_equal Sol::ClassExpression , sol[1].class + assert_equal Sol::ClassExpression , sol[2].class + assert_equal :DataObject , sol[1].name + assert_equal :Data4 , sol[2].name + assert_equal :Data8 , sol[3].name end def test_slot - vool = @compiler.ruby_to_vool source - vool.to_parfait - #puts vool - slot = vool.to_slot(nil) + sol = @compiler.ruby_to_sol source + sol.to_parfait + #puts sol + slot = sol.to_slot(nil) assert_equal SlotMachine::SlotCollection , slot.class end def est_risc diff --git a/test/rubyx/parfait/test_object.rb b/test/rubyx/parfait/test_object.rb index df4843b8..ce1ea00f 100644 --- a/test/rubyx/parfait/test_object.rb +++ b/test/rubyx/parfait/test_object.rb @@ -13,10 +13,10 @@ module RubyX assert source.include?("class Object") assert source.length > 2000 end - def test_vool - vool = compiler.ruby_to_vool source - assert_equal Vool::ClassExpression , vool.class - assert_equal :Object , vool.name + def test_sol + sol = compiler.ruby_to_sol source + assert_equal Sol::ClassExpression , sol.class + assert_equal :Object , sol.name end def test_slot slot = compiler.ruby_to_slot source diff --git a/test/rubyx/rt_parfait/test_object.rb b/test/rubyx/rt_parfait/test_object.rb index b50b93f6..783c058e 100644 --- a/test/rubyx/rt_parfait/test_object.rb +++ b/test/rubyx/rt_parfait/test_object.rb @@ -25,26 +25,26 @@ module RubyX assert_equal Ruby::ClassStatement , compiled[2].class assert_equal :TestObject , compiled[2].name end - def test_vool_object - vool = Ruby::RubyCompiler.compile(@input).to_vool - assert_equal Vool::ScopeStatement , vool.class - assert_equal Vool::ClassExpression , vool.first.class + def test_sol_object + sol = Ruby::RubyCompiler.compile(@input).to_sol + assert_equal Sol::ScopeStatement , sol.class + assert_equal Sol::ClassExpression , sol.first.class end - def test_vool_helper - vool = Ruby::RubyCompiler.compile(@input).to_vool - assert_equal Vool::ClassExpression , vool[1].class - assert_equal :ParfaitTest , vool[1].name + def test_sol_helper + sol = Ruby::RubyCompiler.compile(@input).to_sol + assert_equal Sol::ClassExpression , sol[1].class + assert_equal :ParfaitTest , sol[1].name end - def test_vool_test - vool = Ruby::RubyCompiler.compile(@input).to_vool - assert_equal Vool::ClassExpression , vool[2].class - assert_equal :TestObject , vool[2].name + def test_sol_test + sol = Ruby::RubyCompiler.compile(@input).to_sol + assert_equal Sol::ClassExpression , sol[2].class + assert_equal :TestObject , sol[2].name end - def test_vool_methods - vool = Ruby::RubyCompiler.compile(@input).to_vool - assert_equal Vool::Statements , vool[2].body.class - vool[2].body.statements.each do |st| - assert_equal Vool::MethodExpression , st.class + def test_sol_methods + sol = Ruby::RubyCompiler.compile(@input).to_sol + assert_equal Sol::Statements , sol[2].body.class + sol[2].body.statements.each do |st| + assert_equal Sol::MethodExpression , st.class end end end @@ -54,15 +54,15 @@ module RubyX def self.runnable_methods input = load_parfait(:object) + load_parfait_test(:object) - vool = Ruby::RubyCompiler.compile(input).to_vool + sol = Ruby::RubyCompiler.compile(input).to_sol tests = [ ] - vool[2].body.statements.each do |method| + sol[2].body.statements.each do |method| tests << method.name self.send(:define_method, method.name ) do code = input + <
err assert err.message.include?("Blocks") , err.message end end def test_assign_compiles - vool = Ruby::RubyCompiler.compile( as_class_method("val = 0") ).to_vool - vool.to_parfait - assert_equal SlotMachine::SlotCollection , vool.to_slot(nil).class + sol = Ruby::RubyCompiler.compile( as_class_method("val = 0") ).to_sol + sol.to_parfait + assert_equal SlotMachine::SlotCollection , sol.to_slot(nil).class end end end diff --git a/test/vool/lambdas/test_if_condition.rb b/test/sol/lambdas/test_if_condition.rb similarity index 94% rename from test/vool/lambdas/test_if_condition.rb rename to test/sol/lambdas/test_if_condition.rb index ca129b29..be36d3bd 100644 --- a/test/vool/lambdas/test_if_condition.rb +++ b/test/sol/lambdas/test_if_condition.rb @@ -1,8 +1,8 @@ require_relative "helper" -module VoolBlocks +module SolBlocks class TestConditionIfSlotMachine < MiniTest::Test - include VoolCompile + include SolCompile def setup @ins = compile_main_block( "if(5.div4) ; @a = 6 ; else; @a = 5 ; end" , "local=5", "Integer.div4") diff --git a/test/vool/lambdas/test_while_simple.rb b/test/sol/lambdas/test_while_simple.rb similarity index 93% rename from test/vool/lambdas/test_while_simple.rb rename to test/sol/lambdas/test_while_simple.rb index 8129aef7..c80de3a2 100644 --- a/test/vool/lambdas/test_while_simple.rb +++ b/test/sol/lambdas/test_while_simple.rb @@ -1,8 +1,8 @@ require_relative "helper" -module VoolBlocks +module SolBlocks class TestSimpleWhileSlotMachine < MiniTest::Test - include VoolCompile + include SolCompile def setup @ins = compile_main_block( "while(@a) ; @a = 5 ; end") diff --git a/test/vool/send/helper.rb b/test/sol/send/helper.rb similarity index 97% rename from test/vool/send/helper.rb rename to test/sol/send/helper.rb index 58ae8f77..2b88e6f1 100644 --- a/test/vool/send/helper.rb +++ b/test/sol/send/helper.rb @@ -1,9 +1,9 @@ require_relative "../helper" -module Vool +module Sol # relies on @ins and receiver_type method module SimpleSendHarness - include VoolCompile + include SolCompile include SlotMachine def setup diff --git a/test/vool/send/test_not_found.rb b/test/sol/send/test_not_found.rb similarity index 95% rename from test/vool/send/test_not_found.rb rename to test/sol/send/test_not_found.rb index c8a69bde..ffab9cfe 100644 --- a/test/vool/send/test_not_found.rb +++ b/test/sol/send/test_not_found.rb @@ -1,8 +1,8 @@ require_relative "../helper" -module Vool +module Sol class TestSendCachedSimpleSlotMachine < MiniTest::Test - include VoolCompile + include SolCompile def setup @compiler = compile_main( "5.div8") diff --git a/test/vool/send/test_send_args_send.rb b/test/sol/send/test_send_args_send.rb similarity index 95% rename from test/vool/send/test_send_args_send.rb rename to test/sol/send/test_send_args_send.rb index da203c70..2c3b89a4 100644 --- a/test/vool/send/test_send_args_send.rb +++ b/test/sol/send/test_send_args_send.rb @@ -1,8 +1,8 @@ require_relative "helper" -module Vool +module Sol class TestSendArgsSendSlotMachine < MiniTest::Test - include VoolCompile + include SolCompile def setup @compiler = compile_main( "a = main(4.div4);return a" , "Integer.div4") diff --git a/test/vool/send/test_send_cached_simple.rb b/test/sol/send/test_send_cached_simple.rb similarity index 96% rename from test/vool/send/test_send_cached_simple.rb rename to test/sol/send/test_send_cached_simple.rb index 48090215..d50d4618 100644 --- a/test/vool/send/test_send_cached_simple.rb +++ b/test/sol/send/test_send_cached_simple.rb @@ -1,8 +1,8 @@ require_relative "../helper" -module Vool +module Sol class TestSendCachedSimpleSlotMachine < MiniTest::Test - include VoolCompile + include SolCompile def setup @compiler = compile_main( "a = 5; a.div4;return ") diff --git a/test/vool/send/test_send_self.rb b/test/sol/send/test_send_self.rb similarity index 98% rename from test/vool/send/test_send_self.rb rename to test/sol/send/test_send_self.rb index 1bf1aa5f..334c909a 100644 --- a/test/vool/send/test_send_self.rb +++ b/test/sol/send/test_send_self.rb @@ -1,6 +1,6 @@ require_relative "helper" -module Vool +module Sol class TestSendSelfSlotMachine < MiniTest::Test include SimpleSendHarness diff --git a/test/vool/send/test_send_simple.rb b/test/sol/send/test_send_simple.rb similarity index 96% rename from test/vool/send/test_send_simple.rb rename to test/sol/send/test_send_simple.rb index 9d39f3f6..8fb7aed1 100644 --- a/test/vool/send/test_send_simple.rb +++ b/test/sol/send/test_send_simple.rb @@ -1,6 +1,6 @@ require_relative "helper" -module Vool +module Sol class TestSendSimpleSlotMachine < MiniTest::Test include SimpleSendHarness diff --git a/test/vool/send/test_send_simple_args.rb b/test/sol/send/test_send_simple_args.rb similarity index 98% rename from test/vool/send/test_send_simple_args.rb rename to test/sol/send/test_send_simple_args.rb index e26bd9b9..1c83b73a 100644 --- a/test/vool/send/test_send_simple_args.rb +++ b/test/sol/send/test_send_simple_args.rb @@ -1,6 +1,6 @@ require_relative "helper" -module Vool +module Sol class TestSendSimpleArgsSlotMachine < MiniTest::Test include SimpleSendHarness diff --git a/test/vool/test_assignment.rb b/test/sol/test_assignment.rb similarity index 95% rename from test/vool/test_assignment.rb rename to test/sol/test_assignment.rb index e4a32b18..7c704a78 100644 --- a/test/vool/test_assignment.rb +++ b/test/sol/test_assignment.rb @@ -1,8 +1,8 @@ require_relative "helper" -module Vool +module Sol class TestAssignSlotMachine < MiniTest::Test - include VoolCompile + include SolCompile def setup @compiler = compile_main( "local = 5;return") @@ -31,7 +31,7 @@ module Vool #otherwise as above, but assigning instance, so should get a SlotLoad class TestAssignSlotMachineInstanceToLocal < MiniTest::Test - include VoolCompile + include SolCompile def setup @compiler = compile_main( "@a = 5 ; local = @a;return") @ins = @compiler.slot_instructions.next @@ -43,7 +43,7 @@ module Vool #compiling to an argument should result in different second parameter in the slot array class TestAssignToArg < MiniTest::Test - include VoolCompile + include SolCompile def setup @compiler = compile_main( "arg = 5;return") @@ -65,7 +65,7 @@ module Vool end class TestAssignSlotMachineToInstance < MiniTest::Test - include VoolCompile + include SolCompile def setup Parfait.boot!(Parfait.default_test_options) end diff --git a/test/vool/test_builtin.rb b/test/sol/test_builtin.rb similarity index 69% rename from test/vool/test_builtin.rb rename to test/sol/test_builtin.rb index 26d3323e..145ebe1e 100644 --- a/test/vool/test_builtin.rb +++ b/test/sol/test_builtin.rb @@ -1,8 +1,8 @@ require_relative "helper" -module Vool +module Sol class TestBuiltin < MiniTest::Test - include VoolCompile + include SolCompile def setup Parfait.boot!(Parfait.default_test_options) @@ -12,9 +12,9 @@ module Vool @ruby = Ruby::RubyCompiler.compile(@code) end def as_slot - vool = as_ruby.to_vool - vool.to_parfait - vool.to_slot(nil) + sol = as_ruby.to_sol + sol.to_parfait + sol.to_slot(nil) end def test_boot assert_equal String , @code.class @@ -25,16 +25,16 @@ module Vool assert_equal Ruby::MethodStatement , @ruby.body.first.class assert_equal :+ , @ruby.body.first.name end - def test_compile_vool - vool = as_ruby.to_vool - assert_equal Vool::ClassExpression , vool.class - assert_equal Vool::MethodExpression , vool.body.first.class + def test_compile_sol + sol = as_ruby.to_sol + assert_equal Sol::ClassExpression , sol.class + assert_equal Sol::MethodExpression , sol.body.first.class end - def test_vool_method - vool = as_ruby.to_vool - assert_equal :+ , vool.body.first.name - assert_equal Vool::ReturnStatement , vool.body.first.body.class - assert_equal Vool::MacroExpression , vool.body.first.body.return_value.class + def test_sol_method + sol = as_ruby.to_sol + assert_equal :+ , sol.body.first.name + assert_equal Sol::ReturnStatement , sol.body.first.body.class + assert_equal Sol::MacroExpression , sol.body.first.body.return_value.class end def test_slot_basic slot = as_slot diff --git a/test/vool/test_class_expression.rb b/test/sol/test_class_expression.rb similarity index 73% rename from test/vool/test_class_expression.rb rename to test/sol/test_class_expression.rb index d72b2737..569dca98 100644 --- a/test/vool/test_class_expression.rb +++ b/test/sol/test_class_expression.rb @@ -1,32 +1,32 @@ require_relative "helper" -module Vool +module Sol class TestClassStatement < MiniTest::Test include ScopeHelper def setup Parfait.boot!(Parfait.default_test_options) ruby_tree = Ruby::RubyCompiler.compile( as_test_main("@a = 5") ) - @vool = ruby_tree.to_vool + @sol = ruby_tree.to_sol end def test_class - assert_equal ClassExpression , @vool.class - assert_equal :Test , @vool.name + assert_equal ClassExpression , @sol.class + assert_equal :Test , @sol.name end def test_method - assert_equal MethodExpression , @vool.body.first.class + assert_equal MethodExpression , @sol.body.first.class end def test_create_class - assert_equal Parfait::Class , @vool.create_class_object.class + assert_equal Parfait::Class , @sol.create_class_object.class end def test_create_class - assert_equal :Test , @vool.to_parfait.name + assert_equal :Test , @sol.to_parfait.name end def test_class_instance - assert_equal :a , @vool.to_parfait.instance_type.names[1] + assert_equal :a , @sol.to_parfait.instance_type.names[1] end def test_to_s - assert_tos "class Test < Object;def main(arg);@a = 5;return @a;end;end" , @vool + assert_tos "class Test < Object;def main(arg);@a = 5;return @a;end;end" , @sol end end class TestClassStatementTypeCreation < MiniTest::Test @@ -36,9 +36,9 @@ module Vool end def check_type_for(input) ruby_tree = Ruby::RubyCompiler.compile( as_test_main(input) ) - vool = ruby_tree.to_vool - assert_equal ClassExpression , vool.class - clazz = vool.to_parfait + sol = ruby_tree.to_sol + assert_equal ClassExpression , sol.class + clazz = sol.to_parfait assert_equal Parfait::Class , clazz.class assert_equal :a , clazz.instance_type.names[1] end @@ -76,8 +76,8 @@ module Vool as_test_main("return 1") + ";class Test < Space ; def main();return 1;end;end" end def test_mismatch - vool_tree = Ruby::RubyCompiler.compile( space_test).to_vool - assert_raises {vool_tree.to_parfait} + sol_tree = Ruby::RubyCompiler.compile( space_test).to_sol + assert_raises {sol_tree.to_parfait} end end end diff --git a/test/vool/test_class_expression2.rb b/test/sol/test_class_expression2.rb similarity index 96% rename from test/vool/test_class_expression2.rb rename to test/sol/test_class_expression2.rb index 7e31ebdd..4fe6c2ff 100644 --- a/test/vool/test_class_expression2.rb +++ b/test/sol/test_class_expression2.rb @@ -1,9 +1,9 @@ require_relative "helper" -module Vool +module Sol class TestClassStatementCompile < MiniTest::Test - include VoolCompile + include SolCompile def setup @compiler = compile_main( "if(@a) ; @a = 5 ; else; @a = 6 ; end; return") diff --git a/test/vool/test_class_method_expression.rb b/test/sol/test_class_method_expression.rb similarity index 95% rename from test/vool/test_class_method_expression.rb rename to test/sol/test_class_method_expression.rb index a33f5e74..638a9cec 100644 --- a/test/vool/test_class_method_expression.rb +++ b/test/sol/test_class_method_expression.rb @@ -1,8 +1,8 @@ require_relative "helper" -module Vool +module Sol class TestClassMethodExpression < MiniTest::Test - include VoolCompile + include SolCompile def class_code "class Space;def self.meth; return meth(22 + 22) ; end;end" @@ -10,7 +10,7 @@ module Vool def setup Parfait.boot!(Parfait.default_test_options) ruby_tree = Ruby::RubyCompiler.compile( class_code ) - @clazz = ruby_tree.to_vool + @clazz = ruby_tree.to_sol end def method @clazz.body.first diff --git a/test/vool/test_if_no_else.rb b/test/sol/test_if_no_else.rb similarity index 95% rename from test/vool/test_if_no_else.rb rename to test/sol/test_if_no_else.rb index 25013c99..ccc3dfc9 100644 --- a/test/vool/test_if_no_else.rb +++ b/test/sol/test_if_no_else.rb @@ -1,9 +1,9 @@ require_relative "helper" -module Vool +module Sol class TestIfNoElse < MiniTest::Test - include VoolCompile + include SolCompile def setup @compiler = compile_main( "if(@a) ; @a = 5 ; end;return") diff --git a/test/vool/test_if_no_if.rb b/test/sol/test_if_no_if.rb similarity index 95% rename from test/vool/test_if_no_if.rb rename to test/sol/test_if_no_if.rb index 780d4515..2645be8a 100644 --- a/test/vool/test_if_no_if.rb +++ b/test/sol/test_if_no_if.rb @@ -1,9 +1,9 @@ require_relative "helper" -module Vool +module Sol class TestIfNoIf < MiniTest::Test - include VoolCompile + include SolCompile def setup @compiler = compile_main( "unless(@a) ; @a = 5 ; end;return") diff --git a/test/vool/test_if_simple.rb b/test/sol/test_if_simple.rb similarity index 95% rename from test/vool/test_if_simple.rb rename to test/sol/test_if_simple.rb index c7a4de7d..f55b7b59 100644 --- a/test/vool/test_if_simple.rb +++ b/test/sol/test_if_simple.rb @@ -1,9 +1,9 @@ require_relative "helper" -module Vool +module Sol class TestSimpleIfSlotMachine < MiniTest::Test - include VoolCompile + include SolCompile def setup @compiler = compile_main( "if(@a) ; @a = 5 ; else; @a = 6 ; end;return") diff --git a/test/vool/test_if_statement.rb b/test/sol/test_if_statement.rb similarity index 95% rename from test/vool/test_if_statement.rb rename to test/sol/test_if_statement.rb index 4252c974..e2b274ee 100644 --- a/test/vool/test_if_statement.rb +++ b/test/sol/test_if_statement.rb @@ -1,8 +1,8 @@ require_relative "helper" -module Vool +module Sol class TestConditionIfSlotMachine < MiniTest::Test - include VoolCompile + include SolCompile def setup @compiler = compile_main( "if(5.div4) ; @a = 6 ; else; @a = 5 ; end;return" , "Integer.div4") diff --git a/test/vool/test_ivar.rb b/test/sol/test_ivar.rb similarity index 95% rename from test/vool/test_ivar.rb rename to test/sol/test_ivar.rb index 3ae3fa99..c43d8983 100644 --- a/test/vool/test_ivar.rb +++ b/test/sol/test_ivar.rb @@ -1,8 +1,8 @@ require_relative "helper" -module Vool +module Sol class TestIvarSlotMachine < MiniTest::Test - include VoolCompile + include SolCompile def setup @compiler = compile_main( "@a = 5") diff --git a/test/vool/test_local_assignment.rb b/test/sol/test_local_assignment.rb similarity index 96% rename from test/vool/test_local_assignment.rb rename to test/sol/test_local_assignment.rb index 20914713..757f6df8 100644 --- a/test/vool/test_local_assignment.rb +++ b/test/sol/test_local_assignment.rb @@ -1,8 +1,8 @@ require_relative "helper" -module Vool +module Sol class TestLocalSlotMachine < MiniTest::Test - include VoolCompile + include SolCompile def setup @compiler = compile_main( "a = 5") @@ -33,7 +33,7 @@ module Vool end class TestArgSlotMachine < MiniTest::Test - include VoolCompile + include SolCompile def setup Parfait.boot!(Parfait.default_test_options) diff --git a/test/vool/test_macro_expression.rb b/test/sol/test_macro_expression.rb similarity index 85% rename from test/vool/test_macro_expression.rb rename to test/sol/test_macro_expression.rb index 815e76fe..69855f9d 100644 --- a/test/vool/test_macro_expression.rb +++ b/test/sol/test_macro_expression.rb @@ -13,9 +13,9 @@ module SlotMachine end end -module Vool +module Sol class TestMacroSlotMachine < MiniTest::Test - include VoolCompile + include SolCompile def setup @compiler = compile_main( "X.plus_equals(arg,1)") @@ -26,11 +26,11 @@ module Vool assert_equal SlotMachine::PlusEquals , @ins.class , @ins end def test_arg1 - assert_equal Vool::LocalVariable , @ins.a.class + assert_equal Sol::LocalVariable , @ins.a.class assert_equal :arg , @ins.a.name end def test_arg2 - assert_equal Vool::IntegerConstant , @ins.b.class + assert_equal Sol::IntegerConstant , @ins.b.class assert_equal 1 , @ins.b.value end def test_to_risc diff --git a/test/vool/test_method_expression.rb b/test/sol/test_method_expression.rb similarity index 87% rename from test/vool/test_method_expression.rb rename to test/sol/test_method_expression.rb index ef3f29e6..f97ffd3f 100644 --- a/test/vool/test_method_expression.rb +++ b/test/sol/test_method_expression.rb @@ -1,13 +1,13 @@ require_relative "helper" -module Vool +module Sol class TestMethodExpression < MiniTest::Test - include VoolCompile + include SolCompile def setup Parfait.boot!(Parfait.default_test_options) ruby_tree = Ruby::RubyCompiler.compile( as_main("a = 5") ) - @clazz = ruby_tree.to_vool + @clazz = ruby_tree.to_sol end def method @clazz.body.first @@ -25,7 +25,7 @@ module Vool end def test_creates_instance_method main = @clazz.to_parfait.get_instance_method(:main) - assert_equal Parfait::VoolMethod , main.class + assert_equal Parfait::SolMethod , main.class assert_equal :main , main.name end def test_creates_type_method @@ -36,12 +36,12 @@ module Vool end class TestMethodExpressionDoubleDef < MiniTest::Test - include VoolCompile + include SolCompile def setup Parfait.boot!(Parfait.default_test_options) ruby_tree = Ruby::RubyCompiler.compile( as_main("a = 5") + ";" + as_main("a = 5") ) - @clazz = ruby_tree.to_vool + @clazz = ruby_tree.to_sol end def method @clazz.body.first diff --git a/test/vool/test_return.rb b/test/sol/test_return.rb similarity index 96% rename from test/vool/test_return.rb rename to test/sol/test_return.rb index 3c00e2ec..e6309be7 100644 --- a/test/vool/test_return.rb +++ b/test/sol/test_return.rb @@ -1,8 +1,8 @@ require_relative "helper" -module Vool +module Sol class TestReturnSlotMachine < MiniTest::Test - include VoolCompile + include SolCompile def setup @compiler = compile_main( "return 5") @@ -38,7 +38,7 @@ module Vool end end class TestReturnSendSlotMachine < MiniTest::Test - include VoolCompile + include SolCompile def setup @compiler = compile_main( "return 5.div4" , "Integer.div4" ) diff --git a/test/vool/test_while_statement.rb b/test/sol/test_while_statement.rb similarity index 95% rename from test/vool/test_while_statement.rb rename to test/sol/test_while_statement.rb index c5c929cf..2d8ee7ed 100644 --- a/test/vool/test_while_statement.rb +++ b/test/sol/test_while_statement.rb @@ -1,8 +1,8 @@ require_relative "helper" -module Vool +module Sol class TestSimpleWhileSlotMachine < MiniTest::Test - include VoolCompile + include SolCompile def setup @compiler = compile_main( "while(@a) ; @a = 5 ; end;return") diff --git a/test/vool/test_while_statement1.rb b/test/sol/test_while_statement1.rb similarity index 96% rename from test/vool/test_while_statement1.rb rename to test/sol/test_while_statement1.rb index 29c96ac9..a8fefd42 100644 --- a/test/vool/test_while_statement1.rb +++ b/test/sol/test_while_statement1.rb @@ -1,9 +1,9 @@ require_relative "helper" -module Vool +module Sol class TestWhileConditionSlotMachine < MiniTest::Test - include VoolCompile + include SolCompile def setup @compiler = compile_main( "while(5.div4) ; 5.div4 ; end;return" , "Integer.div4") diff --git a/test/vool/test_yield_statement.rb b/test/sol/test_yield_statement.rb similarity index 98% rename from test/vool/test_yield_statement.rb rename to test/sol/test_yield_statement.rb index 12420dcd..99941328 100644 --- a/test/vool/test_yield_statement.rb +++ b/test/sol/test_yield_statement.rb @@ -1,8 +1,8 @@ require_relative "helper" -module Vool +module Sol class TestYieldArgsSendSlotMachine < MiniTest::Test - include VoolCompile + include SolCompile def setup @compiler = compile_main( "return yield(1)" ) @@ -66,7 +66,7 @@ module Vool end end class TestYieldNoArgsSendSlotMachine < MiniTest::Test - include VoolCompile + include SolCompile def setup @compiler = compile_main( "return yield(some.extra.calls)" ) diff --git a/test/support/compiling.rb b/test/support/compiling.rb index dc4588ae..35403cab 100644 --- a/test/support/compiling.rb +++ b/test/support/compiling.rb @@ -4,7 +4,7 @@ module ScopeHelper def compiler_with_main(options = {}) compiler = RubyX::RubyXCompiler.new(RubyX.default_test_options.merge(options)) - compiler.ruby_to_vool( "class Space;def main(arg);return;end;end" ) + compiler.ruby_to_sol( "class Space;def main(arg);return;end;end" ) compiler end def in_Test(statements) @@ -28,7 +28,7 @@ module ScopeHelper end end -module VoolCompile +module SolCompile include ScopeHelper include SlotMachine include Preloader diff --git a/test/support/preloader.rb b/test/support/preloader.rb index 07c9744f..a90af4bd 100644 --- a/test/support/preloader.rb +++ b/test/support/preloader.rb @@ -2,11 +2,11 @@ module Preloader def get_preload(preload) return "" unless preload if( preload == "all" ) - loading = Vool::Builtin.builtin.keys + loading = Sol::Builtin.builtin.keys else loading = preload.split(";") end - loading.collect { |loads| Vool::Builtin.load_builtin(loads)}.join(";") + ";" + loading.collect { |loads| Sol::Builtin.load_builtin(loads)}.join(";") + ";" end def preload get_preload(@preload)