fix message_setup with new builder

lib/risc/register_slot.rb

@@ -27,7 +27,7 @@ module Risc
       when RegisterValue
         to_mem("#{reg.class_name} -> #{register.class_name}[#{index}]" , reg)
       when RegisterSlot
-        reg = to_reg("reduce #{@register.symbol}[@index]")
+        reg = to_reg()
         to_mem("#{reg.class_name} -> #{register.class_name}[#{index}]" , reg)
       else
         raise "not reg value or slot #{reg}"
@@ -41,7 +41,7 @@ module Risc
     #     message[:caller] returns a RegisterSlot, which would be self for this example
     #    to evaluate self[:next_message] we reduce self to a register with to_reg
     def []( index )
-      reg = to_reg("reduce #{@register.symbol}[@index]")
+      reg = to_reg()
       reg[index]
     end
 
@@ -58,7 +58,8 @@ module Risc
     # load the conntent of the slot that self descibes into a a new register.
     # the register is created, and the slot_to_reg instruction added to the
     # compiler. the return is a bit like @register[@index]
-    def to_reg( source )
+    def to_reg()
+      source = "reduce #{@register.symbol}[@index]"
       slot_to_reg = Risc.slot_to_reg(source , register, index)
       if compiler
         compiler.add_code(slot_to_reg)

lib/risc/register_value.rb

@@ -171,6 +171,7 @@ module Risc
     # create operator instruction for self and add
     # doesn't read quite as smoothly as one would like, but better than the compiler version
     def op( operator , right)
+      right = right.to_reg() if(right.is_a?(RegisterSlot))
       ret = Risc.op( "operator #{operator}" , operator , self , right)
       compiler.add_code(ret) if compiler
       ret

lib/slot_machine/instruction/message_setup.rb

@@ -37,20 +37,15 @@ module SlotMachine
     def build_with(builder)
       case from = method_source
       when Parfait::CallableMethod
-        builder.build { callable! << from }
+        callable = builder.load_object(from)
       when Parfait::CacheEntry
-        builder.build do
-          cache_entry! << from
-          callable! << cache_entry[:cached_method]
-        end
+        callable = builder.load_object(from)[:cached_method].to_reg
       when Integer
-        builder.build do
-          callable! << message[ "arg#{from}".to_sym ]
-        end
+        callable = builder.message[ "arg#{from}".to_sym ].to_reg
       else
         raise "unknown source #{method_source.class}:#{method_source}"
       end
-      build_message_data(builder)
+      build_message_data(builder , callable)
       return builder.built
     end
 
@@ -60,14 +55,8 @@ module SlotMachine
     end
 
     # set the method into the message
-    def build_message_data( builder )
-      if(reg = builder.names["next_message"])
-        raise "NEXT = #{reg}"
-      end
-      builder.build do
-        next_message! << message[:next_message]
-        next_message[:method] << callable
-      end
+    def build_message_data( builder , callable)
+      builder.message[:next_message][:method] << callable
     end
   end
 end