// SPDX-License-Identifier: GPL-3.0-or-later import Foundation struct AssemblyBuffer: Codable, Identifiable, Sendable { var id = UUID() var path: String var text: String var saved: String? var dirty: Bool { saved.map { !text.utf8.elementsEqual($0.utf8) } ?? true } } struct AssemblyWorkspaceDocument: Codable, Identifiable, Sendable { var id = UUID() var title: String var directory: URL? var isProject = false var mainPath: String var buffers: [AssemblyBuffer] var selectedPath: String var cpu: AssemblyCPU = .mc6809 var breakpoints = Set() var paths: [String] = [] var inputPaths: [String]? static let starterTitle = "Hello World — Earth or Mars" static let starterSource = DevelopmentStarterSource.planet(withExtension: "asm") ?? "; The Earth or Mars example is missing. Reinstall VCC Plus to restore it.\n" static func example(title: String, source: String, cpu: AssemblyCPU) -> Self { let file = AssemblyBuffer(path: "main.asm", text: source, saved: nil) return Self(title: title, mainPath: file.path, buffers: [file], selectedPath: file.path, cpu: cpu) } static func open(_ url: URL, folder: Bool) throws -> Self { let physical = URL(fileURLWithPath: try CMOCProject.physicalURL(url).path, isDirectory: folder) let snapshot = try folder ? AssemblyProjectSnapshot.read(directory: physical) : AssemblyProjectSnapshot.readSource(at: physical) guard let data = snapshot.files[snapshot.mainPath], let text = String(data: data, encoding: .utf8) else { throw AssemblyBuildFailure("The entry source must be a UTF-8 text file.") } return Self(title: physical.lastPathComponent, directory: folder ? physical : physical.deletingLastPathComponent(), isProject: folder, mainPath: snapshot.mainPath, buffers: [.init(path: snapshot.mainPath, text: text, saved: text)], selectedPath: snapshot.mainPath, paths: editablePaths(snapshot), inputPaths: Array(snapshot.files.keys)) } static func editablePaths(_ snapshot: AssemblyProjectSnapshot) -> [String] { snapshot.files.keys.filter { ["asm", "s", "inc", "lwasm", "link", "lw", "json", "mk"].contains(URL(fileURLWithPath: $0).pathExtension.lowercased()) || $0 == snapshot.settings.linkScript || $0 == snapshot.settings.makefile || $0 == "Makefile" || $0 == snapshot.mainPath }.sorted() } func checkedURL(_ path: String) throws -> URL { try CMOCProject.validateRelativePath(path) guard let directory else { throw AssemblyBuildFailure("Save the source before opening relative files.") } let url = directory.appendingPathComponent(path) let candidate = FileManager.default.fileExists(atPath: url.path) ? url : url.deletingLastPathComponent() // directory was canonicalized at Open/Save. Foundation standardization // may shorten /private/var to /var; compare the two physical spellings. guard try CMOCProject.physicalURL(candidate).path == candidate.path, (try? FileManager.default.destinationOfSymbolicLink(atPath: url.path)) == nil else { throw AssemblyBuildFailure("The project path now points through a symbolic link: " + path) } return url } func snapshot() throws -> AssemblyProjectSnapshot { guard let directory else { guard let entry = buffers.first(where: { $0.path == mainPath }) else { throw AssemblyBuildFailure("Entry source is missing.") } return .single(source: entry.text, path: mainPath, cpu: cpu) } var overlays: [String: String] = [:] for buffer in buffers { let url = try checkedURL(buffer.path) if let saved = buffer.saved { guard try CMOCProject.readText(url, maximumBytes: CMOCProject.maximumSourceBytes) == saved else { throw AssemblyBuildFailure("\(buffer.path) changed on disk. Reload it or save your edits separately.") } } else if FileManager.default.fileExists(atPath: url.path) { throw AssemblyBuildFailure("\(buffer.path) appeared on disk. Reload it before building.") } if buffer.dirty { overlays[buffer.path] = buffer.text } } if isProject { return try .read(directory: directory, mainPath: mainPath, overlays: overlays, cpu: cpu) } return try .readSource(at: checkedURL(mainPath), overlays: overlays, cpu: cpu) } } struct AssemblyRecovery: Codable, Sendable { var version = 1 var documents: [AssemblyWorkspaceDocument] var active: UUID func write(to url: URL) throws { let data = try JSONEncoder().encode(self) guard data.count <= 64 * 1024 * 1024 else { throw AssemblyBuildFailure("Assembly drafts exceed the 64 MB recovery limit. Save and close completed documents.") } try FileManager.default.createDirectory(at: url.deletingLastPathComponent(), withIntermediateDirectories: true) try data.write(to: url, options: .atomic) } static func read(from url: URL) throws -> Self { let values = try url.resourceValues(forKeys: [.fileSizeKey, .isRegularFileKey]) guard values.isRegularFile == true, let size = values.fileSize, size <= 64 * 1024 * 1024 else { throw CocoaError(.fileReadTooLarge) } let saved = try JSONDecoder().decode(Self.self, from: Data(contentsOf: url)) guard saved.version == 1, saved.documents.contains(where: { $0.id == saved.active }), Set(saved.documents.map(\.id)).count == saved.documents.count else { throw CocoaError(.fileReadCorruptFile) } var bufferIDs = Set() for doc in saved.documents { guard doc.buffers.contains(where: { $0.path == doc.selectedPath }), doc.buffers.contains(where: { $0.path == doc.mainPath }), Set(doc.buffers.map(\.path)).count == doc.buffers.count else { throw CocoaError(.fileReadCorruptFile) } for buffer in doc.buffers { try CMOCProject.validateRelativePath(buffer.path) guard bufferIDs.insert(buffer.id).inserted else { throw CocoaError(.fileReadCorruptFile) } } } return saved } }