Files
VCCPlusOSS/platforms/macos/App/AssemblyReference.swift

124 lines
4.7 KiB
Swift

// 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 · <direct · offset,X · >address"
case .memory: return "<direct · offset,X · >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<String>
private let allWords: Set<String>
init() {
entries = (Self.instructions() + Self.topics()).sorted { $0.name < $1.name }
var index: [String: AssemblyReferenceEntry] = [:]
var common = Set<String>(), all = Set<String>()
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<String> { 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
}
}