Struct resymgen::data_formats::symgen_yml::SymGen

pub struct SymGen(_);

A programmatic representation of the resymgen YAML format.

At its core, a SymGen is just a mapping between block names and Blocks, along with convenient methods for manipulating the data within those Blocks.

Implementations

impl SymGen

pub fn merge_symgen(&mut self, other: &Self) -> Result<(), MergeError>

Merges other into self.

pub fn merge_symbols<I>(&mut self, other: I) -> Result<Vec<Symbol>, MergeError>where
    I: Iterator<Item = AddSymbol>,

Merges other into self.

Returns a Vec<Symbol> containing symbols that were not successfully merged if no fatal error was encountered, or a MergeError if a fatal error was encountered.

impl SymGen

pub fn init(&mut self)

Initializes all the block names and Blocks within the SymGen.

pub fn read_no_init<R: Read>(rdr: R) -> Result<SymGen>

Reads an uninitialized SymGen from rdr.

pub fn read<R: Read>(rdr: R) -> Result<SymGen>

Reads a SymGen from rdr. The returned SymGen will be initialized.

pub fn read_sorted<R: Read>(rdr: R) -> Result<SymGen>

Reads a SymGen from rdr. The returned SymGen will be initialized and sorted.

Blocks and their contained Symbols are sorted by address. For version-dependent addresses, comparison is lexicographic in Version order.

pub fn write<W: Write>(&self, writer: W, int_format: IntFormat) -> Result<()>

Writes the SymGen data to writer in resymgen YAML format.

Integers will be written with the given int_format.

pub fn write_to_str(&self, int_format: IntFormat) -> Result<String>

Writes the SymGen data to a String in resymgen YAML format.

Integers will be written with the given int_format.

pub fn resolve_subregions<P, R, F>(
    &mut self,
    dir_path: P,
    file_opener: F
) -> Result<()>where
    P: AsRef<Path>,
    R: Read,
    F: Fn(&Path) -> Result<R> + Copy,

Recursively resolves the contents of all Subregions in all Blocks within the SymGen.

Subregions are read from files using file_opener, with file paths based on the root directory specified by dir_path.

pub fn collapse_subregions(&mut self)

Moves all symbols within Subregions into their parent Blocks’ main symbol lists, destroying the Subregions in the process.

pub fn expand_versions(&mut self)

Expands the versions of all the addresses and lengths contained within the SymGen (in all the contained Blocks).

See Block::expand_versions().

pub fn block_key(&self, block_name: &str) -> Option<&OrdString>

Gets a reference to the OrdString key in the SymGen corresponding to block_name, if present.

pub fn get(&self, key: &OrdString) -> Option<&Block>

Gets a reference to the Block associated with key, if present.

pub fn get_mut(&mut self, key: &OrdString) -> Option<&mut Block>

Gets a mutable reference to the Block associated with key, if present.

pub fn insert(&mut self, key: OrdString, value: Block) -> Option<Block>

Inserts the Block contained by value into the SymGen, keyed by key.

If the SymGen already had a Block keyed by key, the old Block is returned.

pub fn iter(&self) -> impl Iterator<Item = (&OrdString, &Block)>

Returns an Iterator over references to (block name, Block) pairs in the SymGen.

pub fn iter_mut(&mut self) -> impl Iterator<Item = (&OrdString, &mut Block)>

Returns an Iterator over mutable references to (block name, Block) pairs in the SymGen.

pub fn blocks(&self) -> impl Iterator<Item = &Block>

Returns an Iterator over references to Blocks in the SymGen.

pub fn blocks_mut(&mut self) -> impl Iterator<Item = &mut Block>

Returns an Iterator over mutable references to Blocks in the SymGen.

pub fn symbols(&self) -> impl Iterator<Item = &Symbol>

Returns a flat Iterator over references to the Symbols contained within every Block in the SymGen.

pub fn symbols_realized(
    &self,
    version_name: &str
) -> impl Iterator<Item = RealizedSymbol<'_>> + '_

Returns a flat Iterator over all symbols contained within every Block in the SymGen, realized for the Version corresponding to version_name.

pub fn functions_realized(
    &self,
    version_name: &str
) -> impl Iterator<Item = RealizedSymbol<'_>> + '_

Returns a flat Iterator over all function symbols contained within every Block in the SymGen, realized for the Version corresponding to version_name.

pub fn data_realized(
    &self,
    version_name: &str
) -> impl Iterator<Item = RealizedSymbol<'_>> + '_

Returns a flat Iterator over all data symbols contained within every Block in the SymGen, realized for the Version corresponding to version_name.

pub fn cursor<'s, 'p>(&'s self, path: &'p Path) -> SymGenCursor<'s, 'p>

Returns a SymGenCursor for this SymGen with the given file path.

Trait Implementations

impl Clone for SymGen

fn clone(&self) -> SymGen

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SymGen

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SymGen

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for SymGen

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

Formats the value using the given formatter.

impl<const N: usize> From<[(OrdString, Block); N]> for SymGen

fn from(arr: [(OrdString, Block); N]) -> Self

Converts to this type from the input type.

impl PartialEq<SymGen> for SymGen

fn eq(&self, other: &SymGen) -> 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 Serialize for SymGen

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl Sort for SymGen

fn sort(&mut self)

impl Eq for SymGen

impl StructuralEq for SymGen

impl StructuralPartialEq for SymGen