OSDN Git Service

2010-11-18 Nicola Pero <nicola.pero@meta-innovation.com>
[pf3gnuchains/gcc-fork.git] / libobjc / ivars.c
1 /* GNU Objective C Runtime ivar related functions.
2    Copyright (C) 2010 Free Software Foundation, Inc.
3    Contributed by Nicola Pero
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify it under the
8 terms of the GNU General Public License as published by the Free Software
9 Foundation; either version 3, or (at your option) any later version.
10
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
13 FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
14 details.
15
16 Under Section 7 of GPL version 3, you are granted additional
17 permissions described in the GCC Runtime Library Exception, version
18 3.1, as published by the Free Software Foundation.
19
20 You should have received a copy of the GNU General Public License and
21 a copy of the GCC Runtime Library Exception along with this program;
22 see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23 <http://www.gnu.org/licenses/>.  */
24
25 #include "objc-private/common.h"
26 #include "objc/runtime.h"
27 #include "objc-private/module-abi-8.h" /* For runtime structures  */
28 #include "objc/thr.h"
29 #include "objc-private/runtime.h"      /* the kitchen sink */
30 #include <string.h>                    /* For strcmp.  */
31 #include <stdlib.h>                    /* For malloc.  */
32
33 struct objc_ivar *
34 class_getInstanceVariable (Class class_, const char *name)
35 {
36   if (class_ != Nil  &&  name != NULL  &&  ! CLS_IS_IN_CONSTRUCTION (class_))
37     {
38       while (class_ != Nil)
39         {
40           struct objc_ivar_list *ivars = class_->ivars;
41           if (ivars != NULL)
42             {
43               int i;
44               
45               for (i = 0; i < ivars->ivar_count; i++)
46                 {
47                   struct objc_ivar *ivar = &(ivars->ivar_list[i]);
48                   
49                   if (!strcmp (ivar->ivar_name, name))
50                     {
51                       return ivar;
52                     }
53                 }
54             }
55           class_ = class_getSuperclass (class_);
56         }
57     }
58   return NULL;
59 }
60
61 struct objc_ivar *
62 class_getClassVariable (Class class_, const char *name)
63 {
64   if (class_ == Nil)
65     return NULL;
66
67   /* Logically, since a class is an instance of its meta-class, and
68      since its class methods are the instance methods of the
69      meta-class, class variables should be instance variables of the
70      meta-class.  That is different from the normal use of having
71      'static' variables in the class implementation file, because
72      every class would have its own variables.
73
74      Anyway, it is all speculative at this stage, but if we get class
75      variables in Objective-C, it is conceivable that this
76      implementation should work.  */
77   return class_getInstanceVariable (class_->class_pointer, name);
78 }
79
80 void *
81 object_getIndexedIvars (id object)
82 {
83   if (object == nil)
84     return NULL;
85   else
86     {
87       return (void *)(((char *)object) 
88                       + object->class_pointer->instance_size);
89     }
90 }
91
92 struct objc_ivar *
93 object_getInstanceVariable (id object, const char *name, void **returnValue)
94 {
95   if (object == nil  ||  name == NULL)
96     return NULL;
97   else
98     {
99       struct objc_ivar * variable = class_getInstanceVariable (object->class_pointer, name);
100
101       if (variable != NULL  &&  returnValue != NULL)
102         {
103           char *location = (char *)object + variable->ivar_offset;
104          
105           *returnValue = *((id *)location);
106         }
107
108       return variable;
109     }
110 }
111
112 struct objc_ivar *
113 object_setInstanceVariable (id object, const char *name, void *newValue)
114 {
115   if (object == nil  ||  name == NULL)
116     return NULL;
117   else
118     {
119       struct objc_ivar * variable = class_getInstanceVariable (object->class_pointer, name);
120
121       if (variable != NULL)
122         {
123           char *location = (char *)object + variable->ivar_offset;
124           
125           *((id *)location) = (id)newValue;
126         }
127
128       return variable;
129     }
130 }
131
132 id object_getIvar (id object, struct objc_ivar * variable)
133 {
134   if (object == nil  ||  variable == NULL)
135     return nil;
136   else
137     {
138       char *location = (char *)object + variable->ivar_offset;
139
140       return *((id *)location);
141     }
142 }
143
144 void object_setIvar (id object, struct objc_ivar * variable, id value)
145 {
146   if (object == nil  ||  variable == NULL)
147     return;
148   else
149     {
150       char *location = (char *)object + variable->ivar_offset;
151
152       *((id *)location) = value;
153     }
154 }
155
156 const char * ivar_getName (struct objc_ivar * variable)
157 {
158   if (variable == NULL)
159     return NULL;
160
161   return variable->ivar_name;
162 }
163
164 ptrdiff_t ivar_getOffset (struct objc_ivar * variable)
165 {
166   if (variable == NULL)
167     return 0;
168
169   return (ptrdiff_t)(variable->ivar_offset);
170 }
171
172 const char * ivar_getTypeEncoding (struct objc_ivar * variable)
173 {
174   if (variable == NULL)
175     return NULL;
176
177   return variable->ivar_type;
178 }
179
180 struct objc_ivar ** class_copyIvarList (Class class_, unsigned int *numberOfReturnedIvars)
181 {
182   unsigned int count = 0;
183   struct objc_ivar **returnValue = NULL;
184   struct objc_ivar_list* ivar_list;
185
186   if (class_ == Nil  ||  CLS_IS_IN_CONSTRUCTION (class_))
187     {
188       if (numberOfReturnedIvars)
189         *numberOfReturnedIvars = 0;
190       return NULL;
191     }
192     
193   /* Count how many ivars we have.  */
194   ivar_list = class_->ivars;
195   count = ivar_list->ivar_count;
196
197   if (count != 0)
198     {
199       unsigned int i = 0;
200       
201       /* Allocate enough memory to hold them.  */
202       returnValue = (struct objc_ivar **)(malloc (sizeof (struct objc_ivar *) * (count + 1)));
203       
204       /* Copy the ivars.  */
205       for (i = 0; i < count; i++)
206         {
207           returnValue[i] = &(ivar_list->ivar_list[i]);
208         }
209       
210       returnValue[i] = NULL;
211     }
212   
213   if (numberOfReturnedIvars)
214     *numberOfReturnedIvars = count;
215
216   return returnValue;
217 }
218
219 BOOL
220 class_addIvar (Class class_, const char * ivar_name, size_t size,
221                unsigned char alignment, const char *type)
222 {
223   struct objc_ivar_list *ivars;
224
225   if (class_ == Nil
226       || (! CLS_IS_IN_CONSTRUCTION (class_))  
227       || ivar_name == NULL  
228       || (strcmp (ivar_name, "") == 0)
229       || size == 0
230       || type == NULL)
231     return NO;
232
233   /* Check if the class has an instance variable with that name
234      already.  */
235   ivars = class_->ivars;
236
237   if (ivars != NULL)
238     {
239       int i;
240       
241       for (i = 0; i < ivars->ivar_count; i++)
242         {
243           struct objc_ivar *ivar = &(ivars->ivar_list[i]);
244           
245           if (strcmp (ivar->ivar_name, ivar_name) == 0)
246             {
247               return NO;
248             }
249         }
250     }
251
252   /* Ok, no direct ivars.  Check superclasses.  */
253   if (class_getInstanceVariable (objc_getClass ((char *)(class_->super_class)),
254                                  ivar_name))
255     return NO;
256
257   /* Good.  Create space for the new instance variable.  */
258   if (ivars)
259     {
260       int ivar_count = ivars->ivar_count + 1;
261       int new_size = sizeof (struct objc_ivar_list) 
262         + (ivar_count - 1) * sizeof (struct objc_ivar);
263       
264       ivars = (struct objc_ivar_list*) objc_realloc (ivars, new_size);
265       ivars->ivar_count = ivar_count;
266       class_->ivars = ivars;
267     }
268   else
269     {
270       int new_size = sizeof (struct objc_ivar_list);
271       
272       ivars = (struct objc_ivar_list*) objc_malloc (new_size);
273       ivars->ivar_count = 1;
274       class_->ivars = ivars;
275     }
276     
277   /* Now ivars is set to a list of instance variables of the right
278      size. */
279   {
280     struct objc_ivar *ivar = &(ivars->ivar_list[ivars->ivar_count - 1]);
281     int misalignment;
282     
283     ivar->ivar_name = objc_malloc (strlen (ivar_name) + 1);
284     strcpy ((char *)ivar->ivar_name, ivar_name);
285
286     ivar->ivar_type = objc_malloc (strlen (type) + 1);
287     strcpy ((char *)ivar->ivar_type, type);
288
289     /* The new instance variable is placed at the end of the existing
290        instance_size, at the first byte that is aligned with
291        alignment.  */
292     misalignment = class_->instance_size % alignment;
293     
294     if (misalignment == 0)
295       ivar->ivar_offset = class_->instance_size;
296     else
297       ivar->ivar_offset = class_->instance_size - misalignment + alignment;
298     
299     class_->instance_size = ivar->ivar_offset + objc_sizeof_type (ivar->ivar_type);
300   }
301   
302   return YES;
303 }
304
305
306 const char *
307 property_getName (struct objc_property * property __attribute__ ((__unused__)))
308 {
309   if (property == NULL)
310     return NULL;
311
312   /* TODO: New ABI.  */
313   /* The current ABI does not have any information on properties.  */
314   return NULL;
315 }
316
317 const char *
318 property_getAttributes (struct objc_property * property __attribute__ ((__unused__)))
319 {
320   if (property == NULL)
321     return NULL;
322
323   /* TODO: New ABI.  */
324   /* The current ABI does not have any information on properties.  */
325   return NULL;
326 }
327
328 struct objc_property *
329 class_getProperty (Class class_ __attribute__ ((__unused__)),
330                    const char *propertyName __attribute__ ((__unused__)))
331 {
332   if (class_ == NULL  ||  propertyName == NULL)
333     return NULL;
334
335   /* TODO: New ABI.  */
336   /* The current ABI does not have any information on class properties.  */
337   return NULL;
338 }
339
340 struct objc_property ** 
341 class_copyPropertyList (Class class_ __attribute__ ((__unused__)), 
342                         unsigned int *numberOfReturnedProperties __attribute__ ((__unused__)))
343 {
344   if (class_ == Nil)
345     {
346       if (numberOfReturnedProperties)
347         *numberOfReturnedProperties = 0;
348       return NULL;
349     }
350
351   /* TODO: New ABI.  */
352   /* The current ABI does not have any information on class properties.  */
353   if (numberOfReturnedProperties)
354     *numberOfReturnedProperties = 0;
355
356   return NULL;
357 }
358
359 const char *
360 class_getIvarLayout (Class class_ __attribute__ ((__unused__)))
361 {
362   return NULL;
363 }
364
365 const char *
366 class_getWeakIvarLayout (Class class_ __attribute__ ((__unused__)))
367 {
368   return NULL;
369 }
370
371 void
372 class_setIvarLayout (Class class_ __attribute__ ((__unused__)),
373                      const char *layout __attribute__ ((__unused__)))
374 {
375   return;
376 }
377
378 void
379 class_setWeakIvarLayout (Class class_ __attribute__ ((__unused__)),
380                          const char *layout __attribute__ ((__unused__)))
381 {
382   return;
383 }