Enum Instr 

#[non_exhaustive]
pub enum Instr<Extension = NOp>
where
    Extension: InstructionSet,
{
    ControlFlow(ControlFlowOp),
    Put(PutOp),
    Move(MoveOp),
    Cmp(CmpOp),
    Arithmetic(ArithmeticOp),
    Bitwise(BitwiseOp),
    Bytes(BytesOp),
    Digest(DigestOp),
    ExtensionCodes(Extension),
    Nop,
}

Full set of instructions

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

ControlFlow(ControlFlowOp)

Control-flow instructions

Put(PutOp)

Instructions setting register values

Move(MoveOp)

Instructions moving and swapping register values

Cmp(CmpOp)

Instructions comparing register values

Arithmetic(ArithmeticOp)

Arithmetic instructions

Bitwise(BitwiseOp)

Bit operations & boolean algebra instructions

Bytes(BytesOp)

Operations on byte strings

Digest(DigestOp)

Cryptographic hashing functions

ExtensionCodes(Extension)

Extension operations which can be provided by a host environment

Nop

No-operation instruction

Trait Implementations

impl<Extension> Bytecode for Instr<Extension>

where Extension: InstructionSet,

fn byte_count(&self) -> u16

Returns number of bytes which instruction and its argument occupies

fn instr_range() -> RangeInclusive<u8>

Returns range of instruction btecodes covered by a set of operations

fn instr_byte(&self) -> u8

Returns byte representing instruction code (without its arguments)

fn write_args<W>(&self, writer: &mut W) -> Result<(), EncodeError>

where W: Write, EncodeError: From<<W as Write>::Error>,

Writes instruction arguments as bytecode, omitting instruction code byte

fn read<R>(reader: &mut R) -> Result<Self, DecodeError>

where R: Read, DecodeError: From<<R as Read>::Error>,

Reads the instruction from bytecode

fn write<W>(&self, writer: &mut W) -> Result<(), EncodeError>

where W: Write, EncodeError: From<<W as Write>::Error>,

Writes the instruction as bytecode

impl<Extension> Clone for Instr<Extension>

where Extension: InstructionSet + Clone,

fn clone(&self) -> Instr<Extension>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Extension> Debug for Instr<Extension>

where Extension: InstructionSet + Debug,

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

Formats the value using the given formatter.

impl<Extension> Display for Instr<Extension>

where Extension: InstructionSet,

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

Formats the value using the given formatter.

impl<Extension> Hash for Instr<Extension>

where Extension: InstructionSet + Hash,

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<Extension> InstructionSet for Instr<Extension>

where Extension: InstructionSet,

fn exec(self, regs: &mut Registers, site: LibSite) -> ExecStep

Executes given instruction taking all registers as input and output. The method is provided with the current code position which may be used by the instruction for constructing call stack.

impl<Extension> PartialEq for Instr<Extension>

where Extension: InstructionSet + PartialEq,

fn eq(&self, other: &Instr<Extension>) -> 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<Extension> Eq for Instr<Extension>

where Extension: InstructionSet + Eq,

impl<Extension> StructuralPartialEq for Instr<Extension>

where Extension: InstructionSet,