540 lines
31 KiB
Swift
540 lines
31 KiB
Swift
// SPDX-License-Identifier: GPL-3.0-or-later
|
||
import Foundation
|
||
|
||
/// Read-only watches over one atomic, side-effect-free debugger snapshot.
|
||
/// This is a deliberately bounded expression evaluator, not guest execution.
|
||
struct CMOCWatchEvaluator {
|
||
struct Context {
|
||
let pc: UInt16
|
||
let u: UInt16
|
||
let memory: Data
|
||
let available: Data
|
||
init(pc: UInt16, u: UInt16, memory: Data, available: Data) {
|
||
self.pc = pc; self.u = u
|
||
// Foundation's NSData bridge may share mutable backing even when
|
||
// the Swift value is let-bound. Verification is cached, so own the
|
||
// snapshot bytes rather than relying on that bridge's copy-on-write.
|
||
func owned(_ data: Data) -> Data {
|
||
data.withUnsafeBytes { bytes in
|
||
bytes.isEmpty ? Data() : Data(bytes: bytes.baseAddress!, count: bytes.count)
|
||
}
|
||
}
|
||
self.memory = owned(memory); self.available = owned(available)
|
||
}
|
||
}
|
||
struct Value: Identifiable {
|
||
var id: String { name }
|
||
let name: String
|
||
let typeName: String
|
||
let value: String
|
||
let address: UInt16?
|
||
let error: String?
|
||
}
|
||
enum Root: Hashable { case variable(String), watch(String) }
|
||
enum Component: Hashable { case index(Int), member(String), pointee }
|
||
struct TreePath: Hashable {
|
||
let root: Root
|
||
let components: [Component]
|
||
init(root: Root, components: [Component] = []) { self.root = root; self.components = components }
|
||
func appending(_ component: Component) -> TreePath { TreePath(root: root, components: components + [component]) }
|
||
}
|
||
struct TreeNode: Identifiable {
|
||
var id: TreePath { path }
|
||
let path: TreePath
|
||
let name: String
|
||
let typeName: String
|
||
let value: String
|
||
let address: UInt16?
|
||
let error: String?
|
||
let childCount: Int
|
||
}
|
||
struct TreePage {
|
||
let nodes: [TreeNode]
|
||
let totalCount: Int
|
||
let nextOffset: Int?
|
||
let error: String?
|
||
}
|
||
private final class VerificationCache { var result: Result<Void, Error>? }
|
||
// Copies share only immutable snapshot provenance. Each newly captured
|
||
// evaluator gets a new cache; expanding 32 children must not rescan all code
|
||
// 32 times. Frame availability is checked separately on every root resolve.
|
||
private let verificationCache = VerificationCache()
|
||
private struct Problem: Error { let message: String; init(_ message: String) { self.message = message } }
|
||
private struct Operand {
|
||
let type: CMOCVariableDebug.CType
|
||
let address: Int?
|
||
let immediate: Int64?
|
||
}
|
||
let metadata: CMOCVariableDebug
|
||
let context: Context
|
||
var frameLocalsAvailable = true
|
||
private var function: CMOCVariableDebug.Function? {
|
||
metadata.functions.first { $0.body <= Int(context.pc) && Int(context.pc) < $0.end }
|
||
}
|
||
// A verified assembly entry/prologue establishes file identity without
|
||
// establishing a C frame. Keep stack-local eligibility on the body above.
|
||
private var fileScopeFunction: CMOCVariableDebug.Function? {
|
||
function ?? metadata.entryFunction(containing: context.pc)
|
||
}
|
||
private func verified() throws {
|
||
if let result = verificationCache.result { return try result.get() }
|
||
do {
|
||
try verifySnapshot()
|
||
verificationCache.result = .success(())
|
||
} catch {
|
||
verificationCache.result = .failure(error)
|
||
throw error
|
||
}
|
||
}
|
||
private func verifySnapshot() throws {
|
||
guard context.memory.count == 65536, context.available.count == 65536 else { throw Problem("A complete paused memory snapshot is required.") }
|
||
guard metadata.sourceMap.verifiesRuntime(memory: context.memory, available: context.available) else {
|
||
throw Problem("The running code no longer matches this build, or its memory is unavailable.")
|
||
}
|
||
}
|
||
private func candidates(named name: String? = nil) -> [CMOCVariableDebug.Variable] {
|
||
let location = metadata.sourceMap.location(at: context.pc)
|
||
return metadata.variables.filter { variable in
|
||
if let name, variable.name != name { return false }
|
||
if let scope = variable.scope {
|
||
guard scope.contains(Int(context.pc)), function != nil else { return false }
|
||
// A block's stack reservation precedes its declarations. Do not
|
||
// expose a later declaration (or shadow an outer name) early.
|
||
if variable.offset != nil, let location, location.path == variable.sourcePath,
|
||
location.line < variable.line { return false }
|
||
} else if variable.isStatic, variable.sourcePath != fileScopeFunction?.sourcePath { return false }
|
||
return true
|
||
}
|
||
}
|
||
private func resolve(_ name: String) throws -> CMOCVariableDebug.Variable {
|
||
let matches = candidates(named: name)
|
||
let locals = matches.filter { $0.scope != nil }.sorted { $0.scope!.count < $1.scope!.count }
|
||
if let first = locals.first {
|
||
guard locals.count == 1 || locals[1].scope != first.scope else { throw Problem("The name ‘\(name)’ is ambiguous in this scope.") }
|
||
return first
|
||
}
|
||
let sameFile = matches.filter { $0.sourcePath == fileScopeFunction?.sourcePath }
|
||
let globals = sameFile.isEmpty ? matches : sameFile
|
||
guard globals.count == 1, let variable = globals.first else {
|
||
throw Problem(globals.isEmpty ? "‘\(name)’ is not available in the current C scope." : "The name ‘\(name)’ is ambiguous; stop in its source file.")
|
||
}
|
||
return variable
|
||
}
|
||
private func operand(_ variable: CMOCVariableDebug.Variable) throws -> Operand {
|
||
if let address = variable.address { return Operand(type: variable.type, address: address, immediate: nil) }
|
||
guard frameLocalsAvailable else {
|
||
throw Problem("This frame’s local storage cannot be verified. Pause inside a supported unoptimized function body with a preserved frame pointer.")
|
||
}
|
||
guard let offset = variable.offset, function?.frame == true else {
|
||
throw Problem("Local variables require an unoptimized, preserved frame pointer. Rebuild with -O0 -fno-omit-frame-pointer and pause inside the function body.")
|
||
}
|
||
let address = Int(context.u) + offset
|
||
guard address >= 0, address + variable.type.size <= 65536 else { throw Problem("The variable's stack storage is outside logical memory.") }
|
||
return Operand(type: variable.type, address: address, immediate: nil)
|
||
}
|
||
private func bytes(at address: Int, count: Int) throws -> [UInt8] {
|
||
guard address >= 0, count >= 0, address <= 65536 - count,
|
||
!(address..<(address + count)).contains(where: { context.available[$0] == 0 }) else {
|
||
throw Problem("This memory is unavailable for inspection (including hardware I/O).")
|
||
}
|
||
return Array(context.memory[address..<(address + count)])
|
||
}
|
||
private func integer(_ value: Operand) throws -> Int64 {
|
||
if let immediate = value.immediate { return immediate }
|
||
if value.type.kind == "floating" {
|
||
throw Problem("Floating-point values can be inspected, but floating-point watch arithmetic is not supported.")
|
||
}
|
||
guard ["integer", "pointer"].contains(value.type.kind), let address = value.address else {
|
||
throw Problem("This operation requires an integer or pointer value.")
|
||
}
|
||
let data = try bytes(at: address, count: value.type.size)
|
||
var result: Int64 = 0
|
||
for byte in data { result = (result << 8) | Int64(byte) }
|
||
if value.type.kind == "integer", value.type.signed == true, let first = data.first, first & 0x80 != 0 {
|
||
result -= Int64(1) << (data.count * 8)
|
||
}
|
||
return result
|
||
}
|
||
private func floating(_ operand: Operand) throws -> String {
|
||
guard let format = operand.type.floatingFormat else {
|
||
throw Problem("This build does not identify its floating-point format. Rebuild with the current VCC Plus compiler.")
|
||
}
|
||
let expectedSize: Int
|
||
switch format {
|
||
case "coco-basic-40": expectedSize = 5
|
||
case "ieee754-binary32-be": expectedSize = 4
|
||
default: throw Problem("Unsupported floating-point format ‘\(format)’; inspect its bytes in Memory.")
|
||
}
|
||
guard operand.type.size == expectedSize, let address = operand.address else {
|
||
throw Problem("The floating-point storage does not match its compiler-described format.")
|
||
}
|
||
let data = try bytes(at: address, count: expectedSize)
|
||
let value: Double
|
||
if format == "coco-basic-40" {
|
||
// CMOC RealConstantExpr::getRepresentation and Color BASIC's packed
|
||
// format: exponent byte, sign bit, 31 fraction bits; hidden leading 1.
|
||
// Exponent zero represents zero regardless of the remaining bytes.
|
||
if data[0] == 0 { return "0" }
|
||
let fraction = (UInt32(data[1] & 0x7f) << 24) | (UInt32(data[2]) << 16)
|
||
| (UInt32(data[3]) << 8) | UInt32(data[4])
|
||
let magnitude = ldexp(1 + Double(fraction) / 2147483648, Int32(data[0]) - 129)
|
||
value = data[1] & 0x80 == 0 ? magnitude : -magnitude
|
||
} else {
|
||
// Decode the target byte order explicitly, independent of host CPU.
|
||
let bits = data.reduce(UInt32(0)) { ($0 << 8) | UInt32($1) }
|
||
value = Double(Float(bitPattern: bits))
|
||
}
|
||
if value.isNaN { return "NaN" }
|
||
if value.isInfinite { return value.sign == .minus ? "-Infinity" : "Infinity" }
|
||
if value == 0 { return value.sign == .minus ? "-0" : "0" }
|
||
// Enough significant decimal digits to distinguish adjacent target
|
||
// values (32-bit significand for BASIC, 24-bit for IEEE binary32).
|
||
return String(format: expectedSize == 5 ? "%.11g" : "%.9g",
|
||
locale: Locale(identifier: "en_US_POSIX"), value)
|
||
}
|
||
private func describe(_ operand: Operand, depth: Int = 0) throws -> String {
|
||
let type = operand.type
|
||
switch type.kind {
|
||
case "integer": return String(try integer(operand))
|
||
case "pointer": return String(format: "$%04llX", try integer(operand))
|
||
case "array":
|
||
guard let address = operand.address, let element = type.element, let count = type.count else { throw Problem("Array layout is unavailable.") }
|
||
if depth >= 2 { return "[\(count) elements]" }
|
||
let values = try (0..<min(count, 8)).map { index in
|
||
try describe(Operand(type: element, address: address + index * element.size, immediate: nil), depth: depth + 1)
|
||
}
|
||
return "[" + values.joined(separator: ", ") + (count > 8 ? ", …]" : "]")
|
||
case "aggregate":
|
||
guard let address = operand.address, let members = type.members else { throw Problem("Aggregate layout is unavailable.") }
|
||
if depth >= 2 { return "{…}" }
|
||
let values = try members.prefix(4).map { member in
|
||
member.name + " = " + (try describe(Operand(type: member.type, address: address + member.offset, immediate: nil), depth: depth + 1))
|
||
}
|
||
return "{" + values.joined(separator: ", ") + (members.count > 4 ? ", …}" : "}")
|
||
case "floating": return try floating(operand)
|
||
default: throw Problem("This compiler type is not supported by the watch evaluator.")
|
||
}
|
||
}
|
||
func visibleVariables() -> [Value] {
|
||
let names = Set(candidates().map(\.name)).sorted()
|
||
let verificationError: Error?
|
||
do { try verified(); verificationError = nil } catch { verificationError = error }
|
||
return names.map { name in
|
||
do {
|
||
if let verificationError { throw verificationError }
|
||
let variable = try resolve(name), value = try operand(variable)
|
||
return Value(name: name, typeName: value.type.name, value: try describe(value),
|
||
address: value.address.flatMap(UInt16.init(exactly:)), error: nil)
|
||
} catch {
|
||
let type = (try? resolve(name))?.type.name ?? ""
|
||
return Value(name: name, typeName: type, value: "Unavailable", address: nil, error: message(error))
|
||
}
|
||
}
|
||
}
|
||
func evaluate(_ expression: String) -> Value {
|
||
do {
|
||
try verified()
|
||
var parser = try Parser(expression)
|
||
let tree = try parser.parse()
|
||
let result = try evaluate(tree, depth: 0)
|
||
return Value(name: expression, typeName: result.type.name, value: try describe(result),
|
||
address: result.address.flatMap(UInt16.init(exactly:)), error: nil)
|
||
} catch { return Value(name: expression, typeName: "", value: "Unavailable", address: nil, error: message(error)) }
|
||
}
|
||
// Lazy tree access resolves typed paths from the current root and frame.
|
||
// No stored node is a capability to read an address from an older snapshot.
|
||
func variableRootPaths() -> [TreePath] {
|
||
Set(candidates().map(\.name)).sorted().map { TreePath(root: .variable($0)) }
|
||
}
|
||
func variableRoots() -> [TreeNode] { variableRootPaths().map { treeNode(at: $0) } }
|
||
func variableTreeRoots() -> [TreeNode] { variableRoots() }
|
||
func watchRoot(_ expression: String) -> TreeNode { treeNode(at: .init(root: .watch(expression))) }
|
||
func watchTreeRoot(_ expression: String) -> TreeNode { watchRoot(expression) }
|
||
func treeNode(at path: TreePath) -> TreeNode {
|
||
do {
|
||
try verified()
|
||
return try makeTreeNode(path: path, operand: treeOperand(at: path))
|
||
} catch { return treeError(path, error) }
|
||
}
|
||
func children(of path: TreePath, offset: Int = 0) -> TreePage {
|
||
do {
|
||
try verified()
|
||
guard path.components.count < 12 else { throw Problem("The 12-level inspection limit has been reached.") }
|
||
let parent = try treeOperand(at: path)
|
||
let total = treeChildCount(parent.type)
|
||
guard offset >= 0, offset <= total else { throw Problem("This child page is outside the declared bounds.") }
|
||
let end = min(total, offset + 32)
|
||
let nodes = (offset..<end).map { index -> TreeNode in
|
||
let component: Component
|
||
switch parent.type.kind {
|
||
case "array": component = .index(index)
|
||
case "aggregate": component = .member(parent.type.members![index].name)
|
||
default: component = .pointee
|
||
}
|
||
let child = path.appending(component)
|
||
do { return try makeTreeNode(path: child, operand: treeOperand(at: child)) }
|
||
catch { return treeError(child, error) }
|
||
}
|
||
return TreePage(nodes: nodes, totalCount: total, nextOffset: end < total ? end : nil, error: nil)
|
||
} catch { return TreePage(nodes: [], totalCount: 0, nextOffset: nil, error: message(error)) }
|
||
}
|
||
private func treeName(_ path: TreePath) -> String {
|
||
if let last = path.components.last {
|
||
switch last { case .index(let i): return "[\(i)]"; case .member(let name): return name; case .pointee: return "Pointee" }
|
||
}
|
||
switch path.root { case .variable(let name), .watch(let name): return name }
|
||
}
|
||
private func treeError(_ path: TreePath, _ error: Error) -> TreeNode {
|
||
TreeNode(path: path, name: treeName(path), typeName: "", value: "Unavailable", address: nil,
|
||
error: message(error), childCount: 0)
|
||
}
|
||
private func treeChildCount(_ type: CMOCVariableDebug.CType) -> Int {
|
||
switch type.kind {
|
||
case "array": return min(max(type.count ?? 0, 0), 65535)
|
||
case "aggregate": return min(type.members?.count ?? 0, 1024)
|
||
case "pointer": return 1 // Explicit expansion explains null/unknown targets.
|
||
default: return 0
|
||
}
|
||
}
|
||
private func makeTreeNode(path: TreePath, operand: Operand) throws -> TreeNode {
|
||
let type = operand.type
|
||
let count = treeChildCount(type)
|
||
let summary: String
|
||
// Aggregate rows do not read children. An unavailable member cannot
|
||
// prevent expansion of its inspectable siblings.
|
||
do {
|
||
switch type.kind {
|
||
case "array": summary = "[\(count) elements]"
|
||
case "aggregate": summary = "{\(count) members}"
|
||
default: summary = try describe(operand)
|
||
}
|
||
} catch {
|
||
return TreeNode(path: path, name: treeName(path), typeName: type.name, value: "Unavailable",
|
||
address: operand.address.flatMap(UInt16.init(exactly:)), error: message(error), childCount: 0)
|
||
}
|
||
let atLimit = path.components.count >= 12 && count > 0
|
||
return TreeNode(path: path, name: treeName(path), typeName: type.name, value: summary,
|
||
address: operand.address.flatMap(UInt16.init(exactly:)),
|
||
error: atLimit ? "The 12-level inspection limit has been reached." : nil,
|
||
childCount: atLimit ? 0 : count)
|
||
}
|
||
private struct TreeVisit: Hashable {
|
||
let address: Int
|
||
let name: String
|
||
let kind: String
|
||
let size: Int
|
||
}
|
||
private func treeOperand(at path: TreePath) throws -> Operand {
|
||
guard path.components.count <= 12 else { throw Problem("The 12-level inspection limit has been reached.") }
|
||
var value: Operand
|
||
switch path.root {
|
||
case .variable(let name): value = try operand(resolve(name))
|
||
case .watch(let expression):
|
||
var parser = try Parser(expression)
|
||
value = try evaluate(parser.parse(), depth: 0)
|
||
}
|
||
var visited = Set<TreeVisit>()
|
||
func visit(_ operand: Operand) -> TreeVisit? {
|
||
operand.address.map { TreeVisit(address: $0, name: operand.type.name, kind: operand.type.kind, size: operand.type.size) }
|
||
}
|
||
if let root = visit(value) { visited.insert(root) }
|
||
for component in path.components {
|
||
switch component {
|
||
case .index(let index):
|
||
guard value.type.kind == "array", let count = value.type.count, let element = value.type.element,
|
||
let first = value.address, index >= 0, index < count, element.size > 0 else {
|
||
throw Problem("Array index is outside its declared bounds or its element layout is unavailable.")
|
||
}
|
||
let (displacement, overflow) = index.multipliedReportingOverflow(by: element.size)
|
||
let (address, additionOverflow) = first.addingReportingOverflow(displacement)
|
||
guard !overflow, !additionOverflow, address >= 0, element.size <= 65536,
|
||
address <= 65536 - element.size else { throw Problem("Indexed address is outside logical memory.") }
|
||
value = Operand(type: element, address: address, immediate: nil)
|
||
case .member(let name):
|
||
guard value.type.kind == "aggregate", let first = value.address,
|
||
let member = value.type.members?.first(where: { $0.name == name }) else {
|
||
throw Problem("No inspectable member named ‘\(name)’.")
|
||
}
|
||
let (address, overflow) = first.addingReportingOverflow(member.offset)
|
||
guard !overflow, address >= 0, member.type.size >= 0, member.type.size <= 65536,
|
||
address <= 65536 - member.type.size else { throw Problem("Member address is outside logical memory.") }
|
||
value = Operand(type: member.type, address: address, immediate: nil)
|
||
case .pointee:
|
||
value = try dereference(value)
|
||
if let next = visit(value), visited.contains(next) { throw Problem("Pointer cycle: this object already appears in the expanded path.") }
|
||
}
|
||
if let next = visit(value) { visited.insert(next) }
|
||
}
|
||
return value
|
||
}
|
||
private func message(_ error: Error) -> String { (error as? Problem)?.message ?? error.localizedDescription }
|
||
private indirect enum Expr {
|
||
case identifier(String), number(Int64), unary(String, Expr), binary(String, Expr, Expr), index(Expr, Expr), member(Expr, String, Bool)
|
||
}
|
||
private func evaluate(_ expression: Expr, depth: Int) throws -> Operand {
|
||
guard depth <= 32 else { throw Problem("Watch expression is too deeply nested.") }
|
||
func eval(_ value: Expr) throws -> Operand { try evaluate(value, depth: depth + 1) }
|
||
func literal(_ value: Int64) -> Operand { Operand(type: .init(name: "watch integer (64-bit)", kind: "integer", size: 8, signed: true), address: nil, immediate: value) }
|
||
switch expression {
|
||
case .identifier(let name): return try operand(resolve(name))
|
||
case .number(let value): return literal(value)
|
||
case .unary(let operation, let expression):
|
||
let value = try eval(expression)
|
||
if operation == "&" {
|
||
guard let address = value.address else { throw Problem("Address-of requires stored data.") }
|
||
return Operand(type: .init(name: value.type.name + " *", kind: "pointer", size: 2, element: value.type), address: nil, immediate: Int64(address))
|
||
}
|
||
if operation == "*" { return try dereference(value) }
|
||
let number = try integer(value)
|
||
switch operation {
|
||
case "+": return literal(number)
|
||
case "-": guard number != Int64.min else { throw Problem("Integer overflow in watch.") }; return literal(-number)
|
||
case "~": return literal(~number)
|
||
case "!": return literal(number == 0 ? 1 : 0)
|
||
default: throw Problem("Unsupported unary operation.")
|
||
}
|
||
case .index(let target, let index):
|
||
let base = try eval(target), number = try integer(eval(index))
|
||
let element: CMOCVariableDebug.CType, address: Int64
|
||
if base.type.kind == "array", let next = base.type.element, let first = base.address, let count = base.type.count {
|
||
guard number >= 0, number < count else { throw Problem("Array index is outside its declared bounds.") }
|
||
element = next; address = Int64(first)
|
||
} else if base.type.kind == "pointer", let next = base.type.element {
|
||
element = next; address = try integer(base)
|
||
} else { throw Problem("Indexing requires an array or pointer.") }
|
||
guard element.size > 0, number >= -65536, number <= 65536 else { throw Problem("Invalid element size or index.") }
|
||
let result = address + number * Int64(element.size)
|
||
guard result >= 0, result + Int64(element.size) <= 65536 else { throw Problem("Indexed address is outside logical memory.") }
|
||
return Operand(type: element, address: Int(result), immediate: nil)
|
||
case .member(let target, let name, let pointer):
|
||
let source = try eval(target), base = try pointer ? dereference(source) : source
|
||
guard base.type.kind == "aggregate", let address = base.address,
|
||
let member = base.type.members?.first(where: { $0.name == name }) else { throw Problem("No inspectable member named ‘\(name)’.") }
|
||
return Operand(type: member.type, address: address + member.offset, immediate: nil)
|
||
case .binary(let operation, let left, let right):
|
||
let lhs = try eval(left)
|
||
let a = try integer(lhs)
|
||
if operation == "&&", a == 0 { return literal(0) }
|
||
if operation == "||", a != 0 { return literal(1) }
|
||
let rhs = try eval(right), b = try integer(rhs)
|
||
if lhs.type.kind == "pointer", ["+", "-"].contains(operation), rhs.type.kind == "integer", let element = lhs.type.element {
|
||
guard element.size > 0, b >= -65536, b <= 65536 else { throw Problem("Invalid pointer arithmetic.") }
|
||
let address = a + (operation == "+" ? b : -b) * Int64(element.size)
|
||
guard (0...65535).contains(address) else { throw Problem("Pointer arithmetic leaves logical memory.") }
|
||
return Operand(type: lhs.type, address: nil, immediate: address)
|
||
}
|
||
switch operation {
|
||
case "+": let (r,o) = a.addingReportingOverflow(b); guard !o else { throw Problem("Integer overflow in watch.") }; return literal(r)
|
||
case "-": let (r,o) = a.subtractingReportingOverflow(b); guard !o else { throw Problem("Integer overflow in watch.") }; return literal(r)
|
||
case "*": let (r,o) = a.multipliedReportingOverflow(by: b); guard !o else { throw Problem("Integer overflow in watch.") }; return literal(r)
|
||
case "/", "%": guard b != 0, !(a == Int64.min && b == -1) else { throw Problem("Invalid division in watch.") }; return literal(operation == "/" ? a / b : a % b)
|
||
case "&": return literal(a & b)
|
||
case "|": return literal(a | b)
|
||
case "^": return literal(a ^ b)
|
||
case "<<", ">>":
|
||
guard (0...31).contains(b) else { throw Problem("Shift count must be between 0 and 31.") }
|
||
if operation == ">>" { return literal(a >> b) }
|
||
let (shifted, overflow) = a.multipliedReportingOverflow(by: Int64(1) << b)
|
||
guard !overflow else { throw Problem("Integer overflow in watch.") }; return literal(shifted)
|
||
case "==": return literal(a == b ? 1 : 0)
|
||
case "!=": return literal(a != b ? 1 : 0)
|
||
case "<": return literal(a < b ? 1 : 0)
|
||
case "<=": return literal(a <= b ? 1 : 0)
|
||
case ">": return literal(a > b ? 1 : 0)
|
||
case ">=": return literal(a >= b ? 1 : 0)
|
||
case "&&": return literal(a != 0 && b != 0 ? 1 : 0)
|
||
case "||": return literal(a != 0 || b != 0 ? 1 : 0)
|
||
default: throw Problem("Unsupported binary operation.")
|
||
}
|
||
}
|
||
}
|
||
private func dereference(_ value: Operand) throws -> Operand {
|
||
guard value.type.kind == "pointer", let element = value.type.element, element.size > 0 else { throw Problem("Dereference requires a pointer to a known data type.") }
|
||
let address = try integer(value)
|
||
guard address > 0, address + Int64(element.size) <= 65536 else { throw Problem("Null or out-of-range pointer.") }
|
||
return Operand(type: element, address: Int(address), immediate: nil)
|
||
}
|
||
private struct Parser {
|
||
var tokens: [String] = []
|
||
var index = 0
|
||
init(_ text: String) throws {
|
||
guard text.utf8.count <= 1024 else { throw Problem("Watch expression is too long.") }
|
||
let chars = Array(text)
|
||
var i = 0
|
||
while i < chars.count {
|
||
let c = chars[i]
|
||
if c.isWhitespace { i += 1; continue }
|
||
if c.isASCII && (c.isLetter || c == "_" || c.isNumber) {
|
||
let begin = i; i += 1
|
||
while i < chars.count, chars[i].isASCII && (chars[i].isLetter || chars[i].isNumber || chars[i] == "_") { i += 1 }
|
||
tokens.append(String(chars[begin..<i])); continue
|
||
}
|
||
let pair = i + 1 < chars.count ? String(chars[i...i+1]) : ""
|
||
guard pair != "++", pair != "--" else { throw Problem("Increment and decrement would modify guest data and are not supported.") }
|
||
if ["->", "==", "!=", "<=", ">=", "&&", "||", "<<", ">>"].contains(pair) { tokens.append(pair); i += 2; continue }
|
||
guard "()+-*/%&|^~!<>[].".contains(c) else { throw Problem("Only read-only expressions are supported; assignments and function calls are unavailable.") }
|
||
tokens.append(String(c)); i += 1
|
||
}
|
||
guard !tokens.isEmpty, tokens.count <= 128 else { throw Problem("Enter a variable or a short read-only expression.") }
|
||
}
|
||
mutating func parse() throws -> Expr {
|
||
let result = try binary(minimum: 0, depth: 0)
|
||
guard index == tokens.count else { throw Problem("Unsupported expression syntax. Function calls and assignments are not evaluated.") }
|
||
return result
|
||
}
|
||
func precedence(_ token: String) -> Int? {
|
||
switch token {
|
||
case "||": return 0
|
||
case "&&": return 1
|
||
case "|": return 2
|
||
case "^": return 3
|
||
case "&": return 4
|
||
case "==", "!=": return 5
|
||
case "<", "<=", ">", ">=": return 6
|
||
case "<<", ">>": return 7
|
||
case "+", "-": return 8
|
||
case "*", "/", "%": return 9
|
||
default: return nil
|
||
}
|
||
}
|
||
mutating func binary(minimum: Int, depth: Int) throws -> Expr {
|
||
guard depth <= 32 else { throw Problem("Watch expression is too deeply nested.") }
|
||
var left = try unary(depth: depth + 1)
|
||
while index < tokens.count, let p = precedence(tokens[index]), p >= minimum {
|
||
let operation = tokens[index]; index += 1
|
||
left = .binary(operation, left, try binary(minimum: p + 1, depth: depth + 1))
|
||
}
|
||
return left
|
||
}
|
||
mutating func unary(depth: Int) throws -> Expr {
|
||
guard depth <= 32, index < tokens.count else { throw Problem("Incomplete or overly nested watch expression.") }
|
||
let token = tokens[index]; index += 1
|
||
if ["*", "&", "+", "-", "~", "!"].contains(token) { return .unary(token, try unary(depth: depth + 1)) }
|
||
var result: Expr
|
||
if token == "(" {
|
||
result = try binary(minimum: 0, depth: depth + 1); try expect(")")
|
||
} else if token.first?.isNumber == true {
|
||
let number: Int64?
|
||
if token.lowercased().hasPrefix("0x") { number = Int64(token.dropFirst(2), radix: 16) }
|
||
else { number = Int64(token, radix: 10) }
|
||
guard let number else { throw Problem("Invalid integer literal.") }; result = .number(number)
|
||
} else if token.first?.isLetter == true || token.first == "_" { result = .identifier(token) }
|
||
else { throw Problem("Expected a variable, number or parenthesized expression.") }
|
||
while index < tokens.count {
|
||
if tokens[index] == "[" {
|
||
index += 1; let subscriptValue = try binary(minimum: 0, depth: depth + 1); try expect("]")
|
||
result = .index(result, subscriptValue)
|
||
} else if [".", "->"].contains(tokens[index]) {
|
||
let pointer = tokens[index] == "->"; index += 1
|
||
guard index < tokens.count, tokens[index].first?.isLetter == true || tokens[index].first == "_" else { throw Problem("Expected a member name.") }
|
||
result = .member(result, tokens[index], pointer); index += 1
|
||
} else { break }
|
||
}
|
||
return result
|
||
}
|
||
mutating func expect(_ token: String) throws {
|
||
guard index < tokens.count, tokens[index] == token else { throw Problem("Expected ‘\(token)’.") }; index += 1
|
||
}
|
||
}
|
||
}
|