Enum regex_syntax::ErrorKind

pub enum ErrorKind {
    DoubleFlagNegation,
    DuplicateCaptureName(String),
    EmptyAlternate,
    EmptyCaptureName,
    EmptyFlagNegation,
    EmptyGroup,
    InvalidBase10(String),
    InvalidBase16(String),
    InvalidCaptureName(String),
    InvalidClassRange {
        start: char,
        end: char,
    },
    InvalidClassEscape(Expr),
    InvalidRepeatRange {
        min: u32,
        max: u32,
    },
    InvalidScalarValue(u32),
    MissingBase10,
    RepeaterExpectsExpr,
    RepeaterUnexpectedExpr(Expr),
    UnclosedCaptureName(String),
    UnclosedHex,
    UnclosedParen,
    UnclosedRepeat,
    UnclosedUnicodeName,
    UnexpectedClassEof,
    UnexpectedEscapeEof,
    UnexpectedFlagEof,
    UnexpectedTwoDigitHexEof,
    UnopenedParen,
    UnrecognizedEscape(char),
    UnrecognizedFlag(char),
    UnrecognizedUnicodeClass(String),
    StackExhausted,
    FlagNotAllowed(char),
    UnicodeNotAllowed,
    InvalidUtf8,
    EmptyClass,
    UnsupportedClassChar(char),
    // some variants omitted
}

The specific type of parse error that can occur.

Variants

DoubleFlagNegation

A negation symbol is used twice in flag settings. e.g., (?-i-s).

DuplicateCaptureName(String)

The same capture name was used more than once. e.g., (?P<a>.)(?P<a>.).

EmptyAlternate

An alternate is empty. e.g., (|a).

EmptyCaptureName

A capture group name is empty. e.g., (?P<>a).

EmptyFlagNegation

A negation symbol was not proceded by any flags. e.g., (?i-).

EmptyGroup

A group is empty. e.g., ().

InvalidBase10(String)

An invalid number was used in a counted repetition. e.g., a{b}.

InvalidBase16(String)

An invalid hexadecimal number was used in an escape sequence. e.g., \xAG.

InvalidCaptureName(String)

An invalid capture name was used. e.g., (?P<0a>b).

InvalidClassRange

An invalid class range was givien. Specifically, when the start of the range is greater than the end. e.g., [z-a].

Fields of InvalidClassRange

start: char

The first character specified in the range.

end: char

The second character specified in the range.

InvalidClassEscape(Expr)

An escape sequence was used in a character class where it is not allowed. e.g., [a-\pN] or [\A].

InvalidRepeatRange

An invalid counted repetition min/max was given. e.g., a{2,1}.

Fields of InvalidRepeatRange

min: u32

The first number specified in the repetition.

max: u32

The second number specified in the repetition.

InvalidScalarValue(u32)

An invalid Unicode scalar value was used in a long hexadecimal sequence. e.g., \x{D800}.

MissingBase10

An empty counted repetition operator. e.g., a{}.

RepeaterExpectsExpr

A repetition operator was not applied to an expression. e.g., *.

RepeaterUnexpectedExpr(Expr)

A repetition operator was applied to an expression that cannot be repeated. e.g., a+* or a|*.

UnclosedCaptureName(String)

A capture group name that is never closed. e.g., (?P<a.

UnclosedHex

An unclosed hexadecimal literal. e.g., \x{a.

UnclosedParen

An unclosed parenthesis. e.g., (a.

UnclosedRepeat

An unclosed counted repetition operator. e.g., a{2.

UnclosedUnicodeName

An unclosed named Unicode class. e.g., \p{Yi.

UnexpectedClassEof

Saw end of regex before class was closed. e.g., [a.

UnexpectedEscapeEof

Saw end of regex before escape sequence was closed. e.g., \.

UnexpectedFlagEof

Saw end of regex before flags were closed. e.g., (?i.

UnexpectedTwoDigitHexEof

Saw end of regex before two hexadecimal digits were seen. e.g., \xA.

UnopenedParen

Unopened parenthesis. e.g., ).

UnrecognizedEscape(char)

Unrecognized escape sequence. e.g., \q.

UnrecognizedFlag(char)

Unrecognized flag. e.g., (?a).

UnrecognizedUnicodeClass(String)

Unrecognized named Unicode class. e.g., \p{Foo}.

StackExhausted

Indicates that the regex uses too much nesting.

(N.B. This error exists because traversing the Expr is recursive and an explicit heap allocated stack is not (yet?) used. Regardless, some sort of limit must be applied to avoid unbounded memory growth.

FlagNotAllowed(char)

A disallowed flag was found (e.g., u).

UnicodeNotAllowed

A Unicode class was used when the Unicode (u) flag was disabled.

InvalidUtf8

InvalidUtf8 indicates that the expression may match non-UTF-8 bytes. This never returned if the parser is permitted to allow expressions that match arbitrary bytes.

EmptyClass

A character class was constructed such that it is empty. e.g., [^\d\D].

UnsupportedClassChar(char)

Indicates that unsupported notation was used in a character class.

The char in this error corresponds to the illegal character.

The intent of this error is to carve a path to support set notation as described in UTS#18 RL1.3. We do this by rejecting regexes that would use the notation.

The work around for end users is to escape the character included in this error message.

Trait Implementations

impl Clone for ErrorKind

fn clone(&self) -> ErrorKind

Returns a copy of the value.

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

Performs copy-assignment from source.

impl PartialEq<ErrorKind> for ErrorKind

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl Display for ErrorKind

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

Formats the value using the given formatter.

impl Debug for ErrorKind

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

Formats the value using the given formatter.

impl StructuralPartialEq for ErrorKind