Enum chip_8::instructions::Instruction

pub enum Instruction {
    Sys(Addr),
    Clear,
    Return,
    Jump(Addr),
    Call(Addr),
    SkipEqualOperand(Vx, Byte),
    SkipNotEqualOperand(Vx, Byte),
    SkipEqual(Vx, Vy),
    LoadOperand(Vx, Byte),
    AddOperand(Vx, Byte),
    Load(Vx, Vy),
    Or(Vx, Vy),
    And(Vx, Vy),
    XOr(Vx, Vy),
    Add(Vx, Vy),
    Sub(Vx, Vy),
    ShiftRight(Vx, Vy),
    SubNegated(Vx, Vy),
    ShiftLeft(Vx, Vy),
    SkipNotEqual(Vx, Vy),
    LoadI(Addr),
    LongJump(Addr),
    Random(Vx, Byte),
    Draw(Vx, Vy, Nibble),
    SkipKeyPressed(Vx),
    SkipKeyNotPressed(Vx),
    LoadRegisterDelayTimer(Vx),
    LoadKey(Vx),
    LoadDelayTimerRegister(Vx),
    LoadSoundTimerRegister(Vx),
    AddI(Vx),
    LoadSprite(Vx),
    LoadBinaryCodedDecimal(Vx),
    LoadMemoryRegisters(Vx),
    LoadRegistersMemory(Vx),
}

Byte code instruction

Variants

Sys(Addr)

Jumps to machine routine at Addr

0nnn - SYS addr

Clear

Clears the display

00E0 - CLS

Return

Returns from a subroutine

00EE - RET

Jump(Addr)

Jumps to Addr

1nnn - JP addr

Call(Addr)

Calls subroutine at Addr

2nnn - CALL addr

SkipEqualOperand(Vx, Byte)

Skips next instruction if Vx equals byte

3xkk - SE Vx, byte

SkipNotEqualOperand(Vx, Byte)

Skips next instruction if Vx is not equal to byte

4xkk - SNE Vx, byte

SkipEqual(Vx, Vy)

Skips next instruction if Vy is equal to Vy

5xy0 - SE Vx, Vy

LoadOperand(Vx, Byte)

Loads byte into Vx

6xkk - LD Vx, byte

AddOperand(Vx, Byte)

Adds byte to Vx, then stores it in Vx

7xkk - ADD Vx, byte

Load(Vx, Vy)

Loads Vy into Vx

8xy0 - LD Vx, Vy

Or(Vx, Vy)

Sets Vx to Vx OR Vy

8xy1 - OR Vx, Vy

And(Vx, Vy)

Sets Vx to Vx AND Vy

8xy2 - AND Vx, Vy

XOr(Vx, Vy)

Sets Vx to Vx XOR Vy

8xy3 - XOR Vx, Vy

Add(Vx, Vy)

Sets Vx to Vx + Vy, VF to carry

8xy4 - ADD Vx, Vy

Sub(Vx, Vy)

Sets Vx to Vx - Vy, VF to not borrow

8xy5 - SUB Vx, Vy

ShiftRight(Vx, Vy)

Sets Vx to Vy SHR 1

8xy6 - SHR Vx {, Vy}

SubNegated(Vx, Vy)

Sets Vx to Vy - Vx, VF to not borrow

8xy7 - SUBN Vx, Vy

ShiftLeft(Vx, Vy)

Sets Vx to Vy SHL 1

8xyE - SHL Vx {, Vy}

SkipNotEqual(Vx, Vy)

Skips next instruction if Vx is not equal to Vy

9xy0 - SNE Vx, Vy

LoadI(Addr)

Loads Addr into register I

Annn - LD I, addr

LongJump(Addr)

Jumps to Addr + V0

Bnnn - JP V0, addr

Random(Vx, Byte)

Sets Vx to random number AND kk

Cxkk - RND Vx, byte

Draw(Vx, Vy, Nibble)

Read n bytes of memory from address I, draw it at Vx and Vy screen coordinates and set VF for erased pixels

Dxyn - DRW Vx, Vy, nibble

SkipKeyPressed(Vx)

Skip next instruction if key Vx is pressed

Ex9E - SKP Vx

SkipKeyNotPressed(Vx)

Skip next instruction if key Vx is not pressed

ExA1 - SKNP Vx

LoadRegisterDelayTimer(Vx)

Set Vx to delay timer value

Fx07 - LD Vx, DT

LoadKey(Vx)

Wait for key press and store it in Vx

Fx0A - LD Vx, K

LoadDelayTimerRegister(Vx)

Set delay timer to Vx

Fx15 - LD DT, Vx

LoadSoundTimerRegister(Vx)

Set sound timer to Vx

Fx18 - LD ST, Vx

AddI(Vx)

Add Vx to I

Fx1E - ADD I, Vx

LoadSprite(Vx)

Set I to the address of the sprite Vx

Fx29 - LD F, Vx

LoadBinaryCodedDecimal(Vx)

Store binary-coded decimal (BCD) at I, I+1 and I+2

Fx33 - LD B, Vx

LoadMemoryRegisters(Vx)

Store registers V0..Vx in memory at I

Fx55 - LD [I], Vx

LoadRegistersMemory(Vx)

Read registers V0..Vx from memory at I

Fx65 - LD Vx, [I]

Implementations

impl Instruction

pub fn decode(bits: u16) -> Result<Self>

Decodes raw bits into a valid Instruction

Errors

Will return Chip8Error::UnknownInstruction if given bits don't match any known instruction.

Trait Implementations

impl Clone for Instruction

fn clone(&self) -> Instruction

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for Instruction

impl Debug for Instruction

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

Formats the value using the given formatter.

impl Eq for Instruction

impl PartialEq<Instruction> for Instruction

fn eq(&self, other: &Instruction) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Instruction) -> bool

This method tests for !=.

impl StructuralEq for Instruction

impl StructuralPartialEq for Instruction