Objective-C, or Cocoa specifically, supports variadic arguments, like for example class the method on NSString +(NSString *)stringWithFormat:(NSString *)string, .....
Now, what I would like to know is if it is possible to follow that variadic argument must be at the end of the method, or can the method continue after that?
As an example, suppose I have the variadic method (with the appropriate macro),
- (void)setObjects:(id)obj, ... NS_REQUIRES_NIL_TERMINATION;
If I want to use it at a specific index, could I do something like this,
- (void)setObjects:(id)obj, ... NS_REQUIRES_NIL_TERMINATION atIndex:(int)index;
I've been trying, and this specific example doesn't work, giving me an error message saying "Expected ';' after method prototype". Of course, I could shuffle the arguments around to make sure the variadic one is at the end, like this,
- (void)atIndex:(int)index setObjects:(id)obj, ... NS_REQUIRES_NIL_TERMINATION;
This certainly works, but to me it feels rather alien amidst the Cocoa naming conventions -- which is a problem for me.
Thank you,
Variadic arguments must be the last argument. This is because a method in Objective-C is really just an ordinary C function in disguise, and C doesn't allow any arguments after a variadic argument either.
The reason C doesn't allow it has to do with the calling convention that C supports. When you call a variadic function, the number of variadic arguments is not actually known be the function at first. Different functions can then figure it out in different ways. In Objective C, terminating a variadic argument with nil is common. The printf function figures out how many arguments it's passed based on the format string. Since the function doesn't initially know how many variadic arguments there are, it has no way of knowing the memory location of an argument after the variadic argument list.
Look up "C calling conventions" if you wish to know more.
(Some consider this limitation to be a "wart" of the C language, which is fair. However, we are stuck with it due to the need for ABI compatibility. C++ has the same issue with variadic functions.)
Related
Read a function call like this in Apple's tutorial for OC. a bit confused about how function stringWithFormat is defined or its signature...
[NSString stringWithFormat:#"The magic number is %i", magicNumber];
A relative question is about NSLog as
NSLog(#"%i is a number", someScalarVarNumber);
Should a function call be like
[Obj FuncName:param FuncName1:param1 FuncName2:param2];
You said:
[I am] a bit confused about how function stringWithFormat is defined or its signature.
If you command-click on stringWithFormat in your code, it will take you directly to its declaration (and you can hit the "back" button to return to your code). Anyway, stringWithFormat is defined as follows:
+ (instancetype)stringWithFormat:(NSString *)format, ... NS_FORMAT_FUNCTION(1,2);
Those ellipses (...) indicate that it is a "variadic function", that it takes a variable length list of parameters separated by commas. This is a C programming pattern which is also incorporated into Objective-C.
In case you're wondering, that NS_FORMAT_FUNCTION is a hint to the compiler that the first parameter (1) is a printf-style format string (or more accurately, slightly richer rendition that NSString uses), and that the parameters starting at the second parameter (2) should match up with what appears in the format string. That lets the compiler check your list of parameters to see if it matches the format string.
The fact that they felt compelled to add this special logic for printf-style parameters is actually a clue to the deeper problem of variadic parameters: With the exception of printf-style case, it's hard to ensure that the parameters passed to the function match what the function was expecting.
As a result, you will generally only see variadic method declarations where the number of parameters being passed to a method is variable and that it has a printf-style format string. (Technically, you can use it in any situation with variable number of parameters, but in those situations there are generally better approaches, e.g. pass an array. In fact, if you look at Apple's newer Cocoa API, where they need variable number of parameters, they generally pass an array rather than using the variadic patterns that you'll see in some of the older API.)
So, you're right, we generally invoke a method like so:
[objectName funcName:firstValue secondParameterName:secondValue thirdParameterName:thirdValue];
But, in special cases, you can employ variadic functions.
Im currently learning some objective-c from the big ranch guide book. My understanding is that methods with multiple parameters use colons to separate each parameter, but when reading about creating arrays, i found this snippet of code:
NSArray *dateList = [NSArray arrayWithObjects:now, tomorrow, yesterday, nil];
This has left me confused as i thought objective-c method parameters must each be preceded by a portion of the method name along with a colon. Can anybody explain this to me?
This is an exception to the rule; this is commonly called a variadic method. If you look at the definition in NSArray.h:
+ (instancetype)arrayWithObjects:(id)firstObj, ... NS_REQUIRES_NIL_TERMINATION;
you see that you can specify an arbitrary number of parameters, as long as the last one is nil (this is called the sentinel).
This saves the developers from creating a large number of different methods having roughly the same functionality, each of which accept a different number of parameters. They did so in NSObject, where you have
- (id)performSelector:(SEL)aSelector withObject:(id)object1;
- (id)performSelector:(SEL)aSelector withObject:(id)object1 withObject:(id)object2;
(but no further methods).
The method only has one parameter, a variable parameter list.
Here is the Objective-C declaration from the Apple Developer website:
+ (instancetype nonnull)arrayWithObjects:(ObjectType nonnull)firstObj, ...;
There's no need for colon separation, because the object list is treated as one parameter, even thought it looks like many parameters!
The Objective C Runtime Guide from Apple, states that you should never use objc_msgSend() in your own code, and recommends using methodForSelector: instead. However, it doesn't provide any reason for this.
What are the dangers of calling objc_msgSend() in your code?
Reason #1: Bad style - it's redundant and unreadable.
The compiler automatically generates calls to objc_msgSend() (or some variant thereof) when it encounters Objective-C messaging expressions. If you know the class and the selector to be sent at compile-time, there's no reason to write
id obj = objc_msgSend(objc_msgSend([NSObject class], #selector(alloc)), #selector(init));
instead of
id obj = [[NSObject alloc] init];
Even if you don't know the class or the selector (or even both), it's still safer (at least the compiler has a chance to warn you if you are doing something potentially nasty/wrong) to obtain a correctly typed function pointer to the implementation itself and use that function pointer instead:
const char *(*fptr)(NSString *, SEL) = [NSString instanceMethodForSelector:#selector(UTF8String)];
const char *cstr = fptr(#"Foo");
This is especially true when the types of the arguments of a method are sensitive to default promotions - if they are, then you don't want to pass them through the variadic arguments objc_msgSend() takes, because your program will quickly invoke undefined behavior.
Reason #2: dangerous and error-prone.
Notice the "or some variant thereof" part in #1. Not all message sends use the objc_msgSend() function itself. Due to complications and requirements in the ABI (in the calling convention of functions, in particular), there are separate functions for returning, for example, floating-point values or structures. For example, in the case of a method that performs some sort of searching (substrings, etc.), and it returns an NSRange structure, depending on the platform, it may be necessary to use the structure-returning version of the messenger function:
NSRange retval;
objc_msgSend_stret(&retval, #"FooBar", #selector(rangeOfString:), #"Bar");
And if you get this wrong (e. g. you use the inappropriate messenger function, you mix up the pointers to the return value and to self, etc.), your program will likely behave incorrectly and/or crash. (And you will most probably get it wrong, because it's not even that simple - not all methods returning a struct use this variant, since small structures will fit into one or two processor registers, eliminating the need for using the stack as the place of the return value. That's why - unless you are a hardcore ABI hacker - you rather want to let the compiler do its job, or there be dragons.)
You ask "what are the dangers?" and #H2CO3 has listed some ending with "unless you are a hardcore ABI hacker"...
As with many rules there are exceptions (and possibly a few more under ARC). So your reasoning for using msgSend should go something along the lines of:
[ 1] I think I should use msgSend - don't.
[2] But I've a case here... - you probably haven't, keep looking for another solution.
...
[10] I really think I should use it here - think again.
...
[100] Really, this looks like a case for msgSend, I can't see any other solution! OK, go read Document.m in the TextEdit code sample from Apple. Do you know why they used msgSend? Are you sure... think again...
...
[1000] I understand why Apple used it, and my case is similar... You've found and understood the exception that proves the rule and your case matches, use it!
HTH
I can make a case. We used msgSend in one of our C++ files (before we switched to ARC) that's in a cross-platform project (Windows, Mac and Linux). We use it to ref count a reference in the backed (the shared code) that's used later to go from frontend to backend and vice versa. Very special case, admittedly.
Going through Apache Cordova's source code, I ran into two lines of code that I'm puzzled about:
//[obj performSelector:normalSelector withObject:command];
objc_msgSend(obj,normalSelector,command);
From Apple's documentation, there doesn't seem to be a lot of difference between these two methods.
id objc_msgSend(id theReceiver, SEL theSelector, ...)
Sends a message with a simple return value to an instance of a class.
- (id)performSelector:(SEL)aSelectorwithObject:(id)anObject
Sends a message to the receiver with an object as the argument. (required)
What exactly is the difference between these two methods? In the case above, both are sending messages with an object as an argument to a receiving object.
You're asking the difference between two "methods" but only one of them is actually a method. The objc_msgSend function is, well, a function. Not a method.
The objc_msgSend function is the function that you actually call when you invoke any method on any object in Objective C. For example, the following two are basically equivalent:
// This is what the compiler generates
objc_msgSend(obj, #selector(sel:), param);
// This is what you write
[obj sel:param];
// You can check the assembly output, they are *almost* identical!
The major difference here is that objc_msgSend does not get type checked by the compiler -- or at least, its arguments don't get type checked against the selector's parameter types. So the following are roughly equivalent:
[obj performSelector:normalSelector withObject:command];
objc_msgSend(obj, #selector(performSelector:withObject:),
normalSelector, command);
But, that's a bit of a waste, since all performSelector:withObject: does is call objc_msgSend.
HOWEVER: You should stay away from obc_msgSend because it is not type-safe, as mentioned above. All the apache devs are doing is removing a single method call, which will only give you very slight performance benefits in most cases.
The commented out line is correct, the objc_msgSend() line is incorrect in that it needs to be explicitly typed (varargs are not compatible with non-varargs function calls on some platforms sometimes).
Effectively they do the same thing. Really, the method call version is just a wrapper around objc_msgSend().
I want to add scripting support for an Objective-C project using the objc runtime. Now I face the problem, that I don't have a clue, how I should call an Objective-C method which takes several named arguments.
So for example the following objective-c call
[object foo:bar];
could be called from C with:
objc_msgSend(object, sel_getUid("foo:"), bar);
But how would I do something similar for the method call:
[object foo:var bar:var2 err:errVar];
??
Best Markus
The accepted answer is close, but it won't work properly for certain types. For example, if the method is declared to take a float as its second argument, this won't work.
To properly use objc_msgSend, you have to cast it to the the appropriate type. For example, if your method is declared as
- (void)foo:(id)foo bar:(float)bar err:(NSError **)err
then you would need to do something like this:
void (*objc_msgSendTyped)(id self, SEL _cmd, id foo, float bar, NSError**error) = (void*)objc_msgSend;
objc_msgSendTyped(self, #selector(foo:bar:err:), foo, bar, error);
Try the above case with just objc_msgSend, and log out the received arguments. You won't see the correct values in the called function. This unusual casting situation arises because objc_msgSend is not intended to be called like a normal C function. It is (and must be) implemented in assembly, and just jumps to a target C function after fiddling with a few registers. In particular, there is no consistent way to refer to any argument past the first two from within objc_msgSend.
Another case where just calling objc_msgSend straight wouldn't work is a method that returns an NSRect, say, because objc_msgSend is not used in that case, objc_msgSend_stret is. In the underlying C function for a method that returns an NSRect, the first argument is actually a pointer to an out value NSRect, and the function itself actually returns void. You must match this convention when calling because it's what the called method will assume. Further, the circumstances in which objc_msgSend_stret is used differ between architectures. There is also an objc_msgSend_fpret, which should be used for methods that return certain floating point types on certain architectures.
Now, since you're trying to do a scripting bridge thing, you probably cannot explicitly cast every case you run across, you want a general solution. All in all, this is not completely trivial, and unfortunately your code has to be specialized to each architecture you wish to target (e.g. i386, x86_64, ppc). Your best bet is probably to see how PyObjC does it. You'll also want to take a look at libffi. It's probably a good idea to understand a little bit more about how parameters are passed in C, which you can read about in the Mac OS X ABI Guide. Last, Greg Parker, who works on the objc runtime, has written a bunch of very nice posts on objc internals.
objc_msgSend(object, sel_getUid("foo:bar:err:"), var, var2, errVar);
If one of the variables is a float, you need to use #Ken's method, or cheat by a reinterpret-cast:
objc_msgSend(..., *(int*)&var, ...)
Also, if the selector returns a float, you may need to use objc_msgSend_fpret, and if it returns a struct you must use objc_msgSend_stret. If that is a call to superclass you need to use objc_msgSendSuper2.
objc_msgSend(obj, #selector(foo:bar:err:), var, var2, &errVar);