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
  32 struct objc_ivar *
  33 class_getInstanceVariable (Class class_, const char *name)
  34 {
  35   if (class_ != Nil  &&  name != NULL  &&  ! CLS_IS_IN_CONSTRUCTION (class_))
  36     {
  37       while (class_ != Nil)
  38         {
  39           struct objc_ivar_list *ivars = class_->ivars;
  40           if (ivars != NULL)
  41             {
  42               int i;
  43
  44               for (i = 0; i < ivars->ivar_count; i++)
  45                 {
  46                   struct objc_ivar *ivar = &(ivars->ivar_list[i]);
  47
  48                   if (!strcmp (ivar->ivar_name, name))
  49                     {
  50                       return ivar;
  51                     }
  52                 }
  53             }
  54           class_ = class_getSuperclass (class_);
  55         }
  56     }
  57   return NULL;
  58 }
  59
  60 struct objc_ivar *
  61 class_getClassVariable (Class class_, const char *name)
  62 {
  63   if (class_ == Nil)
  64     return NULL;
  65
  66   /* Logically, since a class is an instance of its meta-class, and
  67      since its class methods are the instance methods of the
  68      meta-class, class variables should be instance variables of the
  69      meta-class.  That is different from the normal use of having
  70      'static' variables in the class implementation file, because
  71      every class would have its own variables.
  72
  73      Anyway, it is all speculative at this stage, but if we get class
  74      variables in Objective-C, it is conceivable that this
  75      implementation should work.  */
  76   return class_getInstanceVariable (class_->class_pointer, name);
  77 }
  78
  79 void *
  80 object_getIndexedIvars (id object)
  81 {
  82   if (object == nil)
  83     return NULL;
  84   else
  85     {
  86       return (void *)(((char *)object)
  87                       + object->class_pointer->instance_size);
  88     }
  89 }
  90
  91 struct objc_ivar *
  92 object_getInstanceVariable (id object, const char *name, void **returnValue)
  93 {
  94   if (object == nil  ||  name == NULL)
  95     return NULL;
  96   else
  97     {
  98       struct objc_ivar * variable = class_getInstanceVariable (object->class_pointer, name);
  99
 100       if (variable != NULL  &&  returnValue != NULL)
 101         {
 102           char *location = (char *)object + variable->ivar_offset;
 103
 104           *returnValue = *((id *)location);
 105         }
 106
 107       return variable;
 108     }
 109 }
 110
 111 struct objc_ivar *
 112 object_setInstanceVariable (id object, const char *name, void *newValue)
 113 {
 114   if (object == nil  ||  name == NULL)
 115     return NULL;
 116   else
 117     {
 118       struct objc_ivar * variable = class_getInstanceVariable (object->class_pointer, name);
 119
 120       if (variable != NULL)
 121         {
 122           char *location = (char *)object + variable->ivar_offset;
 123
 124           *((id *)location) = (id)newValue;
 125         }
 126
 127       return variable;
 128     }
 129 }
 130
 131 id object_getIvar (id object, struct objc_ivar * variable)
 132 {
 133   if (object == nil  ||  variable == NULL)
 134     return nil;
 135   else
 136     {
 137       char *location = (char *)object + variable->ivar_offset;
 138
 139       return *((id *)location);
 140     }
 141 }
 142
 143 void object_setIvar (id object, struct objc_ivar * variable, id value)
 144 {
 145   if (object == nil  ||  variable == NULL)
 146     return;
 147   else
 148     {
 149       char *location = (char *)object + variable->ivar_offset;
 150
 151       *((id *)location) = value;
 152     }
 153 }
 154
 155 const char * ivar_getName (struct objc_ivar * variable)
 156 {
 157   if (variable == NULL)
 158     return NULL;
 159
 160   return variable->ivar_name;
 161 }
 162
 163 ptrdiff_t ivar_getOffset (struct objc_ivar * variable)
 164 {
 165   if (variable == NULL)
 166     return 0;
 167
 168   return (ptrdiff_t)(variable->ivar_offset);
 169 }
 170
 171 const char * ivar_getTypeEncoding (struct objc_ivar * variable)
 172 {
 173   if (variable == NULL)
 174     return NULL;
 175
 176   return variable->ivar_type;
 177 }
 178
 179 struct objc_ivar ** class_copyIvarList (Class class_, unsigned int *numberOfReturnedIvars)
 180 {
 181   unsigned int count = 0;
 182   struct objc_ivar **returnValue = NULL;
 183   struct objc_ivar_list* ivar_list;
 184
 185   if (class_ == Nil  ||  CLS_IS_IN_CONSTRUCTION (class_))
 186     {
 187       if (numberOfReturnedIvars)
 188         *numberOfReturnedIvars = 0;
 189       return NULL;
 190     }
 191
 192   /* Count how many ivars we have.  */
 193   ivar_list = class_->ivars;
 194   count = ivar_list->ivar_count;
 195
 196   if (count != 0)
 197     {
 198       unsigned int i = 0;
 199
 200       /* Allocate enough memory to hold them.  */
 201       returnValue = (struct objc_ivar **)(malloc (sizeof (struct objc_ivar *) * (count + 1)));
 202
 203       /* Copy the ivars.  */
 204       for (i = 0; i < count; i++)
 205         {
 206           returnValue[i] = &(ivar_list->ivar_list[i]);
 207         }
 208
 209       returnValue[i] = NULL;
 210     }
 211
 212   if (numberOfReturnedIvars)
 213     *numberOfReturnedIvars = count;
 214
 215   return returnValue;
 216 }
 217
 218 BOOL
 219 class_addIvar (Class class_, const char * ivar_name, size_t size,
 220                unsigned char alignment, const char *type)
 221 {
 222   struct objc_ivar_list *ivars;
 223
 224   if (class_ == Nil
 225       || (! CLS_IS_IN_CONSTRUCTION (class_))
 226       || ivar_name == NULL
 227       || (strcmp (ivar_name, "") == 0)
 228       || size == 0
 229       || type == NULL)
 230     return NO;
 231
 232   /* Check if the class has an instance variable with that name
 233      already.  */
 234   ivars = class_->ivars;
 235
 236   if (ivars != NULL)
 237     {
 238       int i;
 239
 240       for (i = 0; i < ivars->ivar_count; i++)
 241         {
 242           struct objc_ivar *ivar = &(ivars->ivar_list[i]);
 243
 244           if (strcmp (ivar->ivar_name, ivar_name) == 0)
 245             {
 246               return NO;
 247             }
 248         }
 249     }
 250
 251   /* Ok, no direct ivars.  Check superclasses.  */
 252   if (class_getInstanceVariable (objc_getClass ((char *)(class_->super_class)),
 253                                  ivar_name))
 254     return NO;
 255
 256   /* Good.  Create space for the new instance variable.  */
 257   if (ivars)
 258     {
 259       int ivar_count = ivars->ivar_count + 1;
 260       int new_size = sizeof (struct objc_ivar_list)
 261         + (ivar_count - 1) * sizeof (struct objc_ivar);
 262
 263       ivars = (struct objc_ivar_list*) objc_realloc (ivars, new_size);
 264       ivars->ivar_count = ivar_count;
 265       class_->ivars = ivars;
 266     }
 267   else
 268     {
 269       int new_size = sizeof (struct objc_ivar_list);
 270
 271       ivars = (struct objc_ivar_list*) objc_malloc (new_size);
 272       ivars->ivar_count = 1;
 273       class_->ivars = ivars;
 274     }
 275
 276   /* Now ivars is set to a list of instance variables of the right
 277      size. */
 278   {
 279     struct objc_ivar *ivar = &(ivars->ivar_list[ivars->ivar_count - 1]);
 280     int misalignment;
 281
 282     ivar->ivar_name = objc_malloc (strlen (ivar_name) + 1);
 283     strcpy ((char *)ivar->ivar_name, ivar_name);
 284
 285     ivar->ivar_type = objc_malloc (strlen (type) + 1);
 286     strcpy ((char *)ivar->ivar_type, type);
 287
 288     /* The new instance variable is placed at the end of the existing
 289        instance_size, at the first byte that is aligned with
 290        alignment.  */
 291     misalignment = class_->instance_size % alignment;
 292
 293     if (misalignment == 0)
 294       ivar->ivar_offset = class_->instance_size;
 295     else
 296       ivar->ivar_offset = class_->instance_size - misalignment + alignment;
 297
 298     class_->instance_size = ivar->ivar_offset + objc_sizeof_type (ivar->ivar_type);
 299   }
 300
 301   return YES;
 302 }
 303
 304
 305 const char *
 306 property_getName (struct objc_property * property __attribute__ ((__unused__)))
 307 {
 308   if (property == NULL)
 309     return NULL;
 310
 311   /* TODO: New ABI.  */
 312   /* The current ABI does not have any information on properties.  */
 313   return NULL;
 314 }
 315
 316 const char *
 317 property_getAttributes (struct objc_property * property __attribute__ ((__unused__)))
 318 {
 319   if (property == NULL)
 320     return NULL;
 321
 322   /* TODO: New ABI.  */
 323   /* The current ABI does not have any information on properties.  */
 324   return NULL;
 325 }
 326
 327 struct objc_property *
 328 class_getProperty (Class class_ __attribute__ ((__unused__)),
 329                    const char *propertyName __attribute__ ((__unused__)))
 330 {
 331   if (class_ == NULL  ||  propertyName == NULL)
 332     return NULL;
 333
 334   /* TODO: New ABI.  */
 335   /* The current ABI does not have any information on class properties.  */
 336   return NULL;
 337 }
 338
 339 struct objc_property **
 340 class_copyPropertyList (Class class_ __attribute__ ((__unused__)),
 341                         unsigned int *numberOfReturnedProperties __attribute__ ((__unused__)))
 342 {
 343   if (class_ == Nil)
 344     {
 345       if (numberOfReturnedProperties)
 346         *numberOfReturnedProperties = 0;
 347       return NULL;
 348     }
 349
 350   /* TODO: New ABI.  */
 351   /* The current ABI does not have any information on class properties.  */
 352   if (numberOfReturnedProperties)
 353     *numberOfReturnedProperties = 0;
 354
 355   return NULL;
 356 }
 357
 358 const char *
 359 class_getIvarLayout (Class class_ __attribute__ ((__unused__)))
 360 {
 361   return NULL;
 362 }
 363
 364 const char *
 365 class_getWeakIvarLayout (Class class_ __attribute__ ((__unused__)))
 366 {
 367   return NULL;
 368 }
 369
 370 void
 371 class_setIvarLayout (Class class_ __attribute__ ((__unused__)),
 372                      const char *layout __attribute__ ((__unused__)))
 373 {
 374   return;
 375 }
 376
 377 void
 378 class_setWeakIvarLayout (Class class_ __attribute__ ((__unused__)),
 379                          const char *layout __attribute__ ((__unused__)))
 380 {
 381   return;
 382 }