From 1b6a04ca5504955c571d1c97504fb45ea0befee4 Mon Sep 17 00:00:00 2001 From: Valentin Popov Date: Mon, 8 Jan 2024 01:21:28 +0400 Subject: Initial vendor packages Signed-off-by: Valentin Popov --- vendor/anstyle-wincon/src/ansi.rs | 25 ++++ vendor/anstyle-wincon/src/lib.rs | 18 +++ vendor/anstyle-wincon/src/stream.rs | 178 ++++++++++++++++++++++++ vendor/anstyle-wincon/src/windows.rs | 263 +++++++++++++++++++++++++++++++++++ 4 files changed, 484 insertions(+) create mode 100644 vendor/anstyle-wincon/src/ansi.rs create mode 100644 vendor/anstyle-wincon/src/lib.rs create mode 100644 vendor/anstyle-wincon/src/stream.rs create mode 100644 vendor/anstyle-wincon/src/windows.rs (limited to 'vendor/anstyle-wincon/src') diff --git a/vendor/anstyle-wincon/src/ansi.rs b/vendor/anstyle-wincon/src/ansi.rs new file mode 100644 index 0000000..6ac7193 --- /dev/null +++ b/vendor/anstyle-wincon/src/ansi.rs @@ -0,0 +1,25 @@ +//! Low-level ANSI-styling + +/// Write ANSI colored text to the stream +pub fn write_colored( + stream: &mut S, + fg: Option, + bg: Option, + data: &[u8], +) -> std::io::Result { + let non_default = fg.is_some() || bg.is_some(); + + if non_default { + if let Some(fg) = fg { + write!(stream, "{}", fg.render_fg())?; + } + if let Some(bg) = bg { + write!(stream, "{}", bg.render_bg())?; + } + } + let written = stream.write(data)?; + if non_default { + write!(stream, "{}", anstyle::Reset.render())?; + } + Ok(written) +} diff --git a/vendor/anstyle-wincon/src/lib.rs b/vendor/anstyle-wincon/src/lib.rs new file mode 100644 index 0000000..e04fab6 --- /dev/null +++ b/vendor/anstyle-wincon/src/lib.rs @@ -0,0 +1,18 @@ +//! Styling legacy Windows terminals +//! +//! See [`WinconStream`] +//! +//! This fills a similar role as [`winapi-util`](https://crates.io/crates/winapi-util) does for +//! [`termcolor`](https://crates.io/crates/termcolor) with the differences +//! - Uses `windows-sys` rather than `winapi` +//! - Uses [`anstyle`](https://crates.io/crates/termcolor) rather than defining its own types +//! - More focused, smaller + +#![cfg_attr(docsrs, feature(doc_auto_cfg))] + +pub mod ansi; +mod stream; +#[cfg(windows)] +pub mod windows; + +pub use stream::WinconStream; diff --git a/vendor/anstyle-wincon/src/stream.rs b/vendor/anstyle-wincon/src/stream.rs new file mode 100644 index 0000000..9f10108 --- /dev/null +++ b/vendor/anstyle-wincon/src/stream.rs @@ -0,0 +1,178 @@ +/// Extend `std::io::Write` with wincon styling +pub trait WinconStream { + /// Write colored text to the stream + fn write_colored( + &mut self, + fg: Option, + bg: Option, + data: &[u8], + ) -> std::io::Result; +} + +impl WinconStream for Box { + fn write_colored( + &mut self, + fg: Option, + bg: Option, + data: &[u8], + ) -> std::io::Result { + crate::ansi::write_colored(self, fg, bg, data) + } +} + +impl WinconStream for &'_ mut Box { + fn write_colored( + &mut self, + fg: Option, + bg: Option, + data: &[u8], + ) -> std::io::Result { + (**self).write_colored(fg, bg, data) + } +} + +impl WinconStream for std::fs::File { + fn write_colored( + &mut self, + fg: Option, + bg: Option, + data: &[u8], + ) -> std::io::Result { + crate::ansi::write_colored(self, fg, bg, data) + } +} + +impl WinconStream for &'_ mut std::fs::File { + fn write_colored( + &mut self, + fg: Option, + bg: Option, + data: &[u8], + ) -> std::io::Result { + (**self).write_colored(fg, bg, data) + } +} + +impl WinconStream for Vec { + fn write_colored( + &mut self, + fg: Option, + bg: Option, + data: &[u8], + ) -> std::io::Result { + crate::ansi::write_colored(self, fg, bg, data) + } +} + +impl WinconStream for &'_ mut Vec { + fn write_colored( + &mut self, + fg: Option, + bg: Option, + data: &[u8], + ) -> std::io::Result { + (**self).write_colored(fg, bg, data) + } +} + +impl WinconStream for std::io::Stdout { + fn write_colored( + &mut self, + fg: Option, + bg: Option, + data: &[u8], + ) -> std::io::Result { + // Ensure exclusive access + self.lock().write_colored(fg, bg, data) + } +} + +impl WinconStream for std::io::Stderr { + fn write_colored( + &mut self, + fg: Option, + bg: Option, + data: &[u8], + ) -> std::io::Result { + // Ensure exclusive access + self.lock().write_colored(fg, bg, data) + } +} + +#[cfg(not(windows))] +mod platform { + use super::*; + + impl WinconStream for std::io::StdoutLock<'_> { + fn write_colored( + &mut self, + fg: Option, + bg: Option, + data: &[u8], + ) -> std::io::Result { + crate::ansi::write_colored(self, fg, bg, data) + } + } + + impl WinconStream for std::io::StderrLock<'_> { + fn write_colored( + &mut self, + fg: Option, + bg: Option, + data: &[u8], + ) -> std::io::Result { + crate::ansi::write_colored(self, fg, bg, data) + } + } +} + +#[cfg(windows)] +mod platform { + use super::*; + + impl WinconStream for std::io::StdoutLock<'_> { + fn write_colored( + &mut self, + fg: Option, + bg: Option, + data: &[u8], + ) -> std::io::Result { + let initial = crate::windows::stdout_initial_colors(); + crate::windows::write_colored(self, fg, bg, data, initial) + } + } + + impl WinconStream for std::io::StderrLock<'_> { + fn write_colored( + &mut self, + fg: Option, + bg: Option, + data: &[u8], + ) -> std::io::Result { + let initial = crate::windows::stderr_initial_colors(); + crate::windows::write_colored(self, fg, bg, data, initial) + } + } +} + +impl WinconStream for &'_ mut std::io::StdoutLock<'_> { + fn write_colored( + &mut self, + fg: Option, + bg: Option, + data: &[u8], + ) -> std::io::Result { + (**self).write_colored(fg, bg, data) + } +} + +impl WinconStream for &'_ mut std::io::StderrLock<'_> { + fn write_colored( + &mut self, + fg: Option, + bg: Option, + data: &[u8], + ) -> std::io::Result { + (**self).write_colored(fg, bg, data) + } +} diff --git a/vendor/anstyle-wincon/src/windows.rs b/vendor/anstyle-wincon/src/windows.rs new file mode 100644 index 0000000..bf1cf56 --- /dev/null +++ b/vendor/anstyle-wincon/src/windows.rs @@ -0,0 +1,263 @@ +//! Low-level wincon-styling + +use std::os::windows::io::AsHandle; +use std::os::windows::io::AsRawHandle; + +type StdioColorResult = std::io::Result<(anstyle::AnsiColor, anstyle::AnsiColor)>; +type StdioColorInnerResult = Result<(anstyle::AnsiColor, anstyle::AnsiColor), inner::IoError>; + +/// Cached [`get_colors`] call for [`std::io::stdout`] +pub fn stdout_initial_colors() -> StdioColorResult { + static INITIAL: std::sync::OnceLock = std::sync::OnceLock::new(); + INITIAL + .get_or_init(|| get_colors_(&std::io::stdout())) + .clone() + .map_err(Into::into) +} + +/// Cached [`get_colors`] call for [`std::io::stderr`] +pub fn stderr_initial_colors() -> StdioColorResult { + static INITIAL: std::sync::OnceLock = std::sync::OnceLock::new(); + INITIAL + .get_or_init(|| get_colors_(&std::io::stderr())) + .clone() + .map_err(Into::into) +} + +/// Apply colors to future writes +/// +/// **Note:** Make sure any buffers are first flushed or else these colors will apply +pub fn set_colors( + stream: &mut S, + fg: anstyle::AnsiColor, + bg: anstyle::AnsiColor, +) -> std::io::Result<()> { + set_colors_(stream, fg, bg).map_err(Into::into) +} + +fn set_colors_( + stream: &mut S, + fg: anstyle::AnsiColor, + bg: anstyle::AnsiColor, +) -> Result<(), inner::IoError> { + let handle = stream.as_handle(); + let handle = handle.as_raw_handle(); + let attributes = inner::set_colors(fg, bg); + inner::set_console_text_attributes(handle, attributes) +} + +/// Get the colors currently active on the console +pub fn get_colors(stream: &S) -> StdioColorResult { + get_colors_(stream).map_err(Into::into) +} + +fn get_colors_(stream: &S) -> StdioColorInnerResult { + let handle = stream.as_handle(); + let handle = handle.as_raw_handle(); + let info = inner::get_screen_buffer_info(handle)?; + let (fg, bg) = inner::get_colors(&info); + Ok((fg, bg)) +} + +pub(crate) fn write_colored( + stream: &mut S, + fg: Option, + bg: Option, + data: &[u8], + initial: StdioColorResult, +) -> std::io::Result { + let (initial_fg, initial_bg) = initial?; + let non_default = fg.is_some() || bg.is_some(); + + if non_default { + let fg = fg.unwrap_or(initial_fg); + let bg = bg.unwrap_or(initial_bg); + // Ensure everything is written with the last set of colors before applying the next set + stream.flush()?; + set_colors(stream, fg, bg)?; + } + let written = stream.write(data)?; + if non_default { + // Ensure everything is written with the last set of colors before applying the next set + stream.flush()?; + set_colors(stream, initial_fg, initial_bg)?; + } + Ok(written) +} + +mod inner { + use windows_sys::Win32::System::Console::CONSOLE_CHARACTER_ATTRIBUTES; + use windows_sys::Win32::System::Console::CONSOLE_SCREEN_BUFFER_INFO; + use windows_sys::Win32::System::Console::FOREGROUND_BLUE; + use windows_sys::Win32::System::Console::FOREGROUND_GREEN; + use windows_sys::Win32::System::Console::FOREGROUND_INTENSITY; + use windows_sys::Win32::System::Console::FOREGROUND_RED; + + use std::os::windows::io::RawHandle; + + const FOREGROUND_CYAN: CONSOLE_CHARACTER_ATTRIBUTES = FOREGROUND_BLUE | FOREGROUND_GREEN; + const FOREGROUND_MAGENTA: CONSOLE_CHARACTER_ATTRIBUTES = FOREGROUND_BLUE | FOREGROUND_RED; + const FOREGROUND_YELLOW: CONSOLE_CHARACTER_ATTRIBUTES = FOREGROUND_GREEN | FOREGROUND_RED; + const FOREGROUND_WHITE: CONSOLE_CHARACTER_ATTRIBUTES = + FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED; + + #[derive(Copy, Clone, Debug)] + pub(crate) enum IoError { + BrokenPipe, + RawOs(i32), + } + + impl From for std::io::Error { + fn from(io: IoError) -> Self { + match io { + IoError::BrokenPipe => { + std::io::Error::new(std::io::ErrorKind::BrokenPipe, "console is detached") + } + IoError::RawOs(code) => std::io::Error::from_raw_os_error(code), + } + } + } + + impl IoError { + fn last_os_error() -> Self { + Self::RawOs(std::io::Error::last_os_error().raw_os_error().unwrap()) + } + } + + pub(crate) fn get_screen_buffer_info( + handle: RawHandle, + ) -> Result { + unsafe { + let handle = std::mem::transmute(handle); + if handle == 0 { + return Err(IoError::BrokenPipe); + } + + let mut info: CONSOLE_SCREEN_BUFFER_INFO = std::mem::zeroed(); + if windows_sys::Win32::System::Console::GetConsoleScreenBufferInfo(handle, &mut info) + != 0 + { + Ok(info) + } else { + Err(IoError::last_os_error()) + } + } + } + + pub(crate) fn set_console_text_attributes( + handle: RawHandle, + attributes: CONSOLE_CHARACTER_ATTRIBUTES, + ) -> Result<(), IoError> { + unsafe { + let handle = std::mem::transmute(handle); + if handle == 0 { + return Err(IoError::BrokenPipe); + } + + if windows_sys::Win32::System::Console::SetConsoleTextAttribute(handle, attributes) != 0 + { + Ok(()) + } else { + Err(IoError::last_os_error()) + } + } + } + + pub(crate) fn get_colors( + info: &CONSOLE_SCREEN_BUFFER_INFO, + ) -> (anstyle::AnsiColor, anstyle::AnsiColor) { + let attributes = info.wAttributes; + let bg = from_nibble(attributes >> 4); + let fg = from_nibble(attributes); + (fg, bg) + } + + pub(crate) fn set_colors( + fg: anstyle::AnsiColor, + bg: anstyle::AnsiColor, + ) -> CONSOLE_CHARACTER_ATTRIBUTES { + to_nibble(bg) << 4 | to_nibble(fg) + } + + fn from_nibble(color: CONSOLE_CHARACTER_ATTRIBUTES) -> anstyle::AnsiColor { + if color & FOREGROUND_WHITE == FOREGROUND_WHITE { + // 3 bits high + anstyle::AnsiColor::White + } else if color & FOREGROUND_CYAN == FOREGROUND_CYAN { + // 2 bits high + anstyle::AnsiColor::Cyan + } else if color & FOREGROUND_YELLOW == FOREGROUND_YELLOW { + // 2 bits high + anstyle::AnsiColor::Yellow + } else if color & FOREGROUND_MAGENTA == FOREGROUND_MAGENTA { + // 2 bits high + anstyle::AnsiColor::Magenta + } else if color & FOREGROUND_RED == FOREGROUND_RED { + // 1 bit high + anstyle::AnsiColor::Red + } else if color & FOREGROUND_GREEN == FOREGROUND_GREEN { + // 1 bit high + anstyle::AnsiColor::Green + } else if color & FOREGROUND_BLUE == FOREGROUND_BLUE { + // 1 bit high + anstyle::AnsiColor::Blue + } else { + // 0 bits high + anstyle::AnsiColor::Black + } + .bright(color & FOREGROUND_INTENSITY == FOREGROUND_INTENSITY) + } + + fn to_nibble(color: anstyle::AnsiColor) -> CONSOLE_CHARACTER_ATTRIBUTES { + let mut attributes = 0; + attributes |= match color.bright(false) { + anstyle::AnsiColor::Black => 0, + anstyle::AnsiColor::Red => FOREGROUND_RED, + anstyle::AnsiColor::Green => FOREGROUND_GREEN, + anstyle::AnsiColor::Yellow => FOREGROUND_YELLOW, + anstyle::AnsiColor::Blue => FOREGROUND_BLUE, + anstyle::AnsiColor::Magenta => FOREGROUND_MAGENTA, + anstyle::AnsiColor::Cyan => FOREGROUND_CYAN, + anstyle::AnsiColor::White => FOREGROUND_WHITE, + anstyle::AnsiColor::BrightBlack + | anstyle::AnsiColor::BrightRed + | anstyle::AnsiColor::BrightGreen + | anstyle::AnsiColor::BrightYellow + | anstyle::AnsiColor::BrightBlue + | anstyle::AnsiColor::BrightMagenta + | anstyle::AnsiColor::BrightCyan + | anstyle::AnsiColor::BrightWhite => unreachable!("brights were toggled off"), + }; + if color.is_bright() { + attributes |= FOREGROUND_INTENSITY; + } + attributes + } + + #[test] + fn to_from_nibble() { + const COLORS: [anstyle::AnsiColor; 16] = [ + anstyle::AnsiColor::Black, + anstyle::AnsiColor::Red, + anstyle::AnsiColor::Green, + anstyle::AnsiColor::Yellow, + anstyle::AnsiColor::Blue, + anstyle::AnsiColor::Magenta, + anstyle::AnsiColor::Cyan, + anstyle::AnsiColor::White, + anstyle::AnsiColor::BrightBlack, + anstyle::AnsiColor::BrightRed, + anstyle::AnsiColor::BrightGreen, + anstyle::AnsiColor::BrightYellow, + anstyle::AnsiColor::BrightBlue, + anstyle::AnsiColor::BrightMagenta, + anstyle::AnsiColor::BrightCyan, + anstyle::AnsiColor::BrightWhite, + ]; + for expected in COLORS { + let nibble = to_nibble(expected); + let actual = from_nibble(nibble); + assert_eq!(expected, actual, "Intermediate: {}", nibble); + } + } +} -- cgit v1.2.3