libs/iovm/source/IoObject_inline.h

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