![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to objc.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc / objc|
Return to objc.h CVS log | Up to [GCC 2.x] / gcc / objc |
1.1 root 1: /* Basic data types for Objective C.
2: Copyright (C) 1992 Free Software Foundation, Inc.
3:
4: This file is part of GNU CC.
5:
6: GNU CC is free software; you can redistribute it and/or modify
7: it under the terms of the GNU General Public License as published by
8: the Free Software Foundation; either version 2, or (at your option)
9: any later version.
10:
11: GNU CC is distributed in the hope that it will be useful,
12: but WITHOUT ANY WARRANTY; without even the implied warranty of
13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14: GNU General Public License for more details.
15:
16: You should have received a copy of the GNU General Public License
17: along with GNU CC; see the file COPYING. If not, write to
18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
19:
20: /* As a special exception, if you link this library with files
21: compiled with GCC to produce an executable, this does not cause
22: the resulting executable to be covered by the GNU General Public License.
23: This exception does not however invalidate any other reasons why
24: the executable file might be covered by the GNU General Public License. */
25:
26:
27: #ifndef __objc_INCLUDE_GNU
28: #define __objc_INCLUDE_GNU
29:
30: /* If someone is using a c++ compiler then adjust the types in the
31: file back to C. */
32: #ifdef __cplusplus
33: extern "C" {
34: #endif
35:
36: #include "record.h"
37:
38:
39: #define nil (id)0 /* id of Nil instance */
40: #define Nil (Class_t)0 /* id of Nil class */
41: typedef char* STR; /* String alias */
42:
43: /* Boolean typedefs */
44: typedef char BOOL;
45: #define YES (BOOL)1
46: #define NO (BOOL)0
47:
48: /* Definition of a selector. Selectors are really of type char*. The
49: run-time hashes the string's address to locate the method. If the
50: method isn't in the hash table then a search is made through the
51: class hierarchy using strcmp to locate the method. */
52: #if 0
53: typedef struct objc_selector* SEL;
54: #else
55: typedef void* SEL;
56: #endif
57:
58: /* ObjC uses this typedef for untyped instances. */
59:
60: typedef struct objc_object {
61: struct objc_class* class_pointer;
62: } *id;
63:
64: /* Prototype for method functions. */
65: typedef id (*IMP)(id, SEL, ...);
66:
67: /* Filer types used to describe Ivars and Methods. */
68: #define _C_ID '@'
69: #define _C_CLASS '#'
70: #define _C_SEL ':'
71: #define _C_CHR 'c'
72: #define _C_UCHR 'C'
73: #define _C_SHT 's'
74: #define _C_USHT 'S'
75: #define _C_INT 'i'
76: #define _C_UINT 'I'
77: #define _C_LNG 'l'
78: #define _C_ULNG 'L'
79: #define _C_FLT 'f'
80: #define _C_DBL 'd'
81: #define _C_BFLD 'b'
82: #define _C_VOID 'v'
83: #define _C_UNDEF '?'
84: #define _C_PTR '^'
85: #define _C_CHARPTR '*'
86: #define _C_ARY_B '['
87: #define _C_ARY_E ']'
88: #define _C_UNION_B '('
89: #define _C_UNION_E ')'
90: #define _C_STRUCT_B '{'
91: #define _C_STRUCT_E '}'
92:
93: /* These definitions are masks used with the "info" member variable in
94: the lass and meta class structures. */
95: #define CLS_CLASS 0x1L /* The structure is of type
96: class (Class_t). */
97: #define CLS_META 0x2L /* The structure is of type
98: meta class (MetaClass_t). */
99: #define CLS_INITIALIZED 0x4L /* Class is initialized. A
100: +initialize method is the
101: first message sent to a
102: class. It isn't guaranteed
103: to be sent only once. */
104: #define CLS_RTI 0x8L /* The class has been initialized
105: within the run time library. */
106:
107: /* Set this variable nonzero to print a line describing each
108: message that is sent. */
109: extern BOOL objc_trace;
110:
111:
112: /*
113: * Whereas a Module (defined further down) is the root (typically) of a file,
114: * a Symtab is the root of the class and category definitions within the
115: * module.
116: *
117: * A Symtab contains a variable length array of pointers to classes and
118: * categories defined in the module.
119: */
120: typedef struct objc_symtab {
121: unsigned long sel_ref_cnt; /* Unknown. */
122: SEL *refs; /* Unknown. */
123: unsigned short cls_def_cnt; /* Number of classes compiled
124: (defined) in the module. */
125: unsigned short cat_def_cnt; /* Number of categories
126: compiled (defined) in the
127: module. */
128: void *defs[1]; /* Variable array of pointers.
129: cls_def_cnt of type Class_t
130: followed by cat_def_cnt of
131: type Category_t. */
132: } Symtab, *Symtab_t;
133:
134:
135: /*
136: * The compiler generates one of these structures for each module that
137: * composes the executable (eg main.m).
138: *
139: * This data structure is the root of the definition tree for the module.
140: *
141: * A collect program runs between ld stages and creates a ObjC ctor array.
142: * That array holds a pointer to each module structure of the executable.
143: */
144: typedef struct objc_module {
145: unsigned long version; /* Compiler revision. */
146: unsigned long size; /* sizeof(Module). */
147: const char* name; /* Name of the file where the
148: module was generated. The
149: name includes the path. */
150: Symtab_t symtab; /* Pointer to the Symtab of
151: the module. The Symtab
152: holds an array of pointers to
153: the classes and categories
154: defined in the module. */
155: } Module, *Module_t;
156:
157:
158: /*
159: * The compiler generates one of these structures for a class that has
160: * instance variables defined in its specification.
161: */
162: typedef struct objc_ivar* Ivar_t;
163: typedef struct objc_ivar_list {
164: int ivar_count; /* Number of structures (Ivar)
165: contained in the list. One
166: structure per instance
167: variable defined in the
168: class. */
169: struct objc_ivar {
170: const char* ivar_name; /* Name of the instance
171: variable as entered in the
172: class definition. */
173: const char* ivar_type; /* Description of the Ivar's
174: type. Useful for
175: debuggers. */
176: int ivar_offset; /* Byte offset from the base
177: address of the instance
178: structure to the variable. */
179:
180: } ivar_list[1]; /* Variable length
181: structure. */
182: } IvarList, *IvarList_t;
183:
184:
185: /*
186: * The compiler generates one (or more) of these structures for a class that
187: * has methods defined in its specification.
188: *
189: * The implementation of a class can be broken into separate pieces in a file
190: * and categories can break them across modules. To handle this problem is a
191: * singly linked list of methods.
192: */
193: typedef struct objc_method Method;
194: typedef Method* Method_t;
195: typedef struct objc_method_list {
196: struct objc_method_list* method_next; /* This variable is used to link
197: a method list to another. It
198: is a singly linked list. */
199: int method_count; /* Number of methods defined in
200: this structure. */
201: struct objc_method {
202: SEL method_name; /* This variable is the method's
203: name. It is a char*.
204: The unique integer passed to
205: objc_msgSend is a char* too.
206: It is compared against
207: method_name using strcmp. */
208: const char* method_types; /* Description of the method's
209: parameter list. Useful for
210: debuggers. */
211: IMP method_imp; /* Address of the method in the
212: executable. */
213: } method_list[1]; /* Variable length
214: structure. */
215: } MethodList, *MethodList_t;
216:
217:
218: /*
219: * The compiler generates one of these structures for each class.
220: *
221: * This structure is the definition for meta classes. By definition a meta
222: * class is the class's class. Its most relevant contribution is that its
223: * method list contain the class's factory methods.
224: *
225: * This structure is generated by the compiler in the executable and used by
226: * the run-time during normal messaging operations. Therefore some members
227: * change type. The compiler generates "char* const" and places a string in
228: * the following member variables: class_pointer and super_class.
229: */
230: typedef struct objc_metaClass {
231: struct objc_metaClass* class_pointer; /* Pointer to Object meta class. */
232: struct objc_metaClass* super_class; /* Pointer to meta class's
233: super class. NULL for
234: Object. */
235: const char* name; /* Name of the meta class. */
236: long version; /* Unknown. */
237: long info; /* Bit mask. See class masks
238: defined above. */
239: long instance_size; /* Always 0 except for Object.
240: Should be ignored. */
241: IvarList_t ivars; /* Always NULL except for
242: Object. Should be ignored. */
243: MethodList_t methods; /* Linked List of factory methods
244: for the class. */
245: struct record ** cache; /* Pointer to factory method dispatch table. */
246: } MetaClass, *MetaClass_t;
247:
248:
249: /*
250: * The compiler generates one of these structures for each class.
251: *
252: * This structure is the definition for classes.
253: *
254: * This structure is generated by the compiler in the executable and used by
255: * the run-time during normal messaging operations. Therefore some members
256: * change type. The compiler generates "char* const" and places a string in
257: * the following member variables: super_class.
258: */
259: typedef struct objc_class {
260: MetaClass_t class_pointer; /* Pointer to the class's
261: meta class. */
262: struct objc_class* super_class; /* Pointer to the super
263: class. NULL for class
264: Object. */
265: const char* name; /* Name of the class. */
266: long version; /* Unknown. */
267: long info; /* Bit mask. See class masks
268: defined above. */
269: long instance_size; /* Size in bytes of the class.
270: The sum of the class definition
271: and all super class
272: definitions. */
273: IvarList_t ivars; /* Pointer to a structure that
274: describes the instance
275: variables in the class
276: definition. NULL indicates
277: no instance variables. Does
278: not include super class
279: variables. */
280: MethodList_t methods; /* Linked list of instance
281: methods defined for the
282: class. */
283: struct record ** cache; /* Pointer to instance method dispatch table. */
284: } Class, *Class_t;
285:
286:
287: /*
288: * The compiler generates one of these structures for each category. A class
289: * may have many categories and contain both instance and factory methods.
290: */
291: typedef struct objc_category {
292: const char* category_name; /* Name of the category. Name
293: contained in the () of the
294: category definition. */
295: const char* class_name; /* Name of the class to which
296: the category belongs. */
297: MethodList_t instance_methods; /* Linked list of instance
298: methods defined in the
299: category. NULL indicates no
300: instance methods defined. */
301: MethodList_t class_methods; /* Linked list of factory
302: methods defined in the
303: category. NULL indicates no
304: class methods defined. */
305: } Category, *Category_t;
306:
307:
308: /*
309: * Structure used when a message is send to a class's super class. The
310: * compiler generates one of these structures and passes it to
311: * objc_msgSuper.
312: */
313: typedef struct objc_super {
314: id receiver; /* Id of the object sending
315: the message. */
316: Class_t class; /* Object's super class. */
317: } Super, *Super_t;
318:
319: /*
320: * _alloc points to the function, called through class_createInstance, used
321: * to allocate memory for new instances.
322: */
323: extern id (*_alloc)(Class_t);
324: /*
325: * _dealloc points to the function, called through object_dispose, used to
326: * free instances.
327: */
328: extern id (*_dealloc)(id);
329: /*
330: * _realloc points to the function, called through object_realloc, used to
331: * reallocate memory for an object
332: */
333: extern id (*_realloc)(id, unsigned int);
334:
335: /*
336: * _copy points to the function, called through object_copy, used to create
337: * an exact copy of an object.
338: */
339: extern id (*_copy)(id);
340:
341: /*
342: * _error points to the function that the run-time system calls in response
343: * to an error. By default, it prints formatted error messages to the
344: * standard error stream and calls abort to produce a core file.
345: */
346: extern void (*_error)(id object, const char *fmt, va_list ap);
347:
348:
349: #ifdef __cplusplus
350: }
351: #endif
352:
353:
354: #endif /* not __objc_INCLUDE_GNU */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.