Initial revision

From-SVN: r4077

1 files changed, 440 insertions, 0 deletions

diff --git a/gcc/objc/objc-api.h b/gcc/objc/objc-api.h
new file mode 100644
index 0000000..ff2b3f2
--- /dev/null
+++ b/gcc/objc/objc-api.h
@@ -0,0 +1,440 @@
+/* GNU Objective-C Runtime API.
+   Copyright (C) 1993 Free Software Foundation, Inc.
+
+This file is part of GNU CC.
+
+GNU CC 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 2, or (at your option) any
+later version.
+
+GNU CC is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU CC; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/* As a special exception, if you link this library with files compiled
+   with GCC to produce an executable, this does not cause the resulting
+   executable to be covered by the GNU General Public License.  This
+   exception does not however invalidate any other reasons why the
+   executable file might be covered by the GNU General Public License. */
+
+#ifndef __objc_api_INCLUDE_GNU
+#define __objc_api_INCLUDE_GNU
+
+#include <stdlib.h>
+#include <objc/objc.h>
+
+static const ARGSIZE = 96;		/* for `method_get_argsize()' */
+
+/*
+** Points to the function that the runtime system calls to handle
+** an error.  By default, it prints formatted error messages to the
+** standard error stream and calls abort to produce a core file.
+** The function is guaranteed to be passed a valid object and a
+** non-NULL format string.
+*/
+extern void (*_objc_error)(id object, const char *format, va_list args);
+
+/*
+** This is a hook which is called by objc_lookup_class and
+** objc_get_class if the runtime is not able to find the class.
+** This may e.g. try to load in the class using dynamic loading.
+** The function is guaranteed to be passed a non-NULL name string.
+*/
+extern Class_t (*_objc_lookup_class)(const char *name);
+
+/*
+** Points to the function that the runtime system calls to allocate
+** memory for new instances.  Called through class_create_instance(),
+** this function should return a valid block of memory of at least
+** class_get_instance_size() bytes, or nil upon failure.  The
+** function is guaranteed to be passed a valid class object.
+*/
+extern id (*_objc_object_alloc)(Class_t class);
+
+/*
+** Points to the function that the runtime system calls to create
+** an exact copy of an object.  Called through object_copy(), this
+** function should return a new instance of object's class created
+** by class_create_instance() which is bit-identical to object, or
+** nil upon failure.  The function is guaranteed to be passed a
+** valid instance object.
+*/
+extern id (*_objc_object_copy)(id object);
+
+/*
+** Points to the function that the runtime system calls to free
+** instances.  Called through object_dispose(), this function
+** should free the memory pointed to by object and return nil.
+** This function is not responsible for freeing memory pointed
+** to by any of the object's instance variables.  The function
+** is guaranteed to be passed a valid instance object.
+*/
+extern id (*_objc_object_dispose)(id object);
+
+/*
+** Searches for a class method specified by aSel, starting with the
+** metaclass class and proceeding up the class hierarchy, until either
+** the method is found or the root class has been examined.  Returns
+** a pointer to the method's Method structure if found.  Returns the
+** value METHOD_NULL if the method is not found, class is not a
+** metaclass object, or aSel is not a valid selector.
+*/
+Method_t class_get_class_method(MetaClass_t class, SEL aSel);
+
+/*
+** Searches for an instance method specified by aSel, starting with
+** the class class and proceeding up the class hierarchy, until either
+** the method is found or the root class has been examined.  Returns
+** a pointer to the method's Method structure if found.  Returns the
+** value METHOD_NULL if the method is not found, class is not a class
+** object, or aSel is not a valid selector.
+*/
+Method_t class_get_instance_method(Class_t class, SEL aSel);
+
+/*
+** Causes impostor to pose as its superclass.  Messages sent to the
+** superclass will actually be sent to the posing class.  Instance
+** variables may not be declared in the posing class.  The posing
+** class can add new methods to the class or override existing methods
+** in the superclass.  Returns non-nil on success.  Returns nil if
+** either of impostor or superclass are not class objects, impostor is
+** not a subclass of superclass, or upon some other error.
+*/
+Class_t class_pose_as(Class_t impostor, Class_t superclass);
+
+/*
+** Returns the class object for the class named name.  If name does not
+** identify a known class, the hook _objc_lookup_class is called.  If
+** this fails, an error message is issued and the system aborts.
+*/
+Class_t objc_get_class(const char *name);
+
+/*
+** Returns the class object for the class named name.  If name does not
+** identify a known class, the hook _objc_lookup_class is called.  If
+** this fails, nil is returned.
+*/
+Class_t objc_lookup_class(const char *name);
+
+/*
+** Returns the method name associated with selector, or NULL
+** if selector is not defined.
+*/
+const char *sel_get_name(SEL selector);
+
+/*
+** Returns the selector associated with the method name name.  If name
+** has not been defined or name is NULL, 0 is returned.
+*/
+SEL sel_get_uid(const char *name);
+
+/*
+** Registers a selector for name and returns the new selector.  If
+** name is NULL or the empty string (""), 0 is returned.
+*/
+SEL sel_register_name(const char *name);
+
+/*
+** Indicate if aSel is a valid selector.  This is not a safe
+** operation, and it should really never be nessecary to use.
+*/
+BOOL sel_is_mapped (SEL aSel);
+
+/*******************************************************************/
+/*                                                                 */
+/* Internal __inline functions                                     */
+/*                                                                 */
+/*******************************************************************/
+
+/*
+** Allocates memory for a new object of class class by calling the
+** function specified by the variable _objc_object_alloc if non-zero,
+** otherwise uses a default method.  Then, initializes the object's
+** isa instance variable to class, and returns the new object.
+** Returns nil if the memory could not be allocated or class is not
+** a class object.
+*/
+extern inline id
+class_create_instance(Class_t class)
+{
+  id new = nil;
+  if (CLS_ISCLASS(class))
+    new = (_objc_object_alloc
+           ?(*_objc_object_alloc)(class)
+           :(id)malloc(class->instance_size));
+  if (new!=nil)
+    new->class_pointer = class;
+  return new;
+}
+
+/*
+** Returns name of the class class or empty string if class is not
+** a class object.  If class is Nil, the string "Nil" is returned.
+*/
+static inline const char *
+class_get_class_name(Class_t class)
+{
+  return CLS_ISCLASS(class)?class->name:((class==Nil)?"Nil":0);
+}
+
+/*
+** Returns the size of an instance of class class in bytes, or 0 if
+** class is not a class.  The size of an instance is at least 4 bytes.
+*/
+static inline long
+class_get_instance_size(Class_t class)
+{
+  return CLS_ISCLASS(class)?class->instance_size:0;
+}
+
+/*
+** Returns a pointer to class's metaclass, or Nil if class is not a
+** class.
+*/
+static inline MetaClass_t
+class_get_meta_class(Class_t class)
+{
+  return CLS_ISCLASS(class)?class->class_pointer:Nil;
+}
+
+/*
+** Returns a pointer to class's superclass, or Nil if class is not a
+** class.  Note that the superclass of Object is Nil.
+*/
+static inline Class_t
+class_get_super_class(Class_t class)
+{
+  return CLS_ISCLASS(class)?class->super_class:Nil;
+}
+
+/*
+** Returns the version number for the class, or -1 if class is not a
+** class.
+*/
+static inline int
+class_get_version(Class_t class)
+{
+  return CLS_ISCLASS(class)?class->version:-1;
+}
+
+/*
+** Returns YES if class is a class, or NO if not.
+*/
+static inline BOOL
+class_is_class(Class_t class)
+{
+  return CLS_ISCLASS(class);
+}
+
+/*
+** Returns YES if class is a metaclass, or NO if not.
+*/
+static inline BOOL
+class_is_meta_class(Class_t class)
+{
+  return CLS_ISMETA(class);
+}
+
+
+/*
+** Sets the version number of class class.  Does nothing if class is
+** not a class.
+*/
+static inline void
+class_set_version(Class_t class, long version)
+{
+  if (CLS_ISCLASS(class))
+    class->version = version;
+}
+
+/*
+** Returns the size in bytes of the argument frame to a method.  Since
+** at least two parameters (self and _cmd) are sent to each method, this
+** value will be at least 8.  If method is not a valid method, 0 is
+** returned.
+** 
+** Currently, the frame size info is only reliable on a NeXT, so until
+** we get this fixed, we'll use a value which is most possibly large
+** enough. You can possibly reduce this value (96) on anything but a
+** Sparc if you don't return structs from the methods forwarded to.
+*/
+static inline unsigned int
+method_get_argsize(Method_t method)
+{
+  return ARGSIZE;		/* This was a magic number (96)... */
+}
+
+/*
+** Returns a pointer to the implementation of method method.  If method
+** is not a method, NULL is returned.
+*/
+static inline IMP
+method_get_imp(Method_t method)
+{
+  return (method!=METHOD_NULL)?method->method_imp:(IMP)0;
+}
+
+/*
+** Returns the implementation (pointer to function) of the method
+** identified by a (class, selector) pair.  Use this, and *not* 
+** objc_msg_lookup, since objc_msg_lookup may eventually return a
+** pointer to an internal function which does lazy initialization...
+*/
+IMP get_imp (Class_t class, SEL sel);
+
+/*
+** Creates a new instance object that's an exact copy of object by
+** calling the function pointed to by the variable _objc_object_copy if
+** non-zero, otherwise uses a default method.  Returns the new object.
+** Returns nil if object is not an instance object, memory for the new
+** object could not be allocated, or some other error occurred.
+*/
+extern inline id
+object_copy(id object)
+{
+  if ((object!=nil)&&CLS_ISCLASS(object->class_pointer))
+    {
+      if (_objc_object_copy)
+        return (*_objc_object_copy)(object);
+      else
+        {
+          id copy = class_create_instance(object->class_pointer);
+          if (copy!=nil)
+            bcopy(object, copy, object->class_pointer->instance_size);
+          return copy;
+        }
+      return nil;
+    }
+}
+
+/*
+** Frees the memory occupied by object by calling the function pointed
+** to by the variable _objc_object_dispose if non-zero, otherwise uses
+** a default method.  Always returns nil.  If object is not an instance
+** object, does nothing.
+*/
+extern inline id
+object_dispose(id object)
+{
+  if ((object!=nil)&&CLS_ISCLASS(object->class_pointer))
+    {
+      if (_objc_object_dispose)
+        (*_objc_object_dispose)(object);
+      else
+        free(object);
+    }
+  return nil;
+}
+
+/*
+** Returns the class of an object.  If object is an instance, this is
+** its class object.  If object is a class object, returns object (this
+** is arguably not correct, but is implemented this way for compatibility
+** with NeXT (and Stepstone?)).  If object is a metaclass object, or
+** object is nil, returns Nil.
+*/
+static inline Class_t
+object_get_class(id object)
+{
+  return ((object!=nil)
+	  ? (CLS_ISCLASS(object->class_pointer)
+	     ? object->class_pointer
+	     : (CLS_ISMETA(object->class_pointer)
+		? (Class_t)object
+		: Nil))
+	  : Nil);
+}
+
+/*
+** Returns the name of the class of object.  If object is an instace,
+** this is the name of its class.  If object is a class or a metaclass,
+** returns its name.  If object is nil, returns "Nil".
+*/
+static inline const char *
+object_get_class_name(id object)
+{
+  return ((object!=nil)?(CLS_ISCLASS(object->class_pointer)
+                         ?object->class_pointer->name
+                         :((Class_t)object)->name)
+                       :"Nil");
+}
+
+/*
+** Returns the metaclass of an object.  If object is an instance or a
+** class, this is the metaclass object for it.  If object is a metaclass
+** object, or object is nil, returns Nil.
+*/
+static inline MetaClass_t
+object_get_meta_class(id object)
+{
+  return ((object!=nil)?(CLS_ISCLASS(object->class_pointer)
+                         ?object->class_pointer->class_pointer
+                         :(CLS_ISMETA(object->class_pointer)
+                           ?object->class_pointer
+                           :Nil))
+                       :Nil);
+}
+
+/*
+** Returns the superclass of object.  If object is an instance or
+** a class, this is its superclass-object for it.  If object is a
+** metaclass-object or nil, this is Nil.
+*/
+static inline Class_t
+object_get_super_class(id object)
+{
+  return ((object!=nil)?(CLS_ISCLASS(object->class_pointer)
+                         ?object->class_pointer->super_class
+                         :(CLS_ISMETA(object->class_pointer)
+                           ?((Class_t)object)->super_class
+                           :Nil))
+                       :Nil);
+}
+
+/*
+** YES if object is a class, NO if not.
+*/
+static inline BOOL
+object_is_class(id object)
+{
+  return CLS_ISCLASS((Class_t)object);
+}
+
+/*
+** YES if object is an instance, NO if not.
+*/
+static inline BOOL
+object_is_instance(id object)
+{
+  return (object!=nil)&&CLS_ISCLASS(object->class_pointer);
+}
+
+/*
+** YES if object is a metaclass, NO if not.
+*/
+static inline BOOL
+object_is_meta_class(id object)
+{
+  return CLS_ISMETA((Class_t)object);
+}
+
+/*
+** Functions used for archiving.  This is not documented yet!
+*/
+
+TypedStream* new_typed_stream(FILE* physical);
+void free_typed_stream(TypedStream* stream);
+
+void objc_write_object(TypedStream* stream, id object);
+int objc_read_object(TypedStream* stream, id *object);
+
+void objc_write_type(TypedStream* stream, const char* type, const void* data);
+void objc_read_type(TypedStream* stream, const char* type, void* data);
+
+#endif /* not __objc_api_INCLUDE_GNU */