Struct regex_syntax::ast::parse::ParserBuilder
source · [−]pub struct ParserBuilder { /* private fields */ }
Expand description
A builder for a regular expression parser.
This builder permits modifying configuration options for the parser.
Implementations
sourceimpl ParserBuilder
impl ParserBuilder
sourcepub fn new() -> ParserBuilder
pub fn new() -> ParserBuilder
Create a new parser builder with a default configuration.
sourcepub fn nest_limit(&mut self, limit: u32) -> &mut ParserBuilder
pub fn nest_limit(&mut self, limit: u32) -> &mut ParserBuilder
Set the nesting limit for this parser.
The nesting limit controls how deep the abstract syntax tree is allowed to be. If the AST exceeds the given limit (e.g., with too many nested groups), then an error is returned by the parser.
The purpose of this limit is to act as a heuristic to prevent stack
overflow for consumers that do structural induction on an Ast
using
explicit recursion. While this crate never does this (instead using
constant stack space and moving the call stack to the heap), other
crates may.
This limit is not checked until the entire Ast is parsed. Therefore, if callers want to put a limit on the amount of heap space used, then they should impose a limit on the length, in bytes, of the concrete pattern string. In particular, this is viable since this parser implementation will limit itself to heap space proportional to the lenth of the pattern string.
Note that a nest limit of 0
will return a nest limit error for most
patterns but not all. For example, a nest limit of 0
permits a
but
not ab
, since ab
requires a concatenation, which results in a nest
depth of 1
. In general, a nest limit is not something that manifests
in an obvious way in the concrete syntax, therefore, it should not be
used in a granular way.
sourcepub fn octal(&mut self, yes: bool) -> &mut ParserBuilder
pub fn octal(&mut self, yes: bool) -> &mut ParserBuilder
Whether to support octal syntax or not.
Octal syntax is a little-known way of uttering Unicode codepoints in
a regular expression. For example, a
, \x61
, \u0061
and
\141
are all equivalent regular expressions, where the last example
shows octal syntax.
While supporting octal syntax isn’t in and of itself a problem, it does
make good error messages harder. That is, in PCRE based regex engines,
syntax like \0
invokes a backreference, which is explicitly
unsupported in Rust’s regex engine. However, many users expect it to
be supported. Therefore, when octal support is disabled, the error
message will explicitly mention that backreferences aren’t supported.
Octal syntax is disabled by default.
sourcepub fn ignore_whitespace(&mut self, yes: bool) -> &mut ParserBuilder
pub fn ignore_whitespace(&mut self, yes: bool) -> &mut ParserBuilder
Enable verbose mode in the regular expression.
When enabled, verbose mode permits insigificant whitespace in many
places in the regular expression, as well as comments. Comments are
started using #
and continue until the end of the line.
By default, this is disabled. It may be selectively enabled in the
regular expression by using the x
flag regardless of this setting.
Trait Implementations
sourceimpl Clone for ParserBuilder
impl Clone for ParserBuilder
sourcefn clone(&self) -> ParserBuilder
fn clone(&self) -> ParserBuilder
Returns a copy of the value. Read more
1.0.0 · sourcefn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source
. Read more
sourceimpl Debug for ParserBuilder
impl Debug for ParserBuilder
sourceimpl Default for ParserBuilder
impl Default for ParserBuilder
sourcefn default() -> ParserBuilder
fn default() -> ParserBuilder
Returns the “default value” for a type. Read more
Auto Trait Implementations
impl RefUnwindSafe for ParserBuilder
impl Send for ParserBuilder
impl Sync for ParserBuilder
impl Unpin for ParserBuilder
impl UnwindSafe for ParserBuilder
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> ToOwned for T where
T: Clone,
impl<T> ToOwned for T where
T: Clone,
type Owned = T
type Owned = T
The resulting type after obtaining ownership.
sourcefn clone_into(&self, target: &mut T)
fn clone_into(&self, target: &mut T)
toowned_clone_into
)Uses borrowed data to replace owned data, usually by cloning. Read more