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,660 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
import AppKit
|
||||
import SwiftUI
|
||||
|
||||
@MainActor
|
||||
final class AssemblyDevelopmentModel: ObservableObject {
|
||||
struct SourceLine: Hashable, Codable, Sendable {
|
||||
let path: String
|
||||
let line: Int
|
||||
}
|
||||
struct Selection { let id = UUID(); let buffer: UUID; let range: NSRange }
|
||||
enum Action { case assemble, run, debug, exportBinary(URL), exportDisk(URL, String, dosBoot: Bool) }
|
||||
struct Attachment {
|
||||
let document: UUID
|
||||
let artifact: AssemblyBuildArtifact
|
||||
var expected: VCCMachineSnapshot
|
||||
var guards: [UInt16: Data]
|
||||
}
|
||||
|
||||
let machine: MachineModel
|
||||
let service: AssemblyBuildService
|
||||
private(set) var recoveryURL: URL
|
||||
private let recoveryQueue = DispatchQueue(label: "VCCPlus.AssemblyRecovery")
|
||||
private var recoveryTask: Task<Void, Never>?
|
||||
@Published private(set) var documents: [AssemblyWorkspaceDocument]
|
||||
@Published private(set) var activeID: UUID
|
||||
@Published private(set) var artifact: AssemblyBuildArtifact?
|
||||
@Published private(set) var diagnostics: [AssemblyDiagnostic] = []
|
||||
@Published var message = "Ready to assemble."
|
||||
@Published var buildLog = ""
|
||||
@Published private(set) var working = false
|
||||
@Published private(set) var cursor = 0
|
||||
@Published private(set) var selection: Selection?
|
||||
@Published private(set) var executionLine: SourceLine?
|
||||
@Published private(set) var execution = ""
|
||||
@Published private(set) var commanding = false
|
||||
@Published private(set) var attached = false
|
||||
@Published private(set) var paused = false
|
||||
@Published private(set) var displayRequest = 0
|
||||
private var cursors: [UUID: Int] = [:]
|
||||
private var fileRequest = UUID()
|
||||
private var work: Task<Void, Never>?
|
||||
private var revision = UUID()
|
||||
var workspaceRevision: UUID { revision }
|
||||
@Published private(set) var sourceRevision = UUID()
|
||||
private var connection: Attachment?
|
||||
// Remember ownership across source edits so a repeat Run can replace our own bytes immediately.
|
||||
private var owner: (document: UUID, generation: UInt64, revision: UInt64)?
|
||||
private var reading = false
|
||||
private var checking = false
|
||||
private var nextCheck = Date.distantPast
|
||||
private var index: Int { documents.firstIndex { $0.id == activeID }! }
|
||||
var document: AssemblyWorkspaceDocument { documents[index] }
|
||||
var buffer: AssemblyBuffer { document.buffers.first { $0.path == document.selectedPath }! }
|
||||
var cpu: AssemblyCPU { document.cpu }
|
||||
|
||||
init(machine: MachineModel, service: AssemblyBuildService = .init(), recoveryURL: URL? = nil) {
|
||||
self.machine = machine; self.service = service
|
||||
self.recoveryURL = recoveryURL ?? machine.developmentRunDirectory.deletingLastPathComponent().appendingPathComponent("Assembly Workspace/Drafts.json")
|
||||
let first = AssemblyWorkspaceDocument.example(title: AssemblyWorkspaceDocument.starterTitle, source: AssemblyWorkspaceDocument.starterSource, cpu: .mc6809)
|
||||
documents = [first]; activeID = first.id
|
||||
while FileManager.default.fileExists(atPath: self.recoveryURL.path) {
|
||||
do {
|
||||
let saved = try AssemblyRecovery.read(from: self.recoveryURL)
|
||||
documents = saved.documents; activeID = saved.active
|
||||
message = "Restored assembly workspace."
|
||||
break
|
||||
} catch {
|
||||
// Preserve an unreadable record at its original location. New sessions
|
||||
// use a neighboring recovery file that is discovered on the next launch.
|
||||
self.recoveryURL = self.recoveryURL.deletingPathExtension().appendingPathExtension("recovered.json")
|
||||
message = "The previous Assembly draft file could not be read. It has been preserved separately."
|
||||
}
|
||||
}
|
||||
indexLabels()
|
||||
}
|
||||
|
||||
static func lineRange(_ line: Int, text: String) -> NSRange? {
|
||||
guard line > 0 else { return nil }
|
||||
let ns = text as NSString
|
||||
var start = 0
|
||||
for _ in 1..<line {
|
||||
guard start < ns.length else { return nil }
|
||||
start = NSMaxRange(ns.lineRange(for: NSRange(location: start, length: 0)))
|
||||
}
|
||||
return ns.lineRange(for: NSRange(location: start, length: 0))
|
||||
}
|
||||
var cursorLine: Int {
|
||||
(buffer.text as NSString).substring(to: min(cursor, buffer.text.utf16.count)).components(separatedBy: "\n").count
|
||||
}
|
||||
func moveCursor(_ offset: Int) {
|
||||
let next = min(max(offset, 0), buffer.text.utf16.count)
|
||||
cursors[buffer.id] = next
|
||||
if cursor != next { cursor = next }
|
||||
}
|
||||
|
||||
func select(_ id: UUID) {
|
||||
guard id != activeID, documents.contains(where: { $0.id == id }) else { return }
|
||||
cancelPending()
|
||||
activeID = id; restoreCursor()
|
||||
artifact = connection?.document == id ? connection?.artifact : nil
|
||||
diagnostics = []; buildLog = artifact?.buildLog ?? ""
|
||||
executionLine = nil; execution = ""; attached = connection?.document == id; paused = false
|
||||
message = "Ready to assemble."; labelLocations = []; indexLabels(); scheduleRecovery(); refresh()
|
||||
}
|
||||
|
||||
func openExample(title: String, source: String, target6309: Bool) {
|
||||
append(.example(title: title, source: source, cpu: target6309 ? .hd6309 : .mc6809))
|
||||
}
|
||||
private func append(_ doc: AssemblyWorkspaceDocument) { documents.append(doc); select(doc.id) }
|
||||
func open(_ url: URL, folder: Bool) {
|
||||
Task {
|
||||
do {
|
||||
let doc = try await Task.detached { try AssemblyWorkspaceDocument.open(url, folder: folder) }.value
|
||||
if let existing = documents.first(where: { $0.directory == doc.directory && $0.mainPath == doc.mainPath && $0.isProject == doc.isProject }) {
|
||||
select(existing.id)
|
||||
} else { append(doc) }
|
||||
} catch { message = error.localizedDescription }
|
||||
}
|
||||
}
|
||||
func closeDocument() {
|
||||
let doc = document
|
||||
if doc.buffers.contains(where: \.dirty) {
|
||||
let alert = NSAlert()
|
||||
alert.messageText = "Discard edits to \(doc.title)?"
|
||||
alert.informativeText = "Closing removes this document and its recoverable drafts."
|
||||
alert.addButton(withTitle: "Cancel"); alert.addButton(withTitle: "Discard and Close")
|
||||
guard alert.runModal() == .alertSecondButtonReturn else { return }
|
||||
}
|
||||
if documents.count == 1 { openExample(title: "Untitled", source: "", target6309: false) }
|
||||
else if let next = documents.first(where: { $0.id != doc.id }) { select(next.id) }
|
||||
documents.removeAll { $0.id == doc.id }
|
||||
if let conn = connection, conn.document == doc.id { machine.clearAssembly(expected: conn.expected); connection = nil }
|
||||
scheduleRecovery()
|
||||
}
|
||||
|
||||
func edit(_ text: String) {
|
||||
guard !text.utf8.elementsEqual(buffer.text.utf8), let i = document.buffers.firstIndex(where: { $0.path == document.selectedPath }) else { return }
|
||||
let path = buffer.path, original = buffer.text
|
||||
let count = document.breakpoints.count
|
||||
documents[index].breakpoints = document.breakpoints.filter { stop in
|
||||
guard stop.path == path else { return true }
|
||||
guard let before = Self.lineRange(stop.line, text: original), let after = Self.lineRange(stop.line, text: text) else { return false }
|
||||
return (original as NSString).substring(with: before) == (text as NSString).substring(with: after)
|
||||
}
|
||||
documents[index].buffers[i].text = text
|
||||
sourceRevision = UUID()
|
||||
let removed = count - document.breakpoints.count
|
||||
let note: String
|
||||
switch removed {
|
||||
case 0: note = ""
|
||||
case 1: note = " Removed one source stop on an edited line."
|
||||
default: note = " Removed \(removed) source stops on edited lines."
|
||||
}
|
||||
invalidate("Source changed. Assemble to refresh the listing and source stops." + note)
|
||||
scheduleRecovery()
|
||||
}
|
||||
/// Commit every reviewed buffer to the same draft generation. Disk writes remain explicit Save actions.
|
||||
func replaceReviewedFiles(_ edits: [AssemblyProjectEdit], snapshot: AssemblyProjectSnapshot,
|
||||
undo: Bool = false, restoreStops: Set<SourceLine> = []) throws -> Set<SourceLine> {
|
||||
guard !working, !commanding, !edits.isEmpty else { throw AssemblyBuildFailure("workspace_busy") }
|
||||
var updated = document
|
||||
let originalStops = updated.breakpoints
|
||||
for edit in edits {
|
||||
let before = undo ? edit.after : edit.before
|
||||
let after = undo ? edit.before : edit.after
|
||||
guard snapshot.files[edit.path] == Data(before.utf8) else { throw AssemblyBuildFailure("revision_conflict") }
|
||||
if let index = updated.buffers.firstIndex(where: { $0.path == edit.path }) {
|
||||
guard updated.buffers[index].text.utf8.elementsEqual(before.utf8) else { throw AssemblyBuildFailure("revision_conflict") }
|
||||
updated.buffers[index].text = after
|
||||
} else {
|
||||
// An unopened file in the live snapshot has no draft overlay.
|
||||
guard !undo else { throw AssemblyBuildFailure("revision_conflict") }
|
||||
updated.buffers.append(.init(path: edit.path, text: after, saved: before))
|
||||
}
|
||||
updated.breakpoints = updated.breakpoints.filter { stop in
|
||||
guard stop.path == edit.path else { return true }
|
||||
guard let a = Self.lineRange(stop.line, text: before), let b = Self.lineRange(stop.line, text: after) else { return false }
|
||||
return (before as NSString).substring(with: a).utf8.elementsEqual((after as NSString).substring(with: b).utf8)
|
||||
}
|
||||
}
|
||||
updated.breakpoints.formUnion(restoreStops)
|
||||
documents[index] = updated
|
||||
fileRequest = UUID()
|
||||
sourceRevision = UUID()
|
||||
restoreCursor()
|
||||
invalidate("Source changed. Assemble the reviewed project revision.")
|
||||
scheduleRecovery()
|
||||
return originalStops.subtracting(updated.breakpoints)
|
||||
}
|
||||
|
||||
func setCPU(_ target: AssemblyCPU) {
|
||||
guard cpu != target else { return }
|
||||
documents[index].cpu = target
|
||||
sourceRevision = UUID()
|
||||
invalidate("Build target changed. Assemble to refresh the listing and source stops.")
|
||||
scheduleRecovery()
|
||||
}
|
||||
private func cancelPending() {
|
||||
revision = UUID(); work?.cancel(); work = nil; working = false
|
||||
}
|
||||
func cancelBuild() { invalidate("Assembly cancelled.") }
|
||||
private func invalidate(_ reason: String) {
|
||||
cancelPending(); artifact = nil; diagnostics = []
|
||||
if let conn = connection, conn.document == activeID {
|
||||
machine.clearAssembly(expected: conn.expected); connection = nil
|
||||
}
|
||||
attached = false; paused = false; execution = ""; executionLine = nil; message = reason; indexLabels()
|
||||
}
|
||||
|
||||
func selectFile(_ path: String, line: Int? = nil) {
|
||||
let doc = document, request = UUID()
|
||||
fileRequest = request
|
||||
if doc.buffers.contains(where: { $0.path == path }) { displayFile(path, line: line); return }
|
||||
Task {
|
||||
do {
|
||||
let text = try await Task.detached {
|
||||
try CMOCProject.readText(doc.checkedURL(path), maximumBytes: CMOCProject.maximumSourceBytes)
|
||||
}.value
|
||||
guard activeID == doc.id, fileRequest == request else { return }
|
||||
if !document.buffers.contains(where: { $0.path == path }) {
|
||||
documents[index].buffers.append(.init(path: path, text: text, saved: text)); indexLabels()
|
||||
}
|
||||
displayFile(path, line: line)
|
||||
} catch { message = error.localizedDescription }
|
||||
}
|
||||
}
|
||||
private func displayFile(_ path: String, line: Int?) {
|
||||
if document.selectedPath != path {
|
||||
documents[index].selectedPath = path; restoreCursor()
|
||||
}
|
||||
if let line, let range = Self.lineRange(line, text: buffer.text) {
|
||||
moveCursor(range.location)
|
||||
selection = .init(buffer: buffer.id, range: range)
|
||||
}
|
||||
scheduleRecovery()
|
||||
}
|
||||
private func restoreCursor() {
|
||||
cursor = min(cursors[buffer.id] ?? 0, buffer.text.utf16.count)
|
||||
selection = .init(buffer: buffer.id, range: NSRange(location: cursor, length: 0))
|
||||
}
|
||||
func editSettings() {
|
||||
guard document.isProject else { return }
|
||||
let path = AssemblyProjectSnapshot.configurationFilename
|
||||
if document.paths.contains(path) || document.buffers.contains(where: { $0.path == path }) { selectFile(path); return }
|
||||
let text = "{\n \"main\": \"main.asm\"\n}\n"
|
||||
documents[index].buffers.append(.init(path: path, text: text, saved: nil))
|
||||
documents[index].paths.append(path)
|
||||
sourceRevision = UUID()
|
||||
displayFile(path, line: nil); invalidate("Edit project settings, then assemble to validate them.")
|
||||
}
|
||||
func reload() {
|
||||
let doc = document, file = buffer
|
||||
if file.dirty {
|
||||
let alert = NSAlert(); alert.messageText = "Replace edits with the saved \(file.path)?"
|
||||
alert.addButton(withTitle: "Cancel"); alert.addButton(withTitle: "Reload")
|
||||
guard alert.runModal() == .alertSecondButtonReturn else { return }
|
||||
}
|
||||
Task {
|
||||
do {
|
||||
let text = try await Task.detached { try CMOCProject.readText(doc.checkedURL(file.path), maximumBytes: CMOCProject.maximumSourceBytes) }.value
|
||||
guard activeID == doc.id, buffer.id == file.id, buffer.text == file.text,
|
||||
let i = document.buffers.firstIndex(where: { $0.id == file.id }) else { return }
|
||||
documents[index].buffers[i] = .init(path: file.path, text: text, saved: text)
|
||||
sourceRevision = UUID()
|
||||
invalidate("Reloaded \(file.path)."); scheduleRecovery()
|
||||
} catch { message = error.localizedDescription }
|
||||
}
|
||||
}
|
||||
private var protectedSourceURLs: [URL] {
|
||||
var urls = [recoveryURL]
|
||||
for doc in documents {
|
||||
guard let root = doc.directory else { continue }
|
||||
let paths = Set(doc.inputPaths ?? doc.paths).union(doc.buffers.map(\.path))
|
||||
urls += paths.map { root.appendingPathComponent($0) }
|
||||
}
|
||||
return urls
|
||||
}
|
||||
|
||||
func save(to copy: URL? = nil) {
|
||||
let doc = document, file = buffer
|
||||
Task {
|
||||
do {
|
||||
let url = try copy ?? doc.checkedURL(file.path)
|
||||
var protected = protectedSourceURLs
|
||||
var expected: Data?
|
||||
if copy == nil {
|
||||
// Only Save Source may replace the selected source file.
|
||||
protected.removeAll { $0.standardizedFileURL == url.standardizedFileURL }
|
||||
expected = file.saved.map { Data($0.utf8) }
|
||||
if expected == nil, FileManager.default.fileExists(atPath: url.path) {
|
||||
throw AssemblyBuildFailure("The source appeared on disk. Reload it or Save a Copy.")
|
||||
}
|
||||
}
|
||||
try await machine.writeDevelopmentFile(Data(file.text.utf8), to: url, protecting: protected,
|
||||
allowEmpty: true, replacing: expected)
|
||||
guard let d = documents.firstIndex(where: { $0.id == doc.id }),
|
||||
let i = documents[d].buffers.firstIndex(where: { $0.id == file.id }) else { return }
|
||||
if doc.directory == nil {
|
||||
documents[d].directory = try CMOCProject.physicalURL(url.deletingLastPathComponent())
|
||||
documents[d].mainPath = url.lastPathComponent; documents[d].selectedPath = url.lastPathComponent
|
||||
documents[d].buffers[i].path = url.lastPathComponent; documents[d].title = url.lastPathComponent
|
||||
documents[d].breakpoints.removeAll()
|
||||
if activeID == doc.id { invalidate("Source saved.") }
|
||||
}
|
||||
if doc.directory == nil || copy == nil { documents[d].buffers[i].saved = file.text }
|
||||
message = "Saved \(url.lastPathComponent)."; scheduleRecovery()
|
||||
} catch { message = error.localizedDescription }
|
||||
}
|
||||
}
|
||||
|
||||
@Published private(set) var labelLocations: [(String, SourceLine)] = []
|
||||
private var labelTask: Task<Void, Never>?
|
||||
private func indexLabels() {
|
||||
labelTask?.cancel()
|
||||
let doc = document, snapshot = artifact?.snapshot
|
||||
labelTask = Task {
|
||||
do { try await Task.sleep(nanoseconds: 120_000_000) } catch { return }
|
||||
let result = await Task.detached(priority: .utility) {
|
||||
let words = AssemblyReference.shared.vocabulary(target6309: doc.cpu == .hd6309)
|
||||
var sources = [String: String]()
|
||||
for (path, bytes) in snapshot?.files ?? [:] {
|
||||
let ext = URL(fileURLWithPath: path).pathExtension.lowercased()
|
||||
if ["asm", "s", "lwasm", "inc"].contains(ext) { sources[path] = String(data: bytes, encoding: .utf8) }
|
||||
}
|
||||
for file in doc.buffers where file.path == doc.mainPath || ["asm", "s", "lwasm", "inc"].contains(URL(fileURLWithPath: file.path).pathExtension.lowercased()) {
|
||||
sources[file.path] = file.text
|
||||
}
|
||||
return sources.flatMap { path, text in
|
||||
AssemblyEditorSyntax.labels(in: text, vocabulary: words).map { ($0.0, SourceLine(path: path, line: $0.1)) }
|
||||
}.sorted { ($0.0, $0.1.path, $0.1.line) < ($1.0, $1.1.path, $1.1.line) }
|
||||
}.value
|
||||
if !Task.isCancelled, activeID == doc.id { labelLocations = result }
|
||||
}
|
||||
}
|
||||
func goToDefinition() {
|
||||
let words = AssemblyReference.shared.vocabulary(target6309: cpu == .hd6309)
|
||||
guard let term = AssemblyEditorSyntax.token(in: buffer.text, offset: cursor, vocabulary: words) else {
|
||||
message = "Place the caret on a label."; return
|
||||
}
|
||||
let matches = labelLocations.filter { $0.0 == term }
|
||||
guard matches.count == 1, let match = matches.first else {
|
||||
message = matches.isEmpty ? "No label definition found for \(term)." : "Multiple definitions for \(term). Choose a location in Labels."
|
||||
return
|
||||
}
|
||||
selectFile(match.1.path, line: match.1.line)
|
||||
}
|
||||
|
||||
private func scheduleRecovery() {
|
||||
recoveryTask?.cancel()
|
||||
recoveryTask = Task {
|
||||
do { try await Task.sleep(nanoseconds: 350_000_000) } catch { return }
|
||||
let state = AssemblyRecovery(documents: documents, active: activeID), url = recoveryURL
|
||||
recoveryQueue.async {
|
||||
do { try state.write(to: url) }
|
||||
catch { Task { @MainActor in self.message = "Could not preserve assembly drafts: " + error.localizedDescription } }
|
||||
}
|
||||
}
|
||||
}
|
||||
func prepareToQuit() -> Bool {
|
||||
cancelPending(); recoveryTask?.cancel()
|
||||
let state = AssemblyRecovery(documents: documents, active: activeID)
|
||||
do { try recoveryQueue.sync { try state.write(to: recoveryURL) }; return true }
|
||||
catch {
|
||||
message = "Could not preserve assembly drafts: " + error.localizedDescription
|
||||
let alert = NSAlert(); alert.messageText = "Could not save Assembly drafts"; alert.informativeText = message
|
||||
alert.runModal(); return false
|
||||
}
|
||||
}
|
||||
|
||||
static func codeGuards(_ instructions: [AssemblyInstructionLocation]) -> [UInt16: Data] {
|
||||
Dictionary(grouping: instructions, by: \.address).compactMapValues { candidates in
|
||||
guard candidates.count == 1, let first = candidates.first, !first.bytes.isEmpty else { return nil }
|
||||
return Data(first.bytes)
|
||||
}
|
||||
}
|
||||
static func location(_ stop: SourceLine, in artifact: AssemblyBuildArtifact) -> AssemblyInstructionLocation? {
|
||||
let candidates = artifact.instructions.filter { $0.path == stop.path && $0.line == stop.line }
|
||||
guard candidates.count == 1, let candidate = candidates.first,
|
||||
artifact.instructions.filter({ $0.address == candidate.address }).count == 1 else { return nil }
|
||||
return candidate
|
||||
}
|
||||
func toggleBreakpoint() {
|
||||
guard !commanding else { return }
|
||||
let stop = SourceLine(path: buffer.path, line: cursorLine)
|
||||
if document.breakpoints.contains(stop) { documents[index].breakpoints.remove(stop) }
|
||||
else {
|
||||
guard let artifact, Self.location(stop, in: artifact) != nil else {
|
||||
message = "Assemble first and choose a line with one verified instruction. Use the listing for ambiguous or data lines."; return
|
||||
}
|
||||
documents[index].breakpoints.insert(stop)
|
||||
}
|
||||
applyStops()
|
||||
}
|
||||
func clearStops() {
|
||||
guard !commanding else { return }
|
||||
documents[index].breakpoints.removeAll(); applyStops()
|
||||
}
|
||||
private func applyStops() {
|
||||
scheduleRecovery()
|
||||
guard let conn = connection, conn.document == activeID else { return }
|
||||
let points = document.breakpoints.compactMap { Self.location($0, in: conn.artifact)?.address }
|
||||
validateForControl(conn) {
|
||||
self.machine.updateAssembly(breakpoints: points, guards: conn.guards, expected: conn.expected) { snapshot in
|
||||
self.finishCommand(snapshot, connection: conn)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func perform(_ action: Action) {
|
||||
guard !commanding, !working else { return }
|
||||
let doc = document, request = UUID(), previous = artifact
|
||||
revision = request; working = true; diagnostics = []; message = "Preparing assembly inputs…"
|
||||
work = Task {
|
||||
defer { if revision == request { working = false; work = nil } }
|
||||
do {
|
||||
let snapshot = try await Task.detached { try doc.snapshot() }.value
|
||||
try check(request, doc.id)
|
||||
documents[index].inputPaths = Array(snapshot.files.keys)
|
||||
let result: AssemblyBuildArtifact
|
||||
if let previous, previous.snapshot == snapshot { result = previous }
|
||||
else {
|
||||
if let makefile = snapshot.settings.makefile {
|
||||
let alert = NSAlert(); alert.messageText = "Run this project’s Makefile?"
|
||||
alert.informativeText = "\(doc.title) will execute \(makefile), target \(snapshot.settings.target ?? "all"), with your account’s permissions. ASFLAGS supplies the selected CPU target. The recipe controls the resulting binary. Without a verified source map, use the machine debugger."
|
||||
alert.addButton(withTitle: "Cancel"); alert.addButton(withTitle: "Run Make")
|
||||
guard alert.runModal() == .alertSecondButtonReturn else { throw CancellationError() }
|
||||
}
|
||||
message = "Assembling for the \(cpu.rawValue)…"
|
||||
result = try await service.build(snapshot)
|
||||
try check(request, doc.id)
|
||||
if doc.directory != nil {
|
||||
guard try await Task.detached(operation: { try doc.snapshot() }).value == snapshot else {
|
||||
throw AssemblyBuildFailure("Assembly inputs changed during the build. Assemble again.")
|
||||
}
|
||||
}
|
||||
}
|
||||
try check(request, doc.id)
|
||||
artifact = result; buildLog = result.buildLog; documents[index].paths = AssemblyWorkspaceDocument.editablePaths(snapshot)
|
||||
indexLabels(); message = "Assembled · " + Self.summary(result)
|
||||
switch action {
|
||||
case .assemble: break
|
||||
case .run, .debug:
|
||||
let debug: Bool
|
||||
if case .debug = action { debug = true } else { debug = false }
|
||||
try await launch(result, doc: doc, request: request, debug: debug)
|
||||
case .exportBinary(let url): try await write(result.binaryData, url: url, request: request, doc: doc.id)
|
||||
case .exportDisk(let url, let name, let dosBoot):
|
||||
let disk = try await service.diskImage(for: result, name: name, dosBoot: dosBoot)
|
||||
try check(request, doc.id)
|
||||
if doc.directory != nil, try await Task.detached(operation: { try doc.snapshot() }).value != snapshot {
|
||||
throw AssemblyBuildFailure("Project inputs changed during disk export. Assemble again.")
|
||||
}
|
||||
try await write(disk, url: url, request: request, doc: doc.id)
|
||||
}
|
||||
} catch {
|
||||
guard revision == request else { return }
|
||||
let failure = (error as? AssemblyBuildFailure)?.diagnostics ?? []
|
||||
let reason = error is CancellationError ? "Assembly cancelled." : error.localizedDescription
|
||||
invalidate(reason); buildLog = reason; diagnostics = failure
|
||||
}
|
||||
}
|
||||
}
|
||||
private func check(_ request: UUID, _ doc: UUID) throws {
|
||||
try Task.checkCancellation()
|
||||
guard revision == request && activeID == doc else { throw CancellationError() }
|
||||
}
|
||||
private func write(_ data: Data, url: URL, request: UUID, doc: UUID) async throws {
|
||||
try check(request, doc)
|
||||
do {
|
||||
try await machine.writeDevelopmentFile(data, to: url, protecting: protectedSourceURLs)
|
||||
} catch {
|
||||
if revision == request { message = error.localizedDescription }
|
||||
return
|
||||
}
|
||||
try check(request, doc); message = "Exported \(url.lastPathComponent)."
|
||||
}
|
||||
static func summary(_ artifact: AssemblyBuildArtifact) -> String {
|
||||
let ranges = artifact.ranges.map { String(format: "$%04X–$%04X", $0.lowerBound, $0.upperBound) }.joined(separator: ", ")
|
||||
return "Load " + ranges + String(format: " · Entry $%04X", artifact.entry)
|
||||
}
|
||||
func acceptSharedBuild(_ build: AssemblyBuildArtifact) {
|
||||
artifact = build; diagnostics = []; buildLog = build.buildLog
|
||||
message = "Assembled · " + Self.summary(build)
|
||||
indexLabels()
|
||||
}
|
||||
|
||||
func launchShared(_ build: AssemblyBuildArtifact, stillGranted: @escaping () -> Bool,
|
||||
confirm: ((String) -> Bool)? = nil) async throws -> VCCMachineSnapshot {
|
||||
guard !working, !commanding, artifact?.id == build.id, stillGranted() else {
|
||||
throw AssemblyBuildFailure("The shared build is no longer current.")
|
||||
}
|
||||
working = true
|
||||
let request = revision, priorProgram = machine.assemblyProgramRevision
|
||||
defer { if revision == request { working = false } }
|
||||
try await launch(build, doc: document, request: request, debug: false, stillGranted: stillGranted, confirm: confirm)
|
||||
guard let connection, connection.artifact.id == build.id, connection.expected.debuggerProgramRevision != priorProgram, stillGranted() else { throw AssemblyBuildFailure(message) }
|
||||
return connection.expected
|
||||
}
|
||||
|
||||
private func launch(_ artifact: AssemblyBuildArtifact, doc: AssemblyWorkspaceDocument, request: UUID, debug: Bool, stillGranted: (() -> Bool)? = nil, confirm: ((String) -> Bool)? = nil) async throws {
|
||||
let generation = machine.basicDebug.generation, program = machine.assemblyProgramRevision
|
||||
let mapping = machine.assemblyMappingFingerprint
|
||||
let sameOwner = owner?.document == doc.id && owner?.generation == generation && owner?.revision == program
|
||||
guard machine.state == .paused || machine.state == .running else {
|
||||
message = "Start a Disk BASIC, Hard Drive BASIC or CoCoSDC machine before running. The build is ready for export."; return
|
||||
}
|
||||
if let confirm, !sameOwner {
|
||||
guard confirm(Self.summary(artifact)) else { throw CancellationError() }
|
||||
} else if !sameOwner {
|
||||
let alert = NSAlert(); alert.messageText = "Load this assembly program into the CoCo?"
|
||||
alert.informativeText = Self.summary(artifact) + "\n\nLoading replaces guest program memory and takes over any active development session. Save any BASIC program or variables you want to keep."
|
||||
if stillGranted != nil {
|
||||
alert.informativeText += "\n\nWhile this program runs, the connected assistant can read the CoCo text screen and send up to 64 individual letters, digits or spaces. Its run receipt can include the last text screen when the program returns to BASIC."
|
||||
}
|
||||
alert.addButton(withTitle: "Cancel"); alert.addButton(withTitle: debug ? "Debug from Entry" : "Run")
|
||||
guard alert.runModal() == .alertSecondButtonReturn else { message = "Launch cancelled. The build is ready."; return }
|
||||
}
|
||||
try check(request, doc.id)
|
||||
if doc.directory != nil, try await Task.detached(operation: { try doc.snapshot() }).value != artifact.snapshot {
|
||||
throw AssemblyBuildFailure("Inputs changed before launch. Assemble again.")
|
||||
}
|
||||
try check(request, doc.id)
|
||||
guard stillGranted?() != false else { throw CancellationError() }
|
||||
let points = doc.breakpoints.compactMap { Self.location($0, in: artifact)?.address }
|
||||
guard points.count == doc.breakpoints.count else {
|
||||
message = "An armed line no longer has one executable instruction. Remove that source stop before launching."; return
|
||||
}
|
||||
let guards = Self.codeGuards(artifact.instructions)
|
||||
commanding = true
|
||||
let result: VCCMachineSnapshot? = await withCheckedContinuation { continuation in
|
||||
machine.launchAssembly(artifact.binaryData, breakpoints: points, guards: guards, pauseAtEntry: debug,
|
||||
requires6309: doc.cpu == .hd6309, expectedGeneration: generation, expectedRevision: program, expectedMapping: mapping, shared: stillGranted != nil) {
|
||||
continuation.resume(returning: $0)
|
||||
}
|
||||
}
|
||||
commanding = false
|
||||
guard let result, result.errorMessage == nil else {
|
||||
if revision == request { message = result?.errorMessage ?? machine.fileError ?? "The CoCo is busy or unavailable." }; return
|
||||
}
|
||||
owner = (doc.id, result.generation, result.debuggerProgramRevision)
|
||||
guard revision == request, activeID == doc.id else { machine.clearAssembly(expected: result); return }
|
||||
connection = .init(document: doc.id, artifact: artifact, expected: result, guards: guards)
|
||||
attached = true; paused = result.state == .paused
|
||||
message = "Loaded · " + Self.summary(artifact)
|
||||
if !debug { displayRequest += 1 }
|
||||
refresh()
|
||||
}
|
||||
|
||||
func pause() {
|
||||
guard attached, !commanding, let conn = connection, conn.document == activeID else { return }
|
||||
commanding = true
|
||||
machine.pauseAssembly(expected: conn.expected) { snapshot in
|
||||
self.finishCommand(snapshot, connection: conn)
|
||||
}
|
||||
}
|
||||
func control(step: Bool) {
|
||||
guard paused, let conn = connection, conn.document == activeID, !commanding else { return }
|
||||
validateForControl(conn) {
|
||||
self.machine.controlAssembly(step: step, expected: conn.expected) { snapshot in
|
||||
self.finishCommand(snapshot, connection: conn)
|
||||
}
|
||||
}
|
||||
}
|
||||
private func validateForControl(_ conn: Attachment, command: @escaping @MainActor () -> Void) {
|
||||
let doc = document, request = revision
|
||||
commanding = true
|
||||
Task {
|
||||
do {
|
||||
let inputs = try await Task.detached { try doc.snapshot() }.value
|
||||
guard request == revision, activeID == doc.id, connection?.artifact.id == conn.artifact.id else { commanding = false; return }
|
||||
guard inputs == conn.artifact.snapshot else { throw AssemblyBuildFailure("Project inputs changed. Run again to reconnect source debugging.") }
|
||||
command()
|
||||
} catch {
|
||||
commanding = false
|
||||
if revision == request { invalidate(error.localizedDescription) }
|
||||
}
|
||||
}
|
||||
}
|
||||
private func finishCommand(_ snapshot: VCCMachineSnapshot?, connection conn: Attachment) {
|
||||
commanding = false
|
||||
guard connection?.artifact.id == conn.artifact.id else { return }
|
||||
guard let snapshot, snapshot.errorMessage == nil else {
|
||||
invalidate(snapshot?.errorMessage ?? machine.fileError ?? "The machine changed. Run again to reconnect.")
|
||||
return
|
||||
}
|
||||
connection?.expected = snapshot
|
||||
paused = snapshot.state == .paused; refresh()
|
||||
}
|
||||
|
||||
func refresh() {
|
||||
if let build = artifact, document.directory != nil, !checking, !working, !commanding, Date() >= nextCheck {
|
||||
nextCheck = Date().addingTimeInterval(2); checking = true
|
||||
let doc = document, request = revision
|
||||
Task {
|
||||
let copy = await Task.detached { try? doc.snapshot() }.value
|
||||
checking = false
|
||||
if revision == request, activeID == doc.id, artifact?.id == build.id, copy != build.snapshot {
|
||||
invalidate("A project input changed on disk. Reload any open changed file and assemble again.")
|
||||
}
|
||||
}
|
||||
}
|
||||
guard let conn = connection, conn.document == activeID, !reading, !commanding else { return }
|
||||
if machine.state == .running {
|
||||
guard machine.assemblyAttached, machine.basicDebug.generation == conn.expected.generation,
|
||||
machine.assemblyProgramRevision == conn.expected.debuggerProgramRevision,
|
||||
machine.assemblyMappingFingerprint == conn.expected.debuggerMappingFingerprint else {
|
||||
invalidate("The running program or memory mapping changed. Run again to reconnect."); return
|
||||
}
|
||||
if paused { paused = false }
|
||||
if executionLine != nil { executionLine = nil }
|
||||
if execution != "Running" { execution = "Running" }
|
||||
return
|
||||
}
|
||||
reading = true
|
||||
machine.readDebugger(address: 0, followPC: true, memoryAddress: 0x0400) { [weak self] capture in
|
||||
guard let self else { return }; reading = false
|
||||
guard connection?.artifact.id == conn.artifact.id, activeID == conn.document, let capture else { return }
|
||||
let snapshot = capture.machine
|
||||
guard snapshot.generation == conn.expected.generation, snapshot.debuggerProgramRevision == conn.expected.debuggerProgramRevision,
|
||||
snapshot.debuggerMappingFingerprint == conn.expected.debuggerMappingFingerprint,
|
||||
snapshot.debuggerAssemblyAttached else {
|
||||
invalidate("Machine program or memory mapping changed. Run again to reconnect source debugging."); return
|
||||
}
|
||||
connection?.expected = snapshot
|
||||
let stopped = snapshot.state == .paused
|
||||
if paused != stopped { paused = stopped }
|
||||
guard stopped else {
|
||||
if executionLine != nil { executionLine = nil }
|
||||
if execution != "Running" { execution = "Running" }; return
|
||||
}
|
||||
let memory = capture.logicalMemory, available = capture.logicalMemoryAvailable
|
||||
for (address, bytes) in conn.guards {
|
||||
let start = Int(address), end = start + bytes.count
|
||||
guard end <= memory.count, end <= available.count, available[start..<end].allSatisfy({ $0 != 0 }),
|
||||
memory[start..<end].elementsEqual(bytes) else {
|
||||
invalidate("An assembled instruction changed in mapped RAM. Use Debugger to inspect it, or run again."); return
|
||||
}
|
||||
}
|
||||
let pc = snapshot.programCounter
|
||||
let candidates = conn.artifact.instructions.filter { $0.address == pc }
|
||||
let first = candidates.count == 1 ? candidates.first : nil
|
||||
let live = capture.instructions.first
|
||||
let next: SourceLine?
|
||||
if let first, live?.address == pc, let live, Array(live.bytes) == first.bytes,
|
||||
Self.location(.init(path: first.path, line: first.line), in: conn.artifact) != nil {
|
||||
next = .init(path: first.path, line: first.line)
|
||||
} else { next = nil }
|
||||
let a = capture.registers["A"]?.uint8Value ?? capture.registers["D"].map { UInt8(truncatingIfNeeded: $0.uint16Value >> 8) }
|
||||
let cc = capture.registers["CC"]?.uint8Value
|
||||
let reg = String(format: "PC $%04X", pc) + (a.map { String(format: " · A $%02X", $0) } ?? "") + (cc.map { String(format: " · CC $%02X", $0) } ?? "")
|
||||
let status = (next.map { "Paused · \($0.path):\($0.line)" } ?? "Paused · no verified source line") + " · " + reg
|
||||
if execution != status { execution = status }
|
||||
if executionLine != next {
|
||||
executionLine = next
|
||||
if let next { selectFile(next.path, line: next.line) }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user