tijmen/wassembly
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compile to bytecode

Browse Source
This commit is contained in:
Tijmen van Nesselrooij
2020-09-03 19:03:32 +02:00
parent 473334c3db
commit 96345ad6ba
45 changed files with 1615 additions and 1231 deletions
Download Patch File Download Diff File Expand all files Collapse all files

433
src/compile/compiler.cpp Normal file
View File

@@ -0,0 +1,433 @@
#include <compile/compiler.hpp>
#include <compile/errors.hpp>
#include <execute/bytecode.hpp>
#include <stdexcept>
#include <utils.hpp>
namespace Compile
{
int GetRequiredNumberOfArguments(Token::OperandType const type)
{
switch (type)
{
case Token::OperandType::AddInteger:
case Token::OperandType::SubtractInteger:
case Token::OperandType::DivideInteger:
case Token::OperandType::MultiplyInteger:
case Token::OperandType::ShiftIntegerLeft:
case Token::OperandType::ShiftIntegerRight:
return 3;
case Token::OperandType::LessThanInteger:
case Token::OperandType::GreaterThanInteger:
case Token::OperandType::EqualInteger:
case Token::OperandType::SetInteger:
return 2;
case Token::OperandType::Jump:
case Token::OperandType::CallFunction:
case Token::OperandType::Interrupt:
case Token::OperandType::PushInteger:
case Token::OperandType::PopInteger:
return 1;
default:
std::printf("WARNING: returning default argument length of 0 for operand type %i\n", static_cast<int>(type));
case Token::OperandType::ReturnFromFunction:
case Token::OperandType::ExitProgram:
return 0;
}
}
bool IsArgumentToken(Token::Token const & t)
{
return
t.type == Token::TokenType::ImmediateInteger ||
t.type == Token::TokenType::Register ||
t.type == Token::TokenType::LabelArgument ||
t.type == Token::TokenType::Memory;
}
bool IsReadableToken(Token::Token const & t)
{
return
t.type == Token::TokenType::ImmediateInteger ||
t.type == Token::TokenType::Register ||
t.type == Token::TokenType::Memory;
}
bool IsWriteableToken(Token::Token const & t)
{
return
t.type == Token::TokenType::Register ||
t.type == Token::TokenType::Memory;
}
void ValidateArguments(
std::vector<Token::Token> const & tokens,
std::size_t const operandIndex)
{
auto const operandType = std::get<Token::OperandType>(tokens[operandIndex].data);
switch(operandType)
{
// 2 Read values + 1 write value
case Token::OperandType::AddInteger:
case Token::OperandType::SubtractInteger:
case Token::OperandType::DivideInteger:
case Token::OperandType::MultiplyInteger:
case Token::OperandType::ShiftIntegerLeft:
case Token::OperandType::ShiftIntegerRight:
if (!IsReadableToken(tokens[operandIndex + 1]))
{
throw CompilationError::CreateExpectedImmediateOrRegisterOrMemory(tokens[operandIndex + 1]);
}
if (!IsReadableToken(tokens[operandIndex + 2]))
{
throw CompilationError::CreateExpectedImmediateOrRegisterOrMemory(tokens[operandIndex + 2]);
}
if (!IsWriteableToken(tokens[operandIndex + 3]))
{
throw CompilationError::CreateExpectedRegisterOrMemoryError(tokens[operandIndex + 3]);
}
break;
// 2 Read values
case Token::OperandType::LessThanInteger:
case Token::OperandType::GreaterThanInteger:
case Token::OperandType::EqualInteger:
case Token::OperandType::SetInteger:
if (!IsReadableToken(tokens[operandIndex + 1]))
{
throw CompilationError::CreateExpectedImmediateOrRegisterOrMemory(tokens[operandIndex + 1]);
}
if (!IsReadableToken(tokens[operandIndex + 2]))
{
throw CompilationError::CreateExpectedImmediateOrRegisterOrMemory(tokens[operandIndex + 2]);
}
break;
// 1 Label value
case Token::OperandType::Jump:
case Token::OperandType::CallFunction:
if (tokens[operandIndex + 1].type != Token::TokenType::LabelArgument)
{
throw CompilationError::CreateExpectedLabelError(tokens[operandIndex + 1]);
}
break;
// 1 Read value
case Token::OperandType::Interrupt:
case Token::OperandType::PushInteger:
if (!IsReadableToken(tokens[operandIndex + 1]))
{
throw CompilationError::CreateExpectedImmediateOrRegisterOrMemory(tokens[operandIndex + 1]);
}
break;
// 1 Write value
case Token::OperandType::PopInteger:
if (!IsWriteableToken(tokens[operandIndex + 1]))
{
throw CompilationError::CreateExpectedRegisterOrMemoryError(tokens[operandIndex + 1]);
}
break;
default:
throw std::runtime_error("Unimplemented operandType case in ValidateArguments");
}
}
Execute::RegisterByte GetByteCodeRegister(Token::RegisterType const v)
{
switch(v)
{
case Token::RegisterType::A:
return Execute::RegisterByte::A;
case Token::RegisterType::B:
return Execute::RegisterByte::B;
case Token::RegisterType::C:
return Execute::RegisterByte::C;
case Token::RegisterType::D:
return Execute::RegisterByte::D;
default:
throw std::runtime_error("Unhandled register type in GetByteCodeRegister");
}
}
void Compiler::InsertAsBytes(
Token::Token const & token,
std::vector<std::uint8_t> & bytes)
{
switch(token.type)
{
case Token::TokenType::ImmediateInteger:
bytes.push_back(static_cast<std::uint8_t>(Execute::InstructionByte::IMMEDIATE_INTEGER));
{
int value = std::get<int>(token.data);
auto const insertionIndex = bytes.size();
bytes.resize(bytes.size() + 4);
Utils::Bytes::Write(value, bytes, insertionIndex);
}
break;
case Token::TokenType::Operand:
{
switch(std::get<Token::OperandType>(token.data))
{
case Token::OperandType::AddInteger:
bytes.push_back(static_cast<std::uint8_t>(Execute::InstructionByte::ADD_INTEGER));
break;
case Token::OperandType::SubtractInteger:
bytes.push_back(static_cast<std::uint8_t>(Execute::InstructionByte::SUBTRACT_INTEGER));
break;
case Token::OperandType::DivideInteger:
bytes.push_back(static_cast<std::uint8_t>(Execute::InstructionByte::DIVIDE_INTEGER));
break;
case Token::OperandType::MultiplyInteger:
bytes.push_back(static_cast<std::uint8_t>(Execute::InstructionByte::MULTIPLY_INTEGER));
break;
case Token::OperandType::ShiftIntegerLeft:
bytes.push_back(static_cast<std::uint8_t>(Execute::InstructionByte::SHIFT_LEFT_INTEGER));
break;
case Token::OperandType::ShiftIntegerRight:
bytes.push_back(static_cast<std::uint8_t>(Execute::InstructionByte::SHIFT_RIGHT_INTEGER));
break;
case Token::OperandType::LessThanInteger:
bytes.push_back(static_cast<std::uint8_t>(Execute::InstructionByte::LESS_THAN_INTEGER));
break;
case Token::OperandType::GreaterThanInteger:
bytes.push_back(static_cast<std::uint8_t>(Execute::InstructionByte::GREATER_THAN_INTEGER));
break;
case Token::OperandType::EqualInteger:
bytes.push_back(static_cast<std::uint8_t>(Execute::InstructionByte::EQUALS_INTEGER));
break;
case Token::OperandType::SetInteger:
bytes.push_back(static_cast<std::uint8_t>(Execute::InstructionByte::SET_INTEGER));
break;
case Token::OperandType::Jump:
bytes.push_back(static_cast<std::uint8_t>(Execute::InstructionByte::JUMP));
break;
case Token::OperandType::CallFunction:
bytes.push_back(static_cast<std::uint8_t>(Execute::InstructionByte::CALL));
break;
case Token::OperandType::Interrupt:
bytes.push_back(static_cast<std::uint8_t>(Execute::InstructionByte::INTERRUPT));
break;
case Token::OperandType::PushInteger:
bytes.push_back(static_cast<std::uint8_t>(Execute::InstructionByte::PUSH_INTEGER));
break;
case Token::OperandType::PopInteger:
bytes.push_back(static_cast<std::uint8_t>(Execute::InstructionByte::POP_INTEGER));
break;
case Token::OperandType::ReturnFromFunction:
bytes.push_back(static_cast<std::uint8_t>(Execute::InstructionByte::RETURN));
break;
case Token::OperandType::ExitProgram:
bytes.push_back(static_cast<std::uint8_t>(Execute::InstructionByte::EXIT));
break;
break;
default:
throw std::runtime_error("Unhandled operand type in InsertAsBytes");
}
}
break;
case Token::TokenType::Register:
bytes.push_back(static_cast<std::uint8_t>(Execute::InstructionByte::REGISTER));
bytes.push_back(static_cast<std::uint8_t>(GetByteCodeRegister(std::get<Token::RegisterType>(token.data))));
break;
case Token::TokenType::StatementEnd:
case Token::TokenType::LabelDefinition:
// NO OP
break;
case Token::TokenType::LabelArgument:
{
bytes.push_back(static_cast<std::uint8_t>(Execute::InstructionByte::LABEL));
auto const & label = std::get<std::string>(token.data);
auto const findResult = jumpLabelLocations.find(label);
int jumpLocation = 0;
if (findResult == jumpLabelLocations.end())
{
unresolvedJumpLabels.push_back(std::make_pair(token, bytes.size()));
}
else
{
jumpLocation = findResult->second;
}
auto const insertionIndex = bytes.size();
bytes.resize(bytes.size() + 4);
Utils::Bytes::Write(jumpLocation, bytes, insertionIndex);
}
break;
case Token::TokenType::Memory:
{
bytes.push_back(static_cast<std::uint8_t>(Execute::InstructionByte::MEMORY_OP));
switch(token.valueType)
{
case Token::TokenValueType::Register:
bytes.push_back(static_cast<std::uint8_t>(Execute::InstructionByte::REGISTER));
bytes.push_back(static_cast<std::uint8_t>(GetByteCodeRegister(std::get<Token::RegisterType>(token.data))));
break;
case Token::TokenValueType::Integer:
bytes.push_back(static_cast<std::uint8_t>(Execute::InstructionByte::IMMEDIATE_INTEGER));
{
auto const insertionIndex = bytes.size();
bytes.resize(bytes.size() + 4);
Utils::Bytes::Write(std::get<int>(token.data), bytes, insertionIndex);
}
break;
default:
throw std::runtime_error("Unhandled value type for memory operand in InsertAsBytes");
}
}
break;
default:
throw std::runtime_error("Unhandled token type in InsertAsBytes");
}
}
bool Compiler::Compile(
std::vector<Token::Token> const & tokens,
std::vector<std::uint8_t> & bytes)
{
jumpLabelLocations.clear();
unresolvedJumpLabels.clear();
enum class State
{
FindOperand,
FindArguments,
FindStatementEnd
};
State state = State::FindOperand;
Token::OperandType operandType;
unsigned operatorTokenIndex = 0u;
int expectedNumberOfArguments = 0;
for(std::size_t i = 0u; i < tokens.size(); ++i)
{
auto const & token = tokens[i];
InsertAsBytes(token, bytes);
switch(state)
{
case State::FindOperand:
switch(token.type)
{
case Token::TokenType::Operand:
operatorTokenIndex = i;
operandType = std::get<Token::OperandType>(token.data);
expectedNumberOfArguments = GetRequiredNumberOfArguments(operandType);
if (expectedNumberOfArguments < 1)
{
state = State::FindStatementEnd;
}
else
{
state = State::FindArguments;
}
break;
case Token::TokenType::LabelDefinition:
{
auto findResult = jumpLabelLocations.find(std::get<std::string>(token.data));
if (findResult == jumpLabelLocations.end())
{
jumpLabelLocations[std::get<std::string>(token.data)] = bytes.size();
}
else
{
throw CompilationError::CreateDuplicateLabelError(token);
}
}
break;
case Token::TokenType::StatementEnd:
// NO OP
break;
default:
throw CompilationError::CreateExpectedOperandError(token);
}
break;
case State::FindArguments:
if (IsArgumentToken(token))
{
expectedNumberOfArguments -= 1;
if (expectedNumberOfArguments < 1)
{
ValidateArguments(tokens, operatorTokenIndex);
state = State::FindStatementEnd;
}
}
else
{
// TODO Further specify this error?
throw CompilationError::CreateExpectedArgumentError(token);
}
break;
case State::FindStatementEnd:
if (token.type != Token::TokenType::StatementEnd)
{
// TODO Further specify this error?
throw CompilationError::CreateExpectedEndOfStatementError(token);
}
else
{
InsertAsBytes(
token,
bytes);
state = State::FindOperand;
}
break;
}
}
for(auto const & unresolved : unresolvedJumpLabels)
{
auto const & findResult = jumpLabelLocations.find(std::get<std::string>(unresolved.first.data));
if (findResult == jumpLabelLocations.end())
{
throw CompilationError::CreateNonExistingLabelError(unresolved.first);
}
int const jumpLocation = findResult->second;
auto const index = unresolved.second;
Utils::Bytes::Write(jumpLocation, bytes, index);
}
return true;
}
}

75
src/compile/errors.cpp Normal file
View File

@@ -0,0 +1,75 @@
#include <compile/errors.hpp>
#include <sstream>
namespace Compile
{
CompilationError::CompilationError(
std::string const & message,
Token::Token const & token)
: errorToken(token)
{
errorToken.errorMessage = message;
}
CompilationError CompilationError::CreateExpectedArgumentError(Token::Token const & token)
{
return CompilationError("Expected an argument", token);
}
CompilationError CompilationError::CreateExpectedLabelError(Token::Token const & token)
{
return CompilationError("Expected a label", token);
}
CompilationError CompilationError::CreateExpectedImmediateError(Token::Token const & token)
{
return CompilationError("Expected an immediate value", token);
}
CompilationError CompilationError::CreateExpectedImmediateOrRegisterOrMemory(Token::Token const & token)
{
return CompilationError("Expected an immediate value, a register or a memory location", token);
}
CompilationError CompilationError::CreateExpectedRegisterError(Token::Token const & token)
{
return CompilationError("Expected a register", token);
}
CompilationError CompilationError::CreateExpectedRegisterOrMemoryError(Token::Token const & token)
{
return CompilationError("Expected a register or a memory location", token);
}
CompilationError CompilationError::CreateExpectedOperandError(Token::Token const & token)
{
return CompilationError("Expected an operand", token);
}
CompilationError CompilationError::CreateTooManyArgumentsError(Token::Token const & token)
{
return CompilationError("Too many arguments for operand", token);
}
CompilationError CompilationError::CreateTooFewArgumentsError(Token::Token const & token)
{
return CompilationError("Too few arguments for operand", token);
}
CompilationError CompilationError::CreateExpectedEndOfStatementError(Token::Token const & token)
{
std::stringstream ss;
ss << "Expected end of statement (;), but got " << token.GetName() << " instead";
return CompilationError(ss.str(), token);
}
CompilationError CompilationError::CreateDuplicateLabelError(Token::Token const & token)
{
return CompilationError("Duplicate label definition", token);
}
CompilationError CompilationError::CreateNonExistingLabelError(Token::Token const & token)
{
return CompilationError("Jumping to non existing label", token);
}
}

25
src/configuration.cpp
View File

@@ -1,25 +0,0 @@
#include <configuration.hpp>
void Configuration::PrepareMemory(std::vector<std::uint8_t> & memory) const
{
memory.resize(memorySize);
for(auto const & pair : strings)
{
for(std::size_t i = 0; i < pair.second.size(); ++i)
{
auto const index = i + pair.first;
if (index >= memory.size())
{
break;
}
memory[index] = pair.second[i];
}
}
}
Configuration::Configuration()
: memorySize(1024)
{
}

144
src/execute/argumentvalue.cpp Normal file
View File

@@ -0,0 +1,144 @@
#include <execute/argumentvalue.hpp>
#include <utils.hpp>
namespace Execute
{
int & ArgumentValue::GetRegister(State & state) const
{
switch(std::get<RegisterByte>(data))
{
case RegisterByte::A:
return state.registers.A;
case RegisterByte::B:
return state.registers.B;
case RegisterByte::C:
return state.registers.C;
case RegisterByte::D:
return state.registers.D;
default:
throw std::runtime_error("Unhandled register byte in GetRegister");
}
}
std::uint8_t * ArgumentValue::GetMemory(State & state) const
{
switch (memoryValueType)
{
case ArgumentType::Immediate:
return &(state.memory[std::get<int>(data)]);
case ArgumentType::Register:
return &(state.memory[GetRegister(state)]);
default:
throw std::runtime_error("Unhandled argument type in GetMemory");
}
}
void ArgumentValue::Write(int const value, State & state) const
{
if (type == ArgumentType::Immediate)
{
throw AttemptedWriteToImmediate(state.registers.programCounter);
}
switch(type)
{
case ArgumentType::Memory:
{
auto * ptr = GetMemory(state);
*ptr = value & 0xFF;
*(++ptr) = (value >> 8) & 0xFF;
*(++ptr) = (value >> 16) & 0xFF;
*(++ptr) = (value >> 24) & 0xFF;
}
break;
case ArgumentType::Register:
GetRegister(state) = value;
break;
default:
throw std::runtime_error("Unhandled argument type in Write");
}
}
int ArgumentValue::Read(State & state) const
{
switch(type)
{
case ArgumentType::Immediate:
return std::get<int>(data);
case ArgumentType::Memory:
{
int result = 0;
auto * ptr = GetMemory(state);
result |= static_cast<int>(*ptr);
result |= static_cast<int>(*(++ptr)) << 8;
result |= static_cast<int>(*(++ptr)) << 16;
result |= static_cast<int>(*(++ptr)) << 24;
}
break;
case ArgumentType::Register:
return GetRegister(state);
default:
throw std::runtime_error("Unhandled argument type in Read");
}
}
// Returns the size of the argument in bytes
std::size_t ArgumentValue::Parse(
std::vector<std::uint8_t> const & memory,
std::size_t const pos)
{
InstructionByte const valueByte = static_cast<InstructionByte>(memory[pos]);
switch(valueByte)
{
case InstructionByte::IMMEDIATE_INTEGER:
case InstructionByte::LABEL:
type = ArgumentType::Immediate;
data = Utils::Bytes::Read(memory, pos + 1);
return 5;
case InstructionByte::REGISTER:
type = ArgumentType::Register;
data = static_cast<RegisterByte>(memory[pos + 1]);
return 2;
case InstructionByte::MEMORY_OP:
{
type = ArgumentType::Memory;
InstructionByte const memoryArgTypeByte = static_cast<InstructionByte>(memory[pos + 1]);
switch(memoryArgTypeByte)
{
case InstructionByte::IMMEDIATE_INTEGER:
memoryValueType = ArgumentType::Immediate;
data = Utils::Bytes::Read(memory, pos + 2);
return 6;
case InstructionByte::REGISTER:
memoryValueType = ArgumentType::Register;
data = static_cast<RegisterByte>(memory[pos + 2]);
return 3;
default:
// TODO throw more specific error?
throw NonArgumentByte(pos);
}
}
break;
default:
throw NonArgumentByte(pos);
}
throw std::runtime_error("Reached end of function in Parse");
}
}

69
src/execute/error.cpp
View File

@@ -12,49 +12,54 @@ namespace Execute
{
}
RuntimeError::RuntimeError(std::string const & what)
: message(what)
RuntimeError::RuntimeError(
std::string const & what,
std::size_t const _byteLocation)
: message(what),
byteLocation(_byteLocation)
{
}
StackUnderflow::StackUnderflow()
: RuntimeError("Stack underflow error")
InterruptIndexOutOfRange::InterruptIndexOutOfRange(std::size_t const location, int const index)
: RuntimeError("", location)
{
}
StackOverflow::StackOverflow()
: RuntimeError("Stack overflow error")
{
}
MissingLabel::MissingLabel(std::string const & label)
{
message = "Missing jump/function label \"";
message += label;
message += '"';
}
InterruptIndexOutOfRange::InterruptIndexOutOfRange(int const index)
{
message = "Interrupt index ";
message = "Interrupt at byte ";
message += std::to_string(location);
message += " with index ";
message += std::to_string(index);
message += " is out of range";
}
OutOfMemory::OutOfMemory(int const memoryLocation, int const memorySize)
AttemptedWriteToImmediate::AttemptedWriteToImmediate(std::size_t const location)
: RuntimeError("", location)
{
message = "Attempted interaction at memory location ";
message += std::to_string(memoryLocation);
message += " with size ";
message += std::to_string(memorySize);
message += " failed";
message = "Instruction at ";
message += std::to_string(location);
message += " attempted to write to an immediate value";
}
namespace Internal
NonExecutableInstruction::NonExecutableInstruction(std::size_t const location)
: RuntimeError("", location)
{
BadValueType::BadValueType()
: RuntimeError("Internal error: bad value type")
{
}
message = "Attempted to execute byte at ";
message += std::to_string(location);
message += " which is not an instruction byte";
}
NonArgumentByte::NonArgumentByte(std::size_t const location)
: RuntimeError("", location)
{
message = "Expected an argument byte (immediate, register or memory location) at ";
message += std::to_string(location);
}
OutOfMemory::OutOfMemory(
std::size_t const requiredMemorySize,
std::size_t const actualMemorySize)
{
message = "Not enough memory to fit code. Actual size is ";
message += std::to_string(actualMemorySize);
message += ". Minimal required size is ";
message += std::to_string(requiredMemorySize);
}
}

60
src/execute/interrupts.cpp
View File

@@ -1,38 +1,43 @@
#include <cstdio>
#include <execute/error.hpp>
#include <execute/interrupts.hpp>
#include <vector>
namespace Execute
{
std::vector<InterruptFn> GetInterrupts()
void ExecuteInterrupt(
int const id,
Execute::Registers & registers,
std::vector<std::uint8_t> & memory)
{
return std::vector<InterruptFn>
switch(id)
{
/* STDOUT INTERRUPTS */
// 0 print char
[](Execute::Registers & registers, std::vector<std::uint8_t> & memory) { std::putc(registers.A, stdout); },
// 1 print decimal integer
[](Execute::Registers & registers, std::vector<std::uint8_t> & memory) { std::printf("%i", registers.A); },
// 2 print hexadecimal integer
[](Execute::Registers & registers, std::vector<std::uint8_t> & memory) { std::printf("0x%x", registers.A); },
// 3 print string from memory
[](Execute::Registers & registers, std::vector<std::uint8_t> & memory)
/* STDOUT interrupts */
case 0:
std::putc(registers.A, stdout);
break;
case 1:
std::printf("%i", registers.A);
break;
case 2:
std::printf("0x%x", registers.A);
break;
case 3:
{
unsigned const end = registers.A + registers.B;
if (end >= memory.size())
{
throw OutOfMemory(registers.A, registers.B);
}
// TODO handle out of bounds
for(unsigned i = registers.A; i < end; ++i)
{
std::putc(memory[i], stdout);
}
},
}
break;
/* STDIN INTERRUPTS */
// 4 get char from STDIN
[](Execute::Registers & registers, std::vector<std::uint8_t> & memory)
/* STDIN interrupts */
case 10:
{
registers.A = std::getchar();
if (registers.A == '\n')
@@ -41,9 +46,10 @@ namespace Execute
}
while(std::getchar() != '\n');
},
// 5 get string from STDIN
[](Execute::Registers & registers, std::vector<std::uint8_t> & memory)
}
break;
case 11:
{
if (registers.B <= 0)
{
@@ -77,7 +83,11 @@ namespace Execute
{
while(std::getchar() != '\n');
}
},
};
}
break;
default:
throw InterruptIndexOutOfRange(registers.programCounter, id);
}
}
}

28
src/execute/state.cpp Normal file
View File

@@ -0,0 +1,28 @@
#include <execute/state.hpp>
namespace Execute
{
void State::PushToStack(int const value)
{
memory[registers.stackPointer] = value & 0xFF;
memory[registers.stackPointer + 1] = (value >> 8) & 0xFF;
memory[registers.stackPointer + 2] = (value >> 16) & 0xFF;
memory[registers.stackPointer + 3] = (value >> 24) & 0xFF;
registers.stackPointer += 4;
return;
}
int State::PopFromStack()
{
int value = static_cast<int>(memory[registers.stackPointer - 1]) << 24;
value |= static_cast<int>(memory[registers.stackPointer - 2]) << 16;
value |= static_cast<int>(memory[registers.stackPointer - 3]) << 8;
value |= static_cast<int>(memory[registers.stackPointer - 4]);
registers.stackPointer -= 4;
return value;
}
}

430
src/execute/virtualmachine.cpp
View File

@@ -1,32 +1,399 @@
#include <execute/virtualmachine.hpp>
#include <execute/error.hpp>
#include <execute/interrupts.hpp>
#include <execute/virtualmachine.hpp>
#include <stdexcept>
#include <utils.hpp>
#include <variant>
namespace Execute
{
void VirtualMachine::Step()
std::size_t GetArguments(
InstructionByte const instruction,
std::array<ArgumentValue, 3> & arguments,
std::vector<std::uint8_t> const & memory,
std::size_t const memoryPos)
{
state.nextStatement = state.currentStatement + 1u;
try
std::size_t expectedNumberOfArguments = 0;
switch(instruction)
{
codePtr->statements[state.currentStatement]->Execute(flags, state, registers);
case InstructionByte::JUMP:
case InstructionByte::INTERRUPT:
case InstructionByte::CALL:
case InstructionByte::POP_INTEGER:
case InstructionByte::PUSH_INTEGER:
expectedNumberOfArguments = 1;
break;
case InstructionByte::SET_INTEGER:
case InstructionByte::LESS_THAN_INTEGER:
case InstructionByte::GREATER_THAN_INTEGER:
case InstructionByte::EQUALS_INTEGER:
expectedNumberOfArguments = 2;
break;
case InstructionByte::ADD_INTEGER:
case InstructionByte::SUBTRACT_INTEGER:
case InstructionByte::DIVIDE_INTEGER:
case InstructionByte::MULTIPLY_INTEGER:
case InstructionByte::SHIFT_LEFT_INTEGER:
case InstructionByte::SHIFT_RIGHT_INTEGER:
expectedNumberOfArguments = 3;
break;
default:
throw std::runtime_error("No instruction length set for instruction byte");
}
catch(RuntimeError & ex)
{
state.terminated = true;
std::puts("\nA fatal error occurred and execution has been halted:");
std::printf("%s\n", ex.GetMessage().c_str());
std::size_t memoryOffset = memoryPos;
for(std::size_t i = 0; i < expectedNumberOfArguments; ++i)
{
memoryOffset += arguments[i].Parse(memory, memoryOffset);
}
return memoryOffset - memoryPos;
}
void VirtualMachine::DoArithmatic(
InstructionByte const instruction,
std::array<ArgumentValue, 3> & arguments)
{
switch (instruction)
{
case InstructionByte::ADD_INTEGER:
arguments[2].Write(arguments[0].Read(state) + arguments[1].Read(state), state);
break;
case InstructionByte::SUBTRACT_INTEGER:
arguments[2].Write(arguments[0].Read(state) - arguments[1].Read(state), state);
break;
case InstructionByte::DIVIDE_INTEGER:
arguments[2].Write(arguments[0].Read(state) / arguments[1].Read(state), state);
break;
case InstructionByte::MULTIPLY_INTEGER:
arguments[2].Write(arguments[0].Read(state) * arguments[1].Read(state), state);
break;
case InstructionByte::SHIFT_LEFT_INTEGER:
arguments[2].Write(arguments[0].Read(state) >> arguments[1].Read(state), state);
break;
case InstructionByte::SHIFT_RIGHT_INTEGER:
arguments[2].Write(arguments[0].Read(state) << arguments[1].Read(state), state);
break;
default:
throw std::runtime_error("Unhandled instruction bytr in DoArithmatic");
}
}
void VirtualMachine::SetInteger(std::array<ArgumentValue, 3> & arguments)
{
arguments[0].Write(arguments[1].Read(state), state);
}
void VirtualMachine::ExecuteJump(std::array<ArgumentValue, 3> & arguments)
{
state.registers.programCounter = arguments[0].Read(state);
}
void VirtualMachine::ExecuteInterrupt(std::array<ArgumentValue, 3> & arguments)
{
int const interruptNo = arguments[0].Read(state);
Execute::ExecuteInterrupt(interruptNo, state.registers, state.memory);
}
void VirtualMachine::ExecuteCall(
std::array<ArgumentValue, 3> & arguments,
std::size_t const returnByte)
{
state.PushToStack(returnByte);
state.registers.programCounter = arguments[0].Read(state);
}
void VirtualMachine::ExecuteReturn()
{
int const returnByte = state.PopFromStack();
state.registers.programCounter = returnByte;
}
void VirtualMachine::DoBooleanLogic(
InstructionByte const instruction,
std::array<ArgumentValue, 3> & arguments,
std::size_t const nextInstruction)
{
bool executeNextInstruction = false;
switch(instruction)
{
case InstructionByte::LESS_THAN_INTEGER:
executeNextInstruction = arguments[0].Read(state) < arguments[1].Read(state);
break;
case InstructionByte::GREATER_THAN_INTEGER:
executeNextInstruction = arguments[0].Read(state) > arguments[1].Read(state);
break;
case InstructionByte::EQUALS_INTEGER:
executeNextInstruction = arguments[0].Read(state) == arguments[1].Read(state);
break;
default:
throw std::runtime_error("Unhandled instruction byte for boolean logic");
}
if (executeNextInstruction)
{
state.registers.programCounter = nextInstruction;
return;
}
state.currentStatement = state.nextStatement;
if (state.currentStatement >= codePtr->statements.size())
auto const argumentOffset = GetArguments(
static_cast<InstructionByte>(state.memory[nextInstruction]),
arguments,
state.memory,
nextInstruction + 1);
state.registers.programCounter = nextInstruction + 1 + argumentOffset;
}
void VirtualMachine::ExecutePop(std::array<ArgumentValue, 3> & arguments)
{
arguments[0].Write(state.PopFromStack(), state);
}
void VirtualMachine::ExecutePush(std::array<ArgumentValue, 3> & arguments)
{
state.PushToStack(arguments[0].Read(state));
}
void VirtualMachine::Step()
{
// Default to 1 byte (= 1 instruction)
std::size_t programCounterIncrement = 1;
std::array<ArgumentValue, 3> arguments;
InstructionByte const instruction =
static_cast<InstructionByte>(state.memory[state.registers.programCounter]);
switch(instruction)
{
case InstructionByte::ADD_INTEGER:
case InstructionByte::SUBTRACT_INTEGER:
case InstructionByte::DIVIDE_INTEGER:
case InstructionByte::MULTIPLY_INTEGER:
case InstructionByte::SHIFT_LEFT_INTEGER:
case InstructionByte::SHIFT_RIGHT_INTEGER:
programCounterIncrement += GetArguments(
instruction,
arguments,
state.memory,
state.registers.programCounter + 1);
DoArithmatic(instruction, arguments);
state.registers.programCounter += programCounterIncrement;
break;
case InstructionByte::SET_INTEGER:
programCounterIncrement += GetArguments(
instruction,
arguments,
state.memory,
state.registers.programCounter + 1);
SetInteger(arguments);
state.registers.programCounter += programCounterIncrement;
break;
case InstructionByte::JUMP:
GetArguments(
instruction,
arguments,
state.memory,
state.registers.programCounter + 1);
ExecuteJump(arguments);
break;
case InstructionByte::INTERRUPT:
programCounterIncrement += GetArguments(
instruction,
arguments,
state.memory,
state.registers.programCounter + 1);
ExecuteInterrupt(arguments);
state.registers.programCounter += programCounterIncrement;
break;
case InstructionByte::CALL:
programCounterIncrement += GetArguments(
instruction,
arguments,
state.memory,
state.registers.programCounter + 1);
ExecuteCall(arguments, state.registers.programCounter + programCounterIncrement);
break;
case InstructionByte::RETURN:
ExecuteReturn();
break;
case InstructionByte::EXIT:
state.terminated = true;
return;
case InstructionByte::LESS_THAN_INTEGER:
case InstructionByte::GREATER_THAN_INTEGER:
case InstructionByte::EQUALS_INTEGER:
programCounterIncrement += GetArguments(
instruction,
arguments,
state.memory,
state.registers.programCounter + 1);
DoBooleanLogic(
instruction,
arguments,
state.registers.programCounter + programCounterIncrement);
break;
case InstructionByte::POP_INTEGER:
programCounterIncrement += GetArguments(
instruction,
arguments,
state.memory,
state.registers.programCounter + 1);
ExecutePop(arguments);
state.registers.programCounter += programCounterIncrement;
break;
case InstructionByte::PUSH_INTEGER:
programCounterIncrement += GetArguments(
instruction,
arguments,
state.memory,
state.registers.programCounter + 1);
ExecutePush(arguments);
state.registers.programCounter += programCounterIncrement;
break;
case InstructionByte::IMMEDIATE_INTEGER:
case InstructionByte::REGISTER:
case InstructionByte::MEMORY_OP:
case InstructionByte::LABEL:
default:
throw NonExecutableInstruction(state.registers.programCounter);
break;
}
}
void PrintOperand(std::size_t const index, std::string const name)
{
std::printf("\n%04lu %s", index, name.c_str());
}
void PrintBytes(std::vector<std::uint8_t> const & byteCode)
{
for(std::size_t i = 0; i < byteCode.size(); ++i)
{
InstructionByte const id = static_cast<InstructionByte>(byteCode[i]);
switch(id)
{
case InstructionByte::ADD_INTEGER:
PrintOperand(i, "addi");
break;
case InstructionByte::SUBTRACT_INTEGER:
PrintOperand(i, "subi");
break;
case InstructionByte::DIVIDE_INTEGER:
PrintOperand(i, "divi");
break;
case InstructionByte::MULTIPLY_INTEGER:
PrintOperand(i, "muli");
break;
case InstructionByte::SHIFT_LEFT_INTEGER:
PrintOperand(i, "shli");
break;
case InstructionByte::SHIFT_RIGHT_INTEGER:
PrintOperand(i, "shri");
break;
case InstructionByte::SET_INTEGER:
PrintOperand(i, "sti");
break;
case InstructionByte::JUMP:
PrintOperand(i, "jmp");
break;
case InstructionByte::INTERRUPT:
PrintOperand(i, "int");
break;
case InstructionByte::CALL:
PrintOperand(i, "call");
break;
case InstructionByte::RETURN:
PrintOperand(i, "ret");
break;
case InstructionByte::EXIT:
PrintOperand(i, "exit");
break;
case InstructionByte::LESS_THAN_INTEGER:
PrintOperand(i, "lti");
break;
case InstructionByte::GREATER_THAN_INTEGER:
PrintOperand(i, "gti");
break;
case InstructionByte::EQUALS_INTEGER:
PrintOperand(i, "eqi");
break;
case InstructionByte::POP_INTEGER:
PrintOperand(i, "popi");
break;
case InstructionByte::PUSH_INTEGER:
PrintOperand(i, "pushi");
break;
case InstructionByte::IMMEDIATE_INTEGER:
std::printf("$%i", Utils::Bytes::Read(byteCode, i + 1));
i += 4u;
break;
case InstructionByte::REGISTER:
{
std::string registerName {"A"};
registerName[0] += byteCode[i + 1] - 1;
std::printf("%%%s", registerName.c_str());
++i;
}
break;
case InstructionByte::MEMORY_OP:
std::printf("[]");
break;
case InstructionByte::LABEL:
std::printf("%i:", Utils::Bytes::Read(byteCode, i + 1));
i += 4u;
break;
default:
std::printf("UNKNOWN");
break;
}
std::putc(' ', stdout);
}
std::puts("");
}
void VirtualMachine::Run()
{
while(!IsTerminated())
@@ -43,29 +410,38 @@ namespace Execute
}
}
void VirtualMachine::LoadConfiguration(Configuration const & c)
void VirtualMachine::SetMemorySize(std::size_t const size)
{
c.PrepareMemory(state.memory);
state.memory.resize(size);
}
void VirtualMachine::LoadCode(std::unique_ptr<Interpret::Code> code)
void VirtualMachine::LoadCode(
std::vector<std::uint8_t> const & byteCode,
bool const printDecodedBytes)
{
codePtr = std::move(code);
state.labelStatementIndice = &(codePtr->labelStatementIndice);
if (printDecodedBytes)
{
PrintBytes(byteCode);
}
if (state.memory.size() < byteCode.size())
{
throw OutOfMemory(byteCode.size(), state.memory.size());
}
for (std::size_t i = 0; i < byteCode.size(); ++i)
{
state.memory[i] = byteCode[i];
}
state.registers.stackPointer = byteCode.size();
}
Flags const & VirtualMachine::GetFlags() const { return flags; }
Registers const & VirtualMachine::GetRegisters() const { return registers; }
State const & VirtualMachine::GetState() const { return state; }
Interpret::Statement const * const VirtualMachine::GetCurrentStatement() const
Execute::InstructionByte VirtualMachine::GetCurrentInstruction() const
{
return codePtr->statements[state.currentStatement].get();
return static_cast<InstructionByte>(state.memory[state.registers.programCounter]);
}
bool VirtualMachine::IsTerminated() const { return state.terminated; }
VirtualMachine::VirtualMachine()
{
state.interrupts = GetInterrupts();
}
}

73
src/interpret/errors.cpp
View File

@@ -1,73 +0,0 @@
#include <interpret/errors.hpp>
namespace Interpret
{
InterpretationError::InterpretationError(Token::Token const & token, std::string const & msg)
: errorToken(token)
{
errorToken.errorMessage = msg;
}
ExpectedArgument::ExpectedArgument(Token::Token const & token)
: InterpretationError(token, "Expected an argument")
{
}
ExpectedLabel::ExpectedLabel(Token::Token const & token)
: InterpretationError(token, "Expected a label")
{
}
ExpectedValue::ExpectedValue(Token::Token const & token)
: InterpretationError(token, "Expected an immediate value, a register or a memory location")
{
}
ExpectedImmediate::ExpectedImmediate(Token::Token const & token)
: InterpretationError(token, "Expected an immediate value")
{
}
ExpectedImmediateOrMemory::ExpectedImmediateOrMemory(Token::Token const & token)
: InterpretationError(token, "Expected an immediate value or a memory location")
{
}
ExpectedRegister::ExpectedRegister(Token::Token const & token)
: InterpretationError(token, "Expected a register")
{
}
ExpectedRegisterOrMemory::ExpectedRegisterOrMemory(Token::Token const & token)
: InterpretationError(token, "Expected a register or a memory location")
{
}
ExpectedOperand::ExpectedOperand(Token::Token const & token)
: InterpretationError(token, "Expected an operand")
{
}
TooManyArguments::TooManyArguments(Token::Token const & token)
: InterpretationError(token, "Too many arguments for operand")
{
}
TooFewArguments::TooFewArguments(Token::Token const & token)
: InterpretationError(token, "Too few arguments for operand")
{
}
MissingEndOfStatment::MissingEndOfStatment(Token::Token const & token)
: InterpretationError(token, "Missing end of line terminator (;)")
{
}
namespace Internal
{
BadTokenForValue::BadTokenForValue(Token::Token const & token)
: InterpretationError(token, "Internal error when converting token to value")
{
}
}
}

86
src/interpret/interpreter.cpp
View File

@@ -1,86 +0,0 @@
#include <interpret/errors.hpp>
#include <interpret/interpreter.hpp>
#include <interpret/operanddefinitions.hpp>
namespace Interpret
{
bool IsArgumentToken(Token::Token const & t)
{
return
t.type == Token::TokenType::ImmediateInteger ||
t.type == Token::TokenType::Register ||
t.type == Token::TokenType::Label ||
t.type == Token::TokenType::Memory;
}
void Interpreter::Interpret(std::vector<Token::Token> const & tokens, Code & code)
{
enum class InterpreterState
{
FindOperand,
FindArguments,
FindStatementEnd
};
InterpreterState state = InterpreterState::FindOperand;
unsigned operatorTokenIndex = 0u;
int expectedNumberOfArguments = 0;
for(unsigned i = 0u; i < tokens.size(); ++i)
{
auto const & token = tokens[i];
switch(state)
{
case InterpreterState::FindOperand:
if (token.type == Token::TokenType::Operand)
{
operatorTokenIndex = i;
expectedNumberOfArguments = GetRequiredNumberOfArguments(std::get<Token::OperandType>(token.data));
if (expectedNumberOfArguments < 1)
{
state = InterpreterState::FindStatementEnd;
}
else
{
state = InterpreterState::FindArguments;
}
}
else if (token.type == Token::TokenType::Label)
{
code.labelStatementIndice[std::get<std::string>(token.data)] = code.statements.size();
}
else if (token.type != Token::TokenType::StatementEnd)
{
throw ExpectedOperand(token);
}
break;
case InterpreterState::FindArguments:
if (IsArgumentToken(token))
{
expectedNumberOfArguments -= 1;
if (expectedNumberOfArguments < 1)
{
state = InterpreterState::FindStatementEnd;
}
}
else
{
throw ExpectedArgument(token);
}
break;
case InterpreterState::FindStatementEnd:
if (token.type != Token::TokenType::StatementEnd)
{
throw MissingEndOfStatment(token);
}
else
{
code.statements.emplace_back(ExtractStatement(operatorTokenIndex, tokens));
state = InterpreterState::FindOperand;
}
break;
}
}
}
}

327
src/interpret/operanddefinitions.cpp
View File

@@ -1,327 +0,0 @@
#include <interpret/operanddefinitions.hpp>
#include <interpret/errors.hpp>
namespace Interpret
{
Value GetImmediateArgument(unsigned const index, std::vector<Token::Token> const & tokens)
{
auto const & token = tokens[index];
if (token.type == Token::TokenType::ImmediateInteger)
{
Value v;
v.CreateFromToken(token);
return v;
}
throw ExpectedImmediate(token);
}
Value GetRegisterArgument(unsigned const index, std::vector<Token::Token> const & tokens)
{
auto const & token = tokens[index];
if (token.type == Token::TokenType::Register)
{
Value v;
v.CreateFromToken(token);
return v;
}
throw ExpectedRegister(token);
}
Value GetRegisterOrMemoryArgument(unsigned const index, std::vector<Token::Token> const & tokens)
{
auto const & token = tokens[index];
if (token.type == Token::TokenType::Register || token.type == Token::TokenType::Memory)
{
Value v;
v.CreateFromToken(token);
return v;
}
throw ExpectedRegisterOrMemory(token);
}
Value GetValueArgument(unsigned const index, std::vector<Token::Token> const & tokens)
{
auto const & token = tokens[index];
if (token.type == Token::TokenType::ImmediateInteger || token.type == Token::TokenType::Register || token.type == Token::TokenType::Memory)
{
Value v;
v.CreateFromToken(token);
return v;
}
throw ExpectedValue(token);
}
void AddArithmeticArguments(ArithmeticStatement & statement, unsigned const operandIndex, std::vector<Token::Token> const & tokens)
{
statement.firstArgument = GetValueArgument(operandIndex + 1u, tokens);
statement.secondArgument = GetValueArgument(operandIndex + 2u, tokens);
statement.thirdArgument = GetRegisterOrMemoryArgument(operandIndex + 3u, tokens);
}
void AddLogicArguments(ControlFlowStatement & statement, unsigned const operandIndex, std::vector<Token::Token> const & tokens)
{
statement.firstArgument = GetValueArgument(operandIndex + 1u, tokens);
statement.secondArgument = GetValueArgument(operandIndex + 2u, tokens);
}
std::unique_ptr<Statement> ExtractStatement(unsigned const operandIndex, std::vector<Token::Token> const & tokens)
{
auto const & token = tokens[operandIndex];
switch(std::get<Token::OperandType>(token.data))
{
case Token::OperandType::AddInteger:
{
auto statement = std::make_unique<ArithmeticStatement>();
statement->function = [](int argument1, int argument2, int & argument3)
{
argument3 = argument1 + argument2;
};
AddArithmeticArguments(*statement, operandIndex, tokens);
return statement;
}
case Token::OperandType::SubtractInteger:
{
auto statement = std::make_unique<ArithmeticStatement>();
statement->function = [](int argument1, int argument2, int & argument3)
{
argument3 = argument1 - argument2;
};
AddArithmeticArguments(*statement, operandIndex, tokens);
return statement;
}
case Token::OperandType::DivideInteger:
{
auto statement = std::make_unique<ArithmeticStatement>();
statement->function = [](int argument1, int argument2, int & argument3)
{
argument3 = argument1 / argument2;
};
AddArithmeticArguments(*statement, operandIndex, tokens);
return statement;
}
case Token::OperandType::MultiplyInteger:
{
auto statement = std::make_unique<ArithmeticStatement>();
statement->function = [](int argument1, int argument2, int & argument3)
{
argument3 = argument1 * argument2;
};
AddArithmeticArguments(*statement, operandIndex, tokens);
return statement;
}
case Token::OperandType::ShiftIntegerLeft:
{
auto statement = std::make_unique<ArithmeticStatement>();
statement->function = [](int argument1, int argument2, int & argument3)
{
argument3 = argument1 << argument2;
};
AddArithmeticArguments(*statement, operandIndex, tokens);
return statement;
}
case Token::OperandType::ShiftIntegerRight:
{
auto statement = std::make_unique<ArithmeticStatement>();
statement->function = [](int argument1, int argument2, int & argument3)
{
argument3 = argument1 >> argument2;
};
AddArithmeticArguments(*statement, operandIndex, tokens);
return statement;
}
case Token::OperandType::Jump:
{
auto labelToken = tokens[operandIndex + 1u];
if (labelToken.type != Token::TokenType::Label)
{
throw ExpectedLabel(labelToken);
}
return std::make_unique<JumpStatement>(std::get<std::string>(labelToken.data));
}
case Token::OperandType::CallFunction:
{
auto labelToken = tokens[operandIndex + 1u];
if (labelToken.type != Token::TokenType::Label)
{
throw ExpectedLabel(labelToken);
}
return std::make_unique<FunctionCallStatement>(std::get<std::string>(labelToken.data));
}
case Token::OperandType::ReturnFromFunction:
{
return std::make_unique<ReturnFromFunctionStatement>();
}
case Token::OperandType::ExitProgram:
{
return std::make_unique<ExitProgramStatement>();
}
case Token::OperandType::LessThanInteger:
{
auto statement = std::make_unique<ControlFlowStatement>();
statement->function = [](Execute::State & state, int argument1, int argument2)
{
if (argument1 < argument2)
{
state.nextStatement = state.currentStatement + 1u;
}
else
{
state.nextStatement = state.currentStatement + 2u;
}
};
AddLogicArguments(*statement, operandIndex, tokens);
return statement;
}
case Token::OperandType::GreaterThanInteger:
{
auto statement = std::make_unique<ControlFlowStatement>();
statement->function = [](Execute::State & state, int argument1, int argument2)
{
if (argument1 > argument2)
{
state.nextStatement = state.currentStatement + 1u;
}
else
{
state.nextStatement = state.currentStatement + 2u;
}
};
AddLogicArguments(*statement, operandIndex, tokens);
return statement;
}
case Token::OperandType::EqualInteger:
{
auto statement = std::make_unique<ControlFlowStatement>();
statement->function = [](Execute::State & state, int argument1, int argument2)
{
if (argument1 == argument2)
{
state.nextStatement = state.currentStatement + 1u;
}
else
{
state.nextStatement = state.currentStatement + 2u;
}
};
AddLogicArguments(*statement, operandIndex, tokens);
return statement;
}
case Token::OperandType::SetInteger:
{
auto statement = std::make_unique<SetStatement>();
statement->firstArgument = GetRegisterOrMemoryArgument(operandIndex + 1u, tokens);
statement->secondArgument = GetValueArgument(operandIndex + 2u, tokens);
return statement;
}
case Token::OperandType::Interrupt:
{
auto statement = std::make_unique<InterruptStatement>();
statement->firstArgument = GetValueArgument(operandIndex + 1u, tokens);
return statement;
}
case Token::OperandType::PopInteger:
{
auto statement = std::make_unique<PopStatement>();
statement->firstArgument = GetRegisterArgument(operandIndex + 1u, tokens);
return statement;
}
case Token::OperandType::PushInteger:
{
auto statement = std::make_unique<PushStatement>();
statement->firstArgument = GetValueArgument(operandIndex + 1u, tokens);
return statement;
}
default:
{
auto statement = std::make_unique<NoArgumentStatement>();
// TODO throw error?
statement->function = [](Execute::Flags & flags, Execute::Registers & registers)
{
std::puts("ExtractStatement: Extracted unhandled operator type");
};
return statement;
}
}
}
std::tuple<std::string, int> ExtractDeclaration(unsigned const operatorIndex, std::vector<Token::Token> const & tokens)
{
if (tokens[operatorIndex + 1u].type != Token::TokenType::Label)
{
throw ExpectedLabel(tokens[operatorIndex + 1u]);
}
if (tokens[operatorIndex + 2u].type != Token::TokenType::ImmediateInteger)
{
throw ExpectedImmediate(tokens[operatorIndex + 2u]);
}
auto const label = std::get<std::string>(tokens[operatorIndex + 1u].data);
auto const value = std::get<int>(tokens[operatorIndex + 2u].data);
return std::make_tuple(label, value);
}
int GetRequiredNumberOfArguments(Token::OperandType const type)
{
switch (type)
{
case Token::OperandType::AddInteger:
case Token::OperandType::SubtractInteger:
case Token::OperandType::DivideInteger:
case Token::OperandType::MultiplyInteger:
case Token::OperandType::ShiftIntegerLeft:
case Token::OperandType::ShiftIntegerRight:
return 3;
case Token::OperandType::LessThanInteger:
case Token::OperandType::GreaterThanInteger:
case Token::OperandType::EqualInteger:
case Token::OperandType::SetInteger:
return 2;
case Token::OperandType::Jump:
case Token::OperandType::CallFunction:
case Token::OperandType::Interrupt:
case Token::OperandType::PushInteger:
case Token::OperandType::PopInteger:
return 1;
default:
std::printf("WARNING: returning default argument length of 0 for operand type %i\n", static_cast<int>(type));
case Token::OperandType::ReturnFromFunction:
case Token::OperandType::ExitProgram:
return 0;
}
}
}

125
src/interpret/statement.cpp
View File

@@ -1,125 +0,0 @@
#include <execute/error.hpp>
#include <interpret/statement.hpp>
#include <stdexcept>
namespace Interpret
{
void NoArgumentStatement::Execute(Execute::Flags & flags, Execute::State & state, Execute::Registers & registers)
{
function(flags, registers);
}
void OneArgumentStatement::Execute(Execute::Flags & flags, Execute::State & state, Execute::Registers & registers)
{
function(flags, firstArgument.GetValue(state, registers));
}
void ControlFlowStatement::Execute(Execute::Flags & flags, Execute::State & state, Execute::Registers & registers)
{
function(state, firstArgument.GetValue(state, registers), secondArgument.GetValue(state, registers));
}
void ArithmeticStatement::Execute(Execute::Flags & flags, Execute::State & state, Execute::Registers & registers)
{
function(firstArgument.GetValue(state, registers), secondArgument.GetValue(state, registers), thirdArgument.GetValue(state, registers));
}
void JumpStatement::Execute(Execute::Flags & flags, Execute::State & state, Execute::Registers & registers)
{
auto const & elem = state.labelStatementIndice->find(label);
if (elem != state.labelStatementIndice->end())
{
state.nextStatement = elem->second;
}
else
{
throw Execute::MissingLabel(label);
}
}
JumpStatement::JumpStatement(std::string const & _label)
: label(_label)
{
}
void FunctionCallStatement::Execute(Execute::Flags & flags, Execute::State & state, Execute::Registers & registers)
{
auto const & elem = state.labelStatementIndice->find(label);
if (elem == state.labelStatementIndice->end())
{
throw Execute::MissingLabel(label);
}
if ((state.memory.size() - state.stackPointer) < sizeof(unsigned))
{
throw Execute::StackOverflow();
}
*(reinterpret_cast<unsigned *>(state.memory.data() + state.stackPointer + (sizeof(unsigned) - 1))) = state.nextStatement;
state.stackPointer += sizeof(int);
state.nextStatement = elem->second;
}
FunctionCallStatement::FunctionCallStatement(std::string const & _label)
: label(_label)
{
}
void ReturnFromFunctionStatement::Execute(Execute::Flags & flags, Execute::State & state, Execute::Registers & registers)
{
if (state.stackPointer < sizeof(unsigned))
{
throw Execute::StackUnderflow();
}
state.nextStatement = *(reinterpret_cast<unsigned const *>(state.memory.data() + (state.stackPointer - 1u)));
state.stackPointer -= sizeof(unsigned);
}
void ExitProgramStatement::Execute(Execute::Flags & flags, Execute::State & state, Execute::Registers & registers)
{
state.terminated = true;
}
void SetStatement::Execute(Execute::Flags & flags, Execute::State & state, Execute::Registers & registers)
{
firstArgument.GetValue(state, registers) = secondArgument.GetValue(state, registers);
}
void InterruptStatement::Execute(Execute::Flags & flags, Execute::State & state, Execute::Registers & registers)
{
auto const interruptIndex = firstArgument.GetValue(state, registers);
if (interruptIndex < 0 || static_cast<unsigned>(interruptIndex) > state.interrupts.size())
{
throw Execute::InterruptIndexOutOfRange(interruptIndex);
}
state.interrupts[interruptIndex](registers, state.memory);
}
void PopStatement::Execute(Execute::Flags & flags, Execute::State & state, Execute::Registers & registers)
{
if (state.stackPointer < sizeof(int))
{
throw Execute::StackUnderflow();
}
auto const value = *(reinterpret_cast<int const *>(state.memory.data() + (state.stackPointer - 1u)));
firstArgument.GetValue(state, registers) = value;
state.stackPointer -= sizeof(int);
}
void PushStatement::Execute(Execute::Flags & flags, Execute::State & state, Execute::Registers & registers)
{
if ((state.memory.size() - state.stackPointer) < sizeof(int))
{
throw Execute::StackOverflow();
}
*(reinterpret_cast<int *>(state.memory.data() + state.stackPointer + (sizeof(int) - 1))) = firstArgument.GetValue(state, registers);
state.stackPointer += sizeof(int);
}
}

75
src/interpret/value.cpp
View File

@@ -1,75 +0,0 @@
#include <execute/error.hpp>
#include <interpret/errors.hpp>
#include <interpret/value.hpp>
namespace Interpret
{
int & Value::GetValue(Execute::State & state, Execute::Registers & registers)
{
switch(type)
{
case ValueType::ImmediateInteger:
return data;
case ValueType::Register:
return registers.registers[data];
case ValueType::MemoryLocation:
if (dataType == ValueDataType::Register)
{
return *reinterpret_cast<int *>(state.memory.data() + registers.registers[data]);
}
else if (dataType == ValueDataType::Immediate)
{
return *reinterpret_cast<int *>(state.memory.data() + data);
}
else
{
throw Execute::Internal::BadValueType();
}
break;
default:
throw Execute::Internal::BadValueType();
}
}
void Value::CreateFromToken(Token::Token const & token)
{
switch(token.type)
{
case Token::TokenType::ImmediateInteger:
type = ValueType::ImmediateInteger;
dataType = ValueDataType::Immediate;
data = std::get<int>(token.data);
break;
case Token::TokenType::Register:
type = ValueType::Register;
dataType = ValueDataType::Register;
data = static_cast<int>(std::get<Token::RegisterType>(token.data));
break;
case Token::TokenType::Memory:
type = ValueType::MemoryLocation;
if (token.valueType == Token::TokenValueType::Integer)
{
dataType = ValueDataType::Immediate;
data = std::get<int>(token.data);
}
else if(token.valueType == Token::TokenValueType::Register)
{
dataType = ValueDataType::Register;
data = static_cast<int>(std::get<Token::RegisterType>(token.data));
}
else
{
throw Internal::BadTokenForValue(token);
}
break;
default:
throw Internal::BadTokenForValue(token);
}
}
}

39
src/main.cpp
View File

@@ -6,13 +6,22 @@
int main(int argc, char ** argv)
{
std::string inputFile;
unsigned memorySize = 1024;
bool printSubstitutions = false;
bool printTokens = false;
unsigned memorySize = 4096;
bool printSubstitutions = false, printTokens = false, printBytes = false;
bool execute = false, compile = false;
std::string outputFile("program.bin");
auto cli = (
clipp::value("input wasm file").set(inputFile),
clipp::option("-m", "--memory-size") & clipp::value("memory size", memorySize),
clipp::value("input file").set(inputFile),
(
clipp::required("-e", "--execute").set(execute),
clipp::option("-m", "--memory-size") & clipp::value("memory size in bytes (defaults to 4096)", memorySize),
clipp::option("-pb", "--print-bytes").set(printBytes)
) |
(
clipp::required("-c", "--compile").set(compile),
clipp::option("-o", "--output-file") & clipp::value("output file", outputFile)
),
clipp::option("-ps", "--print-substitutions").set(printSubstitutions),
clipp::option("-pt", "--print-tokens").set(printTokens)
);
@@ -35,12 +44,26 @@ int main(int argc, char ** argv)
wassembler.EnableTokensLogging();
}
if (!wassembler.LoadFromFile(inputFile))
if (execute)
{
exit(1);
if (printBytes)
{
wassembler.EnableByteTranslationLogging();
}
if (!wassembler.CompileAndRun(inputFile))
{
exit(1);
}
}
wassembler.Run();
if (compile)
{
if (!wassembler.CompileToFile(inputFile, outputFile))
{
exit(1);
}
}
return 0;
}

5
src/token/errors.cpp
View File

@@ -7,9 +7,4 @@ namespace Token
errorMsg(msg)
{
}
MissingEndOfString::MissingEndOfString(Token const & token)
: TokenizationError(token, "Missing string terminator (\")")
{
}
}

46
src/token/token.cpp
View File

@@ -86,9 +86,14 @@ namespace Token
return Token(TokenType::StatementEnd, true, lineNumber, lineColumn);
}
Token Token::CreateLabelToken(std::string const & string, int const lineNumber, int const lineColumn)
Token Token::CreateLabelDefinitionToken(std::string const & string, int const lineNumber, int const lineColumn)
{
return Token(TokenType::Label, string, true, lineNumber, lineColumn);
return Token(TokenType::LabelDefinition, string, true, lineNumber, lineColumn);
}
Token Token::CreateLabelArgumentToken(std::string const & string, int const lineNumber, int const lineColumn)
{
return Token(TokenType::LabelArgument, string, true, lineNumber, lineColumn);
}
Token Token::CreateImmediateValueToken(int const value, int const lineNumber, int const lineColumn)
@@ -121,6 +126,35 @@ namespace Token
return Token(TokenType::Memory, value, true, lineNumber, lineColumn);
}
std::string Token::GetName() const
{
switch(type)
{
case TokenType::ImmediateInteger:
return "immediate value";
case TokenType::Operand:
return "operand";
case TokenType::Register:
return "register";
case TokenType::StatementEnd:
return "end of statement";
case TokenType::LabelDefinition:
case TokenType::LabelArgument:
return "label";
case TokenType::Memory:
return "memory location";
case TokenType::Unknown:
default:
return "UNKNOWN";
}
}
void Token::Print() const
{
std::putc(' ', stdout);
@@ -183,8 +217,12 @@ namespace Token
std::printf("EOS");
break;
case TokenType::Label:
std::printf("LABEL=%s", std::get<std::string>(data).c_str());
case TokenType::LabelDefinition:
std::printf("LABEL_DEF=%s", std::get<std::string>(data).c_str());
break;
case TokenType::LabelArgument:
std::printf("LABEL_ARG=%s", std::get<std::string>(data).c_str());
break;
case TokenType::Memory:

4
src/token/tokenizer.cpp
View File

@@ -178,7 +178,7 @@ namespace Token
case ':':
// TODO check if label is an Operand?
return Token::CreateLabelToken(
return Token::CreateLabelDefinitionToken(
string.substr(0, string.size() - 1),
lineNumber,
lineColumn);
@@ -196,7 +196,7 @@ namespace Token
}
// Last resort: it must be a jump target
return Token::CreateLabelToken(string, lineNumber, lineColumn);
return Token::CreateLabelArgumentToken(string, lineNumber, lineColumn);
}
void Tokenizer::Tokenize(

24
src/utils.cpp
View File

@@ -37,4 +37,28 @@ namespace Utils
return src.substr(pos);
}
namespace Bytes
{
void Write(
int const value,
std::vector<std::uint8_t> & vec,
std::size_t const pos)
{
vec[pos] = value & 0xFF;
vec[pos + 1] = (value >> 8) & 0xFF;
vec[pos + 2] = (value >> 16) & 0xFF;
vec[pos + 3] = (value >> 24) & 0xFF;
}
int Read(std::vector<std::uint8_t> const & vec, std::size_t const pos)
{
int value = vec[pos];
value |= static_cast<int>(vec[pos + 1]) << 8;
value |= static_cast<int>(vec[pos + 2]) << 16;
value |= static_cast<int>(vec[pos + 3]) << 24;
return value;
}
}
}

144
src/wassembler.cpp
View File

@@ -1,5 +1,7 @@
#include <compile/compiler.hpp>
#include <compile/errors.hpp>
#include <execute/error.hpp>
#include <fstream>
#include <interpret/errors.hpp>
#include <preprocessor/preprocessor.hpp>
#include <token/errors.hpp>
#include <wassembler.hpp>
@@ -19,18 +21,13 @@ void PrintBadToken(Token::Token const & token, std::vector<std::string> const &
std::puts("^");
}
void PrintTokenError(Interpret::InterpretationError const & err, std::vector<std::string> const & lines)
{
PrintBadToken(err.errorToken, lines);
}
void PrintTokenError(Token::TokenizationError const & err, std::vector<std::string> const & lines)
{
std::printf("%s ", err.errorMsg.c_str());
PrintBadToken(err.errorToken, lines);
}
bool Wassembler::LoadLinesFromFile(std::string const & filePath, std::vector<std::string> & lines) const
bool Wassembler::LoadTextFile(std::string const & filePath, std::vector<std::string> & lines) const
{
std::ifstream input(filePath);
if (!input.is_open())
@@ -48,7 +45,19 @@ bool Wassembler::LoadLinesFromFile(std::string const & filePath, std::vector<std
return true;
}
bool Wassembler::LoadTokens(std::vector<std::string> const & lines, std::vector<Token::Token> & tokens) const
bool Wassembler::Preprocess(std::vector<std::string> & lines) const
{
Preprocessor preprocessor;
preprocessor.process(lines);
if (printSubstitutions)
{
preprocessor.printSubstitutions();
}
return true;
}
bool Wassembler::Tokenize(std::vector<std::string> const & lines, std::vector<Token::Token> & tokens) const
{
Token::Tokenizer tokenizer;
bool tokenizationError = false;
@@ -98,9 +107,64 @@ bool Wassembler::LoadTokens(std::vector<std::string> const & lines, std::vector<
return !(syntaxError || tokenizationError);
}
bool Wassembler::CompileToBytes(
std::vector<Token::Token> const & tokens,
std::vector<std::string> const & lines,
std::vector<std::uint8_t> & bytes) const
{
Compile::Compiler compiler;
try
{
compiler.Compile(tokens, bytes);
}
catch(Compile::CompilationError & e)
{
std::printf("Semantic error ");
PrintBadToken(e.errorToken, lines);
return false;
}
return true;
}
void Wassembler::ExecuteCode(std::vector<uint8_t> const & bytes)
{
vm.LoadCode(bytes, printTranslatedBytes);
// TODO clear memory?
vm.Run();
}
bool Wassembler::CompileFile(
std::string const & filePath,
std::vector<std::uint8_t> & bytes) const
{
std::vector<std::string> lines;
if (!LoadTextFile(filePath, lines))
{
std::printf("Error: Cannot open file %s for reading", filePath.c_str());
return false;
}
if(!Preprocess(lines))
{
std::puts("Aborting due to preprocessor error(s)");
return false;
}
std::vector<Token::Token> tokens;
if (!Tokenize(lines, tokens) || !CompileToBytes(tokens, lines, bytes))
{
std::puts("Aborting due to syntax error(s)");
return false;
}
return true;
}
void Wassembler::SetMemorySize(unsigned const size)
{
config.memorySize = size;
vm.SetMemorySize(size);
}
void Wassembler::EnableSubstitutionsLogging()
@@ -113,50 +177,54 @@ void Wassembler::EnableTokensLogging()
printTokens = true;
}
bool Wassembler::LoadFromFile(std::string const & filePath)
void Wassembler::EnableByteTranslationLogging()
{
printTranslatedBytes = true;
}
bool Wassembler::CompileAndRun(std::string const & filePath)
{
std::vector<std::string> lines;
if (!LoadLinesFromFile(filePath, lines))
std::vector<std::uint8_t> bytes;
if (!CompileFile(filePath, bytes))
{
std::printf("Error: Cannot open file %s for reading", filePath.c_str());
return false;
}
Preprocessor preprocessor;
preprocessor.process(lines);
if (printSubstitutions)
{
preprocessor.printSubstitutions();
}
std::vector<Token::Token> tokens;
if (!LoadTokens(lines, tokens))
{
std::puts("Aborting due to syntax error(s)");
return false;
}
Interpret::Interpreter interpreter;
auto codePtr = std::make_unique<Interpret::Code>();
try
{
interpreter.Interpret(tokens, *codePtr);
ExecuteCode(bytes);
}
catch(Interpret::InterpretationError & e)
catch (Execute::RuntimeError const & e)
{
std::printf("Semantic error ");
PrintBadToken(e.errorToken, lines);
std::puts("Aborting due to semantic error(s)");
std::puts(e.GetMessage().c_str());
std::puts("Aborting due to runtime error(s)");
return false;
}
vm.LoadCode(std::move(codePtr));
vm.LoadConfiguration(config);
return true;
}
void Wassembler::Run()
bool Wassembler::CompileToFile(
std::string const & inputFilePath,
std::string const & outputFilePath)
{
vm.Run();
std::vector<std::uint8_t> bytes;
if (!CompileFile(inputFilePath, bytes))
{
return false;
}
std::ofstream output(outputFilePath, std::ios::binary | std::ios::trunc);
if (!output.is_open())
{
std::printf("Error: Cannot open file %s for writing", outputFilePath.c_str());
return false;
}
for(std::size_t i = 0; i < bytes.size(); ++i)
{
output << bytes[i];
}
return true;
}