added "lw" and "sw"

src/components/Alu.cpp

@@ -4,8 +4,10 @@
 
 #include "Alu.h"
 
+#include <algorithm>
 #include <vector>
 
+#include "Memory.h"
 #include "Register.h"
 
 void Alu::calculate(const std::vector<std::string> &commandVector) {
@@ -14,7 +16,10 @@ void Alu::calculate(const std::vector<std::string> &commandVector) {
 
     /// Extrahiere die Argumente des Befehls
     const auto arg1 = parseArgument(commandVector.at(0));
-    const auto arg2 = parseArgument(commandVector.at(1));
+    int arg2 = 0;
+    if (commandVector.at(1).find('(') != std::string::npos) {
+        arg2 = parseArgument(commandVector.at(2));
+    }
     int arg3 = 0;
     if (!commandVector.at(2).empty()) {
         arg3 = parseArgument(commandVector.at(2));
@@ -47,19 +52,27 @@ void Alu::calculate(const std::vector<std::string> &commandVector) {
         Register::getInstance().setRegister(arg1, result);
     } else if (command == "addi") {
         const auto register1 = Register::getInstance().getRegister(arg2);
-        const auto immediate = parseArgument(commandVector.at(1));
+        const auto immediate = arg3;
         const auto result = register1 + immediate;
         Register::getInstance().setRegister(arg1, result);
     } else if (command == "andi") {
         const auto register1 = Register::getInstance().getRegister(arg2);
-        const auto immediate = parseArgument(commandVector.at(1));
+        const auto immediate = arg3;
         const auto result = register1 & immediate;
         Register::getInstance().setRegister(arg1, result);
     } else if (command == "ori") {
         const auto register1 = Register::getInstance().getRegister(arg2);
-        const auto immediate = parseArgument(commandVector.at(1));
+        const auto immediate = arg3;
         const auto result = register1 | immediate;
         Register::getInstance().setRegister(arg1, result);
+    } else if (command == "lw") {
+        const auto address = parseAddress(commandVector.at(2));
+        const auto data = Memory::getInstance()->load(address);
+        Register::getInstance().setRegister(arg1, data);
+    } else if (command == "sw") {
+        const auto address = parseAddress(commandVector.at(2));
+        const auto data = Register::getInstance().getRegister(arg1);
+        Memory::getInstance()->store(address, data);
     }
 }
 
@@ -71,3 +84,16 @@ int Alu::parseArgument(std::string argument) {
     /// Da das Argument noch als String vorliegt, muss es in ein int umgewandelt werden
     return std::stoi(argument);
 }
+
+int Alu::parseAddress(const std::string &argument) {
+    /// Trenne das Argument bei '('
+    /// 0(x1)
+    const size_t pos = argument.find('(');
+    if (pos != std::string::npos) {
+        const auto immediate = argument.substr(0, pos);
+        const auto register1 = argument.substr(pos + 1);
+        const auto address = immediate + register1;
+        return std::stoi(address);
+    }
+    return 0;
+}

src/components/Alu.h

@@ -26,6 +26,15 @@ public:
      * @return Das Befehlsargument als int
      */
     static int parseArgument(std::string argument);
+
+    /**
+     * Wandelt das angegebene Befehlsargument in eine auf
+     * Speicherbereich zeigende Adresse um
+     *
+     * @param argument Die Adresse des Befehlsargument, die geparst werden soll
+     * @return Die Adresse des Befehlsargument als int
+     */
+    static int parseAddress(const std::string &argument);
 };
 
 

src/components/Memory.cpp

@@ -4,6 +4,10 @@
 
 #include "Memory.h"
 
+Memory::Memory() {
+    m_memory = {0};
+}
+
 Memory *Memory::getInstance() {
     static Memory instance;
     return &instance;

src/components/Memory.h

@@ -10,22 +10,25 @@
 /// Als Hauptspeicher wird ein Array genutzt.
 
 
-
 class Memory {
 private:
-    Memory() = default;
+    Memory();
 
     /// Singleton instance
     static Memory *m_instance;
     /// Hauptspeicher (hier 32 kB groß)
-    std::array<int, 8192> m_memory;
+    std::array<int, 8192> m_memory{};
 
 public:
     /// Singleton Logik
     Memory(const Memory &) = delete;
+
     Memory(const Memory &&) = delete;
+
     Memory &operator=(const Memory &) = delete;
+
     Memory &operator=(const Memory &&) = delete;
+
     ~Memory() = default;
 
     /**
@@ -49,9 +52,7 @@ public:
      * @return Der Wert aus der Adresse
      */
     int load(int address) const;
-
 };
 
 
-
 #endif //MEMORY_H