libs/iovm/source/IoState_inline.h

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