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 IoMessage_ifPossibleCacheToken_(IoMessage *self, IoToken *p)
{
IoSymbol *method = DATA(self)->name;
IoObject *r = NULL;
switch ((int)IoToken_type(p))
{
case TRIQUOTE_TOKEN:
r = IoSeq_rawAsUntriquotedSymbol(method);
break;
case MONOQUOTE_TOKEN:
r = IoSeq_rawAsUnescapedSymbol(IoSeq_rawAsUnquotedSymbol(method));
break;
case NUMBER_TOKEN:
r = IONUMBER(IoSeq_asDouble(method));
break;
case HEXNUMBER_TOKEN:
r = IONUMBER(IoSeq_rawAsDoubleFromHex(method));
break;
default:
if (IoSeq_rawEqualsCString_(method, "nil"))
{
r = IONIL(self);
}
else if (IoSeq_rawEqualsCString_(method, "true"))
{
r = IOTRUE(self);
}
else if (IoSeq_rawEqualsCString_(method, "false"))
{
r = IOFALSE(self);
}
}
IoMessage_cachedResult_(self, r);
}
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 Levels_attach(Levels *self, IoMessage *msg, List *expressions)
{
// TODO clean up this method.
IoState *state = IoObject_state(msg);
IoSymbol *messageSymbol = IoMessage_name(msg);
char *messageName = CSTRING(messageSymbol);
int precedence = Levels_levelForOp(self, messageName, messageSymbol, msg);
int msgArgCount = IoMessage_argCount(msg);
// `o a := b c ; d` becomes `o setSlot("a", b c) ; d`
//
// a attaching
// := msg
// b c msg->next
if (Levels_isAssignOperator(self, messageSymbol))
{
Level *currentLevel = Levels_currentLevel(self);
IoMessage *attaching = currentLevel->message;
IoSymbol *setSlotName;
if (attaching == NULL) // `:= b ;`
{
// Could be handled as, message(:= 42) -> setSlot(nil, 42)
IoState_error_(state, msg, "compile error: %s requires a symbol to its left.", messageName);
}
if (IoMessage_argCount(attaching) > 0) // `a(1,2,3) := b ;`
{
IoState_error_(state, msg, "compile error: The symbol to the left of %s cannot have arguments.", messageName);
}
if (msgArgCount > 1) // `setSlot("a") :=(b, c, d) e ;`
{
IoState_error_(state, msg, "compile error: Assign operator passed multiple arguments, e.g., a := (b, c).", messageName);
}
{
// `a := b ;`
IoSymbol *slotName = DATA(attaching)->name;
IoSymbol *quotedSlotName = IoSeq_newSymbolWithFormat_(state, "\"%s\"", CSTRING(slotName));
IoMessage *slotNameMessage = IoMessage_newWithName_returnsValue_(state, quotedSlotName, slotName);
IoMessage_rawCopySourceLocation(slotNameMessage, attaching);
// `a := b ;` -> `a("a") := b ;`
IoMessage_addArg_(attaching, slotNameMessage);
setSlotName = Levels_nameForAssignOperator(self, state, messageSymbol, slotName, msg);
}
// `a("a") := b ;` -> `setSlot("a") := b ;`
DATA(attaching)->name = IoObject_addingRef_(attaching, setSlotName);
currentLevel->type = ATTACH;
if (msgArgCount > 0) // `setSlot("a") :=(b c) d e ;`
{
// `b c`
IoMessage *arg = IoMessage_rawArgAt_(msg, 0);
if (DATA(msg)->next == NULL || IoMessage_rawIsEOL(DATA(msg)->next))
{
IoMessage_addArg_(attaching, arg);
}
else
{
// `()`
IoMessage *foo = IoMessage_newWithName_(state, IoState_symbolWithCString_(state, ""));
IoMessage_rawCopySourceLocation(foo, attaching);
// `()` -> `(b c)`
IoMessage_addArg_(foo, arg);
// `(b c)` -> `(b c) d e ;`
IoMessage_rawSetNext(foo, DATA(msg)->next);
// `setSlot("a") :=(b c) d e ;` -> `setSlot("a", (b c) d e ;) :=(b c) d e ;`
IoMessage_addArg_(attaching, foo);
}
}
else // `setSlot("a") := b ;`
{
// `setSlot("a") :=` or `setSlot("a") := ;`
IoMessage *mn = DATA(msg)->next;
IoSymbol *name = mn ? DATA(mn)->name : NULL;
IoSymbol *semi = IoObject_state(msg)->semicolonSymbol;
//if (mn == NULL || IoMessage_rawIsEOL(mn))
if (mn == NULL || name == semi)
{
IoState_error_(state, msg, "compile error: %s must be followed by a value.", messageName);
}
// `setSlot("a") := b c ;` -> `setSlot("a", b c ;) := b c ;`
IoMessage_addArg_(attaching, DATA(msg)->next);
}
// process the value (`b c d`) later (`setSlot("a", b c d) := b c d ;`)
if (DATA(msg)->next != NULL && !IoMessage_rawIsEOL(DATA(msg)->next))
{
List_push_(expressions, DATA(msg)->next);
}
{
IoMessage *last = msg;
while (DATA(last)->next != NULL && !IoMessage_rawIsEOL(DATA(last)->next))
{
last = DATA(last)->next;
}
IoMessage_rawSetNext(attaching, DATA(last)->next);
// Continue processing in IoMessage_opShuffle loop
IoMessage_rawSetNext(msg, DATA(last)->next);
if (last != msg)
{
IoMessage_rawSetNext(last, NULL);
}
}
// make sure b in `1 := b` gets executed
IoMessage_cachedResult_(attaching, NULL);
}
else if (IoMessage_rawIsEOL(msg))
{
Levels_popDownTo(self, IO_OP_MAX_LEVEL-1);
Level_attachAndReplace(Levels_currentLevel(self), msg);
}
else if (precedence != -1) // is an operator
{
if (msgArgCount > 0)
{
// move arguments off to their own message to make () after operators behave like C's grouping ()
IoMessage *brackets = IoMessage_newWithName_(state, IoState_symbolWithCString_(state, ""));
IoMessage_rawCopySourceLocation(brackets, msg);
List_copy_(IoMessage_rawArgList(brackets), IoMessage_rawArgList(msg));
List_removeAll(IoMessage_rawArgList(msg));
// Insert the brackets message between msg and it's next message
IoMessage_rawSetNext(brackets, DATA(msg)->next);
IoMessage_rawSetNext(msg, brackets);
}
Levels_popDownTo(self, precedence);
Levels_attachToTopAndPush(self, msg, precedence);
}
else
{
Level_attachAndReplace(Levels_currentLevel(self), msg);
}
}
