path: root/libobjc/objc/runtime.h

/* GNU Objective-C Runtime API - Modern API
   Copyright (C) 2010-2013 Free Software Foundation, Inc.
   Contributed by Nicola Pero <nicola.pero@meta-innovation.com>

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 3, or (at your option) any
later version.

GCC is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
License for more details.

Under Section 7 of GPL version 3, you are granted additional
permissions described in the GCC Runtime Library Exception, version
3.1, as published by the Free Software Foundation.

You should have received a copy of the GNU General Public License and
a copy of the GCC Runtime Library Exception along with this program;
see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
<http://www.gnu.org/licenses/>.  */

#ifndef __objc_runtime_INCLUDE_GNU
#define __objc_runtime_INCLUDE_GNU

/*
  This file declares the "modern" GNU Objective-C Runtime API.

  This API replaced the "traditional" GNU Objective-C Runtime API
  (which used to be declared in objc/objc-api.h) which is the one
  supported by older versions of the GNU Objective-C Runtime.  The
  "modern" API is very similar to the API used by the modern
  Apple/NeXT runtime.
*/
#include "objc.h"
#include "objc-decls.h"

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

/* An 'Ivar' represents an instance variable.  It holds information
   about the name, type and offset of the instance variable.  */
typedef struct objc_ivar *Ivar;

/* A 'Property' represents a property.  It holds information about the
   name of the property, and its attributes.

   Compatibility Note: the Apple/NeXT runtime defines this as
   objc_property_t, so we define it that way as well, but obviously
   Property is the right name.  */
typedef struct objc_property *Property;
typedef struct objc_property *objc_property_t;

/* A 'Method' represents a method.  It holds information about the
   name, types and the IMP of the method.  */
typedef struct objc_method *Method;

/* A 'Category' represents a category.  It holds information about the
   name of the category, the class it belongs to, and the methods,
   protocols and such like provided by the category.  */
typedef struct objc_category *Category;

/* 'Protocol' is defined in objc/objc.h (which is included by this
   file).  */

/* Method descriptor returned by introspective Object methods.  At the
   moment, this is really just the first part of the more complete
   objc_method structure used internally by the runtime.  (PS: In the
   GNU Objective-C Runtime, selectors already include a type, so an
   objc_method_description does not add much to a SEL.  But in other
   runtimes, that is not the case, which is why
   objc_method_description exists).  */
struct objc_method_description
{
  SEL name;      /* Selector (name and signature) */
  char *types;   /* Type encoding */
};

/* The following are used in encode strings to describe the type of
   Ivars and Methods.  */
#define _C_ID       '@'
#define _C_CLASS    '#'
#define _C_SEL      ':'
#define _C_CHR      'c'
#define _C_UCHR     'C'
#define _C_SHT      's'
#define _C_USHT     'S'
#define _C_INT      'i'
#define _C_UINT     'I'
#define _C_LNG      'l'
#define _C_ULNG     'L'
#define _C_LNG_LNG  'q'
#define _C_ULNG_LNG 'Q'
#define _C_FLT      'f'
#define _C_DBL      'd'
#define _C_LNG_DBL  'D'
#define _C_BFLD     'b'
#define _C_BOOL     'B'
#define _C_VOID     'v'
#define _C_UNDEF    '?'
#define _C_PTR      '^'
#define _C_CHARPTR  '*'
#define _C_ARY_B    '['
#define _C_ARY_E    ']'
#define _C_UNION_B  '('
#define _C_UNION_E  ')'
#define _C_STRUCT_B '{'
#define _C_STRUCT_E '}'
#define _C_VECTOR   '!'
#define _C_COMPLEX  'j'

/* _C_ATOM is never generated by the compiler.  You can treat it as
   equivalent to "*".  */
#define _C_ATOM     '%'

/* The following are used in encode strings to describe some
   qualifiers of method and ivar types.  */
#define _C_CONST	'r'
#define _C_IN		'n'
#define _C_INOUT	'N'
#define _C_OUT      	'o'
#define _C_BYCOPY	'O'
#define _C_BYREF	'R'
#define _C_ONEWAY	'V'
#define _C_GCINVISIBLE	'|'

/* The same when used as flags.  */
#define _F_CONST	0x01
#define _F_IN		0x01
#define _F_OUT		0x02
#define _F_INOUT	0x03
#define _F_BYCOPY	0x04
#define _F_BYREF	0x08
#define _F_ONEWAY	0x10
#define _F_GCINVISIBLE	0x20


/** Implementation: the following functions are defined inline.  */

/* Return the class of 'object', or Nil if the object is nil.  If
   'object' is a class, the meta class is returned; if 'object' is a
   meta class, the root meta class is returned (note that this is
   different from the traditional GNU Objective-C Runtime API function
   object_get_class(), which for a meta class would return the meta
   class itself).  This function is inline, so it is really fast and
   should be used instead of accessing object->class_pointer
   directly.  */
static inline Class
object_getClass (id object)
{
  if (object != nil)
    return object->class_pointer;
  else
    return Nil;
}


/** Implementation: the following functions are in selector.c.  */

/* Return the name of a given selector.  If 'selector' is NULL, return
   "<null selector>".  */
objc_EXPORT const char *sel_getName (SEL selector);

/* Return the type of a given selector.  Return NULL if selector is
   NULL.

   Compatibility Note: the Apple/NeXT runtime has untyped selectors,
   so it does not have this function, which is specific to the GNU
   Runtime.  */
objc_EXPORT const char *sel_getTypeEncoding (SEL selector);

/* This is the same as sel_registerName ().  Please use
   sel_registerName () instead.  */
objc_EXPORT SEL sel_getUid (const char *name);

/* Register a selector with a given name (but unspecified types).  If
   you know the types, it is better to call sel_registerTypedName().
   If a selector with this name and no types already exists, it is
   returned.  Note that this function should really be called
   'objc_registerSelector'.  Return NULL if 'name' is NULL.  */
objc_EXPORT SEL sel_registerName (const char *name);

/* Register a selector with a given name and types.  If a selector
   with this name and types already exists, it is returned.  Note that
   this function should really be called 'objc_registerTypedSelector',
   and it's called 'sel_registerTypedName' only for consistency with
   'sel_registerName'.  Return NULL if 'name' is NULL.

   Compatibility Note: the Apple/NeXT runtime has untyped selectors,
   so it does not have this function, which is specific to the GNU
   Runtime.  */
objc_EXPORT SEL sel_registerTypedName (const char *name, const char *type);

/* Return YES if first_selector is the same as second_selector, and NO
   if not.  */
objc_EXPORT BOOL sel_isEqual (SEL first_selector, SEL second_selector);

/* Return all the selectors with the supplied name.  In the GNU
   runtime, selectors are typed and there may be multiple selectors
   with the same name but a different type.  The return value of the
   function is a pointer to an area, allocated with malloc(), that
   contains all the selectors with the supplier name known to the
   runtime.  The list is terminated by NULL.  Optionally, if you pass
   a non-NULL 'numberOfReturnedSelectors' pointer, the unsigned int
   that it points to will be filled with the number of selectors
   returned.

   Compatibility Note: the Apple/NeXT runtime has untyped selectors,
   so it does not have this function, which is specific to the GNU
   Runtime.  */
objc_EXPORT SEL * sel_copyTypedSelectorList (const char *name,
					     unsigned int *numberOfReturnedSelectors);

/* Return a selector with name 'name' and a non-zero type encoding, if
   there is a single selector with a type, and with that name,
   registered with the runtime.  If there is no such selector, or if
   there are multiple selectors with the same name but conflicting
   types, NULL is returned.  Return NULL if 'name' is NULL.

   This is useful if you have the name of the selector, and would
   really like to get a selector for it that includes the type
   encoding.  Unfortunately, if the program contains multiple selector
   with the same name but different types, sel_getTypedSelector can
   not possibly know which one you need, and so will return NULL.

   Compatibility Note: the Apple/NeXT runtime has untyped selectors,
   so it does not have this function, which is specific to the GNU
   Runtime.  */
objc_EXPORT SEL sel_getTypedSelector (const char *name);


/** Implementation: the following functions are in objects.c.  */

/* Create an instance of class 'class_', adding extraBytes to the size
   of the returned object.  This method allocates the appropriate
   amount of memory for the instance, initializes it to zero, then
   calls all the C++ constructors on appropriate C++ instance
   variables of the instance (if any) (TODO: The C++ constructors bit
   is not implemented yet).  */
objc_EXPORT id class_createInstance (Class class_, size_t extraBytes);

/* Copy an object and return the copy.  extraBytes should be identical
   to the extraBytes parameter that was passed when creating the
   original object.  */
objc_EXPORT id object_copy (id object, size_t extraBytes);

/* Dispose of an object.  This method calls the appropriate C++
   destructors on appropriate C++ instance variables of the instance
   (if any) (TODO: This is not implemented yet), then frees the memory
   for the instance.  */
objc_EXPORT id object_dispose (id object);

/* Return the name of the class of 'object'.  If 'object' is 'nil',
   returns "Nil".  */
objc_EXPORT const char * object_getClassName (id object);

/* Change the class of object to be class_.  Return the previous class
   of object.  This is currently not really thread-safe.  */
objc_EXPORT Class object_setClass (id object, Class class_);


/** Implementation: the following functions are in ivars.c.  */

/* Return an instance variable given the class and the instance
   variable name.  This is an expensive function to call, so try to
   reuse the returned Ivar if you can.  */
objc_EXPORT Ivar class_getInstanceVariable (Class class_, const char *name);

/* Return a class variable given the class and the class variable
   name.  This is an expensive function to call, so try to reuse the
   returned Ivar if you can.  
   
   This function always returns NULL since class variables are
   currently unavailable in Objective-C.  */
objc_EXPORT Ivar class_getClassVariable (Class class_, const char *name);

/* If the object was created in class_createInstance() with some
   extraBytes, returns a pointer to them.  If it was not, then the
   returned pointer may make no sense.  */
objc_EXPORT void * object_getIndexedIvars (id object);

/* Get the value of an instance variable of type 'id'.  The function
   returns the instance variable.  To get the value of the instance
   variable, you should pass as 'returnValue' a pointer to an 'id';
   the value will be copied there.  Note that 'returnValue' is really
   a 'void *', not a 'void **'.  This function really works only with
   instance variables of type 'id'; for other types of instance
   variables, access directly the data at (char *)object +
   ivar_getOffset (ivar).  */
objc_EXPORT Ivar object_getInstanceVariable (id object, const char *name, void **returnValue);

/* Set the value of an instance variable.  The value to set is passed
   in 'newValue' (which really is an 'id', not a 'void *').  The
   function returns the instance variable.  This function really works
   only with instance variables of type 'id'; for other types of
   instance variables, access directly the data at (char *)object +
   ivar_getOffset (ivar).  */
objc_EXPORT Ivar object_setInstanceVariable (id object, const char *name, void *newValue);

/* Get the value of an instance variable of type 'id' of the object
   'object'.  This is faster than object_getInstanceVariable if you
   already have the instance variable because it avoids the expensive
   call to class_getInstanceVariable that is done by
   object_getInstanceVariable.  */
objc_EXPORT id object_getIvar (id object, Ivar variable);

/* Set the value of an instance variable of type 'id' of the object
   'object'.  This is faster than object_setInstanceVariable if you
   already have the instance variable because it avoids the expensive
   call to class_getInstanceVariable that is done by
   object_setInstanceVariable.  */
objc_EXPORT void object_setIvar (id object, Ivar variable, id value);

/* Return the name of the instance variable.  Return NULL if
   'variable' is NULL.  */
objc_EXPORT const char * ivar_getName (Ivar variable);

/* Return the offset of the instance variable from the start of the
   object data.  Return 0 if 'variable' is NULL.  */
objc_EXPORT ptrdiff_t ivar_getOffset (Ivar variable);

/* Return the type encoding of the variable.  Return NULL if
   'variable' is NULL.  */
objc_EXPORT const char * ivar_getTypeEncoding (Ivar variable);

/* Return all the instance variables of the class.  The return value
   of the function is a pointer to an area, allocated with malloc(),
   that contains all the instance variables of the class.  It does not
   include instance variables of superclasses.  The list is terminated
   by NULL.  Optionally, if you pass a non-NULL
   'numberOfReturnedIvars' pointer, the unsigned int that it points to
   will be filled with the number of instance variables returned.
   Return NULL for classes still in construction (ie, allocated using
   objc_allocatedClassPair() but not yet registered with the runtime
   using objc_registerClassPair()).  */
objc_EXPORT Ivar * class_copyIvarList (Class class_, unsigned int *numberOfReturnedIvars);

/* Add an instance variable with name 'ivar_name' to class 'class_',
   where 'class_' is a class in construction that has been created
   using objc_allocateClassPair() and has not been registered with the
   runtime using objc_registerClassPair() yet.  You can not add
   instance variables to classes already registered with the runtime.
   'size' is the size of the instance variable, 'log_2_of_alignment'
   the alignment as a power of 2 (so 0 means alignment to a 1 byte
   boundary, 1 means alignment to a 2 byte boundary, 2 means alignment
   to a 4 byte boundary, etc), and 'type' the type encoding of the
   variable type.  You can use sizeof(), log2(__alignof__()) and
   @encode() to determine the right 'size', 'alignment' and 'type' for
   your instance variable.  For example, to add an instance variable
   name "my_variable" and of type 'id', you can use:

   class_addIvar (class, "my_variable", sizeof (id), log2 ( __alignof__ (id)),
                  @encode (id));

   Return YES if the variable was added, and NO if not.  In
   particular, return NO if 'class_' is Nil, or a meta-class or a
   class not in construction.  Return Nil also if 'ivar_name' or
   'type' is NULL, or 'size' is 0.
 */
objc_EXPORT BOOL class_addIvar (Class class_, const char * ivar_name, size_t size,
				unsigned char log_2_of_alignment, const char *type);

/* Return the name of the property.  Return NULL if 'property' is
   NULL.  */
objc_EXPORT const char * property_getName (Property property);

/* Return the attributes of the property as a string.  Return NULL if
   'property' is NULL.  */
objc_EXPORT const char * property_getAttributes (Property property);

/* Return the property with name 'propertyName' of the class 'class_'.
   This function returns NULL if the required property can not be
   found.  Return NULL if 'class_' or 'propertyName' is NULL.

   Note that the traditional ABI does not store the list of properties
   of a class in a compiled module, so the traditional ABI will always
   return NULL.  */
objc_EXPORT Property class_getProperty (Class class_, const char *propertyName);

/* Return all the properties of the class.  The return value
   of the function is a pointer to an area, allocated with malloc(),
   that contains all the properties of the class.  It does not
   include properties of superclasses.  The list is terminated
   by NULL.  Optionally, if you pass a non-NULL
   'numberOfReturnedIvars' pointer, the unsigned int that it points to
   will be filled with the number of properties returned.

   Note that the traditional ABI does not store the list of properties
   of a class in a compiled module, so the traditional ABI will always
   return an empty list.  */
objc_EXPORT Property * class_copyPropertyList 
(Class class_, unsigned int *numberOfReturnedProperties);

/* Return the ivar layout for class 'class_'.

   At the moment this function always returns NULL.  */
objc_EXPORT const char * class_getIvarLayout (Class class_);

/* Return the weak ivar layout for class 'class_'.

   At the moment this function always returns NULL.  */
objc_EXPORT const char * class_getWeakIvarLayout (Class class_);

/* Set the ivar layout for class 'class_'.

   At the moment, this function does nothing.  */
objc_EXPORT void class_setIvarLayout (Class class_, const char *layout);

/* Set the weak ivar layout for class 'class_'.

   At the moment, this function does nothing.  With the GNU runtime,
   you should use class_ivar_set_gcinvisible () to hide variables from
   the Garbage Collector.  */
objc_EXPORT void class_setWeakIvarLayout (Class class_, const char *layout);


/** Implementation: the following functions are in class.c.  */

/* Compatibility Note: The Apple/NeXT runtime does not have
   objc_get_unknown_class_handler and
   objc_setGetUnknownClassHandler().  They provide functionality that
   the traditional GNU Objective-C Runtime API used to provide via the
   _objc_lookup_class hook.  */

/* An 'objc_get_unknown_class_handler' function is used by
   objc_getClass() to get a class that is currently unknown to the
   compiler.  You could use it for example to have the class loaded by
   dynamically loading a library.  'class_name' is the name of the
   class.  The function should return the Class object if it manages to
   load the class, and Nil if not.  */
typedef Class (*objc_get_unknown_class_handler)(const char *class_name);

/* Sets a new handler function for getting unknown classes (to be used
   by objc_getClass () and related), and returns the previous one.
   This function is not safe to call in a multi-threaded environment
   because other threads may be trying to use the get unknown class
   handler while you change it!  */
objc_EXPORT 
objc_get_unknown_class_handler
objc_setGetUnknownClassHandler (objc_get_unknown_class_handler new_handler);

/* Return the class with name 'name', if it is already registered with
   the runtime.  If it is not registered, and
   objc_setGetUnknownClassHandler() has been called to set a handler
   for unknown classes, the handler is called to give it a chance to
   load the class in some other way.  If the class is not known to the
   runtime and the handler is not set or returns Nil, objc_getClass()
   returns Nil.  */
objc_EXPORT Class objc_getClass (const char *name);

/* Return the class with name 'name', if it is already registered with
   the runtime.  Return Nil if not.  This function does not call the
   objc_get_unknown_class_handler function if the class is not
   found.  */
objc_EXPORT Class objc_lookUpClass (const char *name);

/* Return the meta class associated to the class with name 'name', if
   it is already registered with the runtime.  First, it finds the
   class using objc_getClass().  Then, it returns the associated meta
   class.  If the class could not be found using objc_getClass(),
   returns Nil.  */
objc_EXPORT Class objc_getMetaClass (const char *name);

/* This is identical to objc_getClass(), but if the class is not found,
   it aborts the process instead of returning Nil.  */
objc_EXPORT Class objc_getRequiredClass (const char *name);

/* If 'returnValue' is NULL, 'objc_getClassList' returns the number of
   classes currently registered with the runtime.  If 'returnValue' is
   not NULL, it should be a (Class *) pointer to an area of memory
   which can contain up to 'maxNumberOfClassesToReturn' Class records.
   'objc_getClassList' will fill the area pointed to by 'returnValue'
   with all the Classes registered with the runtime (or up to
   maxNumberOfClassesToReturn if there are more than
   maxNumberOfClassesToReturn).  The function return value is the
   number of classes actually returned in 'returnValue'.  */
objc_EXPORT int objc_getClassList (Class *returnValue, int maxNumberOfClassesToReturn); 

/* Compatibility Note: The Apple/NeXT runtime also has

    Class objc_getFutureClass (const char *name);
    void objc_setFutureClass (Class class_, const char *name);

   the documentation is unclear on what they are supposed to do, and
   the GNU Objective-C Runtime currently does not provide them.  */

/* Return the name of the class 'class_', or the string "nil" if the
   class_ is Nil.  */
objc_EXPORT const char * class_getName (Class class_);

/* Return YES if 'class_' is a meta class, and NO if not.  If 'class_'
   is Nil, return NO.  */
objc_EXPORT BOOL class_isMetaClass (Class class_);

/* Return the superclass of 'class_'.  If 'class_' is Nil, or it is a
   root class, return Nil.  This function also works if 'class_' is a
   class being constructed, that is, a class returned by
   objc_allocateClassPair() but before it has been registered with the
   runtime using objc_registerClassPair().  */
objc_EXPORT Class class_getSuperclass (Class class_);

/* Return the 'version' number of the class, which is an integer that
   can be used to track changes in the class API, methods and
   variables.  If class_ is Nil, return 0.  If class_ is not Nil, the
   version is 0 unless class_setVersion() has been called to set a
   different one.

   Please note that internally the version is a long, but the API only
   allows you to set and retrieve int values.  */
objc_EXPORT int class_getVersion (Class class_);

/* Set the 'version' number of the class, which is an integer that can
   be used to track changes in the class API, methods and variables.
   If 'class_' is Nil, does nothing.

   This is typically used internally by "Foundation" libraries such as
   GNUstep Base to support serialization / deserialization of objects
   that work across changes in the classes.  If you are using such a
   library, you probably want to use their versioning API, which may
   be based on this one, but is integrated with the rest of the
   library.

   Please note that internally the version is a long, but the API only
   allows you to set and retrieve int values.  */
objc_EXPORT void class_setVersion (Class class_, int version);

/* Return the size in bytes (a byte is the size of a char) of an
   instance of the class.  If class_ is Nil, return 0; else it return
   a non-zero number (since the 'isa' instance variable is required
   for all classes).  */
objc_EXPORT size_t class_getInstanceSize (Class class_);

/* Change the implementation of the method.  It also searches all
   classes for any class implementing the method, and replaces the
   existing implementation with the new one.  For that to work,
   'method' must be a method returned by class_getInstanceMethod() or
   class_getClassMethod() as the matching is done by comparing the
   pointers; in that case, only the implementation in the class is
   modified.  Return the previous implementation that has been
   replaced.  If method or implementation is NULL, do nothing and
   return NULL.  */
objc_EXPORT IMP
method_setImplementation (Method method, IMP implementation);

/* Swap the implementation of two methods in a single, atomic
   operation.  This is equivalent to getting the implementation of
   each method and then calling method_setImplementation() on the
   other one.  For this to work, the two methods must have been
   returned by class_getInstanceMethod() or class_getClassMethod().
   If 'method_a' or 'method_b' is NULL, do nothing.  */
objc_EXPORT void
method_exchangeImplementations (Method method_a, Method method_b);

/* Create a new class/meta-class pair.  This function is called to
   create a new class at runtime.  The class is created with
   superclass 'superclass' (use 'Nil' to create a new root class) and
   name 'class_name'.  'extraBytes' can be used to specify some extra
   space for indexed variables to be added at the end of the class and
   meta-class objects (it is recommended that you set extraBytes to
   0).  Once you have created the class, it is not usable yet.  You
   need to add any instance variables (by using class_addIvar()), any
   instance methods (by using class_addMethod()) and any class methods
   (by using class_addMethod() on the meta-class, as in
   class_addMethod (object_getClass (class), method)) that are
   required, and then you need to call objc_registerClassPair() to
   activate the class.  If you need to create a hierarchy of classes,
   you need to create and register them one at a time.  You can not
   create a new class using another class in construction as
   superclass.  Return Nil if 'class-name' is NULL or if a class with
   that name already exists or 'superclass' is a class still in
   construction.

   Implementation Note: in the GNU runtime, allocating a class pair
   only creates the structures for the class pair, but does not
   register anything with the runtime.  The class is registered with
   the runtime only when objc_registerClassPair() is called.  In
   particular, if a class is in construction, objc_getClass() will not
   find it, the superclass will not know about it,
   class_getSuperclass() will return Nil and another thread may
   allocate a class pair with the same name; the conflict will only be
   detected when the classes are registered with the runtime.
 */
objc_EXPORT Class
objc_allocateClassPair (Class super_class, const char *class_name, 
			size_t extraBytes);

/* Register a class pair that was created with
   objc_allocateClassPair().  After you register a class, you can no
   longer make changes to its instance variables, but you can start
   creating instances of it.  Do nothing if 'class_' is NULL or if it
   is not a class allocated by objc_allocateClassPair() and still in
   construction.  */
objc_EXPORT void
objc_registerClassPair (Class class_);

/* Dispose of a class pair created using objc_allocateClassPair().
   Call this function if you started creating a new class with
   objc_allocateClassPair() but then want to abort the process.  You
   should not access 'class_' after calling this method.  Note that if
   'class_' has already been registered with the runtime via
   objc_registerClassPair(), this function does nothing; you can only
   dispose of class pairs that are still being constructed.  Do
   nothing if class is 'Nil' or if 'class_' is not a class being
   constructed.  */
objc_EXPORT void
objc_disposeClassPair (Class class_);

/* Compatibility Note: The Apple/NeXT runtime has the function
   objc_duplicateClass () but it's undocumented.  The GNU runtime does
   not have it.  */


/** Implementation: the following functions are in sendmsg.c.  */

/* Return the instance method with selector 'selector' of class
   'class_', or NULL if the class (or one of its superclasses) does
   not implement the method.  Return NULL if class_ is Nil or selector
   is NULL.  Calling this function may trigger a call to
   +resolveInstanceMethod:, but does not return a forwarding
   function.  */
objc_EXPORT Method class_getInstanceMethod (Class class_, SEL selector);

/* Return the class method with selector 'selector' of class 'class_',
   or NULL if the class (or one of its superclasses) does not
   implement the method.  Return NULL if class_ is Nil or selector is
   NULL.  Calling this function may trigger a call to
   +resolveClassMethod:, but does not return a forwarding
   function.  */
objc_EXPORT Method class_getClassMethod (Class class_, SEL selector);

/* Return the IMP (pointer to the function implementing a method) for
   the instance method with selector 'selector' in class 'class_'.
   This is the same routine that is used while messaging, and should
   be very fast.  Note that you most likely would need to cast the
   return function pointer to a function pointer with the appropriate
   arguments and return type before calling it.  To get a class
   method, you can pass the meta-class as the class_ argument (ie, use
   class_getMethodImplementation (object_getClass (class_),
   selector)).  Return NULL if class_ is Nil or selector is NULL.
   This function first looks for an existing method; if it is not
   found, it calls +resolveClassMethod: or +resolveInstanceMethod:
   (depending on whether a class or instance method is being looked
   up) if it is implemented.  If the method returns YES, then it tries
   the look up again (the assumption being that +resolveClassMethod:
   or resolveInstanceMethod: will add the method using
   class_addMethod()).  If it is still not found, it returns a
   forwarding function.  */
objc_EXPORT IMP class_getMethodImplementation (Class class_, SEL selector);

/* Compatibility Note: the Apple/NeXT runtime has the function
   class_getMethodImplementation_stret () which currently does not
   exist on the GNU runtime because the messaging implementation is
   different.  */

/* Return YES if class 'class_' has an instance method implementing
   selector 'selector', and NO if not.  Return NO if class_ is Nil or
   selector is NULL.  If you need to check a class method, use the
   meta-class as the class_ argument (ie, use class_respondsToSelector
   (object_getClass (class_), selector)).  */
objc_EXPORT BOOL class_respondsToSelector (Class class_, SEL selector);

/* Add a method to a class.  Use this function to add a new method to
   a class (potentially overriding a method with the same selector in
   the superclass); if you want to modify an existing method, use
   method_setImplementation() instead (or class_replaceMethod ()).
   This method adds an instance method to 'class_'; to add a class
   method, get the meta class first, then add the method to the meta
   class, that is, use

   class_addMethod (object_getClass (class_), selector,
   implementation, type);

   Return YES if the method was added, and NO if not.  Do nothing if
   one of the arguments is NULL.  */
objc_EXPORT BOOL class_addMethod (Class class_, SEL selector, IMP implementation,
				  const char *method_types);

/* Replace a method in a class.  If the class already have a method
   with this 'selector', find it and use method_setImplementation() to
   replace the implementation with 'implementation' (method_types is
   ignored in that case).  If the class does not already have a method
   with this 'selector', call 'class_addMethod() to add it.

   Return the previous implementation of the method, or NULL if none
   was found.  Return NULL if any of the arguments is NULL.  */
objc_EXPORT IMP class_replaceMethod (Class class_, SEL selector, IMP implementation,
				     const char *method_types);


/** Implementation: the following functions are in methods.c.  */

/* Return the selector for method 'method'.  Return NULL if 'method'
   is NULL.

   This function is misnamed; it should be called
   'method_getSelector'.  To get the actual name, get the selector,
   then the name from the selector (ie, use sel_getName
   (method_getName (method))).  */
objc_EXPORT SEL method_getName (Method method);

/* Return the IMP of the method.  Return NULL if 'method' is NULL.  */
objc_EXPORT IMP method_getImplementation (Method method);

/* Return the type encoding of the method.  Return NULL if 'method' is
   NULL.  */
objc_EXPORT const char * method_getTypeEncoding (Method method);

/* Return a method description for the method.  Return NULL if
   'method' is NULL.  */
objc_EXPORT struct objc_method_description * method_getDescription (Method method);

/* Return all the instance methods of the class.  The return value of
   the function is a pointer to an area, allocated with malloc(), that
   contains all the instance methods of the class.  It does not
   include instance methods of superclasses.  The list is terminated
   by NULL.  Optionally, if you pass a non-NULL
   'numberOfReturnedMethods' pointer, the unsigned int that it points
   to will be filled with the number of instance methods returned.  To
   get the list of class methods, pass the meta-class in the 'class_'
   argument, (ie, use class_copyMethodList (object_getClass (class_),
   &numberOfReturnedMethods)).  */
objc_EXPORT Method * class_copyMethodList (Class class_, unsigned int *numberOfReturnedMethods);


/** Implementation: the following functions are in encoding.c.  */

/* Return the number of arguments that the method 'method' expects.
   Note that all methods need two implicit arguments ('self' for the
   receiver, and '_cmd' for the selector).  Return 0 if 'method' is
   NULL.  */
objc_EXPORT unsigned int method_getNumberOfArguments (Method method);

/* Return the string encoding for the return type of method 'method'.
   The string is a standard zero-terminated string in an area of
   memory allocated with malloc(); you should free it with free() when
   you finish using it.  Return an empty string if method is NULL.  */
objc_EXPORT char * method_copyReturnType (Method method);

/* Return the string encoding for the argument type of method
   'method', argument number 'argumentNumber' ('argumentNumber' is 0
   for self, 1 for _cmd, and 2 or more for the additional arguments if
   any).  The string is a standard zero-terminated string in an area
   of memory allocated with malloc(); you should free it with free()
   when you finish using it.  Return an empty string if method is NULL
   or if 'argumentNumber' refers to a non-existing argument.  */
objc_EXPORT char * method_copyArgumentType (Method method, unsigned int argumentNumber);

/* Return the string encoding for the return type of method 'method'.
   The string is returned by copying it into the supplied
   'returnValue' string, which is of size 'returnValueSize'.  No more
   than 'returnValueSize' characters are copied; if the encoding is
   smaller than 'returnValueSize', the rest of 'returnValue' is filled
   with zeros.  If it is bigger, it is truncated (and would not be
   zero-terminated).  You should supply a big enough
   'returnValueSize'.  If the method is NULL, returnValue is set to a
   string of zeros.  */
objc_EXPORT void method_getReturnType (Method method, char *returnValue, 
				       size_t returnValueSize);

/* Return the string encoding for the argument type of method
   'method', argument number 'argumentNumber' ('argumentNumber' is 0
   for self, 1 for _cmd, and 2 or more for the additional arguments if
   any).  The string is returned by copying it into the supplied
   'returnValue' string, which is of size 'returnValueSize'.  No more
   than 'returnValueSize' characters are copied; if the encoding is
   smaller than 'returnValueSize', the rest of 'returnValue' is filled
   with zeros.  If it is bigger, it is truncated (and would not be
   zero-terminated).  You should supply a big enough
   'returnValueSize'.  If the method is NULL, returnValue is set to a
   string of zeros.  */
objc_EXPORT void method_getArgumentType (Method method, unsigned int argumentNumber,
					 char *returnValue, size_t returnValueSize);


/** Implementation: the following functions are in protocols.c.  */

/* Return the protocol with name 'name', or nil if it the protocol is
   not known to the runtime.  */
objc_EXPORT Protocol *objc_getProtocol (const char *name);

/* Return all the protocols known to the runtime.  The return value of
   the function is a pointer to an area, allocated with malloc(), that
   contains all the protocols known to the runtime; the list is
   terminated by NULL.  You should free this area using free() once
   you no longer need it.  Optionally, if you pass a non-NULL
   'numberOfReturnedProtocols' pointer, the unsigned int that it
   points to will be filled with the number of protocols returned.  If
   there are no protocols known to the runtime, NULL is returned.  */
objc_EXPORT Protocol **objc_copyProtocolList (unsigned int *numberOfReturnedProtocols);

/* Add a protocol to a class, and return YES if it was done
   successfully, and NO if not.  At the moment, NO should only happen
   if class_ or protocol are nil, if the protocol is not a Protocol
   object or if the class already conforms to the protocol.  */
objc_EXPORT BOOL class_addProtocol (Class class_, Protocol *protocol);

/* Return YES if the class 'class_' conforms to Protocol 'protocol',
   and NO if not.  This function does not check superclasses; if you
   want to check for superclasses (in the way that [NSObject
   +conformsToProtocol:] does) you need to iterate over the class
   hierarchy using class_getSuperclass(), and call
   class_conformsToProtocol() for each of them.  */
objc_EXPORT BOOL class_conformsToProtocol (Class class_, Protocol *protocol);

/* Return all the protocols that the class conforms to.  The return
   value of the function is a pointer to an area, allocated with
   malloc(), that contains all the protocols formally adopted by the
   class.  It does not include protocols adopted by superclasses.  The
   list is terminated by NULL.  Optionally, if you pass a non-NULL
   'numberOfReturnedProtocols' pointer, the unsigned int that it
   points to will be filled with the number of protocols returned.
   This function does not return protocols that superclasses conform
   to.  */
objc_EXPORT Protocol **class_copyProtocolList (Class class_, unsigned int *numberOfReturnedProtocols);

/* Return YES if protocol 'protocol' conforms to protocol
   'anotherProtocol', and NO if not.  Note that if one of the two
   protocols is nil, it returns NO.  */
objc_EXPORT BOOL protocol_conformsToProtocol (Protocol *protocol, Protocol *anotherProtocol);

/* Return YES if protocol 'protocol' is the same as protocol
   'anotherProtocol', and 'NO' if not.  Note that it returns YES if
   the two protocols are both nil.  */
objc_EXPORT BOOL protocol_isEqual (Protocol *protocol, Protocol *anotherProtocol);

/* Return the name of protocol 'protocol'.  If 'protocol' is nil or is
   not a Protocol, return NULL.  */
objc_EXPORT const char *protocol_getName (Protocol *protocol);

/* Return the method description for the method with selector
   'selector' in protocol 'protocol'; if 'requiredMethod' is YES, the
   function searches the list of required methods; if NO, the list of
   optional methods.  If 'instanceMethod' is YES, the function search
   for an instance method; if NO, for a class method.  If there is no
   matching method, an objc_method_description structure with both
   name and types set to NULL is returned.  This function will only
   find methods that are directly declared in the protocol itself, not
   in other protocols that this protocol adopts.

   Note that the traditional ABI does not store the list of optional
   methods of a protocol in a compiled module, so the traditional ABI
   will always return (NULL, NULL) when requiredMethod == NO.  */
objc_EXPORT struct objc_method_description protocol_getMethodDescription (Protocol *protocol, 
									  SEL selector,
									  BOOL requiredMethod,
									  BOOL instanceMethod);

/* Return the method descriptions of all the methods of the protocol.
   The return value of the function is a pointer to an area, allocated
   with malloc(), that contains all the method descriptions of the
   methods of the protocol.  It does not recursively include methods
   of the protocols adopted by this protocol.  The list is terminated
   by a NULL objc_method_description (one with both fields set to
   NULL).  Optionally, if you pass a non-NULL
   'numberOfReturnedMethods' pointer, the unsigned int that it points
   to will be filled with the number of properties returned.

   Note that the traditional ABI does not store the list of optional
   methods of a protocol in a compiled module, so the traditional ABI
   will always return an empty list if requiredMethod is set to
   NO.  */
objc_EXPORT struct objc_method_description *protocol_copyMethodDescriptionList (Protocol *protocol,
										BOOL requiredMethod,
										BOOL instanceMethod,
										unsigned int *numberOfReturnedMethods);

/* Return the property with name 'propertyName' of the protocol
   'protocol'.  If 'requiredProperty' is YES, the function searches
   the list of required properties; if NO, the list of optional
   properties.  If 'instanceProperty' is YES, the function searches
   the list of instance properties; if NO, the list of class
   properties.  At the moment, optional properties and class
   properties are not part of the Objective-C language, so both
   'requiredProperty' and 'instanceProperty' should be set to YES.
   This function returns NULL if the required property can not be
   found.

   Note that the traditional ABI does not store the list of properties
   of a protocol in a compiled module, so the traditional ABI will
   always return NULL.  */
objc_EXPORT Property protocol_getProperty (Protocol *protocol, const char *propertyName, 
					   BOOL requiredProperty, BOOL instanceProperty);

/* Return all the properties of the protocol.  The return value of the
   function is a pointer to an area, allocated with malloc(), that
   contains all the properties of the protocol.  It does not
   recursively include properties of the protocols adopted by this
   protocol.  The list is terminated by NULL.  Optionally, if you pass
   a non-NULL 'numberOfReturnedProperties' pointer, the unsigned int
   that it points to will be filled with the number of properties
   returned.

   Note that the traditional ABI does not store the list of properties
   of a protocol in a compiled module, so the traditional ABI will
   always return NULL and store 0 in numberOfReturnedProperties.  */
objc_EXPORT Property *protocol_copyPropertyList (Protocol *protocol, unsigned int *numberOfReturnedProperties);

/* Return all the protocols that the protocol conforms to.  The return
   value of the function is a pointer to an area, allocated with
   malloc(), that contains all the protocols formally adopted by the
   protocol.  It does not recursively include protocols adopted by the
   protocols adopted by this protocol.  The list is terminated by
   NULL.  Optionally, if you pass a non-NULL
   'numberOfReturnedProtocols' pointer, the unsigned int that it
   points to will be filled with the number of protocols returned.  */
objc_EXPORT Protocol **protocol_copyProtocolList (Protocol *protocol, unsigned int *numberOfReturnedProtocols);


/** Implementation: the following hook is in init.c.  */

/* This is a hook which is called by __objc_exec_class every time a
   class or a category is loaded into the runtime.  This may e.g. help
   a dynamic loader determine the classes that have been loaded when
   an object file is dynamically linked in.  */
objc_EXPORT void (*_objc_load_callback)(Class _class, struct objc_category *category);


/** Implementation: the following functions are in objc-foreach.c.  */

/* 'objc_enumerationMutation()' is called when a collection is
   mutated while being "fast enumerated".  That is a hard error, and
   objc_enumerationMutation is called to deal with it.  'collection'
   is the collection object that was mutated during an enumeration.

   objc_enumerationMutation() will invoke the mutation handler if any
   is set.  Then, it will abort the program.

   Compatibility note: the Apple runtime will not abort the program
   after calling the mutation handler.  */
objc_EXPORT void objc_enumerationMutation (id collection);

/* 'objc_set_enumeration_mutation_handler' can be used to set a
   function that will be called (instead of aborting) when a fast
   enumeration is mutated during enumeration.  The handler will be
   called with the 'collection' being mutated as the only argument and
   it should not return; it should either exit the program, or could
   throw an exception.  The recommended implementation is to throw an
   exception - the user can then use exception handlers to deal with
   it.

   This function is not thread safe (other threads may be trying to
   invoke the enumeration mutation handler while you are changing it!)
   and should be called during during the program initialization
   before threads are started.  It is mostly reserved for "Foundation"
   libraries; in the case of GNUstep, GNUstep Base may be using this
   function to improve the standard enumeration mutation handling.
   You probably shouldn't use this function unless you are writing
   your own Foundation library.  */
objc_EXPORT void objc_setEnumerationMutationHandler (void (*handler)(id));

/* This structure (used during fast enumeration) is automatically
   defined by the compiler (it is as if this definition was always
   included in all Objective-C files).  Note that it is usually
   defined again with the name of NSFastEnumeration by "Foundation"
   libraries such as GNUstep Base.  And if NSFastEnumeration is
   defined, the compiler will use it instead of
   __objcFastEnumerationState when doing fast enumeration.  */
/*
struct __objcFastEnumerationState
{
  unsigned long state;
  id            *itemsPtr;
  unsigned long *mutationsPtr;
  unsigned long extra[5];
};
*/


/* Compatibility Note: The Apple/NeXT runtime has the functions
   objc_copyImageNames (), class_getImageName () and
   objc_copyClassNamesForImage () but they are undocumented.  The GNU
   runtime does not have them at the moment.  */

/* Compatibility Note: The Apple/NeXT runtime has the functions
   objc_setAssociatedObject (), objc_getAssociatedObject (),
   objc_removeAssociatedObjects () and the objc_AssociationPolicy type
   and related enum.  The GNU runtime does not have them yet.
   TODO: Implement them.  */

/* Compatibility Note: The Apple/NeXT runtime has the function
   objc_setForwardHandler ().  The GNU runtime does not have it
   because messaging (and, in particular, forwarding) works in a
   different (incompatible) way with the GNU runtime.  If you need to
   customize message forwarding at the Objective-C runtime level (that
   is, if you are implementing your own "Foundation" library such as
   GNUstep Base on top of the Objective-C runtime), in objc/message.h
   there are hooks (that work in the framework of the GNU runtime) to
   do so.  */


/** Implementation: the following functions are in memory.c.  */

/* Traditional GNU Objective-C Runtime functions that are used for
   memory allocation and disposal.  These functions are used in the
   same way as you use malloc, realloc, calloc and free and make sure
   that memory allocation works properly with the garbage
   collector.

   Compatibility Note: these functions are not available with the
   Apple/NeXT runtime.  */

objc_EXPORT void *objc_malloc(size_t size);

/* FIXME: Shouldn't the following be called objc_malloc_atomic ?  The
   GC function is GC_malloc_atomic() which makes sense.
 */
objc_EXPORT void *objc_atomic_malloc(size_t size);

objc_EXPORT void *objc_realloc(void *mem, size_t size);

objc_EXPORT void *objc_calloc(size_t nelem, size_t size);

objc_EXPORT void objc_free(void *mem);


/** Implementation: the following functions are in gc.c.  */

/* The GNU Objective-C Runtime has a different implementation of
   garbage collection.

   Compatibility Note: these functions are not available with the
   Apple/NeXT runtime.  */

/* Mark the instance variable as inaccessible to the garbage
   collector.  */
objc_EXPORT void class_ivar_set_gcinvisible (Class _class,
					     const char* ivarname,
					     BOOL gcInvisible);


/** Implementation: the following functions are in encoding.c.  */

/* Traditional GNU Objective-C Runtime functions that are currently
   used to implement method forwarding.

   Compatibility Note: these functions are not available with the
   Apple/NeXT runtime.  */

/* Return the size of a variable which has the specified 'type'
   encoding.  */
objc_EXPORT int objc_sizeof_type (const char *type);

/* Return the align of a variable which has the specified 'type'
   encoding.  */
objc_EXPORT int objc_alignof_type (const char *type);

/* Return the aligned size of a variable which has the specified
   'type' encoding.  The aligned size is the size rounded up to the
   nearest alignment.  */
objc_EXPORT int objc_aligned_size (const char *type);

/* Return the promoted size of a variable which has the specified
   'type' encoding.  This is the size rounded up to the nearest
   integral of the wordsize, taken to be the size of a void *.  */
objc_EXPORT int objc_promoted_size (const char *type);


/* The following functions are used when parsing the type encoding of
   methods, to skip over parts that are ignored.  They take as
   argument a pointer to a location inside the type encoding of a
   method (which is a string) and return a new pointer, pointing to a
   new location inside the string after having skipped the unwanted
   information.  */

/* Skip some type qualifiers (_C_CONST, _C_IN, etc).  These may
  eventually precede typespecs occurring in method prototype
  encodings.  */
objc_EXPORT const char *objc_skip_type_qualifiers (const char *type);

/* Skip one typespec element (_C_CLASS, _C_SEL, etc).  If the typespec
  is prepended by type qualifiers, these are skipped as well.  */
objc_EXPORT const char *objc_skip_typespec (const char *type);

/* Skip an offset.  */
objc_EXPORT const char *objc_skip_offset (const char *type);

/* Skip an argument specification (ie, skipping a typespec, which may
   include qualifiers, and an offset too).  */
objc_EXPORT const char *objc_skip_argspec (const char *type);

/* Read type qualifiers (_C_CONST, _C_IN, etc) from string 'type'
   (stopping at the first non-type qualifier found) and return an
   unsigned int which is the logical OR of all the corresponding flags
   (_F_CONST, _F_IN etc).  */
objc_EXPORT unsigned objc_get_type_qualifiers (const char *type);


/* Note that the following functions work for very simple structures,
   but get easily confused by more complicated ones (for example,
   containing vectors).  A better solution is required.  These
   functions are likely to change in the next GCC release.  */

/* The following three functions can be used to determine how a
   structure is laid out by the compiler. For example:

  struct objc_struct_layout layout;
  int i;

  objc_layout_structure (type, &layout);
  while (objc_layout_structure_next_member (&layout))
    {
      int position, align;
      const char *type;

      objc_layout_structure_get_info (&layout, &position, &align, &type);
      printf ("element %d has offset %d, alignment %d\n",
              i++, position, align);
    }

  These functions are used by objc_sizeof_type and objc_alignof_type
  functions to compute the size and alignment of structures. The
  previous method of computing the size and alignment of a structure
  was not working on some architectures, particularly on AIX, and in
  the presence of bitfields inside the structure.  */
struct objc_struct_layout
{
  const char *original_type;
  const char *type;
  const char *prev_type;
  unsigned int record_size;
  unsigned int record_align;
};

objc_EXPORT void objc_layout_structure (const char *type,
                            struct objc_struct_layout *layout);
objc_EXPORT BOOL  objc_layout_structure_next_member (struct objc_struct_layout *layout);
objc_EXPORT void objc_layout_finish_structure (struct objc_struct_layout *layout,
					       unsigned int *size,
					       unsigned int *align);
objc_EXPORT void objc_layout_structure_get_info (struct objc_struct_layout *layout,
						 unsigned int *offset,
						 unsigned int *align,
						 const char **type);

#ifdef __cplusplus
}
#endif /* __cplusplus */

#endif