ripgrep: migrate to libripgrep

32 files changed, 2398 insertions, 5829 deletions

diff --git a/Cargo.lock b/Cargo.lock
index b48622fd..8e74b97e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -134,12 +134,12 @@ dependencies = [
 
 [[package]]
 name = "grep"
-version = "0.1.9"
+version = "0.2.0"
 dependencies = [
- "log 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "memchr 2.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "regex 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "regex-syntax 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "grep-matcher 0.0.1",
+ "grep-printer 0.0.1",
+ "grep-regex 0.0.1",
+ "grep-searcher 0.0.1",
 ]
 
 [[package]]
@@ -193,16 +193,6 @@ dependencies = [
 ]
 
 [[package]]
-name = "grep2"
-version = "0.1.8"
-dependencies = [
- "grep-matcher 0.0.1",
- "grep-printer 0.0.1",
- "grep-regex 0.0.1",
- "grep-searcher 0.0.1",
-]
-
-[[package]]
 name = "ignore"
 version = "0.4.3"
 dependencies = [
@@ -339,21 +329,16 @@ name = "ripgrep"
 version = "0.9.0"
 dependencies = [
  "atty 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
- "bytecount 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "clap 2.32.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "encoding_rs 0.8.4 (registry+https://github.com/rust-lang/crates.io-index)",
- "encoding_rs_io 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "globset 0.4.1",
- "grep 0.1.9",
+ "grep 0.2.0",
  "ignore 0.4.3",
  "lazy_static 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "libc 0.2.42 (registry+https://github.com/rust-lang/crates.io-index)",
  "log 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "memchr 2.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "memmap 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "regex 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "same-file 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde_json 1.0.24 (registry+https://github.com/rust-lang/crates.io-index)",
  "termcolor 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "winapi 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index 33a51ee7..e8bec6ec 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -35,25 +35,19 @@ path = "tests/tests.rs"
 members = [
   "grep", "globset", "ignore",
   "grep-matcher", "grep-printer", "grep-regex", "grep-searcher",
-  "grep2",
 ]
 
 [dependencies]
 atty = "0.2.11"
-bytecount = "0.3.2"
-encoding_rs = "0.8"
-encoding_rs_io = "0.1"
 globset = { version = "0.4.0", path = "globset" }
-grep = { version = "0.1.8", path = "grep" }
+grep = { version = "0.2.0", path = "grep" }
 ignore = { version = "0.4.0", path = "ignore" }
 lazy_static = "1"
-libc = "0.2"
 log = "0.4"
-memchr = "2"
-memmap = "0.6"
 num_cpus = "1"
 regex = "1"
 same-file = "1"
+serde_json = "1"
 termcolor = "1"
 
 [dependencies.clap]
@@ -63,7 +57,7 @@ features = ["suggestions", "color"]
 
 [target.'cfg(windows)'.dependencies.winapi]
 version = "0.3"
-features = ["std", "winnt"]
+features = ["std", "fileapi", "winnt"]
 
 [build-dependencies]
 lazy_static = "1"
@@ -74,15 +68,8 @@ default-features = false
 features = ["suggestions", "color"]
 
 [features]
-avx-accel = [
-  "bytecount/avx-accel",
-  "grep2/avx-accel",
-]
-simd-accel = [
-  "bytecount/simd-accel",
-  "encoding_rs/simd-accel",
-  "grep2/simd-accel",
-]
+avx-accel = ["grep/avx-accel"]
+simd-accel = ["grep/simd-accel"]
 
 [profile.release]
-debug = true
+debug = 1
diff --git a/complete/_rg b/complete/_rg
index 4342e8d2..00026a08 100644
--- a/complete/_rg
+++ b/complete/_rg
@@ -131,6 +131,10 @@ _rg() {
     '--mmap[search using memory maps when possible]'
     "--no-mmap[don't search using memory maps]"
 
+    + '(multiline)' # multiline options
+    '--multiline[permit matching across multiple lines]'
+    $no"--no-multiline[restrict matches to at most one line each]"
+
     + '(only)' # Only-match options
     '(passthru replace)'{-o,--only-matching}'[show only matching part of each line]'
 
diff --git a/grep/Cargo.toml b/grep/Cargo.toml
index 562bde1e..afd0d40e 100644
--- a/grep/Cargo.toml
+++ b/grep/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "grep"
-version = "0.1.9"  #:version
+version = "0.2.0"  #:version
 authors = ["Andrew Gallant <jamslam@gmail.com>"]
 description = """
 Fast line oriented regex searching as a library.
@@ -13,7 +13,11 @@ keywords = ["regex", "grep", "egrep", "search", "pattern"]
 license = "Unlicense/MIT"
 
 [dependencies]
-log = "0.4"
-memchr = "2"
-regex = "1"
-regex-syntax = "0.6"
+grep-matcher = { version = "0.0.1", path = "../grep-matcher" }
+grep-printer = { version = "0.0.1", path = "../grep-printer" }
+grep-regex = { version = "0.0.1", path = "../grep-regex" }
+grep-searcher = { version = "0.0.1", path = "../grep-searcher" }
+
+[features]
+avx-accel = ["grep-searcher/avx-accel"]
+simd-accel = ["grep-searcher/simd-accel"]
diff --git a/grep/src/lib.rs b/grep/src/lib.rs
index 023cd64a..b6e02684 100644
--- a/grep/src/lib.rs
+++ b/grep/src/lib.rs
@@ -1,84 +1,10 @@
-#![deny(missing_docs)]
-
 /*!
-A fast line oriented regex searcher.
+TODO.
 */
 
-#[macro_use]
-extern crate log;
-extern crate memchr;
-extern crate regex;
-extern crate regex_syntax as syntax;
-
-use std::error;
-use std::fmt;
-use std::result;
-
-pub use search::{Grep, GrepBuilder, Iter, Match};
-
-mod literals;
-mod nonl;
-mod search;
-mod smart_case;
-mod word_boundary;
-
-/// Result is a convenient type alias that fixes the type of the error to
-/// the `Error` type defined in this crate.
-pub type Result<T> = result::Result<T, Error>;
-
-/// Error enumerates the list of possible error conditions when building or
-/// using a `Grep` line searcher.
-#[derive(Debug)]
-pub enum Error {
-    /// An error from parsing or compiling a regex.
-    Regex(regex::Error),
-    /// This error occurs when an illegal literal was found in the regex
-    /// pattern. For example, if the line terminator is `\n` and the regex
-    /// pattern is `\w+\n\w+`, then the presence of `\n` will cause this error.
-    LiteralNotAllowed(char),
-    /// An unused enum variant that indicates this enum may be expanded in
-    /// the future and therefore should not be exhaustively matched.
-    #[doc(hidden)]
-    __Nonexhaustive,
-}
-
-impl error::Error for Error {
-    fn description(&self) -> &str {
-        match *self {
-            Error::Regex(ref err) => err.description(),
-            Error::LiteralNotAllowed(_) => "use of forbidden literal",
-            Error::__Nonexhaustive => unreachable!(),
-        }
-    }
-
-    fn cause(&self) -> Option<&error::Error> {
-        match *self {
-            Error::Regex(ref err) => err.cause(),
-            _ => None,
-        }
-    }
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Error::Regex(ref err) => err.fmt(f),
-            Error::LiteralNotAllowed(chr) => {
-                write!(f, "Literal {:?} not allowed.", chr)
-            }
-            Error::__Nonexhaustive => unreachable!(),
-        }
-    }
-}
-
-impl From<regex::Error> for Error {
-    fn from(err: regex::Error) -> Error {
-        Error::Regex(err)
-    }
-}
+#![deny(missing_docs)]
 
-impl From<syntax::Error> for Error {
-    fn from(err: syntax::Error) -> Error {
-        Error::Regex(regex::Error::Syntax(err.to_string()))
-    }
-}
+pub extern crate grep_matcher as matcher;
+pub extern crate grep_printer as printer;
+pub extern crate grep_regex as regex;
+pub extern crate grep_searcher as searcher;
diff --git a/grep/src/literals.rs b/grep/src/literals.rs
deleted file mode 100644
index 5e3dc8ea..00000000
--- a/grep/src/literals.rs
+++ /dev/null
@@ -1,274 +0,0 @@
-/*!
-The literals module is responsible for extracting *inner* literals out of the
-AST of a regular expression. Normally this is the job of the regex engine
-itself, but the regex engine doesn't look for inner literals. Since we're doing
-line based searching, we can use them, so we need to do it ourselves.
-
-Note that this implementation is incredibly suspicious. We need something more
-principled.
-*/
-use std::cmp;
-
-use regex::bytes::RegexBuilder;
-use syntax::hir::{self, Hir, HirKind};
-use syntax::hir::literal::{Literal, Literals};
-
-#[derive(Clone, Debug)]
-pub struct LiteralSets {
-    prefixes: Literals,
-    suffixes: Literals,
-    required: Literals,
-}
-
-impl LiteralSets {
-    pub fn create(expr: &Hir) -> Self {
-        let mut required = Literals::empty();
-        union_required(expr, &mut required);
-        LiteralSets {
-            prefixes: Literals::prefixes(expr),
-            suffixes: Literals::suffixes(expr),
-            required: required,
-        }
-    }
-
-    pub fn to_regex_builder(&self) -> Option<RegexBuilder> {
-        if self.prefixes.all_complete() && !self.prefixes.is_empty() {
-            debug!("literal prefixes detected: {:?}", self.prefixes);
-            // When this is true, the regex engine will do a literal scan.
-            return None;
-        }
-
-        // Out of inner required literals, prefixes and suffixes, which one
-        // is the longest? We pick the longest to do fast literal scan under
-        // the assumption that a longer literal will have a lower false
-        // positive rate.
-        let pre_lcp = self.prefixes.longest_common_prefix();
-        let pre_lcs = self.prefixes.longest_common_suffix();
-        let suf_lcp = self.suffixes.longest_common_prefix();
-        let suf_lcs = self.suffixes.longest_common_suffix();
-
-        let req_lits = self.required.literals();
-        let req = match req_lits.iter().max_by_key(|lit| lit.len()) {
-            None => &[],
-            Some(req) => &***req,
-        };
-
-        let mut lit = pre_lcp;
-        if pre_lcs.len() > lit.len() {
-            lit = pre_lcs;
-        }
-        if suf_lcp.len() > lit.len() {
-            lit = suf_lcp;
-        }
-        if suf_lcs.len() > lit.len() {
-            lit = suf_lcs;
-        }
-        if req_lits.len() == 1 && req.len() > lit.len() {
-            lit = req;
-        }
-
-        // Special case: if we have any literals that are all whitespace,
-        // then this is probably a failing of the literal detection since
-        // whitespace is typically pretty common. In this case, don't bother
-        // with inner literal scanning at all and just defer to the regex.
-        let any_all_white = req_lits.iter()
-            .any(|lit| lit.iter().all(|&b| (b as char).is_whitespace()));
-        if any_all_white {
-            return None;
-        }
-
-        // Special case: if we detected an alternation of inner required
-        // literals and its longest literal is bigger than the longest
-        // prefix/suffix, then choose the alternation. In practice, this
-        // helps with case insensitive matching, which can generate lots of
-        // inner required literals.
-        let any_empty = req_lits.iter().any(|lit| lit.is_empty());
-        if req.len() > lit.len() && req_lits.len() > 1 && !any_empty {
-            debug!("required literals found: {:?}", req_lits);
-            let alts: Vec<String> =
-                req_lits.into_iter().map(|x| bytes_to_regex(x)).collect();
-            let mut builder = RegexBuilder::new(&alts.join("|"));
-            builder.unicode(false);
-            Some(builder)
-        } else if lit.is_empty() {
-            None
-        } else {
-            debug!("required literal found: {:?}", show(lit));
-            let mut builder = RegexBuilder::new(&bytes_to_regex(&lit));
-            builder.unicode(false);
-            Some(builder)
-        }
-    }
-}
-
-fn union_required(expr: &Hir, lits: &mut Literals) {
-    match *expr.kind() {
-        HirKind::Literal(hir::Literal::Unicode(c)) => {
-            let mut buf = [0u8; 4];
-            lits.cross_add(c.encode_utf8(&mut buf).as_bytes());
-        }
-        HirKind::Literal(hir::Literal::Byte(b)) => {
-            lits.cross_add(&[b]);
-        }
-        HirKind::Class(hir::Class::Unicode(ref cls)) => {
-            if count_unicode_class(cls) >= 5 || !lits.add_char_class(cls) {
-                lits.cut();
-            }
-        }
-        HirKind::Class(hir::Class::Bytes(ref cls)) => {
-            if count_byte_class(cls) >= 5 || !lits.add_byte_class(cls) {
-                lits.cut();
-            }
-        }
-        HirKind::Group(hir::Group { ref hir, .. }) => {
-            union_required(&**hir, lits);
-        }
-        HirKind::Repetition(ref x) => {
-            match x.kind {
-                hir::RepetitionKind::ZeroOrOne => lits.cut(),
-                hir::RepetitionKind::ZeroOrMore => lits.cut(),
-                hir::RepetitionKind::OneOrMore => {
-                    union_required(&x.hir, lits);
-                    lits.cut();
-                }
-                hir::RepetitionKind::Range(ref rng) => {
-                    let (min, max) = match *rng {
-                        hir::RepetitionRange::Exactly(m) => (m, Some(m)),
-                        hir::RepetitionRange::AtLeast(m) => (m, None),
-                        hir::RepetitionRange::Bounded(m, n) => (m, Some(n)),
-                    };
-                    repeat_range_literals(
-                        &x.hir, min, max, x.greedy, lits, union_required);
-                }
-            }
-        }
-        HirKind::Concat(ref es) if es.is_empty() => {}
-        HirKind::Concat(ref es) if es.len() == 1 => {
-            union_required(&es[0], lits)
-        }
-        HirKind::Concat(ref es) => {
-            for e in es {
-                let mut lits2 = lits.to_empty();
-                union_required(e, &mut lits2);
-                if lits2.is_empty() {
-                    lits.cut();
-                    continue;
-                }
-                if lits2.contains_empty() {
-                    lits.cut();
-                }
-                if !lits.cross_product(&lits2) {
-                    // If this expression couldn't yield any literal that
-                    // could be extended, then we need to quit. Since we're
-                    // short-circuiting, we also need to freeze every member.
-                    lits.cut();
-                    break;
-                }
-            }
-        }
-        HirKind::Alternation(ref es) => {
-            alternate_literals(es, lits, union_required);
-        }
-        _ => lits.cut(),
-    }
-}
-
-fn repeat_range_literals<F: FnMut(&Hir, &mut Literals)>(
-    e: &Hir,
-    min: u32,
-    max: Option<u32>,
-    _greedy: bool,
-    lits: &mut Literals,
-    mut f: F,
-) {
-    if min == 0 {
-        // This is a bit conservative. If `max` is set, then we could
-        // treat this as a finite set of alternations. For now, we
-        // just treat it as `e*`.
-        lits.cut();
-    } else {
-        let n = cmp::min(lits.limit_size(), min as usize);
-        // We only extract literals from a single repetition, even though
-        // we could do more. e.g., `a{3}` will have `a` extracted instead of
-        // `aaa`. The reason is that inner literal extraction can't be unioned
-        // across repetitions. e.g., extracting `foofoofoo` from `(\w+foo){3}`
-        // is wrong.
-        f(e, lits);
-        if n < min as usize {
-            lits.cut();
-        }
-        if max.map_or(true, |max| min < max) {
-            lits.cut();
-        }
-    }
-}
-
-fn alternate_literals<F: FnMut(&Hir, &mut Literals)>(
-    es: &[Hir],
-    lits: &mut Literals,
-    mut f: F,
-) {
-    let mut lits2 = lits.to_empty();
-    for e in es {
-        let mut lits3 = lits.to_empty();
-        lits3.set_limit_size(lits.limit_size() / 5);
-        f(e, &mut lits3);
-        if lits3.is_empty() || !lits2.union(lits3) {
-            // If we couldn't find suffixes for *any* of the
-            // alternates, then the entire alternation has to be thrown
-            // away and any existing members must be frozen. Similarly,
-            // if the union couldn't complete, stop and freeze.
-            lits.cut();
-            return;
-        }
-    }
-    // All we do at the moment is look for prefixes and suffixes. If both
-    // are empty, then we report nothing. We should be able to do better than
-    // this, but we'll need something more expressive than just a "set of
-    // literals."
-    let lcp = lits2.longest_common_prefix();
-    let lcs = lits2.longest_common_suffix();
-    if !lcp.is_empty() {
-        lits.cross_add(lcp);
-    }
-    lits.cut();
-    if !lcs.is_empty() {
-        lits.add(Literal::empty());
-        lits.add(Literal::new(lcs.to_vec()));
-    }
-}
-
-/// Return the number of characters in the given class.
-fn count_unicode_class(cls: &hir::ClassUnicode) -> u32 {
-    cls.iter().map(|r| 1 + (r.end() as u32 - r.start() as u32)).sum()
-}
-
-/// Return the number of bytes in the given class.
-fn count_byte_class(cls: &hir::ClassBytes) -> u32 {
-    cls.iter().map(|r| 1 + (r.end() as u32 - r.start() as u32)).sum()
-}
-
-/// Converts an arbitrary sequence of bytes to a literal suitable for building
-/// a regular expression.
-fn bytes_to_regex(bs: &[u8]) -> String {
-    let mut s = String::with_capacity(bs.len());
-    for &b in bs {
-        s.push_str(&format!("\\x{:02x}", b));
-    }
-    s
-}
-
-/// Converts arbitrary bytes to a nice string.
-fn show(bs: &[u8]) -> String {
-    // Why aren't we using this to feed to the regex? Doesn't really matter
-    // I guess. ---AG
-    use std::ascii::escape_default;
-    use std::str;
-
-    let mut nice = String::new();
-    for &b in bs {
-        let part: Vec<u8> = escape_default(b).collect();
-        nice.push_str(str::from_utf8(&part).unwrap());
-    }
-    nice
-}
diff --git a/grep/src/nonl.rs b/grep/src/nonl.rs
deleted file mode 100644
index 3beb5f61..00000000
--- a/grep/src/nonl.rs
+++ /dev/null
@@ -1,74 +0,0 @@
-use syntax::hir::{self, Hir, HirKind};
-
-use {Error, Result};
-
-/// Returns a new expression that is guaranteed to never match the given
-/// ASCII character.
-///
-/// If the expression contains the literal byte, then an error is returned.
-///
-/// If `byte` is not an ASCII character (i.e., greater than `0x7F`), then this
-/// function panics.
-pub fn remove(expr: Hir, byte: u8) -> Result<Hir> {
-    assert!(byte <= 0x7F);
-    let chr = byte as char;
-    assert!(chr.len_utf8() == 1);
-
-    Ok(match expr.into_kind() {
-        HirKind::Empty => Hir::empty(),
-        HirKind::Literal(hir::Literal::Unicode(c)) => {
-            if c == chr {
-                return Err(Error::LiteralNotAllowed(chr));
-            }
-            Hir::literal(hir::Literal::Unicode(c))
-        }
-        HirKind::Literal(hir::Literal::Byte(b)) => {
-            if b as char == chr {
-                return Err(Error::LiteralNotAllowed(chr));
-            }
-            Hir::literal(hir::Literal::Byte(b))
-        }
-        HirKind::Class(hir::Class::Unicode(mut cls)) => {
-            let remove = hir::ClassUnicode::new(Some(
-                hir::ClassUnicodeRange::new(chr, chr),
-            ));
-            cls.difference(&remove);
-            if cls.iter().next().is_none() {
-                return Err(Error::LiteralNotAllowed(chr));
-            }
-            Hir::class(hir::Class::Unicode(cls))
-        }
-        HirKind::Class(hir::Class::Bytes(mut cls)) => {
-            let remove = hir::ClassBytes::new(Some(
-                hir::ClassBytesRange::new(byte, byte),
-            ));
-            cls.difference(&remove);
-            if cls.iter().next().is_none() {
-                return Err(Error::LiteralNotAllowed(chr));
-            }
-            Hir::class(hir::Class::Bytes(cls))
-        }
-        HirKind::Anchor(x) => Hir::anchor(x),
-        HirKind::WordBoundary(x) => Hir::word_boundary(x),
-        HirKind::Repetition(mut x) => {
-            x.hir = Box::new(remove(*x.hir, byte)?);
-            Hir::repetition(x)
-        }
-        HirKind::Group(mut x) => {
-            x.hir = Box::new(remove(*x.hir, byte)?);
-            Hir::group(x)
-        }
-        HirKind::Concat(xs) => {
-            let xs = xs.into_iter()
-                .map(|e| remove(e, byte))
-                .collect::<Result<Vec<Hir>>>()?;
-            Hir::concat(xs)
-        }
-        HirKind::Alternation(xs) => {
-            let xs = xs.into_iter()
-                .map(|e| remove(e, byte))
-                .collect::<Result<Vec<Hir>>>()?;
-            Hir::alternation(xs)
-        }
-    })
-}
diff --git a/grep/src/search.rs b/grep/src/search.rs
deleted file mode 100644
index af7d680d..00000000
--- a/grep/src/search.rs
+++ /dev/null
@@ -1,317 +0,0 @@
-use memchr::{memchr, memrchr};
-use syntax::ParserBuilder;
-use syntax::hir::Hir;
-use regex::bytes::{Regex, RegexBuilder};
-
-use literals::LiteralSets;
-use nonl;
-use smart_case::Cased;
-use word_boundary::strip_unicode_word_boundaries;
-use Result;
-
-/// A matched line.
-#[derive(Clone, Debug, Default, Eq, PartialEq)]
-pub struct Match {
-    start: usize,
-    end: usize,
-}
-
-impl Match {
-    /// Create a new empty match value.
-    pub fn new() -> Match {
-        Match::default()
-    }
-
-    /// Return the starting byte offset of the line that matched.
-    #[inline]
-    pub fn start(&self) -> usize {
-        self.start
-    }
-
-    /// Return the ending byte offset of the line that matched.
-    #[inline]
-    pub fn end(&self) -> usize {
-        self.end
-    }
-}
-
-/// A fast line oriented regex searcher.
-#[derive(Clone, Debug)]
-pub struct Grep {
-    re: Regex,
-    required: Option<Regex>,
-    opts: Options,
-}
-
-/// A builder for a grep searcher.
-#[derive(Clone, Debug)]
-pub struct GrepBuilder {
-    pattern: String,
-    opts: Options,
-}
-
-#[derive(Clone, Debug)]
-struct Options {
-    case_insensitive: bool,
-    case_smart: bool,
-    line_terminator: u8,
-    size_limit: usize,
-    dfa_size_limit: usize,
-}
-
-impl Default for Options {
-    fn default() -> Options {
-        Options {
-            case_insensitive: false,
-            case_smart: false,
-            line_terminator: b'\n',
-            size_limit: 10 * (1 << 20),
-            dfa_size_limit: 10 * (1 << 20),
-        }
-    }
-}
-
-impl GrepBuilder {
-    /// Create a new builder for line searching.
-    ///
-    /// The pattern given should be a regular expression. The precise syntax
-    /// supported is documented on the regex crate.
-    pub fn new(pattern: &str) -> GrepBuilder {
-        GrepBuilder {
-            pattern: pattern.to_string(),
-            opts: Options::default(),
-        }
-    }
-
-    /// Set the line terminator.
-    ///
-    /// The line terminator can be any ASCII character and serves to delineate
-    /// the match boundaries in the text searched.
-    ///
-    /// This panics if `ascii_byte` is greater than `0x7F` (i.e., not ASCII).
-    pub fn line_terminator(mut self, ascii_byte: u8) -> GrepBuilder {
-        assert!(ascii_byte <= 0x7F);
-        self.opts.line_terminator = ascii_byte;
-        self
-    }
-
-    /// Set the case sensitive flag (`i`) on the regex.
-    pub fn case_insensitive(mut self, yes: bool) -> GrepBuilder {
-        self.opts.case_insensitive = yes;
-        self
-    }
-
-    /// Whether to enable smart case search or not (disabled by default).
-    ///
-    /// Smart case uses case insensitive search if the pattern contains only
-    /// lowercase characters (ignoring any characters which immediately follow
-    /// a '\'). Otherwise, a case sensitive search is used instead.
-    ///
-    /// Enabling the case_insensitive flag overrides this.
-    pub fn case_smart(mut self, yes: bool) -> GrepBuilder {
-        self.opts.case_smart = yes;
-        self
-    }
-
-    /// Set the approximate size limit of the compiled regular expression.
-    ///
-    /// This roughly corresponds to the number of bytes occupied by a
-    /// single compiled program. If the program exceeds this number, then a
-    /// compilation error is returned.
-    pub fn size_limit(mut self, limit: usize) -> GrepBuilder {
-        self.opts.size_limit = limit;
-        self
-    }
-
-    /// Set the approximate size of the cache used by the DFA.
-    ///
-    /// This roughly corresponds to the number of bytes that the DFA will use
-    /// while searching.
-    ///
-    /// Note that this is a per thread limit. There is no way to set a global
-    /// limit. In particular, if a regex is used from multiple threads
-    /// simulanteously, then each thread may use up to the number of bytes
-    /// specified here.
-    pub fn dfa_size_limit(mut self, limit: usize) -> GrepBuilder {
-        self.opts.dfa_size_limit = limit;
-        self
-    }
-
-    /// Create a line searcher.
-    ///
-    /// If there was a problem parsing or compiling the regex with the given
-    /// options, then an error is returned.
-    pub fn build(self) -> Result<Grep> {
-        let expr = self.parse()?;
-        let literals = LiteralSets::create(&expr);
-        let re = self.regex(&expr)?;
-        let required = match literals.to_regex_builder() {
-            Some(builder) => Some(self.regex_build(builder)?),
-            None => {
-                match strip_unicode_word_boundaries(&expr) {
-                    None => None,
-                    Some(expr) => {
-                        debug!("Stripped Unicode word boundaries. \
-                                New AST:\n{:?}", expr);
-                        self.regex(&expr).ok()
-                    }
-                }
-            }
-        };
-        Ok(Grep {
-            re: re,
-            required: required,
-            opts: self.opts,
-        })
-    }
-
-    /// Creates a new regex from the given expression with the current
-    /// configuration.
-    fn regex(&self, expr: &Hir) -> Result<Regex> {
-        let mut builder = RegexBuilder::new(&expr.to_string());
-        builder.unicode(true);
-        self.regex_build(builder)
-    }
-
-    /// Builds a new regex from the given builder using the caller's settings.
-    fn regex_build(&self, mut builder: RegexBuilder) -> Result<Regex> {
-        builder
-            .multi_line(true)
-            .size_limit(self.opts.size_limit)
-            .dfa_size_limit(self.opts.dfa_size_limit)
-            .build()
-            .map_err(From::from)
-    }
-
-    /// Parses the underlying pattern and ensures the pattern can never match
-    /// the line terminator.
-    fn parse(&self) -> Result<Hir> {
-        let expr = ParserBuilder::new()
-            .allow_invalid_utf8(true)
-            .case_insensitive(self.is_case_insensitive()?)
-            .multi_line(true)
-            .build()
-            .parse(&self.pattern)?;
-        debug!("original regex HIR pattern:\n{}", expr);
-        let expr = nonl::remove(expr, self.opts.line_terminator)?;
-        debug!("transformed regex HIR pattern:\n{}", expr);
-        Ok(expr)
-    }
-
-    /// Determines whether the case insensitive flag should be enabled or not.</