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;
}
buzzvm_state CBuzzController::Register(const std::string& str_key,
Real f_value) {
buzzvm_pushs(m_tBuzzVM, buzzvm_string_register(m_tBuzzVM, str_key.c_str(), 1));
buzzvm_pushf(m_tBuzzVM, f_value);
buzzvm_gstore(m_tBuzzVM);
return m_tBuzzVM->state;
}
buzzvm_state CBuzzController::TablePut(buzzobj_t t_table,
const std::string& str_key,
Real f_value) {
buzzvm_push(m_tBuzzVM, t_table);
buzzvm_pushs(m_tBuzzVM, buzzvm_string_register(m_tBuzzVM, str_key.c_str(), 1));
buzzvm_pushf(m_tBuzzVM, f_value);
buzzvm_tput(m_tBuzzVM);
return m_tBuzzVM->state;
}
buzzvm_state CBuzzController::TablePut(buzzobj_t t_table,
SInt32 n_idx,
Real f_value) {
buzzvm_push(m_tBuzzVM, t_table);
buzzvm_pushi(m_tBuzzVM, n_idx);
buzzvm_pushf(m_tBuzzVM, f_value);
buzzvm_tput(m_tBuzzVM);
return m_tBuzzVM->state;
}
int hook(buzzvm_t vm) {
fprintf(stdout, "Hook called!\n\n");
buzzvm_pushf(vm, 17.0);
return buzzvm_ret1(vm);
}
buzzvm_state buzzvm_step(buzzvm_t vm) {
/* buzzvm_dump(vm); */
/* Can't execute if not ready */
if(vm->state != BUZZVM_STATE_READY) return vm->state;
/* Execute GC */
buzzheap_gc(vm);
/* Fetch instruction and (potential) argument */
uint8_t instr = vm->bcode[vm->pc];
/* Execute instruction */
switch(instr) {
case BUZZVM_INSTR_NOP: {
inc_pc();
break;
}
case BUZZVM_INSTR_DONE: {
buzzvm_done(vm);
break;
}
case BUZZVM_INSTR_PUSHNIL: {
inc_pc();
buzzvm_pushnil(vm);
break;
}
case BUZZVM_INSTR_DUP: {
inc_pc();
buzzvm_dup(vm);
break;
}
case BUZZVM_INSTR_POP: {
if(buzzvm_pop(vm) != BUZZVM_STATE_READY) return vm->state;
inc_pc();
break;
}
case BUZZVM_INSTR_RET0: {
if(buzzvm_ret0(vm) != BUZZVM_STATE_READY) return vm->state;
assert_pc(vm->pc);
break;
}
case BUZZVM_INSTR_RET1: {
if(buzzvm_ret1(vm) != BUZZVM_STATE_READY) return vm->state;
assert_pc(vm->pc);
break;
}
case BUZZVM_INSTR_ADD: {
buzzvm_add(vm);
inc_pc();
break;
}
case BUZZVM_INSTR_SUB: {
buzzvm_sub(vm);
inc_pc();
break;
}
case BUZZVM_INSTR_MUL: {
buzzvm_mul(vm);
inc_pc();
break;
}
case BUZZVM_INSTR_DIV: {
buzzvm_div(vm);
inc_pc();
break;
}
case BUZZVM_INSTR_MOD: {
buzzvm_mod(vm);
inc_pc();
break;
}
case BUZZVM_INSTR_POW: {
buzzvm_pow(vm);
inc_pc();
break;
}
case BUZZVM_INSTR_UNM: {
buzzvm_unm(vm);
inc_pc();
break;
}
case BUZZVM_INSTR_AND: {
buzzvm_and(vm);
inc_pc();
break;
}
case BUZZVM_INSTR_OR: {
buzzvm_or(vm);
inc_pc();
break;
}
case BUZZVM_INSTR_NOT: {
buzzvm_not(vm);
inc_pc();
break;
}
case BUZZVM_INSTR_EQ: {
buzzvm_eq(vm);
inc_pc();
break;
}
case BUZZVM_INSTR_NEQ: {
buzzvm_neq(vm);
inc_pc();
break;
}
case BUZZVM_INSTR_GT: {
buzzvm_gt(vm);
inc_pc();
break;
}
case BUZZVM_INSTR_GTE: {
buzzvm_gte(vm);
inc_pc();
break;
}
case BUZZVM_INSTR_LT: {
buzzvm_lt(vm);
inc_pc();
break;
}
case BUZZVM_INSTR_LTE: {
buzzvm_lte(vm);
inc_pc();
break;
}
case BUZZVM_INSTR_GLOAD: {
inc_pc();
buzzvm_gload(vm);
break;
}
case BUZZVM_INSTR_GSTORE: {
inc_pc();
if(buzzvm_gstore(vm) != BUZZVM_STATE_READY) return vm->state;
break;
}
case BUZZVM_INSTR_PUSHT: {
buzzvm_pusht(vm);
inc_pc();
break;
}
case BUZZVM_INSTR_TPUT: {
if(buzzvm_tput(vm) != BUZZVM_STATE_READY) return vm->state;
inc_pc();
break;
}
case BUZZVM_INSTR_TGET: {
if(buzzvm_tget(vm) != BUZZVM_STATE_READY) return vm->state;
inc_pc();
break;
}
case BUZZVM_INSTR_CALLC: {
inc_pc();
if(buzzvm_callc(vm) != BUZZVM_STATE_READY) return vm->state;
assert_pc(vm->pc);
break;
}
case BUZZVM_INSTR_CALLS: {
inc_pc();
if(buzzvm_calls(vm) != BUZZVM_STATE_READY) return vm->state;
assert_pc(vm->pc);
break;
}
case BUZZVM_INSTR_PUSHF: {
inc_pc();
get_arg(float);
if(buzzvm_pushf(vm, arg) != BUZZVM_STATE_READY) return vm->state;
break;
}
case BUZZVM_INSTR_PUSHI: {
inc_pc();
get_arg(int32_t);
if(buzzvm_pushi(vm, arg) != BUZZVM_STATE_READY) return vm->state;
break;
}
case BUZZVM_INSTR_PUSHS: {
inc_pc();
get_arg(int32_t);
if(buzzvm_pushs(vm, arg) != BUZZVM_STATE_READY) return vm->state;
break;
}
case BUZZVM_INSTR_PUSHCN: {
inc_pc();
get_arg(uint32_t);
if(buzzvm_pushcn(vm, arg) != BUZZVM_STATE_READY) return vm->state;
break;
}
case BUZZVM_INSTR_PUSHCC: {
inc_pc();
get_arg(uint32_t);
if(buzzvm_pushcc(vm, arg) != BUZZVM_STATE_READY) return vm->state;
break;
}
case BUZZVM_INSTR_PUSHL: {
inc_pc();
get_arg(uint32_t);
if(buzzvm_pushl(vm, arg) != BUZZVM_STATE_READY) return vm->state;
break;
}
case BUZZVM_INSTR_LLOAD: {
inc_pc();
get_arg(uint32_t);
buzzvm_lload(vm, arg);
break;
}
case BUZZVM_INSTR_LSTORE: {
inc_pc();
get_arg(uint32_t);
buzzvm_lstore(vm, arg);
break;
}
case BUZZVM_INSTR_JUMP: {
inc_pc();
get_arg(uint32_t);
vm->pc = arg;
assert_pc(vm->pc);
break;
}
case BUZZVM_INSTR_JUMPZ: {
inc_pc();
get_arg(uint32_t);
buzzvm_stack_assert(vm, 1);
if(buzzvm_stack_at(vm, 1)->o.type == BUZZTYPE_NIL ||
(buzzvm_stack_at(vm, 1)->o.type == BUZZTYPE_INT &&
buzzvm_stack_at(vm, 1)->i.value == 0)) {
vm->pc = arg;
assert_pc(vm->pc);
}
buzzvm_pop(vm);
break;
}
case BUZZVM_INSTR_JUMPNZ: {
inc_pc();
get_arg(uint32_t);
buzzvm_stack_assert(vm, 1);
if(buzzvm_stack_at(vm, 1)->o.type != BUZZTYPE_NIL &&
(buzzvm_stack_at(vm, 1)->o.type != BUZZTYPE_INT ||
buzzvm_stack_at(vm, 1)->i.value != 0)) {
vm->pc = arg;
assert_pc(vm->pc);
}
buzzvm_pop(vm);
break;
}
default:
buzzvm_seterror(vm, BUZZVM_ERROR_INSTR, NULL);
break;
}
return vm->state;
}
