Enum Register 

#[repr(u8)]
pub enum Register {
    R0 = 0,
    R1 = 1,
    R2 = 2,
    R3 = 3,
    R4 = 4,
    R5 = 5,
    R6 = 6,
    R7 = 7,
    R8 = 8,
    R9 = 9,
    R10 = 10,
    R11 = 11,
    AP = 12,
    FP = 13,
    SP = 14,
    PC = 15,
}

VAX General Registers

The VAX has 16 registers that are directly accessible by all instructions. There are 12 general purpose registers (R0-R11), two named regisers that can be used as general purpose registers (AP (argument) and FP (frame pointer)), and two special purpose registers (SP (stack pointer) and PC (program counter)).

Examples

use vax_disassembler::operand::Register;

// All registers directly map to a u8 value.
assert_eq!(Register::R0 as u8, 0);
assert_eq!(Register::R1 as u8, 1);
assert_eq!(Register::R2 as u8, 2);
assert_eq!(Register::R3 as u8, 3);
assert_eq!(Register::R4 as u8, 4);
assert_eq!(Register::R5 as u8, 5);
assert_eq!(Register::R6 as u8, 6);
assert_eq!(Register::R7 as u8, 7);
assert_eq!(Register::R8 as u8, 8);
assert_eq!(Register::R9 as u8, 9);
assert_eq!(Register::R10 as u8, 10);
assert_eq!(Register::R11 as u8, 11);
assert_eq!(Register::AP as u8, 12);
assert_eq!(Register::FP as u8, 13);
assert_eq!(Register::SP as u8, 14);
assert_eq!(Register::PC as u8, 15);

// All u8 values map to the register based on the low 4 bits.
for byte in (0_u8..=0xF0).step_by(0x10) {
   assert_eq!(Register::R0, Register::from(byte + 0));
   assert_eq!(Register::R1, Register::from(byte + 1));
   assert_eq!(Register::R2, Register::from(byte + 2));
   assert_eq!(Register::R3, Register::from(byte + 3));
   assert_eq!(Register::R4, Register::from(byte + 4));
   assert_eq!(Register::R5, Register::from(byte + 5));
   assert_eq!(Register::R6, Register::from(byte + 6));
   assert_eq!(Register::R7, Register::from(byte + 7));
   assert_eq!(Register::R8, Register::from(byte + 8));
   assert_eq!(Register::R9, Register::from(byte + 9));
   assert_eq!(Register::R10, Register::from(byte + 10));
   assert_eq!(Register::R11, Register::from(byte + 11));
   assert_eq!(Register::AP, Register::from(byte + 12));
   assert_eq!(Register::FP, Register::from(byte + 13));
   assert_eq!(Register::SP, Register::from(byte + 14));
   assert_eq!(Register::PC, Register::from(byte + 15));
}

Variants

R0 = 0

The R0 Register

Examples

use vax_disassembler::Register;

for high_nibble in 0_u8..16 {
    let operand_byte = (high_nibble << 4) + 0;
    assert_eq!(Register::R0, Register::from(operand_byte));
}

R1 = 1

The R1 Register

Examples

use vax_disassembler::Register;

for high_nibble in 0_u8..16 {
    let operand_byte = (high_nibble << 4) + 1;
    assert_eq!(Register::R1, Register::from(operand_byte));
}

R2 = 2

The R2 Register

Examples

use vax_disassembler::Register;

for high_nibble in 0_u8..16 {
    let operand_byte = (high_nibble << 4) + 2;
    assert_eq!(Register::R2, Register::from(operand_byte));
}

R3 = 3

The R3 Register

Examples

use vax_disassembler::Register;

for high_nibble in 0_u8..16 {
    let operand_byte = (high_nibble << 4) + 3;
    assert_eq!(Register::R3, Register::from(operand_byte));
}

R4 = 4

The R4 Register

Examples

use vax_disassembler::Register;

for high_nibble in 0_u8..16 {
    let operand_byte = (high_nibble << 4) + 4;
    assert_eq!(Register::R4, Register::from(operand_byte));
}

R5 = 5

The R5 Register

Examples

use vax_disassembler::Register;

for high_nibble in 0_u8..16 {
    let operand_byte = (high_nibble << 4) + 5;
    assert_eq!(Register::R5, Register::from(operand_byte));
}

R6 = 6

The R6 Register

Examples

use vax_disassembler::Register;

for high_nibble in 0_u8..16 {
    let operand_byte = (high_nibble << 4) + 6;
    assert_eq!(Register::R6, Register::from(operand_byte));
}

R7 = 7

The R7 Register

Examples

use vax_disassembler::Register;

for high_nibble in 0_u8..16 {
    let operand_byte = (high_nibble << 4) + 7;
    assert_eq!(Register::R7, Register::from(operand_byte));
}

R8 = 8

The R8 Register

Examples

use vax_disassembler::Register;

for high_nibble in 0_u8..16 {
    let operand_byte = (high_nibble << 4) + 8;
    assert_eq!(Register::R8, Register::from(operand_byte));
}

R9 = 9

The R9 Register

Examples

use vax_disassembler::Register;

for high_nibble in 0_u8..16 {
    let operand_byte = (high_nibble << 4) + 9;
    assert_eq!(Register::R9, Register::from(operand_byte));
}

R10 = 10

The R10 Register

Examples

use vax_disassembler::Register;

for high_nibble in 0_u8..16 {
    let operand_byte = (high_nibble << 4) + 10;
    assert_eq!(Register::R10, Register::from(operand_byte));
}

R11 = 11

The R11 Register

Examples

use vax_disassembler::Register;

for high_nibble in 0_u8..16 {
    let operand_byte = (high_nibble << 4) + 11;
    assert_eq!(Register::R11, Register::from(operand_byte));
}

AP = 12

The AP Register

Examples

use vax_disassembler::Register;

for high_nibble in 0_u8..16 {
    let operand_byte = (high_nibble << 4) + 12;
    assert_eq!(Register::AP, Register::from(operand_byte));
}

FP = 13

The FP Register

Examples

use vax_disassembler::Register;

for high_nibble in 0_u8..16 {
    let operand_byte = (high_nibble << 4) + 13;
    assert_eq!(Register::FP, Register::from(operand_byte));
}

SP = 14

The SP Register

Examples

use vax_disassembler::Register;

for high_nibble in 0_u8..16 {
    let operand_byte = (high_nibble << 4) + 14;
    assert_eq!(Register::SP, Register::from(operand_byte));
}

PC = 15

The PC Register

Examples

use vax_disassembler::Register;

for high_nibble in 0_u8..16 {
    let operand_byte = (high_nibble << 4) + 15;
    assert_eq!(Register::PC, Register::from(operand_byte));
}

Trait Implementations

impl Clone for Register

fn clone(&self) -> Register

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Register

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

Formats the value using the given formatter.

impl Display for Register

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

Formats the value using the given formatter.

Examples

use vax_disassembler::operand::Register;

assert_eq!(&format!("{}", Register::R0), "R0");
assert_eq!(&format!("{}", Register::R1), "R1");
assert_eq!(&format!("{}", Register::R2), "R2");
assert_eq!(&format!("{}", Register::R3), "R3");
assert_eq!(&format!("{}", Register::R4), "R4");
assert_eq!(&format!("{}", Register::R5), "R5");
assert_eq!(&format!("{}", Register::R6), "R6");
assert_eq!(&format!("{}", Register::R7), "R7");
assert_eq!(&format!("{}", Register::R8), "R8");
assert_eq!(&format!("{}", Register::R9), "R9");
assert_eq!(&format!("{}", Register::R10), "R10");
assert_eq!(&format!("{}", Register::R11), "R11");
assert_eq!(&format!("{}", Register::AP), "AP");
assert_eq!(&format!("{}", Register::FP), "FP");
assert_eq!(&format!("{}", Register::SP), "SP");
assert_eq!(&format!("{}", Register::PC), "PC");

impl From<u8> for Register

fn from(value: u8) -> Register

Converts to this type from the input type.

The general mode addressing formats (other than literal mode) consists of the register number in bits 0-3 (the low nibble) and the addressing mode specifier bits in bits 4-7 (the high nibble). Register::from(u8) will take bits 0-3 of the u8 value and return the Register.

The register numbers are as follows:

R0	=	0
R1	=	1
R2	=	2
R3	=	3
R4	=	4
R5	=	5
R6	=	6
R7	=	7
R8	=	8
R9	=	9
R10	=	10
R11	=	11
AP	=	12
FP	=	13
SP	=	14
PC	=	15

use vax_disassembler::operand::Register;

assert_eq!(Register::R0, Register::from(0));
assert_eq!(Register::R1, Register::from(1));
assert_eq!(Register::R2, Register::from(2));
assert_eq!(Register::R3, Register::from(3));
assert_eq!(Register::R4, Register::from(4));
assert_eq!(Register::R5, Register::from(5));
assert_eq!(Register::R6, Register::from(6));
assert_eq!(Register::R7, Register::from(7));
assert_eq!(Register::R8, Register::from(8));
assert_eq!(Register::R9, Register::from(9));
assert_eq!(Register::R10, Register::from(10));
assert_eq!(Register::R11, Register::from(11));
assert_eq!(Register::AP, Register::from(12));
assert_eq!(Register::FP, Register::from(13));
assert_eq!(Register::SP, Register::from(14));
assert_eq!(Register::PC, Register::from(15));
// Verify that all values of u8 are covered.
for i in 16..=u8::MAX {
    let _ = Register::from(i);
}

impl Ord for Register

fn cmp(&self, other: &Register) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Register

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

fn partial_cmp(&self, other: &Register) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for Register

impl Eq for Register

impl StructuralPartialEq for Register