2017-01-03 15:43:40 +00:00
|
|
|
"use strict";
|
2016-12-16 01:21:51 +00:00
|
|
|
|
2017-01-14 02:31:04 +00:00
|
|
|
// catch errors
|
2017-01-16 19:13:03 +00:00
|
|
|
function installErrorHandler() {
|
|
|
|
if (typeof window.onerror == "object") {
|
|
|
|
window.onerror = function (msgevent, url, line, col, error) {
|
|
|
|
console.log(msgevent, url, line, col);
|
|
|
|
console.log(error);
|
|
|
|
if (window.location.host.endsWith('8bitworkshop.com')) {
|
|
|
|
ga('send', 'exception', {
|
|
|
|
'exDescription': msgevent + " " + url + " " + " " + line + ":" + col + ", " + error,
|
|
|
|
'exFatal': true
|
|
|
|
});
|
|
|
|
}
|
|
|
|
alert(msgevent+"");
|
|
|
|
};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
function uninstallErrorHandler() {
|
|
|
|
window.onerror = null;
|
|
|
|
}
|
|
|
|
|
|
|
|
function gotoNewLocation() {
|
|
|
|
uninstallErrorHandler();
|
|
|
|
window.location = "?" + $.param(qs);
|
2017-01-14 02:31:04 +00:00
|
|
|
}
|
|
|
|
|
2017-01-14 05:47:26 +00:00
|
|
|
// make sure VCS doesn't start
|
2017-11-21 21:36:38 +00:00
|
|
|
if (window.Javatari) Javatari.AUTO_START = false;
|
2017-01-14 05:47:26 +00:00
|
|
|
|
2017-01-13 02:21:35 +00:00
|
|
|
// 8bitworkshop IDE user interface
|
|
|
|
|
|
|
|
var PRESETS; // presets array
|
|
|
|
var platform_id;
|
|
|
|
var platform; // platform object
|
|
|
|
|
2017-04-12 16:23:24 +00:00
|
|
|
var toolbar = $("#controls_top");
|
|
|
|
|
2018-06-29 02:42:47 +00:00
|
|
|
var current_project;
|
|
|
|
|
2018-06-29 23:52:09 +00:00
|
|
|
// TODO: codemirror multiplex support?
|
2017-01-16 04:47:12 +00:00
|
|
|
var TOOL_TO_SOURCE_STYLE = {
|
|
|
|
'dasm': '6502',
|
|
|
|
'acme': '6502',
|
|
|
|
'cc65': 'text/x-csrc',
|
|
|
|
'ca65': '6502',
|
|
|
|
'z80asm': 'z80',
|
|
|
|
'sdasz80': 'z80',
|
|
|
|
'sdcc': 'text/x-csrc',
|
2017-11-11 19:45:32 +00:00
|
|
|
'verilator': 'verilog',
|
2018-03-02 05:15:33 +00:00
|
|
|
'jsasm': 'z80'
|
2017-01-16 04:47:12 +00:00
|
|
|
}
|
|
|
|
|
2018-06-29 02:42:47 +00:00
|
|
|
function newWorker() {
|
|
|
|
return new Worker("./src/worker/workermain.js");
|
|
|
|
}
|
2018-06-28 04:57:06 +00:00
|
|
|
|
|
|
|
var userPaused;
|
|
|
|
|
2018-06-30 02:06:14 +00:00
|
|
|
var active_editor;
|
2017-04-22 01:56:49 +00:00
|
|
|
var current_output;
|
2018-06-28 04:18:16 +00:00
|
|
|
var current_preset_entry;
|
|
|
|
var current_file_id;
|
2017-04-22 01:56:49 +00:00
|
|
|
var assemblyfile;
|
|
|
|
var sourcefile;
|
|
|
|
var symbolmap;
|
|
|
|
var addr2symbol;
|
|
|
|
var compparams;
|
2016-12-16 01:21:51 +00:00
|
|
|
var trace_pending_at_pc;
|
2017-01-04 21:07:59 +00:00
|
|
|
var store;
|
2017-01-08 15:51:19 +00:00
|
|
|
|
2018-06-27 02:32:34 +00:00
|
|
|
var currentDebugLine;
|
|
|
|
var lastDebugInfo;
|
|
|
|
var lastDebugState;
|
2017-04-19 01:18:53 +00:00
|
|
|
|
2018-06-27 02:32:34 +00:00
|
|
|
function inspectVariable(ed, name) {
|
2017-11-21 16:15:08 +00:00
|
|
|
var val;
|
|
|
|
if (platform.inspect) {
|
|
|
|
platform.inspect(name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-12-16 01:21:51 +00:00
|
|
|
function getCurrentPresetTitle() {
|
2018-06-28 04:18:16 +00:00
|
|
|
if (!current_preset_entry)
|
2016-12-16 01:21:51 +00:00
|
|
|
return "ROM";
|
|
|
|
else
|
2018-06-28 04:18:16 +00:00
|
|
|
return current_preset_entry.title || current_preset_entry.name || "ROM";
|
2016-12-16 01:21:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
function setLastPreset(id) {
|
2017-04-29 15:31:11 +00:00
|
|
|
if (platform_id != 'base_z80') { // TODO
|
|
|
|
localStorage.setItem("__lastplatform", platform_id);
|
|
|
|
localStorage.setItem("__lastid_"+platform_id, id);
|
|
|
|
}
|
2016-12-16 01:21:51 +00:00
|
|
|
}
|
|
|
|
|
2018-06-29 23:44:04 +00:00
|
|
|
function initProject() {
|
2018-06-29 02:42:47 +00:00
|
|
|
current_project = new CodeProject(newWorker(), platform_id, platform, store);
|
|
|
|
current_project.callbackResendFiles = function() {
|
2018-07-02 13:34:20 +00:00
|
|
|
current_project.updateFile(getActiveEditor().getPath(), getActiveEditor().getValue(), false);
|
|
|
|
// TODO: let CodeProject handle this
|
2018-06-29 02:42:47 +00:00
|
|
|
};
|
|
|
|
current_project.callbackBuildResult = function(result) {
|
|
|
|
setCompileOutput(result);
|
2018-07-02 13:34:20 +00:00
|
|
|
refreshWindowList();
|
2018-06-29 02:42:47 +00:00
|
|
|
};
|
|
|
|
current_project.callbackBuildStatus = function(busy) {
|
|
|
|
if (busy) {
|
|
|
|
toolbar.addClass("is-busy");
|
|
|
|
} else {
|
|
|
|
toolbar.removeClass("is-busy");
|
2018-06-30 04:42:21 +00:00
|
|
|
toolbar.removeClass("has-errors"); // may be added in next callback
|
|
|
|
getActiveEditor().clearErrors(); // TODO: add current line marker
|
2018-06-29 02:42:47 +00:00
|
|
|
}
|
|
|
|
$('#compile_spinner').css('visibility', busy ? 'visible' : 'hidden');
|
|
|
|
};
|
2018-06-29 23:44:04 +00:00
|
|
|
}
|
2018-06-29 02:42:47 +00:00
|
|
|
|
2018-06-30 02:06:14 +00:00
|
|
|
// TODO: remove some calls of global functions
|
2018-07-02 13:34:20 +00:00
|
|
|
function SourceEditor(path, mode) {
|
2018-06-30 02:06:14 +00:00
|
|
|
var self = this;
|
|
|
|
var editor;
|
2018-07-02 13:34:20 +00:00
|
|
|
|
|
|
|
self.createDiv = function(parent, text) {
|
|
|
|
var div = document.createElement('div');
|
|
|
|
div.setAttribute("class", "editor");
|
|
|
|
parent.appendChild(div);
|
|
|
|
newEditor(div);
|
|
|
|
if (text)
|
|
|
|
self.setText(text); // TODO: this calls setCode() and builds... it shouldn't
|
|
|
|
return div;
|
2018-06-30 02:06:14 +00:00
|
|
|
}
|
|
|
|
|
2018-07-02 13:34:20 +00:00
|
|
|
function newEditor(parent) {
|
2018-06-30 02:06:14 +00:00
|
|
|
var isAsm = mode=='6502' || mode =='z80' || mode=='verilog' || mode=='gas'; // TODO
|
2018-07-02 13:34:20 +00:00
|
|
|
editor = CodeMirror(parent, {
|
2018-06-30 02:06:14 +00:00
|
|
|
theme: 'mbo',
|
|
|
|
lineNumbers: true,
|
|
|
|
matchBrackets: true,
|
|
|
|
tabSize: 8,
|
|
|
|
indentAuto: true,
|
|
|
|
gutters: isAsm ? ["CodeMirror-linenumbers", "gutter-offset", "gutter-bytes", "gutter-clock", "gutter-info"]
|
|
|
|
: ["CodeMirror-linenumbers", "gutter-offset", "gutter-info"],
|
|
|
|
});
|
|
|
|
var timer;
|
|
|
|
editor.on('changes', function(ed, changeobj) {
|
|
|
|
clearTimeout(timer);
|
|
|
|
timer = setTimeout(function() {
|
2018-07-02 13:34:20 +00:00
|
|
|
current_project.updateFile(path, editor.getValue(), false);
|
2018-06-30 02:06:14 +00:00
|
|
|
}, 200);
|
|
|
|
});
|
|
|
|
editor.on('cursorActivity', function(ed) {
|
|
|
|
var start = editor.getCursor(true);
|
|
|
|
var end = editor.getCursor(false);
|
|
|
|
if (start.line == end.line && start.ch < end.ch) {
|
|
|
|
var name = editor.getSelection();
|
|
|
|
inspectVariable(editor, name);
|
|
|
|
} else {
|
|
|
|
inspectVariable(editor);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
//scrollProfileView(editor);
|
|
|
|
editor.setOption("mode", mode);
|
|
|
|
}
|
|
|
|
|
|
|
|
self.setText = function(text) {
|
|
|
|
editor.setValue(text); // calls setCode()
|
|
|
|
editor.clearHistory();
|
2018-07-02 13:34:20 +00:00
|
|
|
current_output = null; // TODO?
|
2018-06-30 02:06:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
self.getValue = function() {
|
|
|
|
return editor.getValue();
|
|
|
|
}
|
2018-07-02 13:34:20 +00:00
|
|
|
|
|
|
|
self.getPath = function() { return path; }
|
2018-06-30 02:06:14 +00:00
|
|
|
|
|
|
|
var lines2errmsg = [];
|
|
|
|
self.addErrorMarker = function(line, msg) {
|
|
|
|
var div = document.createElement("div");
|
|
|
|
div.setAttribute("class", "tooltipbox tooltiperror");
|
|
|
|
div.appendChild(document.createTextNode("\u24cd"));
|
|
|
|
var tooltip = document.createElement("span");
|
|
|
|
tooltip.setAttribute("class", "tooltiptext");
|
|
|
|
if (lines2errmsg[line])
|
|
|
|
msg = lines2errmsg[line] + "\n" + msg;
|
|
|
|
tooltip.appendChild(document.createTextNode(msg));
|
|
|
|
lines2errmsg[line] = msg;
|
|
|
|
div.appendChild(tooltip);
|
|
|
|
editor.setGutterMarker(line, "gutter-info", div);
|
|
|
|
}
|
|
|
|
|
|
|
|
self.markErrors = function(errors) {
|
|
|
|
// TODO: move cursor to error line if offscreen?
|
2018-06-30 04:42:21 +00:00
|
|
|
self.clearErrors();
|
2018-06-30 02:06:14 +00:00
|
|
|
toolbar.addClass("has-errors");
|
|
|
|
var numLines = editor.lineCount();
|
|
|
|
for (var info of errors) {
|
|
|
|
var line = info.line-1;
|
|
|
|
if (line < 0 || line >= numLines) line = numLines-1;
|
|
|
|
self.addErrorMarker(line, info.msg);
|
|
|
|
}
|
|
|
|
}
|
2018-06-30 04:42:21 +00:00
|
|
|
|
|
|
|
self.clearErrors = function() {
|
|
|
|
editor.clearGutter("gutter-info");
|
2018-07-03 02:40:15 +00:00
|
|
|
// TODO: set current line marker
|
2018-06-30 04:42:21 +00:00
|
|
|
}
|
2018-06-30 02:06:14 +00:00
|
|
|
|
2018-07-03 02:40:15 +00:00
|
|
|
// TODO: update gutter only when refreshing this window
|
2018-06-30 02:06:14 +00:00
|
|
|
self.updateListing = function(sourcefile) {
|
|
|
|
// update editor annotations
|
|
|
|
editor.clearGutter("gutter-info");
|
|
|
|
editor.clearGutter("gutter-bytes");
|
|
|
|
editor.clearGutter("gutter-offset");
|
|
|
|
editor.clearGutter("gutter-clock");
|
2018-07-03 02:40:15 +00:00
|
|
|
// TODO: support multiple files (use local sourcefile)
|
2018-06-30 02:06:14 +00:00
|
|
|
var lstlines = sourcefile.lines || [];
|
|
|
|
for (var info of lstlines) {
|
|
|
|
if (info.offset >= 0) {
|
|
|
|
var textel = document.createTextNode(hex(info.offset,4));
|
|
|
|
editor.setGutterMarker(info.line-1, "gutter-offset", textel);
|
|
|
|
}
|
|
|
|
if (info.insns) {
|
|
|
|
var insnstr = info.insns.length > 9 ? ("...") : info.insns;
|
|
|
|
var textel = document.createTextNode(insnstr);
|
|
|
|
editor.setGutterMarker(info.line-1, "gutter-bytes", textel);
|
|
|
|
if (info.iscode) {
|
|
|
|
var opcode = parseInt(info.insns.split()[0], 16);
|
|
|
|
if (platform.getOpcodeMetadata) {
|
|
|
|
var meta = platform.getOpcodeMetadata(opcode, info.offset);
|
|
|
|
var clockstr = meta.minCycles+"";
|
|
|
|
var textel = document.createTextNode(clockstr);
|
|
|
|
editor.setGutterMarker(info.line-1, "gutter-clock", textel);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
self.setGutterBytes = function(line, s) {
|
|
|
|
var textel = document.createTextNode(s);
|
|
|
|
editor.setGutterMarker(line-1, "gutter-bytes", textel);
|
|
|
|
}
|
|
|
|
|
|
|
|
self.setCurrentLine = function(line) {
|
|
|
|
function addCurrentMarker(line) {
|
|
|
|
var div = document.createElement("div");
|
2018-07-03 02:40:15 +00:00
|
|
|
div.style.color = '#66ffff';
|
2018-06-30 02:06:14 +00:00
|
|
|
div.appendChild(document.createTextNode("\u25b6"));
|
|
|
|
editor.setGutterMarker(line, "gutter-info", div);
|
|
|
|
}
|
|
|
|
self.clearCurrentLine();
|
|
|
|
if (line>0) {
|
|
|
|
addCurrentMarker(line-1);
|
|
|
|
editor.setSelection({line:line,ch:0}, {line:line-1,ch:0}, {scroll:true});
|
|
|
|
currentDebugLine = line;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
self.clearCurrentLine = function() {
|
|
|
|
if (currentDebugLine) {
|
|
|
|
editor.clearGutter("gutter-info");
|
2018-07-03 02:40:15 +00:00
|
|
|
editor.setSelection(editor.getCursor());
|
2018-06-30 02:06:14 +00:00
|
|
|
currentDebugLine = 0;
|
|
|
|
}
|
|
|
|
}
|
2018-07-02 13:34:20 +00:00
|
|
|
|
|
|
|
self.refresh = function() {
|
2018-07-03 02:40:15 +00:00
|
|
|
// TODO: only use local sourcefile
|
2018-07-02 13:34:20 +00:00
|
|
|
var state = lastDebugState;
|
|
|
|
if (state && state.c) {
|
|
|
|
var PC = state.c.PC;
|
|
|
|
var line = sourcefile.findLineForOffset(PC);
|
|
|
|
if (line >= 0) {
|
|
|
|
console.log("BREAKPOINT", hex(PC), line);
|
2018-07-03 02:40:15 +00:00
|
|
|
self.setCurrentLine(line);
|
2018-07-02 13:34:20 +00:00
|
|
|
// TODO: switch to disasm
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2018-06-30 02:06:14 +00:00
|
|
|
|
|
|
|
self.getLine = function(line) {
|
|
|
|
return editor.getLine(line-1);
|
|
|
|
}
|
|
|
|
|
|
|
|
self.getCurrentLine = function() {
|
|
|
|
return editor.getCursor().line+1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// bitmap editor (TODO: refactor)
|
|
|
|
|
|
|
|
function handleWindowMessage(e) {
|
|
|
|
//console.log("window message", e.data);
|
|
|
|
if (e.data.bytes) {
|
|
|
|
editor.replaceSelection(e.data.bytestr);
|
|
|
|
}
|
|
|
|
if (e.data.close) {
|
|
|
|
$("#pixeditback").hide();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
function openBitmapEditorWithParams(fmt, bytestr, palfmt, palstr) {
|
|
|
|
$("#pixeditback").show();
|
|
|
|
window.addEventListener("message", handleWindowMessage, false); // TODO: remove listener
|
|
|
|
pixeditframe.contentWindow.postMessage({fmt:fmt, bytestr:bytestr, palfmt:palfmt, palstr:palstr}, '*');
|
|
|
|
}
|
|
|
|
|
|
|
|
function lookBackwardsForJSONComment(line, req) {
|
|
|
|
var re = /[/;][*;]([{].+[}])[*;][/;]/;
|
|
|
|
while (--line >= 0) {
|
|
|
|
var s = editor.getLine(line);
|
|
|
|
var m = re.exec(s);
|
|
|
|
if (m) {
|
|
|
|
var jsontxt = m[1].replace(/([A-Za-z]+):/g, '"$1":'); // fix lenient JSON
|
|
|
|
var obj = JSON.parse(jsontxt);
|
|
|
|
if (obj[req]) {
|
|
|
|
var start = {obj:obj, line:line, ch:s.indexOf(m[0])+m[0].length};
|
|
|
|
var line0 = line;
|
|
|
|
var pos0 = start.ch;
|
|
|
|
line--;
|
|
|
|
while (++line < editor.lineCount()) {
|
|
|
|
var l = editor.getLine(line);
|
|
|
|
var endsection;
|
|
|
|
if (platform_id == 'verilog')
|
|
|
|
endsection = l.indexOf('end') >= pos0;
|
|
|
|
else
|
|
|
|
endsection = l.indexOf(';') >= pos0;
|
|
|
|
if (endsection) {
|
|
|
|
var end = {line:line, ch:editor.getLine(line).length};
|
|
|
|
return {obj:obj, start:start, end:end};
|
|
|
|
}
|
|
|
|
pos0 = 0;
|
|
|
|
}
|
|
|
|
line = line0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
self.openBitmapEditorAtCursor = function() {
|
|
|
|
if ($("#pixeditback").is(":visible")) {
|
|
|
|
$("#pixeditback").hide(250);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
var line = editor.getCursor().line + 1;
|
|
|
|
var data = lookBackwardsForJSONComment(self.getCurrentLine(), 'w');
|
|
|
|
if (data && data.obj && data.obj.w>0 && data.obj.h>0) {
|
|
|
|
var paldata = lookBackwardsForJSONComment(data.start.line-1, 'pal');
|
|
|
|
var palbytestr;
|
|
|
|
if (paldata) {
|
|
|
|
palbytestr = editor.getRange(paldata.start, paldata.end);
|
|
|
|
paldata = paldata.obj;
|
|
|
|
}
|
|
|
|
editor.setSelection(data.end, data.start);
|
|
|
|
openBitmapEditorWithParams(data.obj, editor.getSelection(), paldata, palbytestr);
|
|
|
|
} else {
|
|
|
|
alert("To edit graphics, move cursor to a constant array preceded by a comment in the format:\n\n/*{w:,h:,bpp:,count:...}*/\n\n(See code examples)");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2018-07-02 13:34:20 +00:00
|
|
|
function DisassemblerView() {
|
|
|
|
var self = this;
|
|
|
|
var disasmview;
|
|
|
|
|
|
|
|
self.createDiv = function(parent) {
|
|
|
|
var div = document.createElement('div');
|
|
|
|
div.setAttribute("class", "editor");
|
|
|
|
parent.appendChild(div);
|
|
|
|
newEditor(div);
|
|
|
|
return div;
|
|
|
|
}
|
|
|
|
|
|
|
|
function newEditor(parent) {
|
|
|
|
disasmview = CodeMirror(parent, {
|
|
|
|
mode: 'z80',
|
|
|
|
theme: 'cobalt',
|
|
|
|
tabSize: 8,
|
|
|
|
readOnly: true,
|
|
|
|
styleActiveLine: true
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
// TODO: too many globals
|
|
|
|
self.refresh = function() {
|
|
|
|
var state = lastDebugState || platform.saveState();
|
|
|
|
var pc = state.c ? state.c.PC : 0;
|
|
|
|
// do we have an assembly listing?
|
|
|
|
if (assemblyfile && assemblyfile.text) {
|
|
|
|
var asmtext = assemblyfile.text;
|
|
|
|
if (platform_id == 'base_z80') { // TODO
|
|
|
|
asmtext = asmtext.replace(/[ ]+\d+\s+;.+\n/g, '');
|
|
|
|
asmtext = asmtext.replace(/[ ]+\d+\s+.area .+\n/g, '');
|
|
|
|
}
|
|
|
|
disasmview.setValue(asmtext);
|
|
|
|
var findPC = platform.getDebugCallback() ? pc : -1;
|
|
|
|
if (findPC >= 0) {
|
|
|
|
var lineno = assemblyfile.findLineForOffset(findPC);
|
|
|
|
if (lineno) {
|
|
|
|
// set cursor while debugging
|
|
|
|
if (platform.getDebugCallback())
|
|
|
|
disasmview.setCursor(lineno-1, 0);
|
|
|
|
jumpToLine(disasmview, lineno-1);
|
|
|
|
return; // success, don't disassemble in next step
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// TODO: fall through to platform disassembler?
|
|
|
|
else if (platform.disassemble) {
|
|
|
|
var curline = 0;
|
|
|
|
var selline = 0;
|
|
|
|
// TODO: not perfect disassembler
|
|
|
|
function disassemble(start, end) {
|
|
|
|
if (start < 0) start = 0;
|
|
|
|
if (end > 0xffff) end = 0xffff;
|
|
|
|
// TODO: use pc2visits
|
|
|
|
var a = start;
|
|
|
|
var s = "";
|
|
|
|
while (a < end) {
|
|
|
|
var disasm = platform.disassemble(a, platform.readAddress);
|
|
|
|
var srclinenum = sourcefile.offset2line[a];
|
|
|
|
if (srclinenum) {
|
|
|
|
var srcline = getActiveEditor().getLine(srclinenum); // TODO!
|
|
|
|
if (srcline && srcline.trim().length) {
|
|
|
|
s += "; " + srclinenum + ":\t" + srcline + "\n";
|
|
|
|
curline++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
var bytes = "";
|
|
|
|
for (var i=0; i<disasm.nbytes; i++)
|
|
|
|
bytes += hex(platform.readAddress(a+i));
|
|
|
|
while (bytes.length < 14)
|
|
|
|
bytes += ' ';
|
|
|
|
var dline = hex(parseInt(a)) + "\t" + bytes + "\t" + disasm.line + "\n";
|
|
|
|
s += dline;
|
|
|
|
if (a == pc) selline = curline;
|
|
|
|
curline++;
|
|
|
|
a += disasm.nbytes || 1;
|
|
|
|
}
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
var text = disassemble(pc-96, pc) + disassemble(pc, pc+96);
|
|
|
|
disasmview.setValue(text);
|
|
|
|
disasmview.setCursor(selline, 0);
|
|
|
|
jumpToLine(disasmview, selline);
|
|
|
|
} else if (current_output && current_output.code) {
|
|
|
|
// show verilog javascript
|
|
|
|
disasmview.setValue(current_output.code);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
function MemoryView() {
|
|
|
|
var self = this;
|
|
|
|
var memorylist;
|
|
|
|
var dumplines;
|
|
|
|
var div;
|
|
|
|
|
|
|
|
// TODO?
|
|
|
|
function getVisibleEditorLineHeight() {
|
|
|
|
return $(".CodeMirror-line:visible").first().height();
|
|
|
|
}
|
|
|
|
|
|
|
|
self.createDiv = function(parent) {
|
|
|
|
div = document.createElement('div');
|
|
|
|
div.setAttribute("class", "memdump");
|
|
|
|
parent.appendChild(div);
|
|
|
|
showMemoryWindow(div);
|
|
|
|
return div;
|
|
|
|
}
|
|
|
|
|
|
|
|
function showMemoryWindow(parent) {
|
|
|
|
memorylist = new VirtualList({
|
|
|
|
w:$("#workspace").width(),
|
|
|
|
h:$("#workspace").height(),
|
|
|
|
itemHeight: getVisibleEditorLineHeight(),
|
|
|
|
totalRows: 0x1000,
|
|
|
|
generatorFn: function(row) {
|
|
|
|
var s = getMemoryLineAt(row);
|
|
|
|
var div = document.createElement("div");
|
|
|
|
if (dumplines) {
|
|
|
|
var dlr = dumplines[row];
|
|
|
|
if (dlr) div.classList.add('seg_' + getMemorySegment(dumplines[row].a));
|
|
|
|
}
|
|
|
|
div.appendChild(document.createTextNode(s));
|
|
|
|
return div;
|
|
|
|
}
|
|
|
|
});
|
|
|
|
$(parent).append(memorylist.container);
|
|
|
|
self.tick();
|
|
|
|
if (compparams && dumplines)
|
|
|
|
memorylist.scrollToItem(findMemoryWindowLine(compparams.data_start));
|
|
|
|
}
|
|
|
|
|
|
|
|
self.tick = function() {
|
|
|
|
if (memorylist) {
|
|
|
|
$(div).find('[data-index]').each(function(i,e) {
|
|
|
|
var div = $(e);
|
|
|
|
var row = div.attr('data-index');
|
|
|
|
var oldtext = div.text();
|
|
|
|
var newtext = getMemoryLineAt(row);
|
|
|
|
if (oldtext != newtext)
|
|
|
|
div.text(newtext);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
function getMemoryLineAt(row) {
|
|
|
|
var offset = row * 16;
|
|
|
|
var n1 = 0;
|
|
|
|
var n2 = 16;
|
|
|
|
var sym;
|
|
|
|
if (getDumpLines()) {
|
|
|
|
var dl = dumplines[row];
|
|
|
|
if (dl) {
|
|
|
|
offset = dl.a & 0xfff0;
|
|
|
|
n1 = dl.a - offset;
|
|
|
|
n2 = n1 + dl.l;
|
|
|
|
sym = dl.s;
|
|
|
|
} else {
|
|
|
|
return '.';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
var s = hex(offset,4) + ' ';
|
|
|
|
for (var i=0; i<n1; i++) s += ' ';
|
|
|
|
if (n1 > 8) s += ' ';
|
|
|
|
for (var i=n1; i<n2; i++) {
|
|
|
|
var read = platform.readAddress(offset+i);
|
|
|
|
if (i==8) s += ' ';
|
|
|
|
s += ' ' + (read>=0?hex(read,2):'??');
|
|
|
|
}
|
|
|
|
for (var i=n2; i<16; i++) s += ' ';
|
|
|
|
if (sym) s += ' ' + sym;
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
function getDumpLineAt(line) {
|
|
|
|
var d = dumplines[line];
|
|
|
|
if (d) {
|
|
|
|
return d.a + " " + d.s;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
var IGNORE_SYMS = {s__INITIALIZER:true, /* s__GSINIT:true, */ _color_prom:true};
|
|
|
|
|
|
|
|
// TODO: addr2symbol for ca65; and make it work without symbols
|
|
|
|
function getDumpLines() {
|
|
|
|
if (!dumplines && addr2symbol) {
|
|
|
|
dumplines = [];
|
|
|
|
var ofs = 0;
|
|
|
|
var sym;
|
|
|
|
for (var nextofs in addr2symbol) {
|
|
|
|
nextofs |= 0;
|
|
|
|
var nextsym = addr2symbol[nextofs];
|
|
|
|
if (sym) {
|
|
|
|
if (IGNORE_SYMS[sym]) {
|
|
|
|
ofs = nextofs;
|
|
|
|
} else {
|
|
|
|
while (ofs < nextofs) {
|
|
|
|
var ofs2 = (ofs + 16) & 0xffff0;
|
|
|
|
if (ofs2 > nextofs) ofs2 = nextofs;
|
|
|
|
//if (ofs < 1000) console.log(ofs, ofs2, nextofs, sym);
|
|
|
|
dumplines.push({a:ofs, l:ofs2-ofs, s:sym});
|
|
|
|
ofs = ofs2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
sym = nextsym;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return dumplines;
|
|
|
|
}
|
|
|
|
|
|
|
|
function getMemorySegment(a) {
|
|
|
|
if (!compparams) return 'unknown';
|
|
|
|
if (a >= compparams.data_start && a < compparams.data_start+compparams.data_size) {
|
|
|
|
if (platform.getSP && a >= platform.getSP() - 15)
|
|
|
|
return 'stack';
|
|
|
|
else
|
|
|
|
return 'data';
|
|
|
|
}
|
|
|
|
else if (a >= compparams.code_start && a < compparams.code_start+compparams.code_size)
|
|
|
|
return 'code';
|
|
|
|
else
|
|
|
|
return 'unknown';
|
|
|
|
}
|
|
|
|
|
|
|
|
function findMemoryWindowLine(a) {
|
|
|
|
for (var i=0; i<dumplines.length; i++)
|
|
|
|
if (dumplines[i].a >= a)
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/////
|
|
|
|
|
|
|
|
function ProjectWindows(containerdiv) {
|
|
|
|
var id2window = {};
|
|
|
|
var id2createfn = {};
|
|
|
|
var id2div = {};
|
|
|
|
var activewnd;
|
|
|
|
var activediv;
|
|
|
|
|
|
|
|
this.setCreateFunc = function(id, createfn) {
|
|
|
|
id2createfn[id] = createfn;
|
|
|
|
}
|
|
|
|
|
|
|
|
this.createOrShow = function(id) {
|
|
|
|
var wnd = id2window[id];
|
|
|
|
if (!wnd) {
|
|
|
|
wnd = id2window[id] = id2createfn[id](id);
|
|
|
|
}
|
|
|
|
var div = id2div[id];
|
|
|
|
if (!div) {
|
|
|
|
div = id2div[id] = wnd.createDiv(containerdiv, current_project.getFile(id));
|
|
|
|
}
|
|
|
|
if (activewnd != wnd) {
|
|
|
|
if (activediv)
|
|
|
|
$(activediv).hide();
|
|
|
|
activediv = div;
|
|
|
|
activewnd = wnd;
|
|
|
|
$(div).show();
|
|
|
|
this.refresh();
|
|
|
|
}
|
|
|
|
return wnd;
|
|
|
|
}
|
|
|
|
|
|
|
|
this.put = function(id, window, category) {
|
|
|
|
id2window[id] = window;
|
|
|
|
if (!categories[category])
|
|
|
|
categories[category] = [];
|
|
|
|
// TODO: remove/replace window
|
|
|
|
if (!(id in categories[category]))
|
|
|
|
categories[category].push(id);
|
|
|
|
}
|
|
|
|
|
|
|
|
this.filesForCategory = function(id) {
|
|
|
|
return categories[id] || [];
|
|
|
|
}
|
|
|
|
|
|
|
|
this.refresh = function() {
|
|
|
|
if (activewnd && activewnd.refresh)
|
|
|
|
activewnd.refresh();
|
|
|
|
}
|
|
|
|
|
|
|
|
this.tick = function() {
|
|
|
|
if (activewnd && activewnd.tick)
|
|
|
|
activewnd.tick();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
var projectWindows = new ProjectWindows($("#workspace")[0]);
|
|
|
|
|
|
|
|
// TODO: support multiple editors, this might should go
|
2018-06-30 02:06:14 +00:00
|
|
|
function getActiveEditor() {
|
|
|
|
return active_editor;
|
2016-12-16 01:21:51 +00:00
|
|
|
}
|
|
|
|
|
2018-07-02 13:34:20 +00:00
|
|
|
function refreshWindowList() {
|
|
|
|
var ul = $("#windowMenuList").empty();
|
|
|
|
var separate = false;
|
|
|
|
|
|
|
|
function addWindowItem(id, name, createfn) {
|
|
|
|
if (separate) {
|
|
|
|
ul.append(document.createElement("hr"));
|
|
|
|
separate = false;
|
|
|
|
}
|
|
|
|
var li = document.createElement("li");
|
|
|
|
var a = document.createElement("a");
|
|
|
|
a.setAttribute("class", "dropdown-item");
|
|
|
|
a.setAttribute("href", "#");
|
|
|
|
a.appendChild(document.createTextNode(name));
|
|
|
|
li.appendChild(a);
|
|
|
|
ul.append(li);
|
|
|
|
if (createfn) {
|
|
|
|
projectWindows.setCreateFunc(id, createfn);
|
|
|
|
$(a).click(function() {
|
|
|
|
projectWindows.createOrShow(id);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
function loadEditor(path) {
|
|
|
|
var tool = platform.getToolForFilename(path);
|
|
|
|
var mode = tool && TOOL_TO_SOURCE_STYLE[tool];
|
|
|
|
return new SourceEditor(path, mode, current_project.getFile(path));
|
|
|
|
}
|
|
|
|
|
|
|
|
// add main file editor
|
|
|
|
var id = current_file_id;
|
|
|
|
addWindowItem(id, getFilenameForPath(id), loadEditor);
|
|
|
|
|
|
|
|
// add other files
|
|
|
|
separate = true;
|
|
|
|
current_project.iterateFiles(function(id, text) {
|
|
|
|
if (id != current_file_id)
|
|
|
|
addWindowItem(id, getFilenameForPath(id), loadEditor);
|
|
|
|
});
|
|
|
|
|
|
|
|
// add other tools
|
|
|
|
separate = true;
|
|
|
|
if (platform.saveState) { // TODO: only show if listing or disasm available
|
|
|
|
addWindowItem("#disasm", "Disassembly", function() {
|
|
|
|
return new DisassemblerView();
|
|
|
|
});
|
|
|
|
}
|
|
|
|
// TODO
|
|
|
|
if (platform.readAddress && platform_id != 'vcs') {
|
|
|
|
addWindowItem("#memory", "Memory Browser", function() {
|
|
|
|
return new MemoryView();
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-06-28 04:57:06 +00:00
|
|
|
// can pass integer or string id
|
2018-06-29 23:44:04 +00:00
|
|
|
function loadProject(preset_id) {
|
2018-06-28 04:57:06 +00:00
|
|
|
var index = parseInt(preset_id+""); // might fail -1
|
2016-12-16 01:21:51 +00:00
|
|
|
for (var i=0; i<PRESETS.length; i++)
|
|
|
|
if (PRESETS[i].id == preset_id)
|
|
|
|
index = i;
|
|
|
|
index = (index + PRESETS.length) % PRESETS.length;
|
|
|
|
if (index >= 0) {
|
|
|
|
// load the preset
|
2018-06-29 23:44:04 +00:00
|
|
|
current_preset_entry = PRESETS[index];
|
|
|
|
preset_id = current_preset_entry.id;
|
2016-12-16 01:21:51 +00:00
|
|
|
}
|
2018-06-29 23:52:09 +00:00
|
|
|
// set current file ID
|
2018-06-29 23:44:04 +00:00
|
|
|
current_file_id = preset_id;
|
2018-07-02 13:34:20 +00:00
|
|
|
setLastPreset(preset_id);
|
2018-06-29 23:52:09 +00:00
|
|
|
// load files from storage or web URLs
|
2018-06-29 23:44:04 +00:00
|
|
|
current_project.loadFiles([preset_id], function(err, result) {
|
|
|
|
if (err) {
|
|
|
|
alert(err);
|
|
|
|
} else if (result && result.length) {
|
2018-07-02 13:34:20 +00:00
|
|
|
refreshWindowList();
|
|
|
|
// show main file (need create window list first)
|
|
|
|
active_editor = projectWindows.createOrShow(preset_id);
|
2018-06-29 23:44:04 +00:00
|
|
|
}
|
|
|
|
});
|
2016-12-16 01:21:51 +00:00
|
|
|
}
|
|
|
|
|
2018-06-28 04:57:06 +00:00
|
|
|
function reloadPresetNamed(id) {
|
2017-01-16 15:35:19 +00:00
|
|
|
qs['platform'] = platform_id;
|
|
|
|
qs['file'] = id;
|
2017-01-16 19:13:03 +00:00
|
|
|
gotoNewLocation();
|
2016-12-16 01:21:51 +00:00
|
|
|
}
|
|
|
|
|
2018-06-29 23:44:04 +00:00
|
|
|
function getSkeletonFile(fileid, callback) {
|
|
|
|
var ext = platform.getToolForFilename(fileid);
|
|
|
|
$.get( "presets/"+platform_id+"/skeleton."+ext, function( text ) {
|
|
|
|
callback(null, text);
|
|
|
|
}, 'text')
|
|
|
|
.fail(function() {
|
2018-07-02 13:34:20 +00:00
|
|
|
alert("Could not load skeleton for " + platform_id + "/" + ext + "; using blank file");
|
|
|
|
callback(null, '\n');
|
2018-06-29 23:44:04 +00:00
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2016-12-16 01:21:51 +00:00
|
|
|
function _createNewFile(e) {
|
2017-04-23 13:03:05 +00:00
|
|
|
var filename = prompt("Create New File", "newfile" + platform.getDefaultExtension());
|
2016-12-16 01:21:51 +00:00
|
|
|
if (filename && filename.length) {
|
|
|
|
if (filename.indexOf(".") < 0) {
|
2017-04-20 00:55:13 +00:00
|
|
|
filename += platform.getDefaultExtension();
|
2016-12-16 01:21:51 +00:00
|
|
|
}
|
2018-06-29 23:44:04 +00:00
|
|
|
var path = "local/" + filename;
|
|
|
|
getSkeletonFile(path, function(err, result) {
|
|
|
|
if (result) {
|
|
|
|
store.setItem(path, result, function(err, result) {
|
2018-07-02 13:34:20 +00:00
|
|
|
if (err)
|
|
|
|
alert(err+"");
|
|
|
|
if (result != null)
|
2018-06-29 23:52:09 +00:00
|
|
|
reloadPresetNamed("local/" + filename);
|
2018-06-29 23:44:04 +00:00
|
|
|
});
|
|
|
|
}
|
|
|
|
});
|
2016-12-16 01:21:51 +00:00
|
|
|
}
|
2016-12-30 23:51:15 +00:00
|
|
|
return true;
|
2016-12-16 01:21:51 +00:00
|
|
|
}
|
|
|
|
|
2018-06-26 23:57:03 +00:00
|
|
|
function _uploadNewFile(e) {
|
|
|
|
$("#uploadFileElem").click();
|
|
|
|
}
|
|
|
|
|
|
|
|
function handleFileUpload(files) {
|
|
|
|
console.log(files);
|
|
|
|
var index = 0;
|
|
|
|
function uploadNextFile() {
|
|
|
|
var f = files[index++];
|
|
|
|
if (!f) {
|
|
|
|
console.log("Done uploading");
|
|
|
|
gotoNewLocation();
|
|
|
|
} else {
|
|
|
|
var path = "local/" + f.name;
|
|
|
|
var reader = new FileReader();
|
|
|
|
reader.onload = function(e) {
|
|
|
|
var data = e.target.result;
|
|
|
|
store.setItem(path, data, function(err, result) {
|
|
|
|
if (err)
|
|
|
|
console.log(err);
|
|
|
|
else {
|
|
|
|
console.log("Uploaded " + path + " " + data.length + " bytes");
|
|
|
|
if (index == 1)
|
|
|
|
qs['file'] = path;
|
|
|
|
uploadNextFile();
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
reader.readAsText(f);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (files) uploadNextFile();
|
|
|
|
}
|
|
|
|
|
2017-02-02 19:11:52 +00:00
|
|
|
function getCurrentFilename() {
|
2018-06-28 04:18:16 +00:00
|
|
|
var toks = current_file_id.split("/");
|
2017-02-02 19:11:52 +00:00
|
|
|
return toks[toks.length-1];
|
|
|
|
}
|
|
|
|
|
2016-12-16 01:21:51 +00:00
|
|
|
function _shareFile(e) {
|
2018-06-30 04:42:21 +00:00
|
|
|
if (current_output == null) { // TODO
|
2016-12-30 23:51:15 +00:00
|
|
|
alert("Please fix errors before sharing.");
|
|
|
|
return true;
|
|
|
|
}
|
2017-01-25 17:30:05 +00:00
|
|
|
var github = new Octokat();
|
|
|
|
var files = {};
|
2018-06-30 02:06:14 +00:00
|
|
|
var text = getActiveEditor().getValue();
|
2017-02-02 19:11:52 +00:00
|
|
|
files[getCurrentFilename()] = {"content": text};
|
2017-01-25 17:30:05 +00:00
|
|
|
var gistdata = {
|
|
|
|
"description": '8bitworkshop.com {"platform":"' + platform_id + '"}',
|
|
|
|
"public": true,
|
|
|
|
"files": files
|
|
|
|
};
|
|
|
|
var gist = github.gists.create(gistdata).done(function(val) {
|
|
|
|
var url = "http://8bitworkshop.com/?sharekey=" + val.id;
|
|
|
|
window.prompt("Copy link to clipboard (Ctrl+C, Enter)", url);
|
|
|
|
}).fail(function(err) {
|
|
|
|
alert("Error sharing file: " + err.message);
|
2016-12-16 01:21:51 +00:00
|
|
|
});
|
2016-12-30 23:51:15 +00:00
|
|
|
return true;
|
2016-12-16 01:21:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
function _resetPreset(e) {
|
2018-06-28 04:18:16 +00:00
|
|
|
if (!current_preset_entry) {
|
2017-01-03 01:42:15 +00:00
|
|
|
alert("Can only reset built-in file examples.")
|
2018-06-28 04:18:16 +00:00
|
|
|
} else if (confirm("Reset '" + current_preset_entry.name + "' to default?")) {
|
2016-12-16 01:21:51 +00:00
|
|
|
qs['reset'] = '1';
|
2017-01-16 19:13:03 +00:00
|
|
|
gotoNewLocation();
|
2016-12-16 01:21:51 +00:00
|
|
|
}
|
2016-12-30 23:51:15 +00:00
|
|
|
return true;
|
2016-12-16 01:21:51 +00:00
|
|
|
}
|
|
|
|
|
2017-02-02 19:11:52 +00:00
|
|
|
function _downloadROMImage(e) {
|
2018-06-30 04:42:21 +00:00
|
|
|
if (current_output == null) { // TODO
|
2017-02-02 19:11:52 +00:00
|
|
|
alert("Please fix errors before downloading ROM.");
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
var blob = new Blob([current_output], {type: "application/octet-stream"});
|
|
|
|
saveAs(blob, getCurrentFilename()+".rom");
|
|
|
|
}
|
|
|
|
|
2018-03-23 21:05:08 +00:00
|
|
|
function _downloadSourceFile(e) {
|
2018-06-30 02:06:14 +00:00
|
|
|
var blob = new Blob([getActiveEditor().getValue()], {type: "text/plain;charset=utf-8"});
|
2018-03-23 21:05:08 +00:00
|
|
|
saveAs(blob, getCurrentFilename());
|
|
|
|
}
|
|
|
|
|
2016-12-16 01:21:51 +00:00
|
|
|
function populateExamples(sel) {
|
2018-06-26 06:56:36 +00:00
|
|
|
// make sure to use callback so it follows other sections
|
|
|
|
store.length(function(err, len) {
|
|
|
|
sel.append($("<option />").text("--------- Examples ---------").attr('disabled',true));
|
|
|
|
for (var i=0; i<PRESETS.length; i++) {
|
|
|
|
var preset = PRESETS[i];
|
|
|
|
var name = preset.chapter ? (preset.chapter + ". " + preset.name) : preset.name;
|
2018-06-28 04:18:16 +00:00
|
|
|
sel.append($("<option />").val(preset.id).text(name).attr('selected',preset.id==current_file_id));
|
2018-06-26 06:56:36 +00:00
|
|
|
}
|
|
|
|
});
|
2016-12-16 01:21:51 +00:00
|
|
|
}
|
|
|
|
|
2018-06-26 06:56:36 +00:00
|
|
|
function populateFiles(sel, category, prefix) {
|
|
|
|
store.keys(function(err, keys) {
|
|
|
|
var foundSelected = false;
|
|
|
|
var numFound = 0;
|
|
|
|
if (!keys) keys = [];
|
|
|
|
for (var i = 0; i < keys.length; i++) {
|
|
|
|
var key = keys[i];
|
|
|
|
if (key.startsWith(prefix)) {
|
|
|
|
if (numFound++ == 0)
|
|
|
|
sel.append($("<option />").text("------- " + category + " -------").attr('disabled',true));
|
|
|
|
var name = key.substring(prefix.length);
|
2018-06-28 04:18:16 +00:00
|
|
|
sel.append($("<option />").val(key).text(name).attr('selected',key==current_file_id));
|
|
|
|
if (key == current_file_id) foundSelected = true;
|
2018-06-26 06:56:36 +00:00
|
|
|
}
|
|
|
|
}
|
2018-06-28 04:18:16 +00:00
|
|
|
if (!foundSelected && current_file_id && current_file_id.startsWith(prefix)) {
|
|
|
|
var name = current_file_id.slice(prefix.length);
|
2018-06-26 06:56:36 +00:00
|
|
|
var key = prefix + name;
|
|
|
|
sel.append($("<option />").val(key).text(name).attr('selected',true));
|
|
|
|
}
|
|
|
|
});
|
2016-12-16 01:21:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
function updateSelector() {
|
|
|
|
var sel = $("#preset_select").empty();
|
2017-04-29 15:31:11 +00:00
|
|
|
if (platform_id != 'base_z80') { // TODO
|
|
|
|
populateFiles(sel, "Local Files", "local/");
|
|
|
|
populateFiles(sel, "Shared", "shared/");
|
|
|
|
}
|
2016-12-16 01:21:51 +00:00
|
|
|
populateExamples(sel);
|
|
|
|
// set click handlers
|
|
|
|
sel.off('change').change(function(e) {
|
2018-06-28 04:57:06 +00:00
|
|
|
reloadPresetNamed($(this).val());
|
2016-12-16 01:21:51 +00:00
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2017-03-24 22:10:35 +00:00
|
|
|
function setCompileOutput(data) {
|
2018-07-02 13:34:20 +00:00
|
|
|
// TODO: support multiple edit windows
|
2018-06-30 02:06:14 +00:00
|
|
|
var sed = getActiveEditor();
|
2018-07-02 13:34:20 +00:00
|
|
|
// errors? mark them in editor
|
2018-06-25 23:47:40 +00:00
|
|
|
if (data.errors && data.errors.length > 0) {
|
2018-06-30 02:06:14 +00:00
|
|
|
sed.markErrors(data.errors);
|
2016-12-16 01:21:51 +00:00
|
|
|
} else {
|
2018-06-30 04:42:21 +00:00
|
|
|
// choose first listing (TODO:support multiple source files)
|
|
|
|
sourcefile = null;
|
|
|
|
assemblyfile = null;
|
|
|
|
if (data.listings) {
|
|
|
|
var lst;
|
|
|
|
for (var lstname in data.listings) {
|
|
|
|
lst = data.listings[lstname];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (lst) {
|
|
|
|
sourcefile = lst.sourcefile;
|
|
|
|
assemblyfile = lst.assemblyfile;
|
|
|
|
}
|
|
|
|
}
|
2018-07-03 02:40:15 +00:00
|
|
|
if (!sourcefile) sourcefile = new SourceFile();
|
2018-06-30 04:42:21 +00:00
|
|
|
symbolmap = data.symbolmap;
|
|
|
|
addr2symbol = invertMap(symbolmap);
|
|
|
|
if (!addr2symbol[0x0]) addr2symbol[0x0] = '__START__'; // needed for ...
|
|
|
|
addr2symbol[0x10000] = '__END__'; // needed for dump memory to work
|
|
|
|
compparams = data.params;
|
2016-12-16 01:21:51 +00:00
|
|
|
// load ROM
|
2018-06-28 03:26:23 +00:00
|
|
|
// TODO: don't have to compare anymore; worker does it
|
2017-03-24 22:10:35 +00:00
|
|
|
var rom = data.output;
|
2018-02-26 21:42:20 +00:00
|
|
|
var rom_changed = false;
|
|
|
|
if (rom && rom.code)
|
|
|
|
rom_changed = !current_output || rom.code != current_output.code;
|
|
|
|
else if (rom)
|
|
|
|
rom_changed = !arrayCompare(rom, current_output);
|
2016-12-16 01:21:51 +00:00
|
|
|
if (rom_changed) {
|
|
|
|
try {
|
|
|
|
//console.log("Loading ROM length", rom.length);
|
2016-12-31 16:05:22 +00:00
|
|
|
platform.loadROM(getCurrentPresetTitle(), rom);
|
2017-11-28 02:08:19 +00:00
|
|
|
if (!userPaused) resume();
|
2016-12-16 01:21:51 +00:00
|
|
|
current_output = rom;
|
2018-06-27 02:32:34 +00:00
|
|
|
//resetProfiler();
|
2016-12-16 01:21:51 +00:00
|
|
|
} catch (e) {
|
2017-01-16 15:35:19 +00:00
|
|
|
console.log(e); // TODO: show error
|
2017-01-16 19:13:03 +00:00
|
|
|
toolbar.addClass("has-errors");
|
2018-06-30 02:06:14 +00:00
|
|
|
sed.addErrorMarker(0, e+"");
|
2016-12-16 01:21:51 +00:00
|
|
|
current_output = null;
|
|
|
|
}
|
2018-03-02 05:15:33 +00:00
|
|
|
} else if (rom.program_rom_variable) { //TODO: a little wonky...
|
|
|
|
platform.loadROM(rom.program_rom_variable, rom.program_rom);
|
|
|
|
rom_changed = true;
|
2016-12-16 01:21:51 +00:00
|
|
|
}
|
|
|
|
if (rom_changed || trace_pending_at_pc) {
|
2018-06-30 02:06:14 +00:00
|
|
|
sed.updateListing(sourcefile);
|
2016-12-16 01:21:51 +00:00
|
|
|
}
|
2018-07-02 13:34:20 +00:00
|
|
|
projectWindows.refresh();
|
2016-12-16 01:21:51 +00:00
|
|
|
if (trace_pending_at_pc) {
|
|
|
|
showLoopTimingForPC(trace_pending_at_pc);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
trace_pending_at_pc = null;
|
|
|
|
}
|
|
|
|
|
|
|
|
function showMemory(state) {
|
2018-06-18 08:12:52 +00:00
|
|
|
var s = state && platform.cpuStateToLongString && platform.cpuStateToLongString(state.c);
|
|
|
|
if (s) {
|
2017-01-20 03:42:58 +00:00
|
|
|
if (platform.getRasterPosition) {
|
|
|
|
var pos = platform.getRasterPosition();
|
|
|
|
s += "H:" + pos.x + " V:" + pos.y + "\n"; // TODO: padding
|
|
|
|
}
|
2017-01-14 02:31:04 +00:00
|
|
|
if (platform.ramStateToLongString) {
|
|
|
|
s += platform.ramStateToLongString(state);
|
2016-12-16 01:21:51 +00:00
|
|
|
}
|
|
|
|
var hs = lastDebugInfo ? highlightDifferences(lastDebugInfo, s) : s;
|
|
|
|
$("#mem_info").show().html(hs);
|
|
|
|
lastDebugInfo = s;
|
|
|
|
} else {
|
|
|
|
$("#mem_info").hide();
|
|
|
|
lastDebugInfo = null;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
function setupBreakpoint() {
|
|
|
|
// TODO
|
2016-12-31 16:05:22 +00:00
|
|
|
platform.setupDebug(function(state) {
|
2017-01-06 14:49:07 +00:00
|
|
|
lastDebugState = state;
|
2016-12-16 01:21:51 +00:00
|
|
|
showMemory(state);
|
2018-07-02 13:34:20 +00:00
|
|
|
projectWindows.refresh();
|
2016-12-31 16:05:22 +00:00
|
|
|
});
|
2016-12-16 01:21:51 +00:00
|
|
|
}
|
|
|
|
|
2017-11-16 17:08:06 +00:00
|
|
|
function _pause() {
|
2016-12-31 16:05:22 +00:00
|
|
|
if (platform.isRunning()) {
|
|
|
|
platform.pause();
|
2018-02-21 18:54:53 +00:00
|
|
|
console.log("Paused");
|
2016-12-16 01:21:51 +00:00
|
|
|
}
|
2017-11-16 17:08:06 +00:00
|
|
|
$("#dbg_pause").addClass("btn_stopped");
|
|
|
|
$("#dbg_go").removeClass("btn_active");
|
2016-12-16 01:21:51 +00:00
|
|
|
}
|
|
|
|
|
2017-11-16 17:08:06 +00:00
|
|
|
function pause() {
|
2016-12-16 01:21:51 +00:00
|
|
|
clearBreakpoint();
|
2017-11-16 17:08:06 +00:00
|
|
|
_pause();
|
2017-11-28 02:08:19 +00:00
|
|
|
userPaused = true;
|
2017-11-16 17:08:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
function _resume() {
|
2016-12-31 16:05:22 +00:00
|
|
|
if (! platform.isRunning()) {
|
|
|
|
platform.resume();
|
2018-02-21 18:54:53 +00:00
|
|
|
console.log("Resumed");
|
2016-12-16 01:21:51 +00:00
|
|
|
}
|
2017-11-16 17:08:06 +00:00
|
|
|
$("#dbg_pause").removeClass("btn_stopped");
|
|
|
|
$("#dbg_go").addClass("btn_active");
|
|
|
|
}
|
|
|
|
|
|
|
|
function resume() {
|
|
|
|
clearBreakpoint();
|
2018-06-24 17:39:08 +00:00
|
|
|
if (! platform.isRunning() ) {
|
2018-06-30 02:06:14 +00:00
|
|
|
getActiveEditor().clearCurrentLine(); // TODO
|
2018-06-24 17:39:08 +00:00
|
|
|
}
|
2017-11-16 17:08:06 +00:00
|
|
|
_resume();
|
2017-11-28 02:08:19 +00:00
|
|
|
userPaused = false;
|
2016-12-16 01:21:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
function singleStep() {
|
|
|
|
setupBreakpoint();
|
2016-12-31 16:05:22 +00:00
|
|
|
platform.step();
|
2016-12-16 01:21:51 +00:00
|
|
|
}
|
|
|
|
|
2017-11-24 19:14:22 +00:00
|
|
|
function singleFrameStep() {
|
|
|
|
setupBreakpoint();
|
|
|
|
platform.runToVsync();
|
|
|
|
}
|
|
|
|
|
2018-07-02 13:34:20 +00:00
|
|
|
// TODO: fix these
|
2017-02-18 22:50:51 +00:00
|
|
|
function getDisasmViewPC() {
|
|
|
|
var line = disasmview.getCursor().line;
|
2017-02-25 15:57:39 +00:00
|
|
|
if (line >= 0) {
|
2017-02-18 22:50:51 +00:00
|
|
|
var toks = disasmview.getLine(line).split(/\s+/);
|
2017-02-25 15:57:39 +00:00
|
|
|
if (toks && toks[0].length == 4) {
|
2017-02-18 22:50:51 +00:00
|
|
|
return parseInt(toks[0], 16);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-07-02 13:34:20 +00:00
|
|
|
// TODO: fix this
|
|
|
|
function getEditorPC() {
|
2018-06-30 02:06:14 +00:00
|
|
|
var line = getActiveEditor().getCurrentLine(); // TODO
|
2017-02-25 15:57:39 +00:00
|
|
|
while (line >= 0) {
|
2018-06-21 18:15:05 +00:00
|
|
|
// TODO: what if in disassembler?
|
2017-02-25 15:57:39 +00:00
|
|
|
var pc = sourcefile.line2offset[line];
|
|
|
|
if (pc >= 0) return pc;
|
|
|
|
line--;
|
2017-02-05 04:19:54 +00:00
|
|
|
}
|
2017-02-25 15:57:39 +00:00
|
|
|
return getDisasmViewPC();
|
2017-02-05 04:19:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
function runToCursor() {
|
|
|
|
setupBreakpoint();
|
2018-07-02 13:34:20 +00:00
|
|
|
var pc = getEditorPC();
|
2017-01-14 02:31:04 +00:00
|
|
|
if (pc >= 0) {
|
2017-02-05 04:19:54 +00:00
|
|
|
console.log("Run to", pc.toString(16));
|
2018-06-18 08:12:52 +00:00
|
|
|
if (platform.runToPC) {
|
|
|
|
platform.runToPC(pc);
|
|
|
|
} else {
|
|
|
|
platform.runEval(function(c) {
|
|
|
|
return c.PC == pc;
|
|
|
|
});
|
|
|
|
}
|
2016-12-16 01:21:51 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-07 18:05:02 +00:00
|
|
|
function runUntilReturn() {
|
|
|
|
setupBreakpoint();
|
2017-01-14 02:31:04 +00:00
|
|
|
platform.runUntilReturn();
|
2017-01-07 18:05:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
function runStepBackwards() {
|
|
|
|
setupBreakpoint();
|
|
|
|
platform.stepBack();
|
|
|
|
}
|
|
|
|
|
2016-12-16 01:21:51 +00:00
|
|
|
function clearBreakpoint() {
|
2017-01-06 14:49:07 +00:00
|
|
|
lastDebugState = null;
|
2017-11-11 19:45:32 +00:00
|
|
|
if (platform.clearDebug) platform.clearDebug();
|
2016-12-16 01:21:51 +00:00
|
|
|
showMemory();
|
|
|
|
}
|
|
|
|
|
2017-01-16 04:47:12 +00:00
|
|
|
function jumpToLine(ed, i) {
|
|
|
|
var t = ed.charCoords({line: i, ch: 0}, "local").top;
|
|
|
|
var middleHeight = ed.getScrollerElement().offsetHeight / 2;
|
|
|
|
ed.scrollTo(null, t - middleHeight - 5);
|
|
|
|
}
|
|
|
|
|
2017-04-22 17:33:20 +00:00
|
|
|
function getVisibleSourceFile() {
|
|
|
|
var div = $("#disassembly");
|
|
|
|
return div.is(':visible') ? assemblyfile : sourcefile;
|
|
|
|
}
|
|
|
|
|
2016-12-16 01:21:51 +00:00
|
|
|
function resetAndDebug() {
|
2017-11-29 01:48:27 +00:00
|
|
|
if (platform.setupDebug && platform.readAddress) { // TODO??
|
2017-11-11 19:45:32 +00:00
|
|
|
clearBreakpoint();
|
2017-11-16 17:08:06 +00:00
|
|
|
_resume();
|
2017-11-11 19:45:32 +00:00
|
|
|
platform.reset();
|
|
|
|
setupBreakpoint();
|
2018-06-22 06:24:52 +00:00
|
|
|
if (platform.runEval)
|
|
|
|
platform.runEval(function(c) { return true; }); // break immediately
|
|
|
|
else
|
|
|
|
; // TODO???
|
2017-11-11 19:45:32 +00:00
|
|
|
} else {
|
|
|
|
platform.reset();
|
|
|
|
}
|
2017-01-03 01:42:15 +00:00
|
|
|
}
|
2017-01-06 16:57:28 +00:00
|
|
|
|
2018-06-27 02:32:34 +00:00
|
|
|
var lastBreakExpr = "c.PC = 0x6000";
|
2017-01-07 18:05:02 +00:00
|
|
|
function _breakExpression() {
|
2018-06-27 02:32:34 +00:00
|
|
|
var exprs = window.prompt("Enter break expression", lastBreakExpr);
|
2017-01-07 18:05:02 +00:00
|
|
|
if (exprs) {
|
|
|
|
var fn = new Function('c', 'return (' + exprs + ');');
|
|
|
|
setupBreakpoint();
|
|
|
|
platform.runEval(fn);
|
2018-06-27 02:32:34 +00:00
|
|
|
lastBreakExpr = exprs;
|
2017-01-07 18:05:02 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-04-22 01:56:49 +00:00
|
|
|
function getSymbolAtAddress(a) {
|
|
|
|
if (addr2symbol[a]) return addr2symbol[a];
|
|
|
|
var i=0;
|
|
|
|
while (--a >= 0) {
|
|
|
|
i++;
|
|
|
|
if (addr2symbol[a]) return addr2symbol[a] + '+' + i;
|
|
|
|
}
|
|
|
|
return '';
|
|
|
|
}
|
|
|
|
|
2017-04-19 01:18:53 +00:00
|
|
|
function updateDebugWindows() {
|
|
|
|
if (platform.isRunning()) {
|
2018-07-02 13:34:20 +00:00
|
|
|
projectWindows.tick();
|
2017-04-19 01:18:53 +00:00
|
|
|
}
|
|
|
|
setTimeout(updateDebugWindows, 200);
|
|
|
|
}
|
|
|
|
|
2017-05-20 19:13:23 +00:00
|
|
|
function _recordVideo() {
|
|
|
|
var canvas = $("#emulator").find("canvas")[0];
|
|
|
|
if (!canvas) {
|
|
|
|
alert("Could not find canvas element to record video!");
|
|
|
|
return;
|
|
|
|
}
|
2017-05-25 19:49:30 +00:00
|
|
|
var rotate = 0;
|
|
|
|
if (canvas.style && canvas.style.transform) {
|
|
|
|
if (canvas.style.transform.indexOf("rotate(-90deg)") >= 0)
|
|
|
|
rotate = -1;
|
|
|
|
else if (canvas.style.transform.indexOf("rotate(90deg)") >= 0)
|
|
|
|
rotate = 1;
|
|
|
|
}
|
|
|
|
var gif = new GIF({
|
|
|
|
workerScript: 'gif.js/dist/gif.worker.js',
|
|
|
|
workers: 4,
|
|
|
|
quality: 10,
|
|
|
|
rotate: rotate
|
|
|
|
});
|
2017-05-20 19:13:23 +00:00
|
|
|
var img = $('#videoPreviewImage');
|
|
|
|
//img.attr('src', 'https://articulate-heroes.s3.amazonaws.com/uploads/rte/kgrtehja_DancingBannana.gif');
|
|
|
|
gif.on('finished', function(blob) {
|
|
|
|
img.attr('src', URL.createObjectURL(blob));
|
2017-05-25 19:49:30 +00:00
|
|
|
$("#pleaseWaitModal").modal('hide');
|
2017-11-16 17:08:06 +00:00
|
|
|
_resume();
|
2017-05-20 19:13:23 +00:00
|
|
|
$("#videoPreviewModal").modal('show');
|
|
|
|
});
|
|
|
|
var intervalMsec = 17;
|
|
|
|
var maxFrames = 500;
|
|
|
|
var nframes = 0;
|
|
|
|
console.log("Recording video", canvas);
|
|
|
|
var f = function() {
|
|
|
|
if (nframes++ > maxFrames) {
|
|
|
|
console.log("Rendering video");
|
2017-05-25 19:49:30 +00:00
|
|
|
$("#pleaseWaitModal").modal('show');
|
2017-11-16 17:08:06 +00:00
|
|
|
_pause();
|
2017-05-20 19:13:23 +00:00
|
|
|
gif.render();
|
|
|
|
} else {
|
2017-05-25 19:49:30 +00:00
|
|
|
gif.addFrame(canvas, {delay: intervalMsec, copy: true});
|
2017-05-20 19:13:23 +00:00
|
|
|
setTimeout(f, intervalMsec);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
f();
|
|
|
|
}
|
|
|
|
|
2018-02-26 23:18:23 +00:00
|
|
|
function setFrameRateUI(fps) {
|
|
|
|
platform.setFrameRate(fps);
|
|
|
|
if (fps > 0.01)
|
|
|
|
$("#fps_label").text(fps.toFixed(2));
|
|
|
|
else
|
|
|
|
$("#fps_label").text("1/"+Math.round(1/fps));
|
|
|
|
}
|
|
|
|
|
|
|
|
function _slowerFrameRate() {
|
|
|
|
var fps = platform.getFrameRate();
|
|
|
|
fps = fps/2;
|
|
|
|
if (fps > 0.00001) setFrameRateUI(fps);
|
|
|
|
}
|
|
|
|
|
|
|
|
function _fasterFrameRate() {
|
|
|
|
var fps = platform.getFrameRate();
|
|
|
|
fps = Math.min(60, fps*2);
|
|
|
|
setFrameRateUI(fps);
|
|
|
|
}
|
|
|
|
|
2018-02-27 04:48:36 +00:00
|
|
|
function _slowestFrameRate() {
|
|
|
|
setFrameRateUI(60/65536);
|
|
|
|
}
|
|
|
|
|
|
|
|
function _fastestFrameRate() {
|
|
|
|
setFrameRateUI(60);
|
|
|
|
}
|
|
|
|
|
2018-06-30 02:06:14 +00:00
|
|
|
function _openBitmapEditor() {
|
|
|
|
getActiveEditor().openBitmapEditorAtCursor();
|
|
|
|
}
|
|
|
|
|
2016-12-16 01:21:51 +00:00
|
|
|
function setupDebugControls(){
|
|
|
|
$("#dbg_reset").click(resetAndDebug);
|
|
|
|
$("#dbg_pause").click(pause);
|
|
|
|
$("#dbg_go").click(resume);
|
2017-11-24 19:14:22 +00:00
|
|
|
|
|
|
|
if (platform.step)
|
2017-11-11 19:45:32 +00:00
|
|
|
$("#dbg_step").click(singleStep).show();
|
2017-11-24 19:14:22 +00:00
|
|
|
else
|
2017-11-11 19:45:32 +00:00
|
|
|
$("#dbg_step").hide();
|
2017-11-24 19:14:22 +00:00
|
|
|
if (platform.runToVsync)
|
|
|
|
$("#dbg_tovsync").click(singleFrameStep).show();
|
|
|
|
else
|
|
|
|
$("#dbg_tovsync").hide();
|
2018-06-18 08:12:52 +00:00
|
|
|
if ((platform.runEval || platform.runToPC) && platform_id != 'verilog')
|
2017-11-24 19:14:22 +00:00
|
|
|
$("#dbg_toline").click(runToCursor).show();
|
|
|
|
else
|
2017-11-11 19:45:32 +00:00
|
|
|
$("#dbg_toline").hide();
|
2017-11-24 19:14:22 +00:00
|
|
|
if (platform.runUntilReturn)
|
|
|
|
$("#dbg_stepout").click(runUntilReturn).show();
|
|
|
|
else
|
2017-11-11 19:45:32 +00:00
|
|
|
$("#dbg_stepout").hide();
|
2017-11-24 19:14:22 +00:00
|
|
|
if (platform.stepBack)
|
|
|
|
$("#dbg_stepback").click(runStepBackwards).show();
|
|
|
|
else
|
2017-11-11 19:45:32 +00:00
|
|
|
$("#dbg_stepback").hide();
|
2017-11-24 19:14:22 +00:00
|
|
|
|
2017-11-20 01:32:58 +00:00
|
|
|
if (window.traceTiming) {
|
2017-01-16 15:35:19 +00:00
|
|
|
$("#dbg_timing").click(traceTiming).show();
|
|
|
|
}
|
2017-01-06 14:49:07 +00:00
|
|
|
$("#disassembly").hide();
|
2018-06-30 02:06:14 +00:00
|
|
|
$("#dbg_bitmap").click(_openBitmapEditor);
|
2016-12-30 23:51:15 +00:00
|
|
|
$(".dropdown-menu").collapse({toggle: false});
|
|
|
|
$("#item_new_file").click(_createNewFile);
|
2018-06-26 23:57:03 +00:00
|
|
|
$("#item_upload_file").click(_uploadNewFile);
|
2016-12-30 23:51:15 +00:00
|
|
|
$("#item_share_file").click(_shareFile);
|
|
|
|
$("#item_reset_file").click(_resetPreset);
|
2017-11-24 19:14:22 +00:00
|
|
|
if (platform.runEval)
|
|
|
|
$("#item_debug_expr").click(_breakExpression).show();
|
|
|
|
else
|
|
|
|
$("#item_debug_expr").hide();
|
2017-02-02 19:11:52 +00:00
|
|
|
$("#item_download_rom").click(_downloadROMImage);
|
2018-03-23 21:05:08 +00:00
|
|
|
$("#item_download_file").click(_downloadSourceFile);
|
2017-05-20 19:13:23 +00:00
|
|
|
$("#item_record_video").click(_recordVideo);
|
2018-02-26 23:18:23 +00:00
|
|
|
if (platform.setFrameRate && platform.getFrameRate) {
|
|
|
|
$("#speed_bar").show();
|
|
|
|
$("#dbg_slower").click(_slowerFrameRate);
|
|
|
|
$("#dbg_faster").click(_fasterFrameRate);
|
2018-02-27 04:48:36 +00:00
|
|
|
$("#dbg_slowest").click(_slowestFrameRate);
|
|
|
|
$("#dbg_fastest").click(_fastestFrameRate);
|
2018-02-26 23:18:23 +00:00
|
|
|
}
|
2017-04-19 01:18:53 +00:00
|
|
|
updateDebugWindows();
|
2016-12-16 01:21:51 +00:00
|
|
|
}
|
|
|
|
|
2016-12-18 20:59:31 +00:00
|
|
|
function showWelcomeMessage() {
|
2017-05-01 11:37:48 +00:00
|
|
|
if (!localStorage.getItem("8bitworkshop.hello")) {
|
2016-12-30 23:51:15 +00:00
|
|
|
// Instance the tour
|
2017-04-20 00:55:13 +00:00
|
|
|
var is_vcs = platform_id == 'vcs';
|
2016-12-30 23:51:15 +00:00
|
|
|
var tour = new Tour({
|
2017-01-03 15:43:40 +00:00
|
|
|
autoscroll:false,
|
2016-12-30 23:51:15 +00:00
|
|
|
//storage:false,
|
|
|
|
steps: [
|
|
|
|
{
|
|
|
|
element: "#editor",
|
|
|
|
title: "Welcome to 8bitworkshop!",
|
2017-04-20 00:55:13 +00:00
|
|
|
content: is_vcs ? "Type your 6502 assembly code into the editor, and it'll be assembled in real-time. All changes are saved to browser local storage."
|
|
|
|
: "Type your C source code into the editor, and it'll be compiled in real-time. All changes are saved to browser local storage."
|
2016-12-30 23:51:15 +00:00
|
|
|
},
|
|
|
|
{
|
|
|
|
element: "#emulator",
|
|
|
|
placement: 'left',
|
2017-04-20 00:55:13 +00:00
|
|
|
title: "Emulator",
|
|
|
|
content: "This is an emulator for the \"" + platform_id + "\" platform. We'll load your compiled code into the emulator whenever you make changes."
|
2016-12-30 23:51:15 +00:00
|
|
|
},
|
|
|
|
{
|
|
|
|
element: "#preset_select",
|
|
|
|
title: "File Selector",
|
|
|
|
content: "Pick a code example from the book, or access your own files and files shared by others."
|
|
|
|
},
|
|
|
|
{
|
|
|
|
element: "#debug_bar",
|
|
|
|
placement: 'bottom',
|
|
|
|
title: "Debug Tools",
|
2017-04-20 00:55:13 +00:00
|
|
|
content: "Use these buttons to set breakpoints, single step through code, pause/resume, and use debugging tools."
|
2016-12-30 23:51:15 +00:00
|
|
|
},
|
|
|
|
{
|
|
|
|
element: "#dropdownMenuButton",
|
|
|
|
title: "Main Menu",
|
2017-04-20 00:55:13 +00:00
|
|
|
content: "Click the menu to switch between platforms, create new files, or share your work with others."
|
2016-12-30 23:51:15 +00:00
|
|
|
},
|
|
|
|
]});
|
|
|
|
tour.init();
|
2017-01-03 15:43:40 +00:00
|
|
|
setTimeout(function() { tour.start(); }, 2000);
|
2016-12-18 20:59:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-12-16 01:21:51 +00:00
|
|
|
///////////////////////////////////////////////////
|
|
|
|
|
|
|
|
var qs = (function (a) {
|
|
|
|
if (!a || a == "")
|
|
|
|
return {};
|
|
|
|
var b = {};
|
|
|
|
for (var i = 0; i < a.length; ++i) {
|
|
|
|
var p = a[i].split('=', 2);
|
|
|
|
if (p.length == 1)
|
|
|
|
b[p[0]] = "";
|
|
|
|
else
|
|
|
|
b[p[0]] = decodeURIComponent(p[1].replace(/\+/g, " "));
|
|
|
|
}
|
|
|
|
return b;
|
|
|
|
})(window.location.search.substr(1).split('&'));
|
|
|
|
|
2017-01-25 17:30:05 +00:00
|
|
|
function initPlatform() {
|
2018-06-28 04:18:16 +00:00
|
|
|
store = createNewPersistentStore(platform_id);
|
2017-01-25 17:30:05 +00:00
|
|
|
}
|
|
|
|
|
2017-04-26 19:44:55 +00:00
|
|
|
function showBookLink() {
|
|
|
|
if (platform_id == 'vcs')
|
|
|
|
$("#booklink_vcs").show();
|
2017-11-15 00:12:52 +00:00
|
|
|
else if (platform_id == 'mw8080bw' || platform_id == 'vicdual' || platform_id == 'galaxian-scramble' || platform_id == 'vector-z80color' || platform_id == 'williams-z80')
|
2017-04-26 19:44:55 +00:00
|
|
|
$("#booklink_arcade").show();
|
|
|
|
}
|
|
|
|
|
2017-05-01 15:30:47 +00:00
|
|
|
function addPageFocusHandlers() {
|
2017-05-02 13:09:53 +00:00
|
|
|
var hidden = false;
|
2017-05-01 15:30:47 +00:00
|
|
|
document.addEventListener("visibilitychange", function() {
|
2017-05-02 13:09:53 +00:00
|
|
|
if (document.visibilityState == 'hidden' && platform.isRunning()) {
|
2017-11-16 17:08:06 +00:00
|
|
|
_pause();
|
2017-05-02 13:09:53 +00:00
|
|
|
hidden = true;
|
|
|
|
} else if (document.visibilityState == 'visible' && hidden) {
|
2017-11-16 17:08:06 +00:00
|
|
|
_resume();
|
2017-05-02 13:09:53 +00:00
|
|
|
hidden = false;
|
|
|
|
}
|
|
|
|
});
|
|
|
|
$(window).on("focus", function() {
|
|
|
|
if (hidden) {
|
2017-11-16 17:08:06 +00:00
|
|
|
_resume();
|
2017-05-02 13:09:53 +00:00
|
|
|
hidden = false;
|
|
|
|
}
|
|
|
|
});
|
|
|
|
$(window).on("blur", function() {
|
|
|
|
if (platform.isRunning()) {
|
2017-11-16 17:08:06 +00:00
|
|
|
_pause();
|
2017-05-02 13:09:53 +00:00
|
|
|
hidden = true;
|
|
|
|
}
|
2017-05-01 15:30:47 +00:00
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2017-01-14 16:14:25 +00:00
|
|
|
function startPlatform() {
|
2017-01-25 17:30:05 +00:00
|
|
|
initPlatform();
|
2017-01-29 21:06:05 +00:00
|
|
|
if (!PLATFORMS[platform_id]) throw Error("Invalid platform '" + platform_id + "'.");
|
2017-01-14 16:14:25 +00:00
|
|
|
platform = new PLATFORMS[platform_id]($("#emulator")[0]);
|
|
|
|
PRESETS = platform.getPresets();
|
|
|
|
if (qs['file']) {
|
2017-01-16 15:35:19 +00:00
|
|
|
// start platform and load file
|
|
|
|
platform.start();
|
2017-04-22 01:56:49 +00:00
|
|
|
setupDebugControls();
|
2018-06-29 23:44:04 +00:00
|
|
|
initProject();
|
|
|
|
loadProject(qs['file']);
|
2017-01-14 16:14:25 +00:00
|
|
|
updateSelector();
|
2017-04-26 19:44:55 +00:00
|
|
|
showBookLink();
|
2017-05-01 15:30:47 +00:00
|
|
|
addPageFocusHandlers();
|
2017-01-16 15:35:19 +00:00
|
|
|
return true;
|
2017-01-14 16:14:25 +00:00
|
|
|
} else {
|
2017-01-16 15:35:19 +00:00
|
|
|
// try to load last file (redirect)
|
2017-01-14 16:14:25 +00:00
|
|
|
var lastid = localStorage.getItem("__lastid_"+platform_id) || localStorage.getItem("__lastid");
|
|
|
|
localStorage.removeItem("__lastid");
|
2018-06-28 04:57:06 +00:00
|
|
|
reloadPresetNamed(lastid || PRESETS[0].id);
|
2017-01-16 15:35:19 +00:00
|
|
|
return false;
|
2017-01-14 16:14:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-25 17:30:05 +00:00
|
|
|
function loadSharedFile(sharekey) {
|
|
|
|
var github = new Octokat();
|
|
|
|
var gist = github.gists(sharekey);
|
|
|
|
gist.fetch().done(function(val) {
|
|
|
|
var filename;
|
|
|
|
for (filename in val.files) { break; }
|
|
|
|
var newid = 'shared/' + filename;
|
|
|
|
var json = JSON.parse(val.description.slice(val.description.indexOf(' ')+1));
|
|
|
|
console.log("Fetched " + newid, json);
|
|
|
|
platform_id = json['platform'];
|
|
|
|
initPlatform();
|
2018-06-29 02:42:47 +00:00
|
|
|
current_project.updateFile(newid, val.files[filename].content);
|
2018-06-29 23:52:09 +00:00
|
|
|
reloadPresetNamed(newid);
|
2017-01-25 17:30:05 +00:00
|
|
|
delete qs['sharekey'];
|
|
|
|
gotoNewLocation();
|
|
|
|
}).fail(function(err) {
|
|
|
|
alert("Error loading share file: " + err.message);
|
|
|
|
});
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2017-01-03 01:42:15 +00:00
|
|
|
// start
|
2017-01-14 16:14:25 +00:00
|
|
|
function startUI(loadplatform) {
|
2017-01-16 19:13:03 +00:00
|
|
|
installErrorHandler();
|
2017-01-25 17:30:05 +00:00
|
|
|
// add default platform?
|
|
|
|
platform_id = qs['platform'] || localStorage.getItem("__lastplatform");
|
|
|
|
if (!platform_id) {
|
|
|
|
platform_id = qs['platform'] = "vcs";
|
|
|
|
}
|
2017-01-14 16:14:25 +00:00
|
|
|
// parse query string
|
|
|
|
// is this a share URL?
|
|
|
|
if (qs['sharekey']) {
|
2017-01-25 17:30:05 +00:00
|
|
|
loadSharedFile(qs['sharekey']);
|
2017-01-14 02:31:04 +00:00
|
|
|
} else {
|
2017-01-14 16:14:25 +00:00
|
|
|
// reset file?
|
|
|
|
if (qs['file'] && qs['reset']) {
|
2017-01-27 02:59:34 +00:00
|
|
|
initPlatform();
|
2018-06-26 06:56:36 +00:00
|
|
|
store.removeItem(qs['file']);
|
2017-01-14 16:14:25 +00:00
|
|
|
qs['reset'] = '';
|
2017-01-16 19:13:03 +00:00
|
|
|
gotoNewLocation();
|
2017-01-14 16:14:25 +00:00
|
|
|
} else {
|
|
|
|
// load and start platform object
|
|
|
|
if (loadplatform) {
|
2017-01-29 21:06:05 +00:00
|
|
|
var scriptfn = 'src/platform/' + platform_id.split('-')[0] + '.js';
|
2017-05-01 15:30:47 +00:00
|
|
|
var script = document.createElement('script');
|
|
|
|
script.onload = function() {
|
2017-01-14 16:14:25 +00:00
|
|
|
console.log("loaded platform", platform_id);
|
|
|
|
startPlatform();
|
2017-04-29 15:31:11 +00:00
|
|
|
showWelcomeMessage();
|
2017-05-01 15:30:47 +00:00
|
|
|
};
|
|
|
|
script.src = scriptfn;
|
|
|
|
document.getElementsByTagName('head')[0].appendChild(script);
|
2017-01-14 05:47:26 +00:00
|
|
|
} else {
|
2017-01-14 16:14:25 +00:00
|
|
|
startPlatform();
|
2017-04-29 15:31:11 +00:00
|
|
|
showWelcomeMessage();
|
2017-01-14 05:47:26 +00:00
|
|
|
}
|
2017-01-14 16:14:25 +00:00
|
|
|
}
|
2016-12-16 01:21:51 +00:00
|
|
|
}
|
|
|
|
}
|