pointer chasing

Signed-off-by: Alexander Droste <[email protected]>

Author: 0ax1

vortex-buffer/src/bit/buf.rs

@@ -426,48 +426,47 @@ impl BitBuffer {
             return;
         }
 
-        let buffer_ptr = self.buffer.as_ptr();
+        let is_bit_set = |byte: u8, bit_idx: usize| (byte & (1 << bit_idx)) != 0;
+
+        let mut buffer_ptr = self.buffer.as_ptr();
         let offset = self.offset;
-        let mut current_byte = offset / 8;
         let start_bit_in_byte = offset % 8;
         let mut bit_pos = 0;
 
         // Handle incomplete first byte.
         if start_bit_in_byte > 0 {
             let bits_in_first_byte = (8 - start_bit_in_byte).min(total_bits);
-            let byte = unsafe { *buffer_ptr.add(current_byte) };
+            buffer_ptr = unsafe { buffer_ptr.add(offset / 8) };
+            let byte = unsafe { *buffer_ptr };
 
             for bit_idx in 0..bits_in_first_byte {
-                let is_set = (byte & (1 << (start_bit_in_byte + bit_idx))) != 0;
-                f(bit_pos, is_set);
+                f(bit_pos, is_bit_set(byte, start_bit_in_byte + bit_idx));
             }
 
             bit_pos += bits_in_first_byte;
-            current_byte += 1;
+            buffer_ptr = unsafe { buffer_ptr.add(1) };
         }
 
         let complete_bytes = (total_bits - bit_pos) / 8;
 
         // Process complete bytes.
         for byte_idx in 0..complete_bytes {
-            let byte = unsafe { *buffer_ptr.add(current_byte + byte_idx) };
+            let byte = unsafe { *buffer_ptr };
 
             for bit_idx in 0..8 {
-                let is_set = (byte & (1 << bit_idx)) != 0;
-                f(bit_pos + byte_idx * 8 + bit_idx, is_set);
+                f(bit_pos + byte_idx * 8 + bit_idx, is_bit_set(byte, bit_idx));
             }
+            buffer_ptr = unsafe { buffer_ptr.add(1) };
         }
         bit_pos += complete_bytes * 8;
-        current_byte += complete_bytes;
 
         // Handle remaining bits at the end.
         let remaining_bits = (total_bits - bit_pos) % 8;
         if remaining_bits > 0 {
-            let byte = unsafe { *buffer_ptr.add(current_byte) };
+            let byte = unsafe { *buffer_ptr };
 
             for bit_idx in 0..remaining_bits {
-                let is_set = (byte & (1 << bit_idx)) != 0;
-                f(bit_pos + bit_idx, is_set);
+                f(bit_pos + bit_idx, is_bit_set(byte, bit_idx));
             }
         }
     }