Method exec

core/src/vm/mod.rs:443–482

Starts or resumes execution of `image`. Returns a `StopReason` indicating why execution stopped, which may be due to program termination, an exception, or a pending upcall that requires caller handling.

(&'a mut self, image: &'a Image)

    /// Returns a `StopReason` indicating why execution stopped, which may be due to program
    /// termination, an exception, or a pending upcall that requires caller handling.
    pub fn exec<'a>(&'a mut self, image: &'a Image) -> StopReason<'a> {
        self.sync_upcalls(image);

        loop {
            if self.pending_upcall.is_some() {
                return StopReason::UpcallAsync(UpcallHandler { vm: self, image });
            }

            match self.context.exec(image, &mut self.heap) {
                InternalStopReason::End(code) => {
                    self.park_at_eof(image);
                    return StopReason::End(code);
                }
                InternalStopReason::Eof => return StopReason::Eof,
                InternalStopReason::Exception(pc, e) => {
                    let pos = image.debug_info.instrs[pc].linecol;
                    if !self.handle_exception(image, pc, pos, e.clone()) {
                        self.park_at_eof(image);
                        return StopReason::Exception(pos, e);
                    }
                }
                InternalStopReason::Upcall(index, first_reg, upcall_pc) => {
                    let (upcall, scope) = self.prepare_upcall(image, index, first_reg, upcall_pc);
                    let result = upcall.exec(scope);
                    if let Err(upcall_error) = self.handle_upcall_result(image, upcall_pc, result) {
                        let (pos, message) = upcall_error.parts();
                        self.park_at_eof(image);
                        return StopReason::Exception(pos, message);
                    }
                }

                InternalStopReason::UpcallAsync(index, first_reg, upcall_pc) => {
                    self.pending_upcall = Some((index, first_reg, upcall_pc));
                    return StopReason::UpcallAsync(UpcallHandler { vm: self, image });
                }

                InternalStopReason::Yield => return StopReason::Yield,
            }
        }
    }

    /// Stops execution of `image` so that the next call to `exec` starts at EOF.
    ///