Publish VCC Plus OSS source distribution for 3.6.2 build 60
This commit is contained in:
commit
c652a5276d
1192 files changed
+272368
No files matched your search
@@ -0,0 +1,319 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
import Foundation
|
||||
import Combine
|
||||
|
||||
/// A window-owned inspector of the shared machine. It never owns another CPU
|
||||
/// and only asks for immutable captures on the machine's existing serial queue.
|
||||
@MainActor
|
||||
final class DebuggerModel: ObservableObject {
|
||||
let machine: MachineModel
|
||||
@Published private(set) var snapshot: VCCDebuggerSnapshot?
|
||||
@Published private(set) var changedRegisters: Set<String> = []
|
||||
@Published var followPC = true
|
||||
enum CodePane: String, CaseIterable { case disassembly = "Disassembly", source = "Source" }
|
||||
@Published var codePane = CodePane.disassembly
|
||||
@Published private(set) var listing: DebugSourceListing?
|
||||
@Published private(set) var listingLoading = false
|
||||
@Published var sourceFollowPC = true
|
||||
@Published var selectedSourceLine: Int?
|
||||
@Published var sourceSearch = ""
|
||||
@Published var sourceMessage: String?
|
||||
private var listingRequest = UUID()
|
||||
@Published var addressText = "8000"
|
||||
enum MemorySpace: String, CaseIterable { case mapped = "Mapped CPU", physical = "Physical RAM" }
|
||||
enum MemoryPane: String, CaseIterable { case memory = "Memory", mmu = "MMU" }
|
||||
@Published var memoryPane = MemoryPane.memory
|
||||
@Published private(set) var memorySpace = MemorySpace.mapped
|
||||
@Published var memoryAddressText = "0000"
|
||||
@Published var physicalAddressText = "000000"
|
||||
@Published var pcText = ""
|
||||
@Published var breakpointText = ""
|
||||
@Published var editAddressText = ""
|
||||
@Published var editByteText = ""
|
||||
@Published var validationMessage: String?
|
||||
@Published private(set) var commandPending = false
|
||||
private var address: UInt16 = 0x8000
|
||||
@Published private(set) var highlightedByte: UInt32?
|
||||
private var memoryAddress: UInt16 = 0
|
||||
private var physicalAddress: UInt32 = 0
|
||||
private var readRequest: UUID?
|
||||
|
||||
init(machine: MachineModel) { self.machine = machine }
|
||||
|
||||
var paused: Bool { machine.state == .paused }
|
||||
var loaded: Bool { machine.state == .paused || machine.state == .running }
|
||||
var commandsAvailable: Bool { loaded && !machine.busy && !machine.diskSaving && !commandPending }
|
||||
var canEdit: Bool { commandsAvailable && paused }
|
||||
var breakpoints: [UInt16] { snapshot?.breakpoints.map { $0.uint16Value } ?? [] }
|
||||
var disabledBreakpoints: [UInt16] { snapshot?.disabledBreakpoints.map { $0.uint16Value } ?? [] }
|
||||
var allBreakpoints: [UInt16] { (breakpoints + disabledBreakpoints).sorted() }
|
||||
var programCounter: UInt16 { snapshot?.registers["PC"]?.uint16Value ?? 0 }
|
||||
var currentSourceLine: Int? { listing?.line(at: programCounter, preferring: selectedSourceLine) }
|
||||
var visibleSourceLine: Int? { sourceFollowPC ? currentSourceLine : selectedSourceLine }
|
||||
|
||||
func loadListing(_ url: URL) async {
|
||||
let request = UUID(); listingRequest = request; listingLoading = true; sourceMessage = nil
|
||||
let result = await Task.detached(priority: .userInitiated) { Result { try DebugSourceListing.read(url) } }.value
|
||||
guard listingRequest == request else { return }
|
||||
listingLoading = false
|
||||
switch result {
|
||||
case .success(let listing):
|
||||
self.listing = listing; selectedSourceLine = nil; sourceFollowPC = true; codePane = .source
|
||||
case .failure(let error): sourceMessage = error.localizedDescription
|
||||
}
|
||||
}
|
||||
|
||||
func unloadListing() {
|
||||
listingRequest = UUID(); listingLoading = false; listing = nil; selectedSourceLine = nil; sourceMessage = nil
|
||||
// Source breakpoints are the shared logical-address breakpoints. Closing
|
||||
// a document must not silently remove a user's execution controls.
|
||||
}
|
||||
|
||||
func selectSourceLine(_ index: Int) {
|
||||
guard listing?.lines.indices.contains(index) == true else { return }
|
||||
selectedSourceLine = index; sourceFollowPC = false; sourceMessage = nil
|
||||
}
|
||||
|
||||
func findSource() {
|
||||
guard let listing else { return }
|
||||
guard let index = listing.find(sourceSearch, after: selectedSourceLine) else {
|
||||
sourceMessage = sourceSearch.isEmpty ? "Enter text to find in the listing." : "No matching source line."; return
|
||||
}
|
||||
selectSourceLine(index)
|
||||
}
|
||||
|
||||
func showDisassembly(at address: UInt16) {
|
||||
addressText = Self.hex(address); goToAddress(); codePane = .disassembly
|
||||
}
|
||||
var physical: Bool { memorySpace == .physical }
|
||||
var memory: [UInt8] { snapshot.map { Array(physical ? $0.physicalMemory : $0.memory) } ?? [] }
|
||||
var memoryAvailable: [UInt8] { physical ? Array(repeating: 1, count: memory.count) : snapshot.map { Array($0.memoryAvailable) } ?? [] }
|
||||
var displayedMemoryAddress: UInt32 { snapshot.map { physical ? $0.physicalAddress : UInt32($0.memoryAddress) } ?? 0 }
|
||||
var installedRAM: UInt32 { snapshot?.mmu.ramByteCount ?? 0 }
|
||||
var memoryAddressWidth: Int { physical ? 6 : 4 }
|
||||
var canEditMemory: Bool { canEdit && !physical }
|
||||
var canPreviousMemory: Bool { (physical ? physicalAddress : UInt32(memoryAddress)) > 0 }
|
||||
var canNextMemory: Bool {
|
||||
physical ? physicalAddress + 256 < installedRAM : UInt32(memoryAddress) + 256 < 65536
|
||||
}
|
||||
func memoryLocation(offset: Int) -> UInt32 {
|
||||
let address = displayedMemoryAddress + UInt32(offset)
|
||||
return physical ? address : address & 0xffff
|
||||
}
|
||||
|
||||
// A leading $ or 0x is accepted; all debugger addresses and byte values
|
||||
// are explicitly hexadecimal. Reject overflow instead of truncating it.
|
||||
static func hexadecimal(_ text: String, maximum: UInt32 = 0xffff) -> UInt16? {
|
||||
guard let value = hexadecimalAddress(text, maximum: min(maximum, 0xffff)) else { return nil }
|
||||
return UInt16(value)
|
||||
}
|
||||
|
||||
static func hexadecimalAddress(_ text: String, maximum: UInt32) -> UInt32? {
|
||||
var value = text.trimmingCharacters(in: .whitespacesAndNewlines)
|
||||
if value.hasPrefix("$") { value.removeFirst() }
|
||||
else if value.lowercased().hasPrefix("0x") { value.removeFirst(2) }
|
||||
guard !value.isEmpty, value.allSatisfy({ $0.isASCII && $0.isHexDigit }),
|
||||
let parsed = UInt32(value, radix: 16), parsed <= maximum else { return nil }
|
||||
return parsed
|
||||
}
|
||||
|
||||
static func hex<T: BinaryInteger>(_ value: T, width: Int = 4) -> String {
|
||||
String(format: "%0*X", width, UInt32(truncatingIfNeeded: value))
|
||||
}
|
||||
|
||||
func poll() async {
|
||||
defer {
|
||||
// A queued immutable read can finish after the window disappears.
|
||||
// Discard that result, and permit a fresh capture on reopening.
|
||||
readRequest = nil
|
||||
commandPending = false
|
||||
}
|
||||
while !Task.isCancelled {
|
||||
refresh()
|
||||
do { try await Task.sleep(nanoseconds: 200_000_000) }
|
||||
catch { return }
|
||||
}
|
||||
}
|
||||
|
||||
func refresh() {
|
||||
guard !commandPending else { return }
|
||||
capture()
|
||||
}
|
||||
|
||||
private func capture(releasesCommand: Bool = false) {
|
||||
guard readRequest == nil, !machine.busy else {
|
||||
if releasesCommand { commandPending = false }
|
||||
return
|
||||
}
|
||||
let request = UUID()
|
||||
readRequest = request
|
||||
let requestedPhysicalAddress = physicalAddress
|
||||
let requestedPhysicalMemory = physical
|
||||
machine.readDebugger(address: address, followPC: followPC, memoryAddress: memoryAddress,
|
||||
physicalAddress: requestedPhysicalAddress, physicalMemory: requestedPhysicalMemory) { [weak self] capture in
|
||||
guard let self, self.readRequest == request else { return }
|
||||
self.readRequest = nil
|
||||
if releasesCommand { self.commandPending = false }
|
||||
guard let capture else { return }
|
||||
let registers = capture.registers
|
||||
if let previous = self.snapshot, previous.machine.generation == capture.machine.generation {
|
||||
let changes = Set(registers.compactMap { key, value in
|
||||
previous.registers[key] != value ? key : nil
|
||||
})
|
||||
// Preserve the last instruction's highlights while paused;
|
||||
// repeated inspection is not another instruction.
|
||||
if !changes.isEmpty { self.changedRegisters = changes }
|
||||
} else { self.changedRegisters = [] }
|
||||
self.snapshot = capture
|
||||
// The bridge clamps an old physical location after a RAM-size
|
||||
// change. Preserve an unfinished text draft; only explicit Go
|
||||
// normalizes it to the newly accepted location.
|
||||
if requestedPhysicalMemory && self.physicalAddress == requestedPhysicalAddress {
|
||||
self.physicalAddress = capture.physicalAddress
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private func perform(_ operation: (@escaping () -> Void) -> Void) {
|
||||
commandPending = true
|
||||
operation { [weak self] in
|
||||
guard let self else { return }
|
||||
// Do not accept a pre-command read or enable another breakpoint
|
||||
// mutation until its authoritative post-command list arrives.
|
||||
self.readRequest = nil
|
||||
self.capture(releasesCommand: true)
|
||||
}
|
||||
}
|
||||
|
||||
func toggleExecution() {
|
||||
guard commandsAvailable else { return }
|
||||
validationMessage = nil
|
||||
if machine.state == .running { perform(machine.debuggerPause) }
|
||||
else { perform(machine.debuggerContinue) }
|
||||
}
|
||||
|
||||
func step() {
|
||||
guard canEdit else { return }
|
||||
validationMessage = nil
|
||||
changedRegisters = []
|
||||
perform(machine.debuggerStep)
|
||||
}
|
||||
|
||||
func goToAddress() {
|
||||
guard let value = Self.hexadecimal(addressText) else {
|
||||
validationMessage = "Enter a hexadecimal address from 0000 to FFFF."; return
|
||||
}
|
||||
address = value; addressText = Self.hex(value); followPC = false
|
||||
validationMessage = nil; refresh()
|
||||
}
|
||||
|
||||
func setMemorySpace(_ space: MemorySpace) {
|
||||
highlightedByte = nil; memorySpace = space; validationMessage = nil; refresh()
|
||||
}
|
||||
|
||||
func showPhysicalMemory(at value: UInt32) {
|
||||
guard value < installedRAM else {
|
||||
validationMessage = "That physical address is outside installed RAM."; return
|
||||
}
|
||||
highlightedByte = nil
|
||||
physicalAddress = value & ~UInt32(15)
|
||||
physicalAddressText = Self.hex(physicalAddress, width: 6)
|
||||
memorySpace = .physical; memoryPane = .memory
|
||||
validationMessage = nil; refresh()
|
||||
}
|
||||
|
||||
func pageMemory(forward: Bool) {
|
||||
guard forward ? canNextMemory : canPreviousMemory else { return }
|
||||
if physical {
|
||||
showPhysicalMemory(at: forward ? physicalAddress + 256 : physicalAddress >= 256 ? physicalAddress - 256 : 0)
|
||||
} else {
|
||||
showMemory(at: forward ? memoryAddress + 256 : memoryAddress >= 256 ? memoryAddress - 256 : 0)
|
||||
}
|
||||
}
|
||||
|
||||
func showMemory(at value: UInt16) {
|
||||
memorySpace = .mapped; memoryPane = .memory
|
||||
highlightedByte = nil
|
||||
memoryAddress = value & 0xfff0
|
||||
memoryAddressText = Self.hex(memoryAddress)
|
||||
validationMessage = nil; refresh()
|
||||
}
|
||||
|
||||
func revealGraphicsByte(_ address: UInt32, physical: Bool) {
|
||||
if physical { showPhysicalMemory(at: address) }
|
||||
else if let logical = UInt16(exactly: address) { showMemory(at: logical) }
|
||||
highlightedByte = address
|
||||
}
|
||||
|
||||
func goToMemory() {
|
||||
if physical {
|
||||
guard installedRAM > 0, let value = Self.hexadecimalAddress(physicalAddressText, maximum: installedRAM - 1) else {
|
||||
validationMessage = "Enter a physical RAM address from 000000 to \(Self.hex(installedRAM > 0 ? installedRAM - 1 : 0, width: 6))."; return
|
||||
}
|
||||
showPhysicalMemory(at: value); return
|
||||
}
|
||||
guard let value = Self.hexadecimal(memoryAddressText) else {
|
||||
validationMessage = "Enter a hexadecimal memory address from 0000 to FFFF."; return
|
||||
}
|
||||
showMemory(at: value)
|
||||
}
|
||||
|
||||
func setPC() {
|
||||
guard canEdit else { return }
|
||||
guard let value = Self.hexadecimal(pcText) else {
|
||||
validationMessage = "Enter the new program counter in hexadecimal, from 0000 to FFFF."; return
|
||||
}
|
||||
setPC(to: value)
|
||||
}
|
||||
|
||||
func setPC(to value: UInt16) {
|
||||
guard canEdit else { return }
|
||||
validationMessage = nil; pcText = Self.hex(value)
|
||||
perform { machine.debuggerSetPC(value, completion: $0) }
|
||||
}
|
||||
|
||||
func addBreakpoint() {
|
||||
guard let value = Self.hexadecimal(breakpointText) else {
|
||||
validationMessage = "Enter a hexadecimal breakpoint address from 0000 to FFFF."; return
|
||||
}
|
||||
configureBreakpoints(Array(Set(breakpoints + [value])).sorted(), disabled: disabledBreakpoints.filter { $0 != value })
|
||||
}
|
||||
|
||||
func toggleBreakpoint(at value: UInt16) {
|
||||
if allBreakpoints.contains(value) {
|
||||
configureBreakpoints(breakpoints.filter { $0 != value }, disabled: disabledBreakpoints.filter { $0 != value })
|
||||
} else { configureBreakpoints((breakpoints + [value]).sorted(), disabled: disabledBreakpoints) }
|
||||
}
|
||||
|
||||
func setBreakpoint(_ value: UInt16, enabled: Bool) {
|
||||
guard allBreakpoints.contains(value) else { return }
|
||||
configureBreakpoints(enabled ? Array(Set(breakpoints + [value])).sorted() : breakpoints.filter { $0 != value },
|
||||
disabled: enabled ? disabledBreakpoints.filter { $0 != value } : Array(Set(disabledBreakpoints + [value])).sorted())
|
||||
}
|
||||
|
||||
func removeAllBreakpoints() { configureBreakpoints([], disabled: []) }
|
||||
|
||||
private func configureBreakpoints(_ addresses: [UInt16], disabled: [UInt16]) {
|
||||
guard commandsAvailable else { return }
|
||||
validationMessage = nil
|
||||
perform { machine.debuggerConfigureBreakpoints(addresses.map { NSNumber(value: $0) }, disabled: disabled.map { NSNumber(value: $0) }, completion: $0) }
|
||||
}
|
||||
|
||||
func selectByte(offset: Int) {
|
||||
guard !physical, let snapshot, offset >= 0, offset < memory.count, offset < memoryAvailable.count,
|
||||
memoryAvailable[offset] != 0 else { return }
|
||||
highlightedByte = memoryLocation(offset: offset)
|
||||
editAddressText = Self.hex(snapshot.memoryAddress &+ UInt16(offset))
|
||||
editByteText = Self.hex(UInt16(memory[offset]), width: 2)
|
||||
}
|
||||
|
||||
func writeByte() {
|
||||
guard canEditMemory else { return }
|
||||
guard let target = Self.hexadecimal(editAddressText),
|
||||
let byte = Self.hexadecimal(editByteText, maximum: 0xff) else {
|
||||
validationMessage = "Enter a hexadecimal address (0000–FFFF) and byte (00–FF)."; return
|
||||
}
|
||||
validationMessage = nil
|
||||
perform { machine.debuggerWriteMemory(address: target, data: Data([UInt8(byte)]), completion: $0) }
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user