add no_std support

Author: apoelstra

Cargo.toml

@@ -13,7 +13,8 @@ name = "bitcoin_hashes"
 path = "src/lib.rs"
 
 [features]
-default = []
+default = [ "std" ]
+std = []
 unstable = []  # for benchmarking
 fuzztarget = [] # used by other rust-bitcoin projects to make hashes almost-noops, DON'T USE THIS
 

src/cmp.rs

@@ -20,26 +20,26 @@ pub fn fixed_time_eq(a: &[u8], b: &[u8]) -> bool {
 
     let mut r: u8 = 0;
     for i in 0..count {
-        let mut rs = unsafe { ::std::ptr::read_volatile(&r) };
+        let mut rs = unsafe { ::core::ptr::read_volatile(&r) };
         rs |= lhs[i] ^ rhs[i];
-        unsafe { ::std::ptr::write_volatile(&mut r, rs); }
+        unsafe { ::core::ptr::write_volatile(&mut r, rs); }
     }
     {
-        let mut t = unsafe { ::std::ptr::read_volatile(&r) };
+        let mut t = unsafe { ::core::ptr::read_volatile(&r) };
         t |= t >> 4;
-        unsafe { ::std::ptr::write_volatile(&mut r, t); }
+        unsafe { ::core::ptr::write_volatile(&mut r, t); }
     }
     {
-        let mut t = unsafe { ::std::ptr::read_volatile(&r) };
+        let mut t = unsafe { ::core::ptr::read_volatile(&r) };
         t |= t >> 2;
-        unsafe { ::std::ptr::write_volatile(&mut r, t); }
+        unsafe { ::core::ptr::write_volatile(&mut r, t); }
     }
     {
-        let mut t = unsafe { ::std::ptr::read_volatile(&r) };
+        let mut t = unsafe { ::core::ptr::read_volatile(&r) };
         t |= t >> 1;
-        unsafe { ::std::ptr::write_volatile(&mut r, t); }
+        unsafe { ::core::ptr::write_volatile(&mut r, t); }
     }
-    unsafe { (::std::ptr::read_volatile(&r) & 1) == 0 }
+    unsafe { (::core::ptr::read_volatile(&r) & 1) == 0 }
 }
 
 #[test]

src/error.rs

@@ -15,7 +15,7 @@
 //! # Error Type
 //!
 
-use std::fmt;
+use core::fmt;
 
 /// Hex decoding error
 #[derive(Copy, Clone, PartialEq, Eq)]

src/hash160.rs

@@ -19,7 +19,7 @@
 
 //! # HASH160 (SHA256 then RIPEMD160)
 
-use std::str;
+use core::str;
 
 use sha256;
 use ripemd160;
@@ -109,12 +109,12 @@ mod tests {
                     0xb8, 0x5d, 0xf1, 0x69, 0xc1, 0x8a, 0x3c, 0x69, 0x7f,
                     0xbb, 0x2d, 0xc4, 0xec, 0xef, 0x94, 0xac, 0x55, 0xfe,
                     0x81, 0x64, 0xcc, 0xf9, 0x82, 0xa1, 0x38, 0x69, 0x1a,
-                    0x55, 0x19, 
+                    0x55, 0x19,
                 ],
                 output: vec![
                     0xda, 0x0b, 0x34, 0x52, 0xb0, 0x6f, 0xe3, 0x41,
                     0x62, 0x6a, 0xd0, 0x94, 0x9c, 0x18, 0x3f, 0xbd,
-                    0xa5, 0x67, 0x68, 0x26, 
+                    0xa5, 0x67, 0x68, 0x26,
                 ],
                 output_str: "da0b3452b06fe341626ad0949c183fbda5676826",
             },

src/hex.rs

@@ -15,11 +15,11 @@
 //! # Hex encoding and decoding
 //!
 
-use std::fmt;
-use std::str;
+use core::{fmt, str};
 use {Error, Hash};
 
 /// Trait for objects that can be serialized as hex strings
+#[cfg(any(test, feature = "std"))]
 pub trait ToHex {
     /// Hex representation of the object
     fn to_hex(&self) -> String;
@@ -39,6 +39,7 @@ pub trait FromHex: Sized {
     }
 }
 
+#[cfg(any(test, feature = "std"))]
 impl<T: fmt::LowerHex> ToHex for T {
     /// Outputs the hash in hexadecimal form
     fn to_hex(&self) -> String {
@@ -152,9 +153,10 @@ pub fn format_hex_reverse(data: &[u8], f: &mut fmt::Formatter) -> fmt::Result {
     Ok(())
 }
 
+#[cfg(any(test, feature = "std"))]
 impl ToHex for [u8] {
     fn to_hex(&self) -> String {
-        use std::fmt::Write;
+        use core::fmt::Write;
         let mut ret = String::with_capacity(2 * self.len());
         for ch in self {
             write!(ret, "{:02x}", ch).expect("writing to string");
@@ -163,6 +165,7 @@ impl ToHex for [u8] {
     }
 }
 
+#[cfg(any(test, feature = "std"))]
 impl FromHex for Vec<u8> {
     fn from_byte_iter<I>(iter: I) -> Result<Self, Error>
         where I: Iterator<Item=Result<u8, Error>> +
@@ -217,9 +220,9 @@ impl_fromhex_array!(512);
 
 #[cfg(test)]
 mod tests {
-    use std::fmt;
+    use core::fmt;
 
-    use super::{format_hex, format_hex_reverse, ToHex, FromHex};
+    use super::{format_hex, format_hex_reverse, FromHex, ToHex};
     use Error;
 
     #[test]

src/hmac.rs

@@ -19,7 +19,7 @@
 
 //! # HMAC support
 
-use std::{borrow, fmt, ops, str};
+use core::{borrow, fmt, ops, str};
 #[cfg(feature="serde")]
 use serde::{Serialize, Serializer, Deserialize, Deserializer};
 

src/lib.rs

@@ -27,16 +27,18 @@
 #![deny(unused_mut)]
 #![deny(missing_docs)]
 
+#![cfg_attr(all(not(test), not(feature = "std")), no_std)]
 #![cfg_attr(all(test, feature = "unstable"), feature(test))]
 #[cfg(all(test, feature = "unstable"))] extern crate test;
 
+#[cfg(any(test, feature="std"))] extern crate core;
 #[cfg(feature="serde")] extern crate serde;
 #[cfg(all(test,feature="serde"))] extern crate serde_test;
 extern crate byteorder;
 
 #[macro_use] mod util;
 #[macro_use] mod serde_macros;
-mod std_impls;
+#[cfg(any(test, feature = "std"))] mod std_impls;
 pub mod error;
 pub mod hex;
 pub mod hash160;
@@ -49,7 +51,7 @@ pub mod sha256d;
 pub mod siphash24;
 pub mod cmp;
 
-use std::{borrow, fmt, hash, ops};
+use core::{borrow, fmt, hash, ops};
 
 pub use hmac::{Hmac, HmacEngine};
 pub use error::Error;
@@ -80,7 +82,7 @@ pub trait Hash: Copy + Clone + PartialEq + Eq + Default + PartialOrd + Ord +
     ops::Index<ops::RangeTo<usize>, Output = [u8]> +
     ops::Index<ops::Range<usize>, Output = [u8]> +
     ops::Index<usize, Output = u8> +
-    hex::ToHex + borrow::Borrow<[u8]>
+    borrow::Borrow<[u8]>
 {
     /// A hashing engine which bytes can be serialized into. It is expected
     /// to implement the `io::Write` trait, and to never return errors under

src/ripemd160.rs

@@ -20,7 +20,7 @@
 //! # RIPEMD160
 
 use byteorder::{ByteOrder, LittleEndian};
-use std::{cmp, str};
+use core::{cmp, str};
 
 use HashEngine as EngineTrait;
 use Hash as HashTrait;

src/sha1.rs

@@ -15,7 +15,7 @@
 //! # SHA1
 
 use byteorder::{ByteOrder, BigEndian};
-use std::{cmp, str};
+use core::{cmp, str};
 
 use HashEngine as EngineTrait;
 use Hash as HashTrait;

src/sha256.rs

@@ -15,7 +15,7 @@
 //! # SHA256
 
 use byteorder::{ByteOrder, BigEndian};
-use std::{cmp, str};
+use core::{cmp, str};
 
 use hex;
 use HashEngine as EngineTrait;