Files

114 lines
5.4 KiB
Swift
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// SPDX-License-Identifier: GPL-3.0-or-later
import Foundation
import Combine
@MainActor final class TraceModel: ObservableObject {
let machine: MachineModel
@Published private(set) var snapshot: VCCTraceSnapshot?
@Published var maximum = "10000"
@Published var starts = ""
@Published var stops = ""
@Published var screen = false
@Published var scheduler = false
@Published var firstExport = "1"
@Published var lastExport = ""
@Published var sampleText = "1"
@Published private(set) var selection: VCCTraceRecord?
@Published private(set) var markA: VCCTraceRecord?
@Published private(set) var markB: VCCTraceRecord?
@Published private(set) var pending = false
@Published var error: String?
@Published private(set) var saveMessage: String?
private var offset: UInt = 0
private var request: UUID?
init(machine: MachineModel) { self.machine = machine }
var available: Bool { !pending && !machine.busy && !machine.diskSaving && (machine.state == .running || machine.state == .paused) }
static func addresses(_ text: String) -> [NSNumber]? {
let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
if trimmed.isEmpty { return [] }
let parts = trimmed.split(whereSeparator: { $0 == "," || $0.isWhitespace })
guard parts.count <= 32 else { return nil }
let parsed = parts.compactMap { DebuggerModel.hexadecimal(String($0)).map { NSNumber(value: $0) } }
return parts.count == parsed.count ? parsed : nil
}
func poll() async {
defer { request = nil }
while !Task.isCancelled {
refresh()
do { try await Task.sleep(nanoseconds: 400_000_000) } catch { return }
}
}
func refresh() {
guard request == nil, !pending, !machine.busy else { return }
let token = UUID(); request = token
machine.readDebuggerTrace(offset: offset) { [weak self] value in
guard let self, self.request == token else { return }
self.request = nil
guard let value else { return }
if self.snapshot?.identifier != value.identifier {
self.selection = nil; self.markA = nil; self.markB = nil
self.offset = 0
}
self.snapshot = value
}
}
private func command(_ operation: (@escaping () -> Void) -> Void) {
guard available else { return }
pending = true; request = nil; error = nil
operation { [weak self] in
guard let self else { return }
self.pending = false; self.error = self.machine.error; self.refresh()
}
}
func start() {
guard let limit = UInt(maximum), (1...100000).contains(limit),
let begins = Self.addresses(starts), let ends = Self.addresses(stops) else {
error = "Use 1–100,000 samples and up to 32 hexadecimal start/stop addresses separated by spaces or commas."; return
}
command { machine.startDebuggerTrace(maximum: limit, starts: begins, stops: ends, screen: screen, scheduler: scheduler, completion: $0) }
}
func stop() { command(machine.stopDebuggerTrace) }
func clear() { command(machine.clearDebuggerTrace) }
func choose(_ row: VCCTraceRecord) { selection = row }
func mark(_ first: Bool) { if first { markA = selection } else { markB = selection } }
var markDifference: String? {
guard let a = markA, let b = markB else { return nil }
let ticks = Int64(b.clock) - Int64(a.clock)
// CoCo master crystal: nominal 14.31818 MHz. Host playback pacing is separate.
return "B − A: \(ticks) master clocks · \(String(format: "%.3f", Double(ticks) / 14_318.18)) ms (emulated time)"
}
func page(_ forward: Bool) {
let total = snapshot?.total ?? 0
if forward { guard offset + 256 < total else { return }; offset += 256 }
else { offset = offset >= 256 ? offset - 256 : 0 }
request = nil; refresh()
}
func go() {
guard let value = UInt(sampleText), value > 0, value <= (snapshot?.total ?? 0) else { error = "Enter a captured sample number."; return }
offset = ((value - 1) / 256) * 256; error = nil; request = nil; refresh()
}
func export(completion: @escaping (String?) -> Void) {
guard available, let snapshot, let first = UInt(firstExport), first > 0,
let last = lastExport.isEmpty ? snapshot.total : UInt(lastExport), last >= first, last <= snapshot.total else {
error = "Choose an inclusive sample range within the capture (blank end means the current last sample)."; completion(nil); return
}
pending = true; request = nil; error = nil; saveMessage = nil
machine.exportDebuggerTrace(first: first - 1, count: last - first + 1) { [weak self] text in
self?.pending = false; self?.error = self?.machine.error; completion(text)
}
}
func save(_ text: String, to url: URL) async {
pending = true; request = nil; error = nil; saveMessage = nil
defer { pending = false }
do {
try await Task.detached {
let access = url.startAccessingSecurityScopedResource()
defer { if access { url.stopAccessingSecurityScopedResource() } }
try text.write(to: url, atomically: true, encoding: .utf8)
}.value
saveMessage = "Saved trace to \(url.lastPathComponent)."
} catch { self.error = error.localizedDescription }
}
}