/*

						Extracted from original single fake6502.c file

*/

//
//          65C02 changes.
//
//          ind         absolute indirect
//
//                      A 6502 has a bug whereby if you jmp ($12FF) it reads the address from
//                      $12FF and $1200. This has been fixed in the 65C02.
//
static void imp() { //implied
}

static void imp8() { // brk / cop
}

static void acc() { //accumulator
    addressing_is_acc = true;
}

static void imm8() { //immediate, 8bit
    ea = addr_with_k(regs.pc++);
}

static void immm() { //immediate, 16bit if M = 0
    ea = addr_with_k(regs.pc++);

    if (memory_16bit()) {
        regs.pc++;
    }
}

static void immx() { //immediate, 16bit if X = 0
    ea = addr_with_k(regs.pc++);

    if (index_16bit()) {
        regs.pc++;
    }
}

static void imm16() {
    ea = addr_with_k(regs.pc);
    regs.pc += 2;
}

static void _zp_with_offset(uint16_t offset) {
    uint16_t imm_value = (uint16_t) read6502((uint16_t)regs.pc++, regs.k);

    if (regs.dp & 0x00FF) {
        penaltyd = 1;
    }

    ea = direct_page_add(imm_value + offset);
}

static void _zp_long_with_offset(uint16_t offset) {
    uint16_t eahelp;
    eahelp = (uint16_t)read6502(regs.pc++, regs.k);

    ea = (uint32_t)read6502(direct_page_add(eahelp), 0) | ((uint32_t)read6502(direct_page_add(eahelp + 1), 0) << 8) | ((uint32_t)read6502(direct_page_add(eahelp + 2), 0) << 16);
    ea = mask_long_addr(ea + offset);

    if (regs.dp & 0x00FF) {
        penaltyd = 1;
    }
}

static void zp() { //zero-page
    _zp_with_offset(0);
}

static void zpx() { //zero-page,X
    _zp_with_offset(regs.x);
}

static void zpy() { //zero-page,Y
    _zp_with_offset(regs.y);
}

static void rel() { //relative for branch ops (8-bit immediate value, sign-extended)
    reladdr = (uint16_t)read6502(regs.pc++, regs.k);
    if (reladdr & 0x80) reladdr |= 0xFF00;
}

static void rel16() { //relative for PER and BRL (16-bit immediate value)
    reladdr = (uint16_t)read6502(regs.pc, regs.k) | ((uint16_t)read6502(regs.pc+1, regs.k) << 8);
    regs.pc += 2;
}

static void abso() { //absolute
    ea = addr_with_db((uint16_t) read6502(regs.pc, regs.k) | ((uint16_t)read6502(regs.pc+1, regs.k) << 8));
    regs.pc += 2;
}

static void absl() { // absolute long
    ea = (uint32_t) read6502(regs.pc, regs.k) | ((uint32_t)read6502(regs.pc+1, regs.k) << 8) | ((uint32_t)read6502(regs.pc+2, regs.k) << 16);
    regs.pc += 3;
}

static void absx() { //absolute,X
    uint32_t startpage;
    ea = addr_with_db((uint16_t)read6502(regs.pc, regs.k) | ((uint16_t)read6502(regs.pc+1, regs.k) << 8));
    startpage = ea & 0xFFFF00;
    ea = mask_long_addr(ea + regs.x);

    // Compared across the whole 24-bit address: indexing that carries into
    // the next bank costs the same cycle as crossing a page inside one. With
    // 16-bit index registers the cycle is charged whether or not it crosses,
    // which is the datasheet's "add 1 cycle for indexing across page
    // boundaries, or write, or X=0".
    if (index_16bit() || startpage != (ea & 0xFFFF00)) {
        penaltyaddr = 1;
    }

    regs.pc += 2;
}

static void abslx() { // absolute long, X
    ea = (uint32_t)read6502(regs.pc, regs.k) | ((uint32_t)read6502(regs.pc+1, regs.k) << 8) | ((uint32_t)read6502(regs.pc+2, regs.k) << 16);
    ea = mask_long_addr(ea + regs.x);

    // No page-crossing penalty: a long address already names the bank, so
    // indexing across a page costs nothing. Measured flat at five cycles.

    regs.pc += 3;
}

static void absy() { //absolute,Y
    uint32_t startpage;
    ea = addr_with_db((uint16_t)read6502(regs.pc, regs.k) | ((uint16_t)read6502(regs.pc+1, regs.k) << 8));
    startpage = ea & 0xFFFF00;
    ea = mask_long_addr(ea + regs.y);

    // Compared across the whole 24-bit address: indexing that carries into
    // the next bank costs the same cycle as crossing a page inside one. With
    // 16-bit index registers the cycle is charged whether or not it crosses,
    // which is the datasheet's "add 1 cycle for indexing across page
    // boundaries, or write, or X=0".
    if (index_16bit() || startpage != (ea & 0xFFFF00)) {
        penaltyaddr = 1;
    }

    regs.pc += 2;
}

static void ind() { //indirect - used for jmp, which assumes the pointer is in bank 0!
    uint16_t eahelp, eahelp2;
    eahelp = (uint16_t)read6502(regs.pc, regs.k) | (uint16_t)((uint16_t)read6502(regs.pc+1, regs.k) << 8);
    //
    //      The 6502 page boundary wraparound bug does not occur on a 65C02.
    //
    //eahelp2 = (eahelp & 0xFF00) | ((eahelp + 1) & 0x00FF); //replicate 6502 page-boundary wraparound bug
    eahelp2 = (eahelp+1) & 0xFFFF;
    ea = (uint16_t)read6502(eahelp, 0) | ((uint16_t)read6502(eahelp2, 0) << 8);
    regs.pc += 2;
}

static void aindl() { // [addr]    uint16_t eahelp, eahelp2;
    uint16_t eahelp, eahelp2;
    eahelp = (uint16_t)read6502(regs.pc, regs.k) | (uint16_t)((uint16_t)read6502(regs.pc+1, regs.k) << 8);
    eahelp2 = (eahelp+1) & 0xFFFF;
    ea = (uint32_t)read6502(eahelp, 0) | ((uint32_t)read6502(eahelp2, 0) << 8) | ((uint16_t)read6502((eahelp2 + 1) & 0xFFFF, 0) << 16);
    regs.pc += 2;
}

static void ind0() { // (zp)
    uint16_t eahelp;
    eahelp = (uint16_t)read6502(regs.pc++, regs.k);
    // The pointer lives in the direct page, which is always bank zero. The
    // address it holds is in the data bank.
    ea = addr_with_db((uint16_t)read6502(direct_page_add(eahelp), 0) | ((uint16_t)read6502(direct_page_add(eahelp + 1), 0) << 8));

    if (regs.dp & 0x00FF) {
        penaltyd = 1;
    }
}

static void indl0() { // [dp]
    _zp_long_with_offset(0);
}

static void indx() { // (indirect,X)
    uint16_t eahelp;
    eahelp = (uint16_t)read6502(regs.pc++, regs.k) + regs.x;
    ea = addr_with_db((uint16_t)read6502(direct_page_add(eahelp), 0) | ((uint16_t)read6502(direct_page_add(eahelp + 1), 0) << 8));

    if (regs.dp & 0x00FF) {
        penaltyd = 1;
    }
}

static void indy() { // (indirect),Y
    uint16_t eahelp;
    eahelp = (uint16_t)read6502(regs.pc++, regs.k);
    uint16_t pointer = (uint16_t)read6502(direct_page_add(eahelp), 0) | ((uint16_t)read6502(direct_page_add(eahelp + 1), 0) << 8);
    // Indexing applies to the whole 24-bit address, so carrying past $FFFF
    // moves into the next bank rather than wrapping inside this one, and the
    // crossing costs the same cycle as one inside a bank.
    uint32_t startpage = addr_with_db(pointer) & 0xFFFF00;
    ea = mask_long_addr(addr_with_db(pointer) + regs.y);

    if (regs.dp & 0x00FF) {
        penaltyd = 1;
    }

    if (index_16bit() || startpage != (ea & 0xFFFF00)) {
        penaltyaddr = 1;
    }
}

static void indly() { // [dp],Y
    _zp_long_with_offset(regs.y);
}

static void ind0p() { // (zp) used by PEI, which doesn't do wraparound calculations
    uint16_t eahelp;
    eahelp = (uint16_t)read6502(regs.pc++, regs.k);
    ea = (uint16_t)read6502(regs.dp + eahelp, 0) | ((uint16_t)read6502(regs.dp + eahelp + 1, 0) << 8);

    if (regs.dp & 0x00FF) {
        penaltyd = 1;
    }
}

static void zprel() { // zero-page, relative for branch ops (8-bit immediatel value, sign-extended) - only used for the 65C02's Rockwell extensions
	ea = (uint16_t)read6502(regs.pc, 0);
	reladdr = (uint16_t)read6502(regs.pc+1, 0);
	if (reladdr & 0x80) reladdr |= 0xFF00;

	regs.pc += 2;
}

static void sr() { // absolute,S
    // Masked to 16 bits: S can put the stack anywhere inside bank zero, but not
    // outside it, so an offset running past $FFFF wraps rather than reaching
    // bank one.
    ea = (uint16_t)(regs.sp + (uint16_t)read6502(regs.pc++, regs.k));
}

static void sridy() { // (indirect,S),Y
    uint16_t eahelp;
    eahelp = regs.sp + (uint16_t)read6502(regs.pc++, regs.k);
    uint16_t pointer = (uint16_t)read6502(eahelp, 0) | ((uint16_t)read6502(eahelp + 1, 0) << 8);
    ea = mask_long_addr(addr_with_db(pointer) + (uint16_t)regs.y);

    // No page-crossing penalty: measured flat at seven cycles.
}

static void bmv() { // block move
    uint8_t dest = read6502(regs.pc++, regs.k);
    ea = (read6502(regs.pc++, regs.k) << 8) | dest;
}