src/ rename unused variables to avoid warnings

These vars are used in debug-only prints. Release builds elicit warnings.
jtmoon79 · Jan 9, 2023 · 8a50df1 · 8a50df1
1 parent c4e8c94
commit 8a50df1
Show file tree

Hide file tree

Showing 6 changed files with 27 additions and 27 deletions.
diff --git a/src/data/datetime.rs b/src/data/datetime.rs
@@ -4201,11 +4201,11 @@ pub fn bytes_to_regex_to_datetime(
                 }
             };
             match name_opt {
-                Some(name) => {
+                Some(_name) => {
                     dpo!(
                         "regex captures: {:2} {:<10} {:?}",
                         i,
-                        name,
+                        _name,
                         buffer_to_String_noraw(_match.as_bytes())
                     );
                 }

diff --git a/src/readers/blockreader.rs b/src/readers/blockreader.rs
@@ -853,11 +853,11 @@ impl BlockReader {
                 dpf1o!("FileXz: stream header magic bytes {:?}", buffer_);
                 if cfg!(debug_assertions) {
                     for (i, b_) in buffer_.iter().enumerate() {
-                        let b_ex = XZ_MAGIC_BYTES[i];
-                        let c_ex: char = b_ex as char;
-                        let c_: char = (*b_) as char;
-                        dpf1o!("actual {0:3} (0x{0:02X}) {1:?}", b_, c_);
-                        dpf1o!("expect {0:3} (0x{0:02X}) {1:?}\n", b_ex, c_ex);
+                        let _b_ex = XZ_MAGIC_BYTES[i];
+                        let _c_ex: char = _b_ex as char;
+                        let _c: char = (*b_) as char;
+                        dpf1o!("actual {0:3} (0x{0:02X}) {1:?}", b_, _c);
+                        dpf1o!("expect {0:3} (0x{0:02X}) {1:?}\n", _b_ex, _c_ex);
                     }
                 }
                 if buffer_ != XZ_MAGIC_BYTES {
@@ -989,8 +989,8 @@ impl BlockReader {
                                         break;
                                     }
                                 }
-                                err_ => {
-                                    dpf1o!("FileXz: err {:?}", err_);
+                                _err => {
+                                    dpf1o!("FileXz: err {:?}", _err);
                                 }
                             }
                             dpf1x!("FileXz: xz_decompress Error, return Err({:?})", err);
@@ -2004,8 +2004,8 @@ impl BlockReader {
                                 break;
                             }
                         }
-                        err_ => {
-                            dpfo!("err {:?}", err_);
+                        _err => {
+                            dpfo!("err {:?}", _err);
                         }
                     }
                     dpfx!("xz_decompress Error, return Err({:?})", err);

diff --git a/src/readers/filepreprocessor.rs b/src/readers/filepreprocessor.rs
@@ -579,8 +579,8 @@ pub fn process_path(path: &FPath) -> Vec<ProcessPathResult> {
                 dpo!("Ok({:?})", val);
                 val
             }
-            Err(err) => {
-                dpo!("Err({:?})", err);
+            Err(_err) => {
+                dpo!("Err({:?})", _err);
                 continue;
             }
         };

diff --git a/src/readers/linereader.rs b/src/readers/linereader.rs
@@ -606,8 +606,8 @@ impl LineReader {
                             dpfx!("return ResultS3LineFind::Done");
                             return Some(ResultS3LineFind::Done);
                         }
-                        ResultS3LineFind::Err(err) => {
-                            dpfx!("Err {}", err);
+                        ResultS3LineFind::Err(_err) => {
+                            dpfx!("Err {}", _err);
                             eprintln!(
                                 "ERROR: unexpected Error store in find_line_lru_cache, fileoffset {}",
                                 fileoffset

diff --git a/src/readers/syslinereader.rs b/src/readers/syslinereader.rs
@@ -1193,19 +1193,20 @@ impl SyslineReader {
 
     /// Return most-used `DateTimeParseInstrsIndex`.
     pub(crate) fn dt_pattern_index_max_count(&self) -> DateTimeParseInstrsIndex {
-        if cfg!(debug_assertions) {
-            for (_k, _v) in self.dt_patterns_counts.iter() {
-                let data_: &DateTimeParseInstr = &DATETIME_PARSE_DATAS[*_k];
-                let data_rex_: &DateTimeRegex = DATETIME_PARSE_DATAS_REGEX_VEC
-                    .get(*_k)
+        #[cfg(debug_assertions)]
+        {
+            for (k, v) in self.dt_patterns_counts.iter() {
+                let data: &DateTimeParseInstr = &DATETIME_PARSE_DATAS[*k];
+                let data_rex: &DateTimeRegex = DATETIME_PARSE_DATAS_REGEX_VEC
+                    .get(*k)
                     .unwrap();
-                dpfo!("self.dt_patterns_counts[index {:?}]={:?} is {:?}, {:?}", _k, _v, data_, data_rex_);
+                dpfo!("self.dt_patterns_counts[index {:?}]={:?} is {:?}, {:?}", k, v, data, data_rex);
             }
-            for _val in self
+            for val in self
                 .dt_patterns_indexes
                 .iter()
             {
-                dpfo!("self.dt_patterns_indexes {:?}", _val);
+                dpfo!("self.dt_patterns_indexes {:?}", val);
             }
         }
         if !self.analyzed {
@@ -1408,11 +1409,10 @@ impl SyslineReader {
             .get_key_value(&fileoffset)
         {
             Some(range_fo) => {
-                let range: &SyslineRange = range_fo.0;
                 dpfo!(
                     "hit syslines_by_range cache for FileOffset {} (found in range {:?})",
                     fileoffset,
-                    range
+                    range_fo.0
                 );
                 self.syslines_by_range_hit += 1;
                 let fo: &FileOffset = range_fo.1;

diff --git a/src/readers/syslogprocessor.rs b/src/readers/syslogprocessor.rs
@@ -448,8 +448,8 @@ impl SyslogProcessor {
         error: &Error,
     ) {
         dp_err!("{:?}", error);
-        if let Some(ref err_) = self.Error_ {
-            dp_wrn!("overwriting previous Error {:?} with Error ({:?})", err_, error);
+        if let Some(ref _err) = self.Error_ {
+            dp_wrn!("overwriting previous Error {:?} with Error ({:?})", _err, error);
         }
         self.Error_ = Some(error.to_string());
     }