libs/iovm/source/IoState_inline.h

   1
   2 //metadoc State copyright Steve Dekorte 2002
   3 //metadoc State license BSD revised
   4
   5 #ifdef IOSTATE_C
   6 #define IO_IN_C_FILE
   7 #endif
   8 #include "Common_inline.h"
   9 #ifdef IO_DECLARE_INLINES
  10
  11 // booleans --------------------------------------------------------
  12
  13 #define SIOSYMBOL(stringConstant) IoState_symbolWithCString_(self, stringConstant)
  14
  15 #define IOASSERT(value, message) \
  16 if (!(value)) { IoState_error_(IOSTATE, m, "Io Assertion '%s'", message); }
  17
  18 #define IOCOLLECTOR (IOSTATE->collector)
  19
  20 #define IONIL(self) (IOSTATE->ioNil)
  21 #define ISNIL(self) (self == IOSTATE->ioNil)
  22
  23 // booleans --------------------------------------------------------
  24
  25 #define ISBOOL(self) (((self)==IOSTATE->ioFalse) \
  26                                    || ((self)==IOSTATE->ioNil)   \
  27                                    || ((self)==IOSTATE->ioTrue))
  28
  29 #define IOSUCCESS(self) IOTRUE(self)
  30 #define ISSUCCESS(self) ISTRUE(self)
  31
  32 #define IOFAILURE(self) IOFALSE(self)
  33 #define ISFAILURE(self) ISFALSE(self)
  34
  35 //inline IoObject *IOBOOL(IoObject *self, int b);
  36
  37 #if !defined(IoObjectDataDefined)
  38 typedef struct IoObjectData IoObjectData;
  39 #endif
  40
  41 IOINLINE IoObject *IOTRUE(IoObject *self)
  42 {
  43         return IOSTATE->ioTrue;
  44 }
  45
  46 IOINLINE int ISTRUE(IoObject *self)
  47 {
  48         return self != IOSTATE->ioNil && self != IOSTATE->ioFalse;
  49 }
  50
  51 IOINLINE IoObject *IOFALSE(IoObject *self)
  52 {
  53         return IOSTATE->ioFalse;
  54 }
  55
  56 IOINLINE int ISFALSE(IoObject *self)
  57 {
  58         return self == IOSTATE->ioNil || self == IOSTATE->ioFalse;
  59 }
  60
  61 IOINLINE IoObject *IOBOOL(IoObject *self, int b)
  62 {
  63         return b ? IOTRUE(self) : IOFALSE(self);
  64 }
  65
  66 // collector --------------------------------------------------------
  67
  68 IOINLINE IoObject *IoState_retain_(IoState *self, IoObject *v)
  69 {
  70         IoObject_isReferenced_(v, 1);
  71         Collector_retain_(self->collector, v);
  72         return v;
  73 }
  74
  75 IOINLINE void IoState_stopRetaining_(IoState *self, IoObject *v)
  76 {
  77         Collector_stopRetaining_(self->collector, v);
  78 }
  79
  80 IOINLINE void *IoState_unreferencedStackRetain_(IoState *self, IoObject *v)
  81 {
  82         if (self->currentCoroutine)
  83         {
  84                 Collector_value_addingRefTo_(self->collector, self->currentCoroutine, v);
  85         }
  86
  87         Stack_push_(self->currentIoStack, v);
  88         return v;
  89 }
  90
  91 IOINLINE void *IoState_stackRetain_(IoState *self, IoObject *v)
  92 {
  93         IoObject_isReferenced_(v, 1);
  94         IoState_unreferencedStackRetain_(self, v);
  95         return v;
  96 }
  97
  98 IOINLINE void IoState_addValue_(IoState *self, IoObject *v)
  99 {
 100         Collector_addValue_(self->collector, v);
 101         IoState_unreferencedStackRetain_(self, v);
 102 }
 103
 104 IOINLINE void IoState_addValueIfNecessary_(IoState *self, IoObject *v)
 105 {
 106         if (v->prev)
 107         {
 108                 Collector_addValue_(self->collector, v);
 109         }
 110         IoState_unreferencedStackRetain_(self, v);
 111 }
 112
 113 IOINLINE void IoState_pushCollectorPause(IoState *self)
 114 {
 115         Collector_pushPause(self->collector);
 116 }
 117
 118 IOINLINE void IoState_popCollectorPause(IoState *self)
 119 {
 120         Collector_popPause(self->collector);
 121 }
 122
 123 IOINLINE void IoState_clearRetainStack(IoState *self)
 124 {
 125         Stack_clear(((IoState *)self)->currentIoStack);
 126 }
 127
 128 IOINLINE uintptr_t IoState_pushRetainPool(void *self)
 129 {
 130         uintptr_t m = Stack_pushMarkPoint(((IoState *)self)->currentIoStack);
 131         return m;
 132 }
 133
 134 IOINLINE void IoState_clearTopPool(void *self)
 135 {
 136         Stack *stack = ((IoState *)self)->currentIoStack;
 137         //Stack_popMark(stack);
 138         //Stack_pushMark(stack);
 139         Stack_clearTop(stack);
 140 }
 141
 142 IOINLINE void IoState_popRetainPool(void *self)
 143 {
 144         Stack *stack = ((IoState *)self)->currentIoStack;
 145         Stack_popMark(stack);
 146 }
 147
 148 IOINLINE void IoState_popRetainPool_(void *self, uintptr_t mark)
 149 {
 150         Stack *stack = ((IoState *)self)->currentIoStack;
 151         Stack_popMarkPoint_(stack, mark);
 152 }
 153
 154 IOINLINE void IoState_popRetainPoolExceptFor_(void *state, void *obj)
 155 {
 156         IoState *self = (IoState *)state;
 157 #ifdef STACK_POP_CALLBACK
 158         IoObject_isReferenced_(((IoObject *)obj), 1);
 159 #endif
 160         IoState_popRetainPool(self);
 161         IoState_stackRetain_(self, (IoObject *)obj);
 162 }
 163
 164 // message args --------------------------------------------------------
 165
 166 #define IOMESSAGEDATA(self) ((IoMessageData *)IoObject_dataPointer(self))
 167
 168 IOINLINE IoObject *IoMessage_locals_quickValueArgAt_(IoMessage *self, IoObject *locals, int n)
 169 {
 170         IoMessage *m = (IoMessage *)List_at_(IOMESSAGEDATA(self)->args, n);
 171
 172         if (m)
 173         {
 174                 IoMessageData *md = IOMESSAGEDATA(m);
 175                 IoObject *v = md->cachedResult;
 176
 177                 if (v && !md->next)
 178                 {
 179                         return v;
 180                 }
 181
 182                 return IoMessage_locals_performOn_(m, locals, locals);
 183         }
 184
 185         return IOSTATE->ioNil;
 186 }
 187
 188 IOINLINE IoObject *IoMessage_locals_valueArgAt_(IoMessage *self, IoObject *locals, int n)
 189 {
 190         return IoMessage_locals_quickValueArgAt_(self, locals, n);
 191         /*
 192         List *args = IOMESSAGEDATA(self)->args;
 193         IoMessage *m = (IoMessage *)List_at_(args, n);
 194
 195         if (m)
 196         {
 197                 return IoMessage_locals_performOn_(m, locals, locals);
 198         }
 199
 200         return IOSTATE->ioNil;
 201         */
 202 }
 203
 204 IOINLINE IoObject *IoMessage_locals_firstStringArg(IoMessage *self, IoObject *locals)
 205 {
 206         // special case this, since it's used for setSlot()
 207         List *args = IOMESSAGEDATA(self)->args;
 208
 209         if (List_size(args))
 210         {
 211                 IoMessage *m = (IoMessage *)List_rawAt_(args, 0);
 212
 213                 if (m)
 214                 {
 215                         IoMessageData *md = IOMESSAGEDATA(m);
 216                         IoObject *v = md->cachedResult;
 217
 218                         // avoid calling IoMessage_locals, if possible
 219
 220                         if (v && IoObject_isSymbol(v) && (md->next == NULL))
 221                         {
 222                                 return v;
 223                         }
 224                 }
 225         }
 226
 227         return IoMessage_locals_symbolArgAt_(self, locals, 0);
 228 }
 229
 230 // --------------------------
 231
 232 IOINLINE void IoState_break(IoState *self, IoObject *v)
 233 {
 234         self->stopStatus = MESSAGE_STOP_STATUS_BREAK;
 235         self->returnValue = v;
 236 }
 237
 238 IOINLINE void IoState_continue(IoState *self)
 239 {
 240         self->stopStatus = MESSAGE_STOP_STATUS_CONTINUE;
 241 }
 242
 243 IOINLINE void IoState_eol(IoState *self)
 244 {
 245         self->stopStatus = MESSAGE_STOP_STATUS_EOL;
 246 }
 247
 248 IOINLINE void IoState_return(IoState *self, IoObject *v)
 249 {
 250         self->stopStatus = MESSAGE_STOP_STATUS_RETURN;
 251         self->returnValue = v;
 252 }
 253
 254 IOINLINE void IoState_resetStopStatus(IoState *self)
 255 {
 256         self->stopStatus = MESSAGE_STOP_STATUS_NORMAL;
 257 }
 258
 259 IOINLINE int IoState_handleStatus(IoState *self)
 260 {
 261         switch (self->stopStatus)
 262         {
 263                 case MESSAGE_STOP_STATUS_RETURN:
 264                         return 1;
 265
 266                 case MESSAGE_STOP_STATUS_BREAK:
 267                         IoState_resetStopStatus(self);
 268                         return 1;
 269
 270                 case MESSAGE_STOP_STATUS_CONTINUE:
 271                         IoState_resetStopStatus(self);
 272                         return 0;
 273
 274                 default:
 275                         return 0;
 276         }
 277 }
 278
 279 IOINLINE IoObject* IoState_stopStatusObject(IoState *self, int stopStatus)
 280 {
 281         switch(stopStatus)
 282         {
 283                 case MESSAGE_STOP_STATUS_NORMAL:
 284                         return self->ioNormal;
 285
 286                 case MESSAGE_STOP_STATUS_BREAK:
 287                         return self->ioBreak;
 288
 289                 case MESSAGE_STOP_STATUS_CONTINUE:
 290                         return self->ioContinue;
 291
 292                 case MESSAGE_STOP_STATUS_RETURN:
 293                         return self->ioReturn;
 294
 295                 case MESSAGE_STOP_STATUS_EOL:
 296                         return self->ioEol;
 297
 298                 default:
 299                         return self->ioNormal;
 300         }
 301 }
 302
 303 IOINLINE int IoState_stopStatusNumber(IoState *self, IoObject *obj)
 304 {
 305         if (obj == self->ioNormal)
 306                 return MESSAGE_STOP_STATUS_NORMAL;
 307
 308         if (obj == self->ioBreak)
 309                 return MESSAGE_STOP_STATUS_BREAK;
 310
 311         if (obj == self->ioContinue)
 312                 return MESSAGE_STOP_STATUS_CONTINUE;
 313
 314         if (obj == self->ioReturn)
 315                 return MESSAGE_STOP_STATUS_RETURN;
 316
 317         if (obj == self->ioEol)
 318                 return MESSAGE_STOP_STATUS_EOL;
 319
 320         return MESSAGE_STOP_STATUS_NORMAL;
 321 }
 322
 323
 324 #undef IO_IN_C_FILE
 325 #endif
 326