rename register to risc

seems to fit the layer much better as we really have a very reduced
instruction set

lib/risc/collector.rb

@@ -0,0 +1,58 @@
+module Risc
+
+  #  collect anything that is in the space but and reachable from init
+  module Collector
+    def self.collect_space
+      @objects = {}
+      keep Parfait.object_space , 0
+      Risc.machine.constants.each {|obj| keep(obj,0)}
+      @objects
+    end
+
+    def self.keep( object , depth )
+      return if object.nil?
+      return unless add_object( object , depth )
+      # probably should make labels or even instructions derive from Parfait::Object, but . .
+      if object.is_a? Risc::Label
+        object.each_label { |l| self.add_object(l ,depth)}
+      end
+      return unless object.respond_to? :has_type?
+      type = object.get_type
+      keep(type  , depth + 1)
+      return if object.is_a? Symbol
+      type.names.each do |name|
+        keep(name , depth + 1)
+        inst = object.get_instance_variable name
+        keep(inst , depth + 1)
+      end
+      if object.is_a? Parfait::List
+        object.each do |item|
+          keep(item , depth + 1)
+        end
+      end
+    end
+
+    # Objects are data and get assembled after functions
+    def self.add_object( objekt , depth)
+      return false if @objects[objekt.object_id]
+      return true if objekt.is_a? Fixnum
+      #puts message(objekt , depth)
+      #puts "ADD #{objekt.inspect}, #{objekt.name}" if objekt.is_a? Parfait::TypedMethod
+      unless objekt.is_a?( Parfait::Object) or objekt.is_a?( Symbol) or objekt.is_a?( Risc::Label)
+        raise "adding non parfait #{objekt.class}"
+      end
+      #raise "Method #{objekt.name}" if objekt.is_a? Parfait::TypedMethod
+      @objects[objekt.object_id] = objekt
+      true
+    end
+
+    def self.message(object , depth)
+      msg =  "adding #{depth}#{' ' * depth}:"
+      if( object.respond_to?(:sof_reference_name))
+        msg + object.sof_reference_name.to_s
+      else
+        msg + object.class.name
+      end
+    end
+  end
+end