antcolony

23.3 KB

1. // hl:proc — CHILD PROCESSES as instance events (creator API ruling 2026-08-17:
2. // no eventloop plumbing in app code — `spawn()` hands back a Process the app
3. // subscribes with `on process.line` / `on process.exit`, and `process.kill()`
4. // is the stop button).
5. //
6. // Exports:
7. // hl_proc_spawn(argv_list) → { pid, events } — events is a LOOP SOURCE
8. // (wake_fd bell, the fetch-completions pattern)
9. // delivering { line, stream } per output line and
10. // a final { exit } when the child is gone
11. // hl_proc_kill(pid) → SIGTERM the child; the exit event still arrives
12. //
13. // One worker thread per child reads BOTH pipes with poll(), line-buffers, and
14. // posts events into the spawn's OWN queue — nothing global, nothing shared
15. // between children. No shell anywhere: argv is exec'd verbatim.
17. const std = @import("std");
18. const api = @import("plugin_api");
20. const linux = std.os.linux;
21. const libc = std.c;
22. const PthreadMutex = libc.pthread_mutex_t;
24. fn mutexLock(m: *PthreadMutex) void {
25. _ = libc.pthread_mutex_lock(m);
26. }
27. fn mutexUnlock(m: *PthreadMutex) void {
28. _ = libc.pthread_mutex_unlock(m);
29. }
31. const HlValue = api.HlValue;
32. const HlObject = api.HlObject;
33. const HlField = api.HlField;
34. const HlIterator = api.HlIterator;
35. const HlString = api.HlString;
37. var gpa = std.heap.DebugAllocator(.{ .stack_trace_frames = 0 }){};
38. const allocator = gpa.allocator();
40. // SCRIPT-RELATIVE program paths (the Hybriel path rule — imports, hl:fs and
41. // now spawn all resolve against the SCRIPT, not the process cwd): the loader
42. // installs the script dir right after dlopen.
43. var script_dir: ?[]u8 = null;
45. export fn hl_proc_set_script_dir(ptr: [*]const u8, len: usize) callconv(.c) void {
46. if (script_dir) |old| allocator.free(old);
47. script_dir = allocator.dupe(u8, ptr[0..len]) catch null;
48. }
50. const c = struct {
51. extern "c" fn fork() c_int;
52. extern "c" fn execvp(file: [*:0]const u8, argv: [*:null]const ?[*:0]const u8) c_int;
53. extern "c" fn pipe(fds: *[2]c_int) c_int;
54. extern "c" fn close(fd: c_int) c_int;
55. extern "c" fn dup2(old: c_int, new: c_int) c_int;
56. extern "c" fn kill(pid: c_int, sig: c_int) c_int;
57. extern "c" fn waitpid(pid: c_int, status: ?*c_int, options: c_int) c_int;
58. extern "c" fn _exit(code: c_int) noreturn;
59. extern "c" fn eventfd(initval: c_uint, flags: c_int) c_int;
60. extern "c" fn fcntl(fd: c_int, cmd: c_int, arg: c_int) c_int;
61. extern "c" fn strerror(errnum: c_int) [*:0]const u8;
62. extern "c" fn write(fd: c_int, buf: [*]const u8, n: usize) isize;
63. extern "c" fn read(fd: c_int, buf: [*]u8, n: usize) isize;
64. extern "c" fn poll(fds: [*]PollFd, n: c_ulong, timeout: c_int) c_int;
65. const PollFd = extern struct { fd: c_int, events: c_short, revents: c_short };
66. };
68. const POLLIN: c_short = 0x001;
69. const EFD_NONBLOCK: c_int = 0o4000;
71. fn hlStr(s: []const u8) HlString {
72. return .{ .ptr = s.ptr, .len = s.len };
73. }
75. // ── one spawned child ────────────────────────────────────────────────────────
77. const Event = struct {
78. line: ?[]u8 = null, // owned
79. stream: []const u8 = "", // "out" | "err"
80. exit_code: ?i32 = null,
81. /// exec NEVER HAPPENED: the errno text. The child has no exit — this is
82. /// the ONLY event, delivered as an hl_error so the loop routes it through
83. /// `on x.Error` → `on Error` → located crash (creator ruling 2026-08-17).
84. spawn_err: ?[]u8 = null,
85. };
87. const Child = struct {
88. mutex: PthreadMutex = libc.PTHREAD_MUTEX_INITIALIZER,
89. queue: std.ArrayListUnmanaged(Event) = .empty,
90. wake_fd: i32 = -1,
91. pid: i32 = 0,
92. out_fd: i32 = -1,
93. err_fd: i32 = -1,
94. exec_fd: i32 = -1,
95. argv0: []const u8 = "",
96. thread: ?std.Thread = null,
97. /// the iterator was closed by the loop — the worker frees the Child when done
98. done: bool = false,
100. fn post(self: *Child, ev: Event) void {
101. mutexLock(&self.mutex);
102. self.queue.append(allocator, ev) catch {};
103. mutexUnlock(&self.mutex);
104. const one: u64 = 1;
105. _ = c.write(self.wake_fd, @ptrCast(&one), 8);
106. }
107. };
109. fn workerMain(ch: *Child) void {
110. // the exec verdict first: BYTES on the CLOEXEC pipe = exec never happened
111. {
112. var eno: i32 = 0;
113. const got = c.read(ch.exec_fd, @ptrCast(&eno), 4);
114. _ = c.close(ch.exec_fd);
115. if (got == 4) {
116. var status: c_int = 0;
117. _ = c.waitpid(ch.pid, &status, 0); // reap the stillborn child
118. _ = c.close(ch.out_fd);
119. _ = c.close(ch.err_fd);
120. const msg = std.fmt.allocPrint(allocator, "hl:proc spawn: cannot start '{s}': {s}", .{ ch.argv0, std.mem.span(c.strerror(eno)) }) catch null;
121. ch.post(.{ .spawn_err = msg orelse @constCast("hl:proc spawn failed") });
122. return;
123. }
124. }
125. var bufs = [2]std.ArrayListUnmanaged(u8){ .empty, .empty };
126. defer for (&bufs) |*b| b.deinit(allocator);
127. const names = [2][]const u8{ "stdout", "stderr" };
128. var fds = [2]i32{ ch.out_fd, ch.err_fd };
129. var open_count: usize = 2;
131. var rd: [4096]u8 = undefined;
132. while (open_count > 0) {
133. var pfds: [2]c.PollFd = undefined;
134. var map: [2]usize = undefined;
135. var n: usize = 0;
136. for (fds, 0..) |fd, i| {
137. if (fd < 0) continue;
138. pfds[n] = .{ .fd = fd, .events = POLLIN, .revents = 0 };
139. map[n] = i;
140. n += 1;
141. }
142. const pr = c.poll(&pfds, n, -1);
143. if (pr <= 0) continue;
144. for (pfds[0..n], 0..) |pfd, pi| {
145. if (pfd.revents == 0) continue;
146. const i = map[pi];
147. const got = c.read(pfd.fd, &rd, rd.len);
148. if (got <= 0) {
149. // EOF on this stream: flush a trailing unterminated line
150. if (bufs[i].items.len > 0) {
151. const line = allocator.dupe(u8, bufs[i].items) catch null;
152. if (line) |l| ch.post(.{ .line = l, .stream = names[i] });
153. bufs[i].clearRetainingCapacity();
154. }
155. _ = c.close(pfd.fd);
156. fds[i] = -1;
157. open_count -= 1;
158. continue;
159. }
160. const chunk = rd[0..@intCast(got)];
161. var start: usize = 0;
162. for (chunk, 0..) |ch2, k| {
163. if (ch2 != '\n') continue;
164. bufs[i].appendSlice(allocator, chunk[start..k]) catch {};
165. const line = allocator.dupe(u8, bufs[i].items) catch null;
166. if (line) |l| ch.post(.{ .line = l, .stream = names[i] });
167. bufs[i].clearRetainingCapacity();
168. start = k + 1;
169. }
170. bufs[i].appendSlice(allocator, chunk[start..]) catch {};
171. }
172. }
174. var status: c_int = 0;
175. _ = c.waitpid(ch.pid, &status, 0);
176. // POSIX status decode: exited → code, signalled → 128+sig (the shell rule)
177. const code: i32 = if ((status & 0x7f) == 0) @intCast((status >> 8) & 0xff) else 128 + @as(i32, @intCast(status & 0x7f));
178. ch.post(.{ .exit_code = code });
179. }
181. // ── the loop source ──────────────────────────────────────────────────────────
183. fn eventsTryNext(ctx: ?*anyopaque) callconv(.c) HlValue {
184. const ch: *Child = @ptrCast(@alignCast(ctx orelse return api.makeNull()));
185. // drain the bell (read may fail with EAGAIN — fine)
186. var eat: [8]u8 = undefined;
187. _ = c.read(ch.wake_fd, &eat, 8);
189. mutexLock(&ch.mutex);
190. if (ch.queue.items.len == 0) {
191. mutexUnlock(&ch.mutex);
192. return api.makeNull();
193. }
194. const ev = ch.queue.orderedRemove(0);
195. mutexUnlock(&ch.mutex);
197. if (ev.spawn_err) |msg| {
198. return api.makeError(msg);
199. }
200. if (ev.exit_code) |code| {
201. const fields = allocator.alloc(HlField, 2) catch return api.makeNull();
202. fields[0] = .{ .key = hlStr("exit"), .value = api.makeNumber(@floatFromInt(code)) };
203. fields[1] = .{ .key = hlStr("pid"), .value = api.makeNumber(@floatFromInt(ch.pid)) };
204. const obj = allocator.create(HlObject) catch return api.makeNull();
205. obj.* = .{ .fields = fields.ptr, .field_count = 2, .deinit_fn = null };
206. return api.makeObject(obj);
207. }
208. const fields = allocator.alloc(HlField, 2) catch return api.makeNull();
209. fields[0] = .{ .key = hlStr("line"), .value = api.makeString(ev.line orelse "") };
210. fields[1] = .{ .key = hlStr("stream"), .value = api.makeString(ev.stream) };
211. const obj = allocator.create(HlObject) catch return api.makeNull();
212. obj.* = .{ .fields = fields.ptr, .field_count = 2, .deinit_fn = null };
213. return api.makeObject(obj);
214. }
216. fn eventsDeinit(ctx: ?*anyopaque) callconv(.c) void {
217. const ch: *Child = @ptrCast(@alignCast(ctx orelse return));
218. ch.done = true;
219. }
221. // ── exports ──────────────────────────────────────────────────────────────────
223. /// hl_proc_spawn(argvList) → { pid, events }
224. export fn hl_proc_spawn(argc: u32, argv: [*]const HlValue) callconv(.c) HlValue {
225. // Accepts BOTH forms: a STRING (split on ANY whitespace run — spaces,
226. // tabs, NEWLINES: a long command written across lines, the multi-line-
227. // string way, is one command) or a LIST (an object with numeric keys —
228. // the loader's valueArrayToHl contract) for arguments that contain spaces.
229. if (argc < 1) return api.makeError("hl:proc spawn: pass a command string or an argv list");
230. var parts = std.ArrayListUnmanaged([]const u8).empty;
231. defer parts.deinit(allocator);
232. if (argv[0].type == .hl_string) {
233. // whitespace-run tokens, with QUOTE GROUPING: a token opening with
234. // ' or " runs (whitespace included) to the matching close, quotes
235. // stripped — one argument. NOT a shell: no expansion, no nesting,
236. // no substitution; just grouping, the way a command line reads.
237. const sv0 = argv[0].data.string;
238. const text0 = sv0.ptr[0..sv0.len];
239. var pos: usize = 0;
240. while (pos < text0.len) {
241. const chx = text0[pos];
242. if (chx == ' ' or chx == '\t' or chx == '\r' or chx == '\n') {
243. pos += 1;
244. continue;
245. }
246. if (chx == '\'' or chx == '"') {
247. const close = std.mem.indexOfScalarPos(u8, text0, pos + 1, chx) orelse
248. return api.makeError("hl:proc spawn: unclosed quote in the command string");
249. parts.append(allocator, text0[pos + 1 .. close]) catch return api.makeError("hl:proc: out of memory");
250. pos = close + 1;
251. continue;
252. }
253. var end = pos;
254. while (end < text0.len and text0[end] != ' ' and text0[end] != '\t' and text0[end] != '\r' and text0[end] != '\n') end += 1;
255. parts.append(allocator, text0[pos..end]) catch return api.makeError("hl:proc: out of memory");
256. pos = end;
257. }
258. } else if (argv[0].type == .hl_object) {
259. const obj_in = argv[0].data.object;
260. for (obj_in.fields[0..obj_in.field_count]) |field| {
261. if (field.value.type != .hl_string) return api.makeError("hl:proc spawn: argv entries must be strings");
262. const sv = field.value.data.string;
263. parts.append(allocator, sv.ptr[0..sv.len]) catch return api.makeError("hl:proc: out of memory");
264. }
265. } else {
266. return api.makeError("hl:proc spawn: pass a command string or an argv list");
267. }
268. const n_args: usize = parts.items.len;
269. if (n_args == 0) return api.makeError("hl:proc spawn: empty command");
271. // NUL-terminated argv for exec, before the fork (no allocation after fork)
272. var cargv = allocator.alloc(?[*:0]const u8, n_args + 1) catch return api.makeError("hl:proc: out of memory");
273. for (parts.items, 0..) |part, i| {
274. var text: []const u8 = part;
275. // THE PROGRAM (argv[0]): a path containing '/' that is not absolute
276. // resolves against the SCRIPT's directory — the same rule every other
277. // Hybriel path follows. A bare name searches PATH (exec semantics).
278. var resolved: ?[]u8 = null;
279. defer if (resolved) |r| allocator.free(r);
280. if (i == 0 and text.len > 0 and text[0] != '/' and std.mem.indexOfScalar(u8, text, '/') != null) {
281. if (script_dir) |sd| {
282. resolved = std.fmt.allocPrint(allocator, "{s}/{s}", .{ sd, text }) catch null;
283. if (resolved) |r| text = r;
284. }
285. }
286. const z = allocator.dupeZ(u8, text) catch return api.makeError("hl:proc: out of memory");
287. cargv[i] = z.ptr;
288. }
289. cargv[n_args] = null;
291. var out_pipe: [2]c_int = undefined;
292. var err_pipe: [2]c_int = undefined;
293. var exec_pipe: [2]c_int = undefined; // the exec-failure channel (CLOEXEC)
294. if (c.pipe(&out_pipe) != 0 or c.pipe(&err_pipe) != 0 or c.pipe(&exec_pipe) != 0) {
295. return api.makeError("hl:proc spawn: pipe() failed");
296. }
297. _ = c.fcntl(exec_pipe[1], 2, 1); // F_SETFD FD_CLOEXEC: closes ITSELF on a successful exec
299. const pid = c.fork();
300. if (pid < 0) return api.makeError("hl:proc spawn: fork() failed");
301. if (pid == 0) {
302. // DIE WITH THE PARENT (2026-08-17): a supervisor that crashes or is
303. // Ctrl-C'd must not leave orphaned llama-servers squatting on ports —
304. // the kernel sends the child SIGTERM when hybriel exits, any exit.
305. _ = linux.prctl(1, 15, 0, 0, 0); // PR_SET_PDEATHSIG = 1, SIGTERM = 15
306. // the CHILD: pipes onto stdout/stderr, exec verbatim — no shell
307. _ = c.dup2(out_pipe[1], 1);
308. _ = c.dup2(err_pipe[1], 2);
309. _ = c.close(out_pipe[0]);
310. _ = c.close(out_pipe[1]);
311. _ = c.close(err_pipe[0]);
312. _ = c.close(err_pipe[1]);
313. _ = c.close(exec_pipe[0]);
314. _ = c.execvp(cargv[0].?, @ptrCast(cargv.ptr));
315. // exec failed: write errno through the CLOEXEC pipe — a successful
316. // exec closed it, so the parent reading BYTES means "never started"
317. const e: i32 = std.c._errno().*;
318. _ = c.write(exec_pipe[1], @ptrCast(&e), 4);
319. c._exit(127);
320. }
321. _ = c.close(out_pipe[1]);
322. _ = c.close(err_pipe[1]);
323. _ = c.close(exec_pipe[1]);
325. const ch = allocator.create(Child) catch return api.makeError("hl:proc: out of memory");
326. ch.* = .{
327. .wake_fd = c.eventfd(0, EFD_NONBLOCK),
328. .pid = pid,
329. .out_fd = out_pipe[0],
330. .err_fd = err_pipe[0],
331. .exec_fd = exec_pipe[0],
332. .argv0 = allocator.dupe(u8, std.mem.span(cargv[0].?)) catch "",
333. };
334. ch.thread = std.Thread.spawn(.{}, workerMain, .{ch}) catch {
335. return api.makeError("hl:proc spawn: worker thread failed");
336. };
337. if (ch.thread) |t| t.detach();
339. const iter = allocator.create(HlIterator) catch return api.makeError("hl:proc: out of memory");
340. iter.* = .{
341. .context = @ptrCast(ch),
342. .next_fn = &eventsTryNext,
343. .deinit_fn = &eventsDeinit,
344. .try_next_fn = &eventsTryNext,
345. .wake_fd = ch.wake_fd,
346. };
348. const fields = allocator.alloc(HlField, 2) catch return api.makeNull();
349. fields[0] = .{ .key = hlStr("pid"), .value = api.makeNumber(@floatFromInt(pid)) };
350. fields[1] = .{ .key = hlStr("events"), .value = api.makeIterator(iter) };
351. const obj = allocator.create(HlObject) catch return api.makeNull();
352. obj.* = .{ .fields = fields.ptr, .field_count = 2, .deinit_fn = null };
353. return api.makeObject(obj);
354. }
356. /// hl_proc_kill(pid, signal?) — SIGTERM by default; the exit event still arrives
357. export fn hl_proc_kill(argc: u32, argv: [*]const HlValue) callconv(.c) HlValue {
358. if (argc < 1 or argv[0].type != .hl_number) {
359. return api.makeError("hl:proc kill: pass the pid spawn() returned");
360. }
361. const pid: c_int = @intFromFloat(argv[0].data.number);
362. var sig: c_int = 15; // SIGTERM
363. if (argc >= 2 and argv[1].type == .hl_number) sig = @intFromFloat(argv[1].data.number);
364. if (pid <= 1) return api.makeError("hl:proc kill: refusing pid <= 1");
365. const r = c.kill(pid, sig);
366. return api.makeBool(r == 0);
367. }
369. /// hl_proc_env(name) — one environment variable, null when unset. The
370. /// environment is PROCESS surface, which is why it lives in hl:proc.
371. export fn hl_proc_env(argc: u32, argv: [*]const HlValue) callconv(.c) HlValue {
372. if (argc < 1 or argv[0].type != .hl_string) {
373. return api.makeError("hl:proc env: pass the variable name");
374. }
375. const name = argv[0].data.string;
376. const z = allocator.dupeZ(u8, name.ptr[0..name.len]) catch return api.makeNull();
377. defer allocator.free(z);
378. const v = std.c.getenv(z.ptr) orelse return api.makeNull();
379. const copy = allocator.dupe(u8, std.mem.span(v)) catch return api.makeNull();
380. return api.makeString(copy);
381. }
383. // ── the program's own arguments (mission 317) ────────────────────────────────
384. // The host installs them right after dlopen, the same way it installs the
385. // script directory: one NUL-separated blob and a count. WHAT they are is the
386. // host's ruling, not this plugin's — the interpreter hands over the positionals
387. // that follow a FILE entry, and a compiled binary hands over its own argv minus
388. // argv[0]. A program started with none simply gets none.
390. var arg_blob: ?[]u8 = null;
391. var arg_count: usize = 0;
393. export fn hl_proc_set_args(ptr: [*]const u8, len: usize, count: usize) callconv(.c) void {
394. if (arg_blob) |old| allocator.free(old);
395. arg_blob = allocator.dupe(u8, ptr[0..len]) catch null;
396. arg_count = if (arg_blob == null) 0 else count;
397. }
399. /// hl_proc_argc() — how many arguments the program was given.
400. export fn hl_proc_argc(argc: u32, argv: [*]const HlValue) callconv(.c) HlValue {
401. _ = argc;
402. _ = argv;
403. return api.makeNumber(@floatFromInt(arg_count));
404. }
406. /// hl_proc_arg(i) — the i-th argument, null when there is none. `args()` in
407. /// server.hl walks these into the list the language hands back; the pair exists
408. /// because a plugin's return value is one value, and a LIST is what the caller
409. /// wants.
410. export fn hl_proc_arg(argc: u32, argv: [*]const HlValue) callconv(.c) HlValue {
411. if (argc < 1 or argv[0].type != .hl_number) {
412. return api.makeError("hl:proc arg: pass the index");
413. }
414. const n = argv[0].data.number;
415. if (n < 0 or n != @floor(n)) return api.makeNull();
416. const want: usize = @intFromFloat(n);
417. if (want >= arg_count) return api.makeNull();
418. const blob = arg_blob orelse return api.makeNull();
419. var seen: usize = 0;
420. var start: usize = 0;
421. for (blob, 0..) |ch, i| {
422. if (ch != 0) continue;
423. if (seen == want) {
424. const copy = allocator.dupe(u8, blob[start..i]) catch return api.makeNull();
425. return api.makeString(copy);
426. }
427. seen += 1;
428. start = i + 1;
429. }
430. return api.makeNull();
431. }
433. /// hl_proc_cwd() — the process's current working directory, absolute. NOTE the
434. /// language's paths stay SCRIPT-relative; this is for tools that act where the
435. /// USER is standing (a CLI operating on "here"), not for resolving your own files.
436. export fn hl_proc_cwd(argc: u32, argv: [*]const HlValue) callconv(.c) HlValue {
437. _ = argc;
438. _ = argv;
439. var buf: [4096]u8 = undefined;
440. const p = std.c.getcwd(&buf, buf.len) orelse return api.makeError("hl:proc cwd: getcwd failed");
441. const copy = allocator.dupe(u8, std.mem.sliceTo(p, 0)) catch return api.makeNull();
442. return api.makeString(copy);
443. }
446. // ── stdin as a LOOP SOURCE (realms, 2026-09-01) ──────────────────────────────
447. // hl_proc_stdin() → loop source of { line, eof }: one reader thread on fd 0,
448. // line-buffered, posting under a mutex with an eventfd bell — the same shape
449. // as a child's pipes above. A joined terminal realm reads its keyboard here.
451. const StdinSrc = struct {
452. mutex: PthreadMutex = libc.PTHREAD_MUTEX_INITIALIZER,
453. queue: std.ArrayListUnmanaged([]u8) = .empty,
454. wake_fd: i32 = -1,
455. eof: bool = false,
456. eof_reported: bool = false,
458. fn post(self: *StdinSrc, line: ?[]u8) void {
459. mutexLock(&self.mutex);
460. if (line) |l| {
461. self.queue.append(allocator, l) catch {};
462. } else {
463. self.eof = true;
464. }
465. mutexUnlock(&self.mutex);
466. const one: u64 = 1;
467. _ = stdin_c.write(self.wake_fd, @ptrCast(&one), 8);
468. }
469. };
471. const stdin_c = struct {
472. extern "c" fn read(fd: c_int, buf: [*]u8, n: usize) isize;
473. extern "c" fn write(fd: c_int, buf: [*]const u8, n: usize) isize;
474. extern "c" fn eventfd(initval: c_uint, flags: c_int) c_int;
475. };
477. var stdin_src: ?*StdinSrc = null;
479. fn stdinReaderMain(s: *StdinSrc) void {
480. var buf = std.ArrayListUnmanaged(u8).empty;
481. defer buf.deinit(allocator);
482. var rd: [4096]u8 = undefined;
483. while (true) {
484. const got = stdin_c.read(0, &rd, rd.len);
485. if (got <= 0) break;
486. const chunk = rd[0..@intCast(got)];
487. var start: usize = 0;
488. for (chunk, 0..) |ch, k| {
489. if (ch != '\n') continue;
490. buf.appendSlice(allocator, chunk[start..k]) catch {};
491. const line = allocator.dupe(u8, buf.items) catch null;
492. if (line) |l| s.post(l);
493. buf.clearRetainingCapacity();
494. start = k + 1;
495. }
496. buf.appendSlice(allocator, chunk[start..]) catch {};
497. }
498. if (buf.items.len > 0) {
499. const line = allocator.dupe(u8, buf.items) catch null;
500. if (line) |l| s.post(l);
501. }
502. s.post(null);
503. }
505. fn stdinTryNext(ctx: ?*anyopaque) callconv(.c) HlValue {
506. const s: *StdinSrc = @ptrCast(@alignCast(ctx orelse return api.makeNull()));
507. var eat: [8]u8 = undefined;
508. _ = stdin_c.read(s.wake_fd, &eat, 8);
509. mutexLock(&s.mutex);
510. var line: ?[]u8 = null;
511. var eof_now = false;
512. if (s.queue.items.len > 0) {
513. line = s.queue.orderedRemove(0);
514. } else if (s.eof and !s.eof_reported) {
515. s.eof_reported = true;
516. eof_now = true;
517. }
518. mutexUnlock(&s.mutex);
519. if (line == null and !eof_now) return api.makeNull();
520. const fields = allocator.alloc(HlField, 2) catch return api.makeNull();
521. fields[0] = .{ .key = .{ .ptr = "line".ptr, .len = 4 }, .value = if (line) |l| api.makeString(l) else api.makeNull() };
522. fields[1] = .{ .key = .{ .ptr = "eof".ptr, .len = 3 }, .value = api.makeBool(eof_now) };
523. const obj = allocator.create(HlObject) catch return api.makeNull();
524. obj.* = .{ .fields = fields.ptr, .field_count = 2, .deinit_fn = null };
525. return api.makeObject(obj);
526. }
528. fn stdinDeinit(ctx: ?*anyopaque) callconv(.c) void {
529. _ = ctx;
530. }
532. /// hl_proc_stdin() → loop source
533. export fn hl_proc_stdin(argc: u32, argv: [*]const HlValue) callconv(.c) HlValue {
534. _ = argc;
535. _ = argv;
536. if (stdin_src != null) return api.makeError("hl:proc stdin: this process already reads its terminal");
537. const s = allocator.create(StdinSrc) catch return api.makeError("hl:proc: out of memory");
538. s.* = .{ .wake_fd = stdin_c.eventfd(0, 0o4000) };
539. const t = std.Thread.spawn(.{}, stdinReaderMain, .{s}) catch {
540. allocator.destroy(s);
541. return api.makeError("hl:proc stdin: cannot start the reader thread");
542. };
543. t.detach();
544. stdin_src = s;
545. const iter = allocator.create(HlIterator) catch return api.makeError("hl:proc: out of memory");
546. iter.* = .{
547. .context = @ptrCast(s),
548. .next_fn = &stdinTryNext,
549. .deinit_fn = &stdinDeinit,
550. .try_next_fn = &stdinTryNext,
551. .wake_fd = s.wake_fd,
552. };
553. return api.makeIterator(iter);
554. }