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

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
}
}