// 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 = [] @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? 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) } } }