Get a basic MetaClass going

Does get created in new, but not in boot.
Also not yet used in compiling

lib/parfait.rb

@@ -30,6 +30,7 @@ require_relative "parfait/data_object"
 require_relative "parfait/integer"
 require_relative "parfait/behaviour"
 require_relative "parfait/class"
+require_relative "parfait/meta_class"
 require_relative "parfait/list"
 require_relative "parfait/word"
 require_relative "parfait/binary_code"

lib/parfait/behaviour.rb

@@ -45,7 +45,7 @@ module Parfait
       raise "resolve_method #{m_name}.#{m_name.class}" unless m_name.is_a?(Symbol)
       method = get_instance_method(m_name)
       return method if method
-      if( super_class_name != :Object )
+      if( super_class_name && super_class_name != :Object )
         method = self.super_class.resolve_method(m_name)
       end
       method

lib/parfait/class.rb

@@ -18,10 +18,11 @@ module Parfait
   class Class < Object
     include Behaviour
 
-    attr :type, :instance_type , :name , :instance_methods , :super_class_name
+    attr :type, :instance_type , :name , :instance_methods
+    attr :super_class_name , :meta_class
 
     def self.type_length
-      5
+      6
     end
 
     def initialize( name , superclass , instance_type)
@@ -30,6 +31,7 @@ module Parfait
       self.super_class_name = superclass
       self.instance_methods = List.new
       set_instance_type( instance_type )
+      self.meta_class = MetaClass.new( self )
     end
 
     def rxf_reference_name

lib/parfait/meta_class.rb

@@ -0,0 +1,107 @@
+#
+# In many respects a MetaClass is like a Class. We haven't gone to the full ruby/oo level
+# yet, where the metaclass is actually a class instance, but someday.
+
+# A Class in general can be viewed as a way to generate methods for a group of objects.
+
+# A MetaClass serves the same function, but just for one object, the class object that
+# is the meta_class of.
+# This is slightnly different in the way that the type of the class must actually
+# change, whereas for a class the instance type changes and only objects generated
+# henceafter have a different type.
+
+# This is still a first version, this change is not implemeted, also classes at boot don't
+# have metaclasses yet, so still a bit TODO
+
+# Another current difference is that a metaclass has no superclass. Also no name.
+# There is a one to one relationship between a class instance and it's meta_class instance.
+
+module Parfait
+  class MetaClass < Object
+    include Behaviour
+
+    attr :type, :instance_type , :instance_methods , :clazz
+
+    def self.type_length
+      4
+    end
+
+    def initialize( clazz )
+      super()
+      self.clazz = clazz
+      self.instance_methods = List.new
+      set_instance_type( clazz.get_type() )
+    end
+
+    def rxf_reference_name
+      clazz.name
+    end
+
+    def inspect
+      "MetaClass(#{clazz.name})"
+    end
+
+    # no superclass, return nil to signal
+    def super_class_name
+      nil
+    end
+
+    def add_method_for(name , type , frame , body )
+      method = Parfait::VoolMethod.new(name , type , frame , body )
+      add_method( method )
+      method
+    end
+
+    def add_method(method)
+      raise "Must be untyped method #{method}" unless method.is_a? Parfait::VoolMethod
+      instance_methods.push(method)
+    end
+
+    def get_method(name)
+      instance_methods.find{|m| m.name == name }
+    end
+
+    # adding an instance changes the instance_type to include that variable
+    def add_instance_variable( name , type)
+      self.instance_type = instance_type.add_instance_variable( name , type )
+    end
+
+    # setting the type generates all methods for this type
+    # (or will do, once we store the methods code to do that)
+    def set_instance_type( type )
+      raise "type must be type #{type}" unless type.is_a?(Type)
+      self.instance_type = type
+    end
+
+    # return the super class, but raise exception if either the super class name
+    # or the super classs is nil.
+    # Use only for non Object base class
+    def super_class!
+      raise "No super_class for class #{name}" unless super_class_name
+      s = super_class
+      raise "superclass not found for class #{name} (#{super_class_name})" unless s
+      s
+    end
+
+    # return the super class
+    # we only store the name, and so have to resolve.
+    # Nil name means no superclass, and so nil is a valid return value
+    def super_class
+      return nil unless super_class_name
+      Parfait.object_space.get_class_by_name(super_class_name)
+    end
+
+    # ruby 2.1 list (just for reference, keep at bottom)
+    #:allocate, :new, :superclass
+
+    # + modules
+    # :<, :<=, :>, :>=, :included_modules, :include?, :name, :ancestors, :instance_methods, :public_instance_methods,
+    # :protected_instance_methods, :private_instance_methods, :constants, :const_get, :const_set, :const_defined?,
+    # :const_missing, :class_variables, :remove_class_variable, :class_variable_get, :class_variable_set,
+    # :class_variable_defined?, :public_constant, :private_constant, :singleton_class?, :include, :prepend,
+    # :module_exec, :class_exec, :module_eval, :class_eval, :method_defined?, :public_method_defined?,
+    # :private_method_defined?, :protected_method_defined?, :public_class_method, :private_class_method, :autoload,
+    # :autoload?, :instance_method, :public_instance_method
+
+  end
+end

lib/risc/parfait_boot.rb

@@ -146,7 +146,7 @@ module Parfait
                        arguments_type: :Type , self_type: :Type, frame_type: :Type ,
                        name: :Word , blocks: :Block} ,
       Class: {instance_methods: :List, instance_type: :Type,
-              name: :Word, super_class_name: :Word },
+              name: :Word, super_class_name: :Word , meta_class: :MetaClass},
       DataObject: {},
       Data4: {},
       Data8: {},
@@ -158,6 +158,7 @@ module Parfait
       Message: { next_message: :Message,   receiver: :Object, frame: :NamedList ,
                  return_address: :Integer, return_value: :Object,
                  caller: :Message , method: :TypedMethod ,     arguments: :NamedList },
+      MetaClass: {instance_methods: :List, instance_type: :Type, clazz: :Class },
       NamedList: {},
       NilClass: {},
       Object: {},