void buzzvm_destroy(buzzvm_t* vm) {
/* Get rid of the rng state */
free((*vm)->rngstate);
/* Get rid of the stack */
buzzstrman_destroy(&(*vm)->strings);
/* Get rid of the global variable table */
buzzdict_destroy(&(*vm)->gsyms);
/* Get rid of the local variable tables */
buzzdarray_destroy(&(*vm)->lsymts);
/* Get rid of the stack */
buzzdarray_destroy(&(*vm)->stacks);
/* Get rid of the heap */
buzzheap_destroy(&(*vm)->heap);
/* Get rid of the function list */
buzzdarray_destroy(&(*vm)->flist);
/* Get rid of the swarm list */
buzzdict_destroy(&(*vm)->swarms);
buzzdarray_destroy(&(*vm)->swarmstack);
buzzswarm_members_destroy(&((*vm)->swarmmembers));
/* Get rid of the message queues */
buzzinmsg_queue_destroy(&(*vm)->inmsgs);
buzzoutmsg_queue_destroy(&(*vm)->outmsgs);
/* Get rid of the virtual stigmergy structures */
buzzdict_destroy(&(*vm)->vstigs);
/* Get rid of neighbor value listeners */
buzzdict_destroy(&(*vm)->listeners);
free(*vm);
*vm = 0;
}
void buzzswarm_elem_destroy(const void* key, void* data, void* params) {
buzzswarm_elem_t e = *(buzzswarm_elem_t*)data;
buzzdarray_destroy(&(e->swarms));
free(e);
free((void*)key);
free(data);
}
void buzzvm_lsyms_destroy(uint32_t pos,
void* data,
void* params) {
buzzvm_lsyms_t s = *(buzzvm_lsyms_t*)data;
buzzdarray_destroy(&(s->syms));
free(s);
}
int buzzdict_remove(buzzdict_t dt,
const void* key) {
/* Hash the key */
uint32_t h = dt->hashf(key) % dt->num_buckets, i;
/* Is the bucket empty? */
if(!dt->buckets[h]) return 0;
/* Bucket not empty - is the entry present? */
for(i = 0; i < buzzdarray_size(dt->buckets[h]); ++i) {
const struct buzzdict_entry_s* e = &buzzdarray_get(dt->buckets[h], i, struct buzzdict_entry_s);
if(dt->keycmpf(key, e->key) == 0) {
/* Entry found - remove it */
dt->dstryf(e->key, e->data, dt);
buzzdarray_remove(dt->buckets[h], i);
/* Is the entry list empty? If so, free the memory */
if(buzzdarray_isempty(dt->buckets[h]))
buzzdarray_destroy(&(dt->buckets[h]));
/* Increase size */
--(dt->size);
/* Done */
return 1;
}
}
/* Entry not found, nothing to do */
return 0;
}
void buzzswarm_members_refresh(buzzswarm_members_t m,
uint16_t robot,
buzzdarray_t swarms) {
/* Is an entry for the passed robot already present? */
buzzswarm_elem_t* e = buzzdict_get(m, &robot, buzzswarm_elem_t);
if(e) {
/* Yes, update it */
(*e)->age = 0;
buzzdarray_destroy(&((*e)->swarms));
(*e)->swarms = swarms;
}
else {
/* No, create it */
buzzswarm_elem_t ne = buzzswarm_elem_new();
buzzdarray_destroy(&(ne->swarms));
ne->swarms = swarms;
/* Add it to the structure */
buzzdict_set(m, &robot, &ne);
}
}
void buzzdict_destroy(buzzdict_t* dt) {
/* Destroy buckets */
uint32_t i, j;
for(i = 0; i < (*dt)->num_buckets; ++i) {
/* Is the bucket used? */
if((*dt)->buckets[i] != NULL) {
/* Destroy elements in the bucket */
for(j = 0; j < buzzdarray_size((*dt)->buckets[i]); ++j) {
const struct buzzdict_entry_s* e = &buzzdarray_get((*dt)->buckets[i], j, struct buzzdict_entry_s);
(*dt)->dstryf(e->key, e->data, *dt);
}
/* Destroy bucket */
buzzdarray_destroy(&((*dt)->buckets[i]));
}
}
free((*dt)->buckets);
/* Destroy the rest */
free(*dt);
*dt = NULL;
}
void buzzvm_darray_destroy(uint32_t pos,
void* data,
void* params) {
buzzdarray_t* s = (buzzdarray_t*)data;
buzzdarray_destroy(s);
}
