fix: rewrite process_segment to fix #15

Recursion Versus Iteration: Debate Amongst Yourselves

Author: David James

src/utility.rs

@@ -42,4 +42,14 @@ impl<I: Read + Write + Seek> CrcStore<I> {
         self.inner_pos += i as u64;
         Ok(i)
     }
+
+    /// Reads up to `n` bytes from the `inner` I/O object using the
+    /// pre-allocated `self.buf` buffer. Updates the `hasher` accordingly.
+    /// Returns the checksum from the last 4 bytes read.
+    pub(crate) fn read_checksum(&mut self) -> Result<u32, IoError> {
+        let i = self.read_up_to(4)?;
+        assert_eq!(i, 4);
+        let bytes: [u8; 4] = self.buf[.. 4].try_into().unwrap();
+        Ok(u32::from_be_bytes(bytes))
+    }
 }

src/validate.rs

@@ -124,31 +124,23 @@ impl<I: Read + Write + Seek> CrcStore<I> {
     /// last 4 bytes.
     fn process_segment(&mut self, hasher: &mut Hasher) -> Result<u32, IoError> {
         let s = self.cfg.seg_len as u64;
-        let end_of_seg = s - (self.inner_pos % s);
-        let end_of_inner = self.inner_len - self.inner_pos;
-        let n = min(end_of_inner, end_of_seg) as usize;
-        let b = self.cfg.buf_len as usize;
-        if n <= b {
-            self.process_segment_end(hasher, n)
-        } else {
-            assert!(n > b);
-            let i = self.read_up_to(b)?;
-            let body = &self.buf[.. i];
-            hasher.update(body);
-            self.process_segment(hasher)
+        let buf_len = self.cfg.buf_len as usize;
+        loop {
+            let to_next_seg = s - (self.inner_pos % s);
+            let to_end_of_inner = self.inner_len - self.inner_pos;
+            let remain = min(to_next_seg, to_end_of_inner);
+            if remain == 4 {
+                return self.read_checksum();
+            } else if remain < 4 {
+                panic!("internal error");
+            } else {
+                let body_remain = (remain - 4) as usize;
+                let to_read = min(body_remain, buf_len);
+                let i = self.read_up_to(to_read)?;
+                assert_eq!(i, to_read);
+                let body = &self.buf[.. i];
+                hasher.update(body);
+            }
         }
     }
-
-    /// Reads up to `n` bytes from the `inner` I/O object using the
-    /// pre-allocated `self.buf` buffer. Updates the `hasher` accordingly.
-    /// Returns the checksum from the last 4 bytes read.
-    fn process_segment_end(&mut self, hasher: &mut Hasher, n: usize) -> Result<u32, IoError> {
-        assert!(n <= self.cfg.buf_len as usize);
-        let i = self.read_up_to(n)?;
-        let body = &self.buf[.. i - 4];
-        hasher.update(body);
-        let last4: [u8; 4] = self.buf[i - 4 .. i].try_into().unwrap();
-        let read_checksum = u32::from_be_bytes(last4);
-        Ok(read_checksum)
-    }
 }