Apple-2-SW
/
qasm
mirror of https://github.com/marketideas/qasm.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
qasm/opcodes.cpp

1115 lines
26 KiB
C++
Raw Permalink Blame History

#include "asm.h"
#include "psuedo.h"
#define CLASS T65816Asm
void CLASS::setOpcode(MerlinLine &line, uint8_t op)
{
if (pass > 0)
{
//printf("cpumode=%d\n",cpumode);
if (cpumode < MODE_65816) // instructions are valid if we are in 65816
{
uint8_t m = opCodeCompatibility[op];
if ((m > 0) && (cpumode < MODE_65C02)) // if the instruction is non-zero, and we are in 6502 base mode, error
{
//printf("incompatable: %02X %02X\n",op,m);
if (line.errorcode == 0) // don't replace other errors
{
line.setError(errIncompatibleOpcode);
}
}
}
}
line.outbytes.push_back(op);
}
int CLASS::doPSEUDO(MerlinLine &line, TSymbol &sym)
{
UNUSED(sym);
int res;
res = psuedoops->ProcessOpcode(*this, line, sym);
return (res);
}
int CLASS::doXC(MerlinLine &line, TSymbol &sym)
{
UNUSED(sym);
std::string s;
int res = 0;
if (options.isMerlin()) // in merlin8 mode we don't support XC psuedoop
{
if (line.errorcode == 0) // don't replace other errors
{
line.setError(errIncompatibleOpcode);
}
return(res);
}
if (cpumode < MODE_65816)
{
cpumode++;
}
if (line.operand.length() > 0)
{
s = Poco::toUpper(line.operand);
if (s == "OFF")
{
mx = 0x03;
cpumode = MODE_6502;
}
}
return (res);
}
int CLASS::doMX(MerlinLine &line, TSymbol &sym)
{
UNUSED(sym);
if (cpumode < MODE_65816)
{
line.setError(errIncompatibleOpcode);
}
else
{
mx = (uint8_t)(line.expr_value & 0x03);
line.linemx = mx;
}
return (0);
}
int CLASS::doEQU(MerlinLine &line, TSymbol &sym)
{
UNUSED(sym);
int res = 0;
TSymbol *s;
if (line.lable.length() > 0)
{
//printf("EQU: |%s|\n",line.operand.c_str());
bool isvar = (line.lable[0] == ']') ? true : false;
if ((pass == 0) && (!isvar))
{
res = -1;
//printf("EQU: |%s| %08X\n", line.lable.c_str(), line.expr_value);
s = addSymbol(line.lable, line.expr_value, true);
if (s != NULL)
{
res = 0;
}
}
else if (isvar)
{
res = -1;
#if 1
char buff[32];
sprintf(buff, "$%08X", line.expr_value);
std::string s1 = buff;
s = addVariable(line.lable, s1, variables,true);
#else
// do this if you want to do this more as a #define
s = addVariable(line.lable, line.operand, variables,true);
#endif
if (s != NULL)
{
res = 0;
}
}
}
return (res);
}
int CLASS::doUNK(MerlinLine &line, TSymbol &sym)
{
int res = -1;
UNUSED(sym);
res = 0;
if (pass > 0)
{
line.setError(errIncomplete);
//line.outbytes.push_back(0x00);
line.outbytect = res;
}
return (res);
}
// PER is a special case because it does strange address calcs
int CLASS::doPER(MerlinLine &line, TSymbol &sym)
{
int res;
int32_t value = 0;;
UNUSED(sym);
res = 0;
if ((line.addressmode == syn_abs) || (line.addressmode == syn_imm))
{
res = 3;
if (pass > 0)
{
// SGQ should check under/over flows
value = line.expr_value;
value -= line.startpc + 3;
//printf("addr calc=%08X %08X %08X\n",line.expr_value,line.startpc+3,value);
setOpcode(line, sym.opcode);
line.outbytes.push_back(value & 0xFF);
line.outbytes.push_back((value >> 8) & 0xFF);
line.outbytect = res;
}
}
if (res == 0)
{
line.setError(errBadAddressMode);
}
return (res);
}
int CLASS::doMVN(MerlinLine &line, TSymbol &sym)
{
int res;
uint8_t op;
UNUSED(sym);
if (line.addressmode == syn_bm)
{
res = 3;
if (pass > 0)
{
if (sym.opcode == 0)
{
op = 0x54; // MVN
}
else
{
op = 0x44; // MVP
}
int64_t value = -1;
int x = evaluate(line, line.operand_expr2, value);
if (x == 0)
{
value &= 0xFFFFFFFF;
}
else
{
value = 0xFFFFFFFF;
line.setError(errBadOperand);
//line.errorText = line.operand_expr2;
}
uint32_t v=(value & 0xFFFFFFFF);
//printf("val1 %08X\n",v);
//printf("val1 %08X\n",line.expr_value);
setOpcode(line, op);
// these bytes are the two bank registers
if (options.isMerlin32() && (v<256))
//if (((line.syntax & SYNTAX_MERLIN32) == SYNTAX_MERLIN32) && (v<256))
{
// merlin32 uses the low byte of the two operands
line.outbytes.push_back((v) & 0xFF);
line.outbytes.push_back((line.expr_value) & 0xFF);
}
else
{
// merlin16 uses the high byte (bank) as the opcode
line.outbytes.push_back((v>>16) & 0xFF);
line.outbytes.push_back((line.expr_value>>16) & 0xFF);
}
line.outbytect = res;
}
}
else
{
line.setError(errBadAddressMode);
res = 0;
}
return (res);
}
int CLASS::doNoPattern(MerlinLine &line, TSymbol &sym)
{
// this handles a few opcodes that don't fit mathmatically in the opcode table
// the 'sym.opcode' table identifies what each is:
// STZ = 1
// TSB = 2
// TRB = 3
UNUSED(sym);
int res, i;
uint8_t err;
uint8_t op;
uint8_t m = line.addressmode;
res = 1;
op = 0x00;
err = errBadAddressMode;
switch (sym.opcode)
{
case 1: // STZ
res++;
op = (m == syn_abs ? 0x64 : op);
op = (m == syn_absx ? 0x74 : op);
if ((op != 0) && ((line.expr_value >= 0x100) || (line.flags & FLAG_FORCEABS)))
{
res++;
op = (op == 0x64) ? 0x9C : op;
op = (op == 0x74) ? 0x9E : op;
}
break;
case 2: // TSB
res++;
op = (m == syn_abs ? 0x04 : op);
if ((op != 0) && ((line.expr_value >= 0x100) || (line.flags & FLAG_FORCEABS)))
{
res++;
op = 0x0C;
}
break;
case 3: // TRB
res++;
op = (m == syn_abs ? 0x14 : op);
if ((op != 0) && ((line.expr_value >= 0x100) || (line.flags & FLAG_FORCEABS)))
{
res++;
op = 0x1C;
}
break;
default:
op = 0;
err = errBadOpcode;
break;
}
if (op == 0x00)
{
res = 0;
line.setError(err);
}
if ((pass > 0) && (res > 0))
{
setOpcode(line, op);
for (i = 0; i < (res - 1); i++)
{
line.outbytes.push_back(line.expr_value >> (8 * i));
}
line.outbytect = res;
}
return (res);
}
int CLASS::doAddress(MerlinLine &line, TSymbol &sym)
{
// this routine uses the 'opcode' specifed in the sym.opcode field.
// it also adds the number of bytes stored in the sym.stype field after doing an evaluation
int res, i;
res = 1 + sym.stype;
if (pass > 0)
{
//if (isMerlin816())
//{
//}
switch(line.expr_shift)
{
case '^':
line.expr_value=(line.expr_value>>16)&0xFFFF;
break;
case '<':
line.expr_value=(line.expr_value)&0xFF;
break;
case '>':
line.expr_value=(line.expr_value>>8)&0xFFFF;
break;
}
//line.setError(errIncomplete);
setOpcode(line, sym.opcode);
for (i = 0; i < (res - 1); i++)
{
line.outbytes.push_back(line.expr_value >> (i * 8));
}
line.outbytect = res;
}
// if these are REP or SEP, see if we need to track
if ((trackrep) && ((sym.opcode == 0xC2) || (sym.opcode == 0xE2)))
{
if (cpumode >= MODE_65816)
{
//printf("trackrep: %02X\n",line.expr_value&0xFF);
// SGQ - if evaluation has errors, this must cause an error here
// because expr_value won't be valid during pass 0 and will screw
// up MX
uint8_t newmx = (line.expr_value & 0x30) >> 4;
switch (sym.opcode)
{
case 0xC2: // REP
mx &= ~newmx;
break;
case 0xE2: // SEP
mx |= newmx;
break;
}
line.linemx = mx;
}
}
return (res);
}
int CLASS::doJMP(MerlinLine &line, TSymbol &sym)
{
int res, i;
bool err = false;
uint8_t op;
uint8_t optype = sym.opcode;
uint8_t m = line.addressmode;
res = 3;
op = 0;
if (optype & 0x02) // these are SUBROUTINES
{
op = (m == syn_abs ? 0x20 : op);
op = (m == syn_diix ? 0xFC : op);
if (!(optype & 0x01)) // jsl?
{
res++;
op = 0x22;
}
}
else
{
op = (m == syn_abs ? 0x4C : op);
op = (m == syn_di ? 0x6C : op);
op = (m == syn_diix ? 0x7C : op);
op = (m == syn_dil ? 0xDC : op);
if (!(optype & 0x01)) // JML?
{
op = (m == syn_abs ? 0x5C : op);
}
if ((op == 0xDC) || (op == 0x5C))
{
if (cpumode < MODE_65816)
{
op = 0; // can't do these without an '816
}
if (op == 0x5C)
{
res++;
}
}
}
if (op == 0)
{
err = true;
}
if (err)
{
res = 0;
line.setError(errBadAddressMode);
}
if ((pass > 0) && (res > 0))
{
setOpcode(line, op);
for (i = 0; i < (res - 1); i++)
{
line.outbytes.push_back((line.expr_value >> (8 * i)) & 0xFF);
}
line.outbytect = res;
}
return (res);
}
int CLASS::doBRANCH(MerlinLine & line, TSymbol & sym)
{
int res, i;
res = 2;
uint8_t op = (sym.opcode << 6) & 0xC0;
op |= 0x10; // make it a branch opcode
if (sym.opcode & 0x80)
{
op |= 0x20;
}
if (sym.opcode & 0x40) // BRA
{
op = 0x80;
}
if (sym.opcode & 0x20) // BRL
{
op = 0x82;
res++;
}
if ((pass > 0) && (res > 0))
{
int64_t o64 = line.expr_value;
int32_t o32 = (int32_t)(o64 & 0xFFFFFFFF);
int32_t offset = o32 - line.startpc - res;
bool err = false;
if (res == 2) // short branch
{
if ((offset < -128) || (offset > 127))
{
err = true;
op = 0x00; // merlin does this
}
}
else if (res == 3) // long branch
{
if ((offset < -32768) || (offset > 32767))
{
err = true;
// for BRL, merlin DOES NOT kill the opcode
//op=0x00; // merlin does this
}
}
//printf("offset %d\n", offset);
setOpcode(line, op);
for (i = 0; i < (res - 1); i++)
{
uint8_t v = (offset >> (i * 8));
v = err ? 0x00 : v;
line.outbytes.push_back(v);
}
line.outbytect = res;
if (err)
{
line.setError(errBadBranch);
}
}
return (res);
}
// aaabbbcc
int CLASS::doBase6502(MerlinLine & line, TSymbol & sym)
{
int res = 1;
int i;
uint8_t bytelen = 1;
uint8_t cc;
uint8_t op, amode;
uint16_t opflags;
bool err = false;
uint16_t m = line.addressmode;
//std::string opcode = Poco::toUpper(line.opcode);
line.opflags = opflags = sym.stype;
op = (sym.opcode << 5) & 0xE0;
cc = (sym.stype >> 8) & 0x03;
amode = 0xFF;
if ((sym.stype & OP_C0) == OP_C0)
{
uint8_t cc = 0;
uint8_t bbb = 0xFF;
bbb = (m == syn_imm ? 0 : bbb);
bbb = (m == syn_abs ? 1 : bbb);
bbb = (m == syn_absx ? 5 : bbb);
//printf("expr_value=%08X\n",line.expr_value);
if ((sym.opcode == 1) && (m == syn_imm)) //BIT special case
{
cc = 0x01;
op = 0x80;
bbb = 0x02;
}
else if ((bbb > 0) && ((line.expr_value >= 0x100) || (line.flags & FLAG_FORCEABS)))
{
bbb |= 0x02;
bytelen++;
}
op |= (bbb << 2) | cc;
if (m == syn_imm)
{
int add = 0;
switch (sym.opcode)
{
case 7: // CPX
case 6: // CPY
case 5: // LDY
case 4: // STY
if ((mx & 0x01) == 0)
{
add = 1;
}
break;
case 1: // BIT
if ((mx & 0x02) == 0)
{
add = 1;
}
break;
}
bytelen += add;
}
goto out;
}
if (cc == 0x01)
{
switch (m)
{
case syn_diix:
amode = 0;
break;
case syn_abs:
amode = 1;
break;
case syn_imm:
amode = 2;
break;
case syn_diiy:
amode = 4;
break;
case syn_absx:
amode = 5;
break;
case syn_absy:
amode = 6;
break;
//case syn_none:
// printf("syn_none on ROR OP_A\n");
// break;
default:
err = true;
break;
}
}
else if (cc == 0x02)
{
switch (m)
{
case syn_imm:
amode = 0;
break;
case syn_abs:
amode = 1;
break;
case syn_implied:
amode = 2;
bytelen = 0;
break;
case syn_absy:
if ((opflags & OP_STX) == OP_STX)
{
amode = 5;
}
break;
case syn_absx:
amode = 5;
break; // this is actually Y addressing because X register is used
default:
err = true;
break;
}
if ((opflags & OP_STX) == OP_STX)
{
if (m == syn_implied)
{
err = true;
}
if (m == syn_imm)
{
if ((mx & 0x01) == 0)
{
bytelen++;
}
}
if ( ((m == syn_absx) || (m == syn_diix)) && ((sym.opcode == 4) || (sym.opcode == 5))) // these are STX,LDX
{
err = true;
}
if ((m == syn_absx) || (m == syn_abs) || (m == syn_absy))
{
if ((line.flags & FLAG_FORCEABS) || (line.expr_value >= 0x100) )
{
bytelen++;
amode += 2;
}
}
if (cpumode >= MODE_65C02)
{
if (m == syn_implied)
{
if ((opflags & (OP_STX | OP_SPECIAL)) == (OP_STX | OP_SPECIAL))
{
if (sym.opcode == 0x07) // INC
{
err = false;
op = 0x1A;
bytelen = 0;
goto out;
}
if (sym.opcode == 0x06) // DEC
{
err = false;
op = 0x3A;
bytelen = 0;
goto out;
}
}
}
}
}
else
{
if ((m == syn_absx) || (m == syn_abs))
{
if ((line.flags & FLAG_FORCEABS) || (line.expr_value >= 0x100))
{
bytelen++;
amode += 2;
}
}
}
if (line.flags & FLAG_FORCELONG)
{
//err = errBadAddressMode;
err=true;
line.setError(errBadAddressMode);
}
goto outop;
}
if (m == syn_imm)
{
uint8_t mask = 0x02;
if (cc == 0x02) // the non accumulator
{
mask = 0x01;
}
if ((mx & mask) == 0)
{
bytelen++;
}
}
else if ((m == syn_abs) || (m == syn_absx)
|| (m == syn_absy))
{
if ((((line.flags & FLAG_DP) == 0) && ((line.flags & FLAG_FORCEDP) == 0))
|| (line.flags & FLAG_FORCEABS)
|| (m==syn_absy)
)
{
bytelen++;
if (amode != 6)
{
amode += 2;
}
}
if (line.flags & FLAG_FORCELONG)
{
// we are in 65C02/02 mode, so long addressing not supported
err = true;
}
}
if (err) // not a 6502 address mode
{
//if (cpumode >= MODE_65816)
if (cpumode >= MODE_65C02)
{
cc = 0x03;
err = false;
switch (m)
{
case syn_s:
amode = 0;
break;
case syn_sy:
amode = 4;
break;
case syn_di:
cc = 0x02;
amode = 4;
break;
case syn_iyl:
amode = 5;
break;
case syn_dil:
amode = 1;
break;
case syn_absx:
amode = 7;
break;
case syn_abs:
amode = 3;
break;
default:
//printf("bad syn_mode=%d\n", m);
err = true;
break;
}
if (!err)
{
if ((m == syn_abs) || (m == syn_absx))
{
if (line.flags & FLAG_FORCELONG)
{
bytelen = 3;
}
}
}
}
}
outop:
op |= (amode & 0x07) << 2;
op |= cc;
out:
if (err)
{
line.setError(errBadAddressMode);
printf("bad address mode %d\n",line.addressmode);
op = 0x00;
res = 0;
bytelen = 0;
}
res += bytelen;
if ((pass > 0) && (res > 0))
{
int pidx=0;
uint8_t *ptr=(uint8_t *)&line.expr_value;
setOpcode(line, op);
if (line.shiftchar!=0)
{
if (m==syn_imm)
{
switch(line.shiftchar)
{
case '>':
pidx+=1;
break;
case '^':
pidx+=2;
break;
}
}
else
{
switch(line.shiftchar)
{
case '>':
{
if ((line.flags&FLAG_FORCELONG)!=FLAG_FORCELONG)
{
pidx+=1;
}
}
break;
case '^':
{
}
break;
}
}
}
for (i = 0; i < (res - 1); i++)
{
if (pidx>3) // don't over index into 32 bit int
{
line.outbytes.push_back(0x00);
}
else
{
line.outbytes.push_back(ptr[pidx]);
pidx++;
}
}
line.outbytect = res;
}
return (res);
}
int CLASS::doEND(MerlinLine & line, TSymbol & sym)
{
UNUSED(sym);
UNUSED(line);
int res = 0;
passcomplete = true;
return (res);
}
int CLASS::doBYTE(MerlinLine & line, TSymbol & sym)
{
UNUSED(sym);
int res = 1;
if (pass > 0)
{
setOpcode(line, sym.opcode);
line.outbytect = res;
}
// SGQ merlin32 apparently tracks XCE instructions when tracking MX status
// who knows how they determine this. I am assuming the NEXT instruction
// after a SEC/CLC instruction must be an XCE
if (options.isMerlin32())
{
if (sym.opcode == 0x38) // SEC
{
lastcarry = true;
}
else if (sym.opcode == 0x18) // CLC
{
lastcarry = false;
}
else if (sym.opcode == 0xFB) // XCE
{
if (trackrep)
{
if (lastcarry)
{
mx = 0x03;
}
}
}
}
return (res);
}
int CLASS::doBRK(MerlinLine & line, TSymbol & sym)
{
UNUSED(sym);
int res = 1;
int bytes = 0;
if (line.operand_expr != "")
{
bytes++;
}
if (pass > 0)
{
setOpcode(line, sym.opcode);
for (int i = 0; i < bytes; i++)
{
line.outbytes.push_back((line.expr_value >> (8 * i)) & 0xFF);
}
line.outbytect = res + bytes;
}
return (res + bytes);
}
void CLASS::insertOpcodes(void)
{
pushopcode("=", 0x00, OP_PSUEDO, OPHANDLER(&CLASS::doEQU));
pushopcode("EQU", 0x00, OP_PSUEDO, OPHANDLER(&CLASS::doEQU));
pushopcode("END", 0x00, OP_PSUEDO, OPHANDLER(&CLASS::doEND));
pushopcode("MX", 0x00, OP_PSUEDO, OPHANDLER(&CLASS::doMX));
pushopcode("XC", 0x00, OP_PSUEDO, OPHANDLER(&CLASS::doXC));
pushopcode("EXT", 0x00, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("ENT", 0x00, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("ORG", P_ORG, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("DSK", P_SAV, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("SAV", P_SAV, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("DS", P_DS, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("REL", 0x00, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("OBJ", 0x00, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("PUT", P_PUT, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("USE", P_USE, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("VAR", 0x00, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("TYP", 0x00, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("DUM", P_DUM, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("DEND", P_DEND, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("AST", 0x00, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("CAS", P_CAS, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("CYC", 0x00, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("DAT", 0x00, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("EXP", 0x00, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("LST", P_LST, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("LSTDO", 0x00, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("PAG", 0x00, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("TTL", 0x00, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("SKP", 0x00, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("PAU", P_PAU, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("TR", P_TR, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("ASC", P_ASC, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("DCI", P_ASC, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("INV", P_ASC, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("FLS", P_ASC, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("REV", P_ASC, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("STR", P_ASC, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("STRL", P_ASC, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("DA", P_DATA, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("DW", P_DATA, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("DDB", P_DATA, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("DFB", P_DATA, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("DB", P_DATA, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("ADR", P_DATA, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("ADRL", P_DATA, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("HEX", P_HEX, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("DO", P_DO, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("ELSE", P_DO, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("IF", P_DO, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("FIN", P_DO, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("CHK", P_CHK, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("ERR", P_ERR, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("KBD", 0x00, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("LUP", P_LUP, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("--^", P_LUP, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("SW", 0x00, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("USR", P_USR, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("MAC", P_MAC, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("EOM", P_MAC, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("<<<", P_MAC, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode(">>>", P_MAC, OP_PSUEDO, OPHANDLER(&CLASS::doPSEUDO));
pushopcode("ADC", 0x03, OP_STD | OP_A, OPHANDLER(&CLASS::doBase6502));
pushopcode("AND", 0x01, OP_STD | OP_A, OPHANDLER(&CLASS::doBase6502));
pushopcode("ASL", 0x00, OP_ASL | OP_A, OPHANDLER(&CLASS::doBase6502));
pushopcode("BCC", 0x02, 0, OPHANDLER(&CLASS::doBRANCH));
pushopcode("BLT", 0x02, 0, OPHANDLER(&CLASS::doBRANCH));
pushopcode("BCS", 0x82, 0, OPHANDLER(&CLASS::doBRANCH));
pushopcode("BGE", 0x82, 0, OPHANDLER(&CLASS::doBRANCH));
pushopcode("BEQ", 0x83, 0, OPHANDLER(&CLASS::doBRANCH));
pushopcode("BIT", 0x01, OP_C0, OPHANDLER(&CLASS::doBase6502));
pushopcode("BMI", 0x80, 0, OPHANDLER(&CLASS::doBRANCH));
pushopcode("BNE", 0x03, 0, OPHANDLER(&CLASS::doBRANCH));
pushopcode("BPL", 0x00, 0, OPHANDLER(&CLASS::doBRANCH));
pushopcode("BRA", 0x40, 0, OPHANDLER(&CLASS::doBRANCH));
pushopcode("BRK", 0x00, 1, OPHANDLER(&CLASS::doBRK));
pushopcode("BRL", 0x20, 0, OPHANDLER(&CLASS::doBRANCH));
pushopcode("BVC", 0x01, 0, OPHANDLER(&CLASS::doBRANCH));
pushopcode("BVS", 0x81, 0, OPHANDLER(&CLASS::doBRANCH));
pushopcode("CLC", 0x18, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("CLD", 0xD8, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("CLI", 0x58, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("CLV", 0xB8, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("CMP", 0x06, OP_STD | OP_A, OPHANDLER(&CLASS::doBase6502));
pushopcode("COP", 0x02, 1, OPHANDLER(&CLASS::doAddress));
pushopcode("CPX", 0x07, OP_C0 | OP_XY, OPHANDLER(&CLASS::doBase6502));
pushopcode("CPY", 0x06, OP_C0 | OP_XY, OPHANDLER(&CLASS::doBase6502));
pushopcode("DEC", 0x06, OP_STX | OP_SPECIAL | OP_A, OPHANDLER(&CLASS::doBase6502));
pushopcode("DEX", 0xCA, OP_XY, OPHANDLER(&CLASS::doBYTE));
pushopcode("DEY", 0x88, OP_XY, OPHANDLER(&CLASS::doBYTE));
pushopcode("EOR", 0x02, OP_STD | OP_A, OPHANDLER(&CLASS::doBase6502));
pushopcode("INC", 0x07, OP_STX | OP_A | OP_SPECIAL, OPHANDLER(&CLASS::doBase6502));
pushopcode("INX", 0xE8, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("INY", 0xC8, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("JML", 0x00, 0, OPHANDLER(&CLASS::doJMP));
pushopcode("JMP", 0x01, 0, OPHANDLER(&CLASS::doJMP));
pushopcode("JSL", 0x02, 0, OPHANDLER(&CLASS::doJMP));
pushopcode("JSR", 0x03, 0, OPHANDLER(&CLASS::doJMP));
pushopcode("LDA", 0x05, OP_STD | OP_A, OPHANDLER(&CLASS::doBase6502));
pushopcode("LDX", 0x05, OP_STX | OP_XY, OPHANDLER(&CLASS::doBase6502));
pushopcode("LDY", 0x05, OP_C0 | OP_XY, OPHANDLER(&CLASS::doBase6502));
pushopcode("LSR", 0x02, OP_ASL | OP_A, OPHANDLER(&CLASS::doBase6502));
pushopcode("MVN", 0x00, 0, OPHANDLER(&CLASS::doMVN));
pushopcode("MVP", 0x01, 0, OPHANDLER(&CLASS::doMVN));
pushopcode("NOP", 0xEA, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("ORA", 0x00, OP_STD | OP_A, OPHANDLER(&CLASS::doBase6502));
pushopcode("PEA", 0xF4, 2, OPHANDLER(&CLASS::doAddress));
pushopcode("PEI", 0xD4, 1, OPHANDLER(&CLASS::doAddress));
pushopcode("PER", 0x62, 2, OPHANDLER(&CLASS::doPER));
pushopcode("PHA", 0x48, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("PHB", 0x8B, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("PHD", 0x0B, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("PHK", 0x4B, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("PHP", 0x08, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("PHX", 0xDA, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("PHY", 0x5A, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("PLA", 0x68, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("PLB", 0xAB, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("PLD", 0x2B, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("PLP", 0x28, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("PLX", 0xFA, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("PLY", 0x7A, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("REP", 0xC2, 1, OPHANDLER(&CLASS::doAddress));
pushopcode("ROL", 0x01, OP_ASL | OP_A, OPHANDLER(&CLASS::doBase6502));
pushopcode("ROR", 0x03, OP_ASL | OP_A, OPHANDLER(&CLASS::doBase6502));
pushopcode("RTI", 0x40, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("RTL", 0x6B, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("RTS", 0x60, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("SBC", 0x07, OP_STD | OP_A, OPHANDLER(&CLASS::doBase6502));
pushopcode("SEC", 0x38, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("SED", 0xF8, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("SEI", 0x78, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("SEP", 0xE2, 1, OPHANDLER(&CLASS::doAddress));
pushopcode("STP", 0xDB, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("STA", 0x04, OP_STD | OP_A, OPHANDLER(&CLASS::doBase6502));
pushopcode("STX", 0x04, OP_STX | OP_XY, OPHANDLER(&CLASS::doBase6502));
pushopcode("STY", 0x04, OP_C0 | OP_XY, OPHANDLER(&CLASS::doBase6502));
pushopcode("STZ", 0x01, OP_A, OPHANDLER(&CLASS::doNoPattern));
pushopcode("TAX", 0xAA, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("TAY", 0xA8, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("TCD", 0x5B, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("TAD", 0x5B, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("TCS", 0x1B, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("TAS", 0x1B, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("TDC", 0x7B, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("TDA", 0x7B, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("TRB", 0x03, OP_A, OPHANDLER(&CLASS::doNoPattern));
pushopcode("TSB", 0x02, OP_A, OPHANDLER(&CLASS::doNoPattern));
pushopcode("TSC", 0x3B, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("TSA", 0x3B, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("TSX", 0xBA, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("TXA", 0x8A, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("TXS", 0x9A, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("TXY", 0x9B, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("TYA", 0x98, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("TYX", 0xBB, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("WAI", 0xCB, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("WDM", 0x42, 1, OPHANDLER(&CLASS::doAddress));
pushopcode("XBA", 0xEB, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("SWA", 0xEB, 0, OPHANDLER(&CLASS::doBYTE));
pushopcode("XCE", 0xFB, 0, OPHANDLER(&CLASS::doBYTE));
}
#undef CLASS
Reference in New Issue View Git Blame Copy Permalink