Website Summary Files Commits Branches @commit @diff @stats
path: root / spasm / src / spasm.cpp
diff options
context:
space:
mode:
1 files changed, 517 insertions, 0 deletions
-rw-r--r--spasm/src/spasm.cpp517
diff --git a/spasm/src/spasm.cpp b/spasm/src/spasm.cpp
new file mode 100644
index 0000000..94086a6
--- /dev/null
+++ b/spasm/src/spasm.cpp
@@ -0,0 +1,517 @@
+#include <algorithm>
+#include <cassert>
+#include <iostream>
+
+#include "spasm.hpp"
+
+namespace SpasmImpl
+{
+Spasm::Spasm() {}
+
+/*!
+** Constructs new Spasm object
+**
+** \param _bc_size - size/length of the bytecode
+** \param _bytecode - the bytecode of the program
+** \param _istr - input stream for the machine
+** \param _ostr - output stream for the machine
+*/
+void Spasm::Initialize(PC_t _bc_size,
+ const byte* _bytecode,
+ std::istream& _istr,
+ std::ostream& _ostr)
+
+{
+ m_PC = 0;
+ m_ByteCode.assign(_bytecode, _bytecode + _bc_size);
+ istr = &_istr;
+ ostr = &_ostr;
+ data_stack.resize(1024);
+ m_SP = &data_stack[0];
+ m_FP = &data_stack[0];
+}
+
+Spasm::~Spasm() {}
+
+/*!
+** Runs the machine. The machine stops if it reaches an invalid opcode
+** or opcode 0 or the pc reaches beyond the end of the bytecode.
+** @return error code for success or failure
+*/
+Spasm::RunResult Spasm::run()
+{
+ const auto codeSize = m_ByteCode.size();
+ while (m_PC < codeSize)
+ {
+ const auto instruction = m_ByteCode[m_PC++];
+ const auto opcode = OpCodes(instruction & 0x3f);
+ const auto size = instruction >> 6;
+ switch (opcode)
+ {
+ case OpCodes::Halt:
+ return RunResult::Success;
+ case OpCodes::Dup:
+ dup();
+ break;
+ case OpCodes::Pop:
+ {
+ const auto count = PC_t(read_reg(size));
+ assert(m_SP - count >= m_FP);
+ m_SP -= count;
+ break;
+ }
+ case OpCodes::PopTo:
+ {
+ const auto arg0 = read_reg(size);
+ popto(arg0);
+ break;
+ }
+ case OpCodes::PushFrom:
+ {
+ const auto arg0 = read_reg(size);
+ push(arg0);
+ break;
+ }
+ case OpCodes::Push:
+ {
+ const auto count = PC_t(read_reg(size));
+ assert(m_SP + count <= &data_stack[data_stack.size() - 1]);
+ std::fill(m_SP, m_SP + count, data_t{});
+ m_SP += count;
+ break;
+ }
+ case OpCodes::Print:
+ {
+ const auto arg0 = read_reg(size);
+ print(arg0);
+ break;
+ }
+ case OpCodes::Read:
+ {
+ const auto arg0 = read_reg(size);
+ read(arg0);
+ break;
+ }
+ case OpCodes::Call:
+ {
+ const auto arg0 = read_reg(size);
+ call(arg0);
+ break;
+ }
+ case OpCodes::Ret:
+ {
+ const auto arg0 = read_reg(size);
+ ret(arg0);
+ break;
+ }
+ case OpCodes::Jump:
+ {
+ const auto arg0 = read_reg(size);
+ go(arg0);
+ break;
+ }
+ case OpCodes::JumpT:
+ {
+ const auto arg0 = read_reg(size);
+ const auto arg1 = read_reg(size);
+ gotrue(arg0, arg1);
+ break;
+ }
+ case OpCodes::JumpF:
+ {
+ const auto arg0 = read_reg(size);
+ const auto arg1 = read_reg(size);
+ gofalse(arg0, arg1);
+ break;
+ }
+ case OpCodes::Const:
+ {
+ const auto reg = read_reg(size);
+ const auto value = read_number(size);
+ set_local(reg, value);
+ break;
+ }
+ case OpCodes::String:
+ {
+ const auto reg = read_reg(size);
+ const auto value = read_string(size);
+ set_local(reg, value);
+ break;
+ }
+ case OpCodes::Add:
+ {
+ const auto arg0 = read_reg(size);
+ const auto arg1 = read_reg(size);
+ const auto arg2 = read_reg(size);
+ plus(arg0, arg1, arg2);
+ break;
+ }
+ case OpCodes::Sub:
+ {
+ const auto arg0 = read_reg(size);
+ const auto arg1 = read_reg(size);
+ const auto arg2 = read_reg(size);
+ minus(arg0, arg1, arg2);
+ break;
+ }
+ case OpCodes::Mul:
+ {
+ const auto arg0 = read_reg(size);
+ const auto arg1 = read_reg(size);
+ const auto arg2 = read_reg(size);
+ multiply(arg0, arg1, arg2);
+ break;
+ }
+ case OpCodes::Div:
+ {
+ const auto arg0 = read_reg(size);
+ const auto arg1 = read_reg(size);
+ const auto arg2 = read_reg(size);
+ divide(arg0, arg1, arg2);
+ break;
+ }
+ case OpCodes::Mod:
+ {
+ const auto arg0 = read_reg(size);
+ const auto arg1 = read_reg(size);
+ const auto arg2 = read_reg(size);
+ modulus(arg0, arg1, arg2);
+ break;
+ }
+ case OpCodes::Less:
+ {
+ const auto arg0 = read_reg(size);
+ const auto arg1 = read_reg(size);
+ const auto arg2 = read_reg(size);
+ less(arg0, arg1, arg2);
+ break;
+ }
+ case OpCodes::LessEq:
+ {
+ const auto arg0 = read_reg(size);
+ const auto arg1 = read_reg(size);
+ const auto arg2 = read_reg(size);
+ lesseq(arg0, arg1, arg2);
+ break;
+ }
+ case OpCodes::Greater:
+ {
+ const auto arg0 = read_reg(size);
+ const auto arg1 = read_reg(size);
+ const auto arg2 = read_reg(size);
+ greater(arg0, arg1, arg2);
+ break;
+ }
+ case OpCodes::GreaterEq:
+ {
+ const auto arg0 = read_reg(size);
+ const auto arg1 = read_reg(size);
+ const auto arg2 = read_reg(size);
+ greatereq(arg0, arg1, arg2);
+ break;
+ }
+ case OpCodes::Equal:
+ {
+ const auto arg0 = read_reg(size);
+ const auto arg1 = read_reg(size);
+ const auto arg2 = read_reg(size);
+ equal(arg0, arg1, arg2);
+ break;
+ }
+ case OpCodes::NotEqual:
+ {
+ const auto arg0 = read_reg(size);
+ const auto arg1 = read_reg(size);
+ const auto arg2 = read_reg(size);
+ not_equal(arg0, arg1, arg2);
+ break;
+ }
+ default:
+ {
+ std::cerr << opcode << ": not implemented" << std::endl;
+ return RunResult::NotImplemented;
+ }
+ }
+ }
+ return RunResult::Success;
+}
+
+/*!
+** Pushes the next data_t object on the data stack
+*/
+void Spasm::push(reg_t reg)
+{
+ push_data(get_local(reg));
+}
+
+void Spasm::popto(reg_t reg)
+{
+ m_FP[reg] = *(--m_SP);
+}
+
+/*!
+** Dups the data_t object on top of the data stack.
+*/
+void Spasm::dup()
+{
+ push_data(*(m_SP - 1));
+}
+
+/*!
+** Reads a data_t object from the input stream and pushes it on the data
+** stack.
+*/
+void Spasm::read(reg_t reg)
+{
+ data_t x;
+ *istr >> x;
+ set_local(reg, x);
+}
+
+/*!
+** Pops a data_t object from the data stack and prints it on the output
+** stream.
+*/
+void Spasm::print(reg_t reg)
+{
+ *ostr << get_local(reg);
+}
+
+/*!
+** Pops two data objects from the data stack and pushes their sum on the
+** data stack.
+*/
+void Spasm::plus(reg_t a0, reg_t a1, reg_t a2)
+{
+ set_local(a0, get_local(a1) + get_local(a2));
+}
+
+/*!
+** Pops two data objects from the data stack and pushes their difference
+** on the data stack.
+*/
+void Spasm::minus(reg_t a0, reg_t a1, reg_t a2)
+{
+ set_local(a0, get_local(a1) - get_local(a2));
+}
+
+/*!
+** Pops two data objects from the data stack and pushes their product
+** on the data stack.
+*/
+void Spasm::multiply(reg_t a0, reg_t a1, reg_t a2)
+{
+ set_local(a0, get_local(a1) * get_local(a2));
+}
+
+/*!
+** Pops two data objects from the data stack and pushes their division
+** on the data stack.
+*/
+void Spasm::divide(reg_t a0, reg_t a1, reg_t a2)
+{
+ set_local(a0, get_local(a1) / get_local(a2));
+}
+
+/*!
+** Pops two data objects from the data stack and pushes their modulus
+** on the data stack.
+*/
+void Spasm::modulus(reg_t a0, reg_t a1, reg_t a2)
+{
+ set_local(a0, get_local(a1) % get_local(a2));
+}
+
+/*!
+** Conditional execution.
+** If the data_t object on top of the data stack evaluates to true
+** execution continues from the place pointed by number in the next bytes
+*/
+void Spasm::gotrue(reg_t a0, reg_t a1)
+{
+ if (get_local(a0))
+ {
+ go(a1);
+ }
+}
+
+/*!
+** Conditional execution.
+** If the data_t object on top of the data stack evaluates to false
+** execution continues from the place pointed by number in the next bytes
+*/
+void Spasm::gofalse(reg_t a0, reg_t a1)
+{
+ if (!get_local(a0))
+ {
+ go(a1);
+ }
+}
+
+/*!
+** Unconditional execution.
+** Execution continues from the opcode pointed by the next bytes
+*/
+void Spasm::go(reg_t a0)
+{
+ m_PC = PC_t(a0);
+}
+
+/*!
+** Function call. A new frame with the specified size is created, the
+** return address is saved in the return stack and the new pc is loaded.
+*/
+void Spasm::call(reg_t a0)
+{
+ Frame call{m_PC, PC_t(m_FP - &data_stack[0]),
+ m_SP - &data_stack[0] - PC_t((*(m_SP - 1)).get_double()) - 1};
+ m_Frames.push(std::move(call));
+ m_FP = m_SP - 1;
+ go(a0);
+}
+
+/*!
+** Function return. The frame of the current function is destroyed and the
+** saved return address is loaded in the pc
+*/
+void Spasm::ret(reg_t reg)
+{
+ Frame parent = m_Frames.top();
+ m_Frames.pop();
+ m_SP = &data_stack[parent.StackPointer];
+ *(m_SP - 1) = m_FP[reg];
+ m_FP = &data_stack[parent.FramePointer];
+ m_PC = parent.ReturnAddress;
+}
+
+/*!
+** Local variable with index top of the data stack is pushed on top of the
+** data stack.
+*/
+void Spasm::load()
+{
+ assert(false && "not-implemented");
+}
+
+/*!
+** Local variable is assigned value
+*/
+void Spasm::store()
+{
+ assert(false && "not-implemented");
+}
+
+/*!
+** Compares the values on top of the stack. Pushes 1 if the value before
+** the top of the stack is less than that on top of the stack.
+*/
+void Spasm::less(reg_t a0, reg_t a1, reg_t a2)
+{
+ set_local(a0, get_local(a1) < get_local(a2));
+}
+
+/*!
+** Compares the values on top of the stack. Pushes 1 if the value before
+** the top of the stack is less than or equal to that on top of the stack.
+*/
+void Spasm::lesseq(reg_t a0, reg_t a1, reg_t a2)
+{
+ set_local(a0, get_local(a1) <= get_local(a2));
+}
+
+void Spasm::greater(reg_t a0, reg_t a1, reg_t a2)
+{
+ set_local(a0, get_local(a1) > get_local(a2));
+}
+
+void Spasm::greatereq(reg_t a0, reg_t a1, reg_t a2)
+{
+ set_local(a0, get_local(a1) >= get_local(a2));
+}
+
+void Spasm::equal(reg_t a0, reg_t a1, reg_t a2)
+{
+ set_local(a0, get_local(a1) == get_local(a2));
+}
+
+void Spasm::not_equal(reg_t a0, reg_t a1, reg_t a2)
+{
+ set_local(a0, get_local(a1) != get_local(a2));
+}
+
+data_t Spasm::get_local(reg_t reg)
+{
+ assert(&data_stack[0] <= (m_FP + reg));
+ assert((m_FP + reg) < &data_stack[data_stack.size() - 1]);
+ return m_FP[reg];
+}
+
+void Spasm::set_local(reg_t reg, data_t data)
+{
+ assert(&data_stack[0] <= (m_FP + reg));
+ assert((m_FP + reg) < &data_stack[data_stack.size() - 1]);
+ m_FP[reg] = data;
+}
+
+data_t Spasm::pop_data()
+{
+ auto result = data_stack.back();
+ data_stack.pop_back();
+ return result;
+}
+
+void Spasm::push_data(data_t data)
+{
+ assert(m_SP < &data_stack[data_stack.size() - 1]);
+ *(m_SP++) = data;
+}
+
+reg_t Spasm::read_reg(size_t size)
+{
+ return read_integer(size);
+}
+
+data_t Spasm::read_number(size_t size)
+{
+ return data_t(double(read_integer(size)));
+}
+
+int64_t Spasm::read_integer(size_t size)
+{
+ switch (size)
+ {
+ case 0:
+ return m_ByteCode[m_PC++];
+ case 1:
+ {
+ auto result = *reinterpret_cast<int16_t*>(&m_ByteCode[0] + m_PC);
+ m_PC += 2;
+ return result;
+ }
+ case 2:
+ {
+ auto result = *reinterpret_cast<int32_t*>(&m_ByteCode[0] + m_PC);
+ m_PC += 4;
+ return result;
+ }
+ case 3:
+ {
+ auto result = *reinterpret_cast<int64_t*>(&m_ByteCode[0] + m_PC);
+ m_PC += 8;
+ return result;
+ }
+ }
+ assert(false && "not reached");
+ return 0;
+}
+
+data_t Spasm::read_string(size_t size)
+{
+ const auto length = size_t(read_integer(size));
+ const auto s = reinterpret_cast<const char*>(&m_ByteCode[m_PC]);
+ m_PC += length;
+ const auto value = m_Strings.Get(s, length);
+ return data_t(::Spasm::ValueType::String, (void*)value);
+}
+
+} // namespace SpasmImpl