From: Dennis Glatting Date: Thu, 24 Oct 1991 00:19:24 +0000 (+0000) Subject: Initial check in. Preliminary development stage. X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=e545f2b026512dd56e91a89a0b6951ab4a58a8b7;p=gcc.git Initial check in. Preliminary development stage. From-SVN: r45 --- diff --git a/gcc/objc/objc.h b/gcc/objc/objc.h new file mode 100644 index 00000000000..7b1c117f91f --- /dev/null +++ b/gcc/objc/objc.h @@ -0,0 +1,344 @@ +/* -*-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. + * + $Header$ + $Author$ + $Date$ + $Log$ +*/ + + +#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 +#include + + +#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 + + /* Defination of a + selector. Selectors are + really of type char*. The + run-time uses strcmp() to + locate selectors. */ +typedef STR SEL; + + /* ObjC uses this typedef + for untyped instances. */ +typedef struct objc_object { + struct objc_class* isa; +} *id; + + /* Prototype for method + functions. */ +typedef id ( *IMP )( +#ifdef __STDC__ + id, SEL, ... +#endif +); + + /* 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. */ +#define CLS_POSING 0x8L /* Class is posing as another. + Used to fix broken + classes. */ +#define CLS_MAPPED 0x10L /* Unknown. */ + + + /* 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; /* Unknown. */ + u_long size; /* Suspect this is + sizeof(Module). It is always + 16. */ + 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 { + char* ivar_name; /* Name of the instance + variable as entered in the + class definition. */ + 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(). */ + 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 definitions + * don't make sense in some contexts. + */ +typedef struct objc_metaClass { + char* isa; /* Always a pointer to the + string "Object". */ + char* super_class; /* Name of the class's super + class. */ + 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. */ + Cache_t cache; /* Used to cache factory methods + defined for the class and its + super classes. Entries are + made to the cache as the + messager receives them. */ +} 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 definitions + * don't make sense in some contexts. + */ +typedef struct objc_class { + MetaClass_t isa; /* Pointer to the class's + meta class. */ + char* super_class; /* Name of the class's super + class. */ + 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. */ + Cache_t cache; /* Used to cache instance methods + defined for the class and its + super classes. Entries are + made to the cache as the + messager receives them. */ +} 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 { + char* category_name; /* Name of the category. Name + contained in the () of the + category definition. */ + 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. */ + char* class; /* Name of the object's super + class. Passed to remove a + level of indirection? */ +} Super, *Super_t; + + +#ifdef __cplusplus +} +#endif + +#endif