removed feature for 128 bit

u64 seems the max file size with Rust, which is an Exabyte.

Renamed type to Skip as this seems preferred.

Author: Gunter Schmidt

src/cmp.rs

@@ -21,22 +21,19 @@ use std::os::unix::fs::MetadataExt;
 use std::os::windows::fs::MetadataExt;
 
 /// for --bytes, so really large number limits can be expressed, like 1Y.
-#[cfg(not(feature = "cmp_bytes_limit_128_bit"))]
-pub type Bytes = u64;
-#[cfg(feature = "cmp_bytes_limit_128_bit")]
-pub type Bytes = u128;
+pub type BytesLimitU64 = u64;
 // ignore initial is currently limited to u64, as take(skip) is used.
-pub type IgnInit = u64;
+pub type SkipU64 = u64;
 
 #[derive(Clone, Debug, Default, Eq, PartialEq)]
 pub struct Params {
     executable: OsString,
     from: OsString,
     to: OsString,
     print_bytes: bool,
-    skip_a: Option<IgnInit>,
-    skip_b: Option<IgnInit>,
-    max_bytes: Option<Bytes>,
+    skip_a: Option<SkipU64>,
+    skip_b: Option<SkipU64>,
+    max_bytes: Option<BytesLimitU64>,
     verbose: bool,
     quiet: bool,
 }
@@ -74,13 +71,13 @@ pub fn parse_params<I: Iterator<Item = OsString>>(mut opts: Peekable<I>) -> Resu
     };
     let executable_str = executable.to_string_lossy().to_string();
 
-    let parse_skip = |param: &str, skip_desc: &str| -> Result<IgnInit, String> {
+    let parse_skip = |param: &str, skip_desc: &str| -> Result<SkipU64, String> {
         let suffix_start = param
             .find(|b: char| !b.is_ascii_digit())
             .unwrap_or(param.len());
-        let mut num = match param[..suffix_start].parse::<IgnInit>() {
+        let mut num = match param[..suffix_start].parse::<SkipU64>() {
             Ok(num) => num,
-            Err(e) if *e.kind() == std::num::IntErrorKind::PosOverflow => IgnInit::MAX,
+            Err(e) if *e.kind() == std::num::IntErrorKind::PosOverflow => SkipU64::MAX,
             Err(_) => {
                 return Err(format!(
                     "{executable_str}: invalid --ignore-initial value '{skip_desc}'"
@@ -91,7 +88,7 @@ pub fn parse_params<I: Iterator<Item = OsString>>(mut opts: Peekable<I>) -> Resu
         if suffix_start != param.len() {
             // Note that GNU cmp advertises supporting up to Y, but fails if you try
             // to actually use anything beyond E.
-            let multiplier: IgnInit = match &param[suffix_start..] {
+            let multiplier: SkipU64 = match &param[suffix_start..] {
                 "kB" => 1_000,
                 "K" => 1_024,
                 "MB" => 1_000_000,
@@ -105,10 +102,10 @@ pub fn parse_params<I: Iterator<Item = OsString>>(mut opts: Peekable<I>) -> Resu
                 "EB" => 1_000_000_000_000_000_000,
                 "E" => 1_152_921_504_606_846_976,
                 // TODO setting usize:MAX does not mimic GNU cmp behavior, it should be an error.
-                "ZB" => IgnInit::MAX, // 1_000_000_000_000_000_000_000,
-                "Z" => IgnInit::MAX,  // 1_180_591_620_717_411_303_424,
-                "YB" => IgnInit::MAX, // 1_000_000_000_000_000_000_000_000,
-                "Y" => IgnInit::MAX,  // 1_208_925_819_614_629_174_706_176,
+                "ZB" => SkipU64::MAX, // 1_000_000_000_000_000_000_000,
+                "Z" => SkipU64::MAX,  // 1_180_591_620_717_411_303_424,
+                "YB" => SkipU64::MAX, // 1_000_000_000_000_000_000_000_000,
+                "Y" => SkipU64::MAX,  // 1_208_925_819_614_629_174_706_176,
                 _ => {
                     return Err(format!(
                         "{executable_str}: invalid --ignore-initial value '{skip_desc}'"
@@ -118,7 +115,7 @@ pub fn parse_params<I: Iterator<Item = OsString>>(mut opts: Peekable<I>) -> Resu
 
             num = match num.overflowing_mul(multiplier) {
                 (n, false) => n,
-                _ => IgnInit::MAX,
+                _ => SkipU64::MAX,
             }
         }
 
@@ -172,10 +169,10 @@ pub fn parse_params<I: Iterator<Item = OsString>>(mut opts: Peekable<I>) -> Resu
                 let (_, arg) = param_str.split_once('=').unwrap();
                 arg.to_string()
             };
-            let max_bytes = match max_bytes.parse::<Bytes>() {
+            let max_bytes = match max_bytes.parse::<BytesLimitU64>() {
                 Ok(num) => num,
                 // TODO limit to MAX is dangerous, this should become an error like in GNU cmp.
-                Err(e) if *e.kind() == std::num::IntErrorKind::PosOverflow => Bytes::MAX,
+                Err(e) if *e.kind() == std::num::IntErrorKind::PosOverflow => BytesLimitU64::MAX,
                 Err(_) => {
                     return Err(format!(
                         "{executable_str}: invalid --bytes value '{max_bytes}'"
@@ -285,7 +282,7 @@ pub fn parse_params<I: Iterator<Item = OsString>>(mut opts: Peekable<I>) -> Resu
 
 fn prepare_reader(
     path: &OsString,
-    skip: &Option<IgnInit>,
+    skip: &Option<SkipU64>,
     params: &Params,
 ) -> Result<Box<dyn BufRead>, String> {
     let mut reader: Box<dyn BufRead> = if path == "-" {
@@ -305,8 +302,7 @@ fn prepare_reader(
 
     if let Some(skip) = skip {
         // cast as u64 must remain, because value of IgnInit data type could be changed.
-        #[allow(clippy::unnecessary_cast)]
-        if let Err(e) = io::copy(&mut reader.by_ref().take(*skip as u64), &mut io::sink()) {
+        if let Err(e) = io::copy(&mut reader.by_ref().take(*skip), &mut io::sink()) {
             return Err(format_failure_to_read_input_file(
                 &params.executable,
                 path,
@@ -328,7 +324,7 @@ pub fn cmp(params: &Params) -> Result<Cmp, String> {
     let mut from = prepare_reader(&params.from, &params.skip_a, params)?;
     let mut to = prepare_reader(&params.to, &params.skip_b, params)?;
 
-    let mut offset_width = params.max_bytes.unwrap_or(Bytes::MAX);
+    let mut offset_width = params.max_bytes.unwrap_or(BytesLimitU64::MAX);
 
     if let (Ok(a_meta), Ok(b_meta)) = (fs::metadata(&params.from), fs::metadata(&params.to)) {
         #[cfg(not(target_os = "windows"))]
@@ -343,7 +339,7 @@ pub fn cmp(params: &Params) -> Result<Cmp, String> {
             return Ok(Cmp::Different);
         }
 
-        let smaller = cmp::min(a_size, b_size) as Bytes;
+        let smaller = cmp::min(a_size, b_size) as BytesLimitU64;
         offset_width = cmp::min(smaller, offset_width);
     }
 
@@ -352,7 +348,7 @@ pub fn cmp(params: &Params) -> Result<Cmp, String> {
     // Capacity calc: at_byte width + 2 x 3-byte octal numbers + 2 x 4-byte value + 4 spaces
     let mut output = Vec::<u8>::with_capacity(offset_width + 3 * 2 + 4 * 2 + 4);
 
-    let mut at_byte: Bytes = 1;
+    let mut at_byte: BytesLimitU64 = 1;
     let mut at_line: u64 = 1;
     let mut start_of_line = true;
     let mut stdout = BufWriter::new(io::stdout().lock());
@@ -403,7 +399,7 @@ pub fn cmp(params: &Params) -> Result<Cmp, String> {
         if from_buf[..consumed] == to_buf[..consumed] {
             let last = from_buf[..consumed].last().unwrap();
 
-            at_byte += consumed as Bytes;
+            at_byte += consumed as BytesLimitU64;
             at_line += (from_buf[..consumed].iter().filter(|&c| *c == b'\n').count()) as u64;
 
             start_of_line = *last == b'\n';
@@ -592,7 +588,7 @@ fn format_visible_byte(byte: u8) -> String {
 fn format_verbose_difference(
     from_byte: u8,
     to_byte: u8,
-    at_byte: Bytes,
+    at_byte: BytesLimitU64,
     offset_width: usize,
     output: &mut Vec<u8>,
     params: &Params,
@@ -657,7 +653,13 @@ fn format_verbose_difference(
 }
 
 #[inline]
-fn report_eof(at_byte: Bytes, at_line: u64, start_of_line: bool, eof_on: &str, params: &Params) {
+fn report_eof(
+    at_byte: BytesLimitU64,
+    at_line: u64,
+    start_of_line: bool,
+    eof_on: &str,
+    params: &Params,
+) {
     if params.quiet {
         return;
     }
@@ -709,7 +711,13 @@ fn is_posix_locale() -> bool {
 }
 
 #[inline]
-fn report_difference(from_byte: u8, to_byte: u8, at_byte: Bytes, at_line: u64, params: &Params) {
+fn report_difference(
+    from_byte: u8,
+    to_byte: u8,
+    at_byte: BytesLimitU64,
+    at_line: u64,
+    params: &Params,
+) {
     if params.quiet {
         return;
     }
@@ -806,7 +814,7 @@ mod tests {
                 from: os("foo"),
                 to: os("bar"),
                 skip_a: Some(1),
-                skip_b: Some(IgnInit::MAX),
+                skip_b: Some(SkipU64::MAX),
                 ..Default::default()
             }),
             parse_params(
@@ -984,7 +992,7 @@ mod tests {
                 executable: os("cmp"),
                 from: os("foo"),
                 to: os("bar"),
-                max_bytes: Some(Bytes::MAX),
+                max_bytes: Some(BytesLimitU64::MAX),
                 ..Default::default()
             }),
             parse_params(
@@ -1047,8 +1055,8 @@ mod tests {
                 executable: os("cmp"),
                 from: os("foo"),
                 to: os("bar"),
-                skip_a: Some(IgnInit::MAX),
-                skip_b: Some(IgnInit::MAX),
+                skip_a: Some(SkipU64::MAX),
+                skip_b: Some(SkipU64::MAX),
                 ..Default::default()
             }),
             parse_params(
@@ -1119,12 +1127,12 @@ mod tests {
         .enumerate()
         {
             let values = [
-                (1_000 as IgnInit)
+                (1_000 as SkipU64)
                     .checked_pow((i + 1) as u32)
-                    .unwrap_or(IgnInit::MAX),
-                (1024 as IgnInit)
+                    .unwrap_or(SkipU64::MAX),
+                (1024 as SkipU64)
                     .checked_pow((i + 1) as u32)
-                    .unwrap_or(IgnInit::MAX),
+                    .unwrap_or(SkipU64::MAX),
             ];
             for (j, v) in values.iter().enumerate() {
                 assert_eq!(