"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Base6809MachinePlatform = exports.BaseZ80MachinePlatform = exports.Base6502MachinePlatform = exports.BaseMachinePlatform = exports.hasSerialIO = exports.hasBIOS = exports.hasProbe = exports.isRaster = exports.hasPaddleInput = exports.hasJoyInput = exports.hasKeyInput = exports.hasAudio = exports.hasVideo = exports.lookupSymbol = exports.dumpStackToString = exports.Base6809Platform = exports.getToolForFilename_6809 = exports.cpuStateToLongString_6809 = exports.getToolForFilename_z80 = exports.BaseZ80Platform = exports.cpuStateToLongString_Z80 = exports.getOpcodeMetadata_6502 = exports.cpuStateToLongString_6502 = exports.Base6502Platform = exports.getToolForFilename_6502 = exports.inspectSymbol = exports.BaseDebugPlatform = exports.BasePlatform = exports.BreakpointList = exports.isDebuggable = exports.DebugSymbols = void 0;
const emu_1 = require("./emu");
const util_1 = require("./util");
const disasm6502_1 = require("./cpu/disasm6502");
const disasmz80_1 = require("./cpu/disasmz80");
const ZilogZ80_1 = require("./cpu/ZilogZ80");
const audio_1 = require("./audio");
const probe_1 = require("./probe");
const wasmplatform_1 = require("./wasmplatform");
const _6809_1 = require("./cpu/6809");
const MOS6502_1 = require("./cpu/MOS6502");
;
;
class DebugSymbols {
    constructor(symbolmap, debuginfo) {
        this.symbolmap = symbolmap;
        this.debuginfo = debuginfo;
        this.addr2symbol = (0, util_1.invertMap)(symbolmap);
        //// TODO: shouldn't be necc.
        if (!this.addr2symbol[0x0])
            this.addr2symbol[0x0] = '$00'; // needed for ...
        this.addr2symbol[0x10000] = '__END__'; // ... dump memory to work
    }
}
exports.DebugSymbols = DebugSymbols;
function isDebuggable(arg) {
    return arg && typeof arg.getDebugCategories === 'function';
}
exports.isDebuggable = isDebuggable;
// for composite breakpoints w/ single debug function
class BreakpointList {
    constructor() {
        this.id2bp = {};
    }
    getDebugCondition() {
        if (Object.keys(this.id2bp).length == 0) {
            return null; // no breakpoints
        }
        else {
            // evaluate all breakpoints
            return () => {
                var result = false;
                for (var id in this.id2bp)
                    if (this.id2bp[id].cond())
                        result = true;
                return result;
            };
        }
    }
}
exports.BreakpointList = BreakpointList;
;
/////
class BasePlatform {
    constructor() {
        this.recorder = null;
        this.internalFiles = {};
    }
    setRecorder(recorder) {
        this.recorder = recorder;
    }
    updateRecorder() {
        // are we recording and do we need to save a frame?
        if (this.recorder && this.isRunning() && this.recorder.frameRequested()) {
            this.recorder.recordFrame(this.saveState());
        }
    }
    inspect(sym) {
        return inspectSymbol(this, sym);
    }
    getDebugTree() {
        var _a;
        var o = {};
        o.state = this.saveState();
        if ((_a = this.debugSymbols) === null || _a === void 0 ? void 0 : _a.debuginfo)
            o.debuginfo = this.debugSymbols.debuginfo;
        return o;
    }
    readFile(path) {
        return this.internalFiles[path];
    }
    writeFile(path, data) {
        this.internalFiles[path] = data;
        return true;
    }
}
exports.BasePlatform = BasePlatform;
class BaseDebugPlatform extends BasePlatform {
    constructor() {
        super(...arguments);
        this.debugSavedState = null;
        this.debugBreakState = null;
        this.debugTargetClock = 0;
        this.debugClock = 0;
        this.breakpoints = new BreakpointList();
        this.frameCount = 0;
    }
    setBreakpoint(id, cond) {
        if (cond) {
            this.breakpoints.id2bp[id] = { cond: cond };
            this.restartDebugging();
        }
        else {
            this.clearBreakpoint(id);
        }
    }
    clearBreakpoint(id) {
        delete this.breakpoints.id2bp[id];
    }
    hasBreakpoint(id) {
        return this.breakpoints.id2bp[id] != null;
    }
    getDebugCallback() {
        return this.breakpoints.getDebugCondition();
    }
    setupDebug(callback) {
        this.onBreakpointHit = callback;
    }
    clearDebug() {
        if (this.debugBreakState != null && this.debugSavedState != null) {
            this.loadState(this.debugSavedState);
        }
        this.debugSavedState = null;
        this.debugBreakState = null;
        this.debugTargetClock = -1;
        this.debugClock = 0;
        this.onBreakpointHit = null;
        this.clearBreakpoint('debug');
        this.frameCount = 0;
    }
    setDebugCondition(debugCond) {
        this.setBreakpoint('debug', debugCond);
    }
    resetDebugging() {
        if (this.debugSavedState) {
            this.loadState(this.debugSavedState);
        }
        else {
            this.debugSavedState = this.saveState();
        }
        this.debugClock = 0;
        this.debugCallback = this.getDebugCallback();
        this.debugBreakState = null;
    }
    restartDebugging() {
        this.resetDebugging();
        this.resume();
    }
    preFrame() {
        // save state before frame, to record any inputs that happened pre-frame
        if (this.debugCallback && !this.debugBreakState) {
            // save state every frame and rewind debug clocks
            this.debugSavedState = this.saveState();
            this.debugTargetClock -= this.debugClock;
            this.debugClock = 0;
        }
    }
    postFrame() {
        // reload debug state at end of frame after breakpoint
        if (this.debugCallback && this.debugBreakState) {
            this.loadState(this.debugBreakState);
        }
        this.frameCount++;
    }
    pollControls() {
    }
    nextFrame(novideo) {
        this.pollControls();
        this.updateRecorder();
        this.preFrame();
        var steps = this.advance(novideo);
        this.postFrame();
        return steps;
    }
    evalDebugCondition() {
        if (this.debugCallback && !this.debugBreakState) {
            this.debugCallback();
        }
    }
    wasBreakpointHit() {
        return this.debugBreakState != null;
    }
    breakpointHit(targetClock, reason) {
        console.log(this.debugTargetClock, targetClock, this.debugClock, this.isStable());
        this.debugTargetClock = targetClock;
        this.debugBreakState = this.saveState();
        console.log("Breakpoint at clk", this.debugClock, "PC", this.debugBreakState.c.PC.toString(16));
        this.pause();
        if (this.onBreakpointHit) {
            this.onBreakpointHit(this.debugBreakState, reason);
        }
    }
    haltAndCatchFire(reason) {
        this.breakpointHit(this.debugClock, reason);
    }
    runEval(evalfunc) {
        this.setDebugCondition(() => {
            if (++this.debugClock >= this.debugTargetClock && this.isStable()) {
                var cpuState = this.getCPUState();
                if (evalfunc(cpuState)) {
                    this.breakpointHit(this.debugClock);
                    return true;
                }
                else {
                    return false;
                }
            }
        });
    }
    runToPC(pc) {
        this.debugTargetClock++;
        this.runEval((c) => {
            return c.PC == pc;
        });
    }
    runUntilReturn() {
        var SP0 = this.getSP();
        this.runEval((c) => {
            return c.SP > SP0; // TODO: check for RTS/RET opcode
        });
    }
    runToFrameClock(clock) {
        this.restartDebugging();
        this.debugTargetClock = clock;
        this.runEval(() => { return true; });
    }
    step() {
        this.runToFrameClock(this.debugClock + 1);
    }
    stepBack() {
        var prevState;
        var prevClock;
        var clock0 = this.debugTargetClock;
        this.restartDebugging();
        this.debugTargetClock = clock0 - 25; // TODO: depends on CPU
        this.runEval((c) => {
            if (this.debugClock < clock0) {
                prevState = this.saveState();
                prevClock = this.debugClock;
                return false;
            }
            else {
                if (prevState) {
                    this.loadState(prevState);
                    this.debugClock = prevClock;
                }
                return true;
            }
        });
    }
    runToVsync() {
        this.restartDebugging();
        var frame0 = this.frameCount;
        this.runEval(() => {
            return this.frameCount > frame0;
        });
    }
}
exports.BaseDebugPlatform = BaseDebugPlatform;
function inspectSymbol(platform, sym) {
    if (!platform.debugSymbols)
        return;
    var symmap = platform.debugSymbols.symbolmap;
    var addr2sym = platform.debugSymbols.addr2symbol;
    if (!symmap || !platform.readAddress)
        return null;
    var addr = symmap["_" + sym] || symmap[sym]; // look for C or asm symbol
    if (!(typeof addr == 'number'))
        return null;
    var b = platform.readAddress(addr);
    // don't show 2 bytes if there's a symbol at the next address
    if (addr2sym && addr2sym[addr + 1] != null) {
        return "$" + (0, util_1.hex)(addr, 4) + " = $" + (0, util_1.hex)(b, 2) + " (" + b + " decimal)"; // unsigned
    }
    else {
        let b2 = platform.readAddress(addr + 1);
        let w = b | (b2 << 8);
        return "$" + (0, util_1.hex)(addr, 4) + " = $" + (0, util_1.hex)(b, 2) + " $" + (0, util_1.hex)(b2, 2) + " (" + ((w << 16) >> 16) + " decimal)"; // signed
    }
}
exports.inspectSymbol = inspectSymbol;
////// 6502
function getToolForFilename_6502(fn) {
    if (fn.endsWith("-llvm.c"))
        return "remote:llvm-mos";
    if (fn.endsWith(".c"))
        return "cc65";
    if (fn.endsWith(".h"))
        return "cc65";
    if (fn.endsWith(".s"))
        return "ca65";
    if (fn.endsWith(".ca65"))
        return "ca65";
    if (fn.endsWith(".dasm"))
        return "dasm";
    if (fn.endsWith(".acme"))
        return "acme";
    if (fn.endsWith(".wiz"))
        return "wiz";
    if (fn.endsWith(".ecs"))
        return "ecs";
    return "dasm"; // .a
}
exports.getToolForFilename_6502 = getToolForFilename_6502;
// TODO: can merge w/ Z80?
class Base6502Platform extends BaseDebugPlatform {
    constructor() {
        super(...arguments);
        // some platforms store their PC one byte before or after the first opcode
        // so we correct when saving and loading from state
        this.debugPCDelta = -1;
        this.getToolForFilename = getToolForFilename_6502;
    }
    fixPC(c) { c.PC = (c.PC + this.debugPCDelta) & 0xffff; return c; }
    unfixPC(c) { c.PC = (c.PC - this.debugPCDelta) & 0xffff; return c; }
    getSP() { return this.getCPUState().SP; }
    ;
    getPC() { return this.getCPUState().PC; }
    ;
    isStable() { return !this.getCPUState()['T']; }
    newCPU(membus) {
        var cpu = new MOS6502_1._MOS6502();
        cpu.connectBus(membus);
        return cpu;
    }
    getOpcodeMetadata(opcode, offset) {
        return getOpcodeMetadata_6502(opcode, offset);
    }
    getOriginPC() {
        return (this.readAddress(0xfffc) | (this.readAddress(0xfffd) << 8)) & 0xffff;
    }
    disassemble(pc, read) {
        return (0, disasm6502_1.disassemble6502)(pc, read(pc), read(pc + 1), read(pc + 2));
    }
    getDefaultExtension() { return ".a"; }
    ;
    getDebugCategories() {
        return ['CPU', 'ZPRAM', 'Stack'];
    }
    getDebugInfo(category, state) {
        switch (category) {
            case 'CPU': return cpuStateToLongString_6502(state.c);
            case 'ZPRAM': return (0, emu_1.dumpRAM)(state.b || state.ram, 0x0, 0x100);
            case 'Stack': return dumpStackToString(this, state.b || state.ram, 0x100, 0x1ff, 0x100 + state.c.SP, 0x20);
        }
    }
}
exports.Base6502Platform = Base6502Platform;
function cpuStateToLongString_6502(c) {
    function decodeFlags(c) {
        var s = "";
        s += c.N ? " N" : " -";
        s += c.V ? " V" : " -";
        s += c.D ? " D" : " -";
        s += c.Z ? " Z" : " -";
        s += c.C ? " C" : " -";
        s += c.I ? " I" : " -";
        return s;
    }
    return "PC " + (0, util_1.hex)(c.PC, 4) + "  " + decodeFlags(c) + "\n"
        + " A " + (0, util_1.hex)(c.A) + "     " + (c.R ? "" : "BUSY") + "\n"
        + " X " + (0, util_1.hex)(c.X) + "\n"
        + " Y " + (0, util_1.hex)(c.Y) + "     " + "SP " + (0, util_1.hex)(c.SP) + "\n";
}
exports.cpuStateToLongString_6502 = cpuStateToLongString_6502;
var OPMETA_6502 = {
    cycletime: [
        7, 6, 0, 8, 3, 3, 5, 5, 3, 2, 2, 2, 4, 4, 6, 6, 2, 5, 0, 8, 4, 4, 6, 6, 2, 4, 0, 7, 4, 4, 7, 7, 6, 6, 0, 8, 3, 3, 5, 5, 4, 2, 2, 2, 4, 4, 6, 6, 2, 5, 0, 8, 4, 4, 6, 6, 2, 4, 0, 7, 4, 4, 7, 7, 6, 6, 0, 8, 3, 3, 5, 5, 3, 2, 2, 2, 3, 4, 6, 6, 2, 5, 0, 8, 4, 4, 6, 6, 2, 4, 0, 7, 4, 4, 7, 7, 6, 6, 0, 8, 3, 3, 5, 5, 4, 2, 2, 2, 5, 4, 6, 6, 2, 5, 0, 8, 4, 4, 6, 6, 2, 4, 0, 7, 4, 4, 7, 7, 0, 6, 0, 6, 3, 3, 3, 3, 2, 0, 2, 0, 4, 4, 4, 4, 2, 6, 0, 0, 4, 4, 4, 4, 2, 5, 2, 0, 0, 5, 0, 0, 2, 6, 2, 6, 3, 3, 3, 3, 2, 2, 2, 0, 4, 4, 4, 4, 2, 5, 0, 5, 4, 4, 4, 4, 2, 4, 2, 0, 4, 4, 4, 4, 2, 6, 0, 8, 3, 3, 5, 5, 2, 2, 2, 2, 4, 4, 3, 6, 2, 5, 0, 8, 4, 4, 6, 6, 2, 4, 0, 7, 4, 4, 7, 7, 2, 6, 0, 8, 3, 3, 5, 5, 2, 2, 2, 0, 4, 4, 6, 6, 2, 5, 0, 8, 4, 4, 6, 6, 2, 4, 0, 7, 4, 4, 7, 7
    ],
    extracycles: [
        0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1
    ],
    insnlengths: [
        1, 2, 0, 2, 2, 2, 2, 2, 1, 2, 1, 2, 3, 3, 3, 3, 2, 2, 0, 2, 2, 2, 2, 2, 1, 3, 0, 3, 3, 3, 3, 3, 3, 2, 0, 2, 2, 2, 2, 2, 1, 2, 1, 2, 3, 3, 3, 3, 2, 2, 0, 2, 2, 2, 2, 2, 1, 3, 0, 3, 3, 3, 3, 3, 1, 2, 0, 2, 2, 2, 2, 2, 1, 2, 1, 2, 3, 3, 3, 3, 2, 2, 0, 2, 2, 2, 2, 2, 1, 3, 0, 3, 3, 3, 3, 3, 1, 2, 0, 2, 2, 2, 2, 2, 1, 2, 1, 2, 3, 3, 3, 3, 2, 2, 0, 2, 2, 2, 2, 2, 1, 3, 0, 3, 3, 3, 3, 3, 0, 2, 0, 2, 2, 2, 2, 2, 1, 0, 1, 0, 3, 3, 3, 3, 2, 2, 0, 0, 2, 2, 2, 3, 1, 3, 1, 0, 0, 3, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 1, 0, 3, 3, 3, 3, 2, 2, 0, 2, 2, 2, 2, 2, 1, 3, 1, 0, 3, 3, 3, 3, 2, 2, 0, 2, 2, 2, 2, 2, 1, 2, 1, 2, 3, 3, 3, 3, 2, 2, 0, 2, 2, 2, 2, 2, 1, 3, 0, 3, 3, 3, 3, 3, 2, 2, 0, 2, 2, 2, 2, 2, 1, 2, 1, 0, 3, 3, 3, 3, 2, 2, 0, 2, 2, 2, 2, 2, 1, 3, 0, 3, 3, 3, 3, 3
    ],
    validinsns: [
        1, 2, 0, 0, 0, 2, 2, 0, 1, 2, 1, 0, 0, 3, 3, 0, 2, 2, 0, 0, 0, 2, 2, 0, 1, 3, 0, 0, 0, 3, 3, 0, 3, 2, 0, 0, 2, 2, 2, 0, 1, 2, 1, 0, 3, 3, 3, 0, 2, 2, 0, 0, 0, 2, 2, 0, 1, 3, 0, 0, 0, 3, 3, 0, 1, 2, 0, 0, 0, 2, 2, 0, 1, 2, 1, 0, 3, 3, 3, 0, 2, 2, 0, 0, 0, 2, 2, 0, 1, 3, 0, 0, 0, 3, 3, 0, 1, 2, 0, 0, 0, 2, 2, 0, 1, 2, 1, 0, 3, 3, 3, 0, 2, 2, 0, 0, 0, 2, 2, 0, 1, 3, 0, 0, 0, 3, 3, 0, 0, 2, 0, 0, 2, 2, 2, 0, 1, 0, 1, 0, 3, 3, 3, 0, 2, 2, 0, 0, 2, 2, 2, 0, 1, 3, 1, 0, 0, 3, 0, 0, 2, 2, 2, 0, 2, 2, 2, 0, 1, 2, 1, 0, 3, 3, 3, 0, 2, 2, 0, 0, 2, 2, 2, 0, 1, 3, 1, 0, 3, 3, 3, 0, 2, 2, 0, 0, 2, 2, 2, 0, 1, 2, 1, 0, 3, 3, 3, 0, 2, 2, 0, 0, 0, 2, 2, 0, 1, 3, 0, 0, 0, 3, 3, 0, 2, 2, 0, 0, 2, 2, 2, 0, 1, 2, 1, 0, 3, 3, 3, 0, 2, 2, 0, 0, 0, 2, 2, 0, 1, 3, 0, 0, 0, 3, 3, 0
    ],
};
function getOpcodeMetadata_6502(opcode, address) {
    // TODO: more intelligent maximum cycles
    // TODO: must always be new object, b/c we might modify it
    return {
        opcode: opcode,
        minCycles: OPMETA_6502.cycletime[opcode],
        maxCycles: OPMETA_6502.cycletime[opcode] + OPMETA_6502.extracycles[opcode],
        insnlength: OPMETA_6502.insnlengths[opcode]
    };
}
exports.getOpcodeMetadata_6502 = getOpcodeMetadata_6502;
////// Z80
function cpuStateToLongString_Z80(c) {
    function decodeFlags(flags) {
        return (0, util_1.printFlags)(flags, ["S", "Z", , "H", , "V", "N", "C"], true);
    }
    return "PC " + (0, util_1.hex)(c.PC, 4) + "  " + decodeFlags(c.AF) + " " + (c.iff1 ? "I" : "-") + (c.iff2 ? "I" : "-") + "\n"
        + "SP " + (0, util_1.hex)(c.SP, 4) + "  IR " + (0, util_1.hex)(c.IR, 4) + "\n"
        + "IX " + (0, util_1.hex)(c.IX, 4) + "  IY " + (0, util_1.hex)(c.IY, 4) + "\n"
        + "AF " + (0, util_1.hex)(c.AF, 4) + "  BC " + (0, util_1.hex)(c.BC, 4) + "\n"
        + "DE " + (0, util_1.hex)(c.DE, 4) + "  HL " + (0, util_1.hex)(c.HL, 4) + "\n";
}
exports.cpuStateToLongString_Z80 = cpuStateToLongString_Z80;
class BaseZ80Platform extends BaseDebugPlatform {
    constructor() {
        super(...arguments);
        this.waitCycles = 0;
        this.getToolForFilename = getToolForFilename_z80;
    }
    newCPU(membus, iobus) {
        this._cpu = new ZilogZ80_1.Z80();
        this._cpu.connectMemoryBus(membus);
        this._cpu.connectIOBus(iobus);
        return this._cpu;
    }
    getPC() { return this._cpu.getPC(); }
    getSP() { return this._cpu.getSP(); }
    isStable() { return true; }
    // TODO: refactor other parts into here
    runCPU(cpu, cycles) {
        this._cpu = cpu; // TODO?
        this.waitCycles = 0; // TODO: needs to spill over betwenn calls
        if (this.wasBreakpointHit())
            return 0;
        var debugCond = this.getDebugCallback();
        var n = 0;
        this.waitCycles += cycles;
        while (this.waitCycles > 0) {
            if (debugCond && debugCond()) {
                debugCond = null;
                break;
            }
            var cyc = cpu.advanceInsn();
            n += cyc;
            this.waitCycles -= cyc;
        }
        return n;
    }
    getDefaultExtension() { return ".c"; }
    ;
    // TODO: Z80 opcode metadata
    //this.getOpcodeMetadata = function() { }
    getDebugCategories() {
        return ['CPU', 'Stack'];
    }
    getDebugInfo(category, state) {
        switch (category) {
            case 'CPU': return cpuStateToLongString_Z80(state.c);
            case 'Stack': {
                var sp = (state.c.SP - 1) & 0xffff;
                var start = sp & 0xff00;
                var end = start + 0xff;
                if (sp == 0)
                    sp = 0x10000;
                console.log(sp, start, end);
                return dumpStackToString(this, [], start, end, sp, 0xcd);
            }
        }
    }
    disassemble(pc, read) {
        return (0, disasmz80_1.disassembleZ80)(pc, read(pc), read(pc + 1), read(pc + 2), read(pc + 3));
    }
}
exports.BaseZ80Platform = BaseZ80Platform;
function getToolForFilename_z80(fn) {
    if (fn.endsWith(".c"))
        return "sdcc";
    if (fn.endsWith(".h"))
        return "sdcc";
    if (fn.endsWith(".s"))
        return "sdasz80";
    if (fn.endsWith(".ns"))
        return "naken";
    if (fn.endsWith(".scc"))
        return "sccz80";
    if (fn.endsWith(".z"))
        return "zmac";
    if (fn.endsWith(".wiz"))
        return "wiz";
    return "zmac";
}
exports.getToolForFilename_z80 = getToolForFilename_z80;
////// 6809
function cpuStateToLongString_6809(c) {
    function decodeFlags(flags) {
        return (0, util_1.printFlags)(flags, ["E", "F", "H", "I", "N", "Z", "V", "C"], true);
    }
    return "PC " + (0, util_1.hex)(c.PC, 4) + "  " + decodeFlags(c.CC) + "\n"
        + "SP " + (0, util_1.hex)(c.SP, 4) + "\n"
        + "DP " + (0, util_1.hex)(c.DP, 2) + "\n"
        + " A " + (0, util_1.hex)(c.A, 2) + "\n"
        + " B " + (0, util_1.hex)(c.B, 2) + "\n"
        + " X " + (0, util_1.hex)(c.X, 4) + "\n"
        + " Y " + (0, util_1.hex)(c.Y, 4) + "\n"
        + " U " + (0, util_1.hex)(c.U, 4) + "\n";
}
exports.cpuStateToLongString_6809 = cpuStateToLongString_6809;
function getToolForFilename_6809(fn) {
    if (fn.endsWith(".c"))
        return "cmoc";
    if (fn.endsWith(".h"))
        return "cmoc";
    if (fn.endsWith(".xasm"))
        return "xasm6809";
    if (fn.endsWith(".lwasm"))
        return "lwasm";
    return "cmoc";
}
exports.getToolForFilename_6809 = getToolForFilename_6809;
class Base6809Platform extends BaseZ80Platform {
    constructor() {
        super(...arguments);
        //this.getOpcodeMetadata = function() { }
        this.getToolForFilename = getToolForFilename_6809;
    }
    newCPU(membus) {
        var cpu = Object.create((0, _6809_1.CPU6809)());
        cpu.init(membus.write, membus.read, 0);
        return cpu;
    }
    cpuStateToLongString(c) {
        return cpuStateToLongString_6809(c);
    }
    disassemble(pc, read) {
        // TODO: don't create new CPU
        return Object.create((0, _6809_1.CPU6809)()).disasm(read(pc), read(pc + 1), read(pc + 2), read(pc + 3), read(pc + 4), pc);
    }
    getDefaultExtension() { return ".asm"; }
    ;
    getDebugCategories() {
        return ['CPU', 'Stack'];
    }
    getDebugInfo(category, state) {
        switch (category) {
            case 'CPU': return cpuStateToLongString_6809(state.c);
            default: return super.getDebugInfo(category, state);
        }
    }
}
exports.Base6809Platform = Base6809Platform;
//TODO: how to get stack_end?
function dumpStackToString(platform, mem, start, end, sp, jsrop, bigendian) {
    var s = "";
    var nraw = 0;
    //s = dumpRAM(mem.slice(start,start+end+1), start, end-start+1);
    function read(addr) {
        if (addr < mem.length)
            return mem[addr];
        else
            return platform.readAddress(addr);
    }
    while (sp < end) {
        sp++;
        // see if there's a JSR on the stack here
        // TODO: make work with roms and memory maps
        var addr = read(sp) + read(sp + 1) * 256;
        if (bigendian) {
            addr = ((addr & 0xff) << 8) | ((addr & 0xff00) >> 8);
        }
        var jsrofs = jsrop == 0x20 ? -2 : -3; // 6502 vs Z80
        var opcode = read(addr + jsrofs); // might be out of bounds
        if (opcode == jsrop) { // JSR
            s += "\n$" + (0, util_1.hex)(sp) + ": ";
            s += (0, util_1.hex)(addr, 4) + " " + lookupSymbol(platform, addr, true);
            sp++;
            nraw = 0;
        }
        else {
            if (nraw == 0)
                s += "\n$" + (0, util_1.hex)(sp) + ": ";
            s += (0, util_1.hex)(read(sp)) + " ";
            if (++nraw == 8)
                nraw = 0;
        }
    }
    return s + "\n";
}
exports.dumpStackToString = dumpStackToString;
// TODO: slow, funky, uses global
function lookupSymbol(platform, addr, extra) {
    var start = addr;
    var addr2symbol = platform.debugSymbols && platform.debugSymbols.addr2symbol;
    while (addr2symbol && addr >= 0) {
        var sym = addr2symbol[addr];
        if (sym) { // return first symbol we find
            var sym = addr2symbol[addr];
            return extra ? (sym + " + $" + (0, util_1.hex)(start - addr)) : sym;
        }
        if (!extra)
            break;
        addr--;
    }
    return "";
}
exports.lookupSymbol = lookupSymbol;
function hasVideo(arg) {
    return typeof arg.connectVideo === 'function';
}
exports.hasVideo = hasVideo;
function hasAudio(arg) {
    return typeof arg.connectAudio === 'function';
}
exports.hasAudio = hasAudio;
function hasKeyInput(arg) {
    return typeof arg.setKeyInput === 'function';
}
exports.hasKeyInput = hasKeyInput;
function hasJoyInput(arg) {
    return typeof arg.setJoyInput === 'function';
}
exports.hasJoyInput = hasJoyInput;
function hasPaddleInput(arg) {
    return typeof arg.setPaddleInput === 'function';
}
exports.hasPaddleInput = hasPaddleInput;
function isRaster(arg) {
    return typeof arg.getRasterY === 'function';
}
exports.isRaster = isRaster;
function hasProbe(arg) {
    return typeof arg.connectProbe == 'function';
}
exports.hasProbe = hasProbe;
function hasBIOS(arg) {
    return typeof arg.loadBIOS == 'function';
}
exports.hasBIOS = hasBIOS;
function hasSerialIO(arg) {
    return typeof arg.connectSerialIO === 'function';
}
exports.hasSerialIO = hasSerialIO;
class BaseMachinePlatform extends BaseDebugPlatform {
    constructor(mainElement) {
        super();
        this.mainElement = mainElement;
    }
    reset() {
        this.machine.reset();
        if (this.serialVisualizer != null)
            this.serialVisualizer.reset();
    }
    loadState(s) { this.machine.loadState(s); }
    saveState() { return this.machine.saveState(); }
    getSP() { return this.machine.cpu.getSP(); }
    getPC() { return this.machine.cpu.getPC(); }
    isStable() { return this.machine.cpu.isStable(); }
    getCPUState() { return this.machine.cpu.saveState(); }
    loadControlsState(s) { this.machine.loadControlsState(s); }
    saveControlsState() { return this.machine.saveControlsState(); }
    async start() {
        this.machine = this.newMachine();
        const m = this.machine;
        // block on WASM loading
        if (m instanceof wasmplatform_1.BaseWASMMachine) {
            await m.loadWASM();
        }
        var videoFrequency;
        if (hasVideo(m)) {
            var vp = m.getVideoParams();
            this.video = new emu_1.RasterVideo(this.mainElement, vp.width, vp.height, { overscan: !!vp.overscan,
                rotate: vp.rotate | 0,
                aspect: vp.aspect });
            this.video.create();
            m.connectVideo(this.video.getFrameData());
            // TODO: support keyboard w/o video?
            if (hasKeyInput(m)) {
                this.video.setKeyboardEvents(m.setKeyInput.bind(m));
                this.poller = new emu_1.ControllerPoller(m.setKeyInput.bind(m));
            }
            videoFrequency = vp.videoFrequency;
        }
        this.timer = new emu_1.AnimationTimer(videoFrequency || 60, this.nextFrame.bind(this));
        if (hasAudio(m)) {
            var ap = m.getAudioParams();
            this.audio = new audio_1.SampledAudio(ap.sampleRate);
            this.audio.start();
            m.connectAudio(this.audio);
        }
        if (hasPaddleInput(m)) {
            this.video.setupMouseEvents();
        }
        if (hasProbe(m)) {
            this.probeRecorder = new probe_1.ProbeRecorder(m);
            this.startProbing = () => {
                m.connectProbe(this.probeRecorder);
                return this.probeRecorder;
            };
            this.stopProbing = () => {
                m.connectProbe(null);
            };
        }
        if (hasBIOS(m)) {
            this.loadBIOS = (title, data) => {
                m.loadBIOS(data, title);
            };
        }
        if (hasSerialIO(m)) {
            if (this.serialIOInterface == null) {
                this.serialVisualizer = new SerialIOVisualizer(this.mainElement, m);
            }
            else {
                m.connectSerialIO(this.serialIOInterface);
            }
        }
    }
    loadROM(title, data) {
        this.machine.loadROM(data, title);
        this.reset();
    }
    pollControls() {
        this.poller && this.poller.poll();
        if (hasPaddleInput(this.machine)) {
            this.machine.setPaddleInput(0, this.video.paddle_x);
            this.machine.setPaddleInput(1, this.video.paddle_y);
        }
        // TODO: put into interface
        if (this.machine['pollControls']) {
            this.machine['pollControls']();
        }
    }
    advance(novideo) {
        let trap = this.getDebugCallback();
        try {
            var steps = this.machine.advanceFrame(trap);
            return steps;
        }
        finally {
            // in case EmuHalt is thrown...
            if (!novideo && this.video) {
                this.video.updateFrame();
                this.updateVideoDebugger();
            }
            if (!novideo && this.serialVisualizer) {
                this.serialVisualizer.refresh();
            }
        }
    }
    updateVideoDebugger() {
        var _a;
        if (!this.isRunning() && isRaster(this.machine) && this.machine.getRasterCanvasPosition) {
            const { x, y } = this.machine.getRasterCanvasPosition();
            if (x >= 0 || y >= 0) {
                const ctx = (_a = this.video) === null || _a === void 0 ? void 0 : _a.getContext();
                if (ctx) {
                    (0, emu_1.drawCrosshair)(ctx, x, y, 1);
                }
            }
        }
    }
    advanceFrameClock(trap, step) {
        if (!(step > 0))
            return;
        if (this.machine instanceof wasmplatform_1.BaseWASMMachine) {
            return this.machine.advanceFrameClock(trap, step);
        }
        else {
            return this.machine.advanceFrame(() => {
                return --step <= 0;
            });
        }
    }
    isRunning() {
        return this.timer && this.timer.isRunning();
    }
    resume() {
        this.timer.start();
        this.audio && this.audio.start();
    }
    pause() {
        this.timer.stop();
        this.audio && this.audio.stop();
    }
    // so probe views stick around TODO: must be a better way?
    runToVsync() {
        this.restartDebugging();
        var flag = false;
        this.runEval(() => {
            if (this.getRasterScanline() > 0)
                flag = true;
            else
                return flag;
        });
    }
    // TODO: reset target clock counter
    getRasterScanline() {
        return isRaster(this.machine) && this.machine.getRasterY ? this.machine.getRasterY() : -1;
    }
    getRasterLineClock() {
        return isRaster(this.machine) && this.machine.getRasterX ? this.machine.getRasterX() : -1;
    }
    readAddress(addr) {
        return this.machine.read(addr);
    }
    getDebugCategories() {
        if (isDebuggable(this.machine))
            return this.machine.getDebugCategories();
    }
    getDebugInfo(category, state) {
        return isDebuggable(this.machine) && this.machine.getDebugInfo(category, state);
    }
}
exports.BaseMachinePlatform = BaseMachinePlatform;
// TODO: move debug info into CPU?
class Base6502MachinePlatform extends BaseMachinePlatform {
    constructor() {
        super(...arguments);
        this.getOpcodeMetadata = getOpcodeMetadata_6502;
    }
    getToolForFilename(fn) { return getToolForFilename_6502(fn); }
    disassemble(pc, read) {
        return (0, disasm6502_1.disassemble6502)(pc, read(pc), read(pc + 1), read(pc + 2));
    }
    getDebugCategories() {
        if (isDebuggable(this.machine))
            return this.machine.getDebugCategories();
        else
            return ['CPU', 'ZPRAM', 'Stack'];
    }
    getDebugInfo(category, state) {
        switch (category) {
            case 'CPU': return cpuStateToLongString_6502(state.c);
            case 'ZPRAM': return (0, emu_1.dumpRAM)(state.b || state.ram, 0x0, 0x100);
            case 'Stack': return dumpStackToString(this, state.b || state.ram, 0x100, 0x1ff, 0x100 + state.c.SP, 0x20);
            default: return isDebuggable(this.machine) && this.machine.getDebugInfo(category, state);
        }
    }
}
exports.Base6502MachinePlatform = Base6502MachinePlatform;
class BaseZ80MachinePlatform extends BaseMachinePlatform {
    constructor() {
        super(...arguments);
        //getOpcodeMetadata     = getOpcodeMetadata_z80;
        this.getToolForFilename = getToolForFilename_z80;
    }
    getDebugCategories() {
        if (isDebuggable(this.machine))
            return this.machine.getDebugCategories();
        else
            return ['CPU', 'Stack'];
    }
    getDebugInfo(category, state) {
        switch (category) {
            case 'CPU': return cpuStateToLongString_Z80(state.c);
            case 'Stack': {
                var sp = (state.c.SP - 1) & 0xffff;
                var start = sp & 0xff00;
                var end = start + 0xff;
                if (sp == 0)
                    sp = 0x10000;
                return dumpStackToString(this, [], start, end, sp, 0xcd);
            }
            default: return isDebuggable(this.machine) && this.machine.getDebugInfo(category, state);
        }
    }
    disassemble(pc, read) {
        return (0, disasmz80_1.disassembleZ80)(pc, read(pc), read(pc + 1), read(pc + 2), read(pc + 3));
    }
}
exports.BaseZ80MachinePlatform = BaseZ80MachinePlatform;
class Base6809MachinePlatform extends BaseMachinePlatform {
    constructor() {
        super(...arguments);
        this.getToolForFilename = getToolForFilename_6809;
    }
    getDebugCategories() {
        if (isDebuggable(this.machine))
            return this.machine.getDebugCategories();
        else
            return ['CPU', 'Stack'];
    }
    getDebugInfo(category, state) {
        switch (category) {
            case 'CPU': return cpuStateToLongString_6809(state.c);
            case 'Stack': {
                var sp = (state.c.SP - 1) & 0xffff;
                var start = sp & 0xff00;
                var end = start + 0xff;
                if (sp == 0)
                    sp = 0x10000;
                return dumpStackToString(this, [], start, end, sp, 0x17, true);
            }
            default: return super.getDebugInfo(category, state);
        }
    }
    disassemble(pc, read) {
        // TODO: don't create new CPU
        return Object.create((0, _6809_1.CPU6809)()).disasm(read(pc), read(pc + 1), read(pc + 2), read(pc + 3), read(pc + 4), pc);
    }
}
exports.Base6809MachinePlatform = Base6809MachinePlatform;
///
class SerialIOVisualizer {
    constructor(parentElement, device) {
        this.lastOutCount = -1;
        this.lastInCount = -1;
        this.device = device;
        this.textarea = document.createElement("textarea");
        this.textarea.classList.add('transcript');
        this.textarea.classList.add('transcript-style-2');
        this.textarea.style.display = 'none';
        parentElement.appendChild(this.textarea);
        /*
        this.vlist = new VirtualTextScroller(parentElement);
        this.vlist.create(parentElement, 1024, this.getMemoryLineAt.bind(this));
        this.vlist.maindiv.style.height = '8em';
        this.vlist.maindiv.style.overflow = 'clip';
        */
    }
    reset() {
        this.lastOutCount = 0;
        this.lastInCount = 0;
        this.textarea.style.display = 'none';
    }
    refresh() {
        var lastop = '';
        if (this.device.serialOut.length != this.lastOutCount) {
            var s = '';
            for (var ev of this.device.serialOut) {
                if (lastop != ev.op) {
                    if (s != '')
                        s += '\n';
                    if (ev.op === 'read')
                        s += '<< ';
                    else if (ev.op === 'write')
                        s += '>> ';
                    lastop = ev.op;
                }
                if (ev.value == 10) {
                    s += '\u21b5';
                    lastop = '';
                }
                else {
                    s += (0, util_1.byteToASCII)(ev.value);
                }
            }
            this.textarea.value = s;
            this.lastOutCount = this.device.serialOut.length;
            this.textarea.style.display = 'block';
        }
    }
}
//# sourceMappingURL=baseplatform.js.map