removing builtin as a concept (wip)

the "old" way of generating compilers is now obsolete
we can use ruby code with mom macros to achieve the same
Three step wip
remove old builtin
fix tests (including adding necessary methods)
fixup and inclusion of builtin code to parfait

lib/mom/macro/object.rb

@@ -1,107 +1,3 @@
-require_relative "get_internal_word"
-require_relative "set_internal_word"
-require_relative "method_missing"
-require_relative "init"
-require_relative "exit"
 
 module Mom
-  module Builtin
-    class Object
-      module ClassMethods
-        include CompileHelper
-
-        # self[index] basically. Index is the first arg
-        # return is stored in return_value
-        def get_internal_word( context )
-          compiler = compiler_for(:Object , :get_internal_word ,{at: :Integer})
-          compiler.add_code GetInternalWord.new("get_internal_word")
-          return compiler
-        end
-        # self[index] = val basically. Index is the first arg , value the second
-        # return the value passed in
-        def set_internal_word( context )
-          compiler = compiler_for(:Object , :set_internal_word , {at: :Integer, value: :Object} )
-          compiler.add_code SetInternalWord.new("set_internal_word")
-          return compiler
-        end
-
-        # every object needs a method missing.
-        # Even if it's just this one, sys_exit (later raise)
-        def _method_missing( context )
-          compiler = compiler_for(:Object,:method_missing ,{})
-          compiler.add_code MethodMissing.new("missing")
-          return compiler
-        end
-
-        # this is the really really first place the machine starts (apart from the jump here)
-        # it isn't really a function, ie it is jumped to (not called), exits and may not return
-        # so it is responsible for initial setup:
-        # - load fist message, set up Space as receiver
-        # - call main, ie set up message for that etc
-        # - exit (exit_sequence) which passes a machine int out to c
-        def __init__( context )
-          compiler = compiler_for(:Object,:__init__ ,{})
-          compiler._reset_for_init # no return, just for init
-          compiler.add_code Init.new("missing")
-          return compiler
-        end
-
-        # the exit function
-        # mainly calls exit_sequence
-        def exit( context )
-          compiler = compiler_for(:Object,:exit ,{})
-          compiler.add_code Exit.new("exit")
-          return compiler
-        end
-
-      end
-      extend ClassMethods
-    end
-
-    # emit the syscall with given name
-    # there is a Syscall instruction, but the message has to be saved and restored
-    def self.emit_syscall( builder , name )
-      save_message( builder )
-      builder.add_code Risc::Syscall.new("emit_syscall(#{name})", name )
-      restore_message(builder)
-      return unless (@clazz and @method)
-      builder.add_code Risc.label( "#{@clazz.name}.#{@message.name}" , "return_syscall" )
-    end
-
-    # a sort of inline version of exit method.
-    # Used by exit and __init__ (so it doesn't have to call it)
-    # Assumes int return value and extracts the fixnum for process exit code
-    def self.exit_sequence(builder)
-      save_message( builder )
-      builder.build do
-        message << message[:return_value]
-        message.reduce_int
-        add_code Risc::Syscall.new("emit_syscall(exit)", :exit )
-      end
-    end
-
-    # save the current message, as the syscall destroys all context
-    #
-    # This relies on linux to save and restore all registers
-    #
-    def self.save_message(builder)
-      r8 = Risc::RegisterValue.new( :r8 , :Message).set_builder(builder)
-      builder.build {r8 << message}
-    end
-
-    # restore the message that we save in r8
-    # before th restore, the syscall return, a fixnum, is saved
-    # The caller of this method is assumed to caal prepare_int_return
-    # so that the return value already has an integer instance
-    # This instance is filled with os return value
-    def self.restore_message(builder)
-      r8 = Risc::RegisterValue.new( :r8 , :Message)
-      builder.build do
-        integer_reg! << message
-        message << r8
-        integer_2! << message[:return_value]
-        integer_2[Parfait::Integer.integer_index] << integer_reg
-      end
-    end
-  end
 end