src/cpu/instructions.h at bd65c0cc08c7 · andymccall/x16-emulator

# bd65c0cc08c7 x16-emulator / src / cpu / instructions.h

19.4 KiB · Objective-C · last changed chore(): initial commit 15 days ago source blame history raw

/*

						Extracted from original single fake6502.c file

*/
//
//          65C02 changes.
//
//          BRK                 now clears D
//          ADC/SBC             set N and Z in decimal mode. They also set V
//
//
//
//          instruction handler functions
//
static void adc() {
    penaltyop = 1;
    if (regs.status & FLAG_DECIMAL) {
        uint16_t tmp, tmp2;
        uint32_t tmpov;
        if (memory_16bit()) {
            uint16_t tmp3;
            uint32_t tmp4;
            value = getvalue(1);
            tmp = (regs.c & 0x000F) + (value & 0x000F) + (uint16_t)(regs.status & FLAG_CARRY);
            tmp2 = (regs.c & 0x00F0) + (value & 0x00F0);
            tmp3 = (regs.c & 0x0F00) + (value & 0x0F00);
            tmp4 = ((uint32_t)regs.c & 0xF000) + (value & 0xF000);
            if (tmp > 0x0009) {
                tmp2 += 0x0010;
                tmp += 0x0006;
            }
            if (tmp2 > 0x0090) {
                tmp3 += 0x0100;
                tmp2 += 0x0060;
            }
            if (tmp3 > 0x0900) {
                tmp4 += 0x1000;
                tmp3 += 0x0600;
            }
            tmpov = tmp4;
            if (tmp4 > 0x9000) {
                tmp4 += 0x6000;
            }
            if (tmp4 & 0xFFFF0000) {
                setcarry();
            } else {
                clearcarry();
            }
            result = (tmp & 0x000F) | (tmp2 & 0x00F0) | (tmp3 & 0x0F00) | (tmp4 & 0xF000);
            uint16_t ovresult = (tmp & 0x000F) | (tmp2 & 0x00F0) | (tmp3 & 0x0F00) | (tmpov & 0xF000);
            overflowcalc16(ovresult, regs.c, value);
        } else {
            value = getvalue(0);
            tmp = ((uint16_t)regs.a & 0x0F) + (value & 0x0F) + (uint16_t)(regs.status & FLAG_CARRY);
            tmp2 = ((uint16_t)regs.a & 0xF0) + (value & 0xF0);
            if (tmp > 0x09) {
                tmp2 += 0x10;
                tmp += 0x06;
            }
            tmpov = tmp2;
            if (tmp2 > 0x90) {
                tmp2 += 0x60;
            }
            if (tmp2 & 0xFF00) {
                setcarry();
            } else {
                clearcarry();
            }
            result = (tmp & 0x0F) | (tmp2 & 0xF0);
            uint8_t ovresult = (tmp & 0x0F) | (tmpov & 0xF0);
            overflowcalc8((uint16_t)ovresult, (uint16_t)regs.a, value);
        }
        clockticks6502 += (uint32_t)(!regs.is65c816);
    } else {
        if (memory_16bit()) {
            value = getvalue(1);
            result = regs.c + value + (uint16_t) (regs.status & FLAG_CARRY);
            overflowcalc16(result, regs.c, value);
            carrycalc(result, 1);
        } else {
            value = getvalue(0);
            result = (uint16_t)regs.a + value + (uint16_t) (regs.status & FLAG_CARRY);
            overflowcalc8(result, (uint16_t)regs.a, value);
            carrycalc(result, 0);
        }
    }

    zerocalc(result, memory_16bit());
    signcalc(result, memory_16bit());

    saveaccum(result);
}

static void and() {
    penaltyop = 1;
    value = getvalue(memory_16bit());
    result = acc_for_mode() & value;

    zerocalc(result, memory_16bit());
    signcalc(result, memory_16bit());

    saveaccum(result);
}

static void asl() {
    value = getvalue(memory_16bit());
    result = value << 1;

    carrycalc(result, memory_16bit());
    zerocalc(result, memory_16bit());
    signcalc(result, memory_16bit());

    putvalue(result, memory_16bit());
}

static void _do_branch(int condition) {
    if (condition) {
        oldpc = regs.pc;
        regs.pc += reladdr;
        clockticks6502++;
        if ((oldpc & 0xFF00) != (regs.pc & 0xFF00)) //check if jump crossed a page boundary
            penaltye = 1;
    }
}

static void bcc() {
    _do_branch((regs.status & FLAG_CARRY) == 0);
}

static void bcs() {
    _do_branch((regs.status & FLAG_CARRY) == FLAG_CARRY);
}

static void beq() {
    _do_branch((regs.status & FLAG_ZERO) == FLAG_ZERO);
}

static void bit() {
    value = getvalue(memory_16bit());
    result = acc_for_mode() & value;

    zerocalc(result, memory_16bit());
    // Xark - BUGFIX: 65C02 BIT #$xx only affects Z  See: http://6502.org/tutorials/65c02opcodes.html#2
    if (opcode != 0x89)
    {
        regs.status = (regs.status & 0x3F) | (uint8_t)(value & 0xC0);
    }
}

static void bmi() {
    _do_branch((regs.status & FLAG_SIGN) == FLAG_SIGN);
}

static void bne() {
    _do_branch((regs.status & FLAG_ZERO) == 0);
}

static void bpl() {
    _do_branch((regs.status & FLAG_SIGN) == 0);
}

static void brk() {
    penaltyn = 1;
    regs.pc++;

    interrupt6502(INT_BRK);
}

static void brl() {
    regs.pc += reladdr;
}

static void bvc() {
    _do_branch((regs.status & FLAG_OVERFLOW) == 0);
}

static void bvs() {
    _do_branch((regs.status & FLAG_OVERFLOW) == FLAG_OVERFLOW);
}

static void clc() {
    clearcarry();
}

static void cld() {
    cleardecimal();
}

static void cli() {
    clearinterrupt();
}

static void clv() {
    clearoverflow();
}

static void cmp() {
    penaltyop = 1;
    value = getvalue(memory_16bit());

    if (memory_16bit()) {
        result = regs.c - value;
        if (regs.c >= value) setcarry();
        else clearcarry();
        if (regs.c == value) setzero();
        else clearzero();
    } else {
        result = (uint16_t)regs.a - value;
        if (regs.a >= (uint8_t)(value & 0x00FF)) setcarry();
        else clearcarry();
        if (regs.a == (uint8_t)(value & 0x00FF)) setzero();
        else clearzero();
    }

    signcalc(result, memory_16bit());
}

static void cop() {
    penaltyn = 1;
    regs.pc++;

    interrupt6502(INT_COP);
}

static void cpx() {
    value = getvalue(index_16bit());

    if (index_16bit()) {
        result = regs.x - value;
        if(regs.x >= value) setcarry();
        else clearcarry();
        if (regs.x == value) setzero();
        else clearzero();
    } else {
        result = (uint16_t)regs.xl - value;
        if (regs.xl >= (uint8_t)(value & 0x00FF)) setcarry();
        else clearcarry();
        if (regs.xl == (uint8_t)(value & 0x00FF)) setzero();
        else clearzero();
    }
    signcalc(result, index_16bit());
}

static void cpy() {
    value = getvalue(index_16bit());

    if (index_16bit()) {
        result = regs.y - value;
        if(regs.y >= value) setcarry();
        else clearcarry();
        if (regs.y == value) setzero();
        else clearzero();
    } else {
        result = (uint16_t)regs.yl - value;
        if (regs.yl >= (uint8_t)(value & 0x00FF)) setcarry();
        else clearcarry();
        if (regs.yl == (uint8_t)(value & 0x00FF)) setzero();
        else clearzero();
    }
    signcalc(result, index_16bit());
}

static void dec() {
    value = getvalue(memory_16bit());
    result = value - 1;

    zerocalc(result, memory_16bit());
    signcalc(result, memory_16bit());

    putvalue(result, memory_16bit());
}

static void dex() {
    if (index_16bit()) {
        regs.x--;
        zerocalc(regs.x, 1);
        signcalc(regs.x, 1);
    } else {
        regs.xl--;
        zerocalc(regs.xl, 0);
        signcalc(regs.xl, 0);
    }
}

static void dey() {
    if (index_16bit()) {
        regs.y--;
        zerocalc(regs.y, 1);
        signcalc(regs.y, 1);
    } else {
        regs.yl--;
        zerocalc(regs.yl, 0);
        signcalc(regs.yl, 0);
    }
}

static void eor() {
    penaltyop = 1;
    value = getvalue(memory_16bit());
    result = acc_for_mode() ^ value;

    zerocalc(result, memory_16bit());
    signcalc(result, memory_16bit());

    saveaccum(result);
}

static void inc() {
    value = getvalue(memory_16bit());
    result = value + 1;

    zerocalc(result, memory_16bit());
    signcalc(result, memory_16bit());

    putvalue(result, memory_16bit());
}

static void inx() {
    if (index_16bit()) {
        regs.x++;
        zerocalc(regs.x, 1);
        signcalc(regs.x, 1);
    } else {
        regs.xl++;
        zerocalc(regs.xl, 0);
        signcalc(regs.xl, 0);
    }
}

static void iny() {
    if (index_16bit()) {
        regs.y++;
        zerocalc(regs.y, 1);
        signcalc(regs.y, 1);
    } else {
        regs.yl++;
        zerocalc(regs.yl, 0);
        signcalc(regs.yl, 0);
    }
}

static void jml() {
    regs.pc = ea & 0xFFFF;
    regs.k = ea >> 16;
}

static void jmp() {
    regs.pc = ea;
}

static void jsr() {
    push16(regs.pc - 1);
    regs.pc = ea;
}

static void jsl() {
    push8(regs.k);
    push16(regs.pc - 1);
    regs.pc = ea & 0xFFFF;
    regs.k = ea >> 16;
}

static void lda() {
    penaltyop = 1;
    penaltym = 1;

    if (memory_16bit()) {
        regs.c = getvalue(1);
        zerocalc(regs.c, 1);
        signcalc(regs.c, 1);
    } else {
        value = getvalue(0);
        regs.a = (uint8_t)(value & 0x00FF);
        zerocalc(regs.a, 0);
        signcalc(regs.a, 0);
    }
}

static void ldx() {
    penaltyop = 1;
    penaltyx = 1;

    if (index_16bit()) {
        regs.x = getvalue(1);
        zerocalc(regs.x, 1);
        signcalc(regs.x, 1);
    } else {
        value = getvalue(0);
        regs.xl = (uint8_t)(value & 0x00FF);
        zerocalc(regs.xl, 0);
        signcalc(regs.xl, 0);
    }
}

static void ldy() {
    penaltyop = 1;
    penaltyx = 1;

    if (index_16bit()) {
        regs.y = getvalue(1);
        zerocalc(regs.y, 1);
        signcalc(regs.y, 1);
    } else {
        regs.yl = (uint8_t)(getvalue(0) & 0x00FF);
        zerocalc(regs.yl, 0);
        signcalc(regs.yl, 0);
    }
}

static void lsr() {
    value = getvalue(memory_16bit());
    result = value >> 1;

    if (value & 1) setcarry();
        else clearcarry();
    zerocalc(result, memory_16bit());
    signcalc(result, memory_16bit());

    putvalue(result, memory_16bit());
}

static void nop() {
    switch (opcode) {
        case 0x1C:
        case 0x3C:
        case 0x5C:
        case 0x7C:
        case 0xDC:
        case 0xFC:
            penaltyop = 1;
            break;
    }
}

static void ora() {
    penaltyop = 1;
    value = getvalue(memory_16bit());
    result = acc_for_mode() | value;

    zerocalc(result, memory_16bit());
    signcalc(result, memory_16bit());

    saveaccum(result);
}

static void pea() {
    push16(getvalue(1));
}

static void pei() {
    push16(ea);
}

static void per() {
    push16(regs.pc + reladdr);
}

static void pha() {
    if (memory_16bit()) {
        push16(regs.c);
    } else {
        push8(regs.a);
    }
}

static void phb() {
    push8(regs.db);
}

static void phd() {
    push16(regs.dp);
}

static void phk() {
    push8(regs.k);
}

static void php() {
    push8(regs.e ? regs.status | FLAG_BREAK : regs.status);
}

static void pla() {
    if (memory_16bit()) {
        regs.c = pull16();
        zerocalc(regs.c, 1);
        signcalc(regs.c, 1);
    } else {
        regs.a = pull8();
        zerocalc(regs.a, 0);
        signcalc(regs.a, 0);
    }
}

static void plb() {
    regs.db = pull8();
    zerocalc(regs.db, 0);
    signcalc(regs.db, 0);
}

static void pld() {
    regs.dp = pull16();
}

static void plp() {
    regs.status = pull8();
    if (regs.e) {
        regs.status |= FLAG_INDEX_WIDTH | FLAG_MEMORY_WIDTH;
    } else if (regs.status & FLAG_INDEX_WIDTH) {
        regs.xh = 0;
        regs.yh = 0;
    }
}

static void rep() {
    value = getvalue(0);
    regs.status &= ~(value & 0xFF);

    if (regs.e) {
        regs.status |= FLAG_INDEX_WIDTH | FLAG_MEMORY_WIDTH;
    }
}

static void rol() {
    value = getvalue(memory_16bit());
    result = (value << 1) | (regs.status & FLAG_CARRY);

    carrycalc(result, memory_16bit());
    zerocalc(result, memory_16bit());
    signcalc(result, memory_16bit());

    putvalue(result, memory_16bit());
}

static void ror() {
    value = getvalue(memory_16bit());
    result = (value >> 1) | ((regs.status & FLAG_CARRY) << (memory_16bit() ? 15 : 7));

    if (value & 1) setcarry();
        else clearcarry();
    zerocalc(result, memory_16bit());
    signcalc(result, memory_16bit());

    putvalue(result, memory_16bit());
}

static void rti() {
    regs.status = pull8();
    value = pull16();
    regs.pc = value;

    if (regs.e) {
        regs.status |= FLAG_INDEX_WIDTH | FLAG_MEMORY_WIDTH;
    } else {
        if (regs.status & FLAG_INDEX_WIDTH) {
            regs.xh = 0;
            regs.yh = 0;
        }
        regs.k = pull8();
    }
}

static void rtl() {
    value = pull16();
    regs.pc = value + 1;
    regs.k = pull8();
}

static void rts() {
    value = pull16();
    regs.pc = value + 1;
}

static void sbc() {
    penaltyop = 1;

    if (regs.status & FLAG_DECIMAL) {
        uint16_t tmp, tmp2;
        uint32_t tmpc;
        if (memory_16bit()) {
            uint16_t tmp3;
            uint32_t tmp4;
            value = getvalue(1);
            tmp = (regs.c & 0x000F) - (value & 0x000F) + (regs.status & FLAG_CARRY) - 1;
            tmp2 = (regs.c & 0x00F0) - (value & 0x00F0);
            tmp3 = (regs.c & 0x0F00) - (value & 0x0F00);
            tmp4 = (regs.c & 0xF000) - (value & 0xF000);

            if (tmp & 0xFFF0) {
                tmp2 -= 0x0010;
                tmp -= 0x0006;
            }

            if (tmp2 & 0xFF00) {
                tmp3 -= 0x0100;
                tmp2 -= 0x0060;
            }

            if (tmp3 & 0xF000) {
                tmp4 -= 0x1000;
                tmp3 -= 0x0600;
            }

            tmpc = tmp4;
            if (tmp4 >= 0x0000A000) {
                tmp4 -= 0x6000;
            }

            result = (tmp & 0x000F) | (tmp2 & 0x00F0) | (tmp3 & 0x0F00) | (tmp4 & 0xF000);
            uint16_t c_result = (tmp & 0x000F) | (tmp2 & 0x00F0) | (tmp3 & 0x0F00) | (tmpc & 0xF000);

            if (c_result <= regs.c) {
                setcarry();
            } else {
                clearcarry();
            }
            uint16_t ovresult = regs.c + (value ^ 0xFFFF) + (regs.status & FLAG_CARRY);
            overflowcalc16(ovresult, regs.c, value ^ 0xFFFF);
        } else {
            value = getvalue(0);
            tmp = ((uint16_t)regs.a & 0x0F) - (value & 0x0F) + (regs.status & FLAG_CARRY) - 1;
            tmp2 = ((uint16_t)regs.a & 0xF0) - (value & 0xF0);

            if (tmp & 0xFFF0) {
                tmp2 -= 0x10;
                tmp -= 0x06;
            }

            tmpc = tmp2;
            if (tmp2 & 0xFF00) {
                tmp2 -= 0x60;
            }

            result = (tmp & 0x0F) | (tmp2 & 0xF0);
            uint16_t c_result = (tmp & 0x0F) | (tmpc & 0xF0);

            if (c_result <= (uint16_t)regs.a) {
                setcarry();
            } else {
                clearcarry();
            }
            uint8_t ovresult = regs.a + (value ^ 0xFF) + (regs.status & FLAG_CARRY);
            overflowcalc8((uint16_t)ovresult, (uint16_t)regs.a, value ^ 0xFF);
        }

        clockticks6502 += (uint32_t)(!regs.is65c816);
    } else {
        if (memory_16bit()) {
            value = getvalue(1) ^ 0xFFFF;
            result = regs.c + value + (regs.status & FLAG_CARRY);
            overflowcalc16(result, regs.c, value);
        } else {
            value = getvalue(0) ^ 0x00FF;
            result = (uint16_t)regs.a + value + (uint16_t)(regs.status & FLAG_CARRY);
            overflowcalc8(result, (uint16_t)regs.a, value);
        }

        carrycalc(result, memory_16bit());
    }

    zerocalc(result, memory_16bit());
    signcalc(result, memory_16bit());

    saveaccum(result);
}

static void sec() {
    setcarry();
}

static void sed() {
    setdecimal();
}

static void sei() {
    setinterrupt();
}

static void sep() {
    regs.status |= getvalue(0) & 0xFF;
    if (regs.e) {
        regs.status |= FLAG_INDEX_WIDTH | FLAG_MEMORY_WIDTH;
    }
    if (regs.status & FLAG_INDEX_WIDTH) {
        regs.xh = 0;
        regs.yh = 0;
    }
}

static void sta() {
    putvalue(acc_for_mode(), memory_16bit());
}

static void stx() {
    putvalue(index_16bit() ? regs.x : regs.xl, index_16bit());
}

static void sty() {
    putvalue(index_16bit() ? regs.y : regs.yl, index_16bit());
}

static void tax() {
    if (index_16bit()) {
        regs.x = regs.c; // 16 bits transferred, no matter the state of m
        zerocalc(regs.x, 1);
        signcalc(regs.x, 1);
    } else {
        regs.xl = (uint8_t)(regs.a & 0x00FF);
        zerocalc(regs.xl, 0);
        signcalc(regs.xl, 0);
    }
}

static void tay() {
    if (index_16bit()) {
        regs.y = regs.c; // 16 bits transferred, no matter the state of m
        zerocalc(regs.y, 1);
        signcalc(regs.y, 1);
    } else {
        regs.yl = (uint8_t)(regs.a & 0x00FF);
        zerocalc(regs.yl, 0);
        signcalc(regs.yl, 0);
    }
}

static void tcd() {
    regs.dp = regs.c;
    zerocalc(regs.dp, 1);
    signcalc(regs.dp, 1);
}

static void tdc() {
    regs.c = regs.dp;
    zerocalc(regs.c, 1);
    signcalc(regs.c, 1);
}

static void tsx() {
    if (index_16bit()) {
        regs.x = regs.sp; // 16 bits transferred, no matter the state of m
        zerocalc(regs.x, 1);
        signcalc(regs.x, 1);
    } else {
        regs.xl = (uint8_t)(regs.sp & 0x00FF);
        regs.xh = 0;
        zerocalc(regs.xl, 0);
        signcalc(regs.xl, 0);
    }
}

static void txa() {
    if (memory_16bit()) {
        if (index_16bit()) {
            regs.c = regs.x;
            zerocalc(regs.c, 1);
            signcalc(regs.c, 1);
        } else {
            regs.a = regs.xl;
            regs.b = 0;
            zerocalc(regs.a, 0);
            signcalc(regs.a, 0);
        }
    } else {
        regs.a = regs.xl;
        zerocalc(regs.a, 0);
        signcalc(regs.a, 0);
    }
}

static void txs() {
    if (regs.e) {
        regs.sp = 0x100 | regs.xl;
    } else {
        regs.sp = regs.x;
    }
}

static void txy() {
    if (index_16bit()) {
        regs.y = regs.x;
        zerocalc(regs.y, 1);
        signcalc(regs.y, 1);
    } else {
        regs.yl = regs.xl;
        zerocalc(regs.yl, 0);
        signcalc(regs.yl, 0);
    }
}

static void tya() {
    if (memory_16bit()) {
        if (index_16bit()) {
            regs.c = regs.y;
            zerocalc(regs.c, 1);
            signcalc(regs.c, 1);
        } else {
            regs.a = regs.yl;
            regs.b = 0;
            zerocalc(regs.a, 0);
            signcalc(regs.a, 0);
        }
    } else {
        regs.a = regs.yl;
        zerocalc(regs.a, 0);
        signcalc(regs.a, 0);
    }
}

static void tyx() {
    if (index_16bit()) {
        regs.x = regs.y;
        zerocalc(regs.x, 1);
        signcalc(regs.x, 1);
    } else {
        regs.xl = regs.yl;
        zerocalc(regs.xl, 0);
        signcalc(regs.xl, 0);
    }
}

static void tcs() {
    regs.sp = regs.c;
}

static void tsc() {
    regs.c = regs.sp;
    zerocalc(regs.c, 1);
    signcalc(regs.c, 1);
}

static void mvn() {
    uint8_t sourceBank = ea >> 8;
    uint8_t destBank = ea;
    regs.db = destBank;

    if (index_16bit()) {
        write6502(regs.y++, destBank, read6502(regs.x++, sourceBank));
    } else {
        write6502(regs.yl++, destBank, read6502(regs.xl++, sourceBank));
    }
    if (--regs.c != 0xFFFF) {
        regs.pc -= 3;
    }
}

static void mvp() {
    uint8_t sourceBank = ea >> 8;
    uint8_t destBank = ea;
    regs.db = ea;

    if (index_16bit()) {
        write6502(regs.y--, destBank, read6502(regs.x--, sourceBank));
    } else {
        write6502(regs.yl--, destBank, read6502(regs.xl--, sourceBank));
    }
    if (--regs.c != 0xFFFF) {
        regs.pc -= 3;
    }
}

static void wdm() {
}

static void xba() {
    uint8_t tmp = regs.b;
    regs.b = regs.a;
    regs.a = tmp;
    zerocalc(regs.a, 0);
    signcalc(regs.a, 0);
}

static void xce() {
    uint8_t carry = regs.status & FLAG_CARRY;
    regs.status = (regs.status & ~FLAG_CARRY) | (regs.e ? FLAG_CARRY : 0);
    regs.e = carry != 0;

    if (regs.e) {
        regs.status |= FLAG_INDEX_WIDTH | FLAG_MEMORY_WIDTH;
        regs.sp = 0x0100 | (regs.sp & 0x00FF);
        regs.xh = 0x00;
        regs.yh = 0x00;
    }
}

`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet

1	/*
2
3	Extracted from original single fake6502.c file
4
5	*/
6	//
7	// 65C02 changes.
8	//
9	// BRK now clears D
10	// ADC/SBC set N and Z in decimal mode. They also set V
11	//
12	//
13	//
14	// instruction handler functions
15	//
16	static void adc() {
17	penaltyop = 1;
18	if (regs.status & FLAG_DECIMAL) {
19	uint16_t tmp, tmp2;
20	uint32_t tmpov;
21	if (memory_16bit()) {
22	uint16_t tmp3;
23	uint32_t tmp4;
24	value = getvalue(1);
25	tmp = (regs.c & 0x000F) + (value & 0x000F) + (uint16_t)(regs.status & FLAG_CARRY);
26	tmp2 = (regs.c & 0x00F0) + (value & 0x00F0);
27	tmp3 = (regs.c & 0x0F00) + (value & 0x0F00);
28	tmp4 = ((uint32_t)regs.c & 0xF000) + (value & 0xF000);
29	if (tmp > 0x0009) {
30	tmp2 += 0x0010;
31	tmp += 0x0006;
32	}
33	if (tmp2 > 0x0090) {
34	tmp3 += 0x0100;
35	tmp2 += 0x0060;
36	}
37	if (tmp3 > 0x0900) {
38	tmp4 += 0x1000;
39	tmp3 += 0x0600;
40	}
41	tmpov = tmp4;
42	if (tmp4 > 0x9000) {
43	tmp4 += 0x6000;
44	}
45	if (tmp4 & 0xFFFF0000) {
46	setcarry();
47	} else {
48	clearcarry();
49	}
50	result = (tmp & 0x000F) \| (tmp2 & 0x00F0) \| (tmp3 & 0x0F00) \| (tmp4 & 0xF000);
51	uint16_t ovresult = (tmp & 0x000F) \| (tmp2 & 0x00F0) \| (tmp3 & 0x0F00) \| (tmpov & 0xF000);
52	overflowcalc16(ovresult, regs.c, value);
53	} else {
54	value = getvalue(0);
55	tmp = ((uint16_t)regs.a & 0x0F) + (value & 0x0F) + (uint16_t)(regs.status & FLAG_CARRY);
56	tmp2 = ((uint16_t)regs.a & 0xF0) + (value & 0xF0);
57	if (tmp > 0x09) {
58	tmp2 += 0x10;
59	tmp += 0x06;
60	}
61	tmpov = tmp2;
62	if (tmp2 > 0x90) {
63	tmp2 += 0x60;
64	}
65	if (tmp2 & 0xFF00) {
66	setcarry();
67	} else {
68	clearcarry();
69	}
70	result = (tmp & 0x0F) \| (tmp2 & 0xF0);
71	uint8_t ovresult = (tmp & 0x0F) \| (tmpov & 0xF0);
72	overflowcalc8((uint16_t)ovresult, (uint16_t)regs.a, value);
73	}
74	clockticks6502 += (uint32_t)(!regs.is65c816);
75	} else {
76	if (memory_16bit()) {
77	value = getvalue(1);
78	result = regs.c + value + (uint16_t) (regs.status & FLAG_CARRY);
79	overflowcalc16(result, regs.c, value);
80	carrycalc(result, 1);
81	} else {
82	value = getvalue(0);
83	result = (uint16_t)regs.a + value + (uint16_t) (regs.status & FLAG_CARRY);
84	overflowcalc8(result, (uint16_t)regs.a, value);
85	carrycalc(result, 0);
86	}
87	}
88
89	zerocalc(result, memory_16bit());
90	signcalc(result, memory_16bit());
91
92	saveaccum(result);
93	}
94
95	static void and() {
96	penaltyop = 1;
97	value = getvalue(memory_16bit());
98	result = acc_for_mode() & value;
99
100	zerocalc(result, memory_16bit());
101	signcalc(result, memory_16bit());
102
103	saveaccum(result);
104	}
105
106	static void asl() {
107	value = getvalue(memory_16bit());
108	result = value << 1;
109
110	carrycalc(result, memory_16bit());
111	zerocalc(result, memory_16bit());
112	signcalc(result, memory_16bit());
113
114	putvalue(result, memory_16bit());
115	}
116
117	static void _do_branch(int condition) {
118	if (condition) {
119	oldpc = regs.pc;
120	regs.pc += reladdr;
121	clockticks6502++;
122	if ((oldpc & 0xFF00) != (regs.pc & 0xFF00)) //check if jump crossed a page boundary
123	penaltye = 1;
124	}
125	}
126
127	static void bcc() {
128	_do_branch((regs.status & FLAG_CARRY) == 0);
129	}
130
131	static void bcs() {
132	_do_branch((regs.status & FLAG_CARRY) == FLAG_CARRY);
133	}
134
135	static void beq() {
136	_do_branch((regs.status & FLAG_ZERO) == FLAG_ZERO);
137	}
138
139	static void bit() {
140	value = getvalue(memory_16bit());
141	result = acc_for_mode() & value;
142
143	zerocalc(result, memory_16bit());
144	// Xark - BUGFIX: 65C02 BIT #$xx only affects Z See: http://6502.org/tutorials/65c02opcodes.html#2
145	if (opcode != 0x89)
146	{
147	regs.status = (regs.status & 0x3F) \| (uint8_t)(value & 0xC0);
148	}
149	}
150
151	static void bmi() {
152	_do_branch((regs.status & FLAG_SIGN) == FLAG_SIGN);
153	}
154
155	static void bne() {
156	_do_branch((regs.status & FLAG_ZERO) == 0);
157	}
158
159	static void bpl() {
160	_do_branch((regs.status & FLAG_SIGN) == 0);
161	}
162
163	static void brk() {
164	penaltyn = 1;
165	regs.pc++;
166
167	interrupt6502(INT_BRK);
168	}
169
170	static void brl() {
171	regs.pc += reladdr;
172	}
173
174	static void bvc() {
175	_do_branch((regs.status & FLAG_OVERFLOW) == 0);
176	}
177
178	static void bvs() {
179	_do_branch((regs.status & FLAG_OVERFLOW) == FLAG_OVERFLOW);
180	}
181
182	static void clc() {
183	clearcarry();
184	}
185
186	static void cld() {
187	cleardecimal();
188	}
189
190	static void cli() {
191	clearinterrupt();
192	}
193
194	static void clv() {
195	clearoverflow();
196	}
197
198	static void cmp() {
199	penaltyop = 1;
200	value = getvalue(memory_16bit());
201
202	if (memory_16bit()) {
203	result = regs.c - value;
204	if (regs.c >= value) setcarry();
205	else clearcarry();
206	if (regs.c == value) setzero();
207	else clearzero();
208	} else {
209	result = (uint16_t)regs.a - value;
210	if (regs.a >= (uint8_t)(value & 0x00FF)) setcarry();
211	else clearcarry();
212	if (regs.a == (uint8_t)(value & 0x00FF)) setzero();
213	else clearzero();
214	}
215
216	signcalc(result, memory_16bit());
217	}
218
219	static void cop() {
220	penaltyn = 1;
221	regs.pc++;
222
223	interrupt6502(INT_COP);
224	}
225
226	static void cpx() {
227	value = getvalue(index_16bit());
228
229	if (index_16bit()) {
230	result = regs.x - value;
231	if(regs.x >= value) setcarry();
232	else clearcarry();
233	if (regs.x == value) setzero();
234	else clearzero();
235	} else {
236	result = (uint16_t)regs.xl - value;
237	if (regs.xl >= (uint8_t)(value & 0x00FF)) setcarry();
238	else clearcarry();
239	if (regs.xl == (uint8_t)(value & 0x00FF)) setzero();
240	else clearzero();
241	}
242	signcalc(result, index_16bit());
243	}
244
245	static void cpy() {
246	value = getvalue(index_16bit());
247
248	if (index_16bit()) {
249	result = regs.y - value;
250	if(regs.y >= value) setcarry();
251	else clearcarry();
252	if (regs.y == value) setzero();
253	else clearzero();
254	} else {
255	result = (uint16_t)regs.yl - value;
256	if (regs.yl >= (uint8_t)(value & 0x00FF)) setcarry();
257	else clearcarry();
258	if (regs.yl == (uint8_t)(value & 0x00FF)) setzero();
259	else clearzero();
260	}
261	signcalc(result, index_16bit());
262	}
263
264	static void dec() {
265	value = getvalue(memory_16bit());
266	result = value - 1;
267
268	zerocalc(result, memory_16bit());
269	signcalc(result, memory_16bit());
270
271	putvalue(result, memory_16bit());
272	}
273
274	static void dex() {
275	if (index_16bit()) {
276	regs.x--;
277	zerocalc(regs.x, 1);
278	signcalc(regs.x, 1);
279	} else {
280	regs.xl--;
281	zerocalc(regs.xl, 0);
282	signcalc(regs.xl, 0);
283	}
284	}
285
286	static void dey() {
287	if (index_16bit()) {
288	regs.y--;
289	zerocalc(regs.y, 1);
290	signcalc(regs.y, 1);
291	} else {
292	regs.yl--;
293	zerocalc(regs.yl, 0);
294	signcalc(regs.yl, 0);
295	}
296	}
297
298	static void eor() {
299	penaltyop = 1;
300	value = getvalue(memory_16bit());
301	result = acc_for_mode() ^ value;
302
303	zerocalc(result, memory_16bit());
304	signcalc(result, memory_16bit());
305
306	saveaccum(result);
307	}
308
309	static void inc() {
310	value = getvalue(memory_16bit());
311	result = value + 1;
312
313	zerocalc(result, memory_16bit());
314	signcalc(result, memory_16bit());
315
316	putvalue(result, memory_16bit());
317	}
318
319	static void inx() {
320	if (index_16bit()) {
321	regs.x++;
322	zerocalc(regs.x, 1);
323	signcalc(regs.x, 1);
324	} else {
325	regs.xl++;
326	zerocalc(regs.xl, 0);
327	signcalc(regs.xl, 0);
328	}
329	}
330
331	static void iny() {
332	if (index_16bit()) {
333	regs.y++;
334	zerocalc(regs.y, 1);
335	signcalc(regs.y, 1);
336	} else {
337	regs.yl++;
338	zerocalc(regs.yl, 0);
339	signcalc(regs.yl, 0);
340	}
341	}
342
343	static void jml() {
344	regs.pc = ea & 0xFFFF;
345	regs.k = ea >> 16;
346	}
347
348	static void jmp() {
349	regs.pc = ea;
350	}
351
352	static void jsr() {
353	push16(regs.pc - 1);
354	regs.pc = ea;
355	}
356
357	static void jsl() {
358	push8(regs.k);
359	push16(regs.pc - 1);
360	regs.pc = ea & 0xFFFF;
361	regs.k = ea >> 16;
362	}
363
364	static void lda() {
365	penaltyop = 1;
366	penaltym = 1;
367
368	if (memory_16bit()) {
369	regs.c = getvalue(1);
370	zerocalc(regs.c, 1);
371	signcalc(regs.c, 1);
372	} else {
373	value = getvalue(0);
374	regs.a = (uint8_t)(value & 0x00FF);
375	zerocalc(regs.a, 0);
376	signcalc(regs.a, 0);
377	}
378	}
379
380	static void ldx() {
381	penaltyop = 1;
382	penaltyx = 1;
383
384	if (index_16bit()) {
385	regs.x = getvalue(1);
386	zerocalc(regs.x, 1);
387	signcalc(regs.x, 1);
388	} else {
389	value = getvalue(0);
390	regs.xl = (uint8_t)(value & 0x00FF);
391	zerocalc(regs.xl, 0);
392	signcalc(regs.xl, 0);
393	}
394	}
395
396	static void ldy() {
397	penaltyop = 1;
398	penaltyx = 1;
399
400	if (index_16bit()) {
401	regs.y = getvalue(1);
402	zerocalc(regs.y, 1);
403	signcalc(regs.y, 1);
404	} else {
405	regs.yl = (uint8_t)(getvalue(0) & 0x00FF);
406	zerocalc(regs.yl, 0);
407	signcalc(regs.yl, 0);
408	}
409	}
410
411	static void lsr() {
412	value = getvalue(memory_16bit());
413	result = value >> 1;
414
415	if (value & 1) setcarry();
416	else clearcarry();
417	zerocalc(result, memory_16bit());
418	signcalc(result, memory_16bit());
419
420	putvalue(result, memory_16bit());
421	}
422
423	static void nop() {
424	switch (opcode) {
425	case 0x1C:
426	case 0x3C:
427	case 0x5C:
428	case 0x7C:
429	case 0xDC:
430	case 0xFC:
431	penaltyop = 1;
432	break;
433	}
434	}
435
436	static void ora() {
437	penaltyop = 1;
438	value = getvalue(memory_16bit());
439	result = acc_for_mode() \| value;
440
441	zerocalc(result, memory_16bit());
442	signcalc(result, memory_16bit());
443
444	saveaccum(result);
445	}
446
447	static void pea() {
448	push16(getvalue(1));
449	}
450
451	static void pei() {
452	push16(ea);
453	}
454
455	static void per() {
456	push16(regs.pc + reladdr);
457	}
458
459	static void pha() {
460	if (memory_16bit()) {
461	push16(regs.c);
462	} else {
463	push8(regs.a);
464	}
465	}
466
467	static void phb() {
468	push8(regs.db);
469	}
470
471	static void phd() {
472	push16(regs.dp);
473	}
474
475	static void phk() {
476	push8(regs.k);
477	}
478
479	static void php() {
480	push8(regs.e ? regs.status \| FLAG_BREAK : regs.status);
481	}
482
483	static void pla() {
484	if (memory_16bit()) {
485	regs.c = pull16();
486	zerocalc(regs.c, 1);
487	signcalc(regs.c, 1);
488	} else {
489	regs.a = pull8();
490	zerocalc(regs.a, 0);
491	signcalc(regs.a, 0);
492	}
493	}
494
495	static void plb() {
496	regs.db = pull8();
497	zerocalc(regs.db, 0);
498	signcalc(regs.db, 0);
499	}
500
501	static void pld() {
502	regs.dp = pull16();
503	}
504
505	static void plp() {
506	regs.status = pull8();
507	if (regs.e) {
508	regs.status \|= FLAG_INDEX_WIDTH \| FLAG_MEMORY_WIDTH;
509	} else if (regs.status & FLAG_INDEX_WIDTH) {
510	regs.xh = 0;
511	regs.yh = 0;
512	}
513	}
514
515	static void rep() {
516	value = getvalue(0);
517	regs.status &= ~(value & 0xFF);
518
519	if (regs.e) {
520	regs.status \|= FLAG_INDEX_WIDTH \| FLAG_MEMORY_WIDTH;
521	}
522	}
523
524	static void rol() {
525	value = getvalue(memory_16bit());
526	result = (value << 1) \| (regs.status & FLAG_CARRY);
527
528	carrycalc(result, memory_16bit());
529	zerocalc(result, memory_16bit());
530	signcalc(result, memory_16bit());
531
532	putvalue(result, memory_16bit());
533	}
534
535	static void ror() {
536	value = getvalue(memory_16bit());
537	result = (value >> 1) \| ((regs.status & FLAG_CARRY) << (memory_16bit() ? 15 : 7));
538
539	if (value & 1) setcarry();
540	else clearcarry();
541	zerocalc(result, memory_16bit());
542	signcalc(result, memory_16bit());
543
544	putvalue(result, memory_16bit());
545	}
546
547	static void rti() {
548	regs.status = pull8();
549	value = pull16();
550	regs.pc = value;
551
552	if (regs.e) {
553	regs.status \|= FLAG_INDEX_WIDTH \| FLAG_MEMORY_WIDTH;
554	} else {
555	if (regs.status & FLAG_INDEX_WIDTH) {
556	regs.xh = 0;
557	regs.yh = 0;
558	}
559	regs.k = pull8();
560	}
561	}
562
563	static void rtl() {
564	value = pull16();
565	regs.pc = value + 1;
566	regs.k = pull8();
567	}
568
569	static void rts() {
570	value = pull16();
571	regs.pc = value + 1;
572	}
573
574	static void sbc() {
575	penaltyop = 1;
576
577	if (regs.status & FLAG_DECIMAL) {
578	uint16_t tmp, tmp2;
579	uint32_t tmpc;
580	if (memory_16bit()) {
581	uint16_t tmp3;
582	uint32_t tmp4;
583	value = getvalue(1);
584	tmp = (regs.c & 0x000F) - (value & 0x000F) + (regs.status & FLAG_CARRY) - 1;
585	tmp2 = (regs.c & 0x00F0) - (value & 0x00F0);
586	tmp3 = (regs.c & 0x0F00) - (value & 0x0F00);
587	tmp4 = (regs.c & 0xF000) - (value & 0xF000);
588
589	if (tmp & 0xFFF0) {
590	tmp2 -= 0x0010;
591	tmp -= 0x0006;
592	}
593
594	if (tmp2 & 0xFF00) {
595	tmp3 -= 0x0100;
596	tmp2 -= 0x0060;
597	}
598
599	if (tmp3 & 0xF000) {
600	tmp4 -= 0x1000;
601	tmp3 -= 0x0600;
602	}
603
604	tmpc = tmp4;
605	if (tmp4 >= 0x0000A000) {
606	tmp4 -= 0x6000;
607	}
608
609	result = (tmp & 0x000F) \| (tmp2 & 0x00F0) \| (tmp3 & 0x0F00) \| (tmp4 & 0xF000);
610	uint16_t c_result = (tmp & 0x000F) \| (tmp2 & 0x00F0) \| (tmp3 & 0x0F00) \| (tmpc & 0xF000);
611
612	if (c_result <= regs.c) {
613	setcarry();
614	} else {
615	clearcarry();
616	}
617	uint16_t ovresult = regs.c + (value ^ 0xFFFF) + (regs.status & FLAG_CARRY);
618	overflowcalc16(ovresult, regs.c, value ^ 0xFFFF);
619	} else {
620	value = getvalue(0);
621	tmp = ((uint16_t)regs.a & 0x0F) - (value & 0x0F) + (regs.status & FLAG_CARRY) - 1;
622	tmp2 = ((uint16_t)regs.a & 0xF0) - (value & 0xF0);
623
624	if (tmp & 0xFFF0) {
625	tmp2 -= 0x10;
626	tmp -= 0x06;
627	}
628
629	tmpc = tmp2;
630	if (tmp2 & 0xFF00) {
631	tmp2 -= 0x60;
632	}
633
634	result = (tmp & 0x0F) \| (tmp2 & 0xF0);
635	uint16_t c_result = (tmp & 0x0F) \| (tmpc & 0xF0);
636
637	if (c_result <= (uint16_t)regs.a) {
638	setcarry();
639	} else {
640	clearcarry();
641	}
642	uint8_t ovresult = regs.a + (value ^ 0xFF) + (regs.status & FLAG_CARRY);
643	overflowcalc8((uint16_t)ovresult, (uint16_t)regs.a, value ^ 0xFF);
644	}
645
646	clockticks6502 += (uint32_t)(!regs.is65c816);
647	} else {
648	if (memory_16bit()) {
649	value = getvalue(1) ^ 0xFFFF;
650	result = regs.c + value + (regs.status & FLAG_CARRY);
651	overflowcalc16(result, regs.c, value);
652	} else {
653	value = getvalue(0) ^ 0x00FF;
654	result = (uint16_t)regs.a + value + (uint16_t)(regs.status & FLAG_CARRY);
655	overflowcalc8(result, (uint16_t)regs.a, value);
656	}
657
658	carrycalc(result, memory_16bit());
659	}
660
661	zerocalc(result, memory_16bit());
662	signcalc(result, memory_16bit());
663
664	saveaccum(result);
665	}
666
667	static void sec() {
668	setcarry();
669	}
670
671	static void sed() {
672	setdecimal();
673	}
674
675	static void sei() {
676	setinterrupt();
677	}
678
679	static void sep() {
680	regs.status \|= getvalue(0) & 0xFF;
681	if (regs.e) {
682	regs.status \|= FLAG_INDEX_WIDTH \| FLAG_MEMORY_WIDTH;
683	}
684	if (regs.status & FLAG_INDEX_WIDTH) {
685	regs.xh = 0;
686	regs.yh = 0;
687	}
688	}
689
690	static void sta() {
691	putvalue(acc_for_mode(), memory_16bit());
692	}
693
694	static void stx() {
695	putvalue(index_16bit() ? regs.x : regs.xl, index_16bit());
696	}
697
698	static void sty() {
699	putvalue(index_16bit() ? regs.y : regs.yl, index_16bit());
700	}
701
702	static void tax() {
703	if (index_16bit()) {
704	regs.x = regs.c; // 16 bits transferred, no matter the state of m
705	zerocalc(regs.x, 1);
706	signcalc(regs.x, 1);
707	} else {
708	regs.xl = (uint8_t)(regs.a & 0x00FF);
709	zerocalc(regs.xl, 0);
710	signcalc(regs.xl, 0);
711	}
712	}
713
714	static void tay() {
715	if (index_16bit()) {
716	regs.y = regs.c; // 16 bits transferred, no matter the state of m
717	zerocalc(regs.y, 1);
718	signcalc(regs.y, 1);
719	} else {
720	regs.yl = (uint8_t)(regs.a & 0x00FF);
721	zerocalc(regs.yl, 0);
722	signcalc(regs.yl, 0);
723	}
724	}
725
726	static void tcd() {
727	regs.dp = regs.c;
728	zerocalc(regs.dp, 1);
729	signcalc(regs.dp, 1);
730	}
731
732	static void tdc() {
733	regs.c = regs.dp;
734	zerocalc(regs.c, 1);
735	signcalc(regs.c, 1);
736	}
737
738	static void tsx() {
739	if (index_16bit()) {
740	regs.x = regs.sp; // 16 bits transferred, no matter the state of m
741	zerocalc(regs.x, 1);
742	signcalc(regs.x, 1);
743	} else {
744	regs.xl = (uint8_t)(regs.sp & 0x00FF);
745	regs.xh = 0;
746	zerocalc(regs.xl, 0);
747	signcalc(regs.xl, 0);
748	}
749	}
750
751	static void txa() {
752	if (memory_16bit()) {
753	if (index_16bit()) {
754	regs.c = regs.x;
755	zerocalc(regs.c, 1);
756	signcalc(regs.c, 1);
757	} else {
758	regs.a = regs.xl;
759	regs.b = 0;
760	zerocalc(regs.a, 0);
761	signcalc(regs.a, 0);
762	}
763	} else {
764	regs.a = regs.xl;
765	zerocalc(regs.a, 0);
766	signcalc(regs.a, 0);
767	}
768	}
769
770	static void txs() {
771	if (regs.e) {
772	regs.sp = 0x100 \| regs.xl;
773	} else {
774	regs.sp = regs.x;
775	}
776	}
777
778	static void txy() {
779	if (index_16bit()) {
780	regs.y = regs.x;
781	zerocalc(regs.y, 1);
782	signcalc(regs.y, 1);
783	} else {
784	regs.yl = regs.xl;
785	zerocalc(regs.yl, 0);
786	signcalc(regs.yl, 0);
787	}
788	}
789
790	static void tya() {
791	if (memory_16bit()) {
792	if (index_16bit()) {
793	regs.c = regs.y;
794	zerocalc(regs.c, 1);
795	signcalc(regs.c, 1);
796	} else {
797	regs.a = regs.yl;
798	regs.b = 0;
799	zerocalc(regs.a, 0);
800	signcalc(regs.a, 0);
801	}
802	} else {
803	regs.a = regs.yl;
804	zerocalc(regs.a, 0);
805	signcalc(regs.a, 0);
806	}
807	}
808
809	static void tyx() {
810	if (index_16bit()) {
811	regs.x = regs.y;
812	zerocalc(regs.x, 1);
813	signcalc(regs.x, 1);
814	} else {
815	regs.xl = regs.yl;
816	zerocalc(regs.xl, 0);
817	signcalc(regs.xl, 0);
818	}
819	}
820
821	static void tcs() {
822	regs.sp = regs.c;
823	}
824
825	static void tsc() {
826	regs.c = regs.sp;
827	zerocalc(regs.c, 1);
828	signcalc(regs.c, 1);
829	}
830
831	static void mvn() {
832	uint8_t sourceBank = ea >> 8;
833	uint8_t destBank = ea;
834	regs.db = destBank;
835
836	if (index_16bit()) {
837	write6502(regs.y++, destBank, read6502(regs.x++, sourceBank));
838	} else {
839	write6502(regs.yl++, destBank, read6502(regs.xl++, sourceBank));
840	}
841	if (--regs.c != 0xFFFF) {
842	regs.pc -= 3;
843	}
844	}
845
846	static void mvp() {
847	uint8_t sourceBank = ea >> 8;
848	uint8_t destBank = ea;
849	regs.db = ea;
850
851	if (index_16bit()) {
852	write6502(regs.y--, destBank, read6502(regs.x--, sourceBank));
853	} else {
854	write6502(regs.yl--, destBank, read6502(regs.xl--, sourceBank));
855	}
856	if (--regs.c != 0xFFFF) {
857	regs.pc -= 3;
858	}
859	}
860
861	static void wdm() {
862	}
863
864	static void xba() {
865	uint8_t tmp = regs.b;
866	regs.b = regs.a;
867	regs.a = tmp;
868	zerocalc(regs.a, 0);
869	signcalc(regs.a, 0);
870	}
871
872	static void xce() {
873	uint8_t carry = regs.status & FLAG_CARRY;
874	regs.status = (regs.status & ~FLAG_CARRY) \| (regs.e ? FLAG_CARRY : 0);
875	regs.e = carry != 0;
876
877	if (regs.e) {
878	regs.status \|= FLAG_INDEX_WIDTH \| FLAG_MEMORY_WIDTH;
879	regs.sp = 0x0100 \| (regs.sp & 0x00FF);
880	regs.xh = 0x00;
881	regs.yh = 0x00;
882	}
883	}

Keyboard