Enum Directive 

pub enum Directive {
    Byte,
    CSeg,
    CSegSize,
    Db,
    Def,
    Device,
    DSeg,
    Dw,
    EndM,
    EndMacro,
    Equ,
    ESeg,
    Exit,
    Include,
    IncludePath,
    List,
    ListMac,
    Macro,
    NoList,
    Org,
    Set,
    Define,
    Else,
    ElIf,
    Endif,
    Error,
    If,
    IfDef,
    IfNDef,
    Message,
    Dd,
    Dq,
    Undef,
    Warning,
    Overlap,
    NoOverlap,
    Pragma,
    Custom(String),
}

Variants

Byte

Reserve bytes for a variable in RAM

CSeg

Code segment

CSegSize

Program memory size for AT94K (unsupported)

Db

Define constant bytes in program memory and EEPROM

Def

Define a symbolic name on a register

Device

Device specific

DSeg

Data segment

Dw

Define constant words in program memory and EEPROM

EndM

End of macro define

EndMacro

Equ

Set a symbol equal to an expression

ESeg

EEPROM segment

Exit

Exit from file

Include

Read source from another file

IncludePath

Another path for includes

List

Turn listfile generation on (unsupported)

ListMac

Turn macro expansion in list file on (unsupported)

Macro

Begin macro

NoList

Turn listfile generation off (unsupported)

Org

Set program origin

Set

Set a symbol to an expression

Define

Define a preprocessor macro

Else

Conditional assembly - alternate branches

ElIf

Endif

Conditional assembly - end conditional block

Error

Outputs an error message

If

Conditional assembly - begin of conditional block

IfDef

IfNDef

Message

Outputs a message string

Dd

Define constant double words in program memory and EEPROM

Dq

Define constant quad words in program memory and EEPROM

Undef

Undefine register symbol

Warning

Outputs a warning message

Overlap

Set up/down overlapping section (unsupported)

NoOverlap

Pragma

Preprocessor pragmas

Custom(String)

For extend and macross support

Implementations

impl Directive

pub fn parse( &self, opts: &DirectiveOps, context: &ParseContext, point: CodePoint, ) -> Result<NextItem, Error>

Trait Implementations

impl Clone for Directive

fn clone(&self) -> Directive

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Directive

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

Formats the value using the given formatter.

impl Display for Directive

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

Formats the value using the given formatter.

impl FromStr for Directive

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Directive, <Self as FromStr>::Err>

Parses a string s to return a value of this type.

impl PartialEq for Directive

fn eq(&self, other: &Directive) -> 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 TryFrom<&str> for Directive

type Error = ParseError

The type returned in the event of a conversion error.

fn try_from(s: &str) -> Result<Directive, <Self as TryFrom<&str>>::Error>

Performs the conversion.

impl Eq for Directive

impl StructuralPartialEq for Directive