created basic simulator

ass2/Machine.cpp

@@ -0,0 +1,234 @@
+#include "Machine.h"
+
+#include <cstring>
+#include <iostream>
+
+#include "FileDevice.h"
+#include "InputDevice.h"
+#include "OutputDevice.h"
+
+Machine::Machine() {
+    A = 0;
+    X = 0;
+    L = 0;
+    B = 0;
+    S = 0;
+    T = 0;
+    F = 0.0;
+    PC = 0;
+    SW = 0;
+
+    for (int i = 0; i <= MAX_ADDRESS; i++) {
+        memory[i] = 0;
+    }
+
+    for (int i = 0; i < MAX_DEVICES; i++) {
+        devices[i] = nullptr;
+    }
+
+    devices[0] = new InputDevice(std::cin);
+    devices[1] = new OutputDevice(std::cout);
+    devices[2] = new OutputDevice(std::cerr);
+}
+
+Machine::~Machine() {
+    for (int i = 0; i < MAX_DEVICES; i++) {
+        if (devices[i] != nullptr) {
+            delete devices[i];
+            devices[i] = nullptr;
+        }
+    }
+}
+
+int Machine::getA() const {
+    return A;
+}
+
+int Machine::getX() const {
+    return X;
+}
+
+int Machine::getL() const {
+    return L;
+}
+
+int Machine::getB() const {
+    return B;
+}
+
+int Machine::getS() const {
+    return S;
+}
+
+int Machine::getT() const {
+    return T;
+}
+
+double Machine::getF() const {
+    return F;
+}
+
+int Machine::getPC() const {
+    return PC;
+}
+
+int Machine::getSW() const {
+    return SW;
+}
+
+// mask to 24 bits
+
+void Machine::setA(int val) {
+    A = val & 0xFFFFFF;
+}
+
+void Machine::setX(int val) {
+    X = val & 0xFFFFFF;
+}
+
+void Machine::setL(int val) {
+    L = val & 0xFFFFFF;
+}
+
+void Machine::setB(int val) {
+    B = val & 0xFFFFFF;
+}
+
+void Machine::setS(int val) {
+    S = val & 0xFFFFFF;
+}
+
+void Machine::setT(int val) {
+    T = val & 0xFFFFFF;
+}
+
+void Machine::setF(double val) {
+    F = val;
+}
+
+void Machine::setPC(int val) {
+    PC = val & 0xFFFFFF;
+}
+
+void Machine::setSW(int val) {
+    SW = val & 0xFFFFFF;
+}
+
+void Machine::setCC_less() {
+    SW = (SW & 0xFFFF3F) | 0x0;
+}
+
+void Machine::setCC_equal() {
+    SW = (SW & 0xFFFF3F) | 0x40;
+}
+
+void Machine::setCC_greater() {
+    SW = (SW & 0xFFFF3F) | 0x80;
+}
+
+int Machine::getCC() const {
+    return SW & 0xC0;
+}
+
+int Machine::getReg(int reg) const {
+    switch (reg) {
+        case 0:
+            return A;
+        case 1:
+            return X;
+        case 2:
+            return L;
+        case 3:
+            return B;
+        case 4:
+            return S;
+        case 5:
+            return T;
+        case 6:
+            return (int)F;
+        case 8:
+            return PC;
+        case 9:
+            return SW;
+        default:
+            return 0;
+    }
+}
+
+void Machine::setReg(int reg, int val) {
+    switch (reg) {
+        case 0:
+            setA(val);
+            break;
+        case 1:
+            setX(val);
+            break;
+        case 2:
+            setL(val);
+            break;
+        case 3:
+            setB(val);
+            break;
+        case 4:
+            setS(val);
+            break;
+        case 5:
+            setT(val);
+            break;
+        case 6:
+            setF((double)val);
+            break;
+        case 8:
+            setPC(val);
+            break;
+        case 9:
+            setSW(val);
+            break;
+        default:
+            break;
+    }
+}
+
+int Machine::getByte(int addr) const {
+    if (addr < 0 || addr > MAX_ADDRESS) {
+        return 0;
+    }
+    return memory[addr];
+}
+
+void Machine::setByte(int addr, int val) {
+    if (addr >= 0 && addr <= MAX_ADDRESS) {
+        memory[addr] = val & 0xFF;
+    }
+}
+
+int Machine::getWord(int addr) const {
+    if (addr < 0 || addr + 2 > MAX_ADDRESS) {
+        return 0;
+    }
+    // big-endian
+    return (memory[addr] << 16) | (memory[addr + 1] << 8) | memory[addr + 2];
+}
+
+void Machine::setWord(int addr, int val) {
+    if (addr >= 0 && addr + 2 <= MAX_ADDRESS) {
+        val = val & 0xFFFFFF;
+        // big-endian
+        memory[addr] = (val >> 16) & 0xFF;
+        memory[addr + 1] = (val >> 8) & 0xFF;
+        memory[addr + 2] = val & 0xFF;
+    }
+}
+
+Device* Machine::getDevice(int num) const {
+    if (num < 0 || num >= MAX_DEVICES) {
+        return nullptr;
+    }
+    return devices[num];
+}
+
+void Machine::setDevice(int num, Device* device) {
+    if (num >= 0 && num < MAX_DEVICES) {
+        devices[num] = device;
+    }
+}