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

Added direct memory access

Browse Source
This commit is contained in:
Tijmen van Nesselrooij
2019-11-23 16:47:16 +01:00
parent 22bb974a05
commit 1148682324
14 changed files with 329 additions and 92 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
src/interpret/error.cpp
View File

@@ -19,7 +19,7 @@ namespace Interpret
}
ExpectedValue::ExpectedValue(Token::Token const & token)
: TokenError(token, "Expected an immediate value or register")
: TokenError(token, "Expected an immediate value, a register or a memory location")
{
}
@@ -28,11 +28,21 @@ namespace Interpret
{
}
ExpectedImmediateOrMemory::ExpectedImmediateOrMemory(Token::Token const & token)
: TokenError(token, "Expected an immediate value or a memory location")
{
}
ExpectedRegister::ExpectedRegister(Token::Token const & token)
: TokenError(token, "Expected a register")
{
}
ExpectedRegisterOrMemory::ExpectedRegisterOrMemory(Token::Token const & token)
: TokenError(token, "Expected a register or a memory location")
{
}
ExpectedOperand::ExpectedOperand(Token::Token const & token)
: TokenError(token, "Expected an operand")
{

11
src/interpret/interpreter.cpp
View File

@@ -4,6 +4,15 @@
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
@@ -46,7 +55,7 @@ namespace Interpret
break;
case InterpreterState::FindArguments:
if (token.type == Token::TokenType::ImmediateInteger || token.type == Token::TokenType::Register || token.type == Token::TokenType::Label)
if (IsArgumentToken(token))
{
expectedNumberOfArguments -= 1;
if (expectedNumberOfArguments < 1)

36
src/interpret/operanddefinitions.cpp
View File

@@ -31,10 +31,24 @@ namespace Interpret
throw ExpectedRegister(token);
}
Value GetImmediateOrRegisterArgument(unsigned const index, std::vector<Token::Token> const & tokens)
Value GetRegisterOrMemoryArgument(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)
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);
@@ -47,15 +61,15 @@ namespace Interpret
void AddArithmeticArguments(ArithmeticStatement & statement, unsigned const operandIndex, std::vector<Token::Token> const & tokens)
{
statement.firstArgument = GetImmediateOrRegisterArgument(operandIndex + 1u, tokens);
statement.secondArgument = GetImmediateOrRegisterArgument(operandIndex + 2u, tokens);
statement.thirdArgument = GetRegisterArgument(operandIndex + 3u, 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 = GetImmediateOrRegisterArgument(operandIndex + 1u, tokens);
statement.secondArgument = GetImmediateOrRegisterArgument(operandIndex + 2u, 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)
@@ -196,8 +210,8 @@ namespace Interpret
case Token::OperandType::SetInteger:
{
auto statement = std::make_unique<SetStatement>();
statement->firstArgument = GetRegisterArgument(operandIndex + 1u, tokens);
statement->secondArgument = GetImmediateOrRegisterArgument(operandIndex + 2u, tokens);
statement->firstArgument = GetRegisterOrMemoryArgument(operandIndex + 1u, tokens);
statement->secondArgument = GetValueArgument(operandIndex + 2u, tokens);
return statement;
}
@@ -205,7 +219,7 @@ namespace Interpret
case Token::OperandType::Interrupt:
{
auto statement = std::make_unique<InterruptStatement>();
statement->firstArgument = GetImmediateOrRegisterArgument(operandIndex + 1u, tokens);
statement->firstArgument = GetValueArgument(operandIndex + 1u, tokens);
return statement;
}
@@ -221,7 +235,7 @@ namespace Interpret
case Token::OperandType::PushInteger:
{
auto statement = std::make_unique<PushStatement>();
statement->firstArgument = GetImmediateOrRegisterArgument(operandIndex + 1u, tokens);
statement->firstArgument = GetValueArgument(operandIndex + 1u, tokens);
return statement;
}

14
src/interpret/statement.cpp
View File

@@ -10,17 +10,17 @@ namespace Interpret
void OneArgumentStatement::Execute(Execute::Flags & flags, Execute::State & state, Execute::Registers & registers)
{
function(flags, firstArgument.GetValue(registers));
function(flags, firstArgument.GetValue(state, registers));
}
void ControlFlowStatement::Execute(Execute::Flags & flags, Execute::State & state, Execute::Registers & registers)
{
function(state, firstArgument.GetValue(registers), secondArgument.GetValue(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(registers), secondArgument.GetValue(registers), thirdArgument.GetValue(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)
@@ -43,12 +43,12 @@ namespace Interpret
void SetStatement::Execute(Execute::Flags & flags, Execute::State & state, Execute::Registers & registers)
{
firstArgument.GetValue(registers) = secondArgument.GetValue(registers);
firstArgument.GetValue(state, registers) = secondArgument.GetValue(state, registers);
}
void InterruptStatement::Execute(Execute::Flags & flags, Execute::State & state, Execute::Registers & registers)
{
state.interrupts[firstArgument.GetValue(registers)](registers);
state.interrupts[firstArgument.GetValue(state, registers)](registers);
}
void PopStatement::Execute(Execute::Flags & flags, Execute::State & state, Execute::Registers & registers)
@@ -59,7 +59,7 @@ namespace Interpret
}
auto const value = *(reinterpret_cast<int const *>(state.memory.data() + (state.stackPointer - 1u)));
firstArgument.GetValue(registers) = value;
firstArgument.GetValue(state, registers) = value;
state.stackPointer -= sizeof(int);
}
@@ -71,7 +71,7 @@ namespace Interpret
throw Execute::StackOverflow();
}
*(reinterpret_cast<int *>(state.memory.data() + state.stackPointer + (sizeof(int) - 1))) = firstArgument.GetValue(registers);
*(reinterpret_cast<int *>(state.memory.data() + state.stackPointer + (sizeof(int) - 1))) = firstArgument.GetValue(state, registers);
state.stackPointer += sizeof(int);
}

70
src/interpret/value.cpp
View File

@@ -1,32 +1,74 @@
#include <execute/error.hpp>
#include <interpret/errors.hpp>
#include <interpret/value.hpp>
namespace Interpret
{
int & Value::GetValue(Execute::Registers & registers)
int & Value::GetValue(Execute::State & state, Execute::Registers & registers)
{
if (type == ValueType::ImmediateInteger)
switch(type)
{
return integer;
}
case ValueType::ImmediateInteger:
return data;
return registers.registers[registerIndex];
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)
{
if (token.type == Token::TokenType::ImmediateInteger)
switch(token.type)
{
case Token::TokenType::ImmediateInteger:
type = ValueType::ImmediateInteger;
integer = std::get<int>(token.data);
}
else if (token.type == Token::TokenType::Register)
{
dataType = ValueDataType::Immediate;
data = std::get<int>(token.data);
break;
case Token::TokenType::Register:
type = ValueType::Register;
registerIndex = static_cast<int>(std::get<Token::RegisterType>(token.data));
}
else
{
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);
}
}

104
src/token/token.cpp
View File

@@ -3,47 +3,53 @@
namespace Token
{
Token::Token(int const _lineNumber, int const _lineColumn)
Token::Token(TokenType _type, bool validness, int const _lineNumber, int const _lineColumn)
: lineNumber(_lineNumber),
lineColumn(_lineColumn),
type(TokenType::Unknown),
isValid(false)
{
}
Token::Token(int const _lineNumber, int const _lineColumn, OperandType _operatorType, bool validness)
: lineNumber(_lineNumber),
lineColumn(_lineColumn),
type(TokenType::Operand),
type(_type),
valueType(TokenValueType::None),
isValid(validness),
data(_operatorType)
data(0)
{
}
Token::Token(int const _lineNumber, int const _lineColumn, RegisterType _registerType, bool validness)
Token::Token(TokenType _type, std::string const & string, bool validness, int const _lineNumber, int const _lineColumn)
: lineNumber(_lineNumber),
lineColumn(_lineColumn),
type(TokenType::Register),
type(_type),
valueType(TokenValueType::String),
isValid(validness),
data(_registerType)
data(string)
{
}
Token::Token(int const _lineNumber, int const _lineColumn, int value, bool validness)
Token::Token(TokenType _type, int value, bool validness, int const _lineNumber, int const _lineColumn)
: lineNumber(_lineNumber),
lineColumn(_lineColumn),
type(TokenType::ImmediateInteger),
type(_type),
valueType(TokenValueType::Integer),
isValid(validness),
data(value)
{
}
Token::Token(int const _lineNumber, int const _lineColumn, std::string const & value, bool validness)
Token::Token(TokenType _type, RegisterType const registerType, bool validness, int const _lineNumber, int const _lineColumn)
: lineNumber(_lineNumber),
lineColumn(_lineColumn),
type(TokenType::Label),
type(_type),
valueType(TokenValueType::Register),
isValid(validness),
data(value)
data(registerType)
{
}
Token::Token(TokenType _type, OperandType const operandType, bool validness, int const _lineNumber, int const _lineColumn)
: lineNumber(_lineNumber),
lineColumn(_lineColumn),
type(_type),
valueType(TokenValueType::Operand),
isValid(validness),
data(operandType)
{
}
@@ -52,10 +58,51 @@ namespace Token
lineColumn(other.lineColumn),
type(other.type),
isValid(other.isValid),
valueType(other.valueType),
data(other.data)
{
}
Token Token::CreateUnknownToken(int const lineNumber, int const lineColumn)
{
return Token(TokenType::Unknown, false, lineNumber, lineColumn);
}
Token Token::CreateStatementEndToken(int const lineNumber, int const lineColumn)
{
return Token(TokenType::StatementEnd, true, lineNumber, lineColumn);
}
Token Token::CreateLabelToken(std::string const & string, bool isValid, int const lineNumber, int const lineColumn)
{
return Token(TokenType::Label, string, isValid, lineNumber, lineColumn);
}
Token Token::CreateImmediateValueToken(int const value, bool isValid, int const lineNumber, int const lineColumn)
{
return Token(TokenType::ImmediateInteger, value, isValid, lineNumber, lineColumn);
}
Token Token::CreateRegisterToken(RegisterType const registerType, int const lineNumber, int const lineColumn)
{
return Token(TokenType::Register, registerType, registerType != RegisterType::Unknown, lineNumber, lineColumn);
}
Token Token::CreateOperandToken(OperandType const operandType, int const lineNumber, int const lineColumn)
{
return Token(TokenType::Operand, operandType, operandType != OperandType::Unknown, lineNumber, lineColumn);
}
Token Token::CreateMemoryToken(RegisterType const registerType, int const lineNumber, int const lineColumn)
{
return Token(TokenType::Memory, registerType, registerType != RegisterType::Unknown, lineNumber, lineColumn);
}
Token Token::CreateMemoryToken(int const value, bool isValid, int const lineNumber, int const lineColumn)
{
return Token(TokenType::Memory, value, isValid, lineNumber, lineColumn);
}
void Token::DebugPrint() const
{
std::putc(' ', stdout);
@@ -122,6 +169,25 @@ namespace Token
std::printf("LABEL=%s", std::get<std::string>(data).c_str());
break;
case TokenType::Memory:
{
switch(valueType)
{
case TokenValueType::Integer:
std::printf("[$%i]", std::get<int>(data));
break;
case TokenValueType::Register:
std::printf("[%%%i]", static_cast<int>(std::get<RegisterType>(data)));
break;
default:
std::printf("[UNKNOWN_TYPE]");
break;
}
}
break;
case TokenType::Unknown:
default:
std::printf("UNKNOWN_TOKEN");

71
src/token/tokenizer.cpp
View File

@@ -8,58 +8,87 @@ namespace Token
return c == '\n' || c == ' ' || c == '\t' || c == '\r';
}
std::tuple<int, bool> TryParse(std::string const & string)
{
try
{
int value = std::stoi(string);
return std::make_tuple(value, true);
}
catch(std::invalid_argument &)
{
return std::make_tuple(0, false);
}
}
Token ExtractToken(std::string const & string, int const lineNumber, int const lineColumn)
{
if (string.size() == 0)
{
return Token(lineNumber, lineColumn);
return Token::CreateUnknownToken(lineNumber, lineColumn);
}
char const prefix = string[0];
if (prefix == '$')
{
int value = 0;
try
{
value = std::stoi(string.substr(1, string.size()));
}
catch(std::invalid_argument &)
{
return Token(lineNumber, lineColumn, 0, false);
}
return Token(lineNumber, lineColumn, value, true);
auto const result = TryParse(string.substr(1, string.size()));
return Token::CreateImmediateValueToken(std::get<0>(result), std::get<1>(result), lineNumber, lineColumn);
}
if (prefix == '%')
{
RegisterType const rtype = GetRegisterType(string.substr(1, string.size()));
return Token(lineNumber, lineColumn, rtype, rtype != RegisterType::Unknown);
return Token::CreateRegisterToken(GetRegisterType(string.substr(1, string.size())), lineNumber, lineColumn);
}
if (prefix == ';')
{
Token token(lineNumber, lineColumn);
token.type = TokenType::StatementEnd;
token.isValid = true;
return token;
return Token::CreateStatementEndToken(lineNumber, lineColumn);
}
char const postfix = string[string.size() - 1];
if (postfix == ':')
{
// TODO check if label is an Operand?
return Token(lineNumber, lineColumn, string.substr(0, string.size() - 1), true);
return Token::CreateLabelToken(string.substr(0, string.size() - 1), true, lineNumber, lineColumn);
}
if (prefix == '[' && postfix == ']')
{
if(string.size() < 4)
{
return Token::CreateMemoryToken(0, false, lineNumber, lineColumn + 2u);
}
char const memoryPrefix = string[1];
std::string const valueString = string.substr(2, string.size() - 3u);
if (memoryPrefix == '$')
{
auto const result = TryParse(valueString);
return Token::CreateMemoryToken(std::get<0>(result), std::get<1>(result), lineNumber, lineColumn);
}
else if (memoryPrefix == '%')
{
return Token::CreateMemoryToken(GetRegisterType(valueString), lineNumber, lineColumn);
}
else
{
return Token::CreateMemoryToken(0, false, lineNumber, lineColumn + 1u);
}
}
else if (prefix == '[' || postfix == ']')
{
int const errorLineColumn = (prefix == '[') ? lineColumn : (lineColumn + string.size() - 1u);
return Token::CreateMemoryToken(0, false, lineNumber, errorLineColumn);
}
OperandType const opType = GetOperandType(string);
if (opType != OperandType::Unknown)
{
return Token(lineNumber, lineColumn, opType, true);
return Token::CreateOperandToken(opType, lineNumber, lineColumn);
}
// Last resort: it must be a label
return Token(lineNumber, lineColumn, string, true);
return Token::CreateLabelToken(string, true, lineNumber, lineColumn);
}
void Tokenizer::Tokenize(std::string const & line, int const lineNumber, std::vector<Token> & tokens)