folder reordering

src/Manager.cpp

@@ -0,0 +1,5 @@
+//
+// Created by black on 12.06.25.
+//
+
+#include "emulator/Manager.h"

src/Manager.h

@@ -0,0 +1,18 @@
+//
+// Created by black on 12.06.25.
+//
+
+#ifndef MANAGER_H
+#define MANAGER_H
+
+/// Die Manager Instanz sorgt für die Koordination von user input, Datei einlesen, code execution und anderen Aktionen.
+
+class Manager {
+public:
+
+
+};
+
+
+
+#endif //MANAGER_H

src/components/Memory.cpp

@@ -0,0 +1,18 @@
+//
+// Created by black on 12.06.25.
+//
+
+#include "Memory.h"
+
+Memory *Memory::getInstance() {
+    static Memory instance;
+    return &instance;
+}
+
+void Memory::store(const int address, const int value) {
+    m_memory.at(address) = value;
+}
+
+int Memory::load(const int address) const {
+    return m_memory.at(address);
+}

src/components/Memory.h

@@ -0,0 +1,53 @@
+//
+// Created by black on 12.06.25.
+//
+
+#ifndef MEMORY_H
+#define MEMORY_H
+#include <array>
+
+/// Eine Hauptspeicherklasse als Singleton implementiert.
+/// Als Hauptspeicher wird ein Array genutzt.
+
+
+
+class Memory {
+private:
+    Memory() = default;
+
+    /// Singleton instance
+    static Memory *m_instance;
+    /// Hauptspeicher (hier 32 kB groß)
+    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;
+
+    static Memory *getInstance();
+
+    /**
+     * Speichert den angegebenen Wert an der angegebenen Adresse im Hauptspeicher
+     *
+     * @param address Die Adresse, in die der Wert gespeichert werden soll
+     * @param value Der Wert, der in die Adresse gespeichert werden soll
+     */
+    void store(int address, int value);
+
+    /**
+     * Lädt den gespeicherten Wert aus der angegebenen Adresse
+     *
+     * @param address Die Adresse, aus der der Wert gelesen werden soll
+     * @return Der Wert aus der Adresse
+     */
+    int load(int address) const;
+
+};
+
+
+
+#endif //MEMORY_H

src/components/Register.cpp

@@ -0,0 +1,19 @@
+//
+// Created by black on 12.06.25.
+//
+
+#include "Register.h"
+
+
+Register& Register::getInstance() {
+    static Register instance;
+    return instance;
+}
+
+void Register::setRegister(const int reg, const int value) {
+    m_registers.at(reg) = value;
+}
+
+int Register::getRegister(const int reg) const {
+    return m_registers.at(reg);
+}

src/components/Register.h

@@ -0,0 +1,50 @@
+//
+// Created by black on 12.06.25.
+//
+
+#ifndef REGISTER_H
+#define REGISTER_H
+#include <array>
+
+/// Eine Registerklasse als Singleton implementiert.
+/// Als Speicher (Registers) wird ein int Array genutzt.
+
+
+class Register {
+
+private:
+    Register() = default;
+
+    /// Singleton instance
+    static Register *m_instance;
+    /// "Echter" Register Speicher
+    std::array<int, 32> m_registers;
+
+public:
+    /// Singleton Logik
+    Register(const Register &) = delete;
+    Register(const Register &&) = delete;
+    Register& operator=(const Register &) = delete;
+    Register& operator=(const Register &&) = delete;
+    ~Register() = default;
+
+    static Register& getInstance();
+
+    /**
+     * Speichert den angegebenen Wert im angegebenen Register
+     *
+     * @param reg Die Position des Registers
+     * @param value Der Wert für das Register
+     */
+    void setRegister(int reg, int value);
+
+    /**
+     *
+     * @param reg Die Position des Registers
+     * @return Der Wert des Registers
+     */
+    int getRegister(int reg) const;
+
+};
+
+#endif //REGISTER_H

src/loader/CommandParser.cpp

@@ -0,0 +1,30 @@
+//
+// Created by black on 12.06.25.
+//
+
+#include "emulator/CommandParser.h"
+
+#include <sstream>
+
+CommandParser & CommandParser::getInstance() {
+    static CommandParser instance;
+    return instance;
+}
+
+std::vector<std::string> CommandParser::parseLine(const std::string &input) {
+    std::vector<std::string> output{};
+    /// Konvertiere den Input String in einen IStringStream, damit dieser bei Leerzeichen gesplittet werden kann
+    std::istringstream iss(input);
+    std::string out;
+    do {
+        /// Trenne den IStringStream bei jedem Leerzeichen und füge die Befehl(e)/-sargumente dem Output hinzu
+        std::getline(iss, out, ' ');
+        /// Stoppe, sobald ein Kommentar im Source Code vorkommt
+        if (out.at(0) != '#') {
+            output.push_back(out);
+        } else {
+            break;
+        }
+    } while (!out.empty());
+    return output;
+}

src/loader/CommandParser.h

@@ -0,0 +1,38 @@
+//
+// Created by black on 12.06.25.
+//
+
+#ifndef COMMANDPARSER_H
+#define COMMANDPARSER_H
+#include <string>
+#include <vector>
+
+
+class CommandParser {
+
+private:
+    CommandParser() = default;
+
+public:
+    /// Singleton Logik
+    CommandParser(const CommandParser&) = delete;
+    CommandParser(const CommandParser&&) = delete;
+    CommandParser& operator=(const CommandParser&) = delete;
+    CommandParser& operator=(const CommandParser&&) = delete;
+    ~CommandParser() = default;
+
+    static CommandParser& getInstance();
+
+    /**
+     * Parst eine Zeile des Assembly Codes und gibt diese als sortierten Vektor zurück
+     *
+     * @param input Eine Zeile aus dem Assembly Code
+     * @return Ein Vektor mit Befehl und dessen Argumenten
+     */
+    static std::vector<std::string> parseLine(const std::string& input);
+
+};
+
+
+
+#endif //COMMANDPARSER_H

src/main.cpp

@@ -0,0 +1,7 @@
+//
+// Created by black on 12.06.25.
+//
+
+int main() {
+    return 0;
+}