Basic arithmetic and jump labels

include/interpret/code.hpp

@@ -0,0 +1,15 @@
+#pragma once
+#include <interpret/statement.hpp>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace Interpret
+{
+	struct Code
+	{
+		std::vector<std::unique_ptr<Statement>> statements;
+		std::unordered_map<std::string, unsigned> labelStatementIndice;
+	};
+}

include/interpret/errors.hpp

@@ -0,0 +1,62 @@
+#pragma once
+#include <exception>
+#include <string>
+#include <token/token.hpp>
+
+namespace Interpret
+{
+	struct TokenError : public std::exception
+	{
+		Token::Token errorToken;
+		std::string errorMsg;
+		TokenError(Token::Token const & token, std::string const & msg);
+	};
+
+	struct ExpectedArgument : public TokenError
+	{
+		ExpectedArgument(Token::Token const & token);
+	};
+
+	struct ExpectedLabel : public TokenError
+	{
+		ExpectedLabel(Token::Token const & token);
+	};
+
+	struct ExpectedImmediate : public TokenError
+	{
+		ExpectedImmediate(Token::Token const & token);
+	};
+
+	struct ExpectedRegister : public TokenError
+	{
+		ExpectedRegister(Token::Token const & token);
+	};
+
+	struct ExpectedOperand : public TokenError
+	{
+		ExpectedOperand(Token::Token const & token);
+	};
+
+	struct TooManyArguments : public TokenError
+	{
+		TooManyArguments(Token::Token const & token);
+	};
+
+	struct TooFewArguments : public TokenError
+	{
+		TooFewArguments(Token::Token const & token);
+	};
+
+	struct MissingEndOfStatment : public TokenError
+	{
+		MissingEndOfStatment(Token::Token const & token);
+	};
+
+	namespace Internal
+	{
+		struct BadTokenForValue : public TokenError
+		{
+			BadTokenForValue(Token::Token const & token);
+		};
+	}
+}

include/interpret/interpreter.hpp

@@ -0,0 +1,14 @@
+#pragma once
+#include <interpret/code.hpp>
+#include <memory>
+#include <token/token.hpp>
+#include <vector>
+
+namespace Interpret
+{
+	class Interpreter
+	{
+	public:
+		void Interpret(std::vector<Token::Token> const & tokens, Code & code);
+	};
+}

include/interpret/operanddefinitions.hpp

@@ -0,0 +1,11 @@
+#pragma once
+#include <interpret/statement.hpp>
+#include <memory>
+#include <vector>
+
+namespace Interpret
+{
+	std::unique_ptr<Statement> ExtractStatement(unsigned const operatorIndex, std::vector<Token::Token> const & tokens);
+
+	int GetRequiredNumberOfArguments(Token::OperandType const type);
+}

include/interpret/statement.hpp

@@ -0,0 +1,57 @@
+#pragma once
+#include <execute/flags.hpp>
+#include <execute/registers.hpp>
+#include <execute/state.hpp>
+#include <interpret/value.hpp>
+
+namespace Interpret
+{
+	struct Statement
+	{
+		virtual void Execute(Execute::Flags & flags, Execute::State & state, Execute::Registers & registers) = 0;
+	};
+
+	struct NoArgumentStatement : Statement
+	{
+		void (* function)(Execute::Flags & flags, Execute::Registers & registers);
+		void Execute(Execute::Flags & flags, Execute::State & state, Execute::Registers & registers) override;
+	};
+
+	struct OneArgumentStatement : Statement
+	{
+		void (* function)(Execute::Flags & flags, int argument1);
+		Value firstArgument;
+
+		void Execute(Execute::Flags & flags, Execute::State & state, Execute::Registers & registers) override;
+	};
+
+	struct TwoArgumentStatement : Statement
+	{
+		void (* function)(Execute::Flags & flags, int argument1, int argument2);
+		Value firstArgument;
+		Value secondArgument;
+		
+		void Execute(Execute::Flags & flags, Execute::State & state, Execute::Registers & registers) override;
+	};
+
+	struct ThreeArgumentStatement : Statement
+	{
+		void (* function)(Execute::Flags & flags, int argument1, int argument2, int & argument3);
+		Value firstArgument;
+		Value secondArgument;
+		Value thirdArgument;
+		
+		void Execute(Execute::Flags & flags, Execute::State & state, Execute::Registers & registers) override;
+	};
+
+	struct JumpStatement : Statement
+	{
+	private:
+		std::string const label;
+
+	public:
+		void Execute(Execute::Flags & flags, Execute::State & state, Execute::Registers & registers) override;
+
+		JumpStatement(std::string const & label);
+	};
+}

include/interpret/value.hpp

@@ -0,0 +1,26 @@
+#pragma once
+#include <execute/registers.hpp>
+#include <token/token.hpp>
+
+namespace Interpret
+{
+	enum class ValueType
+	{
+		Register,
+		ImmediateInteger
+	};
+
+	struct Value
+	{
+		ValueType type;
+		union
+		{
+			int registerIndex;
+			int integer;
+		};
+
+		int & GetValue(Execute::Registers & registers);
+
+		void CreateFromToken(Token::Token const & token);
+	};
+}