Enum PreprocessorError 

pub enum PreprocessorError<'a> {
    Endif(Span<'a>),
    NoEndif(Token<'a>, Span<'a>),
    Elsif(Span<'a>),
    Else(Span<'a>),
    EndKeywords(Span<'a>),
    NoEndKeywords(Span<'a>),
    InvalidDefineParameter(SpannedToken<'a>),
    InvalidDefineArgument(SpannedToken<'a>),
    InvalidVersionSpecifier((Option<&'a str>, Span<'a>)),
    IncompleteDirective(Span<'a>),
    IncompleteDefine(SpannedToken<'a>),
    UndefinedMacro((&'a str, Span<'a>)),
    DuplicateMacroParameter((&'a str, &'a str, Span<'a>, Span<'a>)),
    NoDefaultAfterDefault((SpannedString<'a>, SpannedString<'a>)),
    NoMacroArguments((Span<'a>, (&'a str, Span<'a>))),
    TooManyMacroArguments((Span<'a>, (&'a str, usize, usize, Span<'a>))),
    MissingMacroArgument((Span<'a>, (&'a str, Span<'a>))),
    InvalidIdentifierFormation((&'a str, Span<'a>)),
    InvalidRelativeTimescales(Span<'a>),
    IncompleteMacroWithToken(SpannedToken<'a>),
    Include(Span<'a>, String, Error),
    IncludeDepth(Span<'a>, Vec<Span<'a>>),
    VerboseError(VerboseError<'a>),
    NewlineInDefine(Span<'a>),
    EndOfFunctionArgument(SpannedToken<'a>),
}

An error encountered during preprocessing

As preprocessing can affect the interpretation of later source code, these errors are often irrecoverable

Errors marked with INTERNAL are meant for use inside the preprocessor for passing information, and should not be returned

Variants

Endif(Span<'a>)

An `endif encountered outside a conditional preprocessor block

let source = "
`endif
";
let input = lex(source, "test.v").tokens();
let preprocess_result = preprocess(
    &mut TokenIterator::new(input.into_iter()),
    &mut state,
    &cache,
);
assert!(matches!(preprocess_result, Err(PreprocessorError::Endif(_))));

NoEndif(Token<'a>, Span<'a>)

No terminating `endif for a conditional preprocessor block

let source = "
`ifdef TEST
";
let input = lex(source, "test.v").tokens();
let preprocess_result = preprocess(
    &mut TokenIterator::new(input.into_iter()),
    &mut state,
    &cache,
);
assert!(matches!(preprocess_result, Err(PreprocessorError::NoEndif(Token::DirIfdef, _))));

Elsif(Span<'a>)

An `elsif encountered outside a conditional preprocessor block

let source = "
`elsif
";
let input = lex(source, "test.v").tokens();
let preprocess_result = preprocess(
    &mut TokenIterator::new(input.into_iter()),
    &mut state,
    &cache,
);
assert!(matches!(preprocess_result, Err(PreprocessorError::Elsif(_))));

Else(Span<'a>)

An `else encountered outside a conditional preprocessor block

let source = "
`else
";
let input = lex(source, "test.v").tokens();
let preprocess_result = preprocess(
    &mut TokenIterator::new(input.into_iter()),
    &mut state,
    &cache,
);
assert!(matches!(preprocess_result, Err(PreprocessorError::Else(_))));

EndKeywords(Span<'a>)

An `end_keywords encountered outside a `begin_keywords block

let source = "
`end_keywords
";
let input = lex(source, "test.v").tokens();
let preprocess_result = preprocess(
    &mut TokenIterator::new(input.into_iter()),
    &mut state,
    &cache,
);
assert!(matches!(preprocess_result, Err(PreprocessorError::EndKeywords(_))));

NoEndKeywords(Span<'a>)

No terminating `end_keywords for a `begin_keywords block

let source = "
`begin_keywords \"1800-2009\"
";
let input = lex(source, "test.v").tokens();
let preprocess_result = preprocess(
    &mut TokenIterator::new(input.into_iter()),
    &mut state,
    &cache,
);
assert!(matches!(preprocess_result, Err(PreprocessorError::NoEndKeywords(_))));

InvalidDefineParameter(SpannedToken<'a>)

A missing parameter in a `define function declaration where one is expected

let source = "
`define TEST()
";
let input = lex(source, "test.v").tokens();
let preprocess_result = preprocess(
    &mut TokenIterator::new(input.into_iter()),
    &mut state,
    &cache,
);
assert!(matches!(preprocess_result, Err(PreprocessorError::InvalidDefineParameter(_))));

InvalidDefineArgument(SpannedToken<'a>)

A missing or invalid argument specification in a `define function

let source = "
`define TEST(a, b c)
";
let input = lex(source, "test.v").tokens();
let preprocess_result = preprocess(
    &mut TokenIterator::new(input.into_iter()),
    &mut state,
    &cache,
);
assert!(matches!(preprocess_result, Err(PreprocessorError::InvalidDefineArgument(_))));

InvalidVersionSpecifier((Option<&'a str>, Span<'a>))

An invalid version specifier for a `begin_keywords directive

let source = "
`begin_keywords \"MyVersion\"
";
let input = lex(source, "test.v").tokens();
let preprocess_result = preprocess(
    &mut TokenIterator::new(input.into_iter()),
    &mut state,
    &cache,
);
assert!(matches!(preprocess_result, Err(PreprocessorError::InvalidVersionSpecifier(_))));

IncompleteDirective(Span<'a>)

A directive that doesn’t have all of the required components

In general, PreprocessorError::VerboseError is preferred, but may not be suitable due to a lack of subsequent tokens

let source = "`line";
let input = lex(source, "test.v").tokens();
let preprocess_result = preprocess(
    &mut TokenIterator::new(input.into_iter()),
    &mut state,
    &cache,
);
assert!(matches!(preprocess_result, Err(PreprocessorError::IncompleteDirective(_))));

IncompleteDefine(SpannedToken<'a>)

An incomplete preprocessor definition, specifically with function macro arguments

let source = "
`define TEST(
";
let input = lex(source, "test.v").tokens();
let preprocess_result = preprocess(
    &mut TokenIterator::new(input.into_iter()),
    &mut state,
    &cache,
);
assert!(matches!(preprocess_result, Err(PreprocessorError::IncompleteDefine(_))));

UndefinedMacro((&'a str, Span<'a>))

Use of a text macro that wasn’t previously defined

let source = "
`TEST
";
let input = lex(source, "test.v").tokens();
let preprocess_result = preprocess(
    &mut TokenIterator::new(input.into_iter()),
    &mut state,
    &cache,
);
assert!(matches!(preprocess_result, Err(PreprocessorError::UndefinedMacro(_))));

DuplicateMacroParameter((&'a str, &'a str, Span<'a>, Span<'a>))

Specifying a macro parameter that was already specified

let source = "
`define TEST(a, b, a) a + b
";
let input = lex(source, "test.v").tokens();
let preprocess_result = preprocess(
    &mut TokenIterator::new(input.into_iter()),
    &mut state,
    &cache,
);
assert!(matches!(preprocess_result, Err(PreprocessorError::DuplicateMacroParameter(_))));

NoDefaultAfterDefault((SpannedString<'a>, SpannedString<'a>))

Attempting to have a macro parameter with no default value after one that does

let source = "
`define TEST(a = 1, b) a + b
";
let input = lex(source, "test.v").tokens();
let preprocess_result = preprocess(
    &mut TokenIterator::new(input.into_iter()),
    &mut state,
    &cache,
);
assert!(matches!(preprocess_result, Err(PreprocessorError::NoDefaultAfterDefault(_))));

NoMacroArguments((Span<'a>, (&'a str, Span<'a>)))

Specifying no arguments for a macro function that takes arguments

let source = "
`define TEST(a, b) a + b
`TEST
";
let input = lex(source, "test.v").tokens();
let preprocess_result = preprocess(
    &mut TokenIterator::new(input.into_iter()),
    &mut state,
    &cache,
);
assert!(matches!(preprocess_result, Err(PreprocessorError::NoMacroArguments(_))));

TooManyMacroArguments((Span<'a>, (&'a str, usize, usize, Span<'a>)))

Specifying too many arguments for a macro function

let source = "
`define TEST(a, b) a + b
`TEST(1, 2, 3)
";
let input = lex(source, "test.v").tokens();
let preprocess_result = preprocess(
    &mut TokenIterator::new(input.into_iter()),
    &mut state,
    &cache,
);
assert!(matches!(preprocess_result, Err(PreprocessorError::TooManyMacroArguments(_))));

MissingMacroArgument((Span<'a>, (&'a str, Span<'a>)))

Missing an argument in a macro function use

let source = "
`define TEST(a, b) a + b
`TEST(1)
";
let input = lex(source, "test.v").tokens();
let preprocess_result = preprocess(
    &mut TokenIterator::new(input.into_iter()),
    &mut state,
    &cache,
);
assert!(matches!(preprocess_result, Err(PreprocessorError::MissingMacroArgument(_))));

InvalidIdentifierFormation((&'a str, Span<'a>))

An invalid preprocessor identifier specification

let source = "
`define TEST(a, b) a``_with_``b
`TEST(\"one\", \"two\")
";
let input = lex(source, "test.v").tokens();
let preprocess_result = preprocess(
    &mut TokenIterator::new(input.into_iter()),
    &mut state,
    &cache,
);
assert!(matches!(preprocess_result, Err(PreprocessorError::InvalidIdentifierFormation(_))));

InvalidRelativeTimescales(Span<'a>)

A precision that is less precise than the unit in a `timescale directive

let source = "
`timescale 100 fs / 1 s
";
let input = lex(source, "test.v").tokens();
let preprocess_result = preprocess(
    &mut TokenIterator::new(input.into_iter()),
    &mut state,
    &cache,
);
assert!(matches!(preprocess_result, Err(PreprocessorError::InvalidRelativeTimescales(_))));

IncompleteMacroWithToken(SpannedToken<'a>)

An incomplete macro due to mismatching grouping tokens ([], (), or {})

let source = "
`define TEST(a, b) a + b
`TEST(a = 1, b = 2])
";
let input = lex(source, "test.v").tokens();
let preprocess_result = preprocess(
    &mut TokenIterator::new(input.into_iter()),
    &mut state,
    &cache,
);
assert!(matches!(preprocess_result, Err(PreprocessorError::IncompleteMacroWithToken(_))));

Include(Span<'a>, String, Error)

An error reading a file specified by an `include macro

let source = "
`include \"other.v\"
";
let input = lex(source, "test.v").tokens();
let preprocess_result = preprocess(
    &mut TokenIterator::new(input.into_iter()),
    &mut state,
    &cache,
);
assert!(matches!(preprocess_result, Err(PreprocessorError::Include(_, _, _))));

IncludeDepth(Span<'a>, Vec<Span<'a>>)

The maximum include depth was hit, likely as a result of a self-referential `include sequence

let source = "
`include \"test.v\"
";
state.retain_file(
    "test.v".to_string(),
    source.to_string(),
    &cache,
);
let input = lex(source, "test.v").tokens();
let preprocess_result = preprocess(
    &mut TokenIterator::new(input.into_iter()),
    &mut state,
    &cache,
);
assert!(matches!(preprocess_result, Err(PreprocessorError::IncludeDepth(_, _))));

VerboseError(VerboseError<'a>)

A VerboseError detailing the expected and found tokens, for a case not covered above

This is most commonly used when we can provide the user with a bit more context

let source = "
`line
";
let input = lex(source, "test.v").tokens();
let preprocess_result = preprocess(
    &mut TokenIterator::new(input.into_iter()),
    &mut state,
    &cache,
);
// Expects a line number
assert!(matches!(preprocess_result, Err(PreprocessorError::VerboseError(_))));

NewlineInDefine(Span<'a>)

INTERNAL: A newline encountered in a `define directive

EndOfFunctionArgument(SpannedToken<'a>)

INTERNAL: The end of a function argument was encountered

Trait Implementations

impl<'a> Debug for PreprocessorError<'a>

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

Formats the value using the given formatter.

impl<'s> From<&PreprocessorError<'s>> for Report<'s, (String, Range<usize>)>

fn from(s: &PreprocessorError<'s>) -> Self

Converts to this type from the input type.