128 lines
3.8 KiB
Rust
128 lines
3.8 KiB
Rust
use std::fmt::{self, Debug, Display, Write as _};
|
|
use std::marker::PhantomData;
|
|
use std::ptr::NonNull;
|
|
use std::slice;
|
|
use std::str;
|
|
|
|
#[derive(Copy, Clone)]
|
|
pub(crate) struct CStr<'a> {
|
|
ptr: NonNull<u8>,
|
|
marker: PhantomData<&'a [u8]>,
|
|
}
|
|
|
|
unsafe impl<'a> Send for CStr<'a> {}
|
|
unsafe impl<'a> Sync for CStr<'a> {}
|
|
|
|
impl<'a> CStr<'a> {
|
|
pub fn from_bytes_with_nul(bytes: &'static [u8]) -> Self {
|
|
assert_eq!(bytes.last(), Some(&b'\0'));
|
|
let ptr = NonNull::from(bytes).cast();
|
|
unsafe { Self::from_ptr(ptr) }
|
|
}
|
|
|
|
pub unsafe fn from_ptr(ptr: NonNull<i8>) -> Self {
|
|
CStr {
|
|
ptr: ptr.cast(),
|
|
marker: PhantomData,
|
|
}
|
|
}
|
|
|
|
pub fn len(self) -> usize {
|
|
let start = self.ptr.as_ptr();
|
|
let mut end = start;
|
|
unsafe {
|
|
while *end != 0 {
|
|
end = end.add(1);
|
|
}
|
|
end.offset_from(start) as usize
|
|
}
|
|
}
|
|
|
|
pub fn to_bytes(self) -> &'a [u8] {
|
|
let len = self.len();
|
|
unsafe { slice::from_raw_parts(self.ptr.as_ptr(), len) }
|
|
}
|
|
}
|
|
|
|
impl<'a> Display for CStr<'a> {
|
|
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
|
|
let ptr = self.ptr.as_ptr();
|
|
let len = self.len();
|
|
let bytes = unsafe { slice::from_raw_parts(ptr, len) };
|
|
display_lossy(bytes, formatter)
|
|
}
|
|
}
|
|
|
|
impl<'a> Debug for CStr<'a> {
|
|
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
|
|
let ptr = self.ptr.as_ptr();
|
|
let len = self.len();
|
|
let bytes = unsafe { slice::from_raw_parts(ptr, len) };
|
|
debug_lossy(bytes, formatter)
|
|
}
|
|
}
|
|
|
|
fn display_lossy(mut bytes: &[u8], formatter: &mut fmt::Formatter) -> fmt::Result {
|
|
loop {
|
|
match str::from_utf8(bytes) {
|
|
Ok(valid) => return formatter.write_str(valid),
|
|
Err(utf8_error) => {
|
|
let valid_up_to = utf8_error.valid_up_to();
|
|
let valid = unsafe { str::from_utf8_unchecked(&bytes[..valid_up_to]) };
|
|
formatter.write_str(valid)?;
|
|
formatter.write_char(char::REPLACEMENT_CHARACTER)?;
|
|
if let Some(error_len) = utf8_error.error_len() {
|
|
bytes = &bytes[valid_up_to + error_len..];
|
|
} else {
|
|
return Ok(());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) fn debug_lossy(mut bytes: &[u8], formatter: &mut fmt::Formatter) -> fmt::Result {
|
|
formatter.write_char('"')?;
|
|
|
|
while !bytes.is_empty() {
|
|
let from_utf8_result = str::from_utf8(bytes);
|
|
let valid = match from_utf8_result {
|
|
Ok(valid) => valid,
|
|
Err(utf8_error) => {
|
|
let valid_up_to = utf8_error.valid_up_to();
|
|
unsafe { str::from_utf8_unchecked(&bytes[..valid_up_to]) }
|
|
}
|
|
};
|
|
|
|
let mut written = 0;
|
|
for (i, ch) in valid.char_indices() {
|
|
let esc = ch.escape_debug();
|
|
if esc.len() != 1 && ch != '\'' {
|
|
formatter.write_str(&valid[written..i])?;
|
|
for ch in esc {
|
|
formatter.write_char(ch)?;
|
|
}
|
|
written = i + ch.len_utf8();
|
|
}
|
|
}
|
|
formatter.write_str(&valid[written..])?;
|
|
|
|
match from_utf8_result {
|
|
Ok(_valid) => break,
|
|
Err(utf8_error) => {
|
|
let end_of_broken = if let Some(error_len) = utf8_error.error_len() {
|
|
valid.len() + error_len
|
|
} else {
|
|
bytes.len()
|
|
};
|
|
for b in &bytes[valid.len()..end_of_broken] {
|
|
write!(formatter, "\\x{:02x}", b)?;
|
|
}
|
|
bytes = &bytes[end_of_broken..];
|
|
}
|
|
}
|
|
}
|
|
|
|
formatter.write_char('"')
|
|
}
|