// 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 } } }