internal.rs

#![doc(hidden)]
#![doc = include_str!("../../doc/macros/internal.md")]

//  Provide known mount-points of dependency crates.

#[doc(hidden)]
pub use core;

#[doc(hidden)]
pub use funty;

#[doc(hidden)]
#[macro_export]
#[doc = include_str!("../../doc/macros/encode_bits.md")]
macro_rules! __encode_bits {
	/* ENTRY POINTS
	 *
	 * These arms match the syntax provided by the public macros, and dispatch
	 * by storage type width.
	 */

	(u8, $ord:tt; $($val:expr),*) => {
		$crate::__encode_bits!(u8 as u8, $ord; $($val),*)
	};
	(Cell<u8>, $ord:tt; $($val:expr),*) => {
		$crate::__encode_bits!(Cell<u8> as u8, $ord; $($val),*)
	};
	(AtomicU8, $ord:tt; $($val:expr),*) => {
		$crate::__encode_bits!(AtomicU8 as u8, $ord; $($val),*)
	};
	(RadiumU8, $ord:tt; $($val:expr),*) => {
		$crate::__encode_bits!(RadiumU8 as u8, $ord; $($val),*)
	};

	(u16, $ord:tt; $($val:expr),*) => {
		$crate::__encode_bits!(u16 as u16, $ord; $($val),*)
	};
	(Cell<u16>, $ord:tt; $($val:expr),*) => {
		$crate::__encode_bits!(Cell<u16> as u16, $ord; $($val),*)
	};
	(AtomicU16, $ord:tt; $($val:expr),*) => {
		$crate::__encode_bits!(AtomicU16 as u16, $ord; $($val),*)
	};
	(RadiumU16, $ord:tt; $($val:expr),*) => {
		$crate::__encode_bits!(RadiumU16 as u16, $ord; $($val),*)
	};

	(u32, $ord:tt; $($val:expr),*) => {
		$crate::__encode_bits!(u32 as u32, $ord; $($val),*)
	};
	(Cell<u32>, $ord:tt; $($val:expr),*) => {
		$crate::__encode_bits!(Cell<u32> as u32, $ord; $($val),*)
	};
	(AtomicU32, $ord:tt; $($val:expr),*) => {
		$crate::__encode_bits!(AtomicU32 as u32, $ord; $($val),*)
	};
	(RadiumU32, $ord:tt; $($val:expr),*) => {
		$crate::__encode_bits!(RadiumU32 as u32, $ord; $($val),*)
	};

	(u64, $ord:tt; $($val:expr),*) => {
		$crate::__encode_bits!(u64 as u64, $ord; $($val),*)
	};
	(Cell<u64>, $ord:tt; $($val:expr),*) => {
		$crate::__encode_bits!(Cell<u64> as u64, $ord; $($val),*)
	};
	(AtomicU64, $ord:tt; $($val:expr),*) => {
		$crate::__encode_bits!(AtomicU64 as u64, $ord; $($val),*)
	};
	(RadiumU64, $ord:tt; $($val:expr),*) => {
		$crate::__encode_bits!(RadiumU64 as u64, $ord; $($val),*)
	};

	(usize, $ord:tt; $($val:expr),*) => {
		$crate::__encode_bits!(usize as usize, $ord; $($val),*)
	};
	(Cell<usize>, $ord:tt; $($val:expr),*) => {
		$crate::__encode_bits!(Cell<usize> as usize, $ord; $($val),*)
	};
	(AtomicUsize, $ord:tt; $($val:expr),*) => {
		$crate::__encode_bits!(AtomicUsize as usize, $ord; $($val),*)
	};
	(RadiumUsize, $ord:tt; $($val:expr),*) => {
		$crate::__encode_bits!(RadiumUsize as usize, $ord; $($val),*)
	};

	//  This arm routes `usize` into `u32` or `u64`, depending on target, and
	//  marks them to return to `usize` after chunking.
	($typ:ty as usize, $ord:tt; $($val:expr),*) => {{
		const LEN: usize = $crate::__count_elts!(usize; $($val),*);

		let out: [$typ; LEN];

		#[cfg(target_pointer_width = "32")]
		{
			out = $crate::__encode_bits!($typ as u32 as usize, $ord; $($val),*);
		}

		#[cfg(target_pointer_width = "64")]
		{
			out = $crate::__encode_bits!($typ as u64 as usize, $ord; $($val),*);
		}

		out
	}};

	//  ZERO EXTENSION: Supply literal `0, ` tokens to ensure that elements can
	//  be completely filled with bits.
	($typ:ty as $uint:ident $(as $usz:ident)?, $ord:tt; $($val:expr),*) => {
		$crate::__encode_bits!(
			$typ as $uint $(as $usz)?, $ord; []; $($val,)*
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 32
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 48
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 64
		)
	};

	/* EXIT POINT.
	 *
	 * This arm enters once the only remaining bit-expression tokens are the
	 * literal `0, `s provided above. It does not enter while any opaque
	 * user-provided bit expressions remain, and matching falls through to the
	 * chunkers, below.
	 *
	 * Once entered, this converts each chunk of bit expressions into the
	 * requested storage element, then emits an array of the encoded elements.
	 * This array is the final value of the originally-invoked macro. The
	 * invoker is responsible for turning the array into a `bitvec` type.
	 */
	(
		$typ:ty as $uint:ident as usize, $ord:tt;
		[$([$($bit:tt,)+],)*]; $(0,)*
	) => {
		[$($crate::__make_elem!($typ as $uint as usize, $ord; $($bit,)+),)*]
	};
	(
		$typ:ty as $uint:ident, $ord:tt;
		[$([$($bit:tt,)+],)*]; $(0,)*
	) => {
		[$($crate::__make_elem!($typ as $uint, $ord; $($bit,)+),)*]
	};

	/* CHUNKERS
	 *
	 * These arms munch through the token stream, creating a sequence of chunks
	 * of bits. Each chunk contains bits to exactly fill one element, and gets
	 * passed into `__make_elem!` for final encoding.
	 */

	(
		$typ:ty as u8, $ord:tt; [$($elem:tt)*];
		$a0:tt, $b0:tt, $c0:tt, $d0:tt, $e0:tt, $f0:tt, $g0:tt, $h0:tt,
		$($t:tt)*
	) => {
		$crate::__encode_bits!(
			$typ as u8, $ord; [$($elem)* [
				$a0, $b0, $c0, $d0, $e0, $f0, $g0, $h0,
			],]; $($t)*
		)
	};

	(
		$typ:ty as u16, $ord:tt; [$($elem:tt)*];
		$a0:tt, $b0:tt, $c0:tt, $d0:tt, $e0:tt, $f0:tt, $g0:tt, $h0:tt,
		$a1:tt, $b1:tt, $c1:tt, $d1:tt, $e1:tt, $f1:tt, $g1:tt, $h1:tt,
		$($t:tt)*
	) => {
		$crate::__encode_bits!(
			$typ as u16, $ord; [$($elem)* [
				$a0, $b0, $c0, $d0, $e0, $f0, $g0, $h0,
				$a1, $b1, $c1, $d1, $e1, $f1, $g1, $h1,
			],]; $($t)*
		)
	};

	(
		$typ:ty as u32 $(as $usz:ident)?, $ord:tt; [$($elem:tt)*];
		$a0:tt, $b0:tt, $c0:tt, $d0:tt, $e0:tt, $f0:tt, $g0:tt, $h0:tt,
		$a1:tt, $b1:tt, $c1:tt, $d1:tt, $e1:tt, $f1:tt, $g1:tt, $h1:tt,
		$a2:tt, $b2:tt, $c2:tt, $d2:tt, $e2:tt, $f2:tt, $g2:tt, $h2:tt,
		$a3:tt, $b3:tt, $c3:tt, $d3:tt, $e3:tt, $f3:tt, $g3:tt, $h3:tt,
		$($t:tt)*
	) => {
		$crate::__encode_bits!(
			$typ as u32 $(as $usz)?, $ord; [$($elem)* [
				$a0, $b0, $c0, $d0, $e0, $f0, $g0, $h0,
				$a1, $b1, $c1, $d1, $e1, $f1, $g1, $h1,
				$a2, $b2, $c2, $d2, $e2, $f2, $g2, $h2,
				$a3, $b3, $c3, $d3, $e3, $f3, $g3, $h3,
			],]; $($t)*
		)
	};

	(
		$typ:ty as u64 $(as $usz:ident)?, $ord:tt; [$($elem:tt)*];
		$a0:tt, $b0:tt, $c0:tt, $d0:tt, $e0:tt, $f0:tt, $g0:tt, $h0:tt,
		$a1:tt, $b1:tt, $c1:tt, $d1:tt, $e1:tt, $f1:tt, $g1:tt, $h1:tt,
		$a2:tt, $b2:tt, $c2:tt, $d2:tt, $e2:tt, $f2:tt, $g2:tt, $h2:tt,
		$a3:tt, $b3:tt, $c3:tt, $d3:tt, $e3:tt, $f3:tt, $g3:tt, $h3:tt,
		$a4:tt, $b4:tt, $c4:tt, $d4:tt, $e4:tt, $f4:tt, $g4:tt, $h4:tt,
		$a5:tt, $b5:tt, $c5:tt, $d5:tt, $e5:tt, $f5:tt, $g5:tt, $h5:tt,
		$a6:tt, $b6:tt, $c6:tt, $d6:tt, $e6:tt, $f6:tt, $g6:tt, $h6:tt,
		$a7:tt, $b7:tt, $c7:tt, $d7:tt, $e7:tt, $f7:tt, $g7:tt, $h7:tt,
		$($t:tt)*
	) => {
		$crate::__encode_bits!(
			$typ as u64 $(as $usz)?, $ord; [$($elem)* [
				$a0, $b0, $c0, $d0, $e0, $f0, $g0, $h0,
				$a1, $b1, $c1, $d1, $e1, $f1, $g1, $h1,
				$a2, $b2, $c2, $d2, $e2, $f2, $g2, $h2,
				$a3, $b3, $c3, $d3, $e3, $f3, $g3, $h3,
				$a4, $b4, $c4, $d4, $e4, $f4, $g4, $h4,
				$a5, $b5, $c5, $d5, $e5, $f5, $g5, $h5,
				$a6, $b6, $c6, $d6, $e6, $f6, $g6, $h6,
				$a7, $b7, $c7, $d7, $e7, $f7, $g7, $h7,
			],]; $($t)*
		)
	};
}

/// Counts the number of expression tokens in a repetition sequence.
#[doc(hidden)]
#[macro_export]
macro_rules! __count {
	(@ $val:expr) => { 1 };
	($($val:expr),* $(,)?) => {{
		const LEN: usize = 0 $(+ $crate::__count!(@ $val))*;
		LEN
	}};
}

/// Counts the number of storage elements needed to store a bit sequence.
#[doc(hidden)]
#[macro_export]
macro_rules! __count_elts {
	($t:ty; $($val:expr),*) => {
		$crate::mem::elts::<$t>($crate::__count!($($val),*))
	};
}

#[doc(hidden)]
#[macro_export]
#[doc = include_str!("../../doc/macros/make_elem.md")]
macro_rules! __make_elem {
	//  Token-matching ordering names can use specialized work.
	($typ:ty as $uint:ident $(as $usz:ident)?, Lsb0; $(
		$a:expr, $b:expr, $c:expr, $d:expr,
		$e:expr, $f:expr, $g:expr, $h:expr,
	)*) => {{
		const ELEM: $uint = $crate::__ty_from_bytes!(
			$uint, Lsb0, [$($crate::macros::internal::u8_from_le_bits(
				$a != 0, $b != 0, $c != 0, $d != 0,
				$e != 0, $f != 0, $g != 0, $h != 0,
			)),*]
		);
		$crate::mem::BitElement::<$typ>::new(ELEM $(as $usz)?).elem
	}};
	($typ:ty as $uint:ident $(as $usz:ident)?, Msb0; $(
		$a:expr, $b:expr, $c:expr, $d:expr,
		$e:expr, $f:expr, $g:expr, $h:expr,
	)*) => {{
		const ELEM: $uint = $crate::__ty_from_bytes!(
			$uint, Msb0, [$($crate::macros::internal::u8_from_be_bits(
				$a != 0, $b != 0, $c != 0, $d != 0,
				$e != 0, $f != 0, $g != 0, $h != 0,
			)),*]
		);
		$crate::mem::BitElement::<$typ>::new(ELEM $(as $usz)?).elem
	}};
	($typ:ty as $uint:ident $(as $usz:ident)?, LocalBits; $(
		$a:expr, $b:expr, $c:expr, $d:expr,
		$e:expr, $f:expr, $g:expr, $h:expr,
	)*) => {{
		const ELEM: $uint = $crate::__ty_from_bytes!(
			$uint, LocalBits, [$($crate::macros::internal::u8_from_ne_bits(
				$a != 0, $b != 0, $c != 0, $d != 0,
				$e != 0, $f != 0, $g != 0, $h != 0,
			)),*]
		);
		$crate::mem::BitElement::<$typ>::new(ELEM $(as $usz)?).elem
	}};
	//  Otherwise, invoke `BitOrder` for each bit and accumulate.
	($typ:ty as $uint:ident $(as $usz:ident)?, $ord:tt; $($bit:expr),* $(,)?) => {{
		let mut tmp: $uint = 0;
		let _bits = $crate::slice::BitSlice::<$uint, $ord>::from_element_mut(
			&mut tmp
		);
		let mut _idx = 0;
		$( _bits.set(_idx, $bit != 0); _idx += 1; )*
		$crate::mem::BitElement::<$typ>::new(tmp $(as $usz)?).elem
	}};
}

/// Translates `false` into `0` and `true` into `!0`.
#[doc(hidden)]
#[macro_export]
macro_rules! __extend_bool {
	($val:expr, $typ:tt) => {{
		type Mem = <$typ as $crate::store::BitStore>::Mem;
		if $val != 0 {
			<Mem as $crate::mem::BitRegister>::ALL
		}
		else {
			<Mem as $crate::macros::internal::funty::Integral>::ZERO
		}
	}};
}

/// Constructs an unsigned integer from a list of *bytes*.
#[doc(hidden)]
#[macro_export]
macro_rules! __ty_from_bytes {
	(u8, Msb0, [$($byte:expr),*]) => {
		u8::from_be_bytes([$($byte),*])
	};
	(u8, Lsb0, [$($byte:expr),*]) => {
		u8::from_le_bytes([$($byte),*])
	};
	(u8, LocalBits, [$($byte:expr),*]) => {
		u8::from_ne_bytes([$($byte),*])
	};
	(u16, Msb0, [$($byte:expr),*]) => {
		u16::from_be_bytes([$($byte),*])
	};
	(u16, Lsb0, [$($byte:expr),*]) => {
		u16::from_le_bytes([$($byte),*])
	};
	(u16, LocalBits, [$($byte:expr),*]) => {
		u16::from_ne_bytes([$($byte),*])
	};
	(u32, Msb0, [$($byte:expr),*]) => {
		u32::from_be_bytes([$($byte),*])
	};
	(u32, Lsb0, [$($byte:expr),*]) => {
		u32::from_le_bytes([$($byte),*])
	};
	(u32, LocalBits, [$($byte:expr),*]) => {
		u32::from_ne_bytes([$($byte),*])
	};
	(u64, Msb0, [$($byte:expr),*]) => {
		u64::from_be_bytes([$($byte),*])
	};
	(u64, Lsb0, [$($byte:expr),*]) => {
		u64::from_le_bytes([$($byte),*])
	};
	(u64, LocalBits, [$($byte:expr),*]) => {
		u64::from_ne_bytes([$($byte),*])
	};
	(usize, Msb0, [$($byte:expr),*]) => {
		usize::from_be_bytes([$($byte),*])
	};
	(usizeLsb0, , [$($byte:expr),*]) => {
		usize::from_le_bytes([$($byte),*])
	};
	(usize, LocalBits, [$($byte:expr),*]) => {
		usize::from_ne_bytes([$($byte),*])
	};
}

/// Constructs a `u8` from bits applied in `Lsb0` order (`a` low, `h` high).
#[doc(hidden)]
#[inline(always)]
#[cfg(not(tarpaulin_include))]
pub const fn u8_from_le_bits(
	a: bool,
	b: bool,
	c: bool,
	d: bool,
	e: bool,
	f: bool,
	g: bool,
	h: bool,
) -> u8 {
	(a as u8)
		| ((b as u8) << 1)
		| ((c as u8) << 2)
		| ((d as u8) << 3)
		| ((e as u8) << 4)
		| ((f as u8) << 5)
		| ((g as u8) << 6)
		| ((h as u8) << 7)
}

/// Constructs a `u8` from bits applied in `Msb0` order (`a` high, `h` low).
#[doc(hidden)]
#[inline(always)]
#[cfg(not(tarpaulin_include))]
pub const fn u8_from_be_bits(
	a: bool,
	b: bool,
	c: bool,
	d: bool,
	e: bool,
	f: bool,
	g: bool,
	h: bool,
) -> u8 {
	(h as u8)
		| ((g as u8) << 1)
		| ((f as u8) << 2)
		| ((e as u8) << 3)
		| ((d as u8) << 4)
		| ((c as u8) << 5)
		| ((b as u8) << 6)
		| ((a as u8) << 7)
}

#[doc(hidden)]
#[cfg(target_endian = "big")]
pub use self::u8_from_be_bits as u8_from_ne_bits;
#[doc(hidden)]
#[cfg(target_endian = "little")]
pub use self::u8_from_le_bits as u8_from_ne_bits;