jsbeeb 1.23.0 → 1.24.0

package/src/archive.js

@@ -0,0 +1,243 @@
+// Minimal ZIP extractor. Supports methods 0 (stored) and 8 (deflate); other
+// methods (bzip2, lzma, etc.) will throw an error with the method number.
+
+import { inflate as pakoInflate, inflateRaw as pakoInflateRaw, ungzip as pakoUngzip } from "pako";
+
+const ZipLocalHeaderSig = 0x04034b50;
+const ZipCentralDirSig = 0x02014b50;
+const ZipEocdSig = 0x06054b50;
+const ZipMethodStored = 0;
+const ZipMethodDeflate = 8;
+
+function readU16(buf, off) {
+    return buf[off] | (buf[off + 1] << 8);
+}
+
+function readU32(buf, off) {
+    return (buf[off] | (buf[off + 1] << 8) | (buf[off + 2] << 16) | (buf[off + 3] << 24)) >>> 0;
+}
+
+function isValidEocd(buf, off) {
+    const commentLen = readU16(buf, off + 20);
+    if (off + 22 + commentLen !== buf.length) return false;
+    const cdOff = readU32(buf, off + 16);
+    const cdSize = readU32(buf, off + 12);
+    return cdOff <= off && cdSize <= off - cdOff;
+}
+
+// Find the End of Central Directory record by scanning backwards.
+// EOCD is in the last 65557 bytes (22-byte fixed record + up to 65535-byte comment).
+function findEocd(buf) {
+    const searchStart = Math.max(0, buf.length - 65557);
+    for (let i = buf.length - 22; i >= searchStart; i--) {
+        if (readU32(buf, i) === ZipEocdSig && isValidEocd(buf, i)) return i;
+    }
+    throw new Error("Not a ZIP file: EOCD not found");
+}
+
+function inflateWith(inflater, data, context) {
+    if (!(data instanceof Uint8Array)) data = new Uint8Array(data);
+    try {
+        return inflater(data);
+    } catch (cause) {
+        throw new Error(`${context}: ${cause.message || cause}`, { cause });
+    }
+}
+
+export function inflate(data) {
+    return inflateWith(pakoInflate, data, "Unable to inflate");
+}
+
+// Extract all files from a ZIP archive.  Returns {filename: Uint8Array}.
+export async function unzip(buf) {
+    if (!(buf instanceof Uint8Array)) buf = new Uint8Array(buf);
+    const eocdOff = findEocd(buf);
+    const cdOff = readU32(buf, eocdOff + 16);
+    const cdCount = readU16(buf, eocdOff + 10);
+    const decoder = new TextDecoder();
+
+    const files = Object.create(null);
+    let pos = cdOff;
+    for (let i = 0; i < cdCount; i++) {
+        if (pos + 46 > buf.length || readU32(buf, pos) !== ZipCentralDirSig)
+            throw new Error("Bad central directory entry");
+        const flags = readU16(buf, pos + 8);
+        if (flags & 0x0001) throw new Error("Encrypted ZIP entries are not supported");
+        const method = readU16(buf, pos + 10);
+        const expectedCrc = readU32(buf, pos + 16);
+        const compressedSize = readU32(buf, pos + 20);
+        const nameLen = readU16(buf, pos + 28);
+        const extraLen = readU16(buf, pos + 30);
+        const commentLen = readU16(buf, pos + 32);
+        const localHeaderOff = readU32(buf, pos + 42);
+        const name = decoder.decode(buf.subarray(pos + 46, pos + 46 + nameLen));
+        pos += 46 + nameLen + extraLen + commentLen;
+
+        // Read local file header to find actual data offset.
+        if (readU32(buf, localHeaderOff) !== ZipLocalHeaderSig) throw new Error(`Bad local file header for ${name}`);
+        const localNameLen = readU16(buf, localHeaderOff + 26);
+        const localExtraLen = readU16(buf, localHeaderOff + 28);
+        const dataOff = localHeaderOff + 30 + localNameLen + localExtraLen;
+        const dataEnd = dataOff + compressedSize;
+        if (dataEnd > buf.length) throw new Error(`Truncated ZIP entry data for ${name}`);
+        const raw = buf.subarray(dataOff, dataEnd);
+
+        if (method === ZipMethodStored) {
+            files[name] = raw.slice();
+        } else if (method === ZipMethodDeflate) {
+            files[name] = inflateWith(pakoInflateRaw, raw, `Unable to inflate ZIP entry ${name}`);
+        } else {
+            throw new Error(`Unsupported ZIP compression method ${method} for ${name}`);
+        }
+        if (crc32(files[name]) >>> 0 !== expectedCrc) throw new Error(`Corrupt ZIP entry ${name}: CRC32 mismatch`);
+    }
+    return files;
+}
+
+// Standard CRC-32/ISO-HDLC.
+const Crc32Table = new Uint32Array(256).map((_, index) => {
+    let crc = index;
+    for (let bit = 0; bit < 8; ++bit) crc = crc & 1 ? (crc >>> 1) ^ 0xedb88320 : crc >>> 1;
+    return crc;
+});
+
+export function crc32(data) {
+    let crc = 0xffffffff;
+    for (let i = 0; i < data.length; ++i) crc = (crc >>> 8) ^ Crc32Table[(crc ^ data[i]) & 0xff];
+    return ~crc;
+}
+
+// Create a ZIP blob from an array of {name: string, data: Uint8Array} entries.
+// Uses stored method (no compression) with CRC-32 for maximum compatibility.
+export function createZipBlob(files) {
+    const encoder = new TextEncoder();
+    const localHeaders = [];
+    const centralHeaders = [];
+    let offset = 0;
+
+    for (const { name, data } of files) {
+        const nameBytes = encoder.encode(name);
+        const crc = crc32(data);
+        // Local file header (30 + nameLen + data)
+        const local = new Uint8Array(30 + nameBytes.length + data.length);
+        const lv = new DataView(local.buffer);
+        lv.setUint32(0, 0x04034b50, true); // signature
+        lv.setUint16(4, 20, true); // version needed
+        lv.setUint16(8, 0, true); // method: stored
+        lv.setUint32(14, crc, true); // CRC-32
+        lv.setUint32(18, data.length, true); // compressed size
+        lv.setUint32(22, data.length, true); // uncompressed size
+        lv.setUint16(26, nameBytes.length, true); // name length
+        local.set(nameBytes, 30);
+        local.set(data, 30 + nameBytes.length);
+        localHeaders.push(local);
+
+        // Central directory entry (46 + nameLen)
+        const central = new Uint8Array(46 + nameBytes.length);
+        const cv = new DataView(central.buffer);
+        cv.setUint32(0, 0x02014b50, true); // signature
+        cv.setUint16(4, 20, true); // version made by
+        cv.setUint16(6, 20, true); // version needed
+        cv.setUint16(10, 0, true); // method: stored
+        cv.setUint32(16, crc, true); // CRC-32
+        cv.setUint32(20, data.length, true); // compressed size
+        cv.setUint32(24, data.length, true); // uncompressed size
+        cv.setUint16(28, nameBytes.length, true); // name length
+        cv.setUint32(42, offset, true); // local header offset
+        central.set(nameBytes, 46);
+        centralHeaders.push(central);
+
+        offset += local.length;
+    }
+
+    const cdOffset = offset;
+    let cdSize = 0;
+    for (const c of centralHeaders) cdSize += c.length;
+
+    // End of central directory (22 bytes)
+    const eocd = new Uint8Array(22);
+    const ev = new DataView(eocd.buffer);
+    ev.setUint32(0, 0x06054b50, true); // signature
+    ev.setUint16(8, files.length, true); // entries on this disc
+    ev.setUint16(10, files.length, true); // total entries
+    ev.setUint32(12, cdSize, true); // central directory size
+    ev.setUint32(16, cdOffset, true); // central directory offset
+
+    return new Blob([...localHeaders, ...centralHeaders, eocd], { type: "application/zip" });
+}
+
+export function replaceOrAddExtension(name, newExt) {
+    const lastDot = name.lastIndexOf(".");
+    if (lastDot === -1) {
+        return name + newExt;
+    }
+    return name.substring(0, lastDot) + newExt;
+}
+
+export async function ungzip(data) {
+    return inflateWith(pakoUngzip, data, "Unable to ungzip");
+}
+
+const knownDiscExtensions = {
+    uef: true,
+    ssd: true,
+    dsd: true,
+    adf: true,
+    adm: true,
+    adl: true,
+    hfe: true,
+};
+
+const knownRomExtensions = {
+    rom: true,
+};
+
+async function unzipImage(data, knownExtensions) {
+    console.log("Attempting to unzip");
+
+    let files;
+    try {
+        files = await unzip(data);
+    } catch (e) {
+        throw new Error("Error unzipping " + e.message, { cause: e });
+    }
+
+    let uncompressed = null;
+    let loadedFile;
+    const ignored = [];
+
+    for (const [filename, fileData] of Object.entries(files)) {
+        const match = filename.match(/.*\.([a-z]+)/i);
+        if (!match || !knownExtensions[match[1].toLowerCase()]) {
+            console.log("Skipping file", filename);
+            continue;
+        }
+        if (uncompressed) {
+            console.log("Ignoring", filename, "as already found a file");
+            ignored.push(filename);
+            continue;
+        }
+        loadedFile = filename;
+        uncompressed = fileData;
+    }
+
+    if (!uncompressed) {
+        throw new Error("Couldn't find any compatible files in the archive");
+    }
+
+    console.log("Unzipped '" + loadedFile + "'");
+    return { data: uncompressed, name: loadedFile, ignored };
+}
+
+/**
+ * @param {Uint8Array|number[]} data a ZIP archive
+ * @returns {Promise<{data: Uint8Array, name: string, ignored: string[]}>} the one file loaded, and the
+ *     names of any other loadable files the archive held
+ */
+export async function unzipDiscImage(data) {
+    return unzipImage(data, knownDiscExtensions);
+}
+
+export async function unzipRomImage(data) {
+    return unzipImage(data, knownRomExtensions);
+}

package/src/basic-loader.js

@@ -1,10 +1,3 @@
-"use strict";
-
-/** Where the OS sits waiting for a keypress, per machine: the place to interrupt with a program. */
-export function basicIdleAddr(model) {
-    return model.isMaster ? 0xe7e6 : 0xe581;
-}
-
 /**
  * Pokes a tokenised BASIC program into memory at PAGE, and sets TOP and
  * VARTOP after it, exactly as if it had just been typed.

package/src/basic-tokenise.js

@@ -1,9 +1,8 @@
-"use strict";
-import * as utils from "./utils.js";
 import * as models from "./models.js";
 import { fake6502 } from "./fake6502.js";
+import { hexword } from "./hex.js";
 
-export async function create() {
+async function makeTokeniser() {
     const cpu = fake6502(models.basicOnly);
     const callTokeniser = function (line) {
         // Address of the tokenisation subroutine in the Master's BASIC ROM.
@@ -68,9 +67,7 @@ export async function create() {
             result += String.fromCharCode(cpu.readmem(i));
         }
         if (safety === 0) {
-            throw new Error(
-                "Unable to tokenize '" + line + "' - got as far as '" + result + "' pc=" + utils.hexword(cpu.pc),
-            );
+            throw new Error("Unable to tokenize '" + line + "' - got as far as '" + result + "' pc=" + hexword(cpu.pc));
         }
         return result;
     };
@@ -102,3 +99,19 @@ export async function create() {
     await cpu.initialise();
     return { tokenise };
 }
+
+let tokeniser = null;
+
+/**
+ * Building the tokeniser stands up a whole Master CPU and loads its ROMs, so
+ * the one instance is shared by every caller; each call to the tokeniser
+ * resets all the machine state it uses.
+ */
+export function create() {
+    if (!tokeniser)
+        tokeniser = makeTokeniser().catch((error) => {
+            tokeniser = null;
+            throw error;
+        });
+    return tokeniser;
+}

package/src/bbc-palette.js

@@ -1,5 +1,3 @@
-"use strict";
-
 // The 16 standard BBC Micro colours in ABGR format (0xffBBGGRR, little-endian canvas RGBA).
 // Colours 0-7 are the primary palette; 8-15 duplicate them as the default solid/non-flash set.
 // Imported by both video.js (NulaDefaultPalette) and teletext.js (BbcDefaultCollook) to avoid

package/src/bbcdiscs.js

@@ -1,5 +1,3 @@
-"use strict";
-
 const mirrorBase = "https://bbc.xania.org/archive/bbcdiscs";
 
 /** How a disc came to be an image, which is the difference between the archives it came from. */

package/src/bem-snapshot.js

@@ -1,11 +1,9 @@
-"use strict";
-import { inflate } from "./utils.js";
-
 // B-em snapshot format parser (versions 1 and 3).
 // v1 (BEMSNAP1): Fixed-size 327,885 byte packed struct. Reference: beebjit state.c
 // v3 (BEMSNAP3): Section-based with key+size headers, zlib-compressed memory. Reference: b-em savestate.c
 
 import { volumeTable, buildVideoState, buildSnapshot } from "./snapshot-helpers.js";
+import { inflate } from "./archive.js";
 
 const BemV1Size = 327885;
 

package/src/binary.js

@@ -0,0 +1,175 @@
+export function signExtend(val) {
+    return val >= 128 ? val - 256 : val;
+}
+
+export function uint8ArrayToString(array) {
+    let str = "";
+    for (let i = 0; i < array.length; ++i) str += String.fromCharCode(array[i]);
+    return str;
+}
+
+export function stringToUint8Array(str) {
+    if (str instanceof Uint8Array) return str;
+    const len = str.length;
+    const array = new Uint8Array(len);
+    for (let i = 0; i < len; ++i) array[i] = str.charCodeAt(i) & 0xff;
+    return array;
+}
+
+export function readInt32(data, offset) {
+    return (data[offset + 3] << 24) | (data[offset + 2] << 16) | (data[offset + 1] << 8) | data[offset + 0];
+}
+
+export function readInt16(data, offset) {
+    return (data[offset + 1] << 8) | data[offset + 0];
+}
+
+const tempBuf = new ArrayBuffer(4);
+const tempBuf8 = new Uint8Array(tempBuf);
+const tempBufF32 = new Float32Array(tempBuf);
+
+export function readFloat32(data, offset) {
+    tempBuf8[0] = data[offset];
+    tempBuf8[1] = data[offset + 1];
+    tempBuf8[2] = data[offset + 2];
+    tempBuf8[3] = data[offset + 3];
+    return tempBufF32[0];
+}
+
+export class DataStream {
+    constructor(name, data) {
+        this.name = name;
+        this.pos = 0;
+        this.data = stringToUint8Array(data);
+        if (!this.data) {
+            throw new Error("No data in " + name);
+        }
+        this.end = this.data.length;
+    }
+
+    bytesLeft() {
+        return this.end - this.pos;
+    }
+
+    eof() {
+        return this.bytesLeft() === 0;
+    }
+
+    advance(distance) {
+        if (this.bytesLeft() < distance) throw new RangeError("EOF in " + this.name);
+        this.pos += distance;
+        return this.pos - distance;
+    }
+
+    readFloat32(pos) {
+        if (pos === undefined) pos = this.advance(4);
+        return readFloat32(this.data, pos);
+    }
+
+    readInt32(pos) {
+        if (pos === undefined) pos = this.advance(4);
+        return readInt32(this.data, pos);
+    }
+
+    readInt16(pos) {
+        if (pos === undefined) pos = this.advance(2);
+        return readInt16(this.data, pos);
+    }
+
+    readByte(pos) {
+        if (pos === undefined) pos = this.advance(1);
+        return this.data[pos];
+    }
+
+    readNulString(pos, maxLength) {
+        if (!maxLength) maxLength = 1024;
+        let posToUse = pos === undefined ? this.pos : pos;
+        let result = "";
+        let c;
+        while ((c = this.readByte(posToUse++)) !== 0 && --maxLength) {
+            result += String.fromCharCode(c);
+        }
+        if (maxLength === 0) return "";
+        if (pos === undefined) this.pos = posToUse;
+        return result;
+    }
+
+    substream(posOrLength, length) {
+        let pos;
+        if (length === undefined) {
+            length = posOrLength;
+            pos = this.advance(length);
+        } else {
+            pos = posOrLength;
+            if (pos + length >= this.end) throw new RangeError("EOF in " + this.name);
+        }
+        return new DataStream(this.name + ".sub", this.data.subarray(pos, pos + length));
+    }
+
+    seek(to) {
+        if (to >= this.end) throw new RangeError("Seek out of range in " + this.name);
+        this.pos = to;
+    }
+}
+
+export function makeFast32(u32) {
+    // Firefox is ~5% faster with signed 32-bit arrays. Chrome is the same speed
+    // either way, so here we unconditionally wrap all u32 buffers as i32.
+    // Having a function do this makes it easy to test u32 vs i32, and means we
+    // keep the rest of the code using u32 (which makes more sense to me).
+    return new Int32Array(u32.buffer);
+}
+
+export class Fifo {
+    constructor(capacity) {
+        this._buffer = new Uint8Array(capacity);
+        this._size = 0;
+        this._wPtr = 0;
+        this._rPtr = 0;
+    }
+
+    /** @returns {number} */
+    get size() {
+        return this._size;
+    }
+
+    /** @returns {boolean} */
+    get full() {
+        return this._size === this._buffer.length;
+    }
+
+    /** @returns {boolean} */
+    get empty() {
+        return this._size === 0;
+    }
+
+    clear() {
+        this._size = 0;
+        this._wPtr = 0;
+        this._rPtr = 0;
+    }
+
+    /** @type {Number} b */
+    put(b) {
+        if (this.full) return;
+        this._buffer[this._wPtr % this._buffer.length] = b;
+        this._wPtr++;
+        this._size++;
+    }
+
+    /** @returns {Number} */
+    get() {
+        if (this.empty) return;
+        const res = this._buffer[this._rPtr % this._buffer.length];
+        this._rPtr++;
+        this._size--;
+        return res;
+    }
+
+    /** @returns {number[]} pending bytes, oldest first */
+    toArray() {
+        const result = [];
+        for (let i = 0; i < this._size; ++i) result.push(this._buffer[(this._rPtr + i) % this._buffer.length]);
+        return result;
+    }
+}

package/src/cmos.js

@@ -1,5 +1,3 @@
-"use strict";
-
 // CMOS layout: bytes 0-13 are RTC internal registers; bytes 14-63 are the 50
 // bytes of user storage.  Storage byte 11 (= CMOS address 25 = 0x19) holds
 // the BBC Master DFS configuration byte whose bits [1:0] are the WD1770 step

package/src/ddnoise.js

@@ -1,4 +1,3 @@
-"use strict";
 import { SamplePlayer } from "./sample-player.js";
 
 const Idle = 0;

package/src/debounce.js

@@ -0,0 +1,7 @@
+export function debounce(fn, wait) {
+    let timeout;
+    return function (...args) {
+        clearTimeout(timeout);
+        timeout = setTimeout(() => fn.apply(this, args), wait);
+    };
+}

package/src/disc-surface.js

@@ -1,5 +1,3 @@
-"use strict";
-
 // Pure geometry and colour mapping, free of the DOM; disc-visualiser.js owns the canvases.
 
 import { IbmDiscFormat } from "./disc.js";

package/src/disc.js

@@ -1,7 +1,8 @@
 // Translated from beebjit by Chris Evans.
 // https://github.com/scarybeasts/beebjit
 
-import { hexbyte, crc32 } from "./utils.js";
+import { crc32 } from "./archive.js";
+import { hexbyte } from "./hex.js";
 class TrackBuilder {
     /**
      * @param {Track} track
@@ -69,7 +70,7 @@ class TrackBuilder {
     }
 
     appendCrc(isMfm) {
-        // TODO consider remembering isMfM if nothing else needs to know/
+        // TODO(#1061) consider remembering isMfm if nothing else needs to know;
         // could then break this into MFM and FM builder
         const firstByte = (this._crc >>> 8) & 0xff;
         const secondByte = this._crc & 0xff;
@@ -304,7 +305,7 @@ class Sector {
      * @param {Sector|undefined} nextSector
      */
     read(nextSector) {
-        const pulsesPerByte = this.isMfm ? 16 : 32; // todo put in reader
+        const pulsesPerByte = this.isMfm ? 16 : 32; // TODO(#1061) put in reader
         if (this.dataPosBitOffset === null) {
             this._warn(`Sector header without data ${this.description}`);
             return;
@@ -536,7 +537,7 @@ export const DiscLayout = Object.freeze({
 
 export class DiscConfig {
     constructor() {
-        // TODO is this even useful?
+        // TODO(#1061) is this even useful?
         this.logProtection = false;
         this.logIffyPulses = false;
         this.expandTo80 = false;
@@ -707,8 +708,8 @@ export function loadSsd(disc, data, isDsd, onChange) {
     }
 
     if (onChange) {
-        // TODO, maybe construct the disc directly with this stuff?
-        // TODO maybe change this entirely and make it lazy; and have the onChange "pull" the disc as the format it wants
+        // TODO(#822) maybe construct the disc directly with this stuff?
+        // TODO(#822) maybe change this entirely and make it lazy; and have the onChange "pull" the disc as the format it wants
         // instead of doing this here. Most stuff doesn't care about changes and only needs the image on save.
         // Create a dataCopy large enough for all the sectors and tracks.
         const dataCopy = new Uint8Array(maxSize);
@@ -797,7 +798,7 @@ export function loadAdf(disc, data, isDsd) {
         }
     }
 
-    // TODO writeback
+    // TODO(#822) writeback
     return disc;
 }
 
@@ -1053,7 +1054,7 @@ export class Disc {
         this._snapshotDirtyTracks.add(dirtyKey);
         this._everDirtyTracks.add(dirtyKey);
         trackObj.pulses2Us[position] = pulses;
-        // TODO a debug log flag for this
+        // TODO(#1061) a debug log flag for this
         // console.log(`wrote to ${track}:${position * 32}`);
     }
 
@@ -1224,7 +1225,7 @@ export class Disc {
                     console.log(`"Unformatted track ${track.description}"`);
                 }
             }
-            // TODO add fingerprintings, catalog etcetc
+            // TODO(#1061) add fingerprinting, catalog etc
         }
     }
 }

package/src/fake6502.js

@@ -1,40 +1,24 @@
 // Fakes out various 6502s for testing purposes.
-"use strict";
 
 import { FakeVideo } from "./video.js";
 import { FakeSoundChip } from "./soundchip.js";
 import { TEST_6502, TEST_65C02, TEST_65C12, tubeModelFor } from "./models.js";
-import { FakeDdNoise } from "./ddnoise.js";
-import { FakeRelayNoise } from "./relaynoise.js";
-import { Cpu6502, AtomCpu6502 } from "./6502.js";
-import { Cmos } from "./cmos.js";
-import { FakeMusic5000 } from "./music5000.js";
+import { machineSpec, nullIo } from "./machine-spec.js";
 
 const fakeVideo = new FakeVideo();
 const soundChip = new FakeSoundChip();
-const dbgr = {
-    setCpu: () => {},
-};
 
-export function fake6502(model, opts) {
-    opts = opts || {};
+export function fake6502(model, opts = {}) {
     model = model || TEST_6502;
-    const CpuClass = model.isAtom ? AtomCpu6502 : Cpu6502;
-    return new CpuClass(model, {
-        dbgr,
-        video: opts.video || fakeVideo,
-        soundChip: opts.soundChip || soundChip,
-        ddNoise: new FakeDdNoise(),
-        relayNoise: new FakeRelayNoise(),
-        music5000: new FakeMusic5000(),
-        cmos: new Cmos(),
-        cycleAccurate: opts.cycleAccurate,
-        config: {
+    return new model.Cpu(model, {
+        ...nullIo({ video: opts.video ?? fakeVideo, soundChip: opts.soundChip ?? soundChip }),
+        config: machineSpec({
             tube: opts.tube ? tubeModelFor(model) : null,
             tubeCpuMultiplier: opts.tubeCpuMultiplier,
             cpuMultiplier: opts.cpuMultiplier,
             hasTeletextAdaptor: opts.hasTeletextAdaptor,
-        },
+        }),
+        cycleAccurate: opts.cycleAccurate,
     });
 }