buzzvm_state buzzvm_call(buzzvm_t vm, int isswrm) { /* Get argument number and pop it */ buzzvm_stack_assert(vm, 1); buzzvm_type_assert(vm, 1, BUZZTYPE_INT); int32_t argn = buzzvm_stack_at(vm, 1)->i.value; buzzvm_pop(vm); /* Make sure the stack has enough elements */ buzzvm_stack_assert(vm, argn+1); /* Make sure the closure is where expected */ buzzvm_type_assert(vm, argn+1, BUZZTYPE_CLOSURE); buzzobj_t c = buzzvm_stack_at(vm, argn+1); /* Make sure that that data about C closures is correct */ if((!c->c.value.isnative) && ((c->c.value.ref) >= buzzdarray_size(vm->flist))) { buzzvm_seterror(vm, BUZZVM_ERROR_FLIST, NULL); return vm->state; } /* Create a new local symbol list copying the parent's */ vm->lsyms = buzzvm_lsyms_new(isswrm, buzzdarray_clone(c->c.value.actrec)); buzzdarray_push(vm->lsymts, &(vm->lsyms)); /* Add function arguments to the local symbols */ int32_t i; for(i = argn; i > 0; --i) buzzdarray_push(vm->lsyms->syms, &buzzdarray_get(vm->stack, buzzdarray_size(vm->stack) - i, buzzobj_t)); /* Get rid of the function arguments */ for(i = argn+1; i > 0; --i) buzzdarray_pop(vm->stack); /* Pop unused self table */ buzzdarray_pop(vm->stack); /* Push return address */ buzzvm_pushi((vm), vm->pc); /* Make a new stack for the function */ vm->stack = buzzdarray_new(1, sizeof(buzzobj_t), NULL); buzzdarray_push(vm->stacks, &(vm->stack)); /* Jump to/execute the function */ if(c->c.value.isnative) { vm->oldpc = vm->pc; vm->pc = c->c.value.ref; } else buzzdarray_get(vm->flist, c->c.value.ref, buzzvm_funp)(vm); return vm->state; }
int buzzneighbors_listen(buzzvm_t vm) { buzzvm_lnum_assert(vm, 2); /* Get value id argument */ buzzvm_lload(vm, 1); buzzvm_type_assert(vm, 1, BUZZTYPE_STRING); /* Get listener argument */ buzzvm_lload(vm, 2); buzzvm_type_assert(vm, 1, BUZZTYPE_CLOSURE); /* Install listener */ buzzdict_set( vm->listeners, &buzzvm_stack_at(vm, 2)->s.value.sid, &buzzvm_stack_at(vm, 1)); return buzzvm_ret0(vm); }
buzzvm_state buzzvm_ret1(buzzvm_t vm) { /* Pop swarm stack */ if(vm->lsyms->isswarm) buzzdarray_pop(vm->swarmstack); /* Pop local symbol table */ buzzdarray_pop(vm->lsymts); /* Set local symbol table pointer */ vm->lsyms = !buzzdarray_isempty(vm->lsymts) ? buzzdarray_last(vm->lsymts, buzzvm_lsyms_t) : NULL; /* Make sure there's an element on the stack */ buzzvm_stack_assert(vm, 1); /* Save it, it's the return value to pass to the lower stack */ buzzobj_t ret = buzzvm_stack_at(vm, 1); /* Pop stack */ buzzdarray_pop(vm->stacks); /* Set stack pointer */ vm->stack = buzzdarray_last(vm->stacks, buzzdarray_t); /* Make sure the stack contains at least one element */ buzzvm_stack_assert(vm, 1); /* Make sure that element is an integer */ buzzvm_type_assert(vm, 1, BUZZTYPE_INT); /* Use that element as program counter */ vm->oldpc = vm->pc; vm->pc = buzzvm_stack_at(vm, 1)->i.value; /* Pop the return address */ buzzvm_pop(vm); /* Push the return value */ return buzzvm_push(vm, ret); }
buzzvm_state buzzvm_function_call(buzzvm_t vm, const char* fname, uint32_t argc) { /* Reset the VM state if it's DONE */ if(vm->state == BUZZVM_STATE_DONE) vm->state = BUZZVM_STATE_READY; /* Don't continue if the VM has an error */ if(vm->state != BUZZVM_STATE_READY) return vm->state; /* Push the function name (return with error if not found) */ buzzvm_pushs(vm, buzzvm_string_register(vm, fname, 0)); /* Get associated symbol */ buzzvm_gload(vm); /* Make sure it's a closure */ buzzvm_type_assert(vm, 1, BUZZTYPE_CLOSURE); /* Move closure before arguments */ if(argc > 0) { buzzdarray_insert(vm->stack, buzzdarray_size(vm->stack) - argc - 1, buzzvm_stack_at(vm, 1)); buzzvm_pop(vm); } /* Call the closure */ return buzzvm_closure_call(vm, argc); }
int buzzvm_swarm_others(buzzvm_t vm) { buzzvm_lnum_assert(vm, 1); /* Get the id of the current swarm */ buzzvm_lload(vm, 0); buzzvm_pushs(vm, buzzvm_string_register(vm, "id")); buzzvm_tget(vm); uint16_t id1 = buzzvm_stack_at(vm, 1)->i.value; /* Get the swarm entry */ uint8_t* x = buzzdict_get(vm->swarms, &id1, uint8_t); if(!x) { vm->state = BUZZVM_STATE_ERROR; vm->error = BUZZVM_ERROR_SWARM; return BUZZVM_STATE_ERROR; } /* Get the id of the new swarm to create */ buzzvm_lload(vm, 1); buzzvm_type_assert(vm, 1, BUZZTYPE_INT); uint16_t id2 = buzzvm_stack_at(vm, 1)->i.value; /* Add a new entry for the swarm */ uint8_t v = *x ? 0 : 1; buzzdict_set(vm->swarms, &id2, &v); /* Send update, if necessary */ if(v) buzzoutmsg_queue_append_swarm_joinleave( vm->outmsgs, BUZZMSG_SWARM_JOIN, id2); /* Create a table to return */ make_table(vm, id2); /* Return */ return buzzvm_ret1(vm); }
int buzzvm_vstig_setonconflictlost(struct buzzvm_s* vm) { buzzvm_lnum_assert(vm, 1); /* Get vstig id */ buzzvm_lload(vm, 0); buzzvm_pushs(vm, buzzvm_string_register(vm, "id")); buzzvm_tget(vm); uint16_t id = buzzvm_stack_at(vm, 1)->i.value; /* Look for virtual stigmergy */ buzzvstig_t* vs = buzzdict_get(vm->vstigs, &id, buzzvstig_t); if(vs) { /* Virtual stigmergy found */ /* Get closure */ buzzvm_lload(vm, 1); buzzvm_type_assert(vm, 1, BUZZTYPE_CLOSURE); /* Clone the closure */ if((*vs)->onconflictlost) free((*vs)->onconflictlost); (*vs)->onconflictlost = buzzobj_clone(buzzvm_stack_at(vm, 1)); } else { /* No virtual stigmergy found, just push false */ /* If this happens, its a bug */ buzzvm_pushnil(vm); fprintf(stderr, "[BUG] [ROBOT %u] Can't find virtual stigmergy %u\n", vm->robot, id); } /* Return the value found */ return buzzvm_ret0(vm); }
// proper way to send loooong 1D array int BuzzSetMap(buzzvm_t vm){ /* Make sure one parameter has been passed */ buzzvm_lnum_assert(vm, 1); /* Get the parameter */ buzzvm_lload(vm, 1); buzzvm_type_assert(vm, 1, BUZZTYPE_TABLE); // matrix /* Get the table */ buzzobj_t t = buzzvm_stack_at(vm, 1); /* Copy the values into a vector */ std::vector<float> mat; for(int32_t i = 0; i < buzzdict_size(t->t.value); ++i) { /* Duplicate the table */ buzzvm_dup(vm); /* Push the index */ buzzvm_pushi(vm, i); /* Get the value */ buzzvm_tget(vm); /* Store it in the vector (assume all values are float, no mistake...) */ mat.push_back((float)buzzvm_stack_at(vm, 1)->f.value); /* Get rid of the value, now useless */ buzzvm_pop(vm); } /* Get a pointer to the controller */ buzzvm_pushs(vm, buzzvm_string_register(vm, "controller", 1)); buzzvm_gload(vm); /* Copy data into the controller */ reinterpret_cast<CBuzzControllerFootBot*>(buzzvm_stack_at(vm, 1)->u.value)->SetMapParams(mat, Sqrt(buzzdict_size(t->t.value))); /* Done with the function */ return buzzvm_ret0(vm); }
int buzzvstig_create(buzzvm_t vm) { buzzvm_lnum_assert(vm, 1); /* Get vstig id */ buzzvm_lload(vm, 1); buzzvm_type_assert(vm, 1, BUZZTYPE_INT); uint16_t id = buzzvm_stack_at(vm, 1)->i.value; buzzvm_pop(vm); /* Look for virtual stigmergy */ const buzzvstig_t* vs = buzzdict_get(vm->vstigs, &id, buzzvstig_t); if(vs) { /* Found, destroy it */ buzzdict_remove(vm->vstigs, &id); } /* Create a new virtual stigmergy */ buzzvstig_t nvs = buzzvstig_new(); buzzdict_set(vm->vstigs, &id, &nvs); /* Create a table */ buzzvm_pusht(vm); /* Add data and methods */ buzzvm_dup(vm); buzzvm_pushs(vm, buzzvm_string_register(vm, "id", 1)); buzzvm_pushi(vm, id); buzzvm_tput(vm); function_register(foreach); function_register(size); function_register(put); function_register(get); function_register(onconflict); function_register(onconflictlost); /* Return the table */ return buzzvm_ret1(vm); }
int buzzvm_swarm_id(struct buzzvm_s* vm) { /* Is the swarm stack empty? */ if(buzzdarray_isempty(vm->swarmstack)) { /* Yes, no swarm to push, push nil instead */ buzzvm_pushnil(vm); } else { /* Take the stack top by default */ uint16_t stackpos = 1; /* Do we have an argument? */ if(buzzvm_lnum(vm) > 1) { buzzvm_lload(vm, 1); buzzvm_type_assert(vm, 1, BUZZTYPE_INT); stackpos = buzzvm_stack_at(vm, 1)->i.value; } /* Limit stackpos value to avoid out-of-bounds operations */ if(stackpos > buzzdarray_size(vm->swarmstack)) stackpos = buzzdarray_size(vm->swarmstack); /* Push the swarm id located at stackpos */ buzzvm_pushi(vm, buzzdarray_get( vm->swarmstack, buzzdarray_size(vm->swarmstack) - stackpos, uint16_t)); } /* Return the value */ return buzzvm_ret1(vm); }
int buzzvm_swarm_select(buzzvm_t vm) { buzzvm_lnum_assert(vm, 1); /* Get the id */ buzzvm_lload(vm, 0); buzzvm_pushs(vm, buzzvm_string_register(vm, "id")); buzzvm_tget(vm); uint16_t id = buzzvm_stack_at(vm, 1)->i.value; /* Get the result of the condition check */ buzzvm_lload(vm, 1); buzzvm_type_assert(vm, 1, BUZZTYPE_INT); uint8_t in = buzzvm_stack_at(vm, 1)->i.value; /* Update the swarm, if known */ if(buzzdict_exists(vm->swarms, &id)) { /* Store membership */ buzzdict_set(vm->swarms, &id, &in); /* Send update */ buzzoutmsg_queue_append_swarm_joinleave( vm->outmsgs, in ? BUZZMSG_SWARM_JOIN : BUZZMSG_SWARM_LEAVE, id); /* Return */ return buzzvm_ret0(vm); } else { vm->state = BUZZVM_STATE_ERROR; vm->error = BUZZVM_ERROR_SWARM; return BUZZVM_STATE_ERROR; } }
int BuzzSetWheelsFb(buzzvm_t vm) { buzzvm_lnum_assert(vm, 2); /* Push speeds */ buzzvm_lload(vm, 1); /* Left speed */ buzzvm_lload(vm, 2); /* Right speed */ buzzvm_type_assert(vm, 2, BUZZTYPE_FLOAT); buzzvm_type_assert(vm, 1, BUZZTYPE_FLOAT); /* Get pointer to the controller */ buzzvm_pushs(vm, buzzvm_string_register(vm, "controller", 1)); buzzvm_gload(vm); /* Call function */ reinterpret_cast<CBuzzControllerEFootBot*>( buzzvm_stack_at(vm, 1)->u.value)-> SetWheels(buzzvm_stack_at(vm, 3)->f.value, /* Left speed */ buzzvm_stack_at(vm, 2)->f.value /* Right speed */ ); return buzzvm_ret0(vm); }
buzzvm_state buzzvm_gload(buzzvm_t vm) { buzzvm_stack_assert(vm, 1); buzzvm_type_assert(vm, 1, BUZZTYPE_STRING); buzzobj_t str = buzzvm_stack_at(vm, 1); buzzvm_pop(vm); const buzzobj_t* o = buzzdict_get(vm->gsyms, &(str->s.value.sid), buzzobj_t); if(!o) { buzzvm_pushnil(vm); } else { buzzvm_push(vm, (*o)); } return BUZZVM_STATE_READY; }
buzzvm_state buzzvm_gstore(buzzvm_t vm) { buzzvm_stack_assert((vm), 2); buzzvm_type_assert((vm), 2, BUZZTYPE_STRING); buzzobj_t str = buzzvm_stack_at((vm), 2); buzzobj_t o = buzzvm_stack_at((vm), 1); buzzvm_pop(vm); buzzvm_pop(vm); buzzdict_set((vm)->gsyms, &(str->s.value.sid), &o); return BUZZVM_STATE_READY; }
int BuzzSetLEDsFb(buzzvm_t vm) { buzzvm_lnum_assert(vm, 3); /* Push the color components */ buzzvm_lload(vm, 1); buzzvm_lload(vm, 2); buzzvm_lload(vm, 3); buzzvm_type_assert(vm, 3, BUZZTYPE_INT); buzzvm_type_assert(vm, 2, BUZZTYPE_INT); buzzvm_type_assert(vm, 1, BUZZTYPE_INT); /* Create a new color with that */ CColor cColor(buzzvm_stack_at(vm, 3)->i.value, buzzvm_stack_at(vm, 2)->i.value, buzzvm_stack_at(vm, 1)->i.value); /* Get pointer to the controller */ buzzvm_pushs(vm, buzzvm_string_register(vm, "controller", 1)); buzzvm_gload(vm); /* Call function */ reinterpret_cast<CBuzzControllerEFootBot*>(buzzvm_stack_at(vm, 1)->u.value)->SetLEDs(cColor); return buzzvm_ret0(vm); }
int buzzneighbors_ignore(buzzvm_t vm) { buzzvm_lnum_assert(vm, 1); /* Get value id argument */ buzzvm_lload(vm, 1); buzzvm_type_assert(vm, 1, BUZZTYPE_STRING); /* Remove listener */ buzzdict_remove( vm->listeners, &(buzzvm_stack_at(vm, 1)->s.value.sid)); return buzzvm_ret0(vm); }
int BuzzSetArgosMap(buzzvm_t vm) { buzzvm_lnum_assert(vm, 1); buzzvm_lload(vm, 1); buzzvm_type_assert(vm, 1, BUZZTYPE_STRING); std::string text = buzzvm_stack_at(vm, 1)->s.value.str; /* Get pointer to the controller */ buzzvm_pushs(vm, buzzvm_string_register(vm, "controller", 1)); buzzvm_gload(vm); /* Call function */ //printf("Value: %s", buzzvm_stack_at(vm, 1)->s.value.str); reinterpret_cast<CBuzzControllerFootBot*>(buzzvm_stack_at(vm, 1)->u.value)->SetArgosMap(text); return buzzvm_ret0(vm); }
int BuzzRemoveCS(buzzvm_t vm) { buzzvm_lnum_assert(vm, 1); buzzvm_lload(vm, 1); buzzvm_type_assert(vm, 1, BUZZTYPE_INT); int id = buzzvm_stack_at(vm, 1)->i.value; buzzvm_pushs(vm, buzzvm_string_register(vm, "controller", 1)); buzzvm_gload(vm); reinterpret_cast<CBuzzControllerFootBot*>(buzzvm_stack_at(vm, 1)->u.value)->RemoveCS(id); return buzzvm_ret0(vm); }
int BuzzShowCoordinateSystem(buzzvm_t vm) { buzzvm_lnum_assert(vm, 5); buzzvm_lload(vm, 1); buzzvm_lload(vm, 2); buzzvm_lload(vm, 3); buzzvm_lload(vm, 4); buzzvm_lload(vm, 5); buzzvm_type_assert(vm, 5, BUZZTYPE_INT); buzzvm_type_assert(vm, 4, BUZZTYPE_INT); buzzvm_type_assert(vm, 3, BUZZTYPE_INT); buzzvm_type_assert(vm, 2, BUZZTYPE_INT); buzzvm_type_assert(vm, 1, BUZZTYPE_INT); buzzvm_pushs(vm, buzzvm_string_register(vm, "controller", 1)); buzzvm_gload(vm); reinterpret_cast<CBuzzControllerFootBot*>(buzzvm_stack_at(vm, 1)->u.value)->SetArgosCoordinateIDs( buzzvm_stack_at(vm, 6)->i.value, buzzvm_stack_at(vm, 5)->i.value, buzzvm_stack_at(vm, 4)->i.value, buzzvm_stack_at(vm, 3)->i.value, buzzvm_stack_at(vm, 2)->i.value); return buzzvm_ret0(vm); }
int BuzzDebugTrajectoryClear(buzzvm_t vm) { /* * Possible signatures * debug.trajectory.clear() * deletes all the trajectory points */ /* Get pointer to controller user data */ buzzvm_pushs(vm, buzzvm_string_register(vm, "controller", 1)); buzzvm_gload(vm); buzzvm_type_assert(vm, 1, BUZZTYPE_USERDATA); CBuzzController& cContr = *reinterpret_cast<CBuzzController*>(buzzvm_stack_at(vm, 1)->u.value); cContr.GetARGoSDebugInfo().TrajectoryClear(); return buzzvm_ret0(vm); }
int buzzneighbors_broadcast(buzzvm_t vm) { buzzvm_lnum_assert(vm, 2); /* Get value id argument */ buzzvm_lload(vm, 1); buzzvm_type_assert(vm, 1, BUZZTYPE_STRING); /* Get value argument */ buzzvm_lload(vm, 2); /* Queue a message with (value_id, value) */ buzzoutmsg_queue_append_broadcast( vm, buzzvm_stack_at(vm, 2), buzzvm_stack_at(vm, 1)); return buzzvm_ret0(vm); }
int buzzneighbors_add(buzzvm_t vm, uint16_t robot, float distance, float azimuth, float elevation) { if(vm->state != BUZZVM_STATE_READY) return vm->state; /* Get "neighbors" table */ buzzvm_pushs(vm, buzzvm_string_register(vm, "neighbors", 1)); buzzvm_gload(vm); buzzvm_type_assert(vm, 1, BUZZTYPE_TABLE); buzzobj_t nbr = buzzvm_stack_at(vm, 1); /* Get "data" field */ buzzvm_pushs(vm, buzzvm_string_register(vm, "data", 1)); buzzvm_tget(vm); if(buzzvm_stack_at(vm, 1)->o.type == BUZZTYPE_NIL) { /* Empty data, create a new table */ buzzvm_pop(vm); buzzvm_push(vm, nbr); buzzvm_pushs(vm, buzzvm_string_register(vm, "data", 1)); buzzvm_pusht(vm); buzzobj_t data = buzzvm_stack_at(vm, 1); buzzvm_tput(vm); buzzvm_push(vm, data); } /* When we get here, the "data" table is on top of the stack */ /* Push robot id */ buzzvm_pushi(vm, robot); /* Create entry table */ buzzobj_t entry = buzzheap_newobj(vm->heap, BUZZTYPE_TABLE); /* Insert distance */ buzzvm_push(vm, entry); buzzvm_pushs(vm, buzzvm_string_register(vm, "distance", 1)); buzzvm_pushf(vm, distance); buzzvm_tput(vm); /* Insert azimuth */ buzzvm_push(vm, entry); buzzvm_pushs(vm, buzzvm_string_register(vm, "azimuth", 1)); buzzvm_pushf(vm, azimuth); buzzvm_tput(vm); /* Insert elevation */ buzzvm_push(vm, entry); buzzvm_pushs(vm, buzzvm_string_register(vm, "elevation", 1)); buzzvm_pushf(vm, elevation); buzzvm_tput(vm); /* Save entry into data table */ buzzvm_push(vm, entry); buzzvm_tput(vm); return vm->state; }
int BuzzDebugTrajectoryDisable(buzzvm_t vm) { /* * Possible signatures * debug.trajectory.disable() * disables trajectory tracking */ /* Get pointer to controller user data */ buzzvm_pushs(vm, buzzvm_string_register(vm, "controller", 1)); buzzvm_gload(vm); buzzvm_type_assert(vm, 1, BUZZTYPE_USERDATA); CBuzzController* pcContr = reinterpret_cast<CBuzzController*>(buzzvm_stack_at(vm, 1)->u.value); /* Call method */ CBuzzController::DebugTrajectoryDisable(pcContr); return buzzvm_ret0(vm); }
int buzzvm_swarm_create(buzzvm_t vm) { buzzvm_lnum_assert(vm, 1); /* Get the id */ buzzvm_lload(vm, 1); buzzvm_type_assert(vm, 1, BUZZTYPE_INT); uint16_t id = buzzvm_stack_at(vm, 1)->i.value; /* Add a new entry if necessary */ if(!buzzdict_exists(vm->swarms, &id)) { uint8_t v = 0; buzzdict_set(vm->swarms, &id, &v); } /* Create a table to return */ make_table(vm, id); /* Return */ return buzzvm_ret1(vm); }
int BuzzShowBorderRobots(buzzvm_t vm) { buzzvm_lnum_assert(vm, 1); buzzvm_lload(vm, 1); buzzvm_type_assert(vm, 1, BUZZTYPE_TABLE); buzzobj_t t = buzzvm_stack_at(vm, 1); buzzvm_pushs(vm, buzzvm_string_register(vm, "controller", 1)); buzzvm_gload(vm); std::vector<float> v; buzzdict_foreach(t->t.value, di_read_elem, &v); reinterpret_cast<CBuzzControllerFootBot*>(buzzvm_stack_at(vm, 1)->u.value)->m_border_robot_ids = v; return buzzvm_ret0(vm); }
int buzzvm_vstig_create(buzzvm_t vm) { buzzvm_lnum_assert(vm, 1); /* Get vstig id */ buzzvm_lload(vm, 1); buzzvm_type_assert(vm, 1, BUZZTYPE_INT); uint16_t id = buzzvm_stack_at(vm, 1)->i.value; buzzvm_pop(vm); /* Look for virtual stigmergy */ buzzvstig_t* vs = buzzdict_get(vm->vstigs, &id, buzzvstig_t); if(vs) /* Found, destroy it */ buzzdict_remove(vm->vstigs, &id); /* Create a new virtual stigmergy */ buzzvstig_t nvs = buzzvstig_new(); buzzdict_set(vm->vstigs, &id, &nvs); /* Create a table and add data and methods */ buzzobj_t t = buzzheap_newobj(vm->heap, BUZZTYPE_TABLE); buzzvm_push(vm, t); buzzvm_pushs(vm, buzzvm_string_register(vm, "size")); buzzvm_pushcc(vm, buzzvm_function_register(vm, buzzvm_vstig_size)); buzzvm_tput(vm); buzzvm_push(vm, t); buzzvm_pushs(vm, buzzvm_string_register(vm, "put")); buzzvm_pushcc(vm, buzzvm_function_register(vm, buzzvm_vstig_put)); buzzvm_tput(vm); buzzvm_push(vm, t); buzzvm_pushs(vm, buzzvm_string_register(vm, "get")); buzzvm_pushcc(vm, buzzvm_function_register(vm, buzzvm_vstig_get)); buzzvm_tput(vm); buzzvm_push(vm, t); buzzvm_pushs(vm, buzzvm_string_register(vm, "onconflict")); buzzvm_pushcc(vm, buzzvm_function_register(vm, buzzvm_vstig_setonconflict)); buzzvm_tput(vm); buzzvm_push(vm, t); buzzvm_pushs(vm, buzzvm_string_register(vm, "onconflictlost")); buzzvm_pushcc(vm, buzzvm_function_register(vm, buzzvm_vstig_setonconflictlost)); buzzvm_tput(vm); buzzvm_push(vm, t); buzzvm_pushs(vm, buzzvm_string_register(vm, "id")); buzzvm_pushi(vm, id); buzzvm_tput(vm); /* Push the table on the stack */ buzzvm_push(vm, t); /* Return */ return buzzvm_ret1(vm); }
buzzvm_state buzzvm_tget(buzzvm_t vm) { buzzvm_stack_assert(vm, 2); buzzvm_type_assert(vm, 2, BUZZTYPE_TABLE); buzzobj_t k = buzzvm_stack_at(vm, 1); buzzobj_t t = buzzvm_stack_at(vm, 2); buzzvm_pop(vm); buzzvm_pop(vm); if(k->o.type != BUZZTYPE_INT && k->o.type != BUZZTYPE_FLOAT && k->o.type != BUZZTYPE_STRING) { buzzvm_seterror(vm, BUZZVM_ERROR_TYPE, "a %s value can't be used as table key", k->o.type); return vm->state; } const buzzobj_t* v = buzzdict_get(t->t.value, &k, buzzobj_t); if(v) buzzvm_push(vm, *v); else buzzvm_pushnil(vm); return BUZZVM_STATE_READY; }
int buzzneighbors_kin(buzzvm_t vm) { buzzvm_lnum_assert(vm, 0); /* Initialize the swarm id to 'unknown' */ int32_t swarmid = -1; /* If the swarm stack is not empty, look for the swarm id */ if(!buzzdarray_isempty(vm->swarmstack)) { /* Get position in swarm stack */ uint16_t sstackpos = 1; if(buzzdarray_size(vm->lsyms->syms) > 1) sstackpos = buzzdarray_get(vm->lsyms->syms, 1, buzzobj_t)->i.value; /* Get swarm id */ if(sstackpos <= buzzdarray_size(vm->swarmstack)) swarmid = buzzdarray_get(vm->swarmstack, buzzdarray_size(vm->swarmstack) - sstackpos, uint16_t); } /* Get the self table */ buzzvm_lload(vm, 0); buzzvm_type_assert(vm, 1, BUZZTYPE_TABLE); /* Get the data table */ buzzvm_pushs(vm, buzzvm_string_register(vm, "data", 1)); buzzvm_tget(vm); buzzobj_t data = buzzvm_stack_at(vm, 1); /* Create a new table as return value */ buzzobj_t t; vm->state = make_table(vm, &t); if(vm->state != BUZZVM_STATE_READY) return vm->state; /* If data is available, filter it */ if(data->o.type == BUZZTYPE_TABLE) { /* Create a new data table */ buzzobj_t kindata = buzzheap_newobj(vm->heap, BUZZTYPE_TABLE); /* Filter the neighbors in data and add them to kindata */ struct neighbor_filter_s fdata = { .vm = vm, .swarm_id = swarmid, .result = kindata->t.value }; buzzdict_foreach(data->t.value, neighbor_filter_kin, &fdata); /* Add kindata as the "data" field in t */ buzzvm_push(vm, t); buzzvm_pushs(vm, buzzvm_string_register(vm, "data", 1)); buzzvm_push(vm, kindata); buzzvm_tput(vm); } /* Return the table */ buzzvm_push(vm, t); return buzzvm_ret1(vm); }
int BuzzDebugPrint(buzzvm_t vm) { /* Get pointer to controller user data */ buzzvm_pushs(vm, buzzvm_string_register(vm, "controller", 1)); buzzvm_gload(vm); buzzvm_type_assert(vm, 1, BUZZTYPE_USERDATA); CBuzzController& cContr = *reinterpret_cast<CBuzzController*>(buzzvm_stack_at(vm, 1)->u.value); /* Fill message */ std::ostringstream oss; for(UInt32 i = 1; i < buzzdarray_size(vm->lsyms->syms); ++i) { buzzvm_lload(vm, i); buzzobj_t o = buzzvm_stack_at(vm, 1); buzzvm_pop(vm); switch(o->o.type) { case BUZZTYPE_NIL: oss << "[nil]"; break; case BUZZTYPE_INT: oss << o->i.value; break; case BUZZTYPE_FLOAT: oss << o->f.value; break; case BUZZTYPE_TABLE: oss << "[table with " << (buzzdict_size(o->t.value)) << " elems]"; break; case BUZZTYPE_CLOSURE: if(o->c.value.isnative) oss << "[n-closure @" << o->c.value.ref << "]"; else oss << "[c-closure @" << o->c.value.ref << "]"; break; case BUZZTYPE_STRING: oss << o->s.value.str; break; case BUZZTYPE_USERDATA: oss << "[userdata @" << o->u.value << "]"; break; default: break; } } cContr.GetARGoSDebugInfo().Msg = oss.str(); return buzzvm_ret0(vm); }
int buzzvstig_foreach(struct buzzvm_s* vm) { /* Make sure you got one argument */ buzzvm_lnum_assert(vm, 1); /* Get vstig id */ id_get(); /* Look for virtual stigmergy */ const buzzvstig_t* vs = buzzdict_get(vm->vstigs, &id, buzzvstig_t); if(vs) { /* Virtual stigmergy found */ /* Get closure */ buzzvm_lload(vm, 1); buzzvm_type_assert(vm, 1, BUZZTYPE_CLOSURE); buzzobj_t c = buzzvm_stack_at(vm, 1); /* Go through the elements and apply the closure */ struct buzzvstig_foreach_params p = { .vm = vm, .fun = c }; buzzdict_foreach((*vs)->data, buzzvstig_foreach_entry, &p); } /* Return */ return buzzvm_ret0(vm); }
int BuzzSetPath(buzzvm_t vm){ buzzvm_lnum_assert(vm, 1); /* Get the parameter */ buzzvm_lload(vm, 1); buzzvm_type_assert(vm, 1, BUZZTYPE_TABLE); // dictionary buzzobj_t t = buzzvm_stack_at(vm, 1); std::vector<CBuzzControllerFootBot::PathItem> pis; for(int32_t i = 0; i < buzzdict_size(t->t.value); ++i) { buzzvm_dup(vm); buzzvm_pushi(vm, i); buzzvm_tget(vm); int id = 0; int parent = 0; float x = 0.0; float y = 0.0; for(int32_t j = 0; j < buzzdict_size(buzzvm_stack_at(vm, 1)->t.value); ++j) { buzzvm_dup(vm); buzzvm_pushi(vm, j); buzzvm_tget(vm); if(j == 0){ id = (float)buzzvm_stack_at(vm, 1)->i.value; } else if(j == 1){ parent = (float)buzzvm_stack_at(vm, 1)->i.value; } else if (j == 2){ x = (float)buzzvm_stack_at(vm, 1)->f.value; } else if (j == 3){ y = (float)buzzvm_stack_at(vm, 1)->f.value; } //fprintf(stdout, "%d %f \n", j, (float)buzzvm_stack_at(vm, 1)->f.value); buzzvm_pop(vm); } pis.push_back(CBuzzControllerFootBot::PathItem(id, parent, x, y)); buzzvm_pop(vm); } /* Get a pointer to the controller */ buzzvm_pushs(vm, buzzvm_string_register(vm, "controller", 1)); buzzvm_gload(vm); /* Copy data into the controller */ reinterpret_cast<CBuzzControllerFootBot*>(buzzvm_stack_at(vm, 1)->u.value)->Done(pis); /* Done with the function */ return buzzvm_ret0(vm); }