IoMessage *IoMessage_newWithName_returnsValue_(void *state, IoSymbol *symbol, IoObject *v)
{
IoMessage *self = IoMessage_new(state);
IoMessage_rawSetName_(self, symbol);
IoMessage_rawSetCachedResult_(self, v);
return self;
}
void IoMessage_setCachedArg_to_(IoMessage *self, int n, IoObject *v)
{
IoMessage *arg;
while (!(arg = List_at_(DATA(self)->args, n)))
{
IoMessage_addArg_(self, IoMessage_new(IOSTATE));
}
IoMessage_rawSetCachedResult_(arg, v);
}
void IoMessage_setCachedArg_toInt_(IoMessage *self, int n, int anInt)
{
// optimized to avoid creating a number unless necessary
IoMessage *arg = NULL;
while (!(arg = List_at_(DATA(self)->args, n)))
{
List_append_(DATA(self)->args, IOREF(IoMessage_new(IOSTATE)));
}
IoMessage_rawSetCachedResult_(arg, IONUMBER(anInt));
}
void IoMessage_copy_(IoMessage *self, IoMessage *other)
{
IoMessage_rawSetName_(self, DATA(other)->name);
{
List *l1 = DATA(self)->args;
List *l2 = DATA(other)->args;
size_t i, max = List_size(l2);
List_removeAll(l1);
for (i = 0; i < max; i ++)
{
List_append_(l1, IOREF(List_rawAt_(l2, i)));
}
}
IoMessage_rawSetNext_(self, DATA(other)->next);
IoMessage_rawSetCachedResult_(self, DATA(other)->cachedResult);
IoMessage_rawCopySourceLocation(self, other);
}
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_rawSetCachedResult_(self, r);
}
IoMessage *IoMessage_deepCopyOf_(IoMessage *self)
{
IoMessage *child = IoMessage_new(IOSTATE);
int i;
/*printf("deep copying: %s\n", UArray_asCString(IoMessage_description(self)));*/
for (i = 0; i < IoMessage_argCount(self); i ++)
{
List_append_(DATA(child)->args,
IOREF(IoMessage_deepCopyOf_(LIST_AT_(DATA(self)->args, i))));
}
IoMessage_rawSetName_(child, DATA(self)->name);
IoMessage_rawSetCachedResult_(child, (IoObject *)DATA(self)->cachedResult);
if (DATA(self)->next)
{
IoMessage_rawSetNext_(child, IoMessage_deepCopyOf_(DATA(self)->next));
}
/*printf("deep copy result: %s\n", UArray_asCString(IoMessage_description(child)));*/
return child;
}
void IoMessage_addCachedArg_(IoMessage *self, IoObject *v)
{
IoMessage *m = IoMessage_new(IOSTATE);
IoMessage_rawSetCachedResult_(m, v);
IoMessage_addArg_(self, m);
}
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);
return;
}
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);
return;
}
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);
return;
}
{
// 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_rawSetCachedResult_(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 Cs 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 its 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);
}
}
