// Check every op manipulates the stack correctly
TEST op_stack_size() {
for (size_t i = 0; i < E_OP__LENGTH; i++) {
const tele_op_t *op = tele_ops[i];
if (op->get != NULL) {
scene_state_t ss = {}; // initalise to empty
// (needs dedicated initaliser)
exec_state_t es;
es_init(&es);
es_push(&es);
es_variables(&es)->script_number = 1;
command_state_t cs;
cs_init(&cs);
// add params to stack (plus an extra 2, to check that too many
// values aren't removed, warning: note the maximum stack size in
// state.h)
const int16_t stack_extra = 2;
for (int j = 0; j < op->params + stack_extra; j++) cs_push(&cs, 0);
// execute get
op->get(op->data, &ss, &es, &cs);
// check that the stack has the correct number of items in it
if (op->returns) {
ASSERT_EQm(op->name, cs_stack_size(&cs), stack_extra + 1);
}
else {
ASSERT_EQm(op->name, cs_stack_size(&cs), stack_extra);
}
}
if (op->set != NULL) {
scene_state_t ss = {}; // initalise to empty
// (needs dedicated initaliser)
exec_state_t es;
es_init(&es);
command_state_t cs;
cs_init(&cs);
// add params to stack (plus an extra 2, to check that too many
// values aren't removed, warning: note the maximum stack size in
// state.h)
// set functions require an extra value on the stack
const int16_t stack_extra = 2;
for (int j = 0; j < op->params + stack_extra + 1; j++)
cs_push(&cs, 0);
// execute get
op->set(op->data, &ss, &es, &cs);
// check that the stack has the correct number of items in it
ASSERT_EQm(op->name, cs_stack_size(&cs), stack_extra);
}
}
PASS();
}
// Check every mod manipulates the stack correctly
TEST mod_stack_size() {
for (size_t i = 0; i < E_MOD__LENGTH; i++) {
const tele_mod_t *mod = tele_mods[i];
scene_state_t ss = {}; // initalise to empty
// (needs dedicated initaliser)
exec_state_t es;
es_init(&es);
command_state_t cs;
cs_init(&cs);
// add params to stack (plus an extra 2, to check that too many
// values aren't removed, warning: note the maximum stack size in
// state.h)
const int16_t stack_extra = 2;
for (int j = 0; j < mod->params + stack_extra; j++) cs_push(&cs, 0);
// execute func
const tele_command_t sub_command = { .length = 1,
.separator = 0,
.data = { { .tag = OP,
.value = E_OP_A } } };
mod->func(&ss, &es, &cs, &sub_command);
// check that the stack has the correct number of items in it
ASSERT_EQm(mod->name, cs_stack_size(&cs), stack_extra);
}
// run a single command inside a given exec_state
process_result_t process_command(scene_state_t *ss, exec_state_t *es,
const tele_command_t *c) {
command_state_t cs;
cs_init(&cs); // initialise this here as well as inside the loop, in case
// the command has 0 length
// 1. Do we have a PRE seperator?
// ------------------------------
// if we do then only process the PRE part, the MOD will determine if the
// POST should be run and take care of running it
ssize_t start_idx = 0;
ssize_t end_idx = c->separator == -1 ? c->length : c->separator;
// 2. Determine the location of all the SUB commands
// -------------------------------------------------
// an array of structs to hold the start and end of each sub command
struct sub_idx {
ssize_t start;
ssize_t end;
} subs[COMMAND_MAX_LENGTH];
ssize_t sub_len = 0;
ssize_t sub_start = 0;
// iterate through c->data to find all the SUB_SEPs and add to the array
for (ssize_t idx = start_idx; idx < end_idx; idx++) {
tele_word_t word_type = c->data[idx].tag;
if (word_type == SUB_SEP && idx > sub_start) {
subs[sub_len].start = sub_start;
subs[sub_len].end = idx - 1;
sub_len++;
sub_start = idx + 1;
}
}
// the last sub command won't have been added, manually add it here
if (end_idx > sub_start) {
subs[sub_len].start = sub_start;
subs[sub_len].end = end_idx - 1;
sub_len++;
}
// 3. Loop through each sub command and execute it
// -----------------------------------------------
// iterate through sub commands from left to right
for (ssize_t sub_idx = 0; sub_idx < sub_len && !es_variables(es)->breaking;
sub_idx++) {
const ssize_t sub_start = subs[sub_idx].start;
const ssize_t sub_end = subs[sub_idx].end;
// initialise the command state for each sub, otherwise a value left on
// the stack for the previous sub, can cause the set fn to trigger when
// it shouldn't
cs_init(&cs);
// as we are using a stack based language, we must process commands from
// right to left
for (ssize_t idx = sub_end; idx >= sub_start; idx--) {
const tele_word_t word_type = c->data[idx].tag;
const int16_t word_value = c->data[idx].value;
if (word_type == NUMBER) { cs_push(&cs, word_value); }
else if (word_type == OP) {
const tele_op_t *op = tele_ops[word_value];
// if we're in the first command position, and there is a set fn
// pointer and we have enough params, then run set, else run get
if (idx == sub_start && op->set != NULL &&
cs_stack_size(&cs) >= op->params + 1)
op->set(op->data, ss, es, &cs);
else
op->get(op->data, ss, es, &cs);
}
else if (word_type == MOD) {
tele_command_t post_command;
post_command.comment = false;
copy_post_command(&post_command, c);
tele_mods[word_value]->func(ss, es, &cs, &post_command);
}
}
}
// 4. Return
// ---------
// sometimes we have single value left of the stack, if so return it
if (cs_stack_size(&cs)) {
process_result_t o = {.has_value = true, .value = cs_pop(&cs) };
return o;
}
