[−][src]Enum ggbasm::ast::Instruction

pub enum Instruction {
    EmptyLine,
    AdvanceAddress(u16),
    Equ(String, Expr),
    Label(String),
    Db(Vec<u8>),
    DbExpr8(Expr),
    DbExpr16(Expr),
    Nop,
    Stop,
    Halt,
    Di,
    Ei,
    Rrca,
    Rra,
    Cpl,
    Ccf,
    Rlca,
    Rla,
    Daa,
    Scf,
    Ret(Flag),
    Reti,
    Call(Flag, Expr),
    JpI16(Flag, Expr),
    JpRhl,
    Jr(Flag, Expr),
    IncR16(Reg16),
    IncR8(Reg8),
    IncMRhl,
    DecR16(Reg16),
    DecR8(Reg8),
    DecMRhl,
    AddR8(Reg8),
    AddMRhl,
    AddI8(Expr),
    AddRhlR16(Reg16),
    AddRspI8(Expr),
    SubR8(Reg8),
    SubMRhl,
    SubI8(Expr),
    AndR8(Reg8),
    AndMRhl,
    AndI8(Expr),
    OrR8(Reg8),
    OrMRhl,
    OrI8(Expr),
    AdcR8(Reg8),
    AdcMRhl,
    AdcI8(Expr),
    SbcR8(Reg8),
    SbcMRhl,
    SbcI8(Expr),
    XorR8(Reg8),
    XorMRhl,
    XorI8(Expr),
    CpR8(Reg8),
    CpMRhl,
    CpI8(Expr),
    LdR16I16(Reg16, Expr),
    LdMI16Rsp(Expr),
    LdMRbcRa,
    LdMRdeRa,
    LdRaMRbc,
    LdRaMRde,
    LdR8R8(Reg8, Reg8),
    LdR8I8(Reg8, Expr),
    LdR8MRhl(Reg8),
    LdMRhlR8(Reg8),
    LdMRhlI8(Expr),
    LdMI16Ra(Expr),
    LdRaMI16(Expr),
    LdhRaMI8(Expr),
    LdhMI8Ra(Expr),
    LdhRaMRc,
    LdhMRcRa,
    LdiMRhlRa,
    LddMRhlRa,
    LdiRaMRhl,
    LddRaMRhl,
    LdRhlRspI8(Expr),
    LdRspRhl,
    Push(Reg16Push),
    Pop(Reg16Push),
    RlcR8(Reg8),
    RlcMRhl,
    RrcR8(Reg8),
    RrcMRhl,
    RlR8(Reg8),
    RlMRhl,
    RrR8(Reg8),
    RrMRhl,
    SlaR8(Reg8),
    SlaMRhl,
    SraR8(Reg8),
    SraMRhl,
    SwapR8(Reg8),
    SwapMRhl,
    SrlR8(Reg8),
    SrlMRhl,
    BitBitR8(Expr, Reg8),
    BitBitMRhl(Expr),
    ResBitR8(Expr, Reg8),
    ResBitMRhl(Expr),
    SetBitR8(Expr, Reg8),
    SetBitMRhl(Expr),
}

The main type in the AST, the parser creates an Instruction for each line in a *.asm

Key:

R16 - 16 bit register
R8 - 8 bit register
Rhl - the hl register
Ra - the a register
MR16 - 8 bit value in memory pointed at by a 16 bit register
MRhl - 8 bit value in memory pointed at by the HL register
MRc - 8 bit value in memory pointed at by 0xFF + the register C
I8 - immediate 8 bit value
I16 - immediate 16 bit value
Bit - an index to a bit

Variants

EmptyLine

Keeping track of empty lines makes it easier to refer errors back to a line number

AdvanceAddress(u16)

the address within the current ROM bank

Equ(String, Expr)

Label(String)

Db(Vec<u8>)

DbExpr8(Expr)

DbExpr16(Expr)

Nop

Stop

Halt

Di

Ei

Rrca

Rra

Cpl

Ccf

Rlca

Rla

Daa

Scf

Ret(Flag)

Reti

Call(Flag, Expr)

JpI16(Flag, Expr)

JpRhl

Jr(Flag, Expr)

IncR16(Reg16)

IncR8(Reg8)

IncMRhl

DecR16(Reg16)

DecR8(Reg8)

DecMRhl

AddR8(Reg8)

AddMRhl

AddI8(Expr)

AddRhlR16(Reg16)

AddRspI8(Expr)

SubR8(Reg8)

SubMRhl

SubI8(Expr)

AndR8(Reg8)

AndMRhl

AndI8(Expr)

OrR8(Reg8)

OrMRhl

OrI8(Expr)

AdcR8(Reg8)

AdcMRhl

AdcI8(Expr)

SbcR8(Reg8)

SbcMRhl

SbcI8(Expr)

XorR8(Reg8)

XorMRhl

XorI8(Expr)

CpR8(Reg8)

CpMRhl

CpI8(Expr)

LdR16I16(Reg16, Expr)

LdMI16Rsp(Expr)

LdMRbcRa

LdMRdeRa

LdRaMRbc

LdRaMRde

LdR8R8(Reg8, Reg8)

LdR8I8(Reg8, Expr)

LdR8MRhl(Reg8)

LdMRhlR8(Reg8)

LdMRhlI8(Expr)

LdMI16Ra(Expr)

LdRaMI16(Expr)

LdhRaMI8(Expr)

LdhMI8Ra(Expr)

LdhRaMRc

LdhMRcRa

LdiMRhlRa

LddMRhlRa

LdiRaMRhl

LddRaMRhl

LdRhlRspI8(Expr)

LdRspRhl

Push(Reg16Push)

Pop(Reg16Push)

RlcR8(Reg8)

RlcMRhl

RrcR8(Reg8)

RrcMRhl

RlR8(Reg8)

RlMRhl

RrR8(Reg8)

RrMRhl

SlaR8(Reg8)

SlaMRhl

SraR8(Reg8)

SraMRhl

SwapR8(Reg8)

SwapMRhl

SrlR8(Reg8)

SrlMRhl

BitBitR8(Expr, Reg8)

BitBitMRhl(Expr)

ResBitR8(Expr, Reg8)

ResBitMRhl(Expr)

SetBitR8(Expr, Reg8)

SetBitMRhl(Expr)

Implementations

`impl Instruction`[src]

`pub fn write_to_rom( &self, rom: &mut Vec<u8>, constants: &HashMap<String, i64> ) -> Result<(), Error>`[src]

Writes the instructions bytes to the passed rom. If an expr in the instruction uses an identifier than it looks up the value for it in constants. Will return Err if constants doesn't contain the required label.

`pub fn len(&self, start_address: u16) -> u16`[src]

Returns how many bytes the instruction takes up

Trait Implementations

`impl Clone for Instruction`[src]

`pub fn clone(&self) -> Instruction`[src]

`pub fn clone_from(&mut self, source: &Self)`1.0.0[src]

`impl Debug for Instruction`[src]

`pub fn fmt(&self, f: &mut Formatter<'_>) -> Result`[src]

`impl PartialEq<Instruction> for Instruction`[src]

`pub fn eq(&self, other: &Instruction) -> bool`[src]

`pub fn ne(&self, other: &Instruction) -> bool`[src]

`impl StructuralPartialEq for Instruction`[src]

Auto Trait Implementations

`impl RefUnwindSafe for Instruction`[src]

`impl Send for Instruction`[src]

`impl Sync for Instruction`[src]

`impl Unpin for Instruction`[src]

`impl UnwindSafe for Instruction`[src]

Blanket Implementations

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`pub fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`pub fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`pub fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T> Conv for T`

`pub fn conv<T>(self) -> T where Self: Into<T>,`

`impl<T> Conv for T`

`pub fn conv<T>(self) -> T where Self: Into<T>,`

`impl<T> FmtForward for T`

`pub fn fmt_binary(self) -> FmtBinary<Self> where Self: Binary,`

`pub fn fmt_display(self) -> FmtDisplay<Self> where Self: Display,`

`pub fn fmt_lower_exp(self) -> FmtLowerExp<Self> where Self: LowerExp,`

`pub fn fmt_lower_hex(self) -> FmtLowerHex<Self> where Self: LowerHex,`

`pub fn fmt_octal(self) -> FmtOctal<Self> where Self: Octal,`

`pub fn fmt_pointer(self) -> FmtPointer<Self> where Self: Pointer,`

`pub fn fmt_upper_exp(self) -> FmtUpperExp<Self> where Self: UpperExp,`

`pub fn fmt_upper_hex(self) -> FmtUpperHex<Self> where Self: UpperHex,`

`impl<T> From<T> for T`[src]

`pub fn from(t: T) -> T`[src]

`impl<T, U> Into for T where U: From<T>,` [src]

`pub fn into(self) -> U`[src]

`impl<T> Pipe for T where T: ?Sized,`

`pub fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R`

`pub fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where R: 'a,`

`pub fn pipe_ref_mut<'a, R>( &'a mut self, func: impl FnOnce(&'a mut Self) -> R ) -> R where R: 'a,`

`pub fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R where Self: Borrow, B: 'a + ?Sized, R: 'a,`

`pub fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R ) -> R where Self: BorrowMut, B: 'a + ?Sized, R: 'a,`

`pub fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R where Self: AsRef, U: 'a + ?Sized, R: 'a,`

`pub fn pipe_as_mut<'a, U, R>( &'a mut self, func: impl FnOnce(&'a mut U) -> R ) -> R where Self: AsMut, U: 'a + ?Sized, R: 'a,`

`pub fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,`

`pub fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R ) -> R where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,`

`impl<T> Pipe for T`

`pub fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R`

`impl<T> PipeAsRef for T`

`pub fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where Self: AsRef<T>, T: 'a, R: 'a,`

`pub fn pipe_as_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R ) -> R where Self: AsMut<T>, T: 'a, R: 'a,`

`impl<T> PipeBorrow for T`

`pub fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where Self: Borrow<T>, T: 'a, R: 'a,`

`pub fn pipe_borrow_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R ) -> R where Self: BorrowMut<T>, T: 'a, R: 'a,`

`impl<T> PipeDeref for T`

`pub fn pipe_deref<'a, R>( &'a self, func: impl FnOnce(&'a Self::Target) -> R ) -> R where Self: Deref, R: 'a,`

`pub fn pipe_deref_mut<'a, R>( &'a mut self, func: impl FnOnce(&'a mut Self::Target) -> R ) -> R where Self: DerefMut, R: 'a,`

`impl<T> PipeRef for T`

`pub fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where R: 'a,`

`pub fn pipe_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where R: 'a,`

`impl<T> Pointable for T`

`pub const ALIGN: usize`

`type Init = T`

The type for initializers.

`pub unsafe fn init(init: <T as Pointable>::Init) -> usize`

`pub unsafe fn deref<'a>(ptr: usize) -> &'a T`

`pub unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T`

`pub unsafe fn drop(ptr: usize)`

`impl<T> Tap for T`

`pub fn tap(self, func: impl FnOnce(&Self)) -> Self`

`pub fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self`

`pub fn tap_borrow(self, func: impl FnOnce(&B)) -> Self where Self: Borrow, B: ?Sized,`

`pub fn tap_borrow_mut(self, func: impl FnOnce(&mut B)) -> Self where Self: BorrowMut, B: ?Sized,`

`pub fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self where Self: AsRef<R>, R: ?Sized,`

`pub fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self where Self: AsMut<R>, R: ?Sized,`

`pub fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self where Self: Deref<Target = T>, T: ?Sized,`

`pub fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self where Self: DerefMut<Target = T> + Deref, T: ?Sized,`

`pub fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self`

`pub fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self`

`pub fn tap_borrow_dbg(self, func: impl FnOnce(&B)) -> Self where Self: Borrow, B: ?Sized,`

`pub fn tap_borrow_mut_dbg(self, func: impl FnOnce(&mut B)) -> Self where Self: BorrowMut, B: ?Sized,`

`pub fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self where Self: AsRef<R>, R: ?Sized,`

`pub fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self where Self: AsMut<R>, R: ?Sized,`

`pub fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self where Self: Deref<Target = T>, T: ?Sized,`

`pub fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self where Self: DerefMut<Target = T> + Deref, T: ?Sized,`

`impl<T> Tap for T`

`pub fn tap<F, R>(self, func: F) -> Self where F: FnOnce(&Self) -> R,`

`pub fn tap_dbg<F, R>(self, func: F) -> Self where F: FnOnce(&Self) -> R,`

`pub fn tap_mut<F, R>(self, func: F) -> Self where F: FnOnce(&mut Self) -> R,`

`pub fn tap_mut_dbg<F, R>(self, func: F) -> Self where F: FnOnce(&mut Self) -> R,`

`impl<T, U> TapAsRef for T where U: ?Sized,`

`pub fn tap_ref<F, R>(self, func: F) -> Self where Self: AsRef<T>, F: FnOnce(&T) -> R,`

`pub fn tap_ref_dbg<F, R>(self, func: F) -> Self where Self: AsRef<T>, F: FnOnce(&T) -> R,`

`pub fn tap_ref_mut<F, R>(self, func: F) -> Self where Self: AsMut<T>, F: FnOnce(&mut T) -> R,`

`pub fn tap_ref_mut_dbg<F, R>(self, func: F) -> Self where Self: AsMut<T>, F: FnOnce(&mut T) -> R,`

`impl<T, U> TapBorrow for T where U: ?Sized,`

`pub fn tap_borrow<F, R>(self, func: F) -> Self where Self: Borrow<T>, F: FnOnce(&T) -> R,`

`pub fn tap_borrow_dbg<F, R>(self, func: F) -> Self where Self: Borrow<T>, F: FnOnce(&T) -> R,`

`pub fn tap_borrow_mut<F, R>(self, func: F) -> Self where Self: BorrowMut<T>, F: FnOnce(&mut T) -> R,`

`pub fn tap_borrow_mut_dbg<F, R>(self, func: F) -> Self where Self: BorrowMut<T>, F: FnOnce(&mut T) -> R,`

`impl<T> TapDeref for T`

`pub fn tap_deref<F, R>(self, func: F) -> Self where Self: Deref, F: FnOnce(&Self::Target) -> R,`

`pub fn tap_deref_dbg<F, R>(self, func: F) -> Self where Self: Deref, F: FnOnce(&Self::Target) -> R,`

`pub fn tap_deref_mut<F, R>(self, func: F) -> Self where Self: DerefMut, F: FnOnce(&mut Self::Target) -> R,`

`pub fn tap_deref_mut_dbg<F, R>(self, func: F) -> Self where Self: DerefMut, F: FnOnce(&mut Self::Target) -> R,`

`impl<T> ToOwned for T where T: Clone,` [src]

`type Owned = T`

The resulting type after obtaining ownership.

`pub fn to_owned(&self) -> T`[src]

`pub fn clone_into(&self, target: &mut T)`[src]

`impl<T> TryConv for T`

`pub fn try_conv<T>(self) -> Result<T, Self::Error> where Self: TryInto<T>,`

`impl<T> TryConv for T`

`pub fn try_conv<T>(self) -> Result<T, Self::Error> where Self: TryInto<T>,`

`impl<T, U> TryFrom for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`pub fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>`[src]

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = >::Error`

The type returned in the event of a conversion error.

[−][src]Enum ggbasm::ast::Instruction

Variants

Implementations

impl Instruction[src]

pub fn write_to_rom( &self, rom: &mut Vec<u8>, constants: &HashMap<String, i64>) -> Result<(), Error>[src]

pub fn len(&self, start_address: u16) -> u16[src]

Trait Implementations

impl Clone for Instruction[src]

pub fn clone(&self) -> Instruction[src]

pub fn clone_from(&mut self, source: &Self)1.0.0[src]

impl Debug for Instruction[src]

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

impl PartialEq<Instruction> for Instruction[src]

pub fn eq(&self, other: &Instruction) -> bool[src]

pub fn ne(&self, other: &Instruction) -> bool[src]

impl StructuralPartialEq for Instruction[src]

Auto Trait Implementations

impl RefUnwindSafe for Instruction[src]

impl Send for Instruction[src]

impl Sync for Instruction[src]

impl Unpin for Instruction[src]

impl UnwindSafe for Instruction[src]

Blanket Implementations

impl<T> Any for T where T: 'static + ?Sized, [src]

pub fn type_id(&self) -> TypeId[src]

impl<T> Borrow<T> for T where T: ?Sized, [src]

pub fn borrow(&self) -> &T[src]

impl<T> BorrowMut<T> for T where T: ?Sized, [src]

pub fn borrow_mut(&mut self) -> &mut T[src]

impl<T> Conv for T

pub fn conv<T>(self) -> T where Self: Into<T>,

impl<T> Conv for T

pub fn conv<T>(self) -> T where Self: Into<T>,

impl<T> FmtForward for T

pub fn fmt_binary(self) -> FmtBinary<Self> where Self: Binary,

pub fn fmt_display(self) -> FmtDisplay<Self> where Self: Display,

pub fn fmt_lower_exp(self) -> FmtLowerExp<Self> where Self: LowerExp,

pub fn fmt_lower_hex(self) -> FmtLowerHex<Self> where Self: LowerHex,

pub fn fmt_octal(self) -> FmtOctal<Self> where Self: Octal,

pub fn fmt_pointer(self) -> FmtPointer<Self> where Self: Pointer,

pub fn fmt_upper_exp(self) -> FmtUpperExp<Self> where Self: UpperExp,

pub fn fmt_upper_hex(self) -> FmtUpperHex<Self> where Self: UpperHex,

impl<T> From<T> for T[src]

pub fn from(t: T) -> T[src]

impl<T, U> Into<U> for T where U: From<T>, [src]

pub fn into(self) -> U[src]

impl<T> Pipe for T where T: ?Sized,

pub fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R

pub fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where R: 'a,

pub fn pipe_ref_mut<'a, R>( &'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where R: 'a,

pub fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

pub fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R) -> R where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

pub fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

pub fn pipe_as_mut<'a, U, R>( &'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

pub fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

pub fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R) -> R where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

impl<T> Pipe for T

pub fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R

impl<T> PipeAsRef for T

pub fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where Self: AsRef<T>, T: 'a, R: 'a,

pub fn pipe_as_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R) -> R where Self: AsMut<T>, T: 'a, R: 'a,

impl<T> PipeBorrow for T

pub fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where Self: Borrow<T>, T: 'a, R: 'a,

pub fn pipe_borrow_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R) -> R where Self: BorrowMut<T>, T: 'a, R: 'a,

impl<T> PipeDeref for T

pub fn pipe_deref<'a, R>( &'a self, func: impl FnOnce(&'a Self::Target) -> R) -> R where Self: Deref, R: 'a,

pub fn pipe_deref_mut<'a, R>( &'a mut self, func: impl FnOnce(&'a mut Self::Target) -> R) -> R where Self: DerefMut, R: 'a,

impl<T> PipeRef for T

pub fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where R: 'a,

pub fn pipe_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where R: 'a,

impl<T> Pointable for T

pub const ALIGN: usize

type Init = T

pub unsafe fn init(init: <T as Pointable>::Init) -> usize

pub unsafe fn deref<'a>(ptr: usize) -> &'a T

pub unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

pub unsafe fn drop(ptr: usize)

impl<T> Tap for T

pub fn tap(self, func: impl FnOnce(&Self)) -> Self

pub fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

`impl Instruction`[src]

`pub fn write_to_rom( &self, rom: &mut Vec<u8>, constants: &HashMap<String, i64> ) -> Result<(), Error>`[src]

`pub fn len(&self, start_address: u16) -> u16`[src]

`impl Clone for Instruction`[src]

`pub fn clone(&self) -> Instruction`[src]

`pub fn clone_from(&mut self, source: &Self)`1.0.0[src]

`impl Debug for Instruction`[src]

`pub fn fmt(&self, f: &mut Formatter<'_>) -> Result`[src]

`impl PartialEq<Instruction> for Instruction`[src]

`pub fn eq(&self, other: &Instruction) -> bool`[src]

`pub fn ne(&self, other: &Instruction) -> bool`[src]

`impl StructuralPartialEq for Instruction`[src]

`impl RefUnwindSafe for Instruction`[src]

`impl Send for Instruction`[src]

`impl Sync for Instruction`[src]

`impl Unpin for Instruction`[src]

`impl UnwindSafe for Instruction`[src]

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`pub fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`pub fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`pub fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T> Conv for T`

`pub fn conv<T>(self) -> T where Self: Into<T>,`

`impl<T> Conv for T`

`pub fn conv<T>(self) -> T where Self: Into<T>,`

`impl<T> FmtForward for T`

`pub fn fmt_binary(self) -> FmtBinary<Self> where Self: Binary,`

`pub fn fmt_display(self) -> FmtDisplay<Self> where Self: Display,`

`pub fn fmt_lower_exp(self) -> FmtLowerExp<Self> where Self: LowerExp,`

`pub fn fmt_lower_hex(self) -> FmtLowerHex<Self> where Self: LowerHex,`

`pub fn fmt_octal(self) -> FmtOctal<Self> where Self: Octal,`

`pub fn fmt_pointer(self) -> FmtPointer<Self> where Self: Pointer,`

`pub fn fmt_upper_exp(self) -> FmtUpperExp<Self> where Self: UpperExp,`

`pub fn fmt_upper_hex(self) -> FmtUpperHex<Self> where Self: UpperHex,`

`impl<T> From<T> for T`[src]

`pub fn from(t: T) -> T`[src]

`impl<T, U> Into<U> for T where U: From<T>,` [src]

`pub fn into(self) -> U`[src]

`impl<T> Pipe for T where T: ?Sized,`

`pub fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R`

`pub fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where R: 'a,`

`pub fn pipe_ref_mut<'a, R>( &'a mut self, func: impl FnOnce(&'a mut Self) -> R ) -> R where R: 'a,`

`pub fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,`

`pub fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R ) -> R where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,`

`pub fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,`

`pub fn pipe_as_mut<'a, U, R>( &'a mut self, func: impl FnOnce(&'a mut U) -> R ) -> R where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,`

`pub fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,`

`pub fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R ) -> R where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,`

`impl<T> Pipe for T`

`pub fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R`

`impl<T> PipeAsRef for T`

`pub fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where Self: AsRef<T>, T: 'a, R: 'a,`

`pub fn pipe_as_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R ) -> R where Self: AsMut<T>, T: 'a, R: 'a,`

`impl<T> PipeBorrow for T`

`pub fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where Self: Borrow<T>, T: 'a, R: 'a,`

`pub fn pipe_borrow_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R ) -> R where Self: BorrowMut<T>, T: 'a, R: 'a,`

`impl<T> PipeDeref for T`

`pub fn pipe_deref<'a, R>( &'a self, func: impl FnOnce(&'a Self::Target) -> R ) -> R where Self: Deref, R: 'a,`

`pub fn pipe_deref_mut<'a, R>( &'a mut self, func: impl FnOnce(&'a mut Self::Target) -> R ) -> R where Self: DerefMut, R: 'a,`

`impl<T> PipeRef for T`

`pub fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where R: 'a,`

`pub fn pipe_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where R: 'a,`

`impl<T> Pointable for T`

`pub const ALIGN: usize`

`type Init = T`

`pub unsafe fn init(init: <T as Pointable>::Init) -> usize`

`pub unsafe fn deref<'a>(ptr: usize) -> &'a T`

`pub unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T`

`pub unsafe fn drop(ptr: usize)`

`impl<T> Tap for T`

`pub fn tap(self, func: impl FnOnce(&Self)) -> Self`

`pub fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self`

`pub fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self where Self: Borrow<B>, B: ?Sized,`

`pub fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self where Self: BorrowMut<B>, B: ?Sized,`

`pub fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self where Self: AsRef<R>, R: ?Sized,`

`pub fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self where Self: AsMut<R>, R: ?Sized,`

`pub fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self where Self: Deref<Target = T>, T: ?Sized,`

`pub fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self where Self: DerefMut<Target = T> + Deref, T: ?Sized,`