Function run_repl_loop

repl/src/lib.rs:222–291

Enters the interactive interpreter. The `console` provided here is used for the REPL prompt interaction and should match the console that's in use by the machine (if any). They don't necessarily have to match though.

(
    machine: &mut Machine,
    console: Rc<RefCell<dyn Console>>,
    program: Rc<RefCell<dyn Program>>,
)

/// The `console` provided here is used for the REPL prompt interaction and should match the
/// console that's in use by the machine (if any).  They don't necessarily have to match though.
pub async fn run_repl_loop(
    machine: &mut Machine,
    console: Rc<RefCell<dyn Console>>,
    program: Rc<RefCell<dyn Program>>,
) -> io::Result<i32> {
    let mut stop_reason = None;
    let mut history = vec![];
    while stop_reason.is_none() {
        let line = {
            let mut console = console.borrow_mut();
            if console.is_interactive() {
                console.print("Ready")?;
            }
            console::read_line(&mut *console, "", "", Some(&mut history)).await
        };

        // Any signals entered during console input should not impact upcoming execution.  Drain
        // them all.
        machine.drain_signals();

        match line {
            Ok(line) => match machine.compile(&mut line.as_bytes()) {
                Ok(()) => match machine.exec().await {
                    Ok(None) => stop_reason = None,
                    Ok(Some(code)) => {
                        let should_continue = {
                            let program = program.borrow();
                            let mut console = console.borrow_mut();
                            continue_if_modified(&*program, &mut *console).await?
                        };
                        if should_continue {
                            stop_reason = Some(code);
                        } else {
                            let mut console = console.borrow_mut();
                            console.print("Exit aborted; resuming REPL loop.")?;
                        }
                    }
                    Err(StdError::Break) => {
                        let mut console = console.borrow_mut();
                        console.print(BREAK_MSG)?;
                    }
                    Err(e) => {
                        let mut console = console.borrow_mut();
                        console.print(format!("ERROR: {}", e).as_str())?;
                    }
                },
                Err(e) => {
                    let mut console = console.borrow_mut();
                    console.print(format!("ERROR: {}", e).as_str())?;
                }
            },
            Err(e) => {
                if e.kind() == io::ErrorKind::Interrupted {
                    let mut console = console.borrow_mut();
                    console.print(BREAK_MSG)?;
                    // Do not exit the interpreter.  Other REPLs, such as Python's, do not do so,
                    // and it is actually pretty annoying to exit the REPL when one may be furiously
                    // pressing CTRL+C to stop a program inside of it.