From 076eeff3eaa76700e0ce8a4835c26aca46726bd0 Mon Sep 17 00:00:00 2001
From: Andrew Gallant <jamslam@gmail.com>
Date: Fri, 5 Aug 2016 00:10:58 -0400
Subject: [PATCH] update
---
grep/src/search.rs | 20 ++++++++++++++++----
src/main.rs | 16 +++++++++++-----
2 files changed, 27 insertions(+), 9 deletions(-)
diff --git a/grep/src/search.rs b/grep/src/search.rs
index 915acf83..e54a4b22 100644
--- a/grep/src/search.rs
+++ b/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());
}
}
diff --git a/src/main.rs b/src/main.rs
index d93496d1..999b6d98 100644
--- a/src/main.rs
+++ b/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)
}