Code cleanups.

Author: thejpster

src/filesystem/files.rs

@@ -211,7 +211,10 @@ pub(crate) struct FileInfo {
     pub(crate) file_id: RawFile,
     /// The unique ID for the volume this directory is on
     pub(crate) volume_id: RawVolume,
-    /// The current cluster, and how many bytes that short-cuts us
+    /// The last cluster we accessed, and how many bytes that short-cuts us.
+    ///
+    /// This saves us walking from the very start of the FAT chain when we move
+    /// forward through a file.
     pub(crate) current_cluster: (u32, ClusterId),
     /// How far through the file we've read (in bytes).
     pub(crate) current_offset: u32,
@@ -236,41 +239,30 @@ impl FileInfo {
 
     /// Seek to a new position in the file, relative to the start of the file.
     pub fn seek_from_start(&mut self, offset: u32) -> Result<(), FileError> {
-        if offset <= self.entry.size {
-            self.current_offset = offset;
-            if offset < self.current_cluster.0 {
-                // Back to start
-                self.current_cluster = (0, self.entry.cluster);
-            }
-            Ok(())
-        } else {
-            Err(FileError::InvalidOffset)
+        if offset > self.entry.size {
+            return Err(FileError::InvalidOffset);
         }
+        self.current_offset = offset;
+        Ok(())
     }
 
     /// Seek to a new position in the file, relative to the end of the file.
     pub fn seek_from_end(&mut self, offset: u32) -> Result<(), FileError> {
-        if offset <= self.entry.size {
-            self.current_offset = self.entry.size - offset;
-            if self.current_offset < self.current_cluster.0 {
-                // Back to start
-                self.current_cluster = (0, self.entry.cluster);
-            }
-            Ok(())
-        } else {
-            Err(FileError::InvalidOffset)
+        if offset > self.entry.size {
+            return Err(FileError::InvalidOffset);
         }
+        self.current_offset = self.entry.size - offset;
+        Ok(())
     }
 
     /// Seek to a new position in the file, relative to the current position.
     pub fn seek_from_current(&mut self, offset: i32) -> Result<(), FileError> {
         let new_offset = i64::from(self.current_offset) + i64::from(offset);
-        if new_offset >= 0 && new_offset <= i64::from(self.entry.size) {
-            self.current_offset = new_offset as u32;
-            Ok(())
-        } else {
-            Err(FileError::InvalidOffset)
+        if new_offset < 0 || new_offset > i64::from(self.entry.size) {
+            return Err(FileError::InvalidOffset);
         }
+        self.current_offset = new_offset as u32;
+        Ok(())
     }
 
     /// Amount of file left to read.
@@ -281,7 +273,6 @@ impl FileInfo {
     /// Update the file's length.
     pub(crate) fn update_length(&mut self, new: u32) {
         self.entry.size = new;
-        self.entry.size = new;
     }
 }
 

src/volume_mgr.rs

@@ -1045,7 +1045,7 @@ where
 
     /// This function turns `desired_offset` into an appropriate block to be
     /// read. It either calculates this based on the start of the file, or
-    /// from the last cluster we read - whichever is better.
+    /// from the given start point - whichever is better.
     ///
     /// Returns:
     ///
@@ -1062,15 +1062,16 @@ where
         let bytes_per_cluster = match &self.open_volumes[volume_idx].volume_type {
             VolumeType::Fat(fat) => fat.bytes_per_cluster(),
         };
-        // How many clusters forward do we need to go?
+        // do we need to be before our start point?
         if desired_offset < start.0 {
             // user wants to go backwards - start from the beginning of the file
             // because the FAT is only a singly-linked list.
             start.0 = 0;
             start.1 = file_start;
         }
-        // walk through the FAT chain
+        // How many clusters forward do we need to go?
         let offset_from_cluster = desired_offset - start.0;
+        // walk through the FAT chain
         let num_clusters = offset_from_cluster / bytes_per_cluster;
         let mut block_cache = BlockCache::empty();
         for _ in 0..num_clusters {