(function (name, definition) {
if (typeof module != "undefined") module.exports = definition();
else if (typeof define == "function" && typeof define.amd == "object")
define(definition);
else this[name] = definition();
})("CPU6809", function () {
var rA,
rB,
rX,
rY,
rU,
rS,
PC,
CC,
DP,
F_CARRY = 1,
F_OVERFLOW = 2,
F_ZERO = 4,
F_NEGATIVE = 8,
F_IRQMASK = 16,
F_HALFCARRY = 32,
F_FIRQMASK = 64,
F_ENTIRE = 128,
vecRESET = 0xfffe,
vecNMI = 0xfffc,
vecSWI = 0xfffa,
vecIRQ = 0xfff8,
vecFIRQ = 0xfff6,
vecSWI2 = 0xfff4,
vecSWI3 = 0xfff2,
ticks = null,
T = 0;
var IRQs;
var byteTo, byteAt;
var cycles = [
6,
0,
0,
6,
6,
0,
6,
6,
6,
6,
6,
0,
6,
6,
3,
6 /* 00-0F */,
0,
0,
2,
4,
0,
0,
5,
9,
0,
2,
3,
0,
3,
2,
8,
6 /* 10-1F */,
3,
3,
3,
3,
3,
3,
3,
3,
3,
3,
3,
3,
3,
3,
3,
3 /* 20-2F */,
4,
4,
4,
4,
5,
5,
5,
5,
0,
5,
3,
6,
9,
11,
0,
19 /* 30-3F */,
2,
0,
0,
2,
2,
0,
2,
2,
2,
2,
2,
0,
2,
2,
0,
2 /* 40-4F */,
2,
0,
0,
2,
2,
0,
2,
2,
2,
2,
2,
0,
2,
2,
0,
2 /* 50-5F */,
6,
0,
0,
6,
6,
0,
6,
6,
6,
6,
6,
0,
6,
6,
3,
6 /* 60-6F */,
7,
0,
0,
7,
7,
0,
7,
7,
7,
7,
7,
0,
7,
7,
4,
7 /* 70-7F */,
2,
2,
2,
4,
2,
2,
2,
0,
2,
2,
2,
2,
4,
7,
3,
0 /* 80-8F */,
4,
4,
4,
6,
4,
4,
4,
4,
4,
4,
4,
4,
6,
7,
5,
5 /* 90-9F */,
4,
4,
4,
6,
4,
4,
4,
4,
4,
4,
4,
4,
6,
7,
5,
5 /* A0-AF */,
5,
5,
5,
7,
5,
5,
5,
5,
5,
5,
5,
5,
7,
8,
6,
6 /* B0-BF */,
2,
2,
2,
4,
2,
2,
2,
0,
2,
2,
2,
2,
3,
0,
3,
0 /* C0-CF */,
4,
4,
4,
6,
4,
4,
4,
4,
4,
4,
4,
4,
5,
5,
5,
5 /* D0-DF */,
4,
4,
4,
6,
4,
4,
4,
4,
4,
4,
4,
4,
5,
5,
5,
5 /* E0-EF */,
5,
5,
5,
7,
5,
5,
5,
5,
5,
5,
5,
5,
6,
6,
6,
6,
]; /* F0-FF */
/* Instruction timing for the two-byte opcodes */
var cycles2 = [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0 /* 00-0F */,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0 /* 10-1F */,
0,
5,
5,
5,
5,
5,
5,
5,
5,
5,
5,
5,
5,
5,
5,
5 /* 20-2F */,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
20 /* 30-3F */,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0 /* 40-4F */,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0 /* 50-5F */,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0 /* 60-6F */,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0 /* 70-7F */,
0,
0,
0,
5,
0,
0,
0,
0,
0,
0,
0,
0,
5,
0,
4,
0 /* 80-8F */,
0,
0,
0,
7,
0,
0,
0,
0,
0,
0,
0,
0,
7,
0,
6,
6 /* 90-9F */,
0,
0,
0,
7,
0,
0,
0,
0,
0,
0,
0,
0,
7,
0,
6,
6 /* A0-AF */,
0,
0,
0,
8,
0,
0,
0,
0,
0,
0,
0,
0,
8,
0,
7,
7 /* B0-BF */,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
4,
0 /* C0-CF */,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
6,
6 /* D0-DF */,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
6,
6 /* E0-EF */,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
7,
7,
]; /* F0-FF */
/* Negative and zero flags for quicker flag settings */
var flagsNZ = [
4,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0 /* 00-0F */,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0 /* 10-1F */,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0 /* 20-2F */,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0 /* 30-3F */,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0 /* 40-4F */,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0 /* 50-5F */,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0 /* 60-6F */,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0 /* 70-7F */,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8 /* 80-8F */,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8 /* 90-9F */,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8 /* A0-AF */,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8 /* B0-BF */,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8 /* C0-CF */,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8 /* D0-DF */,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8 /* E0-EF */,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
8,
]; /* F0-FF */
var setV8 = function (a, b, r) {
CC |= ((a ^ b ^ r ^ (r >> 1)) & 0x80) >> 6;
};
var setV8cmp = function (a, b, r) {
if ((a ^ b) & (a ^ r)) CC |= F_OVERFLOW;
};
var setV16 = function (a, b, r) {
CC |= ((a ^ b ^ r ^ (r >> 1)) & 0x8000) >> 14;
};
var getD = function () {
return rA * 256 + rB;
};
var setD = function (v) {
rA = (v >> 8) & 0xff;
rB = v & 0xff;
};
var PUSHB = function (b) {
byteTo(--rS, b & 0xff);
};
var PUSHW = function (b) {
byteTo(--rS, b & 0xff);
byteTo(--rS, (b >> 8) & 0xff);
};
var PUSHBU = function (b) {
byteTo(--rU, b & 0xff);
};
var PUSHWU = function (b) {
byteTo(--rU, b & 0xff);
byteTo(--rU, (b >> 8) & 0xff);
};
var PULLB = function (b) {
return byteAt(rS++);
};
var PULLW = function (b) {
return byteAt(rS++) * 256 + byteAt(rS++);
};
var PULLBU = function (b) {
return byteAt(rU++);
};
var PULLWU = function (b) {
return byteAt(rU++) * 256 + byteAt(rU++);
};
var PSHS = function (ucTemp) {
var i = 0;
if (ucTemp & 0x80) {
PUSHW(PC);
i += 2;
}
if (ucTemp & 0x40) {
PUSHW(rU);
i += 2;
}
if (ucTemp & 0x20) {
PUSHW(rY);
i += 2;
}
if (ucTemp & 0x10) {
PUSHW(rX);
i += 2;
}
if (ucTemp & 0x8) {
PUSHB(DP);
i++;
}
if (ucTemp & 0x4) {
PUSHB(rB);
i++;
}
if (ucTemp & 0x2) {
PUSHB(rA);
i++;
}
if (ucTemp & 0x1) {
PUSHB(CC);
i++;
}
T += i; //timing
};
var PSHU = function (ucTemp) {
var i = 0;
if (ucTemp & 0x80) {
PUSHWU(PC);
i += 2;
}
if (ucTemp & 0x40) {
PUSHWU(rS);
i += 2;
}
if (ucTemp & 0x20) {
PUSHWU(rY);
i += 2;
}
if (ucTemp & 0x10) {
PUSHWU(rX);
i += 2;
}
if (ucTemp & 0x8) {
PUSHBU(DP);
i++;
}
if (ucTemp & 0x4) {
PUSHBU(rB);
i++;
}
if (ucTemp & 0x2) {
PUSHBU(rA);
i++;
}
if (ucTemp & 0x1) {
PUSHBU(CC);
i++;
}
T += i; //timing
};
var PULS = function (ucTemp) {
var i = 0;
if (ucTemp & 0x1) {
CC = PULLB();
i++;
}
if (ucTemp & 0x2) {
rA = PULLB();
i++;
}
if (ucTemp & 0x4) {
rB = PULLB();
i++;
}
if (ucTemp & 0x8) {
DP = PULLB();
i++;
}
if (ucTemp & 0x10) {
rX = PULLW();
i += 2;
}
if (ucTemp & 0x20) {
rY = PULLW();
i += 2;
}
if (ucTemp & 0x40) {
rU = PULLW();
i += 2;
}
if (ucTemp & 0x80) {
PC = PULLW();
i += 2;
}
T += i; //timing
};
var PULU = function (ucTemp) {
var i = 0;
if (ucTemp & 0x1) {
CC = PULLBU();
i++;
}
if (ucTemp & 0x2) {
rA = PULLBU();
i++;
}
if (ucTemp & 0x4) {
rB = PULLBU();
i++;
}
if (ucTemp & 0x8) {
DP = PULLBU();
i++;
}
if (ucTemp & 0x10) {
rX = PULLWU();
i += 2;
}
if (ucTemp & 0x20) {
rY = PULLWU();
i += 2;
}
if (ucTemp & 0x40) {
rS = PULLWU();
i += 2;
}
if (ucTemp & 0x80) {
PC = PULLWU();
i += 2;
}
T += i; //timing
};
var getPBR = function (ucPostByte) {
switch (ucPostByte & 0xf) {
case 0x00 /* D */:
return getD();
case 0x1 /* X */:
return rX;
case 0x2 /* Y */:
return rY;
case 0x3 /* U */:
return rU;
case 0x4 /* S */:
return rS;
case 0x5 /* PC */:
return PC;
case 0x8 /* A */:
return rA;
case 0x9 /* B */:
return rB;
case 0xa /* CC */:
return CC;
case 0xb /* DP */:
return DP;
default:
/* illegal */
return null;
}
};
var setPBR = function (ucPostByte, v) {
switch (ucPostByte & 0xf /* Get destination register */) {
case 0x00 /* D */:
setD(v);
return;
case 0x1 /* X */:
rX = v;
return;
case 0x2 /* Y */:
rY = v;
return;
case 0x3 /* U */:
rU = v;
return;
case 0x4 /* S */:
rS = v;
return;
case 0x5 /* PC */:
PC = v;
return;
case 0x8 /* A */:
rA = v;
return;
case 0x9 /* B */:
rB = v;
return;
case 0xa /* CC */:
CC = v;
return;
case 0xb /* DP */:
DP = v;
return;
default:
/* illegal */
return;
}
};
var TFREXG = function (ucPostByte, bExchange) {
var ucTemp = ucPostByte & 0x88;
if (ucTemp == 0x80 || ucTemp == 0x08) ucTemp = 0; /* PROBLEM! */
if (bExchange) {
ucTemp = getPBR(ucPostByte >> 4);
setPBR(ucPostByte >> 4, getPBR(ucPostByte));
setPBR(ucPostByte, ucTemp);
} /* Transfer */ else {
setPBR(ucPostByte, getPBR(ucPostByte >> 4));
}
};
var signed = function (x) {
return x > 127 ? x - 256 : x;
};
var signed16 = function (x) {
return x > 32767 ? x - 65536 : x;
};
var fetch = function () {
var v = byteAt(PC++);
PC &= 0xffff;
return v;
};
var fetch16 = function () {
var v1 = byteAt(PC++);
PC &= 0xffff;
var v2 = byteAt(PC++);
PC &= 0xffff;
return v1 * 256 + v2;
};
var ReadWord = function (addr) {
var v1 = byteAt(addr++);
addr &= 0xffff;
var v2 = byteAt(addr++);
addr &= 0xffff;
return v1 * 256 + v2;
};
var WriteWord = function (addr, v) {
byteTo(addr++, (v >> 8) & 0xff);
addr &= 0xffff;
byteTo(addr, v & 0xff);
};
var PostByte = function () {
var pb = fetch();
var preg;
switch (pb & 0x60) {
case 0:
preg = rX;
break;
case 0x20:
preg = rY;
break;
case 0x40:
preg = rU;
break;
case 0x60:
preg = rS;
break;
}
var xchg = null;
var addr = null;
var sTemp;
if (pb & 0x80) {
/* Complex stuff */
switch (pb & 0x0f) {
case 0 /* EA = ,reg+ */:
addr = preg;
xchg = preg + 1;
T += 2;
break;
case 1 /* EA = ,reg++ */:
addr = preg;
xchg = preg + 2;
T += 3;
break;
case 2 /* EA = ,-reg */:
xchg = preg - 1;
addr = xchg;
T += 2;
break;
case 3 /* EA = ,--reg */:
xchg = preg - 2;
addr = xchg;
T += 3;
break;
case 4 /* EA = ,reg */:
addr = preg;
break;
case 5 /* EA = ,reg + B */:
//usAddr = *pReg + (signed short)(signed char)regs->ucRegB;
addr = preg + signed(rB);
T += 1;
break;
case 6 /* EA = ,reg + A */:
addr = preg + signed(rA);
T += 1;
break;
case 7 /* illegal */:
addr = 0;
break;
case 8 /* EA = ,reg + 8-bit offset */:
addr = preg + signed(fetch());
T += 1;
break;
case 9 /* EA = ,reg + 16-bit offset */:
addr = preg + signed16(fetch16());
T += 4;
break;
case 0xa /* illegal */:
addr = 0;
break;
case 0xb /* EA = ,reg + D */:
T += 4;
addr = preg + getD();
break;
case 0xc /* EA = PC + 8-bit offset */:
sTemp = signed(fetch());
addr = PC + sTemp;
T += 1;
break;
case 0xd /* EA = PC + 16-bit offset */:
sTemp = signed16(fetch16());
addr = PC + sTemp;
T += 5;
break;
case 0xe /* Illegal */:
addr = 0;
break;
case 0xf /* EA = [,address] */:
T += 5;
addr = fetch16();
break;
} /* switch */
addr &= 0xffff;
if (pb & 0x10) {
/* Indirect addressing */
addr = byteAt(addr) * 256 + byteAt((addr + 1) & 0xffff);
T += 3;
}
} /* Just a 5 bit signed offset + register */ else {
var sByte = pb & 0x1f;
if (sByte > 15) /* Two's complement 5-bit value */ sByte -= 32;
addr = preg + sByte;
T += 1;
}
if (xchg !== null) {
switch (pb & 0x60) {
case 0:
rX = xchg;
break;
case 0x20:
rY = xchg;
break;
case 0x40:
rU = xchg;
break;
case 0x60:
rS = xchg;
break;
}
}
return addr & 0xffff; /* Return the effective address */
};
var flagsNZ16 = function (word) {
CC &= ~(F_ZERO | F_NEGATIVE);
if (word === 0) CC |= F_ZERO;
if (word & 0x8000) CC |= F_NEGATIVE;
};
// ============= Operations
var oINC = function (b) {
b++;
b &= 0xff;
CC &= ~(F_ZERO | F_OVERFLOW | F_NEGATIVE);
CC |= flagsNZ[b];
if (b === 0 || b == 0x80) CC |= F_OVERFLOW;
return b;
};
var oDEC = function (b) {
b--;
b &= 0xff;
CC &= ~(F_ZERO | F_OVERFLOW | F_NEGATIVE);
CC |= flagsNZ[b];
if (b === 0x7f || b == 0xff) CC |= F_OVERFLOW;
return b;
};
var oSUB = function (b, v) {
var temp = b - v;
//temp &= 0xff;
CC &= ~(F_CARRY | F_ZERO | F_OVERFLOW | F_NEGATIVE);
CC |= flagsNZ[temp & 0xff];
if (temp & 0x100) CC |= F_CARRY;
setV8(b, v, temp);
return temp & 0xff;
};
var oSUB16 = function (b, v) {
var temp = b - v;
//temp &= 0xff;
CC &= ~(F_CARRY | F_ZERO | F_OVERFLOW | F_NEGATIVE);
if ((temp & 0xffff) === 0) CC |= F_ZERO;
if (temp & 0x8000) CC |= F_NEGATIVE;
if (temp & 0x10000) CC |= F_CARRY;
setV16(b, v, temp);
return temp & 0xffff;
};
var oADD = function (b, v) {
var temp = b + v;
//temp &= 0xff;
CC &= ~(F_HALFCARRY | F_CARRY | F_ZERO | F_OVERFLOW | F_NEGATIVE);
CC |= flagsNZ[temp & 0xff];
if (temp & 0x100) CC |= F_CARRY;
setV8(b, v, temp);
if ((temp ^ b ^ v) & 0x10) CC |= F_HALFCARRY;
return temp & 0xff;
};
var oADD16 = function (b, v) {
var temp = b + v;
//temp &= 0xff;
CC &= ~(F_CARRY | F_ZERO | F_OVERFLOW | F_NEGATIVE);
if ((temp & 0xffff) === 0) CC |= F_ZERO;
if (temp & 0x8000) CC |= F_NEGATIVE;
if (temp & 0x10000) CC |= F_CARRY;
setV16(b, v, temp);
return temp & 0xffff;
};
var oADC = function (b, v) {
var temp = b + v + (CC & F_CARRY);
//temp &= 0xff;
CC &= ~(F_HALFCARRY | F_CARRY | F_ZERO | F_OVERFLOW | F_NEGATIVE);
CC |= flagsNZ[temp & 0xff];
if (temp & 0x100) CC |= F_CARRY;
setV8(b, v, temp);
if ((temp ^ b ^ v) & 0x10) CC |= F_HALFCARRY;
return temp & 0xff;
};
var oSBC = function (b, v) {
var temp = b - v - (CC & F_CARRY);
//temp &= 0xff;
CC &= ~(F_CARRY | F_ZERO | F_OVERFLOW | F_NEGATIVE);
CC |= flagsNZ[temp & 0xff];
if (temp & 0x100) CC |= F_CARRY;
setV8(b, v, temp);
return temp & 0xff;
};
/*
var oSUB = function(b,v) {
var temp = b-v;
//temp &= 0xff;
CC &= ~(F_CARRY | F_ZERO | F_OVERFLOW | F_NEGATIVE);
CC |= flagsNZ[temp & 0xff];
if (temp&0x100) CC|=F_CARRY;
setV8(b,v,temp);
return temp&0xff;
};
*/
var oCMP = function (b, v) {
var temp = b - v;
//temp &= 0xff;
CC &= ~(F_CARRY | F_ZERO | F_OVERFLOW | F_NEGATIVE);
CC |= flagsNZ[temp & 0xff];
if (temp & 0x100) CC |= F_CARRY;
//setV8cmp(b,v,temp);
setV8(b, v, temp);
return;
};
var oCMP16 = function (b, v) {
var temp = b - v;
//temp &= 0xff;
CC &= ~(F_CARRY | F_ZERO | F_OVERFLOW | F_NEGATIVE);
if ((temp & 0xffff) === 0) CC |= F_ZERO;
if (temp & 0x8000) CC |= F_NEGATIVE;
if (temp & 0x10000) CC |= F_CARRY;
setV16(b, v, temp);
return;
};
var oNEG = function (b) {
CC &= ~(F_CARRY | F_ZERO | F_OVERFLOW | F_NEGATIVE);
if (b == 0x80) CC |= F_OVERFLOW;
b = (~b & 0xff) + 1;
if (b === 0) CC |= F_ZERO;
else {
CC |= F_CARRY;
}
if (b & 0x80) {
CC |= F_NEGATIVE;
}
if (b & 0x80) CC |= F_NEGATIVE;
return b;
};
var oLSR = function (b) {
CC &= ~(F_ZERO | F_CARRY | F_NEGATIVE);
if (b & 0x01) CC |= F_CARRY;
b >>= 1;
if (b === 0) CC |= F_ZERO;
return b & 0xff;
};
var oASR = function (b) {
CC &= ~(F_ZERO | F_CARRY | F_NEGATIVE);
if (b & 0x01) CC |= F_CARRY;
b = (b & 0x80) | (b >> 1);
CC |= flagsNZ[b];
return b;
};
var oASL = function (b) {
var temp = b;
CC &= ~(F_ZERO | F_CARRY | F_NEGATIVE | F_OVERFLOW);
if (b & 0x80) CC |= F_CARRY;
b <<= 1;
CC |= flagsNZ[b];
if ((b ^ temp) & 0x80) CC |= F_OVERFLOW;
return b;
};
var oROL = function (b) {
var temp = b;
var oldc = CC & F_CARRY;
CC &= ~(F_ZERO | F_CARRY | F_NEGATIVE | F_OVERFLOW);
if (b & 0x80) CC |= F_CARRY;
b = (b << 1) | oldc;
CC |= flagsNZ[b];
if ((b ^ temp) & 0x80) CC |= F_OVERFLOW;
return b;
};
var oROR = function (b) {
var oldc = CC & F_CARRY;
CC &= ~(F_ZERO | F_CARRY | F_NEGATIVE);
if (b & 0x01) CC |= F_CARRY;
b = (b >> 1) | (oldc << 7);
CC |= flagsNZ[b];
// if ((b ^ temp) & 0x80) CC|=F_OVERFLOW;
return b;
};
var oEOR = function (b, v) {
CC &= ~(F_ZERO | F_NEGATIVE | F_OVERFLOW);
b ^= v;
CC |= flagsNZ[b];
return b;
};
var oOR = function (b, v) {
CC &= ~(F_ZERO | F_NEGATIVE | F_OVERFLOW);
b |= v;
CC |= flagsNZ[b];
return b;
};
var oAND = function (b, v) {
CC &= ~(F_ZERO | F_NEGATIVE | F_OVERFLOW);
b &= v;
CC |= flagsNZ[b];
return b;
};
var oCOM = function (b) {
CC &= ~(F_ZERO | F_NEGATIVE | F_OVERFLOW);
b ^= 0xff;
CC |= flagsNZ[b];
CC |= F_CARRY;
return b;
};
//----common
var dpadd = function () {
//direct page + 8bit index
return DP * 256 + fetch();
};
var step = function () {
var oldT = T;
if (IRQs) {
//;;;
}
var addr = null;
var pb = null;
var oldPC = PC;
var opcode = fetch();
T += cycles[opcode];
switch (opcode) {
case 0x00: //NEG DP
addr = dpadd();
byteTo(addr, oNEG(byteAt(addr)));
break;
case 0x03: //COM DP
addr = dpadd();
byteTo(addr, oCOM(byteAt(addr)));
break;
case 0x04: //LSR DP
addr = dpadd();
byteTo(addr, oLSR(byteAt(addr)));
break;
case 0x06: //ROR DP
addr = dpadd();
byteTo(addr, oROR(byteAt(addr)));
break;
case 0x07: //ASR DP
addr = dpadd();
byteTo(addr, oASR(byteAt(addr)));
break;
case 0x08: //ASL DP
addr = dpadd();
byteTo(addr, oASL(byteAt(addr)));
break;
case 0x09: //ROL DP
addr = dpadd();
byteTo(addr, oROL(byteAt(addr)));
break;
case 0x0a: //DEC DP
addr = dpadd();
byteTo(addr, oDEC(byteAt(addr)));
break;
case 0x0c: //INC DP
addr = dpadd();
byteTo(addr, oINC(byteAt(addr)));
break;
case 0x0d: //TST DP
addr = dpadd();
pb = byteAt(addr);
CC &= ~(F_ZERO | F_NEGATIVE | F_OVERFLOW);
CC |= flagsNZ[pb];
break;
case 0x0e: //JMP DP
addr = dpadd();
PC = addr;
break;
case 0x0f: //CLR DP
addr = dpadd();
byteTo(addr, 0);
CC &= ~(F_CARRY | F_NEGATIVE | F_OVERFLOW);
CC |= F_ZERO;
break;
case 0x12: //NOP
break;
case 0x13: //SYNC
break;
case 0x16: //LBRA relative
addr = signed16(fetch16());
PC += addr;
break;
case 0x17: //LBSR relative
addr = signed16(fetch16());
PUSHW(PC);
PC += addr;
break;
case 0x19: //DAA
var tdaa;
//var precarry = CC & F_CARRY;
var cf = 0;
var nhi = rA & 0xf0,
nlo = rA & 0x0f;
if (nlo > 0x09 || CC & 0x20) cf |= 0x06;
if (nhi > 0x80 && nlo > 0x09) cf |= 0x60;
if (nhi > 0x90 || CC & 0x01) cf |= 0x60;
tdaa = cf + rA;
CC &= ~(F_NEGATIVE | F_ZERO | F_OVERFLOW);
if (tdaa & 0x100) CC |= F_CARRY;
rA = tdaa & 0xff;
CC |= flagsNZ[rA];
//console.log(precarry, CC & F_CARRY);
break;
case 0x1a: //ORCC
CC |= fetch();
break;
case 0x1c: //ANDCC
CC &= fetch();
break;
case 0x1d: //SEX
rA = rB & 0x80 ? 0xff : 0;
flagsNZ16(getD());
CC &= ~F_OVERFLOW;
break;
case 0x1e: //EXG
pb = fetch();
TFREXG(pb, true);
break;
case 0x1f: //EXG
pb = fetch();
TFREXG(pb, false);
break;
case 0x20: //BRA
addr = signed(fetch());
PC += addr;
break;
case 0x21: //BRN
addr = signed(fetch());
break;
case 0x22: //BHI
addr = signed(fetch());
if (!(CC & (F_CARRY | F_ZERO))) PC += addr;
break;
case 0x23: //BLS
addr = signed(fetch());
if (CC & (F_CARRY | F_ZERO)) PC += addr;
break;
case 0x24: //BCC
addr = signed(fetch());
if (!(CC & F_CARRY)) PC += addr;
break;
case 0x25: //BCS
addr = signed(fetch());
if (CC & F_CARRY) PC += addr;
break;
case 0x26: //BNE
addr = signed(fetch());
if (!(CC & F_ZERO)) PC += addr;
break;
case 0x27: //BEQ
addr = signed(fetch());
if (CC & F_ZERO) PC += addr;
break;
case 0x28: //BVC
addr = signed(fetch());
if (!(CC & F_OVERFLOW)) PC += addr;
break;
case 0x29: //BVS
addr = signed(fetch());
if (CC & F_OVERFLOW) PC += addr;
break;
case 0x2a: //BPL
addr = signed(fetch());
if (!(CC & F_NEGATIVE)) PC += addr;
break;
case 0x2b: //BMI
addr = signed(fetch());
if (CC & F_NEGATIVE) PC += addr;
break;
case 0x2c: //BGE
addr = signed(fetch());
if (!((CC & F_NEGATIVE) ^ ((CC & F_OVERFLOW) << 2))) PC += addr;
break;
case 0x2d: //BLT
addr = signed(fetch());
if ((CC & F_NEGATIVE) ^ ((CC & F_OVERFLOW) << 2)) PC += addr;
break;
case 0x2e: //BGT
addr = signed(fetch());
//if (!((CC&F_NEGATIVE) ^ ((CC&F_OVERFLOW)<<2) || (CC&F_ZERO))) PC += addr;
if (!((CC & F_NEGATIVE) ^ ((CC & F_OVERFLOW) << 2) || CC & F_ZERO))
PC += addr;
break;
case 0x2f: //BLE
addr = signed(fetch());
if ((CC & F_NEGATIVE) ^ ((CC & F_OVERFLOW) << 2) || CC & F_ZERO)
PC += addr;
break;
case 0x30: //LEAX
rX = PostByte();
if (rX === 0) CC |= F_ZERO;
else CC &= ~F_ZERO;
break;
case 0x31: //LEAY
rY = PostByte();
if (rY === 0) CC |= F_ZERO;
else CC &= ~F_ZERO;
break;
case 0x32: //LEAS
rS = PostByte();
break;
case 0x33: //LEAU
rU = PostByte();
break;
case 0x34: //PSHS
PSHS(fetch());
break;
case 0x35: //PULS
PULS(fetch());
break;
case 0x36: //PSHU
PSHU(fetch());
break;
case 0x37: //PULU
PULU(fetch());
break;
case 0x39: //RTS
PC = PULLW();
break;
case 0x3a: //ABX
rX += rB;
break;
case 0x3b: //RTI
CC = PULLB();
if (CC & F_ENTIRE) {
T += 9;
rA = PULLB();
rB = PULLB();
DP = PULLB();
rX = PULLW();
rY = PULLW();
rU = PULLW();
}
PC = PULLW();
break;
case 0x3c: //CWAI **todo
CC &= fetch();
break;
case 0x3d: //MUL
addr = rA * rB;
if (addr === 0) CC |= F_ZERO;
else CC &= ~F_ZERO;
if (addr & 0x80) CC |= F_CARRY;
else CC &= ~F_CARRY;
setD(addr);
break;
case 0x3f: //SWI
CC |= F_ENTIRE;
PUSHW(PC);
PUSHW(rU);
PUSHW(rY);
PUSHW(rX);
PUSHB(DP);
PUSHB(rB);
PUSHB(rA);
PUSHB(CC);
CC |= F_IRQMASK | F_FIRQMASK;
PC = ReadWord(vecSWI);
break;
case 0x40:
rA = oNEG(rA);
break;
case 0x43:
rA = oCOM(rA);
break;
case 0x44:
rA = oLSR(rA);
break;
case 0x46:
rA = oROR(rA);
break;
case 0x47:
rA = oASR(rA);
break;
case 0x48:
rA = oASL(rA);
break;
case 0x49:
rA = oROL(rA);
break;
case 0x4a:
rA = oDEC(rA);
break;
case 0x4c:
rA = oINC(rA);
break;
case 0x4d:
CC &= ~(F_ZERO | F_NEGATIVE | F_OVERFLOW);
CC |= flagsNZ[rA];
break;
case 0x4f:
rA = 0;
CC &= ~(F_NEGATIVE | F_OVERFLOW | F_CARRY);
CC |= F_ZERO;
break;
case 0x50:
rB = oNEG(rB);
break;
case 0x53:
rB = oCOM(rB);
break;
case 0x54:
rB = oLSR(rB);
break;
case 0x56:
rB = oROR(rB);
break;
case 0x57:
rB = oASR(rB);
break;
case 0x58:
rB = oASL(rB);
break;
case 0x59:
rB = oROL(rB);
break;
case 0x5a:
rB = oDEC(rB);
break;
case 0x5c:
rB = oINC(rB);
break;
case 0x5d:
CC &= ~(F_ZERO | F_NEGATIVE | F_OVERFLOW);
CC |= flagsNZ[rB];
break;
case 0x5f:
rB = 0;
CC &= ~(F_NEGATIVE | F_OVERFLOW | F_CARRY);
CC |= F_ZERO;
break;
case 0x60: //NEG indexed
addr = PostByte();
byteTo(addr, oNEG(byteAt(addr)));
break;
case 0x63: //COM indexed
addr = PostByte();
byteTo(addr, oCOM(byteAt(addr)));
break;
case 0x64: //LSR indexed
addr = PostByte();
byteTo(addr, oLSR(byteAt(addr)));
break;
case 0x66: //ROR indexed
addr = PostByte();
byteTo(addr, oROR(byteAt(addr)));
break;
case 0x67: //ASR indexed
addr = PostByte();
byteTo(addr, oASR(byteAt(addr)));
break;
case 0x68: //ASL indexed
addr = PostByte();
byteTo(addr, oASL(byteAt(addr)));
break;
case 0x69: //ROL indexed
addr = PostByte();
byteTo(addr, oROL(byteAt(addr)));
break;
case 0x6a: //DEC indexed
addr = PostByte();
byteTo(addr, oDEC(byteAt(addr)));
break;
case 0x6c: //INC indexed
addr = PostByte();
byteTo(addr, oINC(byteAt(addr)));
break;
case 0x6d: //TST indexed
addr = PostByte();
pb = byteAt(addr);
CC &= ~(F_ZERO | F_NEGATIVE | F_OVERFLOW);
CC |= flagsNZ[pb];
break;
case 0x6e: //JMP indexed
addr = PostByte();
PC = addr;
break;
case 0x6f: //CLR indexed
addr = PostByte();
byteTo(addr, 0);
CC &= ~(F_CARRY | F_NEGATIVE | F_OVERFLOW);
CC |= F_ZERO;
break;
case 0x70: //NEG extended
addr = fetch16();
byteTo(addr, oNEG(byteAt(addr)));
break;
case 0x73: //COM extended
addr = fetch16();
byteTo(addr, oCOM(byteAt(addr)));
break;
case 0x74: //LSR extended
addr = fetch16();
byteTo(addr, oLSR(byteAt(addr)));
break;
case 0x76: //ROR extended
addr = fetch16();
byteTo(addr, oROR(byteAt(addr)));
break;
case 0x77: //ASR extended
addr = fetch16();
byteTo(addr, oASR(byteAt(addr)));
break;
case 0x78: //ASL extended
addr = fetch16();
byteTo(addr, oASL(byteAt(addr)));
break;
case 0x79: //ROL extended
addr = fetch16();
byteTo(addr, oROL(byteAt(addr)));
break;
case 0x7a: //DEC extended
addr = fetch16();
byteTo(addr, oDEC(byteAt(addr)));
break;
case 0x7c: //INC extended
addr = fetch16();
byteTo(addr, oINC(byteAt(addr)));
break;
case 0x7d: //TST extended
addr = fetch16();
pb = byteAt(addr);
CC &= ~(F_ZERO | F_NEGATIVE | F_OVERFLOW);
CC |= flagsNZ[pb];
break;
case 0x7e: //JMP extended
addr = fetch16();
PC = addr;
break;
case 0x7f: //CLR extended
addr = fetch16();
byteTo(addr, 0);
CC &= ~(F_CARRY | F_NEGATIVE | F_OVERFLOW);
CC |= F_ZERO;
break;
// regs A,X
case 0x80: //SUBA imm
rA = oSUB(rA, fetch());
break;
case 0x81: //CMPA imm
oCMP(rA, fetch());
break;
case 0x82: //SBCA imm
rA = oSBC(rA, fetch());
break;
case 0x83: //SUBD imm
setD(oSUB16(getD(), fetch16()));
break;
case 0x84: //ANDA imm
rA = oAND(rA, fetch());
break;
case 0x85: //BITA imm
oAND(rA, fetch());
break;
case 0x86: //LDA imm
rA = fetch();
CC &= ~(F_ZERO | F_NEGATIVE | F_OVERFLOW);
CC |= flagsNZ[rA];
break;
case 0x88: //EORA imm
rA = oEOR(rA, fetch());
break;
case 0x89: //ADCA imm
rA = oADC(rA, fetch());
break;
case 0x8a: //ORA imm
rA = oOR(rA, fetch());
break;
case 0x8b: //ADDA imm
rA = oADD(rA, fetch());
break;
case 0x8c: //CMPX imm
oCMP16(rX, fetch16());
break;
case 0x8d: //JSR imm
addr = signed(fetch());
PUSHW(PC);
PC += addr;
break;
case 0x8e: //LDX imm
rX = fetch16();
flagsNZ16(rX);
CC &= ~F_OVERFLOW;
break;
case 0x90: //SUBA direct
addr = dpadd();
rA = oSUB(rA, byteAt(addr));
break;
case 0x91: //CMPA direct
addr = dpadd();
oCMP(rA, byteAt(addr));
break;
case 0x92: //SBCA direct
addr = dpadd();
rA = oSBC(rA, byteAt(addr));
break;
case 0x93: //SUBD direct
addr = dpadd();
setD(oSUB16(getD(), ReadWord(addr)));
break;
case 0x94: //ANDA direct
addr = dpadd();
rA = oAND(rA, byteAt(addr));
break;
case 0x95: //BITA direct
addr = dpadd();
oAND(rA, byteAt(addr));
break;
case 0x96: //LDA direct
addr = dpadd();
rA = byteAt(addr);
CC &= ~(F_ZERO | F_NEGATIVE | F_OVERFLOW);
CC |= flagsNZ[rA];
break;
case 0x97: //STA direct
addr = dpadd();
byteTo(addr, rA);
CC &= ~(F_ZERO | F_NEGATIVE | F_OVERFLOW);
CC |= flagsNZ[rA];
break;
case 0x98: //EORA direct
addr = dpadd();
rA = oEOR(rA, byteAt(addr));
break;
case 0x99: //ADCA direct
addr = dpadd();
rA = oADC(rA, byteAt(addr));
break;
case 0x9a: //ORA direct
addr = dpadd();
rA = oOR(rA, byteAt(addr));
break;
case 0x9b: //ADDA direct
addr = dpadd();
rA = oADD(rA, byteAt(addr));
break;
case 0x9c: //CMPX direct
addr = dpadd();
oCMP16(rX, ReadWord(addr));
break;
case 0x9d: //JSR direct
addr = dpadd();
PUSHW(PC);
PC = addr;
break;
case 0x9e: //LDX direct
addr = dpadd();
rX = ReadWord(addr);
flagsNZ16(rX);
CC &= ~F_OVERFLOW;
break;
case 0x9f: //STX direct
addr = dpadd();
WriteWord(addr, rX);
flagsNZ16(rX);
CC &= ~F_OVERFLOW;
break;
case 0xa0: //SUBA indexed
addr = PostByte();
rA = oSUB(rA, byteAt(addr));
break;
case 0xa1: //CMPA indexed
addr = PostByte();
oCMP(rA, byteAt(addr));
break;
case 0xa2: //SBCA indexed
addr = PostByte();
rA = oSBC(rA, byteAt(addr));
break;
case 0xa3: //SUBD indexed
addr = PostByte();
setD(oSUB16(getD(), ReadWord(addr)));
break;
case 0xa4: //ANDA indexed
addr = PostByte();
rA = oAND(rA, byteAt(addr));
break;
case 0xa5: //BITA indexed
addr = PostByte();
oAND(rA, byteAt(addr));
break;
case 0xa6: //LDA indexed
addr = PostByte();
rA = byteAt(addr);
CC &= ~(F_ZERO | F_NEGATIVE | F_OVERFLOW);
CC |= flagsNZ[rA];
break;
case 0xa7: //STA indexed
addr = PostByte();
byteTo(addr, rA);
CC &= ~(F_ZERO | F_NEGATIVE | F_OVERFLOW);
CC |= flagsNZ[rA];
break;
case 0xa8: //EORA indexed
addr = PostByte();
rA = oEOR(rA, byteAt(addr));
break;
case 0xa9: //ADCA indexed
addr = PostByte();
rA = oADC(rA, byteAt(addr));
break;
case 0xaa: //ORA indexed
addr = PostByte();
rA = oOR(rA, byteAt(addr));
break;
case 0xab: //ADDA indexed
addr = PostByte();
rA = oADD(rA, byteAt(addr));
break;
case 0xac: //CMPX indexed
addr = PostByte();
oCMP16(rX, ReadWord(addr));
break;
case 0xad: //JSR indexed
addr = PostByte();
PUSHW(PC);
PC = addr;
break;
case 0xae: //LDX indexed
addr = PostByte();
rX = ReadWord(addr);
flagsNZ16(rX);
CC &= ~F_OVERFLOW;
break;
case 0xaf: //STX indexed
addr = PostByte();
WriteWord(addr, rX);
flagsNZ16(rX);
CC &= ~F_OVERFLOW;
break;
case 0xb0: //SUBA extended
addr = fetch16();
rA = oSUB(rA, byteAt(addr));
break;
case 0xb1: //CMPA extended
addr = fetch16();
oCMP(rA, byteAt(addr));
break;
case 0xb2: //SBCA extended
addr = fetch16();
rA = oSBC(rA, byteAt(addr));
break;
case 0xb3: //SUBD extended
addr = fetch16();
setD(oSUB16(getD(), ReadWord(addr)));
break;
case 0xb4: //ANDA extended
addr = fetch16();
rA = oAND(rA, byteAt(addr));
break;
case 0xb5: //BITA extended
addr = fetch16();
oAND(rA, byteAt(addr));
break;
case 0xb6: //LDA extended
addr = fetch16();
rA = byteAt(addr);
CC &= ~(F_ZERO | F_NEGATIVE | F_OVERFLOW);
CC |= flagsNZ[rA];
break;
case 0xb7: //STA extended
addr = fetch16();
byteTo(addr, rA);
CC &= ~(F_ZERO | F_NEGATIVE | F_OVERFLOW);
CC |= flagsNZ[rA];
break;
case 0xb8: //EORA extended
addr = fetch16();
rA = oEOR(rA, byteAt(addr));
break;
case 0xb9: //ADCA extended
addr = fetch16();
rA = oADC(rA, byteAt(addr));
break;
case 0xba: //ORA extended
addr = fetch16();
rA = oOR(rA, byteAt(addr));
break;
case 0xbb: //ADDA extended
addr = fetch16();
rA = oADD(rA, byteAt(addr));
break;
case 0xbc: //CMPX extended
addr = fetch16();
oCMP16(rX, ReadWord(addr));
break;
case 0xbd: //JSR extended
addr = fetch16();
PUSHW(PC);
PC = addr;
break;
case 0xbe: //LDX extended
addr = fetch16();
rX = ReadWord(addr);
flagsNZ16(rX);
CC &= ~F_OVERFLOW;
break;
case 0xbf: //STX extended
addr = fetch16();
WriteWord(addr, rX);
flagsNZ16(rX);
CC &= ~F_OVERFLOW;
break;
//Regs B, Y
case 0xc0: //SUBB imm
rB = oSUB(rB, fetch());
break;
case 0xc1: //CMPB imm
oCMP(rB, fetch());
break;
case 0xc2: //SBCB imm
rB = oSBC(rB, fetch());
break;
case 0xc3: //ADDD imm
setD(oADD16(getD(), fetch16()));
break;
case 0xc4: //ANDB imm
rB = oAND(rB, fetch());
break;
case 0xc5: //BITB imm
oAND(rB, fetch());
break;
case 0xc6: //LDB imm
rB = fetch();
CC &= ~(F_ZERO | F_NEGATIVE | F_OVERFLOW);
CC |= flagsNZ[rB];
break;
case 0xc8: //EORB imm
rB = oEOR(rB, fetch());
break;
case 0xc9: //ADCB imm
rB = oADC(rB, fetch());
break;
case 0xca: //ORB imm
rB = oOR(rB, fetch());
break;
case 0xcb: //ADDB imm
rB = oADD(rB, fetch());
break;
case 0xcc: //LDD imm
addr = fetch16();
setD(addr);
flagsNZ16(addr);
CC &= ~F_OVERFLOW;
break;
case 0xce: //LDU imm
rU = fetch16();
flagsNZ16(rU);
CC &= ~F_OVERFLOW;
break;
case 0xd0: //SUBB direct
addr = dpadd();
rB = oSUB(rB, byteAt(addr));
break;
case 0xd1: //CMPB direct
addr = dpadd();
oCMP(rB, byteAt(addr));
break;
case 0xd2: //SBCB direct
addr = dpadd();
rB = oSBC(rB, byteAt(addr));
break;
case 0xd3: //ADDD direct
addr = dpadd();
setD(oADD16(getD(), ReadWord(addr)));
break;
case 0xd4: //ANDB direct
addr = dpadd();
rB = oAND(rB, byteAt(addr));
break;
case 0xd5: //BITB direct
addr = dpadd();
oAND(rB, byteAt(addr));
break;
case 0xd6: //LDB direct
addr = dpadd();
rB = byteAt(addr);
CC &= ~(F_ZERO | F_NEGATIVE | F_OVERFLOW);
CC |= flagsNZ[rB];
break;
case 0xd7: //STB direct
addr = dpadd();
byteTo(addr, rB);
CC &= ~(F_ZERO | F_NEGATIVE | F_OVERFLOW);
CC |= flagsNZ[rB];
break;
case 0xd8: //EORB direct
addr = dpadd();
rB = oEOR(rB, byteAt(addr));
break;
case 0xd9: //ADCB direct
addr = dpadd();
rB = oADC(rB, byteAt(addr));
break;
case 0xda: //ORB direct
addr = dpadd();
rB = oOR(rB, byteAt(addr));
break;
case 0xdb: //ADDB direct
addr = dpadd();
rB = oADD(rB, byteAt(addr));
break;
case 0xdc: //LDD direct
addr = dpadd();
pb = ReadWord(addr);
setD(pb);
flagsNZ16(pb);
CC &= ~F_OVERFLOW;
break;
case 0xdd: //STD direct
addr = dpadd();
WriteWord(addr, getD());
CC &= ~F_OVERFLOW;
break;
case 0xde: //LDU direct
addr = dpadd();
rU = ReadWord(addr);
flagsNZ16(rX);
CC &= ~F_OVERFLOW;
break;
case 0xdf: //STU direct
addr = dpadd();
WriteWord(addr, rU);
flagsNZ16(rU);
CC &= ~F_OVERFLOW;
break;
case 0xe0: //SUBB indexed
addr = PostByte();
rB = oSUB(rB, byteAt(addr));
break;
case 0xe1: //CMPB indexed
addr = PostByte();
oCMP(rB, byteAt(addr));
break;
case 0xe2: //SBCB indexed
addr = PostByte();
rB = oSBC(rB, byteAt(addr));
break;
case 0xe3: //ADDD indexed
addr = PostByte();
setD(oADD16(getD(), ReadWord(addr)));
break;
case 0xe4: //ANDB indexed
addr = PostByte();
rB = oAND(rB, byteAt(addr));
break;
case 0xe5: //BITB indexed
addr = PostByte();
oAND(rB, byteAt(addr));
break;
case 0xe6: //LDB indexed
addr = PostByte();
rB = byteAt(addr);
CC &= ~(F_ZERO | F_NEGATIVE | F_OVERFLOW);
CC |= flagsNZ[rB];
break;
case 0xe7: //STB indexed
addr = PostByte();
byteTo(addr, rB);
CC &= ~(F_ZERO | F_NEGATIVE | F_OVERFLOW);
CC |= flagsNZ[rB];
break;
case 0xe8: //EORB indexed
addr = PostByte();
rB = oEOR(rB, byteAt(addr));
break;
case 0xe9: //ADCB indexed
addr = PostByte();
rB = oADC(rB, byteAt(addr));
break;
case 0xea: //ORB indexed
addr = PostByte();
rB = oOR(rB, byteAt(addr));
break;
case 0xeb: //ADDB indexed
addr = PostByte();
rB = oADD(rB, byteAt(addr));
break;
case 0xec: //LDD indexed
addr = PostByte();
pb = ReadWord(addr);
setD(pb);
flagsNZ16(pb);
CC &= ~F_OVERFLOW;
break;
case 0xed: //STD indexed
addr = PostByte();
WriteWord(addr, getD());
CC &= ~F_OVERFLOW;
break;
case 0xee: //LDU indexed
addr = PostByte();
rU = ReadWord(addr);
flagsNZ16(rU);
CC &= ~F_OVERFLOW;
break;
case 0xef: //STU indexed
addr = PostByte();
WriteWord(addr, rU);
flagsNZ16(rU);
CC &= ~F_OVERFLOW;
break;
case 0xf0: //SUBB extended
addr = fetch16();
rB = oSUB(rB, byteAt(addr));
break;
case 0xf1: //CMPB extended
addr = fetch16();
oCMP(rB, byteAt(addr));
break;
case 0xf2: //SBCB extended
addr = fetch16();
rB = oSBC(rB, byteAt(addr));
break;
case 0xf3: //ADDD extended
addr = fetch16();
setD(oADD16(getD(), ReadWord(addr)));
break;
case 0xf4: //ANDB extended
addr = fetch16();
rB = oAND(rB, byteAt(addr));
break;
case 0xf5: //BITB extended
addr = fetch16();
oAND(rB, byteAt(addr));
break;
case 0xf6: //LDB extended
addr = fetch16();
rB = byteAt(addr);
CC &= ~(F_ZERO | F_NEGATIVE | F_OVERFLOW);
CC |= flagsNZ[rB];
break;
case 0xf7: //STB extended
addr = fetch16();
byteTo(addr, rB);
CC &= ~(F_ZERO | F_NEGATIVE | F_OVERFLOW);
CC |= flagsNZ[rB];
break;
case 0xf8: //EORB extended
addr = fetch16();
rB = oEOR(rB, byteAt(addr));
break;
case 0xf9: //ADCB extended
addr = fetch16();
rB = oADC(rB, byteAt(addr));
break;
case 0xfa: //ORB extended
addr = fetch16();
rB = oOR(rB, byteAt(addr));
break;
case 0xfb: //ADDB extended
addr = fetch16();
rB = oADD(rB, byteAt(addr));
break;
case 0xfc: //LDD extended
addr = fetch16();
pb = ReadWord(addr);
setD(pb);
flagsNZ16(pb);
CC &= ~F_OVERFLOW;
break;
case 0xfd: //STD extended
addr = fetch16();
WriteWord(addr, getD());
CC &= ~F_OVERFLOW;
break;
case 0xfe: //LDU extended
addr = fetch16();
rU = ReadWord(addr);
flagsNZ16(rU);
CC &= ~F_OVERFLOW;
break;
case 0xff: //STU extended
addr = fetch16();
WriteWord(addr, rU);
flagsNZ16(rU);
CC &= ~F_OVERFLOW;
break;
// page 1
case 0x10: //page 1
{
opcode = fetch();
T += cycles2[opcode];
switch (opcode) {
case 0x21: //BRN
addr = signed16(fetch16());
break;
case 0x22: //BHI
addr = signed16(fetch16());
if (!(CC & (F_CARRY | F_ZERO))) PC += addr;
break;
case 0x23: //BLS
addr = signed16(fetch16());
if (CC & (F_CARRY | F_ZERO)) PC += addr;
break;
case 0x24: //BCC
addr = signed16(fetch16());
if (!(CC & F_CARRY)) PC += addr;
break;
case 0x25: //BCS
addr = signed16(fetch16());
if (CC & F_CARRY) PC += addr;
break;
case 0x26: //BNE
addr = signed16(fetch16());
if (!(CC & F_ZERO)) PC += addr;
break;
case 0x27: //BEQ
addr = signed16(fetch16());
if (CC & F_ZERO) PC += addr;
break;
case 0x28: //BVC
addr = signed16(fetch16());
if (!(CC & F_OVERFLOW)) PC += addr;
break;
case 0x29: //BVS
addr = signed16(fetch16());
if (CC & F_OVERFLOW) PC += addr;
break;
case 0x2a: //BPL
addr = signed16(fetch16());
if (!(CC & F_NEGATIVE)) PC += addr;
break;
case 0x2b: //BMI
addr = signed16(fetch16());
if (CC & F_NEGATIVE) PC += addr;
break;
case 0x2c: //BGE
addr = signed16(fetch16());
if (!((CC & F_NEGATIVE) ^ ((CC & F_OVERFLOW) << 2))) PC += addr;
break;
case 0x2d: //BLT
addr = signed16(fetch16());
if ((CC & F_NEGATIVE) ^ ((CC & F_OVERFLOW) << 2)) PC += addr;
break;
case 0x2e: //BGT
addr = signed16(fetch16());
//if (!((CC&F_NEGATIVE) ^ ((CC&F_OVERFLOW)<<2) || (CC&F_ZERO))) PC += addr;
if (
!((CC & F_NEGATIVE) ^ ((CC & F_OVERFLOW) << 2) && CC & F_ZERO)
)
PC += addr;
break;
case 0x2f: //BLE
addr = signed16(fetch16());
if ((CC & F_NEGATIVE) ^ ((CC & F_OVERFLOW) << 2) || CC & F_ZERO)
PC += addr;
break;
case 0x3f: //SWI2
CC |= F_ENTIRE;
PUSHW(PC);
PUSHW(rU);
PUSHW(rY);
PUSHW(rX);
PUSHB(DP);
PUSHB(rB);
PUSHB(rA);
PUSHB(CC);
CC |= F_IRQMASK | F_FIRQMASK;
PC = ReadWord(vecSWI2);
break;
case 0x83: //CMPD imm
oCMP16(getD(), fetch16());
break;
case 0x8c: //CMPY imm
oCMP16(rY, fetch16());
break;
case 0x8e: //LDY imm
rY = fetch16();
flagsNZ16(rY);
CC &= ~F_OVERFLOW;
break;
case 0x93: //CMPD direct
addr = dpadd();
oCMP16(getD(), ReadWord(addr));
break;
case 0x9c: //CMPY direct
addr = dpadd();
oCMP16(rY, ReadWord(addr));
break;
case 0x9e: //LDY direct
addr = dpadd();
rY = ReadWord(addr);
flagsNZ16(rY);
CC &= ~F_OVERFLOW;
break;
case 0x9f: //STY direct
addr = dpadd();
WriteWord(addr, rY);
flagsNZ16(rY);
CC &= ~F_OVERFLOW;
break;
case 0xa3: //CMPD indexed
addr = PostByte();
oCMP16(getD(), ReadWord(addr));
break;
case 0xac: //CMPY indexed
addr = PostByte();
oCMP16(rY, ReadWord(addr));
break;
case 0xae: //LDY indexed
addr = PostByte();
rY = ReadWord(addr);
flagsNZ16(rY);
CC &= ~F_OVERFLOW;
break;
case 0xaf: //STY indexed
addr = PostByte();
WriteWord(addr, rY);
flagsNZ16(rY);
CC &= ~F_OVERFLOW;
break;
case 0xb3: //CMPD extended
addr = fetch16();
oCMP16(getD(), ReadWord(addr));
break;
case 0xbc: //CMPY extended
addr = fetch16();
oCMP16(rY, ReadWord(addr));
break;
case 0xbe: //LDY extended
addr = fetch16();
rY = ReadWord(addr);
flagsNZ16(rY);
CC &= ~F_OVERFLOW;
break;
case 0xbf: //STY extended
addr = fetch16();
WriteWord(addr, rY);
flagsNZ16(rY);
CC &= ~F_OVERFLOW;
break;
case 0xce: //LDS imm
rS = fetch16();
flagsNZ16(rS);
CC &= ~F_OVERFLOW;
break;
case 0xde: //LDS direct
addr = dpadd();
rS = ReadWord(addr);
flagsNZ16(rS);
CC &= ~F_OVERFLOW;
break;
case 0xdf: //STS direct
addr = dpadd();
WriteWord(addr, rS);
flagsNZ16(rS);
CC &= ~F_OVERFLOW;
break;
case 0xee: //LDS indexed
addr = PostByte();
rS = ReadWord(addr);
flagsNZ16(rS);
CC &= ~F_OVERFLOW;
break;
case 0xef: //STS indexed
addr = PostByte();
WriteWord(addr, rS);
flagsNZ16(rS);
CC &= ~F_OVERFLOW;
break;
case 0xfe: //LDS extended
addr = fetch16();
rS = ReadWord(addr);
flagsNZ16(rS);
CC &= ~F_OVERFLOW;
break;
case 0xff: //STS extended
addr = fetch16();
WriteWord(addr, rS);
flagsNZ16(rS);
CC &= ~F_OVERFLOW;
break;
}
}
break;
// page 2
case 0x11: //page 2
{
opcode = fetch();
T += cycles2[opcode];
switch (opcode) {
case 0x3f: //SWI3
CC |= F_ENTIRE;
PUSHW(PC);
PUSHW(rU);
PUSHW(rY);
PUSHW(rX);
PUSHB(DP);
PUSHB(rB);
PUSHB(rA);
PUSHB(CC);
CC |= F_IRQMASK | F_FIRQMASK;
PC = ReadWord(vecSWI3);
break;
case 0x83: //CMPU imm
oCMP16(rU, fetch16());
break;
case 0x8c: //CMPS imm
oCMP16(rS, fetch16());
break;
case 0x93: //CMPU imm
addr = dpadd();
oCMP16(rU, ReadWord(addr));
break;
case 0x9c: //CMPS imm
addr = dpadd();
oCMP16(rS, ReadWord(addr));
break;
case 0xa3: //CMPU imm
addr = PostByte();
oCMP16(rU, ReadWord(addr));
break;
case 0xac: //CMPS imm
addr = PostByte();
oCMP16(rS, ReadWord(addr));
break;
case 0xb3: //CMPU imm
addr = fetch16();
oCMP16(rU, ReadWord(addr));
break;
case 0xbc: //CMPS imm
addr = fetch16();
oCMP16(rS, ReadWord(addr));
break;
}
}
break;
}
rA &= 0xff;
rB &= 0xff;
CC &= 0xff;
DP &= 0xff;
rX &= 0xffff;
rY &= 0xffff;
rU &= 0xffff;
rS &= 0xffff;
PC &= 0xffff;
return T - oldT;
};
var reset = function () {
rA = rA | 0x00;
rB = rB | 0x00;
rX = rX | 0x00;
rY = rY | 0x00;
rU = rU | 0x00;
rS = rS | 0x00;
PC = ReadWord(vecRESET);
DP = 0;
CC |= F_FIRQMASK | F_IRQMASK;
T = 0;
};
//---------- Disassembler
/*
ILLEGAL 0
DIRECT 1
INHERENT 2
BRANCH_REL_16 3
IMMEDIAT_8 4
BRANCH_REL_8 5
INDEXED 6
EXTENDED 7
IMMEDIAT_16 8
PSHS 10
PSHU 11
EXG, TFR 20
*/
var ds = [
[2, 1, "NEG"],
[1, 0, "???"],
[1, 0, "???"],
[2, 1, "COM"],
[2, 1, "LSR"],
[1, 0, "???"],
[2, 1, "ROR"],
[2, 1, "ASR"],
[2, 1, "LSL"],
[2, 1, "ROL"],
[2, 1, "DEC"],
[1, 0, "???"],
[2, 1, "INC"],
[2, 1, "TST"],
[2, 1, "JMP"],
[2, 1, "CLR"],
[1, 0, "Prefix"],
[1, 0, "Prefix"],
[1, 2, "NOP"],
[1, 2, "SYNC"],
[1, 0, "???"],
[1, 0, "???"],
[3, 3, "LBRA"],
[3, 3, "LBSR"],
[1, 0, "???"],
[1, 2, "DAA"],
[2, 4, "ORCC"],
[1, 0, "???"],
[2, 4, "ANDCC"],
[1, 2, "SEX"],
[2, 20, "EXG"],
[2, 20, "TFR"],
[2, 5, "BRA"],
[2, 5, "BRN"],
[2, 5, "BHI"],
[2, 5, "BLS"],
[2, 5, "BCC"],
[2, 5, "BCS"],
[2, 5, "BNE"],
[2, 5, "BEQ"],
[2, 5, "BVC"],
[2, 5, "BVS"],
[2, 5, "BPL"],
[2, 5, "BMI"],
[2, 5, "BGE"],
[2, 5, "BLT"],
[2, 5, "BGT"],
[2, 5, "BLE"],
[2, 6, "LEAX"],
[2, 6, "LEAY"],
[2, 6, "LEAS"],
[2, 6, "LEAU"],
[2, 10, "PSHS"],
[2, 10, "PULS"],
[2, 11, "PSHU"],
[2, 11, "PULU"],
[1, 0, "???"],
[1, 2, "RTS"],
[1, 2, "ABX"],
[1, 2, "RTI"],
[2, 2, "CWAI"],
[1, 2, "MUL"],
[1, 2, "RESET"],
[1, 2, "SWI1"],
[1, 2, "NEGA"],
[1, 0, "???"],
[1, 0, "???"],
[1, 2, "COMA"],
[1, 2, "LSRA"],
[1, 0, "???"],
[1, 2, "RORA"],
[1, 2, "ASRA"],
[1, 2, "ASLA"],
[1, 2, "ROLA"],
[1, 2, "DECA"],
[1, 0, "???"],
[1, 2, "INCA"],
[1, 2, "TSTA"],
[1, 0, "???"],
[1, 2, "CLRA"],
[1, 2, "NEGB"],
[1, 0, "???"],
[1, 0, "???"],
[1, 2, "COMB"],
[1, 2, "LSRB"],
[1, 0, "???"],
[1, 2, "RORB"],
[1, 2, "ASRB"],
[1, 2, "ASLB"],
[1, 2, "ROLB"],
[1, 2, "DECB"],
[1, 0, "???"],
[1, 2, "INCB"],
[1, 2, "TSTB"],
[1, 0, "???"],
[1, 2, "CLRB"],
[2, 6, "NEG"],
[1, 0, "???"],
[1, 0, "???"],
[2, 6, "COM"],
[2, 6, "LSR"],
[1, 0, "???"],
[2, 6, "ROR"],
[2, 6, "ASR"],
[2, 6, "LSL"],
[2, 6, "ROL"],
[2, 6, "DEC"],
[1, 0, "???"],
[2, 6, "INC"],
[2, 6, "TST"],
[2, 6, "JMP"],
[2, 6, "CLR"],
[3, 7, "NEG"],
[1, 0, "???"],
[1, 0, "???"],
[3, 7, "COM"],
[3, 7, "LSR"],
[1, 0, "???"],
[3, 7, "ROR"],
[3, 7, "ASR"],
[3, 7, "LSL"],
[3, 7, "ROL"],
[3, 7, "DEC"],
[1, 0, "???"],
[3, 7, "INC"],
[3, 7, "TST"],
[3, 7, "JMP"],
[3, 7, "CLR"],
[2, 4, "SUBA"],
[2, 4, "CMPA"],
[2, 4, "SBCA"],
[3, 8, "SUBD"],
[2, 4, "ANDA"],
[2, 4, "BITA"],
[2, 4, "LDA"],
[1, 0, "???"],
[2, 4, "EORA"],
[2, 4, "ADCA"],
[2, 4, "ORA"],
[2, 4, "ADDA"],
[3, 8, "CMPX"],
[2, 5, "BSR"],
[3, 8, "LDX"],
[1, 0, "???"],
[2, 1, "SUBA"],
[2, 1, "CMPA"],
[2, 1, "SBCA"],
[2, 1, "SUBd"],
[2, 1, "ANDA"],
[2, 1, "BITA"],
[2, 1, "LDA"],
[2, 1, "STA"],
[2, 1, "EORA"],
[2, 1, "ADCA"],
[2, 1, "ORA"],
[2, 1, "ADDA"],
[2, 1, "CMPX"],
[2, 1, "JSR"],
[2, 1, "LDX"],
[2, 1, "STX"],
[2, 6, "SUBA"],
[2, 6, "CMPA"],
[2, 6, "SBCA"],
[2, 6, "SUBD"],
[2, 6, "ANDA"],
[2, 6, "BITA"],
[2, 6, "LDA"],
[2, 6, "STA"],
[2, 6, "EORA"],
[2, 6, "ADCA"],
[2, 6, "ORA"],
[2, 6, "ADDA"],
[2, 6, "CMPX"],
[2, 6, "JSR"],
[2, 6, "LDX"],
[2, 6, "STX"],
[3, 7, "SUBA"],
[3, 7, "CMPA"],
[3, 7, "SBCA"],
[3, 7, "SUBD"],
[3, 7, "ANDA"],
[3, 7, "BITA"],
[3, 7, "LDA"],
[3, 7, "STA"],
[3, 7, "EORA"],
[3, 7, "ADCA"],
[3, 7, "ORA"],
[3, 7, "ADDA"],
[3, 7, "CMPX"],
[3, 7, "JSR"],
[3, 7, "LDX"],
[3, 7, "STX"],
[2, 4, "SUBB"],
[2, 4, "CMPB"],
[2, 4, "SBCB"],
[3, 8, "ADDD"],
[2, 4, "ANDB"],
[2, 4, "BITB"],
[2, 4, "LDB"],
[1, 0, "???"],
[2, 4, "EORB"],
[2, 4, "ADCB"],
[2, 4, "ORB"],
[2, 4, "ADDB"],
[3, 8, "LDD"],
[1, 0, "???"],
[3, 8, "LDU"],
[1, 0, "???"],
[2, 1, "SUBB"],
[2, 1, "CMPB"],
[2, 1, "SBCB"],
[2, 1, "ADDD"],
[2, 1, "ANDB"],
[2, 1, "BITB"],
[2, 1, "LDB"],
[2, 1, "STB"],
[2, 1, "EORB"],
[2, 1, "ADCB"],
[2, 1, "ORB "],
[2, 1, "ADDB"],
[2, 1, "LDD "],
[2, 1, "STD "],
[2, 1, "LDU "],
[2, 1, "STU "],
[2, 6, "SUBB"],
[2, 6, "CMPB"],
[2, 6, "SBCB"],
[2, 6, "ADDD"],
[2, 6, "ANDB"],
[2, 6, "BITB"],
[2, 6, "LDB"],
[2, 6, "STB"],
[2, 6, "EORB"],
[2, 6, "ADCB"],
[2, 6, "ORB"],
[2, 6, "ADDB"],
[2, 6, "LDD"],
[2, 6, "STD"],
[2, 6, "LDU"],
[2, 6, "STU"],
[3, 7, "SUBB"],
[3, 7, "CMPB"],
[3, 7, "SBCB"],
[3, 7, "ADDD"],
[3, 7, "ANDB"],
[3, 7, "BITB"],
[3, 7, "LDB"],
[3, 7, "STB"],
[3, 7, "EORB"],
[3, 7, "ADCB"],
[3, 7, "ORB"],
[3, 7, "ADDB"],
[3, 7, "LDD"],
[3, 7, "STD"],
[3, 7, "LDU"],
[3, 7, "STU"],
];
var ds11 = {
0x3f: [2, 2, "SWI3"],
0x83: [4, 8, "CMPU"],
0x8c: [4, 8, "CMPS"],
0x93: [3, 1, "CMPU"],
0x9c: [3, 1, "CMPS"],
0xa3: [3, 6, "CMPU"],
0xac: [3, 6, "CMPS"],
0xb3: [4, 7, "CMPU"],
0xbc: [4, 7, "CMPS"],
};
var ds10 = {
0x21: [5, 3, "LBRN"],
0x22: [5, 3, "LBHI"],
0x23: [5, 3, "LBLS"],
0x24: [5, 3, "LBCC"],
0x25: [5, 3, "LBCS"],
0x26: [5, 3, "LBNE"],
0x27: [5, 3, "LBEQ"],
0x28: [5, 3, "LBVC"],
0x29: [5, 3, "LBVS"],
0x2a: [5, 3, "LBPL"],
0x2b: [5, 3, "LBMI"],
0x2c: [5, 3, "LBGE"],
0x2d: [5, 3, "LBLT"],
0x2e: [5, 3, "LBGT"],
0x2f: [5, 3, "LBLE"],
0x3f: [2, 2, "SWI2"],
0x83: [4, 8, "CMPD"],
0x8c: [4, 8, "CMPY"],
0x8e: [4, 8, "LDY"],
0x93: [3, 1, "CMPD"],
0x9c: [3, 1, "CMPY"],
0x9e: [3, 1, "LDY"],
0x9f: [3, 1, "STY"],
0xa3: [3, 6, "CMPD"],
0xac: [3, 6, "CMPY"],
0xae: [3, 6, "LDY"],
0xaf: [3, 6, "STY"],
0xb3: [4, 7, "CMPD"],
0xbc: [4, 7, "CMPY"],
0xbe: [4, 7, "LDY"],
0xbf: [4, 7, "STY"],
0xce: [4, 8, "LDS"],
0xde: [3, 1, "LDS"],
0xdf: [3, 1, "STS"],
0xee: [3, 6, "LDS"],
0xef: [3, 6, "STS"],
0xfe: [4, 7, "LDS"],
0xff: [4, 7, "STS"],
};
/*
ILLEGAL 0
DIRECT 1
INHERENT 2
BRANCH_REL_16 3
IMMEDIAT_8 4
BRANCH_REL_8 5
INDEXED 6
EXTENDED 7
IMMEDIAT_16 8
*/
var disasm = function (i, a, b, c, d, pc) {
var toHexN = function (n, d) {
var s = n.toString(16);
while (s.length < d) {
s = "0" + s;
}
return s.toUpperCase();
};
var toHex2 = function (n) {
return toHexN(n & 0xff, 2);
};
var toHex4 = function (n) {
return toHexN(n, 4);
};
var rx, ro, j;
var sx = ds[i];
if (i === 0x10) {
sx = ds10[a];
if (sx === undefined) {
return ["???", 2];
}
i = a;
a = b;
b = c;
c = d;
}
if (i === 0x11) {
sx = ds11[a];
if (sx === undefined) {
return ["???", 2];
}
i = a;
a = b;
b = c;
c = d;
}
var bytes = sx[0];
var mode = sx[1];
var mnemo = sx[2];
switch (mode) {
case 0: //invalid
break;
case 1: //direct page
mnemo += " $" + toHex2(a);
break;
case 2: // inherent
break;
case 3: //brel16
mnemo +=
" #$" +
toHex4(
a * 256 + b < 32768 ? a * 256 + b + pc : a * 256 + b + pc - 65536
);
break;
case 4: //imm8
mnemo += " #$" + toHex2(a);
break;
case 5: //brel8
mnemo += " #$" + toHex4(a < 128 ? a + pc + 2 : a + pc - 254);
break;
case 6: //indexed, postbyte etc.
mnemo += " ";
var pb = a;
var ixr = ["X", "Y", "U", "S"][(pb & 0x60) >> 5];
if (!(pb & 0x80)) {
//direct5
var disp = pb & 0x1f;
if (disp > 15) disp = disp - 32;
mnemo += disp + "," + ixr;
break;
}
var ind = pb & 0x10;
var mod = pb & 0x0f;
var ofs8 = b > 127 ? b - 256 : b;
var ofs16 = b * 256 + c > 32767 ? b * 256 + c - 65536 : b * 256 + c;
if (!ind) {
switch (mod) {
case 0:
mnemo += "," + ixr + "+";
break;
case 1:
mnemo += "," + ixr + "++";
break;
case 2:
mnemo += ",-" + ixr;
break;
case 3:
mnemo += ",--" + ixr;
break;
case 4:
mnemo += "," + ixr;
break;
case 5:
mnemo += "B," + ixr;
break;
case 6:
mnemo += "A," + ixr;
break;
case 7:
mnemo += "???";
break;
case 8:
mnemo += ofs8 + "," + ixr;
bytes++;
break;
case 9:
mnemo += ofs16 + "," + ixr;
bytes += 2;
break;
case 10:
mnemo += "???";
break;
case 11:
mnemo += "D," + ixr;
break;
case 12:
mnemo += ofs8 + ",PC";
bytes++;
break;
case 13:
mnemo += ofs16 + ",PC";
bytes += 2;
break;
case 14:
mnemo += "???";
break;
case 15:
mnemo += "$" + toHex4(b * 256 + c);
bytes += 2;
break;
}
} else {
switch (mod) {
case 0:
mnemo += "???";
break;
case 1:
mnemo += "[," + ixr + "++]";
break;
case 2:
mnemo += "???";
break;
case 3:
mnemo += "[,--" + ixr + "]";
break;
case 4:
mnemo += "[," + ixr + "]";
break;
case 5:
mnemo += "[B," + ixr + "]";
break;
case 6:
mnemo += "[A," + ixr + "]";
break;
case 7:
mnemo += "???";
break;
case 8:
mnemo += "[" + ofs8 + "," + ixr + "]";
bytes++;
break;
case 9:
mnemo += "[" + ofs16 + "," + ixr + "]";
bytes += 2;
break;
case 10:
mnemo += "???";
break;
case 11:
mnemo += "[D," + ixr + "]";
break;
case 12:
mnemo += "[" + ofs8 + ",PC]";
bytes++;
break;
case 13:
mnemo += "[" + ofs16 + ",PC]";
bytes += 2;
break;
case 14:
mnemo += "???";
break;
case 15:
mnemo += "[$" + toHex4(b * 256 + c) + "]";
bytes += 2;
break;
}
}
break;
case 7: //extended
mnemo += " $" + toHex4(a * 256 + b);
break;
case 8: //imm16
mnemo += " #$" + toHex4(a * 256 + b);
break;
case 10: //pshs, puls
rx = ["PC", "U", "Y", "X", "DP", "B", "A", "CC"];
ro = [];
for (j = 0; j < 8; j++) {
if ((a & 1) !== 0) {
ro.push(rx[7 - j]);
}
a >>= 1;
}
mnemo += " " + ro.join(",");
break;
case 11: //pshs, puls
rx = ["PC", "S", "Y", "X", "DP", "B", "A", "CC"];
ro = [];
for (j = 0; j < 8; j++) {
if ((a & 1) !== 0) {
ro.push(rx[7 - j]);
}
a >>= 1;
}
mnemo += " " + ro.join(",");
break;
case 20: //TFR etc
rx = [
"D",
"X",
"Y",
"U",
"S",
"PC",
"?",
"?",
"A",
"B",
"CC",
"DP",
"?",
"?",
"?",
"?",
];
mnemo += " " + rx[a >> 4] + "," + rx[a & 0x0f];
break;
}
return [mnemo, bytes];
};
//---------- Exports
return {
steps: function (Ts) {
//T=0;
while (Ts > 0) {
Ts -= step();
}
},
T: function () {
return T;
},
memr: function (addr) {
return byteAt(addr);
},
reset: reset,
init: function (bt, ba, tck) {
byteTo = bt;
byteAt = ba;
ticks = tck;
reset();
},
status: function () {
return {
pc: PC,
sp: rS,
u: rU,
a: rA,
b: rB,
x: rX,
y: rY,
dp: DP,
flags: CC,
};
},
interrupt: function () {
/*
if (flags & fINT) {
return;
}
//flags |= fBKC;
stPushWord(pc);
stPush(flags);
flags |= fINT;
pc=wordAt(IrqTo);
T+=7;
//console.log(pc);
*/
},
nmi: function () {
/*
return;
stPushWord(pc);
stPush(flags);
flags |= fINT;
pc=wordAt(NMITo);
T+=7;
//console.log(pc);
*/
},
set: function (reg, value) {
switch (reg.toUpperCase()) {
case "PC":
PC = value;
return;
case "A":
rA = value;
return;
case "B":
rB = value;
return;
case "X":
rX = value;
return;
case "Y":
rY = value;
return;
case "SP":
rS = value;
return;
case "U":
rU = value;
return;
case "FLAGS":
CC = value;
return;
}
},
flagsToString: function () {
var f = "",
fx = "EFHINZVC";
for (var i = 0; i < 8; i++) {
var n = CC & (0x80 >> i);
if (n === 0) {
f += fx[i].toLowerCase();
} else {
f += fx[i];
}
}
return f;
},
disasm: disasm,
};
});