// 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() 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)) } }