Why need to copy the objective-c handler before cast it to void* type?

Question

I want to simulate the NSAlert member function which only exist on 10.9.

- (void)beginSheetModalForWindow:(NSWindow *)sheetWindow completionHandler:(void (^)(NSModalResponse returnCode))handler NS_AVAILABLE_MAC(10_9);

The code is as following:

-(void)compatibleBeginSheetModalForWindow: (NSWindow *)sheetWindow
                        completionHandler: (void (^)(NSInteger returnCode))handler
{
    void *handlerValue = (__bridge void*) [handler copy];
    [self beginSheetModalForWindow: sheetWindow
                     modalDelegate: self
                    didEndSelector: @selector(blockBasedAlertDidEnd:returnCode:contextInfo:)
                       contextInfo: handlerValue];
}

-(void)blockBasedAlertDidEnd: (NSAlert *)alert
                  returnCode: (NSInteger)returnCode
                 contextInfo: (void *)contextInfo
{
    void(^handler)(NSInteger) = (__bridge typeof(handler)) contextInfo;
    handler(returnCode);
    [handler release];
}

I need to copy the handler before cast it to void*, else it will crash, if I change it to following line:

void *handlerValue = (__bridge void*) handler;

And by check the handler in blockBasedAlertDidEnd:returnCode:contextInfo:, it is an incorrect value.

Even I call [handler retain] before cast to void* it doesn't work. It is quite confuse to me, so why I need to copy it?

@newacct, `__bridge` doesn't call `retain`, correct? Do you means I should remove `__bridge`, and why I shouldn't use it, I assume it just do the type case. — ZijingWu, Mar 14 '14 at 02:07
Bridge casts are ignored in MRC; you should be getting a warning about this. They are meaningful only in ARC, to indicate whether the non-object-pointer should be considered "retained" or not. However, if you moved this to ARC, the bridge casts that you have would not be correct, because you must keep the object retained while it is in the `void *`, so you would need to use `__bridge_retained` when casting it from object pointer to `void *`, and `__bridge_transfer` when casting it out of `void *` to consume the retain count. — newacct, Mar 14 '14 at 18:39

score 2 · Accepted Answer · answered Mar 11 '14 at 10:16

2

This is because blocks are created on the stack and not the heap. So when the stack pointer moves on the memory in that stack frame is returned and the block is lost. Thats why you always should copy blocks and not retain them. When you run copy on a block the new copy is allocated on the heap and therefor don't get removed.

answered Mar 11 '14 at 10:16

Peter Segerblom

2,773
1
19
24

But isn't block be an Objective-C NSObject sub class object? I thought it's copy member function is inherit from NSObject. – ZijingWu Mar 11 '14 at 10:21
Blocks are objects but i don't think they inherit from NSObject. I don't know exactly howe they are implemented but i would guess it's a C function pointer somewhere in there. As fare as i know blocks are the only objects in Objective-c that are allocated on the stack. – Peter Segerblom Mar 11 '14 at 10:34
@PeterSegerblom: Blocks (in the Apple implementation) *are* instances of NSObject. – newacct Mar 13 '14 at 08:42

score 1 · Answer 2 · answered Mar 13 '14 at 08:58

Peter Segerblom covered the basics of it. In the current implementation, there are 3 kinds of blocks. Blocks that don't capture local variables are global blocks; there is just one instance that has static lifetime. Blocks that do capture local variables start out as objects on the stack; and copying it will return a block on the heap. Copying heap or global blocks will simply return the same instance.

Basically, a block passed into your function could be a stack block or not. A stack block is only valid for the current function call. Since it could be a stack block, you must use a copy of it if you want to store it somewhere that outlives the current function call. This is the contract for functions that take a block parameter.

Now, if all your function does with this block is pass it to another function, do you need to pass a copy? If this function parameter is of block type, then no, because if this function needs to keep the block around for later, then it is responsible for copying it (according to the contract above). So you don't need to worry about it. But, if you pass it to a function that is not of block type (e.g. -[NSMutableArray addObject:]), then that function does not know to potentially copy it (it doesn't even know it's a block). In that case, you will have to pass a copy if that function keeps the object around for later. This is the case with the function you are passing to here.

Nice explain. So does there any document or standard about block behavior just like how lambda defined in C++ standard? I have read Apple document, but seams even Apple doesn't mention Global block/Stack block/Heap block. — ZijingWu, Mar 14 '14 at 02:04
@ZijingWu: Some of those things are implementation details, but basically you can just assume that all blocks (may potentially) start out on the stack, and therefore must be copied to be used outside the scope where it is defined. The Blocks language spec doesn't really say this specifically (http://clang.llvm.org/docs/BlockLanguageSpec.html). But the Background section of the ARC spec says this clearly (http://clang.llvm.org/docs/AutomaticReferenceCounting.html#background). — newacct, Mar 14 '14 at 18:45

Why need to copy the objective-c handler before cast it to void* type?

2 Answers2