IoObject *IoState_on_doCString_withLabel_(IoState *self,
IoObject *target,
const char *s,
const char *label)
{
IoObject *result;
IoState_pushRetainPool(self);
{
IoMessage *m = IoMessage_newWithName_andCachedArg_(self, SIOSYMBOL("doString"), SIOSYMBOL(s));
if (label)
{
IoMessage_addCachedArg_(m, SIOSYMBOL(label));
}
IoState_zeroSandboxCounts(self);
result = IoState_tryToPerform(self, target, target, m);
}
IoState_popRetainPoolExceptFor_(self, result);
return result;
}
void IoThreadInit(IoObject *context)
{
IoState *self = IoObject_state((IoObject *)context);
IoObject_setSlot_to_(context, SIOSYMBOL("Thread"), IoThread_proto(self));
}
void IoVolcanoInit(IoObject *context)
{
IoState *self = IoObject_state((IoObject *)context);
IoObject_setSlot_to_(context, SIOSYMBOL("HttpParser"), IoHttpParser_proto(self));
}
void IoSystemCallInit(IoObject *context)
{
IoState *self = IoObject_state((IoObject *)context);
IoObject_setSlot_to_(context, SIOSYMBOL("SystemCall"), IoSystemCall_proto(self));
}
void IoUserInit(IoObject *context)
{
IoState *self = IoObject_state((IoObject *)context);
IoObject_setSlot_to_(context, SIOSYMBOL("User"), IoUser_proto(self));
}
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_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_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"));
}
IoObject *IoState_doFile_(IoState *self, const char *path)
{
IoMessage *m = IoMessage_newWithName_andCachedArg_(self, SIOSYMBOL("doFile"), SIOSYMBOL(path));
return IoState_tryToPerform(self, self->lobby, self->lobby, m);
}
IoObject *IoState_doSandboxCString_(IoState *self, const char *s)
{
IoMessage *m = IoMessage_newWithName_andCachedArg_(self, SIOSYMBOL("doString"), SIOSYMBOL(s));
IoState_resetSandboxCounts(self);
return IoState_tryToPerform(self, self->lobby, self->lobby, m);
}
