intptr_t marshal(IoDynLib *self, IoObject *arg)
{
intptr_t n = 0;
if (ISNUMBER(arg))
{
n = IoNumber_asInt(arg);
}
else if (ISSYMBOL(arg))
{
n = (intptr_t)CSTRING(arg);
}
else if (ISLIST(arg))
{
int i;
intptr_t *l = io_calloc(1, IoList_rawSize(arg) * sizeof(intptr_t));
for (i = 0; i < IoList_rawSize(arg); i ++)
l[i] = marshal(self, List_rawAt_(IoList_rawList(arg), i));
n = (intptr_t)l;
}
else if (ISBUFFER(arg))
{
n = (intptr_t)IoSeq_rawBytes(arg);
}
else if (ISBLOCK(arg))
{
unsigned char *blk = io_calloc(1, 20), *p = blk;
// FIXME: need trampoline code for other architectures
*p++ = 0x68;
*((intptr_t *)p) = (intptr_t)arg;
p += sizeof(intptr_t);
*p++ = 0xb8;
*((intptr_t *)p) = (intptr_t)bouncer;
p += sizeof(intptr_t);
*p++ = 0xff;
*p++ = 0xd0;
*p++ = 0x83;
*p++ = 0xc4;
*p++ = 0x04;
*p++ = 0xc3;
n = (intptr_t)blk;
}
else
{
n = (intptr_t)arg; //IONIL(self);
}
return n;
}
Uint64Array *IoTagDB_tagArrayForTagNames_(IoTagDB *self, IoMessage *m, IoList *tagNames)
{
TagDB *tdb = DATA(self);
Uint64Array *tags = Uint64Array_new();
int i;
for (i = 0; i < IoList_rawSize(tagNames); i ++)
{
IoSeq *tagName = IoList_rawAt_(tagNames, i);
symbolid_t keyid;
IOASSERT(ISSEQ(tagName), "tag names must be Sequences");
keyid = TagDB_idForSymbol_size_(tdb, CSTRING(tagName), IoSeq_rawSize(tagName));
Uint64Array_append_(tags, keyid);
/*
{
Datum *keyDatum = TagDB_symbolForId_(tdb, keyid);
printf("%s -> %i && ", CSTRING(tagName), (int)keyid);
printf("%i -> %s\n", (int)keyid, (char *)(keyDatum->data));
Datum_free(keyDatum);
}
*/
}
return tags;
}
/*doc Memcached getMulti(keys)
Asks memcached to retrieve data corresponding to the list of keys.
Returns a Map with the results.
If some of the keys appearing in a retrieval request are not sent back
by the server in the item list this means that the server does not
hold items with such keys
*/
IoObject *IoMemcached_getMulti(IoMemcached *self, IoObject *locals, IoMessage *m)
{
IoList *keys_list = IoMessage_locals_listArgAt_(m, locals, 0);
size_t keys_list_size = IoList_rawSize(keys_list);
IoObject *results_map = IoMap_new(IOSTATE);
if(keys_list_size == 0)
return results_map;
int i;
for(i = 0; i < keys_list_size; i++) {
IoSeq *key = IoList_rawAt_(keys_list, i);
IOASSERT(ISSEQ(key), "key must be a Sequence");
IOASSERT(IOSEQ_LENGTH(key) > 0, "key cannot be an empty Sequence");
IOASSERT(IOSEQ_LENGTH(key) < MEMCACHED_MAX_KEY, "key is too long");
}
const char **ckeys = (const char **) malloc(sizeof(const char *) * keys_list_size);
size_t *ckey_lengths = (size_t *) malloc(sizeof(size_t) * keys_list_size);
for(i = 0; i < keys_list_size; i++) {
ckeys[i] = CSTRING(IoList_rawAt_(keys_list, i));
ckey_lengths[i] = strlen(ckeys[i]);
}
memcached_return_t rc = memcached_mget(DATA(self)->mc, ckeys, ckey_lengths, keys_list_size);
free(ckeys);
free(ckey_lengths);
char returned_key[MEMCACHED_MAX_KEY], *returned_value;
size_t returned_key_length, returned_value_length;
uint32_t flags;
returned_value = memcached_fetch(DATA(self)->mc,
returned_key, &returned_key_length,
&returned_value_length, &flags, &rc
);
while(returned_value != NULL) {
IoMap_rawAtPut(results_map,
IoSeq_newSymbolWithData_length_(IOSTATE, returned_key, returned_key_length),
IoMemcached_deserialize(self, returned_value, returned_value_length, flags)
);
free(returned_value);
returned_value = memcached_fetch(DATA(self)->mc,
returned_key, &returned_key_length,
&returned_value_length, &flags, &rc
);
}
return results_map;
}
cairo_glyph_t *rawGlyphsFromList_count_(IoList *glyphList, int *count)
{
int glyphCount = IoList_rawSize(glyphList);
cairo_glyph_t *glyphs = 0;
int i;
if (count)
*count = glyphCount;
if (glyphCount == 0)
return 0;
glyphs = malloc(sizeof(cairo_glyph_t) * glyphCount);
for (i = 0; i < glyphCount; i++)
{
cairo_glyph_t *glyph = IoCairoGlyph_rawGlyph(IoList_rawAt_(glyphList, i));
memcpy(glyphs + i, glyph, sizeof(cairo_glyph_t));
}
return glyphs;
}
IoObject *demarshal(IoObject *self, IoObject *arg, intptr_t n)
{
if (ISNUMBER(arg))
{
return IONUMBER(n);
}
else if (ISSYMBOL(arg))
{
if (n == 0)
return IOSYMBOL("");
return IOSYMBOL((char*)n);
}
else if (ISLIST(arg))
{
intptr_t *values = (intptr_t *)n;
int i;
for (i = 0; i < IoList_rawSize(arg); i ++)
{
IoObject *value = List_at_(IoList_rawList(arg), i);
List_at_put_(IoList_rawList(arg), i, demarshal(self, value, values[i]));
}
io_free(values);
return arg;
}
else if (ISBUFFER(arg))
{
return arg;
}
else if (ISBLOCK(arg))
{
return arg;
}
return IONIL(self);
}
