Enum Instruction

#[non_exhaustive]
pub enum Instruction {
    Halt,
    Exit(Option<u8>),
    ScrollUp(u4),
    ScrollDown(u4),
    ScrollRight,
    ScrollLeft,
    Clear,
    Return,
    ToggleLoadStoreQuirk,
    LoRes,
    HiRes,
    CallMachineCode(u12),
    Jump(u12),
    Call(u12),
    SkipIfEqual(Register, Byte),
    SkipIfNotEqual(Register, Byte),
    Add(Register, Byte),
    Set(Register, Byte),
    Or(Register, Register),
    And(Register, Register),
    Xor(Register, Register),
    Sub(Register, Register),
    ShiftRight(Register, Register),
    ShiftLeft(Register, Register),
    SubReverse(Register, Register),
    SetIndex(u12),
    SetIndexLong(u16),
    JumpRelative(u12),
    Random(Register, u8),
    Draw(Register, Register, u4),
    SkipKey(Register),
    SkipNotKey(Register),
    LoadAudio,
    LoadDelay(Register),
    BlockKey(Register),
    SelectPlane(u4),
    SetPitch(Register),
    SetDelay(Register),
    SetSound(Register),
    AddRegisterToIndex(Register),
    FontCharacter(Register),
    BigFontCharacter(Register),
    Bcd(Register),
    Store(Register),
    Load(Register),
    StoreRange(Register, Register),
    LoadRange(Register, Register),
    StoreFlags(Register),
    LoadFlags(Register),
}

CHIP-8 instructions.

This instruction set is mostly based on what Octo supports, which comprises the specifications for CHIP-8, SUPER-CHIP and XO-CHIP.

However, there is also support for some more esoteric instructions, especially where there are no collisions in the opcode space.

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.

Halt

Halt the CHIP-8 interpreter.

Based on Octo’s behavior when encountering 0000.

Exit(Option<u8>)

Exit the CHIP-8 interpreter with an optional exit code.

Based on the following opcodes:

• 00FD: Exit interpreter (from SUPER-CHIP 1.1)
• 001N: Exit with exit code N (from chip8run)

ScrollUp(u4)

Scroll the display up.

Based on the following opcodes:

• 00BN: Scroll up by N pixels (from Massung’s SUPER-CHIP interpreter and Mega-Chip)
• 00DN: Scroll up by N pixels (from XO-CHIP)

ScrollDown(u4)

Scroll the display down.

Based on the following opcode:

• 00CN: Scroll down by N pixels

ScrollRight

Scroll the display right.

ScrollLeft

Scroll the display left.

Clear

Clear the display.

Return

Return from subroutine.

ToggleLoadStoreQuirk

Toggle the behavior of Instruction::Load and Instruction::Store

LoRes

Change display to low resolution (“lores”) mode, 64x32 pixels

HiRes

Change display to high resolution (“hires”) mode, 128x64 pixels

CallMachineCode(u12)

Call machine code routine.

Jump(u12)

Jump to memory address

Call(u12)

Call subroutine

SkipIfEqual(Register, Byte)

Skip the next instruction if

SkipIfNotEqual(Register, Byte)

Add(Register, Byte)

Set(Register, Byte)

Or(Register, Register)

And(Register, Register)

Xor(Register, Register)

Sub(Register, Register)

ShiftRight(Register, Register)

ShiftLeft(Register, Register)

SubReverse(Register, Register)

SetIndex(u12)

SetIndexLong(u16)

JumpRelative(u12)

Random(Register, u8)

Draw(Register, Register, u4)

Draw a sprite on the display.

SkipKey(Register)

SkipNotKey(Register)

LoadAudio

LoadDelay(Register)

BlockKey(Register)

SelectPlane(u4)

SetPitch(Register)

SetDelay(Register)

SetSound(Register)

AddRegisterToIndex(Register)

FontCharacter(Register)

BigFontCharacter(Register)

Bcd(Register)

Store(Register)

Load(Register)

StoreRange(Register, Register)

LoadRange(Register, Register)

StoreFlags(Register)

LoadFlags(Register)

Trait Implementations

impl Clone for Instruction

fn clone(&self) -> Instruction

Returns a duplicate 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 Display for Instruction

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

Formats the value using the given formatter.

impl<'_enum> From<&'_enum Instruction> for InstructionDiscriminants

fn from(val: &'_enum Instruction) -> InstructionDiscriminants

Converts to this type from the input type.

impl From<Instruction> for InstructionDiscriminants

fn from(val: Instruction) -> InstructionDiscriminants

Converts to this type from the input type.

impl From<Instruction> for Opcode

fn from(instruction: Instruction) -> Opcode

Converts to this type from the input type.

impl IntoEnumIterator for Instruction

type Iterator = InstructionIter

fn iter() -> InstructionIter

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 TryFrom<Opcode> for Instruction

type Error = DecodeError

The type returned in the event of a conversion error.

fn try_from(op: Opcode) -> Result<Self, Self::Error>

Performs the conversion.

impl Copy for Instruction

impl Eq for Instruction

impl StructuralPartialEq for Instruction