1use core::{mem::MaybeUninit, slice, str};
2
3use crate::{uDebug, uDisplay, uWrite, Formatter};
4
5macro_rules! ixx {
6 ($uxx:ty, $n:expr, $buf:expr) => {{
7 let ptr = $buf.as_mut_ptr().cast::<u8>();
8 let len = $buf.len();
9 let n = $n;
10 let negative = n.is_negative();
11 let mut n = if negative {
12 match n.checked_abs() {
13 Some(n) => n as $uxx,
14 None => <$uxx>::max_value() / 2 + 1,
15 }
16 } else {
17 n as $uxx
18 };
19 let mut i = len - 1;
20 loop {
21 unsafe { ptr.add(i).write((n % 10) as u8 + b'0') }
22 n /= 10;
23
24 if n == 0 {
25 break;
26 } else {
27 i -= 1;
28 }
29 }
30
31 if negative {
32 i -= 1;
33 unsafe { ptr.add(i).write(b'-') }
34 }
35
36 unsafe { str::from_utf8_unchecked(slice::from_raw_parts(ptr.add(i), len - i)) }
37 }};
38}
39
40fn isize(n: isize, buf: &mut [MaybeUninit<u8>]) -> &str {
41 ixx!(usize, n, buf)
42}
43
44impl uDebug for i8 {
45 fn fmt<W>(&self, f: &mut Formatter<'_, W>) -> Result<(), W::Error>
46 where
47 W: uWrite + ?Sized,
48 {
49 let mut buf = [MaybeUninit::uninit(); 4];
50
51 f.write_str(isize(isize::from(*self), &mut buf))
52 }
53}
54
55impl uDisplay for i8 {
56 #[inline(always)]
57 fn fmt<W>(&self, f: &mut Formatter<'_, W>) -> Result<(), W::Error>
58 where
59 W: uWrite + ?Sized,
60 {
61 <i8 as uDebug>::fmt(self, f)
62 }
63}
64
65impl uDebug for i16 {
66 fn fmt<W>(&self, f: &mut Formatter<'_, W>) -> Result<(), W::Error>
67 where
68 W: uWrite + ?Sized,
69 {
70 let mut buf = [MaybeUninit::uninit(); 6];
71
72 f.write_str(isize(isize::from(*self), &mut buf))
73 }
74}
75
76impl uDisplay for i16 {
77 #[inline(always)]
78 fn fmt<W>(&self, f: &mut Formatter<'_, W>) -> Result<(), W::Error>
79 where
80 W: uWrite + ?Sized,
81 {
82 <i16 as uDebug>::fmt(self, f)
83 }
84}
85
86impl uDebug for i32 {
87 #[cfg(not(target_pointer_width = "16"))]
88 fn fmt<W>(&self, f: &mut Formatter<'_, W>) -> Result<(), W::Error>
89 where
90 W: uWrite + ?Sized,
91 {
92 let mut buf = [MaybeUninit::uninit(); 11];
93
94 f.write_str(isize(*self as isize, &mut buf))
95 }
96
97 #[cfg(target_pointer_width = "16")]
98 fn fmt<W>(&self, f: &mut Formatter<'_, W>) -> Result<(), W::Error>
99 where
100 W: uWrite + ?Sized,
101 {
102 let mut buf = [MaybeUninit::<u8>::uninit(); 11];
103
104 let s = ixx!(u32, *self, buf);
105 f.write_str(s)
106 }
107}
108
109impl uDisplay for i32 {
110 #[inline(always)]
111 fn fmt<W>(&self, f: &mut Formatter<'_, W>) -> Result<(), W::Error>
112 where
113 W: uWrite + ?Sized,
114 {
115 <i32 as uDebug>::fmt(self, f)
116 }
117}
118
119impl uDebug for i64 {
120 #[cfg(any(target_pointer_width = "32", target_pointer_width = "16"))]
121 fn fmt<W>(&self, f: &mut Formatter<'_, W>) -> Result<(), W::Error>
122 where
123 W: uWrite + ?Sized,
124 {
125 let mut buf = [MaybeUninit::<u8>::uninit(); 20];
126
127 let s = ixx!(u64, *self, buf);
128 f.write_str(s)
129 }
130
131 #[cfg(target_pointer_width = "64")]
132 fn fmt<W>(&self, f: &mut Formatter<'_, W>) -> Result<(), W::Error>
133 where
134 W: uWrite + ?Sized,
135 {
136 let mut buf = [MaybeUninit::uninit(); 20];
137
138 f.write_str(isize(*self as isize, &mut buf))
139 }
140}
141
142impl uDisplay for i64 {
143 #[inline(always)]
144 fn fmt<W>(&self, f: &mut Formatter<'_, W>) -> Result<(), W::Error>
145 where
146 W: uWrite + ?Sized,
147 {
148 <i64 as uDebug>::fmt(self, f)
149 }
150}
151
152impl uDebug for i128 {
153 fn fmt<W>(&self, f: &mut Formatter<'_, W>) -> Result<(), W::Error>
154 where
155 W: uWrite + ?Sized,
156 {
157 let mut buf = [MaybeUninit::<u8>::uninit(); 40];
158
159 let s = ixx!(u128, *self, buf);
160 f.write_str(s)
161 }
162}
163
164impl uDisplay for i128 {
165 #[inline(always)]
166 fn fmt<W>(&self, f: &mut Formatter<'_, W>) -> Result<(), W::Error>
167 where
168 W: uWrite + ?Sized,
169 {
170 <i128 as uDebug>::fmt(self, f)
171 }
172}
173
174impl uDebug for isize {
175 #[cfg(target_pointer_width = "16")]
176 #[inline(always)]
177 fn fmt<W>(&self, f: &mut Formatter<'_, W>) -> Result<(), W::Error>
178 where
179 W: uWrite + ?Sized,
180 {
181 <i16 as uDebug>::fmt(&(*self as i16), f)
182 }
183
184 #[cfg(target_pointer_width = "32")]
185 #[inline(always)]
186 fn fmt<W>(&self, f: &mut Formatter<'_, W>) -> Result<(), W::Error>
187 where
188 W: uWrite + ?Sized,
189 {
190 <i32 as uDebug>::fmt(&(*self as i32), f)
191 }
192
193 #[cfg(target_pointer_width = "64")]
194 #[inline(always)]
195 fn fmt<W>(&self, f: &mut Formatter<'_, W>) -> Result<(), W::Error>
196 where
197 W: uWrite + ?Sized,
198 {
199 <i64 as uDebug>::fmt(&(*self as i64), f)
200 }
201}
202
203impl uDisplay for isize {
204 #[cfg(target_pointer_width = "16")]
205 #[inline(always)]
206 fn fmt<W>(&self, f: &mut Formatter<'_, W>) -> Result<(), W::Error>
207 where
208 W: uWrite + ?Sized,
209 {
210 <i16 as uDisplay>::fmt(&(*self as i16), f)
211 }
212
213 #[cfg(target_pointer_width = "32")]
214 #[inline(always)]
215 fn fmt<W>(&self, f: &mut Formatter<'_, W>) -> Result<(), W::Error>
216 where
217 W: uWrite + ?Sized,
218 {
219 <i32 as uDisplay>::fmt(&(*self as i32), f)
220 }
221
222 #[cfg(target_pointer_width = "64")]
223 #[inline(always)]
224 fn fmt<W>(&self, f: &mut Formatter<'_, W>) -> Result<(), W::Error>
225 where
226 W: uWrite + ?Sized,
227 {
228 <i64 as uDisplay>::fmt(&(*self as i64), f)
229 }
230}