Struct lc3_ensemble::ast::Offset

pub struct Offset<OFF, const N: u32>(/* private fields */);

A value representing an offset or an immediate value.

The OFF type represents the backing type of this offset. The signedness of this offset type is dependent on the signedness of the OFF type:

• Offset<i16, _>: signed offset (also aliased as IOffset)
• Offset<u16, _>: unsigned offset

N indicates the maximum bit size of this offset/immediate value.

Examples

• Offset<i16, 5> is used to represent ADD/AND’s imm5 operand. See IOffset for more examples of its use.
• Offset<u16, 8> is used to represent the trapvect8 operand of the TRAP instruction. See TrapVect8 for more examples of its use.

Implementations

impl<OFF: OffsetBacking, const N: u32> Offset<OFF, N>

pub fn new(n: OFF) -> Result<Self, OffsetNewErr>

Creates a new offset value. This must fit within N bits of the representation, otherwise an error is raised.

Examples

// Signed:
let neg5 = Offset::<i16, 5>::new(-5);
let pos15 = Offset::<i16, 5>::new(15);
let pos16 = Offset::<i16, 5>::new(16);
assert!(neg5.is_ok());
assert!(pos15.is_ok());
assert!(pos16.is_err());
 
// Unsigned:
let pos15 = Offset::<u16, 5>::new(15);
let pos16 = Offset::<u16, 5>::new(16);
let pos32 = Offset::<u16, 5>::new(32);
assert!(pos15.is_ok());
assert!(pos16.is_ok());
assert!(pos32.is_err());

Panics

This will panic if N is larger than the offset backing (e.g., for backing u16, larger than 16).

let oh_no = Offset::<i16, 17>::new(18);

pub fn new_trunc(n: OFF) -> Self

Creates a new offset by extending the first N bits of the integer, and discarding the rest.

The extension is considered sign-extended if the offset’s backing is signed, and zero-extended if the offset’s backing is unsigned.

Examples

// Signed:
let neg5 = Offset::<i16, 5>::new_trunc(-5);  // 0b11111111111_11011
let pos15 = Offset::<i16, 5>::new_trunc(15); // 0b00000000000_01111
let pos16 = Offset::<i16, 5>::new_trunc(16); // 0b00000000000_10000
assert_eq!(neg5.get(),   -5); // 0b11011
assert_eq!(pos15.get(),  15); // 0b01111
assert_eq!(pos16.get(), -16); // 0b10000
 
// Unsigned:
let pos15 = Offset::<u16, 5>::new_trunc(15); // 0b00000000000_01111
let pos16 = Offset::<u16, 5>::new_trunc(16); // 0b00000000000_10000
let pos32 = Offset::<u16, 5>::new_trunc(32); // 0b00000000001_00000
assert_eq!(pos15.get(), 15); // 01111
assert_eq!(pos16.get(), 16); // 10000
assert_eq!(pos32.get(),  0); // 00000

Panics

This will panic if N is larger than the offset backing (e.g., for backing u16, larger than 16).

let oh_no = Offset::<i16, 17>::new_trunc(18);

pub fn get(&self) -> OFF

Gets the value of the offset.

Trait Implementations

impl<OFF: Binary, const N: u32> Binary for Offset<OFF, N>

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

Formats the value using the given formatter.

impl<OFF: Clone, const N: u32> Clone for Offset<OFF, N>

fn clone(&self) -> Offset<OFF, N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<OFF: Debug, const N: u32> Debug for Offset<OFF, N>

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

Formats the value using the given formatter.

impl<OFF: Display, const N: u32> Display for Offset<OFF, N>

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

Formats the value using the given formatter.

impl<OFF: Hash, const N: u32> Hash for Offset<OFF, N>

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<OFF: LowerHex, const N: u32> LowerHex for Offset<OFF, N>

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

Formats the value using the given formatter.

impl<OFF: PartialEq, const N: u32> PartialEq for Offset<OFF, N>

fn eq(&self, other: &Offset<OFF, N>) -> 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<const N: u32> TokenParse for Offset<i16, N>

type Intermediate = Either<i16, u16>

An intermediate to hold the match before it is converted to the actual component.

fn match_( m_token: Option<&Token>, span: Span, ) -> Result<Self::Intermediate, ParseErr>

Tries to match the next token to the given component, if possible.

fn convert(imed: Self::Intermediate, span: Span) -> Result<Self, ParseErr>

Parses the intermediate into the given component, raising an error if conversion fails.

impl<const N: u32> TokenParse for Offset<u16, N>

type Intermediate = Either<u16, i16>

An intermediate to hold the match before it is converted to the actual component.

fn match_( m_token: Option<&Token>, span: Span, ) -> Result<Self::Intermediate, ParseErr>

Tries to match the next token to the given component, if possible.

fn convert(imed: Self::Intermediate, span: Span) -> Result<Self, ParseErr>

Parses the intermediate into the given component, raising an error if conversion fails.

impl<OFF: UpperHex, const N: u32> UpperHex for Offset<OFF, N>

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

Formats the value using the given formatter.

impl<OFF: Copy, const N: u32> Copy for Offset<OFF, N>

impl<OFF: Eq, const N: u32> Eq for Offset<OFF, N>

impl<OFF, const N: u32> StructuralPartialEq for Offset<OFF, N>