Enum OpCode 

pub enum OpCode {
    Pop,
    Copy(usize),
    Swap(usize),
    LoadLocal(usize),
    LoadGlobal(usize),
    LoadUpvalue(usize),
    LoadConst(usize),
    StoreLocal(usize),
    StoreGlobal(usize),
    StoreUpvalue(usize),
    Import(usize),
    ImportFrom(usize),
    ImportGlob,
    BuildTable(usize),
    BuildList(usize),
    GetAttr,
    GetItem,
    GetMeta,
    SetAttr,
    SetItem,
    SetMeta,
    Neg,
    Not,
    Add,
    Sub,
    Mul,
    Div,
    Mod,
    Eq,
    Ne,
    Gt,
    Ge,
    Lt,
    Le,
    Is,
    Iter,
    Jump(JumpTarget),
    JumpIfNull(JumpTarget),
    JumpPopIfFalse(JumpTarget),
    JumpIfTrueOrPop(JumpTarget),
    JumpIfFalseOrPop(JumpTarget),
    Call(usize),
    TryCall(usize),
    Return,
    Throw,
    ReturnCall(usize),
    JumpTarget(JumpTarget),
}

The operation code.

Variants

Pop

Removes the top-of-stack (TOS) item.

Copy(usize)

Push the i-th item to the top of the stack.

Swap(usize)

Swap TOS with the item at position i.

LoadLocal(usize)

Pushes the value associated with local_names[namei] onto the stack.

LoadGlobal(usize)

Pushes the value associated with global_names[namei] onto the stack.

LoadUpvalue(usize)

Pushes the value associated with upvalue_names[namei] onto the stack.

LoadConst(usize)

Pushes consts[consti] onto the stack.

StoreLocal(usize)

Stores TOS into the local_names[namei].

StoreGlobal(usize)

Stores TOS into the global_names[namei].

StoreUpvalue(usize)

Stores TOS into the upvalue_names[namei].

Import(usize)

Imports the module consts[consti] and pushed it onto the stack.

ImportFrom(usize)

Loads the attribute consts[consti] the module found in TOS and pushed it onto the stack.

ImportGlob

Loads all symbols from the module TOS to the global namespace.

BuildTable(usize)

Pushes a new table onto the stack. Pops 2 * count items to build table.

BuildList(usize)

Pushes a new list onto the stack. Pops count items to build list.

GetAttr

Implements TOS = TOS1::TOS.

GetItem

Implements TOS = TOS1[TOS].

GetMeta

Implements TOS = TOS[#].

SetAttr

Implements TOS1::TOS = TOS2.

SetItem

Implements TOS1[TOS] = TOS2.

SetMeta

Implements TOS[#] = TOS1.

Neg

Implements TOS = -TOS.

Not

Implements TOS = not TOS.

Add

Implements TOS = TOS1 + TOS.

Sub

Implements TOS = TOS1 - TOS.

Mul

Implements TOS = TOS1 * TOS.

Div

Implements TOS = TOS1 / TOS.

Mod

Implements TOS = TOS1 % TOS.

Eq

Implements TOS = TOS1 == TOS.

Ne

Implements TOS = TOS1 != TOS.

Gt

Implements TOS = TOS1 > TOS.

Ge

Implements TOS = TOS1 >= TOS.

Lt

Implements TOS = TOS1 < TOS.

Le

Implements TOS = TOS1 <= TOS.

Is

Implements TOS = TOS1 is TOS.

Iter

Get the iter of TOS and pushed it onto the stack.

Jump(JumpTarget)

Sets the bytecode counter to target.

JumpIfNull(JumpTarget)

If TOS is null, sets the bytecode counter to target.

JumpPopIfFalse(JumpTarget)

If TOS is false, sets the bytecode counter to target. TOS is popped.

JumpIfTrueOrPop(JumpTarget)

If TOS is true, sets the bytecode counter to target and leaves TOS on the stack. Otherwise, TOS is popped.

JumpIfFalseOrPop(JumpTarget)

If TOS is false, sets the bytecode counter to target and leaves TOS on the stack. Otherwise, TOS is popped.

Call(usize)

Pops numbers of item for function arguments, then pop an callable value and call it.

TryCall(usize)

Call with a shortcut for propagating errors.

Return

Returns with TOS to the caller of the function.

Throw

Returns with TOS as a error.

ReturnCall(usize)

Same as “Call(usize); Return;”, this is for tail call optimization.

JumpTarget(JumpTarget)

A jump target, only used during code generation.

Trait Implementations

impl Clone for OpCode

fn clone(&self) -> OpCode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Collect for OpCode

where Self: 'static,

fn needs_trace() -> bool

As an optimization, if this type can never hold a Gc pointer and trace is unnecessary to call, you may implement this method and return false. The default implementation returns true, signaling that Collect::trace must be called.

fn trace(&self, _cc: &Collection)

Must call Collect::trace on all held Gc pointers. If this type holds inner types that implement Collect, a valid implementation would simply call Collect::trace on all the held values to ensure this.

impl Debug for OpCode

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

Formats the value using the given formatter.

impl Display for OpCode

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

Formats the value using the given formatter.

impl Hash for OpCode

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for OpCode

fn cmp(&self, other: &OpCode) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for OpCode

fn eq(&self, other: &OpCode) -> 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 PartialOrd for OpCode

fn partial_cmp(&self, other: &OpCode) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl TryFrom<BinOp> for OpCode

type Error = SyntaxError

The type returned in the event of a conversion error.

fn try_from(value: BinOp) -> Result<Self, Self::Error>

Performs the conversion.

impl Copy for OpCode

impl Eq for OpCode

impl StructuralPartialEq for OpCode