GNU Objective-C Features
************************

This document is meant to describe some of the GNU Objective-C features.  It is not intended to teach you Objective-C.  There are several resources on the Internet that present the language.

GNU Objective-C Runtime API
===========================

This section is specific for the GNU Objective-C runtime.  If you are using a different runtime, you can skip it.

The GNU Objective-C runtime provides an API that allows you to interact with the Objective-C runtime system, querying the live runtime structures and even manipulating them.  This allows you for example to inspect and navigate classes, methods and protocols; to define new classes or new methods, and even to modify existing classes or protocols.

If you are using a ``Foundation'' library such as GNUstep-Base, this library will provide you with a rich set of functionality to do most of the inspection tasks, and you probably will only need direct access to the GNU Objective-C runtime API to define new classes or methods.

Modern GNU Objective-C Runtime API
----------------------------------

The GNU Objective-C runtime provides an API which is similar to the one provided by the ``Objective-C 2.0'' Apple/NeXT Objective-C runtime.  The API is documented in the public header files of the GNU Objective-C runtime:

  * objc/objc.h: this is the basic Objective-C header file, defining the basic Objective-C types such as id, Class and BOOL.  You have to include this header to do almost anything with Objective-C.

  * objc/runtime.h: this header declares most of the public runtime API functions allowing you to inspect and manipulate the Objective-C runtime data structures.  These functions are fairly standardized across Objective-C runtimes and are almost identical to the Apple/NeXT Objective-C runtime ones.  It does not declare functions in some specialized areas (constructing and forwarding message invocations, threading) which are in the other headers below.  You have to include objc/objc.h and objc/runtime.h to use any of the functions, such as class_getName(), declared in objc/runtime.h.

  * objc/message.h: this header declares public functions used to construct, deconstruct and forward message invocations.  Because messaging is done in quite a different way on different runtimes, functions in this header are specific to the GNU Objective-C runtime implementation.

  * objc/objc-exception.h: this header declares some public functions related to Objective-C exceptions.  For example functions in this header allow you to throw an Objective-C exception from plain C/C++ code.

  * objc/objc-sync.h: this header declares some public functions related to the Objective-C @synchronized() syntax, allowing you to emulate an Objective-C @synchronized() block in plain C/C++ code.

  * objc/thr.h: this header declares a public runtime API threading layer that is only provided by the GNU Objective-C runtime.  It declares functions such as objc_mutex_lock(), which provide a platform-independent set of threading functions.

The header files contain detailed documentation for each function in the GNU Objective-C runtime API.

Traditional GNU Objective-C Runtime API
---------------------------------------

The GNU Objective-C runtime used to provide a different API, which we call the ``traditional'' GNU Objective-C runtime API.  Functions belonging to this API are easy to recognize because they use a different naming convention, such as class_get_super_class() (traditional API) instead of class_getSuperclass() (modern API).  Software using this API includes the file objc/objc-api.h where it is declared.

Starting with GCC 4.7.0, the traditional GNU runtime API is no longer available.

+load: Executing Code before main
=================================

This section is specific for the GNU Objective-C runtime.  If you are using a different runtime, you can skip it.

The GNU Objective-C runtime provides a way that allows you to execute code before the execution of the program enters the main function.  The code is executed on a per-class and a per-category basis, through a special class method +load.

This facility is very useful if you want to initialize global variables which can be accessed by the program directly, without sending a message to the class first.  The usual way to initialize global variables, in the +initialize method, might not be useful because +initialize is only called when the first message is sent to a class object, which in some cases could be too late.

Suppose for example you have a FileStream class that declares Stdin, Stdout and Stderr as global variables, like below:

     FileStream *Stdin = nil;
     FileStream *Stdout = nil;
     FileStream *Stderr = nil;

     @implementation FileStream

     + (void)initialize
     {
         Stdin = [[FileStream new] initWithFd:0];
         Stdout = [[FileStream new] initWithFd:1];
         Stderr = [[FileStream new] initWithFd:2];
     }

     /* Other methods here */
     @end

In this example, the initialization of Stdin, Stdout and Stderr in +initialize occurs too late.  The programmer can send a message to one of these objects before the variables are actually initialized, thus sending messages to the nil object.  The +initialize method which actually initializes the global variables is not invoked until the first message is sent to the class object.  The solution would require these variables to be initialized just before entering main.

The correct solution of the above problem is to use the +load method instead of +initialize:

     @implementation FileStream

     + (void)load
     {
         Stdin = [[FileStream new] initWithFd:0];
         Stdout = [[FileStream new] initWithFd:1];
         Stderr = [[FileStream new] initWithFd:2];
     }

     /* Other methods here */
     @end

The +load is a method that is not overridden by categories.  If a class and a category of it both implement +load, both methods are invoked.  This allows some additional initializations to be performed in a category.

This mechanism is not intended to be a replacement for +initialize. You should be aware of its limitations when you decide to use it instead of +initialize.

What You Can and Cannot Do in +load
-----------------------------------

+load is to be used only as a last resort.  Because it is executed very early, most of the Objective-C runtime machinery will not be ready when +load is executed; hence +load works best for executing C code that is independent on the Objective-C runtime.

The +load implementation in the GNU runtime guarantees you the following things:

  * you can write whatever C code you like;

  * you can allocate and send messages to objects whose class is implemented in the same file;

  * the +load implementation of all super classes of a class are executed before the +load of that class is executed;

  * the +load implementation of a class is executed before the +load implementation of any category.

In particular, the following things, even if they can work in a particular case, are not guaranteed:

  * allocation of or sending messages to arbitrary objects;

  * allocation of or sending messages to objects whose classes have a category implemented in the same file;

  * sending messages to Objective-C constant strings (@"this is a constant string");

You should make no assumptions about receiving +load in sibling classes when you write +load of a class.  The order in which sibling classes receive +load is not guaranteed.

The order in which +load and +initialize are called could be problematic if this matters.  If you don't allocate objects inside +load, it is guaranteed that +load is called before +initialize.  If you create an object inside +load the +initialize method of object's class is invoked even if +load was not invoked.  Note if you explicitly call +load on a class, +initialize will be called first.  To avoid possible problems try to implement only one of these methods.

The +load method is also invoked when a bundle is dynamically loaded into your running program.  This happens automatically without any intervening operation from you.  When you write bundles and you need to write +load you can safely create and send messages to objects whose classes already exist in the running program.  The same restrictions as above apply to classes defined in bundle.

Type Encoding
=============

This is an advanced section.  Type encodings are used extensively by the compiler and by the runtime, but you generally do not need to know about them to use Objective-C.

The Objective-C compiler generates type encodings for all the types. These type encodings are used at runtime to find out information about selectors and methods and about objects and classes.

The types are encoded in the following way:

_Bool
B
char
c
unsigned char
C
short
s
unsigned short
S
int
i
unsigned int
I
long
l
unsigned long
L
long long
q
unsigned long long
Q
float
f
double
d
long double
D
void
v
id
@
Class
#
SEL
:
char*
*
enum
an enum is encoded exactly as the integer type that the compiler uses for it, which depends on the enumeration
values.  Often the compiler users unsigned int, which is then encoded as I.
unknown type
?
Complex types
j followed by the inner type.  For example _Complex double is encoded as "jd".
bit-fields
b followed by the starting position of the bit-field, the type of the bit-field and the size of the bit-field (the bit-fields encoding was changed from the NeXT's compiler encoding, see below)

The encoding of bit-fields has changed to allow bit-fields to be properly handled by the runtime functions that compute sizes and alignments of types that contain bit-fields.  The previous encoding contained only the size of the bit-field.  Using only this information it is not possible to reliably compute the size occupied by the bit-field.  This is very important in the presence of the Boehm's garbage collector because the objects are allocated using the typed memory facility available in this collector.  The typed memory allocation requires information about where the pointers are located inside the object.

The position in the bit-field is the position, counting in bits, of the bit closest to the beginning of the structure.

The non-atomic types are encoded as follows:

pointers
^ followed by the pointed type.
arrays
[ followed by the number of elements in the array followed by the type of the elements followed by ]
structures
{ followed by the name of the structure (or ? if the structure is unnamed), the = sign, the type of the members and by }
unions
( followed by the name of the structure (or ? if the union is unnamed), the = sign, the type of the members followed by )
vectors
![ followed by the vector_size (the number of bytes composing the vector) followed by a comma, followed by the alignment (in bytes) of the vector, followed by the type of the elements followed by ]

Here are some types and their encodings, as they are generated by the compiler on an i386 machine:

Objective-C type
Compiler encoding

     int a[10];

[10i]

     struct {
       int i;
       float f[3];
       int a:3;
       int b:2;
       char c;
     }

{?=i[3f]b128i3b131i2c}

     int a __attribute__ ((vector_size (16)));

![16,16i] (alignment depends on the machine)

In addition to the types the compiler also encodes the type specifiers.  The table below describes the encoding of the current Objective-C type specifiers:

Specifier
Encoding
const
r
in
n
inout
N
out
o
bycopy
O
byref
R
oneway
V

The type specifiers are encoded just before the type.  Unlike types however, the type specifiers are only encoded when they appear in method argument types.

Note how const interacts with pointers:

Objective-C type
Compiler encoding

     const int

ri

     const int*

^ri

     int *const

r^i

const int* is a pointer to a const int, and so is encoded as ^ri.  int* const, instead, is a const pointer to an int, and so is encoded as r^i.

Finally, there is a complication when encoding const char * versus char * const.  Because char * is encoded as * and not as ^c, there is no way to express the fact that r applies to the pointer or to the pointee.

Hence, it is assumed as a convention that r* means const char * (since it is what is most often meant), and there is no way to encode char *const.  char *const would simply be encoded as *, and the const is lost.

Legacy Type Encoding
--------------------

Unfortunately, historically GCC used to have a number of bugs in its encoding code.  The NeXT runtime expects GCC to emit type encodings in this historical format (compatible with GCC-3.3), so when using the NeXT runtime, GCC will introduce on purpose a number of incorrect encodings:

  * the read-only qualifier of the pointee gets emitted before the '^'. The read-only qualifier of the pointer itself gets ignored, unless it is a typedef.  Also, the 'r' is only emitted for the outermost type.

  * 32-bit longs are encoded as 'l' or 'L', but not always.  For typedefs, the compiler uses 'i' or 'I' instead if encoding a struct field or a pointer.

  * enums are always encoded as 'i' (int) even if they are actually unsigned or long.

In addition to that, the NeXT runtime uses a different encoding for bitfields.  It encodes them as b followed by the size, without a bit offset or the underlying field type.

@encode
-------

GNU Objective-C supports the @encode syntax that allows you to create a type encoding from a C/Objective-C type.  For example, @encode(int) is compiled by the compiler into "i".

@encode does not support type qualifiers other than const.  For example, @encode(const char*) is valid and is compiled into "r*", while @encode(bycopy char *) is invalid and will cause a compilation error.

Method Signatures
-----------------

This section documents the encoding of method types, which is rarely needed to use Objective-C.  You should skip it at a first reading; the runtime provides functions that will work on methods and can walk through the list of parameters and interpret them for you.  These functions are part of the public ``API'' and are the preferred way to interact with method signatures from user code.

But if you need to debug a problem with method signatures and need to know how they are implemented (i.e., the ``ABI''), read on.

Methods have their ``signature'' encoded and made available to the runtime.  The ``signature'' encodes all the information required to dynamically build invocations of the method at runtime: return type and arguments.

The ``signature'' is a null-terminated string, composed of the following:

  * The return type, including type qualifiers.  For example, a method returning int would have i here.

  * The total size (in bytes) required to pass all the parameters.  This includes the two hidden parameters (the object self and the method selector _cmd).

  * Each argument, with the type encoding, followed by the offset (in bytes) of the argument in the list of parameters.

For example, a method with no arguments and returning int would have the signature i8@0:4 if the size of a pointer is 4.  The signature is interpreted as follows: the i is the return type (an int), the 8 is the total size of the parameters in bytes (two pointers each of size 4), the @0 is the first parameter (an object at byte offset 0) and :4 is the second parameter (a SEL at byte offset 4).

You can easily find more examples by running the ``strings'' program on an Objective-C object file compiled by GCC.  You'll see a lot of strings that look very much like i8@0:4.  They are signatures of Objective-C methods.

Garbage Collection
==================

This section is specific for the GNU Objective-C runtime.  If you are using a different runtime, you can skip it.

Support for garbage collection with the GNU runtime has been added by using a powerful conservative garbage collector, known as the Boehm-Demers-Weiser conservative garbage collector.

To enable the support for it you have to configure the compiler using an additional argument, --enable-objc-gc.  This will build the boehm-gc library, and build an additional runtime library which has several enhancements to support the garbage collector.  The new library has a new name, libobjc_gc.a to not conflict with the non-garbage-collected library.

When the garbage collector is used, the objects are allocated using the so-called typed memory allocation mechanism available in the Boehm-Demers-Weiser collector.  This mode requires precise information on where pointers are located inside objects.  This information is computed once per class, immediately after the class has been initialized.

There is a new runtime function class_ivar_set_gcinvisible() which can be used to declare a so-called weak pointer reference.  Such a pointer is basically hidden for the garbage collector; this can be useful in certain situations, especially when you want to keep track of the allocated objects, yet allow them to be collected.  This kind of pointers can only be members of objects, you cannot declare a global pointer as a weak reference.  Every type which is a pointer type can be declared a weak pointer, including id, Class and SEL.

Here is an example of how to use this feature.  Suppose you want to implement a class whose instances hold a weak pointer reference; the following class does this:

     @interface WeakPointer : Object
     {
         const void* weakPointer;
     }

     - initWithPointer:(const void*)p;
     - (const void*)weakPointer;
     @end

     @implementation WeakPointer

     + (void)initialize
     {
       if (self == objc_lookUpClass ("WeakPointer"))
         class_ivar_set_gcinvisible (self, "weakPointer", YES);
     }

     - initWithPointer:(const void*)p
     {
       weakPointer = p;
       return self;
     }

     - (const void*)weakPointer
     {
       return weakPointer;
     }

     @end

Weak pointers are supported through a new type character specifier represented by the ! character.  The class_ivar_set_gcinvisible() function adds or removes this specifier to the string type description of the instance variable named as argument.

Constant String Objects
=======================

GNU Objective-C provides constant string objects that are generated directly by the compiler.  You declare a constant string object by prefixing a C constant string with the character @:

       id myString = @"this is a constant string object";

The constant string objects are by default instances of the NXConstantString class which is provided by the GNU Objective-C runtime.  To get the definition of this class you must include the objc/NXConstStr.h header file.

User defined libraries may want to implement their own constant string class.  To be able to support them, the GNU Objective-C compiler provides a new command line options -fconstant-string-class=CLASS-NAME. The provided class should adhere to a strict structure, the same as NXConstantString's structure:

     @interface MyConstantStringClass
     {
       Class isa;
       char *c_string;
       unsigned int len;
     }
     @end

NXConstantString inherits from Object; user class libraries may choose to inherit the customized constant string class from a different class than Object.  There is no requirement in the methods the constant string class has to implement, but the final ivar layout of the class must be the compatible with the given structure.

When the compiler creates the statically allocated constant string object, the c_string field will be filled by the compiler with the string; the length field will be filled by the compiler with the string length; the isa pointer will be filled with NULL by the compiler, and it will later be fixed up automatically at runtime by the GNU Objective-C runtime library to point to the class which was set by the -fconstant-string-class option when the object file is loaded (if you wonder how it works behind the scenes, the name of the class to use, and the list of static objects to fixup, are stored by the compiler in the object file in a place where the GNU runtime library will find them at runtime).

As a result, when a file is compiled with the -fconstant-string-class option, all the constant string objects will be instances of the class specified as argument to this option.  It is possible to have multiple compilation units referring to different constant string classes, neither the compiler nor the linker impose any restrictions in doing this.

compatibility_alias
===================

The keyword @compatibility_alias allows you to define a class name as equivalent to another class name.  For example:

     @compatibility_alias WOApplication GSWApplication;

tells the compiler that each time it encounters WOApplication as a class name, it should replace it with GSWApplication (that is, WOApplication is just an alias for GSWApplication).

There are some constraints on how this can be used---

  * WOApplication (the alias) must not be an existing class;

  * GSWApplication (the real class) must be an existing class.

Exceptions
==========

GNU Objective-C provides exception support built into the language, as in the following example:

       @try {
         ...
            @throw expr;
         ...
       }
       @catch (AnObjCClass *exc) {
         ...
           @throw expr;
         ...
           @throw;
         ...
       }
       @catch (AnotherClass *exc) {
         ...
       }
       @catch (id allOthers) {
         ...
       }
       @finally {
         ...
           @throw expr;
         ...
       }

The @throw statement may appear anywhere in an Objective-C or Objective-C++ program; when used inside of a @catch block, the @throw may appear without an argument (as shown above), in which case the object caught by the @catch will be rethrown.

Note that only (pointers to) Objective-C objects may be thrown and caught using this scheme.  When an object is thrown, it will be caught by the nearest @catch clause capable of handling objects of that type, analogously to how catch blocks work in C++ and Java.  A @catch(id ...) clause (as shown above) may also be provided to catch any and all Objective-C exceptions not caught by previous @catch clauses (if any).

The @finally clause, if present, will be executed upon exit from the immediately preceding @try ... @catch section. This will happen regardless of whether any exceptions are thrown, caught or rethrown inside the @try ... @catch section, analogously to the behavior of the finally clause in Java.

There are several caveats to using the new exception mechanism:

  * The -fobjc-exceptions command line option must be used when compiling Objective-C files that use exceptions.

  * With the GNU runtime, exceptions are always implemented as ``native'' exceptions and it is recommended that the -fexceptions and -shared-libgcc options are used when linking.

  * With the NeXT runtime, although currently designed to be binary compatible with NS_HANDLER-style idioms provided by the NSException class, the new exceptions can only be used on Mac OS X 10.3 (Panther) and later systems, due to additional functionality needed in the NeXT Objective-C runtime.

  * As mentioned above, the new exceptions do not support handling types other than Objective-C objects.   Furthermore, when used from Objective-C++, the Objective-C exception model does not interoperate with C++ exceptions at this time.  This means you cannot @throw an exception from Objective-C and catch it in C++, or vice versa (i.e., throw ... @catch).

Synchronization
===============

GNU Objective-C provides support for synchronized blocks:

       @synchronized (ObjCClass *guard) {
         ...
       }

Upon entering the @synchronized block, a thread of execution shall first check whether a lock has been placed on the corresponding guard object by another thread.  If it has, the current thread shall wait until the other thread relinquishes its lock.  Once guard becomes available, the current thread will place its own lock on it, execute the code contained in the @synchronized block, and finally relinquish the lock (thereby making guard available to other threads).

Unlike Java, Objective-C does not allow for entire methods to be marked @synchronized.  Note that throwing exceptions out of @synchronized blocks is allowed, and will cause the guarding object to be unlocked properly.

Because of the interactions between synchronization and exception handling, you can only use @synchronized when compiling with exceptions enabled, that is with the command line option -fobjc-exceptions.

Fast Enumeration
================

Using Fast Enumeration
----------------------

GNU Objective-C provides support for the fast enumeration syntax:

       id array = ...;
       id object;

       for (object in array)
       {
         /* Do something with 'object' */
       }

array needs to be an Objective-C object (usually a collection object, for example an array, a dictionary or a set) which implements the ``Fast Enumeration Protocol'' (see below).  If you are using a Foundation library such as GNUstep Base or Apple Cocoa Foundation, all collection objects in the library implement this protocol and can be used in this way.

The code above would iterate over all objects in array.  For each of them, it assigns it to object, then executes the Do something with 'object' statements.

Here is a fully worked-out example using a Foundation library (which provides the implementation of NSArray, NSString and NSLog):

       NSArray *array = [NSArray arrayWithObjects: @"1", @"2", @"3", nil];
       NSString *object;

       for (object in array)
         NSLog (@"Iterating over %@", object);

C99-Like Fast Enumeration Syntax
--------------------------------

A c99-like declaration syntax is also allowed:

       id array = ...;

       for (id object in array)
       {
         /* Do something with 'object'  */
       }

this is completely equivalent to:

       id array = ...;

       {
         id object;
         for (object in array)
         {
           /* Do something with 'object'  */
         }
       }

but can save some typing.

Note that the option -std=c99 is not required to allow this syntax in Objective-C.

Fast Enumeration Details
------------------------

Here is a more technical description with the gory details.  Consider the code

       for (OBJECT EXPRESSION in COLLECTION EXPRESSION)
       {
         STATEMENTS
       }

here is what happens when you run it:

  * COLLECTION EXPRESSION is evaluated exactly once and the result is used as the collection object to iterate over.  This means it is safe to write code such as for (object in [NSDictionary keyEnumerator]) ....

  * the iteration is implemented by the compiler by repeatedly getting batches of objects from the collection object using the fast enumeration protocol (see below), then iterating over all objects in the batch.  This is faster than a normal enumeration where objects are retrieved one by one (hence the name ``fast enumeration'').

  * if there are no objects in the collection, then OBJECT EXPRESSION is set to nil and the loop immediately terminates.

  * if there are objects in the collection, then for each object in the collection (in the order they are returned) OBJECT EXPRESSION is set to the object, then STATEMENTS are executed.

  * STATEMENTS can contain break and continue commands, which will abort the iteration or skip to the next loop iteration as expected.

  * when the iteration ends because there are no more objects to iterate over, OBJECT EXPRESSION is set to nil.  This allows you to determine whether the iteration finished because a break command was used (in which case OBJECT EXPRESSION will remain set to the last object that was iterated over) or because it iterated over all the objects (in which case OBJECT EXPRESSION will be set to nil).

  * STATEMENTS must not make any changes to the collection object; if they do, it is a hard error and the fast enumeration terminates by invoking objc_enumerationMutation, a runtime function that normally aborts the program but which can be customized by Foundation libraries via objc_set_mutation_handler to do something different, such as raising an exception.

Fast Enumeration Protocol
-------------------------

If you want your own collection object to be usable with fast enumeration, you need to have it implement the method

     - (unsigned long) countByEnumeratingWithState: (NSFastEnumerationState *)state
                                           objects: (id *)objects
                                             count: (unsigned long)len;

where NSFastEnumerationState must be defined in your code as follows:

     typedef struct
     {
       unsigned long state;
       id            *itemsPtr;
       unsigned long *mutationsPtr;
       unsigned long extra[5];
     } NSFastEnumerationState;

If no NSFastEnumerationState is defined in your code, the compiler will automatically replace NSFastEnumerationState * with struct __objcFastEnumerationState *, where that type is silently defined by the compiler in an identical way.  This can be confusing and we recommend that you define NSFastEnumerationState (as shown above) instead.

The method is called repeatedly during a fast enumeration to retrieve batches of objects.  Each invocation of the method should retrieve the next batch of objects.

The return value of the method is the number of objects in the current batch; this should not exceed len, which is the maximum size of a batch as requested by the caller.  The batch itself is returned in the itemsPtr field of the NSFastEnumerationState struct.

To help with returning the objects, the objects array is a C array preallocated by the caller (on the stack) of size len. In many cases you can put the objects you want to return in that objects array, then do itemsPtr = objects.  But you don't have to; if your collection already has the objects to return in some form of C array, it could return them from there instead.

The state and extra fields of the NSFastEnumerationState structure allows your collection object to keep track of the state of the enumeration.  In a simple array implementation, state may keep track of the index of the last object that was returned, and extra may be unused.

The mutationsPtr field of the NSFastEnumerationState is used to keep track of mutations.  It should point to a number; before working on each object, the fast enumeration loop will check that this number has not changed.  If it has, a mutation has happened and the fast enumeration will abort.  So, mutationsPtr could be set to point to some sort of version number of your collection, which is increased by one every time there is a change (for example when an object is added or removed).  Or, if you are content with less strict mutation checks, it could point to the number of objects in your collection or some other value that can be checked to perform an approximate check that the collection has not been mutated.

Finally, note how we declared the len argument and the return value to be of type unsigned long.  They could also be declared to be of type unsigned int and everything would still work.

Messaging with the GNU Objective-C Runtime
==========================================

This section is specific for the GNU Objective-C runtime.  If you are using a different runtime, you can skip it.

The implementation of messaging in the GNU Objective-C runtime is designed to be portable, and so is based on standard C.

Sending a message in the GNU Objective-C runtime is composed of two separate steps.  First, there is a call to the lookup function, objc_msg_lookup () (or, in the case of messages to super, objc_msg_lookup_super ()).  This runtime function takes as argument the receiver and the selector of the method to be called; it returns the IMP, that is a pointer to the function implementing the method.  The second step of method invocation consists of casting this pointer function to the appropriate function pointer type, and calling the function pointed to it with the right arguments.

For example, when the compiler encounters a method invocation such as [object init], it compiles it into a call to objc_msg_lookup (object, @selector(init)) followed by a cast of the returned value to the appropriate function pointer type, and then it calls it.

Dynamically Registering Methods
-------------------------------

If objc_msg_lookup() does not find a suitable method implementation, because the receiver does not implement the required method, it tries to see if the class can dynamically register the method.

To do so, the runtime checks if the class of the receiver implements the method

     + (BOOL) resolveInstanceMethod: (SEL)selector;

in the case of an instance method, or

     + (BOOL) resolveClassMethod: (SEL)selector;

in the case of a class method.  If the class implements it, the runtime invokes it, passing as argument the selector of the original method, and if it returns YES, the runtime tries the lookup again, which could now succeed if a matching method was added dynamically by +resolveInstanceMethod: or +resolveClassMethod:.

This allows classes to dynamically register methods (by adding them to the class using class_addMethod) when they are first called. To do so, a class should implement +resolveInstanceMethod: (or, depending on the case, +resolveClassMethod:) and have it recognize the selectors of methods that can be registered dynamically at runtime, register them, and return YES.  It should return NO for methods that it does not dynamically registered at runtime.

If +resolveInstanceMethod: (or +resolveClassMethod:) is not implemented or returns NO, the runtime then tries the forwarding hook.

Support for +resolveInstanceMethod: and resolveClassMethod: was added to the GNU Objective-C runtime in GCC version 4.6.

Forwarding Hook
---------------

The GNU Objective-C runtime provides a hook, called __objc_msg_forward2, which is called by objc_msg_lookup() when it cannot find a method implementation in the runtime tables and after calling +resolveInstanceMethod: and +resolveClassMethod: has been attempted and did not succeed in dynamically registering the method.

To configure the hook, you set the global variable __objc_msg_forward2 to a function with the same argument and return types of objc_msg_lookup().  When objc_msg_lookup() can not find a method implementation, it invokes the hook function you provided to get a method implementation to return.  So, in practice __objc_msg_forward2 allows you to extend objc_msg_lookup() by adding some custom code that is called to do a further lookup when no standard method implementation can be found using the normal lookup.

This hook is generally reserved for ``Foundation'' libraries such as GNUstep Base, which use it to implement their high-level method forwarding API, typically based around the forwardInvocation: method.  So, unless you are implementing your own ``Foundation'' library, you should not set this hook.

In a typical forwarding implementation, the __objc_msg_forward2 hook function determines the argument and return type of the method that is being looked up, and then creates a function that takes these arguments and has that return type, and returns it to the caller. Creating this function is non-trivial and is typically performed using a dedicated library such as libffi.

The forwarding method implementation thus created is returned by objc_msg_lookup() and is executed as if it was a normal method implementation.  When the forwarding method implementation is called, it is usually expected to pack all arguments into some sort of object (typically, an NSInvocation in a ``Foundation'' library), and hand it over to the programmer (forwardInvocation:) who is then allowed to manipulate the method invocation using a high-level API provided by the ``Foundation'' library.  For example, the programmer may want to examine the method invocation arguments and name and potentially change them before forwarding the method invocation to one or more local objects (performInvocation:) or even to remote objects (by using Distributed Objects or some other mechanism).  When all this completes, the return value is passed back and must be returned correctly to the original caller.

Note that the GNU Objective-C runtime currently provides no support for method forwarding or method invocations other than the __objc_msg_forward2 hook.

If the forwarding hook does not exist or returns NULL, the runtime currently attempts forwarding using an older, deprecated API, and if that fails, it aborts the program.  In future versions of the GNU Objective-C runtime, the runtime will immediately abort.