Wrap all comments to 80 characters

Author: zakcutner

src/lib.rs

@@ -1,6 +1,7 @@
-//! A fast implementation of single-pattern substring search using SIMD acceleration, based on the
-//! work [presented by Wojciech Muła](http://0x80.pl/articles/simd-strfind.html). For a
-//! fast multi-pattern substring search algorithm, see instead the [`aho-corasick`
+//! A fast implementation of single-pattern substring search using SIMD
+//! acceleration, based on the work [presented by Wojciech
+//! Muła](http://0x80.pl/articles/simd-strfind.html). For a fast multi-pattern
+//! substring search algorithm, see instead the [`aho-corasick`
 //! crate](https://github.com/BurntSushi/aho-corasick).
 //!
 //! # Example

src/x86/avx2/deprecated/rust.rs

@@ -81,8 +81,8 @@ fn strstr_rabin_karp(haystack: &[u8], needle: &[u8]) -> bool {
     false
 }
 
-/// Similar to `strstr_avx2_original` implementation, but adapted for safety to prevent reading past
-/// the end of the haystack.
+/// Similar to `strstr_avx2_original` implementation, but adapted for safety to
+/// prevent reading past the end of the haystack.
 #[target_feature(enable = "avx2")]
 pub unsafe fn strstr_avx2_rust(haystack: &[u8], needle: &[u8]) -> bool {
     match needle.len() {

src/x86/avx2/mod.rs

@@ -11,8 +11,8 @@ use std::arch::x86::*;
 use std::arch::x86_64::*;
 use std::mem;
 
-/// Rolling hash for the simple Rabin-Karp implementation. As a hashing function, the sum of all the
-/// bytes is computed.
+/// Rolling hash for the simple Rabin-Karp implementation. As a hashing
+/// function, the sum of all the bytes is computed.
 #[derive(Clone, Copy, Default, PartialEq)]
 struct ScalarHash(usize);
 
@@ -38,8 +38,9 @@ impl ScalarHash {
     }
 }
 
-/// Represents an SIMD register type that is x86-specific (but could be used more generically) in
-/// order to share functionality between SSE2, AVX2 and possibly future implementations.
+/// Represents an SIMD register type that is x86-specific (but could be used
+/// more generically) in order to share functionality between SSE2, AVX2 and
+/// possibly future implementations.
 trait Vector: Copy {
     unsafe fn set1_epi8(a: i8) -> Self;
 
@@ -116,9 +117,10 @@ impl Vector for __m256i {
     }
 }
 
-/// Hash of the first and "last" bytes in the needle for use with the SIMD algorithm implemented by
-/// `Avx2Searcher::vector_search_in`. As explained, any byte can be chosen to represent the "last"
-/// byte of the hash to prevent worst-case attacks.
+/// Hash of the first and "last" bytes in the needle for use with the SIMD
+/// algorithm implemented by `Avx2Searcher::vector_search_in`. As explained, any
+/// byte can be chosen to represent the "last" byte of the hash to prevent
+/// worst-case attacks.
 struct VectorHash<V: Vector> {
     first: V,
     last: V,
@@ -136,30 +138,36 @@ impl<V: Vector> VectorHash<V> {
 
 macro_rules! avx2_searcher {
     ($name:ident, $size:literal, $memcmp:path) => {
-        /// Single-substring searcher using an AVX2 algorithm based on the "Generic SIMD" algorithm
-        /// [presented by Wojciech Muła](http://0x80.pl/articles/simd-strfind.html).
+        /// Single-substring searcher using an AVX2 algorithm based on the
+        /// "Generic SIMD" algorithm [presented by Wojciech
+        /// Muła](http://0x80.pl/articles/simd-strfind.html).
         ///
-        /// It is similar to the Rabin-Karp algorithm, except that the hash is not rolling and is
-        /// calculated for several lanes at once. It begins by picking the first byte in the needle
-        /// and checking at which positions in the haystack it occurs. Any position where it does
-        /// not can be immediately discounted as a potential match.
+        /// It is similar to the Rabin-Karp algorithm, except that the hash is
+        /// not rolling and is calculated for several lanes at once. It begins
+        /// by picking the first byte in the needle and checking at which
+        /// positions in the haystack it occurs. Any position where it does not
+        /// can be immediately discounted as a potential match.
         ///
-        /// We then repeat this idea with a second byte in the needle (where the haystack is
-        /// suitably offset) and take a bitwise AND to further limit the possible positions the
-        /// needle can match in. Any remaining positions are fully evaluated using an equality
-        /// comparison with the needle.
+        /// We then repeat this idea with a second byte in the needle (where the
+        /// haystack is suitably offset) and take a bitwise AND to further limit
+        /// the possible positions the needle can match in. Any remaining
+        /// positions are fully evaluated using an equality comparison with the
+        /// needle.
         ///
-        /// Originally, the algorithm always used the last byte for this second byte. Whilst this is
-        /// often the most efficient option, it is vulnerable to a worst-case attack and so this
-        /// implementation instead allows any byte (including a random one) to be chosen.
+        /// Originally, the algorithm always used the last byte for this second
+        /// byte. Whilst this is often the most efficient option, it is
+        /// vulnerable to a worst-case attack and so this implementation instead
+        /// allows any byte (including a random one) to be chosen.
         ///
-        /// In the case where the needle is not a multiple of the number of SIMD lanes, the last
-        /// chunk is made up of a partial overlap with the penultimate chunk to avoid reading random
-        /// memory, differing from the original implementation. In this case, a mask is used to
-        /// prevent performing an equality comparison on the same position twice.
+        /// In the case where the needle is not a multiple of the number of SIMD
+        /// lanes, the last chunk is made up of a partial overlap with the
+        /// penultimate chunk to avoid reading random memory, differing from the
+        /// original implementation. In this case, a mask is used to prevent
+        /// performing an equality comparison on the same position twice.
         ///
-        /// When the haystack is too short for an AVX2 register, a similar SSE2 fallback is used
-        /// instead. Finally, for very short haystacks there is a scalar Rabin-Karp implementation.
+        /// When the haystack is too short for an AVX2 register, a similar SSE2
+        /// fallback is used instead. Finally, for very short haystacks there is
+        /// a scalar Rabin-Karp implementation.
         pub struct $name {
             needle: Box<[u8]>,
             position: usize,
@@ -169,15 +177,16 @@ macro_rules! avx2_searcher {
         }
 
         impl $name {
-            /// Creates a new searcher for `needle`. By default, `position` is set to the last
-            /// character in the needle.
+            /// Creates a new searcher for `needle`. By default, `position` is
+            /// set to the last character in the needle.
             #[target_feature(enable = "avx2")]
             pub unsafe fn new(needle: Box<[u8]>) -> Self {
                 let position = needle.len() - 1;
                 Self::with_position(needle, position)
             }
 
-            /// Same as `new` but allows additionally specifying the `position` to use.
+            /// Same as `new` but allows additionally specifying the `position`
+            /// to use.
             #[target_feature(enable = "avx2")]
             pub unsafe fn with_position(needle: Box<[u8]>, position: usize) -> Self {
                 assert!(!needle.is_empty());
@@ -344,12 +353,14 @@ avx2_searcher!(Avx2Searcher11, 11, memcmp::memcmp10);
 avx2_searcher!(Avx2Searcher12, 12, memcmp::memcmp11);
 avx2_searcher!(Avx2Searcher13, 13, memcmp::memcmp12);
 
-/// Single-substring searcher based on `Avx2Searcher` but with dynamic algorithm selection.
+/// Single-substring searcher based on `Avx2Searcher` but with dynamic algorithm
+/// selection.
 ///
-/// It has specialized cases for zero-length needles, which are found in all haystacks, and
-/// one-length needles, which uses `MemchrSearcher`. For needles up to a length of thirteen it uses
-/// specialized versions of `Avx2Searcher`, finally falling back to the generic version of
-/// `Avx2Searcher` for longer needles.
+/// It has specialized cases for zero-length needles, which are found in all
+/// haystacks, and one-length needles, which uses `MemchrSearcher`. For needles
+/// up to a length of thirteen it uses specialized versions of `Avx2Searcher`,
+/// finally falling back to the generic version of `Avx2Searcher` for longer
+/// needles.
 pub enum DynamicAvx2Searcher {
     /// Specialization for needles with length 0.
     N0,
@@ -384,8 +395,8 @@ pub enum DynamicAvx2Searcher {
 }
 
 impl DynamicAvx2Searcher {
-    /// Creates a new searcher for `needle`. By default, `position` is set to the last character in
-    /// the needle.
+    /// Creates a new searcher for `needle`. By default, `position` is set to
+    /// the last character in the needle.
     #[target_feature(enable = "avx2")]
     pub unsafe fn new(needle: Box<[u8]>) -> Self {
         let position = needle.len() - 1;