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_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);
}
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;
}
int buzzvm_vstig_get(buzzvm_t 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;
/* Get key */
buzzvm_lload(vm, 1);
buzzobj_t k = buzzvm_stack_at(vm, 1);
/* Look for virtual stigmergy */
buzzvstig_t* vs = buzzdict_get(vm->vstigs, &id, buzzvstig_t);
if(vs) {
/* Virtual stigmergy found */
/* Look for key and push result */
buzzvstig_elem_t* e = buzzvstig_fetch(*vs, &k);
if(e) {
/* Key found */
buzzvm_push(vm, (*e)->data);
/* Append the message to the out message queue */
buzzoutmsg_queue_append_vstig(vm->outmsgs, BUZZMSG_VSTIG_QUERY, id, k, *e);
}
else {
/* Key not found, add a new one containing nil */
buzzvm_pushnil(vm);
buzzvstig_elem_t x =
buzzvstig_elem_new(buzzvm_stack_at(vm, 1),
1, vm->robot);
/* Append the message to the out message queue */
buzzoutmsg_queue_append_vstig(vm->outmsgs, BUZZMSG_VSTIG_QUERY, id, k, x);
}
}
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_ret1(vm);
}
int buzzvstig_get(buzzvm_t vm) {
buzzvm_lnum_assert(vm, 1);
/* Get vstig id */
id_get();
/* Get key */
buzzvm_lload(vm, 1);
buzzobj_t k = buzzvm_stack_at(vm, 1);
/* Look for virtual stigmergy */
const buzzvstig_t* vs = buzzdict_get(vm->vstigs, &id, buzzvstig_t);
if(vs) {
/* Virtual stigmergy found */
/* Look for key and push result */
const buzzvstig_elem_t* e = buzzvstig_fetch(*vs, &k);
if(e) {
/* Key found */
buzzvm_push(vm, (*e)->data);
/* Append the message to the out message queue */
buzzoutmsg_queue_append_vstig(vm, BUZZMSG_VSTIG_QUERY, id, k, *e);
}
else {
/* Key not found, make a new one containing nil */
buzzvm_pushnil(vm);
buzzvstig_elem_t x =
buzzvstig_elem_new(buzzvm_stack_at(vm, 1), // nil value
0, // timestamp
vm->robot); // robot id
/* Append the message to the out message queue */
buzzoutmsg_queue_append_vstig(vm, BUZZMSG_VSTIG_QUERY, id, k, x);
free(x);
}
}
else {
/* No virtual stigmergy found, just push false */
/* If this happens, its a bug */
buzzvm_pushnil(vm);
}
/* Return the value found */
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;
}
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;
}