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

+107
View File
@@ -0,0 +1,107 @@
// SPDX-License-Identifier: GPL-3.0-or-later
import Foundation
import Combine
@MainActor
final class MemoryToolsModel: ObservableObject {
enum Space: String, CaseIterable { case mapped = "Mapped CPU", physical = "Physical RAM" }
struct Row: Identifiable {
let id: Int
let location: UInt32
let logicalAddress: UInt16
let bytes: String
let mnemonic: String
let operand: String
}
let machine: MachineModel
@Published var space = Space.physical
@Published var startText = "000000"
@Published var endText = "0000FF"
@Published var logicalText = "0000"
@Published var os9 = false
@Published private(set) var pending = false
@Published private(set) var rows: [Row] = []
@Published private(set) var caption = "Capture memory to inspect it. The machine keeps its current running or paused state."
@Published var error: String?
@Published var saveMessage: String?
private(set) var capturedPhysical = true
private var subscriptions: Set<AnyCancellable> = []
init(machine: MachineModel) {
self.machine = machine
// Observe only command availability and RAM capacity, not the 60 Hz
// display publisher. A profile change must update range validation even
// while this tab retains an older, explicitly labeled capture.
let changes: [AnyPublisher<Void, Never>] = [
machine.$state.removeDuplicates().map { _ in () }.eraseToAnyPublisher(),
machine.$busy.removeDuplicates().map { _ in () }.eraseToAnyPublisher(),
machine.$diskSaving.removeDuplicates().map { _ in () }.eraseToAnyPublisher(),
machine.$settings.map(\.ram).removeDuplicates().map { _ in () }.eraseToAnyPublisher()
]
Publishers.MergeMany(changes).sink { [weak self] in self?.objectWillChange.send() }.store(in: &subscriptions)
}
var available: Bool { !pending && !machine.busy && !machine.diskSaving && (machine.state == .paused || machine.state == .running) }
var capacity: UInt32 { space == .mapped ? 65536 : [0x20000, 0x80000, 0x200000, 0x800000][min(3, max(0, machine.settings.ram))] }
static func range(start: String, end: String, capacity: UInt32) -> (UInt32, UInt32)? {
guard capacity > 0,
let first = DebuggerModel.hexadecimalAddress(start, maximum: capacity - 1),
let last = DebuggerModel.hexadecimalAddress(end, maximum: capacity - 1), last >= first else { return nil }
return (first, last - first + 1)
}
private func capture(decode: Bool) async -> VCCDebugMemoryCapture? {
guard available else { return nil }
guard let (start, length) = Self.range(start: startText, end: endText, capacity: capacity) else {
error = "Enter an inclusive hexadecimal range within 000000–\(DebuggerModel.hex(capacity - 1, width: 6)). The end must not precede the start."; return nil
}
let physical = space == .physical
guard let logical = decode && physical ? DebuggerModel.hexadecimal(logicalText) : 0 else {
error = "Enter a logical origin from 0000 to FFFF."; return nil
}
let interpretOS9 = os9
pending = true; error = nil; saveMessage = nil
defer { pending = false }
let capture: VCCDebugMemoryCapture? = await withCheckedContinuation { continuation in
machine.readDebuggerMemory(address: start, count: decode ? min(length, 4096) : length,
physical: physical, logicalAddress: logical, os9: interpretOS9, decode: decode) { continuation.resume(returning: $0) }
}
guard let capture else { error = "The machine is busy. Try again when its current operation finishes."; return nil }
guard capture.machine.errorMessage == nil else { error = capture.machine.errorMessage; return nil }
if decode {
capturedPhysical = physical
rows = capture.instructions.enumerated().map { index, instruction in
Row(id: index, location: capture.address + capture.instructionOffsets[index].uint32Value,
logicalAddress: instruction.address,
bytes: instruction.bytes.map { String(format: "%02X", $0) }.joined(separator: " "),
mnemonic: instruction.mnemonic, operand: instruction.operand)
}
caption = "\(physical ? "Physical RAM" : "Mapped CPU") capture at \(capture.machine.cycles.formatted()) cycles · \(rows.count) rows · \(capture.machine.use6309 ? "HD6309" : "MC6809")\(physical ? " · \(capture.capacity / 1024) KB captured RAM space" : "")\(interpretOS9 ? " · OS-9 interpretation" : "")"
}
return capture
}
func decode() async { _ = await capture(decode: true) }
func exportBytes() async -> Data? {
guard let result = await capture(decode: false) else { return nil }
guard !result.bytes.isEmpty, result.available.count == result.bytes.count,
result.available.allSatisfy({ $0 != 0 }) else {
error = "This range contains I/O that cannot be read without side effects. Choose a range excluding it, or export physical RAM. No file was written."
return nil
}
return result.bytes
}
func save(_ data: Data, to url: URL) async {
pending = true; error = nil
defer { pending = false }
do {
try await Task.detached {
let access = url.startAccessingSecurityScopedResource()
defer { if access { url.stopAccessingSecurityScopedResource() } }
try data.write(to: url, options: .atomic)
}.value
saveMessage = "Saved \(data.count.formatted()) raw bytes to \(url.lastPathComponent)."
} catch { self.error = error.localizedDescription }
}
}