114 lines
5.4 KiB
Swift
114 lines
5.4 KiB
Swift
// 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 }
|
||
}
|
||
|
||
}
|