OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libobjc/] [ivars.c] - Blame information for rev 775

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.