bring the blocks down to mom level

reusing message_setup, but adding yield specific instructions

lib/vool/method_statement.rb

@@ -31,7 +31,7 @@ module Vool
     def make_arg_type(  )
       type_hash = {}
       @args.each {|arg| type_hash[arg] = :Object }
-      type_hash[:implicit_block] = :Object if has_yield?
+      type_hash[:implicit_block] = :Block if has_yield?
       Parfait::NamedList.type_for( type_hash )
     end
 

lib/vool/yield_statement.rb

@@ -13,6 +13,7 @@ module Vool
     def to_s
       "#{receiver}.#{name}(#{arguments.join(', ')})"
     end
+
     def each(&block)
       block.call(self)
       block.call(@receiver)
@@ -21,27 +22,50 @@ module Vool
       end
     end
 
-    # A Send breaks down to 2 steps:
-    # - Setting up the next message, with receiver, arguments, and (importantly) return address
-    # - a SimpleCall,
-    def to_mom( compiler )
-      @parfait_block = @block.to_mom(compiler) if @block
-      @receiver = SelfExpression.new(compiler.receiver_type) if @receiver.is_a?(SelfExpression)
-      if(@receiver.ct_type)
-        simple_call(compiler)
-      else
-        raise "ERROR"
-      end
-    end
-
     # When used as right hand side, this tells what data to move to get the result into
     # a varaible. It is (off course) the return value of the message
     def slot_definition(compiler)
       Mom::SlotDefinition.new(:message ,[ :return_value])
     end
 
-    def message_setup(in_method,called_method)
-      setup  = Mom::MessageSetup.new( called_method )
+    # A Send breaks down to 2 steps:
+    # - Setting up the next message, with receiver, arguments, and (importantly) return address
+    # - a SimpleCall,
+    def to_mom( compiler )
+      @parfait_block = @block.to_mom(compiler) if @block
+      @receiver = SelfExpression.new(compiler.receiver_type) if @receiver.is_a?(SelfExpression)
+      yield_call(compiler)
+    end
+
+    # this breaks into two parts:
+    # - check the calling method and break to a (not implemented) dynamic version
+    # - call the block, that is the last argument of the method
+    def yield_call(compiler)
+      method_check(compiler) << yield_arg_block(compiler)
+    end
+
+    # check that the calling method is the method that the block was created in.
+    # In that case variable resolution is reasy and we can prceed to yield
+    # Note: the else case is not implemented (ie passing lambdas around)
+    #      this needs run-time variable resolution, which is just not done.
+    #      we brace ourselves with the check, and exit (later raise) if . . .
+    def method_check(compiler)
+      ok_label = Mom::Label.new("method_ok_#{self.object_id}")
+      compile_method = Mom::SlotDefinition.new( compiler.get_method , [])
+      runtime_method = Mom::SlotDefinition.new( :message , [ :method] )
+      check = Mom::NotSameCheck.new(compile_method , runtime_method, ok_label)
+      # TODO? Maybe create mom instructions for this
+      #builder = compiler.code_builder("yield")
+      #Risc::Builtin::Object.exit_sequence(builder)
+      #check << builder.built
+      check << ok_label
+    end
+
+    # to call the block (that we know now to be the last arg),
+    # we do a message setup, arg transfer and the a arg_yield (which is similar to dynamic_call)
+    def yield_arg_block(compiler)
+      arg_index = compiler.get_method.arguments_type.get_length
+      setup  = Mom::MessageSetup.new( arg_index )
       mom_receive = @receiver.slot_definition(compiler)
       arg_target = [:message , :next_message , :arguments]
       args = []
@@ -49,13 +73,12 @@ module Vool
         args << Mom::SlotLoad.new( arg_target + [index + 1] , arg.slot_definition(compiler))
       end
       setup << Mom::ArgumentTransfer.new( mom_receive , args )
+      setup << Mom::BlockYield.new( arg_index )
     end
 
-    def simple_call(in_method)
-      type = @receiver.ct_type
-      called_method = type.resolve_method(@name)
-      raise "No method #{@name} for #{type}" unless called_method
-      message_setup(in_method,called_method) << Mom::SimpleCall.new(called_method)
+    def to_s(depth = 0)
+      sen = "#{receiver}.#{name}(#{@arguments.collect{|a| a.to_s}.join(', ')})"
+      at_depth(depth , sen)
     end
 
   end