Enum ResumptionValue 

pub enum ResumptionValue {
    Normal,
    InjectCall(InjectCall),
    ThrowException(Resource<WasmException>),
    EarlyReturn(Vec<Resource<WasmValue>>),
}

A resumption value indicates how we want to continue execution after a pause.

By default, if we are a “read-only” debugger, there is only one answer: with no mutation, according to the abstract Wasm machine semantics and current machine state.

However, this interface also supports various kinds of mutations. For example, the debugger can ask to insert a call to an arbitrary Wasm function, it can force an early return from the current function, or it can throw an exception.

This resumption value is orthogonal to the continue vs. single-step resume axis: the resumption value indicates whether we want to mutate the executing abstract machine’s state, while the single-step vs. continue axis indicates how we want to step that machine forward from whatever state is indicated (i.e., one step or many until an event).

Variants

Normal

Resume normally: do not alter the machine state.

InjectCall(InjectCall)

Inject a call to a Wasm function at the current point, as-if the program contained a call instruction with the given values on the operand stack.

Execution is subject to ordinary debugger events as with any other; e.g., the function we call may experience breakpoint pauses, may be single-stepped if we resume with single-step, etc.

If the injected function call completes normally, an injected-call-return debug event is raised with the return value(s).

ThrowException(Resource<WasmException>)

Resume as-if an exception were thrown at the current point.

EarlyReturn(Vec<Resource<WasmValue>>)

Force a return from the current function frame, with the given value(s) as return value(s).

Trait Implementations

impl Debug for ResumptionValue

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl ComponentType for ResumptionValue

impl Lift for ResumptionValue

impl Lower for ResumptionValue