// SPDX-License-Identifier: GPL-3.0-or-later import AppKit import Combine enum CMOCSourceStepMode: Int { case into, over, out } struct CMOCEditorDocument: Identifiable { let id: String var text: String var savedText: String var savedHash: String var conflict = false var generated = false var reference = false var missing = false var dirty: Bool { !text.utf8.elementsEqual(savedText.utf8) } } struct CMOCSourceBreakpoint: Hashable, Codable { let file: String let line: Int } struct CMOCBuildDiagnostic: Identifiable { let id = UUID() let file: String let line: Int let message: String } struct CMOCVariableTreeRow: Identifiable { enum ID: Hashable { case node(CMOCWatchEvaluator.TreePath), page(CMOCWatchEvaluator.TreePath), limit } enum Content { case node(CMOCWatchEvaluator.TreeNode) case page(CMOCWatchEvaluator.TreePath, offset: Int, total: Int, next: Int?) case message(String) } let id: ID let depth: Int let content: Content } struct CMOCVariableTreeListing { let rows: [CMOCVariableTreeRow] let rootCount: Int let rootOffset: Int } /// Documents and the exact build snapshot live independently of window lifetime. /// The existing machine is the only authority for execution and mounted media. @MainActor final class CMOCDevelopmentModel: ObservableObject { private(set) var assistantProjectID = UUID() private(set) var assistantEditEpoch = 0 weak var assistantEditor: NSTextView? weak var assistantEditorPool: CSourceEditor.Coordinator? var assistantEditorFile = "" let machine: MachineModel let service: CMOCBuildService @Published var source = CMOCProject.starterSource { didSet { guard !selecting, let index = documents.firstIndex(where: { $0.id == selectedFile }) else { return } if source != oldValue { assistantEditEpoch += 1 } documents[index].text = source scheduleDraftSave(); scheduleProjectIndex(); scheduleParameterHints() } } @Published private(set) var documents: [CMOCEditorDocument] = [] @Published private(set) var files: [CMOCProjectFile] = [] @Published private(set) var selectedFile = "main.c" @Published private(set) var project: CMOCProject? @Published private(set) var building = false @Published private(set) var commanding = false @Published private(set) var log = "Create or open a C project to begin. Build runs its Makefile; only build projects you trust." @Published private(set) var message: String? @Published private(set) var mapping: CMOCSourceMap? @Published private(set) var projectMapping: CMOCProjectSourceMap? @Published private(set) var artifact: CMOCBuildArtifact? @Published private(set) var diagnostics: [CMOCBuildDiagnostic] = [] @Published var breakpointLine = 9 @Published private(set) var breakpoints: Set = [] @Published private(set) var currentLine: Int? @Published private(set) var currentFile: String? @Published private(set) var execution = "No development program loaded" @Published private(set) var pc: UInt16? @Published var configurationName = "Debug" { didSet { rememberWorkspace(); scheduleProjectIndex() } } @Published var customTarget = "" @Published private(set) var navigationLine: Int? @Published private(set) var navigationRequest = UUID() private var pausedInputEpoch: UInt64? @Published private var pausedDebugSnapshot: VCCDebuggerSnapshot? @Published private(set) var variableMetadata: CMOCVariableDebug? @Published private(set) var variableStatus = "Build with the bundled compiler to inspect C variables." @Published private(set) var watches: [String] = [] @Published var watchExpression = "" @Published private(set) var sourceStepping = false @Published private(set) var inspectionRevision = UUID() @Published private var capturedCallStack: CMOCCallStack? @Published private(set) var selectedFrameIndex = 0 private let defaults: UserDefaults private var selecting = false private var task: Task? private var loadedGeneration: UInt64? private var loadedRevision: UInt64? private var loadedMapping: UInt64? private var loadedBuild: UUID? private var awaitingDiskLoad = false private var reading = false private var revision = UUID() private var checkingFiles = false private var nextFileCheck = Date.distantPast private var externalBuildChange = false private var restorationAttempted = false @Published private(set) var launchedBuildID: UUID? private var launchedGeneration: UInt64? private var launchedRevision: UInt64? @Published private(set) var latestBuildAttempt = "Not built in this session" @Published private(set) var buildHistory: [CMOCBuildHistory.Entry] = [] @Published private(set) var historyBusy = false @Published private(set) var historyMessage: String? @Published private(set) var recoveryRecords: [CMOCWorkspaceRecovery.Record] = [] @Published private(set) var recoveryIssues: [String] = [] @Published private(set) var recoveryBusy = false private var historyRemoving = false private var historyRefreshPending = false private var recoveryRefreshPending = false private var recoveryProjectDirectory: URL? private let recoveryStore: CMOCWorkspaceRecovery private let recoveryQueue = DispatchQueue(label: "VCCPlus.CMOCRecovery") private var recoveryDebounce: Task? init(machine: MachineModel, toolchain: URL? = nil, defaults: UserDefaults? = nil, buildRoot: URL? = nil, recoveryRoot: URL? = nil) { self.machine = machine self.defaults = defaults ?? machine.developmentDefaults self.service = CMOCBuildService(toolchain: toolchain ?? Bundle.main.resourceURL!.appendingPathComponent("Toolchain"), buildRoot: buildRoot ?? machine.developmentRunDirectory.deletingLastPathComponent().appendingPathComponent("Development Builds")) self.recoveryStore = CMOCWorkspaceRecovery(root: recoveryRoot ?? machine.developmentRunDirectory.deletingLastPathComponent().appendingPathComponent("C Workspace Recovery")) } struct SourceLocation: Equatable { let path: String let line: Int let column: Int let length: Int } @Published var navigationPane = "Files" @Published var searchQuery = "" { didSet { scheduleProjectSearch() } } @Published var searchCaseSensitive = false { didSet { scheduleProjectSearch() } } @Published private(set) var searchMatches: [CMOCProjectIndex.Match] = [] @Published private(set) var searchTruncated = false @Published private(set) var indexing = false @Published private(set) var indexMessage = "Open a project to browse its source." @Published private(set) var indexNotes: [String] = [] @Published private(set) var projectIndex: CMOCProjectIndex? @Published private(set) var definitionCandidates: [CMOCProjectIndex.Symbol] = [] @Published private(set) var definitionName = "" @Published private(set) var navigationColumn: Int? @Published private(set) var navigationLength = 0 @Published private(set) var cursorOffset = 0 @Published private(set) var editorActionRequest = UUID() private(set) var editorAction: CMOCEditorAction = .indent func requestEditorAction(_ action: CMOCEditorAction) { editorAction = action; editorActionRequest = UUID() } @Published private(set) var completionRequest = UUID() @Published private(set) var completionMessage = "Complete identifiers with Control-Space." @Published private(set) var parameterHints: [CMOCCompletion.ParameterHint] = [] private var parameterTask: Task? private var parameterGeneration = UUID() func requestCompletion() { completionMessage = "Preparing identifier completion…" guard project != nil, !selectedFileIsGenerated else { completionMessage = "Completion is available in editable project C sources."; return } guard projectIndex != nil else { completionMessage = "Reading project declarations; try completion again shortly." refreshProjectIndex(); return } completionRequest = UUID() } func reportCompletion(message: String) { completionMessage = message } func clearParameterHints() { parameterTask?.cancel(); parameterGeneration = UUID() if !parameterHints.isEmpty { parameterHints = [] } } func refreshParameterHints() { scheduleParameterHints(delay: 0) } private func scheduleParameterHints(delay: UInt64 = 80_000_000) { clearParameterHints() guard let index = projectIndex, let directory = project?.directory else { return } let path = selectedFile, text = source, offset = cursorOffset, generation = parameterGeneration parameterTask = Task { [weak self] in do { if delay > 0 { try await Task.sleep(nanoseconds: delay) } try Task.checkCancellation() let worker = Task.detached(priority: .utility) { CMOCCompletion.parameterHints(index: index, path: path, text: text, offset: offset) } let hints = await withTaskCancellationHandler(operation: { await worker.value }, onCancel: { worker.cancel() }) guard let self, !Task.isCancelled, parameterGeneration == generation, project?.directory == directory, selectedFile == path, source == text, cursorOffset == offset else { return } parameterHints = hints } catch { } } } @Published private var backwardLocations: [SourceLocation] = [] @Published private var forwardLocations: [SourceLocation] = [] private var cursorOffsets: [String: Int] = [:] private var indexInputs = CMOCIndexInputs() private var indexTask: Task? private var searchTask: Task? private var indexGeneration = UUID() private var searchGeneration = UUID() private var navigationDiskHashes: [String: String] = [:] var currentOutline: [CMOCProjectIndex.Symbol] { projectIndex?.outline(path: selectedFile) ?? [] } var canNavigateBack: Bool { !backwardLocations.isEmpty } var canNavigateForward: Bool { !forwardLocations.isEmpty } func updateCursor(offset: Int) { cursorOffset = max(0, min(offset, source.utf16.count)); cursorOffsets[selectedFile] = cursorOffset scheduleParameterHints() } private func location(path: String, text: String, offset: Int, length: Int = 0) -> SourceLocation { let value = text as NSString, offset = min(max(0, offset), value.length) let prefix = value.substring(to: offset) as NSString let lines = prefix.components(separatedBy: "\n") return .init(path: path, line: lines.count, column: (lines.last?.utf16.count ?? 0) + 1, length: length) } private var cursorLocation: SourceLocation { location(path: selectedFile, text: source, offset: cursorOffset) } private func resetNavigation() { clearParameterHints(); completionRequest = UUID() completionMessage = "Complete identifiers with Control-Space." indexTask?.cancel(); searchTask?.cancel(); indexGeneration = UUID(); searchGeneration = UUID() projectIndex = nil; indexInputs = .init(); navigationDiskHashes = [:] searchMatches = []; searchTruncated = false; definitionCandidates = []; definitionName = "" backwardLocations = []; forwardLocations = []; cursorOffsets = [:]; cursorOffset = 0 navigationColumn = nil; navigationLength = 0; indexing = false indexMessage = "Reading project text…"; indexNotes = [] } private func scheduleProjectIndex() { startProjectIndex(delay: 350_000_000) } func refreshProjectIndex() { startProjectIndex(delay: 0) } private func startProjectIndex(delay: UInt64) { indexTask?.cancel(); indexGeneration = UUID() guard let project else { indexing = false; return } indexing = true let generation = indexGeneration, inputs = overlays, configuration = configurationName, toolchain = service.toolchain var generated = artifact?.sources.filter { artifact?.fileHashes[$0.key] == nil } ?? [:] for document in documents where document.generated && !document.reference && artifact?.fileHashes[document.id] == nil { generated[document.id] = Data(document.text.utf8) } let snapshots = generated indexTask = Task { [weak self] in do { if delay > 0 { try await Task.sleep(nanoseconds: delay) } try Task.checkCancellation() let worker = Task.detached(priority: .utility) { let collected = try CMOCIndexInputs.load(project: project, toolchain: toolchain, configurationName: configuration, overlays: inputs, generated: snapshots) try Task.checkCancellation() let index = CMOCProjectIndex(documents: collected.documents, defines: collected.defines, includePaths: collected.includePaths, configurationUncertain: collected.configurationUncertain) try Task.checkCancellation() return (collected, index) } let (collected, index) = try await withTaskCancellationHandler(operation: { try await worker.value }, onCancel: { worker.cancel() }) guard let self, !Task.isCancelled, indexGeneration == generation, self.project?.directory == project.directory else { return } indexInputs = collected; projectIndex = index; indexing = false let notes = Array(Set(collected.issues + index.issues)).sorted() indexNotes = notes indexMessage = "\(index.symbols.count) symbols · Source-based navigation" scheduleProjectSearch(); scheduleParameterHints() } catch is CancellationError { } catch { guard let self, indexGeneration == generation else { return } indexing = false; projectIndex = nil; searchMatches = []; definitionCandidates = []; clearParameterHints() indexMessage = "Navigation unavailable: " + error.localizedDescription } } } private func scheduleProjectSearch() { searchTask?.cancel(); searchGeneration = UUID(); searchMatches = []; searchTruncated = false guard let index = projectIndex, !searchQuery.isEmpty else { return } let generation = searchGeneration, query = searchQuery, sensitive = searchCaseSensitive let paths = Set(index.documents.keys).subtracting(indexInputs.referencePaths) searchTask = Task { [weak self] in do { try await Task.sleep(nanoseconds: 150_000_000) let worker = Task.detached(priority: .utility) { index.search(query: query, caseSensitive: sensitive, limit: 500, paths: paths) } let results = await withTaskCancellationHandler(operation: { await worker.value }, onCancel: { worker.cancel() }) guard let self, !Task.isCancelled, searchGeneration == generation else { return } searchMatches = results.matches; searchTruncated = results.truncated } catch { } } } func goToDefinition() { guard !indexing, let index = projectIndex, index.documents[selectedFile] == source else { indexMessage = "Updating source navigation; try Go to Definition again when indexing finishes." refreshProjectIndex(); return } guard let name = index.token(atUTF16Offset: cursorOffset, in: selectedFile) else { definitionName = ""; definitionCandidates = []; navigationPane = "Definitions" indexMessage = "Place the insertion point on a C identifier to find its definition."; return } definitionName = name let position = cursorLocation definitionCandidates = index.definitions(named: name, from: selectedFile, line: position.line, column: position.column) if definitionCandidates.count == 1, let target = definitionCandidates.first, !target.conditional { openSymbol(target) } else { navigationPane = "Definitions" } } func openSymbol(_ symbol: CMOCProjectIndex.Symbol) { guard projectIndex?.symbols.contains(symbol) == true else { message = "This symbol result is out of date. Refresh navigation and select it again."; return } openIndexedLocation(.init(path: symbol.path, line: symbol.line, column: symbol.column, length: symbol.lengthUTF16)) } func openSearchMatch(_ match: CMOCProjectIndex.Match) { guard searchMatches.contains(match) else { message = "This search result is out of date. Search again before navigating."; return } openIndexedLocation(.init(path: match.path, line: match.line, column: match.column, length: match.lengthUTF16)) } private func openIndexedLocation(_ target: SourceLocation) { guard !indexing, let expected = projectIndex?.documents[target.path] else { message = "Source navigation is updating. Please select the result again when it finishes."; return } do { let current: String? if let document = documents.first(where: { $0.id == target.path && !$0.reference }) { current = document.text } else if indexInputs.referencePaths.contains(target.path) { current = indexInputs.documents[target.path] } else if indexInputs.generatedPaths.contains(target.path) { current = artifact?.sources[target.path].flatMap { String(data: $0, encoding: .utf8) } } else { current = try project?.readText(relativePath: target.path) } guard current == expected else { throw CMOCBuildError.message("This result changed since it was indexed. Refresh navigation and select it again.") } navigate(to: target, recording: true) } catch { message = error.localizedDescription; refreshProjectIndex() } } private func navigate(to target: SourceLocation, recording: Bool) { let origin = cursorLocation openFile(target.path, line: target.line) guard selectedFile == target.path else { return } if recording && origin != target { if backwardLocations.last != origin { backwardLocations.append(origin) } if backwardLocations.count > 100 { backwardLocations.removeFirst(backwardLocations.count - 100) } forwardLocations = [] } navigationColumn = target.column; navigationLength = target.length let lines = source.components(separatedBy: "\n") let line = min(max(1, target.line), max(1, lines.count)) let offset = lines.prefix(line - 1).reduce(0) { $0 + $1.utf16.count + 1 } + min(max(0, target.column - 1), lines[line - 1].utf16.count) updateCursor(offset: offset); navigationRequest = UUID() } func navigateBack() { guard let target = backwardLocations.last else { return } let origin = cursorLocation navigate(to: target, recording: false) guard selectedFile == target.path else { return } backwardLocations.removeLast(); forwardLocations.append(origin) } func navigateForward() { guard let target = forwardLocations.last else { return } let origin = cursorLocation navigate(to: target, recording: false) guard selectedFile == target.path else { return } forwardLocations.removeLast(); backwardLocations.append(origin) } private func buildAttemptKey(_ directory: URL) -> String { "CMOCBuildAttempt." + CMOCProject.sha256(Data(directory.resolvingSymlinksInPath().path.utf8)) } var sourceStatus: String { guard project != nil else { return "No project open" } if documents.contains(where: { $0.missing }) { return "Missing files" } if documents.contains(where: { $0.conflict }) { return "External changes" } return unsaved ? "Unsaved edits" : "Saved" } var buildStatus: String { guard let artifact else { return latestBuildAttempt } return "Build \(artifact.id.uuidString.prefix(8)) · \(buildMatchesEditor ? "current" : "out of date")" } var programStatus: String { if awaitingDiskLoad { return "Disk launch pending verification" } guard let id = launchedBuildID else { return "No verified development launch" } return "Program \(id.uuidString.prefix(8)) · \(id == artifact?.id ? "latest build" : "earlier or other project")" } private func trackLaunch(_ artifact: CMOCBuildArtifact, snapshot: VCCMachineSnapshot) { launchedBuildID = artifact.id; launchedGeneration = snapshot.generation launchedRevision = snapshot.debuggerProgramRevision refreshBuildHistory() } private func historyProtection(_ entries: [CMOCBuildHistory.Entry]) -> Set { var ids = Set([artifact?.id, launchedBuildID].compactMap { $0 }) if let latest = entries.first(where: { $0.hasBinary || $0.hasDisk }) { ids.insert(latest.id) } let media = machine.developmentAssignedMediaURLs.map { $0.resolvingSymlinksInPath().standardizedFileURL.path } for entry in entries { let path = entry.directory.resolvingSymlinksInPath().standardizedFileURL.path if media.contains(where: { $0 == path || $0.hasPrefix(path + "/") || path.hasPrefix($0 + "/") }) { ids.insert(entry.id) } } return ids } func refreshBuildHistory() { guard let project else { return } guard !historyBusy else { historyRefreshPending = true; return } historyBusy = true; historyRefreshPending = false let service = service Task { defer { historyBusy = false if historyRefreshPending { refreshBuildHistory() } } do { let entries = try await Task.detached(priority: .utility) { try service.history(project: project.directory) }.value guard self.project?.directory == project.directory else { return } let protected = historyProtection(entries) let checked = try await Task.detached(priority: .utility) { try service.history(project: project.directory, protectedIDs: protected) }.value guard self.project?.directory == project.directory else { return } buildHistory = checked } catch { historyMessage = error.localizedDescription } } } func trashBuilds(_ ids: Set) { guard !historyBusy, !building, !commanding, !ids.isEmpty, let project else { return } let alert = NSAlert(); alert.messageText = "Move selected build results to Trash?" alert.informativeText = "Only verified, unchanged build snapshots can be removed. The latest and loaded builds, assigned media, and your writable Development Runs disks are protected." alert.addButton(withTitle: "Move to Trash"); alert.addButton(withTitle: "Cancel") guard alert.runModal() == .alertFirstButtonReturn else { return } historyBusy = true; historyRemoving = true; historyMessage = nil let service = service Task { do { let entries = try await Task.detached(priority: .utility) { try service.history(project: project.directory) }.value let protected = historyProtection(entries) let result = try await Task.detached(priority: .utility) { try service.removeBuilds(ids: ids, project: project.directory, protectedIDs: protected) }.value historyMessage = "Moved \(result.removedIDs.count) result(s) to Trash." + (result.retained.isEmpty ? "" : " Kept \(result.retained.count): " + Set(result.retained.values).sorted().joined(separator: "; ")) } catch { historyMessage = error.localizedDescription } historyBusy = false; historyRemoving = false; refreshBuildHistory() } } func revealDevelopmentDisks() { do { try FileManager.default.createDirectory(at: machine.developmentRunDirectory, withIntermediateDirectories: true) NSWorkspace.shared.open(machine.developmentRunDirectory) } catch { historyMessage = error.localizedDescription } } private var recoveryDrafts: [CMOCWorkspaceRecovery.Draft] { documents.filter { !$0.generated && !$0.reference && ($0.dirty || $0.missing || $0.conflict) }.map { .init(path: $0.id, text: $0.text, savedText: $0.savedText, savedHash: $0.savedHash) } } private func scheduleDraftSave() { recoveryDebounce?.cancel() recoveryDebounce = Task { [weak self] in do { try await Task.sleep(nanoseconds: 500_000_000) } catch { return } self?.persistDrafts() } } func persistDrafts() { scheduleProjectIndex() recoveryDebounce?.cancel(); recoveryDebounce = nil guard let project else { return } let drafts = recoveryDrafts, store = recoveryStore recoveryQueue.async { [weak self] in do { try store.save(projectDirectory: project.directory, drafts: drafts) } catch { let detail = error.localizedDescription Task { @MainActor [weak self] in guard self?.project?.directory == project.directory else { return } self?.message = "Could not save recovery copies: " + detail } } } } func flushDraftRecovery(completion: @escaping @MainActor () -> Void) { persistDrafts() recoveryQueue.async { Task { @MainActor in completion() } } } func refreshRecovery() { guard let directory = recoveryProjectDirectory else { return } guard !recoveryBusy else { recoveryRefreshPending = true; return } recoveryBusy = true; recoveryRefreshPending = false let store = recoveryStore recoveryQueue.async { [weak self] in let result = Result { try store.scan(projectDirectory: directory) } Task { @MainActor [weak self] in guard let self else { return }; recoveryBusy = false guard recoveryProjectDirectory == directory else { refreshRecovery(); return } switch result { case .success(let scan): recoveryRecords = scan.records.filter { $0.id != store.sessionID }; recoveryIssues = scan.issues case .failure(let error): recoveryIssues = [error.localizedDescription] } if recoveryRefreshPending { refreshRecovery() } } } } func restoreRecovery(_ record: CMOCWorkspaceRecovery.Record) { guard !building, !commanding, !recoveryBusy, !record.isFromRunningSession else { return } guard let project, project.directory.resolvingSymlinksInPath().path == record.projectPath else { message = "Open this draft's project to restore into the editor, or export its files to a new folder."; return } guard confirmDiscard() else { return } for draft in record.drafts { let disk = try? project.readText(relativePath: draft.path) let conflict = disk.map { CMOCProject.sha256(Data($0.utf8)) != draft.savedHash } ?? true let doc = CMOCEditorDocument(id: draft.path, text: draft.text, savedText: draft.savedText, savedHash: draft.savedHash, conflict: conflict, missing: disk == nil) if let index = documents.firstIndex(where: { $0.id == draft.path }) { documents[index] = doc } else { documents.append(doc) } } if let first = record.drafts.first { selecting = true; selectedFile = first.path; source = first.text; selecting = false } externalBuildChange = true; rememberWorkspace(); recoveryBusy = true let store = recoveryStore, drafts = recoveryDrafts // Publish a new durable copy before removing the prior session's copy. recoveryQueue.async { [weak self] in let result = Result { try store.save(projectDirectory: project.directory, drafts: drafts); try store.discard(record) } Task { @MainActor [weak self] in guard let self else { return }; recoveryBusy = false if case .failure(let error) = result { message = error.localizedDescription } else { message = "Drafts restored into the editor. Project files have not been overwritten." } refreshRecovery() } } } func discardRecovery(_ record: CMOCWorkspaceRecovery.Record) { guard !recoveryBusy, !record.isFromRunningSession else { return } let alert = NSAlert(); alert.messageText = "Discard this recovery copy?" alert.informativeText = "This removes only the saved recovery copy of \(record.drafts.count) file(s). Export it first if you may need it. Project files are unchanged." alert.addButton(withTitle: "Discard Recovery Copy"); alert.addButton(withTitle: "Cancel") guard alert.runModal() == .alertFirstButtonReturn else { return } recoveryBusy = true; let store = recoveryStore recoveryQueue.async { [weak self] in let result = Result { try store.discard(record) } Task { @MainActor [weak self] in guard let self else { return }; recoveryBusy = false if case .failure(let error) = result { recoveryIssues = [error.localizedDescription] } refreshRecovery() } } } func exportRecovery(_ record: CMOCWorkspaceRecovery.Record) { let panel = NSOpenPanel(); panel.title = "Export Recovered Sources" panel.canChooseDirectories = true; panel.canChooseFiles = false; panel.canCreateDirectories = true guard panel.runModal() == .OK, let parent = panel.url else { return } do { let folder = parent.appendingPathComponent("Recovered Sources-" + UUID().uuidString) try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: false) for draft in record.drafts { try CMOCProject.validateRelativePath(draft.path) let target = folder.appendingPathComponent(draft.path) try FileManager.default.createDirectory(at: target.deletingLastPathComponent(), withIntermediateDirectories: true) try CMOCProject.sourceBytes(draft.text).write(to: target, options: .withoutOverwriting) } NSWorkspace.shared.open(folder) } catch { recoveryIssues = [error.localizedDescription] } } func saveSelectedCopy() { guard let doc = documents.first(where: { $0.id == selectedFile }) else { return } let panel = NSSavePanel(); panel.title = "Save Selected Copy"; panel.nameFieldStringValue = URL(fileURLWithPath: doc.id).lastPathComponent guard panel.runModal() == .OK, let url = panel.url else { return } do { if let original = try project?.fileURL(relativePath: doc.id), original.resolvingSymlinksInPath() == url.resolvingSymlinksInPath() { throw CMOCBuildError.message("Choose a different filename or folder for this recovery copy. Use Save All to update an unchanged original.") } try CMOCProject.sourceBytes(doc.text).write(to: url, options: .atomic) message = "Saved a copy of \(doc.id). The editor and original file are unchanged." } catch { message = error.localizedDescription } } var unsaved: Bool { documents.contains(where: \.dirty) } var overlays: [String:String] { Dictionary(uniqueKeysWithValues: documents.filter { !$0.generated && !$0.reference }.map { ($0.id, $0.text) }) } var selectedFileIsGenerated: Bool { documents.first(where: { $0.id == selectedFile }).map { $0.generated || $0.reference } == true } var buildMatchesEditor: Bool { guard let artifact, !externalBuildChange, !documents.contains(where: { $0.missing || $0.conflict }), artifact.configurationName == configurationName else { return false } return documents.filter { !$0.reference }.allSatisfy { document in // Build inputs include Makefile and headers, not just mapped C files. guard let hash = (document.generated ? artifact.sourceHashes[document.id] : artifact.fileHashes[document.id]) else { return false } return hash == CMOCProject.sha256(Data(document.text.utf8)) } } var breakpointAddress: UInt16? { buildMatchesEditor ? projectMapping?.addresses(file: selectedFile, line: breakpointLine).first : nil } var canRun: Bool { !historyRemoving && !building && !commanding && machine.canQuickLoad && !runToBreakpointAddresses.isEmpty && (projectMapping?.bankedLayout == nil || artifact?.hasDisk == true) } var bundledLibraryCatalog: [CMOCBundledLibrary] { (try? CMOCBundledLibrary.catalog(at: service.toolchain)) ?? [] } var canLaunch: Bool { !historyRemoving && !building && !commanding && !machine.busy && !machine.diskSaving && buildMatchesEditor && (artifact?.hasBinary == true || artifact?.hasDisk == true) } var loadedMatchesEditor: Bool { loadedBuild == artifact?.id && loadedBuild != nil && buildMatchesEditor && projectMapping != nil } var canCommand: Bool { !commanding && !machine.busy && !machine.diskSaving && (machine.state == .running || machine.state == .paused) } var canStepC: Bool { canCommand && !building && loadedMatchesEditor && !awaitingDiskLoad && machine.state == .paused && currentLine != nil && pausedDebugSnapshot != nil && pausedInputEpoch == machine.inputEpoch } var canInspectC: Bool { !building && !commanding && !machine.busy && loadedMatchesEditor && machine.state == .paused && pausedDebugSnapshot != nil && pausedInputEpoch == machine.inputEpoch && variableMetadata != nil } var callStack: CMOCCallStack? { canInspectC ? capturedCallStack : nil } var inspectionFrame: CMOCCallStack.Frame? { guard let frames = callStack?.frames, frames.indices.contains(selectedFrameIndex) else { return nil } return frames[selectedFrameIndex] } var inspectingCaller: Bool { inspectionFrame != nil && selectedFrameIndex > 0 } var inspectionFrameDescription: String? { guard let frame = inspectionFrame else { return nil } let location = frame.sourceLine.map { "\(frame.sourcePath):\($0)" } ?? frame.sourcePath return "Frame \(frame.id) · \(frame.functionName) · \(location)" } func selectFrame(_ index: Int) { guard let frames = callStack?.frames, frames.indices.contains(index) else { return } selectedFrameIndex = index let frame = frames[index] openFile(frame.sourcePath, line: frame.sourceLine) } private var evaluator: CMOCWatchEvaluator? { guard canInspectC, let metadata = variableMetadata, let snapshot = pausedDebugSnapshot, let u = snapshot.registers["U"] else { return nil } let frame = inspectionFrame return CMOCWatchEvaluator(metadata: metadata.projected(physicalPages: Self.physicalPages(snapshot), memory: snapshot.logicalMemory, available: snapshot.logicalMemoryAvailable), context: .init(pc: frame?.pc ?? snapshot.machine.programCounter, u: frame?.u ?? u.uint16Value, memory: snapshot.logicalMemory, available: snapshot.logicalMemoryAvailable), frameLocalsAvailable: frame?.localsInspectable == true) } var visibleVariables: [CMOCWatchEvaluator.Value] { evaluator?.visibleVariables() ?? [] } func watchValue(_ expression: String) -> CMOCWatchEvaluator.Value? { evaluator?.evaluate(expression) } var variableInspectionIdentity: String? { canInspectC ? "\(inspectionRevision.uuidString):\(selectedFrameIndex)" : nil } func variableTree(watches: Bool, expanded: Set, offsets: [CMOCWatchEvaluator.TreePath: Int], rootOffset: Int) -> CMOCVariableTreeListing { guard let evaluator else { return .init(rows: [], rootCount: 0, rootOffset: 0) } let roots = watches ? self.watches.map { CMOCWatchEvaluator.TreePath(root: .watch($0)) } : evaluator.variableRootPaths() let start = max(0, min(rootOffset, max(0, ((roots.count - 1) / 32) * 32))) var rows: [CMOCVariableTreeRow] = [] var limited = false func append(_ node: CMOCWatchEvaluator.TreeNode, depth: Int) { guard rows.count < 255 else { limited = true; return } rows.append(.init(id: .node(node.path), depth: depth, content: .node(node))) guard node.childCount > 0, expanded.contains(node.path) else { return } let offset = max(0, min(offsets[node.path] ?? 0, ((node.childCount - 1) / 32) * 32)) let page = evaluator.children(of: node.path, offset: offset) for child in page.nodes { append(child, depth: depth + 1) } if let error = page.error, rows.count < 255 { rows.append(.init(id: .page(node.path), depth: depth + 1, content: .message(error))) } else if offset > 0 || page.nextOffset != nil { if rows.count < 255 { rows.append(.init(id: .page(node.path), depth: depth + 1, content: .page(node.path, offset: offset, total: page.totalCount, next: page.nextOffset))) } else { limited = true } } } for root in roots.dropFirst(start).prefix(32) { append(evaluator.treeNode(at: root), depth: 0) } if limited { rows.append(.init(id: .limit, depth: 0, content: .message("Showing 255 rows. Collapse a branch to inspect more of this page."))) } return .init(rows: rows, rootCount: roots.count, rootOffset: start) } var inspectionMessage: String { if variableMetadata == nil { return variableStatus } if !loadedMatchesEditor { return "Run this build with unchanged sources to inspect C values." } if machine.state == .running { return "Pause at a verified C location to inspect values." } if pausedDebugSnapshot == nil { return "No verified C location here. Instruction stepping remains available in Debugger." } return "Values are read from the paused CoCo. Watches never execute code or change memory." } private var watchKey: String? { project.map { "CMOCWorkspace.watches." + CMOCProject.sha256(Data($0.directory.path.utf8)) } } func addWatch() { let expression = watchExpression.trimmingCharacters(in: .whitespacesAndNewlines) guard !expression.isEmpty, expression.count <= 256, watches.count < 32 else { return } if !watches.contains(expression) { watches.append(expression) } watchExpression = "" if let watchKey { defaults.set(watches, forKey: watchKey) } } func removeWatch(_ expression: String) { watches.removeAll { $0 == expression } if let watchKey { defaults.set(watches, forKey: watchKey) } } var selectedBreakpoints: Set { Set(breakpoints.filter { $0.file == selectedFile }.map(\.line)) } var executableLines: [Int] { projectMapping?.executableLines(in: selectedFile) ?? [] } func confirmDiscard() -> Bool { guard unsaved else { return true } let alert = NSAlert(); alert.messageText = "Save changes to this project?" alert.informativeText = "\(documents.filter(\.dirty).count) open file(s) contain unsaved changes." alert.addButton(withTitle: "Save All"); alert.addButton(withTitle: "Cancel"); alert.addButton(withTitle: "Discard Changes") switch alert.runModal() { case .alertFirstButtonReturn: return save() case .alertThirdButtonReturn: for i in documents.indices { documents[i].text = documents[i].savedText } if let selected = documents.first(where: { $0.id == selectedFile }) { selecting = true; source = selected.text; selecting = false } persistDrafts(); return true default: return false } } func newProject() { guard !building, confirmDiscard() else { return } let choice = NSAlert(); choice.messageText = "Choose a C project template" choice.informativeText = "Hello Disk demonstrates multiple source files, generated data, disk-file reading and a settings-generated Makefile. Hello World asks you to pick Earth or Mars in a single C file. Talking Planet Lander uses two optional sound cartridges and a joystick. Each template creates an editable copy." choice.addButton(withTitle: "Hello Disk"); choice.addButton(withTitle: "Hello World"); choice.addButton(withTitle: "Talking Planet Lander"); choice.addButton(withTitle: "Cancel").keyEquivalent = "\u{1b}" let selection = choice.runModal() guard [.alertFirstButtonReturn, .alertSecondButtonReturn, .alertThirdButtonReturn].contains(selection) else { return } let diskTemplate = selection == .alertFirstButtonReturn let panel = NSSavePanel(); panel.title = "Create C Project Folder"; panel.nameFieldStringValue = diskTemplate ? "HelloDisk" : (selection == .alertThirdButtonReturn ? "TalkingPlanetLander" : "HelloCoCo") panel.canCreateDirectories = true; panel.prompt = "Create Project" guard panel.runModal() == .OK, let url = panel.url else { return } do { switch selection { case .alertFirstButtonReturn: try adopt(CMOCProject.createHelloDisk(at: url)) case .alertThirdButtonReturn: try adopt(CMOCProject.createTalkingLander(at: url)) default: try adopt(CMOCProject.create(at: url)) } } catch { message = error.localizedDescription } } func openProject() { guard !building, confirmDiscard() else { return } let panel = NSOpenPanel(); panel.title = "Open C Project"; panel.message = "Choose a project folder with a Makefile. Opening does not run its build commands." panel.canChooseDirectories = true; panel.canChooseFiles = false; panel.allowsMultipleSelection = false guard panel.runModal() == .OK, let url = panel.url else { return } recoveryProjectDirectory = url; refreshRecovery() do { try adopt(CMOCProject.open(at: url)) } catch { message = error.localizedDescription } } /// An explicit Library import opens known source without executing its Makefile. /// Recheck the workspace after asynchronous disk validation and after review. @discardableResult func openImportedProject(at directory: URL, expectedProjectID: UUID, preferredConfiguration: String? = nil, reviewUnsaved: (() -> Bool)? = nil) async throws -> Bool { func checkWorkspace() throws { guard assistantProjectID == expectedProjectID else { throw CMOCBuildError.message("The C project changed during the download. Your imported source is saved; open its folder when you are ready.") } guard !building, !commanding, !historyRemoving else { throw CMOCBuildError.message("Your imported source is saved. Wait for the current C operation to finish before opening its folder.") } } try checkWorkspace() let checked = try await Task.detached(priority: .userInitiated) { try CMOCProject.open(at: directory) }.value if let preferredConfiguration, !checked.configuration.configurations.contains(where: { $0.name == preferredConfiguration }) { throw CMOCBuildError.message("The source package's requested build configuration is missing. Your current project is kept.") } try Task.checkCancellation() try checkWorkspace() let accepted: Bool if let reviewUnsaved { accepted = reviewUnsaved() } else { accepted = try await reviewImportedProjectSwitch(expectedProjectID: expectedProjectID) } guard accepted else { return false } try checkWorkspace() try adopt(checked) if let preferredConfiguration { configurationName = preferredConfiguration } return true } private func reviewImportedProjectSwitch(expectedProjectID: UUID) async throws -> Bool { guard unsaved else { return true } guard let parent = NSApp.windows.first(where: { $0.identifier?.rawValue == "c-development" && $0.isVisible }) ?? NSApp.keyWindow else { throw CMOCBuildError.message("Your source copy is saved. Open C Development to review unsaved changes before switching projects.") } let alert = NSAlert(); alert.messageText = "Save changes to this project?" alert.informativeText = "\(documents.filter(\.dirty).count) open file(s) contain unsaved changes. Your downloaded source folder is already saved." alert.addButton(withTitle: "Save All"); alert.addButton(withTitle: "Cancel"); alert.addButton(withTitle: "Discard Changes") parent.makeKeyAndOrderFront(nil) let response = await LibraryReviewSheet(alert: alert, parent: parent).present() try Task.checkCancellation() guard assistantProjectID == expectedProjectID, !building, !commanding, !historyRemoving else { throw CMOCBuildError.message("The C workspace changed during review. Your imported folder and current project are kept.") } switch response { case .alertFirstButtonReturn: return save() case .alertThirdButtonReturn: for i in documents.indices { documents[i].text = documents[i].savedText } if let selected = documents.first(where: { $0.id == selectedFile }) { selecting = true; source = selected.text; selecting = false } persistDrafts(); return true default: return false } } func adopt(_ project: CMOCProject) throws { guard !building, !commanding, !historyRemoving else { throw CMOCBuildError.message("Wait for the current build or launch to finish before changing projects.") } persistDrafts() let entries = try project.fileEntries() let entry = project.configuration.entrySource let text = try project.readText(relativePath: entry) MCPCMOC.shared.closing(self) assistantProjectID = UUID() resetNavigation(); self.project = project; files = entries documents = [.init(id: entry, text: text, savedText: text, savedHash: CMOCProject.sha256(Data(text.utf8)))] selecting = true; selectedFile = entry; source = text; selecting = false pausedDebugSnapshot = nil; capturedCallStack = nil; selectedFrameIndex = 0; sourceStepping = false artifact = nil; mapping = nil; projectMapping = nil; loadedBuild = nil; loadedGeneration = nil; currentLine = nil; currentFile = nil; pc = nil variableMetadata = nil; variableStatus = "Build with the bundled compiler to inspect C variables." watches = watchKey.flatMap { defaults.stringArray(forKey: $0) }?.filter { !$0.isEmpty && $0.count <= 256 }.prefix(32).map { $0 } ?? [] watchExpression = "" breakpoints = []; externalBuildChange = false configurationName = project.configuration.configurations.first?.name ?? "Debug" revision = UUID(); message = nil; execution = "No build from this project loaded" log = "Opened \(project.directory.lastPathComponent). Build executes this project's Makefile." diagnostics = [] let previousAttempt = defaults.string(forKey: buildAttemptKey(project.directory)) latestBuildAttempt = previousAttempt == "In progress" ? "Previous build did not report completion; rebuild to continue" : "Not built in this session" rememberWorkspace() buildHistory = []; historyMessage = nil; recoveryRecords = []; recoveryIssues = [] recoveryProjectDirectory = project.directory; refreshRecovery(); refreshBuildHistory(); refreshProjectIndex() } func restoreWorkspace() { guard !restorationAttempted else { return }; restorationAttempted = true guard project == nil, let path = defaults.string(forKey: "CMOCWorkspace.directory") else { return } recoveryProjectDirectory = URL(fileURLWithPath: path); refreshRecovery() let tabs = defaults.stringArray(forKey: "CMOCWorkspace.tabs") ?? [] let selected = defaults.string(forKey: "CMOCWorkspace.selected") let configuration = defaults.string(forKey: "CMOCWorkspace.configuration") do { try adopt(CMOCProject.open(at: URL(fileURLWithPath: path))) if let configuration, project?.configuration.configurations.contains(where: { $0.name == configuration }) == true { configurationName = configuration } for tab in tabs where files.contains(where: { $0.relativePath == tab && $0.isEditable }) { openFile(tab) } if let selected, documents.contains(where: { $0.id == selected }) { openFile(selected) } } catch { message = "The previous project could not be reopened: \(error.localizedDescription)" } } private func rememberWorkspace() { guard let project else { return } defaults.set(project.directory.path, forKey: "CMOCWorkspace.directory") defaults.set(documents.filter { !$0.reference }.map(\.id), forKey: "CMOCWorkspace.tabs") defaults.set(selectedFile, forKey: "CMOCWorkspace.selected") defaults.set(configurationName, forKey: "CMOCWorkspace.configuration") } func openFile(_ requestedPath: String, line: Int? = nil) { let path = diagnosticPath(requestedPath) guard let project else { return } do { if indexInputs.referencePaths.contains(path), let text = indexInputs.documents[path] { let document = CMOCEditorDocument(id: path, text: text, savedText: text, savedHash: CMOCProject.sha256(Data(text.utf8)), reference: true) if let i = documents.firstIndex(where: { $0.id == path }) { documents[i] = document } else { documents.append(document) } } if !documents.contains(where: { $0.id == path }) { let diskText = try? project.readText(relativePath: path) guard let text = diskText ?? artifact?.sources[path].flatMap({ String(data: $0, encoding: .utf8) }) else { throw CMOCBuildError.message("This source file is unavailable: " + path) } documents.append(.init(id: path, text: text, savedText: text, savedHash: CMOCProject.sha256(Data(text.utf8)), generated: diskText == nil)) } guard let document = documents.first(where: { $0.id == path }) else { return } selecting = true; selectedFile = path; source = document.text; selecting = false mapping = projectMapping?.map(forFile: path) if !executableLines.contains(breakpointLine) { breakpointLine = executableLines.first ?? 1 } navigationLine = line; navigationColumn = nil; navigationLength = 0 cursorOffset = min(cursorOffsets[path] ?? 0, source.utf16.count) clearParameterHints(); scheduleParameterHints() navigationRequest = UUID(); rememberWorkspace() } catch { message = error.localizedDescription } } private func diagnosticPath(_ path: String) -> String { guard path.hasPrefix("/") else { return path } if let project, path.hasPrefix(project.directory.path + "/") { return String(path.dropFirst(project.directory.path.count + 1)) } // Compile diagnostics use the controlled .workspaces//project root. // Require a known complete project-relative suffix; never match a basename. if let range = path.range(of: "/project/", options: .backwards), (path.contains("/.workspaces/") || path.hasPrefix("/private/tmp/vccplus-cmoc-")) { let relative = String(path[range.upperBound...]) if files.contains(where: { $0.relativePath == relative }) { return relative } } return path } func closeFile(_ path: String) { guard let document = documents.first(where: { $0.id == path }) else { return } if document.dirty { let alert = NSAlert(); alert.messageText = "Save changes to \(path)?" alert.addButton(withTitle: "Save"); alert.addButton(withTitle: "Cancel"); alert.addButton(withTitle: "Discard") let result = alert.runModal() if result == .alertSecondButtonReturn { return } if result == .alertFirstButtonReturn && !saveFile(path) { return } } // Keep the final tab visible, but honor the user's Save/Discard decision. if documents.count == 1 { if let text = try? project?.readText(relativePath: path) { documents[0] = .init(id: path, text: text, savedText: text, savedHash: CMOCProject.sha256(Data(text.utf8))) selecting = true; source = text; selecting = false } else { documents[0].text = documents[0].savedText selecting = true; source = documents[0].text; selecting = false } persistDrafts(); return } documents.removeAll { $0.id == path } if selectedFile == path, let first = documents.first { openFile(first.id) } rememberWorkspace(); persistDrafts() } /// Prepare all affected editor drafts before publishing any of them. Files /// stay on disk until the user explicitly saves through the normal workspace. func applyAssistantEdits(_ edits: [MCPCMOCEdit], disk: [String: String], projectID: UUID, epoch: Int, undoing: Bool = false) throws { guard assistantProjectID == projectID, assistantEditEpoch == epoch, !building, !commanding, assistantEditor?.hasMarkedText() != true else { throw CMOCBuildError.message("stale_revision") } var updated = documents for edit in edits { guard let saved = disk[edit.path] else { throw CMOCBuildError.message("stale_revision") } if let i = updated.firstIndex(where: { $0.id == edit.path }) { guard !updated[i].conflict, !updated[i].missing, !updated[i].reference, !updated[i].generated, updated[i].text.utf8.elementsEqual(edit.before.utf8), updated[i].savedText.utf8.elementsEqual(saved.utf8) else { throw CMOCBuildError.message("stale_revision") } updated[i].text = edit.after } else { guard saved.utf8.elementsEqual(edit.before.utf8) else { throw CMOCBuildError.message("stale_revision") } updated.append(.init(id: edit.path, text: edit.after, savedText: saved, savedHash: CMOCProject.sha256(Data(saved.utf8)))) } } assistantEditorPool?.setReviewedBuffers(edits, undoing: undoing) documents = updated if let selected = updated.first(where: { $0.id == selectedFile }) { selecting = true; source = selected.text; selecting = false } assistantEditEpoch += 1 rememberWorkspace(); persistDrafts(); scheduleParameterHints() } /// Adopt an already captured and reviewed disk/configuration snapshot. /// Clean tabs follow external edits; dirty drafts keep their exact bytes and /// can only continue when their saved disk base is still unchanged. func acceptAssistantProjectRefresh(_ updatedProject: CMOCProject, diskFiles: [String: Data], projectID: UUID, epoch: Int) throws { guard assistantProjectID == projectID, assistantEditEpoch == epoch, project?.directory == updatedProject.directory, !building, !commanding, assistantEditor?.hasMarkedText() != true else { throw CMOCBuildError.message("stale_revision") } var updated = documents for index in updated.indices where !updated[index].generated && !updated[index].reference { let document = updated[index] let bytes = diskFiles[document.id] if document.dirty || document.conflict { guard let bytes, CMOCProject.sha256(bytes) == document.savedHash, !document.conflict else { throw CMOCBuildError.message("external_file_change: " + document.id + ": Your editor draft is kept; resolve its disk conflict locally before refreshing.") } continue } guard let bytes, let text = String(data: bytes, encoding: .utf8), !bytes.contains(0) else { updated[index].missing = true; continue } updated[index].text = text; updated[index].savedText = text updated[index].savedHash = CMOCProject.sha256(bytes) updated[index].missing = false; updated[index].conflict = false } self.project = updatedProject files = diskFiles.keys.sorted().map { .init(relativePath: $0, isEditable: CMOCProject.isEditable($0)) } documents = updated if let selected = updated.first(where: { $0.id == selectedFile }) { selecting = true; source = selected.text; selecting = false } if !updatedProject.configuration.configurations.contains(where: { $0.name == configurationName }) { configurationName = updatedProject.configuration.configurations.first?.name ?? "Debug" } externalBuildChange = true rememberWorkspace(); persistDrafts(); scheduleProjectIndex() } @discardableResult func saveFile(_ path: String) -> Bool { guard let project, let index = documents.firstIndex(where: { $0.id == path }) else { return false } guard !documents[index].generated && !documents[index].reference else { message = "Reference and generated source is read-only. Edit project sources or generator inputs."; return false } do { let hash = try project.saveText(documents[index].text, relativePath: path, replacingSHA256: documents[index].savedHash) documents[index].savedHash = hash; documents[index].savedText = documents[index].text; documents[index].conflict = false message = nil; persistDrafts(); return true } catch { message = error.localizedDescription; return false } } @discardableResult func save() -> Bool { guard project != nil else { message = "Create a project before saving."; return false } for path in documents.filter(\.dirty).map(\.id) { if !saveFile(path) { return false } } return true } func reloadSelected() { guard let project else { return } if documents.first(where: { $0.id == selectedFile })?.reference == true { refreshProjectIndex(); return } if documents.first(where: { $0.id == selectedFile })?.dirty == true { let alert = NSAlert(); alert.messageText = "Reload \(selectedFile) from disk?" alert.informativeText = "This discards unsaved edits in this file." alert.addButton(withTitle: "Cancel"); alert.addButton(withTitle: "Reload") guard alert.runModal() == .alertSecondButtonReturn else { return } } do { let text = try project.readText(relativePath: selectedFile) if let i = documents.firstIndex(where: { $0.id == selectedFile }) { documents[i] = .init(id: selectedFile, text: text, savedText: text, savedHash: CMOCProject.sha256(Data(text.utf8))) selecting = true; source = text; selecting = false; message = nil; persistDrafts() } } catch { message = error.localizedDescription } } func addFile() { guard !building, !commanding, let project else { return } let panel = NSSavePanel(); panel.title = "New Project File"; panel.nameFieldStringValue = "module.c"; panel.directoryURL = project.directory guard panel.runModal() == .OK, let url = panel.url else { return } let prefix = project.directory.standardizedFileURL.path + "/" guard url.standardizedFileURL.path.hasPrefix(prefix) else { message = "Choose a location inside this project."; return } do { guard !FileManager.default.fileExists(atPath: url.path) else { throw CMOCBuildError.message("Choose a new filename; existing files are kept.") } let path = String(url.standardizedFileURL.path.dropFirst(prefix.count)) _ = try project.fileURL(relativePath: path) try Data().write(to: url, options: .withoutOverwriting) files = try project.fileEntries(); openFile(path) } catch { message = error.localizedDescription } } func editProjectConfiguration() { guard let project else { return } do { let url = project.directory.appendingPathComponent("vccplus-project.json") if !FileManager.default.fileExists(atPath: url.path) { let encoder = JSONEncoder(); encoder.outputFormatting = [.prettyPrinted, .sortedKeys] try encoder.encode(project.configuration).write(to: url, options: .withoutOverwriting) } files = try project.fileEntries(); openFile("vccplus-project.json") log = "Project settings are ordinary JSON. Save before building to apply changes; Makefile rules remain authoritative." } catch { message = error.localizedDescription } } func applyProjectSettings(_ configuration: CMOCProjectConfiguration, makefile: String?, expectedMakefileHash: String, expectedConfigHash: String?) throws { guard let project, !building, !commanding else { return } let configPath = CMOCProject.configurationFilename guard !documents.contains(where: { ($0.id == project.configuration.makefile || $0.id == configPath) && $0.dirty }) else { throw CMOCBuildError.message("Save or reload your edited Makefile and project settings before applying this window.") } let validated = try configuration.validated() let originalMakefile = try project.readText(relativePath: project.configuration.makefile) guard CMOCProject.sha256(Data(originalMakefile.utf8)) == expectedMakefileHash else { throw CMOCBuildError.message("The Makefile changed while Project Settings was open. Reopen settings to review it.") } let configURL = try project.fileURL(relativePath: configPath) let oldConfig = try? Data(contentsOf: configURL) guard oldConfig.map(CMOCProject.sha256) == expectedConfigHash else { throw CMOCBuildError.message("Project settings changed outside this window. Reopen settings to review them.") } let encoder = JSONEncoder(); encoder.outputFormatting = [.prettyPrinted, .sortedKeys] let configData = try encoder.encode(validated) // Keep the Makefile's previous version recoverable when regenerating. if let makefile, makefile != originalMakefile { let backups = project.directory.appendingPathComponent(".vccplus-build/Makefile Backups") try FileManager.default.createDirectory(at: backups, withIntermediateDirectories: true) try Data(originalMakefile.utf8).write(to: backups.appendingPathComponent(UUID().uuidString + ".make"), options: .atomic) _ = try project.saveText(makefile, relativePath: project.configuration.makefile, replacingSHA256: expectedMakefileHash) } do { try configData.write(to: configURL, options: .atomic) } catch { if makefile != nil { try? Data(originalMakefile.utf8).write(to: project.makefileURL, options: .atomic) } throw error } self.project = CMOCProject(directory: project.directory, configuration: validated) for path in [configPath, project.configuration.makefile] { if let i = documents.firstIndex(where: { $0.id == path }), let value = try? self.project?.readText(relativePath: path) { documents[i] = .init(id: path, text: value, savedText: value, savedHash: CMOCProject.sha256(Data(value.utf8))) if selectedFile == path { selecting = true; source = value; selecting = false } } } files = try self.project!.fileEntries(); externalBuildChange = true if !validated.configurations.contains(where: { $0.name == configurationName }) { configurationName = validated.configurations.first!.name } refreshProjectIndex() message = nil; log = makefile == nil ? "Project settings saved. The custom Makefile was kept." : "Project settings and Makefile saved. The previous Makefile is retained in .vccplus-build/Makefile Backups." } func build() { build(.build) } func build(_ action: CMOCBuildAction, target: String? = nil) { guard let project, !building, !commanding, !historyRemoving else { return } pausedDebugSnapshot = nil; capturedCallStack = nil; selectedFrameIndex = 0; sourceStepping = false defaults.set("In progress", forKey: buildAttemptKey(project.directory)) building = true; message = nil; currentLine = nil; currentFile = nil; latestBuildAttempt = "Building \(configurationName)…"; persistDrafts() revision = UUID() variableStatus = "Building C debug information…" log = "Building a project snapshot…"; diagnostics = [] let inputs = overlays; let configuration = configurationName task = Task { defer { defaults.set(latestBuildAttempt, forKey: buildAttemptKey(project.directory)) building = false; task = nil; checkExternalFiles(); refreshBuildHistory(); refreshProjectIndex() } do { let built = try await service.build(project: project, overlays: inputs, action: action, configuration: configuration, target: target) try Task.checkCancellation() log = built.buildLog latestBuildAttempt = "\(action == .clean ? "Clean" : "Build") succeeded" guard built.hasBinary || built.hasDisk else { execution = "Build action finished; the last runnable build and machine are unchanged" return } var nextMapping: CMOCProjectSourceMap? var nextVariables: CMOCVariableDebug? diagnostics = Self.parseDiagnostics(built.buildLog, directory: built.compilationDirectory) variableStatus = "This build has no verified C variable information." if built.hasBinary { do { let verified = try await Task.detached(priority: .userInitiated) { try CMOCProjectSourceMap.parse(artifact: built) }.value try Task.checkCancellation() nextMapping = verified log += "\nVerified source locations in \(verified.sourcePaths.count) C file(s)." do { nextVariables = try await Task.detached(priority: .userInitiated) { try CMOCVariableDebug.parse(artifact: built, verifiedMap: verified) }.value try Task.checkCancellation() variableStatus = "Compiler types and locations verified." } catch is CancellationError { throw CancellationError() } catch { variableStatus = error.localizedDescription } } catch is CancellationError { throw CancellationError() } catch { log += "\nBuild succeeded. Source debugging unavailable: \(error.localizedDescription)" } } try Task.checkCancellation() artifact = built; projectMapping = nextMapping; mapping = nextMapping?.map(forFile: selectedFile); variableMetadata = nextVariables pausedDebugSnapshot = nil; capturedCallStack = nil if let data = try? Data(contentsOf: built.fileURL(CMOCProject.configurationFilename)), let config = try? JSONDecoder().decode(CMOCProjectConfiguration.self, from: data).validated() { self.project = CMOCProject(directory: project.directory, configuration: config) } for i in documents.indices where documents[i].generated { if let data = built.sources[documents[i].id], let text = String(data: data, encoding: .utf8) { documents[i].text = text; documents[i].savedText = text; documents[i].savedHash = CMOCProject.sha256(data) if selectedFile == documents[i].id { selecting = true; source = text; selecting = false } } } if !executableLines.contains(breakpointLine) { breakpointLine = executableLines.first ?? 1 } execution = "Build finished; the machine has not been changed" } catch is CancellationError { latestBuildAttempt = "Build cancelled"; variableStatus = "Build cancelled; the last successful result is retained."; log = "Build cancelled. The last successful result and machine are unchanged." } catch { message = error.localizedDescription; log = error.localizedDescription latestBuildAttempt = "Build failed"; variableStatus = "Build failed; the last successful result is retained." diagnostics = Self.parseDiagnostics(log, directory: nil) } } } func cancelBuild() { task?.cancel(); service.cancel() } static func parseDiagnostics(_ text: String, directory: URL?) -> [CMOCBuildDiagnostic] { guard let regex = try? NSRegularExpression(pattern: #"^(.+?):([0-9]+)(?::[0-9]+)?:\s*(.+)$"#) else { return [] } return text.components(separatedBy: .newlines).compactMap { line in let ns = line as NSString guard let m = regex.firstMatch(in: line, range: NSRange(location: 0, length: ns.length)), let number = Int(ns.substring(with: m.range(at: 2))), number > 0 else { return nil } var file = ns.substring(with: m.range(at: 1)) if let directory, file.hasPrefix(directory.path + "/") { file = String(file.dropFirst(directory.path.count + 1)) } if file.hasPrefix("./") { file = String(file.dropFirst(2)) } return .init(file: file, line: number, message: ns.substring(with: m.range(at: 3))) } } func toggleBreakpoint(_ line: Int) { guard !commanding, !building else { return } guard machine.pasteRemaining == 0 else { message = "Wait for the launch commands to finish before changing source breakpoints."; return } let point = CMOCSourceBreakpoint(file: selectedFile, line: line) if breakpoints.contains(point) { breakpoints.remove(point) } else { breakpoints.insert(point); breakpointLine = line } updateLiveBreakpoints() } private func updateLiveBreakpoints() { guard loadedMatchesEditor, let artifact, let projectMapping, canCommand else { return } let points = sourceBreakpointAddresses(includeFallback: false) let wasRunning = machine.state == .running let wasSourceStepping = sourceStepping let wasAwaitingDiskLoad = awaitingDiskLoad let expectedGeneration = loadedGeneration, expectedRevision = loadedRevision, expectedMapping = loadedMapping // Discard an older poll already in flight while this command changes the // breakpoint set. A source edit is still caught by loadedMatchesEditor. revision = UUID(); let request = revision commanding = true let unchanged: (VCCMachineSnapshot) -> Bool = { snapshot in snapshot.generation == expectedGeneration && snapshot.debuggerProgramRevision == expectedRevision && (projectMapping.bankedLayout != nil || wasAwaitingDiskLoad || snapshot.debuggerMappingFingerprint == expectedMapping) } let invalidate: (String) -> Void = { [weak self] text in guard let self else { return } loadedBuild = nil; loadedGeneration = nil; awaitingDiskLoad = false currentLine = nil; currentFile = nil; pc = nil; execution = text // Never leave this feature's old addresses armed in a changed MMU // layout, and never resume a machine that changed during the command. machine.clearDevelopmentBreakpoints { [weak self] in self?.commanding = false } } let finish = { [weak self] in guard let self else { return } if wasRunning && !wasSourceStepping { machine.debuggerContinue { [weak self] in self?.commanding = false; self?.refresh() } } else { commanding = false; refresh() } } machine.debuggerPause { [weak self] in guard let self else { return } machine.readDebugger(address: 0, followPC: true, memoryAddress: 0) { [weak self] detail in guard let self else { return } guard revision == request, loadedMatchesEditor, let detail, unchanged(detail.machine), detail.machine.errorMessage == nil else { invalidate("Machine or project changed; run the build again before updating source breakpoints"); return } if points.isEmpty, projectMapping.bankedLayout != nil { // Removing the last stop does not discard verified bank // evidence needed by Pause, source steps and watches. machine.armDevelopmentBreakpoints([], sourceMap: projectMapping, pointModules: [:]) { [weak self] snapshot in guard let self else { return } guard revision == request, loadedMatchesEditor, let snapshot, snapshot.errorMessage == nil, unchanged(snapshot) else { invalidate(snapshot?.errorMessage ?? "Machine changed while updating source breakpoints"); return } attach(artifact, snapshot: snapshot); awaitingDiskLoad = wasAwaitingDiskLoad finish() } } else if points.isEmpty { machine.clearDevelopmentBreakpoints { [weak self] in guard let self else { return } if wasAwaitingDiskLoad { loadedBuild = nil; loadedGeneration = nil; currentLine = nil; currentFile = nil; pc = nil execution = "Source breakpoints cleared before the disk program was verified" } awaitingDiskLoad = false; finish() } } else { machine.armDevelopmentBreakpoints(points, sourceMap: projectMapping, pointModules: sourceBreakpointModules(includeFallback: false)) { [weak self] snapshot in guard let self else { return } guard revision == request, loadedMatchesEditor, let snapshot, snapshot.errorMessage == nil, unchanged(snapshot) else { invalidate(snapshot?.errorMessage ?? "Machine changed while updating source breakpoints; run the build again"); return } // Rearming doesn't replace code. Retain a previously // verified paused source connection so instruction steps // keep updating even before another breakpoint is hit. // An unverified disk launch, however, must keep waiting. attach(artifact, snapshot: snapshot) awaitingDiskLoad = wasAwaitingDiskLoad finish() } } } } } /// Every compiled instance of a C line owns its own module-qualified stop. /// Ordinary flat programs retain their first mapped address per line. private func sourceBreakpointSelection(includeFallback: Bool) -> [(UInt16, String?)] { guard let projectMapping else { return [] } func selection(_ point: CMOCSourceBreakpoint) -> [(UInt16, String?)] { let code = projectMapping.instructions.filter { $0.sourcePath == point.file && $0.sourceLine == point.line } if projectMapping.bankedLayout == nil { return code.first.map { [($0.address, nil)] } ?? [] } return Dictionary(grouping: code, by: { $0.moduleID ?? "" }).values.compactMap { group in group.min(by: { $0.address < $1.address }).map { ($0.address, $0.moduleID) } } } let configured = breakpoints.flatMap(selection) if configured.isEmpty && includeFallback { return selection(CMOCSourceBreakpoint(file: selectedFile, line: breakpointLine)) } return configured } private func sourceBreakpointAddresses(includeFallback: Bool) -> [UInt16] { Array(Set(sourceBreakpointSelection(includeFallback: includeFallback).map { $0.0 })).sorted() } private func sourceBreakpointModules(includeFallback: Bool) -> [UInt16: Set] { var result: [UInt16: Set] = [:] for (address, module) in sourceBreakpointSelection(includeFallback: includeFallback) { if let module { result[address, default: []].insert(module) } } return result } /// Normal launches use only breakpoints the user explicitly added. var resolvedBreakpointAddresses: [UInt16] { buildMatchesEditor ? sourceBreakpointAddresses(includeFallback: false) : [] } /// The selected-line fallback belongs only to the explicit Run to Breakpoint action. var runToBreakpointAddresses: [UInt16] { buildMatchesEditor ? sourceBreakpointAddresses(includeFallback: true) : [] } func confirmRun() { guard canRun else { return } if projectMapping?.bankedLayout != nil { confirmDiskLaunch(toBreakpoint: true); return } let alert = NSAlert(); alert.messageText = "Run C program in this CoCo?" alert.informativeText = "This replaces program memory without restarting or changing mounted media, then runs to a verified source breakpoint. Use a booted Disk BASIC machine. Save any BASIC program you want to keep first." alert.addButton(withTitle: "Run to Breakpoint"); alert.addButton(withTitle: "Cancel") if alert.runModal() == .alertFirstButtonReturn { run() } } func run() { checkExternalFiles() guard canRun, let artifact else { return } if projectMapping?.bankedLayout != nil { launchDisk(commands: project?.configuration.launchCommands ?? [], toBreakpoint: true); return } let addresses = runToBreakpointAddresses guard !addresses.isEmpty else { return } commanding = true; message = nil; currentLine = nil; revision = UUID() machine.prepareToQuit { [weak self] in guard let self else { return } guard !machine.unsavedMedia else { commanding = false; message = "Save or export pending media before running. The machine is paused."; return } guard buildMatchesEditor, self.artifact?.id == artifact.id else { commanding = false; message = "Project changed. Build again before running."; return } machine.debuggerLoadDevelopmentBinary(artifact.binaryData, breakpoints: addresses) { [weak self] snapshot in guard let self else { return }; commanding = false guard let snapshot else { message = "The machine became unavailable."; return } if let error = snapshot.errorMessage { message = error; return } attach(artifact, snapshot: snapshot); execution = "Running to source breakpoint"; refresh() } } } private func attach(_ artifact: CMOCBuildArtifact, snapshot: VCCMachineSnapshot) { trackLaunch(artifact, snapshot: snapshot) loadedBuild = artifact.id; loadedGeneration = snapshot.generation loadedRevision = snapshot.debuggerProgramRevision; loadedMapping = snapshot.debuggerMappingFingerprint } func launch() { checkExternalFiles() guard canLaunch, let project, let artifact else { return } if project.configuration.launchMode == .disk || (!artifact.hasBinary && artifact.hasDisk) { confirmDiskLaunch(); return } if !resolvedBreakpointAddresses.isEmpty { guard canRun else { message = "Banked source debugging needs a declared disk image. Clear source breakpoints to run this binary without source debugging."; return } confirmRun(); return } let alert = NSAlert(); alert.messageText = "Load and run the built program?" alert.informativeText = "This replaces CoCo program memory and runs without a source breakpoint. Mounted media and machine settings are kept." alert.addButton(withTitle: "Cancel"); alert.addButton(withTitle: "Run") guard alert.runModal() == .alertSecondButtonReturn else { return } launchQuickload() } /// Confirmation-free execution shared with regression tests; the UI confirms first. func launchQuickload() { checkExternalFiles() guard canLaunch, let artifact, artifact.hasBinary else { return } commanding = true; revision = UUID() machine.prepareToQuit { [weak self] in guard let self else { return } guard !machine.unsavedMedia, buildMatchesEditor, self.artifact?.id == artifact.id else { commanding = false; message = "Save pending media and rebuild changed sources before running."; return } machine.runDevelopmentBinary(artifact.binaryData) { [weak self] snapshot in guard let self else { return } commanding = false guard let snapshot, snapshot.errorMessage == nil else { message = snapshot?.errorMessage ?? "Program launch failed."; return } loadedBuild = nil; loadedGeneration = nil; awaitingDiskLoad = false pausedDebugSnapshot = nil; currentLine = nil; currentFile = nil; pc = nil trackLaunch(artifact, snapshot: snapshot) execution = "Program running without source breakpoints" } } } func confirmDiskLaunch(toBreakpoint: Bool = false) { guard canLaunch, let artifact, artifact.hasDisk, let project else { message = "Build a disk target first."; return } guard machine.diskEnabled else { message = "Select a machine profile with its floppy controller enabled before launching this disk."; return } let commands = project.configuration.launchCommands let alert = NSAlert(); alert.messageText = "Mount the development disk in FD0?" alert.informativeText = "This replaces the current FD0 assignment with a separate working copy of the build disk. Pending media must be saved first. Machine settings are kept.\n\n" + (commands.isEmpty ? "No commands will be typed. Load or boot the program yourself." : "At the BASIC prompt, these commands will be typed:\n" + commands.joined(separator: "\n")) alert.addButton(withTitle: "Mount and Launch"); alert.addButton(withTitle: "Cancel") guard alert.runModal() == .alertFirstButtonReturn else { return } launchDisk(commands: commands, toBreakpoint: toBreakpoint) } func launchDisk(commands: [String], toBreakpoint: Bool = false) { checkExternalFiles() guard let artifact, let diskPath = artifact.diskRelativePath, canLaunch else { return } commanding = true; message = nil; revision = UUID() machine.prepareToQuit { [weak self] in guard let self else { return } guard !machine.unsavedMedia, buildMatchesEditor, self.artifact?.id == artifact.id else { commanding = false; message = "Save pending media and rebuild changed sources before mounting the development disk."; return } do { let copyFolder = machine.developmentRunDirectory.appendingPathComponent("Run-\(UUID().uuidString)") try FileManager.default.createDirectory(at: copyFolder, withIntermediateDirectories: true) let copy = copyFolder.appendingPathComponent(URL(fileURLWithPath: diskPath).lastPathComponent) try FileManager.default.copyItem(at: artifact.fileURL(diskPath), to: copy) machine.mountDevelopmentDisk(copy) { [weak self] snapshot in guard let self else { return } guard let snapshot, snapshot.errorMessage == nil else { commanding = false; message = snapshot?.errorMessage ?? "Disk mounting failed."; return } trackLaunch(artifact, snapshot: snapshot) armDiskAndResume(artifact: artifact, commands: commands, toBreakpoint: toBreakpoint) } } catch { commanding = false; message = error.localizedDescription } } } private func armDiskAndResume(artifact: CMOCBuildArtifact, commands: [String], toBreakpoint: Bool = false) { let addresses = toBreakpoint ? runToBreakpointAddresses : resolvedBreakpointAddresses let finish = { [weak self] in guard let self else { return } machine.debuggerContinue { [weak self] in guard let self else { return }; commanding = false do { if !commands.isEmpty { machine.startPaste(try CocoPaste(commands.joined(separator: "\n") + "\n", mode: .text)) } } catch { message = error.localizedDescription } } } guard let projectMapping, !addresses.isEmpty else { // A prior debugging run may still own temporary source breakpoints. // Clear only that set before booting; retain the assembly debugger's breakpoints. loadedBuild = nil; loadedGeneration = nil; awaitingDiskLoad = false pausedDebugSnapshot = nil; currentLine = nil; currentFile = nil; pc = nil execution = "Development disk mounted; running without source breakpoints" machine.clearDevelopmentBreakpoints(completion: finish) return } machine.armDevelopmentBreakpoints(addresses, sourceMap: projectMapping, pointModules: sourceBreakpointModules(includeFallback: toBreakpoint)) { [weak self] snapshot in guard let self else { return } guard let snapshot, snapshot.errorMessage == nil else { commanding = false; message = snapshot?.errorMessage ?? "Cannot arm disk breakpoints."; return } attach(artifact, snapshot: snapshot); awaitingDiskLoad = true execution = "Waiting for the disk loader to reach verified program code"; finish() } } func revealBuild() { if let artifact { NSWorkspace.shared.open(artifact.directory) } } func toggleExecution() { guard canCommand else { return }; commanding = true pausedDebugSnapshot = nil; revision = UUID() let complete = { [weak self] in self?.commanding = false; self?.refresh() } if machine.state == .running { machine.debuggerPause(completion: complete) } else { machine.debuggerContinue(completion: complete) } } func stepInstruction() { guard canCommand, machine.state == .paused else { return }; commanding = true pausedDebugSnapshot = nil; revision = UUID() machine.debuggerStep { [weak self] in self?.commanding = false; self?.refresh() } } func stepSource(_ mode: CMOCSourceStepMode) { checkExternalFiles() guard canStepC, let projectMapping, let snapshot = pausedDebugSnapshot else { return } var identities: [String: UInt32] = [:] let instructions = projectMapping.instructions let locations = instructions.map { instruction -> NSNumber in let key = "\(instruction.moduleID ?? ""):\(instruction.sourcePath):\(instruction.sourceLine)" if identities[key] == nil { identities[key] = UInt32(identities.count + 1) } return NSNumber(value: identities[key]!) } commanding = true; sourceStepping = true; message = nil; revision = UUID() pausedDebugSnapshot = nil; currentLine = nil; currentFile = nil machine.debuggerStepSource(mode: mode.rawValue, addresses: instructions.map { NSNumber(value: $0.address) }, locations: locations, bytes: instructions.map { Data($0.bytes) }, expected: snapshot.machine, moduleIdentifiers: projectMapping.bankedLayout == nil ? nil : instructions.map { $0.moduleID ?? "" }) { [weak self] in guard let self else { return } commanding = false if let error = machine.fileError { message = error } refresh() } } func checkExternalFiles() { guard !building, let project else { return } do { let entries = try project.fileEntries() if entries.map(\.relativePath) != files.map(\.relativePath) { files = entries } for index in documents.indices where !documents[index].generated && !documents[index].reference { guard let disk = try? project.readText(relativePath: documents[index].id) else { documents[index].missing = true; externalBuildChange = true message = "\(documents[index].id) is missing or unreadable. Its editor contents are kept; use Save Selected Copy to recover them." scheduleDraftSave(); continue } documents[index].missing = false let hash = CMOCProject.sha256(Data(disk.utf8)) guard hash != documents[index].savedHash else { continue } if documents[index].dirty || documents[index].conflict { if !documents[index].conflict { documents[index].conflict = true; message = "\(documents[index].id) changed outside VCC Plus. Your edits are kept; use Reload File to accept the disk version." } } else { documents[index].text = disk; documents[index].savedText = disk; documents[index].savedHash = hash if selectedFile == documents[index].id { selecting = true; source = disk; selecting = false } } } if let artifact { let hashes = try project.currentFileHashes(overlays: overlays) let changed = hashes != artifact.fileHashes if externalBuildChange != changed { externalBuildChange = changed } } } catch { if message != error.localizedDescription { message = error.localizedDescription }; externalBuildChange = true } } private func scheduleExternalCheck() { guard !building, !checkingFiles, let project else { return } checkingFiles = true let saved = Dictionary(uniqueKeysWithValues: documents.map { ($0.id, $0.savedHash) }) let request = revision Task { defer { checkingFiles = false } do { let filesOnDisk = try await Task.detached(priority: .utility) { try project.inputFiles() }.value let hashes = await Task.detached(priority: .utility) { filesOnDisk.mapValues(CMOCProject.sha256) }.value let supportHashes = try await Task.detached(priority: .utility) { var captured = project if let bytes = filesOnDisk[CMOCProject.configurationFilename] { captured.configuration = try JSONDecoder().decode(CMOCProjectConfiguration.self, from: bytes).validated() } return try captured.supportFileHashes() }.value guard !building, revision == request, self.project?.directory == project.directory, saved == Dictionary(uniqueKeysWithValues: documents.map { ($0.id, $0.savedHash) }) else { return } let entries = filesOnDisk.keys.sorted().map { CMOCProjectFile(relativePath: $0, isEditable: CMOCProject.isEditable($0)) } if entries != files { files = entries } for index in documents.indices where !documents[index].generated && !documents[index].reference { guard let bytes = filesOnDisk[documents[index].id], let disk = String(data: bytes, encoding: .utf8), let hash = hashes[documents[index].id] else { if !documents[index].missing { documents[index].missing = true message = "\(documents[index].id) is missing or unreadable. Its editor contents are kept; use Save Selected Copy to recover them." scheduleDraftSave() } continue } documents[index].missing = false guard hash != documents[index].savedHash else { continue } if documents[index].dirty || documents[index].conflict { if !documents[index].conflict { documents[index].conflict = true message = "\(documents[index].id) changed outside VCC Plus. Your edits are kept; reload the file to accept the disk version." } } else { documents[index].text = disk; documents[index].savedText = disk; documents[index].savedHash = hash if selectedFile == documents[index].id { selecting = true; source = disk; selecting = false } } } let textHashes = hashes.filter { CMOCProject.isEditable($0.key) } if textHashes != navigationDiskHashes { navigationDiskHashes = textHashes; scheduleProjectIndex() } if let artifact { var current = hashes.merging(supportHashes) { first, _ in first } for (path, text) in overlays { current[path] = CMOCProject.sha256(Data(text.utf8)) } let changed = current != artifact.fileHashes if changed != externalBuildChange { externalBuildChange = changed } } } catch { guard self.project?.directory == project.directory else { return } if message != error.localizedDescription { message = error.localizedDescription } externalBuildChange = true } } } static func physicalPages(_ snapshot: VCCDebuggerSnapshot) -> [Int: Int] { Dictionary(uniqueKeysWithValues: snapshot.mmu.effective.enumerated().filter { $0.element.source == 0 }.map { ($0.offset, Int($0.element.sourceAddress) / 8192) }) } func refresh() { if Date() >= nextFileCheck { nextFileCheck = Date().addingTimeInterval(3); scheduleExternalCheck() } guard (loadedBuild != nil || launchedBuildID != nil), !building, !reading, !commanding else { return } reading = true; let request = revision; let epoch = machine.inputEpoch machine.readDebugger(address: 0, followPC: true, memoryAddress: 0) { [weak self] snapshot in guard let self else { return }; reading = false guard revision == request, machine.inputEpoch == epoch, let snapshot else { return } if launchedGeneration != snapshot.machine.generation || launchedRevision != snapshot.machine.debuggerProgramRevision { launchedBuildID = nil; launchedGeneration = nil; launchedRevision = nil } guard loadedBuild != nil else { return } let previousSnapshot = pausedDebugSnapshot let previousEpoch = pausedInputEpoch pausedDebugSnapshot = nil sourceStepping = snapshot.machine.debuggerSourceStepping if loadedGeneration != snapshot.machine.generation || loadedRevision != snapshot.machine.debuggerProgramRevision || (!awaitingDiskLoad && projectMapping?.bankedLayout == nil && loadedMapping != snapshot.machine.debuggerMappingFingerprint) { loadedBuild = nil; loadedGeneration = nil; currentLine = nil; currentFile = nil; pc = nil execution = "Machine changed; run the build again to reconnect source locations"; return } guard loadedMatchesEditor else { publishStop(nil, file: nil, line: nil, text: "Project changed; build again before using source locations"); return } if awaitingDiskLoad { guard snapshot.machine.debuggerDevelopmentAttached else { return } awaitingDiskLoad = false; loadedMapping = snapshot.machine.debuggerMappingFingerprint } if snapshot.machine.state == .running { publishStop(nil, file: nil, line: nil, text: sourceStepping ? "Stepping through C — Pause to stop" : "Running"); return } let address = snapshot.machine.programCounter let activeMap = projectMapping?.projected(physicalPages: Self.physicalPages(snapshot), memory: snapshot.logicalMemory, available: snapshot.logicalMemoryAvailable) guard let instruction = activeMap?.instruction(at: address), let live = snapshot.instructions.first, live.address == instruction.address, Array(live.bytes) == instruction.bytes else { publishStop(address, file: nil, line: nil, text: "Paused at \(String(format: "$%04X", address)) — no verified C line here; use Debugger for assembly"); return } // Variable locations are valid only while all mapped code still matches. // Inspection reads the same immutable snapshot as PC and registers. let memory = snapshot.logicalMemory, available = snapshot.logicalMemoryAvailable let codeMatches = (projectMapping?.bankedLayout == nil || snapshot.machine.debuggerDevelopmentAttached) && activeMap?.verifiesRuntime(memory: memory, available: available) == true if codeMatches { pausedDebugSnapshot = snapshot; pausedInputEpoch = epoch let sameStop = previousEpoch == epoch && previousSnapshot?.machine.programCounter == address && previousSnapshot?.machine.debuggerMappingFingerprint == snapshot.machine.debuggerMappingFingerprint && previousSnapshot?.registers["U"] == snapshot.registers["U"] && previousSnapshot?.registers["S"] == snapshot.registers["S"] && previousSnapshot?.logicalMemory == snapshot.logicalMemory && previousSnapshot?.logicalMemoryAvailable == snapshot.logicalMemoryAvailable if !sameStop { inspectionRevision = UUID() selectedFrameIndex = 0 capturedCallStack = variableMetadata.flatMap { metadata in guard let u = snapshot.registers["U"], let s = snapshot.registers["S"] else { return nil } return CMOCCallStack.capture(metadata: metadata.projected(physicalPages: Self.physicalPages(snapshot), memory: snapshot.logicalMemory, available: snapshot.logicalMemoryAvailable), pc: address, u: u.uint16Value, s: s.uint16Value, memory: memory, available: available) } } } else { publishStop(address, file: nil, line: nil, text: "Program bytes changed; run the build again before C debugging") return } let changedLocation = currentFile != instruction.sourcePath || currentLine != instruction.sourceLine || pc != address publishStop(address, file: instruction.sourcePath, line: instruction.sourceLine, text: "Paused at \(instruction.sourcePath):\(instruction.sourceLine) · \(String(format: "$%04X", address)) · \(snapshot.stopReason)") if changedLocation { openFile(instruction.sourcePath, line: instruction.sourceLine) } } } private func publishStop(_ address: UInt16?, file: String?, line: Int?, text: String) { if pc != address { pc = address }; if currentFile != file { currentFile = file } if currentLine != line { currentLine = line }; if execution != text { execution = text } } }