Publish VCC Plus OSS source distribution for 3.6.2 build 60

This commit is contained in:
Brian Holman committed 2026-11-13 00:14:03 -07:00
commit c652a5276d
1192 files changed
+272368

No files matched your search

+113
View File
@@ -0,0 +1,113 @@
// 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 }
}
}