Function main

rust/py_repl_host/src/main.rs:73–117

()

}

fn main() -> io::Result<()> {
    let stdin = io::stdin();
    let stdout = io::stdout();
    let mut input = stdin.lock().lines();
    let mut output = BufWriter::new(stdout.lock());
    let mut kernel: Option<KernelProcess> = None;

    while let Some(line) = next_nonempty_line(&mut input)? {
        let message = match serde_json::from_str::<ParentMessage>(&line) {
            Ok(message) => message,
            Err(_) => continue,
        };

        match message {
            ParentMessage::Exec {
                id,
                code,
                timeout_ms,
            } => {
                if kernel.is_none() {
                    kernel = Some(spawn_kernel()?);
                }

                let result = relay_exec(
                    &id,
                    &code,
                    timeout_ms,
                    kernel.as_mut().expect("kernel initialized"),
                    &mut input,
                    &mut output,
                );

                if let Err(error) = result {
                    write_exec_result(&mut output, &id, false, "", Some(&error))?;
                    kernel = None;
                }
            }
            ParentMessage::RunToolResult { .. } => {
                // Ignored outside an active exec loop.
            }
        }
    }

    Ok(())
}

fn next_nonempty_line<I>(input: &mut I) -> io::Result<Option<String>>
where