Enum VMStatus

pub enum VMStatus<F> {
    Finished {
        return_data_offset: u32,
        return_data_size: u32,
    },
    InProgress,
    Failure {
        reason: FailureReason,
        call_stack: ErrorCallStack,
    },
    ForeignCallWait {
        function: String,
        inputs: Vec<ForeignCallParam<F>>,
    },
}

Represents the current execution status of the Brillig VM.

Variants

Finished

The VM has completed execution successfully. The output of the program is stored in the VM memory and can be accessed via the provided offset and size.

Fields

return_data_offset: u32

Offset in memory where the return data begins.

return_data_size: u32

Size of the return data.

InProgress

The VM is still in progress and has not yet completed execution. This is used when simulating execution.

Failure

The VM encountered a failure and halted execution.

Fields

reason: FailureReason

The reason for the failure.

call_stack: ErrorCallStack

The call stack at the time the failure occurred, useful for debugging nested calls.

ForeignCallWait

The VM process is not solvable as a [foreign call][Opcode::ForeignCall] has been reached where the outputs are yet to be resolved.

The caller should interpret the information returned to compute a [ForeignCallResult] and update the Brillig process. The VM can then be restarted to fully solve the previously unresolved foreign call as well as the remaining Brillig opcodes.

Fields

function: String

Interpreted by simulator context.

inputs: Vec<ForeignCallParam<F>>

Input values. Each input can be either a single value or an array of values read from a memory pointer.

Trait Implementations

impl<F: Clone> Clone for VMStatus<F>

fn clone(&self) -> VMStatus<F>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<F: Debug> Debug for VMStatus<F>

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

Formats the value using the given formatter.

impl<F: PartialEq> PartialEq for VMStatus<F>

fn eq(&self, other: &VMStatus<F>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<F: Eq> Eq for VMStatus<F>

impl<F> StructuralPartialEq for VMStatus<F>