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"));
}
