Use find_byte (memchr) in substring search

Author: bluss

Diff for: src/libcore/str/pattern.rs

@@ -20,6 +20,7 @@
 use prelude::v1::*;
 
 use cmp;
+use slice;
 use usize;
 
 // Pattern
@@ -545,6 +546,7 @@ pub struct StrSearcher<'a, 'b> {
 #[derive(Clone, Debug)]
 enum StrSearcherImpl {
     Empty(EmptyNeedle),
+    Single(SingleByte),
     TwoWay(TwoWaySearcher),
 }
 
@@ -556,6 +558,15 @@ struct EmptyNeedle {
     is_match_bw: bool,
 }
 
+#[derive(Clone, Debug)]
+struct SingleByte {
+    byte: u8,
+    position: usize,
+    end: usize,
+    is_match_fw: bool,
+    is_match_bw: bool,
+}
+
 impl<'a, 'b> StrSearcher<'a, 'b> {
     fn new(haystack: &'a str, needle: &'b str) -> StrSearcher<'a, 'b> {
         if needle.is_empty() {
@@ -569,6 +580,19 @@ impl<'a, 'b> StrSearcher<'a, 'b> {
                     is_match_bw: true,
                 }),
             }
+        } else if needle.len() == 1 {
+            // Note: A single byte needle must have a single ASCII byte.
+            StrSearcher {
+                haystack: haystack,
+                needle: needle,
+                searcher: StrSearcherImpl::Single(SingleByte {
+                    byte: needle.as_bytes()[0],
+                    position: 0,
+                    end: haystack.len(),
+                    is_match_fw: false,
+                    is_match_bw: false,
+                }),
+            }
         } else {
             StrSearcher {
                 haystack: haystack,
@@ -601,6 +625,24 @@ unsafe impl<'a, 'b> Searcher<'a> for StrSearcher<'a, 'b> {
                     }
                 }
             }
+            StrSearcherImpl::Single(ref mut searcher) => {
+                let pos = searcher.position;
+                if searcher.is_match_fw {
+                    searcher.is_match_fw = false;
+                    searcher.position += 1;
+                    SearchStep::Match(pos, pos + 1)
+                } else {
+                    match slice::bytes::find_byte(searcher.byte,
+                                                  &self.haystack.as_bytes()[pos..]) {
+                        None => SearchStep::Done,
+                        Some(index) => {
+                            searcher.position += index;
+                            searcher.is_match_fw = true;
+                            SearchStep::Reject(pos, searcher.position)
+                        }
+                    }
+                }
+            }
             StrSearcherImpl::TwoWay(ref mut searcher) => {
                 // TwoWaySearcher produces valid *Match* indices that split at char boundaries
                 // as long as it does correct matching and that haystack and needle are
@@ -641,6 +683,18 @@ unsafe impl<'a, 'b> Searcher<'a> for StrSearcher<'a, 'b> {
                     }
                 }
             }
+            StrSearcherImpl::Single(ref mut searcher) => {
+                let pos = searcher.position;
+                searcher.is_match_fw = false;
+                match slice::bytes::find_byte(searcher.byte,
+                                              &self.haystack.as_bytes()[pos..]) {
+                    None => None,
+                    Some(index) => {
+                        searcher.position += index;
+                        Some((index, index + 1))
+                    }
+                }
+            }
             StrSearcherImpl::TwoWay(ref mut searcher) => {
                 let is_long = searcher.memory == usize::MAX;
                 // write out `true` and `false` cases to encourage the compiler
@@ -676,6 +730,24 @@ unsafe impl<'a, 'b> ReverseSearcher<'a> for StrSearcher<'a, 'b> {
                     }
                 }
             }
+            StrSearcherImpl::Single(ref mut searcher) => {
+                let end = searcher.position;
+                if searcher.is_match_bw {
+                    searcher.is_match_bw = false;
+                    searcher.end -= 1;
+                    SearchStep::Match(end - 1, end)
+                } else {
+                    match slice::bytes::rfind_byte(searcher.byte,
+                                                   &self.haystack.as_bytes()[..end]) {
+                        None => SearchStep::Done,
+                        Some(index) => {
+                            searcher.end = index + 1;
+                            searcher.is_match_bw = true;
+                            SearchStep::Reject(index, end)
+                        }
+                    }
+                }
+            }
             StrSearcherImpl::TwoWay(ref mut searcher) => {
                 if searcher.end == 0 {
                     return SearchStep::Done;
@@ -711,6 +783,18 @@ unsafe impl<'a, 'b> ReverseSearcher<'a> for StrSearcher<'a, 'b> {
                     }
                 }
             }
+            StrSearcherImpl::Single(ref mut searcher) => {
+                let end = searcher.position;
+                searcher.is_match_bw = false;
+                match slice::bytes::rfind_byte(searcher.byte,
+                                              &self.haystack.as_bytes()[..end]) {
+                    None => None,
+                    Some(index) => {
+                        searcher.end = index;
+                        Some((index, index + 1))
+                    }
+                }
+            }
             StrSearcherImpl::TwoWay(ref mut searcher) => {
                 let is_long = searcher.memory == usize::MAX;
                 // write out `true` and `false`, like `next_match`