OSDN Git Service

In libobjc/:
[pf3gnuchains/gcc-fork.git] / libobjc / objc / objc-api.h
1 /* GNU Objective-C Runtime API.
2    Copyright (C) 1993, 1995, 1996, 1997, 2001, 2002, 2003, 2004, 2005,
3    2007, 2009 Free Software Foundation, Inc.
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by the
9 Free Software Foundation; either version 3, or (at your option) any
10 later version.
11
12 GCC is distributed in the hope that it will be useful, but WITHOUT
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
15 License for more details.
16
17 Under Section 7 of GPL version 3, you are granted additional
18 permissions described in the GCC Runtime Library Exception, version
19 3.1, as published by the Free Software Foundation.
20
21 You should have received a copy of the GNU General Public License and
22 a copy of the GCC Runtime Library Exception along with this program;
23 see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
24 <http://www.gnu.org/licenses/>.  */
25
26
27 #ifndef __objc_api_INCLUDE_GNU
28 #define __objc_api_INCLUDE_GNU
29
30 #include "objc.h"
31 #include "hash.h"
32 #include "thr.h"
33 #include "objc-decls.h"
34 #include <stdio.h>
35 #include <stdarg.h>
36
37 #ifdef __cplusplus
38 extern "C" {
39 #endif /* __cplusplus */
40
41 /* For functions which return Method_t */
42 #define METHOD_NULL     (Method_t)0
43                                                 /* Boolean typedefs */
44 /* Method descriptor returned by introspective Object methods.
45    This is really just the first part of the more complete objc_method
46    structure defined below and used internally by the runtime.  */
47 struct objc_method_description
48 {
49     SEL name;                   /* this is a selector, not a string */
50     char *types;                /* type encoding */
51 };
52
53 /* Filer types used to describe Ivars and Methods.  */
54 #define _C_ID       '@'
55 #define _C_CLASS    '#'
56 #define _C_SEL      ':'
57 #define _C_CHR      'c'
58 #define _C_UCHR     'C'
59 #define _C_SHT      's'
60 #define _C_USHT     'S'
61 #define _C_INT      'i'
62 #define _C_UINT     'I'
63 #define _C_LNG      'l'
64 #define _C_ULNG     'L'
65 #define _C_LNG_LNG  'q'
66 #define _C_ULNG_LNG 'Q'
67 #define _C_FLT      'f'
68 #define _C_DBL      'd'
69 #define _C_BFLD     'b'
70 #define _C_BOOL     'B'
71 #define _C_VOID     'v'
72 #define _C_UNDEF    '?'
73 #define _C_PTR      '^'
74 #define _C_CHARPTR  '*'
75 #define _C_ATOM     '%'
76 #define _C_ARY_B    '['
77 #define _C_ARY_E    ']'
78 #define _C_UNION_B  '('
79 #define _C_UNION_E  ')'
80 #define _C_STRUCT_B '{'
81 #define _C_STRUCT_E '}'
82 #define _C_VECTOR   '!'
83 #define _C_COMPLEX   'j'
84
85
86 #include "deprecated/objc_error.h"
87
88
89 /* For every class which happens to have statically allocated instances in
90    this module, one OBJC_STATIC_INSTANCES is allocated by the compiler.
91    INSTANCES is NULL terminated and points to all statically allocated
92    instances of this class.  */
93 struct objc_static_instances
94 {
95   char *class_name;
96 #ifdef __cplusplus
97   id instances[1];
98 #else
99   id instances[0];
100 #endif
101 };
102
103 /* Whereas a Module (defined further down) is the root (typically) of a file,
104    a Symtab is the root of the class and category definitions within the
105    module.  
106    
107    A Symtab contains a variable length array of pointers to classes and
108    categories  defined in the module.   */
109 typedef struct objc_symtab {
110   unsigned long sel_ref_cnt;                     /* Unknown. */
111   SEL        refs;                              /* Unknown. */
112   unsigned short cls_def_cnt;                   /* Number of classes compiled
113                                                   (defined) in the module. */
114   unsigned short cat_def_cnt;                   /* Number of categories 
115                                                   compiled (defined) in the 
116                                                   module. */
117
118   void      *defs[1];                           /* Variable array of pointers.
119                                                   cls_def_cnt of type Class 
120                                                   followed by cat_def_cnt of
121                                                   type Category_t, followed
122                                                   by a NULL terminated array
123                                                   of objc_static_instances. */
124 } Symtab,   *Symtab_t;
125
126
127 /*
128 ** The compiler generates one of these structures for each module that
129 ** composes the executable (eg main.m).  
130 ** 
131 ** This data structure is the root of the definition tree for the module.  
132 ** 
133 ** A collect program runs between ld stages and creates a ObjC ctor array. 
134 ** That array holds a pointer to each module structure of the executable. 
135 */
136 typedef struct objc_module {
137   unsigned long version; /* Version of the Module data structure.  */
138   unsigned long size;    /* sizeof(Module) according to the compiler -
139                             only used to sanity check that it matches
140                             sizeof(Module) according to the
141                             runtime.  */
142   const char* name;      /* Name of the file used to compile the
143                             module - not set by modern compilers for
144                             security reasons.  */
145   Symtab_t    symtab;    /* Pointer to the Symtab of the module.  The
146                             Symtab holds an array of pointers to the
147                             classes and categories defined in the
148                             module. */
149 } Module, *Module_t;
150
151
152 /*
153 ** The compiler generates one of these structures for a class that has
154 ** instance variables defined in its specification. 
155 */
156 typedef struct objc_ivar {
157     const char* ivar_name;                      /* Name of the instance
158                                                   variable as entered in the
159                                                   class definition. */
160     const char* ivar_type;                      /* Description of the Ivar's
161                                                   type.  Useful for 
162                                                   debuggers. */
163     int        ivar_offset;                    /* Byte offset from the base 
164                                                   address of the instance 
165                                                   structure to the variable. */
166 } *Ivar_t;
167
168 typedef struct objc_ivar_list {
169   int   ivar_count;                             /* Number of structures (Ivar) 
170                                                   contained in the list.  One
171                                                   structure per instance 
172                                                   variable defined in the
173                                                   class. */
174   struct objc_ivar ivar_list[1];               /* Variable length 
175                                                   structure. */
176 } IvarList, *IvarList_t;
177
178
179 /*
180 ** The compiler generates one (or more) of these structures for a class that
181 ** has methods defined in its specification. 
182 ** 
183 ** The implementation of a class can be broken into separate pieces in a file
184 ** and categories can break them across modules. To handle this problem is a
185 ** singly linked list of methods. 
186 */
187 typedef struct objc_method {
188   SEL         method_name;                  /* This variable is the method's 
189                                                name.  It is a char*. 
190                                                The unique integer passed to 
191                                                objc_msg_send is a char* too.  
192                                                It is compared against 
193                                                method_name using strcmp. */
194   const char* method_types;                 /* Description of the method's
195                                                parameter list.  Useful for
196                                                debuggers. */
197   IMP         method_imp;                   /* Address of the method in the 
198                                                executable. */
199 } Method, *Method_t;
200
201 typedef struct objc_method_list {
202   struct objc_method_list*  method_next;    /* This variable is used to link 
203                                                a method list to another.  It 
204                                                is a singly linked list. */
205   int            method_count;              /* Number of methods defined in 
206                                                this structure. */
207   Method method_list[1];                    /* Variable length 
208                                                structure. */
209 } MethodList, *MethodList_t;
210
211 struct objc_protocol_list {
212   struct objc_protocol_list *next;
213   size_t count;
214   Protocol *list[1];
215 };
216
217 /*
218 ** This is used to assure consistent access to the info field of 
219 ** classes
220 */
221 #ifndef HOST_BITS_PER_LONG
222 #define HOST_BITS_PER_LONG  (sizeof(long)*8)
223 #endif 
224
225 #define __CLS_INFO(cls) ((cls)->info)
226 #define __CLS_ISINFO(cls, mask) ((__CLS_INFO(cls)&mask)==mask)
227 #define __CLS_SETINFO(cls, mask) (__CLS_INFO(cls) |= mask)
228
229 /* The structure is of type MetaClass */
230 #define _CLS_META 0x2L
231 #define CLS_ISMETA(cls) ((cls)&&__CLS_ISINFO(cls, _CLS_META))
232
233
234 /* The structure is of type Class */
235 #define _CLS_CLASS 0x1L
236 #define CLS_ISCLASS(cls) ((cls)&&__CLS_ISINFO(cls, _CLS_CLASS))
237
238 /*
239 ** The class is initialized within the runtime.  This means that 
240 ** it has had correct super and sublinks assigned
241 */
242 #define _CLS_RESOLV 0x8L
243 #define CLS_ISRESOLV(cls) __CLS_ISINFO(cls, _CLS_RESOLV)
244 #define CLS_SETRESOLV(cls) __CLS_SETINFO(cls, _CLS_RESOLV)
245
246 /*
247 ** The class has been send a +initialize message or a such is not 
248 ** defined for this class
249 */
250 #define _CLS_INITIALIZED 0x04L
251 #define CLS_ISINITIALIZED(cls) __CLS_ISINFO(cls, _CLS_INITIALIZED)
252 #define CLS_SETINITIALIZED(cls) __CLS_SETINFO(cls, _CLS_INITIALIZED)
253
254 /*
255 ** The class number of this class.  This must be the same for both the 
256 ** class and its meta class object
257 */
258 #define CLS_GETNUMBER(cls) (__CLS_INFO(cls) >> (HOST_BITS_PER_LONG/2))
259 #define CLS_SETNUMBER(cls, num) \
260   ({ (cls)->info <<= (HOST_BITS_PER_LONG/2); \
261      (cls)->info >>= (HOST_BITS_PER_LONG/2); \
262      __CLS_SETINFO(cls, (((unsigned long)num) << (HOST_BITS_PER_LONG/2))); })
263
264 /*
265 ** The compiler generates one of these structures for each category.  A class
266 ** may have many categories and contain both instance and factory methods.  
267 */
268 typedef struct objc_category {
269   const char*   category_name;                /* Name of the category.  Name
270                                                 contained in the () of the
271                                                 category definition. */
272   const char*   class_name;                   /* Name of the class to which
273                                                 the category belongs. */
274   MethodList_t  instance_methods;             /* Linked list of instance
275                                                 methods defined in the 
276                                                 category. NULL indicates no
277                                                 instance methods defined. */
278   MethodList_t  class_methods;                /* Linked list of factory 
279                                                 methods defined in the
280                                                 category.  NULL indicates no
281                                                 class methods defined. */
282   struct objc_protocol_list *protocols;       /* List of Protocols 
283                                                  conformed to */
284 } Category, *Category_t;
285
286 /*
287 ** Structure used when a message is send to a class's super class.  The
288 ** compiler generates one of these structures and passes it to
289 ** objc_msg_super.
290 */
291 typedef struct objc_super {
292   id      self;                           /* Id of the object sending
293                                                 the message. */
294 #ifdef __cplusplus
295   Class super_class;
296 #else
297   Class class;                              /* Object's super class. */
298 #endif
299 } Super, *Super_t;
300
301 IMP objc_msg_lookup_super(Super_t super, SEL sel);
302
303 retval_t objc_msg_sendv(id, SEL, arglist_t);
304
305
306
307 /*
308 ** This is a hook which is called by objc_lookup_class and
309 ** objc_get_class if the runtime is not able to find the class.
310 ** This may e.g. try to load in the class using dynamic loading.
311 ** The function is guaranteed to be passed a non-NULL name string.
312 */
313 objc_EXPORT Class (*_objc_lookup_class)(const char *name);
314
315 /*
316 ** This is a hook which is called by __objc_exec_class every time a class
317 ** or a category is loaded into the runtime.  This may e.g. help a
318 ** dynamic loader determine the classes that have been loaded when
319 ** an object file is dynamically linked in.
320 */
321 objc_EXPORT void (*_objc_load_callback)(Class _class, Category* category);
322
323 /*
324 ** Hook functions for allocating, copying and disposing of instances
325 */
326 objc_EXPORT id (*_objc_object_alloc)(Class _class);
327 objc_EXPORT id (*_objc_object_copy)(id object);
328 objc_EXPORT id (*_objc_object_dispose)(id object);
329
330 /*
331 ** Standard functions for memory allocation and disposal.
332 ** Users should use these functions in their ObjC programs so
333 ** that they work properly with garbage collectors as well as
334 ** can take advantage of the exception/error handling available.
335 */
336 void *
337 objc_malloc(size_t size);
338
339 void *
340 objc_atomic_malloc(size_t size);
341
342 void *
343 objc_valloc(size_t size);
344
345 void *
346 objc_realloc(void *mem, size_t size);
347
348 void *
349 objc_calloc(size_t nelem, size_t size);
350
351 void
352 objc_free(void *mem);
353
354 /*
355 ** Hook functions for memory allocation and disposal.
356 ** This makes it easy to substitute garbage collection systems
357 ** such as Boehm's GC by assigning these function pointers
358 ** to the GC's allocation routines.  By default these point
359 ** to the ANSI standard malloc, realloc, free, etc.
360 **
361 ** Users should call the normal objc routines above for
362 ** memory allocation and disposal within their programs.
363 */
364 objc_EXPORT void *(*_objc_malloc)(size_t);
365 objc_EXPORT void *(*_objc_atomic_malloc)(size_t);
366 objc_EXPORT void *(*_objc_valloc)(size_t);
367 objc_EXPORT void *(*_objc_realloc)(void *, size_t);
368 objc_EXPORT void *(*_objc_calloc)(size_t, size_t);
369 objc_EXPORT void (*_objc_free)(void *);
370
371 /*
372 **  Hooks for method forwarding. This makes it easy to substitute a
373 **  library, such as ffcall, that implements closures, thereby avoiding
374 **  gcc's __builtin_apply problems.  __objc_msg_forward2's result will
375 **  be preferred over that of __objc_msg_forward if both are set and
376 **  return non-NULL.
377 */
378 objc_EXPORT IMP (*__objc_msg_forward)(SEL);
379 objc_EXPORT IMP (*__objc_msg_forward2)(id, SEL);
380
381 #include "deprecated/objc_unexpected_exception.h"
382
383 Method_t class_get_class_method(MetaClass _class, SEL aSel);
384
385 Method_t class_get_instance_method(Class _class, SEL aSel);
386
387 Class class_pose_as(Class impostor, Class superclass);
388
389 Class objc_get_class(const char *name);
390
391 Class objc_lookup_class(const char *name);
392
393 Class objc_next_class(void **enum_state);
394
395 const char *sel_get_name(SEL selector);
396
397 const char *sel_get_type(SEL selector);
398
399 SEL sel_get_uid(const char *name);
400
401 SEL sel_get_any_uid(const char *name);
402
403 SEL sel_get_any_typed_uid(const char *name);
404
405 SEL sel_get_typed_uid(const char *name, const char*);
406
407 SEL sel_register_name(const char *name);
408
409 SEL sel_register_typed_name(const char *name, const char*type);
410
411
412 BOOL sel_is_mapped (SEL aSel);
413
414 extern id class_create_instance(Class _class);
415
416 static inline const char *
417 class_get_class_name(Class _class)
418 {
419   return CLS_ISCLASS(_class)?_class->name:((_class==Nil)?"Nil":0);
420 }
421
422 static inline long
423 class_get_instance_size(Class _class)
424 {
425   return CLS_ISCLASS(_class)?_class->instance_size:0;
426 }
427
428 static inline MetaClass
429 class_get_meta_class(Class _class)
430 {
431   return CLS_ISCLASS(_class)?_class->class_pointer:Nil;
432 }
433
434 static inline Class
435 class_get_super_class(Class _class)
436 {
437   return CLS_ISCLASS(_class)?_class->super_class:Nil;
438 }
439
440 static inline int
441 class_get_version(Class _class)
442 {
443   return CLS_ISCLASS(_class)?_class->version:-1;
444 }
445
446 static inline BOOL
447 class_is_class(Class _class)
448 {
449   return CLS_ISCLASS(_class);
450 }
451
452 static inline BOOL
453 class_is_meta_class(Class _class)
454 {
455   return CLS_ISMETA(_class);
456 }
457
458
459 static inline void
460 class_set_version(Class _class, long version)
461 {
462   if (CLS_ISCLASS(_class))
463     _class->version = version;
464 }
465
466 static inline void *
467 class_get_gc_object_type (Class _class)
468 {
469   return CLS_ISCLASS(_class) ? _class->gc_object_type : NULL;
470 }
471
472 /* Mark the instance variable as innaccessible to the garbage collector */
473 extern void class_ivar_set_gcinvisible (Class _class,
474                                         const char* ivarname,
475                                         BOOL gcInvisible);
476
477 static inline IMP
478 method_get_imp(Method_t method)
479 {
480   return (method!=METHOD_NULL)?method->method_imp:(IMP)0;
481 }
482
483 IMP get_imp (Class _class, SEL sel);
484
485 id object_copy(id object);
486
487 id object_dispose(id object);
488
489 static inline Class
490 object_get_class(id object)
491 {
492   return ((object!=nil)
493           ? (CLS_ISCLASS(object->class_pointer)
494              ? object->class_pointer
495              : (CLS_ISMETA(object->class_pointer)
496                 ? (Class)object
497                 : Nil))
498           : Nil);
499 }
500
501 static inline const char *
502 object_get_class_name(id object)
503 {
504   return ((object!=nil)?(CLS_ISCLASS(object->class_pointer)
505                          ?object->class_pointer->name
506                          :((Class)object)->name)
507                        :"Nil");
508 }
509
510 static inline MetaClass
511 object_get_meta_class(id object)
512 {
513   return ((object!=nil)?(CLS_ISCLASS(object->class_pointer)
514                          ?object->class_pointer->class_pointer
515                          :(CLS_ISMETA(object->class_pointer)
516                            ?object->class_pointer
517                            :Nil))
518                        :Nil);
519 }
520
521 static inline Class
522 object_get_super_class
523 (id object)
524 {
525   return ((object!=nil)?(CLS_ISCLASS(object->class_pointer)
526                          ?object->class_pointer->super_class
527                          :(CLS_ISMETA(object->class_pointer)
528                            ?((Class)object)->super_class
529                            :Nil))
530                        :Nil);
531 }
532
533 static inline BOOL
534 object_is_class (id object)
535 {
536   return ((object != nil)  &&  CLS_ISMETA (object->class_pointer));
537 }
538  
539 static inline BOOL
540 object_is_instance (id object)
541 {
542   return ((object != nil)  &&  CLS_ISCLASS (object->class_pointer));
543 }
544
545 static inline BOOL
546 object_is_meta_class (id object)
547 {
548   return ((object != nil)
549           &&  !object_is_instance (object)  
550           &&  !object_is_class (object));
551 }
552
553 struct sarray* 
554 objc_get_uninstalled_dtable(void);
555
556 #ifdef __cplusplus
557 }
558 #endif /* __cplusplus */
559
560 #endif /* not __objc_api_INCLUDE_GNU */
561
562
563