2661 lines
66 KiB
JavaScript
2661 lines
66 KiB
JavaScript
/*
|
|
* 6502 assembler and simulator in Javascript
|
|
* (C)2006-2010 Stian Soreng - www.6502asm.com
|
|
*
|
|
* Adapted by Nick Morgan
|
|
* https://github.com/skilldrick/6502js
|
|
*
|
|
* Released under the GNU General Public License
|
|
* see http://gnu.org/licenses/gpl.html
|
|
*/
|
|
/* eslint no-use-before-define: 0 */ // --> OFF
|
|
|
|
'use strict';
|
|
|
|
function SimulatorWidget(node) {
|
|
var $node = $(node);
|
|
var ui = UI();
|
|
var display = Display();
|
|
var memory = Memory();
|
|
var labels = Labels();
|
|
var simulator = Simulator();
|
|
var assembler = Assembler();
|
|
|
|
function initialize() {
|
|
stripText();
|
|
ui.initialize();
|
|
display.initialize();
|
|
simulator.reset();
|
|
|
|
$node.find('.assembleButton').click(function () {
|
|
assembler.assembleCode();
|
|
});
|
|
$node.find('.runButton').click(simulator.runBinary);
|
|
$node.find('.runButton').click(simulator.stopDebugger);
|
|
$node.find('.resetButton').click(simulator.reset);
|
|
$node.find('.hexdumpButton').click(assembler.hexdump).trigger('keydown', {which: 65});
|
|
$node.find('.disassembleButton').click(assembler.disassemble);
|
|
$node.find('.debug').on('click', function () {
|
|
$(this).toggleClass('active');
|
|
var debug = $(this).hasClass('active');
|
|
if (debug) {
|
|
ui.debugOn();
|
|
simulator.enableDebugger();
|
|
} else {
|
|
ui.debugOff();
|
|
simulator.stopDebugger();
|
|
}
|
|
});
|
|
$node.find('.monitoring').on('click', function () {
|
|
$(this).toggleClass('active');
|
|
if($(this).hasClass('active')) {
|
|
|
|
}
|
|
ui.toggleMonitor();
|
|
simulator.toggleMonitor();
|
|
});
|
|
$node.find('.start, .length').blur(simulator.handleMonitorRangeChange);
|
|
$node.find('.stepButton').click(simulator.debugExec);
|
|
$node.find('.gotoButton').click(simulator.gotoAddr);
|
|
$node.find('.notesButton').click(ui.showNotes);
|
|
|
|
var editor = $node.find('.code');
|
|
|
|
editor.on('keypress input', simulator.stop);
|
|
editor.on('keypress input', ui.initialize);
|
|
editor.keydown(ui.captureTabInEditor);
|
|
|
|
$(document).keypress(memory.storeKeypress);
|
|
|
|
simulator.handleMonitorRangeChange();
|
|
}
|
|
|
|
function stripText() {
|
|
//Remove leading and trailing space in textarea
|
|
var text = $node.find('.code').val();
|
|
text = text.replace(/^\n+/, '').replace(/\s+$/, '');
|
|
$node.find('.code').val(text);
|
|
}
|
|
|
|
function UI() {
|
|
var currentState;
|
|
|
|
var start = {
|
|
assemble: true,
|
|
run: [false, 'Run'],
|
|
reset: false,
|
|
hexdump: false,
|
|
disassemble: false,
|
|
debug: [false, false]
|
|
};
|
|
var assembled = {
|
|
assemble: false,
|
|
run: [true, 'Run'],
|
|
reset: true,
|
|
hexdump: true,
|
|
disassemble: true,
|
|
debug: [true, false]
|
|
};
|
|
var running = {
|
|
assemble: false,
|
|
run: [true, 'Stop'],
|
|
reset: true,
|
|
hexdump: false,
|
|
disassemble: false,
|
|
debug: [true, false]
|
|
};
|
|
var debugging = {
|
|
assemble: false,
|
|
reset: true,
|
|
hexdump: true,
|
|
disassemble: true,
|
|
debug: [true, true]
|
|
};
|
|
var postDebugging = {
|
|
assemble: false,
|
|
reset: true,
|
|
hexdump: true,
|
|
disassemble: true,
|
|
debug: [true, false]
|
|
};
|
|
|
|
|
|
function setState(state) {
|
|
$node.find('.assembleButton').attr('disabled', !state.assemble);
|
|
if (state.run) {
|
|
$node.find('.runButton').attr('disabled', !state.run[0]);
|
|
$node.find('.runButton').val(state.run[1]);
|
|
}
|
|
$node.find('.resetButton').attr('disabled', !state.reset);
|
|
$node.find('.hexdumpButton').attr('disabled', !state.hexdump);
|
|
$node.find('.disassembleButton').attr('disabled', !state.disassemble);
|
|
$node.find('.debug').attr('disabled', !state.debug[0]);
|
|
$node.find('.debug').attr('checked', state.debug[1]);
|
|
$node.find('.stepButton').attr('disabled', !state.debug[1]);
|
|
$node.find('.gotoButton').attr('disabled', !state.debug[1]);
|
|
currentState = state;
|
|
}
|
|
|
|
function initialize() {
|
|
setState(start);
|
|
}
|
|
|
|
function play() {
|
|
setState(running);
|
|
}
|
|
|
|
function stop() {
|
|
setState(assembled);
|
|
}
|
|
|
|
function debugOn() {
|
|
setState(debugging);
|
|
}
|
|
|
|
function debugOff() {
|
|
setState(postDebugging);
|
|
}
|
|
|
|
function assembleSuccess() {
|
|
setState(assembled);
|
|
}
|
|
|
|
function toggleMonitor() {
|
|
$node.find('.monitor-container').toggle();
|
|
}
|
|
|
|
function showNotes() {
|
|
$node.find('.messages code').html($node.find('.notes').html());
|
|
}
|
|
|
|
function captureTabInEditor(e) {
|
|
// Tab Key
|
|
if(e.keyCode === 9) {
|
|
|
|
// Prevent focus loss
|
|
e.preventDefault();
|
|
|
|
// Insert tab at caret position (instead of losing focus)
|
|
var caretStart = this.selectionStart,
|
|
caretEnd = this.selectionEnd,
|
|
currentValue = this.value;
|
|
|
|
this.value = currentValue.substring(0, caretStart) + '\t' + currentValue.substring(caretEnd);
|
|
|
|
// Move cursor forwards one (after tab)
|
|
this.selectionStart = this.selectionEnd = caretStart + 1;
|
|
}
|
|
}
|
|
|
|
return {
|
|
initialize: initialize,
|
|
play: play,
|
|
stop: stop,
|
|
assembleSuccess: assembleSuccess,
|
|
debugOn: debugOn,
|
|
debugOff: debugOff,
|
|
toggleMonitor: toggleMonitor,
|
|
showNotes: showNotes,
|
|
captureTabInEditor: captureTabInEditor
|
|
};
|
|
}
|
|
|
|
|
|
function Display() {
|
|
var displayArray = [];
|
|
var palette = [
|
|
'#000000', '#ffffff', '#880000', '#aaffee',
|
|
'#cc44cc', '#00cc55', '#0000aa', '#eeee77',
|
|
'#dd8855', '#664400', '#ff7777', '#333333',
|
|
'#777777', '#aaff66', '#0088ff', '#bbbbbb'
|
|
];
|
|
var ctx;
|
|
var width;
|
|
var height;
|
|
var pixelSize;
|
|
var numX = 32;
|
|
var numY = 32;
|
|
|
|
function initialize() {
|
|
var canvas = $node.find('.screen')[0];
|
|
width = canvas.width;
|
|
height = canvas.height;
|
|
pixelSize = width / numX;
|
|
ctx = canvas.getContext('2d');
|
|
reset();
|
|
}
|
|
|
|
function reset() {
|
|
ctx.fillStyle = 'black';
|
|
ctx.fillRect(0, 0, width, height);
|
|
}
|
|
|
|
function updatePixel(addr) {
|
|
ctx.fillStyle = palette[memory.get(addr) & 0x0f];
|
|
var y = Math.floor((addr - 0x200) / 32);
|
|
var x = (addr - 0x200) % 32;
|
|
ctx.fillRect(x * pixelSize, y * pixelSize, pixelSize, pixelSize);
|
|
}
|
|
|
|
return {
|
|
initialize: initialize,
|
|
reset: reset,
|
|
updatePixel: updatePixel
|
|
};
|
|
}
|
|
|
|
function Memory() {
|
|
var memArray = new Array(0x600);
|
|
|
|
function set(addr, val) {
|
|
return memArray[addr] = val;
|
|
}
|
|
|
|
function get(addr) {
|
|
return memArray[addr];
|
|
}
|
|
|
|
function getWord(addr) {
|
|
return get(addr) + (get(addr + 1) << 8);
|
|
}
|
|
|
|
// Poke a byte, don't touch any registers
|
|
function storeByte(addr, value) {
|
|
set(addr, value & 0xff);
|
|
if ((addr >= 0x200) && (addr <= 0x5ff)) {
|
|
display.updatePixel(addr);
|
|
}
|
|
}
|
|
|
|
// Store keycode in ZP $ff
|
|
function storeKeypress(e) {
|
|
var value = e.which;
|
|
memory.storeByte(0xff, value);
|
|
}
|
|
|
|
function format(start, length) {
|
|
var html = '';
|
|
var n;
|
|
|
|
for (var x = 0; x < length; x++) {
|
|
if ((x & 15) === 0) {
|
|
if (x > 0) { html += '\n'; }
|
|
n = (start + x);
|
|
html += num2hex(((n >> 8) & 0xff));
|
|
html += num2hex((n & 0xff));
|
|
html += ': ';
|
|
}
|
|
html += num2hex(memory.get(start + x));
|
|
html += ' ';
|
|
}
|
|
return html;
|
|
}
|
|
|
|
return {
|
|
set: set,
|
|
get: get,
|
|
getWord: getWord,
|
|
storeByte: storeByte,
|
|
storeKeypress: storeKeypress,
|
|
format: format
|
|
};
|
|
}
|
|
|
|
function Simulator() {
|
|
var regA = 0;
|
|
var regX = 0;
|
|
var regY = 0;
|
|
var regP = 0;
|
|
var regPC = 0x600;
|
|
var regSP = 0xff;
|
|
var codeRunning = false;
|
|
var debug = false;
|
|
var monitoring = false;
|
|
var executeId;
|
|
|
|
// Set zero and negative processor flags based on result
|
|
function setNVflags(value) {
|
|
if (value) {
|
|
regP &= 0xfd;
|
|
} else {
|
|
regP |= 0x02;
|
|
}
|
|
if (value & 0x80) {
|
|
regP |= 0x80;
|
|
} else {
|
|
regP &= 0x7f;
|
|
}
|
|
}
|
|
|
|
function setCarryFlagFromBit0(value) {
|
|
regP = (regP & 0xfe) | (value & 1);
|
|
}
|
|
|
|
function setCarryFlagFromBit7(value) {
|
|
regP = (regP & 0xfe) | ((value >> 7) & 1);
|
|
}
|
|
|
|
function setNVflagsForRegA() {
|
|
setNVflags(regA);
|
|
}
|
|
|
|
function setNVflagsForRegX() {
|
|
setNVflags(regX);
|
|
}
|
|
|
|
function setNVflagsForRegY() {
|
|
setNVflags(regY);
|
|
}
|
|
|
|
var ORA = setNVflagsForRegA;
|
|
var AND = setNVflagsForRegA;
|
|
var EOR = setNVflagsForRegA;
|
|
var ASL = setNVflags;
|
|
var LSR = setNVflags;
|
|
var ROL = setNVflags;
|
|
var ROR = setNVflags;
|
|
var LDA = setNVflagsForRegA;
|
|
var LDX = setNVflagsForRegX;
|
|
var LDY = setNVflagsForRegY;
|
|
|
|
function BIT(value) {
|
|
if (value & 0x80) {
|
|
regP |= 0x80;
|
|
} else {
|
|
regP &= 0x7f;
|
|
}
|
|
if (value & 0x40) {
|
|
regP |= 0x40;
|
|
} else {
|
|
regP &= ~0x40;
|
|
}
|
|
if (regA & value) {
|
|
regP &= 0xfd;
|
|
} else {
|
|
regP |= 0x02;
|
|
}
|
|
}
|
|
|
|
function CLC() {
|
|
regP &= 0xfe;
|
|
}
|
|
|
|
function SEC() {
|
|
regP |= 1;
|
|
}
|
|
|
|
|
|
function CLV() {
|
|
regP &= 0xbf;
|
|
}
|
|
|
|
function setOverflow() {
|
|
regP |= 0x40;
|
|
}
|
|
|
|
function DEC(addr) {
|
|
var value = memory.get(addr);
|
|
value--;
|
|
value &= 0xff;
|
|
memory.storeByte(addr, value);
|
|
setNVflags(value);
|
|
}
|
|
|
|
function INC(addr) {
|
|
var value = memory.get(addr);
|
|
value++;
|
|
value &= 0xff;
|
|
memory.storeByte(addr, value);
|
|
setNVflags(value);
|
|
}
|
|
|
|
function jumpBranch(offset) {
|
|
if (offset > 0x7f) {
|
|
regPC = (regPC - (0x100 - offset));
|
|
} else {
|
|
regPC = (regPC + offset);
|
|
}
|
|
}
|
|
|
|
function overflowSet() {
|
|
return regP & 0x40;
|
|
}
|
|
|
|
function decimalMode() {
|
|
return regP & 8;
|
|
}
|
|
|
|
function carrySet() {
|
|
return regP & 1;
|
|
}
|
|
|
|
function negativeSet() {
|
|
return regP & 0x80;
|
|
}
|
|
|
|
function zeroSet() {
|
|
return regP & 0x02;
|
|
}
|
|
|
|
function doCompare(reg, val) {
|
|
if (reg >= val) {
|
|
SEC();
|
|
} else {
|
|
CLC();
|
|
}
|
|
val = (reg - val);
|
|
setNVflags(val);
|
|
}
|
|
|
|
function testSBC(value) {
|
|
var tmp, w;
|
|
if ((regA ^ value) & 0x80) {
|
|
setOverflow();
|
|
} else {
|
|
CLV();
|
|
}
|
|
|
|
if (decimalMode()) {
|
|
tmp = 0xf + (regA & 0xf) - (value & 0xf) + carrySet();
|
|
if (tmp < 0x10) {
|
|
w = 0;
|
|
tmp -= 6;
|
|
} else {
|
|
w = 0x10;
|
|
tmp -= 0x10;
|
|
}
|
|
w += 0xf0 + (regA & 0xf0) - (value & 0xf0);
|
|
if (w < 0x100) {
|
|
CLC();
|
|
if (overflowSet() && w < 0x80) { CLV(); }
|
|
w -= 0x60;
|
|
} else {
|
|
SEC();
|
|
if (overflowSet() && w >= 0x180) { CLV(); }
|
|
}
|
|
w += tmp;
|
|
} else {
|
|
w = 0xff + regA - value + carrySet();
|
|
if (w < 0x100) {
|
|
CLC();
|
|
if (overflowSet() && w < 0x80) { CLV(); }
|
|
} else {
|
|
SEC();
|
|
if (overflowSet() && w >= 0x180) { CLV(); }
|
|
}
|
|
}
|
|
regA = w & 0xff;
|
|
setNVflagsForRegA();
|
|
}
|
|
|
|
function testADC(value) {
|
|
var tmp;
|
|
if ((regA ^ value) & 0x80) {
|
|
CLV();
|
|
} else {
|
|
setOverflow();
|
|
}
|
|
|
|
if (decimalMode()) {
|
|
tmp = (regA & 0xf) + (value & 0xf) + carrySet();
|
|
if (tmp >= 10) {
|
|
tmp = 0x10 | ((tmp + 6) & 0xf);
|
|
}
|
|
tmp += (regA & 0xf0) + (value & 0xf0);
|
|
if (tmp >= 160) {
|
|
SEC();
|
|
if (overflowSet() && tmp >= 0x180) { CLV(); }
|
|
tmp += 0x60;
|
|
} else {
|
|
CLC();
|
|
if (overflowSet() && tmp < 0x80) { CLV(); }
|
|
}
|
|
} else {
|
|
tmp = regA + value + carrySet();
|
|
if (tmp >= 0x100) {
|
|
SEC();
|
|
if (overflowSet() && tmp >= 0x180) { CLV(); }
|
|
} else {
|
|
CLC();
|
|
if (overflowSet() && tmp < 0x80) { CLV(); }
|
|
}
|
|
}
|
|
regA = tmp & 0xff;
|
|
setNVflagsForRegA();
|
|
}
|
|
|
|
var instructions = {
|
|
i00: function () {
|
|
codeRunning = false;
|
|
//BRK
|
|
},
|
|
|
|
i01: function () {
|
|
var zp = (popByte() + regX) & 0xff;
|
|
var addr = memory.getWord(zp);
|
|
var value = memory.get(addr);
|
|
regA |= value;
|
|
ORA();
|
|
},
|
|
|
|
i05: function () {
|
|
var zp = popByte();
|
|
regA |= memory.get(zp);
|
|
ORA();
|
|
},
|
|
|
|
i06: function () {
|
|
var zp = popByte();
|
|
var value = memory.get(zp);
|
|
setCarryFlagFromBit7(value);
|
|
value = value << 1;
|
|
memory.storeByte(zp, value);
|
|
ASL(value);
|
|
},
|
|
|
|
i08: function () {
|
|
stackPush(regP | 0x30);
|
|
//PHP
|
|
},
|
|
|
|
i09: function () {
|
|
regA |= popByte();
|
|
ORA();
|
|
},
|
|
|
|
i0a: function () {
|
|
setCarryFlagFromBit7(regA);
|
|
regA = (regA << 1) & 0xff;
|
|
ASL(regA);
|
|
},
|
|
|
|
i0d: function () {
|
|
regA |= memory.get(popWord());
|
|
ORA();
|
|
},
|
|
|
|
i0e: function () {
|
|
var addr = popWord();
|
|
var value = memory.get(addr);
|
|
setCarryFlagFromBit7(value);
|
|
value = value << 1;
|
|
memory.storeByte(addr, value);
|
|
ASL(value);
|
|
},
|
|
|
|
i10: function () {
|
|
var offset = popByte();
|
|
if (!negativeSet()) { jumpBranch(offset); }
|
|
//BPL
|
|
},
|
|
|
|
i11: function () {
|
|
var zp = popByte();
|
|
var value = memory.getWord(zp) + regY;
|
|
regA |= memory.get(value);
|
|
ORA();
|
|
},
|
|
|
|
i15: function () {
|
|
var addr = (popByte() + regX) & 0xff;
|
|
regA |= memory.get(addr);
|
|
ORA();
|
|
},
|
|
|
|
i16: function () {
|
|
var addr = (popByte() + regX) & 0xff;
|
|
var value = memory.get(addr);
|
|
setCarryFlagFromBit7(value);
|
|
value = value << 1;
|
|
memory.storeByte(addr, value);
|
|
ASL(value);
|
|
},
|
|
|
|
i18: function () {
|
|
CLC();
|
|
},
|
|
|
|
i19: function () {
|
|
var addr = popWord() + regY;
|
|
regA |= memory.get(addr);
|
|
ORA();
|
|
},
|
|
|
|
i1d: function () {
|
|
var addr = popWord() + regX;
|
|
regA |= memory.get(addr);
|
|
ORA();
|
|
},
|
|
|
|
i1e: function () {
|
|
var addr = popWord() + regX;
|
|
var value = memory.get(addr);
|
|
setCarryFlagFromBit7(value);
|
|
value = value << 1;
|
|
memory.storeByte(addr, value);
|
|
ASL(value);
|
|
},
|
|
|
|
i20: function () {
|
|
var addr = popWord();
|
|
var currAddr = regPC - 1;
|
|
stackPush(((currAddr >> 8) & 0xff));
|
|
stackPush((currAddr & 0xff));
|
|
regPC = addr;
|
|
//JSR
|
|
},
|
|
|
|
i21: function () {
|
|
var zp = (popByte() + regX) & 0xff;
|
|
var addr = memory.getWord(zp);
|
|
var value = memory.get(addr);
|
|
regA &= value;
|
|
AND();
|
|
},
|
|
|
|
i24: function () {
|
|
var zp = popByte();
|
|
var value = memory.get(zp);
|
|
BIT(value);
|
|
},
|
|
|
|
i25: function () {
|
|
var zp = popByte();
|
|
regA &= memory.get(zp);
|
|
AND();
|
|
},
|
|
|
|
i26: function () {
|
|
var sf = carrySet();
|
|
var addr = popByte();
|
|
var value = memory.get(addr);
|
|
setCarryFlagFromBit7(value);
|
|
value = value << 1;
|
|
value |= sf;
|
|
memory.storeByte(addr, value);
|
|
ROL(value);
|
|
},
|
|
|
|
i28: function () {
|
|
regP = stackPop() | 0x30; // There is no B bit!
|
|
//PLP
|
|
},
|
|
|
|
i29: function () {
|
|
regA &= popByte();
|
|
AND();
|
|
},
|
|
|
|
i2a: function () {
|
|
var sf = carrySet();
|
|
setCarryFlagFromBit7(regA);
|
|
regA = (regA << 1) & 0xff;
|
|
regA |= sf;
|
|
ROL(regA);
|
|
},
|
|
|
|
i2c: function () {
|
|
var value = memory.get(popWord());
|
|
BIT(value);
|
|
},
|
|
|
|
i2d: function () {
|
|
var value = memory.get(popWord());
|
|
regA &= value;
|
|
AND();
|
|
},
|
|
|
|
i2e: function () {
|
|
var sf = carrySet();
|
|
var addr = popWord();
|
|
var value = memory.get(addr);
|
|
setCarryFlagFromBit7(value);
|
|
value = value << 1;
|
|
value |= sf;
|
|
memory.storeByte(addr, value);
|
|
ROL(value);
|
|
},
|
|
|
|
i30: function () {
|
|
var offset = popByte();
|
|
if (negativeSet()) { jumpBranch(offset); }
|
|
//BMI
|
|
},
|
|
|
|
i31: function () {
|
|
var zp = popByte();
|
|
var value = memory.getWord(zp) + regY;
|
|
regA &= memory.get(value);
|
|
AND();
|
|
},
|
|
|
|
i35: function () {
|
|
var addr = (popByte() + regX) & 0xff;
|
|
regA &= memory.get(addr);
|
|
AND();
|
|
},
|
|
|
|
i36: function () {
|
|
var sf = carrySet();
|
|
var addr = (popByte() + regX) & 0xff;
|
|
var value = memory.get(addr);
|
|
setCarryFlagFromBit7(value);
|
|
value = value << 1;
|
|
value |= sf;
|
|
memory.storeByte(addr, value);
|
|
ROL(value);
|
|
},
|
|
|
|
i38: function () {
|
|
SEC();
|
|
},
|
|
|
|
i39: function () {
|
|
var addr = popWord() + regY;
|
|
var value = memory.get(addr);
|
|
regA &= value;
|
|
AND();
|
|
},
|
|
|
|
i3d: function () {
|
|
var addr = popWord() + regX;
|
|
var value = memory.get(addr);
|
|
regA &= value;
|
|
AND();
|
|
},
|
|
|
|
i3e: function () {
|
|
var sf = carrySet();
|
|
var addr = popWord() + regX;
|
|
var value = memory.get(addr);
|
|
setCarryFlagFromBit7(value);
|
|
value = value << 1;
|
|
value |= sf;
|
|
memory.storeByte(addr, value);
|
|
ROL(value);
|
|
},
|
|
|
|
i40: function () {
|
|
regP = stackPop() | 0x30; // There is no B bit!
|
|
regPC = stackPop() | (stackPop() << 8);
|
|
//RTI
|
|
},
|
|
|
|
i41: function () {
|
|
var zp = (popByte() + regX) & 0xff;
|
|
var value = memory.getWord(zp);
|
|
regA ^= memory.get(value);
|
|
EOR();
|
|
},
|
|
|
|
i45: function () {
|
|
var addr = popByte() & 0xff;
|
|
var value = memory.get(addr);
|
|
regA ^= value;
|
|
EOR();
|
|
},
|
|
|
|
i46: function () {
|
|
var addr = popByte() & 0xff;
|
|
var value = memory.get(addr);
|
|
setCarryFlagFromBit0(value);
|
|
value = value >> 1;
|
|
memory.storeByte(addr, value);
|
|
LSR(value);
|
|
},
|
|
|
|
i48: function () {
|
|
stackPush(regA);
|
|
//PHA
|
|
},
|
|
|
|
i49: function () {
|
|
regA ^= popByte();
|
|
EOR();
|
|
},
|
|
|
|
i4a: function () {
|
|
setCarryFlagFromBit0(regA);
|
|
regA = regA >> 1;
|
|
LSR(regA);
|
|
},
|
|
|
|
i4c: function () {
|
|
regPC = popWord();
|
|
//JMP
|
|
},
|
|
|
|
i4d: function () {
|
|
var addr = popWord();
|
|
var value = memory.get(addr);
|
|
regA ^= value;
|
|
EOR();
|
|
},
|
|
|
|
i4e: function () {
|
|
var addr = popWord();
|
|
var value = memory.get(addr);
|
|
setCarryFlagFromBit0(value);
|
|
value = value >> 1;
|
|
memory.storeByte(addr, value);
|
|
LSR(value);
|
|
},
|
|
|
|
i50: function () {
|
|
var offset = popByte();
|
|
if (!overflowSet()) { jumpBranch(offset); }
|
|
//BVC
|
|
},
|
|
|
|
i51: function () {
|
|
var zp = popByte();
|
|
var value = memory.getWord(zp) + regY;
|
|
regA ^= memory.get(value);
|
|
EOR();
|
|
},
|
|
|
|
i55: function () {
|
|
var addr = (popByte() + regX) & 0xff;
|
|
regA ^= memory.get(addr);
|
|
EOR();
|
|
},
|
|
|
|
i56: function () {
|
|
var addr = (popByte() + regX) & 0xff;
|
|
var value = memory.get(addr);
|
|
setCarryFlagFromBit0(value);
|
|
value = value >> 1;
|
|
memory.storeByte(addr, value);
|
|
LSR(value);
|
|
},
|
|
|
|
i58: function () {
|
|
regP &= ~0x04;
|
|
throw new Error('Interrupts not implemented');
|
|
//CLI
|
|
},
|
|
|
|
i59: function () {
|
|
var addr = popWord() + regY;
|
|
var value = memory.get(addr);
|
|
regA ^= value;
|
|
EOR();
|
|
},
|
|
|
|
i5d: function () {
|
|
var addr = popWord() + regX;
|
|
var value = memory.get(addr);
|
|
regA ^= value;
|
|
EOR();
|
|
},
|
|
|
|
i5e: function () {
|
|
var addr = popWord() + regX;
|
|
var value = memory.get(addr);
|
|
setCarryFlagFromBit0(value);
|
|
value = value >> 1;
|
|
memory.storeByte(addr, value);
|
|
LSR(value);
|
|
},
|
|
|
|
i60: function () {
|
|
regPC = (stackPop() | (stackPop() << 8)) + 1;
|
|
//RTS
|
|
},
|
|
|
|
i61: function () {
|
|
var zp = (popByte() + regX) & 0xff;
|
|
var addr = memory.getWord(zp);
|
|
var value = memory.get(addr);
|
|
testADC(value);
|
|
//ADC
|
|
},
|
|
|
|
i65: function () {
|
|
var addr = popByte();
|
|
var value = memory.get(addr);
|
|
testADC(value);
|
|
//ADC
|
|
},
|
|
|
|
i66: function () {
|
|
var sf = carrySet();
|
|
var addr = popByte();
|
|
var value = memory.get(addr);
|
|
setCarryFlagFromBit0(value);
|
|
value = value >> 1;
|
|
if (sf) { value |= 0x80; }
|
|
memory.storeByte(addr, value);
|
|
ROR(value);
|
|
},
|
|
|
|
i68: function () {
|
|
regA = stackPop();
|
|
setNVflagsForRegA();
|
|
//PLA
|
|
},
|
|
|
|
i69: function () {
|
|
var value = popByte();
|
|
testADC(value);
|
|
//ADC
|
|
},
|
|
|
|
i6a: function () {
|
|
var sf = carrySet();
|
|
setCarryFlagFromBit0(regA);
|
|
regA = regA >> 1;
|
|
if (sf) { regA |= 0x80; }
|
|
ROR(regA);
|
|
},
|
|
|
|
i6c: function () {
|
|
regPC = memory.getWord(popWord());
|
|
//JMP
|
|
},
|
|
|
|
i6d: function () {
|
|
var addr = popWord();
|
|
var value = memory.get(addr);
|
|
testADC(value);
|
|
//ADC
|
|
},
|
|
|
|
i6e: function () {
|
|
var sf = carrySet();
|
|
var addr = popWord();
|
|
var value = memory.get(addr);
|
|
setCarryFlagFromBit0(value);
|
|
value = value >> 1;
|
|
if (sf) { value |= 0x80; }
|
|
memory.storeByte(addr, value);
|
|
ROR(value);
|
|
},
|
|
|
|
i70: function () {
|
|
var offset = popByte();
|
|
if (overflowSet()) { jumpBranch(offset); }
|
|
//BVS
|
|
},
|
|
|
|
i71: function () {
|
|
var zp = popByte();
|
|
var addr = memory.getWord(zp);
|
|
var value = memory.get(addr + regY);
|
|
testADC(value);
|
|
//ADC
|
|
},
|
|
|
|
i75: function () {
|
|
var addr = (popByte() + regX) & 0xff;
|
|
var value = memory.get(addr);
|
|
testADC(value);
|
|
//ADC
|
|
},
|
|
|
|
i76: function () {
|
|
var sf = carrySet();
|
|
var addr = (popByte() + regX) & 0xff;
|
|
var value = memory.get(addr);
|
|
setCarryFlagFromBit0(value);
|
|
value = value >> 1;
|
|
if (sf) { value |= 0x80; }
|
|
memory.storeByte(addr, value);
|
|
ROR(value);
|
|
},
|
|
|
|
i78: function () {
|
|
regP |= 0x04;
|
|
throw new Error('Interrupts not implemented');
|
|
//SEI
|
|
},
|
|
|
|
i79: function () {
|
|
var addr = popWord();
|
|
var value = memory.get(addr + regY);
|
|
testADC(value);
|
|
//ADC
|
|
},
|
|
|
|
i7d: function () {
|
|
var addr = popWord();
|
|
var value = memory.get(addr + regX);
|
|
testADC(value);
|
|
//ADC
|
|
},
|
|
|
|
i7e: function () {
|
|
var sf = carrySet();
|
|
var addr = popWord() + regX;
|
|
var value = memory.get(addr);
|
|
setCarryFlagFromBit0(value);
|
|
value = value >> 1;
|
|
if (sf) { value |= 0x80; }
|
|
memory.storeByte(addr, value);
|
|
ROR(value);
|
|
},
|
|
|
|
i81: function () {
|
|
var zp = (popByte() + regX) & 0xff;
|
|
var addr = memory.getWord(zp);
|
|
memory.storeByte(addr, regA);
|
|
//STA
|
|
},
|
|
|
|
i84: function () {
|
|
memory.storeByte(popByte(), regY);
|
|
//STY
|
|
},
|
|
|
|
i85: function () {
|
|
memory.storeByte(popByte(), regA);
|
|
//STA
|
|
},
|
|
|
|
i86: function () {
|
|
memory.storeByte(popByte(), regX);
|
|
//STX
|
|
},
|
|
|
|
i88: function () {
|
|
regY = (regY - 1) & 0xff;
|
|
setNVflagsForRegY();
|
|
//DEY
|
|
},
|
|
|
|
i8a: function () {
|
|
regA = regX & 0xff;
|
|
setNVflagsForRegA();
|
|
//TXA
|
|
},
|
|
|
|
i8c: function () {
|
|
memory.storeByte(popWord(), regY);
|
|
//STY
|
|
},
|
|
|
|
i8d: function () {
|
|
memory.storeByte(popWord(), regA);
|
|
//STA
|
|
},
|
|
|
|
i8e: function () {
|
|
memory.storeByte(popWord(), regX);
|
|
//STX
|
|
},
|
|
|
|
i90: function () {
|
|
var offset = popByte();
|
|
if (!carrySet()) { jumpBranch(offset); }
|
|
//BCC
|
|
},
|
|
|
|
i91: function () {
|
|
var zp = popByte();
|
|
var addr = memory.getWord(zp) + regY;
|
|
memory.storeByte(addr, regA);
|
|
//STA
|
|
},
|
|
|
|
i94: function () {
|
|
memory.storeByte((popByte() + regX) & 0xff, regY);
|
|
//STY
|
|
},
|
|
|
|
i95: function () {
|
|
memory.storeByte((popByte() + regX) & 0xff, regA);
|
|
//STA
|
|
},
|
|
|
|
i96: function () {
|
|
memory.storeByte((popByte() + regY) & 0xff, regX);
|
|
//STX
|
|
},
|
|
|
|
i98: function () {
|
|
regA = regY & 0xff;
|
|
setNVflagsForRegA();
|
|
//TYA
|
|
},
|
|
|
|
i99: function () {
|
|
memory.storeByte(popWord() + regY, regA);
|
|
//STA
|
|
},
|
|
|
|
i9a: function () {
|
|
regSP = regX & 0xff;
|
|
//TXS
|
|
},
|
|
|
|
i9d: function () {
|
|
var addr = popWord();
|
|
memory.storeByte(addr + regX, regA);
|
|
//STA
|
|
},
|
|
|
|
ia0: function () {
|
|
regY = popByte();
|
|
LDY();
|
|
},
|
|
|
|
ia1: function () {
|
|
var zp = (popByte() + regX) & 0xff;
|
|
var addr = memory.getWord(zp);
|
|
regA = memory.get(addr);
|
|
LDA();
|
|
},
|
|
|
|
ia2: function () {
|
|
regX = popByte();
|
|
LDX();
|
|
},
|
|
|
|
ia4: function () {
|
|
regY = memory.get(popByte());
|
|
LDY();
|
|
},
|
|
|
|
ia5: function () {
|
|
regA = memory.get(popByte());
|
|
LDA();
|
|
},
|
|
|
|
ia6: function () {
|
|
regX = memory.get(popByte());
|
|
LDX();
|
|
},
|
|
|
|
ia8: function () {
|
|
regY = regA & 0xff;
|
|
setNVflagsForRegY();
|
|
//TAY
|
|
},
|
|
|
|
ia9: function () {
|
|
regA = popByte();
|
|
LDA();
|
|
},
|
|
|
|
iaa: function () {
|
|
regX = regA & 0xff;
|
|
setNVflagsForRegX();
|
|
//TAX
|
|
},
|
|
|
|
iac: function () {
|
|
regY = memory.get(popWord());
|
|
LDY();
|
|
},
|
|
|
|
iad: function () {
|
|
regA = memory.get(popWord());
|
|
LDA();
|
|
},
|
|
|
|
iae: function () {
|
|
regX = memory.get(popWord());
|
|
LDX();
|
|
},
|
|
|
|
ib0: function () {
|
|
var offset = popByte();
|
|
if (carrySet()) { jumpBranch(offset); }
|
|
//BCS
|
|
},
|
|
|
|
ib1: function () {
|
|
var zp = popByte();
|
|
var addr = memory.getWord(zp) + regY;
|
|
regA = memory.get(addr);
|
|
LDA();
|
|
},
|
|
|
|
ib4: function () {
|
|
regY = memory.get((popByte() + regX) & 0xff);
|
|
LDY();
|
|
},
|
|
|
|
ib5: function () {
|
|
regA = memory.get((popByte() + regX) & 0xff);
|
|
LDA();
|
|
},
|
|
|
|
ib6: function () {
|
|
regX = memory.get((popByte() + regY) & 0xff);
|
|
LDX();
|
|
},
|
|
|
|
ib8: function () {
|
|
CLV();
|
|
},
|
|
|
|
ib9: function () {
|
|
var addr = popWord() + regY;
|
|
regA = memory.get(addr);
|
|
LDA();
|
|
},
|
|
|
|
iba: function () {
|
|
regX = regSP & 0xff;
|
|
LDX();
|
|
//TSX
|
|
},
|
|
|
|
ibc: function () {
|
|
var addr = popWord() + regX;
|
|
regY = memory.get(addr);
|
|
LDY();
|
|
},
|
|
|
|
ibd: function () {
|
|
var addr = popWord() + regX;
|
|
regA = memory.get(addr);
|
|
LDA();
|
|
},
|
|
|
|
ibe: function () {
|
|
var addr = popWord() + regY;
|
|
regX = memory.get(addr);
|
|
LDX();
|
|
},
|
|
|
|
ic0: function () {
|
|
var value = popByte();
|
|
doCompare(regY, value);
|
|
//CPY
|
|
},
|
|
|
|
ic1: function () {
|
|
var zp = (popByte() + regX) & 0xff;
|
|
var addr = memory.getWord(zp);
|
|
var value = memory.get(addr);
|
|
doCompare(regA, value);
|
|
//CPA
|
|
},
|
|
|
|
ic4: function () {
|
|
var value = memory.get(popByte());
|
|
doCompare(regY, value);
|
|
//CPY
|
|
},
|
|
|
|
ic5: function () {
|
|
var value = memory.get(popByte());
|
|
doCompare(regA, value);
|
|
//CPA
|
|
},
|
|
|
|
ic6: function () {
|
|
var zp = popByte();
|
|
DEC(zp);
|
|
},
|
|
|
|
ic8: function () {
|
|
regY = (regY + 1) & 0xff;
|
|
setNVflagsForRegY();
|
|
//INY
|
|
},
|
|
|
|
ic9: function () {
|
|
var value = popByte();
|
|
doCompare(regA, value);
|
|
//CMP
|
|
},
|
|
|
|
ica: function () {
|
|
regX = (regX - 1) & 0xff;
|
|
setNVflagsForRegX();
|
|
//DEX
|
|
},
|
|
|
|
icc: function () {
|
|
var value = memory.get(popWord());
|
|
doCompare(regY, value);
|
|
//CPY
|
|
},
|
|
|
|
icd: function () {
|
|
var value = memory.get(popWord());
|
|
doCompare(regA, value);
|
|
//CPA
|
|
},
|
|
|
|
ice: function () {
|
|
var addr = popWord();
|
|
DEC(addr);
|
|
},
|
|
|
|
id0: function () {
|
|
var offset = popByte();
|
|
if (!zeroSet()) { jumpBranch(offset); }
|
|
//BNE
|
|
},
|
|
|
|
id1: function () {
|
|
var zp = popByte();
|
|
var addr = memory.getWord(zp) + regY;
|
|
var value = memory.get(addr);
|
|
doCompare(regA, value);
|
|
//CMP
|
|
},
|
|
|
|
id5: function () {
|
|
var value = memory.get((popByte() + regX) & 0xff);
|
|
doCompare(regA, value);
|
|
//CMP
|
|
},
|
|
|
|
id6: function () {
|
|
var addr = (popByte() + regX) & 0xff;
|
|
DEC(addr);
|
|
},
|
|
|
|
id8: function () {
|
|
regP &= 0xf7;
|
|
//CLD
|
|
},
|
|
|
|
id9: function () {
|
|
var addr = popWord() + regY;
|
|
var value = memory.get(addr);
|
|
doCompare(regA, value);
|
|
//CMP
|
|
},
|
|
|
|
idd: function () {
|
|
var addr = popWord() + regX;
|
|
var value = memory.get(addr);
|
|
doCompare(regA, value);
|
|
//CMP
|
|
},
|
|
|
|
ide: function () {
|
|
var addr = popWord() + regX;
|
|
DEC(addr);
|
|
},
|
|
|
|
ie0: function () {
|
|
var value = popByte();
|
|
doCompare(regX, value);
|
|
//CPX
|
|
},
|
|
|
|
ie1: function () {
|
|
var zp = (popByte() + regX) & 0xff;
|
|
var addr = memory.getWord(zp);
|
|
var value = memory.get(addr);
|
|
testSBC(value);
|
|
//SBC
|
|
},
|
|
|
|
ie4: function () {
|
|
var value = memory.get(popByte());
|
|
doCompare(regX, value);
|
|
//CPX
|
|
},
|
|
|
|
ie5: function () {
|
|
var addr = popByte();
|
|
var value = memory.get(addr);
|
|
testSBC(value);
|
|
//SBC
|
|
},
|
|
|
|
ie6: function () {
|
|
var zp = popByte();
|
|
INC(zp);
|
|
},
|
|
|
|
ie8: function () {
|
|
regX = (regX + 1) & 0xff;
|
|
setNVflagsForRegX();
|
|
//INX
|
|
},
|
|
|
|
ie9: function () {
|
|
var value = popByte();
|
|
testSBC(value);
|
|
//SBC
|
|
},
|
|
|
|
iea: function () {
|
|
//NOP
|
|
},
|
|
|
|
i42: function () {
|
|
//WDM -- pseudo op for emulator: arg 0 to output A to message box
|
|
var value = popByte();
|
|
if (value == 0)
|
|
message(String.fromCharCode(regA));
|
|
},
|
|
|
|
iec: function () {
|
|
var value = memory.get(popWord());
|
|
doCompare(regX, value);
|
|
//CPX
|
|
},
|
|
|
|
ied: function () {
|
|
var addr = popWord();
|
|
var value = memory.get(addr);
|
|
testSBC(value);
|
|
//SBC
|
|
},
|
|
|
|
iee: function () {
|
|
var addr = popWord();
|
|
INC(addr);
|
|
},
|
|
|
|
if0: function () {
|
|
var offset = popByte();
|
|
if (zeroSet()) { jumpBranch(offset); }
|
|
//BEQ
|
|
},
|
|
|
|
if1: function () {
|
|
var zp = popByte();
|
|
var addr = memory.getWord(zp);
|
|
var value = memory.get(addr + regY);
|
|
testSBC(value);
|
|
//SBC
|
|
},
|
|
|
|
if5: function () {
|
|
var addr = (popByte() + regX) & 0xff;
|
|
var value = memory.get(addr);
|
|
testSBC(value);
|
|
//SBC
|
|
},
|
|
|
|
if6: function () {
|
|
var addr = (popByte() + regX) & 0xff;
|
|
INC(addr);
|
|
},
|
|
|
|
if8: function () {
|
|
regP |= 8;
|
|
//SED
|
|
},
|
|
|
|
if9: function () {
|
|
var addr = popWord();
|
|
var value = memory.get(addr + regY);
|
|
testSBC(value);
|
|
//SBC
|
|
},
|
|
|
|
ifd: function () {
|
|
var addr = popWord();
|
|
var value = memory.get(addr + regX);
|
|
testSBC(value);
|
|
//SBC
|
|
},
|
|
|
|
ife: function () {
|
|
var addr = popWord() + regX;
|
|
INC(addr);
|
|
},
|
|
|
|
ierr: function () {
|
|
message('Address $' + addr2hex(regPC) + ' - unknown opcode');
|
|
codeRunning = false;
|
|
}
|
|
};
|
|
|
|
function stackPush(value) {
|
|
memory.set((regSP & 0xff) + 0x100, value & 0xff);
|
|
regSP--;
|
|
if (regSP < 0) {
|
|
regSP &= 0xff;
|
|
message('6502 Stack filled! Wrapping...');
|
|
}
|
|
}
|
|
|
|
function stackPop() {
|
|
var value;
|
|
regSP++;
|
|
if (regSP >= 0x100) {
|
|
regSP &= 0xff;
|
|
message('6502 Stack emptied! Wrapping...');
|
|
}
|
|
value = memory.get(regSP + 0x100);
|
|
return value;
|
|
}
|
|
|
|
// Pops a byte
|
|
function popByte() {
|
|
return(memory.get(regPC++) & 0xff);
|
|
}
|
|
|
|
// Pops a little-endian word
|
|
function popWord() {
|
|
return popByte() + (popByte() << 8);
|
|
}
|
|
|
|
// Executes the assembled code
|
|
function runBinary() {
|
|
if (codeRunning) {
|
|
// Switch OFF everything
|
|
stop();
|
|
ui.stop();
|
|
} else {
|
|
ui.play();
|
|
codeRunning = true;
|
|
executeId = setInterval(multiExecute, 15);
|
|
}
|
|
}
|
|
|
|
function multiExecute() {
|
|
if (!debug) {
|
|
// use a prime number of iterations to avoid aliasing effects
|
|
|
|
for (var w = 0; w < 97; w++) {
|
|
execute();
|
|
}
|
|
}
|
|
updateDebugInfo();
|
|
}
|
|
|
|
|
|
function executeNextInstruction() {
|
|
var instructionName = popByte().toString(16).toLowerCase();
|
|
if (instructionName.length === 1) {
|
|
instructionName = '0' + instructionName;
|
|
}
|
|
var instruction = instructions['i' + instructionName];
|
|
|
|
if (instruction) {
|
|
instruction();
|
|
} else {
|
|
instructions.ierr();
|
|
}
|
|
}
|
|
|
|
// Executes one instruction. This is the main part of the CPU simulator.
|
|
function execute(debugging) {
|
|
if (!codeRunning && !debugging) { return; }
|
|
|
|
setRandomByte();
|
|
executeNextInstruction();
|
|
|
|
if ((regPC === 0) || (!codeRunning && !debugging)) {
|
|
stop();
|
|
message('Program end at PC=$' + addr2hex(regPC - 1));
|
|
ui.stop();
|
|
}
|
|
}
|
|
|
|
function setRandomByte() {
|
|
memory.set(0xfe, Math.floor(Math.random() * 256));
|
|
}
|
|
|
|
function updateMonitor() {
|
|
if (monitoring) {
|
|
var start = parseInt($node.find('.start').val(), 16);
|
|
var length = parseInt($node.find('.length').val(), 16);
|
|
|
|
var end = start + length - 1;
|
|
|
|
var monitorNode = $node.find('.monitor code');
|
|
|
|
if (!isNaN(start) && !isNaN(length) && start >= 0 && length > 0 && end <= 0xffff) {
|
|
monitorNode.html(memory.format(start, length));
|
|
} else {
|
|
monitorNode.html('Cannot monitor this range. Valid ranges are between $0000 and $ffff, inclusive.');
|
|
}
|
|
}
|
|
}
|
|
|
|
function handleMonitorRangeChange() {
|
|
|
|
var $start = $node.find('.start'),
|
|
$length = $node.find('.length'),
|
|
start = parseInt($start.val(), 16),
|
|
length = parseInt($length.val(), 16),
|
|
end = start + length - 1;
|
|
|
|
$start.removeClass('monitor-invalid');
|
|
$length.removeClass('monitor-invalid');
|
|
|
|
if(isNaN(start) || start < 0 || start > 0xffff) {
|
|
|
|
$start.addClass('monitor-invalid');
|
|
|
|
} else if(isNaN(length) || end > 0xffff) {
|
|
|
|
$length.addClass('monitor-invalid');
|
|
}
|
|
}
|
|
|
|
// Execute one instruction and print values
|
|
function debugExec() {
|
|
//if (codeRunning) {
|
|
execute(true);
|
|
//}
|
|
updateDebugInfo();
|
|
}
|
|
|
|
function updateDebugInfo() {
|
|
var html = 'A=$' + num2hex(regA) + ' X=$' + num2hex(regX) + ' Y=$' + num2hex(regY) +
|
|
' SP=$' + num2hex(regSP) + ' PC=$' + addr2hex(regPC) + ' NV-BDIZC: ';
|
|
for (var i = 7; i >= 0; i--) {
|
|
html += regP >> i & 1;
|
|
}
|
|
$node.find('.minidebugger').html(html);
|
|
updateMonitor();
|
|
}
|
|
|
|
// gotoAddr() - Set PC to address (or address of label)
|
|
function gotoAddr() {
|
|
var inp = prompt('Enter address or label', '');
|
|
var addr = 0;
|
|
if (labels.find(inp)) {
|
|
addr = labels.getPC(inp);
|
|
} else {
|
|
if (inp.match(/^0x[0-9a-f]{1,4}$/i)) {
|
|
inp = inp.replace(/^0x/, '');
|
|
addr = parseInt(inp, 16);
|
|
} else if (inp.match(/^\$[0-9a-f]{1,4}$/i)) {
|
|
inp = inp.replace(/^\$/, '');
|
|
addr = parseInt(inp, 16);
|
|
}
|
|
}
|
|
if (addr === 0) {
|
|
message('Unable to find/parse given address/label');
|
|
} else {
|
|
regPC = addr;
|
|
}
|
|
updateDebugInfo();
|
|
}
|
|
|
|
|
|
function stopDebugger() {
|
|
debug = false;
|
|
}
|
|
|
|
function enableDebugger() {
|
|
debug = true;
|
|
if (codeRunning) {
|
|
updateDebugInfo();
|
|
}
|
|
}
|
|
|
|
// reset() - Reset CPU and memory.
|
|
function reset() {
|
|
display.reset();
|
|
for (var i = 0; i < 0x600; i++) { // clear ZP, stack and screen
|
|
memory.set(i, 0x00);
|
|
}
|
|
regA = regX = regY = 0;
|
|
regPC = 0x600;
|
|
regSP = 0xff;
|
|
regP = 0x30;
|
|
updateDebugInfo();
|
|
}
|
|
|
|
function stop() {
|
|
codeRunning = false;
|
|
clearInterval(executeId);
|
|
message('\nStopped\n');
|
|
}
|
|
|
|
function toggleMonitor() {
|
|
monitoring = !monitoring;
|
|
}
|
|
|
|
return {
|
|
runBinary: runBinary,
|
|
enableDebugger: enableDebugger,
|
|
stopDebugger: stopDebugger,
|
|
debugExec: debugExec,
|
|
gotoAddr: gotoAddr,
|
|
reset: reset,
|
|
stop: stop,
|
|
toggleMonitor: toggleMonitor,
|
|
handleMonitorRangeChange: handleMonitorRangeChange
|
|
};
|
|
}
|
|
|
|
|
|
function Labels() {
|
|
var labelIndex = [];
|
|
|
|
function indexLines(lines, symbols) {
|
|
for (var i = 0; i < lines.length; i++) {
|
|
if (!indexLine(lines[i], symbols)) {
|
|
message('**Label already defined at line ' + (i + 1) + ':** ' + lines[i]);
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Extract label if line contains one and calculate position in memory.
|
|
// Return false if label already exists.
|
|
function indexLine(input, symbols) {
|
|
|
|
// Figure out how many bytes this instruction takes
|
|
var currentPC = assembler.getCurrentPC();
|
|
assembler.assembleLine(input, 0, symbols); //TODO: find a better way for Labels to have access to assembler
|
|
|
|
// Find command or label
|
|
if (input.match(/^\w+:/)) {
|
|
var label = input.replace(/(^\w+):.*$/, '$1');
|
|
|
|
if (symbols.lookup(label)) {
|
|
message('**Label ' + label + 'is already used as a symbol; please rename one of them**');
|
|
return false;
|
|
}
|
|
|
|
return push(label + '|' + currentPC);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Push label to array. Return false if label already exists.
|
|
function push(name) {
|
|
if (find(name)) {
|
|
return false;
|
|
}
|
|
labelIndex.push(name + '|');
|
|
return true;
|
|
}
|
|
|
|
// Returns true if label exists.
|
|
function find(name) {
|
|
var nameAndAddr;
|
|
for (var i = 0; i < labelIndex.length; i++) {
|
|
nameAndAddr = labelIndex[i].split('|');
|
|
if (name === nameAndAddr[0]) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Associates label with address
|
|
function setPC(name, addr) {
|
|
var nameAndAddr;
|
|
for (var i = 0; i < labelIndex.length; i++) {
|
|
nameAndAddr = labelIndex[i].split('|');
|
|
if (name === nameAndAddr[0]) {
|
|
labelIndex[i] = name + '|' + addr;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Get address associated with label
|
|
function getPC(name) {
|
|
var nameAndAddr;
|
|
for (var i = 0; i < labelIndex.length; i++) {
|
|
nameAndAddr = labelIndex[i].split('|');
|
|
if (name === nameAndAddr[0]) {
|
|
return (nameAndAddr[1]);
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
function displayMessage() {
|
|
var str = 'Found ' + labelIndex.length + ' label';
|
|
if (labelIndex.length !== 1) {
|
|
str += 's';
|
|
}
|
|
message(str + '.');
|
|
}
|
|
|
|
function reset() {
|
|
labelIndex = [];
|
|
}
|
|
|
|
return {
|
|
indexLines: indexLines,
|
|
find: find,
|
|
getPC: getPC,
|
|
displayMessage: displayMessage,
|
|
reset: reset
|
|
};
|
|
}
|
|
|
|
|
|
function Assembler() {
|
|
var defaultCodePC;
|
|
var codeLen;
|
|
var codeAssembledOK = false;
|
|
var wasOutOfRangeBranch = false;
|
|
|
|
var Opcodes = [
|
|
/* Name, Imm, ZP, ZPX, ZPY, ABS, ABSX, ABSY, IND, INDX, INDY, SNGL, BRA */
|
|
['ADC', 0x69, 0x65, 0x75, null, 0x6d, 0x7d, 0x79, null, 0x61, 0x71, null, null],
|
|
['AND', 0x29, 0x25, 0x35, null, 0x2d, 0x3d, 0x39, null, 0x21, 0x31, null, null],
|
|
['ASL', null, 0x06, 0x16, null, 0x0e, 0x1e, null, null, null, null, 0x0a, null],
|
|
['BIT', null, 0x24, null, null, 0x2c, null, null, null, null, null, null, null],
|
|
['BPL', null, null, null, null, null, null, null, null, null, null, null, 0x10],
|
|
['BMI', null, null, null, null, null, null, null, null, null, null, null, 0x30],
|
|
['BVC', null, null, null, null, null, null, null, null, null, null, null, 0x50],
|
|
['BVS', null, null, null, null, null, null, null, null, null, null, null, 0x70],
|
|
['BCC', null, null, null, null, null, null, null, null, null, null, null, 0x90],
|
|
['BCS', null, null, null, null, null, null, null, null, null, null, null, 0xb0],
|
|
['BNE', null, null, null, null, null, null, null, null, null, null, null, 0xd0],
|
|
['BEQ', null, null, null, null, null, null, null, null, null, null, null, 0xf0],
|
|
['BRK', null, null, null, null, null, null, null, null, null, null, 0x00, null],
|
|
['CMP', 0xc9, 0xc5, 0xd5, null, 0xcd, 0xdd, 0xd9, null, 0xc1, 0xd1, null, null],
|
|
['CPX', 0xe0, 0xe4, null, null, 0xec, null, null, null, null, null, null, null],
|
|
['CPY', 0xc0, 0xc4, null, null, 0xcc, null, null, null, null, null, null, null],
|
|
['DEC', null, 0xc6, 0xd6, null, 0xce, 0xde, null, null, null, null, null, null],
|
|
['EOR', 0x49, 0x45, 0x55, null, 0x4d, 0x5d, 0x59, null, 0x41, 0x51, null, null],
|
|
['CLC', null, null, null, null, null, null, null, null, null, null, 0x18, null],
|
|
['SEC', null, null, null, null, null, null, null, null, null, null, 0x38, null],
|
|
['CLI', null, null, null, null, null, null, null, null, null, null, 0x58, null],
|
|
['SEI', null, null, null, null, null, null, null, null, null, null, 0x78, null],
|
|
['CLV', null, null, null, null, null, null, null, null, null, null, 0xb8, null],
|
|
['CLD', null, null, null, null, null, null, null, null, null, null, 0xd8, null],
|
|
['SED', null, null, null, null, null, null, null, null, null, null, 0xf8, null],
|
|
['INC', null, 0xe6, 0xf6, null, 0xee, 0xfe, null, null, null, null, null, null],
|
|
['JMP', null, null, null, null, 0x4c, null, null, 0x6c, null, null, null, null],
|
|
['JSR', null, null, null, null, 0x20, null, null, null, null, null, null, null],
|
|
['LDA', 0xa9, 0xa5, 0xb5, null, 0xad, 0xbd, 0xb9, null, 0xa1, 0xb1, null, null],
|
|
['LDX', 0xa2, 0xa6, null, 0xb6, 0xae, null, 0xbe, null, null, null, null, null],
|
|
['LDY', 0xa0, 0xa4, 0xb4, null, 0xac, 0xbc, null, null, null, null, null, null],
|
|
['LSR', null, 0x46, 0x56, null, 0x4e, 0x5e, null, null, null, null, 0x4a, null],
|
|
['NOP', null, null, null, null, null, null, null, null, null, null, 0xea, null],
|
|
['ORA', 0x09, 0x05, 0x15, null, 0x0d, 0x1d, 0x19, null, 0x01, 0x11, null, null],
|
|
['TAX', null, null, null, null, null, null, null, null, null, null, 0xaa, null],
|
|
['TXA', null, null, null, null, null, null, null, null, null, null, 0x8a, null],
|
|
['DEX', null, null, null, null, null, null, null, null, null, null, 0xca, null],
|
|
['INX', null, null, null, null, null, null, null, null, null, null, 0xe8, null],
|
|
['TAY', null, null, null, null, null, null, null, null, null, null, 0xa8, null],
|
|
['TYA', null, null, null, null, null, null, null, null, null, null, 0x98, null],
|
|
['DEY', null, null, null, null, null, null, null, null, null, null, 0x88, null],
|
|
['INY', null, null, null, null, null, null, null, null, null, null, 0xc8, null],
|
|
['ROR', null, 0x66, 0x76, null, 0x6e, 0x7e, null, null, null, null, 0x6a, null],
|
|
['ROL', null, 0x26, 0x36, null, 0x2e, 0x3e, null, null, null, null, 0x2a, null],
|
|
['RTI', null, null, null, null, null, null, null, null, null, null, 0x40, null],
|
|
['RTS', null, null, null, null, null, null, null, null, null, null, 0x60, null],
|
|
['SBC', 0xe9, 0xe5, 0xf5, null, 0xed, 0xfd, 0xf9, null, 0xe1, 0xf1, null, null],
|
|
['STA', null, 0x85, 0x95, null, 0x8d, 0x9d, 0x99, null, 0x81, 0x91, null, null],
|
|
['TXS', null, null, null, null, null, null, null, null, null, null, 0x9a, null],
|
|
['TSX', null, null, null, null, null, null, null, null, null, null, 0xba, null],
|
|
['PHA', null, null, null, null, null, null, null, null, null, null, 0x48, null],
|
|
['PLA', null, null, null, null, null, null, null, null, null, null, 0x68, null],
|
|
['PHP', null, null, null, null, null, null, null, null, null, null, 0x08, null],
|
|
['PLP', null, null, null, null, null, null, null, null, null, null, 0x28, null],
|
|
['STX', null, 0x86, null, 0x96, 0x8e, null, null, null, null, null, null, null],
|
|
['STY', null, 0x84, 0x94, null, 0x8c, null, null, null, null, null, null, null],
|
|
['WDM', 0x42, 0x42, null, null, null, null, null, null, null, null, null, null],
|
|
['---', null, null, null, null, null, null, null, null, null, null, null, null]
|
|
];
|
|
|
|
// Assembles the code into memory
|
|
function assembleCode() {
|
|
var BOOTSTRAP_ADDRESS = 0x600;
|
|
|
|
wasOutOfRangeBranch = false;
|
|
|
|
simulator.reset();
|
|
labels.reset();
|
|
defaultCodePC = BOOTSTRAP_ADDRESS;
|
|
$node.find('.messages code').empty();
|
|
|
|
var code = $node.find('.code').val();
|
|
code += '\n\n';
|
|
var lines = code.split('\n');
|
|
codeAssembledOK = true;
|
|
|
|
message('Preprocessing ...');
|
|
var symbols = preprocess(lines);
|
|
|
|
message('Indexing labels ...');
|
|
defaultCodePC = BOOTSTRAP_ADDRESS;
|
|
if (!labels.indexLines(lines, symbols)) {
|
|
return false;
|
|
}
|
|
labels.displayMessage();
|
|
|
|
defaultCodePC = BOOTSTRAP_ADDRESS;
|
|
message('Assembling code ...');
|
|
|
|
codeLen = 0;
|
|
for (var i = 0; i < lines.length; i++) {
|
|
if (!assembleLine(lines[i], i, symbols)) {
|
|
codeAssembledOK = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (codeLen === 0) {
|
|
codeAssembledOK = false;
|
|
message('No code to run.');
|
|
}
|
|
|
|
if (codeAssembledOK) {
|
|
ui.assembleSuccess();
|
|
memory.set(defaultCodePC, 0x00); //set a null byte at the end of the code
|
|
} else {
|
|
|
|
var str = lines[i].replace('<', '<').replace('>', '>');
|
|
|
|
if(!wasOutOfRangeBranch) {
|
|
message('**Syntax error line ' + (i + 1) + ': ' + str + '**');
|
|
} else {
|
|
message('**Out of range branch on line ' + (i + 1) + ' (branches are limited to -128 to +127): ' + str + '**');
|
|
}
|
|
|
|
ui.initialize();
|
|
return false;
|
|
}
|
|
|
|
message('Code assembled successfully, ' + codeLen + ' bytes.');
|
|
return true;
|
|
}
|
|
|
|
// Sanitize input: remove comments and trim leading/trailing whitespace
|
|
function sanitize(line) {
|
|
// remove comments
|
|
var no_comments = line.replace(/^(.*?);.*/, '$1');
|
|
|
|
// trim line
|
|
return no_comments.replace(/^\s+/, '').replace(/\s+$/, '');
|
|
}
|
|
|
|
function preprocess(lines) {
|
|
var table = [];
|
|
var PREFIX = '__'; // Using a prefix avoids clobbering any predefined properties
|
|
|
|
function lookup(key) {
|
|
if (table.hasOwnProperty(PREFIX + key)) return table[PREFIX + key];
|
|
else return undefined;
|
|
}
|
|
|
|
function add(key, value) {
|
|
var valueAlreadyExists = table.hasOwnProperty(PREFIX + key)
|
|
if (!valueAlreadyExists) {
|
|
table[PREFIX + key] = value;
|
|
}
|
|
}
|
|
|
|
// Build the substitution table
|
|
for (var i = 0; i < lines.length; i++) {
|
|
lines[i] = sanitize(lines[i]);
|
|
var match_data = lines[i].match(/^define\s+(\w+)\s+(\S+)/);
|
|
if (match_data) {
|
|
add(match_data[1], sanitize(match_data[2]));
|
|
lines[i] = ''; // We're done with this preprocessor directive, so delete it
|
|
}
|
|
}
|
|
|
|
// Callers will only need the lookup function
|
|
return {
|
|
lookup: lookup
|
|
}
|
|
}
|
|
|
|
// Assembles one line of code.
|
|
// Returns true if it assembled successfully, false otherwise.
|
|
function assembleLine(input, lineno, symbols) {
|
|
var label, command, param, addr;
|
|
|
|
// Find command or label
|
|
if (input.match(/^\w+:/)) {
|
|
label = input.replace(/(^\w+):.*$/, '$1');
|
|
if (input.match(/^\w+:[\s]*\w+.*$/)) {
|
|
input = input.replace(/^\w+:[\s]*(.*)$/, '$1');
|
|
command = input.replace(/^(\w+).*$/, '$1');
|
|
} else {
|
|
command = '';
|
|
}
|
|
} else {
|
|
command = input.replace(/^(\w+).*$/, '$1');
|
|
}
|
|
|
|
// Nothing to do for blank lines
|
|
if (command === '') {
|
|
return true;
|
|
}
|
|
|
|
command = command.toUpperCase();
|
|
|
|
if (input.match(/^\*\s*=\s*\$?[0-9a-f]*$/)) {
|
|
// equ spotted
|
|
param = input.replace(/^\s*\*\s*=\s*/, '');
|
|
if (param[0] === '$') {
|
|
param = param.replace(/^\$/, '');
|
|
addr = parseInt(param, 16);
|
|
} else {
|
|
addr = parseInt(param, 10);
|
|
}
|
|
if ((addr < 0) || (addr > 0xffff)) {
|
|
message('Unable to relocate code outside 64k memory');
|
|
return false;
|
|
}
|
|
defaultCodePC = addr;
|
|
return true;
|
|
}
|
|
|
|
if (input.match(/^\w+\s+.*?$/)) {
|
|
param = input.replace(/^\w+\s+(.*?)/, '$1');
|
|
} else if (input.match(/^\w+$/)) {
|
|
param = '';
|
|
} else {
|
|
return false;
|
|
}
|
|
|
|
param = param.replace(/[ ]/g, '');
|
|
|
|
if (command === 'DCB') {
|
|
return DCB(param);
|
|
}
|
|
for (var o = 0; o < Opcodes.length; o++) {
|
|
if (Opcodes[o][0] === command) {
|
|
if (checkSingle(param, Opcodes[o][11])) { return true; }
|
|
if (checkImmediate(param, Opcodes[o][1], symbols)) { return true; }
|
|
if (checkZeroPage(param, Opcodes[o][2], symbols)) { return true; }
|
|
if (checkZeroPageX(param, Opcodes[o][3], symbols)) { return true; }
|
|
if (checkZeroPageY(param, Opcodes[o][4], symbols)) { return true; }
|
|
if (checkAbsoluteX(param, Opcodes[o][6], symbols)) { return true; }
|
|
if (checkAbsoluteY(param, Opcodes[o][7], symbols)) { return true; }
|
|
if (checkIndirect(param, Opcodes[o][8], symbols)) { return true; }
|
|
if (checkIndirectX(param, Opcodes[o][9], symbols)) { return true; }
|
|
if (checkIndirectY(param, Opcodes[o][10], symbols)) { return true; }
|
|
if (checkAbsolute(param, Opcodes[o][5], symbols)) { return true; }
|
|
if (checkBranch(param, Opcodes[o][12])) { return true; }
|
|
}
|
|
}
|
|
|
|
return false; // Unknown syntax
|
|
}
|
|
|
|
function DCB(param) {
|
|
var values, number, str, ch;
|
|
values = param.split(',');
|
|
if (values.length === 0) { return false; }
|
|
for (var v = 0; v < values.length; v++) {
|
|
str = values[v];
|
|
if (str) {
|
|
ch = str.substring(0, 1);
|
|
if (ch === '$') {
|
|
number = parseInt(str.replace(/^\$/, ''), 16);
|
|
pushByte(number);
|
|
} else if (ch >= '0' && ch <= '9') {
|
|
number = parseInt(str, 10);
|
|
pushByte(number);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Try to parse the given parameter as a byte operand.
|
|
// Returns the (positive) value if successful, otherwise -1
|
|
function tryParseByteOperand(param, symbols) {
|
|
if (param.match(/^\w+$/)) {
|
|
var lookupVal = symbols.lookup(param); // Substitute symbol by actual value, then proceed
|
|
if (lookupVal) {
|
|
param = lookupVal;
|
|
}
|
|
}
|
|
|
|
var value;
|
|
|
|
// Is it a hexadecimal operand?
|
|
var match_data = param.match(/^\$([0-9a-f]{1,2})$/i);
|
|
if (match_data) {
|
|
value = parseInt(match_data[1], 16);
|
|
} else {
|
|
// Is it a decimal operand?
|
|
match_data = param.match(/^([0-9]{1,3})$/i);
|
|
if (match_data) {
|
|
value = parseInt(match_data[1], 10);
|
|
}
|
|
}
|
|
|
|
// Validate range
|
|
if (value >= 0 && value <= 0xff) {
|
|
return value;
|
|
} else {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
// Try to parse the given parameter as a word operand.
|
|
// Returns the (positive) value if successful, otherwise -1
|
|
function tryParseWordOperand(param, symbols) {
|
|
if (param.match(/^\w+$/)) {
|
|
var lookupVal = symbols.lookup(param); // Substitute symbol by actual value, then proceed
|
|
if (lookupVal) {
|
|
param = lookupVal;
|
|
}
|
|
}
|
|
|
|
var value;
|
|
|
|
// Is it a hexadecimal operand?
|
|
var match_data = param.match(/^\$([0-9a-f]{3,4})$/i);
|
|
if (match_data) {
|
|
value = parseInt(match_data[1], 16);
|
|
} else {
|
|
// Is it a decimal operand?
|
|
match_data = param.match(/^([0-9]{1,5})$/i);
|
|
if (match_data) {
|
|
value = parseInt(match_data[1], 10);
|
|
}
|
|
}
|
|
|
|
// Validate range
|
|
if (value >= 0 && value <= 0xffff) {
|
|
return value;
|
|
} else {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
// Common branch function for all branches (BCC, BCS, BEQ, BNE..)
|
|
function checkBranch(param, opcode) {
|
|
var addr;
|
|
if (opcode === null) { return false; }
|
|
|
|
addr = -1;
|
|
if (param.match(/\w+/)) {
|
|
addr = labels.getPC(param);
|
|
}
|
|
if (addr === -1) { pushWord(0x00); return false; }
|
|
pushByte(opcode);
|
|
|
|
var distance = addr - defaultCodePC - 1;
|
|
|
|
if(distance < -128 || distance > 127) {
|
|
wasOutOfRangeBranch = true;
|
|
return false;
|
|
}
|
|
|
|
pushByte(distance);
|
|
return true;
|
|
}
|
|
|
|
// Check if param is immediate and push value
|
|
function checkImmediate(param, opcode, symbols) {
|
|
var value, label, hilo, addr;
|
|
if (opcode === null) { return false; }
|
|
|
|
var match_data = param.match(/^#([\w\$]+)$/i);
|
|
if (match_data) {
|
|
var operand = tryParseByteOperand(match_data[1], symbols);
|
|
if (operand >= 0) {
|
|
pushByte(opcode);
|
|
pushByte(operand);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Label lo/hi
|
|
if (param.match(/^#[<>]\w+$/)) {
|
|
label = param.replace(/^#[<>](\w+)$/, '$1');
|
|
hilo = param.replace(/^#([<>]).*$/, '$1');
|
|
pushByte(opcode);
|
|
if (labels.find(label)) {
|
|
addr = labels.getPC(label);
|
|
switch(hilo) {
|
|
case '>':
|
|
pushByte((addr >> 8) & 0xff);
|
|
return true;
|
|
case '<':
|
|
pushByte(addr & 0xff);
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
} else {
|
|
pushByte(0x00);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// Check if param is indirect and push value
|
|
function checkIndirect(param, opcode, symbols) {
|
|
var value;
|
|
if (opcode === null) { return false; }
|
|
|
|
var match_data = param.match(/^\(([\w\$]+)\)$/i);
|
|
if (match_data) {
|
|
var operand = tryParseWordOperand(match_data[1], symbols);
|
|
if (operand >= 0) {
|
|
pushByte(opcode);
|
|
pushWord(operand);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Check if param is indirect X and push value
|
|
function checkIndirectX(param, opcode, symbols) {
|
|
var value;
|
|
if (opcode === null) { return false; }
|
|
|
|
var match_data = param.match(/^\(([\w\$]+),X\)$/i);
|
|
if (match_data) {
|
|
var operand = tryParseByteOperand(match_data[1], symbols);
|
|
if (operand >= 0) {
|
|
pushByte(opcode);
|
|
pushByte(operand);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Check if param is indirect Y and push value
|
|
function checkIndirectY(param, opcode, symbols) {
|
|
var value;
|
|
if (opcode === null) { return false; }
|
|
|
|
var match_data = param.match(/^\(([\w\$]+)\),Y$/i);
|
|
if (match_data) {
|
|
var operand = tryParseByteOperand(match_data[1], symbols);
|
|
if (operand >= 0) {
|
|
pushByte(opcode);
|
|
pushByte(operand);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Check single-byte opcodes
|
|
function checkSingle(param, opcode) {
|
|
if (opcode === null) { return false; }
|
|
// Accumulator instructions are counted as single-byte opcodes
|
|
if (param !== '' && param !== 'A') { return false; }
|
|
pushByte(opcode);
|
|
return true;
|
|
}
|
|
|
|
// Check if param is ZP and push value
|
|
function checkZeroPage(param, opcode, symbols) {
|
|
var value;
|
|
if (opcode === null) { return false; }
|
|
|
|
var operand = tryParseByteOperand(param, symbols);
|
|
if (operand >= 0) {
|
|
pushByte(opcode);
|
|
pushByte(operand);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// Check if param is ABSX and push value
|
|
function checkAbsoluteX(param, opcode, symbols) {
|
|
var number, value, addr;
|
|
if (opcode === null) { return false; }
|
|
|
|
var match_data = param.match(/^([\w\$]+),X$/i);
|
|
if (match_data) {
|
|
var operand = tryParseWordOperand(match_data[1], symbols);
|
|
if (operand >= 0) {
|
|
pushByte(opcode);
|
|
pushWord(operand);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// it could be a label too..
|
|
if (param.match(/^\w+,X$/i)) {
|
|
param = param.replace(/,X$/i, '');
|
|
pushByte(opcode);
|
|
if (labels.find(param)) {
|
|
addr = labels.getPC(param);
|
|
if (addr < 0 || addr > 0xffff) { return false; }
|
|
pushWord(addr);
|
|
return true;
|
|
} else {
|
|
pushWord(0xffff); // filler, only used while indexing labels
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// Check if param is ABSY and push value
|
|
function checkAbsoluteY(param, opcode, symbols) {
|
|
var number, value, addr;
|
|
if (opcode === null) { return false; }
|
|
|
|
var match_data = param.match(/^([\w\$]+),Y$/i);
|
|
if (match_data) {
|
|
var operand = tryParseWordOperand(match_data[1], symbols);
|
|
if (operand >= 0) {
|
|
pushByte(opcode);
|
|
pushWord(operand);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// it could be a label too..
|
|
if (param.match(/^\w+,Y$/i)) {
|
|
param = param.replace(/,Y$/i, '');
|
|
pushByte(opcode);
|
|
if (labels.find(param)) {
|
|
addr = labels.getPC(param);
|
|
if (addr < 0 || addr > 0xffff) { return false; }
|
|
pushWord(addr);
|
|
return true;
|
|
} else {
|
|
pushWord(0xffff); // filler, only used while indexing labels
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Check if param is ZPX and push value
|
|
function checkZeroPageX(param, opcode, symbols) {
|
|
var number, value;
|
|
if (opcode === null) { return false; }
|
|
|
|
var match_data = param.match(/^([\w\$]+),X$/i);
|
|
if (match_data) {
|
|
var operand = tryParseByteOperand(match_data[1], symbols);
|
|
if (operand >= 0) {
|
|
pushByte(opcode);
|
|
pushByte(operand);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// Check if param is ZPY and push value
|
|
function checkZeroPageY(param, opcode, symbols) {
|
|
var number, value;
|
|
if (opcode === null) { return false; }
|
|
|
|
var match_data = param.match(/^([\w\$]+),Y$/i);
|
|
if (match_data) {
|
|
var operand = tryParseByteOperand(match_data[1], symbols);
|
|
if (operand >= 0) {
|
|
pushByte(opcode);
|
|
pushByte(operand);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// Check if param is ABS and push value
|
|
function checkAbsolute(param, opcode, symbols) {
|
|
var value, number, addr;
|
|
if (opcode === null) { return false; }
|
|
|
|
var match_data = param.match(/^([\w\$]+)$/i);
|
|
if (match_data) {
|
|
var operand = tryParseWordOperand(match_data[1], symbols);
|
|
if (operand >= 0) {
|
|
pushByte(opcode);
|
|
pushWord(operand);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// it could be a label too..
|
|
if (param.match(/^\w+$/)) {
|
|
pushByte(opcode);
|
|
if (labels.find(param)) {
|
|
addr = (labels.getPC(param));
|
|
if (addr < 0 || addr > 0xffff) { return false; }
|
|
pushWord(addr);
|
|
return true;
|
|
} else {
|
|
pushWord(0xffff); // filler, only used while indexing labels
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Push a byte to memory
|
|
function pushByte(value) {
|
|
memory.set(defaultCodePC, value & 0xff);
|
|
defaultCodePC++;
|
|
codeLen++;
|
|
}
|
|
|
|
// Push a word to memory in little-endian order
|
|
function pushWord(value) {
|
|
pushByte(value & 0xff);
|
|
pushByte((value >> 8) & 0xff);
|
|
}
|
|
|
|
function openDiv(content, title) {
|
|
var w = document.querySelector('.banner');
|
|
var ele = document.createElement('div');
|
|
// var html = "<link href='style.css' rel='stylesheet' type='text/css' />";
|
|
// html += "<title>" + title + "</title></head><body>";
|
|
// html += "<pre><code>";
|
|
// html += content;
|
|
// html += "</code></pre></body></html>";
|
|
ele.innerHTML = '<code>' + content + '</code>';
|
|
w.appendChild(ele);
|
|
}
|
|
|
|
// Dump binary as hex to new window
|
|
function hexdump() {
|
|
openDiv(memory.format(0x600, codeLen), 'Hexdump');
|
|
}
|
|
|
|
// TODO: Create separate disassembler object?
|
|
var addressingModes = [
|
|
null,
|
|
'Imm',
|
|
'ZP',
|
|
'ZPX',
|
|
'ZPY',
|
|
'ABS',
|
|
'ABSX',
|
|
'ABSY',
|
|
'IND',
|
|
'INDX',
|
|
'INDY',
|
|
'SNGL',
|
|
'BRA'
|
|
];
|
|
|
|
var instructionLength = {
|
|
Imm: 2,
|
|
ZP: 2,
|
|
ZPX: 2,
|
|
ZPY: 2,
|
|
ABS: 3,
|
|
ABSX: 3,
|
|
ABSY: 3,
|
|
IND: 3,
|
|
INDX: 2,
|
|
INDY: 2,
|
|
SNGL: 1,
|
|
BRA: 2
|
|
};
|
|
|
|
function getModeAndCode(byte) {
|
|
var index;
|
|
var line = Opcodes.filter(function (line) {
|
|
var possibleIndex = line.indexOf(byte);
|
|
if (possibleIndex > -1) {
|
|
index = possibleIndex;
|
|
return true;
|
|
}
|
|
})[0];
|
|
|
|
if (!line) { //instruction not found
|
|
return {
|
|
opCode: '???',
|
|
mode: 'SNGL'
|
|
};
|
|
} else {
|
|
return {
|
|
opCode: line[0],
|
|
mode: addressingModes[index]
|
|
};
|
|
}
|
|
}
|
|
|
|
function createInstruction(address) {
|
|
var bytes = [];
|
|
var opCode;
|
|
var args = [];
|
|
var mode;
|
|
|
|
function isAccumulatorInstruction() {
|
|
var accumulatorBytes = [0x0a, 0x4a, 0x2a, 0x6a];
|
|
if (accumulatorBytes.indexOf(bytes[0]) > -1) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
function isBranchInstruction() {
|
|
return opCode.match(/^B/) && !(opCode == 'BIT' || opCode == 'BRK');
|
|
}
|
|
|
|
//This is gnarly, but unavoidably so?
|
|
function formatArguments() {
|
|
var argsString = args.map(num2hex).reverse().join('');
|
|
|
|
if (isBranchInstruction()) {
|
|
var destination = address + 2;
|
|
if (args[0] > 0x7f) {
|
|
destination -= 0x100 - args[0];
|
|
} else {
|
|
destination += args[0];
|
|
}
|
|
argsString = addr2hex(destination);
|
|
}
|
|
|
|
if (argsString) {
|
|
argsString = '$' + argsString;
|
|
}
|
|
if (mode == 'Imm') {
|
|
argsString = '#' + argsString;
|
|
}
|
|
if (mode.match(/X$/)) {
|
|
argsString += ',X';
|
|
}
|
|
if (mode.match(/^IND/)) {
|
|
argsString = '(' + argsString + ')';
|
|
}
|
|
if (mode.match(/Y$/)) {
|
|
argsString += ',Y';
|
|
}
|
|
|
|
if (isAccumulatorInstruction()) {
|
|
argsString = 'A';
|
|
}
|
|
|
|
return argsString;
|
|
}
|
|
|
|
return {
|
|
addByte: function (byte) {
|
|
bytes.push(byte);
|
|
},
|
|
setModeAndCode: function (modeAndCode) {
|
|
opCode = modeAndCode.opCode;
|
|
mode = modeAndCode.mode;
|
|
},
|
|
addArg: function (arg) {
|
|
args.push(arg);
|
|
},
|
|
toString: function () {
|
|
var bytesString = bytes.map(num2hex).join(' ');
|
|
var padding = Array(11 - bytesString.length).join(' ');
|
|
return '$' + addr2hex(address) + ' ' + bytesString + padding + opCode +
|
|
' ' + formatArguments(args);
|
|
}
|
|
};
|
|
}
|
|
|
|
function disassemble() {
|
|
var startAddress = 0x600;
|
|
var currentAddress = startAddress;
|
|
var endAddress = startAddress + codeLen;
|
|
var instructions = [];
|
|
var length;
|
|
var inst;
|
|
var byte;
|
|
var modeAndCode;
|
|
|
|
while (currentAddress < endAddress) {
|
|
inst = createInstruction(currentAddress);
|
|
byte = memory.get(currentAddress);
|
|
inst.addByte(byte);
|
|
|
|
modeAndCode = getModeAndCode(byte);
|
|
length = instructionLength[modeAndCode.mode];
|
|
inst.setModeAndCode(modeAndCode);
|
|
|
|
for (var i = 1; i < length; i++) {
|
|
currentAddress++;
|
|
byte = memory.get(currentAddress);
|
|
inst.addByte(byte);
|
|
inst.addArg(byte);
|
|
}
|
|
instructions.push(inst);
|
|
currentAddress++;
|
|
}
|
|
|
|
var html = 'Address Hexdump Dissassembly\n';
|
|
html += '-------------------------------\n';
|
|
html += instructions.join('\n');
|
|
openDiv(html, 'Disassembly');
|
|
}
|
|
|
|
return {
|
|
assembleLine: assembleLine,
|
|
assembleCode: assembleCode,
|
|
getCurrentPC: function () {
|
|
return defaultCodePC;
|
|
},
|
|
hexdump: hexdump,
|
|
disassemble: disassemble
|
|
};
|
|
}
|
|
|
|
|
|
function addr2hex(addr) {
|
|
return num2hex((addr >> 8) & 0xff) + num2hex(addr & 0xff);
|
|
}
|
|
|
|
function num2hex(nr) {
|
|
var str = '0123456789abcdef';
|
|
var hi = ((nr & 0xf0) >> 4);
|
|
var lo = (nr & 15);
|
|
return str.substring(hi, hi + 1) + str.substring(lo, lo + 1);
|
|
}
|
|
|
|
// Prints text in the message window
|
|
function message(text) {
|
|
if (text.length > 1)
|
|
text += '\n'; // allow putc operations from the simulator (WDM opcode)
|
|
$node.find('.messages code').append(text).scrollTop(10000);
|
|
}
|
|
|
|
initialize();
|
|
}
|
|
|
|
$(document).ready(function () {
|
|
$('.widget').each(function () {
|
|
SimulatorWidget(this);
|
|
});
|
|
});
|