Remove limb_width32 and limb_width64 features

Moved dispatch directly into the type system.

build.rs

@@ -1,36 +0,0 @@
-use std::env;
-use std::process::Command;
-use std::str::{self, FromStr};
-
-fn main() {
-    println!("cargo:rerun-if-changed=build.rs");
-
-    // Decide ideal limb width for arithmetic in the float parser. Refer to
-    // src/lexical/math.rs for where this has an effect.
-    let target_arch = env::var("CARGO_CFG_TARGET_ARCH").unwrap();
-    match target_arch.as_str() {
-        "aarch64" | "mips64" | "powerpc64" | "x86_64" => {
-            println!("cargo:rustc-cfg=limb_width_64");
-        }
-        _ => {
-            println!("cargo:rustc-cfg=limb_width_32");
-        }
-    }
-
-    let minor = match rustc_minor_version() {
-        Some(minor) => minor,
-        None => return,
-    };
-}
-
-fn rustc_minor_version() -> Option<u32> {
-    let rustc = env::var_os("RUSTC")?;
-    let output = Command::new(rustc).arg("--version").output().ok()?;
-    let version = str::from_utf8(&output.stdout).ok()?;
-    let mut pieces = version.split('.');
-    if pieces.next() != Some("rustc 1") {
-        return None;
-    }
-    let next = pieces.next()?;
-    u32::from_str(next).ok()
-}

src/lexical/math.rs

@@ -6,7 +6,6 @@
 //! buffers, so for a `vec![0, 1, 2, 3]`, `3` is the most significant limb,
 //! and `0` is the least significant limb.
 
-use super::large_powers;
 use super::num::*;
 use super::small_powers::*;
 use alloc::vec::Vec;
@@ -36,31 +35,48 @@ use core::{cmp, iter, mem};
 //  requiring software emulation.
 //      sparc64 (`UMUL` only supported double-word arguments).
 
+#[doc(hidden)]
+pub trait LimbConfig {
+    type Limb: 'static;
+    type Wide: 'static;
+    const POW5_LIMB: &'static [Self::Limb];
+    const POW10_LIMB: &'static [Self::Limb];
+    const LARGE_POWERS: &'static [&'static [Self::Limb]];
+}
+
 // 32-BIT LIMB
-#[cfg(limb_width_32)]
-pub type Limb = u32;
+#[doc(hidden)]
+pub struct LimbConfig32;
 
-#[cfg(limb_width_32)]
-pub const POW5_LIMB: &[Limb] = &POW5_32;
-
-#[cfg(limb_width_32)]
-pub const POW10_LIMB: &[Limb] = &POW10_32;
-
-#[cfg(limb_width_32)]
-type Wide = u64;
+impl LimbConfig for LimbConfig32 {
+    type Limb = u32;
+    type Wide = u64;
+    const POW5_LIMB: &'static [Self::Limb] = &POW5_32;
+    const POW10_LIMB: &'static [Self::Limb] = &POW10_32;
+    const LARGE_POWERS: &'static [&'static [Self::Limb]] = &super::large_powers32::POW5;
+}
 
 // 64-BIT LIMB
-#[cfg(limb_width_64)]
-pub type Limb = u64;
+#[doc(hidden)]
+pub struct LimbConfig64;
+impl LimbConfig for LimbConfig64 {
+    type Limb = u64;
+    type Wide = u128;
+    const POW5_LIMB: &'static [Self::Limb] = &POW5_64;
+    const POW10_LIMB: &'static [Self::Limb] = &POW10_64;
+    const LARGE_POWERS: &'static [&'static [Self::Limb]] = &super::large_powers64::POW5;
+}
 
-#[cfg(limb_width_64)]
-pub const POW5_LIMB: &[Limb] = &POW5_64;
+#[cfg(any(target_arch = "aarch64", target_arch = "mips64", target_arch = "powerpc64", target_arch = x86_64))]
+type PlatformLimbConfig = LimbConfig64;
+#[cfg(not(any(target_arch = "aarch64", target_arch = "mips64", target_arch = "powerpc64", target_arch = x86_64)))]
+type PlatformLimbConfig = LimbConfig32;
 
-#[cfg(limb_width_64)]
-pub const POW10_LIMB: &[Limb] = &POW10_64;
-
-#[cfg(limb_width_64)]
-type Wide = u128;
+pub type Limb = <PlatformLimbConfig as LimbConfig>::Limb;
+type Wide = <PlatformLimbConfig as LimbConfig>::Wide;
+pub const POW5_LIMB: &[Limb] = PlatformLimbConfig::POW5_LIMB;
+pub const POW10_LIMB: &[Limb] = PlatformLimbConfig::POW10_LIMB;
+const LARGE_POWERS: &'static [&'static [Limb]] = PlatformLimbConfig::LARGE_POWERS;
 
 /// Cast to limb type.
 #[inline]
@@ -391,7 +407,7 @@ mod small {
         use super::large::KARATSUBA_CUTOFF;
 
         let small_powers = POW5_LIMB;
-        let large_powers = large_powers::POW5;
+        let large_powers = LARGE_POWERS;
 
         if n == 0 {
             // No exponent, just return.

src/lexical/mod.rs

@@ -20,7 +20,8 @@ mod digit;
 mod errors;
 pub(crate) mod exponent;
 pub(crate) mod float;
-mod large_powers;
+mod large_powers32;
+mod large_powers64;
 pub(crate) mod math;
 pub(crate) mod num;
 pub(crate) mod parse;
@@ -28,11 +29,5 @@ pub(crate) mod rounding;
 mod shift;
 mod small_powers;
 
-#[cfg(limb_width_32)]
-mod large_powers32;
-
-#[cfg(limb_width_64)]
-mod large_powers64;
-
 // API
 pub use self::parse::{parse_concise_float, parse_truncated_float};

src/lexical/small_powers.rs

@@ -3,19 +3,16 @@
 //! Pre-computed small powers.
 
 // 32 BIT
-#[cfg(limb_width_32)]
 pub(crate) const POW5_32: [u32; 14] = [
     1, 5, 25, 125, 625, 3125, 15625, 78125, 390625, 1953125, 9765625, 48828125, 244140625,
     1220703125,
 ];
 
-#[cfg(limb_width_32)]
 pub(crate) const POW10_32: [u32; 10] = [
     1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000,
 ];
 
 // 64 BIT
-#[cfg(limb_width_64)]
 pub(crate) const POW5_64: [u64; 28] = [
     1,
     5,