Merge branch 'main' into 7903_pretty_print

Author: irbeam256

Cargo.lock

@@ -349,7 +349,7 @@ walkdir = "2.5"
 winapi-util = "0.1.8"
 windows-sys = { version = "0.59.0", default-features = false }
 xattr = "1.3.1"
-zip = { version = "2.2.2", default-features = false, features = ["deflate"] }
+zip = { version = "3.0.0", default-features = false, features = ["deflate"] }
 
 hex = "0.4.3"
 md-5 = "0.10.6"

Cargo.toml

@@ -2576,26 +2576,21 @@ fn display_items(
 
         for item in items {
             #[cfg(unix)]
-            if config.inode || config.alloc_size {
-                let more_info = display_additional_leading_info(
-                    item,
-                    &padding_collection,
-                    config,
-                    &mut state.out,
-                )?;
-
-                write!(state.out, "{more_info}")?;
-            }
+            let should_display_leading_info = config.inode || config.alloc_size;
             #[cfg(not(unix))]
-            if config.alloc_size {
+            let should_display_leading_info = config.alloc_size;
+
+            if should_display_leading_info {
                 let more_info = display_additional_leading_info(
                     item,
                     &padding_collection,
                     config,
                     &mut state.out,
                 )?;
+
                 write!(state.out, "{more_info}")?;
             }
+
             display_item_long(item, &padding_collection, config, state, dired, quoted)?;
         }
     } else {

src/uu/ls/src/ls.rs

@@ -20,10 +20,10 @@ path = "src/pr.rs"
 [dependencies]
 clap = { workspace = true }
 uucore = { workspace = true, features = ["entries"] }
-quick-error = { workspace = true }
 itertools = { workspace = true }
 regex = { workspace = true }
 chrono = { workspace = true }
+thiserror = { workspace = true }
 
 [[bin]]
 name = "pr"

src/uu/pr/Cargo.toml

@@ -9,14 +9,13 @@
 use chrono::{DateTime, Local};
 use clap::{Arg, ArgAction, ArgMatches, Command};
 use itertools::Itertools;
-use quick_error::ResultExt;
 use regex::Regex;
 use std::fs::{File, metadata};
 use std::io::{BufRead, BufReader, Lines, Read, Write, stdin, stdout};
 #[cfg(unix)]
 use std::os::unix::fs::FileTypeExt;
+use thiserror::Error;
 
-use quick_error::quick_error;
 use uucore::display::Quotable;
 use uucore::error::UResult;
 use uucore::{format_usage, help_about, help_section, help_usage};
@@ -134,35 +133,21 @@ impl From<std::io::Error> for PrError {
     }
 }
 
-quick_error! {
-    #[derive(Debug)]
-    enum PrError {
-        Input(err: std::io::Error, path: String) {
-            context(path: &'a str, err: std::io::Error) -> (err, path.to_owned())
-            display("pr: Reading from input {path} gave error")
-            source(err)
-        }
-
-        UnknownFiletype(path: String) {
-            display("pr: {path}: unknown filetype")
-        }
-
-        EncounteredErrors(msg: String) {
-            display("pr: {msg}")
-        }
-
-        IsDirectory(path: String) {
-            display("pr: {path}: Is a directory")
-        }
-
-        IsSocket(path: String) {
-            display("pr: cannot open {path}, Operation not supported on socket")
-        }
-
-        NotExists(path: String) {
-            display("pr: cannot open {path}, No such file or directory")
-        }
-    }
+#[derive(Debug, Error)]
+enum PrError {
+    #[error("pr: Reading from input {1} gave error")]
+    Input(std::io::Error, String),
+    #[error("pr: {0}: unknown filetype")]
+    UnknownFiletype(String),
+    #[error("pr: {0}")]
+    EncounteredErrors(String),
+    #[error("pr: {0}: Is a directory")]
+    IsDirectory(String),
+    #[cfg(not(windows))]
+    #[error("pr: cannot open {0}, Operation not supported on socket")]
+    IsSocket(String),
+    #[error("pr: cannot open {0}, No such file or directory")]
+    NotExists(String),
 }
 
 pub fn uu_app() -> Command {
@@ -795,9 +780,9 @@ fn open(path: &str) -> Result<Box<dyn Read>, PrError> {
                 #[cfg(unix)]
                 ft if ft.is_socket() => Err(PrError::IsSocket(path_string)),
                 ft if ft.is_dir() => Err(PrError::IsDirectory(path_string)),
-                ft if ft.is_file() || ft.is_symlink() => {
-                    Ok(Box::new(File::open(path).context(path)?) as Box<dyn Read>)
-                }
+                ft if ft.is_file() || ft.is_symlink() => Ok(Box::new(
+                    File::open(path).map_err(|e| PrError::Input(e, path.to_string()))?,
+                ) as Box<dyn Read>),
                 _ => Err(PrError::UnknownFiletype(path_string)),
             }
         })

src/uu/pr/src/pr.rs

@@ -32,7 +32,7 @@ use libc::S_IFIFO;
 #[cfg(any(target_os = "linux", target_os = "android"))]
 use uucore::pipes::{pipe, splice, splice_exact};
 
-const BUF_SIZE: usize = 16 * 1024;
+const BUF_SIZE: usize = 256 * 1024;
 #[cfg(any(target_os = "linux", target_os = "android"))]
 const SPLICE_SIZE: usize = 128 * 1024;
 
@@ -197,6 +197,23 @@ pub(crate) fn count_bytes_fast<T: WordCountable>(handle: &mut T) -> (usize, Opti
     }
 }
 
+/// A simple structure used to align a BUF_SIZE buffer to 32-byte boundary.
+///
+/// This is useful as bytecount uses 256-bit wide vector operations that run much
+/// faster on aligned data (at least on x86 with AVX2 support).
+#[repr(align(32))]
+struct AlignedBuffer {
+    data: [u8; BUF_SIZE],
+}
+
+impl Default for AlignedBuffer {
+    fn default() -> Self {
+        Self {
+            data: [0; BUF_SIZE],
+        }
+    }
+}
+
 /// Returns a WordCount that counts the number of bytes, lines, and/or the number of Unicode characters encoded in UTF-8 read via a Reader.
 ///
 /// This corresponds to the `-c`, `-l` and `-m` command line flags to wc.
@@ -213,9 +230,9 @@ pub(crate) fn count_bytes_chars_and_lines_fast<
     handle: &mut R,
 ) -> (WordCount, Option<io::Error>) {
     let mut total = WordCount::default();
-    let mut buf = [0; BUF_SIZE];
+    let buf: &mut [u8] = &mut AlignedBuffer::default().data;
     loop {
-        match handle.read(&mut buf) {
+        match handle.read(buf) {
             Ok(0) => return (total, None),
             Ok(n) => {
                 if COUNT_BYTES {