// SPDX-License-Identifier: GPL-3.0-or-later import Foundation enum AssemblyReferenceCategory: String, CaseIterable { case instructions = "Instructions" case registers = "Registers & Flags" case addressing = "Addressing Modes" case directives = "LWASM Directives" case examples = "CoCo Examples" case dialect = "Dialect & Compatibility" } enum AssemblyOperandForm { case inherent, value, memory, indexed, relative, immediate, pair, stack, bit, maskMemory, transfer, directive, topic var description: String { switch self { case .inherent: return "No operand" case .value: return "#literal · address" case .memory: return "address" case .indexed: return "offset,index" case .relative: return "target label" case .immediate: return "#mask" case .pair: return "source register,destination register" case .stack: return "register[,register…] · #mask" case .bit: return "A|B|CC,source bit,destination bit,direct address" case .maskMemory: return "#mask,address · #mask,offset,X" case .transfer: return "r+,r+ · r-,r- · r+,r · r,r+" case .directive, .topic: return "" } } } struct AssemblyReferenceEntry: Identifiable { let id: String let name: String let category: AssemblyReferenceCategory let only6309: Bool let aliases: [String] let form: AssemblyOperandForm let syntax: String let operation: String let flags: String let detail: String let links: [String] let citations: [String] let terms: [String] let example: String? init(_ name: String, _ category: AssemblyReferenceCategory, only6309: Bool = false, aliases: [String] = [], form: AssemblyOperandForm = .topic, syntax: String = "", operation: String, flags: String = "", detail: String = "", links: [String] = [], citations: [String], terms: [String] = [], example: String? = nil) { self.name = name self.category = category self.id = "\(category).\(name.lowercased().replacingOccurrences(of: " ", with: "-"))" self.only6309 = only6309 self.aliases = aliases self.form = form self.syntax = syntax.isEmpty ? form.description : syntax self.operation = operation self.flags = flags self.detail = detail self.links = links self.citations = citations self.terms = terms self.example = example } } struct AssemblyReferenceExampleRequest: Codable, Hashable { var id = UUID() let title: String let source: String let target6309: Bool } struct AssemblyReference { static let shared = AssemblyReference() let entries: [AssemblyReferenceEntry] private let byTerm: [String: AssemblyReferenceEntry] private let commonWords: Set private let allWords: Set init() { entries = (Self.instructions() + Self.topics()).sorted { $0.name < $1.name } var index: [String: AssemblyReferenceEntry] = [:] var common = Set(), all = Set() for entry in entries { for word in [entry.name] + entry.aliases { index[word.uppercased()] = entry if entry.category == .instructions || entry.category == .directives { all.insert(word.uppercased()) if !entry.only6309 { common.insert(word.uppercased()) } } } index[entry.id.uppercased()] = entry } byTerm = index commonWords = common allWords = all } func entry(_ term: String) -> AssemblyReferenceEntry? { byTerm[term.uppercased()] } func vocabulary(target6309: Bool) -> Set { target6309 ? allWords : commonWords } func search(_ query: String, target6309: Bool?, category: AssemblyReferenceCategory?) -> [AssemblyReferenceEntry] { let words = query.lowercased().split(whereSeparator: \.isWhitespace) let result = entries.filter { entry in guard (target6309 != false || !entry.only6309), category == nil || entry.category == category else { return false } let fields = [entry.name, entry.operation, entry.flags, entry.detail] + entry.aliases + entry.terms let haystack = fields.joined(separator: " ").lowercased() return words.allSatisfy { haystack.contains($0) } } if let exact = entry(query), let i = result.firstIndex(where: { $0.id == exact.id }) { var ranked = result ranked.insert(ranked.remove(at: i), at: 0) return ranked } return result } }