Invert event loop

compiler/src/emit/calls.rs

@@ -97,6 +97,36 @@ impl<'a> Emitter<'a> {
                 let value = operand(self, FIRST_ARG as usize, self.rep(&self.cache.protos[kind as usize]));
                 (format!("({} = {value}, (undefined_t){{0}})", proto_global(kind)), Type::Undefined)
             }
+
+            // Keeps the fn where `jsrt_complete` finds it
+            Code::HostLink => {
+                let value = operand(self, FIRST_ARG as usize, self.rep(&self.cache.host_complete));
+                (format!("({HOST_COMPLETE_GLOBAL} = {value}, (undefined_t){{0}})"), Type::Undefined)
+            }
         }
     }
+
+    /// The body of `jsrt_complete(h)`: a call of the fn that the stdlib links
+    /// for the host, with op `h` (see `infer::host_calls()`)
+    pub(super) fn host_complete(&mut self) -> String {
+        let ty = self.cache.host_complete.clone();
+        let mut out = String::new();
+
+        if ty == Type::Unknown {
+            return out;
+        }
+
+        let rep = self.rep(&ty);
+        let operands = [(HOST_COMPLETE_GLOBAL.to_string(), rep), ("(undefined_t){0}".into(), Rep::Undefined), ("h".into(), Rep::Int)];
+
+        self.dispatch(HOST_COMPLETE_GLOBAL, &ty, "jsrt_type_error();", &mut out, |e, member, callee, rep| {
+            let Type::Obj(cell) = member else { return None };
+            let mut operands = operands.clone();
+            operands[0] = (callee.into(), rep);
+            let arg_types = [member.clone(), Type::Undefined, Type::Int];
+            Some(format!("{};", e.call_code(cell.code()?, HOST_COMPLETE, &arg_types, &operands).0))
+        });
+
+        out
+    }
 }

compiler/src/emit/classes.rs

@@ -121,6 +121,7 @@ pub(super) fn cell_sig(cell: &Cell, class: &HashMap<Cell, CellNum>, sig: &mut Ve
             Code::Fn(id) => [1, id as u32],
             Code::Native(id) => [2, id as u32],
             Code::ProtoLink(kind) => [3, kind as u32],
+            Code::HostLink => [5, 0],
         }),
         ObjKind::Array { elems } => {
             sig.push(4);

compiler/src/emit/instrs.rs

@@ -69,6 +69,7 @@ impl<'a> Emitter<'a> {
                 JsValue::String(s) => self.string_lit(&js_string_text(s)),
                 JsValue::NativeFn(id) => format!("&{}", builtin_name(self.num(self.cache.builtin(Code::Native(*id))))),
                 JsValue::ProtoLink(kind) => format!("&{}", builtin_name(self.num(self.cache.builtin(Code::ProtoLink(*kind))))),
+                JsValue::HostLink => format!("&{}", builtin_name(self.num(self.cache.builtin(Code::HostLink)))),
                 _ => format!("({}){{0}}", self.c_type(rep)),
             },
             Undefined | Null => format!("({}){{0}}", self.c_type(rep)),

compiler/src/emit/mod.rs

@@ -18,7 +18,7 @@ use std::{
 
 use crate::{
     infer::{
-        HOST, InferResult, Place, TypeCache,
+        HOST, HOST_COMPLETE, InferResult, Place, TypeCache,
         cells::{Cell, Code, LENGTH_FIELD, ObjKind, read_value},
         types::Type,
     },
@@ -94,11 +94,16 @@ pub fn emit(fns: &[RegFn], cache: &TypeCache, atoms: &[Atom]) -> String {
         }
     }
 
-    // The walks that the code calls, from the entry. The host calls the entry
-    // with nothing: its env and `this` are undefined
+    if cache.host_complete != Type::Unknown {
+        let _ = writeln!(statics, "static {} {HOST_COMPLETE_GLOBAL};", e.c_type(e.rep(&cache.host_complete)));
+    }
+
+    // The walks that the code calls, from the host's calls. The host calls the
+    // entry with nothing: its env and `this` are undefined
     let entry = cache.find(fns.len() - 1, HOST, &[], fns);
     let entry_args = vec!["(undefined_t){0}"; cache.walks[entry].req.arg_types.len()].join(", ");
     e.use_walk(entry);
+    let complete = e.host_complete();
 
     let mut fn_protos = String::new();
     let mut bodies = String::new();
@@ -127,7 +132,9 @@ pub fn emit(fns: &[RegFn], cache: &TypeCache, atoms: &[Atom]) -> String {
         e.helper_protos,
         e.helper_defs
     );
-    let _ = writeln!(out, "int main(void) {{\n{init}    {}({entry_args});\n    return 0;\n}}", e.fn_name(entry));
+    // What the host calls (see `lib/rt/jsrt.h`)
+    let _ = writeln!(out, "void jsrt_start(void) {{\n{init}    {}({entry_args});\n}}\n", e.fn_name(entry));
+    let _ = writeln!(out, "void jsrt_complete(int32_t h) {{\n{complete}}}");
     out
 }
 
@@ -287,6 +294,9 @@ fn builtin_name(id: CellNum) -> String {
     format!("b{id}")
 }
 
+/// The global that holds what the host calls when an IO op completes
+const HOST_COMPLETE_GLOBAL: &str = "jsrt_host_complete";
+
 fn proto_global(kind: ProtoOf) -> String {
     format!("proto_{kind:?}").to_lowercase()
 }

compiler/src/infer/cells.rs

@@ -27,6 +27,7 @@ pub enum Code {
     Fn(usize),
     Native(usize),
     ProtoLink(ProtoOf),
+    HostLink,
 }
 
 /// What the objects of a cell are, besides objects with named fields

compiler/src/infer/mod.rs

@@ -29,6 +29,10 @@ pub type Place = (usize, usize);
 /// The call place of the entry fn, which the host calls
 pub const HOST: Place = (usize::MAX, 0);
 
+/// The call place of the fn that the host calls when an IO op completes (see
+/// `Code::HostLink`)
+pub const HOST_COMPLETE: Place = (usize::MAX, 1);
+
 #[derive(Debug, Clone, Hash, PartialEq, Eq)]
 pub struct InferRequest {
     pub fn_id: usize,
@@ -60,6 +64,7 @@ pub struct TypeCache {
     objects: BTreeMap<(usize, usize, Place), Cell>, // the cell of each name: the fn and instr that make the objects, and the call place
     builtins: Vec<Cell>, // the cells of the natives, then of the proto links
     pub protos: Protos,  // the prototype of each `ProtoOf`, as the stdlib links it
+    pub host_complete: Type, // what the host calls when an IO op completes, as the stdlib links it
     version: usize,      // goes up on every change of a cell, a return or a proto, and on every new cell or walk
 }
 
@@ -83,6 +88,7 @@ impl TypeCache {
         match code {
             Code::Native(id) => &self.builtins[id],
             Code::ProtoLink(kind) => &self.builtins[NATIVES.len() + kind as usize],
+            Code::HostLink => &self.builtins[NATIVES.len() + ProtoOf::ALL.len()],
             Code::Fn(_) => unreachable!(),
         }
     }
@@ -184,6 +190,28 @@ fn call_code(cache: &mut TypeCache, code: Code, arg_types: &[Type], fns: &[RegFn
             cache.protos[kind as usize] = joined;
             Type::Undefined
         }
+        Code::HostLink => {
+            let joined = join(&cache.host_complete, args.first().unwrap_or(&Type::Undefined));
+            cache.changed(joined != cache.host_complete);
+            cache.host_complete = joined;
+            Type::Undefined
+        }
+    }
+}
+
+/// The calls that the host makes: the entry, with no args, then the fn that
+/// it calls when an IO op completes, with the op's handle. Each member of its
+/// type is its own env, and `this` is undefined
+fn host_calls(cache: &mut TypeCache, fns: &[RegFn]) {
+    // The synthetic program entry is appended last by `flatten`
+    cache.call(fns.len() - 1, HOST, &[], fns);
+
+    for member in cache.host_complete.clone().members() {
+        if let Type::Obj(cell) = member
+            && let Some(Code::Fn(fn_id)) = cell.code()
+        {
+            cache.call(fn_id, HOST_COMPLETE, &[member.clone(), Type::Undefined, Type::Int], fns);
+        }
     }
 }
 
@@ -206,19 +234,18 @@ pub fn infer_types(fns: &[RegFn]) -> TypeCache {
         objects: BTreeMap::new(),
         builtins: vec![],
         protos: std::array::from_fn(|_| Type::Unknown),
+        host_complete: Type::Unknown,
         version: 0,
     };
 
-    let codes = (0..NATIVES.len()).map(Code::Native).chain(ProtoOf::ALL.map(Code::ProtoLink));
+    let codes = (0..NATIVES.len()).map(Code::Native).chain(ProtoOf::ALL.map(Code::ProtoLink)).chain([Code::HostLink]);
     cache.builtins = codes.map(|code| Cell::new(ObjKind::Fn(code))).collect();
 
     loop {
         let version = cache.version;
         cache.walks.iter_mut().for_each(|w| w.result = None);
 
-        // The synthetic program entry is appended last by `flatten`. It is
-        // called by the host with no args
-        cache.call(fns.len() - 1, HOST, &[], fns);
+        host_calls(&mut cache, fns);
 
         if cache.version == version {
             return cache;
@@ -302,6 +329,7 @@ fn walk_fn(w: usize, reg_fns: &[RegFn], cache: &mut TypeCache) -> InferResult {
                         JsValue::Undefined => Type::Undefined,
                         JsValue::NativeFn(id) => Type::Obj(cache.builtin(Code::Native(id)).clone()),
                         JsValue::ProtoLink(kind) => Type::Obj(cache.builtin(Code::ProtoLink(kind)).clone()),
+                        JsValue::HostLink => Type::Obj(cache.builtin(Code::HostLink).clone()),
                         _ => unreachable!(),
                     },
 

compiler/src/libqjs/parse.rs

@@ -173,6 +173,8 @@ pub enum JsValue {
     NativeFn(usize),
     /// Makes its arg the prototype of a primitive kind (see `native`)
     ProtoLink(crate::native::ProtoOf),
+    /// `__link_host_complete`: its arg is what the host calls when an op completes
+    HostLink,
     Module(Module),
     TypedArray,
     ArrayBuffer,

compiler/src/native.rs

@@ -58,7 +58,6 @@ pub const NATIVES: &[NativeFn] = &[
     native!("__native_io_queue_close"(Int) -> Int),
     native!("__native_io_queue_stat"(String) -> Int),
     native!("__native_io_queue_cancel"(Int) -> Int),
-    native!("__native_io_wait"() -> Int),
     native!("__native_io_status"(Int) -> Int),
     native!("__native_io_result_string"(Int) -> String),
     native!("__native_io_result_number"(Int) -> Float),
@@ -110,6 +109,12 @@ static PROTO_LINKS: &[(&str, ProtoOf)] = &[
     ("__link_proto_array", ProtoOf::Array),
 ];
 
+/// `__link_host_complete(f)` makes `f` what the host calls when an IO op
+/// completes, with the op's handle (see `jsrt_complete` in `lib/rt/jsrt.h`).
+/// The host owns the event loop: a flavor of the runtime runs it, and the
+/// program only queues ops and handles their completions
+pub const HOST_LINK: &str = "__link_host_complete";
+
 /// The value of the global `name`. The only globals are the ones the stdlib
 /// may read, anything else is an error
 pub fn global(name: AtomRef, atoms: &[Atom]) -> JsValue {
@@ -124,6 +129,10 @@ pub fn global(name: AtomRef, atoms: &[Atom]) -> JsValue {
         return JsValue::NativeFn(idx);
     }
 
+    if name == HOST_LINK {
+        return JsValue::HostLink;
+    }
+
     match PROTO_LINKS.iter().find(|(link, _)| name == *link) {
         Some(&(_, kind)) => JsValue::ProtoLink(kind),
         None => panic!("unknown global `{name}`"),