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

@@ -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"] }

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

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"

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
 

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),

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

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 )

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 )

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

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

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.

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)

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

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

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)

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)

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?

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

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)

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

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)

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

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

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

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

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

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

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)

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"

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

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
 

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:
 

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

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
 

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)

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

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)

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 )

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

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

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
 #

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,

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

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)

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

lib/sol/call_statement.rb

@@ -1,4 +1,4 @@
-module Vool
+module Sol
 
   class CallStatement < Statement
     attr_reader :name , :receiver , :arguments

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)

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)

lib/sol/if_statement.rb

@@ -1,5 +1,5 @@
 
-module Vool
+module Sol
   class IfStatement < Statement
 
     attr_reader :condition , :if_true , :if_false

lib/sol/ivar_assignment.rb

@@ -1,4 +1,4 @@
-module Vool
+module Sol
 
   class IvarAssignment < Assignment
 

lib/sol/lambda_expression.rb

@@ -1,4 +1,4 @@
-module Vool
+module Sol
   class LambdaExpression < Expression
     attr_reader :args , :body , :clazz
 

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

lib/sol/macro_expression.rb

@@ -1,4 +1,4 @@
-module Vool
+module Sol
 
   class MacroExpression < CallStatement
 

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

lib/sol/return_statement.rb

@@ -1,4 +1,4 @@
-module Vool
+module Sol
   class ReturnStatement < Statement
 
     attr_reader :return_value

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

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
 

lib/sol/statements.rb

@@ -1,4 +1,4 @@
-module Vool
+module Sol
   class Statements < Statement
     attr_reader :statements
     def initialize(statements)

lib/sol/super_statement.rb

@@ -1,4 +1,4 @@
-module Vool
+module Sol
   class SuperStatement < SendStatement
 
   end

lib/sol/variables.rb

@@ -1,4 +1,4 @@
-module Vool
+module Sol
   module Named
     attr_reader :name
     def initialize name

lib/sol/while_statement.rb

@@ -1,5 +1,5 @@
 
-module Vool
+module Sol
   class WhileStatement < Statement
     attr_reader :condition , :body , :hoisted
 

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

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

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

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

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

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

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")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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
 

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

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

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

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.
 

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

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

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

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 + <<MAIN
             class Space
               def main(args)
-                test = #{vool[2].name}.new
+                test = #{sol[2].name}.new
                 test.setup
                 test.#{method.name}
               end

test/rubyx/test_rubyx_compiler.rb

@@ -16,15 +16,15 @@ module RubyX
     end
 
     def test_class_body_is_scope
-      clazz = ruby_to_vool in_Test("def meth; @ivar = 5 ;end")
-      assert_equal Vool::Statements , clazz.body.class
-      assert_equal Vool::MethodExpression , clazz.body.first.class
+      clazz = ruby_to_sol in_Test("def meth; @ivar = 5 ;end")
+      assert_equal Sol::Statements , clazz.body.class
+      assert_equal Sol::MethodExpression , clazz.body.first.class
     end
 
     def test_space_is_unchanged_by_compile
       compiler = RubyXCompiler.new(RubyX.default_test_options)
       space1 = Parfait.object_space.get_class_by_name(:Space)
-      compiler.ruby_to_vool  "class Space ;end"
+      compiler.ruby_to_sol  "class Space ;end"
       space2 = Parfait.object_space.get_class_by_name(:Space)
       assert_equal space1 , space2
     end
@@ -32,7 +32,7 @@ module RubyX
     def test_space_type_is_unchanged_by_compile
       compiler = RubyXCompiler.new(RubyX.default_test_options)
       space1 = Parfait.object_space.get_type_by_class_name(:Space)
-      compiler.ruby_to_vool  "class Space ;end"
+      compiler.ruby_to_sol  "class Space ;end"
       space2 = Parfait.object_space.get_type_by_class_name(:Space)
       assert_equal space1 , space2
     end

test/rubyx/test_rubyx_compiler1.rb

@@ -27,7 +27,7 @@ module RubyX
     def test_space_type_is_unchanged_by_compile
       compiler = RubyXCompiler.new(RubyX.default_test_options)
       space1 = Parfait.object_space.get_type_by_class_name(:Space)
-      compiler.ruby_to_vool  "class Space ;end"
+      compiler.ruby_to_sol  "class Space ;end"
       space2 = Parfait.object_space.get_type_by_class_name(:Space)
       assert_equal space1 , space2
     end

test/rubyx/test_rubyx_compiler2.rb

@@ -38,7 +38,7 @@ module RubyX
 
     def test_load
       object = Parfait.object_space.get_class_by_name(:Object)
-      assert_equal Parfait::VoolMethod , object.get_instance_method(:set_type).class
+      assert_equal Parfait::SolMethod , object.get_instance_method(:set_type).class
       assert_equal Parfait::CallableMethod , object.instance_type.get_method(:set_type).class
     end
   end

test/rubyx/test_rubyx_compiler3.rb

@@ -17,23 +17,23 @@ module RubyX
       @linker = RubyXCompiler.ruby_to_binary(space_source_for("main"), RubyX.interpreter_test_options)
       assert_equal Risc::Linker , @linker.class
     end
-    def test_one_vool_call
+    def test_one_sol_call
       compiler = RubyXCompiler.new(RubyX.default_test_options)
-      compiler.ruby_to_vool(space_source_for("main"))
-      assert_equal Vool::ClassExpression , compiler.vool.class
+      compiler.ruby_to_sol(space_source_for("main"))
+      assert_equal Sol::ClassExpression , compiler.sol.class
     end
-    def test_two_vool_calls
+    def test_two_sol_calls
       compiler = RubyXCompiler.new(RubyX.default_test_options)
-      compiler.ruby_to_vool(space_source_for("main"))
-      compiler.ruby_to_vool(space_source_for("twain"))
-      assert_equal Vool::ScopeStatement , compiler.vool.class
-      assert_equal 2 , compiler.vool.length
+      compiler.ruby_to_sol(space_source_for("main"))
+      compiler.ruby_to_sol(space_source_for("twain"))
+      assert_equal Sol::ScopeStatement , compiler.sol.class
+      assert_equal 2 , compiler.sol.length
     end
     def test_bin_two_sources
       compiler = RubyXCompiler.new(RubyX.default_test_options)
-      compiler.ruby_to_vool(space_source_for("main"))
-      compiler.ruby_to_vool(space_source_for("twain"))
-      assert_equal 2 , compiler.vool.length
+      compiler.ruby_to_sol(space_source_for("main"))
+      compiler.ruby_to_sol(space_source_for("twain"))
+      assert_equal 2 , compiler.sol.length
       linker = compiler.to_binary(:interpreter)
       assert_equal Risc::Linker , linker.class
       assert_equal 4 , linker.assemblers.length

test/slot_machine/test_block_statement.rb

@@ -1,7 +1,7 @@
 
 require_relative "helper"
 
-module Vool
+module Sol
   class TestBlockArg < MiniTest::Test
     include SlotMachineCompile
 

test/slot_machine/test_class_statement.rb

@@ -1,7 +1,7 @@
 
 require_relative "helper"
 
-module Vool
+module Sol
   class TestClassStatementSlotMachine < MiniTest::Test
     include SlotMachineCompile
 

test/slot_machine/test_method_compiler.rb

@@ -7,21 +7,21 @@ module SlotMachine
     def setup
     end
 
-    def in_test_vool(str)
-      vool = RubyX::RubyXCompiler.new(RubyX.default_test_options).ruby_to_vool(in_Test(str))
-      vool.to_parfait
-      vool.to_slot(nil)
-      vool
+    def in_test_sol(str)
+      sol = RubyX::RubyXCompiler.new(RubyX.default_test_options).ruby_to_sol(in_Test(str))
+      sol.to_parfait
+      sol.to_slot(nil)
+      sol
     end
     def create_method(body = "@ivar = 5;return")
-      in_test_vool("def meth; #{body};end")
+      in_test_sol("def meth; #{body};end")
       test = Parfait.object_space.get_class_by_name(:Test)
       test.get_instance_method(:meth)
     end
 
     def test_method_has_source
       method = create_method
-      assert_equal Vool::Statements ,  method.source.class
+      assert_equal Sol::Statements ,  method.source.class
     end
 
     def test_method_has_no_locals
@@ -37,24 +37,24 @@ module SlotMachine
     def test_creates_method_in_class
       method = create_method
       assert method , "No method created"
-      assert_equal Parfait::VoolMethod , method.class
+      assert_equal Parfait::SolMethod , method.class
     end
 
     def test_creates_method_statement_in_class
-      clazz = in_test_vool("def meth; @ivar = 5 ;return;end")
-      assert_equal Vool::Statements , clazz.body.class
-      assert_equal Vool::MethodExpression , clazz.body.first.class
+      clazz = in_test_sol("def meth; @ivar = 5 ;return;end")
+      assert_equal Sol::Statements , clazz.body.class
+      assert_equal Sol::MethodExpression , clazz.body.first.class
     end
 
     def test_callable_method_instance_type
-      in_test_vool("def meth; @ivar = 5; @ibar = 4;return;end")
+      in_test_sol("def meth; @ivar = 5; @ibar = 4;return;end")
       test = Parfait.object_space.get_class_by_name(:Test)
       method = test.instance_type.get_method(:meth)
       assert_equal 1, method.self_type.variable_index(:ivar)
       assert_equal 2, method.self_type.variable_index(:ibar)
     end
     def test_callable_method_has_one_local
-      in_test_vool("def meth; local = 5 ; a = 6;return;end")
+      in_test_sol("def meth; local = 5 ; a = 6;return;end")
       test = Parfait.object_space.get_class_by_name(:Test)
       method = test.get_instance_method(:meth)
       assert_equal 3 , method.frame_type.instance_length

test/sol/class_send/test_class_def.rb

@@ -1,9 +1,9 @@
 require_relative "helper"
 
-module Vool
+module Sol
   class TestClassDef < MiniTest::Test
     include SlotMachine
-    include VoolCompile
+    include SolCompile
 
     def class_main
       <<-eos

test/sol/class_send/test_class_instance.rb

@@ -1,9 +1,9 @@
 require_relative "helper"
 
-module Vool
+module Sol
   class TestClassInstance < MiniTest::Test
     include SlotMachine
-    include VoolCompile
+    include SolCompile
 
     def class_main
       <<-eos

test/sol/class_send/test_class_send_inherited.rb

@@ -1,9 +1,9 @@
 require_relative "helper"
 
-module Vool
+module Sol
   class TestClassSendInherited < MiniTest::Test
     include SlotMachine
-    include VoolCompile
+    include SolCompile
 
     def class_main
       <<-eos

test/sol/class_send/test_send_class.rb

@@ -1,8 +1,8 @@
 require_relative "helper"
 
-module Vool
+module Sol
   class TestSendClassSlotMachine < MiniTest::Test
-    include VoolCompile
+    include SolCompile
 
     def class_main
       <<-eos

test/sol/lambdas/test_assign.rb

@@ -1,8 +1,8 @@
 require_relative "../helper"
 
-module VoolBlocks
+module SolBlocks
   class TestAssignSlotMachine < MiniTest::Test
-    include VoolCompile
+    include SolCompile
 
     def setup
       @ins = compile_main_block(  "local = 5" )
@@ -28,7 +28,7 @@ module VoolBlocks
   end
 
   class TestAssignSlotMachineInstanceToLocal < MiniTest::Test
-    include VoolCompile
+    include SolCompile
     def setup
       @ins = compile_main_block( "local = @a" , "@a = 5") #second arg in method scope
     end
@@ -44,7 +44,7 @@ module VoolBlocks
   end
 
   class TestAssignToArg < MiniTest::Test
-    include VoolCompile
+    include SolCompile
 
     def setup
       @ins = compile_main_block( "arg = 5")
@@ -62,7 +62,7 @@ module VoolBlocks
   end
 
   class TestAssignSlotMachineToInstance < MiniTest::Test
-    include VoolCompile
+    include SolCompile
     def setup
     end
     def test_assigns_const

test/sol/lambdas/test_class_blocks.rb

@@ -1,6 +1,6 @@
 require_relative "../helper"
 
-module VoolBlocks
+module SolBlocks
   class TestClassAssignSlotMachine < MiniTest::Test
 
     def setup
@@ -11,18 +11,18 @@ module VoolBlocks
     end
     def test_block_not_compiles
       source =  "main{|val| val = 0}"
-      vool = Ruby::RubyCompiler.compile( as_class_method(source) ).to_vool
-      vool.to_parfait
+      sol = Ruby::RubyCompiler.compile( as_class_method(source) ).to_sol
+      sol.to_parfait
       begin
-        vool.to_slot(nil)
+        sol.to_slot(nil)
      rescue => 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

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")

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")

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

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")

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")

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 ")

test/sol/send/test_send_self.rb

@@ -1,6 +1,6 @@
 require_relative "helper"
 
-module Vool
+module Sol
   class TestSendSelfSlotMachine < MiniTest::Test
     include SimpleSendHarness
 

test/sol/send/test_send_simple.rb

@@ -1,6 +1,6 @@
 require_relative "helper"
 
-module Vool
+module Sol
   class TestSendSimpleSlotMachine < MiniTest::Test
     include SimpleSendHarness
 

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
 

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

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

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

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")

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

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")

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")

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")

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")

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")

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)

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

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

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" )

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")

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")

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)" )

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

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)