Enum Instruction

pub enum Instruction {
    Import {
        name: Option<String>,
        symbols: Vec<String>,
        level: usize,
    },
    ImportStar,
    ImportFrom {
        name: String,
    },
    LoadName {
        name: String,
        scope: NameScope,
    },
    StoreName {
        name: String,
        scope: NameScope,
    },
    DeleteName {
        name: String,
    },
    Subscript,
    StoreSubscript,
    DeleteSubscript,
    StoreAttr {
        name: String,
    },
    DeleteAttr {
        name: String,
    },
    LoadConst {
        value: Constant,
    },
    UnaryOperation {
        op: UnaryOperator,
    },
    BinaryOperation {
        op: BinaryOperator,
        inplace: bool,
    },
    LoadAttr {
        name: String,
    },
    CompareOperation {
        op: ComparisonOperator,
    },
    Pop,
    Rotate {
        amount: usize,
    },
    Duplicate,
    GetIter,
    Continue,
    Break,
    Jump {
        target: Label,
    },
    JumpIfTrue {
        target: Label,
    },
    JumpIfFalse {
        target: Label,
    },
    JumpIfTrueOrPop {
        target: Label,
    },
    JumpIfFalseOrPop {
        target: Label,
    },
    MakeFunction,
    CallFunction {
        typ: CallType,
    },
    ForIter {
        target: Label,
    },
    ReturnValue,
    YieldValue,
    YieldFrom,
    SetupLoop {
        start: Label,
        end: Label,
    },
    SetupFinally {
        handler: Label,
    },
    EnterFinally,
    EndFinally,
    SetupExcept {
        handler: Label,
    },
    SetupWith {
        end: Label,
    },
    WithCleanupStart,
    WithCleanupFinish,
    PopBlock,
    Raise {
        argc: usize,
    },
    BuildString {
        size: usize,
    },
    BuildTuple {
        size: usize,
        unpack: bool,
    },
    BuildList {
        size: usize,
        unpack: bool,
    },
    BuildSet {
        size: usize,
        unpack: bool,
    },
    BuildMap {
        size: usize,
        unpack: bool,
        for_call: bool,
    },
    BuildSlice {
        size: usize,
    },
    ListAppend {
        i: usize,
    },
    SetAdd {
        i: usize,
    },
    MapAdd {
        i: usize,
    },
    PrintExpr,
    LoadBuildClass,
    UnpackSequence {
        size: usize,
    },
    UnpackEx {
        before: usize,
        after: usize,
    },
    FormatValue {
        conversion: Option<ConversionFlag>,
    },
    PopException,
    Reverse {
        amount: usize,
    },
    GetAwaitable,
    BeforeAsyncWith,
    SetupAsyncWith {
        end: Label,
    },
    GetAIter,
    GetANext,
    MapAddRev {
        i: usize,
    },
}

A Single bytecode instruction.

Variants

Import

Fields

name: Option<String>

symbols: Vec<String>

level: usize

ImportStar

ImportFrom

Fields

name: String

LoadName

Fields

name: String

scope: NameScope

StoreName

Fields

name: String

scope: NameScope

DeleteName

Fields

name: String

Subscript

StoreSubscript

DeleteSubscript

StoreAttr

Fields

name: String

DeleteAttr

Fields

name: String

LoadConst

Fields

value: Constant

UnaryOperation

Fields

op: UnaryOperator

BinaryOperation

Fields

op: BinaryOperator

inplace: bool

LoadAttr

Fields

name: String

CompareOperation

Fields

op: ComparisonOperator

Pop

Rotate

Fields

amount: usize

Duplicate

GetIter

Continue

Break

Jump

Fields

target: Label

JumpIfTrue

Pop the top of the stack, and jump if this value is true.

Fields

target: Label

JumpIfFalse

Pop the top of the stack, and jump if this value is false.

Fields

target: Label

JumpIfTrueOrPop

Peek at the top of the stack, and jump if this value is true. Otherwise, pop top of stack.

Fields

target: Label

JumpIfFalseOrPop

Peek at the top of the stack, and jump if this value is false. Otherwise, pop top of stack.

Fields

target: Label

MakeFunction

CallFunction

Fields

typ: CallType

ForIter

Fields

target: Label

ReturnValue

YieldValue

YieldFrom

SetupLoop

Fields

start: Label

end: Label

SetupFinally

Setup a finally handler, which will be called whenever one of this events occurs:

• the block is popped
• the function returns
• an exception is returned

Fields

handler: Label

EnterFinally

Enter a finally block, without returning, excepting, just because we are there.

EndFinally

Marker bytecode for the end of a finally sequence. When this bytecode is executed, the eval loop does one of those things:

• Continue at a certain bytecode position
• Propagate the exception
• Return from a function
• Do nothing at all, just continue

SetupExcept

Fields

handler: Label

SetupWith

Fields

end: Label

WithCleanupStart

WithCleanupFinish

PopBlock

Raise

Fields

argc: usize

BuildString

Fields

size: usize

BuildTuple

Fields

size: usize

unpack: bool

BuildList

Fields

size: usize

unpack: bool

BuildSet

Fields

size: usize

unpack: bool

BuildMap

Fields

size: usize

unpack: bool

for_call: bool

BuildSlice

Fields

size: usize

ListAppend

Fields

i: usize

SetAdd

Fields

i: usize

MapAdd

Fields

i: usize

PrintExpr

LoadBuildClass

UnpackSequence

Fields

size: usize

UnpackEx

Fields

before: usize

after: usize

FormatValue

Fields

conversion: Option<ConversionFlag>

PopException

Reverse

Fields

amount: usize

GetAwaitable

BeforeAsyncWith

SetupAsyncWith

Fields

end: Label

GetAIter

GetANext

MapAddRev

Reverse order evaluation in MapAdd required to support named expressions of Python 3.8 in dict comprehension today (including Py3.9) only required in dict comprehension.

Fields

i: usize

Trait Implementations

impl Clone for Instruction

fn clone(&self) -> Instruction

Returns a copy 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 PartialEq for Instruction

fn eq(&self, other: &Instruction) -> 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 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.

impl StructuralPartialEq for Instruction