Commit `46d6a046f5`

46d6a046f519e5ab5a9338ff643341bd53e7788f

parent: 5bb13b8565

Verified · cmc

cmc <hello@cleberg.net> · 2026-10-07 07:29 UTC

Run Emacs Lisp blocks on iOS

Emacs Lisp blocks run in the Lisp interpreter on iOS, which writes
what the Emacs script would print, so results are inserted the same
way; a Lisp error fails the run as in Emacs. The interpreter gains
princ, prin1, print, terpri, message, prin1-to-string and
with-output-to-string. Other languages, and Lisp the interpreter
doesn't have, say they need the Mac. Runs are confirmed as on the
Mac.

The command palette now runs the chosen command once it has closed,
not after a fixed delay, which crashed when the command's prompt
arrived while the palette and its keyboard were still going.

Layout: unified · split

Sources/OrgApp/DocumentSession.swift +17 −6

     /// Runs a src block and writes its result under it, unless the block changed while it
     /// ran. Returns a message for the echo area.
     public func runBabel(_ job: BabelJob) async -> String {
-        #if os(macOS)
         guard let entry = current else { return "No file is open." }
         let directory = URL(fileURLWithPath: entry.path).deletingLastPathComponent()
+        /// A program on the Mac; on iOS, Emacs Lisp in `Elisp`, and nothing else.
+        func run(_ job: BabelJob) async throws -> BabelOutput {
+            #if os(macOS)
+            return try await BabelRunner.run(job, fileDirectory: directory)
+            #else
+            guard let output = try Babel.evaluateNatively(job) else {
+                throw Babel.Failure.message(job.lispForm == nil
+                    ? "\(job.language) blocks need the Mac to run."
+                    : "This block uses Emacs Lisp that runs only in Emacs, on the Mac.")
+            }
+            return output
+            #endif
+        }
         do {
             // Blocks the `:var`s refer to run first, one at a time.
             var job = job
             while let need = job.needs.first {
-                let output = try await BabelRunner.run(need.job, fileDirectory: directory)
+                let output = try await run(need.job)
                 guard entries.contains(where: { $0 === entry }) else { return "The file was closed before the block finished." }
                 let document = entry.buffer.document
                 switch Babel.resume(job, need: need, output: output, text: document.text, tree: document.tree) {
                 case .success(let next): job = next
                 }
             }
-            let output = try await BabelRunner.run(job, fileDirectory: directory)
+            let output = try await run(job)
             guard entries.contains(where: { $0 === entry }) else { return "The file was closed before the block finished." }
             if let file = Babel.fileResult(job, output: output) {
                 let runDirectory = job.directory.map { URL(fileURLWithPath: $0, relativeTo: directory).standardizedFileURL } ?? directory
             }
         } catch is CancellationError {
             return "Code block canceled."
+        } catch Babel.Failure.message(let message) {
+            return message
         } catch {
             return "\(error)"
         }
-        #else
-        return "Source blocks don't run on iOS."
-        #endif
     }
     /// The block running now, to cancel.

Sources/OrgCore/Compute/Babel.swift +46 −2

	@@ -36,6 +36,8 @@ public struct BabelJob: Sendable, Equatable {
36	var resolved: [String: Babel.VarValue] = [:]	36	var resolved: [String: Babel.VarValue] = [:]
37	var caret = 0	37	var caret = 0
38	var options = Babel.Options()	38	var options = Babel.Options()
		39	/// An Emacs Lisp block's form, for `Babel.evaluateNatively`.
		40	public internal(set) var lispForm: String?
39		41
40	public struct Need: Sendable, Equatable {	42	public struct Need: Sendable, Equatable {
41	/// The `:var` value, `name` or `name(args)`.	43	/// The `:var` value, `name` or `name(args)`.
	@@ -367,10 +369,12 @@ public enum Babel {
367	let bindings = vars.map { "(\($0.0) '\(lispLiteral($0.1)))" }	369	let bindings = vars.map { "(\($0.0) '\(lispLiteral($0.1)))" }
368	let expanded = bindings.isEmpty ? body + "\n" : "(let (\(bindings.joined(separator: "\n ")))\n\(body)\n)"	370	let expanded = bindings.isEmpty ? body + "\n" : "(let (\(bindings.joined(separator: "\n ")))\n\(body)\n)"
369	let form = output ? "(with-output-to-string \(expanded))" : "(progn \(expanded)\n)"	371	let form = output ? "(with-output-to-string \(expanded))" : "(progn \(expanded)\n)"
370	return .success(BabelJob(	372	var job = BabelJob(
371	language: language, runner: .emacs, input: emacsScript(form: form, params: params.results),	373	language: language, runner: .emacs, input: emacsScript(form: form, params: params.results),
372	directory: dir, block: location, blockText: blockText, alwaysAsk: alwaysAsk, finish: finishBase(.emacsLisp)	374	directory: dir, block: location, blockText: blockText, alwaysAsk: alwaysAsk, finish: finishBase(.emacsLisp)
373	))	375	)
		376	job.lispForm = form
		377	return .success(job)
374	}	378	}
375	if ["dot", "plantuml", "mermaid"].contains(language) {	379	if ["dot", "plantuml", "mermaid"].contains(language) {
376	// ob-dot, ob-plantuml and ob-mermaid: the program draws into `:file`.	380	// ob-dot, ob-plantuml and ob-mermaid: the program draws into `:file`.
	@@ -939,6 +943,46 @@ public enum Babel {
939	"""	943	"""
940	}	944	}
941		945
		946	/// An Emacs Lisp job run by `Elisp` instead of Emacs: the output `emacsScript` would print.
		947	/// A Lisp error fails the run, as it does in Emacs; nil when the block uses what `Elisp`
		948	/// doesn't have.
		949	public static func evaluateNatively(_ job: BabelJob) throws(Failure) -> BabelOutput? {
		950	guard let form = job.lispForm, let sexp = try? LispReader.readFirst(form).sexp else { return nil }
		951	let lisp = Elisp()
		952	let result: Sexp
		953	do {
		954	result = try lisp.eval(sexp)
		955	} catch is Elisp.Unsupported {
		956	return nil
		957	} catch {
		958	throw .message("\(error)")
		959	}
		960	func cell(_ c: Sexp) -> String { Elisp.printed(c) }
		961	func isProper(_ v: Sexp) -> Bool {
		962	if case .list = v { return true }
		963	return Elisp.isNil(v)
		964	}
		965	func isAtom(_ v: Sexp) -> Bool {
		966	switch v {
		967	case .list(let items): items.isEmpty
		968	case .dotted: false
		969	default: true
		970	}
		971	}
		972	var rows: [Any] = []
		973	if case .list(let items) = result, items.allSatisfy({ isAtom($0) \|\| isProper($0) }) {
		974	if items.allSatisfy({ $0 == .symbol("hline") \|\| isProper($0) }) {
		975	rows = items.map { $0 == .symbol("hline") ? "hline" as Any : ((try? Elisp.elements($0)) ?? []).map(cell) as Any }
		976	} else {
		977	rows = [items.map(cell)]
		978	}
		979	}
		980	var object: [String: Any] = ["s": Elisp.printed(result), "S": Elisp.printed(result, escape: true), "string": result.string != nil]
		981	object["rows"] = rows.isEmpty ? NSNull() : rows
		982	guard let data = try? JSONSerialization.data(withJSONObject: object), let json = String(data: data, encoding: .utf8) else { return nil }
		983	return BabelOutput(stdout: lisp.standardOutput + json, stderr: lisp.messages)
		984	}
		985
942	// MARK: - Finishing	986	// MARK: - Finishing
943		987
944	/// What the run produced, as Babel holds it before inserting.	988	/// What the run produced, as Babel holds it before inserting.

Sources/OrgCore/Config/Elisp.swift +41 −1

	@@ -20,6 +20,13 @@ public final class Elisp {
20	private var functions: [String: Builtin] = [:]	20	private var functions: [String: Builtin] = [:]
21	private var steps = 0	21	private var steps = 0
22	static let stepLimit = 1_000_000	22	static let stepLimit = 1_000_000
		23	/// What `princ` and the other printers wrote: the innermost `with-output-to-string`, or
		24	/// standard output.
		25	private var outputs: [String] = [""]
		26	/// What went to standard output.
		27	public var standardOutput: String { outputs[0] }
		28	/// What `message` wrote.
		29	public private(set) var messages = ""
23		30
24	public init() {	31	public init() {
25	Self.core(self)	32	Self.core(self)
	@@ -135,7 +142,7 @@ public final class Elisp {
135	/// `prin1-to-string` with `princ` for strings when `escape` is false.	142	/// `prin1-to-string` with `princ` for strings when `escape` is false.
136	public static func printed(_ v: Sexp, escape: Bool = false) -> String {	143	public static func printed(_ v: Sexp, escape: Bool = false) -> String {
137	switch v {	144	switch v {
138	case .string(let s): return escape ? v.description : s	145	case .string(let s): return escape ? "\"" + s.replacingOccurrences(of: "\\", with: "\\\\").replacingOccurrences(of: "\"", with: "\\\"") + "\"" : s
139	case .float(let d): return floatText(d)	146	case .float(let d): return floatText(d)
140	case .character(let c): return String(c)	147	case .character(let c): return String(c)
141	case .list(let items): return "(" + items.map { printed($0, escape: true) }.joined(separator: " ") + ")"	148	case .list(let items): return "(" + items.map { printed($0, escape: true) }.joined(separator: " ") + ")"
	@@ -290,6 +297,15 @@ public final class Elisp {
290	return try eval(spec[2])	297	return try eval(spec[2])
291	}	298	}
292	return .nil	299	return .nil
		300	case "with-output-to-string":
		301	outputs.append("")
		302	do {
		303	_ = try progn(args)
		304	} catch {
		305	outputs.removeLast()
		306	throw error
		307	}
		308	return .string(outputs.removeLast())
293	case "ignore-errors":	309	case "ignore-errors":
294	do { return try progn(args) } catch is Signal { return .nil }	310	do { return try progn(args) } catch is Signal { return .nil }
295	case "condition-case":	311	case "condition-case":
	@@ -623,6 +639,30 @@ public final class Elisp {
623	throw Signal(message: args.isEmpty ? "" : try format(args))	639	throw Signal(message: args.isEmpty ? "" : try format(args))
624	}	640	}
625		641
		642	// Printing.
		643	for (name, escape) in [("princ", false), ("prin1", true), ("print", true)] {
		644	lisp.define(name) { lisp, args in
		645	try arity(args, 1...2, name)
		646	let text = printed(args[0], escape: escape)
		647	lisp.outputs[lisp.outputs.count - 1] += name == "print" ? "\n" + text + "\n" : text
		648	return args[0]
		649	}
		650	}
		651	lisp.define("terpri") { lisp, _ in
		652	lisp.outputs[lisp.outputs.count - 1] += "\n"
		653	return t
		654	}
		655	lisp.define("message") { lisp, args in
		656	guard !args.isEmpty, !isNil(args[0]) else { return .nil }
		657	let text = try format(args)
		658	lisp.messages += text + "\n"
		659	return .string(text)
		660	}
		661	lisp.define("prin1-to-string") { _, args in
		662	try arity(args, 1...2, "prin1-to-string")
		663	return .string(printed(args[0], escape: args.count < 2 \|\| isNil(args[1])))
		664	}
		665
626	// Strings.	666	// Strings.
627	lisp.define("concat") { _, args in .string(try args.map(printedString).joined()) }	667	lisp.define("concat") { _, args in .string(try args.map(printedString).joined()) }
628	lisp.define("format") { _, args in .string(try format(args)) }	668	lisp.define("format") { _, args in .string(try format(args)) }

Sources/OrgstarMobile/EditorScreen.swift +34 −4

     @State private var prompt: PromptRequest?
     @State private var message: String?
     @State private var sheet: Sheet?
+    @State private var trust = TrustStore()
+    /// The command chosen in the palette, run once the palette is gone.
+    @State private var chosen: String?
     @Environment(ClockModel.self) private var clock
     @Environment(MobileModel.self) private var model
     @Environment(\.openURL) private var openURL
                 request.reply(answer)
             }
         }
-        .sheet(item: $sheet) { sheet in
+        .sheet(item: $sheet, onDismiss: {
+            // After the sheet has gone, so a command's own prompt can show.
+            if let id = chosen {
+                chosen = nil
+                editor?.run(id)
+            }
+        }) { sheet in
             switch sheet {
-            case .palette: if let editor { CommandPalette(editor: editor) }
+            case .palette: if let editor { CommandPalette(editor: editor) { chosen = $0 } }
             case .conflict: ConflictSheet(session: session)
             case .syncCopies: SyncConflictSheet(session: session) { message = $0 }
             case .recovery: RecoverySheet(session: session) { message = $0 }
         }
     }
+    /// Runs a block once it's trusted, asking as `org-confirm-babel-evaluate` does.
+    private func run(_ job: BabelJob) {
+        let go = {
+            message = "Running \(job.language) block…"
+            session.startBabel(job) { message = $0 }
+        }
+        if !job.alwaysAsk, trust.isTrusted(path: path, content: job.blockText) { return go() }
+        let choices = job.alwaysAsk ? ["yes", "no"] : ["yes", "no", "always"]
+        prompt = PromptRequest(prompt: Prompt(key: "confirm", message: "Run this \(job.language) block?", choices: choices)) { answer in
+            switch answer {
+            case "always":
+                trust.trust(path: path, content: job.blockText)
+                go()
+            case "yes": go()
+            default: message = "Not run"
+            }
+        }
+    }
     private func start() {
         if session.path != path { session.open(path) }
         if editor == nil, let document = session.document {
             }
             editor.onEditBlock = { edit in sheet = .block(edit) }
             editor.onTangle = { scope in message = session.tangle(scope) }
+            editor.onBabel = { job in run(job) }
             editor.onAgenda = { start, count in model.agendaRequest = .init(start: start, count: count) }
             editor.onAppCommand = { id in
                 switch id {
 /// Every command that applies at the caret, by name.
 struct CommandPalette: View {
     let editor: MobileEditor
+    /// Called with the chosen command before the palette closes.
+    let choose: (String) -> Void
     @State private var query = ""
     @Environment(\.dismiss) private var dismiss
         NavigationStack {
             List(shown, id: \.id) { command in
                 Button {
+                    choose(command.id)
                     dismiss()
-                    // After the sheet goes, so a command's own prompt can show.
-                    DispatchQueue.main.asyncAfter(deadline: .now() + 0.4) { editor.run(command.id) }
                 } label: {
                     HStack {
                         Text(command.title).foregroundStyle(.primary)

Sources/OrgstarMobile/MobileEditor.swift +4

     private var applyingEdits = false
     /// Source blocks to write to their files (C-c C-v t).
     var onTangle: ((Tangle.Scope) -> Void)?
+    /// A source block to run (C-c C-c).
+    var onBabel: ((BabelJob) -> Void)?
     /// A block, a table's formulas or a field to edit apart (C-c ', C-c `).
     var onEditBlock: ((BlockEdit) -> Void)?
     /// A followed timestamp's agenda days: the first (a `Days` number) and how many.
             }
         case .external(.editBlock(let edit)) where onEditBlock != nil:
             onEditBlock?(edit)
+        case .external(.babel(let job)) where onBabel != nil:
+            onBabel?(job)
         case .external(.tangle(let scope)) where onTangle != nil:
             onTangle?(scope)
         case .external(.agenda(let start, let count)) where onAgenda != nil:

Tests/OrgCoreTests/BabelTests.swift +65 −2

	@@ -3,6 +3,8 @@ import Testing
3	@testable import OrgCore	3	@testable import OrgCore
4		4
5	/// Runs a Babel job the way the app does, for tests.	5	/// Runs a Babel job the way the app does, for tests.
		6	struct NativeUnsupported: Error {}
		7
6	enum TestBabelRunner {	8	enum TestBabelRunner {
7	static func run(_ job: BabelJob, directory: URL) throws -> BabelOutput {	9	static func run(_ job: BabelJob, directory: URL) throws -> BabelOutput {
8	let folder = FileManager.default.temporaryDirectory.appendingPathComponent("orgstar-babel-\(UUID().uuidString)")	10	let folder = FileManager.default.temporaryDirectory.appendingPathComponent("orgstar-babel-\(UUID().uuidString)")
	@@ -37,7 +39,13 @@ enum TestBabelRunner {
37	}	39	}
38		40
39	/// Plans, runs and finishes the block at `caret`: the new text, or the failure.	41	/// Plans, runs and finishes the block at `caret`: the new text, or the failure.
40	static func execute(_ text: String, caret: Int, directory: URL) throws -> (text: String, failure: String?) {	42	/// `native` runs Emacs Lisp blocks with `Babel.evaluateNatively` instead of Emacs.
		43	static func execute(_ text: String, caret: Int, directory: URL, native: Bool = false) throws -> (text: String, failure: String?) {
		44	func run(_ job: BabelJob, directory: URL) throws -> BabelOutput {
		45	guard native else { return try TestBabelRunner.run(job, directory: directory) }
		46	guard let output = try Babel.evaluateNatively(job) else { throw NativeUnsupported() }
		47	return output
		48	}
41	let context = EditContext(revision: 0, text: text, tree: OrgParser.parse(text), selection: [caret..<caret])	49	let context = EditContext(revision: 0, text: text, tree: OrgParser.parse(text), selection: [caret..<caret])
42	switch Babel.plan(context) {	50	switch Babel.plan(context) {
43	case .failure(.message(let message)): return (text, message)	51	case .failure(.message(let message)): return (text, message)
	@@ -48,7 +56,13 @@ enum TestBabelRunner {
48	case .success(let next): job = next	56	case .success(let next): job = next
49	}	57	}
50	}	58	}
51	let output = try run(job, directory: directory)	59	let output: BabelOutput
		60	do {
		61	output = try run(job, directory: directory)
		62	} catch let failure as Babel.Failure {
		63	guard case .message(let message) = failure else { return (text, nil) }
		64	return (text, message)
		65	}
52	if let file = Babel.fileResult(job, output: output) {	66	if let file = Babel.fileResult(job, output: output) {
53	try file.contents.write(to: directory.appendingPathComponent(file.path), atomically: true, encoding: .utf8)	67	try file.contents.write(to: directory.appendingPathComponent(file.path), atomically: true, encoding: .utf8)
54	}	68	}
	@@ -153,6 +167,55 @@ struct BabelTests {
153	}	167	}
154	}	168	}
155		169
		170	static let lispCases = [
		171	"#+begin_src emacs-lisp\n(list 1 2.5 \"three\" 'four)\n#+end_src\n",
		172	"#+begin_src emacs-lisp\n(list '(a 1) 'hline '(b 2))\n#+end_src\n",
		173	"#+begin_src emacs-lisp\n(format \"%05.2f\|%s\" 3.14159 'sym)\n#+end_src\n",
		174	"#+begin_src emacs-lisp\n\"line one\\nline \\\"two\\\"\"\n#+end_src\n",
		175	"#+begin_src emacs-lisp :results verbatim\n\"with \\\"quotes\\\" and \\\\ slash\"\n#+end_src\n",
		176	"#+begin_src emacs-lisp\nnil\n#+end_src\n",
		177	"#+begin_src emacs-lisp\nt\n#+end_src\n",
		178	"#+begin_src emacs-lisp\n[1 2 3]\n#+end_src\n",
		179	"#+begin_src emacs-lisp\n(cons 1 2)\n#+end_src\n",
		180	"#+begin_src emacs-lisp\n(/ 10 4.0)\n#+end_src\n",
		181	"#+begin_src emacs-lisp\n(let ((s 0)) (dotimes (i 5) (setq s (+ s i))) s)\n#+end_src\n",
		182	"#+begin_src emacs-lisp\n(mapcar (lambda (x) (* x x)) '(1 2 3))\n#+end_src\n",
		183	"#+begin_src emacs-lisp :results output\n(princ \"a\")\n(terpri)\n(prin1 \"b\")\n(print 'c)\n#+end_src\n",
		184	"#+begin_src emacs-lisp :results value scalar\n'(1 2)\n#+end_src\n",
		185	"#+begin_src emacs-lisp :results list\n'(\"x\" \"y\")\n#+end_src\n",
		186	"#+NAME: tbl\n\| 1 \| 2 \|\n\| 3 \| 4 \|\n\n#+begin_src emacs-lisp :var rows=tbl\n(mapcar (lambda (r) (apply #'+ r)) rows)\n#+end_src\n",
		187	"#+begin_src emacs-lisp :var n=6 :var s=\"hi\"\n(concat s (number-to-string (* n 7)))\n#+end_src\n",
		188	"#+begin_src emacs-lisp\n(car 1)\n#+end_src\n",
		189	"#+begin_src emacs-lisp :results raw\n\"bold\"\n#+end_src\n",
		190	"#+begin_src emacs-lisp :wrap example\n(upcase \"wrapped\")\n#+end_src\n",
		191	]
		192
		193	@Test(.enabled(if: ProcessInfo.processInfo.environment["ORGSTAR_SKIP_ORACLE"] == nil))
		194	func lispRunsNativelyLikeEmacs() throws {
		195	let folder = FileManager.default.temporaryDirectory
		196	let texts = Self.lispCases + Self.cases.filter { ($0.contains("emacs-lisp") \|\| $0.contains("begin_src elisp")) && !$0.contains("begin_src sh") }
		197	var emacsCases: [EmacsOracle.Case] = []
		198	var ours: [(text: String, failure: String?)] = []
		199	for text in texts {
		200	let caret = (text as NSString).range(of: "#+begin_src").location + 2
		201	do {
		202	ours.append(try TestBabelRunner.execute(text, caret: caret, directory: folder, native: true))
		203	} catch is NativeUnsupported {
		204	Issue.record("not run natively:\n\(text)")
		205	ours.append((text, "unsupported"))
		206	}
		207	emacsCases.append(EmacsOracle.Case(text: text, point: EmacsOracle.point(caret, in: text), form: """
		208	(progn
		209	(setq org-confirm-babel-evaluate nil)
		210	(org-babel-execute-src-block))
		211	"""))
		212	}
		213	let emacs = try EmacsOracle.run(emacsCases)
		214	for (i, (mine, theirs)) in zip(ours, emacs).enumerated() {
		215	#expect(mine.text == theirs.text, "case \(i):\n\(texts[i])\nours (\(mine.failure ?? "")):\n\(mine.text)\nemacs (\(theirs.error)):\n\(theirs.text)")
		216	}
		217	}
		218
156	@Test func asksOnceForEveryReferencedBlock() throws {	219	@Test func asksOnceForEveryReferencedBlock() throws {
157	let text = BabelTests.cases.first { $0.contains(":var a=outer") }!	220	let text = BabelTests.cases.first { $0.contains(":var a=outer") }!
158	guard case .success(let job) = Babel.plan(EditContext(revision: 0, text: text, tree: OrgParser.parse(text), selection: [2..<2])) else {	221	guard case .success(let job) = Babel.plan(EditContext(revision: 0, text: text, tree: OrgParser.parse(text), selection: [2..<2])) else {

Commit 46d6a046f5

Commit `46d6a046f5`