PIC-Simu/src/main/java/fabrik/simulator/pic16f84/DataRegister.java

package fabrik.simulator.pic16f84;

import java.util.Arrays;

public class DataRegister {
    private static final int PCL = 0x2;
    private static final int STATUS = 0x3;
    private static final int FSR = 0x4;
    private static final int PCLATH = 0xA;
    private static final int INTCON = 0xB;

    private static final int TRISA = 0x85;
    private static final int TRISB = 0x86;

    private static final int C = 0x0;
    private static final int DC = 0x1;
    private static final int Z = 0x2;
    private static final int RP0 = 0x5;


    private static final int [] dataRegister =  new int[0xFF];
    private static final int [] syncedRegisters = {PCL, STATUS, FSR, PCLATH, INTCON};

    public static void initDataRegister() {
        dataRegister[PCL] = 0b0;
        dataRegister[STATUS] = 0b00011000;
        dataRegister[PCLATH] = 0b0;
        dataRegister[INTCON] = 0b0;

        dataRegister[0x81] = 0b11111111;
        dataRegister[0x80 + PCL] = dataRegister[PCL];
        dataRegister[0x80 + STATUS] = dataRegister[STATUS];
        dataRegister[TRISA] = 0b11111000;
        dataRegister[TRISB] = 0b11111111;
        dataRegister[0x80 + PCLATH] = dataRegister[PCLATH];
        dataRegister[0x80 + INTCON] = dataRegister[INTCON];
        System.out.println(Arrays.toString(dataRegister));
    }

    private static boolean isSyncedRegister (int address){
        for (int register : syncedRegisters){
            if (address == register || address == 0x80 + register){
                return true;
            }
        }
        return false;
    }

    public static int[] getDataRegister() {
        return dataRegister;
    }

    private static int bank() {
        return ((dataRegister[STATUS] >> RP0) & 1) * 0x80;
    }

    public static int getRegister(int fileAddress){
        return dataRegister[bank() + fileAddress];
    }

    public static void setRegister(int fileAddress, int content){
        if (!isSyncedRegister(fileAddress))
            dataRegister[bank() + fileAddress] = content;
        else {
            dataRegister[fileAddress] = content;
            dataRegister[0x80 + fileAddress] = content;
        }
    }

    public static int getBit(int address, int bit) {
        return (dataRegister[bank() + address] >> bit) & 1;
    }

    private static int getDirectBit(int address, int bit){
        return (dataRegister[address] >> bit) & 1;
    }

    public static void clearBit(int address, int bit) {
        if (!isSyncedRegister(address)) {
            if (getBit(address, bit) == 1) {
                dataRegister[bank() + address] -= (int) Math.pow(2, bit);
            }
        }
        else {
            if (getBit(address, bit) == 1) {
                dataRegister[address] -= (int) Math.pow(2, bit);
                dataRegister[0x80 + address] = dataRegister[address];
            }
        }
    }

    public static void setBit(int address, int bit) {
        if (!isSyncedRegister(address)) {
            if (getBit(address, bit) == 0) {
                dataRegister[bank() + address] += (int) Math.pow(2, bit);
            }
        }
        else {
            if (getBit(address, bit) == 0) {
                dataRegister[address] += (int) Math.pow(2, bit);
                dataRegister[0x80 + address] = dataRegister[address];
            }
        }
    }

    private static int programCounter = 0;

    private static void writeToPCL(){
        dataRegister[PCL] = programCounter;
        dataRegister[0x82] = dataRegister[PCL];
    }

    public static void increasePC (){
        programCounter = getRegister(PCL);
        if (programCounter != 0x3FF) {
            programCounter++;
        }
        else {
            programCounter = 0;
        }
        writeToPCL();
    }

    public static void setPC (int value){
        programCounter = value;
        writeToPCL();
    }

    public static int getPC(){
        return programCounter;
    }

    private static int zeroFlag = 0;

    public static void determineZeroFlag(int result){
        if (result == 0){
            zeroFlag = 1;
            if (getBit(STATUS, Z) == 0){
                dataRegister[STATUS] += 0b100;
                dataRegister[0x80 + STATUS] = dataRegister[STATUS];
            }
        }
        else {
            zeroFlag = 0;
            if (getBit(STATUS, Z) == 1){
                dataRegister[STATUS] -= 0b100;
                dataRegister[0x80 + STATUS] = dataRegister[STATUS];
            }
        }
    }

    private static int carryFlag = 0;

    public static void setCarryFlag(int value){
        carryFlag = value;
        if (value == 1){
            if (getBit(STATUS, C) == 0){
                dataRegister[STATUS] += 0b1;
                dataRegister[0x80 + STATUS] = dataRegister[STATUS];
            }
        }
        else {
            if (getBit(STATUS, C) == 1){
                dataRegister[STATUS] -= 0b1;
                dataRegister[0x80 + STATUS] = dataRegister[STATUS];
            }
        }
    }

    public static void determineCarryFlag (int result){
        if (result > 0xFF){
            setCarryFlag(1);
        }
        else {
            setCarryFlag(0);
        }
    }

    public static int getCarryFlag (){
        return carryFlag;
    }

    private static int digitCarryFlag = 0;

    public static void setDigitCarryFlag(int value){
        digitCarryFlag = value;
        if (value == 1){
            if (getBit(STATUS, DC) == 0){
                dataRegister[STATUS] += 0b10;
                dataRegister[0x80 + STATUS] = dataRegister[STATUS];
            }
        }
        else {
            if (getBit(STATUS, DC) == 1){
                dataRegister[STATUS] -= 0b10;
                dataRegister[0x80 + STATUS] = dataRegister[STATUS];
            }
        }
    }

    public static void determineDigitCarryFlag(int result){
        if (result > 0xF){
            setDigitCarryFlag(1);
        }
        else {
            setDigitCarryFlag(0);
        }
    }

    public static int getDigitCarryFlag(){
        return digitCarryFlag;
    }

}