mirror of
https://github.com/BurntSushi/ripgrep.git
synced 2025-05-19 09:40:22 -07:00
d9ca529356
libripgrep is not any one library, but rather, a collection of libraries that roughly separate the following key distinct phases in a grep implementation: 1. Pattern matching (e.g., by a regex engine). 2. Searching a file using a pattern matcher. 3. Printing results. Ultimately, both (1) and (3) are defined by de-coupled interfaces, of which there may be multiple implementations. Namely, (1) is satisfied by the `Matcher` trait in the `grep-matcher` crate and (3) is satisfied by the `Sink` trait in the `grep2` crate. The searcher (2) ties everything together and finds results using a matcher and reports those results using a `Sink` implementation. Closes #162
89 lines
2.9 KiB
Rust
89 lines
2.9 KiB
Rust
use std::error;
|
|
use std::fmt;
|
|
|
|
use util;
|
|
|
|
/// An error that can occur in this crate.
|
|
///
|
|
/// Generally, this error corresponds to problems building a regular
|
|
/// expression, whether it's in parsing, compilation or a problem with
|
|
/// guaranteeing a configured optimization.
|
|
#[derive(Clone, Debug)]
|
|
pub struct Error {
|
|
kind: ErrorKind,
|
|
}
|
|
|
|
impl Error {
|
|
pub(crate) fn new(kind: ErrorKind) -> Error {
|
|
Error { kind }
|
|
}
|
|
|
|
pub(crate) fn regex<E: error::Error>(err: E) -> Error {
|
|
Error { kind: ErrorKind::Regex(err.to_string()) }
|
|
}
|
|
|
|
/// Return the kind of this error.
|
|
pub fn kind(&self) -> &ErrorKind {
|
|
&self.kind
|
|
}
|
|
}
|
|
|
|
/// The kind of an error that can occur.
|
|
#[derive(Clone, Debug)]
|
|
pub enum ErrorKind {
|
|
/// An error that occurred as a result of parsing a regular expression.
|
|
/// This can be a syntax error or an error that results from attempting to
|
|
/// compile a regular expression that is too big.
|
|
///
|
|
/// The string here is the underlying error converted to a string.
|
|
Regex(String),
|
|
/// An error that occurs when a building a regex that isn't permitted to
|
|
/// match a line terminator. In general, building the regex will do its
|
|
/// best to make matching a line terminator impossible (e.g., by removing
|
|
/// `\n` from the `\s` character class), but if the regex contains a
|
|
/// `\n` literal, then there is no reasonable choice that can be made and
|
|
/// therefore an error is reported.
|
|
///
|
|
/// The string is the literal sequence found in the regex that is not
|
|
/// allowed.
|
|
NotAllowed(String),
|
|
/// This error occurs when a non-ASCII line terminator was provided.
|
|
///
|
|
/// The invalid byte is included in this error.
|
|
InvalidLineTerminator(u8),
|
|
/// Hints that destructuring should not be exhaustive.
|
|
///
|
|
/// This enum may grow additional variants, so this makes sure clients
|
|
/// don't count on exhaustive matching. (Otherwise, adding a new variant
|
|
/// could break existing code.)
|
|
#[doc(hidden)]
|
|
__Nonexhaustive,
|
|
}
|
|
|
|
impl error::Error for Error {
|
|
fn description(&self) -> &str {
|
|
match self.kind {
|
|
ErrorKind::Regex(_) => "regex error",
|
|
ErrorKind::NotAllowed(_) => "literal not allowed",
|
|
ErrorKind::InvalidLineTerminator(_) => "invalid line terminator",
|
|
ErrorKind::__Nonexhaustive => unreachable!(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl fmt::Display for Error {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
match self.kind {
|
|
ErrorKind::Regex(ref s) => write!(f, "{}", s),
|
|
ErrorKind::NotAllowed(ref lit) => {
|
|
write!(f, "the literal '{:?}' is not allowed in a regex", lit)
|
|
}
|
|
ErrorKind::InvalidLineTerminator(byte) => {
|
|
let x = util::show_bytes(&[byte]);
|
|
write!(f, "line terminators must be ASCII, but '{}' is not", x)
|
|
}
|
|
ErrorKind::__Nonexhaustive => unreachable!(),
|
|
}
|
|
}
|
|
}
|