144 lines
7.6 KiB
Swift
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)) }
|
|
}
|