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); }