Enum Op 

#[repr(u8)]
pub enum Op {
    Const = 0,
    Nil = 1,
    True = 2,
    False = 3,
    Pop = 4,
    Dup = 5,
    LoadLocal = 6,
    StoreLocal = 7,
    LoadUpvalue = 8,
    StoreUpvalue = 9,
    LoadGlobal = 10,
    StoreGlobal = 11,
    DefineGlobal = 12,
    Jump = 13,
    JumpIfFalse = 14,
    JumpIfTrue = 15,
    Call = 16,
    TailCall = 17,
    Return = 18,
    MakeClosure = 19,
    CallNative = 20,
    MakeList = 21,
    MakeVector = 22,
    MakeMap = 23,
    MakeHashMap = 24,
    Throw = 25,
    Add = 26,
    Sub = 27,
    Mul = 28,
    Div = 29,
    Negate = 30,
    Not = 31,
    Eq = 32,
    Lt = 33,
    Gt = 34,
    Le = 35,
    Ge = 36,
    AddInt = 37,
    SubInt = 38,
    MulInt = 39,
    LtInt = 40,
    EqInt = 41,
    LoadLocal0 = 42,
    LoadLocal1 = 43,
    LoadLocal2 = 44,
    LoadLocal3 = 45,
    StoreLocal0 = 46,
    StoreLocal1 = 47,
    StoreLocal2 = 48,
    StoreLocal3 = 49,
    CallGlobal = 50,
}

Bytecode opcodes for the Sema VM.

Stack-based: operands are pushed/popped from the value stack. Variable-length encoding: opcode (1 byte) + operands (u16/u32/i32).

Variants

Const = 0

Nil = 1

True = 2

False = 3

Pop = 4

Dup = 5

LoadLocal = 6

StoreLocal = 7

LoadUpvalue = 8

StoreUpvalue = 9

LoadGlobal = 10

StoreGlobal = 11

DefineGlobal = 12

Jump = 13

JumpIfFalse = 14

JumpIfTrue = 15

Call = 16

TailCall = 17

Return = 18

MakeClosure = 19

CallNative = 20

MakeList = 21

MakeVector = 22

MakeMap = 23

MakeHashMap = 24

Throw = 25

Add = 26

Sub = 27

Mul = 28

Div = 29

Negate = 30

Not = 31

Eq = 32

Lt = 33

Gt = 34

Le = 35

Ge = 36

AddInt = 37

SubInt = 38

MulInt = 39

LtInt = 40

EqInt = 41

LoadLocal0 = 42

LoadLocal1 = 43

LoadLocal2 = 44

LoadLocal3 = 45

StoreLocal0 = 46

StoreLocal1 = 47

StoreLocal2 = 48

StoreLocal3 = 49

CallGlobal = 50

Implementations

impl Op

pub fn from_u8(byte: u8) -> Option<Op>

Convert a raw byte to an Op. Valid because the enum is #[repr(u8)] with dense variants from 0 through CallGlobal. If new variants are added with gaps, this must be updated.

Trait Implementations

impl Clone for Op

fn clone(&self) -> Op

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Op

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

Formats the value using the given formatter.

impl PartialEq for Op

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

impl Eq for Op

impl StructuralPartialEq for Op