spo/ass2/Machine.cpp

#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;
    }
}