@aptre/v86 0.5.0

package/src/log.ts

@@ -0,0 +1,149 @@
+declare let DEBUG: boolean
+
+if (typeof DEBUG === 'undefined') {
+    Object.defineProperty(globalThis, 'DEBUG', {
+        value: true,
+        writable: true,
+        configurable: true,
+    })
+}
+
+import { LOG_NAMES } from './const.js'
+import { pad0, pads } from './lib.js'
+import {
+    LOG_ALL,
+    LOG_PS2,
+    LOG_PIT,
+    LOG_9P,
+    LOG_PIC,
+    LOG_DMA,
+    LOG_NET,
+    LOG_FLOPPY,
+    LOG_DISK,
+    LOG_SERIAL,
+    LOG_VGA,
+    LOG_SB16,
+    LOG_VIRTIO,
+} from './const.js'
+
+export const LOG_TO_FILE = false
+
+export let LOG_LEVEL: number =
+    LOG_ALL &
+    ~LOG_PS2 &
+    ~LOG_PIT &
+    ~LOG_VIRTIO &
+    ~LOG_9P &
+    ~LOG_PIC &
+    ~LOG_DMA &
+    ~LOG_SERIAL &
+    ~LOG_NET &
+    ~LOG_FLOPPY &
+    ~LOG_DISK &
+    ~LOG_VGA &
+    ~LOG_SB16
+
+export function set_log_level(level: number): void {
+    LOG_LEVEL = level
+}
+
+export const log_data: string[] = []
+
+function do_the_log(message: string): void {
+    if (LOG_TO_FILE) {
+        log_data.push(message, '\n')
+    } else {
+        console.log(message)
+    }
+}
+
+export const dbg_log: (stuff: string | number, level?: number) => void =
+    (function () {
+        if (!DEBUG) {
+            return function () {}
+        }
+
+        const init: Record<number, string> = {}
+        const dbg_names = LOG_NAMES.reduce(function (a, x) {
+            a[x[0]] = x[1]
+            return a
+        }, init)
+
+        let log_last_message = ''
+        let log_message_repetitions = 0
+
+        function dbg_log_(stuff: string | number, level?: number): void {
+            if (!DEBUG) return
+
+            level = level || 1
+
+            if (level & LOG_LEVEL) {
+                const level_name = dbg_names[level] || '',
+                    message = '[' + pads(level_name, 4) + '] ' + stuff
+
+                if (message === log_last_message) {
+                    log_message_repetitions++
+
+                    if (log_message_repetitions < 2048) {
+                        return
+                    }
+                }
+
+                const now = new Date()
+                const time_str =
+                    pad0(now.getHours(), 2) +
+                    ':' +
+                    pad0(now.getMinutes(), 2) +
+                    ':' +
+                    pad0(now.getSeconds(), 2) +
+                    '+' +
+                    pad0(now.getMilliseconds(), 3) +
+                    ' '
+
+                if (log_message_repetitions) {
+                    if (log_message_repetitions === 1) {
+                        do_the_log(time_str + log_last_message)
+                    } else {
+                        do_the_log(
+                            'Previous message repeated ' +
+                                log_message_repetitions +
+                                ' times',
+                        )
+                    }
+
+                    log_message_repetitions = 0
+                }
+
+                do_the_log(time_str + message)
+                log_last_message = message
+            }
+        }
+
+        return dbg_log_
+    })()
+
+export function dbg_trace(level?: number): void {
+    if (!DEBUG) return
+
+    dbg_log(Error().stack!, level)
+}
+
+export function dbg_assert(cond: boolean, msg?: string, _level?: number): void {
+    if (!DEBUG) return
+
+    if (!cond) {
+        dbg_assert_failed(msg)
+    }
+}
+
+export function dbg_assert_failed(msg?: string): never {
+    // eslint-disable-next-line no-debugger
+    debugger
+    console.trace()
+
+    if (msg) {
+        throw 'Assert failed: ' + msg
+    } else {
+        throw 'Assert failed'
+    }
+}

package/src/main.ts

@@ -0,0 +1,199 @@
+import { CPU } from './cpu.js'
+import { save_state, restore_state } from './state.js'
+export { V86 } from './browser/starter.js'
+
+import { BusConnector } from './bus.js'
+
+// CPU is a constructor function (not a TS class), so it lacks a construct
+// signature. We alias it through an untyped binding to call with `new`.
+
+const CPUConstructor: any = CPU
+
+type CPUInstance = any
+
+function the_worker() {
+    let timeout: ReturnType<typeof setTimeout> | undefined
+    globalThis.onmessage = function (e: MessageEvent) {
+        const t = e.data.t
+        if (timeout) {
+            clearTimeout(timeout)
+            timeout = undefined
+        }
+        if (t < 1) postMessage(e.data.tick)
+        else timeout = setTimeout(() => postMessage(e.data.tick), t)
+    }
+}
+
+export class v86 {
+    running: boolean = false
+    stopping: boolean = false
+    idle: boolean = true
+    tick_counter: number = 0
+    worker: Worker | null = null
+    cpu: CPUInstance
+    bus: BusConnector
+
+    static microtick: () => number
+
+    constructor(bus: BusConnector, wasm: any) {
+        this.cpu = new CPUConstructor(bus, wasm, () => {
+            if (this.idle) {
+                this.next_tick(0)
+            }
+        })
+        this.bus = bus
+        this.register_yield()
+    }
+
+    run(): void {
+        this.stopping = false
+
+        if (!this.running) {
+            this.running = true
+            this.bus.send('emulator-started')
+        }
+
+        this.next_tick(0)
+    }
+
+    do_tick(): void {
+        if (this.stopping || !this.running) {
+            this.stopping = this.running = false
+            this.bus.send('emulator-stopped')
+            return
+        }
+
+        this.idle = false
+        const t = this.cpu.main_loop()
+
+        this.next_tick(t)
+    }
+
+    next_tick(t: number): void {
+        const tick = ++this.tick_counter
+        this.idle = true
+        this.yield(t, tick)
+    }
+
+    yield_callback(tick: number): void {
+        if (tick === this.tick_counter) {
+            this.do_tick()
+        }
+    }
+
+    stop(): void {
+        if (this.running) {
+            this.stopping = true
+        }
+    }
+
+    destroy(): void {
+        this.unregister_yield()
+    }
+
+    restart(): void {
+        this.cpu.reset_cpu()
+        this.cpu.load_bios()
+    }
+
+    init(settings: any): void {
+        this.cpu.init(settings, this.bus)
+        this.bus.send('emulator-ready')
+    }
+
+    save_state(): ArrayBuffer {
+        return save_state(this.cpu)
+    }
+
+    restore_state(state: any): void {
+        return restore_state(this.cpu, state)
+    }
+
+    yield(t: number, _tick: number): void {
+        // Default fallback: setTimeout
+        setTimeout(() => {
+            this.do_tick()
+        }, t)
+    }
+
+    register_yield(): void {
+        // no-op by default
+    }
+
+    unregister_yield(): void {
+        // no-op by default
+    }
+}
+
+const _global: any = globalThis
+
+// Environment-specific yield strategy overrides
+if (typeof process !== 'undefined') {
+    v86.prototype.yield = function (t: number, tick: number): void {
+        if (t < 1) {
+            _global.setImmediate(
+                (tick: number) => this.yield_callback(tick),
+                tick,
+            )
+        } else {
+            setTimeout((tick: number) => this.yield_callback(tick), t, tick)
+        }
+    }
+
+    v86.prototype.register_yield = function (): void {}
+    v86.prototype.unregister_yield = function (): void {}
+} else if (
+    _global['scheduler'] &&
+    typeof _global['scheduler']['postTask'] === 'function' &&
+    location.href.includes('use-scheduling-api')
+) {
+    v86.prototype.yield = function (t: number, tick: number): void {
+        t = Math.max(0, t)
+        _global['scheduler']['postTask'](() => this.yield_callback(tick), {
+            delay: t,
+        })
+    }
+
+    v86.prototype.register_yield = function (): void {}
+    v86.prototype.unregister_yield = function (): void {}
+} else if (typeof Worker !== 'undefined') {
+    // XXX: This has a slightly lower throughput compared to window.postMessage
+
+    v86.prototype.register_yield = function (): void {
+        const url = URL.createObjectURL(
+            new Blob(['(' + the_worker.toString() + ')()'], {
+                type: 'text/javascript',
+            }),
+        )
+        this.worker = new Worker(url)
+        this.worker.onmessage = (e: MessageEvent) => this.yield_callback(e.data)
+        URL.revokeObjectURL(url)
+    }
+
+    v86.prototype.yield = function (t: number, tick: number): void {
+        this.worker!.postMessage({ t, tick })
+    }
+
+    v86.prototype.unregister_yield = function (): void {
+        if (this.worker) {
+            this.worker.terminate()
+        }
+        this.worker = null
+    }
+}
+
+// Static microtick initialization
+if (typeof performance === 'object' && performance.now) {
+    v86.microtick = performance.now.bind(performance)
+} else if (typeof require === 'function') {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { performance } = require('perf_hooks')
+    v86.microtick = performance.now.bind(performance)
+} else if (typeof process === 'object' && process.hrtime) {
+    v86.microtick = function () {
+        const t = process.hrtime()
+        return t[0] * 1000 + t[1] / 1e6
+    }
+} else {
+    v86.microtick = Date.now
+}