mirror of
https://github.com/fish-shell/fish-shell
synced 2025-01-23 18:25:06 +00:00
0aa08cf267
Like FLOGF!, this now needs at least one argument to format.
This avoids some issues with missing variables and broken format
strings - it is how I found 13ba5bd405 -
where disown had a format string, with two placeholders, but no
arguments to fill them with.
For use in e.g. macros, where it's otherwise hard to tell if we have
something to format or not, this adds a wgettext_maybe_fmt! version to
"maybe" format, if necessary.
66 lines
2.2 KiB
Rust
66 lines
2.2 KiB
Rust
//! Support for wide strings.
|
|
//!
|
|
//! There are two wide string types that are commonly used:
|
|
//! - wstr: a string slice without a nul terminator. Like `&str` but wide chars.
|
|
//! - WString: an owning string without a nul terminator. Like `String` but wide chars.
|
|
|
|
use crate::common::{ENCODE_DIRECT_BASE, ENCODE_DIRECT_END};
|
|
pub use widestring::{Utf32Str as wstr, Utf32String as WString};
|
|
|
|
/// Pull in our extensions.
|
|
pub use crate::wchar_ext::{IntoCharIter, WExt};
|
|
|
|
pub(crate) mod prelude {
|
|
pub(crate) use crate::{
|
|
wchar::{wstr, IntoCharIter, WString, L},
|
|
wchar_ext::{ToWString, WExt},
|
|
wutil::{sprintf, wgettext, wgettext_fmt, wgettext_maybe_fmt, wgettext_str},
|
|
};
|
|
pub(crate) use widestring_suffix::widestrs;
|
|
}
|
|
|
|
/// Creates a wstr string slice, like the "L" prefix of C++.
|
|
/// The result is of type wstr.
|
|
/// It is NOT nul-terminated.
|
|
macro_rules! L {
|
|
($string:expr) => {
|
|
widestring::utf32str!($string)
|
|
};
|
|
}
|
|
pub(crate) use L;
|
|
|
|
/// A proc-macro for creating wide string literals using an L *suffix*.
|
|
/// Example usage:
|
|
/// ```
|
|
/// #[widestrs]
|
|
/// pub fn func() {
|
|
/// let s = "hello"L; // type &'static wstr
|
|
/// }
|
|
/// ```
|
|
/// Note: the resulting string is NOT nul-terminated.
|
|
pub use widestring_suffix::widestrs;
|
|
|
|
/// Encode a literal byte in a UTF-32 character. This is required for e.g. the echo builtin, whose
|
|
/// escape sequences can be used to construct raw byte sequences which are then interpreted as e.g.
|
|
/// UTF-8 by the terminal. If we were to interpret each of those bytes as a codepoint and encode it
|
|
/// as a UTF-32 character, printing them would result in several characters instead of one UTF-8
|
|
/// character.
|
|
///
|
|
/// See https://github.com/fish-shell/fish-shell/issues/1894.
|
|
pub fn encode_byte_to_char(byte: u8) -> char {
|
|
char::from_u32(u32::from(ENCODE_DIRECT_BASE) + u32::from(byte))
|
|
.expect("private-use codepoint should be valid char")
|
|
}
|
|
|
|
/// Decode a literal byte from a UTF-32 character.
|
|
pub fn decode_byte_from_char(c: char) -> Option<u8> {
|
|
if c >= ENCODE_DIRECT_BASE && c < ENCODE_DIRECT_END {
|
|
Some(
|
|
(u32::from(c) - u32::from(ENCODE_DIRECT_BASE))
|
|
.try_into()
|
|
.unwrap(),
|
|
)
|
|
} else {
|
|
None
|
|
}
|
|
}
|