/*

						Extracted from original single fake6502.c file

*/


//flag modifier macros
#define setcarry() regs.status |= FLAG_CARRY
#define clearcarry() regs.status &= (~FLAG_CARRY)
#define setzero() regs.status |= FLAG_ZERO
#define clearzero() regs.status &= (~FLAG_ZERO)
#define setinterrupt() regs.status |= FLAG_INTERRUPT
#define clearinterrupt() regs.status &= (~FLAG_INTERRUPT)
#define setdecimal() regs.status |= FLAG_DECIMAL
#define cleardecimal() regs.status &= (~FLAG_DECIMAL)
#define setoverflow() regs.status |= FLAG_OVERFLOW
#define clearoverflow() regs.status &= (~FLAG_OVERFLOW)
#define setsign() regs.status |= FLAG_SIGN
#define clearsign() regs.status &= (~FLAG_SIGN)


//flag calculation macros
#define zerocalc(n, use16Bit) {\
    if (use16Bit) \
        if ((n) & 0xFFFF) clearzero();\
            else setzero();\
    else if ((n) & 0x00FF) clearzero();\
        else setzero();\
}

#define signcalc(n, use16Bit) {\
    if (use16Bit) \
        if ((n) & 0x8000) setsign();\
            else clearsign();\
    else if ((n) & 0x0080) setsign();\
        else clearsign();\
}

#define carrycalc(n, use16Bit) {\
    if (use16Bit) \
        if ((n) & 0x10000) setcarry();\
            else clearcarry();\
    else if ((n) & 0x0100) setcarry();\
        else clearcarry();\
}

#define overflowcalc8(n, m, o) { /* n = result, m = accumulator, o = memory */ \
    if (((n) ^ (m)) & ((n) ^ (o)) & 0x80) setoverflow();\
        else clearoverflow();\
}

#define overflowcalc16(n, m, o) { /* n = result, m = accumulator, o = memory */ \
    if (((n) ^ (m)) & ((n) ^ (o)) & 0x8000) setoverflow();\
        else clearoverflow();\
}

#define index_16bit() (regs.is65c816 && !(regs.status & FLAG_INDEX_WIDTH))
#define memory_16bit() (regs.is65c816 && !(regs.status & FLAG_MEMORY_WIDTH))
#define acc_for_mode() (memory_16bit() ? regs.c : ((uint16_t) regs.a))


#define saveaccum(n) (memory_16bit() ? (regs.c = (n)) : (regs.a = (uint8_t)((n) & 0x00FF)))

#define mask_long_addr(addr) ((addr) & 0xFFFFFF)
#define as_bank_byte(b) ((uint32_t) (((uint8_t) (b)) << 16))
#define bank_byte(b) ((uint8_t) ((b) >> 16))

//a few general functions used by various other functions

uint16_t add_wrap_at_page_boundary(uint16_t value, uint8_t add) {
    if (regs.e) {
        return (value & 0xFF00) | ((uint16_t) (((uint8_t) (value & 0x00FF)) + add) & 0x00FF);
    } else {
        return value + add;
    }
}

uint16_t subtract_wrap_at_page_boundary(uint16_t value, uint8_t subtract) {
    if (regs.e) {
        return (value & 0xFF00) | ((uint16_t) (((uint8_t) (value & 0x00FF)) - subtract) & 0x00FF);
    } else {
        return value - subtract;
    }
}

void increment_wrap_at_page_boundary(uint16_t *value) {
    if (regs.e) {
        *value = (*value & 0xFF00) | ((uint16_t) (((uint8_t) (*value & 0x00FF)) + 1) & 0x00FF);
    } else {
        (*value)++;
    }
}

void decrement_wrap_at_page_boundary(uint16_t *value) {
    if (regs.e) {
        *value = (*value & 0xFF00) | ((uint16_t) (((uint8_t) (*value & 0x00FF)) - 1) & 0x00FF);
    } else {
        (*value)--;
    }
}

uint16_t direct_page_add(uint16_t offset) {
    if (regs.e && (regs.dp & 0x00FF) == 0) {
        return (regs.dp & 0xFF00) | ((uint16_t) ((uint8_t) (regs.dp & 0x00FF)) + (offset & 0xFF));
    } else {
        return regs.dp + offset;
    }
}

#define incsp() increment_wrap_at_page_boundary(&regs.sp)
#define decsp() decrement_wrap_at_page_boundary(&regs.sp)

void push16(uint16_t pushval) {
    write6502(regs.sp, 0, (pushval >> 8) & 0xFF);
    decsp();
    write6502(regs.sp, 0, pushval & 0xFF);
    decsp();
}

void push8(uint8_t pushval) {
    write6502(regs.sp, 0, pushval);
    decsp();
}

uint16_t pull16() {
    incsp();
    uint16_t temp16 = read6502(regs.sp, 0);
    incsp();
    temp16 |= (uint16_t) read6502(regs.sp, 0) << 8;
    return temp16;
}

uint8_t pull8() {
    incsp();
    uint8_t value = read6502(regs.sp, 0);
    return value;
}

void reset6502(bool c816) {
    regs.pc = (uint16_t)read6502(0xFFFC, 0) | ((uint16_t)read6502(0xFFFD, 0) << 8);
    regs.c = 0;
    regs.x = 0;
    regs.y = 0;
    regs.dp = 0;
    regs.sp = 0x1FD;
    regs.e = 1;
    regs.k = 0;
    regs.db = 0;
    if (c816) {
        regs.status |= FLAG_INDEX_WIDTH | FLAG_MEMORY_WIDTH;
        regs.is65c816 = true;
        ticktable = ticktable_c816;
        optable = optable_c816;
        addrtable = addrtable_c816;
    } else {
        regs.status |= FLAG_CONSTANT;
        regs.is65c816 = false;
        ticktable = ticktable_c02;
        optable = optable_c02;
        addrtable = addrtable_c02;
    }
    setinterrupt();
    cleardecimal();
    waiting = 0;
}

enum InterruptType {
    INT_COP = 0x4,
    INT_BRK = 0x6,
    INT_NMI = 0xA,
    INT_IRQ = 0xE
};

void interrupt6502(enum InterruptType vector) {
    if (!regs.e) {
        push8(regs.k);
    }

    regs.k = 0; // also in emulated mode

    push16(regs.pc);

    if (regs.e) {
        if (vector == INT_BRK) {
            push8(regs.status | FLAG_BREAK);
            vector = INT_IRQ;
        } else {
            push8(regs.status & ~FLAG_BREAK);
        }
    } else {
        push8(regs.status);
    }

    setinterrupt();
    cleardecimal();
    vp6502();

    uint16_t vector_address = (regs.e ? 0xFFF0 : 0xFFE0) + (uint8_t) vector;
    regs.pc = (uint16_t) read6502(vector_address, 0) | ((uint16_t) read6502(vector_address + 1, 0) << 8);

    clockticks6502 += 7; // consumed by CPU to process interrupt
}

static uint32_t addr_with_db(uint16_t addr) {
    return mask_long_addr(as_bank_byte(regs.db) | addr);
}