starting to redo message_setup

apart from previous commits bug, it also needs to deal with
dynamic/static correctly
and while at it will do the getting from space

lib/mom/instruction/message_setup.rb

@@ -4,34 +4,58 @@ module Mom
   # Ie: MessageSetup,ArgumentTransfer,SimpleCall
   #
   # MessageSetup does Setup before a call can be made, acquiring and filling the message
-  # basically.
+  # basically.Only after MessageSetup is the next_message safe to use.
   #
-  # With the current design the next message is already ready (hardwired as a linked list),
-  # so nothing to be done there.
-  # (but this does not account for continuations or closures and so will have to be changed)
+  # The space keeps a linked list of Messages, from which we take and currenty also return.
   #
-  # But we do need to set the message name to the called method's name,
-  # and also set the arg and local types on the new message, currently for debugging
-  # but later for dynamic checking
+  # Message setup set the name to the called method's name, and also set the arg and local
+  # types on the new message, currently for debugging but later for dynamic checking
+  #
+  # The only difference between the setup of a static call and a dynamic one is where
+  # the method comes from. A static, or simple call, passes the method, but a dynamic
+  # call passes the cache_entry that holds the resolved method.
+  #
+  # In either case, the method is loaded and name,frame and args set
   #
   class MessageSetup < Instruction
-    attr_reader :method
+    attr_reader :method_source
 
-    def initialize(method)
-        @method = method
+    def initialize(method_source)
+      @method_source = method_source
     end
 
-    # Move method name, frame and arguemnt types from the method to the neext_message
-    # Assumes the message is ready, see class description
+    # Move method name, frame and arguemnt types from the method to the next_message
+    # Get the message from Space and link it.
     def to_risc(compiler)
-      name_move = SlotLoad.new( [:message , :next_message,:name] , [method , :name],self)
+      method = compiler.use_reg( :TypedMethod )
+      risc = move_method_to(compiler , method)
+      message = compiler.use_reg( :Message )
+      risc << get_message_to(compiler , message)
+
+      # move name args frame
+      # this time using Risc instructions (create helpers?)
+      name_move = SlotLoad.new( [:message , :next_message,:name] , [method_source , :name],self)
       moves = name_move.to_risc(compiler)
-      args_move = SlotLoad.new( [:message , :next_message, :arguments,:type] , [method , :arguments, :type],self)
+      args_move = SlotLoad.new( [:message , :next_message, :arguments, :type] , [method_source , :arguments_type],self)
       moves << args_move.to_risc(compiler)
-      type_move = SlotLoad.new( [:message , :next_message, :frame,:type] , [method , :frame,:type],self)
+      type_move = SlotLoad.new( [:message , :next_message, :frame, :type] , [method_source , :frame_type],self)
       moves << type_move.to_risc(compiler)
+      return risc
+    end
+    private
+    # get the method from method_source into the given register
+    # return instruction that do this
+    def move_method_to(compiler, register)
+      Risc.load_constant("message setup move method" , @method_source ,register)
     end
 
+    # get the next message from space and unlink it there
+    # also put it into next_message of current message
+    # use given message regster
+    # return instructions to do this
+    def get_message_to( compiler , message)
+      Risc.load_constant("message setup move method" , @method_source ,message)
+    end
   end