Enum Instruction 

pub enum Instruction {
    Unreachable,
    LoadLiteral {
        dst: RegId,
        lit: Literal,
    },
    LoadValue {
        dst: RegId,
        val: Box<Value>,
    },
    Move {
        dst: RegId,
        src: RegId,
    },
    Clone {
        dst: RegId,
        src: RegId,
    },
    Collect {
        src_dst: RegId,
    },
    TryCollect {
        src_dst: RegId,
    },
    Span {
        src_dst: RegId,
    },
    Drop {
        src: RegId,
    },
    Drain {
        src: RegId,
    },
    DrainIfEnd {
        src: RegId,
    },
    LoadVariable {
        dst: RegId,
        var_id: VarId,
        preserve_origin: bool,
    },
    StoreVariable {
        var_id: VarId,
        src: RegId,
    },
    DropVariable {
        var_id: VarId,
    },
    LoadEnv {
        dst: RegId,
        key: DataSlice,
    },
    LoadEnvOpt {
        dst: RegId,
        key: DataSlice,
    },
    StoreEnv {
        key: DataSlice,
        src: RegId,
    },
    PushPositional {
        src: RegId,
    },
    AppendRest {
        src: RegId,
    },
    PushFlag {
        name: DataSlice,
    },
    PushShortFlag {
        short: DataSlice,
    },
    PushNamed {
        name: DataSlice,
        src: RegId,
    },
    PushShortNamed {
        short: DataSlice,
        src: RegId,
    },
    PushParserInfo {
        name: DataSlice,
        info: Box<Expression>,
    },
    RedirectOut {
        mode: RedirectMode,
    },
    RedirectErr {
        mode: RedirectMode,
    },
    CheckErrRedirected {
        src: RegId,
    },
    OpenFile {
        file_num: u32,
        path: RegId,
        append: bool,
    },
    WriteFile {
        file_num: u32,
        src: RegId,
    },
    CloseFile {
        file_num: u32,
    },
    Call {
        decl_id: DeclId,
        src_dst: RegId,
    },
    StringAppend {
        src_dst: RegId,
        val: RegId,
    },
    GlobFrom {
        src_dst: RegId,
        no_expand: bool,
    },
    ListPush {
        src_dst: RegId,
        item: RegId,
    },
    ListSpread {
        src_dst: RegId,
        items: RegId,
    },
    RecordInsert {
        src_dst: RegId,
        key: RegId,
        val: RegId,
    },
    RecordSpread {
        src_dst: RegId,
        items: RegId,
    },
    Not {
        src_dst: RegId,
    },
    BinaryOp {
        lhs_dst: RegId,
        op: Operator,
        rhs: RegId,
    },
    FollowCellPath {
        src_dst: RegId,
        path: RegId,
    },
    CloneCellPath {
        dst: RegId,
        src: RegId,
        path: RegId,
    },
    UpsertCellPath {
        src_dst: RegId,
        path: RegId,
        new_value: RegId,
    },
    UpdateVarCellPath {
        var_id: VarId,
        cell_path: RegId,
        new_value: RegId,
    },
    Jump {
        index: usize,
    },
    BranchIf {
        cond: RegId,
        index: usize,
    },
    BranchIfEmpty {
        src: RegId,
        index: usize,
    },
    Match {
        pattern: Box<Pattern>,
        src: RegId,
        index: usize,
    },
    CheckMatchGuard {
        src: RegId,
    },
    Iterate {
        dst: RegId,
        stream: RegId,
        end_index: usize,
    },
    UnwindJump {
        index: usize,
        handlers: usize,
    },
    OnError {
        index: usize,
    },
    OnErrorInto {
        index: usize,
        dst: RegId,
    },
    FinallyInto {
        index: usize,
        dst: RegId,
    },
    PopErrorHandler,
    BeginFinally,
    EndFinally,
    ReturnEarly {
        src: RegId,
    },
    Return {
        src: RegId,
    },
}

Variants

Unreachable

Unreachable code path (error)

LoadLiteral

Load a literal value into the dst register

Fields

dst: RegId

lit: Literal

LoadValue

Load a clone of a boxed value into the dst register (e.g. from const evaluation)

Fields

dst: RegId

val: Box<Value>

Move

Move a register. Value is taken from src (used by this instruction).

Fields

dst: RegId

src: RegId

Clone

Copy a register (must be a collected value). Value is still in src after this instruction.

Fields

dst: RegId

src: RegId

Collect

Collect a stream in a register to a value. Because it collects to a value, nushell will ignore the errors in the stream. It’s important when the stream is from an external command

Fields

src_dst: RegId

TryCollect

Collect a stream in a register to a value. But it’s different from Collect in that if there is an error in the stream, it will be returned as an error instead of being ignored.

Fields

src_dst: RegId

Span

Change the span of the contents of a register to the span of this instruction.

Fields

src_dst: RegId

Drop

Drop the value/stream in a register, without draining

Fields

src: RegId

Drain

Drain the value/stream in a register and discard (e.g. semicolon).

If passed a stream from an external command, sets $env.LAST_EXIT_CODE to the resulting exit code, and invokes any available error handler with Empty, or if not available, returns an exit-code-only stream, leaving the block.

Fields

src: RegId

DrainIfEnd

Drain the value/stream in a register and discard only if this is the last pipeline element.

Fields

src: RegId

LoadVariable

Load the value of a variable into the dst register.

When preserve_origin is false (the default), the value is re-spanned to this instruction’s span so error labels point at the use site. When true, the value keeps the span from where it was defined (used by metadata $var).

Fields

dst: RegId

var_id: VarId

preserve_origin: bool

StoreVariable

Store the value of a variable from the src register

Fields

var_id: VarId

src: RegId

DropVariable

Remove a variable from the stack, freeing up whatever resources were associated with it

Fields

var_id: VarId

LoadEnv

Load the value of an environment variable into the dst register

Fields

dst: RegId

key: DataSlice

LoadEnvOpt

Load the value of an environment variable into the dst register, or Nothing if it doesn’t exist

Fields

dst: RegId

key: DataSlice

StoreEnv

Store the value of an environment variable from the src register

Fields

key: DataSlice

src: RegId

PushPositional

Add a positional arg to the next (internal) call.

Fields

src: RegId

AppendRest

Add a list of args to the next (internal) call (spread/rest).

Fields

src: RegId

PushFlag

Add a named arg with no value to the next (internal) call.

Fields

name: DataSlice

PushShortFlag

Add a short named arg with no value to the next (internal) call.

Fields

short: DataSlice

PushNamed

Add a named arg with a value to the next (internal) call.

Fields

name: DataSlice

src: RegId

PushShortNamed

Add a short named arg with a value to the next (internal) call.

Fields

short: DataSlice

src: RegId

PushParserInfo

Add parser info to the next (internal) call.

Fields

name: DataSlice

info: Box<Expression>

RedirectOut

Set the redirection for stdout for the next call (only).

The register for a file redirection is not consumed.

Fields

mode: RedirectMode

RedirectErr

Set the redirection for stderr for the next call (only).

The register for a file redirection is not consumed.

Fields

mode: RedirectMode

CheckErrRedirected

Throw an error if stderr wasn’t redirected in the given stream. src is preserved.

Fields

src: RegId

OpenFile

Open a file for redirection, pushing it onto the file stack.

Fields

file_num: u32

path: RegId

append: bool

WriteFile

Write data from the register to a file. This is done to finish a file redirection, in case an internal command or expression was evaluated rather than an external one.

Fields

file_num: u32

src: RegId

CloseFile

Pop a file used for redirection from the file stack.

Fields

file_num: u32

Call

Make a call. The input is taken from src_dst, and the output is placed in src_dst, overwriting it. The argument stack is used implicitly and cleared when the call ends.

Fields

decl_id: DeclId

src_dst: RegId

StringAppend

Append a value onto the end of a string. Uses to_expanded_string(", ", ...) on the value. Used for string interpolation literals. Not the same thing as the ++ operator.

Fields

src_dst: RegId

val: RegId

GlobFrom

Convert a string into a glob. Used for glob interpolation and setting glob variables. If the value is already a glob, it won’t be modified (no_expand will have no effect).

Fields

src_dst: RegId

no_expand: bool

ListPush

Push a value onto the end of a list. Used to construct list literals.

Fields

src_dst: RegId

item: RegId

ListSpread

Spread a value onto the end of a list. Used to construct list literals.

Fields

src_dst: RegId

items: RegId

RecordInsert

Insert a key-value pair into a record. Used to construct record literals. Raises an error if the key already existed in the record.

Fields

src_dst: RegId

key: RegId

val: RegId

RecordSpread

Spread a record onto a record. Used to construct record literals. Any existing value for the key is overwritten.

Fields

src_dst: RegId

items: RegId

Not

Negate a boolean.

Fields

src_dst: RegId

BinaryOp

Do a binary operation on lhs_dst (left) and rhs (right) and write the result to lhs_dst.

Fields

lhs_dst: RegId

op: Operator

rhs: RegId

FollowCellPath

Follow a cell path on the value in src_dst, storing the result back to src_dst

Fields

src_dst: RegId

path: RegId

CloneCellPath

Clone the value at a cell path in src, storing the result to dst. The original value remains in src. Must be a collected value.

Fields

dst: RegId

src: RegId

path: RegId

UpsertCellPath

Update/insert a cell path to new_value on the value in src_dst, storing the modified value back to src_dst

Fields

src_dst: RegId

path: RegId

new_value: RegId

UpdateVarCellPath

Update/insert a cell path directly on a variable in the stack, without cloning the variable first. Combines LoadVariable + UpsertCellPath + StoreVariable into a single in-place mutation. The variable must be mutable.

Fields

var_id: VarId

cell_path: RegId

new_value: RegId

Jump

Jump to an offset in this block

Fields

index: usize

BranchIf

Branch to an offset in this block if the value of the cond register is a true boolean, otherwise continue execution

Fields

cond: RegId

index: usize

BranchIfEmpty

Branch to an offset in this block if the value of the src register is Empty or Nothing, otherwise continue execution. The original value in src is preserved.

Fields

src: RegId

index: usize

Match

Match a pattern on src. If the pattern matches, branch to index after having set any variables captured by the pattern. If the pattern doesn’t match, continue execution. The original value is preserved in src through this instruction.

Fields

pattern: Box<Pattern>

src: RegId

index: usize

CheckMatchGuard

Check that a match guard is a boolean, throwing MatchGuardNotBool if it isn’t. Preserves src.

Fields

src: RegId

Iterate

Iterate on register stream, putting the next value in dst if present, or jumping to end_index if the iterator is finished

Fields

dst: RegId

stream: RegId

end_index: usize

UnwindJump

Jump to an offset in this block, unwinding through handlers entries of the try handler stack first. This is how break and continue leave try expressions: any finally block among those handlers runs before the jump completes.

Fields

index: usize

handlers: usize

OnError

Push a catch handler, without capturing the error value

Fields

index: usize

OnErrorInto

Push a catch handler, capturing the error value into dst. If the error handler is not called, the register should be freed manually.

Fields

index: usize

dst: RegId

FinallyInto

Push a finally handler, capturing the error value into dst. If the handler is entered for any other reason than an error, dst is set to empty instead.

Fields

index: usize

dst: RegId

PopErrorHandler

Pop a catch handler. This is not necessary when control flow is directed to the error handler due to an error.

BeginFinally

Mark the finally handler on top of the handler stack as running, on the way into its block from the try/catch fall-through path. The unwinder does this itself when it enters a finally block, so index of finally points just past this instruction.

EndFinally

Leave a finally block: pops its running marker and, if the block was entered by unwinding (an error, return, exit, break, or continue), resumes that unwinding.

ReturnEarly

Return early from the block with the value in the register.

Unlike return, this runs pending finally handlers first (collecting the value in that case, like the try-collect on the fall-through path), and flags the result as an early return. Custom command and closure calls clear that flag; only top-level file evaluation reads it, to skip main.

Fields

src: RegId

Return

Return from the block with the value in the register

Fields

src: RegId

Implementations

impl Instruction

pub fn display<'a>( &'a self, engine_state: &'a EngineState, data: &'a [u8], ) -> FmtInstruction<'a>

Returns a value that can be formatted with Display to show a detailed listing of the instruction.

pub fn output_register(&self) -> Option<RegId>

Get the output register, for instructions that produce some kind of immediate result.

pub fn branch_target(&self) -> Option<usize>

Returns the branch target index of the instruction if this is a branching instruction.

pub fn set_branch_target(&mut self, target_index: usize) -> Result<(), usize>

Sets the branch target of the instruction if this is a branching instruction.

Returns Err(target_index) if it isn’t a branching instruction.

pub fn check_interrupt( &self, engine_state: &EngineState, span: &Span, ) -> Result<(), ShellError>

Check for an interrupt before certain instructions

Trait Implementations

impl Clone for Instruction

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Instruction

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Instruction

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Instruction

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.