92 lines
5.4 KiB
Swift
92 lines
5.4 KiB
Swift
// SPDX-License-Identifier: GPL-3.0-or-later
|
|
import Foundation
|
|
|
|
/// Resolves explicit Quick Help requests without interpreting or changing a
|
|
/// program. Offsets use NSTextView's UTF-16 convention, just like editor spans.
|
|
enum BASICReferenceContext {
|
|
private struct Token {
|
|
var keyword: String
|
|
var range: NSRange
|
|
}
|
|
|
|
static func keyword(in source: String, at offset: Int) -> String? {
|
|
let text = source as NSString
|
|
guard source.utf8.count <= BASICLanguage.maximumSourceBytes,
|
|
offset >= 0, offset <= text.length, text.length > 0 else { return nil }
|
|
let spans = BASICLanguage.spans(source)
|
|
let opaque = spans.filter { [.string, .comment, .data].contains($0.kind) }
|
|
// In literals, comments and DATA values, words are data rather than
|
|
// commands. An unfinished literal at EOF remains opaque at its end.
|
|
for span in opaque {
|
|
if NSLocationInRange(offset, span.range) { return nil }
|
|
if span.range.length > 0 && offset == text.length && offset == NSMaxRange(span.range) {
|
|
if span.kind != .string || text.character(at: text.length - 1) != 34 { return nil }
|
|
}
|
|
}
|
|
let line = text.lineRange(for: NSRange(location: offset, length: 0))
|
|
let units = Array(source.utf16)
|
|
func isOpaque(_ at: Int) -> Bool { opaque.contains { NSLocationInRange(at, $0.range) } }
|
|
func whitespace(_ at: Int) -> Bool { units[at] == 32 || units[at] == 9 }
|
|
var start = line.location, end = NSMaxRange(line)
|
|
while end > start && [10, 13].contains(units[end - 1]) { end -= 1 }
|
|
guard start < end else { return nil }
|
|
for at in start..<min(offset, end) where units[at] == 58 && !isOpaque(at) { start = at + 1 }
|
|
if offset < end, units[offset] == 58, !isOpaque(offset) { return nil }
|
|
if offset < end {
|
|
for at in offset..<end where units[at] == 58 && !isOpaque(at) { end = at; break }
|
|
}
|
|
var tokens = spans.filter { $0.kind == .keyword && $0.range.location >= start && $0.range.location < end }
|
|
.map { Token(keyword: $0.word, range: $0.range) }
|
|
// Several public command spellings are composed from shorter ROM
|
|
// tokens. Keep their reference entries distinct from their prefixes.
|
|
var merged: [Token] = [], index = 0
|
|
let pairs = ["GO TO": "GOTO", "GO SUB": "GOSUB", "LINE INPUT": "LINE INPUT",
|
|
"DEF FN": "DEF FN", "ON ERR": "ON ERR", "PRINT USING": "PRINT USING"]
|
|
while index < tokens.count {
|
|
var token = tokens[index]
|
|
if index + 1 < tokens.count {
|
|
let next = tokens[index + 1], gap = NSMaxRange(token.range)..<tokens[index + 1].range.location
|
|
if gap.allSatisfy(whitespace), let combined = pairs[token.keyword + " " + next.keyword] {
|
|
token.keyword = combined; token.range.length = NSMaxRange(next.range) - token.range.location
|
|
index += 1
|
|
}
|
|
}
|
|
let after = NSMaxRange(token.range)
|
|
if ["LOAD", "SAVE", "CLOAD", "CSAVE"].contains(token.keyword), after < end,
|
|
units[after] == 77 || units[after] == 109 {
|
|
token.keyword += "M"; token.range.length += 1
|
|
}
|
|
if token.keyword == "PRINT" {
|
|
var at = after
|
|
while at < end && whitespace(at) { at += 1 }
|
|
if at < end && units[at] == 64 {
|
|
token.keyword = "PRINT@"; token.range.length = at + 1 - token.range.location
|
|
}
|
|
}
|
|
merged.append(token); index += 1
|
|
}
|
|
tokens = merged
|
|
if let exact = tokens.first(where: { NSLocationInRange(offset, $0.range) }) { return exact.keyword }
|
|
if let left = tokens.first(where: { NSMaxRange($0.range) == offset }) { return left.keyword }
|
|
// THEN and ELSE can introduce another statement without a colon. If
|
|
// the branch contains only a destination line, retain the IF topic.
|
|
var statementStart = start
|
|
if let branch = tokens.last(where: { ["THEN", "ELSE"].contains($0.keyword) && NSMaxRange($0.range) < offset }) {
|
|
var following = NSMaxRange(branch.range)
|
|
while following < end && whitespace(following) { following += 1 }
|
|
if following < end && !(48...57).contains(units[following]) { statementStart = following }
|
|
}
|
|
while statementStart < end && whitespace(statementStart) { statementStart += 1 }
|
|
if statementStart == line.location || text.substring(with: NSRange(location: line.location, length: statementStart - line.location)).allSatisfy({ $0 == " " || $0 == "\t" }) {
|
|
while statementStart < end && (48...57).contains(units[statementStart]) { statementStart += 1 }
|
|
while statementStart < end && whitespace(statementStart) { statementStart += 1 }
|
|
}
|
|
guard offset >= statementStart else { return nil }
|
|
if let first = tokens.first(where: { $0.range.location >= statementStart }), first.range.location == statementStart { return first.keyword }
|
|
// Assignment statements can omit LET; an argument position within one
|
|
// still has a useful help topic. A function name itself wins above.
|
|
let prefix = text.substring(with: NSRange(location: statementStart, length: min(offset, end) - statementStart))
|
|
return prefix.contains("=") ? "LET" : nil
|
|
}
|
|
}
|