uint: optimize FromStr, make it no_std-compatible

uint/Cargo.toml

@@ -14,13 +14,13 @@ byteorder = { version = "1.3.2", default-features = false }
 crunchy = { version = "0.2.2", default-features = false }
 qc = { package = "quickcheck", version = "0.9.0", optional = true }
 rand = { version = "0.7.2", default-features = false, optional = true }
-rustc-hex = { version = "2.0.1", default-features = false }
+hex = { version = "0.4", default-features = false }
 static_assertions = "1.0.0"
 arbitrary = { version = "0.4", optional = true }
 
 [features]
 default = ["std"]
-std = ["byteorder/std", "rustc-hex/std", "crunchy/std"]
+std = ["byteorder/std", "crunchy/std", "hex/std"]
 quickcheck = ["qc", "rand"]
 
 [[example]]

uint/benches/bigint.rs

@@ -71,6 +71,7 @@ criterion_group!(
 	u128_mul,
 	u128_div,
 	from_fixed_array,
+	from_str,
 );
 criterion_main!(bigint);
 
@@ -642,3 +643,13 @@ fn from_fixed_array(c: &mut Criterion) {
 		})
 	});
 }
+
+fn from_str(c: &mut Criterion) {
+	c.bench_function("from_str", move |b| {
+		b.iter(|| {
+			black_box(U512::from_str(black_box("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF")).unwrap());
+			black_box(U512::from_str(black_box("0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF")).unwrap());
+			black_box(U512::from_str(black_box("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF")).unwrap());
+		})
+	});
+}

uint/src/lib.rs

@@ -19,7 +19,7 @@ pub use byteorder;
 pub use core as core_;
 
 #[doc(hidden)]
-pub use rustc_hex;
+pub use hex;
 
 #[cfg(feature = "quickcheck")]
 #[doc(hidden)]

uint/src/uint.rs

@@ -29,6 +29,8 @@
 //! implementations for even more speed, hidden behind the `x64_arithmetic`
 //! feature flag.
 
+use core::fmt;
+
 /// Conversion from decimal string error
 #[derive(Debug, PartialEq)]
 pub enum FromDecStrErr {
@@ -38,9 +40,8 @@ pub enum FromDecStrErr {
 	InvalidLength,
 }
 
-#[cfg(feature = "std")]
-impl std::fmt::Display for FromDecStrErr {
-	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl fmt::Display for FromDecStrErr {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 		write!(
 			f,
 			"{}",
@@ -55,6 +56,31 @@ impl std::fmt::Display for FromDecStrErr {
 #[cfg(feature = "std")]
 impl std::error::Error for FromDecStrErr {}
 
+#[derive(Debug)]
+pub struct FromHexError {
+	inner: hex::FromHexError,
+}
+
+impl fmt::Display for FromHexError {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		write!(f, "{}", self.inner)
+	}
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for FromHexError {
+	fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+		Some(&self.inner)
+	}
+}
+
+#[doc(hidden)]
+impl From<hex::FromHexError> for FromHexError {
+	fn from(inner: hex::FromHexError) -> Self {
+		Self { inner }
+	}
+}
+
 #[macro_export]
 #[doc(hidden)]
 macro_rules! impl_map_from {
@@ -1550,31 +1576,34 @@ macro_rules! construct_uint {
 			}
 		}
 
-		$crate::impl_std_for_uint!($name, $n_words);
-		// `$n_words * 8` because macro expects bytes and
-		// uints use 64 bit (8 byte) words
-		$crate::impl_quickcheck_arbitrary_for_uint!($name, ($n_words * 8));
-		$crate::impl_arbitrary_for_uint!($name, ($n_words * 8));
-	}
-}
-
-#[cfg(feature = "std")]
-#[macro_export]
-#[doc(hidden)]
-macro_rules! impl_std_for_uint {
-	($name: ident, $n_words: tt) => {
 		impl $crate::core_::str::FromStr for $name {
-			type Err = $crate::rustc_hex::FromHexError;
+			type Err = $crate::FromHexError;
 
 			fn from_str(value: &str) -> $crate::core_::result::Result<$name, Self::Err> {
-				use $crate::rustc_hex::FromHex;
-				let bytes: Vec<u8> = match value.len() % 2 == 0 {
-					true => value.from_hex()?,
-					false => ("0".to_owned() + value).from_hex()?,
-				};
+				const BYTES_LEN: usize = $n_words * 8;
+				const MAX_ENCODED_LEN: usize = BYTES_LEN * 2;
+
+				let mut bytes = [0_u8; BYTES_LEN];
+
+				let encoded = value.as_bytes();
 
-				if $n_words * 8 < bytes.len() {
-					return Err(Self::Err::InvalidHexLength);
+				if encoded.len() > MAX_ENCODED_LEN {
+					return Err($crate::hex::FromHexError::InvalidStringLength.into());
+				}
+
+				if encoded.len() % 2 == 0 {
+					let out = &mut bytes[BYTES_LEN - encoded.len() / 2..];
+
+					$crate::hex::decode_to_slice(encoded, out).map_err(Self::Err::from)?;
+				} else {
+					// Prepend '0' by overlaying our value on a scratch buffer filled with '0' characters.
+					let mut s = [b'0'; MAX_ENCODED_LEN];
+					s[MAX_ENCODED_LEN - encoded.len()..].copy_from_slice(encoded);
+					let encoded = &s[MAX_ENCODED_LEN - encoded.len() - 1..];
+
+					let out = &mut bytes[BYTES_LEN - encoded.len() / 2..];
+
+					$crate::hex::decode_to_slice(encoded, out).map_err(Self::Err::from)?;
 				}
 
 				let bytes_ref: &[u8] = &bytes;
@@ -1587,14 +1616,12 @@ macro_rules! impl_std_for_uint {
 				s.parse().unwrap()
 			}
 		}
-	};
-}
 
-#[cfg(not(feature = "std"))]
-#[macro_export]
-#[doc(hidden)]
-macro_rules! impl_std_for_uint {
-	($name: ident, $n_words: tt) => {};
+		// `$n_words * 8` because macro expects bytes and
+		// uints use 64 bit (8 byte) words
+		$crate::impl_quickcheck_arbitrary_for_uint!($name, ($n_words * 8));
+		$crate::impl_arbitrary_for_uint!($name, ($n_words * 8));
+	}
 }
 
 #[cfg(feature = "quickcheck")]

uint/tests/uint_tests.rs

@@ -134,6 +134,9 @@ fn uint256_from() {
 	// test initializtion from string
 	let sa = U256::from_str("0a").unwrap();
 	assert_eq!(e, sa);
+	assert_eq!(U256([0, 0, 0, 0]), U256::from_str("").unwrap());
+	assert_eq!(U256([0x1, 0, 0, 0]), U256::from_str("1").unwrap());
+	assert_eq!(U256([0x101, 0, 0, 0]), U256::from_str("101").unwrap());
 	assert_eq!(U256([0x1010, 0, 0, 0]), U256::from_str("1010").unwrap());
 	assert_eq!(U256([0x12f0, 0, 0, 0]), U256::from_str("12f0").unwrap());
 	assert_eq!(U256([0x12f0, 0, 0, 0]), U256::from_str("0000000012f0").unwrap());
@@ -145,6 +148,7 @@ fn uint256_from() {
 
 	// This string contains more bits than what fits in a U256.
 	assert!(U256::from_str("000000000000000000000000000000000000000000000000000000000000000000").is_err());
+	assert!(U256::from_str("100000000000000000000000000000000000000000000000000000000000000000").is_err());
 }
 
 #[test]