1 files changed, 261 insertions, 0 deletions
diff --git a/vendor/rustix/src/path/dec_int.rs b/vendor/rustix/src/path/dec_int.rs
new file mode 100644
index 00000000..5b6e2f81
--- /dev/null
+++ b/vendor/rustix/src/path/dec_int.rs
@@ -0,0 +1,261 @@
+//! Efficient decimal integer formatting.
+//!
+//! # Safety
+//!
+//! This uses `CStr::from_bytes_with_nul_unchecked` and
+//! `str::from_utf8_unchecked`on the buffer that it filled itself.
+#![allow(unsafe_code)]
+
+use crate::backend::fd::{AsFd, AsRawFd as _};
+use crate::ffi::CStr;
+use core::fmt;
+use core::hint::unreachable_unchecked;
+use core::mem::{self, MaybeUninit};
+use core::num::{NonZeroU8, NonZeroUsize};
+#[cfg(all(feature = "std", unix))]
+use std::os::unix::ffi::OsStrExt;
+#[cfg(all(
+    feature = "std",
+    target_os = "wasi",
+    any(not(target_env = "p2"), wasip2)
+))]
+use std::os::wasi::ffi::OsStrExt;
+#[cfg(feature = "std")]
+use {std::ffi::OsStr, std::path::Path};
+
+/// Format an integer into a decimal `Path` component, without constructing a
+/// temporary `PathBuf` or `String`.
+///
+/// This is used for opening paths such as `/proc/self/fd/<fd>` on Linux.
+///
+/// # Examples
+///
+/// ```
+/// # #[cfg(any(feature = "fs", feature = "net"))]
+/// use rustix::path::DecInt;
+///
+/// # #[cfg(any(feature = "fs", feature = "net"))]
+/// assert_eq!(
+///     format!("hello {}", DecInt::new(9876).as_ref().display()),
+///     "hello 9876"
+/// );
+/// ```
+#[derive(Clone)]
+pub struct DecInt {
+    buf: [MaybeUninit<u8>; BUF_LEN],
+    len: NonZeroU8,
+}
+
+/// Enough to hold an {u,i}64 and NUL terminator.
+const BUF_LEN: usize = U64_MAX_STR_LEN + 1;
+
+/// Maximum length of a formatted [`u64`].
+const U64_MAX_STR_LEN: usize = "18446744073709551615".len();
+
+/// Maximum length of a formatted [`i64`].
+#[allow(dead_code)]
+const I64_MAX_STR_LEN: usize = "-9223372036854775808".len();
+
+const _: () = assert!(U64_MAX_STR_LEN == I64_MAX_STR_LEN);
+
+mod private {
+    pub trait Sealed: Copy {
+        type Unsigned: super::Integer;
+
+        fn as_unsigned(self) -> (bool, Self::Unsigned);
+        fn eq_zero(self) -> bool;
+        fn div_mod_10(&mut self) -> u8;
+    }
+
+    macro_rules! impl_unsigned {
+        ($($ty:ty)+) => { $(
+            impl Sealed for $ty {
+                type Unsigned = $ty;
+
+                #[inline]
+                fn as_unsigned(self) -> (bool, $ty) {
+                    (false, self)
+                }
+
+                #[inline]
+                fn eq_zero(self) -> bool {
+                    self == 0
+                }
+
+                #[inline]
+                fn div_mod_10(&mut self) -> u8 {
+                    let result = (*self % 10) as u8;
+                    *self /= 10;
+                    result
+                }
+            }
+        )+ }
+    }
+
+    macro_rules! impl_signed {
+        ($($signed:ty : $unsigned:ty)+) => { $(
+            impl Sealed for $signed {
+                type Unsigned = $unsigned;
+
+                #[inline]
+                fn as_unsigned(self) -> (bool, $unsigned) {
+                    if self >= 0 {
+                        (false, self as $unsigned)
+                    } else {
+                        (true, !(self as $unsigned) + 1)
+                    }
+                }
+
+                #[inline]
+                fn eq_zero(self) -> bool {
+                    unimplemented!()
+                }
+
+                #[inline]
+                fn div_mod_10(&mut self) -> u8 {
+                    unimplemented!()
+                }
+            }
+        )+ }
+    }
+
+    impl_unsigned!(u8 u16 u32 u64);
+    impl_signed!(i8:u8 i16:u16 i32:u32 i64:u64);
+
+    #[cfg(any(
+        target_pointer_width = "16",
+        target_pointer_width = "32",
+        target_pointer_width = "64"
+    ))]
+    const _: () = {
+        impl_unsigned!(usize);
+        impl_signed!(isize:usize);
+    };
+}
+
+/// An integer that can be used by [`DecInt::new`].
+pub trait Integer: private::Sealed {}
+
+impl Integer for i8 {}
+impl Integer for i16 {}
+impl Integer for i32 {}
+impl Integer for i64 {}
+impl Integer for u8 {}
+impl Integer for u16 {}
+impl Integer for u32 {}
+impl Integer for u64 {}
+
+#[cfg(any(
+    target_pointer_width = "16",
+    target_pointer_width = "32",
+    target_pointer_width = "64"
+))]
+const _: () = {
+    impl Integer for isize {}
+    impl Integer for usize {}
+};
+
+impl DecInt {
+    /// Construct a new path component from an integer.
+    pub fn new<Int: Integer>(i: Int) -> Self {
+        use private::Sealed as _;
+
+        let (is_neg, mut i) = i.as_unsigned();
+        let mut len = 1;
+        let mut buf = [MaybeUninit::uninit(); BUF_LEN];
+        buf[BUF_LEN - 1] = MaybeUninit::new(b'\0');
+
+        // We use `loop { …; if cond { break } }` instead of
+        // `while !cond { … }` so the loop is entered at least once. This way
+        // `0` does not need a special handling.
+        loop {
+            len += 1;
+            if len > BUF_LEN {
+                // SAFETY: A stringified `i64`/`u64` cannot be longer than
+                // `U64_MAX_STR_LEN` bytes.
+                unsafe { unreachable_unchecked() };
+            }
+            buf[BUF_LEN - len] = MaybeUninit::new(b'0' + i.div_mod_10());
+            if i.eq_zero() {
+                break;
+            }
+        }
+
+        if is_neg {
+            len += 1;
+            if len > BUF_LEN {
+                // SAFETY: A stringified `i64`/`u64` cannot be longer than
+                // `U64_MAX_STR_LEN` bytes.
+                unsafe { unreachable_unchecked() };
+            }
+            buf[BUF_LEN - len] = MaybeUninit::new(b'-');
+        }
+
+        Self {
+            buf,
+            len: NonZeroU8::new(len as u8).unwrap(),
+        }
+    }
+
+    /// Construct a new path component from a file descriptor.
+    #[inline]
+    pub fn from_fd<Fd: AsFd>(fd: Fd) -> Self {
+        Self::new(fd.as_fd().as_raw_fd())
+    }
+
+    /// Return the raw byte buffer as a `&str`.
+    #[inline]
+    pub fn as_str(&self) -> &str {
+        // SAFETY: `DecInt` always holds a formatted decimal number, so it's
+        // always valid UTF-8.
+        unsafe { core::str::from_utf8_unchecked(self.as_bytes()) }
+    }
+
+    /// Return the raw byte buffer as a `&CStr`.
+    #[inline]
+    pub fn as_c_str(&self) -> &CStr {
+        let bytes_with_nul = self.as_bytes_with_nul();
+        debug_assert!(CStr::from_bytes_with_nul(bytes_with_nul).is_ok());
+
+        // SAFETY: `self.buf` holds a single decimal ASCII representation and
+        // at least one extra NUL byte.
+        unsafe { CStr::from_bytes_with_nul_unchecked(bytes_with_nul) }
+    }
+
+    /// Return the raw byte buffer including the NUL byte.
+    #[inline]
+    pub fn as_bytes_with_nul(&self) -> &[u8] {
+        let len = NonZeroUsize::from(self.len).get();
+        if len > BUF_LEN {
+            // SAFETY: A stringified `i64`/`u64` cannot be longer than
+            // `U64_MAX_STR_LEN` bytes.
+            unsafe { unreachable_unchecked() };
+        }
+        let init = &self.buf[(self.buf.len() - len)..];
+        // SAFETY: We're guaranteed to have initialized `len + 1` bytes.
+        unsafe { mem::transmute::<&[MaybeUninit<u8>], &[u8]>(init) }
+    }
+
+    /// Return the raw byte buffer.
+    #[inline]
+    pub fn as_bytes(&self) -> &[u8] {
+        let bytes = self.as_bytes_with_nul();
+        &bytes[..bytes.len() - 1]
+    }
+}
+
+#[cfg(feature = "std")]
+#[cfg(any(not(target_os = "wasi"), not(target_env = "p2"), wasip2))]
+impl AsRef<Path> for DecInt {
+    #[inline]
+    fn as_ref(&self) -> &Path {
+        let as_os_str: &OsStr = OsStrExt::from_bytes(self.as_bytes());
+        Path::new(as_os_str)
+    }
+}
+
+impl fmt::Debug for DecInt {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.as_str().fmt(f)
+    }
+}