update

grep/src/search.rs

@@ -366,7 +366,6 @@ impl<'g, R: io::Read> GrepBuffered<'g, R> {
         let nread = try!(self.rdr.read(&mut self.b.buf[self.b.tmp.len()..]));
         // Now update our various positions.
         self.pos += self.start;
-        println!("start: {:?}, pos: {:?}", self.start, self.pos);
         self.start = 0;
         // The end is the total number of bytes read plus whatever we had for
         // leftovers.
@@ -460,18 +459,31 @@ fn s(bytes: &[u8]) -> String {
 mod tests {
     #![allow(unused_imports)]
 
+    use memchr::{memchr, memrchr};
+    use regex::bytes::Regex;
+
     use super::{Buffer, GrepBuilder, s};
 
     static SHERLOCK: &'static [u8] = include_bytes!("./data/sherlock.txt");
 
     #[test]
     fn buffered() {
+        // Find the expected number of matches and the position of the last
+        // match.
+        let re = Regex::new("Sherlock Holmes").unwrap();
+        let ms: Vec<_> = re.find_iter(SHERLOCK).collect();
+        let expected_count = ms.len();
+        let (start, end) = *ms.last().unwrap();
+        let start = memrchr(b'\n', &SHERLOCK[..start]).unwrap() + 1;
+        let end = memchr(b'\n', &SHERLOCK[end..]).unwrap() + end;
+
+        // Now compare it with what Grep finds.
         let g = GrepBuilder::new("Sherlock Holmes").create().unwrap();
         let mut bg = g.buffered_reader(Buffer::new(), SHERLOCK);
         let ms: Vec<_> = bg.iter().map(|r| r.unwrap()).collect();
         let m = ms.last().unwrap();
-        assert_eq!(91, ms.len());
-        assert_eq!(575707, m.start());
-        assert_eq!(575784, m.end());
+        assert_eq!(expected_count, ms.len());
+        assert_eq!(start, m.start());
+        assert_eq!(end, m.end());
     }
 }

src/main.rs

@@ -50,13 +50,18 @@ fn run(args: &Args) -> Result<u64> {
     if args.arg_file.is_empty() {
         unimplemented!()
     } else {
-        let searcher =
-            try!(GrepBuilder::new(&args.arg_pattern).create());
-        run_mmap(args, &searcher)
+        let searcher = try!(GrepBuilder::new(&args.arg_pattern).create());
+        if args.flag_count {
+            run_mmap_count_only(args, &searcher)
+        } else {
+            run_mmap(args, &searcher)
+        }
     }
 }
 
 fn run_mmap(args: &Args, searcher: &Grep) -> Result<u64> {
+    unimplemented!()
+    /*
     for m in searcher.iter(text) {
         if !args.flag_count {
             try!(wtr.write(&text[m.start()..m.end()]));
@@ -65,17 +70,18 @@ fn run_mmap(args: &Args, searcher: &Grep) -> Result<u64> {
         count += 1;
     }
     Ok(count)
+    */
 }
 
 #[inline(never)]
-fn run_mmap_count_only(args: &Args, searcher: &LineSearcher) -> Result<u64> {
+fn run_mmap_count_only(args: &Args, searcher: &Grep) -> Result<u64> {
     use memmap::{Mmap, Protection};
 
     assert!(args.arg_file.len() == 1);
     let mut wtr = io::BufWriter::new(io::stdout());
     let mmap = try!(Mmap::open_path(&args.arg_file[0], Protection::Read));
     let text = unsafe { mmap.as_slice() };
-    let count = searcher.search(text).last().map_or(0, |m| m.count + 1);
+    let count = searcher.iter(text).count() as u64;
     try!(writeln!(wtr, "{}", count));
     Ok(count)
 }