Merge pull request rust-num#300 from cuviper/no-build

Remove the build script

Author: cuviper

Cargo.toml

@@ -10,7 +10,6 @@ name = "num-bigint"
 repository = "https://github.com/rust-num/num-bigint"
 version = "0.4.4"
 readme = "README.md"
-build = "build.rs"
 exclude = ["/ci/*", "/.github/*"]
 edition = "2021"
 rust-version = "1.60"

build.rs

@@ -47,42 +47,42 @@ fn gen_bits<R: Rng + ?Sized>(rng: &mut R, data: &mut [u32], rem: u64) {
 }
 
 impl<R: Rng + ?Sized> RandBigInt for R {
- #[cfg(not(u64_digit))]
- fn gen_biguint(&mut self, bit_size: u64) -> BigUint {
- let (digits, rem) = bit_size.div_rem(&32);
- let len = (digits + (rem > 0) as u64)
- .to_usize()
- .expect("capacity overflow");
- let mut data = vec![0u32; len];
- gen_bits(self, &mut data, rem);
- biguint_from_vec(data)
- }
-
- #[cfg(u64_digit)]
- fn gen_biguint(&mut self, bit_size: u64) -> BigUint {
- use core::slice;
-
- let (digits, rem) = bit_size.div_rem(&32);
- let len = (digits + (rem > 0) as u64)
- .to_usize()
- .expect("capacity overflow");
- let native_digits = Integer::div_ceil(&bit_size, &64);
- let native_len = native_digits.to_usize().expect("capacity overflow");
- let mut data = vec![0u64; native_len];
- unsafe {
- // Generate bits in a `&mut [u32]` slice for value stability
- let ptr = data.as_mut_ptr() as *mut u32;
- debug_assert!(native_len * 2 >= len);
- let data = slice::from_raw_parts_mut(ptr, len);
- gen_bits(self, data, rem);
+ cfg_digit!(
+ fn gen_biguint(&mut self, bit_size: u64) -> BigUint {
+ let (digits, rem) = bit_size.div_rem(&32);
+ let len = (digits + (rem > 0) as u64)
+ .to_usize()
+ .expect("capacity overflow");
+ let mut data = vec![0u32; len];
+ gen_bits(self, &mut data, rem);
+ biguint_from_vec(data)
  }
- #[cfg(target_endian = "big")]
- for digit in &mut data {
- // swap u32 digits into u64 endianness
- *digit = (*digit << 32) | (*digit >> 32);
+
+ fn gen_biguint(&mut self, bit_size: u64) -> BigUint {
+ use core::slice;
+
+ let (digits, rem) = bit_size.div_rem(&32);
+ let len = (digits + (rem > 0) as u64)
+ .to_usize()
+ .expect("capacity overflow");
+ let native_digits = Integer::div_ceil(&bit_size, &64);
+ let native_len = native_digits.to_usize().expect("capacity overflow");
+ let mut data = vec![0u64; native_len];
+ unsafe {
+ // Generate bits in a `&mut [u32]` slice for value stability
+ let ptr = data.as_mut_ptr() as *mut u32;
+ debug_assert!(native_len * 2 >= len);
+ let data = slice::from_raw_parts_mut(ptr, len);
+ gen_bits(self, data, rem);
+ }
+ #[cfg(target_endian = "big")]
+ for digit in &mut data {
+ // swap u32 digits into u64 endianness
+ *digit = (*digit << 32) | (*digit >> 32);
+ }
+ biguint_from_vec(data)
  }
- biguint_from_vec(data)
- }
+ );
 
  fn gen_bigint(&mut self, bit_size: u64) -> BigInt {
  loop {

src/bigrand.rs

@@ -542,14 +542,13 @@ impl BigUint {
  pub fn new(digits: Vec<u32>) -> BigUint {
  let mut big = Self::ZERO;
 
- #[cfg(not(u64_digit))]
- {
- big.data = digits;
- big.normalize();
- }
-
- #[cfg(u64_digit)]
- big.assign_from_slice(&digits);
+ cfg_digit_expr!(
+ {
+ big.data = digits;
+ big.normalize();
+ },
+ big.assign_from_slice(&digits)
+ );
 
  big
  }
@@ -571,11 +570,10 @@ impl BigUint {
  pub fn assign_from_slice(&mut self, slice: &[u32]) {
  self.data.clear();
 
- #[cfg(not(u64_digit))]
- self.data.extend_from_slice(slice);
-
- #[cfg(u64_digit)]
- self.data.extend(slice.chunks(2).map(u32_chunk_to_u64));
+ cfg_digit_expr!(
+ self.data.extend_from_slice(slice),
+ self.data.extend(slice.chunks(2).map(u32_chunk_to_u64))
+ );
 
  self.normalize();
  }
@@ -1118,59 +1116,61 @@ fn u32_chunk_to_u64(chunk: &[u32]) -> u64 {
  digit
 }
 
-/// Combine four `u32`s into a single `u128`.
-#[cfg(any(test, not(u64_digit)))]
-#[inline]
-fn u32_to_u128(a: u32, b: u32, c: u32, d: u32) -> u128 {
- u128::from(d) | (u128::from(c) << 32) | (u128::from(b) << 64) | (u128::from(a) << 96)
-}
-
-/// Split a single `u128` into four `u32`.
-#[cfg(any(test, not(u64_digit)))]
-#[inline]
-fn u32_from_u128(n: u128) -> (u32, u32, u32, u32) {
- (
- (n >> 96) as u32,
- (n >> 64) as u32,
- (n >> 32) as u32,
- n as u32,
- )
-}
-
-#[cfg(not(u64_digit))]
-#[test]
-fn test_from_slice() {
- fn check(slice: &[u32], data: &[BigDigit]) {
- assert_eq!(BigUint::from_slice(slice).data, data);
- }
- check(&[1], &[1]);
- check(&[0, 0, 0], &[]);
- check(&[1, 2, 0, 0], &[1, 2]);
- check(&[0, 0, 1, 2], &[0, 0, 1, 2]);
- check(&[0, 0, 1, 2, 0, 0], &[0, 0, 1, 2]);
- check(&[-1i32 as u32], &[-1i32 as BigDigit]);
-}
+cfg_32_or_test!(
+ /// Combine four `u32`s into a single `u128`.
+ #[inline]
+ fn u32_to_u128(a: u32, b: u32, c: u32, d: u32) -> u128 {
+ u128::from(d) | (u128::from(c) << 32) | (u128::from(b) << 64) | (u128::from(a) << 96)
+ }
+);
 
-#[cfg(u64_digit)]
-#[test]
-fn test_from_slice() {
- fn check(slice: &[u32], data: &[BigDigit]) {
- assert_eq!(
- BigUint::from_slice(slice).data,
- data,
- "from {:?}, to {:?}",
- slice,
- data
- );
+cfg_32_or_test!(
+ /// Split a single `u128` into four `u32`.
+ #[inline]
+ fn u32_from_u128(n: u128) -> (u32, u32, u32, u32) {
+ (
+ (n >> 96) as u32,
+ (n >> 64) as u32,
+ (n >> 32) as u32,
+ n as u32,
+ )
  }
- check(&[1], &[1]);
- check(&[0, 0, 0], &[]);
- check(&[1, 2], &[8_589_934_593]);
- check(&[1, 2, 0, 0], &[8_589_934_593]);
- check(&[0, 0, 1, 2], &[0, 8_589_934_593]);
- check(&[0, 0, 1, 2, 0, 0], &[0, 8_589_934_593]);
- check(&[-1i32 as u32], &[(-1i32 as u32) as BigDigit]);
-}
+);
+
+cfg_digit!(
+ #[test]
+ fn test_from_slice() {
+ fn check(slice: &[u32], data: &[BigDigit]) {
+ assert_eq!(BigUint::from_slice(slice).data, data);
+ }
+ check(&[1], &[1]);
+ check(&[0, 0, 0], &[]);
+ check(&[1, 2, 0, 0], &[1, 2]);
+ check(&[0, 0, 1, 2], &[0, 0, 1, 2]);
+ check(&[0, 0, 1, 2, 0, 0], &[0, 0, 1, 2]);
+ check(&[-1i32 as u32], &[-1i32 as BigDigit]);
+ }
+
+ #[test]
+ fn test_from_slice() {
+ fn check(slice: &[u32], data: &[BigDigit]) {
+ assert_eq!(
+ BigUint::from_slice(slice).data,
+ data,
+ "from {:?}, to {:?}",
+ slice,
+ data
+ );
+ }
+ check(&[1], &[1]);
+ check(&[0, 0, 0], &[]);
+ check(&[1, 2], &[8_589_934_593]);
+ check(&[1, 2, 0, 0], &[8_589_934_593]);
+ check(&[0, 0, 1, 2], &[0, 8_589_934_593]);
+ check(&[0, 0, 1, 2, 0, 0], &[0, 8_589_934_593]);
+ check(&[-1i32 as u32], &[(-1i32 as u32) as BigDigit]);
+ }
+);
 
 #[test]
 fn test_u32_u128() {