stabby_abi/
num.rs

1/// Returned when using [`core::convert::TryInto`] on the illegal value of a restricted integer.
2#[crate::stabby]
3#[derive(Clone, Copy, Default, Debug, Ord, PartialEq, PartialOrd, Eq, Hash)]
4pub struct IllegalValue;
5impl core::fmt::Display for IllegalValue {
6    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
7        core::fmt::Debug::fmt(&self, f)
8    }
9}
10#[cfg(feature = "std")]
11impl std::error::Error for IllegalValue {}
12
13macro_rules! define_non_max {
14    ($NonMaxU8:ident: $u8: ty = $NonZeroU8: ty; $u8s: literal ) => {
15        /// A number whose bit pattern is guaranteed not to be only 1s.
16        ///
17        /// `x` is stored as `NonZero(!x)`, so transmuting results in wrong values.
18        #[repr(transparent)]
19        #[derive(Clone, Copy, PartialEq, Eq)]
20        #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
21        #[cfg_attr(feature = "serde", serde(into = $u8s))]
22        #[cfg_attr(feature = "serde", serde(try_from = $u8s))]
23        pub struct $NonMaxU8 {
24            inner: $NonZeroU8,
25        }
26        impl $NonMaxU8 {
27            /// Constructs `Self`, returning `None` if `n == MAX`
28            pub const fn new(n: $u8) -> Option<Self> {
29                match <$NonZeroU8>::new(!n) {
30                    Some(n) => Some(Self { inner: n }),
31                    None => None,
32                }
33            }
34            /// Constructs `Self` without checking whether or not it is only 1s.
35            ///
36            /// # Safety
37            /// Calling this with the illegal value may result in undefined behaviour.
38            pub const unsafe fn new_unchecked(n: $u8) -> Self {
39                Self {
40                    inner: <$NonZeroU8>::new_unchecked(!n),
41                }
42            }
43            /// Returns the inner value.
44            pub const fn get(self) -> $u8 {
45                !self.inner.get()
46            }
47        }
48        impl From<$NonMaxU8> for $u8 {
49            fn from(value: $NonMaxU8) -> Self {
50                value.get()
51            }
52        }
53        impl TryFrom<$u8> for $NonMaxU8 {
54            type Error = IllegalValue;
55            fn try_from(value: $u8) -> Result<Self, Self::Error> {
56                Self::new(value).ok_or(IllegalValue)
57            }
58        }
59        impl PartialOrd for $NonMaxU8 {
60            fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
61                Some(self.cmp(other))
62            }
63        }
64        impl Ord for $NonMaxU8 {
65            fn cmp(&self, other: &Self) -> core::cmp::Ordering {
66                self.get().cmp(&other.get())
67            }
68        }
69        impl core::hash::Hash for $NonMaxU8 {
70            fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
71                self.get().hash(state)
72            }
73        }
74        unsafe impl crate::IStable for $NonMaxU8 {
75            type Size = <$NonZeroU8 as crate::IStable>::Size;
76            type Align = <$NonZeroU8 as crate::IStable>::Align;
77            type ForbiddenValues = <$NonZeroU8 as crate::IStable>::ForbiddenValues;
78            type UnusedBits = <$NonZeroU8 as crate::IStable>::UnusedBits;
79            type HasExactlyOneNiche = <$NonZeroU8 as crate::IStable>::HasExactlyOneNiche;
80            type ContainsIndirections = <$NonZeroU8 as crate::IStable>::ContainsIndirections;
81            #[cfg(feature = "experimental-ctypes")]
82            type CType = <$NonZeroU8 as crate::IStable>::CType;
83            const ID: u64 = $crate::report::gen_id(Self::REPORT);
84            const REPORT: &'static $crate::report::TypeReport = &$crate::report::TypeReport {
85                name: $crate::str::Str::new(stringify!($NonMaxU8)),
86                module: $crate::str::Str::new(core::module_path!()),
87                fields: $crate::StableLike::new(None),
88                version: 0,
89                tyty: $crate::report::TyTy::Struct,
90            };
91        }
92    };
93}
94macro_rules! define_non_x {
95    ($NonMaxU8:ident: $u8: ty = $NonZeroU8: ty; $u8s: literal ) => {
96        /// A number whose value is guaranteed not to be `FORBIDDEN`.
97        ///
98        /// `x` is stored as `NonZero(x.wrapping_sub(FORBIDDEN))`, so transmuting results in wrong values.
99        #[repr(transparent)]
100        #[derive(Clone, Copy, PartialEq, Eq)]
101        #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
102        #[cfg_attr(feature = "serde", serde(into = $u8s))]
103        #[cfg_attr(feature = "serde", serde(try_from = $u8s))]
104        pub struct $NonMaxU8<const FORBIDDEN: $u8> {
105            inner: $NonZeroU8,
106        }
107        impl<const FORBIDDEN: $u8> $NonMaxU8<{ FORBIDDEN }> {
108            /// Construct `Self`, returning `None` if `n` is the `FORBIDDEN` value.
109            pub const fn new(n: $u8) -> Option<Self> {
110                match <$NonZeroU8>::new(n.wrapping_sub(FORBIDDEN)) {
111                    Some(n) => Some(Self { inner: n }),
112                    None => None,
113                }
114            }
115            /// Constructs `Self` without checking whether or not it is only 1s.
116            ///
117            /// # Safety
118            /// Calling this with the illegal value may result in undefined behaviour.
119            pub const unsafe fn new_unchecked(n: $u8) -> Self {
120                Self {
121                    inner: <$NonZeroU8>::new_unchecked(n.wrapping_sub(FORBIDDEN)),
122                }
123            }
124            /// Get the inner value.
125            pub const fn get(self) -> $u8 {
126                self.inner.get().wrapping_add(FORBIDDEN)
127            }
128        }
129        impl<const FORBIDDEN: $u8> From<$NonMaxU8<{ FORBIDDEN }>> for $u8 {
130            fn from(value: $NonMaxU8<{ FORBIDDEN }>) -> Self {
131                value.get()
132            }
133        }
134        impl<const FORBIDDEN: $u8> TryFrom<$u8> for $NonMaxU8<{ FORBIDDEN }> {
135            type Error = IllegalValue;
136            fn try_from(value: $u8) -> Result<Self, Self::Error> {
137                Self::new(value).ok_or(IllegalValue)
138            }
139        }
140        impl<const FORBIDDEN: $u8> PartialOrd for $NonMaxU8<{ FORBIDDEN }> {
141            fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
142                Some(self.cmp(other))
143            }
144        }
145        impl<const FORBIDDEN: $u8> Ord for $NonMaxU8<{ FORBIDDEN }> {
146            fn cmp(&self, other: &Self) -> core::cmp::Ordering {
147                self.get().cmp(&other.get())
148            }
149        }
150        impl<const FORBIDDEN: $u8> core::hash::Hash for $NonMaxU8<{ FORBIDDEN }> {
151            fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
152                self.get().hash(state)
153            }
154        }
155        unsafe impl<const FORBIDDEN: $u8> crate::IStable for $NonMaxU8<{ FORBIDDEN }> {
156            type Size = <$NonZeroU8 as crate::IStable>::Size;
157            type Align = <$NonZeroU8 as crate::IStable>::Align;
158            type ForbiddenValues = <$NonZeroU8 as crate::IStable>::ForbiddenValues;
159            type UnusedBits = <$NonZeroU8 as crate::IStable>::UnusedBits;
160            type HasExactlyOneNiche = <$NonZeroU8 as crate::IStable>::HasExactlyOneNiche;
161            type ContainsIndirections = <$NonZeroU8 as crate::IStable>::ContainsIndirections;
162            #[cfg(feature = "experimental-ctypes")]
163            type CType = <$NonZeroU8 as crate::IStable>::CType;
164            const ID: u64 = $crate::report::gen_id(Self::REPORT);
165            const REPORT: &'static $crate::report::TypeReport = &$crate::report::TypeReport {
166                name: $crate::str::Str::new(stringify!($NonMaxU8)),
167                module: $crate::str::Str::new(core::module_path!()),
168                fields: $crate::StableLike::new(None),
169                version: 0,
170                tyty: $crate::report::TyTy::Struct,
171            };
172        }
173    };
174}
175
176define_non_max!(NonMaxU8: u8 = core::num::NonZeroU8; "u8");
177define_non_max!(NonMaxU16: u16 = core::num::NonZeroU16; "u16");
178define_non_max!(NonMaxU32: u32 = core::num::NonZeroU32; "u32");
179define_non_max!(NonMaxU64: u64 = core::num::NonZeroU64; "u64");
180define_non_max!(NonMaxU128: u128 = core::num::NonZeroU128; "u128");
181define_non_max!(NonMaxUsize: usize = core::num::NonZeroUsize; "usize");
182
183define_non_x!(NonXU8: u8 = core::num::NonZeroU8; "u8");
184define_non_x!(NonXU16: u16 = core::num::NonZeroU16; "u16");
185define_non_x!(NonXU32: u32 = core::num::NonZeroU32; "u32");
186define_non_x!(NonXU64: u64 = core::num::NonZeroU64; "u64");
187define_non_x!(NonXU128: u128 = core::num::NonZeroU128; "u128");
188define_non_x!(NonXUsize: usize = core::num::NonZeroUsize; "usize");
189define_non_x!(NonXI8: i8 = core::num::NonZeroI8; "i8");
190define_non_x!(NonXI16: i16 = core::num::NonZeroI16; "i16");
191define_non_x!(NonXI32: i32 = core::num::NonZeroI32; "i32");
192define_non_x!(NonXI64: i64 = core::num::NonZeroI64; "i64");
193define_non_x!(NonXI128: i128 = core::num::NonZeroI128; "i128");
194define_non_x!(NonXIsize: isize = core::num::NonZeroIsize; "isize");
195
196macro_rules! makeutest {
197    ($u8: ident, $NonMaxU8: ident, $NonXU8: ident) => {
198        #[test]
199        fn $u8() {
200            for i in 0..255 {
201                assert_eq!($NonMaxU8::new(i).unwrap().get(), i);
202                assert_eq!($NonXU8::<{ $u8::MAX }>::new(i).unwrap().get(), i);
203            }
204            assert!($NonMaxU8::new($u8::MAX).is_none());
205            assert!($NonXU8::<{ $u8::MAX }>::new($u8::MAX).is_none());
206            assert!($NonXU8::<72>::new(72).is_none());
207            for i in 0..=255 {
208                if i != 72 {
209                    assert_eq!($NonXU8::<72>::new(i).unwrap().get(), i);
210                }
211            }
212        }
213    };
214}
215makeutest!(u8, NonMaxU8, NonXU8);
216makeutest!(u16, NonMaxU16, NonXU16);
217makeutest!(u32, NonMaxU32, NonXU32);
218makeutest!(u64, NonMaxU64, NonXU64);
219makeutest!(u128, NonMaxU128, NonXU128);
220makeutest!(usize, NonMaxUsize, NonXUsize);
221macro_rules! makeitest {
222    ($i8: ident,  $NonXI8: ident) => {
223        #[test]
224        fn $i8() {
225            for i in -127..=127 {
226                assert_eq!($NonXI8::<{ $i8::MIN }>::new(i).unwrap().get(), i);
227            }
228            assert!($NonXI8::<{ $i8::MIN }>::new($i8::MIN).is_none());
229            assert!($NonXI8::<72>::new(72).is_none());
230            for i in -128..=127 {
231                if i != 72 {
232                    assert_eq!($NonXI8::<72>::new(i).unwrap().get(), i);
233                }
234            }
235        }
236    };
237}
238makeitest!(i8, NonXI8);
239makeitest!(i16, NonXI16);
240makeitest!(i32, NonXI32);
241makeitest!(i64, NonXI64);
242makeitest!(i128, NonXI128);
243makeitest!(isize, NonXIsize);
244
245macro_rules! makeumask {
246    ($name: ident, $base: ident, $bits: ty, $docs: literal) => {
247        #[doc = $docs]
248        ///
249        /// Its memory layout from Rust's point of view is that of the smallest unsigned type
250        /// that can contain it.
251        ///
252        /// However, `stabby` can tell that it's most significant bits are unused, and use that knowledge to make
253        /// `#[repr(stabby)]` `enum`s smaller.
254        #[allow(non_camel_case_types)]
255        #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash, Default)]
256        pub struct $name($base);
257        impl $name {
258            const MASK: $base = $base::MAX
259                >> (8 * ::core::mem::size_of::<$base>() as $base
260                    - <$bits as $crate::typenum2::Unsigned>::U128 as $base);
261            /// The maximum value for this type.
262            pub const MAX: Self = Self(Self::MASK);
263            /// The maximum value for this type.
264            pub const MIN: Self = Self(0);
265            /// Construct a new value if it can fit.
266            pub const fn new(value: $base) -> Option<Self> {
267                match value <= Self::MASK {
268                    true => Some(Self(value)),
269                    false => None,
270                }
271            }
272            /// Get the inner value.
273            pub const fn get(&self) -> $base {
274                self.0 & Self::MASK
275            }
276        }
277        impl ::core::fmt::Debug for $name {
278            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> core::fmt::Result {
279                ::core::fmt::Debug::fmt(&self.0, f)
280            }
281        }
282        impl ::core::fmt::Display for $name {
283            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> core::fmt::Result {
284                ::core::fmt::Display::fmt(&self.0, f)
285            }
286        }
287        impl ::core::fmt::LowerHex for $name {
288            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> core::fmt::Result {
289                ::core::fmt::LowerHex::fmt(&self.0, f)
290            }
291        }
292        impl ::core::fmt::UpperHex for $name {
293            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> core::fmt::Result {
294                ::core::fmt::UpperHex::fmt(&self.0, f)
295            }
296        }
297        impl ::core::fmt::LowerExp for $name {
298            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> core::fmt::Result {
299                ::core::fmt::LowerExp::fmt(&self.0, f)
300            }
301        }
302        impl ::core::fmt::UpperExp for $name {
303            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> core::fmt::Result {
304                ::core::fmt::UpperExp::fmt(&self.0, f)
305            }
306        }
307        impl ::core::fmt::Binary for $name {
308            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> core::fmt::Result {
309                ::core::fmt::Binary::fmt(&self.0, f)
310            }
311        }
312        impl ::core::fmt::Octal for $name {
313            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> core::fmt::Result {
314                ::core::fmt::Octal::fmt(&self.0, f)
315            }
316        }
317        impl ::core::ops::BitAnd<$base> for $name {
318            type Output = Self;
319            fn bitand(self, rhs: $base) -> Self {
320                Self(self.0 & rhs)
321            }
322        }
323        impl ::core::ops::BitAnd for $name {
324            type Output = Self;
325            fn bitand(self, rhs: Self) -> Self {
326                Self(self.0 & rhs.0)
327            }
328        }
329        impl<T> ::core::ops::BitAndAssign<T> for $name
330        where
331            Self: ::core::ops::BitAnd<T, Output = Self>,
332        {
333            fn bitand_assign(&mut self, rhs: T) {
334                *self = *self & rhs;
335            }
336        }
337        impl ::core::ops::BitOr for $name {
338            type Output = Self;
339            fn bitor(self, rhs: Self) -> Self {
340                Self(self.0 | rhs.0)
341            }
342        }
343        impl ::core::ops::BitOr<$base> for $name {
344            type Output = $base;
345            fn bitor(self, rhs: $base) -> $base {
346                self.get() | rhs
347            }
348        }
349        impl<T> ::core::ops::BitOrAssign<T> for $name
350        where
351            Self: ::core::ops::BitOr<T, Output = Self>,
352        {
353            fn bitor_assign(&mut self, rhs: T) {
354                *self = *self | rhs;
355            }
356        }
357        impl ::core::ops::Add for $name {
358            type Output = $base;
359            fn add(self, rhs: Self) -> $base {
360                // SAFETY: Since the type is masked, addition will never overflow.
361                unsafe { self.get().checked_add(rhs.get()).unwrap_unchecked() }
362            }
363        }
364        impl ::core::ops::Sub<$base> for $name {
365            type Output = Self;
366            fn sub(self, rhs: $base) -> Self {
367                Self(self.get() - rhs)
368            }
369        }
370        impl ::core::ops::Sub for $name {
371            type Output = Self;
372            fn sub(self, rhs: Self) -> Self {
373                Self(self.get() - rhs.get())
374            }
375        }
376    };
377}
378
379macro_rules! makeimask {
380    ($name: ident, $base: ident, $bits: ty, $docs: literal) => {
381        #[doc = $docs]
382        ///
383        /// Its memory layout from Rust's point of view is that of the smallest unsigned type
384        /// that can contain it.
385        ///
386        /// However, `stabby` can tell that it's most significant bits are unused, and use that knowledge to make
387        /// `#[repr(stabby)]` `enum`s smaller.
388        #[allow(non_camel_case_types)]
389        #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash, Default)]
390        pub struct $name($base);
391        impl $name {
392            const MASK: $base = ($base::MAX
393                >> (8 * ::core::mem::size_of::<$base>() as i32
394                    - <$bits as $crate::typenum2::Unsigned>::U128 as i32))
395                | (1 << (<$bits as $crate::typenum2::Unsigned>::U128 as i32 - 1));
396            /// The maximum value for this type.
397            pub const MAX: Self =
398                Self($base::MAX >> (<$bits as $crate::typenum2::Unsigned>::U128 as $base));
399            /// The maximum value for this type.
400            pub const MIN: Self =
401                Self(1 << (<$bits as $crate::typenum2::Unsigned>::U128 as i32 - 1));
402            /// Construct a new value if it can fit.
403            pub const fn new(value: $base) -> Option<Self> {
404                match value <= Self::MAX.get() && value >= Self::MIN.get() {
405                    true => Some(Self(value)),
406                    false => None,
407                }
408            }
409            const fn sign_extend(value: $base) -> $base {
410                const SHIFT: i32 = (8 * ::core::mem::size_of::<$base>() as i32
411                    - <$bits as $crate::typenum2::Unsigned>::U128 as i32);
412                value | ((value & Self::MIN.0) << SHIFT) >> (SHIFT - 1)
413            }
414            /// Get the inner value.
415            pub const fn get(&self) -> $base {
416                Self::sign_extend(self.0 & Self::MASK)
417            }
418        }
419        impl ::core::fmt::Debug for $name {
420            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> core::fmt::Result {
421                ::core::fmt::Debug::fmt(&self.0, f)
422            }
423        }
424        impl ::core::fmt::Display for $name {
425            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> core::fmt::Result {
426                ::core::fmt::Display::fmt(&self.0, f)
427            }
428        }
429        impl ::core::fmt::LowerHex for $name {
430            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> core::fmt::Result {
431                ::core::fmt::LowerHex::fmt(&self.0, f)
432            }
433        }
434        impl ::core::fmt::UpperHex for $name {
435            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> core::fmt::Result {
436                ::core::fmt::UpperHex::fmt(&self.0, f)
437            }
438        }
439        impl ::core::fmt::LowerExp for $name {
440            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> core::fmt::Result {
441                ::core::fmt::LowerExp::fmt(&self.0, f)
442            }
443        }
444        impl ::core::fmt::UpperExp for $name {
445            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> core::fmt::Result {
446                ::core::fmt::UpperExp::fmt(&self.0, f)
447            }
448        }
449        impl ::core::fmt::Binary for $name {
450            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> core::fmt::Result {
451                ::core::fmt::Binary::fmt(&self.0, f)
452            }
453        }
454        impl ::core::fmt::Octal for $name {
455            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> core::fmt::Result {
456                ::core::fmt::Octal::fmt(&self.0, f)
457            }
458        }
459        impl ::core::ops::BitAnd<$base> for $name {
460            type Output = Self;
461            fn bitand(self, rhs: $base) -> Self {
462                Self(self.0 & rhs)
463            }
464        }
465        impl ::core::ops::BitAnd for $name {
466            type Output = Self;
467            fn bitand(self, rhs: Self) -> Self {
468                Self(self.0 & rhs.0)
469            }
470        }
471        impl<T> ::core::ops::BitAndAssign<T> for $name
472        where
473            Self: ::core::ops::BitAnd<T, Output = Self>,
474        {
475            fn bitand_assign(&mut self, rhs: T) {
476                *self = *self & rhs;
477            }
478        }
479        impl ::core::ops::BitOr for $name {
480            type Output = Self;
481            fn bitor(self, rhs: Self) -> Self {
482                Self(self.0 | rhs.0)
483            }
484        }
485        impl<T> ::core::ops::BitOrAssign<T> for $name
486        where
487            Self: ::core::ops::BitOr<T, Output = Self>,
488        {
489            fn bitor_assign(&mut self, rhs: T) {
490                *self = *self | rhs;
491            }
492        }
493    };
494}
495
496#[test]
497fn numbers() {
498    macro_rules! deftest {
499        ($name: ty, $base: ty) => {
500            for i in (<$base>::MIN..<$base>::MAX)
501                .rev()
502                .step_by(<$base>::MAX as usize / 127)
503            {
504                let Some(n) = <$name>::new(dbg!(i)) else {
505                    assert!(i > <$name>::MAX.get() || i < <$name>::MIN.get());
506                    continue;
507                };
508                assert_eq!(n.get(), i);
509                assert!(i <= dbg!(<$name>::MAX.get()));
510                assert!(i >= dbg!(<$name>::MIN.get()));
511            }
512        };
513    }
514    deftest!(u6, u8);
515    deftest!(u26, u32);
516    deftest!(i6, i8);
517    deftest!(i26, i32);
518}
519
520makeumask!(u1, u8, crate::typenum2::U1, "A 1 bit unsigned integer");
521makeumask!(u2, u8, crate::typenum2::U2, "A 2 bit unsigned integer");
522makeumask!(u3, u8, crate::typenum2::U3, "A 3 bit unsigned integer");
523makeumask!(u4, u8, crate::typenum2::U4, "A 4 bit unsigned integer");
524makeumask!(u5, u8, crate::typenum2::U5, "A 5 bit unsigned integer");
525makeumask!(u6, u8, crate::typenum2::U6, "A 6 bit unsigned integer");
526makeumask!(u7, u8, crate::typenum2::U7, "A 7 bit unsigned integer");
527
528makeumask!(u9, u16, crate::typenum2::U9, "A 9 bit unsigned integer");
529makeumask!(u10, u16, crate::typenum2::U10, "A 10 bit unsigned integer");
530makeumask!(u11, u16, crate::typenum2::U11, "A 11 bit unsigned integer");
531makeumask!(u12, u16, crate::typenum2::U12, "A 12 bit unsigned integer");
532makeumask!(u13, u16, crate::typenum2::U13, "A 13 bit unsigned integer");
533makeumask!(u14, u16, crate::typenum2::U14, "A 14 bit unsigned integer");
534makeumask!(u15, u16, crate::typenum2::U15, "A 15 bit unsigned integer");
535
536makeumask!(u17, u32, crate::typenum2::U17, "A 17 bit unsigned integer");
537makeumask!(u18, u32, crate::typenum2::U18, "A 18 bit unsigned integer");
538makeumask!(u19, u32, crate::typenum2::U19, "A 19 bit unsigned integer");
539makeumask!(u20, u32, crate::typenum2::U20, "A 20 bit unsigned integer");
540makeumask!(u21, u32, crate::typenum2::U21, "A 21 bit unsigned integer");
541makeumask!(u22, u32, crate::typenum2::U22, "A 22 bit unsigned integer");
542makeumask!(u23, u32, crate::typenum2::U23, "A 23 bit unsigned integer");
543makeumask!(u24, u32, crate::typenum2::U24, "A 24 bit unsigned integer");
544makeumask!(u25, u32, crate::typenum2::U25, "A 25 bit unsigned integer");
545makeumask!(u26, u32, crate::typenum2::U26, "A 26 bit unsigned integer");
546makeumask!(u27, u32, crate::typenum2::U27, "A 27 bit unsigned integer");
547makeumask!(u28, u32, crate::typenum2::U28, "A 28 bit unsigned integer");
548makeumask!(u29, u32, crate::typenum2::U29, "A 29 bit unsigned integer");
549makeumask!(u30, u32, crate::typenum2::U30, "A 30 bit unsigned integer");
550makeumask!(u31, u32, crate::typenum2::U31, "A 31 bit unsigned integer");
551
552makeumask!(u33, u64, crate::typenum2::U33, "A 33 bit unsigned integer");
553makeumask!(u34, u64, crate::typenum2::U34, "A 34 bit unsigned integer");
554makeumask!(u35, u64, crate::typenum2::U35, "A 35 bit unsigned integer");
555makeumask!(u36, u64, crate::typenum2::U36, "A 36 bit unsigned integer");
556makeumask!(u37, u64, crate::typenum2::U37, "A 37 bit unsigned integer");
557makeumask!(u38, u64, crate::typenum2::U38, "A 38 bit unsigned integer");
558makeumask!(u39, u64, crate::typenum2::U39, "A 39 bit unsigned integer");
559makeumask!(u40, u64, crate::typenum2::U40, "A 40 bit unsigned integer");
560makeumask!(u41, u64, crate::typenum2::U41, "A 41 bit unsigned integer");
561makeumask!(u42, u64, crate::typenum2::U42, "A 42 bit unsigned integer");
562makeumask!(u43, u64, crate::typenum2::U43, "A 43 bit unsigned integer");
563makeumask!(u44, u64, crate::typenum2::U44, "A 44 bit unsigned integer");
564makeumask!(u45, u64, crate::typenum2::U45, "A 45 bit unsigned integer");
565makeumask!(u46, u64, crate::typenum2::U46, "A 46 bit unsigned integer");
566makeumask!(u47, u64, crate::typenum2::U47, "A 47 bit unsigned integer");
567makeumask!(u48, u64, crate::typenum2::U48, "A 48 bit unsigned integer");
568makeumask!(u49, u64, crate::typenum2::U49, "A 49 bit unsigned integer");
569makeumask!(u50, u64, crate::typenum2::U50, "A 50 bit unsigned integer");
570makeumask!(u51, u64, crate::typenum2::U51, "A 51 bit unsigned integer");
571makeumask!(u52, u64, crate::typenum2::U52, "A 52 bit unsigned integer");
572makeumask!(u53, u64, crate::typenum2::U53, "A 53 bit unsigned integer");
573makeumask!(u54, u64, crate::typenum2::U54, "A 54 bit unsigned integer");
574makeumask!(u55, u64, crate::typenum2::U55, "A 55 bit unsigned integer");
575makeumask!(u56, u64, crate::typenum2::U56, "A 56 bit unsigned integer");
576makeumask!(u57, u64, crate::typenum2::U57, "A 57 bit unsigned integer");
577makeumask!(u58, u64, crate::typenum2::U58, "A 58 bit unsigned integer");
578makeumask!(u59, u64, crate::typenum2::U59, "A 59 bit unsigned integer");
579makeumask!(u60, u64, crate::typenum2::U60, "A 60 bit unsigned integer");
580makeumask!(u61, u64, crate::typenum2::U61, "A 61 bit unsigned integer");
581makeumask!(u62, u64, crate::typenum2::U62, "A 62 bit unsigned integer");
582makeumask!(u63, u64, crate::typenum2::U63, "A 63 bit unsigned integer");
583
584makeumask!(u65, u128, crate::typenum2::U65, "A 65 bit unsigned integer");
585makeumask!(u66, u128, crate::typenum2::U66, "A 66 bit unsigned integer");
586makeumask!(u67, u128, crate::typenum2::U67, "A 67 bit unsigned integer");
587makeumask!(u68, u128, crate::typenum2::U68, "A 68 bit unsigned integer");
588makeumask!(u69, u128, crate::typenum2::U69, "A 69 bit unsigned integer");
589makeumask!(u70, u128, crate::typenum2::U70, "A 70 bit unsigned integer");
590makeumask!(u71, u128, crate::typenum2::U71, "A 71 bit unsigned integer");
591makeumask!(u72, u128, crate::typenum2::U72, "A 72 bit unsigned integer");
592makeumask!(u73, u128, crate::typenum2::U73, "A 73 bit unsigned integer");
593makeumask!(u74, u128, crate::typenum2::U74, "A 74 bit unsigned integer");
594makeumask!(u75, u128, crate::typenum2::U75, "A 75 bit unsigned integer");
595makeumask!(u76, u128, crate::typenum2::U76, "A 76 bit unsigned integer");
596makeumask!(u77, u128, crate::typenum2::U77, "A 77 bit unsigned integer");
597makeumask!(u78, u128, crate::typenum2::U78, "A 78 bit unsigned integer");
598makeumask!(u79, u128, crate::typenum2::U79, "A 79 bit unsigned integer");
599makeumask!(u80, u128, crate::typenum2::U80, "A 80 bit unsigned integer");
600makeumask!(u81, u128, crate::typenum2::U81, "A 81 bit unsigned integer");
601makeumask!(u82, u128, crate::typenum2::U82, "A 82 bit unsigned integer");
602makeumask!(u83, u128, crate::typenum2::U83, "A 83 bit unsigned integer");
603makeumask!(u84, u128, crate::typenum2::U84, "A 84 bit unsigned integer");
604makeumask!(u85, u128, crate::typenum2::U85, "A 85 bit unsigned integer");
605makeumask!(u86, u128, crate::typenum2::U86, "A 86 bit unsigned integer");
606makeumask!(u87, u128, crate::typenum2::U87, "A 87 bit unsigned integer");
607makeumask!(u88, u128, crate::typenum2::U88, "A 88 bit unsigned integer");
608makeumask!(u89, u128, crate::typenum2::U89, "A 89 bit unsigned integer");
609makeumask!(u90, u128, crate::typenum2::U90, "A 90 bit unsigned integer");
610makeumask!(u91, u128, crate::typenum2::U91, "A 91 bit unsigned integer");
611makeumask!(u92, u128, crate::typenum2::U92, "A 92 bit unsigned integer");
612makeumask!(u93, u128, crate::typenum2::U93, "A 93 bit unsigned integer");
613makeumask!(u94, u128, crate::typenum2::U94, "A 94 bit unsigned integer");
614makeumask!(u95, u128, crate::typenum2::U95, "A 95 bit unsigned integer");
615makeumask!(u96, u128, crate::typenum2::U96, "A 96 bit unsigned integer");
616makeumask!(u97, u128, crate::typenum2::U97, "A 97 bit unsigned integer");
617makeumask!(u98, u128, crate::typenum2::U98, "A 98 bit unsigned integer");
618makeumask!(u99, u128, crate::typenum2::U99, "A 99 bit unsigned integer");
619makeumask!(
620    u100,
621    u128,
622    crate::typenum2::U100,
623    "A 100 bit unsigned integer"
624);
625makeumask!(
626    u101,
627    u128,
628    crate::typenum2::U101,
629    "A 101 bit unsigned integer"
630);
631makeumask!(
632    u102,
633    u128,
634    crate::typenum2::U102,
635    "A 102 bit unsigned integer"
636);
637makeumask!(
638    u103,
639    u128,
640    crate::typenum2::U103,
641    "A 103 bit unsigned integer"
642);
643makeumask!(
644    u104,
645    u128,
646    crate::typenum2::U104,
647    "A 104 bit unsigned integer"
648);
649makeumask!(
650    u105,
651    u128,
652    crate::typenum2::U105,
653    "A 105 bit unsigned integer"
654);
655makeumask!(
656    u106,
657    u128,
658    crate::typenum2::U106,
659    "A 106 bit unsigned integer"
660);
661makeumask!(
662    u107,
663    u128,
664    crate::typenum2::U107,
665    "A 107 bit unsigned integer"
666);
667makeumask!(
668    u108,
669    u128,
670    crate::typenum2::U108,
671    "A 108 bit unsigned integer"
672);
673makeumask!(
674    u109,
675    u128,
676    crate::typenum2::U109,
677    "A 109 bit unsigned integer"
678);
679makeumask!(
680    u110,
681    u128,
682    crate::typenum2::U110,
683    "A 110 bit unsigned integer"
684);
685makeumask!(
686    u111,
687    u128,
688    crate::typenum2::U111,
689    "A 111 bit unsigned integer"
690);
691makeumask!(
692    u112,
693    u128,
694    crate::typenum2::U112,
695    "A 112 bit unsigned integer"
696);
697makeumask!(
698    u113,
699    u128,
700    crate::typenum2::U113,
701    "A 113 bit unsigned integer"
702);
703makeumask!(
704    u114,
705    u128,
706    crate::typenum2::U114,
707    "A 114 bit unsigned integer"
708);
709makeumask!(
710    u115,
711    u128,
712    crate::typenum2::U115,
713    "A 115 bit unsigned integer"
714);
715makeumask!(
716    u116,
717    u128,
718    crate::typenum2::U116,
719    "A 116 bit unsigned integer"
720);
721makeumask!(
722    u117,
723    u128,
724    crate::typenum2::U117,
725    "A 117 bit unsigned integer"
726);
727makeumask!(
728    u118,
729    u128,
730    crate::typenum2::U118,
731    "A 118 bit unsigned integer"
732);
733makeumask!(
734    u119,
735    u128,
736    crate::typenum2::U119,
737    "A 119 bit unsigned integer"
738);
739makeumask!(
740    u120,
741    u128,
742    crate::typenum2::U120,
743    "A 120 bit unsigned integer"
744);
745makeumask!(
746    u121,
747    u128,
748    crate::typenum2::U121,
749    "A 121 bit unsigned integer"
750);
751makeumask!(
752    u122,
753    u128,
754    crate::typenum2::U122,
755    "A 122 bit unsigned integer"
756);
757makeumask!(
758    u123,
759    u128,
760    crate::typenum2::U123,
761    "A 123 bit unsigned integer"
762);
763makeumask!(
764    u124,
765    u128,
766    crate::typenum2::U124,
767    "A 124 bit unsigned integer"
768);
769makeumask!(
770    u125,
771    u128,
772    crate::typenum2::U125,
773    "A 125 bit unsigned integer"
774);
775makeumask!(
776    u126,
777    u128,
778    crate::typenum2::U126,
779    "A 126 bit unsigned integer"
780);
781makeumask!(
782    u127,
783    u128,
784    crate::typenum2::U127,
785    "A 127 bit unsigned integer"
786);
787
788makeimask!(i1, i8, crate::typenum2::U1, "A 1 bit signed integer");
789makeimask!(i2, i8, crate::typenum2::U2, "A 2 bit signed integer");
790makeimask!(i3, i8, crate::typenum2::U3, "A 3 bit signed integer");
791makeimask!(i4, i8, crate::typenum2::U4, "A 4 bit signed integer");
792makeimask!(i5, i8, crate::typenum2::U5, "A 5 bit signed integer");
793makeimask!(i6, i8, crate::typenum2::U6, "A 6 bit signed integer");
794makeimask!(i7, i8, crate::typenum2::U7, "A 7 bit signed integer");
795
796makeimask!(i9, i16, crate::typenum2::U9, "A 9 bit signed integer");
797makeimask!(i10, i16, crate::typenum2::U10, "A 10 bit signed integer");
798makeimask!(i11, i16, crate::typenum2::U11, "A 11 bit signed integer");
799makeimask!(i12, i16, crate::typenum2::U12, "A 12 bit signed integer");
800makeimask!(i13, i16, crate::typenum2::U13, "A 13 bit signed integer");
801makeimask!(i14, i16, crate::typenum2::U14, "A 14 bit signed integer");
802makeimask!(i15, i16, crate::typenum2::U15, "A 15 bit signed integer");
803
804makeimask!(i17, i32, crate::typenum2::U17, "A 17 bit signed integer");
805makeimask!(i18, i32, crate::typenum2::U18, "A 18 bit signed integer");
806makeimask!(i19, i32, crate::typenum2::U19, "A 19 bit signed integer");
807makeimask!(i20, i32, crate::typenum2::U20, "A 20 bit signed integer");
808makeimask!(i21, i32, crate::typenum2::U21, "A 21 bit signed integer");
809makeimask!(i22, i32, crate::typenum2::U22, "A 22 bit signed integer");
810makeimask!(i23, i32, crate::typenum2::U23, "A 23 bit signed integer");
811makeimask!(i24, i32, crate::typenum2::U24, "A 24 bit signed integer");
812makeimask!(i25, i32, crate::typenum2::U25, "A 25 bit signed integer");
813makeimask!(i26, i32, crate::typenum2::U26, "A 26 bit signed integer");
814makeimask!(i27, i32, crate::typenum2::U27, "A 27 bit signed integer");
815makeimask!(i28, i32, crate::typenum2::U28, "A 28 bit signed integer");
816makeimask!(i29, i32, crate::typenum2::U29, "A 29 bit signed integer");
817makeimask!(i30, i32, crate::typenum2::U30, "A 30 bit signed integer");
818makeimask!(i31, i32, crate::typenum2::U31, "A 31 bit signed integer");
819
820makeimask!(i33, i64, crate::typenum2::U33, "A 33 bit signed integer");
821makeimask!(i34, i64, crate::typenum2::U34, "A 34 bit signed integer");
822makeimask!(i35, i64, crate::typenum2::U35, "A 35 bit signed integer");
823makeimask!(i36, i64, crate::typenum2::U36, "A 36 bit signed integer");
824makeimask!(i37, i64, crate::typenum2::U37, "A 37 bit signed integer");
825makeimask!(i38, i64, crate::typenum2::U38, "A 38 bit signed integer");
826makeimask!(i39, i64, crate::typenum2::U39, "A 39 bit signed integer");
827makeimask!(i40, i64, crate::typenum2::U40, "A 40 bit signed integer");
828makeimask!(i41, i64, crate::typenum2::U41, "A 41 bit signed integer");
829makeimask!(i42, i64, crate::typenum2::U42, "A 42 bit signed integer");
830makeimask!(i43, i64, crate::typenum2::U43, "A 43 bit signed integer");
831makeimask!(i44, i64, crate::typenum2::U44, "A 44 bit signed integer");
832makeimask!(i45, i64, crate::typenum2::U45, "A 45 bit signed integer");
833makeimask!(i46, i64, crate::typenum2::U46, "A 46 bit signed integer");
834makeimask!(i47, i64, crate::typenum2::U47, "A 47 bit signed integer");
835makeimask!(i48, i64, crate::typenum2::U48, "A 48 bit signed integer");
836makeimask!(i49, i64, crate::typenum2::U49, "A 49 bit signed integer");
837makeimask!(i50, i64, crate::typenum2::U50, "A 50 bit signed integer");
838makeimask!(i51, i64, crate::typenum2::U51, "A 51 bit signed integer");
839makeimask!(i52, i64, crate::typenum2::U52, "A 52 bit signed integer");
840makeimask!(i53, i64, crate::typenum2::U53, "A 53 bit signed integer");
841makeimask!(i54, i64, crate::typenum2::U54, "A 54 bit signed integer");
842makeimask!(i55, i64, crate::typenum2::U55, "A 55 bit signed integer");
843makeimask!(i56, i64, crate::typenum2::U56, "A 56 bit signed integer");
844makeimask!(i57, i64, crate::typenum2::U57, "A 57 bit signed integer");
845makeimask!(i58, i64, crate::typenum2::U58, "A 58 bit signed integer");
846makeimask!(i59, i64, crate::typenum2::U59, "A 59 bit signed integer");
847makeimask!(i60, i64, crate::typenum2::U60, "A 60 bit signed integer");
848makeimask!(i61, i64, crate::typenum2::U61, "A 61 bit signed integer");
849makeimask!(i62, i64, crate::typenum2::U62, "A 62 bit signed integer");
850makeimask!(i63, i64, crate::typenum2::U63, "A 63 bit signed integer");
851
852makeimask!(i65, i128, crate::typenum2::U65, "A 65 bit signed integer");
853makeimask!(i66, i128, crate::typenum2::U66, "A 66 bit signed integer");
854makeimask!(i67, i128, crate::typenum2::U67, "A 67 bit signed integer");
855makeimask!(i68, i128, crate::typenum2::U68, "A 68 bit signed integer");
856makeimask!(i69, i128, crate::typenum2::U69, "A 69 bit signed integer");
857makeimask!(i70, i128, crate::typenum2::U70, "A 70 bit signed integer");
858makeimask!(i71, i128, crate::typenum2::U71, "A 71 bit signed integer");
859makeimask!(i72, i128, crate::typenum2::U72, "A 72 bit signed integer");
860makeimask!(i73, i128, crate::typenum2::U73, "A 73 bit signed integer");
861makeimask!(i74, i128, crate::typenum2::U74, "A 74 bit signed integer");
862makeimask!(i75, i128, crate::typenum2::U75, "A 75 bit signed integer");
863makeimask!(i76, i128, crate::typenum2::U76, "A 76 bit signed integer");
864makeimask!(i77, i128, crate::typenum2::U77, "A 77 bit signed integer");
865makeimask!(i78, i128, crate::typenum2::U78, "A 78 bit signed integer");
866makeimask!(i79, i128, crate::typenum2::U79, "A 79 bit signed integer");
867makeimask!(i80, i128, crate::typenum2::U80, "A 80 bit signed integer");
868makeimask!(i81, i128, crate::typenum2::U81, "A 81 bit signed integer");
869makeimask!(i82, i128, crate::typenum2::U82, "A 82 bit signed integer");
870makeimask!(i83, i128, crate::typenum2::U83, "A 83 bit signed integer");
871makeimask!(i84, i128, crate::typenum2::U84, "A 84 bit signed integer");
872makeimask!(i85, i128, crate::typenum2::U85, "A 85 bit signed integer");
873makeimask!(i86, i128, crate::typenum2::U86, "A 86 bit signed integer");
874makeimask!(i87, i128, crate::typenum2::U87, "A 87 bit signed integer");
875makeimask!(i88, i128, crate::typenum2::U88, "A 88 bit signed integer");
876makeimask!(i89, i128, crate::typenum2::U89, "A 89 bit signed integer");
877makeimask!(i90, i128, crate::typenum2::U90, "A 90 bit signed integer");
878makeimask!(i91, i128, crate::typenum2::U91, "A 91 bit signed integer");
879makeimask!(i92, i128, crate::typenum2::U92, "A 92 bit signed integer");
880makeimask!(i93, i128, crate::typenum2::U93, "A 93 bit signed integer");
881makeimask!(i94, i128, crate::typenum2::U94, "A 94 bit signed integer");
882makeimask!(i95, i128, crate::typenum2::U95, "A 95 bit signed integer");
883makeimask!(i96, i128, crate::typenum2::U96, "A 96 bit signed integer");
884makeimask!(i97, i128, crate::typenum2::U97, "A 97 bit signed integer");
885makeimask!(i98, i128, crate::typenum2::U98, "A 98 bit signed integer");
886makeimask!(i99, i128, crate::typenum2::U99, "A 99 bit signed integer");
887makeimask!(
888    i100,
889    i128,
890    crate::typenum2::U100,
891    "A 100 bit signed integer"
892);
893makeimask!(
894    i101,
895    i128,
896    crate::typenum2::U101,
897    "A 101 bit signed integer"
898);
899makeimask!(
900    i102,
901    i128,
902    crate::typenum2::U102,
903    "A 102 bit signed integer"
904);
905makeimask!(
906    i103,
907    i128,
908    crate::typenum2::U103,
909    "A 103 bit signed integer"
910);
911makeimask!(
912    i104,
913    i128,
914    crate::typenum2::U104,
915    "A 104 bit signed integer"
916);
917makeimask!(
918    i105,
919    i128,
920    crate::typenum2::U105,
921    "A 105 bit signed integer"
922);
923makeimask!(
924    i106,
925    i128,
926    crate::typenum2::U106,
927    "A 106 bit signed integer"
928);
929makeimask!(
930    i107,
931    i128,
932    crate::typenum2::U107,
933    "A 107 bit signed integer"
934);
935makeimask!(
936    i108,
937    i128,
938    crate::typenum2::U108,
939    "A 108 bit signed integer"
940);
941makeimask!(
942    i109,
943    i128,
944    crate::typenum2::U109,
945    "A 109 bit signed integer"
946);
947makeimask!(
948    i110,
949    i128,
950    crate::typenum2::U110,
951    "A 110 bit signed integer"
952);
953makeimask!(
954    i111,
955    i128,
956    crate::typenum2::U111,
957    "A 111 bit signed integer"
958);
959makeimask!(
960    i112,
961    i128,
962    crate::typenum2::U112,
963    "A 112 bit signed integer"
964);
965makeimask!(
966    i113,
967    i128,
968    crate::typenum2::U113,
969    "A 113 bit signed integer"
970);
971makeimask!(
972    i114,
973    i128,
974    crate::typenum2::U114,
975    "A 114 bit signed integer"
976);
977makeimask!(
978    i115,
979    i128,
980    crate::typenum2::U115,
981    "A 115 bit signed integer"
982);
983makeimask!(
984    i116,
985    i128,
986    crate::typenum2::U116,
987    "A 116 bit signed integer"
988);
989makeimask!(
990    i117,
991    i128,
992    crate::typenum2::U117,
993    "A 117 bit signed integer"
994);
995makeimask!(
996    i118,
997    i128,
998    crate::typenum2::U118,
999    "A 118 bit signed integer"
1000);
1001makeimask!(
1002    i119,
1003    i128,
1004    crate::typenum2::U119,
1005    "A 119 bit signed integer"
1006);
1007makeimask!(
1008    i120,
1009    i128,
1010    crate::typenum2::U120,
1011    "A 120 bit signed integer"
1012);
1013makeimask!(
1014    i121,
1015    i128,
1016    crate::typenum2::U121,
1017    "A 121 bit signed integer"
1018);
1019makeimask!(
1020    i122,
1021    i128,
1022    crate::typenum2::U122,
1023    "A 122 bit signed integer"
1024);
1025makeimask!(
1026    i123,
1027    i128,
1028    crate::typenum2::U123,
1029    "A 123 bit signed integer"
1030);
1031makeimask!(
1032    i124,
1033    i128,
1034    crate::typenum2::U124,
1035    "A 124 bit signed integer"
1036);
1037makeimask!(
1038    i125,
1039    i128,
1040    crate::typenum2::U125,
1041    "A 125 bit signed integer"
1042);
1043makeimask!(
1044    i126,
1045    i128,
1046    crate::typenum2::U126,
1047    "A 126 bit signed integer"
1048);
1049makeimask!(
1050    i127,
1051    i128,
1052    crate::typenum2::U127,
1053    "A 127 bit signed integer"
1054);
stabby_abi/num.rs

stabby_abi/
num.rs
