Esempio n. 1
0
int main() {
   buzzstrman_t sm = buzzstrman_new();

   printf("=== ADDING PROTECTED STRINGS ===\n\n");
   buzzstrman_register(sm, "ciao", 1);
   buzzstrman_register(sm, "come va?", 1);
   buzzstrman_register(sm, "io bene", 1);
   buzzstrman_print(sm);
   
   printf("\n=== ADDING UNPROTECTED STRINGS ===\n\n");
   buzzstrman_register(sm, "la famiglia?", 0);
   buzzstrman_register(sm, "eh, si tira avanti", 0);
   buzzstrman_register(sm, "si, son ragazzi", 0);
   buzzstrman_register(sm, "i figli so piezz'e core", 0);
   buzzstrman_print(sm);

   printf("\n=== ADDING DUPLICATE STRING ===\n\n");
   buzzstrman_register(sm, "ciao", 1);
   buzzstrman_register(sm, "eh, si tira avanti", 1);
   buzzstrman_print(sm);

   printf("\n=== GARBAGE COLLECTION ===\n\n");
   buzzstrman_gc_clear(sm);
   buzzstrman_gc_mark(sm, buzzstrman_register(sm, "la famiglia?", 0));
   buzzstrman_gc_mark(sm, buzzstrman_register(sm, "si, son ragazzi", 0));
   buzzstrman_gc_prune(sm);
   buzzstrman_print(sm);

   buzzstrman_destroy(&sm);
   return 0;
}
Esempio n. 2
0
buzzvm_t buzzvm_new(uint16_t robot) {
   /* Create VM state. calloc() takes care of zeroing everything */
   buzzvm_t vm = (buzzvm_t)calloc(1, sizeof(struct buzzvm_s));
   /* Create stacks */
   vm->stacks = buzzdarray_new(BUZZVM_STACKS_INIT_CAPACITY,
                               sizeof(buzzdarray_t),
                               buzzvm_darray_destroy);
   vm->stack = buzzdarray_new(BUZZVM_STACK_INIT_CAPACITY,
                              sizeof(buzzobj_t),
                              NULL);
   buzzdarray_push(vm->stacks, &(vm->stack));
   /* Create local variable tables */
   vm->lsymts = buzzdarray_new(BUZZVM_LSYMTS_INIT_CAPACITY,
                               sizeof(buzzvm_lsyms_t),
                               buzzvm_lsyms_destroy);
   vm->lsyms = NULL;
   /* Create global variable tables */
   vm->gsyms = buzzdict_new(BUZZVM_SYMS_INIT_CAPACITY,
                            sizeof(int32_t),
                            sizeof(buzzobj_t),
                            buzzdict_int32keyhash,
                            buzzdict_int32keycmp,
                            NULL);
   /* Create string list */
   vm->strings = buzzstrman_new();
   /* Create heap */
   vm->heap = buzzheap_new();
   /* Create function list */
   vm->flist = buzzdarray_new(20, sizeof(buzzvm_funp), NULL);
   /* Create swarm list */
   vm->swarms = buzzdict_new(10,
                             sizeof(uint16_t),
                             sizeof(uint8_t),
                             buzzdict_uint16keyhash,
                             buzzdict_uint16keycmp,
                             NULL);
   /* Create swarm stack */
   vm->swarmstack = buzzdarray_new(10,
                                   sizeof(uint16_t),
                                   NULL);
   /* Create swarm member structure */
   vm->swarmmembers = buzzswarm_members_new();
   vm->swarmbroadcast = SWARM_BROADCAST_PERIOD;
   /* Create message queues */
   vm->inmsgs = buzzinmsg_queue_new();
   vm->outmsgs = buzzoutmsg_queue_new(robot);
   /* Create virtual stigmergy */
   vm->vstigs = buzzdict_new(10,
                             sizeof(uint16_t),
                             sizeof(buzzvstig_t),
                             buzzdict_uint16keyhash,
                             buzzdict_uint16keycmp,
                             buzzvm_vstig_destroy);
   /* Create virtual stigmergy */
   vm->listeners = buzzdict_new(10,
                                sizeof(uint16_t),
                                sizeof(buzzobj_t),
                                buzzdict_uint16keyhash,
                                buzzdict_uint16keycmp,
                                NULL);
   /* Take care of the robot id */
   vm->robot = robot;
   /* Initialize empty random number generator (buzzvm_math takes care of creating it) */
   vm->rngstate = NULL;
   vm->rngidx = 0;
   /* Return new vm */
   return vm;
}