373 lines
12 KiB
C++
373 lines
12 KiB
C++
#include <lib94/lib94.hpp>
|
|
#include <functional>
|
|
#include <cassert>
|
|
|
|
namespace lib94 {
|
|
|
|
void enqueue_process(number_t pc);
|
|
|
|
extern instruction core[LIB94_CORE_SIZE];
|
|
extern number_t program_counter;
|
|
extern instruction a_instruction, b_instruction;
|
|
extern instruction *a_instruction_writable;
|
|
extern instruction *b_instruction_writable;
|
|
|
|
void add_written_instruction(const instruction *instr);
|
|
void add_read_instruction(const instruction *instr);
|
|
|
|
#define maybe_add_written_instruction(instr) \
|
|
if constexpr (uas) add_written_instruction(instr)
|
|
#define maybe_add_read_instruction(instr) \
|
|
if constexpr (uas) add_read_instruction(instr)
|
|
|
|
struct single_target {
|
|
number_t *ptr;
|
|
|
|
inline bool assign(const single_target &left, const single_target &right,
|
|
std::function<std::optional<number_t> (number_t, number_t)> f) {
|
|
|
|
std::optional<number_t> result = f(*left.ptr, *right.ptr);
|
|
if (result.has_value()) {
|
|
*ptr = result.value();
|
|
return true;
|
|
}
|
|
return false;
|
|
|
|
}
|
|
|
|
inline bool is_zero() {
|
|
return *ptr == 0;
|
|
}
|
|
|
|
inline bool dec_not_zero() {
|
|
*ptr = (*ptr + LIB94_CORE_SIZE - 1) % LIB94_CORE_SIZE;
|
|
return *ptr != 0;
|
|
}
|
|
|
|
inline bool equal_to(const single_target &other) {
|
|
return *ptr == *other.ptr;
|
|
}
|
|
|
|
inline bool less_than(const single_target &other) {
|
|
return *ptr < *other.ptr;
|
|
}
|
|
};
|
|
|
|
struct pair_target {
|
|
number_t *ptr1;
|
|
number_t *ptr2;
|
|
|
|
inline bool assign(const pair_target &left, const pair_target &right,
|
|
std::function<std::optional<number_t> (number_t, number_t)> f) {
|
|
bool to_return = true;
|
|
|
|
std::optional<number_t> result1 = f(*left.ptr1, *right.ptr1);
|
|
if (result1.has_value())
|
|
*ptr1 = result1.value();
|
|
else
|
|
to_return = false;
|
|
|
|
std::optional<number_t> result2 = f(*left.ptr2, *right.ptr2);
|
|
if (result2.has_value())
|
|
*ptr2 = result2.value();
|
|
else
|
|
to_return = false;
|
|
|
|
return to_return;
|
|
|
|
}
|
|
|
|
inline bool is_zero() {
|
|
return *ptr1 == 0 && *ptr2 == 0;
|
|
}
|
|
|
|
inline bool dec_not_zero() {
|
|
*ptr1 = (*ptr1 + LIB94_CORE_SIZE - 1) % LIB94_CORE_SIZE;
|
|
*ptr2 = (*ptr2 + LIB94_CORE_SIZE - 1) % LIB94_CORE_SIZE;
|
|
return *ptr1 != 0 || *ptr2 != 0;
|
|
}
|
|
|
|
inline bool equal_to(const pair_target &other) {
|
|
return *ptr1 == *other.ptr1 &&
|
|
*ptr2 == *other.ptr2;
|
|
}
|
|
|
|
inline bool less_than(const pair_target &other) {
|
|
return *ptr1 < *other.ptr1 &&
|
|
*ptr2 < *other.ptr2;
|
|
}
|
|
};
|
|
|
|
struct instruction_target {
|
|
instruction *instr;
|
|
|
|
inline bool assign(const instruction_target &left, const instruction_target &right,
|
|
std::function<std::optional<number_t> (number_t, number_t)> f) {
|
|
bool to_return = true;
|
|
|
|
std::optional<number_t> result1 = f(left.instr->anumber, right.instr->anumber);
|
|
if (result1.has_value())
|
|
instr->anumber = result1.value();
|
|
else
|
|
to_return = false;
|
|
|
|
std::optional<number_t> result2 = f(left.instr->bnumber, right.instr->bnumber);
|
|
if (result2.has_value())
|
|
instr->bnumber = result2.value();
|
|
else
|
|
to_return = false;
|
|
|
|
return to_return;
|
|
|
|
}
|
|
|
|
inline bool is_zero() {
|
|
return instr->anumber == 0 && instr->bnumber == 0;
|
|
}
|
|
|
|
inline bool dec_not_zero() {
|
|
instr->anumber = (instr->anumber + LIB94_CORE_SIZE - 1) % LIB94_CORE_SIZE;
|
|
instr->bnumber = (instr->bnumber + LIB94_CORE_SIZE - 1) % LIB94_CORE_SIZE;
|
|
return instr->anumber != 0 || instr->bnumber != 0;
|
|
}
|
|
|
|
inline bool equal_to(const instruction_target &other) {
|
|
return instr->op == other.instr->op &&
|
|
instr->mod == other.instr->mod &&
|
|
instr->amode == other.instr->amode &&
|
|
instr->anumber == other.instr->anumber &&
|
|
instr->bmode == other.instr->bmode &&
|
|
instr->bnumber == other.instr->bnumber;
|
|
}
|
|
|
|
inline bool less_than(const instruction_target &other) {
|
|
return instr->anumber < other.instr->anumber &&
|
|
instr->bnumber < other.instr->bnumber;
|
|
}
|
|
};
|
|
|
|
template<modifier mod>
|
|
struct target;
|
|
|
|
template<> struct target<A> : single_target {};
|
|
template<> struct target<B> : single_target {};
|
|
template<> struct target<AB> : single_target {};
|
|
template<> struct target<BA> : single_target {};
|
|
template<> struct target<F> : pair_target {};
|
|
template<> struct target<X> : pair_target {};
|
|
template<> struct target<I> : instruction_target {};
|
|
|
|
template<opcode op, modifier mod, bool uas>
|
|
bool execute() {
|
|
target<mod> dest_out;
|
|
target<mod> dest_in;
|
|
target<mod> src_in;
|
|
|
|
if constexpr (mod == A) {
|
|
dest_out.ptr = &b_instruction_writable->anumber;
|
|
dest_in.ptr = &b_instruction.anumber;
|
|
src_in.ptr = &a_instruction.anumber;
|
|
}
|
|
|
|
else if constexpr (mod == B) {
|
|
dest_out.ptr = &b_instruction_writable->bnumber;
|
|
dest_in.ptr = &b_instruction.bnumber;
|
|
src_in.ptr = &a_instruction.bnumber;
|
|
}
|
|
|
|
else if constexpr (mod == AB) {
|
|
dest_out.ptr = &b_instruction_writable->bnumber;
|
|
dest_in.ptr = &b_instruction.bnumber;
|
|
src_in.ptr = &a_instruction.anumber;
|
|
}
|
|
|
|
else if constexpr (mod == BA) {
|
|
dest_out.ptr = &b_instruction_writable->anumber;
|
|
dest_in.ptr = &b_instruction.anumber;
|
|
src_in.ptr = &a_instruction.bnumber;
|
|
}
|
|
|
|
else if constexpr (mod == F) {
|
|
dest_out.ptr1 = &b_instruction_writable->anumber;
|
|
dest_out.ptr2 = &b_instruction_writable->bnumber;
|
|
dest_in.ptr1 = &b_instruction.anumber;
|
|
dest_in.ptr2 = &b_instruction.bnumber;
|
|
src_in.ptr1 = &a_instruction.anumber;
|
|
src_in.ptr2 = &a_instruction.bnumber;
|
|
}
|
|
|
|
else if constexpr (mod == X) {
|
|
dest_out.ptr1 = &b_instruction_writable->anumber;
|
|
dest_out.ptr2 = &b_instruction_writable->bnumber;
|
|
dest_in.ptr1 = &b_instruction.anumber;
|
|
dest_in.ptr2 = &b_instruction.bnumber;
|
|
src_in.ptr1 = &a_instruction.bnumber;
|
|
src_in.ptr2 = &a_instruction.anumber;
|
|
}
|
|
|
|
else if constexpr (mod == I) {
|
|
dest_out.instr = b_instruction_writable;
|
|
dest_in.instr = &b_instruction;
|
|
src_in.instr = &a_instruction;
|
|
}
|
|
|
|
else assert(false);
|
|
|
|
if constexpr (op == DAT)
|
|
return false;
|
|
|
|
else if constexpr (op == MOV) {
|
|
maybe_add_read_instruction(a_instruction_writable);
|
|
maybe_add_written_instruction(b_instruction_writable);
|
|
if constexpr (mod == I) {
|
|
dest_out.instr->op = src_in.instr->op;
|
|
dest_out.instr->mod = src_in.instr->mod;
|
|
dest_out.instr->amode = src_in.instr->amode;
|
|
dest_out.instr->bmode = src_in.instr->bmode;
|
|
}
|
|
return dest_out.assign(dest_in, src_in, [](number_t a, number_t b) -> std::optional<number_t> {
|
|
(void)a;
|
|
return b;
|
|
});
|
|
}
|
|
|
|
else if constexpr (op == ADD) {
|
|
maybe_add_read_instruction(a_instruction_writable);
|
|
maybe_add_read_instruction(b_instruction_writable);
|
|
maybe_add_written_instruction(b_instruction_writable);
|
|
return dest_out.assign(dest_in, src_in, [](number_t a, number_t b) -> std::optional<number_t> {
|
|
return (a + b) % LIB94_CORE_SIZE;
|
|
});
|
|
}
|
|
|
|
else if constexpr (op == SUB) {
|
|
maybe_add_read_instruction(a_instruction_writable);
|
|
maybe_add_read_instruction(b_instruction_writable);
|
|
maybe_add_written_instruction(b_instruction_writable);
|
|
return dest_out.assign(dest_in, src_in, [](number_t a, number_t b) -> std::optional<number_t> {
|
|
return (a + LIB94_CORE_SIZE - b) % LIB94_CORE_SIZE;
|
|
});
|
|
}
|
|
|
|
else if constexpr (op == MUL) {
|
|
maybe_add_read_instruction(a_instruction_writable);
|
|
maybe_add_read_instruction(b_instruction_writable);
|
|
maybe_add_written_instruction(b_instruction_writable);
|
|
return dest_out.assign(dest_in, src_in, [](number_t a, number_t b) -> std::optional<number_t> {
|
|
return (a * b) % LIB94_CORE_SIZE;
|
|
});
|
|
}
|
|
|
|
else if constexpr (op == DIV) {
|
|
maybe_add_read_instruction(a_instruction_writable);
|
|
maybe_add_read_instruction(b_instruction_writable);
|
|
maybe_add_written_instruction(b_instruction_writable);
|
|
return dest_out.assign(dest_in, src_in, [](number_t a, number_t b) -> std::optional<number_t> {
|
|
if (b == 0)
|
|
return {};
|
|
return a / b;
|
|
});
|
|
}
|
|
|
|
else if constexpr (op == MOD) {
|
|
maybe_add_read_instruction(a_instruction_writable);
|
|
maybe_add_read_instruction(b_instruction_writable);
|
|
maybe_add_written_instruction(b_instruction_writable);
|
|
return dest_out.assign(dest_in, src_in, [](number_t a, number_t b) -> std::optional<number_t> {
|
|
if (b == 0)
|
|
return {};
|
|
return a % b;
|
|
});
|
|
}
|
|
|
|
else if constexpr (op == JMP) {
|
|
maybe_add_read_instruction(a_instruction_writable);
|
|
program_counter = (a_instruction_writable - core + LIB94_CORE_SIZE - 1) % LIB94_CORE_SIZE;
|
|
return true;
|
|
}
|
|
|
|
else if constexpr (op == JMZ) {
|
|
maybe_add_read_instruction(a_instruction_writable);
|
|
maybe_add_read_instruction(b_instruction_writable);
|
|
if (dest_in.is_zero())
|
|
program_counter = (a_instruction_writable - core + LIB94_CORE_SIZE - 1) % LIB94_CORE_SIZE;
|
|
return true;
|
|
}
|
|
|
|
else if constexpr (op == JMN) {
|
|
maybe_add_read_instruction(a_instruction_writable);
|
|
maybe_add_read_instruction(b_instruction_writable);
|
|
if (!dest_in.is_zero())
|
|
program_counter = (a_instruction_writable - core + LIB94_CORE_SIZE - 1) % LIB94_CORE_SIZE;
|
|
return true;
|
|
}
|
|
|
|
else if constexpr (op == DJN) {
|
|
maybe_add_read_instruction(a_instruction_writable);
|
|
maybe_add_read_instruction(b_instruction_writable);
|
|
maybe_add_written_instruction(b_instruction_writable);
|
|
if (dest_out.dec_not_zero())
|
|
program_counter = (a_instruction_writable - core + LIB94_CORE_SIZE - 1) % LIB94_CORE_SIZE;
|
|
return true;
|
|
}
|
|
|
|
else if constexpr (op == SEQ) {
|
|
maybe_add_read_instruction(a_instruction_writable);
|
|
maybe_add_read_instruction(b_instruction_writable);
|
|
if (src_in.equal_to(dest_in))
|
|
program_counter = (program_counter + 1) % LIB94_CORE_SIZE;
|
|
return true;
|
|
}
|
|
|
|
else if constexpr (op == SNE) {
|
|
maybe_add_read_instruction(a_instruction_writable);
|
|
maybe_add_read_instruction(b_instruction_writable);
|
|
if (!src_in.equal_to(dest_in))
|
|
program_counter = (program_counter + 1) % LIB94_CORE_SIZE;
|
|
return true;
|
|
}
|
|
|
|
else if constexpr (op == SLT) {
|
|
maybe_add_read_instruction(a_instruction_writable);
|
|
maybe_add_read_instruction(b_instruction_writable);
|
|
if (src_in.less_than(dest_in))
|
|
program_counter = (program_counter + 1) % LIB94_CORE_SIZE;
|
|
return true;
|
|
}
|
|
|
|
else if constexpr (op == SPL) {
|
|
maybe_add_read_instruction(a_instruction_writable);
|
|
enqueue_process((program_counter + 1) % LIB94_CORE_SIZE);
|
|
program_counter = (a_instruction_writable - core + LIB94_CORE_SIZE - 1) % LIB94_CORE_SIZE;
|
|
return true;
|
|
}
|
|
|
|
else if constexpr (op == NOP)
|
|
return true;
|
|
|
|
else assert(false);
|
|
}
|
|
|
|
#define EXECUTOR_INST_LINE(mod, uas) \
|
|
template bool execute<DAT, mod, uas>(); template bool execute<MOV, mod, uas>(); \
|
|
template bool execute<ADD, mod, uas>(); template bool execute<SUB, mod, uas>(); \
|
|
template bool execute<MUL, mod, uas>(); template bool execute<DIV, mod, uas>(); \
|
|
template bool execute<MOD, mod, uas>(); template bool execute<JMP, mod, uas>(); \
|
|
template bool execute<JMZ, mod, uas>(); template bool execute<JMN, mod, uas>(); \
|
|
template bool execute<DJN, mod, uas>(); template bool execute<SEQ, mod, uas>(); \
|
|
template bool execute<SNE, mod, uas>(); template bool execute<SLT, mod, uas>(); \
|
|
template bool execute<SPL, mod, uas>(); template bool execute<NOP, mod, uas>();
|
|
|
|
#define EXECUTOR_INST(uas) \
|
|
EXECUTOR_INST_LINE(A, uas) \
|
|
EXECUTOR_INST_LINE(B, uas) \
|
|
EXECUTOR_INST_LINE(AB, uas) \
|
|
EXECUTOR_INST_LINE(BA, uas) \
|
|
EXECUTOR_INST_LINE(F, uas) \
|
|
EXECUTOR_INST_LINE(X, uas) \
|
|
EXECUTOR_INST_LINE(I, uas)
|
|
|
|
EXECUTOR_INST(true)
|
|
EXECUTOR_INST(false)
|
|
|
|
}
|