Add seti and int operators

src/execute/interrupts.cpp

@@ -0,0 +1,16 @@
+#include <cstdio>
+#include <execute/interrupts.hpp>
+
+namespace Execute
+{
+	std::vector<InterruptFn> GetInterrupts()
+	{
+		return std::vector<InterruptFn>
+		{
+			// 0 print char
+			[](Execute::Registers & registers) { std::putc(registers.A, stdout); },
+			// 1 print decimal integer
+			[](Execute::Registers & registers) { std::printf("%i", registers.A); }
+		};
+	}
+}

src/execute/state.cpp

@@ -5,7 +5,8 @@ namespace Execute
 	State::State(std::unordered_map<std::string, unsigned> const & _labelStatementIndice)
 		: currentStatement(0u),
 		nextStatement(1u),
-		labelStatementIndice(_labelStatementIndice)
+		labelStatementIndice(_labelStatementIndice),
+		interrupts(GetInterrupts())
 	{
 	}
 }

src/interpret/error.cpp

@@ -18,6 +18,11 @@ namespace Interpret
 	{
 	}
 
+	ExpectedValue::ExpectedValue(Token::Token const & token)
+		: TokenError(token, "Expected an immediate value or register")
+	{
+	}
+
 	ExpectedImmediate::ExpectedImmediate(Token::Token const & token)
 		: TokenError(token, "Expected an immediate value")
 	{

src/interpret/operanddefinitions.cpp

@@ -42,7 +42,7 @@ namespace Interpret
 			return v;
 		}
 
-		throw ExpectedRegister(token);
+		throw ExpectedValue(token);
 	}
 
 	void AddArithmeticArguments(ArithmeticStatement & statement, unsigned const operandIndex, std::vector<Token::Token> const & tokens)
@@ -193,9 +193,27 @@ namespace Interpret
 				return statement;
 			}
 
+			case Token::OperandType::SetInteger:
+			{
+				auto statement = std::make_unique<SetStatement>();
+				statement->firstArgument = GetRegisterArgument(operandIndex + 1u, tokens);
+				statement->secondArgument = GetImmediateOrRegisterArgument(operandIndex + 2u, tokens);
+
+				return statement;
+			}
+
+			case Token::OperandType::Interrupt:
+			{
+				auto statement = std::make_unique<InterruptStatement>();
+				statement->firstArgument = GetImmediateOrRegisterArgument(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;
@@ -218,12 +236,15 @@ namespace Interpret
 			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::Interrupt:
 			return 1;
 
 			default:
+			std::printf("WARNING: returning default argument length of 0 for operand type %i\n", static_cast<int>(type));
 			return 0;
 		}
 	}

src/interpret/statement.cpp

@@ -39,4 +39,14 @@ namespace Interpret
 		: label(_label)
 	{
 	}
+
+	void SetStatement::Execute(Execute::Flags & flags, Execute::State & state, Execute::Registers & registers)
+	{
+		firstArgument.GetValue(registers) = secondArgument.GetValue(registers);
+	}
+
+	void InterruptStatement::Execute(Execute::Flags & flags, Execute::State & state, Execute::Registers & registers)
+	{
+		state.interrupts[firstArgument.GetValue(registers)](registers);
+	}
 }

src/main.cpp

@@ -114,6 +114,8 @@ int main(int argc, char ** argv)
 
 	std::puts("\n*** Execution ***");
 	Execute::VirtualMachine vm(code);
+	vm.Run();
+	/*
 	while(!vm.IsTerminated())
 	{
 		vm.SingleStep();
@@ -125,6 +127,7 @@ int main(int argc, char ** argv)
 		std::puts("Press any key to step...");
 		std::getchar();
 	}
+	*/
 	// END DEBUG
 	
 	return 0;

src/token/operandtype.cpp

@@ -17,6 +17,8 @@ namespace Token
 			{ "lti", OperandType::LessThanInteger },
 			{ "gti", OperandType::GreaterThanInteger },
 			{ "eqi", OperandType::EqualInteger },
+			{ "seti", OperandType::SetInteger },
+			{ "int", OperandType::Interrupt }
 		};
 
 		auto const & result = operations.find(op);

src/token/token.cpp

@@ -64,49 +64,26 @@ namespace Token
 			case TokenType::ImmediateInteger:
 			if (isValid)
 			{
-				std::printf("$int=%i", std::get<int>(data));
+				std::printf("%i", std::get<int>(data));
 			}
 			else
 			{
-				std::printf("BAD_IMM_INT");
+				std::printf("BAD_IMM");
 			}
 			break;
 
 			case TokenType::Operand:
 			if (isValid)
 			{
-				switch(std::get<OperandType>(data))
+				OperandType const opType = std::get<OperandType>(data);
+				switch(opType)
 				{
-					case OperandType::AddInteger:
-					std::printf("addi");
-					break;
-
-					case OperandType::MultiplyInteger:
-					std::printf("muli");
-					break;
-
-					case OperandType::SubtractInteger:
-					std::printf("subi");
-					break;
-
-					case OperandType::DivideInteger:
-					std::printf("divi");
-					break;
-
-					case OperandType::ShiftIntegerLeft:
-					std::printf("shli");
-					break;
-
-					case OperandType::ShiftIntegerRight:
-					std::printf("shri");
-					break;
-
-					case OperandType::Jump:
-					std::printf("jump");
+					case OperandType::Unknown:
+					std::printf("unknown_op");
 					break;
 
 					default:
-					std::printf("unknown_op");
+					std::printf("op%i", static_cast<int>(opType));
 					break;
 				}
 			}
@@ -119,25 +96,14 @@ namespace Token
 			case TokenType::Register:
 			if (isValid)
 			{
-				switch(std::get<RegisterType>(data))
+				RegisterType const regType = std::get<RegisterType>(data);
+				switch(regType)
 				{
-					case RegisterType::A:
-					std::printf("%%A");
-					break;
-
-					case RegisterType::B:
-					std::printf("%%B");
-					break;
-
-					case RegisterType::C:
-					std::printf("%%C");
-					break;
-
-					case RegisterType::D:
-					std::printf("%%D");
-					break;
-
 					default:
+					std::printf("%%%i", static_cast<int>(regType));
+					break;
+
+					case RegisterType::Unknown:
 					std::printf("%%unknown_reg");
 					break;
 				}
@@ -153,7 +119,7 @@ namespace Token
 			break;
 
 			case TokenType::Label:
-			std::printf("label=%s", std::get<std::string>(data).c_str());
+			std::printf("LABEL=%s", std::get<std::string>(data).c_str());
 			break;
 
 			case TokenType::Unknown:

src/token/tokenizer.cpp

@@ -70,32 +70,32 @@ namespace Token
 			LookForTokenEnd,
 		};
 		TokenizerState state = TokenizerState::LookForNextToken;
-		unsigned tokenStart = 0;
-		for(unsigned i = 0u; i < line.size(); ++i)
+		unsigned columnTokenStart = 0;
+		for(unsigned column = 0u; column < line.size(); ++column)
 		{
 			switch(state)
 			{
 				case TokenizerState::LookForNextToken:
-				if (!IsWhiteSpace(line[i]))
+				if (!IsWhiteSpace(line[column]))
 				{
-					if (line[i] == '#')
+					if (line[column] == '#')
 					{
 						// Ignore comments
 						return;
 					}
 
-					tokenStart = i;
+					columnTokenStart = column;
 					state = TokenizerState::LookForTokenEnd;
 				}
 				break;
 
 				case TokenizerState::LookForTokenEnd:
-				if (IsWhiteSpace(line[i]) || line[i] == ';')
+				if (IsWhiteSpace(line[column]) || line[column] == ';')
 				{
-					tokens.push_back(ExtractToken(line.substr(tokenStart, i - tokenStart), lineNumber, tokenStart));
-					if (line[i] == ';')
+					tokens.push_back(ExtractToken(line.substr(columnTokenStart, column - columnTokenStart), lineNumber, columnTokenStart));
+					if (line[column] == ';')
 					{
-						tokens.push_back(ExtractToken(line.substr(i, 1), lineNumber, tokenStart));
+						tokens.push_back(ExtractToken(line.substr(column, 1), lineNumber, column));
 					}
 					state = TokenizerState::LookForNextToken;
 				}
@@ -104,7 +104,7 @@ namespace Token
 		}
 		if (state == TokenizerState::LookForTokenEnd)
 		{
-			tokens.push_back(ExtractToken(line.substr(tokenStart, line.size()), lineNumber, tokenStart));
+			tokens.push_back(ExtractToken(line.substr(columnTokenStart, line.size()), lineNumber, columnTokenStart));
 		}
 	}
 }