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