fix most mom and risc apart

apart from things involving builtn, which is not yet conceptually solved (as it codes risc, not mom)

lib/mom/instruction/argument_transfer.rb

@@ -22,7 +22,8 @@ module Mom
 
     # receiver is a slot_definition
     # arguments is an array of SlotLoads
-    def initialize( receiver,arguments )
+    def initialize( source , receiver,arguments )
+      super(source)
       @receiver , @arguments = receiver , arguments
       raise "Receiver not SlotDefinition #{@receiver}" unless @receiver.is_a?(SlotDefinition)
       @arguments.each{|a| raise "args not SlotLoad #{a}" unless a.is_a?(SlotLoad)}
@@ -35,7 +36,7 @@ module Mom
     # load receiver and then each arg into the new message
     # delegates to SlotLoad for receiver and to the actual args.to_risc
     def to_risc(compiler)
-      transfer = SlotLoad.new([:message , :next_message , :receiver] , @receiver, self).to_risc(compiler)
+      transfer = SlotLoad.new(self.source ,[:message , :next_message , :receiver] , @receiver, self).to_risc(compiler)
       compiler.reset_regs
       @arguments.each do |arg|
         arg.to_risc(compiler)

lib/mom/instruction/return_jump.rb

@@ -7,9 +7,20 @@ module Mom
   #
   class ReturnJump < Instruction
 
+    attr_reader :return_label
+
+    # pass in the source_name (string/vool_instruction) for accounting purposes
+    # and the return_label, where we actually jump to. This is set up by the
+    # method_compiler, so it is easy to find (see return_label in compiler)
+    def initialize( source , label )
+      super(source)
+      @return_label = label
+    end
+
     # the jump quite simple resolves to an uncondition risc Branch
+    # we use the label that is passed in at creation
     def to_risc(compiler)
-      compiler.add_code Risc::Branch.new(self , compiler.return_label)
+      compiler.add_code Risc::Branch.new(self , return_label.risc_label(compiler))
     end
   end
 

lib/mom/mom_collection.rb

@@ -38,7 +38,9 @@ module Mom
     end
 
     def to_risc(  )
-      riscs = []
+      riscs = method_compilers.collect do | mom_c |
+        mom_c.to_risc
+      end
       # to_risc all compilers
       # for each suffling constnts and fist label, then all instructions (see below)
       # then create risc collection

lib/risc/risc_collection.rb

@@ -19,7 +19,7 @@ module Risc
     # Return all compilers, namely the MethodCompilers passed in, plus the
     # boot_function's compilers (boot_compilers)
     def compilers
-      @method_compilers + boot_compilers
+      @method_compilers #+ boot_compilers
     end
 
     # collects constants from all compilers into one array

lib/vool/return_statement.rb

@@ -18,7 +18,7 @@ module Vool
     def to_mom( compiler )
       ret = Mom::SlotLoad.new( self , [:message , :return_value] ,
                         @return_value.slot_definition(compiler) )
-      ret << Mom::ReturnJump.new(self)
+      ret << Mom::ReturnJump.new(self , compiler.return_label )
     end
 
     def to_s(depth = 0)

lib/vool/send_statement.rb

@@ -52,7 +52,7 @@ module Vool
       @arguments.each_with_index do |arg , index| # +1 because of type
         args << Mom::SlotLoad.new(self, arg_target + [index + 1] , arg.slot_definition(compiler))
       end
-      setup << Mom::ArgumentTransfer.new( mom_receive , args )
+      setup << Mom::ArgumentTransfer.new(self, mom_receive , args )
     end
 
     def simple_call(compiler)