Enum PreprocessorError 

pub enum PreprocessorError {
    Endif {
        endif_span: Span,
    },
    NoEndif {
        cond_token: Token,
        cond_token_span: Span,
    },
    Elsif {
        elsif_span: Span,
    },
    Else {
        else_span: Span,
    },
    EndKeywords {
        end_keywords_span: Span,
    },
    NoEndKeywords {
        begin_keywords_span: Span,
    },
    InvalidDefineParameter {
        other_token: Token,
        other_span: Span,
    },
    InvalidDefineArgument {
        other_token: Token,
        other_span: Span,
    },
    InvalidVersionSpecifier {
        invalid_version: Token,
        invalid_version_span: Span,
    },
    IncompleteDirective {
        directive_span: Span,
    },
    IncompleteDefine {
        other_token: Token,
        other_span: Span,
    },
    UndefinedMacro {
        undefined_name: String,
        undefined_span: Span,
    },
    DuplicateMacroParameter {
        define_name: String,
        param_name: String,
        dup_span: Span,
        prev_span: Span,
    },
    NoDefaultAfterDefault {
        default_param: String,
        default_param_span: Span,
        non_default_param: String,
        non_default_param_span: Span,
    },
    NoMacroArguments {
        macro_name: String,
        define_span: Span,
        use_span: Span,
    },
    TooManyMacroArguments {
        macro_name: String,
        define_span: Span,
        use_span: Span,
        expected: usize,
        found: usize,
    },
    MissingMacroArgument {
        define_span: Span,
        use_span: Span,
        param_name: String,
    },
    InvalidIdentifierFormation {
        param_name: String,
        arg_span: Span,
    },
    InvalidRelativeTimescales {
        timescale_span: Span,
    },
    IncompleteMacroWithToken {
        error_token: Token,
        error_span: Span,
    },
    Include {
        include_path: String,
        include_path_span: Span,
        read_err: String,
    },
    IncludeDepth {
        include_span: Span,
    },
    VerboseError {
        err: VerboseError,
    },
    NotPreviouslyDefinedMacro {
        macro_name: String,
        macro_span: Span,
    },
    RedefinedMacro {
        macro_name: String,
        redef_span: Span,
        prev_def_span: Span,
    },
}

A wrapper around scarf_parser::PreprocessorError

See its documentation for details on each variant

Variants

Endif

Fields

endif_span: Span

The Span of the `endif

NoEndif

Fields

cond_token: Token

The conditional token (either Token::DirIfdef, Token::DirIfndef, Token::DirElsif, or Token::DirElse) with no matching `endif

cond_token_span: Span

The Span of the conditional token

Elsif

Fields

elsif_span: Span

The Span of the `elsif

Else

Fields

else_span: Span

The Span of the `else

EndKeywords

Fields

end_keywords_span: Span

The Span of the `end_keywords

NoEndKeywords

Fields

begin_keywords_span: Span

The Span of the unterminated `begin_keywords

InvalidDefineParameter

Fields

other_token: Token

The Token found instead of the `define parameter

other_span: Span

The Span of the token found instead

InvalidDefineArgument

Fields

other_token: Token

The Token found instead of the valid `define argument

other_span: Span

The Span of the token found instead

InvalidVersionSpecifier

Fields

invalid_version: Token

The Token provided instead of a valid version specifier

If the token is a Token::StringLiteral, the string isn’t a version recognized by 1800-2023

invalid_version_span: Span

The Span of the invalid version specifier

IncompleteDirective

Fields

directive_span: Span

The Span of the incomplete preprocessor directive

This is usually the primary directive, but can be other more indicative tokens as well, such as an unmatched opening parenthesis

IncompleteDefine

Fields

other_token: Token

If known, the Token found instead of a valid function macro argument specification

In the case that the token wasn’t tracked, the opening Token::Paren is referenced instead

other_span: Span

The Span of the token found instead

UndefinedMacro

Fields

undefined_name: String

The name of the undefined macro

undefined_span: Span

The Span of the undefined macro

DuplicateMacroParameter

Fields

define_name: String

The name of the macro for which duplicate parameters were specified

param_name: String

The name of the parameter that was specified multiple times

dup_span: Span

The Span of the duplicate specification

prev_span: Span

The Span of the previous/original specification

NoDefaultAfterDefault

Fields

default_param: String

The name of the previously-specified default parameter

default_param_span: Span

The Span of the previously-specified default parameter

non_default_param: String

The name of the non-default parameter

non_default_param_span: Span

The Span of the non-default parameter

NoMacroArguments

Fields

macro_name: String

The name of the macro

define_span: Span

The Span of the macro definition (with arguments)

use_span: Span

The Span where the macro was used with no arguments

TooManyMacroArguments

Fields

macro_name: String

The name of the macro

define_span: Span

The Span of the macro definition

use_span: Span

The Span where the macro was used with too many arguments

expected: usize

How many arguments were expected

found: usize

How many arguments were found

MissingMacroArgument

Fields

define_span: Span

The Span of the macro definition

use_span: Span

The Span where the macro was used with a missing argument

param_name: String

The name of the missing parameter

InvalidIdentifierFormation

Fields

param_name: String

The name of the parameter used in a preprocessor identifier

arg_span: Span

The Span of the invalid argument

InvalidRelativeTimescales

Fields

timescale_span: Span

The Span of the `timescale directive

IncompleteMacroWithToken

Fields

error_token: Token

The error-causing Token (either Token::EParen, Token::EBracket, or Token::EBrace)

error_span: Span

The error-causing Span

Include

Fields

include_path: String

The path for the `include directive

include_path_span: Span

The Span of the include path

read_err: String

The std::io::Error raised when attempting to read the file

IncludeDepth

Fields

include_span: Span

The Span of the `include directive that exceeded the limit

VerboseError

Fields

err: VerboseError

The VerboseError for the preprocessor error

NotPreviouslyDefinedMacro

Fields

macro_name: String

The name that wasn’t previously defined

macro_span: Span

The Span where the not-previously-defined name was specified

RedefinedMacro

Fields

macro_name: String

The name of the macro being redefined

redef_span: Span

The Span of the redefinition

prev_def_span: Span

The Span where the macro was previously defined

Implementations

impl PreprocessorError

pub fn report(&self) -> PyResult<Report>

Trait Implementations

impl Clone for PreprocessorError

fn clone(&self) -> PreprocessorError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Eq for PreprocessorError

impl<'a> From<PreprocessorError<'a>> for PreprocessorError

fn from(value: PreprocessorError<'a>) -> Self

Converts to this type from the input type.

impl<'a, 'py> FromPyObject<'a, 'py> for PreprocessorError

where Self: Clone,

const INPUT_TYPE: PyStaticExpr = <PreprocessorError as ::pyo3::PyTypeInfo>::TYPE_HINT

Provides the type hint information for this type when it appears as an argument.

type Error = PyClassGuardError<'a, 'py>

The type returned in the event of a conversion error.

fn extract( obj: Borrowed<'a, 'py, PyAny>, ) -> Result<Self, <Self as FromPyObject<'a, 'py>>::Error>

Extracts Self from the bound smart pointer obj.

impl<'py> IntoPyObject<'py> for PreprocessorError

const OUTPUT_TYPE: PyStaticExpr = <PreprocessorError as ::pyo3::PyTypeInfo>::TYPE_HINT

Extracts the type hint information for this type when it appears as a return value.

type Target = PreprocessorError

The Python output type

type Output = Bound<'py, <PreprocessorError as IntoPyObject<'py>>::Target>

The smart pointer type to use.

type Error = PyErr

The type returned in the event of a conversion error.

fn into_pyobject( self, py: Python<'py>, ) -> Result<<Self as IntoPyObject<'_>>::Output, <Self as IntoPyObject<'_>>::Error>

Performs the conversion.

impl PartialEq for PreprocessorError

fn eq(&self, other: &PreprocessorError) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PyClass for PreprocessorError

const NAME: &str = "PreprocessorError"

Name of the class.

type Frozen = True

Whether the pyclass is frozen.

impl PyClassBaseType for PreprocessorError

type LayoutAsBase = <PreprocessorError as PyClassImpl>::Layout

type BaseNativeType = <PreprocessorError as PyClassImpl>::BaseNativeType

type Initializer = PyClassInitializer<PreprocessorError>

type PyClassMutability = <PreprocessorError as PyClassImpl>::PyClassMutability

type Layout<T: PyClassImpl> = <<PreprocessorError as PyClassBaseType>::BaseNativeType as PyClassBaseType>::Layout<T>

The type of object layout to use for ancestors or descendants of this type.

impl PyClassImpl for PreprocessorError

const MODULE: Option<&str>

Module which the class will be associated with.

const IS_BASETYPE: bool = true

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

const IS_IMMUTABLE_TYPE: bool = false

#[pyclass(immutable_type)]

const RAW_DOC: &'static CStr = /// A wrapper around [`scarf_parser::PreprocessorError`] /// /// See its documentation for details on each variant

Docstring for the class provided on the struct or enum.

const DOC: &'static CStr

Fully rendered class doc, including the text_signature if a constructor is defined.

type Layout = <<PreprocessorError as PyClassImpl>::BaseNativeType as PyClassBaseType>::Layout<PreprocessorError>

Description of how this class is laid out in memory

type BaseType = PyAny

Base class

type ThreadChecker = NoopThreadChecker

This handles following two situations:

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::ImmutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<PyObjectOffset>

Used to provide the dictoffset slot (equivalent to tp_dictoffset)

fn weaklist_offset() -> Option<PyObjectOffset>

Used to provide the weaklistoffset slot (equivalent to tp_weaklistoffset

impl PyMethods<PreprocessorError> for PyClassImplCollector<PreprocessorError>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for PreprocessorError

const NAME: &str = <Self as ::pyo3::PyClass>::NAME

👎Deprecated since 0.28.0:

prefer using ::type_object(py).name() to get the correct runtime value

Class name.

const MODULE: Option<&str> = <Self as ::pyo3::impl_::pyclass::PyClassImpl>::MODULE

👎Deprecated since 0.28.0:

prefer using ::type_object(py).module() to get the correct runtime value

Module name, if any.

const TYPE_HINT: PyStaticExpr

Provides the full python type as a type hint.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object(py: Python<'_>) -> Bound<'_, PyType>

Returns the safe abstraction over the type object.

fn is_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type.

impl StructuralPartialEq for PreprocessorError