IoObject *IoObject_addTaglessMethod_(IoObject *self, IoSymbol *slotName, IoMethodFunc *fp)
{
IoCFunction *f;
f = IoCFunction_newWithFunctionPointer_tag_name_(IOSTATE, (IoUserFunction *)fp, NULL, CSTRING(slotName));
IoObject_setSlot_to_(self, slotName, f);
return f;
}
IoObject *IoObject_addMethod_(IoObject *self, IoSymbol *slotName, IoMethodFunc *fp)
{
IoTag *t = IoObject_tag(self);
IoObject *proto = IoState_protoWithInitFunction_(IOSTATE, IoObject_proto);
IoCFunction *f;
f = IoCFunction_newWithFunctionPointer_tag_name_(IOSTATE, (IoUserFunction *)fp, t, CSTRING(slotName));
IoObject_setSlot_to_(self, slotName, f);
return f;
}
IoObject *IoLinker_makeCFunction(IoLinker *self, IoObject *locals, IoMessage *m)
{
/*doc Linker makeCFunction(aSeq, slotName, object)
Creates a CFunction which users the beginning address of the data in aSeq as its function pointer and
adds the CFunction to the given object on slot slotName.
*/
IoSeq *buffer = IoMessage_locals_seqArgAt_(m, locals, 0);
IoSeq *slotName = IoMessage_locals_seqArgAt_(m, locals, 1);
IoObject *object = IoMessage_locals_valueArgAt_(m, locals, 2);
IoCFunction *f;
IoUserFunction* fp = (IoUserFunction*)IoSeq_rawBytes(buffer);
f = IoCFunction_newWithFunctionPointer_tag_name_(IOSTATE, fp, IoObject_tag(object), CSTRING(slotName));
IoObject_setSlot_to_(f, IOSYMBOL("compiledCode"), buffer);
return f;
}
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);
}
}
