int Levels_levelForOp(Levels *self, char *messageName, IoSymbol *messageSymbol, IoMessage *msg)
{
IoObject *value = IoMap_rawAt(self->operatorTable, messageSymbol);
if (!value)
{
return -1;
}
if (ISNUMBER(value))
{
int precedence = IoNumber_asInt((IoNumber*)value);
if (precedence < 0 || precedence >= IO_OP_MAX_LEVEL)
{
IoState_error_(IoObject_state(msg), msg, "compile error: Precedence for operators must be between 0 and %d. Precedence was %d.", IO_OP_MAX_LEVEL - 1, precedence);
}
return precedence;
}
else
{
IoState_error_(IoObject_state(msg), msg, "compile error: Value for '%s' in Message OperatorTable operators is not a number. Values in the OperatorTable operators are numbers which indicate the precedence of the operator.", messageName);
return -1; // The C compiler does not know that IoState_error_() will never return.
}
}
IoObject *IoCInvokeStructureInstance_getValue(IoCInvokeStructureInstance *self, IoObject *locals, IoMessage *m) {
CInvContext* context = getGlobalContext();
CInvStructure* structure = IoCInvokeStructure_getStructure_(IoObject_getSlot_(self, IOSYMBOL("structure")));
if(!DATA(self)->instance) {
DATA(self)->instance = cinv_structure_create_instance(context, structure); // ... is that intelligent?
}
char* name = IoMessage_locals_cStringArgAt_(m, locals, 0);
void* value = cinv_structure_instance_getvalue(context, structure, DATA(self)->instance, name);
IoObject *memberType = IoMap_rawAt(IoObject_getSlot_(
IoObject_getSlot_(self, IOSYMBOL("structure")), IOSYMBOL("memberTypes")),
IOSYMBOL(name));
IoObject *io_value = IoCInvokeDataType_objectFromData_(memberType, value);
return io_value;
}
IoSymbol *Levels_nameForAssignOperator(Levels *self, IoState *state, IoSymbol *operator, IoSymbol *slotName, IoMessage *msg)
{
IoObject *value = IoMap_rawAt(self->assignOperatorTable, operator);
char *operatorString = CSTRING(operator);
if (value != NULL && ISSYMBOL(value))
{
if (strcmp(operatorString, ":=") == 0 && isupper(CSTRING(slotName)[0]))
{
return state->setSlotWithTypeSymbol;
}
else
{
return value;
}
}
else
{
IoState_error_(IoObject_state(msg), msg, "compile error: Value for '%s' in Message OperatorTable assignOperators is not a symbol. Values in the OperatorTable assignOperators are symbols which are the name of the operator.", operatorString);
return NULL; // To keep the compiler happy.
}
}
IoCFFIPointer *IoCFFIPointer_ToType_(IoObject *type)
{
IoObject *pointer, *self;
IoMap *pointers;
IoSymbol *key;
// this is a hack so macros relying on self will work
self = type;
pointers = IoObject_getSlot_(IoState_protoWithInitFunction_(IOSTATE, IoCFFIPointer_proto), IOSYMBOL("pointers"));
key = IoState_on_doCString_withLabel_(IOSTATE, type, "uniqueHexId", "IoCFFIPointer_ToType_");
pointer = IoMap_rawAt(pointers, key);
if (!pointer)
{
// create new pointer and add to cache
pointer = IoCFFIPointer_new(IOSTATE);
IoObject_setSlot_to_(pointer, IOSYMBOL("pointedToType"), type);
IoMap_rawAtPut(pointers, key, pointer);
}
return pointer;
}
int Levels_isAssignOperator(Levels *self, IoSymbol *operator)
{
return IoMap_rawAt(self->assignOperatorTable, operator) != NULL;
}
