Enum pir_8_emu::binutils::pir_8_as::AssemblerDirective

pub enum AssemblerDirective<'s> {
    SetOrigin(u16),
    SaveLabel(&'s str),
    LoadLabel(&'s str, i16, LabelFragment),
    InsertLiteral(&'s str),
}

An assembler directive, extending the normal assembly syntax

Variants

SetOrigin(u16)

Start writing the code at the specified address, 0-padding thereupto

Using this directive the second time or after processing an instruction is an error

Syntax: :origin [address]

SaveLabel(&'s str)

Save the current output address to recall later

Syntax: :label save [name]

LoadLabel(&'s str, i16, LabelFragment)

Load the specified part of the label with the specified name, or wait for it to be saved later, adding the specified offset

Not having saved all previously loaded labels by the end of input is an error

Attempting to load a full label when the current instruction doesn't expect 2-byte data is an error, and attempting to load a partial label when the current instruction doesn't expect 1-byte data is an error.

Syntax: :label load [full|high|low] [name]

Syntax: :label load-offset [full|high|low] [name] [offset]

InsertLiteral(&'s str)

Blindly write the specified literal

Attempting to insert a literal when the current instruction is expecting data is an error

Syntax: :literal "UwU"

Methods

impl<'s> AssemblerDirective<'s>

pub fn from_str(s: &'s str) -> Result<Option<Self>, ParseInstructionError>

Parse a directive as found among other assembly

If the specified string doesn't start with a colon, Ok(None) is returned

Examples

assert_eq!(AssemblerDirective::from_str(":origin 0x0110"),
           Ok(Some(AssemblerDirective::SetOrigin(0x0110))));

assert_eq!(AssemblerDirective::from_str(": label load full OwO"),
           Ok(Some(AssemblerDirective::LoadLabel("OwO", 0, LabelFragment::Full))));

assert_eq!(AssemblerDirective::from_str(": label load-offset high OwO -1"),
           Ok(Some(AssemblerDirective::LoadLabel("OwO", -1, LabelFragment::High))));

assert_eq!(AssemblerDirective::from_str("label save uwu"),
           Ok(None));

pub fn obey(
    &self,
    next_output_address: &mut Option<u16>,
    labels: &mut BTreeMap<String, u16>
) -> Result<Option<Result<LabelLoad, &'s str>>, AssemblerDirectiveObeyError<'s>>

Obey this directive, updating the output address and labelset as required

Examples

let mut next_output_address = None;
let mut labels = BTreeMap::new();

assert_eq!(AssemblerDirective::SetOrigin(0x0110)
               .obey(&mut next_output_address, &mut labels),
           Ok(None));

assert_eq!(AssemblerDirective::LoadLabel("owo", 0, LabelFragment::Full)
               .obey(&mut next_output_address, &mut labels),
           Ok(Some(Ok(LabelLoad::WaitFor("owo".to_string(), 0, LabelFragment::Full)))));
assert_eq!(AssemblerDirective::SaveLabel("owo")
               .obey(&mut next_output_address, &mut labels),
           Ok(None));
assert_eq!(AssemblerDirective::LoadLabel("owo", 0, LabelFragment::High)
               .obey(&mut next_output_address, &mut labels),
           Ok(Some(Ok(LabelLoad::HaveImmediately(0x0110, LabelFragment::High)))));
assert_eq!(AssemblerDirective::LoadLabel("owo", 0x0F, LabelFragment::Low)
               .obey(&mut next_output_address, &mut labels),
           Ok(Some(Ok(LabelLoad::HaveImmediately(0x011F, LabelFragment::Low)))));

assert_eq!(AssemblerDirective::InsertLiteral("EwE")
               .obey(&mut next_output_address, &mut labels),
           Ok(Some(Err("EwE"))));

assert_eq!(next_output_address, Some(0x0110));
assert_eq!(labels, vec![("owo".to_string(), 0x0110)].into_iter().collect());

Trait Implementations

impl<'s> Clone for AssemblerDirective<'s>

fn clone(&self) -> AssemblerDirective<'s>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'s> Copy for AssemblerDirective<'s>

impl<'s> Debug for AssemblerDirective<'s>

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

Formats the value using the given formatter.

impl<'s> Eq for AssemblerDirective<'s>

impl<'s> Hash for AssemblerDirective<'s>

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, 

Feeds a slice of this type into the given [Hasher].

impl<'s> Ord for AssemblerDirective<'s>

fn cmp(&self, other: &AssemblerDirective<'s>) -> Ordering

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

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

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<'s> PartialEq<AssemblerDirective<'s>> for AssemblerDirective<'s>

fn eq(&self, other: &AssemblerDirective<'s>) -> bool

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

fn ne(&self, other: &AssemblerDirective<'s>) -> bool

This method tests for !=.

impl<'s> PartialOrd<AssemblerDirective<'s>> for AssemblerDirective<'s>

fn partial_cmp(&self, other: &AssemblerDirective<'s>) -> Option<Ordering>

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

fn lt(&self, other: &AssemblerDirective<'s>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &AssemblerDirective<'s>) -> bool

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

fn gt(&self, other: &AssemblerDirective<'s>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &AssemblerDirective<'s>) -> bool

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

impl<'s> StructuralEq for AssemblerDirective<'s>

impl<'s> StructuralPartialEq for AssemblerDirective<'s>