1 | //! [![github]](https://github.com/dtolnay/itoa) [![crates-io]](https://crates.io/crates/itoa) [![docs-rs]](https://docs.rs/itoa) |
2 | //! |
3 | //! [github]: https://img.shields.io/badge/github-8da0cb?style=for-the-badge&labelColor=555555&logo=github |
4 | //! [crates-io]: https://img.shields.io/badge/crates.io-fc8d62?style=for-the-badge&labelColor=555555&logo=rust |
5 | //! [docs-rs]: https://img.shields.io/badge/docs.rs-66c2a5?style=for-the-badge&labelColor=555555&logo=docs.rs |
6 | //! |
7 | //! <br> |
8 | //! |
9 | //! This crate provides a fast conversion of integer primitives to decimal |
10 | //! strings. The implementation comes straight from [libcore] but avoids the |
11 | //! performance penalty of going through [`core::fmt::Formatter`]. |
12 | //! |
13 | //! See also [`ryu`] for printing floating point primitives. |
14 | //! |
15 | //! [libcore]: https://github.com/rust-lang/rust/blob/b8214dc6c6fc20d0a660fb5700dca9ebf51ebe89/src/libcore/fmt/num.rs#L201-L254 |
16 | //! [`core::fmt::Formatter`]: https://doc.rust-lang.org/std/fmt/struct.Formatter.html |
17 | //! [`ryu`]: https://github.com/dtolnay/ryu |
18 | //! |
19 | //! # Example |
20 | //! |
21 | //! ``` |
22 | //! fn main() { |
23 | //! let mut buffer = itoa::Buffer::new(); |
24 | //! let printed = buffer.format(128u64); |
25 | //! assert_eq!(printed, "128" ); |
26 | //! } |
27 | //! ``` |
28 | //! |
29 | //! # Performance (lower is better) |
30 | //! |
31 | //! ![performance](https://raw.githubusercontent.com/dtolnay/itoa/master/performance.png) |
32 | |
33 | #![doc (html_root_url = "https://docs.rs/itoa/1.0.6" )] |
34 | #![no_std ] |
35 | #![allow ( |
36 | clippy::cast_lossless, |
37 | clippy::cast_possible_truncation, |
38 | clippy::must_use_candidate, |
39 | clippy::unreadable_literal |
40 | )] |
41 | |
42 | mod udiv128; |
43 | |
44 | use core::mem::{self, MaybeUninit}; |
45 | use core::{ptr, slice, str}; |
46 | #[cfg (feature = "no-panic" )] |
47 | use no_panic::no_panic; |
48 | |
49 | /// A correctly sized stack allocation for the formatted integer to be written |
50 | /// into. |
51 | /// |
52 | /// # Example |
53 | /// |
54 | /// ``` |
55 | /// let mut buffer = itoa::Buffer::new(); |
56 | /// let printed = buffer.format(1234); |
57 | /// assert_eq!(printed, "1234" ); |
58 | /// ``` |
59 | pub struct Buffer { |
60 | bytes: [MaybeUninit<u8>; I128_MAX_LEN], |
61 | } |
62 | |
63 | impl Default for Buffer { |
64 | #[inline ] |
65 | fn default() -> Buffer { |
66 | Buffer::new() |
67 | } |
68 | } |
69 | |
70 | impl Clone for Buffer { |
71 | #[inline ] |
72 | fn clone(&self) -> Self { |
73 | Buffer::new() |
74 | } |
75 | } |
76 | |
77 | impl Buffer { |
78 | /// This is a cheap operation; you don't need to worry about reusing buffers |
79 | /// for efficiency. |
80 | #[inline ] |
81 | #[cfg_attr (feature = "no-panic" , no_panic)] |
82 | pub fn new() -> Buffer { |
83 | let bytes: [MaybeUninit; 40] = [MaybeUninit::<u8>::uninit(); I128_MAX_LEN]; |
84 | Buffer { bytes } |
85 | } |
86 | |
87 | /// Print an integer into this buffer and return a reference to its string |
88 | /// representation within the buffer. |
89 | #[cfg_attr (feature = "no-panic" , no_panic)] |
90 | pub fn format<I: Integer>(&mut self, i: I) -> &str { |
91 | i.write(buf:unsafe { |
92 | &mut *(&mut self.bytes as *mut [MaybeUninit<u8>; I128_MAX_LEN] |
93 | as *mut <I as private::Sealed>::Buffer) |
94 | }) |
95 | } |
96 | } |
97 | |
98 | /// An integer that can be written into an [`itoa::Buffer`][Buffer]. |
99 | /// |
100 | /// This trait is sealed and cannot be implemented for types outside of itoa. |
101 | pub trait Integer: private::Sealed {} |
102 | |
103 | // Seal to prevent downstream implementations of the Integer trait. |
104 | mod private { |
105 | pub trait Sealed: Copy { |
106 | type Buffer: 'static; |
107 | fn write(self, buf: &mut Self::Buffer) -> &str; |
108 | } |
109 | } |
110 | |
111 | const DEC_DIGITS_LUT: &[u8] = b"\ |
112 | 0001020304050607080910111213141516171819\ |
113 | 2021222324252627282930313233343536373839\ |
114 | 4041424344454647484950515253545556575859\ |
115 | 6061626364656667686970717273747576777879\ |
116 | 8081828384858687888990919293949596979899" ; |
117 | |
118 | // Adaptation of the original implementation at |
119 | // https://github.com/rust-lang/rust/blob/b8214dc6c6fc20d0a660fb5700dca9ebf51ebe89/src/libcore/fmt/num.rs#L188-L266 |
120 | macro_rules! impl_Integer { |
121 | ($($max_len:expr => $t:ident),* as $conv_fn:ident) => {$( |
122 | impl Integer for $t {} |
123 | |
124 | impl private::Sealed for $t { |
125 | type Buffer = [MaybeUninit<u8>; $max_len]; |
126 | |
127 | #[allow(unused_comparisons)] |
128 | #[inline] |
129 | #[cfg_attr(feature = "no-panic" , no_panic)] |
130 | fn write(self, buf: &mut [MaybeUninit<u8>; $max_len]) -> &str { |
131 | let is_nonnegative = self >= 0; |
132 | let mut n = if is_nonnegative { |
133 | self as $conv_fn |
134 | } else { |
135 | // convert the negative num to positive by summing 1 to it's 2 complement |
136 | (!(self as $conv_fn)).wrapping_add(1) |
137 | }; |
138 | let mut curr = buf.len() as isize; |
139 | let buf_ptr = buf.as_mut_ptr() as *mut u8; |
140 | let lut_ptr = DEC_DIGITS_LUT.as_ptr(); |
141 | |
142 | unsafe { |
143 | // need at least 16 bits for the 4-characters-at-a-time to work. |
144 | if mem::size_of::<$t>() >= 2 { |
145 | // eagerly decode 4 characters at a time |
146 | while n >= 10000 { |
147 | let rem = (n % 10000) as isize; |
148 | n /= 10000; |
149 | |
150 | let d1 = (rem / 100) << 1; |
151 | let d2 = (rem % 100) << 1; |
152 | curr -= 4; |
153 | ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2); |
154 | ptr::copy_nonoverlapping(lut_ptr.offset(d2), buf_ptr.offset(curr + 2), 2); |
155 | } |
156 | } |
157 | |
158 | // if we reach here numbers are <= 9999, so at most 4 chars long |
159 | let mut n = n as isize; // possibly reduce 64bit math |
160 | |
161 | // decode 2 more chars, if > 2 chars |
162 | if n >= 100 { |
163 | let d1 = (n % 100) << 1; |
164 | n /= 100; |
165 | curr -= 2; |
166 | ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2); |
167 | } |
168 | |
169 | // decode last 1 or 2 chars |
170 | if n < 10 { |
171 | curr -= 1; |
172 | *buf_ptr.offset(curr) = (n as u8) + b'0' ; |
173 | } else { |
174 | let d1 = n << 1; |
175 | curr -= 2; |
176 | ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2); |
177 | } |
178 | |
179 | if !is_nonnegative { |
180 | curr -= 1; |
181 | *buf_ptr.offset(curr) = b'-' ; |
182 | } |
183 | } |
184 | |
185 | let len = buf.len() - curr as usize; |
186 | let bytes = unsafe { slice::from_raw_parts(buf_ptr.offset(curr), len) }; |
187 | unsafe { str::from_utf8_unchecked(bytes) } |
188 | } |
189 | } |
190 | )*}; |
191 | } |
192 | |
193 | const I8_MAX_LEN: usize = 4; |
194 | const U8_MAX_LEN: usize = 3; |
195 | const I16_MAX_LEN: usize = 6; |
196 | const U16_MAX_LEN: usize = 5; |
197 | const I32_MAX_LEN: usize = 11; |
198 | const U32_MAX_LEN: usize = 10; |
199 | const I64_MAX_LEN: usize = 20; |
200 | const U64_MAX_LEN: usize = 20; |
201 | |
202 | impl_Integer!( |
203 | I8_MAX_LEN => i8, |
204 | U8_MAX_LEN => u8, |
205 | I16_MAX_LEN => i16, |
206 | U16_MAX_LEN => u16, |
207 | I32_MAX_LEN => i32, |
208 | U32_MAX_LEN => u32 |
209 | as u32); |
210 | |
211 | impl_Integer!(I64_MAX_LEN => i64, U64_MAX_LEN => u64 as u64); |
212 | |
213 | #[cfg (target_pointer_width = "16" )] |
214 | impl_Integer!(I16_MAX_LEN => isize, U16_MAX_LEN => usize as u16); |
215 | |
216 | #[cfg (target_pointer_width = "32" )] |
217 | impl_Integer!(I32_MAX_LEN => isize, U32_MAX_LEN => usize as u32); |
218 | |
219 | #[cfg (target_pointer_width = "64" )] |
220 | impl_Integer!(I64_MAX_LEN => isize, U64_MAX_LEN => usize as u64); |
221 | |
222 | macro_rules! impl_Integer128 { |
223 | ($($max_len:expr => $t:ident),*) => {$( |
224 | impl Integer for $t {} |
225 | |
226 | impl private::Sealed for $t { |
227 | type Buffer = [MaybeUninit<u8>; $max_len]; |
228 | |
229 | #[allow(unused_comparisons)] |
230 | #[inline] |
231 | #[cfg_attr(feature = "no-panic" , no_panic)] |
232 | fn write(self, buf: &mut [MaybeUninit<u8>; $max_len]) -> &str { |
233 | let is_nonnegative = self >= 0; |
234 | let n = if is_nonnegative { |
235 | self as u128 |
236 | } else { |
237 | // convert the negative num to positive by summing 1 to it's 2 complement |
238 | (!(self as u128)).wrapping_add(1) |
239 | }; |
240 | let mut curr = buf.len() as isize; |
241 | let buf_ptr = buf.as_mut_ptr() as *mut u8; |
242 | |
243 | unsafe { |
244 | // Divide by 10^19 which is the highest power less than 2^64. |
245 | let (n, rem) = udiv128::udivmod_1e19(n); |
246 | let buf1 = buf_ptr.offset(curr - U64_MAX_LEN as isize) as *mut [MaybeUninit<u8>; U64_MAX_LEN]; |
247 | curr -= rem.write(&mut *buf1).len() as isize; |
248 | |
249 | if n != 0 { |
250 | // Memset the base10 leading zeros of rem. |
251 | let target = buf.len() as isize - 19; |
252 | ptr::write_bytes(buf_ptr.offset(target), b'0' , (curr - target) as usize); |
253 | curr = target; |
254 | |
255 | // Divide by 10^19 again. |
256 | let (n, rem) = udiv128::udivmod_1e19(n); |
257 | let buf2 = buf_ptr.offset(curr - U64_MAX_LEN as isize) as *mut [MaybeUninit<u8>; U64_MAX_LEN]; |
258 | curr -= rem.write(&mut *buf2).len() as isize; |
259 | |
260 | if n != 0 { |
261 | // Memset the leading zeros. |
262 | let target = buf.len() as isize - 38; |
263 | ptr::write_bytes(buf_ptr.offset(target), b'0' , (curr - target) as usize); |
264 | curr = target; |
265 | |
266 | // There is at most one digit left |
267 | // because u128::max / 10^19 / 10^19 is 3. |
268 | curr -= 1; |
269 | *buf_ptr.offset(curr) = (n as u8) + b'0' ; |
270 | } |
271 | } |
272 | |
273 | if !is_nonnegative { |
274 | curr -= 1; |
275 | *buf_ptr.offset(curr) = b'-' ; |
276 | } |
277 | |
278 | let len = buf.len() - curr as usize; |
279 | let bytes = slice::from_raw_parts(buf_ptr.offset(curr), len); |
280 | str::from_utf8_unchecked(bytes) |
281 | } |
282 | } |
283 | } |
284 | )*}; |
285 | } |
286 | |
287 | const U128_MAX_LEN: usize = 39; |
288 | const I128_MAX_LEN: usize = 40; |
289 | |
290 | impl_Integer128!(I128_MAX_LEN => i128, U128_MAX_LEN => u128); |
291 | |