libs/iovm/source/IoObject_inline.h

   1
   2 //metadoc Object copyright Steve Dekorte 2002
   3 //metadoc Object license BSD revised
   4
   5 #ifdef IOOBJECT_C
   6 #define IO_IN_C_FILE
   7 #endif
   8 #include "Common_inline.h"
   9 #ifdef IO_DECLARE_INLINES
  10
  11 #include "IoVMApi.h"
  12 #include "IoState.h"
  13
  14 #define IOOBJECT_FOREACHPROTO(self, pvar, code) \
  15 {\
  16         IoObject **_proto = IoObject_protos(self); \
  17         while (*_proto) \
  18         { \
  19                 IoObject *pvar = *_proto; \
  20                 code; \
  21                 _proto++; \
  22         } \
  23 }
  24
  25 /*
  26 IOINLINE PHash *IoObject_slots(IoObject *self)
  27 {
  28         IoObjectData *od = IoObject_deref(self);
  29         return od->slots;
  30 }
  31
  32 IOINLINE void IoObject_slots_(IoObject *self, PHash *v)
  33 {
  34         IoObjectData *od = IoObject_deref(self);
  35         od->slots = v;
  36 }
  37
  38 IOINLINE IoObject **IoObject_protos(IoObject *self)
  39 {
  40         IoObjectData *od = IoObject_deref(self);
  41         return od->protos;
  42 }
  43
  44 IOINLINE void IoObject_protos_(IoObject *self, IoObject **v)
  45 {
  46         IoObjectData *od = IoObject_deref(self);
  47         od->protos = v;
  48 }
  49 */
  50
  51 /*
  52 IOINLINE int IoObject_isWhite(IoObject *self)
  53 {
  54         return Collector_markerIsWhite_(IOCOLLECTOR, (CollectorMarker *)self);
  55 }
  56
  57 IOINLINE int IoObject_isGray(IoObject *self)
  58 {
  59         return Collector_markerIsGray_(IOCOLLECTOR, (CollectorMarker *)self);
  60 }
  61
  62 IOINLINE int IoObject_isBlack(IoObject *self)
  63 {
  64         return Collector_markerIsBlack_(IOCOLLECTOR, (CollectorMarker *)self);
  65 }
  66 */
  67
  68 IOINLINE void IoObject_createSlotsIfNeeded(IoObject *self)
  69 {
  70         if (!IoObject_ownsSlots(self))
  71         {
  72                 /*printf("creating slots for %s %p\n", IoObject_tag(self)->name, (void *)self);*/
  73                 IoObject_createSlots(self);
  74         }
  75 }
  76
  77 IOINLINE void IoObject_rawRemoveAllProtos(IoObject *self)
  78 {
  79         //IoObject_createSlotsIfNeeded(self);
  80         memset(IoObject_protos(self), 0, IoObject_rawProtosCount(self) * sizeof(IoObject *));
  81 }
  82
  83 IOINLINE void IoObject_shouldMark(IoObject *self)
  84 {
  85         Collector_shouldMark_(IOCOLLECTOR, self);
  86 }
  87
  88 IOINLINE void IoObject_shouldMarkIfNonNull(IoObject *self)
  89 {
  90         if (self)
  91         {
  92                 IoObject_shouldMark(self);
  93         }
  94 }
  95
  96 IOINLINE void IoObject_freeIfUnreferenced(IoObject *self)
  97 {
  98         if (!IoObject_isReferenced(self) && !Collector_isPaused(IOSTATE->collector))
  99         {
 100                 CollectorMarker_remove((CollectorMarker *)self);
 101                 IoObject_free(self);
 102         }
 103 }
 104
 105 IOINLINE IoObject *IoObject_addingRef_(IoObject *self, IoObject *ref)
 106 {
 107         #ifdef IO_BLOCK_LOCALS_RECYCLING
 108         //printf("IoObject_addingRef_\n");
 109         if(IoObject_isLocals(self))
 110         {
 111                 //printf("IoObject_isReferenced_\n");
 112                 IoObject_isReferenced_(ref, 1);
 113         }
 114         #endif
 115
 116         Collector_value_addingRefTo_(IOCOLLECTOR, self, ref);
 117         //IoObject_isDirty_(self, 1);
 118
 119         return ref;
 120 }
 121
 122 IOINLINE void IoObject_inlineSetSlot_to_(IoObject *self,
 123                                                                                  IoSymbol *slotName,
 124                                                                                  IoObject *value)
 125 {
 126         IoObject_createSlotsIfNeeded(self);
 127         /*
 128         if (!slotName->isSymbol)
 129         {
 130                 printf("Io System Error: setSlot slotName not symbol\n");
 131                 exit(1);
 132         }
 133         */
 134
 135         PHash_at_put_(IoObject_slots(self), IOREF(slotName), IOREF(value));
 136
 137         /*
 138         if(PHash_at_put_(IoObject_slots(self), IOREF(slotName), IOREF(value)))
 139         {
 140                 IoObject_isDirty_(self, 1);
 141         }
 142         */
 143 }
 144
 145 IOINLINE IoObject *IoObject_rawGetSlot_context_(IoObject *self,
 146                                                                                                 IoSymbol *slotName,
 147                                                                                                 IoObject **context)
 148 {
 149         register IoObject *v = (IoObject *)NULL;
 150
 151         if (IoObject_ownsSlots(self))
 152         {
 153                 v = (IoObject *)PHash_at_(IoObject_slots(self), slotName);
 154
 155                 if (v)
 156                 {
 157                         *context = self;
 158                         return v;
 159                 }
 160         }
 161
 162         IoObject_hasDoneLookup_(self, 1);
 163
 164         {
 165                 register IoObject **protos = IoObject_protos(self);
 166
 167                 for (; *protos; protos ++)
 168                 {
 169                         if (IoObject_hasDoneLookup((*protos)))
 170                         {
 171                                 continue;
 172                         }
 173
 174                         v = IoObject_rawGetSlot_context_(*protos, slotName, context);
 175
 176                         if (v)
 177                         {
 178                                 break;
 179                         }
 180                 }
 181         }
 182
 183         IoObject_hasDoneLookup_(self, 0);
 184
 185         return v;
 186 }
 187
 188 IOINLINE IoObject *IoObject_rawGetSlot_(IoObject *self, IoSymbol *slotName)
 189 {
 190         register IoObject *v = (IoObject *)NULL;
 191
 192         if (IoObject_ownsSlots(self))
 193         {
 194                 v = (IoObject *)PHash_at_(IoObject_slots(self), slotName);
 195
 196                 if (v) return v;
 197         }
 198
 199         IoObject_hasDoneLookup_(self, 1);
 200
 201         {
 202                 register IoObject **protos = IoObject_protos(self);
 203
 204                 for (; *protos; protos ++)
 205                 {
 206                         if (IoObject_hasDoneLookup((*protos)))
 207                         {
 208                                 continue;
 209                         }
 210
 211                         v = IoObject_rawGetSlot_(*protos, slotName);
 212
 213                         if (v) break;
 214                 }
 215         }
 216
 217         IoObject_hasDoneLookup_(self, 0);
 218
 219         return v;
 220 }
 221
 222 IOINLINE int IoObject_mark(IoObject *self)
 223 {
 224         /*
 225         if (IoObject_isLocals(self))
 226         {
 227                 printf("mark %p locals\n", (void *)self);
 228         }
 229         else
 230         {
 231                 printf("mark %p %s\n", (void *)self, IoObject_name(self));
 232         }
 233         */
 234
 235         if (IoObject_ownsSlots(self))
 236         {
 237                 PHASH_FOREACH(IoObject_slots(self), k, v,
 238                         IoObject_shouldMark((IoObject *)k);
 239                         IoObject_shouldMark((IoObject *)v);
 240                 );
 241         }
 242
 243         // mark protos
 244
 245         IOOBJECT_FOREACHPROTO(self, proto, IoObject_shouldMark(proto));
 246
 247         {
 248                 IoTagMarkFunc *func = IoTag_markFunc(IoObject_tag(self));
 249
 250                 if (func)
 251                 {
 252                         (func)(self);
 253                 }
 254         }
 255
 256         return 1;
 257 }
 258
 259 IoObject *IoObject_addingRef_(IoObject *self, IoObject *ref);
 260 IOVM_API int IoObject_hasCloneFunc_(IoObject *self, IoTagCloneFunc *func);
 261
 262 IOINLINE IoObject *IoObject_activate(IoObject *self,
 263                                                                          IoObject *target,
 264                                                                          IoObject *locals,
 265                                                                          IoMessage *m,
 266                                                                          IoObject *slotContext)
 267 {
 268         //TagActivateFunc *act = IoObject_tag(self)->activateFunc;
 269         //return act ? (IoObject *)((*act)(self, target, locals, m, slotContext)) : self;
 270         //printf("activate %s %i\n", IoObject_tag(self)->name, IoObject_isActivatable(self));
 271
 272         return IoObject_isActivatable(self) ? (IoObject *)((IoObject_tag(self)->activateFunc)(self, target, locals, m, slotContext)) : self;
 273         //return IoObject_tag(self)->activateFunc ? (IoObject *)((IoObject_tag(self)->activateFunc)(self, target, locals, m, slotContext)) : self;
 274 }
 275
 276 IOINLINE IoObject *IoObject_forward(IoObject *self, IoObject *locals, IoMessage *m)
 277 {
 278         IoState *state = IOSTATE;
 279         IoObject *context;
 280         IoObject *forwardSlot = IoObject_rawGetSlot_context_(self, state->forwardSymbol, &context);
 281
 282         /*
 283         if (Coro_stackSpaceAlmostGone((Coro*)IoCoroutine_cid(state->currentCoroutine)))
 284         {
 285
 286                 IoState_error_(IOSTATE, m, "stack overflow in forward while sending '%s' message to a '%s' object",
 287                                         CSTRING(IoMessage_name(m)), IoObject_name(self));
 288         }
 289         */
 290
 291         if (forwardSlot)
 292         {
 293                 return IoObject_activate(forwardSlot, self, locals, m, context);
 294         }
 295
 296         IoState_error_(state, m, "'%s' does not respond to message '%s'",
 297                                 IoObject_name(self), CSTRING(IoMessage_name(m)));
 298         return self;
 299 }
 300
 301 IOINLINE IoObject *IoObject_perform(IoObject *self, IoObject *locals, IoMessage *m)
 302 {
 303         IoObject *context;
 304         IoObject *slotValue = IoObject_rawGetSlot_context_(self, IoMessage_name(m), &context);
 305
 306         // note: coro chaining was moved to IoBlock.c
 307
 308         if (slotValue)
 309         {
 310                 return IoObject_activate(slotValue, self, locals, m, context);
 311         }
 312
 313         if (IoObject_isLocals(self))
 314         {
 315                 return IoObject_localsForward(self, locals, m);
 316         }
 317
 318         return IoObject_forward(self, locals, m);
 319 }
 320
 321 #undef IO_IN_C_FILE
 322 #endif