IoDrawStuff *IoDrawStuff_proto(void *state) { IoObject *self = IoObject_new(state); proto = self; IoObject_tag_(self, IoDrawStuff_newTag(state)); IoObject_setDataPointer_(self, calloc(1, sizeof(IoDrawStuffData))); DATA(self)->coroutine = IoCoroutine_new(state); //printf("DrawStuff coro = %p\n", DATA(self)->coroutine); DATA(self)->eventTarget = NULL; DATA(self)->keyboardMessage = DRAWMESSAGE("keyboard"); DATA(self)->startMessage = DRAWMESSAGE("start"); DATA(self)->stepMessage = DRAWMESSAGE("step"); DATA(self)->stopMessage = DRAWMESSAGE("stop"); IoState_retain_(state, DATA(self)->coroutine); IoState_retain_(state, DATA(self)->keyboardMessage); IoState_retain_(state, DATA(self)->startMessage); IoState_retain_(state, DATA(self)->stepMessage); IoState_retain_(state, DATA(self)->stopMessage); IoState_registerProtoWithId_(state, self, protoId); { IoMethodTable methodTable[] = { {"dsSimulationLoop", IoDrawStuff_dsSimulationLoop}, {"dsSetViewpoint", IoDrawStuff_dsSetViewpoint}, {"dsGetViewpoint", IoDrawStuff_dsGetViewpoint}, {"dsElapsedTime", IoDrawStuff_dsElapsedTime}, {"dsStop", IoDrawStuff_dsStop}, {"dsSetTexture", IoDrawStuff_dsSetTexture}, {"dsSetColor", IoDrawStuff_dsSetColor}, {"dsSetColorAlpha", IoDrawStuff_dsSetColorAlpha}, {"dsDrawBox", IoDrawStuff_dsDrawBox}, {"dsDrawSphere", IoDrawStuff_dsDrawSphere}, {"dsDrawTriangle", IoDrawStuff_dsDrawTriangle}, {"dsDrawCylinder", IoDrawStuff_dsDrawCylinder}, {"dsDrawCapsule", IoDrawStuff_dsDrawCapsule}, {"dsDrawLine", IoDrawStuff_dsDrawLine}, {"dsDrawConvex", IoDrawStuff_dsDrawConvex}, {"dsSetSphereQuality", IoDrawStuff_dsSetSphereQuality}, {"dsSetCapsuleQuality", IoDrawStuff_dsSetCapsuleQuality}, {"dsSetDrawMode", IoDrawStuff_dsSetDrawMode}, {"eventTarget", IoDrawStuff_eventTarget}, {NULL, NULL}, }; IoObject_addMethodTable_(self, methodTable); } //IoDrawStuff_protoInit(self); return self; }
void IoState_setupSingletons(IoState *self) { IoObject *core = self->core; // nil self->ioNil = IOCLONE(self->objectProto); IoObject_setSlot_to_(core, SIOSYMBOL("nil"), self->ioNil); //IoObject_setSlot_to_(core, self->noShufflingSymbol, self->ioNil); IoObject_setSlot_to_(core, SIOSYMBOL("Message"), IoMessage_proto(self)); IoObject_setSlot_to_(core, SIOSYMBOL("Call"), IoCall_proto(self)); self->nilMessage = IoMessage_newWithName_(self, SIOSYMBOL("nil")); IoMessage_cachedResult_(self->nilMessage, self->ioNil); IoState_retain_(self, self->nilMessage); // true self->ioTrue = IoObject_new(self); IoObject_setSlot_to_(core, SIOSYMBOL("true"), self->ioTrue); IoObject_setSlot_to_(self->ioTrue, SIOSYMBOL("type"), SIOSYMBOL("true")); IoState_retain_(self, self->ioTrue); // false self->ioFalse = IoObject_new(self); IoObject_setSlot_to_(core, SIOSYMBOL("false"), self->ioFalse); IoObject_setSlot_to_(self->ioFalse, SIOSYMBOL("type"), SIOSYMBOL("false")); IoState_retain_(self, self->ioFalse); // Flow control: Normal self->ioNormal = IoObject_new(self); IoObject_setSlot_to_(core, SIOSYMBOL("Normal"), self->ioNormal); IoObject_setSlot_to_(self->ioNormal, SIOSYMBOL("type"), SIOSYMBOL("Normal")); IoState_retain_(self, self->ioNormal); // Flow control: Break self->ioBreak = IoObject_new(self); IoObject_setSlot_to_(core, SIOSYMBOL("Break"), self->ioBreak); IoObject_setSlot_to_(self->ioBreak, SIOSYMBOL("type"), SIOSYMBOL("Break")); IoState_retain_(self, self->ioBreak); // Flow control: Continue self->ioContinue = IoObject_new(self); IoObject_setSlot_to_(core, SIOSYMBOL("Continue"), self->ioContinue); IoObject_setSlot_to_(self->ioContinue, SIOSYMBOL("type"), SIOSYMBOL("Continue")); IoState_retain_(self, self->ioContinue); // Flow control: Return self->ioReturn = IoObject_new(self); IoObject_setSlot_to_(core, SIOSYMBOL("Return"), self->ioReturn); IoObject_setSlot_to_(self->ioReturn, SIOSYMBOL("type"), SIOSYMBOL("Return")); IoState_retain_(self, self->ioReturn); // Flow control: Eol self->ioEol = IoObject_new(self); IoObject_setSlot_to_(core, SIOSYMBOL("Eol"), self->ioEol); IoObject_setSlot_to_(self->ioEol, SIOSYMBOL("type"), SIOSYMBOL("Eol")); IoState_retain_(self, self->ioEol); }
void IoState_registerProtoWithFunc_(IoState *self, IoObject *proto, IoStateProtoFunc *func) { if (PHash_at_(self->primitives, (void *)func)) { IoState_fatalError_(self, "IoState_registerProtoWithFunc_() Error: attempt to add the same proto twice"); } IoState_retain_(self, proto); PHash_at_put_(self->primitives, (void *)func, proto); //printf("registered %s\n", IoObject_name(proto)); }
void IoState_setupCachedNumbers(IoState *self) { int i; self->cachedNumbers = List_new(); for (i = MIN_CACHED_NUMBER; i < MAX_CACHED_NUMBER + 1; i ++) { IoNumber *number = IoNumber_newWithDouble_(self, i); List_append_(self->cachedNumbers, number); IoState_retain_(self, number); } }
void IoState_new_atAddress(void *address) { IoState *self = (IoState *)address; IoCFunction *cFunctionProto; IoSeq *seqProto; // collector self->collector = Collector_new(); IoState_pushCollectorPause(self); Collector_setMarkFunc_(self->collector, (CollectorMarkFunc *)IoObject_mark); Collector_setWillFreeFunc_(self->collector, (CollectorWillFreeFunc *)IoObject_willFree); Collector_setFreeFunc_(self->collector, (CollectorFreeFunc *)IoObject_free); self->mainArgs = MainArgs_new(); self->primitives = PHash_new(); self->recycledObjects = List_new(); self->maxRecycledObjects = IOSTATE_DEFAULT_MAX_RECYCLED_OBJECTS; // Sandbox self->messageCount = 0; self->messageCountLimit = 0; self->endTime = 0; // symbol table self->symbols = SHash_new(); SHash_setKeysEqualCallback(self->symbols, (SHashKeysEqualCallback *)UArray_equalsWithHashCheck_); SHash_setHashForKeyCallback(self->symbols, (SHashHashforKeyCallback *)UArray_hash); /* Problem: - there are some interdependencies here: - creating instances requires a retain stack - we need a Coroutine to use for our retainStack - defining any primitive methods requires Strings and CFunctions Solution: - create a temporary fake stack - create Object, CFunction and String protos sans methods. - then add methods to Object, CFunction and String */ self->currentIoStack = Stack_new(); // temp retain stack until coro is up self->objectProto = IoObject_proto(self); // need to do this first, so we have a retain stack //IoState_retain_(self, self->objectProto); self->mainCoroutine = IoCoroutine_proto(self); Stack_free(self->currentIoStack); self->currentIoStack = NULL; IoState_setCurrentCoroutine_(self, self->mainCoroutine); seqProto = IoSeq_proto(self); IoState_setupQuickAccessSymbols(self); IoObject_rawSetProto_(seqProto, self->objectProto); cFunctionProto = IoCFunction_proto(self); self->localsUpdateSlotCFunc = IoState_retain_(self, IoCFunction_newWithFunctionPointer_tag_name_(self, IoObject_localsUpdateSlot, NULL, "localsUpdate")); IoSeq_protoFinish(seqProto); IoObject_protoFinish(self); IoCFunction_protoFinish(self); IoCoroutine_protoFinish(self->mainCoroutine); self->setSlotBlock = IoState_retain_(self, IoObject_getSlot_(self->objectProto, SIOSYMBOL("setSlot"))); // setup lobby { IoObject *objectProto = self->objectProto; IoObject *protos = IOCLONE(objectProto); IoObject *core = IOCLONE(objectProto); self->core = core; self->lobby = IOCLONE(objectProto); IoState_retain_(self, self->lobby); IoState_retain_(self, self->core); // setup namespace IoObject_setSlot_to_(self->lobby, SIOSYMBOL("Lobby"), self->lobby); IoObject_setSlot_to_(self->lobby, SIOSYMBOL("Protos"), protos); IoObject_setSlot_to_(protos, SIOSYMBOL("Core"), core); IoObject_setSlot_to_(protos, SIOSYMBOL("Addons"), IOCLONE(objectProto)); IoObject_setSlot_to_(core, SIOSYMBOL("Compiler"), IoCompiler_proto(self)); IoObject_setSlot_to_(core, SIOSYMBOL("Collector"), IoCollector_proto(self)); IoObject_setSlot_to_(core, SIOSYMBOL("Exception"), IOCLONE(objectProto)); // setup proto chain IoObject_rawSetProto_(objectProto, self->lobby); IoObject_rawSetProto_(self->lobby, protos); IoObject_rawSetProto_(protos, core); // add protos to namespace IoObject_setSlot_to_(core, SIOSYMBOL("Object"), objectProto); IoObject_setSlot_to_(core, SIOSYMBOL("Sequence"), seqProto); IoObject_setSlot_to_(core, SIOSYMBOL("Number"), IoNumber_proto(self)); IoState_setupCachedNumbers(self); { IoObject *systemProto = IoSystem_proto(self); IoObject_setSlot_to_(core, SIOSYMBOL("System"), systemProto); } IoState_setupSingletons(self); IoState_setupCachedMessages(self); { self->debugger = IoState_retain_(self, IoDebugger_proto(self)); IoObject_setSlot_to_(core, SIOSYMBOL("Debugger"), self->debugger); self->vmWillSendMessage = IoMessage_newWithName_(self, SIOSYMBOL("vmWillSendMessage")); IoMessage_cachedResult_(self->nilMessage, self->ioNil); IoState_retain_(self, self->vmWillSendMessage); } IoObject_setSlot_to_(core, SIOSYMBOL("Block"), IoBlock_proto(self)); IoObject_setSlot_to_(core, SIOSYMBOL("List"), IoList_proto(self)); IoObject_setSlot_to_(core, SIOSYMBOL("Map"), IoMap_proto(self)); //IoObject_setSlot_to_(core, SIOSYMBOL("Range"), IoRange_proto(self)); IoObject_setSlot_to_(core, SIOSYMBOL("Coroutine"), self->mainCoroutine); IoObject_setSlot_to_(core, SIOSYMBOL("Error"), IoError_proto(self)); IoObject_setSlot_to_(core, SIOSYMBOL("File"), IoFile_proto(self)); IoObject_setSlot_to_(core, SIOSYMBOL("Directory"), IoDirectory_proto(self)); IoObject_setSlot_to_(core, SIOSYMBOL("Date"), IoDate_proto(self)); IoObject_setSlot_to_(core, SIOSYMBOL("Duration"), IoDuration_proto(self)); IoObject_setSlot_to_(core, SIOSYMBOL("WeakLink"), IoWeakLink_proto(self)); IoObject_setSlot_to_(core, SIOSYMBOL("Sandbox"), IoSandbox_proto(self)); //IoObject_setSlot_to_(core, SIOSYMBOL("EditLine"), IoEditLine_proto(self)); #if !defined(__SYMBIAN32__) IoObject_setSlot_to_(core, SIOSYMBOL("DynLib"), IoDynLib_proto(self)); #endif //self->store = //IoObject_setSlot_to_(core, SIOSYMBOL("Store"), self->store); IoObject_setSlot_to_(core, SIOSYMBOL("CFunction"), cFunctionProto); self->localsProto = IoState_retain_(self, IoObject_localsProto(self)); IoObject_setSlot_to_(core, SIOSYMBOL("Locals"), self->localsProto); self->stopStatus = MESSAGE_STOP_STATUS_NORMAL; self->returnValue = self->ioNil; IoState_clearRetainStack(self); IoState_popCollectorPause(self); //Collector_collect(self->collector); //io_show_mem("before IoVMCodeInit"); IoVMCodeInit(core); //io_show_mem("after IoVMCodeInit"); //Collector_collect(self->collector); //io_show_mem("after Collector_collect"); // IoState_popCollectorPause(self); IoState_clearRetainStack(self); Collector_collect(self->collector); //io_show_mem("after IoState_clearRetainStack and Collector_collect"); IoState_setupUserInterruptHandler(self); } }
void IoState_setupCachedMessages(IoState *self) { self->asStringMessage = IoMessage_newWithName_(self, SIOSYMBOL("asString")); IoState_retain_(self, self->asStringMessage); self->collectedLinkMessage = IoMessage_newWithName_(self, SIOSYMBOL("collectedLink")); IoState_retain_(self, self->collectedLinkMessage); self->compareMessage = IoMessage_newWithName_(self, SIOSYMBOL("compare")); IoState_retain_(self, self->compareMessage); //self->doStringMessage = IoMessage_newWithName_(self, SIOSYMBOL("doString")); //IoState_retain_(self, self->doStringMessage); self->initMessage = IoMessage_newWithName_(self, SIOSYMBOL("init")); IoState_retain_(self, self->initMessage); self->mainMessage = IoMessage_newWithName_(self, SIOSYMBOL("main")); IoState_retain_(self, self->mainMessage); self->opShuffleMessage = IoMessage_newWithName_(self, self->opShuffleSymbol); IoState_retain_(self, self->opShuffleMessage); self->printMessage = IoMessage_newWithName_(self, SIOSYMBOL("print")); IoState_retain_(self, self->printMessage); self->referenceIdForObjectMessage = IoMessage_newWithName_(self, SIOSYMBOL("referenceIdForObject")); IoState_retain_(self, self->referenceIdForObjectMessage); self->objectForReferenceIdMessage = IoMessage_newWithName_(self, SIOSYMBOL("objectForReferenceId")); IoState_retain_(self, self->objectForReferenceIdMessage); self->runMessage = IoMessage_newWithName_(self, SIOSYMBOL("run")); IoState_retain_(self, self->runMessage); self->willFreeMessage = IoMessage_newWithName_(self, SIOSYMBOL("willFree")); IoState_retain_(self, self->willFreeMessage); self->yieldMessage = IoMessage_newWithName_(self, SIOSYMBOL("yield")); IoState_retain_(self, self->yieldMessage); }
void IoState_setupQuickAccessSymbols(IoState *self) { self->activateSymbol = IoState_retain_(self, SIOSYMBOL("activate")); self->callSymbol = IoState_retain_(self, SIOSYMBOL("call")); self->forwardSymbol = IoState_retain_(self, SIOSYMBOL("forward")); self->noShufflingSymbol = IoState_retain_(self, SIOSYMBOL("__noShuffling__")); self->opShuffleSymbol = IoState_retain_(self, SIOSYMBOL("opShuffle")); //self->referenceIdSymbol = IoState_retain_(self, SIOSYMBOL("referenceId")); self->semicolonSymbol = IoState_retain_(self, SIOSYMBOL(";")); self->selfSymbol = IoState_retain_(self, SIOSYMBOL("self")); self->setSlotSymbol = IoState_retain_(self, SIOSYMBOL("setSlot")); self->setSlotWithTypeSymbol = IoState_retain_(self, SIOSYMBOL("setSlotWithType")); self->stackSizeSymbol = IoState_retain_(self, SIOSYMBOL("stackSize")); self->typeSymbol = IoState_retain_(self, SIOSYMBOL("type")); self->updateSlotSymbol = IoState_retain_(self, SIOSYMBOL("updateSlot")); }