Publish VCC Plus OSS source distribution for 3.6.2 build 60

This commit is contained in:
Brian Holman committed 2026-11-13 00:14:03 -07:00
commit c652a5276d
1192 files changed
+272368

No files matched your search

@@ -0,0 +1,316 @@
// SPDX-License-Identifier: GPL-3.0-or-later
import Foundation
struct AssemblyDiagnostic: Hashable, Sendable {
let path: String
let line: Int
let message: String
}
struct AssemblyBuildFailure: LocalizedError {
let message: String
let diagnostics: [AssemblyDiagnostic]
init(_ message: String, diagnostics: [AssemblyDiagnostic] = []) {
self.message = message
self.diagnostics = diagnostics
}
var errorDescription: String? { message }
}
struct AssemblyInstructionLocation: Hashable, Sendable {
let path: String
let line: Int
let address: UInt16
let bytes: [UInt8]
}
struct AssemblyBuildArtifact: Sendable {
let id: UUID
let snapshot: AssemblyProjectSnapshot
let binaryData: Data
let entry: UInt16
let ranges: [ClosedRange<UInt16>]
let listing: String
let symbols: String
let buildLog: String
let instructions: [AssemblyInstructionLocation]
}
/// Export accepts the full DECB address space. The machine's loader separately
/// decides whether a given block and entry are safe in its current RAM mapping.
private struct AssemblyImage {
let entry: UInt16
let ranges: [ClosedRange<UInt16>]
let bytes: [Int: UInt8]
init(_ data: Data) throws {
var offset = 0, ranges: [ClosedRange<UInt16>] = [], memory: [Int: UInt8] = [:]
var entry: UInt16?, ambiguous = false
while offset + 5 <= data.count {
let type = data[offset], length = Int(data[offset + 1]) * 256 + Int(data[offset + 2])
let start = Int(data[offset + 3]) * 256 + Int(data[offset + 4])
offset += 5
if type == 255 {
guard length == 0, offset == data.count else { throw AssemblyBuildFailure("Malformed DECB execution record.") }
entry = UInt16(start)
break
}
guard type == 0, length <= data.count - offset else { throw AssemblyBuildFailure("Malformed DECB load block.") }
if length > 0 {
let end = start + length - 1
ranges.append(UInt16(start)...UInt16(min(end, 65535)))
if end > 65535 { ranges.append(0...UInt16(end - 65536)); ambiguous = true }
for index in 0..<length {
if memory.updateValue(data[offset + index], forKey: start + index) != nil { ambiguous = true }
}
}
offset += length
}
guard let entry else { throw AssemblyBuildFailure("The binary is missing its DECB execution record.") }
self.entry = entry
self.ranges = ranges
self.bytes = ambiguous ? [:] : memory
}
}
struct DevelopmentBuildTools: Sendable {
let toolchain: URL
init(toolchain: URL = Bundle.main.bundleURL.appendingPathComponent("Contents/Resources/Toolchain")) {
self.toolchain = toolchain
}
static func readFile(_ url: URL, limit: Int) throws -> Data {
let properties = try url.resourceValues(forKeys: [.isRegularFileKey, .isSymbolicLinkKey, .fileSizeKey])
guard properties.isRegularFile == true, properties.isSymbolicLink != true,
let size = properties.fileSize, size <= limit else {
throw AssemblyBuildFailure("The file is missing, linked, or exceeds its size limit: " + url.lastPathComponent)
}
let handle = try FileHandle(forReadingFrom: url)
defer { try? handle.close() }
let bytes = try handle.read(upToCount: limit + 1) ?? Data()
guard bytes.count <= limit else { throw AssemblyBuildFailure("File grew beyond its size limit.") }
return bytes
}
func withWorkspace<T: Sendable>(_ body: @escaping @Sendable (URL, DevelopmentProcessControl) throws -> T) async throws -> T {
let control = DevelopmentProcessControl()
return try await withTaskCancellationHandler {
try await Task.detached(priority: .userInitiated) {
try control.checkCancellation()
let root = FileManager.default.temporaryDirectory.appendingPathComponent("VCC-Development-" + UUID().uuidString)
try FileManager.default.createDirectory(at: root, withIntermediateDirectories: false, attributes: [.posixPermissions: 0o700])
defer { try? FileManager.default.removeItem(at: root) }
let result = try body(root, control)
try control.checkCancellation()
return result
}.value
} onCancel: { control.cancel() }
}
func run(_ name: String, _ arguments: [String], in folder: URL,
control: DevelopmentProcessControl, cpu: AssemblyCPU = .mc6809) throws -> (status: Int32, text: String) {
let bin = toolchain.appendingPathComponent("bin")
let executable = bin.appendingPathComponent(name)
guard FileManager.default.isExecutableFile(atPath: executable.path) else {
throw AssemblyBuildFailure("The bundled development tool is missing: " + name)
}
let environment = ["PATH": bin.path + ":/usr/bin:/bin", "LC_ALL": "C", "TMPDIR": folder.path,
"LWASM": "lwasm", "LWLINK": "lwlink", "ASFLAGS": "--" + cpu.rawValue,
"VCC_TOOLCHAIN": toolchain.path]
return try control.run(executable: executable, arguments: arguments, directory: folder,
environment: environment, timeout: 120)
}
/// BASIC already produced a fresh tokenized disk. Stage only that image so a
/// failed tool invocation cannot alter a mounted disk or the chosen destination.
func bootableBASICDisk(_ disk: Data, name: String) async throws -> Data {
guard let name = BASICExportName.normalized(name) else { throw AssemblyBuildFailure("Invalid Disk BASIC program name.") }
return try await withWorkspace { root, control in
let url = root.appendingPathComponent("export.dsk")
try disk.write(to: url)
try installBootLoader(.basic(name), in: root, control: control)
return try Self.readFile(url, limit: 35 * 18 * 256)
}
}
func installBootLoader(_ program: DevelopmentDiskProgram, in root: URL, control: DevelopmentProcessControl) throws {
// Both callers validate the on-disk name before it becomes a C literal.
let command = program.bootCommand.replacingOccurrences(of: "\"", with: "\\\"")
let source = "#define COMMAND \"\(command)\"\n" + CMOCMakefileSettings.dosBootLoaderSource
try Data(source.utf8).write(to: root.appendingPathComponent("loader.c"))
let compiled = try run("cmoc", ["--dos", "-O0", "--limit=2800", "-o", "loader.bin", "loader.c"], in: root, control: control)
guard compiled.status == 0 else { throw AssemblyBuildFailure("Could not build the DOS bootloader.\n" + compiled.text) }
let installed = try run("install-coco-boot-loader", ["export.dsk", "loader.bin"], in: root, control: control)
guard installed.status == 0 else { throw AssemblyBuildFailure("Could not install the DOS bootloader.\n" + installed.text) }
}
}
struct AssemblyBuildService: Sendable {
let tools: DevelopmentBuildTools
init(toolchain: URL = Bundle.main.bundleURL.appendingPathComponent("Contents/Resources/Toolchain")) {
tools = DevelopmentBuildTools(toolchain: toolchain)
}
func build(_ snapshot: AssemblyProjectSnapshot) async throws -> AssemblyBuildArtifact {
try await tools.withWorkspace { root, control in
try snapshot.validate()
let workspace = root.appendingPathComponent("src")
let output = root.appendingPathComponent("out")
try FileManager.default.createDirectory(at: output, withIntermediateDirectories: true)
for (path, data) in snapshot.files {
try control.checkCancellation()
let url = workspace.appendingPathComponent(path)
try FileManager.default.createDirectory(at: url.deletingLastPathComponent(), withIntermediateDirectories: true)
try data.write(to: url, options: .withoutOverwriting)
}
var log = "", listings: [String] = [], symbols = ""
var objects: [String] = [], modules: [(object: String, records: String)] = []
func invoke(_ tool: String, _ args: [String]) throws -> String {
let result = try tools.run(tool, args, in: workspace, control: control, cpu: snapshot.cpu)
let command = ([tool] + args).joined(separator: " ")
if log.utf8.count < 512 * 1024 { log += command + "\n" + result.text + "\n" }
guard result.status == 0 else {
throw AssemblyBuildFailure(command + "\n" + result.text, diagnostics: Self.diagnostics(result.text, files: snapshot.files))
}
return result.text
}
var binaryURL = output.appendingPathComponent("program.bin")
let settings = snapshot.settings
if let makefile = settings.makefile, let binary = settings.binary {
_ = try invoke("make", ["-B", "-f", "./" + makefile, "MAKE=make", "--", settings.target ?? "all"])
binaryURL = workspace.appendingPathComponent(binary)
guard binaryURL.resolvingSymlinksInPath().path == workspace.resolvingSymlinksInPath().appendingPathComponent(binary).path else {
throw AssemblyBuildFailure("The Makefile must produce a regular binary within the build folder.")
}
log += "Custom Make declares the CPU target in its recipe. Its instruction set and source locations are unverified. Use the machine debugger.\n"
} else {
let linked = settings.linkScript != nil
_ = try invoke("lwasm", ["--version"])
for (index, path) in ([snapshot.mainPath] + (settings.modules ?? [])).enumerated() {
let stem = "../out/module" + String(index)
let object = stem + ".o"
let flags = ["--project-inputs", "--" + snapshot.cpu.rawValue, linked ? "--obj" : "--decb", "--error-format=gcc", "-I."]
let fileArg = "./" + path
_ = try invoke("lwasm", flags + ["--tabs=0", "--list=" + stem + ".lst", "--project-map=" + stem + ".lines",
"--symbol-dump=" + stem + ".sym", "-o", linked ? object : "../out/program.bin", fileArg])
let records = try DevelopmentBuildTools.readFile(workspace.appendingPathComponent(stem + ".lines"), limit: 4 * 1024 * 1024)
let list = try DevelopmentBuildTools.readFile(workspace.appendingPathComponent(stem + ".lst"), limit: 8 * 1024 * 1024)
let listing = String(decoding: list, as: UTF8.self)
guard listings.reduce(listing.utf8.count, { $0 + $1.utf8.count }) <= 16 * 1024 * 1024 else {
throw AssemblyBuildFailure("Combined listings exceed 16 MB.")
}
modules.append((object, String(decoding: records, as: UTF8.self)))
listings.append(listing)
if linked { objects.append(object) }
else {
symbols = String(decoding: try DevelopmentBuildTools.readFile(workspace.appendingPathComponent(stem + ".sym"), limit: 4 * 1024 * 1024), as: UTF8.self)
}
}
if let script = settings.linkScript {
_ = try invoke("lwlink", ["--version"])
_ = try invoke("lwlink", ["--decb", "--script=./" + script, "--map=../out/link.map", "-o", "../out/program.bin"] + objects)
symbols = String(decoding: try DevelopmentBuildTools.readFile(output.appendingPathComponent("link.map"), limit: 4 * 1024 * 1024), as: UTF8.self)
}
}
let binary = try DevelopmentBuildTools.readFile(binaryURL, limit: BinaryFile.limit)
let image = try AssemblyImage(binary)
var instructions: [AssemblyInstructionLocation] = []
for (object, records) in modules {
try control.checkCancellation()
var sections: [String: CMOCSourceMap.VerifiedSection]?
if settings.linkScript != nil {
do {
let data = try DevelopmentBuildTools.readFile(workspace.appendingPathComponent(object), limit: 8 * 1024 * 1024)
sections = try CMOCSourceMap.verifiedSections(object: data, objectName: object, linkMap: Data(symbols.utf8), binary: binary).sections
} catch {
log += "Source locations unavailable for " + object + ". " + error.localizedDescription + "\n"
continue
}
}
instructions += Self.locations(records, files: snapshot.files, image: image, sections: sections)
}
// Repeated include expansions or two rows claiming a PC are ambiguous.
let addresses = Dictionary(grouping: instructions, by: \.address)
let lines = Dictionary(grouping: instructions) { $0.path + "\n" + String($0.line) }
let verified = instructions.filter { addresses[$0.address]?.count == 1 && lines[$0.path + "\n" + String($0.line)]?.count == 1 }
return AssemblyBuildArtifact(id: UUID(), snapshot: snapshot, binaryData: binary, entry: image.entry,
ranges: image.ranges, listing: listings.joined(separator: "\n"), symbols: symbols, buildLog: log, instructions: verified)
}
}
func diskImage(for artifact: AssemblyBuildArtifact, name: String, dosBoot: Bool = false) async throws -> Data {
let dosName = name.uppercased()
guard dosName.range(of: #"\A[A-Z0-9][A-Z0-9_-]{0,7}\z"#, options: .regularExpression) != nil else {
throw AssemblyBuildFailure("Use a Disk BASIC name of one to eight letters or digits, with optional hyphens or underscores.")
}
return try await tools.withWorkspace { root, control in
let image = root.appendingPathComponent("export.dsk")
try Data(repeating: 0xff, count: 35 * 18 * 256).write(to: image)
if dosBoot {
try tools.installBootLoader(.binary(dosName), in: root, control: control)
}
let file = dosName + ".BIN"
try artifact.binaryData.write(to: root.appendingPathComponent(file))
let result = try tools.run("writecocofile", ["export.dsk", file], in: root, control: control)
guard result.status == 0 else { throw AssemblyBuildFailure(result.text) }
return try DevelopmentBuildTools.readFile(image, limit: 35 * 18 * 256)
}
}
private static func diagnostics(_ text: String, files: [String: Data]) -> [AssemblyDiagnostic] {
let pattern = try! NSRegularExpression(pattern: #"^(.+?):([0-9]+): (?:error|warning): (.+)$"#)
return text.components(separatedBy: .newlines).compactMap { row in
guard let fields = groups(pattern, row), let number = Int(fields[2]),
let path = sourcePath(fields[1], in: Set(files.keys)) else { return nil }
return AssemblyDiagnostic(path: path, line: number, message: fields[3])
}
}
private static func groups(_ regex: NSRegularExpression, _ row: String) -> [String]? {
let ns = row as NSString
guard let match = regex.firstMatch(in: row, range: NSRange(location: 0, length: ns.length)) else { return nil }
return (0..<match.numberOfRanges).map { ns.substring(with: match.range(at: $0)) }
}
private static func sourcePath(_ token: String, in inputs: Set<String>) -> String? {
var token = token
while token.hasPrefix("./") { token.removeFirst(2) }
guard !token.isEmpty else { return nil }
let candidates = inputs.filter { path in
path == token || path.hasSuffix("/" + token)
}
return candidates.count == 1 ? candidates.first : nil
}
/// Physical source names, lines and section names come directly from LWASM.
/// The display listing abbreviates names and can include macro expansions.
private static func locations(_ records: String, files: [String: Data], image: AssemblyImage,
sections: [String: CMOCSourceMap.VerifiedSection]?) -> [AssemblyInstructionLocation] {
var result: [AssemblyInstructionLocation] = []
for row in records.split(whereSeparator: \.isNewline) {
let fields = row.split(separator: "\t", omittingEmptySubsequences: false)
guard fields.count == 5, let line = Int(fields[1]), line > 0, let offset = Int(fields[3], radix: 16),
(0..<65536).contains(offset) else { continue }
let path = String(fields[0]), digits = Array(fields[4])
guard files[path] != nil, (2...16).contains(digits.count), digits.count.isMultiple(of: 2) else { continue }
let original = stride(from: 0, to: digits.count, by: 2).compactMap { UInt8(String(digits[$0...($0 + 1)]), radix: 16) }
guard original.count * 2 == digits.count else { continue }
let address: Int, bytes: [UInt8]
if let sections {
guard let section = sections[String(fields[2])], let final = section.final,
offset + original.count <= section.original.count,
section.original[offset..<(offset + original.count)].elementsEqual(original) else { continue }
address = section.base + offset
bytes = Array(final[offset..<(offset + original.count)])
} else {
guard fields[2].isEmpty else { continue }
address = offset
bytes = original
}
guard address + bytes.count <= 65536,
bytes.enumerated().allSatisfy({ image.bytes[address + $0.offset] == $0.element }) else { continue }
result.append(.init(path: path, line: line, address: UInt16(address), bytes: bytes))
}
return result
}
}