Fix clippy issues in blocksort.rs

bzip2recover.rs

@@ -298,12 +298,7 @@ fn main_help(program_name: &Path, in_filename: &Path) -> Result<(), Error> {
 
     bits_read = 0;
 
-    loop {
-        let Some(b) = input_bitstream.get_bit()? else {
-            // EOF
-            break;
-        };
-
+    while let Some(b) = input_bitstream.get_bit()? {
         buff_hi = (buff_hi << 1) | (buff_lo >> 31);
         buff_lo = (buff_lo << 1) | b as u32;
 

libbz2-rs-sys/src/blocksort.rs

@@ -516,10 +516,8 @@ fn mainQSort3(
     let mut unHi: i32;
     let mut ltLo: i32;
     let mut gtHi: i32;
-    let mut n: i32;
-    let mut m: i32;
-    let mut med: i32;
 
+    // We run into underflow issues below if lo and hi use u32.
     let mut stack = [(0i32, 0i32, 0u32); 100];
 
     stack[0] = (loSt, hiSt, dSt);
@@ -538,19 +536,18 @@ fn mainQSort3(
                 return;
             }
         } else {
-            med = median_of_3(
+            let med = median_of_3(
                 block[(ptr[lo as usize]).wrapping_add(d) as usize],
                 block[(ptr[hi as usize]).wrapping_add(d) as usize],
                 block[((ptr[((lo + hi) >> 1) as usize]).wrapping_add(d) as isize) as usize],
-            ) as i32;
+            );
             ltLo = lo;
             unLo = ltLo;
             gtHi = hi;
             unHi = gtHi;
             loop {
                 while unLo <= unHi {
-                    n = block[(ptr[unLo as usize]).wrapping_add(d) as usize] as i32 - med;
-                    match n.cmp(&0) {
+                    match u8::cmp(&block[(ptr[unLo as usize]).wrapping_add(d) as usize], &med) {
                         Ordering::Greater => break,
                         Ordering::Equal => {
                             ptr.swap(unLo as usize, ltLo as usize);
@@ -561,8 +558,7 @@ fn mainQSort3(
                     }
                 }
                 while unLo <= unHi {
-                    n = block[(ptr[unHi as usize]).wrapping_add(d) as usize] as i32 - med;
-                    match n.cmp(&0) {
+                    match u8::cmp(&block[(ptr[unHi as usize]).wrapping_add(d) as usize], &med) {
                         Ordering::Less => break,
                         Ordering::Equal => {
                             ptr.swap(unHi as usize, gtHi as usize);
@@ -583,26 +579,18 @@ fn mainQSort3(
                 stack[sp] = (lo, hi, d + 1);
                 sp += 1;
             } else {
-                n = Ord::min(ltLo - lo, unLo - ltLo);
-                let mut yyp1: i32 = lo;
-                let mut yyp2: i32 = unLo - n;
-                for _ in 0..n {
+                let n = Ord::min(ltLo - lo, unLo - ltLo);
+                for (yyp1, yyp2) in (lo..lo + n).zip(unLo - n..unLo) {
                     ptr.swap(yyp1 as usize, yyp2 as usize);
-                    yyp1 += 1;
-                    yyp2 += 1;
                 }
 
-                m = Ord::min(hi - gtHi, gtHi - unHi);
-                let mut yyp1_0: i32 = unLo;
-                let mut yyp2_0: i32 = hi - m + 1;
-                for _ in 0..m {
-                    ptr.swap(yyp1_0 as usize, yyp2_0 as usize);
-                    yyp1_0 += 1;
-                    yyp2_0 += 1;
+                let m = Ord::min(hi - gtHi, gtHi - unHi);
+                for (yyp1, yyp2) in (unLo..unLo + m).zip(hi - m + 1..hi + 1) {
+                    ptr.swap(yyp1 as usize, yyp2 as usize);
                 }
 
-                n = lo + unLo - ltLo - 1;
-                m = hi - (gtHi - unHi) + 1;
+                let n = lo + unLo - ltLo - 1;
+                let m = hi - (gtHi - unHi) + 1;
 
                 let mut next = [(lo, n, d), (m, hi, d), (n + 1, m - 1, d + 1)];
 
@@ -641,7 +629,6 @@ fn mainSort(
     let mut copyStart: [i32; 256] = [0; 256];
     let mut copyEnd: [i32; 256] = [0; 256];
     let mut c1: u8;
-    let mut numQSorted: i32;
     let mut s: u16;
     if verb >= 4 {
         debug_logln!("        main sort initialise ...");
@@ -719,7 +706,7 @@ fn mainSort(
        The main sorting loop.
     --*/
 
-    numQSorted = 0;
+    let mut numQSorted = 0;
 
     for i in 0..255 + 1 {
         /*--
@@ -745,8 +732,9 @@ fn mainSort(
             if j != ss {
                 sb = (ss << 8) + j;
                 if ftab[sb as usize] & SETMASK == 0 {
-                    let lo: i32 = (ftab[sb as usize] & CLEARMASK) as i32;
-                    let hi: i32 = ((ftab[sb as usize + 1] & CLEARMASK).wrapping_sub(1)) as i32;
+                    // It is tempting to use u32 instead, but -1/u32::MAX is actually used.
+                    let lo = (ftab[sb as usize] & CLEARMASK) as i32;
+                    let hi = ((ftab[sb as usize + 1] & CLEARMASK).wrapping_sub(1)) as i32;
 
                     if hi > lo {
                         if verb >= 4 {
@@ -896,7 +884,7 @@ fn mainSort(
             "        {} pointers, {} sorted, {} scanned",
             nblock,
             numQSorted,
-            nblock as i32 - numQSorted,
+            nblock - numQSorted as usize,
         );
     }
 }