Compare commits
10 Commits
d5e45f2273
...
e6cbf0b921
Author | SHA1 | Date |
---|---|---|
|
e6cbf0b921 | |
|
3ef6de9039 | |
![]() |
945f297a24 | |
![]() |
3895493dc3 | |
![]() |
0ce0ec2440 | |
![]() |
8f392032fa | |
![]() |
eeca57ddcf | |
![]() |
ea29bbdbbf | |
![]() |
526d4e408c | |
![]() |
fde7fa5e2a |
|
@ -69,7 +69,7 @@ jobs:
|
|||
- uses: actions/checkout@v4
|
||||
- uses: dtolnay/rust-toolchain@miri
|
||||
- run: cargo miri setup
|
||||
- run: cargo miri test --all-targets # exclude doctests https://github.com/rust-lang/miri/issues/3404
|
||||
- run: cargo miri test
|
||||
env:
|
||||
MIRIFLAGS: -Zmiri-strict-provenance
|
||||
|
||||
|
@ -102,6 +102,7 @@ jobs:
|
|||
timeout-minutes: 45
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: dtolnay/rust-toolchain@stable
|
||||
- uses: dtolnay/install@cargo-outdated
|
||||
- run: cargo outdated --workspace --exit-code 1
|
||||
- run: cargo outdated --manifest-path fuzz/Cargo.toml --exit-code 1
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
[package]
|
||||
name = "itoa"
|
||||
version = "1.0.10"
|
||||
version = "1.0.11"
|
||||
authors = ["David Tolnay <dtolnay@gmail.com>"]
|
||||
categories = ["value-formatting", "no-std", "no-std::no-alloc"]
|
||||
description = "Fast integer primitive to string conversion"
|
||||
|
|
160
src/lib.rs
160
src/lib.rs
|
@ -30,16 +30,23 @@
|
|||
//!
|
||||
//! ![performance](https://raw.githubusercontent.com/dtolnay/itoa/master/performance.png)
|
||||
|
||||
#![doc(html_root_url = "https://docs.rs/itoa/1.0.10")]
|
||||
#![doc(html_root_url = "https://docs.rs/itoa/1.0.11")]
|
||||
#![no_std]
|
||||
#![allow(
|
||||
clippy::cast_lossless,
|
||||
clippy::cast_possible_truncation,
|
||||
clippy::cast_possible_wrap,
|
||||
clippy::cast_sign_loss,
|
||||
clippy::expl_impl_clone_on_copy,
|
||||
clippy::must_use_candidate,
|
||||
clippy::needless_doctest_main,
|
||||
clippy::unreadable_literal
|
||||
)]
|
||||
#![feature(const_intrinsic_copy)]
|
||||
#![feature(const_mut_refs)]
|
||||
#![feature(const_ptr_write)]
|
||||
#![feature(const_trait_impl)]
|
||||
#![feature(effects)]
|
||||
|
||||
mod udiv128;
|
||||
|
||||
|
@ -84,7 +91,7 @@ impl Buffer {
|
|||
/// for efficiency.
|
||||
#[inline]
|
||||
#[cfg_attr(feature = "no-panic", no_panic)]
|
||||
pub fn new() -> Buffer {
|
||||
pub const fn new() -> Buffer {
|
||||
let bytes = [MaybeUninit::<u8>::uninit(); I128_MAX_LEN];
|
||||
Buffer { bytes }
|
||||
}
|
||||
|
@ -92,10 +99,10 @@ impl Buffer {
|
|||
/// Print an integer into this buffer and return a reference to its string
|
||||
/// representation within the buffer.
|
||||
#[cfg_attr(feature = "no-panic", no_panic)]
|
||||
pub fn format<I: Integer>(&mut self, i: I) -> &str {
|
||||
pub const fn format<I: ~const Integer>(&mut self, i: I) -> &str {
|
||||
i.write(unsafe {
|
||||
&mut *(&mut self.bytes as *mut [MaybeUninit<u8>; I128_MAX_LEN]
|
||||
as *mut <I as private::Sealed>::Buffer)
|
||||
as *mut I::Buffer)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
@ -103,13 +110,18 @@ impl Buffer {
|
|||
/// An integer that can be written into an [`itoa::Buffer`][Buffer].
|
||||
///
|
||||
/// This trait is sealed and cannot be implemented for types outside of itoa.
|
||||
pub trait Integer: private::Sealed {}
|
||||
#[const_trait]
|
||||
pub trait Integer: private::Sealed {
|
||||
#[doc(hidden)]
|
||||
type Buffer: 'static;
|
||||
|
||||
#[doc(hidden)]
|
||||
fn write(self, buf: &mut Self::Buffer) -> &str;
|
||||
}
|
||||
|
||||
// Seal to prevent downstream implementations of the Integer trait.
|
||||
mod private {
|
||||
pub trait Sealed: Copy {
|
||||
type Buffer: 'static;
|
||||
fn write(self, buf: &mut Self::Buffer) -> &str;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -124,9 +136,7 @@ const DEC_DIGITS_LUT: &[u8] = b"\
|
|||
// https://github.com/rust-lang/rust/blob/b8214dc6c6fc20d0a660fb5700dca9ebf51ebe89/src/libcore/fmt/num.rs#L188-L266
|
||||
macro_rules! impl_Integer {
|
||||
($($max_len:expr => $t:ident),* as $conv_fn:ident) => {$(
|
||||
impl Integer for $t {}
|
||||
|
||||
impl private::Sealed for $t {
|
||||
impl const Integer for $t {
|
||||
type Buffer = [MaybeUninit<u8>; $max_len];
|
||||
|
||||
#[allow(unused_comparisons)]
|
||||
|
@ -137,52 +147,60 @@ macro_rules! impl_Integer {
|
|||
let mut n = if is_nonnegative {
|
||||
self as $conv_fn
|
||||
} else {
|
||||
// convert the negative num to positive by summing 1 to it's 2 complement
|
||||
// Convert negative number to positive by summing 1 to its two's complement.
|
||||
(!(self as $conv_fn)).wrapping_add(1)
|
||||
};
|
||||
let mut curr = buf.len() as isize;
|
||||
let buf_ptr = buf.as_mut_ptr() as *mut u8;
|
||||
let lut_ptr = DEC_DIGITS_LUT.as_ptr();
|
||||
|
||||
unsafe {
|
||||
// need at least 16 bits for the 4-characters-at-a-time to work.
|
||||
if mem::size_of::<$t>() >= 2 {
|
||||
// eagerly decode 4 characters at a time
|
||||
while n >= 10000 {
|
||||
let rem = (n % 10000) as isize;
|
||||
n /= 10000;
|
||||
// Need at least 16 bits for the 4-digits-at-a-time to work.
|
||||
if mem::size_of::<$t>() >= 2 {
|
||||
// Eagerly decode 4 digits at a time.
|
||||
while n >= 10000 {
|
||||
let rem = (n % 10000) as isize;
|
||||
n /= 10000;
|
||||
|
||||
let d1 = (rem / 100) << 1;
|
||||
let d2 = (rem % 100) << 1;
|
||||
curr -= 4;
|
||||
let d1 = (rem / 100) << 1;
|
||||
let d2 = (rem % 100) << 1;
|
||||
curr -= 4;
|
||||
unsafe {
|
||||
ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);
|
||||
ptr::copy_nonoverlapping(lut_ptr.offset(d2), buf_ptr.offset(curr + 2), 2);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// if we reach here numbers are <= 9999, so at most 4 chars long
|
||||
let mut n = n as isize; // possibly reduce 64bit math
|
||||
// If we reach here, numbers are <=9999 so at most 4 digits long.
|
||||
let mut n = n as isize; // Possibly reduce 64-bit math.
|
||||
|
||||
// decode 2 more chars, if > 2 chars
|
||||
if n >= 100 {
|
||||
let d1 = (n % 100) << 1;
|
||||
n /= 100;
|
||||
curr -= 2;
|
||||
// Decode 2 more digits, if >2 digits.
|
||||
if n >= 100 {
|
||||
let d1 = (n % 100) << 1;
|
||||
n /= 100;
|
||||
curr -= 2;
|
||||
unsafe {
|
||||
ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);
|
||||
}
|
||||
}
|
||||
|
||||
// decode last 1 or 2 chars
|
||||
if n < 10 {
|
||||
curr -= 1;
|
||||
// Decode last 1 or 2 digits.
|
||||
if n < 10 {
|
||||
curr -= 1;
|
||||
unsafe {
|
||||
*buf_ptr.offset(curr) = (n as u8) + b'0';
|
||||
} else {
|
||||
let d1 = n << 1;
|
||||
curr -= 2;
|
||||
}
|
||||
} else {
|
||||
let d1 = n << 1;
|
||||
curr -= 2;
|
||||
unsafe {
|
||||
ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);
|
||||
}
|
||||
}
|
||||
|
||||
if !is_nonnegative {
|
||||
curr -= 1;
|
||||
if !is_nonnegative {
|
||||
curr -= 1;
|
||||
unsafe {
|
||||
*buf_ptr.offset(curr) = b'-';
|
||||
}
|
||||
}
|
||||
|
@ -192,6 +210,8 @@ macro_rules! impl_Integer {
|
|||
unsafe { str::from_utf8_unchecked(bytes) }
|
||||
}
|
||||
}
|
||||
|
||||
impl private::Sealed for $t {}
|
||||
)*};
|
||||
}
|
||||
|
||||
|
@ -226,9 +246,7 @@ impl_Integer!(I64_MAX_LEN => isize, U64_MAX_LEN => usize as u64);
|
|||
|
||||
macro_rules! impl_Integer128 {
|
||||
($($max_len:expr => $t:ident),*) => {$(
|
||||
impl Integer for $t {}
|
||||
|
||||
impl private::Sealed for $t {
|
||||
impl const Integer for $t {
|
||||
type Buffer = [MaybeUninit<u8>; $max_len];
|
||||
|
||||
#[allow(unused_comparisons)]
|
||||
|
@ -239,53 +257,61 @@ macro_rules! impl_Integer128 {
|
|||
let n = if is_nonnegative {
|
||||
self as u128
|
||||
} else {
|
||||
// convert the negative num to positive by summing 1 to it's 2 complement
|
||||
// Convert negative number to positive by summing 1 to its two's complement.
|
||||
(!(self as u128)).wrapping_add(1)
|
||||
};
|
||||
let mut curr = buf.len() as isize;
|
||||
let buf_ptr = buf.as_mut_ptr() as *mut u8;
|
||||
|
||||
unsafe {
|
||||
// Divide by 10^19 which is the highest power less than 2^64.
|
||||
// Divide by 10^19 which is the highest power less than 2^64.
|
||||
let (n, rem) = udiv128::udivmod_1e19(n);
|
||||
let buf1 = unsafe { buf_ptr.offset(curr - U64_MAX_LEN as isize) as *mut [MaybeUninit<u8>; U64_MAX_LEN] };
|
||||
curr -= rem.write(unsafe { &mut *buf1 }).len() as isize;
|
||||
|
||||
if n != 0 {
|
||||
// Memset the base10 leading zeros of rem.
|
||||
let target = buf.len() as isize - 19;
|
||||
unsafe {
|
||||
ptr::write_bytes(buf_ptr.offset(target), b'0', (curr - target) as usize);
|
||||
}
|
||||
curr = target;
|
||||
|
||||
// Divide by 10^19 again.
|
||||
let (n, rem) = udiv128::udivmod_1e19(n);
|
||||
let buf1 = buf_ptr.offset(curr - U64_MAX_LEN as isize) as *mut [MaybeUninit<u8>; U64_MAX_LEN];
|
||||
curr -= rem.write(&mut *buf1).len() as isize;
|
||||
let buf2 = unsafe { buf_ptr.offset(curr - U64_MAX_LEN as isize) as *mut [MaybeUninit<u8>; U64_MAX_LEN] };
|
||||
curr -= rem.write(unsafe { &mut *buf2 }).len() as isize;
|
||||
|
||||
if n != 0 {
|
||||
// Memset the base10 leading zeros of rem.
|
||||
let target = buf.len() as isize - 19;
|
||||
ptr::write_bytes(buf_ptr.offset(target), b'0', (curr - target) as usize);
|
||||
// Memset the leading zeros.
|
||||
let target = buf.len() as isize - 38;
|
||||
unsafe {
|
||||
ptr::write_bytes(buf_ptr.offset(target), b'0', (curr - target) as usize);
|
||||
}
|
||||
curr = target;
|
||||
|
||||
// Divide by 10^19 again.
|
||||
let (n, rem) = udiv128::udivmod_1e19(n);
|
||||
let buf2 = buf_ptr.offset(curr - U64_MAX_LEN as isize) as *mut [MaybeUninit<u8>; U64_MAX_LEN];
|
||||
curr -= rem.write(&mut *buf2).len() as isize;
|
||||
|
||||
if n != 0 {
|
||||
// Memset the leading zeros.
|
||||
let target = buf.len() as isize - 38;
|
||||
ptr::write_bytes(buf_ptr.offset(target), b'0', (curr - target) as usize);
|
||||
curr = target;
|
||||
|
||||
// There is at most one digit left
|
||||
// because u128::max / 10^19 / 10^19 is 3.
|
||||
curr -= 1;
|
||||
// There is at most one digit left
|
||||
// because u128::MAX / 10^19 / 10^19 is 3.
|
||||
curr -= 1;
|
||||
unsafe {
|
||||
*buf_ptr.offset(curr) = (n as u8) + b'0';
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if !is_nonnegative {
|
||||
curr -= 1;
|
||||
if !is_nonnegative {
|
||||
curr -= 1;
|
||||
unsafe {
|
||||
*buf_ptr.offset(curr) = b'-';
|
||||
}
|
||||
|
||||
let len = buf.len() - curr as usize;
|
||||
let bytes = slice::from_raw_parts(buf_ptr.offset(curr), len);
|
||||
str::from_utf8_unchecked(bytes)
|
||||
}
|
||||
|
||||
let len = buf.len() - curr as usize;
|
||||
let bytes = unsafe { slice::from_raw_parts(buf_ptr.offset(curr), len) };
|
||||
unsafe { str::from_utf8_unchecked(bytes) }
|
||||
}
|
||||
}
|
||||
|
||||
impl private::Sealed for $t {}
|
||||
)*};
|
||||
}
|
||||
|
||||
|
|
|
@ -4,7 +4,7 @@ use no_panic::no_panic;
|
|||
/// Multiply unsigned 128 bit integers, return upper 128 bits of the result
|
||||
#[inline]
|
||||
#[cfg_attr(feature = "no-panic", no_panic)]
|
||||
fn u128_mulhi(x: u128, y: u128) -> u128 {
|
||||
const fn u128_mulhi(x: u128, y: u128) -> u128 {
|
||||
let x_lo = x as u64;
|
||||
let x_hi = (x >> 64) as u64;
|
||||
let y_lo = y as u64;
|
||||
|
@ -31,7 +31,7 @@ fn u128_mulhi(x: u128, y: u128) -> u128 {
|
|||
///
|
||||
#[inline]
|
||||
#[cfg_attr(feature = "no-panic", no_panic)]
|
||||
pub fn udivmod_1e19(n: u128) -> (u128, u64) {
|
||||
pub const fn udivmod_1e19(n: u128) -> (u128, u64) {
|
||||
let d = 10_000_000_000_000_000_000_u64; // 10^19
|
||||
|
||||
let quot = if n < 1 << 83 {
|
||||
|
@ -41,8 +41,8 @@ pub fn udivmod_1e19(n: u128) -> (u128, u64) {
|
|||
};
|
||||
|
||||
let rem = (n - quot * d as u128) as u64;
|
||||
debug_assert_eq!(quot, n / d as u128);
|
||||
debug_assert_eq!(rem as u128, n % d as u128);
|
||||
debug_assert!(quot == n / d as u128);
|
||||
debug_assert!(rem as u128 == n % d as u128);
|
||||
|
||||
(quot, rem)
|
||||
}
|
||||
|
|
Loading…
Reference in New Issue