Files
VCCPlusOSS/platforms/macos/App/BASICDevelopmentModel.swift
T

532 lines
31 KiB
Swift
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// SPDX-License-Identifier: GPL-3.0-or-later
import AppKit
import Combine
import CryptoKit
import UniformTypeIdentifiers
enum BASICExportKind: String, Identifiable, Sendable {
case disk, cassette
var id: String { rawValue }
var fileExtension: String { self == .disk ? "dsk" : "cas" }
var title: String { self == .disk ? "Export Disk" : "Export Cassette" }
func instructions(name: String, dosBoot: Bool) -> String {
self == .disk ? DevelopmentDiskProgram.basic(name).instructions(dos: dosBoot)
: "Open the cassette and press Play. Type CLOAD\"\(name)\", then type RUN on the next line."
}
var symbol: String { self == .disk ? "externaldrive" : "recordingtape" }
}
enum BASICExportName {
static func normalized(_ text: String) -> String? {
let value = text.trimmingCharacters(in: .whitespacesAndNewlines)
guard (1...8).contains(value.utf8.count), value.utf8.allSatisfy({
(65...90).contains($0) || (97...122).contains($0) || (48...57).contains($0)
}) else { return nil }
return value.uppercased()
}
static func suggestion(for url: URL?) -> String {
guard let url else { return "HELLO" }
let bytes = url.deletingPathExtension().lastPathComponent.utf8.filter {
(65...90).contains($0) || (97...122).contains($0) || (48...57).contains($0)
}.prefix(8)
return bytes.isEmpty ? "HELLO" : String(decoding: bytes, as: UTF8.self).uppercased()
}
}
struct BASICEditorAction: Identifiable {
enum Operation { case replace(source: String, undoName: String), select(NSRange) }
let id = UUID()
let expectedSource: String
let operation: Operation
}
@MainActor
final class BASICDevelopmentModel: ObservableObject {
weak var assistantEditor: BASICTextView?
let machine: MachineModel
let directory: URL
let workspaceID = UUID()
private var untitledTitle = "Untitled BASIC"
private(set) var sourceRevision = 0
@Published var source = BASICLanguage.sample {
didSet {
if !source.utf8.elementsEqual(oldValue.utf8) {
sourceRevision += 1
diagnostics = []; clearInspection()
if armedSource != nil {
armedSource = nil; stoppedLine = nil; stoppedToken = nil; runtimeErrorLine = nil; runtimeErrorCode = ""
debugStatus = "Source changed. Breakpoints will apply on the next Run; the CoCo program is unchanged."
detachOwnedDebug()
}
}
if !restoring { scheduleRecovery() }
}
}
@Published private(set) var diagnostics: [BASICLanguage.Diagnostic] = []
@Published private(set) var editorAction: BASICEditorAction?
@Published private(set) var fileURL: URL?
@Published private(set) var savedSource = BASICLanguage.sample
@Published private(set) var busy = false
@Published var message: String?
@Published private(set) var status = "Ready to edit. Nothing has been loaded into the CoCo."
@Published var hint: String?
@Published var completionRequest = UUID()
@Published var documentID = UUID()
@Published var editorOffset = 0
private var fileFingerprint: String?
private var knownGuestSource: String?
@Published private(set) var breakpoints: Set<Int> = []
@Published private(set) var stoppedLine: Int?
@Published private(set) var stoppedToken: NSRange?
@Published private(set) var stepping = false
@Published private(set) var callerAvailable = false
@Published private(set) var runtimeErrorLine: Int?
@Published private(set) var runtimeErrorCode = ""
@Published private(set) var debugStatus = "Click beside a numbered line to set a breakpoint."
@Published private(set) var variables: [BASICVariable] = []
@Published private(set) var inspectionAvailable = false
@Published private(set) var inspectionStatus = "Pause at a BASIC breakpoint to inspect variables."
@Published private(set) var watches: [String] = []
@Published var watchEntry = ""
@Published var watchError: String?
private var inspectionRequest = UUID()
private var armedSource: String?
private var debugObservation: AnyCancellable?
var canContinue: Bool { machine.basicWorkspaceOwner == workspaceID && canTransfer && machine.state == .paused && machine.basicDebug.attached && source == armedSource }
var canStep: Bool { canContinue && stoppedLine != nil }
var canStepOut: Bool { canStep && callerAvailable }
var editorLocked: Bool { busy || stepping }
private var recoveryTask: Task<Void, Never>?
private var restoring = false
var dirty: Bool { !source.utf8.elementsEqual(savedSource.utf8) }
var title: String { fileURL?.lastPathComponent ?? untitledTitle }
var canTransfer: Bool { !busy && !machine.busy && (machine.state == .running || machine.state == .paused) }
struct Draft: Codable {
var source: String
var savedSource: String
var filePath: String?
var fingerprint: String?
var watches: [String]?
}
init(machine: MachineModel, directory: URL, initialSource: String? = nil, title: String? = nil) {
self.machine = machine; self.directory = directory
if let initialSource { source = initialSource; savedSource = initialSource }
if let title { untitledTitle = title }
restoreRecovery()
debugObservation = machine.$basicDebug.combineLatest(machine.$basicWorkspaceOwner).sink { [weak self] value, owner in
guard let self else { return }
if owner != self.workspaceID {
if self.armedSource != nil {
self.armedSource = nil; self.stoppedLine = nil; self.stoppedToken = nil
self.stepping = false; self.callerAvailable = false
self.runtimeErrorLine = nil; self.runtimeErrorCode = ""; self.clearInspection()
self.debugStatus = "Another BASIC workspace controls the CoCo. These breakpoints apply on your next Run."
}
return
}
// @Published sends before MachineModel stores the new value.
// Defer the read until that snapshot has been fully accepted.
Task { [weak self] in self?.refreshInspection() }
self.stoppedLine = self.armedSource == self.source && value.attached ? value.line : nil
self.stoppedToken = self.stoppedLine != nil ? value.sourceRange : nil
self.stepping = self.armedSource == self.source && value.attached && value.stepping
self.refreshRuntimeState(value)
if self.armedSource != nil && !value.attached {
self.armedSource = nil
self.debugStatus = value.status.isEmpty ? "BASIC debugging ended after the machine changed." : value.status
} else if self.armedSource != nil {
self.debugStatus = value.line.map { "Paused at BASIC line \($0). Continue keeps variables and open files." }
?? (value.status.isEmpty ? "BASIC breakpoints are active." : value.status)
}
}
}
private func detachOwnedDebug() {
guard machine.basicWorkspaceOwner == workspaceID else { return }
machine.basicWorkspaceOwner = nil
machine.detachBASICDebug()
}
private func refreshRuntimeState(_ value: MachineModel.BASICDebugState) {
let attached = machine.basicWorkspaceOwner == workspaceID && armedSource == source && value.attached
callerAvailable = attached && value.canStepOut
runtimeErrorLine = attached ? value.errorLine : nil
runtimeErrorCode = attached ? value.errorCode : ""
}
func clearInspection() {
inspectionRequest = UUID(); variables = []; inspectionAvailable = false
inspectionStatus = "Pause at a BASIC breakpoint or completed statement to inspect variables."
}
func refreshInspection() {
let stop = machine.basicDebug
guard machine.basicWorkspaceOwner == workspaceID, armedSource == source, stop.attached, stop.paused, !stop.stepping,
stop.line != nil || stop.atPrompt else { clearInspection(); return }
let text = source, request = UUID(); inspectionRequest = request
Task {
let (values, error) = await machine.inspectBASIC(source: text, stop: stop)
guard inspectionRequest == request, source == text, armedSource == text,
machine.basicWorkspaceOwner == workspaceID, machine.basicDebug == stop else { return }
variables = values ?? []; inspectionAvailable = values != nil
inspectionStatus = error ?? (values?.isEmpty == true ? "No variables have been assigned yet." : "Read-only · BASIC uses the first two characters of a name.")
}
}
func addWatch() {
guard let watch = BASICWatch(watchEntry) else {
watchError = "Use a variable name or numeric subscripts, such as A, NAME$ or A(2,3). Expressions are not evaluated."; return
}
guard watches.count < 128 || watches.contains(watch.canonical) else { watchError = "Up to 128 watches are supported."; return }
if !watches.contains(watch.canonical) { watches.append(watch.canonical) }
watchEntry = ""; watchError = nil; persistDraft()
}
func removeWatch(_ name: String) { watches.removeAll { $0 == name }; persistDraft() }
func watchValue(_ name: String) -> String {
inspectionAvailable ? (BASICWatch(name)?.value(in: variables) ?? "Invalid watch") : "Waiting for a BASIC stop"
}
static func fingerprint(_ data: Data) -> String { SHA256.hash(data: data).map { String(format: "%02x", $0) }.joined() }
static func readText(_ url: URL) throws -> (String, String) {
let values = try url.resourceValues(forKeys: [.isRegularFileKey, .fileSizeKey])
guard values.isRegularFile == true, let count = values.fileSize, count <= BASICLanguage.maximumSourceBytes else {
throw CocoaError(.fileReadTooLarge)
}
let data = try Data(contentsOf: url)
guard data.count <= BASICLanguage.maximumSourceBytes, !data.contains(0),
let text = String(data: data, encoding: .utf8) else { throw CocoaError(.fileReadInapplicableStringEncoding) }
return (text.replacingOccurrences(of: "\r\n", with: "\n").replacingOccurrences(of: "\r", with: "\n"), fingerprint(data))
}
private func restoreRecovery() {
let url = directory.appendingPathComponent("Draft.json")
guard FileManager.default.fileExists(atPath: url.path) else { return }
do {
let values = try url.resourceValues(forKeys: [.fileSizeKey])
guard let count = values.fileSize, count <= BASICLanguage.maximumSourceBytes * 12 else { throw CocoaError(.fileReadTooLarge) }
let draft = try JSONDecoder().decode(Draft.self, from: Data(contentsOf: url))
guard draft.source.utf8.count <= BASICLanguage.maximumSourceBytes,
draft.savedSource.utf8.count <= BASICLanguage.maximumSourceBytes else { throw CocoaError(.fileReadTooLarge) }
restoring = true
source = draft.source; savedSource = draft.savedSource; fileURL = draft.filePath.map { URL(fileURLWithPath: $0) }
watches = Array((draft.watches ?? []).compactMap { BASICWatch($0)?.canonical }.prefix(128))
fileFingerprint = draft.fingerprint; restoring = false
status = "Restored your BASIC workspace. The CoCo has not been changed."
} catch { message = "The saved BASIC workspace could not be restored: \(error.localizedDescription)" }
}
private func scheduleRecovery() {
recoveryTask?.cancel()
recoveryTask = Task { [weak self] in
do { try await Task.sleep(for: .milliseconds(350)) } catch { return }
self?.persistDraft()
}
}
func persistDraft() {
recoveryTask?.cancel()
guard source.utf8.count <= BASICLanguage.maximumSourceBytes else { message = "BASIC source is limited to 1 MB."; return }
do {
try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
let value = Draft(source: source, savedSource: savedSource, filePath: fileURL?.path, fingerprint: fileFingerprint, watches: watches)
try JSONEncoder().encode(value).write(to: directory.appendingPathComponent("Draft.json"), options: .atomic)
} catch { message = "Could not save the recovery draft: \(error.localizedDescription)" }
}
func confirmDiscard(applyDiscard: Bool = true) -> Bool {
guard !busy else { message = "Wait for the BASIC operation to finish."; return false }
guard dirty else { persistDraft(); return true }
let alert = NSAlert(); alert.messageText = "Save changes to \(title)?"
alert.informativeText = "Save your readable BASIC source on the Mac before replacing it or quitting."
alert.addButton(withTitle: "Save"); alert.addButton(withTitle: "Cancel"); alert.addButton(withTitle: "Discard Changes")
switch alert.runModal() {
case .alertFirstButtonReturn: return save()
case .alertThirdButtonReturn:
if applyDiscard { source = savedSource; persistDraft() }; return true
default: return false
}
}
func newProgram() {
guard !busy, confirmDiscard() else { return }
fileURL = nil; fileFingerprint = nil; savedSource = BASICLanguage.sample; source = BASICLanguage.sample
breakpoints = []; armedSource = nil; stoppedLine = nil; detachOwnedDebug()
documentID = UUID(); message = nil; hint = nil; status = "New example. Nothing has been loaded into the CoCo."; persistDraft()
}
func open() {
guard !busy, confirmDiscard(applyDiscard: false) else { return }
let panel = NSOpenPanel(); panel.title = "Open BASIC Source"; panel.allowsMultipleSelection = false
panel.canChooseDirectories = false
panel.message = "Choose readable, line-numbered BASIC text. Tokenized disk or cassette files are not source text."
panel.allowedContentTypes = [.plainText, UTType(filenameExtension: "bas") ?? .plainText]
guard panel.runModal() == .OK, let url = panel.url else { return }
openSource(at: url)
}
@discardableResult func openSource(at url: URL) -> Bool {
guard !busy else { return false }
do {
let (text, hash) = try Self.readText(url)
fileURL = url; fileFingerprint = hash; savedSource = text; source = text
breakpoints = []; armedSource = nil; stoppedLine = nil; detachOwnedDebug()
documentID = UUID(); message = nil; hint = nil; status = "Opened \(url.lastPathComponent). The CoCo has not been changed."; persistDraft()
return true
} catch { message = "Could not open BASIC source: \(error.localizedDescription)"; return false }
}
@discardableResult func save(as: Bool = false) -> Bool {
guard !busy, source.utf8.count <= BASICLanguage.maximumSourceBytes else { return false }
var target = fileURL
if target == nil || `as` {
let panel = NSSavePanel(); panel.title = "Save BASIC Source"; panel.nameFieldStringValue = fileURL?.lastPathComponent ?? "HelloCoCo.bas"
panel.allowedContentTypes = [UTType(filenameExtension: "bas") ?? .plainText]; panel.canCreateDirectories = true
guard panel.runModal() == .OK, let url = panel.url else { return false }; target = url
}
guard let target else { return false }
return saveSource(to: target)
}
@discardableResult func saveSource(to target: URL) -> Bool {
guard !busy, source.utf8.count <= BASICLanguage.maximumSourceBytes else { return false }
do {
if target == fileURL, let fingerprint = fileFingerprint {
let existing = try? Self.readText(target).1
if existing != fingerprint {
let alert = NSAlert(); alert.messageText = "The BASIC source changed outside VCC Plus."
alert.informativeText = "Replace the file with your editor text? Choose Cancel to keep both and use Save As."
alert.addButton(withTitle: "Cancel"); alert.addButton(withTitle: "Replace File")
guard alert.runModal() == .alertSecondButtonReturn else { return false }
}
}
let data = Data(source.utf8); try data.write(to: target, options: .atomic)
fileURL = target; fileFingerprint = Self.fingerprint(data); savedSource = source
message = nil; status = "Saved \(target.lastPathComponent)."; persistDraft(); return true
} catch { message = "Could not save BASIC source: \(error.localizedDescription)"; return false }
}
private var cursorBreakpointLine: Int? {
let text = source as NSString
guard editorOffset >= 0, editorOffset <= text.length else { return nil }
let range = text.lineRange(for: NSRange(location: editorOffset, length: 0))
return BASICLanguage.analyze(text.substring(with: range)).lines.first?.number
}
var cursorBreakpointHelp: String {
guard let line = cursorBreakpointLine else { return "Place the insertion point on a numbered BASIC statement to set a breakpoint" }
return BreakpointRuler.actionName(line, set: breakpoints.contains(line))
}
func toggleBreakpointAtCursor() {
guard let line = cursorBreakpointLine else {
message = "Place the insertion point on a numbered BASIC statement first."; return
}
toggleBreakpoint(line)
}
func toggleBreakpoint(_ line: Int) {
guard !busy else { return }
if breakpoints.contains(line) { breakpoints.remove(line) }
else {
let matches = BASICLanguage.analyze(source).lines.filter { $0.number == line }
guard matches.count == 1, let entry = matches.first,
NSMaxRange(entry.labelRange) < NSMaxRange(entry.range),
!(source as NSString).substring(with: NSRange(location: NSMaxRange(entry.labelRange), length: NSMaxRange(entry.range) - NSMaxRange(entry.labelRange)))
.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
message = "Breakpoints need a unique line number with a BASIC statement."; return
}
guard breakpoints.count < 1024 else { message = "At most 1024 BASIC breakpoints are supported."; return }
breakpoints.insert(line)
}
updateBreakpoints()
}
func clearBreakpoints() {
guard !busy else { return }; breakpoints = []; updateBreakpoints()
}
private func updateBreakpoints() {
message = nil
let text = source, points = breakpoints
// Before the first transfer these are editor intentions only. An
// atomic Run installs the program and its points together.
guard canTransfer, knownGuestSource != nil, machine.basicWorkspaceOwner == workspaceID else {
debugStatus = points.isEmpty ? "No BASIC breakpoints." : "\(points.count) breakpoint(s) will apply on Run."; return
}
busy = true
Task {
defer { busy = false }
let configured = await machine.configureBASICBreakpoints(points, source: text)
guard machine.basicWorkspaceOwner == workspaceID, source == text else { return }
if configured {
armedSource = text
stoppedLine = machine.basicDebug.line; stoppedToken = machine.basicDebug.sourceRange
refreshInspection()
debugStatus = stoppedLine.map { "Paused at BASIC line \($0)." } ?? "BASIC breakpoints are active."
} else {
armedSource = nil; stoppedLine = nil; detachOwnedDebug()
debugStatus = "Editor and CoCo differ. These breakpoints will apply on the next Run."
}
}
}
func stepProgram(over: Bool, out: Bool = false) {
guard out ? canStepOut : canStep else { return }
let text = source; busy = true; message = nil
Task {
defer { busy = false }
let succeeded = out ? await machine.stepOutBASIC(source: text) : await machine.stepBASIC(source: text, over: over)
if !succeeded {
message = machine.fileError ?? "The BASIC stop is no longer current."
}
}
}
func cancelStep() { guard stepping else { return }; machine.pause() }
func continueProgram() {
guard canContinue else { return }
let text = source; busy = true; message = nil
Task {
defer { busy = false }
if !((await machine.continueBASIC(source: text))) { message = machine.fileError ?? "The BASIC stop is no longer current." }
}
}
func checkSource() {
guard !busy, editorAction == nil else { return }
let analysis = BASICLanguage.analyze(source)
diagnostics = analysis.diagnostics; message = nil
status = analysis.diagnostics.isEmpty
? "No source-structure issues found. BASIC checks statement syntax when the program runs."
: "Source check found \(analysis.diagnostics.count) \(analysis.diagnostics.count == 1 ? "issue" : "issues"). Select an issue to show its source line."
}
func goToLine(_ number: Int) {
guard !busy, editorAction == nil else { return }
let analysis = BASICLanguage.analyze(source)
let matches = analysis.lines.filter { $0.number == number }
guard (0...63999).contains(number), matches.count == 1, let line = matches.first else {
message = matches.count > 1 ? "BASIC line \(number) is duplicated. Check Source before navigating."
: "No BASIC line \(number) exists in this source. Use a program line number, not an editor row."
return
}
message = nil
editorAction = .init(expectedSource: source, operation: .select(line.range))
status = "BASIC line \(number)."
}
func selectDiagnostic(_ diagnostic: BASICLanguage.Diagnostic) {
guard !busy, editorAction == nil, diagnostics.contains(where: { $0.id == diagnostic.id }) else { return }
editorAction = .init(expectedSource: source, operation: .select(diagnostic.range))
}
func renumber(start: Int, increment: Int) {
guard !busy, editorAction == nil else { return }
do {
let result = try BASICLanguage.renumber(source, start: start, step: increment)
message = nil; diagnostics = []
guard result.source != source else { status = "The program already uses those line numbers."; return }
editorAction = .init(expectedSource: source, operation: .replace(source: result.source, undoName: "Renumber BASIC"))
status = "Renumbered \(result.lineCount) lines and \(result.changedReferences) references. Undo restores the previous source."
} catch {
diagnostics = BASICLanguage.analyze(source).diagnostics
message = error.localizedDescription
}
}
func editorActionHandled(id: UUID, applied: Bool) {
guard editorAction?.id == id else { return }
if applied, case .replace(_, let name) = editorAction?.operation, name == "Renumber BASIC", !breakpoints.isEmpty {
breakpoints = []; armedSource = nil; stoppedLine = nil; detachOwnedDebug()
debugStatus = "Line numbers changed. Set breakpoints on the renumbered program."
}
editorAction = nil
if !applied { message = "The source or insertion point changed before the edit could be applied. Try the action again." }
}
private func validateSourceStructure(_ text: String) -> Bool {
let analysis = BASICLanguage.analyze(text)
diagnostics = analysis.diagnostics
guard !analysis.hasErrors else {
message = "Fix the source errors below before loading or exporting. Select an issue to show its source line."
return false
}
return true
}
var suggestedExportName: String { BASICExportName.suggestion(for: fileURL) }
func chooseExport(_ kind: BASICExportKind, name: String, dosBoot: Bool) {
Task { _ = await performExport(kind, name: name, dosBoot: dosBoot, destination: nil) }
}
/// The save panel and regression checks share one production export path.
@discardableResult func exportImage(_ kind: BASICExportKind, name: String, dosBoot: Bool = false, to destination: URL) async -> Bool {
await performExport(kind, name: name, dosBoot: dosBoot, destination: destination)
}
private func performExport(_ kind: BASICExportKind, name: String, dosBoot: Bool, destination: URL?) async -> Bool {
guard canTransfer else { message = "Start the bundled CoCo BASIC setup before exporting."; return false }
guard let name = BASICExportName.normalized(name) else {
message = "Use 1–8 letters or numbers for the CoCo program name, without an extension."; return false
}
let text = source, sourceURL = fileURL
guard !text.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
message = "Enter a line-numbered BASIC program before exporting."; return false
}
guard validateSourceStructure(text) else { return false }
busy = true; message = nil; persistDraft()
defer { busy = false }
guard let data = await machine.exportBASICSource(text, name: name, cassette: kind == .cassette) else {
message = machine.fileError ?? "Could not prepare the BASIC export."; return false
}
var target = destination
if target == nil {
let panel = NSSavePanel(); panel.title = kind.title
panel.nameFieldStringValue = name + "." + kind.fileExtension
panel.allowedContentTypes = [UTType(filenameExtension: kind.fileExtension) ?? .data]
panel.canCreateDirectories = true; panel.isExtensionHidden = false
panel.message = kind.instructions(name: name, dosBoot: dosBoot)
guard panel.runModal() == .OK, let chosen = panel.url else { return false }; target = chosen
}
guard let target else { return false }
do {
let output = kind == .disk && dosBoot ? try await DevelopmentBuildTools().bootableBASICDisk(data, name: name) : data
try await machine.writeBASICExport(output, to: target, sourceURL: sourceURL)
status = "Exported \(target.lastPathComponent). " + kind.instructions(name: name, dosBoot: dosBoot)
return true
} catch { message = "Could not export BASIC: \(error.localizedDescription)"; return false }
}
func transfer(run: Bool) {
Task { _ = await performTransfer(run: run) }
}
/// Both the editor and the reviewed run use the same source validation and replacement confirmation.
func performTransfer(run: Bool, reviewIsCurrent: (() -> Bool)? = nil) async -> (VCCMachineSnapshot, String)? {
guard canTransfer else { return nil }
let text = source
guard !text.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else { message = "Enter a line-numbered BASIC program first."; return nil }
guard validateSourceStructure(text) else { return nil }
busy = true; message = nil; persistDraft()
defer { busy = false }
let prior = reviewIsCurrent == nil ? nil : await machine.mcpMachineSnapshot()
guard reviewIsCurrent?() != false else { return nil }
guard let existing = await machine.readBASICSource() else { message = machine.fileError ?? "Could not inspect BASIC memory."; return nil }
if machine.assemblyAttached || (!existing.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty && existing != knownGuestSource) {
let alert = NSAlert(); alert.messageText = machine.assemblyAttached ? "Take over the assembly session with BASIC?" : "Replace the BASIC program in the CoCo?"
alert.informativeText = "This replaces program memory and clears its variables. Mounted media and machine settings are kept. Use Read from CoCo first if you want to save that program."
alert.addButton(withTitle: "Cancel"); alert.addButton(withTitle: run ? "Replace and Run" : "Replace and Load")
guard alert.runModal() == .alertSecondButtonReturn else { return nil }
}
guard reviewIsCurrent?() != false, source == text else { return nil }
guard let snapshot = await machine.loadBASICSource(text, run: run, breakpoints: breakpoints,
review: prior.map { ($0, existing) }) else { message = machine.fileError ?? "BASIC transfer failed."; return nil }
machine.basicWorkspaceOwner = workspaceID
let loadedSource = reviewIsCurrent == nil ? await machine.readBASICSource() : snapshot.assistantLoadedSource
guard machine.basicWorkspaceOwner == workspaceID, source == text else { return nil }
knownGuestSource = loadedSource
armedSource = machine.basicDebug.attached ? text : nil
refreshRuntimeState(machine.basicDebug)
stoppedLine = machine.basicDebug.line; stoppedToken = machine.basicDebug.sourceRange
refreshInspection()
if machine.basicDebug.attached {
debugStatus = stoppedLine.map { "Paused at BASIC line \($0). Continue keeps variables and open files." }
?? (breakpoints.isEmpty ? "No BASIC breakpoints." : "BASIC breakpoints are active.")
} else {
debugStatus = machine.basicDebug.status.isEmpty ? "BASIC debugging is detached." : machine.basicDebug.status
}
status = run ? "Loaded directly into BASIC memory and started. Use CoCo Break to stop a running program." : "Loaded directly into BASIC memory. Use LIST or RUN in the CoCo."
return loadedSource.map { (snapshot, $0) }
}
func readFromCoCo() {
guard canTransfer, confirmDiscard(applyDiscard: false) else { return }
busy = true; message = nil
Task {
defer { busy = false }
guard let text = await machine.readBASICSource() else { message = machine.fileError ?? "Could not read BASIC memory."; return }
fileURL = nil; fileFingerprint = nil; savedSource = ""; source = text; knownGuestSource = text
breakpoints = []; armedSource = nil; stoppedLine = nil; detachOwnedDebug()
documentID = UUID(); hint = nil; status = "Read from CoCo memory. Save a source copy on the Mac to keep it."; persistDraft()
}
}
func statusMessage(_ value: String) { status = value }
func cursorChanged(_ offset: Int) {
editorOffset = offset
if let keyword = BASICReferenceContext.keyword(in: source, at: offset),
let catalog = try? BASICReferenceCatalog.bundled.get() {
let candidates = catalog.entries.filter { $0.keyword == keyword }
let entry = candidates.first { $0.dialect == machine.basicReferenceDialect }
?? candidates.first { $0.dialect == .common }
?? candidates.first { $0.dialect == .disk }
hint = entry?.syntax.first
} else { hint = BASICLanguage.hint(source, at: offset) }
}
}