jsbeeb 1.6.0 → 1.8.0

package/src/wd-fdc.js

@@ -1301,9 +1301,106 @@ export class WdFdc {
         this._dataRegister = data;
     }
 
-    /// jsbeeb compatibility stuff TODO combine with the noise aware stuff?
+    snapshotState() {
+        const scheduler = this._timerTask.scheduler;
+        return {
+            controlRegister: this._controlRegister,
+            statusRegister: this._statusRegister,
+            trackRegister: this._trackRegister,
+            sectorRegister: this._sectorRegister,
+            dataRegister: this._dataRegister,
+            isIntRq: this._isIntRq,
+            isDrq: this._isDrq,
+            doRaiseIntRq: this._doRaiseIntRq,
+            isIndexPulse: this._isIndexPulse,
+            isInterruptOnIndexPulse: this._isInterruptOnIndexPulse,
+            isWriteTrackCrcSecondByte: this._isWriteTrackCrcSecondByte,
+            command: this._command,
+            commandType: this._commandType,
+            isCommandSettle: this._isCommandSettle,
+            isCommandWrite: this._isCommandWrite,
+            isCommandVerify: this._isCommandVerify,
+            isCommandMulti: this._isCommandMulti,
+            isCommandDeleted: this._isCommandDeleted,
+            commandStepRateMs: this._commandStepRateMs,
+            state: this._state,
+            timerState: this._timerState,
+            stateCount: this._stateCount,
+            indexPulseCount: this._indexPulseCount,
+            // BigInt must be converted to string for JSON serialization
+            markDetector: this._markDetector.toString(),
+            dataShifter: this._dataShifter,
+            dataShiftCount: this._dataShiftCount,
+            deliverData: this._deliverData,
+            deliverIsMarker: this._deliverIsMarker,
+            crc: this._crc,
+            onDiscTrack: this._onDiscTrack,
+            onDiscSector: this._onDiscSector,
+            onDiscLength: this._onDiscLength,
+            onDiscCrc: this._onDiscCrc,
+            lastMfmBit: this._lastMfmBit,
+            timerTaskOffset: this._timerTask.scheduled() ? this._timerTask.expireEpoch - scheduler.epoch : null,
+            drives: this._drives.map((d) => d.snapshotState()),
+        };
+    }
+
+    restoreState(state) {
+        this._controlRegister = state.controlRegister;
+        this._statusRegister = state.statusRegister;
+        this._trackRegister = state.trackRegister;
+        this._sectorRegister = state.sectorRegister;
+        this._dataRegister = state.dataRegister;
+        this._isIntRq = state.isIntRq;
+        this._isDrq = state.isDrq;
+        this._doRaiseIntRq = state.doRaiseIntRq;
+        this._isIndexPulse = state.isIndexPulse;
+        this._isInterruptOnIndexPulse = state.isInterruptOnIndexPulse;
+        this._isWriteTrackCrcSecondByte = state.isWriteTrackCrcSecondByte;
+        this._command = state.command;
+        this._commandType = state.commandType;
+        this._isCommandSettle = state.isCommandSettle;
+        this._isCommandWrite = state.isCommandWrite;
+        this._isCommandVerify = state.isCommandVerify;
+        this._isCommandMulti = state.isCommandMulti;
+        this._isCommandDeleted = state.isCommandDeleted;
+        this._commandStepRateMs = state.commandStepRateMs;
+        this._state = state.state;
+        this._timerState = state.timerState;
+        this._stateCount = state.stateCount;
+        this._indexPulseCount = state.indexPulseCount;
+        this._markDetector = BigInt(state.markDetector);
+        this._dataShifter = state.dataShifter;
+        this._dataShiftCount = state.dataShiftCount;
+        this._deliverData = state.deliverData;
+        this._deliverIsMarker = state.deliverIsMarker;
+        this._crc = state.crc;
+        this._onDiscTrack = state.onDiscTrack;
+        this._onDiscSector = state.onDiscSector;
+        this._onDiscLength = state.onDiscLength;
+        this._onDiscCrc = state.onDiscCrc;
+        this._lastMfmBit = state.lastMfmBit;
+
+        // Restore drives
+        for (let i = 0; i < this._drives.length; i++) {
+            this._drives[i].restoreState(state.drives[i]);
+        }
+
+        // Derive _currentDrive from _controlRegister
+        this._currentDrive = null;
+        if (this._controlRegister & Control.drive0 || this._controlRegister & Control.drive1) {
+            this._currentDrive = this._drives[this._controlRegister & Control.drive0 ? 0 : 1];
+        }
+
+        // Restore timer
+        this._timerTask.cancel();
+        if (state.timerTaskOffset !== null) this._timerTask.schedule(state.timerTaskOffset);
+
+        // NMI level is saved/restored by the CPU snapshot directly,
+        // so we don't reassert it here.
+    }
+
+    /// jsbeeb compatibility stuff
     /**
-     *
      * @param {Number} drive
      * @param {Disc} disc
      */

package/tests/test-machine.js

@@ -30,13 +30,28 @@ export class TestMachine {
                 if (left && !stopped) {
                     setTimeout(runAnIter, 0);
                 } else {
-                    resolve();
+                    resolve(stopped);
                 }
             };
             runAnIter();
         });
     }
 
+    /**
+     * Run until the cursor blink reaches the desired state.
+     * This ensures deterministic screenshots regardless of how many
+     * cycles were consumed by prior type() or runFor() calls.
+     * @param {boolean} on - true for cursor visible, false for hidden
+     */
+    async runToCursorState(on) {
+        const video = this.processor.video;
+        for (let i = 0; i < 100; i++) {
+            if (video.cursorOnThisFrame === on) return;
+            await this.runFor(40000);
+        }
+        throw new Error(`Cursor did not reach state ${on} in time (cursorOnThisFrame=${video.cursorOnThisFrame})`);
+    }
+
     async runUntilVblank() {
         let hit = false;
         if (this.processor.isMaster) throw new Error("Not yet implemented");
@@ -87,6 +102,22 @@ export class TestMachine {
         this.processor.fdc.loadDisc(0, fdc.discFor(this.processor.fdc, "", data));
     }
 
+    /**
+     * Load a disc image from raw data (Uint8Array or Buffer).
+     * @param {Uint8Array|Buffer} data - raw disc image bytes
+     */
+    loadDiscData(data) {
+        this.processor.fdc.loadDisc(0, fdc.discFor(this.processor.fdc, "", data));
+    }
+
+    /**
+     * Reset the machine.
+     * @param {boolean} hard - true for power-on reset, false for soft reset
+     */
+    reset(hard) {
+        this.processor.reset(hard);
+    }
+
     async loadBasic(source) {
         const tokeniser = await Tokeniser.create();
         const tokenised = tokeniser.tokenise(source);
@@ -105,157 +136,169 @@ export class TestMachine {
         this.writebyte(0x13, endHigh);
     }
 
+    /**
+     * Convert an ASCII character to a {code, shift} pair for the BBC keyboard.
+     */
+    _charToKey(ch) {
+        switch (ch) {
+            case "\n":
+            case "\r":
+                return { code: 13, shift: false };
+            case '"':
+                return { code: utils.keyCodes.K2, shift: true };
+            case "*":
+                return { code: utils.keyCodes.APOSTROPHE, shift: true };
+            case "!":
+                return { code: utils.keyCodes.K1, shift: true };
+            case ".":
+                return { code: utils.keyCodes.PERIOD, shift: false };
+            case ";":
+                return { code: utils.keyCodes.SEMICOLON, shift: false };
+            case ":":
+                return { code: utils.keyCodes.APOSTROPHE, shift: false };
+            case ",":
+                return { code: utils.keyCodes.COMMA, shift: false };
+            case "&":
+                return { code: utils.keyCodes.K6, shift: true };
+            case " ":
+                return { code: utils.keyCodes.SPACE, shift: false };
+            case "-":
+                return { code: utils.keyCodes.MINUS, shift: false };
+            case "=":
+                return { code: utils.keyCodes.MINUS, shift: true };
+            case "+":
+                return { code: utils.keyCodes.SEMICOLON, shift: true };
+            case "^":
+                return { code: utils.keyCodes.EQUALS, shift: false };
+            case "~":
+                return { code: utils.keyCodes.EQUALS, shift: true };
+            case "[":
+                return { code: utils.keyCodes.LEFT_SQUARE_BRACKET, shift: false };
+            case "]":
+                return { code: utils.keyCodes.RIGHT_SQUARE_BRACKET, shift: false };
+            case "{":
+                return { code: utils.keyCodes.LEFT_SQUARE_BRACKET, shift: true };
+            case "}":
+                return { code: utils.keyCodes.HASH, shift: true };
+            case "\\":
+                return { code: utils.keyCodes.BACKSLASH, shift: false };
+            case "/":
+                return { code: utils.keyCodes.SLASH, shift: false };
+            case "?":
+                return { code: utils.keyCodes.SLASH, shift: true };
+            case "<":
+                return { code: utils.keyCodes.COMMA, shift: true };
+            case ">":
+                return { code: utils.keyCodes.PERIOD, shift: true };
+            case "(":
+                return { code: utils.keyCodes.K8, shift: true };
+            case ")":
+                return { code: utils.keyCodes.K9, shift: true };
+            case "@":
+                return { code: utils.keyCodes.BACK_QUOTE, shift: false };
+            case "#":
+                return { code: utils.keyCodes.K3, shift: true };
+            case "$":
+                return { code: utils.keyCodes.K4, shift: true };
+            case "%":
+                return { code: utils.keyCodes.K5, shift: true };
+            default: {
+                const upper = ch.toUpperCase();
+                const isLetter = (ch >= "a" && ch <= "z") || (ch >= "A" && ch <= "Z");
+                if (isLetter) {
+                    const wantUpper = ch >= "A" && ch <= "Z";
+                    const capsOn = this.processor.sysvia.capsLockLight;
+                    // CAPS LOCK on: unshifted = upper, shifted = lower
+                    // CAPS LOCK off: unshifted = lower, shifted = upper
+                    const needShift = capsOn ? !wantUpper : wantUpper;
+                    return { code: upper.charCodeAt(0), shift: needShift };
+                }
+                return { code: ch.charCodeAt(0), shift: false };
+            }
+        }
+    }
+
+    /**
+     * Type text by installing a debugInstruction hook that presses/releases
+     * keys at timed intervals during CPU execution.  The hook persists across
+     * runFor calls, so breakpoints naturally coexist: if a breakpoint halts
+     * execution mid-typing, the remaining characters are typed when execution
+     * resumes.
+     */
     async type(text) {
-        console.log("Typing '" + text + "'");
-        const cycles = 40 * 1000;
+        const fullText = text + "\n"; // append RETURN
+        const keys = fullText.split("").map((ch) => this._charToKey(ch));
+        const holdCycles = 40000;
+        let index = 0;
+        let phase = "idle"; // "idle" → "down" → "idle"
+        let nextEventCycle = 0;
+        let done = false;
 
-        const kd = (ch) => {
-            this.processor.sysvia.keyDown(ch);
-            return this.runFor(cycles).then(() => {
-                this.processor.sysvia.keyUp(ch);
-                return this.runFor(cycles);
-            });
-        };
+        const currentCycle = () => this.processor.cycleSeconds * 2000000 + this.processor.currentCycles;
 
-        const typeChar = (ch) => {
-            let shift = false;
-            // Map printable ASCII characters to BBC Micro key codes (UK layout).
-            // Characters not listed here fall through to the default case which
-            // uses toUpperCase().charCodeAt(0) — valid for A–Z and 0–9 only.
-            switch (ch) {
-                case '"':
-                    ch = utils.keyCodes.K2;
-                    shift = true;
-                    break;
-                case "*":
-                    ch = utils.keyCodes.APOSTROPHE;
-                    shift = true;
-                    break;
-                case "!":
-                    ch = utils.keyCodes.K1;
-                    shift = true;
-                    break;
-                case ".":
-                    ch = utils.keyCodes.PERIOD;
-                    break;
-                case ";":
-                    ch = utils.keyCodes.SEMICOLON;
-                    break;
-                case ":":
-                    ch = utils.keyCodes.APOSTROPHE;
-                    break;
-                case ",":
-                    ch = utils.keyCodes.COMMA;
-                    break;
-                case "&":
-                    ch = utils.keyCodes.K6;
-                    shift = true;
-                    break;
-                case " ":
-                    ch = utils.keyCodes.SPACE;
-                    break;
-                case "-":
-                    ch = utils.keyCodes.MINUS;
-                    break;
-                case "=":
-                    ch = utils.keyCodes.MINUS;
-                    shift = true;
-                    break;
-                case "+":
-                    ch = utils.keyCodes.SEMICOLON;
-                    shift = true;
-                    break;
-                case "^":
-                    ch = utils.keyCodes.EQUALS;
-                    break;
-                case "~":
-                    ch = utils.keyCodes.EQUALS;
-                    shift = true;
-                    break;
-                case "[":
-                    ch = utils.keyCodes.LEFT_SQUARE_BRACKET;
-                    break;
-                case "]":
-                    ch = utils.keyCodes.RIGHT_SQUARE_BRACKET;
-                    break;
-                case "{":
-                    ch = utils.keyCodes.LEFT_SQUARE_BRACKET;
-                    shift = true;
-                    break;
-                case "}":
-                    ch = utils.keyCodes.HASH;
-                    shift = true;
-                    break;
-                case "\\":
-                    ch = utils.keyCodes.BACKSLASH;
-                    break;
-                case "/":
-                    ch = utils.keyCodes.SLASH;
-                    break;
-                case "?":
-                    ch = utils.keyCodes.SLASH;
-                    shift = true;
-                    break;
-                case "<":
-                    ch = utils.keyCodes.COMMA;
-                    shift = true;
-                    break;
-                case ">":
-                    ch = utils.keyCodes.PERIOD;
-                    shift = true;
-                    break;
-                case "(":
-                    ch = utils.keyCodes.K8;
-                    shift = true;
-                    break;
-                case ")":
-                    ch = utils.keyCodes.K9;
-                    shift = true;
-                    break;
-                case "@":
-                    ch = utils.keyCodes.BACK_QUOTE;
-                    break;
-                case "#":
-                    ch = utils.keyCodes.K3;
-                    shift = true;
-                    break;
-                case "$":
-                    ch = utils.keyCodes.K4;
-                    shift = true;
-                    break;
-                case "%":
-                    ch = utils.keyCodes.K5;
-                    shift = true;
-                    break;
-                default:
-                    // A-Z and 0-9: ASCII value == DOM keyCode — works as-is.
-                    // Anything else (e.g. '_', '£', '`') is not yet mapped.
-                    ch = ch.toUpperCase().charCodeAt(0);
-                    break;
+        const hook = this.processor.debugInstruction.add(() => {
+            if (currentCycle() < nextEventCycle) return;
+
+            if (phase === "down") {
+                // Release current key
+                const key = keys[index];
+                this.processor.sysvia.keyUp(key.code);
+                if (key.shift) this.processor.sysvia.keyUp(16);
+                index++;
+                phase = "idle";
+                nextEventCycle = currentCycle() + holdCycles;
+                return;
             }
-            if (shift) {
-                this.processor.sysvia.keyDown(16);
-                return this.runFor(cycles).then(() => {
-                    return kd(ch).then(() => {
-                        this.processor.sysvia.keyUp(16);
-                        return this.runFor(cycles);
-                    });
-                });
-            } else {
-                return kd(ch);
+
+            // phase === "idle"
+            if (index >= keys.length) {
+                hook.remove();
+                done = true;
+                return;
             }
-        };
 
-        return text
-            .split("")
-            .reduce(function (p, char) {
-                return p.then(function () {
-                    return typeChar(char);
-                });
-            }, Promise.resolve())
-            .then(function () {
-                return kd(13);
-            });
+            // Press next key
+            const key = keys[index];
+            if (key.shift) this.processor.sysvia.keyDown(16);
+            this.processor.sysvia.keyDown(key.code);
+            phase = "down";
+            nextEventCycle = currentCycle() + holdCycles;
+        });
+
+        // Drive execution in chunks until all characters are typed or
+        // a breakpoint halts the CPU.
+        while (!done) {
+            const stopped = await this.runFor(holdCycles);
+            if (stopped) break;
+        }
+    }
+
+    /**
+     * Press a key on the BBC keyboard.
+     * @param {number} code - BBC key code (e.g. utils.keyCodes.SPACE)
+     */
+    keyDown(code) {
+        this.processor.sysvia.keyDown(code);
+    }
+
+    /**
+     * Release a key on the BBC keyboard.
+     * @param {number} code - BBC key code
+     */
+    keyUp(code) {
+        this.processor.sysvia.keyUp(code);
+    }
+
+    /**
+     * Load a ROM image directly into a sideways RAM slot.
+     * @param {number} slot - slot number (0-15, typically 4-7 for SWRAM)
+     * @param {Uint8Array|Buffer} data - ROM data (up to 16384 bytes)
+     */
+    loadSidewaysRam(slot, data) {
+        const offset = this.processor.romOffset + slot * 16384;
+        for (let i = 0; i < data.length && i < 16384; i++) {
+            this.processor.ramRomOs[offset + i] = data[i];
+        }
     }
 
     writebyte(addr, val) {