Enum capstone_sys::mos65xx_address_mode

#[repr(u32)]
pub enum mos65xx_address_mode {
    MOS65XX_AM_NONE = 0,
    MOS65XX_AM_IMP = 1,
    MOS65XX_AM_ACC = 2,
    MOS65XX_AM_IMM = 3,
    MOS65XX_AM_REL = 4,
    MOS65XX_AM_INT = 5,
    MOS65XX_AM_BLOCK = 6,
    MOS65XX_AM_ZP = 7,
    MOS65XX_AM_ZP_X = 8,
    MOS65XX_AM_ZP_Y = 9,
    MOS65XX_AM_ZP_REL = 10,
    MOS65XX_AM_ZP_IND = 11,
    MOS65XX_AM_ZP_X_IND = 12,
    MOS65XX_AM_ZP_IND_Y = 13,
    MOS65XX_AM_ZP_IND_LONG = 14,
    MOS65XX_AM_ZP_IND_LONG_Y = 15,
    MOS65XX_AM_ABS = 16,
    MOS65XX_AM_ABS_X = 17,
    MOS65XX_AM_ABS_Y = 18,
    MOS65XX_AM_ABS_IND = 19,
    MOS65XX_AM_ABS_X_IND = 20,
    MOS65XX_AM_ABS_IND_LONG = 21,
    MOS65XX_AM_ABS_LONG = 22,
    MOS65XX_AM_ABS_LONG_X = 23,
    MOS65XX_AM_SR = 24,
    MOS65XX_AM_SR_IND_Y = 25,
}

MOS65XX Addressing Modes

Variants

MOS65XX_AM_NONE = 0

< No address mode.

MOS65XX_AM_IMP = 1

< implied addressing (no addressing mode)

MOS65XX_AM_ACC = 2

< accumulator addressing

MOS65XX_AM_IMM = 3

< 8/16 Bit immediate value

MOS65XX_AM_REL = 4

< relative addressing used by branches

MOS65XX_AM_INT = 5

< interrupt addressing

MOS65XX_AM_BLOCK = 6

< memory block addressing

MOS65XX_AM_ZP = 7

< zeropage addressing

MOS65XX_AM_ZP_X = 8

< indexed zeropage addressing by the X index register

MOS65XX_AM_ZP_Y = 9

< indexed zeropage addressing by the Y index register

MOS65XX_AM_ZP_REL = 10

< zero page address, branch relative address

MOS65XX_AM_ZP_IND = 11

< indirect zeropage addressing

MOS65XX_AM_ZP_X_IND = 12

< indexed zeropage indirect addressing by the X index register

MOS65XX_AM_ZP_IND_Y = 13

< indirect zeropage indexed addressing by the Y index register

MOS65XX_AM_ZP_IND_LONG = 14

< zeropage indirect long addressing

MOS65XX_AM_ZP_IND_LONG_Y = 15

< zeropage indirect long addressing indexed by Y register

MOS65XX_AM_ABS = 16

< absolute addressing

MOS65XX_AM_ABS_X = 17

< indexed absolute addressing by the X index register

MOS65XX_AM_ABS_Y = 18

< indexed absolute addressing by the Y index register

MOS65XX_AM_ABS_IND = 19

< absolute indirect addressing

MOS65XX_AM_ABS_X_IND = 20

< indexed absolute indirect addressing by the X index register

MOS65XX_AM_ABS_IND_LONG = 21

< absolute indirect long addressing

MOS65XX_AM_ABS_LONG = 22

< absolute long address mode

MOS65XX_AM_ABS_LONG_X = 23

< absolute long address mode, indexed by X register

MOS65XX_AM_SR = 24

< stack relative addressing

MOS65XX_AM_SR_IND_Y = 25

< indirect stack relative addressing indexed by the Y index register

Trait Implementations

impl Clone for mos65xx_address_mode

fn clone(&self) -> mos65xx_address_mode

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for mos65xx_address_mode

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

Formats the value using the given formatter.

impl Hash for mos65xx_address_mode

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 PartialEq for mos65xx_address_mode

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for mos65xx_address_mode

impl Eq for mos65xx_address_mode

impl StructuralPartialEq for mos65xx_address_mode