1349 lines
37 KiB
JavaScript
1349 lines
37 KiB
JavaScript
/* -*- mode: Javascript; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*
|
|
* Copyright 2010-2013 Will Scullin <scullin@scullinsteel.com>
|
|
*
|
|
* Permission to use, copy, modify, distribute, and sell this software and its
|
|
* documentation for any purpose is hereby granted without fee, provided that
|
|
* the above copyright notice appear in all copies and that both that
|
|
* copyright notice and this permission notice appear in supporting
|
|
* documentation. No representations are made about the suitability of this
|
|
* software for any purpose. It is provided "as is" without express or
|
|
* implied warranty.
|
|
*/
|
|
|
|
/*globals toHex: false, debug: false*/
|
|
/*exported CPU6502 */
|
|
|
|
function CPU6502(options)
|
|
{
|
|
options = options || {};
|
|
|
|
var is65C02 = options['65C02'] ? true : false;
|
|
|
|
/* Registers */
|
|
var pc = 0, // Program Counter
|
|
sr = 0x20, // Process Status Register
|
|
ar = 0, // Accumulator
|
|
xr = 0, // X Register
|
|
yr = 0, // Y Register
|
|
sp = 0xff; // Stack Pointer
|
|
|
|
/* Addressing Mode */
|
|
var modes = {
|
|
accumulator: 0, // A (Accumulator)
|
|
implied: 1, // Implied
|
|
immediate: 2, // # Immediate
|
|
absolute: 3, // a Absolute
|
|
zeroPage: 4, // zp Zero Page
|
|
relative: 5, // r Relative
|
|
|
|
absoluteX: 6, // a,X Absolute, X
|
|
absoluteY: 7, // a,Y Absolute, Y
|
|
zeroPageX: 8, // zp,X Zero Page, X
|
|
zeroPageY: 9, // zp,Y Zero Page, Y
|
|
|
|
absoluteIndirect: 10, // (a) Indirect
|
|
zeroPageXIndirect: 11, // (zp,X) Zero Page Indexed Indirect
|
|
zeroPageIndirectY: 12, // (zp),Y Zero Page Indexed with Y
|
|
|
|
/* 65c02 */
|
|
zeroPageIndirect: 13, // (zp),
|
|
absoluteXIndirect: 14 // (a, X)
|
|
};
|
|
|
|
var sizes = {
|
|
0 /* modes.accumulator */: 1,
|
|
1 /* modes.implied */: 1,
|
|
2 /* modes.immediate */: 2,
|
|
3 /* modes.absolute */: 3,
|
|
4 /* modes.zeroPage */: 2,
|
|
5 /* modes.relative */: 2,
|
|
6 /* modes.absoluteX */: 3,
|
|
7 /* modes.absoluteY */: 3,
|
|
8 /* modes.zeroPageX */: 2,
|
|
9 /* modes.zeroPageY */: 2,
|
|
10 /* modes.indirect */: 3,
|
|
11 /* modes.zeroPageXIndirect */: 2,
|
|
12 /* modes.zeroPageYIndirect */: 2,
|
|
|
|
13 /* mode.zeroPageIndirect */: 2,
|
|
14 /* mode.absoluteXIndirect */: 3
|
|
};
|
|
|
|
/* Flags */
|
|
var flags = {
|
|
N: 0x80, // Negative
|
|
V: 0x40, // oVerflow
|
|
B: 0x10, // Break
|
|
D: 0x08, // Decimal
|
|
I: 0x04, // Interrupt
|
|
Z: 0x02, // Zero
|
|
C: 0x01 // Carry
|
|
};
|
|
|
|
/* Memory Locations */
|
|
var loc = {
|
|
STACK: 0x100,
|
|
NMI: 0xFFFA,
|
|
RESET: 0xFFFC,
|
|
BRK: 0xFFFE
|
|
};
|
|
|
|
var idx;
|
|
|
|
var readPages = [];
|
|
var writePages = [];
|
|
var resetHandlers = [];
|
|
var inCallback = false;
|
|
var cycles = 0;
|
|
|
|
var blankPage = {
|
|
read: function() { return 0; },
|
|
write: function() {}
|
|
};
|
|
|
|
for (idx = 0; idx < 0x100; idx++) {
|
|
readPages[idx] = blankPage;
|
|
writePages[idx] = blankPage;
|
|
}
|
|
|
|
function setFlag(f, on) {
|
|
sr = on ? (sr | f) : (sr & ~f);
|
|
}
|
|
|
|
function testNZ(val) {
|
|
sr = val === 0 ? (sr | flags.Z) : (sr & ~flags.Z);
|
|
sr = val & 0x80 ? (sr | flags.N) : (sr & ~flags.N);
|
|
|
|
return val;
|
|
}
|
|
|
|
function testZ(val) {
|
|
sr = val === 0 ? (sr | flags.Z) : (sr & ~flags.Z);
|
|
|
|
return val;
|
|
}
|
|
|
|
function add(a, b, sub) {
|
|
if (sub)
|
|
b ^= 0xff;
|
|
|
|
// KEGS
|
|
var c, v;
|
|
if (sr & flags.D) {
|
|
c = (a & 0x0f) + (b & 0x0f) + (sr & flags.C);
|
|
if (sub) {
|
|
if (c < 0x10)
|
|
c = (c - 0x06) & 0x0f;
|
|
c += (a & 0xf0) + (b & 0xf0);
|
|
v = (c >> 1) ^ c;
|
|
if (c < 0x100)
|
|
c = (c + 0xa0) & 0xff;
|
|
} else {
|
|
if (c > 0x09)
|
|
c = (c - 0x0a) | 0x10; // carry to MSN
|
|
c += (a & 0xf0) + (b & 0xf0);
|
|
v = (c >> 1) ^ c;
|
|
if (c > 0x99)
|
|
c += 0x60;
|
|
}
|
|
} else {
|
|
c = a + b + (sr & flags.C);
|
|
v = (c ^ a) & 0x80;
|
|
}
|
|
|
|
if ((a ^ b) & 0x80)
|
|
v = 0;
|
|
|
|
setFlag(flags.C, c > 0xff);
|
|
setFlag(flags.V, v);
|
|
|
|
return testNZ(c & 0xff);
|
|
}
|
|
|
|
function increment(a) {
|
|
return testNZ((a + 0x01) & 0xff);
|
|
}
|
|
|
|
function decrement(a) {
|
|
return testNZ((a + 0xff) & 0xff);
|
|
}
|
|
|
|
function readBytePC(dbg) {
|
|
var addr = (pc++) & 0xffff,
|
|
page = addr >> 8,
|
|
off = addr & 0xff;
|
|
|
|
return readPages[page].read(page, off, dbg);
|
|
}
|
|
|
|
function readByte(addr, dbg) {
|
|
var page = addr >> 8,
|
|
off = addr & 0xff;
|
|
|
|
return readPages[page].read(page, off, dbg);
|
|
}
|
|
|
|
function writeByte(addr, val) {
|
|
var page = addr >> 8,
|
|
off = addr & 0xff;
|
|
|
|
writePages[page].write(page, off, val);
|
|
}
|
|
|
|
function readWord(addr, dbg) {
|
|
return readByte(addr, dbg) | (readByte(addr + 1, dbg) << 8);
|
|
}
|
|
|
|
function readWordPC(dbg) {
|
|
return readBytePC(dbg) | (readBytePC(dbg) << 8);
|
|
}
|
|
|
|
function readZPWord(addr, dbg) {
|
|
var lsb, msb;
|
|
|
|
lsb = readByte(addr & 0xff, dbg);
|
|
msb = readByte((addr + 1) & 0xff, dbg);
|
|
|
|
return (msb << 8) | lsb;
|
|
}
|
|
|
|
function pushByte(val) {
|
|
writeByte(loc.STACK | sp, val);
|
|
sp = (sp + 0xff) & 0xff;
|
|
}
|
|
|
|
function pushWord(val) {
|
|
pushByte(val >> 8);
|
|
pushByte(val & 0xff);
|
|
}
|
|
|
|
function pullByte() {
|
|
sp = (sp + 0x01) & 0xff;
|
|
var result = readByte(loc.STACK | sp);
|
|
return result;
|
|
}
|
|
|
|
function pullWord() {
|
|
var lsb = pullByte(),
|
|
msb = pullByte();
|
|
|
|
return (msb << 8) | lsb;
|
|
}
|
|
|
|
function indirectBug(addr) {
|
|
var page = addr & 0xff00;
|
|
var off = addr & 0xff;
|
|
var lsb = readByte(page | (off & 0xff));
|
|
var msb = readByte(page | ((off + 0x01) & 0xff));
|
|
|
|
return (msb << 8) | lsb;
|
|
}
|
|
|
|
/*
|
|
* Read functions
|
|
*/
|
|
|
|
// #$00
|
|
function readImmediate() {
|
|
return readBytePC();
|
|
}
|
|
|
|
// $0000
|
|
function readAbsolute() {
|
|
return readByte(readWordPC());
|
|
}
|
|
|
|
// $00
|
|
function readZeroPage() {
|
|
return readByte(readBytePC());
|
|
}
|
|
|
|
// $0000,X
|
|
function readAbsoluteX() {
|
|
var addr = readWordPC(), oldPage = addr >> 8, page;
|
|
addr = (addr + xr) & 0xffff;
|
|
page = addr >> 8;
|
|
if (page != oldPage) {
|
|
cycles++;
|
|
}
|
|
return readByte(addr);
|
|
}
|
|
|
|
// $0000,Y
|
|
function readAbsoluteY() {
|
|
var addr = readWordPC(), oldPage = addr >> 8, page;
|
|
addr = (addr + yr) & 0xffff;
|
|
page = addr >> 8;
|
|
if (page != oldPage) {
|
|
cycles++;
|
|
}
|
|
return readByte(addr);
|
|
}
|
|
|
|
// $00,X
|
|
function readZeroPageX() {
|
|
return readByte((readBytePC() + xr) & 0xff);
|
|
}
|
|
|
|
// $00,Y
|
|
function readZeroPageY() {
|
|
return readByte((readBytePC() + yr) & 0xff);
|
|
}
|
|
|
|
// ($00,X)
|
|
function readZeroPageXIndirect() {
|
|
return readByte(readZPWord((readBytePC() + xr) & 0xff));
|
|
}
|
|
|
|
// ($00),Y
|
|
function readZeroPageIndirectY() {
|
|
var addr = readZPWord(readBytePC()), oldPage = addr >> 8, page;
|
|
addr = (addr + yr) & 0xffff;
|
|
page = addr >> 8;
|
|
if (page != oldPage) {
|
|
cycles++;
|
|
}
|
|
return readByte(addr);
|
|
}
|
|
|
|
// ($00) (65C02)
|
|
function readZeroPageIndirect() {
|
|
return readByte(readZPWord(readBytePC()));
|
|
}
|
|
|
|
/*
|
|
* Write Functions
|
|
*/
|
|
|
|
// $0000
|
|
function writeAbsolute(val) {
|
|
writeByte(readWordPC(), val);
|
|
}
|
|
|
|
// $00
|
|
function writeZeroPage(val) {
|
|
writeByte(readBytePC(), val);
|
|
}
|
|
|
|
// $0000,X
|
|
function writeAbsoluteX(val) {
|
|
writeByte((readWordPC() + xr) & 0xffff, val);
|
|
}
|
|
|
|
// $0000,Y
|
|
function writeAbsoluteY(val) {
|
|
writeByte((readWordPC() + yr) & 0xffff, val);
|
|
}
|
|
|
|
// $00,X
|
|
function writeZeroPageX(val) {
|
|
writeByte((readBytePC() + xr) & 0xff, val);
|
|
}
|
|
|
|
// $00,Y
|
|
function writeZeroPageY(val) {
|
|
writeByte((readBytePC() + yr) & 0xff, val);
|
|
}
|
|
|
|
// ($00,X)
|
|
function writeZeroPageXIndirect(val) {
|
|
writeByte(readZPWord((readBytePC() + xr) & 0xff), val);
|
|
}
|
|
|
|
// ($00),Y
|
|
function writeZeroPageIndirectY(val) {
|
|
writeByte((readZPWord(readBytePC()) + yr) & 0xffff, val);
|
|
}
|
|
|
|
// ($00) (65C02)
|
|
function writeZeroPageIndirect(val) {
|
|
writeByte(readZPWord(readBytePC()), val);
|
|
}
|
|
|
|
// $00
|
|
function readAddrZeroPage() {
|
|
return readBytePC();
|
|
}
|
|
|
|
// $00,X
|
|
function readAddrZeroPageX() {
|
|
return (readBytePC() + xr) & 0xff;
|
|
}
|
|
|
|
// $0000 (65C02)
|
|
function readAddrAbsolute() {
|
|
return readWordPC();
|
|
}
|
|
|
|
// $0000
|
|
function readAddrAbsoluteIndirectBug() {
|
|
return indirectBug(readWordPC());
|
|
}
|
|
|
|
// ($0000)
|
|
function readAddrAbsoluteIndirect() {
|
|
return readWord(readWordPC());
|
|
}
|
|
|
|
// $0000,X
|
|
function readAddrAbsoluteX() {
|
|
return (readWordPC() + xr) & 0xffff;
|
|
}
|
|
|
|
// $(0000,X)
|
|
function readAddrAbsoluteXIndirect() {
|
|
return readWord((readWordPC() + xr) & 0xffff);
|
|
}
|
|
|
|
/* Break */
|
|
function brk(readFn) {
|
|
readFn();
|
|
pushWord(pc);
|
|
pushByte(sr | flags.B);
|
|
if (is65C02) {
|
|
setFlag(flags.D, false);
|
|
}
|
|
setFlag(flags.I, true);
|
|
pc = readWord(loc.BRK);
|
|
}
|
|
|
|
/* Load Accumulator */
|
|
function lda(readFn) {
|
|
ar = testNZ(readFn());
|
|
}
|
|
|
|
/* Load X Register */
|
|
function ldx(readFn) {
|
|
xr = testNZ(readFn());
|
|
}
|
|
|
|
/* Load Y Register */
|
|
function ldy(readFn) {
|
|
yr = testNZ(readFn());
|
|
}
|
|
|
|
/* Store Accumulator */
|
|
function sta(writeFn) {
|
|
writeFn(ar);
|
|
}
|
|
|
|
/* Store X Register */
|
|
function stx(writeFn) {
|
|
writeFn(xr);
|
|
}
|
|
|
|
/* Store Y Register */
|
|
function sty(writeFn) {
|
|
writeFn(yr);
|
|
}
|
|
|
|
/* Store Zero */
|
|
function stz(writeFn) {
|
|
writeFn(0);
|
|
}
|
|
|
|
/* Add with Carry */
|
|
function adc(readFn) {
|
|
ar = add(ar, readFn(), false);
|
|
}
|
|
|
|
/* Subtract with Carry */
|
|
function sbc(readFn) {
|
|
ar = add(ar, readFn(), true);
|
|
}
|
|
|
|
/* Increment Memory */
|
|
function incA() {
|
|
ar = increment(ar);
|
|
}
|
|
|
|
function inc(readAddrFn) {
|
|
var addr = readAddrFn();
|
|
writeByte(addr, increment(readByte(addr)));
|
|
}
|
|
|
|
/* Increment X */
|
|
function inx() {
|
|
xr = increment(xr);
|
|
}
|
|
|
|
/* Increment Y */
|
|
function iny() {
|
|
yr = increment(yr);
|
|
}
|
|
|
|
/* Decrement Memory */
|
|
function decA() {
|
|
ar = decrement(ar);
|
|
}
|
|
|
|
function dec(readAddrFn) {
|
|
var addr = readAddrFn();
|
|
writeByte(addr, decrement(readByte(addr)));
|
|
}
|
|
|
|
/* Decrement X */
|
|
function dex() {
|
|
xr = decrement(xr);
|
|
}
|
|
|
|
/* Decrement Y */
|
|
function dey() {
|
|
yr = decrement(yr);
|
|
}
|
|
|
|
function shiftLeft(val) {
|
|
setFlag(flags.C, val & 0x80);
|
|
return testNZ((val << 1) & 0xff);
|
|
}
|
|
|
|
/* Arithmatic Shift Left */
|
|
function aslA() {
|
|
ar = shiftLeft(ar);
|
|
}
|
|
|
|
function asl(readAddrFn) {
|
|
var addr = readAddrFn();
|
|
writeByte(addr, shiftLeft(readByte(addr)));
|
|
}
|
|
|
|
function shiftRight(val) {
|
|
setFlag(flags.C, val & 0x01);
|
|
return testNZ(val >> 1);
|
|
}
|
|
|
|
/* Logical Shift Right */
|
|
function lsrA() {
|
|
ar = shiftRight(ar);
|
|
}
|
|
|
|
function lsr(readAddrFn) {
|
|
var addr = readAddrFn();
|
|
writeByte(addr, shiftRight(readByte(addr)));
|
|
}
|
|
|
|
function rotateLeft(val) {
|
|
var c = (sr & flags.C);
|
|
setFlag(flags.C, val & 0x80);
|
|
return testNZ(((val << 1) | (c ? 0x01 : 0x00)) & 0xff);
|
|
}
|
|
|
|
/* Rotate Left */
|
|
function rolA() {
|
|
ar = rotateLeft(ar);
|
|
}
|
|
|
|
function rol(readAddrFn) {
|
|
var addr = readAddrFn();
|
|
writeByte(addr, rotateLeft(readByte(addr)));
|
|
}
|
|
|
|
function rotateRight(a) {
|
|
var c = (sr & flags.C);
|
|
setFlag(flags.C, a & 0x01);
|
|
return testNZ((a >> 1) | (c ? 0x80 : 0x00));
|
|
}
|
|
|
|
/* Rotate Right */
|
|
function rorA() {
|
|
ar = rotateRight(ar);
|
|
}
|
|
|
|
function ror(readAddrFn) {
|
|
var addr = readAddrFn();
|
|
writeByte(addr, rotateRight(readByte(addr)));
|
|
}
|
|
|
|
/* Logical And Accumulator */
|
|
function and(readFn) {
|
|
ar = testNZ(ar & readFn());
|
|
}
|
|
|
|
/* Logical Or Accumulator */
|
|
function ora(readFn) {
|
|
ar = testNZ(ar | readFn());
|
|
}
|
|
|
|
/* Logical Exclusive Or Accumulator */
|
|
function eor(readFn) {
|
|
ar = testNZ(ar ^ readFn());
|
|
}
|
|
|
|
/* Test and Reset Bits */
|
|
function trb(readAddrFn) {
|
|
var addr = readAddrFn(),
|
|
val = readByte(addr);
|
|
testZ(val & ar);
|
|
writeByte(addr, val & ~ar);
|
|
}
|
|
|
|
/* Test and Set Bits */
|
|
function tsb(readAddrFn) {
|
|
var addr = readAddrFn(),
|
|
val = readByte(addr);
|
|
testZ(val & ar);
|
|
writeByte(addr, val | ar);
|
|
}
|
|
|
|
/* Bit */
|
|
function bit(readFn) {
|
|
var val = readFn();
|
|
setFlag(flags.Z, !(val & ar));
|
|
setFlag(flags.N, val & 0x80);
|
|
setFlag(flags.V, val & 0x40);
|
|
}
|
|
|
|
/* Bit Immediate*/
|
|
function bitI(readFn) {
|
|
var val = readFn();
|
|
setFlag(flags.Z, !(val & ar));
|
|
}
|
|
|
|
function compare(a, b)
|
|
{
|
|
b = (b ^ 0xff);
|
|
var c = a + b + 1;
|
|
setFlag(flags.C, c > 0xff);
|
|
testNZ(c & 0xff);
|
|
}
|
|
|
|
function cmp(readFn) {
|
|
compare(ar, readFn());
|
|
}
|
|
|
|
function cpx(readFn) {
|
|
compare(xr, readFn());
|
|
}
|
|
|
|
function cpy(readFn) {
|
|
compare(yr, readFn());
|
|
}
|
|
|
|
/* Branches */
|
|
function brs(f) {
|
|
var off = readBytePC(); // changes pc
|
|
if (f & sr) {
|
|
var oldPC = pc;
|
|
pc += off > 127 ? off - 256 : off;
|
|
cycles++;
|
|
if ((pc >> 8) != (oldPC >> 8)) cycles++;
|
|
}
|
|
}
|
|
|
|
function brc(f) {
|
|
var off = readBytePC(); // changes pc
|
|
if (!(f & sr)) {
|
|
var oldPC = pc;
|
|
pc += off > 127 ? off - 256 : off;
|
|
cycles++;
|
|
if ((pc >> 8) != (oldPC >> 8)) cycles++;
|
|
}
|
|
}
|
|
|
|
/* Transfers and stack */
|
|
function tax() { testNZ(xr = ar); }
|
|
|
|
function txa() { testNZ(ar = xr); }
|
|
|
|
function tay() { testNZ(yr = ar); }
|
|
|
|
function tya() { testNZ(ar = yr); }
|
|
|
|
function tsx() { testNZ(xr = sp); }
|
|
|
|
function txs() { sp = xr; }
|
|
|
|
function pha() { pushByte(ar); }
|
|
|
|
function pla() { testNZ(ar = pullByte()); }
|
|
|
|
function phx() { pushByte(xr); }
|
|
|
|
function plx() { testNZ(xr = pullByte()); }
|
|
|
|
function phy() { pushByte(yr); }
|
|
|
|
function ply() { testNZ(yr = pullByte()); }
|
|
|
|
function php() { pushByte(sr | flags.B); }
|
|
|
|
function plp() { sr = (pullByte() & ~flags.B) | 0x20; }
|
|
|
|
/* Jump */
|
|
function jmp(readAddrFn) {
|
|
pc = readAddrFn();
|
|
}
|
|
|
|
/* Jump Subroutine */
|
|
function jsr(readAddrFn) {
|
|
var dest = readAddrFn();
|
|
pushWord(pc - 1);
|
|
pc = dest;
|
|
}
|
|
|
|
/* Return from Subroutine */
|
|
function rts() {
|
|
pc = (pullWord() + 1) & 0xffff;
|
|
}
|
|
|
|
/* Return from Subroutine */
|
|
function rti() {
|
|
sr = pullByte() & 0xef;
|
|
pc = pullWord();
|
|
}
|
|
|
|
/* Set and Clear */
|
|
function set(flag) {
|
|
sr |= flag;
|
|
}
|
|
|
|
function clr(flag) {
|
|
sr &= ~flag;
|
|
}
|
|
|
|
/* No-Op */
|
|
function nop() {
|
|
}
|
|
|
|
var ops = {
|
|
// LDA
|
|
0xa9: ["LDA", lda, readImmediate, modes.immediate, 2],
|
|
0xa5: ["LDA", lda, readZeroPage, modes.zeroPage, 3],
|
|
0xb5: ["LDA", lda, readZeroPageX, modes.zeroPageX, 4],
|
|
0xad: ["LDA", lda, readAbsolute, modes.absolute, 4],
|
|
0xbd: ["LDA", lda, readAbsoluteX, modes.absoluteX, 4],
|
|
0xb9: ["LDA", lda, readAbsoluteY, modes.absoluteY, 4],
|
|
0xa1: ["LDA", lda, readZeroPageXIndirect, modes.zeroPageXIndirect, 6],
|
|
0xb1: ["LDA", lda, readZeroPageIndirectY, modes.zeroPageIndirectY, 5],
|
|
|
|
// LDX
|
|
0xa2: ["LDX", ldx, readImmediate, modes.immediate, 2],
|
|
0xa6: ["LDX", ldx, readZeroPage, modes.zeroPage, 3],
|
|
0xb6: ["LDX", ldx, readZeroPageY, modes.zeroPageY, 4],
|
|
0xae: ["LDX", ldx, readAbsolute, modes.absolute, 4],
|
|
0xbe: ["LDX", ldx, readAbsoluteY, modes.absoluteY, 4],
|
|
|
|
// LDY
|
|
0xa0: ["LDY", ldy, readImmediate, modes.immediate, 2],
|
|
0xa4: ["LDY", ldy, readZeroPage, modes.zeroPage, 3],
|
|
0xb4: ["LDY", ldy, readZeroPageX, modes.zeroPageX, 4],
|
|
0xac: ["LDY", ldy, readAbsolute, modes.absolute, 4],
|
|
0xbc: ["LDY", ldy, readAbsoluteX, modes.absoluteX, 4],
|
|
|
|
// STA
|
|
0x85: ["STA", sta, writeZeroPage, modes.zeroPage, 3],
|
|
0x95: ["STA", sta, writeZeroPageX, modes.zeroPageX, 4],
|
|
0x8d: ["STA", sta, writeAbsolute, modes.absolute, 4],
|
|
0x9d: ["STA", sta, writeAbsoluteX, modes.absoluteX, 5],
|
|
0x99: ["STA", sta, writeAbsoluteY, modes.absoluteY, 5],
|
|
0x81: ["STA", sta, writeZeroPageXIndirect, modes.zeroPageXIndirect, 6],
|
|
0x91: ["STA", sta, writeZeroPageIndirectY, modes.zeroPageIndirectY, 6],
|
|
|
|
// STX
|
|
0x86: ["STX", stx, writeZeroPage, modes.zeroPage, 3],
|
|
0x96: ["STX", stx, writeZeroPageY, modes.zeroPageY, 4],
|
|
0x8e: ["STX", stx, writeAbsolute, modes.absolute, 4],
|
|
|
|
// STY
|
|
0x84: ["STY", sty, writeZeroPage, modes.zeroPage, 3],
|
|
0x94: ["STY", sty, writeZeroPageX, modes.zeroPageX, 4],
|
|
0x8c: ["STY", sty, writeAbsolute, modes.absolute, 4],
|
|
|
|
// ADC
|
|
0x69: ["ADC", adc, readImmediate, modes.immediate, 2],
|
|
0x65: ["ADC", adc, readZeroPage, modes.zeroPage, 3],
|
|
0x75: ["ADC", adc, readZeroPageX, modes.zeroPageX, 4],
|
|
0x6D: ["ADC", adc, readAbsolute, modes.absolute, 4],
|
|
0x7D: ["ADC", adc, readAbsoluteX, modes.absoluteX, 4],
|
|
0x79: ["ADC", adc, readAbsoluteY, modes.absoluteY, 4],
|
|
0x61: ["ADC", adc, readZeroPageXIndirect, modes.zeroPageXIndirect, 6],
|
|
0x71: ["ADC", adc, readZeroPageIndirectY, modes.zeroPageIndirectY, 5],
|
|
|
|
// SBC
|
|
0xe9: ["SBC", sbc, readImmediate, modes.immediate, 2],
|
|
0xe5: ["SBC", sbc, readZeroPage, modes.zeroPage, 3],
|
|
0xf5: ["SBC", sbc, readZeroPageX, modes.zeroPageX, 4],
|
|
0xeD: ["SBC", sbc, readAbsolute, modes.absolute, 4],
|
|
0xfD: ["SBC", sbc, readAbsoluteX, modes.absoluteX, 4],
|
|
0xf9: ["SBC", sbc, readAbsoluteY, modes.absoluteY, 4],
|
|
0xe1: ["SBC", sbc, readZeroPageXIndirect, modes.zeroPageXIndirect, 6],
|
|
0xf1: ["SBC", sbc, readZeroPageIndirectY, modes.zeroPageIndirectY, 5],
|
|
|
|
// INC
|
|
0xe6: ["INC", inc, readAddrZeroPage, modes.zeroPage, 5],
|
|
0xf6: ["INC", inc, readAddrZeroPageX, modes.zeroPageX, 6],
|
|
0xee: ["INC", inc, readAddrAbsolute, modes.absolute, 6],
|
|
0xfe: ["INC", inc, readAddrAbsoluteX, modes.absoluteX, 7],
|
|
|
|
// INX
|
|
0xe8: ["INX", inx, null, modes.implied, 2],
|
|
|
|
// INY
|
|
0xc8: ["INY", iny, null, modes.implied, 2],
|
|
|
|
// DEC
|
|
0xc6: ["DEC", dec, readAddrZeroPage, modes.zeroPage, 5],
|
|
0xd6: ["DEC", dec, readAddrZeroPageX, modes.zeroPageX, 6],
|
|
0xce: ["DEC", dec, readAddrAbsolute, modes.absolute, 6],
|
|
0xde: ["DEC", dec, readAddrAbsoluteX, modes.absoluteX, 7],
|
|
|
|
// DEX
|
|
0xca: ["DEX", dex, null, modes.implied, 2],
|
|
|
|
// DEY
|
|
0x88: ["DEY", dey, null, modes.implied, 2],
|
|
|
|
// ASL
|
|
0x0A: ["ASL", aslA, null, modes.accumulator, 2],
|
|
0x06: ["ASL", asl, readAddrZeroPage, modes.zeroPage, 5],
|
|
0x16: ["ASL", asl, readAddrZeroPageX, modes.zeroPageX, 6],
|
|
0x0E: ["ASL", asl, readAddrAbsolute, modes.absolute, 6],
|
|
0x1E: ["ASL", asl, readAddrAbsoluteX, modes.absoluteX, 7],
|
|
|
|
// LSR
|
|
0x4A: ["LSR", lsrA, null, modes.accumulator, 2],
|
|
0x46: ["LSR", lsr, readAddrZeroPage, modes.zeroPage, 5],
|
|
0x56: ["LSR", lsr, readAddrZeroPageX, modes.zeroPageX, 6],
|
|
0x4E: ["LSR", lsr, readAddrAbsolute, modes.absolute, 6],
|
|
0x5E: ["LSR", lsr, readAddrAbsoluteX, modes.absoluteX, 7],
|
|
|
|
// ROL
|
|
0x2A: ["ROL", rolA, null, modes.accumulator, 2],
|
|
0x26: ["ROL", rol, readAddrZeroPage, modes.zeroPage, 5],
|
|
0x36: ["ROL", rol, readAddrZeroPageX, modes.zeroPageX, 6],
|
|
0x2E: ["ROL", rol, readAddrAbsolute, modes.absolute, 6],
|
|
0x3E: ["ROL", rol, readAddrAbsoluteX, modes.absoluteX, 7],
|
|
|
|
// ROR
|
|
0x6A: ["ROR", rorA, null, modes.accumulator, 2],
|
|
0x66: ["ROR", ror, readAddrZeroPage, modes.zeroPage, 5],
|
|
0x76: ["ROR", ror, readAddrZeroPageX, modes.zeroPageX, 6],
|
|
0x6E: ["ROR", ror, readAddrAbsolute, modes.absolute, 6],
|
|
0x7E: ["ROR", ror, readAddrAbsoluteX, modes.absoluteX, 7],
|
|
|
|
// AND
|
|
0x29: ["AND", and, readImmediate, modes.immediate, 2],
|
|
0x25: ["AND", and, readZeroPage, modes.zeroPage, 2],
|
|
0x35: ["AND", and, readZeroPageX, modes.zeroPageX, 3],
|
|
0x2D: ["AND", and, readAbsolute, modes.absolute, 4],
|
|
0x3D: ["AND", and, readAbsoluteX, modes.absoluteX, 4],
|
|
0x39: ["AND", and, readAbsoluteY, modes.absoluteY, 4],
|
|
0x21: ["AND", and, readZeroPageXIndirect, modes.zeroPageXIndirect, 6],
|
|
0x31: ["AND", and, readZeroPageIndirectY, modes.zeroPageIndirectY, 5],
|
|
|
|
// ORA
|
|
0x09: ["ORA", ora, readImmediate, modes.immediate, 2],
|
|
0x05: ["ORA", ora, readZeroPage, modes.zeroPage, 2],
|
|
0x15: ["ORA", ora, readZeroPageX, modes.zeroPageX, 3],
|
|
0x0D: ["ORA", ora, readAbsolute, modes.absolute, 4],
|
|
0x1D: ["ORA", ora, readAbsoluteX, modes.absoluteX, 4],
|
|
0x19: ["ORA", ora, readAbsoluteY, modes.absoluteY, 4],
|
|
0x01: ["ORA", ora, readZeroPageXIndirect, modes.zeroPageXIndirect, 6],
|
|
0x11: ["ORA", ora, readZeroPageIndirectY, modes.zeroPageIndirectY, 5],
|
|
|
|
// EOR
|
|
0x49: ["EOR", eor, readImmediate, modes.immediate, 2],
|
|
0x45: ["EOR", eor, readZeroPage, modes.zeroPage, 3],
|
|
0x55: ["EOR", eor, readZeroPageX, modes.zeroPageX, 4],
|
|
0x4D: ["EOR", eor, readAbsolute, modes.absolute, 4],
|
|
0x5D: ["EOR", eor, readAbsoluteX, modes.absoluteX, 4],
|
|
0x59: ["EOR", eor, readAbsoluteY, modes.absoluteY, 4],
|
|
0x41: ["EOR", eor, readZeroPageXIndirect, modes.zeroPageXIndirect, 6],
|
|
0x51: ["EOR", eor, readZeroPageIndirectY, modes.zeroPageIndirectY, 5],
|
|
|
|
// CMP
|
|
0xc9: ["CMP", cmp, readImmediate, modes.immediate, 2],
|
|
0xc5: ["CMP", cmp, readZeroPage, modes.zeroPage, 3],
|
|
0xd5: ["CMP", cmp, readZeroPageX, modes.zeroPageX, 4],
|
|
0xcD: ["CMP", cmp, readAbsolute, modes.absolute, 4],
|
|
0xdD: ["CMP", cmp, readAbsoluteX, modes.absoluteX, 4],
|
|
0xd9: ["CMP", cmp, readAbsoluteY, modes.absoluteY, 4],
|
|
0xc1: ["CMP", cmp, readZeroPageXIndirect, modes.zeroPageXIndirect, 6],
|
|
0xd1: ["CMP", cmp, readZeroPageIndirectY, modes.zeroPageIndirectY, 5],
|
|
|
|
// CPX
|
|
0xE0: ["CPX", cpx, readImmediate, modes.immediate, 2],
|
|
0xE4: ["CPX", cpx, readZeroPage, modes.zeroPage, 3],
|
|
0xEC: ["CPX", cpx, readAbsolute, modes.absolute, 4],
|
|
|
|
// CPY
|
|
0xC0: ["CPY", cpy, readImmediate, modes.immediate, 2],
|
|
0xC4: ["CPY", cpy, readZeroPage, modes.zeroPage, 3],
|
|
0xCC: ["CPY", cpy, readAbsolute, modes.absolute, 4],
|
|
|
|
// BIT
|
|
0x24: ["BIT", bit, readZeroPage, modes.zeroPage, 3],
|
|
0x2C: ["BIT", bit, readAbsolute, modes.absolute, 4],
|
|
|
|
// BCC
|
|
0x90: ["BCC", brc, flags.C, modes.relative, 2],
|
|
|
|
// BCS
|
|
0xB0: ["BCS", brs, flags.C, modes.relative, 2],
|
|
|
|
// BEQ
|
|
0xF0: ["BEQ", brs, flags.Z, modes.relative, 2],
|
|
|
|
// BMI
|
|
0x30: ["BMI", brs, flags.N, modes.relative, 2],
|
|
|
|
// BNE
|
|
0xD0: ["BNE", brc, flags.Z, modes.relative, 2],
|
|
|
|
// BPL
|
|
0x10: ["BPL", brc, flags.N, modes.relative, 2],
|
|
|
|
// BVC
|
|
0x50: ["BVC", brc, flags.V, modes.relative, 2],
|
|
|
|
// BVS
|
|
0x70: ["BVS", brs, flags.V, modes.relative, 2],
|
|
|
|
// TAX
|
|
0xAA: ["TAX", tax, null, modes.implied, 2],
|
|
|
|
// TXA
|
|
0x8A: ["TXA", txa, null, modes.implied, 2],
|
|
|
|
// TAY
|
|
0xA8: ["TAY", tay, null, modes.implied, 2],
|
|
|
|
// TYA
|
|
0x98: ["TYA", tya, null, modes.implied, 2],
|
|
|
|
// TSX
|
|
0xBA: ["TSX", tsx, null, modes.implied, 2],
|
|
|
|
// TXS
|
|
0x9A: ["TXS", txs, null, modes.implied, 2],
|
|
|
|
// PHA
|
|
0x48: ["PHA", pha, null, modes.implied, 3],
|
|
|
|
// PLA
|
|
0x68: ["PLA", pla, null, modes.implied, 4],
|
|
|
|
// PHP
|
|
0x08: ["PHP", php, null, modes.implied, 3],
|
|
|
|
// PLP
|
|
0x28: ["PLP", plp, null, modes.implied, 4],
|
|
|
|
// JMP
|
|
0x4C: ["JMP", jmp,
|
|
readAddrAbsolute, modes.absolute, 3],
|
|
0x6C: ["JMP", jmp,
|
|
readAddrAbsoluteIndirectBug, modes.absoluteIndirect, 5],
|
|
|
|
// JSR
|
|
0x20: ["JSR", jsr, readAddrAbsolute, modes.absolute, 6],
|
|
|
|
// RTS
|
|
0x60: ["RTS", rts, null, modes.implied, 6],
|
|
|
|
// RTI
|
|
0x40: ["RTI", rti, null, modes.implied, 6],
|
|
|
|
// SEC
|
|
0x38: ["SEC", set, flags.C, modes.implied, 2],
|
|
|
|
// SED
|
|
0xF8: ["SED", set, flags.D, modes.implied, 2],
|
|
|
|
// SEI
|
|
0x78: ["SEI", set, flags.I, modes.implied, 2],
|
|
|
|
// CLC
|
|
0x18: ["CLC", clr, flags.C, modes.implied, 2],
|
|
|
|
// CLD
|
|
0xD8: ["CLD", clr, flags.D, modes.implied, 2],
|
|
|
|
// CLI
|
|
0x58: ["CLI", clr, flags.I, modes.implied, 2],
|
|
|
|
// CLV
|
|
0xB8: ["CLV", clr, flags.V, modes.implied, 2],
|
|
|
|
// NOP
|
|
0xea: ["NOP", nop, null, modes.implied, 2],
|
|
|
|
// BRK
|
|
0x00: ["BRK", brk, readImmediate, modes.immediate, 7]
|
|
};
|
|
|
|
/* 65C02 Instructions */
|
|
|
|
var cops = {
|
|
// INC / DEC A
|
|
0x1A: ["INC", incA, null, modes.accumulator, 2],
|
|
0x3A: ["DEC", decA, null, modes.accumulator, 2],
|
|
|
|
// Indirect Zero Page for the masses
|
|
0x12: ["ORA", ora, readZeroPageIndirect, modes.zeroPageIndirect, 5],
|
|
0x32: ["AND", and, readZeroPageIndirect, modes.zeroPageIndirect, 5],
|
|
0x52: ["EOR", eor, readZeroPageIndirect, modes.zeroPageIndirect, 5],
|
|
0x72: ["ADC", adc, readZeroPageIndirect, modes.zeroPageIndirect, 5],
|
|
0x92: ["STA", sta, writeZeroPageIndirect, modes.zeroPageIndirect, 5],
|
|
0xB2: ["LDA", lda, readZeroPageIndirect, modes.zeroPageIndirect, 5],
|
|
0xD2: ["CMP", cmp, readZeroPageIndirect, modes.zeroPageIndirect, 5],
|
|
0xF2: ["SBC", sbc, readZeroPageIndirect, modes.zeroPageIndirect, 5],
|
|
|
|
// Better BIT
|
|
0x34: ["BIT", bit, readZeroPageX, modes.zeroPageX, 4],
|
|
0x3C: ["BIT", bit, readAbsoluteX, modes.absoluteX, 4],
|
|
0x89: ["BIT", bitI, readImmediate, modes.immediate, 2],
|
|
|
|
// JMP absolute indirect indexed
|
|
0x6C: ["JMP", jmp, readAddrAbsoluteIndirect,
|
|
modes.absoluteIndirect, 6],
|
|
0x7C: ["JMP", jmp, readAddrAbsoluteXIndirect,
|
|
modes.absoluteXIndirect, 6],
|
|
|
|
// BRA
|
|
0x80: ["BRA", brc, 0, modes.relative, 3],
|
|
|
|
// PHX
|
|
0xDA: ["PHX", phx, null, modes.implied, 3],
|
|
|
|
// PHY
|
|
0x5A: ["PHY", phy, null, modes.implied, 3],
|
|
|
|
// PLX
|
|
0xFA: ["PLX", plx, null, modes.implied, 3],
|
|
|
|
// PLY
|
|
0x7A: ["PLY", ply, null, modes.implied, 3],
|
|
|
|
// STZ
|
|
0x64: ["STZ", stz, writeZeroPage, modes.zeroPage, 3],
|
|
0x74: ["STZ", stz, writeZeroPageX, modes.zeroPageX, 4],
|
|
0x9C: ["STZ", stz, writeAbsolute, modes.absolute, 4],
|
|
0x9E: ["STZ", stz, writeAbsoluteX, modes.absoluteX, 5],
|
|
|
|
// TRB
|
|
0x14: ["TRB", trb, readAddrZeroPage, modes.zeroPage, 5],
|
|
0x1C: ["TRB", trb, readAddrAbsolute, modes.absolute, 6],
|
|
|
|
// TSB
|
|
0x04: ["TSB", tsb, readAddrZeroPage, modes.zeroPage, 5],
|
|
0x0C: ["TSB", tsb, readAddrAbsolute, modes.absolute, 6]
|
|
};
|
|
|
|
if (is65C02) {
|
|
for (var key in cops) {
|
|
ops[key] = cops[key];
|
|
}
|
|
}
|
|
|
|
function unknown(b) {
|
|
var unk;
|
|
|
|
if (is65C02) {
|
|
unk = ["NOP (" + toHex(b) + ")", function() {
|
|
debug("Unknown OpCode: " + toHex(b) + " at " + toHex(pc - 1, 4));
|
|
}, null, modes.implied, 2];
|
|
} else {
|
|
unk = ["???",
|
|
function() { /* debug("Unknown OpCode: " + toHex(b) +
|
|
" at " + toHex(pc - 1, 4)); */ },
|
|
null, modes.implied,
|
|
1];
|
|
}
|
|
ops[b] = unk;
|
|
return unk;
|
|
}
|
|
|
|
/* Certain browsers benefit from using arrays over maps */
|
|
var opary = [];
|
|
|
|
for (idx = 0; idx < 0x100; idx++) {
|
|
opary[idx] = ops[idx] || unknown(idx);
|
|
}
|
|
|
|
function dumpArgs(addr, m, symbols) {
|
|
function toHexOrSymbol(v, n) {
|
|
if (symbols && symbols[v]) {
|
|
return symbols[v];
|
|
} else {
|
|
return "$" + toHex(v, n);
|
|
}
|
|
}
|
|
var result = "";
|
|
switch (m) {
|
|
case modes.implied:
|
|
break;
|
|
case modes.immediate:
|
|
result = "#" + toHexOrSymbol(readByte(addr, true));
|
|
break;
|
|
case modes.absolute:
|
|
result = "" + toHexOrSymbol(readWord(addr, true), 4);
|
|
break;
|
|
case modes.zeroPage:
|
|
result = "" + toHexOrSymbol(readByte(addr, true));
|
|
break;
|
|
case modes.relative:
|
|
{
|
|
var off = readByte(addr, true);
|
|
if (off > 127) {
|
|
off -= 256;
|
|
}
|
|
addr += off + 1;
|
|
result = "" + toHexOrSymbol(addr, 4) + " (" + off + ")";
|
|
}
|
|
break;
|
|
case modes.absoluteX:
|
|
result = "" + toHexOrSymbol(readWord(addr, true), 4) + ",X";
|
|
break;
|
|
case modes.absoluteY:
|
|
result = "" + toHexOrSymbol(readWord(addr, true), 4) + ",Y";
|
|
break;
|
|
case modes.zeroPageX:
|
|
result = "" + toHexOrSymbol(readByte(addr, true)) + ",X";
|
|
break;
|
|
case modes.zeroPageY:
|
|
result = "" + toHexOrSymbol(readByte(addr, true)) + ",Y";
|
|
break;
|
|
case modes.absoluteIndirect:
|
|
result = "(" + toHexOrSymbol(readWord(addr, true), 4) + ")";
|
|
break;
|
|
case modes.zeroPageXIndirect:
|
|
result = "(" + toHexOrSymbol(readByte(addr, true)) + ",X)";
|
|
break;
|
|
case modes.zeroPageIndirectY:
|
|
result = "(" + toHexOrSymbol(readByte(addr, true)) + "),Y";
|
|
break;
|
|
case modes.accumulator:
|
|
result = "A";
|
|
break;
|
|
case modes.zeroPageIndirect:
|
|
result = "(" + toHexOrSymbol(readByte(addr, true)) + ")";
|
|
break;
|
|
case modes.absoluteXIndirect:
|
|
result = "(" + toHexOrSymbol(readWord(addr, true), 4) + ",X)";
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
return {
|
|
step: function cpu_step(cb) {
|
|
var op = opary[readBytePC()];
|
|
|
|
op[1](op[2]);
|
|
cycles += op[4];
|
|
|
|
if (cb) {
|
|
inCallback = true;
|
|
cb(this);
|
|
inCallback = false;
|
|
}
|
|
},
|
|
|
|
stepN: function(n) {
|
|
var op, idx;
|
|
|
|
for (idx = 0; idx < n; idx++) {
|
|
op = opary[readBytePC()];
|
|
op[1](op[2]);
|
|
cycles += op[4];
|
|
}
|
|
},
|
|
|
|
stepCycles: function(c) {
|
|
var op, end = cycles + c;
|
|
|
|
while (cycles < end) {
|
|
op = opary[readBytePC()];
|
|
op[1](op[2]);
|
|
cycles += op[4];
|
|
}
|
|
},
|
|
|
|
stepCyclesDebug: function(c, cb)
|
|
{
|
|
var op, end = cycles + c;
|
|
|
|
if (inCallback)
|
|
return;
|
|
|
|
while (cycles < end) {
|
|
op = opary[readBytePC()];
|
|
op[1](op[2]);
|
|
cycles += op[4];
|
|
|
|
if (cb) {
|
|
inCallback = true;
|
|
cb(this);
|
|
inCallback = false;
|
|
}
|
|
}
|
|
},
|
|
|
|
addPageHandler: function(pho) {
|
|
for (var idx = pho.start(); idx <= pho.end(); idx++) {
|
|
writePages[idx] = pho;
|
|
if (pho.read)
|
|
readPages[idx] = pho;
|
|
if (pho.write)
|
|
writePages[idx] = pho;
|
|
}
|
|
if (pho.reset)
|
|
resetHandlers.push(pho);
|
|
},
|
|
|
|
reset: function cpu_reset()
|
|
{
|
|
// cycles = 0;
|
|
sr = 0x20;
|
|
sp = 0xff;
|
|
ar = 0;
|
|
yr = 0;
|
|
xr = 0;
|
|
pc = readWord(loc.RESET);
|
|
|
|
for (var idx = 0; idx < resetHandlers.length; idx++) {
|
|
resetHandlers[idx].reset();
|
|
}
|
|
},
|
|
|
|
setPC: function(_pc) {
|
|
pc = _pc;
|
|
},
|
|
|
|
dumpPC: function(_pc, symbols) {
|
|
if (_pc === undefined) {
|
|
_pc = pc;
|
|
}
|
|
var b = readByte(_pc, true),
|
|
op = ops[b],
|
|
size = sizes[op[3]],
|
|
result = toHex(_pc, 4) + "- ";
|
|
|
|
if (symbols) {
|
|
if (symbols[_pc]) {
|
|
result += symbols[_pc] +
|
|
" ".substring(symbols[_pc].length);
|
|
} else {
|
|
result += " ";
|
|
}
|
|
}
|
|
|
|
for (var idx = 0; idx < 4; idx++) {
|
|
if (idx < size) {
|
|
result += toHex(readByte(_pc + idx, true)) + " ";
|
|
} else {
|
|
result += " ";
|
|
}
|
|
}
|
|
|
|
if (op === undefined)
|
|
result += "??? (" + toHex(b) + ")";
|
|
else
|
|
result += op[0] + " " + dumpArgs(_pc + 1, op[3], symbols);
|
|
|
|
return result;
|
|
},
|
|
|
|
dumpPage: function(start, end) {
|
|
var result = "";
|
|
if (start === undefined) {
|
|
start = pc >> 8;
|
|
}
|
|
if (end === undefined) {
|
|
end = start;
|
|
}
|
|
for (var page = start; page <= end; page++) {
|
|
var b, idx, jdx;
|
|
for (idx = 0; idx < 16; idx++) {
|
|
result += toHex(page) + toHex(idx << 4) + ": ";
|
|
for (jdx = 0; jdx < 16; jdx++) {
|
|
b = readByte(page * 256 + idx * 16 + jdx, true);
|
|
result += toHex(b) + " ";
|
|
}
|
|
result += " ";
|
|
for (jdx = 0; jdx < 16; jdx++) {
|
|
b = readByte(page * 256 + idx * 16 + jdx, true) & 0x7f;
|
|
if (b >= 0x20 && b < 0x7f) {
|
|
result += String.fromCharCode(b);
|
|
} else {
|
|
result += ".";
|
|
}
|
|
}
|
|
result += "\n";
|
|
}
|
|
}
|
|
return result;
|
|
},
|
|
|
|
list: function(_pc, symbols) {
|
|
if (_pc === undefined) {
|
|
_pc = pc;
|
|
}
|
|
var results = [];
|
|
for (var jdx = 0; jdx < 20; jdx++) {
|
|
var b = readByte(_pc), op = ops[b];
|
|
results.push(this.dumpPC(_pc, symbols));
|
|
_pc += sizes[op[3]];
|
|
}
|
|
return results;
|
|
},
|
|
|
|
cycles: function() {
|
|
return cycles;
|
|
},
|
|
|
|
registers: function() {
|
|
return [pc,ar,xr,yr,sr,sp];
|
|
},
|
|
|
|
getState: function() {
|
|
return {
|
|
a: ar,
|
|
x: xr,
|
|
y: yr,
|
|
s: sr,
|
|
pc: pc,
|
|
sp: sp,
|
|
cycles: cycles
|
|
};
|
|
},
|
|
|
|
setState: function(state) {
|
|
ar = state.a;
|
|
xr = state.x;
|
|
yr = state.y;
|
|
sr = state.s;
|
|
pc = state.pc;
|
|
sp = state.sp;
|
|
cycles = state.cycles;
|
|
},
|
|
|
|
dumpRegisters: function() {
|
|
return toHex(pc, 4) +
|
|
"- A=" + toHex(ar) +
|
|
" X=" + toHex(xr) +
|
|
" Y=" + toHex(yr) +
|
|
" P=" + toHex(sr) +
|
|
" S=" + toHex(sp) +
|
|
" " +
|
|
(sr & flags.N ? "N" : "-") +
|
|
(sr & flags.V ? "V" : "-") +
|
|
"-" +
|
|
(sr & flags.B ? "B" : "-") +
|
|
(sr & flags.D ? "D" : "-") +
|
|
(sr & flags.I ? "I" : "-") +
|
|
(sr & flags.Z ? "Z" : "-") +
|
|
(sr & flags.C ? "C" : "-");
|
|
},
|
|
|
|
write: function(page, off, val) {
|
|
writePages[page].write(page, off, val);
|
|
}
|
|
};
|
|
}
|
|
|