124 lines
4.7 KiB
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
|
|
}
|
|
}
|