Emulation/bsnes-plus
1
0
Fork 0
mirror of https://github.com/devinacker/bsnes-plus.git synced 2025-04-02 10:52:46 -04:00
Code Issues Projects Releases Packages Wiki Activity
bsnes-plus/common/nall/snes/smp.hpp
devinacker 6c483ba040 smp: fix typo in opcode 0xFE mnemonic
2019-12-04 20:42:56 -05:00

588 lines
19 KiB
C++
Raw Permalink Blame History

#ifndef NALL_SNES_SMP_HPP
#define NALL_SNES_SMP_HPP
namespace nall {
struct SNESSMP {
enum : unsigned {
Implied, //
TVector, //0
Direct, //$00
DirectRelative, //$00,+/-$00
ADirect, //a,$00
AAbsolute, //a,$0000
AIX, //a,(x)
AIDirectIndX, //a,($00+x)
AConstant, //a,#$00
DirectDirect, //$00,$00
CAbsoluteBit, //c,$0000:0
Absolute, //$0000
P, //p
AbsoluteA, //$0000,a
Relative, //+/-$00
ADirectIndX, //a,$00+x
AAbsoluteX, //a,$0000+x
AAbsoluteY, //a,$0000+y
AIDirectIndY, //a,($00)+y
DirectConstant, //$00,#$00
IXIY, //(x),(y)
DirectIndX, //$00+x
A, //a
X, //x
XAbsolute, //x,$0000
IAbsoluteX, //($0000+x)
CNAbsoluteBit, //c,!$0000:0
XDirect, //x,$00
PVector, //$ff00
YaDirect, //ya,$00
XA, //x,a
YAbsolute, //y,$0000
Y, //y
AX, //a,x
YDirect, //y,$00
YConstant, //y,#$00
XSp, //x,sp
YaX, //ya,x
IXPA, //(x)+,a
SpX, //sp,x
AIXP, //a,(x)+
DirectA, //$00,a
IXA, //(x),a
IDirectIndXA, //($00+x),a
XConstant, //x,#$00
AbsoluteX, //$0000,x
AbsoluteBitC, //$0000:0,c
DirectY, //$00,y
AbsoluteY, //$0000,y
Ya, //ya
DirectIndXA, //$00+x,a
AbsoluteXA, //$0000+x,a
AbsoluteYA, //$0000+y,a
IDirectIndYA, //($00)+y,a
DirectX, //$00,x
DirectIndYX, //$00+y,x
DirectYa, //$00,ya
DirectIndXY, //$00+x,y
AY, //a,y
DirectIndXRelative,//$00+x,+/-$00
XDirectIndY, //x,$00+y
YDirectIndX, //y,$00+x
YA, //y,a
YRelative, //y,+/-$00
};
struct OpcodeInfo {
char name[6];
unsigned mode;
};
static unsigned getOpcodeLength(uint8_t opcode);
static bool getOpcodeIndirect(uint8_t opcode);
static string disassemble(uint16_t pc, uint8_t opcode, uint8_t pl, uint8_t ph, bool p = false);
};
static const SNESSMP::OpcodeInfo smpOpcodeInfo[256] = {
//0x00 - 0x0f
{ "nop ", SNESSMP::Implied },
{ "tcall", SNESSMP::TVector },
{ "set0 ", SNESSMP::Direct },
{ "bbs0 ", SNESSMP::DirectRelative },
{ "or ", SNESSMP::ADirect },
{ "or ", SNESSMP::AAbsolute },
{ "or ", SNESSMP::AIX },
{ "or ", SNESSMP::AIDirectIndX },
{ "or ", SNESSMP::AConstant },
{ "or ", SNESSMP::DirectDirect },
{ "or1 ", SNESSMP::CAbsoluteBit },
{ "asl ", SNESSMP::Direct },
{ "asl ", SNESSMP::Absolute },
{ "push ", SNESSMP::P },
{ "tset ", SNESSMP::AbsoluteA },
{ "brk ", SNESSMP::Implied },
//0x10 - 0x1f
{ "bpl ", SNESSMP::Relative },
{ "tcall", SNESSMP::TVector },
{ "clr0 ", SNESSMP::Direct },
{ "bbc0 ", SNESSMP::DirectRelative },
{ "or ", SNESSMP::ADirectIndX },
{ "or ", SNESSMP::AAbsoluteX },
{ "or ", SNESSMP::AAbsoluteY },
{ "or ", SNESSMP::AIDirectIndY },
{ "or ", SNESSMP::DirectConstant },
{ "or ", SNESSMP::IXIY },
{ "decw ", SNESSMP::Direct },
{ "asl ", SNESSMP::DirectIndX },
{ "asl ", SNESSMP::A },
{ "dec ", SNESSMP::X },
{ "cmp ", SNESSMP::XAbsolute },
{ "jmp ", SNESSMP::IAbsoluteX },
//0x20 - 0x2f
{ "clrp ", SNESSMP::Implied },
{ "tcall", SNESSMP::TVector },
{ "set1 ", SNESSMP::Direct },
{ "bbs1 ", SNESSMP::DirectRelative },
{ "and ", SNESSMP::ADirect },
{ "and ", SNESSMP::AAbsolute },
{ "and ", SNESSMP::AIX },
{ "and ", SNESSMP::AIDirectIndX },
{ "and ", SNESSMP::AConstant },
{ "and ", SNESSMP::DirectDirect },
{ "or1 ", SNESSMP::CNAbsoluteBit },
{ "rol ", SNESSMP::Direct },
{ "rol ", SNESSMP::Absolute },
{ "push ", SNESSMP::A },
{ "cbne ", SNESSMP::DirectRelative },
{ "bra ", SNESSMP::Relative },
//0x30 - 0x3f
{ "bmi ", SNESSMP::Relative },
{ "tcall", SNESSMP::TVector },
{ "clr1 ", SNESSMP::Direct },
{ "bbc1 ", SNESSMP::DirectRelative },
{ "and ", SNESSMP::ADirectIndX },
{ "and ", SNESSMP::AAbsoluteX },
{ "and ", SNESSMP::AAbsoluteY },
{ "and ", SNESSMP::AIDirectIndY },
{ "and ", SNESSMP::DirectConstant },
{ "and ", SNESSMP::IXIY },
{ "incw ", SNESSMP::Direct },
{ "rol ", SNESSMP::DirectIndX },
{ "rol ", SNESSMP::A },
{ "inc ", SNESSMP::X },
{ "cmp ", SNESSMP::XDirect },
{ "call ", SNESSMP::Absolute },
//0x40 - 0x4f
{ "setp ", SNESSMP::Implied },
{ "tcall", SNESSMP::TVector },
{ "set2 ", SNESSMP::Direct },
{ "bbs2 ", SNESSMP::DirectRelative },
{ "eor ", SNESSMP::ADirect },
{ "eor ", SNESSMP::AAbsolute },
{ "eor ", SNESSMP::AIX },
{ "eor ", SNESSMP::AIDirectIndX },
{ "eor ", SNESSMP::AConstant },
{ "eor ", SNESSMP::DirectDirect },
{ "and1 ", SNESSMP::CAbsoluteBit },
{ "lsr ", SNESSMP::Direct },
{ "lsr ", SNESSMP::Absolute },
{ "push ", SNESSMP::X },
{ "tclr ", SNESSMP::AbsoluteA },
{ "pcall", SNESSMP::PVector },
//0x50 - 0x5f
{ "bvc ", SNESSMP::Relative },
{ "tcall", SNESSMP::TVector },
{ "clr2 ", SNESSMP::Direct },
{ "bbc2 ", SNESSMP::DirectRelative },
{ "eor ", SNESSMP::ADirectIndX },
{ "eor ", SNESSMP::AAbsoluteX },
{ "eor ", SNESSMP::AAbsoluteY },
{ "eor ", SNESSMP::AIDirectIndY },
{ "eor ", SNESSMP::DirectConstant },
{ "eor ", SNESSMP::IXIY },
{ "cmpw ", SNESSMP::YaDirect },
{ "lsr ", SNESSMP::DirectIndX },
{ "lsr ", SNESSMP::A },
{ "mov ", SNESSMP::XA },
{ "cmp ", SNESSMP::YAbsolute },
{ "jmp ", SNESSMP::Absolute },
//0x60 - 0x6f
{ "clrc ", SNESSMP::Implied },
{ "tcall", SNESSMP::TVector },
{ "set3 ", SNESSMP::Direct },
{ "bbs3 ", SNESSMP::DirectRelative },
{ "cmp ", SNESSMP::ADirect },
{ "cmp ", SNESSMP::AAbsolute },
{ "cmp ", SNESSMP::AIX },
{ "cmp ", SNESSMP::AIDirectIndX },
{ "cmp ", SNESSMP::AConstant },
{ "cmp ", SNESSMP::DirectDirect },
{ "and1 ", SNESSMP::CNAbsoluteBit },
{ "ror ", SNESSMP::Direct },
{ "ror ", SNESSMP::Absolute },
{ "push ", SNESSMP::Y },
{ "dbnz ", SNESSMP::DirectRelative },
{ "ret ", SNESSMP::Implied },
//0x70 - 0x7f
{ "bvs ", SNESSMP::Relative },
{ "tcall", SNESSMP::TVector },
{ "clr3 ", SNESSMP::Direct },
{ "bbc3 ", SNESSMP::DirectRelative },
{ "cmp ", SNESSMP::ADirectIndX },
{ "cmp ", SNESSMP::AAbsoluteX },
{ "cmp ", SNESSMP::AAbsoluteY },
{ "cmp ", SNESSMP::AIDirectIndY },
{ "cmp ", SNESSMP::DirectConstant },
{ "cmp ", SNESSMP::IXIY },
{ "addw ", SNESSMP::YaDirect },
{ "ror ", SNESSMP::DirectIndX },
{ "ror ", SNESSMP::A },
{ "mov ", SNESSMP::AX },
{ "cmp ", SNESSMP::YDirect },
{ "reti ", SNESSMP::Implied },
//0x80 - 0x8f
{ "setc ", SNESSMP::Implied },
{ "tcall", SNESSMP::TVector },
{ "set4 ", SNESSMP::Direct },
{ "bbs4 ", SNESSMP::DirectRelative },
{ "adc ", SNESSMP::ADirect },
{ "adc ", SNESSMP::AAbsolute },
{ "adc ", SNESSMP::AIX },
{ "adc ", SNESSMP::AIDirectIndX },
{ "adc ", SNESSMP::AConstant },
{ "adc ", SNESSMP::DirectDirect },
{ "eor1 ", SNESSMP::CAbsoluteBit },
{ "dec ", SNESSMP::Direct },
{ "dec ", SNESSMP::Absolute },
{ "mov ", SNESSMP::YConstant },
{ "pop ", SNESSMP::P },
{ "mov ", SNESSMP::DirectConstant },
//0x90 - 0x9f
{ "bcc ", SNESSMP::Relative },
{ "tcall", SNESSMP::TVector },
{ "clr4 ", SNESSMP::Direct },
{ "bbc4 ", SNESSMP::DirectRelative },
{ "adc ", SNESSMP::ADirectIndX },
{ "adc ", SNESSMP::AAbsoluteX },
{ "adc ", SNESSMP::AAbsoluteY },
{ "adc ", SNESSMP::AIDirectIndY },
{ "adc ", SNESSMP::DirectConstant },
{ "adc ", SNESSMP::IXIY },
{ "subw ", SNESSMP::YaDirect },
{ "dec ", SNESSMP::DirectIndX },
{ "dec ", SNESSMP::A },
{ "mov ", SNESSMP::XSp },
{ "div ", SNESSMP::YaX },
{ "xcn ", SNESSMP::A },
//0xa0 - 0xaf
{ "ei ", SNESSMP::Implied },
{ "tcall", SNESSMP::TVector },
{ "set5 ", SNESSMP::Direct },
{ "bbs5 ", SNESSMP::DirectRelative },
{ "sbc ", SNESSMP::ADirect },
{ "sbc ", SNESSMP::AAbsolute },
{ "sbc ", SNESSMP::AIX },
{ "sbc ", SNESSMP::AIDirectIndX },
{ "sbc ", SNESSMP::AConstant },
{ "sbc ", SNESSMP::DirectDirect },
{ "mov1 ", SNESSMP::CAbsoluteBit },
{ "inc ", SNESSMP::Direct },
{ "inc ", SNESSMP::Absolute },
{ "cmp ", SNESSMP::YConstant },
{ "pop ", SNESSMP::A },
{ "mov ", SNESSMP::IXPA },
//0xb0 - 0xbf
{ "bcs ", SNESSMP::Relative },
{ "tcall", SNESSMP::TVector },
{ "clr5 ", SNESSMP::Direct },
{ "bbc5 ", SNESSMP::DirectRelative },
{ "sbc ", SNESSMP::ADirectIndX },
{ "sbc ", SNESSMP::AAbsoluteX },
{ "sbc ", SNESSMP::AAbsoluteY },
{ "sbc ", SNESSMP::AIDirectIndY },
{ "sbc ", SNESSMP::DirectConstant },
{ "sbc ", SNESSMP::IXIY },
{ "movw ", SNESSMP::YaDirect },
{ "inc ", SNESSMP::DirectIndX },
{ "inc ", SNESSMP::A },
{ "mov ", SNESSMP::SpX },
{ "das ", SNESSMP::A },
{ "mov ", SNESSMP::AIXP },
//0xc0 - 0xcf
{ "di ", SNESSMP::Implied },
{ "tcall", SNESSMP::TVector },
{ "set6 ", SNESSMP::Direct },
{ "bbs6 ", SNESSMP::DirectRelative },
{ "mov ", SNESSMP::DirectA },
{ "mov ", SNESSMP::AbsoluteA },
{ "mov ", SNESSMP::IXA },
{ "mov ", SNESSMP::IDirectIndXA },
{ "cmp ", SNESSMP::XConstant },
{ "mov ", SNESSMP::AbsoluteX },
{ "mov1 ", SNESSMP::AbsoluteBitC },
{ "mov ", SNESSMP::DirectY },
{ "mov ", SNESSMP::AbsoluteY },
{ "mov ", SNESSMP::XConstant },
{ "pop ", SNESSMP::X },
{ "mul ", SNESSMP::Ya },
//0xd0 - 0xdf
{ "bne ", SNESSMP::Relative },
{ "tcall", SNESSMP::TVector },
{ "clr6 ", SNESSMP::Relative },
{ "bbc6 ", SNESSMP::DirectRelative },
{ "mov ", SNESSMP::DirectIndXA },
{ "mov ", SNESSMP::AbsoluteXA },
{ "mov ", SNESSMP::AbsoluteYA },
{ "mov ", SNESSMP::IDirectIndYA },
{ "mov ", SNESSMP::DirectX },
{ "mov ", SNESSMP::DirectIndYX },
{ "movw ", SNESSMP::DirectYa },
{ "mov ", SNESSMP::DirectIndXY },
{ "dec ", SNESSMP::Y },
{ "mov ", SNESSMP::AY },
{ "cbne ", SNESSMP::DirectIndXRelative },
{ "daa ", SNESSMP::A },
//0xe0 - 0xef
{ "clrv ", SNESSMP::Implied },
{ "tcall", SNESSMP::TVector },
{ "set7 ", SNESSMP::Direct },
{ "bbs7 ", SNESSMP::DirectRelative },
{ "mov ", SNESSMP::ADirect },
{ "mov ", SNESSMP::AAbsolute },
{ "mov ", SNESSMP::AIX },
{ "mov ", SNESSMP::AIDirectIndX },
{ "mov ", SNESSMP::AConstant },
{ "mov ", SNESSMP::XAbsolute },
{ "not1 ", SNESSMP::CAbsoluteBit },
{ "mov ", SNESSMP::YDirect },
{ "mov ", SNESSMP::YAbsolute },
{ "notc ", SNESSMP::Implied },
{ "pop ", SNESSMP::Y },
{ "sleep", SNESSMP::Implied },
//0xf0 - 0xff
{ "beq ", SNESSMP::Relative },
{ "tcall", SNESSMP::TVector },
{ "clr7 ", SNESSMP::Direct },
{ "bbc7 ", SNESSMP::DirectRelative },
{ "mov ", SNESSMP::ADirectIndX },
{ "mov ", SNESSMP::AAbsoluteX },
{ "mov ", SNESSMP::AAbsoluteY },
{ "mov ", SNESSMP::AIDirectIndY },
{ "mov ", SNESSMP::XDirect },
{ "mov ", SNESSMP::XDirectIndY },
{ "mov ", SNESSMP::DirectDirect },
{ "mov ", SNESSMP::YDirectIndX },
{ "inc ", SNESSMP::Y },
{ "mov ", SNESSMP::YA },
{ "dbnz ", SNESSMP::YRelative },
{ "stop ", SNESSMP::Implied },
};
inline unsigned SNESSMP::getOpcodeLength(uint8_t opcode) {
switch(smpOpcodeInfo[opcode].mode) { default:
case Implied: return 1; //
case TVector: return 1; //0
case Direct: return 2; //$00
case DirectRelative: return 3; //$00,+/-$00
case ADirect: return 2; //a,$00
case AAbsolute: return 3; //a,$0000
case AIX: return 1; //a,(x)
case AIDirectIndX: return 2; //a,($00+x)
case AConstant: return 2; //a,#$00
case DirectDirect: return 3; //$00,$00
case CAbsoluteBit: return 3; //c,$0000:0
case Absolute: return 3; //$0000
case P: return 1; //p
case AbsoluteA: return 3; //$0000,a
case Relative: return 2; //+/-$00
case ADirectIndX: return 2; //a,$00+x
case AAbsoluteX: return 3; //a,$0000+x
case AAbsoluteY: return 3; //a,$0000+y
case AIDirectIndY: return 2; //a,($00)+y
case DirectConstant: return 3; //$00,#$00
case IXIY: return 1; //(x),(y)
case DirectIndX: return 2; //$00+x
case A: return 1; //a
case X: return 1; //x
case XAbsolute: return 3; //x,$0000
case IAbsoluteX: return 3; //($0000+x)
case CNAbsoluteBit: return 3; //c,!$0000:0
case XDirect: return 2; //x,$00
case PVector: return 2; //$ff00
case YaDirect: return 2; //ya,$00
case XA: return 1; //x,a
case YAbsolute: return 3; //y,$0000
case Y: return 1; //y
case AX: return 1; //a,x
case YDirect: return 2; //y,$00
case YConstant: return 2; //y,#$00
case XSp: return 1; //x,sp
case YaX: return 1; //ya,x
case IXPA: return 1; //(x)+,a
case SpX: return 1; //sp,x
case AIXP: return 1; //a,(x)+
case DirectA: return 2; //$00,a
case IXA: return 1; //(x),a
case IDirectIndXA: return 2; //($00+x),a
case XConstant: return 2; //x,#$00
case AbsoluteX: return 3; //$0000,x
case AbsoluteBitC: return 3; //$0000:0,c
case DirectY: return 2; //$00,y
case AbsoluteY: return 3; //$0000,y
case Ya: return 1; //ya
case DirectIndXA: return 2; //$00+x,a
case AbsoluteXA: return 3; //$0000+x,a
case AbsoluteYA: return 3; //$0000+y,a
case IDirectIndYA: return 2; //($00)+y,a
case DirectX: return 2; //$00,x
case DirectIndYX: return 2; //$00+y,x
case DirectYa: return 2; //$00,ya
case DirectIndXY: return 2; //$00+x,y
case AY: return 1; //a,y
case DirectIndXRelative: return 3; //$00+x,+/-$00
case XDirectIndY: return 2; //x,$00+y
case YDirectIndX: return 2; //y,$00+x
case YA: return 1; //y,a
case YRelative: return 2; //y,+/-$00
}
}
inline bool SNESSMP::getOpcodeIndirect(uint8_t opcode) {
switch(smpOpcodeInfo[opcode].mode) {
case TVector:
case AIX:
case AIDirectIndX:
case AIDirectIndY:
case IXIY:
case IAbsoluteX:
case IXPA:
case AIXP:
case IXA:
case IDirectIndXA:
case IDirectIndYA:
return true;
default:
return false;
}
}
inline string SNESSMP::disassemble(uint16_t pc, uint8_t opcode, uint8_t pl, uint8_t ph, bool p) {
string name = smpOpcodeInfo[opcode].name;
unsigned mode = smpOpcodeInfo[opcode].mode;
unsigned pdl = (p << 8) + pl;
unsigned pdh = (p << 8) + ph;
unsigned pa = (ph << 8) + pl;
if(mode == Implied) return name;
if(mode == TVector) return { name, " ", opcode >> 4 };
if(mode == Direct) return { name, " $", hex<3>(pdl) };
if(mode == DirectRelative) return { name, " $", hex<3>(pdl), ",$", hex<4>(pc + 3 + (int8_t)ph) };
if(mode == ADirect) return { name, " a, $", hex<3>(pdl) };
if(mode == AAbsolute) return { name, " a, $", hex<4>(pa) };
if(mode == AIX) return { name, "a,(x)" };
if(mode == AIDirectIndX) return { name, " a, ($", hex<3>(pdl), "+x)" };
if(mode == AConstant) return { name, " a, #$", hex<2>(pl) };
if(mode == DirectDirect) return { name, " $", hex<3>(pdh), ", $", hex<3>(pdl) };
if(mode == CAbsoluteBit) return { name, " c, $", hex<4>(pa & 0x1fff), ":", pa >> 13 };
if(mode == Absolute) return { name, " $", hex<4>(pa) };
if(mode == P) return { name, " p" };
if(mode == AbsoluteA) return { name, " $", hex<4>(pa), ",a" };
if(mode == Relative) return { name, " $", hex<4>(pc + 2 + (int8_t)pl) };
if(mode == ADirectIndX) return { name, " a, $", hex<3>(pdl), "+x" };
if(mode == AAbsoluteX) return { name, " a, $", hex<4>(pa), "+x" };
if(mode == AAbsoluteY) return { name, " a, $", hex<4>(pa), "+y" };
if(mode == AIDirectIndY) return { name, " a, ($", hex<3>(pdl), ")+y" };
if(mode == DirectConstant) return { name, " $", hex<3>(pdh), ", #$", hex<2>(pl) };
if(mode == IXIY) return { name, " (x), (y)" };
if(mode == DirectIndX) return { name, " $", hex<3>(pdl), "+x" };
if(mode == A) return { name, " a" };
if(mode == X) return { name, " x" };
if(mode == XAbsolute) return { name, " x, $", hex<4>(pa) };
if(mode == IAbsoluteX) return { name, " ($", hex<4>(pa), "+x)" };
if(mode == CNAbsoluteBit) return { name, " c, !$", hex<4>(pa & 0x1fff), ":", pa >> 13 };
if(mode == XDirect) return { name, " x, $", hex<3>(pdl) };
if(mode == PVector) return { name, " $ff", hex<2>(pl) };
if(mode == YaDirect) return { name, " ya, $", hex<3>(pdl) };
if(mode == XA) return { name, " x, a" };
if(mode == YAbsolute) return { name, " y, $", hex<4>(pa) };
if(mode == Y) return { name, " y" };
if(mode == AX) return { name, " a, x" };
if(mode == YDirect) return { name, " y, $", hex<3>(pdl) };
if(mode == YConstant) return { name, " y, #$", hex<2>(pl) };
if(mode == XSp) return { name, " x, sp" };
if(mode == YaX) return { name, " ya, x" };
if(mode == IXPA) return { name, " (x)+, a" };
if(mode == SpX) return { name, " sp, x" };
if(mode == AIXP) return { name, " a, (x)+" };
if(mode == DirectA) return { name, " $", hex<3>(pdl), ", a" };
if(mode == IXA) return { name, " (x), a" };
if(mode == IDirectIndXA) return { name, " ($", hex<3>(pdl), "+x), a" };
if(mode == XConstant) return { name, " x, #$", hex<2>(pl) };
if(mode == AbsoluteX) return { name, " $", hex<4>(pa), ", x" };
if(mode == AbsoluteBitC) return { name, " $", hex<4>(pa & 0x1fff), ":", pa >> 13, ", c" };
if(mode == DirectY) return { name, " $", hex<3>(pdl), ", y" };
if(mode == AbsoluteY) return { name, " $", hex<4>(pa), ", y" };
if(mode == Ya) return { name, " ya" };
if(mode == DirectIndXA) return { name, " $", hex<3>(pdl), "+x, a" };
if(mode == AbsoluteXA) return { name, " $", hex<4>(pa), "+x, a" };
if(mode == AbsoluteYA) return { name, " $", hex<4>(pa), "+y, a" };
if(mode == IDirectIndYA) return { name, " ($", hex<3>(pdl), ")+y, a" };
if(mode == DirectX) return { name, " $", hex<3>(pdl), ", x" };
if(mode == DirectIndYX) return { name, " $", hex<3>(pdl), "+y, x" };
if(mode == DirectYa) return { name, " $", hex<3>(pdl), ",ya" };
if(mode == DirectIndXY) return { name, " $", hex<3>(pdl), "+x, y" };
if(mode == AY) return { name, " a, y" };
if(mode == DirectIndXRelative) return { name, " $", hex<3>(pdl), ", $", hex<4>(pc + 3 + (int8_t)ph) };
if(mode == XDirectIndY) return { name, " x, $", hex<3>(pdl), "+y" };
if(mode == YDirectIndX) return { name, " y, $", hex<3>(pdl), "+x" };
if(mode == YA) return { name, " y, a" };
if(mode == YRelative) return { name, " y, $", hex<4>(pc + 2 + (int8_t)pl) };
return "";
}
}
#endif
Reference in a new issue View git blame Copy permalink