| 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('"') | |
| } |