Evaluate more table formulas natively !127

merged merged by cmc on 2026-10-07 04:21 UTC · krz/orgstar:native-formulas into main

5 files changed, +628 −76

Layout: unified · split

Sources/OrgCore/Compute/Calc.swift +227 −14

		@@ -11,11 +11,21 @@ public enum Calc {
11	11	init(_ reason: String) { self.reason = reason }
12	12	}
13	13
14		public enum Value: Equatable, Sendable {
	14	/// An error Calc reports, which a table shows as `#ERROR`.
	15	public struct Failure: Error, Equatable, CustomStringConvertible {
	16	public let reason: String
	17	public var description: String { reason }
	18	init(_ reason: String) { self.reason = reason }
	19	}
	20
	21	public indirect enum Value: Equatable, Sendable {
15	22	case int(Int)
16	23	/// Mantissa and exponent, normalized: at most `precision` digits, no trailing zeros.
17	24	case float(Int, Int)
18	25	case vector([Value])
	26	/// A date form: the day number, with the time of day as a fraction.
	27	case date(Value)
	28	case nan
19	29	}
20	30
21	31	public enum FloatFormat: Equatable, Sendable {
		@@ -29,12 +39,19 @@ public enum Calc {
29	39	public init() {}
30	40	}
31	41
32		/// `calc-eval` of `expression`, as the string Calc would return.
33		public static func evaluate(_ expression: String, modes: Modes = Modes()) throws -> String {
	42	/// `calc-eval` of `expression`, as the string Calc would return; with `numeric`, as
	43	/// `calc-eval` with `num`, a result that isn't a number is an error.
	44	public static func evaluate(_ expression: String, modes: Modes = Modes(), numeric: Bool = false) throws -> String {
34	45	guard modes.precision == 12 else { throw Unsupported("calc precision") }
35	46	var parser = Parser(expression)
36	47	let tree = try parser.parse()
37	48	let value = try Evaluator(modes: modes).eval(tree)
	49	if numeric {
	50	switch value {
	51	case .int, .float: break
	52	default: throw Failure("Number expected")
	53	}
	54	}
38	55	return try format(value, modes.format)
39	56	}
40	57
		@@ -95,6 +112,7 @@ public enum Calc {
95	112	case .int(let i): return (Int128(i), 0)
96	113	case .float(let m, let e): return (Int128(m), e)
97	114	case .vector: throw Unsupported("vector arithmetic")
	115	case .date, .nan: throw Unsupported("date arithmetic")
98	116	}
99	117	}
100	118
		@@ -103,6 +121,7 @@ public enum Calc {
103	121	case .int(let i): return Double(i)
104	122	case .float(let m, let e): return Double(m) * pow(10, Double(e))
105	123	case .vector: throw Unsupported("vector arithmetic")
	124	case .date, .nan: throw Unsupported("date arithmetic")
106	125	}
107	126	}
108	127
		@@ -118,6 +137,14 @@ public enum Calc {
118	137	}
119	138
120	139	static func add(_ a: Value, _ b: Value) throws -> Value {
	140	switch (a, b) {
	141	case (.nan, .vector), (.vector, .nan): throw Unsupported("vector arithmetic")
	142	case (.nan, _), (_, .nan): return .nan
	143	case (.date, .date): throw Unsupported("date arithmetic")
	144	case (.date(let d), _): return .date(try add(d, b))
	145	case (_, .date(let d)): return .date(try add(a, d))
	146	default: break
	147	}
121	148	if case .int(let x) = a, case .int(let y) = b {
122	149	let (sum, overflow) = x.addingReportingOverflow(y)
123	150	if overflow { throw Unsupported("integer size") }
		@@ -143,10 +170,26 @@ public enum Calc {
143	170	return .int(-i)
144	171	case .float(let m, let e): return .float(-m, e)
145	172	case .vector: throw Unsupported("vector arithmetic")
	173	case .date: throw Unsupported("date arithmetic")
	174	case .nan: return .nan
146	175	}
147	176	}
148	177
	178	/// `a - b`: a date less a date is the days between them.
	179	static func subtract(_ a: Value, _ b: Value) throws -> Value {
	180	if case .date(let x) = a, case .date(let y) = b { return try add(x, try negate(y)) }
	181	if case .date(let x) = a, b != .nan { return .date(try add(x, try negate(b))) }
	182	return try add(a, try negate(b))
	183	}
	184
	185	static func isNaN(_ a: Value, _ b: Value) -> Bool {
	186	if case .vector = a { return false }
	187	if case .vector = b { return false }
	188	return a == .nan \|\| b == .nan
	189	}
	190
149	191	static func multiply(_ a: Value, _ b: Value) throws -> Value {
	192	if isNaN(a, b) { return .nan }
150	193	if case .int(let x) = a, case .int(let y) = b {
151	194	let (product, overflow) = x.multipliedReportingOverflow(by: y)
152	195	if overflow { throw Unsupported("integer size") }
		@@ -160,6 +203,7 @@ public enum Calc {
160	203	}
161	204
162	205	static func divide(_ a: Value, _ b: Value) throws -> Value {
	206	if isNaN(a, b) { return .nan }
163	207	if case .int(let x) = a, case .int(let y) = b {
164	208	guard y != 0 else { throw Unsupported("division by zero") }
165	209	if x % y == 0 { return .int(x / y) }
		@@ -189,6 +233,7 @@ public enum Calc {
189	233	}
190	234
191	235	static func power(_ a: Value, _ b: Value) throws -> Value {
	236	if isNaN(a, b) { return .nan }
192	237	if case .int(let n) = b { return try integerPower(a, n) }
193	238	let base = try double(a)
194	239	guard base >= 0 else { throw Unsupported("complex result") }
		@@ -196,6 +241,8 @@ public enum Calc {
196	241	}
197	242
198	243	static func compare(_ a: Value, _ b: Value) throws -> Int {
	244	if case .date(let x) = a, case .date(let y) = b { return try compare(x, y) }
	245	if a == .nan \|\| b == .nan { throw Unsupported("comparison with nan") }
199	246	let difference = try add(a, try negate(b))
200	247	let (m, _) = try parts(difference)
201	248	return m == 0 ? 0 : (m < 0 ? -1 : 1)
		@@ -208,6 +255,8 @@ public enum Calc {
208	255	switch value {
209	256	case .int(let i): return String(i)
210	257	case .vector: throw Unsupported("vector result")
	258	case .nan: return "nan"
	259	case .date(let d): return "<" + (try formatDate(d)) + ">"
211	260	case .float(let m, _) where m < 0:
212	261	guard case .float(let m, let e) = value else { fatalError() }
213	262	return "-" + (try format(.float(-m, e), floatFormat))
		@@ -263,6 +312,34 @@ public enum Calc {
263	312	}
264	313	}
265	314
	315	static let weekdays = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]
	316
	317	/// `calc-date-format` as Org sets it: `YYYY-MM-DD Www`, then ` hh:mm` for a time of day.
	318	static func formatDate(_ value: Value) throws -> String {
	319	let days = try double(value)
	320	let day = Int(days.rounded(.down))
	321	let date = Days.date(day)
	322	var text = String(format: "%04d-%02d-%02d ", date.year, date.month, date.day) + weekdays[Days.weekday(day)]
	323	if case .float = value, days != Double(day) {
	324	let seconds = Int(((days - Double(day)) * 86400).rounded())
	325	text += String(format: " %02d:%02d", seconds / 3600, seconds / 60 % 60)
	326	}
	327	return text
	328	}
	329
	330	/// A date form `<YYYY-MM-DD Www>` or `<YYYY-MM-DD Www hh:mm>`, from the text between
	331	/// the brackets.
	332	static func parseDate(_ text: String) throws -> Value {
	333	guard let m = text.firstMatch(of: /^([0-9]{4})-([0-9]{2})-([0-9]{2})(?: +[A-Za-z]+)?(?: +([0-9]{1,2}):([0-9]{2})(?::([0-9]{2}))?)?$/) else {
	334	throw Unsupported("date syntax")
	335	}
	336	let day = Days.absolute(year: Int(m.1)!, month: Int(m.2)!, day: Int(m.3)!)
	337	guard let hour = m.4.flatMap({ Int($0) }), let minute = m.5.flatMap({ Int($0) }) else { return .date(.int(day)) }
	338	let seconds = hour * 3600 + minute * 60 + (m.6.flatMap { Int($0) } ?? 0)
	339	if seconds == 0 { return .date(.int(day)) }
	340	return .date(try add(.int(day), try divide(.int(seconds), .int(86400))))
	341	}
	342
266	343	// MARK: - Parsing
267	344
268	345	indirect enum Node {
		@@ -289,11 +366,50 @@ public enum Calc {
289	366	}
290	367
291	368	mutating func parse() throws -> Node {
292		let node = try sum()
	369	let node = try or()
293	370	guard peek() == nil else { throw Unsupported("formula syntax") }
294	371	return node
295	372	}
296	373
	374	mutating func take(_ token: String) -> Bool {
	375	guard peek() != nil else { return false }
	376	let t = Array(token)
	377	guard i + t.count <= chars.count, Array(chars[i..<(i + t.count)]) == t else { return false }
	378	i += t.count
	379	return true
	380	}
	381
	382	// `\|\|` < `&&` < `!` < comparisons < sums.
	383	mutating func or() throws -> Node {
	384	var left = try and()
	385	while take("\|\|") { left = .binary("\|", left, try and()) }
	386	return left
	387	}
	388
	389	mutating func and() throws -> Node {
	390	var left = try not()
	391	while take("&&") { left = .binary("&", left, try not()) }
	392	return left
	393	}
	394
	395	mutating func not() throws -> Node {
	396	if peek() == "!", i + 1 >= chars.count \|\| chars[i + 1] != "=" {
	397	i += 1
	398	return .unary("!", try not())
	399	}
	400	return try comparison()
	401	}
	402
	403	mutating func comparison() throws -> Node {
	404	let left = try sum()
	405	for (token, op) in [("==", "="), ("!=", "≠"), ("<=", "≤"), (">=", "≥"), ("<", "<"), (">", ">")] where take(token) {
	406	let right = try sum()
	407	if let next = peek(), "=!<>".contains(next) { throw Unsupported("chained comparison") }
	408	return .binary(Character(op), left, right)
	409	}
	410	return left
	411	}
	412
297	413	// `+ -` < `/` < `*` < unary minus < `^`, as Calc's operator table orders them.
298	414	mutating func sum() throws -> Node {
299	415	var left = try quotient()
		@@ -306,9 +422,9 @@ public enum Calc {
306	422
307	423	mutating func quotient() throws -> Node {
308	424	var left = try product()
309		while peek() == "/" {
	425	while let c = peek(), c == "/" \|\| c == "%" \|\| c == "\\" {
310	426	i += 1
311		left = .binary("/", left, try product())
	427	left = .binary(c, left, try product())
312	428	}
313	429	return left
314	430	}
		@@ -344,7 +460,7 @@ public enum Calc {
344	460	guard let c = peek() else { throw Unsupported("formula syntax") }
345	461	if c == "(" {
346	462	i += 1
347		let inner = try sum()
	463	let inner = try or()
348	464	guard peek() == ")" else { throw Unsupported("formula syntax") }
349	465	i += 1
350	466	return inner
		@@ -353,10 +469,10 @@ public enum Calc {
353	469	i += 1
354	470	var items: [Node] = []
355	471	if peek() != "]" {
356		items.append(try sum())
	472	items.append(try or())
357	473	while peek() == "," {
358	474	i += 1
359		items.append(try sum())
	475	items.append(try or())
360	476	}
361	477	}
362	478	guard peek() == "]" else { throw Unsupported("formula syntax") }
		@@ -364,20 +480,29 @@ public enum Calc {
364	480	return .vector(items)
365	481	}
366	482	if c.isASCII, c.isNumber \|\| c == "." { return .number(try number()) }
	483	if c == "<" {
	484	guard let close = chars[i...].firstIndex(of: ">") else { throw Unsupported("formula syntax") }
	485	let text = String(chars[(i + 1)..<close])
	486	i = close + 1
	487	return .number(try parseDate(text))
	488	}
367	489	if c.isLetter {
368	490	var name = ""
369	491	while i < chars.count, chars[i].isLetter \|\| chars[i].isNumber \|\| chars[i] == "_" {
370	492	name.append(chars[i])
371	493	i += 1
372	494	}
373		guard peek() == "(" else { throw Unsupported("variable \(name)") }
	495	guard peek() == "(" else {
	496	if name == "nan" { return .number(.nan) }
	497	throw Unsupported("variable \(name)")
	498	}
374	499	i += 1
375	500	var args: [Node] = []
376	501	if peek() != ")" {
377		args.append(try sum())
	502	args.append(try or())
378	503	while peek() == "," {
379	504	i += 1
380		args.append(try sum())
	505	args.append(try or())
381	506	}
382	507	}
383	508	guard peek() == ")" else { throw Unsupported("formula syntax") }
		@@ -443,22 +568,90 @@ public enum Calc {
443	568	switch node {
444	569	case .number(let v): return v
445	570	case .vector(let items): return .vector(try items.map(eval))
	571	case .unary("!", let operand): return .int(try truth(try eval(operand)) ? 0 : 1)
446	572	case .unary(_, let operand): return try negate(try eval(operand))
447	573	case .binary(let op, let l, let r):
448	574	let a = try eval(l)
449	575	let b = try eval(r)
450	576	switch op {
451	577	case "+": return try add(a, b)
452		case "-": return try add(a, try negate(b))
	578	case "-": return try subtract(a, b)
453	579	case "*": return try multiply(a, b)
454	580	case "/": return try divide(a, b)
455		default: return try power(a, b)
	581	case "%": return try mod(a, b)
	582	case "\\": return try idiv(a, b)
	583	case "^": return try power(a, b)
	584	case "\|": return .int(try truth(a) \|\| truth(b) ? 1 : 0)
	585	case "&": return .int(try truth(a) && truth(b) ? 1 : 0)
	586	default:
	587	let order = try compare(a, b)
	588	let holds = switch op {
	589	case "=": order == 0
	590	case "≠": order != 0
	591	case "<": order < 0
	592	case ">": order > 0
	593	case "≤": order <= 0
	594	default: order >= 0
	595	}
	596	return .int(holds ? 1 : 0)
456	597	}
457	598	case .call(let name, let args):
458	599	return try call(name, try args.map(eval))
459	600	}
460	601	}
461	602
	603	/// A condition's value: a number, nonzero for true.
	604	func truth(_ v: Value) throws -> Bool {
	605	switch v {
	606	case .int(let i): return i != 0
	607	case .float(let m, _): return m != 0
	608	default: throw Unsupported("condition")
	609	}
	610	}
	611
	612	/// `math-mod`: the remainder with the divisor's sign.
	613	func mod(_ a: Value, _ b: Value) throws -> Value {
	614	if case .int(let x) = a, case .int(let y) = b {
	615	guard y != 0 else { throw Unsupported("division by zero") }
	616	let r = x % y
	617	return .int(r != 0 && (r < 0) != (y < 0) ? r + y : r)
	618	}
	619	let q = try floorOf(try divide(a, b))
	620	return try subtract(a, try multiply(b, q))
	621	}
	622
	623	/// `calcFunc-idiv`: the quotient rounded down.
	624	func idiv(_ a: Value, _ b: Value) throws -> Value {
	625	if case .int(let x) = a, case .int(let y) = b {
	626	guard y != 0 else { throw Unsupported("division by zero") }
	627	let q = x / y
	628	return .int(q * y != x && (x < 0) != (y < 0) ? q - 1 : q)
	629	}
	630	return try floorOf(try divide(a, b))
	631	}
	632
	633	func floorOf(_ v: Value) throws -> Value {
	634	if case .int = v { return v }
	635	guard let i = Int(exactly: try double(v).rounded(.down)) else { throw Unsupported("integer size") }
	636	return .int(i)
	637	}
	638
	639	/// The sum of squared deviations from the mean, and the count.
	640	func deviations(_ args: [Value]) throws -> (Value, Int) {
	641	let items = try elements(args)
	642	guard !items.isEmpty else { throw Unsupported("empty vector") }
	643	let mean = try divide(try items.reduce(Value.int(0)) { try add($0, $1) }, .int(items.count))
	644	let squares = try items.reduce(Value.int(0)) { sum, x in
	645	let d = try subtract(x, mean)
	646	return try add(sum, try multiply(d, d))
	647	}
	648	return (squares, items.count)
	649	}
	650
	651	func root(_ x: Value) throws -> Value {
	652	try call("sqrt", [x])
	653	}
	654
462	655	func elements(_ args: [Value]) throws -> [Value] {
463	656	guard args.count == 1 else { throw Unsupported("arguments") }
464	657	if case .vector(let items) = args[0] { return items }
		@@ -500,6 +693,26 @@ public enum Calc {
500	693	try items.sort { try compare($0, $1) < 0 }
501	694	if items.count % 2 == 1 { return items[items.count / 2] }
502	695	return try divide(try add(items[items.count / 2 - 1], items[items.count / 2]), .int(2))
	696	case "if":
	697	guard args.count == 3 else { throw Unsupported("arguments") }
	698	return try truth(args[0]) ? args[1] : args[2]
	699	case "vvar", "vpvar", "vsdev", "vpsdev":
	700	let (squares, n) = try deviations(args)
	701	let population = name == "vpvar" \|\| name == "vpsdev"
	702	if !population, n < 2 { throw Unsupported("variance of one value") }
	703	let variance = try divide(squares, .int(population ? n : n - 1))
	704	return name.hasSuffix("sdev") ? try root(variance) : variance
	705	case "mod":
	706	guard args.count == 2 else { throw Unsupported("arguments") }
	707	return try mod(args[0], args[1])
	708	case "idiv":
	709	guard args.count == 2 else { throw Unsupported("arguments") }
	710	return try idiv(args[0], args[1])
	711	case "fact":
	712	guard case .int(let n) = try one(args), n >= 0 else { throw Unsupported("arguments") }
	713	var result = Value.int(1)
	714	for k in stride(from: 2, through: n, by: 1) { result = try multiply(result, .int(k)) }
	715	return result
503	716	case "max", "min":
504	717	guard !args.isEmpty else { throw Unsupported("arguments") }
505	718	var best = args[0]

Sources/OrgCore/Compute/TableFormulas.swift +350 −60

		@@ -1,9 +1,9 @@
1	1	import Foundation
2	2
3	3	// Table formulas (org-table.el, Org 9.8.7): `org-table-recalculate` and
4		// `org-table-eval-formula` with Calc evaluated natively. Column names, constants, named
5		// fields, marked rows, `remote()`, Lisp formulas, durations and Calc features beyond `Calc`
6		// throw `Calc.Unsupported`; the caller then recalculates the table in Emacs.
	4	// `org-table-eval-formula` with Calc and Lisp evaluated natively. Symbolic results, Calc
	5	// features beyond `Calc`, Lisp beyond `Elisp`, remote tables found by ID and relative field
	6	// targets throw `Calc.Unsupported`; the caller then recalculates the table in Emacs.
7	7
8	8	extension EmacsBuffer {
9	9	struct TableAnalysis {
		@@ -13,6 +13,14 @@ extension EmacsBuffer {
13	13	var types: [Bool]
14	14	var ncol: Int
15	15	var begin: Int
	16	/// `org-table-column-names`: from the first `!` row.
	17	var columnNames: [(name: String, column: Int)] = []
	18	/// `org-table-local-parameters`, in the order org pushes them; the last match wins.
	19	var parameters: [(name: String, value: String)] = []
	20	/// `org-table-named-field-locations`: the table-relative line and the column.
	21	var namedFields: [(name: String, line: Int, column: Int)] = []
	22	/// A row marked for calculation (`org-table-calculate-mark-regexp`).
	23	var marked = false
16	24	}
17	25
18	26	static let tblfmPattern = "^[ \\t]#\\+TBLFM: (.*)"
		@@ -26,13 +34,12 @@ extension EmacsBuffer {
26	34	point = begin
27	35	var dlines = [0]
28	36	var types: [Bool] = []
	37	var lines: [String] = []
29	38	var line = 0
30	39	while point < end \|\| (point == end && false) {
31	40	let content = substring(lineStart(point), lineEnd(point))
32	41	guard content.range(of: "^[ \\t]*\\\|", options: .regularExpression) != nil else { break }
33		if content.range(of: "^[ \\t]\\\| [!$_^] *(\\\|\|$)", options: .regularExpression) != nil {
34		throw Calc.Unsupported("named columns, parameters or fields")
35		}
	42	lines.append(content)
36	43	let isHline = content.range(of: "^[ \\t]*\\\|-", options: .regularExpression) != nil
37	44	types.append(isHline)
38	45	if !isHline { dlines.append(line) }
		@@ -45,10 +52,43 @@ extension EmacsBuffer {
45	52	forwardLine(dlines[1])
46	53	let first = substring(lineStart(point), lineEnd(point))
47	54	let ncol = Self.splitFields(first, separator: "[ \\t]\\\|[ \\t]").count
48		return TableAnalysis(dlines: dlines, types: types, ncol: ncol, begin: begin)
	55	var analysis = TableAnalysis(dlines: dlines, types: types, ncol: ncol, begin: begin)
	56	Self.names(lines, into: &analysis)
	57	return analysis
49	58	}
50	59	}
51	60
	61	/// The names part of `org-table-analyze`.
	62	static func names(_ lines: [String], into analysis: inout TableAnalysis) {
	63	let identifier = "^[a-zA-Z][_a-zA-Z0-9]*$"
	64	func rest(_ line: String, _ pattern: String) -> String? {
	65	guard let m = try! NSRegularExpression(pattern: pattern).firstMatch(in: line, range: NSRange(location: 0, length: (line as NSString).length)) else { return nil }
	66	return (line as NSString).substring(with: m.range(at: m.numberOfRanges - 1))
	67	}
	68	if let names = lines.lazy.compactMap({ rest($0, "^[ \\t]\\\| ! (\\\|.)") }).first {
	69	for (i, name) in splitFields(names, separator: " \\\| ").enumerated() where name.range(of: identifier, options: .regularExpression) != nil {
	70	analysis.columnNames.append((name, i + 2))
	71	}
	72	}
	73	for line in lines {
	74	guard let fields = rest(line, "^[ \\t]\\\| \\$ (\\\|.)") else { continue }
	75	for field in splitFields(fields, separator: " \\\| ") {
	76	if let m = field.firstMatch(of: /^([a-zA-Z][_a-zA-Z0-9]\|%) = (.)/) { analysis.parameters.append((String(m.1), String(m.2))) }
	77	}
	78	}
	79	for (k, line) in lines.enumerated() {
	80	guard let m = line.firstMatch(of: /^[ \t]\\| ([_^]) (\\|.)/) else { continue }
	81	let target = m.1 == "_" ? k + 1 : k - 1
	82	guard lines.indices.contains(target), let values = rest(lines[target], "^[ \\t]\\\|[^\|](\\\|.*)") else { continue }
	83	for (i, (name, value)) in zip(splitFields(String(m.2), separator: " \\\| "), splitFields(values, separator: " \\\| ")).enumerated()
	84	where name.range(of: identifier, options: .regularExpression) != nil {
	85	analysis.parameters.append((name, value))
	86	analysis.namedFields.append((name, target, i + 2))
	87	}
	88	}
	89	analysis.marked = lines.contains { $0.range(of: "^[ \\t]\\\| [!$^_#] (\\\|\|$)", options: .regularExpression) != nil }
	90	}
	91
52	92	/// `org-split-string`: leading and trailing separators produce no empty strings.
53	93	static func splitFields(_ s: String, separator: String) -> [String] {
54	94	let ns = s as NSString
		@@ -259,28 +299,180 @@ extension EmacsBuffer {
259	299	}
260	300
261	301	static let calcNumber = "^[-+]?([0-9]+\\.?[0-9]*\|\\.[0-9]+)([eE][-+]?[0-9]+)?$"
	302	/// `org-ts-regexp-both`.
	303	static let timestampBoth = "[\\[<]([0-9]{4}-[0-9]{2}-[0-9]{2}(?: [^\\]>\\n]*)?)[\\]>]"
	304
	305	/// How `org-table-make-reference` turns fields into formula text.
	306	struct ReferenceMode {
	307	enum Lisp { case none, lisp, literal }
	308	var keepEmpty = false
	309	var numbers = false
	310	var lisp = Lisp.none
	311	}
	312
	313	/// `number-to-string` of `string-to-number`.
	314	static func numberText(_ s: String) -> String { Elisp.printed(Elisp.stringToNumber(s)) }
262	315
263		/// `org-table-make-reference` for Calc, refusing what isn't a number.
264		static func reference(_ value: TableRangeValue) throws -> String {
265		func number(_ s: String) throws -> String {
266		guard s.range(of: calcNumber, options: .regularExpression) != nil else { throw Calc.Unsupported("non-numeric field \(s)") }
267		return s
	316	/// `org-table-make-reference`. For Calc, a field that isn't a number, a date or `nan`
	317	/// would be a symbol, which isn't supported.
	318	static func makeReference(_ value: TableRangeValue, _ mode: ReferenceMode) throws -> String {
	319	func blank(_ s: String) -> Bool { !s.contains { !$0.isWhitespace } }
	320	func lisp(_ s: String) -> String {
	321	switch mode.lisp {
	322	case .literal: s
	323	default: mode.numbers ? numberText(s) : Elisp.printed(.string(s), escape: true)
	324	}
268	325	}
	326	func calc(_ s: String) throws -> String {
	327	let text = mode.numbers ? numberText(s) : s
	328	guard text.range(of: calcNumber, options: .regularExpression) != nil \|\| text == "nan"
	329	\|\| text.range(of: "^" + timestampBoth + "$", options: .regularExpression) != nil else {
	330	throw Calc.Unsupported("non-numeric field \(text)")
	331	}
	332	return text
	333	}
	334	let empty = !mode.keepEmpty \|\| mode.numbers ? "0" : "nan"
269	335	switch value {
270	336	case .field(let s):
271		return s.contains(where: { !$0.isWhitespace }) ? "(" + (try number(s)) + ")" : "(0)"
272		case .list(let items):
273		return "[" + (try items.filter { $0.contains(where: { !$0.isWhitespace }) }.map(number)).joined(separator: ",") + "]"
	337	if mode.lisp != .none { return lisp(s) }
	338	return blank(s) ? (empty == "0" ? "(0)" : "nan") : "(" + (try calc(s)) + ")"
	339	case .list(var items):
	340	if !mode.keepEmpty { items = items.filter { !blank($0) } }
	341	if mode.lisp != .none { return items.map(lisp).joined(separator: " ") }
	342	return "[" + (try items.map { blank($0) ? empty : try calc($0) }).joined(separator: ",") + "]"
	343	}
	344	}
	345
	346	/// `org-table-time-string-to-seconds`.
	347	static func timeStringToSeconds(_ s: String) -> String {
	348	guard !s.isEmpty else { return s }
	349	func seconds(_ sign: Substring, _ parts: [Substring]) -> String {
	350	let total = parts.enumerated().reduce(0) { sum, part in
	351	sum + (Int(part.element) ?? 0) * [3600, 60, 1][part.offset]
	352	}
	353	return String(sign.isEmpty ? total : -total)
	354	}
	355	if let m = s.firstMatch(of: /(-?)([0-9]+):([0-9]+):([0-9]+)/) { return seconds(m.1, [m.2, m.3, m.4]) }
	356	if s.range(of: timestampBoth, options: .regularExpression) == nil, let m = s.firstMatch(of: /(-?)([0-9]+):([0-9]+)/) {
	357	return seconds(m.1, [m.2, m.3])
	358	}
	359	return numberText(s)
	360	}
	361
	362	enum DurationFormat { case hms, hhmm, hours }
	363
	364	/// `org-table-time-seconds-to-string`, with `org-table-duration-custom-format` `hours`
	365	/// and zero-padded hours.
	366	static func secondsToString(_ seconds: Sexp, _ format: DurationFormat) -> String {
	367	let value = (try? Elisp.number(seconds))?.double ?? 0
	368	let magnitude = abs(value)
	369	let result: String
	370	switch format {
	371	case .hours:
	372	result = String(format: "%.2f", magnitude / 3600)
	373	case .hms, .hhmm:
	374	let total = Int(magnitude.rounded(.down))
	375	let hms = String(format: "%02d:%02d:%02d", total / 3600, total / 60 % 60, total % 60)
	376	result = format == .hhmm ? String(hms.dropLast(3)) : hms
	377	}
	378	return value < 0 ? "-" + result : result
	379	}
	380
	381	/// `org-table-convert-refs-to-rc` for a remote reference: `B3` is `@3$2`.
	382	static func refsToRC(_ s: String) -> String {
	383	let regex = try! NSRegularExpression(pattern: "(?<![A-Za-z0-9_$@])([a-zA-Z]{1,2})([0-9]+)(?![A-Za-z0-9_])")
	384	var out = s
	385	while let m = regex.firstMatch(in: out, range: NSRange(location: 0, length: (out as NSString).length)) {
	386	let ns = out as NSString
	387	let column = ns.substring(with: m.range(at: 1)).uppercased().unicodeScalars.reduce(0) { $0 * 26 + Int($1.value) - 64 }
	388	out = ns.replacingCharacters(in: m.range, with: "@\(ns.substring(with: m.range(at: 2)))$\(column)")
	389	}
	390	return out
	391	}
	392
	393	/// `org-table-get-constant`: a parameter or named field, a `#+CONSTANTS` value, or the
	394	/// entry's property for `PROP_name`.
	395	func tableConstant(_ name: String, analysis: TableAnalysis) -> String {
	396	if let parameter = analysis.parameters.last(where: { $0.name == name }) { return parameter.value }
	397	for m in (settings.setupKeywords + string).matches(of: #/(?mi)^[ \t]#\+CONSTANTS:(.)$/#) {
	398	for pair in m.1.split(whereSeparator: \.isWhitespace) {
	399	let parts = pair.split(separator: "=", maxSplits: 1)
	400	if parts.count == 2, parts[0] == name { return String(parts[1]) }
	401	}
274	402	}
	403	if name.hasPrefix("PROP_"), let value = inheritedProperty(String(name.dropFirst(5)))?.value { return value }
	404	return "#UNDEFINED_NAME"
275	405	}
276	406
277		/// `org-table-eval-formula` with the equation given, at point.
278		func tableEvalFormula(_ formula: String, analysis: TableAnalysis) throws {
	407	/// `org-table-formula-substitute-names`: column names become `$N`; parameters, named
	408	/// fields and constants their values, in parentheses outside Lisp formulas.
	409	func substituteNames(_ formula: String, analysis: TableAnalysis) -> String {
	410	let parenthesize = !formula.hasPrefix("'")
	411	let duration = formula.range(of: ";.[Tt].$", options: .regularExpression) != nil
	412	var new = formula
	413	if !analysis.columnNames.isEmpty {
	414	let names = analysis.columnNames.map { NSRegularExpression.escapedPattern(for: $0.name) }.joined(separator: "\|")
	415	let regex = try! NSRegularExpression(pattern: "\\$(\(names))(?![[:alnum:]])")
	416	var start = 0
	417	while let m = regex.firstMatch(in: new, range: NSRange(location: start, length: (new as NSString).length - start)) {
	418	let ns = new as NSString
	419	let column = analysis.columnNames.first { $0.name == ns.substring(with: m.range(at: 1)) }!.column
	420	new = ns.replacingCharacters(in: m.range, with: "$\(column)")
	421	start = m.range.location + 1
	422	}
	423	}
	424	let regex = try! NSRegularExpression(pattern: "\\$([a-zA-Z][_a-zA-Z0-9])\|(\\bremote\$[^)]\$)")
	425	var start = 0
	426	while let m = regex.firstMatch(in: new, range: NSRange(location: start, length: (new as NSString).length - start)) {
	427	let ns = new as NSString
	428	if m.range(at: 2).location != NSNotFound {
	429	start = NSMaxRange(m.range(at: 2))
	430	continue
	431	}
	432	start = m.range.location + 1
	433	var value = tableConstant(ns.substring(with: m.range(at: 1)), analysis: analysis)
	434	if duration, value.contains(where: { !$0.isWhitespace }) { value = Self.timeStringToSeconds(value) }
	435	new = ns.replacingCharacters(in: m.range, with: parenthesize ? "(" + value + ")" : value)
	436	}
	437	return new
	438	}
	439
	440	/// `org-table-get-remote-range`: the table after `#+NAME: name` in this file.
	441	func remoteRange(_ name: String, _ form: String) throws -> TableRangeValue {
	442	let ns = string as NSString
	443	let pattern = "^[ \\t]#\\+(tbl)?name:[ \\t]" + NSRegularExpression.escapedPattern(for: name) + "[ \\t]*$"
	444	let keyword = try! NSRegularExpression(pattern: pattern, options: [.anchorsMatchLines, .caseInsensitive])
	445	guard let found = keyword.firstMatch(in: string, range: NSRange(location: 0, length: ns.length)) else {
	446	throw Calc.Unsupported("remote table \(name) by ID")
	447	}
	448	let after = min(ns.length, found.range.location + 1)
	449	let next = try! NSRegularExpression(pattern: "^(\\+ )\|^[ \\t]\\\|", options: .anchorsMatchLines)
	450	guard let m = next.firstMatch(in: string, range: NSRange(location: after, length: ns.length - after)),
	451	m.range(at: 1).location == NSNotFound else {
	452	throw UserError(message: "Cannot find a table at NAME or ID \(name)")
	453	}
	454	let remote = EmacsBuffer(string, point: m.range.location, settings: settings, options: options)
	455	let analysis = try remote.tableAnalyze()
	456	let resolved = remote.substituteNames(try Self.handleFirstLast(Self.refsToRC(form), analysis: analysis), analysis: analysis)
	457	let range = try! NSRegularExpression(pattern: Self.rangePattern)
	458	let rns = resolved as NSString
	459	if let r = range.firstMatch(in: resolved, range: NSRange(location: 0, length: rns.length)), r.range.length > 1 {
	460	return try remote.tableRange(rns.substring(with: r.range), thisline: 0, col: 1, analysis: analysis)
	461	}
	462	return .field(resolved)
	463	}
	464
	465	/// `org-table-eval-formula` with the equation given, at point. `substituted` when names
	466	/// and constants were already replaced, as `org-table-recalculate` does.
	467	func tableEvalFormula(_ formula: String, analysis: TableAnalysis, substituted: Bool = true) throws {
279	468	var formula = formula
280	469	var modes = Calc.Modes()
	470	var mode = ReferenceMode()
	471	var duration: DurationFormat?
	472	var literal = false
281	473	var fmt: String?
282	474	if let semicolon = formula.lastIndex(of: ";") {
283		var flags = String(formula[formula.index(after: semicolon)...])
	475	var flags = (analysis.parameters.last { $0.name == "%" }?.value ?? "") + formula[formula.index(after: semicolon)...]
284	476	formula = String(formula[..<semicolon])
285	477	let numeric = try! NSRegularExpression(pattern: "([pnfse])(-?[0-9]+)")
286	478	while let m = numeric.firstMatch(in: flags, range: NSRange(location: 0, length: (flags as NSString).length)) {
		@@ -299,27 +491,32 @@ extension EmacsBuffer {
299	491	while let m = letters.firstMatch(in: flags, range: NSRange(location: 0, length: (flags as NSString).length)) {
300	492	let ns = flags as NSString
301	493	switch ns.substring(with: m.range) {
	494	case "t": (duration, mode.numbers) = (.hours, true)
	495	case "T": (duration, mode.numbers) = (.hms, true)
	496	case "U": (duration, mode.numbers) = (.hhmm, true)
	497	case "N": mode.numbers = true
	498	case "L": literal = true
	499	case "E": mode.keepEmpty = true
302	500	case "D": modes.degrees = true
303	501	case "R": modes.degrees = false
304	502	default: throw Calc.Unsupported("format flag \(ns.substring(with: m.range))")
305	503	}
306	504	flags = ns.replacingCharacters(in: m.range, with: "")
307	505	}
308		if flags.contains(where: { !$0.isWhitespace }) {
309		guard flags.range(of: "^%[-+ #0][0-9](\\.[0-9]+)?[fgeE]$", options: .regularExpression) != nil else {
310		throw Calc.Unsupported("format \(flags)")
311		}
312		fmt = flags
313		}
	506	if flags.contains(where: { !$0.isWhitespace }) { fmt = flags }
314	507	}
315		if formula.hasPrefix("'(") { throw Calc.Unsupported("Lisp formula") }
316		formula = substituteConstants(formula)
317		if formula.range(of: "\\$[a-zA-Z_]", options: .regularExpression) != nil \|\| formula.contains("remote(")
318		\|\| formula.range(of: "[<\\[][0-9]{4}-", options: .regularExpression) != nil \|\| formula.contains("&") {
319		throw Calc.Unsupported("names, constants, remote references or dates")
	508	if !substituted { formula = try Self.handleFirstLast(substituteNames(formula, analysis: analysis), analysis: analysis) }
	509	var fields = Self.splitFields(substring(lineStart(point), lineEnd(point)).trimmingCharacters(in: .whitespaces), separator: " \\\| ")
	510	if duration != nil { fields = fields.map(Self.timeStringToSeconds) }
	511	if mode.numbers { fields = fields.map { $0.contains(where: { !$0.isWhitespace }) ? Self.numberText($0) : $0 } }
	512	if formula.count > 2, formula.hasPrefix("'(") { mode.lisp = literal ? .literal : .lisp }
	513	func reference(_ value: TableRangeValue) throws -> String {
	514	guard duration != nil else { return try Self.makeReference(value, mode) }
	515	switch value {
	516	case .field(let s): return try Self.makeReference(.field(Self.timeStringToSeconds(s)), mode)
	517	case .list(let items): return try Self.makeReference(.list(items.map(Self.timeStringToSeconds)), mode)
	518	}
320	519	}
321		let line = substring(lineStart(point), lineEnd(point)).trimmingCharacters(in: .whitespaces)
322		let fields = Self.splitFields(line, separator: " \\\| ")
323	520	let n0 = tableCurrentColumn()
324	521	let thisline = try saveExcursion { () -> Int in
325	522	let here = lineStart(point)
		@@ -334,10 +531,31 @@ extension EmacsBuffer {
334	531	var form = formula
335	532	form = form.replacingOccurrences(of: "@#", with: String(tableCurrentDataLine()))
336	533	form = form.replacingOccurrences(of: "$#", with: String(n0))
	534	// `org-table-remote-reference-indirection`: `remote($1, …)` names the table in a field.
	535	let indirect = try! NSRegularExpression(pattern: "\\bremote\$[ \\t]([@$][^ \\t,]+)[ \\t],[ \\t]*([^\\n)]+)\$")
	536	var start = 0
	537	while let m = indirect.firstMatch(in: form, range: NSRange(location: start, length: (form as NSString).length - start)) {
	538	let ns = form as NSString
	539	var eq = try Self.handleFirstLast(ns.substring(with: m.range(at: 1)), analysis: analysis)
	540	if eq.range(of: "^\\$[0-9]+$", options: .regularExpression) != nil { eq = "@0" + eq }
	541	guard case .field(let name) = try tableRange(eq, thisline: thisline, col: n0, analysis: analysis) else {
	542	throw Calc.Unsupported("remote table name from a range")
	543	}
	544	form = ns.replacingCharacters(in: m.range(at: 1), with: name)
	545	start = m.range(at: 1).location + (name as NSString).length
	546	}
	547	let remote = try! NSRegularExpression(pattern: "\\bremote\$[ \\t]([^,)]+)[ \\t],[ \\t]*([^\\n)]+)\$")
	548	while let m = remote.firstMatch(in: form, range: NSRange(location: 0, length: (form as NSString).length)) {
	549	let ns = form as NSString
	550	let name = ns.substring(with: m.range(at: 1)).trimmingCharacters(in: .whitespaces)
	551	let value = try remoteRange(name, ns.substring(with: m.range(at: 2)))
	552	form = ns.replacingCharacters(in: m.range, with: try reference(value))
	553	}
337	554	let range = try! NSRegularExpression(pattern: Self.rangePattern)
338	555	while let m = range.firstMatch(in: form, range: NSRange(location: 0, length: (form as NSString).length)), m.range.length > 1 {
339	556	let ns = form as NSString
340		let replacement = try Self.reference(try tableRange(ns.substring(with: m.range), thisline: thisline, col: n0, analysis: analysis))
	557	let replacement = try reference(try tableRange(ns.substring(with: m.range), thisline: thisline, col: n0, analysis: analysis))
	558	if replacement.contains(form) { throw UserError(message: "Spreadsheet error: invalid reference \"\(form)\"") }
341	559	form = ns.replacingCharacters(in: m.range, with: replacement)
342	560	}
343	561	let rowRange = try! NSRegularExpression(pattern: "\\$(([-+])?[0-9]+)\\.\\.\\$(([-+])?[0-9]+)")
		@@ -346,7 +564,7 @@ extension EmacsBuffer {
346	564	let a = Int(ns.substring(with: m.range(at: 1)))! + (m.range(at: 2).location != NSNotFound ? n0 : 0)
347	565	let b = Int(ns.substring(with: m.range(at: 3)))! + (m.range(at: 4).location != NSNotFound ? n0 : 0)
348	566	guard a >= 1, b <= fields.count, a - 1 <= b else { throw Calc.Unsupported("range outside row") }
349		form = ns.replacingCharacters(in: m.range, with: try Self.reference(.list(Array(fields[(a - 1)..<b]))))
	567	form = ns.replacingCharacters(in: m.range, with: try Self.makeReference(.list(Array(fields[(a - 1)..<b])), mode))
350	568	}
351	569	let single = try! NSRegularExpression(pattern: "\\$(([-+])?[0-9]+)")
352	570	while let m = single.firstMatch(in: form, range: NSRange(location: 0, length: (form as NSString).length)) {
		@@ -354,37 +572,100 @@ extension EmacsBuffer {
354	572	let n = Int(ns.substring(with: m.range(at: 1)))! + (m.range(at: 2).location != NSNotFound ? n0 : 0)
355	573	let index = (n == 0 ? n0 : max(n, 1)) - 1
356	574	guard index < fields.count else { throw UserError(message: "Invalid field specifier \"\(ns.substring(with: m.range))\"") }
357		form = ns.replacingCharacters(in: m.range, with: try Self.reference(.field(fields[index])))
	575	let replacement = try Self.makeReference(.field(fields[index]), mode)
	576	if replacement.contains(formula) { throw UserError(message: "Invalid field specifier \"\(ns.substring(with: m.range))\"") }
	577	form = ns.replacingCharacters(in: m.range, with: replacement)
	578	}
	579
	580	var result: String
	581	if mode.lisp != .none {
	582	result = try evalLisp(form, duration: duration)
	583	} else {
	584	form = form.replacingOccurrences(of: "\\[([0-9]{4}-[0-9]{2}-[0-9]{2}(?: [^\\]>\\n]*)?)\\]", with: "<$1>", options: .regularExpression)
	585	form = Self.normalizeTimestamps(form)
	586	if duration != nil, form.range(of: "^[0-9]+:[0-9]+(:[0-9]+)?$", options: .regularExpression) != nil {
	587	result = form
	588	} else {
	589	do {
	590	result = try Calc.evaluate(form, modes: modes, numeric: !mode.keepEmpty && mode.numbers)
	591	} catch is Calc.Failure {
	592	(result, fmt) = ("#ERROR", nil)
	593	}
	594	}
	595	if let duration, !result.isEmpty, result != "#ERROR" {
	596	let seconds = result.range(of: "^[0-9]+:[0-9]+(:[0-9]+)?$", options: .regularExpression) != nil ? Self.timeStringToSeconds(result) : result
	597	result = Self.secondsToString(Elisp.stringToNumber(seconds), duration)
	598	}
358	599	}
359		var result = try Calc.evaluate(form, modes: modes)
360	600	if let fmt {
361		result = String(format: fmt, Self.stringToNumber(result))
	601	do {
	602	result = try Elisp.format([.string(fmt), Elisp.stringToNumber(result)])
	603	} catch let error as Elisp.Signal {
	604	throw UserError(message: error.message)
	605	}
	606	} else {
	607	result = result.replacingOccurrences(of: "<([0-9]{4}-[0-9]{2}-[0-9]{2}(?: [^\\]>\\n]*)?)>", with: "[$1]", options: .regularExpression)
362	608	}
363	609	tableSetField(result)
364	610	}
365	611
366		/// `org-table-formula-substitute-names` for constants: `$name` from `#+CONSTANTS`, or
367		/// `$PROP_name` from the entry's property, in parentheses; unknown names become
368		/// `#UNDEFINED_NAME`.
369		func substituteConstants(_ formula: String) -> String {
370		guard formula.range(of: "\\$[a-zA-Z]", options: .regularExpression) != nil else { return formula }
371		var constants: [String: String] = [:]
372		for m in (settings.setupKeywords + string).matches(of: #/(?mi)^[ \t]#\+CONSTANTS:(.)$/#) {
373		for pair in m.1.split(whereSeparator: \.isWhitespace) {
374		let parts = pair.split(separator: "=", maxSplits: 1)
375		if parts.count == 2, constants[String(parts[0])] == nil { constants[String(parts[0])] = String(parts[1]) }
	612	/// `(eval (eval (read form)))` for a Lisp formula; an error is `#ERROR`.
	613	func evalLisp(_ form: String, duration: DurationFormat?) throws -> String {
	614	let lisp = Elisp()
	615	Self.defineLookups(lisp)
	616	let value: Sexp
	617	do {
	618	value = try lisp.eval(try lisp.eval(try LispReader.readFirst(form).sexp))
	619	} catch let unsupported as Elisp.Unsupported {
	620	throw Calc.Unsupported("Lisp \(unsupported.what)")
	621	} catch {
	622	return "#ERROR"
	623	}
	624	var result = Elisp.printed(value)
	625	if let duration { result = Self.secondsToString(Elisp.stringToNumber(result), duration) }
	626	return result
	627	}
	628
	629	/// `org-lookup-first`, `org-lookup-last` and `org-lookup-all`.
	630	static func defineLookups(_ lisp: Elisp) {
	631	func matches(_ lisp: Elisp, _ args: [Sexp]) throws -> [Sexp] {
	632	try Elisp.arity(args, 3...4, "org-lookup")
	633	let keys = try Elisp.elements(args[1])
	634	let values = Elisp.isNil(args[2]) ? keys : try Elisp.elements(args[2])
	635	let predicate = args.count > 3 && !Elisp.isNil(args[3]) ? args[3] : .symbol("equal")
	636	var found: [Sexp] = []
	637	for (i, key) in keys.enumerated() where !Elisp.isNil(try lisp.call(predicate, [args[0], key])) {
	638	found.append(i < values.count ? values[i] : .nil)
376	639	}
	640	return found
377	641	}
378		let regex = try! NSRegularExpression(pattern: "\\$([a-zA-Z][_a-zA-Z0-9]*)")
379		var out = formula
380		while let m = regex.firstMatch(in: out, range: NSRange(location: 0, length: (out as NSString).length)) {
	642	lisp.define("org-lookup-first") { lisp, args in try matches(lisp, args).first ?? .nil }
	643	lisp.define("org-lookup-last") { lisp, args in try matches(lisp, args).last ?? .nil }
	644	lisp.define("org-lookup-all") { lisp, args in
	645	let found = try matches(lisp, args)
	646	return found.isEmpty ? .nil : .list(found)
	647	}
	648	}
	649
	650	/// Timestamps in a formula as Calc reads them: `<YYYY-MM-DD Www>`, with ` HH:MM` when
	651	/// the stamp has a time, as org formats them for Calc.
	652	static func normalizeTimestamps(_ form: String) -> String {
	653	let regex = try! NSRegularExpression(pattern: "<([0-9]{4}-[0-9]{2}-[0-9]{2}(?: [^\\]>\\n]*)?)>")
	654	var out = form
	655	var start = 0
	656	while let m = regex.firstMatch(in: out, range: NSRange(location: start, length: (out as NSString).length - start)) {
381	657	let ns = out as NSString
382		let name = ns.substring(with: m.range(at: 1))
383		var value = constants[name]
384		if value == nil, name.hasPrefix("PROP_") {
385		value = inheritedProperty(String(name.dropFirst(5)))?.value
	658	let stamp = ns.substring(with: m.range(at: 1))
	659	let parts = stamp.firstMatch(of: /^([0-9]{4})-([0-9]{2})-([0-9]{2})/)!
	660	let day = Days.absolute(year: Int(parts.1)!, month: Int(parts.2)!, day: Int(parts.3)!)
	661	let date = Days.date(day)
	662	var text = String(format: "<%04d-%02d-%02d %@", date.year, date.month, date.day, Calc.weekdays[Days.weekday(day)])
	663	if let time = stamp.firstMatch(of: /([0-9]{1,2}):([0-9]{2})/) {
	664	text += String(format: " %02d:%02d", Int(time.1)!, Int(time.2)!)
386	665	}
387		out = ns.replacingCharacters(in: m.range, with: "(" + (value ?? "#UNDEFINED_NAME") + ")")
	666	text += ">"
	667	out = ns.replacingCharacters(in: m.range, with: text)
	668	start = m.range.location + (text as NSString).length
388	669	}
389	670	return out
390	671	}
		@@ -429,7 +710,7 @@ extension EmacsBuffer {
429	710	var columnEquations: [(Int, String)] = []
430	711	var fieldEquations: [(String, String)] = []
431	712	for (oldLHS, rawRHS) in stored {
432		let rhs = try Self.handleFirstLast(rawRHS, analysis: analysis)
	713	let rhs = substituteNames(try Self.handleFirstLast(rawRHS, analysis: analysis), analysis: analysis)
433	714	if oldLHS.range(of: "^@-?I+", options: .regularExpression) != nil { throw UserError(message: "Can't assign to hline relative reference") }
434	715	let lhs = try Self.handleFirstLast(oldLHS, analysis: analysis)
435	716	if lhs.range(of: "^\\$[0-9]+$", options: .regularExpression) != nil {
		@@ -443,8 +724,13 @@ extension EmacsBuffer {
443	724	for (lhs, rhs) in fieldEquations {
444	725	if let m = lhs.firstMatch(of: /^@([0-9]+)\$([0-9]+)$/) {
445	726	fields.append((Int(m.1)!, Int(m.2)!, rhs))
446		} else if lhs.range(of: "^@[-+0-9]+\\$-?[0-9]+$", options: .regularExpression) != nil \|\| lhs.range(of: "^[a-zA-Z]", options: .regularExpression) != nil {
447		throw Calc.Unsupported("relative or named field formula")
	727	} else if lhs.range(of: "^[a-zA-Z][_a-zA-Z0-9]*$", options: .regularExpression) != nil {
	728	guard let location = analysis.namedFields.last(where: { $0.name == lhs }), let row = Self.lineToDline(location.line, analysis) else {
	729	throw UserError(message: "Unknown field: \(lhs)")
	730	}
	731	fields.append((row, location.column, rhs))
	732	} else if lhs.range(of: "^@[-+0-9]+\\$-?[0-9]+$", options: .regularExpression) != nil {
	733	throw Calc.Unsupported("relative field formula")
448	734	} else if let m = lhs.firstMatch(of: /^@([0-9]+)$/) {
449	735	for c in 1...analysis.ncol { fields.append((Int(m.1)!, c, rhs)) }
450	736	} else {
		@@ -463,7 +749,11 @@ extension EmacsBuffer {
463	749	let endMarker = marker(end)
464	750	defer { release(endMarker) }
465	751	var beg: Int
466		if all {
	752	var lineRegexp = "^[ \\t]*\\\|[^-]"
	753	if all, analysis.marked {
	754	beg = analysis.begin
	755	lineRegexp = "^[ \\t]\\\| [#] (\\\|\|$)"
	756	} else if all {
467	757	beg = analysis.begin
468	758	point = beg
469	759	if searchForward("^[ \\t]*\\\|[^-]", bound: end, caseInsensitive: false) != nil,
		@@ -493,7 +783,7 @@ extension EmacsBuffer {
493	783	point = beg
494	784	let rowMarker = marker(beg)
495	785	defer { release(rowMarker) }
496		while let match = searchForward("^[ \\t]*\\\|[^-]", bound: endMarker.position, caseInsensitive: false) {
	786	while let match = searchForward(lineRegexp, bound: endMarker.position, caseInsensitive: false) {
497	787	_ = match
498	788	let rowStart = lineStart(point)
499	789	rowMarker.position = rowStart
		@@ -713,7 +1003,7 @@ extension EmacsBuffer {
713	1003	let analysis = try tableAnalyze()
714	1004	let formula = try tableGetFormula(equation, named: named, analysis: analysis)
715	1005	do {
716		try tableEvalFormula(try Self.handleFirstLast(formula, analysis: analysis), analysis: analysis)
	1006	try tableEvalFormula(formula, analysis: analysis, substituted: false)
717	1007	} catch let error as Calc.Unsupported {
718	1008	throw UserError(message: "The formula was stored; recalculating it needs Emacs: " + error.reason)
719	1009	}

Sources/OrgstarMobile/MobileEditor.swift +2

		@@ -172,6 +172,8 @@ final class MobileEditor: NSObject, DocumentBuffer {
172	172	onTangle?(scope)
173	173	case .external(.agenda(let start, let count)) where onAgenda != nil:
174	174	onAgenda?(start, count)
	175	case .external(.emacsTable(_, _, _, let reason, _)):
	176	onMessage?("This table needs Emacs, which runs on the Mac: \(reason).")
175	177	case .external:
176	178	onMessage?("\(command.title) needs Emacs, which runs on the Mac.")
177	179	}

Tests/OrgCoreTests/CalcTests.swift +10 −1

		@@ -53,6 +53,15 @@ struct CalcTests {
53	53	"exp(100)", "ln(0.5)", "sqrt(1e-10)", "2.0^2", "0^0", "1-1.0", "0.0", "-0.0", "1.0-1.0", "(-1.5)*(-2)",
54	54	"(12)+(3.5)(2)", "vsum([12,3.5,7])/3", "(1.5)/(0.5)", "(100)(1.07)^(5)", "(19.99)(3)", "(0.07)(19.99)",
55	55	"vmean([10,20,25])", "(5)-(7.25)", "(-0.001)(1000)", "1/(3)", "(2)/(3)(3)",
	56	// Dates, nan, comparisons and logic, and the rest of the functions tables use.
	57	"<2026-10-05 Mon>+3", "<2026-10-12 Mon>-<2026-10-05 Mon>", "<2026-10-05 Mon 10:00>-<2026-10-05 Mon 08:30>",
	58	"<2026-10-05 Mon 08:30>+0.5", "<2026-10-05 Mon 10:00>+1", "<2026-10-05 Mon 08:30>-<2026-10-04 Sun>", "(<2026-12-31 Thu>)+(1)",
	59	"<2026-03-01 Sun>-30", "1+<2026-10-05 Mon>", "<2026-10-05 Mon 23:59>-<2026-10-05 Mon 00:01>", "<2026-10-05 Mon 12:00>-0.25",
	60	"vmax([<2026-10-05 Mon>,<2026-10-07 Wed>])", "<2026-10-05 Mon> < <2026-10-06 Tue>", "nan", "nan+1", "vsum([1,nan])", "2*nan",
	61	"3<4", "3>4", "3<=3", "4>=5", "2==2", "2!=2", "1 && 0", "1 \|\| 0", "!0", "!2", "if(3>4, 1, 2)", "if($1, 7, 8)".replacingOccurrences(of: "$1", with: "0"),
	62	"if(1.5, 2.5, 3)", "7%3", "-7%3", "7%-3", "7.5%2", "7\\2", "-7\\2", "7.5\\2", "mod(10,4)", "idiv(-9,4)", "fact(5)", "fact(0)",
	63	"vsdev([1,2,3,4])", "vvar([1,2,3])", "vpvar([1,2,3,4])", "vpsdev([2,4,4,4,5,5,7,9])", "vsdev([1.5,2.5,4])",
	64	"2+3<4*2", "1<2 && 3<4", "!(1<2)", "(1<2)+(2<3)",
56	65	]
57	66
58	67	@Test(.enabled(if: ProcessInfo.processInfo.environment["ORGSTAR_SKIP_ORACLE"] == nil))
		@@ -98,7 +107,7 @@ struct CalcTests {
98	107	}
99	108
100	109	@Test func unsupported() {
101		for e in ["abc*2", "1/0", "vmean([])", "pi", "5%", "(-8)^(1/3)", "2 3"] {
	110	for e in ["abc*2", "1/0", "vmean([])", "pi", "5%", "(-8)^(1/3)", "2 3", "vvar([5])", "1<2<3"] {
102	111	#expect(throws: Calc.Unsupported.self, "\(e)") { try Calc.evaluate(e) }
103	112	}
104	113	}

Tests/OrgCoreTests/TableFormulaTests.swift +39 −1

		@@ -28,6 +28,33 @@ struct TableFormulaTests {
28	28	"* Rates\n:PROPERTIES:\n:Rate: 3\n:END:\n\| h \| pay \|\n\|---+-----\|\n\| 2 \| \|\n#+TBLFM: $2=$1*$PROP_Rate\n",
29	29	]
30	30
	31	/// Lisp formulas, names, parameters, marked rows, remote tables, durations, dates and
	32	/// the rest that once needed Emacs: all run natively.
	33	static let native = [
	34	"\| a \| b \|\n\|---+---\|\n\| hello \| \|\n\| x \"q\" \| \|\n\| \| \|\n#+TBLFM: $2='(concat $1 \"!\")\n",
	35	"\| a \| b \|\n\|---+---\|\n\| 1 \| \|\n\| 2.5 \| \|\n\| x \| \|\n#+TBLFM: $2='(* 2 $1);N\n",
	36	"\| a \| b \| c \|\n\|---+---+---\|\n\| 1 \| 2 \| \|\n\| 3 \| 4 \| \|\n#+TBLFM: $3='(+ $1 $2);L\n",
	37	"\| a \|\n\|---\|\n\| 1 \|\n\| 2 \|\n\|---\|\n\| \|\n#+TBLFM: @>$1='(apply '+ '(@I..@II));N\n",
	38	"\| a \| b \|\n\|---+---\|\n\| 1 \| \|\n#+TBLFM: $2='(car 1)\n",
	39	"\| a \| b \| c \|\n\|---+---+---\|\n\| 3.14159 \| \| \|\n\| 2 \| \| \|\n#+TBLFM: $2='(format \"%05.1f\" $1);N::$3='(+ $1 1);N%.2f\n",
	40	"\| a \| b \|\n\|---+---\|\n\| 5 \| \|\n\| 12 \| \|\n#+TBLFM: $2='(if (> $1 10) \"big\" \"small\");N\n",
	41	"\| ! \| qty \| price \| total \|\n\|---+-----+-------+-------\|\n\| \| 2 \| 3 \| \|\n\| \| 4 \| 0.5 \| \|\n#+TBLFM: $4=$qty*$price\n",
	42	"\| \| x \| y \|\n\|---+---+---\|\n\| # \| 2 \| \|\n\| \| 3 \| \|\n\| * \| 4 \| \|\n\| $ \| k=10 \| \|\n#+TBLFM: $3=$2*$k\n",
	43	"\| \| a \| b \|\n\|---+----+----\|\n\| \| 1 \| 2 \|\n\| ^ \| aa \| bb \|\n\| _ \| \| cc \|\n\| \| \| \|\n#+TBLFM: $cc=$aa+$bb::$2=7\n",
	44	"\| \| a \| b \|\n\|---+----+----\|\n\| \| 1 \| 2 \|\n\| _ \| \| dd \|\n#+TBLFM: $dd=1\n",
	45	"\| start \| end \| sum \| diff \| hours \|\n\|-------+-----+-----+------+-------\|\n\| 1:30 \| 0:45 \| \| \| \|\n\| 10:00:30 \| 2:15:10 \| \| \| \|\n\|-------+-----+-----+------+-------\|\n\| \| \| \| \| \|\n#+TBLFM: $3=$1+$2;T::$4=$1-$2;U::$5=$1*2;t::@>$1=vsum(@I..@II);T\n",
	46	"\| d1 \| d2 \| days \| later \|\n\|----+----+------+-------\|\n\| <2026-10-05 Mon> \| <2026-10-12 Mon> \| \| \|\n\| [2026-01-31 Sat] \| [2026-03-01 Sun] \| \| \|\n\| <2026-10-05 Mon 08:30> \| <2026-10-05 Mon 10:00> \| \| \|\n#+TBLFM: $3=$2-$1::$4=$1+7\n",
	47	"\| d \| until \|\n\|---+-------\|\n\| <2026-10-05 Mon> \| \|\n#+TBLFM: $2=<2026-12-25 Fri>-$1\n",
	48	"\| a \| b \| c \| d \|\n\|---+---+---+---\|\n\| 1 \| \| \| \|\n\| 2 \| 3 \| \| \|\n#+TBLFM: $3=$1+$2;E::$4=vcount($1..$2);E\n",
	49	"\| a \| b \| c \|\n\|---+---+---\|\n\| 5 \| 3 \| \|\n\| 2 \| 9 \| \|\n#+TBLFM: $3=if($1>$2, $1, $2)\n",
	50	"\| a \| b \| c \|\n\|---+---+---\|\n\| 7 \| 3 \| \|\n\| -7 \| 2 \| \|\n#+TBLFM: $3=$1%$2+$1\\$2*100\n",
	51	"#+NAME: rates\n\| item \| rate \|\n\|------+------\|\n\| a \| 2 \|\n\| b \| 3 \|\n\n\| x \| y \| z \| w \|\n\|---+---+---+---\|\n\| 4 \| \| \| \|\n#+TBLFM: $2=$1*remote(rates,@2$2)::$3=remote(rates, B3)::$4=vsum(remote(rates,@2$2..@>$2))\n",
	52	"#+NAME: prices\n\| fruit \| price \|\n\|-------+-------\|\n\| apple \| 1.5 \|\n\| pear \| 2 \|\n\n\| item \| cost \|\n\|------+------\|\n\| pear \| \|\n\| plum \| \|\n#+TBLFM: $2='(org-lookup-first $1 '(remote(prices,@2$1..@>$1)) '(remote(prices,@2$2..@>$2)))\n",
	53	"#+CONSTANTS: c=3\n\| a \| b \| c \|\n\|---+---+---\|\n\| 2 \| \| \|\n#+TBLFM: $2='(* $c $1);N::$3=$1*$c\n",
	54	"\| \| a \| b \|\n\|---+---+---\|\n\| \| 2 \| \|\n\| \| 3 \| \|\n\| $ \| %=%.2f \| \|\n#+TBLFM: $3=$2/3;\n",
	55	"\| a \| b \|\n\|---+---\|\n\| 4 \| \|\n\| 9 \| \|\n#+TBLFM: $2=vsdev(@I$1..@II$1)+fact(3)\n",
	56	]
	57
31	58	static func carets(_ text: String) -> [Int] {
32	59	let ns = text as NSString
33	60	var result: [Int] = []
		@@ -47,9 +74,18 @@ struct TableFormulaTests {
47	74
48	75	@Test(.enabled(if: ProcessInfo.processInfo.environment["ORGSTAR_SKIP_ORACLE"] == nil))
49	76	func matchesEmacs() throws {
	77	try compare(Self.tables, fallbacksAllowed: true)
	78	}
	79
	80	@Test(.enabled(if: ProcessInfo.processInfo.environment["ORGSTAR_SKIP_ORACLE"] == nil))
	81	func extendedFormulasMatchEmacsNatively() throws {
	82	try compare(Self.native, fallbacksAllowed: false)
	83	}
	84
	85	func compare(_ tables: [String], fallbacksAllowed: Bool) throws {
50	86	var cases: [EmacsOracle.Case] = []
51	87	var ours: [(text: String, caret: Int, failure: String?)] = []
52		for text in Self.tables {
	88	for text in tables {
53	89	for caret in Self.carets(text) {
54	90	let onTblfm = (text as NSString).substring(with: (text as NSString).lineRange(for: NSRange(location: caret, length: 0))).uppercased().contains("#+TBLFM")
55	91	let commands: [(any OrgCommand, String)] = onTblfm
		@@ -66,6 +102,8 @@ struct TableFormulaTests {
66	102	for (i, (mine, theirs)) in zip(ours, emacs).enumerated() {
67	103	if let failure = mine.failure, failure.hasPrefix("external:") {
68	104	fallbacks += 1
	105	// Calc keeps text as symbols, which goes to Emacs.
	106	#expect(fallbacksAllowed \|\| failure.contains("non-numeric field"), "\(failure) in\n\(cases[i].text)")
69	107	// Emacs gives symbolic results for text and division by zero.
70	108	#expect(failure.contains("non-numeric field") \|\| failure.contains("division by zero"), "\(failure)")
71	109	continue