notes

2.5 KB

1. // process.hl → class Process — one child, its lifetime, its events. The
2. // eventloop wiring lives HERE so app code never sees it: the events source is
3. // registered AT this instance, the internal fan-out re-emits `line` and
4. // `exit` at itself, and `on process.line` / `on process.exit` in the app are
5. // ordinary instance-scoped handlers.
7. Number pid = 0
8. Boolean running = false
9. Number #srcId = 0
11. start(String cmd, options) {
12. // THE STRING GOES OVER WHOLE (mission 249). `hl_proc_spawn` branches on
13. // the argument's type and its string branch is the tokenizer server.hl
14. // documents: whitespace RUNS (spaces, tabs, newlines — a command written
15. // across lines is one command) and quote GROUPING. Splitting here on " "
16. // and handing the pieces to the LIST branch is what kept that code
17. // unreached, and put a tab or a newline inside argv[0].
18. return this.launch(cmd, options)
19. }
21. startArgs(args, options) {
22. return this.launch(args, options)
23. }
25. // The one spawn: `spec` is the command STRING or the argv LIST, and which
26. // one it is decides the branch inside `hl_proc_spawn`, never anything here.
27. launch(spec, options) {
28. let spawned = __native("proc.spawn", spec, options)
29. pid = spawned.pid
30. running = true
31. #srcId = __native("eventloop.register", spawned.events, "__procEvent")
32. return this
33. }
35. on __procEvent(ev) {
36. if (ev.exit != null) {
37. running = false
38. // A FINISHED CHILD RETIRES ITS SOURCE (server.hl: "a program whose
39. // children are done simply ends"). Without this the loop still holds
40. // a source that will never speak again and the program never returns.
41. __native("eventloop.unregister", #srcId)
42. emit exit(ev)
43. return null
44. }
45. // a `binary = true` child (ticket #42): the raw bytes as a Bytes, never
46. // split into lines
47. if (ev.chunk != null) {
48. emit data({ data = toBytes(ev.chunk), stream = ev.stream })
49. return null
50. }
51. emit line(ev)
52. return null
53. }
55. \* WRITE TO THE CHILD'S STDIN (ruling on ticket #42): a String's bytes, or a
56. Bytes, exactly as they are — nothing added, no newline. Answers how many
57. bytes went. Only for a child spawned with `{ stdin = 'pipe' }` (a child's
58. stdin is inherited otherwise). The child reads EOF after end(), or when it
59. exits; a write after that is an Error. *\
60. write(data) {
61. if (hlTypeName(data) == 'Bytes') {
62. return __native("proc.write_hex", pid, data.hex())
63. }
64. return __native("proc.write", pid, data)
65. }
67. \* Close the child's stdin: it reads EOF. *\
68. end() {
69. return __native("proc.end", pid)
70. }
72. kill() {
73. if (running == false) {
74. return false
75. }
76. return __native("proc.kill", pid)
77. }