Struct PreprocessorState 

pub struct PreprocessorState<'a> {
    pub includes: Vec<&'a Path>,
    pub defines: Vec<Define<'a>>,
    pub timescales: Vec<Timescale<'a>>,
    pub default_nettypes: Vec<(DefaultNettype, Span<'a>)>,
    pub unconnected_drives: Vec<(UnconnectedDrive, Span<'a>)>,
    pub cell_defines: Vec<(bool, Span<'a>)>,
    pub line_directives: Vec<LineDirective<'a>>,
    pub included_files: HashMap<&'a str, &'a str>,
    pub curr_standard: StandardVersion,
    pub warnings: Vec<PreprocessorWarning<'a>>,
    /* private fields */
}

The current state of the preprocessor

The preprocessor has to keep track of various directives and how they affect later preprocessing. A PreprocessorState encapsulates all of this.

This is primarily meant to be used in the preprocessor, but can be examined afterwards to glean extra information, such as which files were included.

Fields

includes: Vec<&'a Path>

The include paths to search for included files

defines: Vec<Define<'a>>

The preprocessor definitions

timescales: Vec<Timescale<'a>>

Any timescales declared with `timescale

default_nettypes: Vec<(DefaultNettype, Span<'a>)>

Default nettypes declared with `default_nettype

unconnected_drives: Vec<(UnconnectedDrive, Span<'a>)>

Unconnected drives declared with `unconnected_drive or `nounconnected_drive

cell_defines: Vec<(bool, Span<'a>)>

Cell definitions from `celldefine and `endcelldefine

line_directives: Vec<LineDirective<'a>>

Line directives declared with `line

included_files: HashMap<&'a str, &'a str>

The contents of included files (file_name -> content)

curr_standard: StandardVersion

The current standard for reserved keywords

warnings: Vec<PreprocessorWarning<'a>>

Any warnings encountered so far

Implementations

impl<'a> PreprocessorState<'a>

pub fn new(includes: Vec<&'a Path>, defines: Vec<Define<'a>>) -> Self

Create a new PreprocessorState

pub fn make_fresh(&mut self, defines: Vec<Define<'a>>)

Make the PreprocessorState fresh, as though it had just started preprocessing

This retains all files that were read in, avoiding reading in their contents again

pub fn reset_all(&mut self, reset_all_span: Span<'a>)

Reset all resetable configs

This is called when a `resetall is encountered

pub fn is_defined(&self, macro_name: &'a str) -> bool

Check whether the given macro is defined

pub fn get_define_decl(&self, macro_name: &'a str) -> Option<Span<'a>>

Get the definition span for a macro, if it’s been defined

pub fn in_define(&self) -> bool

Whether we’re currently preprocessing a definition

pub fn in_define_arg(&self) -> bool

Whether we’re currently preprocessing a definition argument

pub fn undefine(&mut self, macro_name: &'a str) -> bool

Remove a given macro, evaluating to whether a macro was removed

This is called when a `undef is encountered

pub fn define( &mut self, macro_name: &'a str, macro_span: Span<'a>, macro_body: DefineBody<'a>, )

Define a new macro

This is called when a `define is encountered, and assumes that any previous definitions were removed with PreprocessorState::undefine

pub fn command_line_define( &mut self, macro_name: &'a str, macro_text: Option<Vec<SpannedToken<'a>>>, )

Define a new macro from the command line

This is similar to PreprocessorState::define, but uses a Span with no file name

pub fn undefineall(&mut self)

Undefine all macros

This is called when a `undefineall is encountered

pub fn get_macro_tokens( &self, macro_name: &'a str, ) -> Option<(Span<'a>, (Vec<SpannedToken<'a>>, Option<Vec<(SpannedString<'a>, Option<Vec<SpannedToken<'a>>>)>>))>

Get the (Span, DefineBody::get_tokens) for a text macro, if it exists

pub fn get_file_path(&self, include_path: &str) -> Option<PathBuf>

Get the full path from an `include statement

pub fn add_timescale(&mut self, timescale: Timescale<'a>)

Add a compiler directive timescale

This is called when a `timescale is encountered

pub fn get_timescale(&self, span: &Span<'a>) -> &Timescale<'a>

Get the correct compiler timescale, based on the Span where a delay is encountered

pub fn add_default_nettype( &mut self, def_span: Span<'a>, default_nettype: DefaultNettype, )

Add a compiler directive default nettype

This is called when a `default_nettype is encountered

pub fn get_default_nettype(&self, span: &Span<'a>) -> &DefaultNettype

Get the correct compiler default nettype, based on the Span where an implicit nettype is needed

pub fn retain_file( &mut self, file_path: String, file_contents: String, cache: &'a PreprocessorCache<'a>, ) -> (&'a str, &'a str)

Retain the contents of a file

Produces (&file_path, &file_contents) as references to the cached passed arguments

pub fn included_files(&self) -> Vec<(String, String)>

Get the included files as a Vec of (name, content) tuples

pub fn add_unconnected_drive( &mut self, unconnected_drive_span: Span<'a>, unconnected_drive: UnconnectedDrive, )

Add an unconnected drive

This is called when a `unconnected_drive or a `nounconnected_drive is encountered

pub fn get_unconnected_drive(&self, span: &Span<'a>) -> &UnconnectedDrive

Get the unconnected drive based on the Span where an unconnected net is encountered

pub fn add_cell_define(&mut self, is_cell_define: bool, span: Span<'a>)

Add a cell define declaration

This is called when a `celldefine is encountered

pub fn is_cell_module(&self, declaration_span: &Span<'a>) -> bool

Determine whether a module is a cell module, based on the Span of the module declaration

pub fn add_line_directive( &mut self, file_name: &'a str, line_number: &'a str, dir_span: Span<'a>, )

Add a line directive

This is called when a `line is encountered

pub fn get_line_directive_file(&self, span: &Span<'a>) -> &'a str

Get the file name from a Span, factoring in `line directives

pub fn get_line_directive_line( &mut self, span: &Span<'a>, cache: &'a PreprocessorCache<'a>, ) -> &'a str

Get the line number of a Span, factoring in `line directives

pub fn retain_string( &mut self, string: String, cache: &'a PreprocessorCache<'a>, ) -> &'a str

pub fn warn(&mut self, warning: PreprocessorWarning<'a>)

Add a warning encountered during preprocessing

Trait Implementations

impl<'a> Clone for PreprocessorState<'a>

fn clone(&self) -> PreprocessorState<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.