Files
VCCPlusOSS/platforms/macos/App/AssemblyReferenceContext.swift
T

144 lines
7.6 KiB
Swift

// SPDX-License-Identifier: GPL-3.0-or-later
import Foundation
extension AssemblyReference {
func isDirective(_ word: String) -> Bool { entry(word)?.category == .directives }
private struct LineFields {
let opcode: String
let operand: String
let atMnemonic: Bool
let partial: String
}
/// LWASM's first column is the optional label field. NSTextView supplies UTF-16 offsets.
private func fields(_ source: String, _ offset: Int) -> LineFields? {
let text = source as NSString
guard offset >= 0, offset <= text.length else { return nil }
let range = text.lineRange(for: NSRange(location: offset, length: 0))
let line = text.substring(with: range) as NSString
let caret = offset - range.location
let before = line.substring(to: caret)
let trimmed = before.drop(while: \.isWhitespace)
guard !trimmed.hasPrefix("*"), !trimmed.hasPrefix(";") else { return nil }
// Only a prefix of the operand is needed. Never suggest into a string or a comment.
guard !before.contains(";"), !before.contains("\""), !before.contains("'") else { return nil }
func space(_ i: Int) -> Bool { [9,10,13,32].contains(line.character(at: i)) }
var i = 0
if i < line.length, !space(i) {
while i < line.length && !space(i) { i += 1 }
if caret <= i { return nil }
}
while i < line.length && space(i) { i += 1 }
let start = i
while i < line.length && !space(i) && line.character(at: i) != 59 { i += 1 }
let opcode = line.substring(with: NSRange(location: start, length: i - start)).uppercased()
if caret <= i {
let length = max(0, caret - start)
return .init(opcode: opcode, operand: "", atMnemonic: true,
partial: line.substring(with: NSRange(location: start, length: length)).uppercased())
}
let tail = (before as NSString).substring(from: i)
.trimmingPrefixWhitespace
// LWASM's ordinary syntax permits trailing comments after the operand, even without a semicolon.
guard !["FCC","FCN","FCS"].contains(entry(opcode)?.name ?? ""), !tail.contains(where: \.isWhitespace), !tail.hasPrefix("*") else { return nil }
let partial = String(tail.reversed().prefix { $0.isLetter || $0.isNumber || $0 == "_" }.reversed())
return .init(opcode: opcode, operand: tail, atMnemonic: false, partial: partial)
}
func topic(in source: String, at offset: Int, target6309: Bool) -> String? {
guard let fields = fields(source, offset), let entry = entry(fields.opcode),
vocabulary(target6309: target6309).contains(fields.opcode) else { return nil }
return entry.name
}
func completions(in source: String, at offset: Int, target6309: Bool) -> [String] {
guard let fields = fields(source, offset) else { return [] }
let words = vocabulary(target6309: target6309)
if fields.atMnemonic {
return words.filter { $0.hasPrefix(fields.partial) }.sorted()
}
guard words.contains(fields.opcode), let item = entry(fields.opcode) else { return [] }
let parts = fields.operand.uppercased().components(separatedBy: ",")
let candidates: [String]
let byteRegs = ["A","B","CC","DP"] + (target6309 ? ["E","F"] : [])
let wordRegs = ["X","Y","D","S","U","PC"] + (target6309 ? ["W","V"] : [])
switch item.form {
case .pair:
guard parts.count <= 2 else { return [] }
if parts.count == 2 && !target6309 {
if byteRegs.contains(parts[0]) { candidates = byteRegs }
else if wordRegs.contains(parts[0]) { candidates = wordRegs }
else { return [] }
} else {
// The HD6309 register arithmetic family has unpredictable PC operands.
let regs = byteRegs + wordRegs + (target6309 ? ["0"] : [])
candidates = ["TFR","EXG"].contains(item.name) ? regs : regs.filter { $0 != "PC" }
}
case .transfer:
guard parts.count <= 2 else { return [] }
let regs = ["D","X","Y","U","S"]
if parts.count == 2 {
let sourceReg = parts[0].trimmingCharacters(in: CharacterSet(charactersIn: "+-"))
guard regs.contains(sourceReg) else { return [] }
}
if fields.opcode != "TFM" { candidates = regs }
else {
let suffixes: [String]
if parts.count == 1 { suffixes = ["","+","-"] }
else if parts[0].hasSuffix("+") { suffixes = ["","+"] }
else if parts[0].hasSuffix("-") { suffixes = ["-"] }
else { suffixes = ["+"] }
guard !fields.operand.hasSuffix("+"), !fields.operand.hasSuffix("-") else { return [] }
candidates = regs.flatMap { reg in suffixes.map { reg + $0 } }
}
case .stack:
guard !fields.operand.hasPrefix("#") else { return [] }
let regs = ["A","B","D","CC","DP","PC","X","Y",item.name.hasSuffix("S") ? "U" : "S"]
candidates = regs.filter { !parts.dropLast().contains($0) }
case .bit:
if parts.count == 1 { candidates = ["A","B","CC"] }
else if parts.count == 2 || parts.count == 3 { candidates = (0...7).map(String.init) }
else if parts.count == 4 { candidates = labels(in: source) } else { return [] }
case .indexed, .memory, .value, .maskMemory:
if item.form != .maskMemory && fields.operand.hasPrefix("#") {
guard item.form == .value && parts.count == 1 else { return [] }
}
let index = item.form == .maskMemory ? 2 : 1
guard parts.count <= index + 1 else { return [] }
if parts.count == index + 1 {
let displacement = parts[index - 1].trimmingCharacters(in: CharacterSet(charactersIn: "["))
var regs = ["X","Y","U","S"]
guard target6309 || !["E","F","W"].contains(displacement) else { return [] }
let registerOffset = ["A","B","D","E","F","W"].contains(displacement)
if !registerOffset && !displacement.isEmpty { regs.append("PCR") }
if target6309 && !registerOffset { regs.append("W") }
guard !fields.operand.hasSuffix("+") && !fields.operand.hasSuffix("]") else { return [] }
if parts.last?.hasPrefix("-") == true { regs = regs.filter { $0 != "PCR" && ($0 != "W" || parts.last?.hasPrefix("--") == true) } }
candidates = regs
} else if parts.count == index || (item.form == .maskMemory && parts.count == 1) {
candidates = labels(in: source)
} else { return [] }
case .relative:
guard !fields.operand.hasPrefix("#"), parts.count == 1 else { return [] }
candidates = labels(in: source)
case .immediate: candidates = labels(in: source)
case .directive, .topic, .inherent: return []
}
return candidates.filter { $0.uppercased().hasPrefix(fields.partial.uppercased()) }.sorted()
}
private func labels(in source: String) -> [String] {
var names = Set<String>()
for line in source.split(whereSeparator: \.isNewline) {
guard let first = line.first, first.isLetter || first == "_" else { continue }
names.insert(String(line.prefix { $0.isLetter || $0.isNumber || $0 == "_" }))
}
return names.sorted()
}
}
private extension String {
var trimmingPrefixWhitespace: String { String(drop(while: \.isWhitespace)) }
}