/* -*-c-*-
 * This file contains declarations used by the run-time system.
 *
 *  Most of these declarations are defined by virtue of data 
 *  structures produced by the compiler.
 *
 * Copyright (C) 1991 Threaded Technologies Inc.
 * 
 * This program 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 1, or any later version.
 * 
 * This program 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.
 * 
 * You should receive a copy of the GNU General Public License 
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 * 
  $Header: /usr/user/dennis_glatting/ObjC/c-runtime/include/RCS/ObjC.h,v 0.10 1991/12/31 20:16:08 dennisg Exp dennisg $
  $Author: dennisg $
  $Date: 1991/12/31 20:16:08 $
  $Log: ObjC.h,v $
 * Revision 0.10  1991/12/31  20:16:08  dennisg
 * Deleted index variable stuff.  Index variables are a hack to the language.
 * Cleaned up some documentation.
 *
 * Revision 0.9  1991/12/10  12:04:22  dennisg
 * Cleaned up file format for a distribution.
 *
 * Revision 0.8  1991/12/01  01:29:29  dennisg
 * modified to remove changes previously made to
 * implement posing.  posing just got easy.
 *
 * Revision 0.7  1991/11/29  22:00:10  dennisg
 * modified to implement set functions.
 *
 * Revision 0.6  1991/11/29  20:02:01  dennisg
 * fixed several const decls.  bozo.
 *
 * Revision 0.5  1991/11/29  00:24:14  dennisg
 * many changes including posing, things to make the compiler
 * happier, structure changes, and things to make it play better.
 *
 * Revision 0.4  1991/11/19  12:37:49  dennisg
 * changed typedef and struct decls.
 * the run-time was changed and those decls changed too.
 *
 * Revision 0.3  1991/11/16  15:57:35  dennisg
 * changed the defs for class structures for new implementation of run-time.
 * changed def of SEL back to its original type.
 *
 * Revision 0.2  1991/11/07  22:31:42  dennisg
 * added copyleft.
 *
 * Revision 0.1  1991/10/24  00:19:24  dennisg
 * Initial check in.  Preliminary development stage.
 *
*/
 

#ifndef _objc_INCLUDE_GNU
#define _objc_INCLUDE_GNU

                                                /* If someone is using a c++
                                                  compiler then adjust the 
                                                  types in the file back 
                                                  to C. */
#ifdef __cplusplus
extern "C" {
#endif

#include  <sys/types.h>
#include  <record-inline.h>
#include  <stdarg.h>


#define nil (id)0                               /* id of Nil instance */
#define Nil (Class_t)0                          /* id of Nil class */
typedef char* STR;                              /* String alias */

                                                /* Boolean typedefs */
typedef char  BOOL;
#define YES   (BOOL)1
#define NO    (BOOL)0

                                                /* Definition of a 
                                                  selector.  Selectors are 
                                                  really of type char*. The
                                                  run-time hashes the 
                                                  string's address to locate
                                                  the method.  If the method
                                                  isn't in the hash table then
                                                  a search is made through the 
                                                  class hierarchy using 
                                                  strcmp() to locate the
                                                  method. */
#if 0
typedef struct objc_selector*   SEL;
#else
typedef void* SEL;
#endif

                                                /* ObjC uses this typedef 
                                                  for untyped instances. */
typedef struct objc_object {
  struct objc_class*  isa;
} *id;

                                                /* Prototype for method 
                                                  functions. */
typedef id  ( *IMP )( id, SEL, ... ); 

                                                /* Filer types used to 
                                                  describe 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_FLT      'f'
#define _C_DBL      'd'
#define _C_BFLD     '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 '}'

/*
 * These definitions are masks used with the "info" member variable in the
 * class and meta class structures. 
 */
#define CLS_CLASS         0x1L                  /* The structure is of type
                                                  class (Class_t). */
#define CLS_META          0x2L                  /* The structure is of type
                                                  meta class (MetaClass_t). */
#define CLS_INITIALIZED   0x4L                  /* Class is initialized. A
                                                  +initialize method is the
                                                  first message sent to a
                                                  class.  It isn't guaranteed
                                                  to be sent only once. */


                                                /* Set this variable to !0 to
                                                  have the messager print
                                                  messaging operations. */
  extern BOOL objc_trace;


/*
 * Whereas a Module (defined further down) is the root (typically) of a file,
 * a Symtab is the root of the class and category definitions within the
 * module.  
 *
 * A Symtab contains a variable length array of pointers to classes and
 * categories  defined in the module. 
 */
typedef struct objc_symtab {
  u_long    sel_ref_cnt;                        /* Unknown. */
  SEL       *refs;                              /* Unknown. */
  u_short   cls_def_cnt;                        /* Number of classes compiled
                                                  (defined) in the module. */
  u_short   cat_def_cnt;                        /* Number of categories 
                                                  compiled (defined) in the 
                                                  module. */
  void      *defs[1];                           /* Variable array of pointers.
                                                  cls_def_cnt of type Class_t 
                                                  followed by cat_def_cnt of
                                                  type Category_t. */
} Symtab,   *Symtab_t;


/*
 * The compiler generates one of these structures for each module that
 * composes the executable (eg main.m).  
 *
 * This data structure is the root of the definition tree for the module.  
 *
 * A collect program runs between ld stages and creates a ObjC ctor array. 
 * That array holds a pointer to each module structure of the executable. 
 */
typedef struct objc_module {
  u_long      version;                          /* Compiler revision. */
  u_long      size;                             /* sizeof(Module). */
  const char* name;                             /* Name of the file where the 
                                                  module was generated.   The 
                                                  name includes the path. */
  Symtab_t    symtab;                           /* Pointer to the Symtab of
                                                  the module.  The Symtab
                                                  holds an array of pointers to 
                                                  the classes and categories 
                                                  defined in the module. */
} Module, *Module_t;


/*
 * The compiler generates one of these structures for a class that has
 * instance variables defined in its specification. 
 */
typedef struct objc_ivar* Ivar_t;
typedef struct objc_ivar_list {
  int   ivar_count;                             /* Number of structures (Ivar) 
                                                  contained in the list.  One
                                                  structure per instance 
                                                  variable defined in the
                                                  class. */
  struct objc_ivar {
    const char* ivar_name;                      /* Name of the instance
                                                  variable as entered in the
                                                  class definition. */
    const char* ivar_type;                      /* Description of the Ivar's
                                                  type.  Useful for 
                                                  debuggers. */
    int         ivar_offset;                    /* Byte offset from the base 
                                                  address of the instance 
                                                  structure to the variable. */

  } ivar_list[1];                               /* Variable length 
                                                  structure. */
} IvarList, *IvarList_t;


/*
 * The compiler generates one (or more) of these structures for a class that
 * has methods defined in its specification. 
 *
 * The implementation of a class can be broken into separate pieces in a file
 * and categories can break them across modules. To handle this problem is a
 * singly linked list of methods. 
 */
typedef struct objc_method Method;
typedef Method* Method_t;
typedef struct objc_method_list {
  struct objc_method_list*  method_next;      /* This variable is used to link 
                                                a method list to another.  It 
                                                is a singly linked list. */
  int             method_count;               /* Number of methods defined in 
                                                this structure. */
  struct objc_method {
    SEL         method_name;                  /* This variable is the method's 
                                                name.  It is a char*. 
                                                  The unique integer passed to 
                                                objc_msgSend() is a char* too.  
                                                It is compared against 
                                                method_name using strcmp(). */
    const char* method_types;                 /* Description of the method's
                                                parameter list.  Useful for
                                                debuggers. */
    IMP         method_imp;                   /* Address of the method in the 
                                                executable. */
  } method_list[1];                           /* Variable length 
                                                structure. */
} MethodList, *MethodList_t;


/*
 * The compiler generates one of these structures for each class.  
 *
 * This structure is the definition for meta classes. By definition a meta
 * class is the class's class.  Its most relevant contribution is that its
 * method list contain the class's factory methods. 
 *
 * This structure is generated by the compiler in the executable and used by
 * the run-time during normal messaging operations.  Therefore some members
 * change type. The compiler generates "char* const" and places a string in
 * the following member variables:  isa and super_class. 
 */
typedef struct objc_metaClass {     
  struct objc_metaClass*  isa;                /* Pointer to Object meta
                                                class. */
  struct objc_metaClass*  super_class;        /* Pointer to meta class's
                                                super class. NULL for 
                                                Object. */
  const char*             name;               /* Name of the meta class. */
  long                    version;            /* Unknown. */
  long                    info;               /* Bit mask.  See class masks 
                                                defined above. */
  long                    instance_size;      /* Always 0 except for Object.
                                                Should be ignored. */
  IvarList_t              ivars;              /* Always NULL except for 
                                                Object.  Should be ignored. */
  MethodList_t            methods;            /* Linked List of factory methods 
                                                for the class. */
  Record_t*               cache;              /* Pointer to factory method
																								dispatch table. */
} MetaClass, *MetaClass_t;


/*
 * The compiler generates one of these structures for each class.  
 *
 * This structure is the definition for classes. 
 *
 * This structure is generated by the compiler in the executable and used by
 * the run-time during normal messaging operations.  Therefore some members
 * change type. The compiler generates "char* const" and places a string in
 * the following member variables:  super_class. 
 */
typedef struct objc_class {     
  MetaClass_t         isa;                    /* Pointer to the class's
                                                meta class. */
  struct objc_class*  super_class;            /* Pointer to the super 
                                                class. NULL for class 
                                                Object. */
  const char*         name;                   /* Name of the class. */
  long                version;                /* Unknown. */
  long                info;                   /* Bit mask.  See class masks 
                                                defined above. */
  long                instance_size;          /* Size in bytes of the class.  
                                                The sum of the class definition 
                                                and all super class 
                                                definitions. */
  IvarList_t          ivars;                  /* Pointer to a structure that
                                                describes the instance 
                                                variables in the class
                                                definition.  NULL indicates
                                                no instance variables.  Does
                                                not include super class
                                                variables. */
  MethodList_t        methods;                /* Linked list of instance
                                                methods defined for the 
                                                class. */
  Record_t*           cache;                  /* Pointer to instance method 
																								dispatch table. */
} Class, *Class_t;


/*
 * The compiler generates one of these structures for each category.  A class
 * may have many categories and contain both instance and factory methods.  
 */
typedef struct objc_category {
  const char*   category_name;                /* Name of the category.  Name
                                                contained in the () of the
                                                category definition. */
  const char*   class_name;                   /* Name of the class to which
                                                the category belongs. */
  MethodList_t  instance_methods;             /* Linked list of instance
                                                methods defined in the 
                                                category. NULL indicates no
                                                instance methods defined. */
  MethodList_t  class_methods;                /* Linked list of factory 
                                                methods defined in the
                                                category.  NULL indicates no
                                                class methods defined. */
} Category, *Category_t;


/*
 * Structure used when a message is send to a class's super class.  The
 * compiler generates one of these structures and passes it to
 * objc_msgSuper(). 
 */
typedef struct objc_super {
  id      receiver;                           /* Id of the object sending
                                                the message. */
  Class_t class;                              /* Object's super class. */
} Super, *Super_t;

/*
 * _alloc points to the function, called through class_createInstance(), used
 * to allocate memory for new instances. 
 */
extern id (*_alloc)(Class_t aClass);
/*
 * _dealloc points to the function, called through object_dispose(), used to
 * free instances. 
 */
extern id (*_dealloc)(id aObject);
/*
 * _realloc points to the function, called through object_realloc(), used to
 * reallocate memory for an object 
 */
extern id (*_realloc)(id aObject, u_int newSize);

/*
 * _copy points to the function, called through object_copy(), used to create
 * an exact copy of an object. 
 */
extern  id (*_copy)(id aObject);

/*
 * _error points to the function that the run-time system calls in response
 * to an error.  By default, it prints formatted error messages to the
 * standard error stream and calls abort() to produce a core file. 
 */
extern void (*_error)(id aObject, const char* fmt, va_list ap);


#ifdef __cplusplus
}
#endif


#endif
