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

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