IoObject *IoCFFIPointer_castTo(IoCFFIPointer *self, IoObject *locals, IoMessage *m)
{
IoObject *toType = IoMessage_locals_valueArgAt_(m, locals, 0);
IoObject *o = IoState_on_doCString_withLabel_(IOSTATE, toType, "?typeString", "IoCFFIPointer_castTo");
if(!ISNIL(o)) {
char *typeStr = CSTRING(o);
switch(typeStr[0]) {
case '^':
toType = IOCLONE(toType);
*(DATA(toType)->valuePointer) = *((void **)IoCFFIDataType_ValuePointerFromObject_(toType, self));
return toType;
case '*':
toType = IOCLONE(toType);
IoCFFIDataType_rawSetValue(toType, self);
return toType;
default:
IoState_error_(IOSTATE, m, "Wrong type to cast to.");
break;
}
}
else {
// Mm... well, if the type to cast to does not have a typeString slot,
// it should be an Io Object, so the address stored here is a pointer to an
// Io Object. Simply cast the pointer and return it... dangerous but...
IoObject *obj = (IoObject *)*(DATA(self)->valuePointer);
if(ISOBJECT(obj))
return (IoObject *)*(DATA(self)->valuePointer);
}
return IONIL(self);
}
void IoCoroutine_rawPrintBackTrace(IoCoroutine *self)
{
IoObject *e = IoCoroutine_rawException(self);
IoMessage *caughtMessage = IoObject_rawGetSlot_(e, IOSYMBOL("caughtMessage"));
if (IoObject_rawGetSlot_(e, IOSYMBOL("showStack"))) // sanity check
{
IoState_on_doCString_withLabel_(IOSTATE, e, "showStack", "[Coroutine]");
}
else
{
IoSymbol *error = IoObject_rawGetSlot_(e, IOSYMBOL("error"));
if (error)
{
fputs(CSTRING(error), stderr);
fputs("\n", stderr);
}
else
{
fputs("error: [missing error slot in Exception object]\n", stderr);
}
if (caughtMessage)
{
UArray *ba = IoMessage_asMinimalStackEntryDescription(caughtMessage);
fputs(UArray_asCString(ba), stderr);
fputs("\n", stderr);
UArray_free(ba);
}
}
}
IoCFFIArray *IoCFFIArray_with(IoCFFIArray *self, IoObject *locals, IoMessage *m)
{
IoCFFIDataType *type;
int size, i;
ffi_type *item_type;
IoCFFIArray *o = IOCLONE(self);
IoState_on_doCString_withLabel_(IoObject_state(o), o, "init", "IoCFFIArray_with");
type = IOCLONE(IoMessage_locals_valueArgAt_(m, locals, 0));
IoObject_setSlot_to_(o, IOSYMBOL("arrayType"), type);
size = IoMessage_locals_intArgAt_(m, locals, 1);
DATA(o)->arraySize = size;
item_type = IoCFFIDataType_ffiType(type);
DATA(o)->itemSize = item_type->size;
// Fake libffi to think we are a Struct
DATA(o)->ffiType.size = 0;
DATA(o)->ffiType.alignment = 0;
DATA(o)->ffiType.type = FFI_TYPE_STRUCT;
DATA(o)->ffiType.elements = io_calloc(size + 1, sizeof(ffi_type *));
DATA(o)->needToFreeFFIType = 1;
for ( i = 0 ; i < size ; i++ ) {
DATA(o)->ffiType.elements[i] = item_type;
}
DATA(o)->ffiType.elements[size] = NULL;
ffi_cif cif;
ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 0, &(DATA(o)->ffiType), NULL);
return o;
}
int IoSecureSockets_Password_Callback(char *buf, int size, int flag, void *selfPtr)
{
IoObject *self = (IoObject *)selfPtr;
IoSeq *passSeq;
if(flag == 0) //decryption
{
passSeq = IoState_on_doCString_withLabel_(IoObject_state(self), self, "fetchDecryptionPassword", "Decryption Password Callback");
}
else //encryption
{
passSeq = IoState_on_doCString_withLabel_(IoObject_state(self), self, "fetchEncryptionPassword", "Encryption Password Callback");
}
char *cpass = CSTRING(passSeq);
strncpy(buf, cpass, size);
buf[size-1] = '\0';
return strlen(buf);
}
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;
}
IoObject *IoCFFIPointer_value(IoCFFIPointer *self, IoObject *locals, IoMessage *m)
{
IoObject *pointedToType;
IoCFFIPointer *pointer;
char *typeString, *cp, c;
if (*(DATA(self)->valuePointer) == NULL)
{
//IoState_error_(IOSTATE, m, "attempt to dereference NULL pointer");
return IONIL(self);
}
typeString = CSTRING(IoState_on_doCString_withLabel_(IOSTATE, self, "typeString", "IoCFFIPointer_value"));
pointedToType = IoObject_getSlot_(self, IOSYMBOL("pointedToType"));
if (ISCFFIPointer(pointedToType))
{
// we are a pointer to a pointer, so return a new Pointer
// that points to the address of our ptr dereferenced
cp = strrchr(typeString, '^');
switch (c = *(++cp))
{
#define IoCFFIPointer_value_SET_DATA_PTR(cType) \
pointer = IOCLONE(IoCFFIPointer_ToType_(IoObject_getSlot_(pointedToType, IOSYMBOL("pointedToType")))); \
*(DATA(pointer)->valuePointer) = *((cType **)(*(DATA(self)->valuePointer))); break
//DATA(pointer)->ptr = *((cType **)(DATA(self)->ptr)); break
case 'c':
case 'b':
IoCFFIPointer_value_SET_DATA_PTR(char);
case 'C':
case 'B':
IoCFFIPointer_value_SET_DATA_PTR(unsigned char);
case 's':
IoCFFIPointer_value_SET_DATA_PTR(short);
case 'S':
IoCFFIPointer_value_SET_DATA_PTR(unsigned short);
case 'i':
IoCFFIPointer_value_SET_DATA_PTR(int);
case 'I':
IoCFFIPointer_value_SET_DATA_PTR(unsigned int);
case 'l':
IoCFFIPointer_value_SET_DATA_PTR(long);
case 'L':
IoCFFIPointer_value_SET_DATA_PTR(unsigned long);
case 'f':
IoCFFIPointer_value_SET_DATA_PTR(float);
case 'd':
IoCFFIPointer_value_SET_DATA_PTR(double);
case '*':
IoCFFIPointer_value_SET_DATA_PTR(char *);
case '{':
case '(':
case '&':
case '[':
case 'v':
IoCFFIPointer_value_SET_DATA_PTR(void);
#undef IoCFFIPointer_value_SET_DATA_PTR
//case 'v':
// IoState_error_(IOSTATE, m, "attempt to dereference a void pointer");
// return IONIL(self);
default:
IoState_error_(IOSTATE, m, "unknown character '%c' in Pointer typeString", c);
return IONIL(self);
}
return pointer;
}
else if(ISCFFIDataType(pointedToType) || ISCFFIStructure(pointedToType) || ISCFFIFunction(pointedToType) || ISCFFIArray(pointedToType))
{
return IoCFFIDataType_objectFromData_(pointedToType, *(DATA(self)->valuePointer));
}
else
{
IoState_error_(IOSTATE, m, "attempt to dereference Pointer object whose pointedToType is unknown.");
return IONIL(self);
}
}
IoObject *IoState_doCString_(IoState *self, const char *s)
{
return IoState_on_doCString_withLabel_(self, self->lobby, s, "IoState_doCString");
}
