Enum Opcode 

#[repr(u8)]
pub enum Opcode {
    LoadConst = 0,
    LoadLocal = 1,
    StoreLocal = 2,
    LoadGlobal = 3,
    StoreGlobal = 4,
    LoadProperty = 5,
    StoreProperty = 6,
    LoadIndex = 7,
    StoreIndex = 8,
    Add = 10,
    Sub = 11,
    Mul = 12,
    Div = 13,
    Mod = 14,
    Neg = 15,
    Not = 20,
    BitAnd = 21,
    BitOr = 22,
    BitXor = 23,
    ShiftLeft = 24,
    ShiftRight = 25,
    Eq = 30,
    StrictEq = 31,
    NotEq = 32,
    StrictNotEq = 33,
    Lt = 34,
    Gt = 35,
    LtEq = 36,
    GtEq = 37,
    LogicalAnd = 38,
    LogicalOr = 39,
    Jump = 40,
    JumpIfFalse = 41,
    JumpIfTrue = 42,
    Call = 50,
    Return = 51,
    CreateClosure = 52,
    CreateObject = 60,
    CreateArray = 61,
    GetThis = 70,
    Typeof = 71,
    Instanceof = 72,
    In = 73,
    Throw = 74,
    EnterTry = 75,
    LeaveTry = 76,
    Pop = 80,
    Dup = 81,
    Halt = 255,
}

Bytecode opcodes (single-byte encoding)

Variants

LoadConst = 0

Push constant from pool onto stack

LoadLocal = 1

Push local variable onto stack

StoreLocal = 2

Pop stack into local variable

LoadGlobal = 3

Push global variable onto stack

StoreGlobal = 4

Pop stack into global variable

LoadProperty = 5

Pop object+key, push property value

StoreProperty = 6

Pop object+key+value, set property

LoadIndex = 7

Pop array+index, push element

StoreIndex = 8

Pop array+index+value, set element

Add = 10

Sub = 11

Mul = 12

Div = 13

Mod = 14

Neg = 15

Not = 20

BitAnd = 21

BitOr = 22

BitXor = 23

ShiftLeft = 24

ShiftRight = 25

Eq = 30

StrictEq = 31

NotEq = 32

StrictNotEq = 33

Lt = 34

Gt = 35

LtEq = 36

GtEq = 37

LogicalAnd = 38

LogicalOr = 39

Jump = 40

JumpIfFalse = 41

JumpIfTrue = 42

Call = 50

Return = 51

CreateClosure = 52

CreateObject = 60

CreateArray = 61

GetThis = 70

Typeof = 71

Instanceof = 72

In = 73

Throw = 74

EnterTry = 75

LeaveTry = 76

Pop = 80

Dup = 81

Halt = 255

Implementations

impl Opcode

pub fn from_byte(b: u8) -> Option<Self>

Decode from byte

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 Debug for Opcode

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

Formats the value using the given formatter.

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 Copy for Opcode

impl Eq for Opcode

impl StructuralPartialEq for Opcode