From 11ce86681f9901439d03ac723d494a955e78d939 Mon Sep 17 00:00:00 2001 From: Elichai Turkel Date: Mon, 18 Feb 2019 14:30:39 +0200 Subject: [PATCH] Replaced std with core, and made std::error::Error optional through feature --- Cargo.toml | 5 ++++- src/ecdh.rs | 2 +- src/key.rs | 2 +- src/lib.rs | 24 +++++++++++------------- src/macros.rs | 34 +++++++++++++++++----------------- 5 files changed, 34 insertions(+), 33 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index f114fef..8ada2de 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -27,8 +27,9 @@ path = "src/lib.rs" [features] unstable = [] -default = [] +default = ["std"] fuzztarget = [] +std = [] [dev-dependencies] rand = "0.6" @@ -38,7 +39,9 @@ serde_test = "1.0" [dependencies.rand] version = "0.6" optional = true +default-features = false [dependencies.serde] version = "1.0" optional = true +default-features = false diff --git a/src/ecdh.rs b/src/ecdh.rs index aec2dbc..35de210 100644 --- a/src/ecdh.rs +++ b/src/ecdh.rs @@ -16,7 +16,7 @@ //! Support for shared secret computations //! -use std::{ops, ptr}; +use core::{ops, ptr}; use key::{SecretKey, PublicKey}; use ffi; diff --git a/src/key.rs b/src/key.rs index 2d90c2e..ff1d9a1 100644 --- a/src/key.rs +++ b/src/key.rs @@ -17,7 +17,7 @@ #[cfg(any(test, feature = "rand"))] use rand::Rng; -use std::{fmt, mem, str}; +use core::{fmt, mem, str}; use super::{from_hex, Secp256k1}; use super::Error::{self, InvalidPublicKey, InvalidSecretKey}; diff --git a/src/lib.rs b/src/lib.rs index 5cb3d9b..89c61f8 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -133,15 +133,17 @@ #![cfg_attr(feature = "dev", feature(plugin))] #![cfg_attr(feature = "dev", plugin(clippy))] +#![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 = "rand"))] pub extern crate rand; #[cfg(any(test))] extern crate rand_core; #[cfg(feature = "serde")] pub extern crate serde; #[cfg(all(test, feature = "serde"))] extern crate serde_test; - -use std::{error, fmt, ptr, str}; #[cfg(any(test, feature = "rand"))] use rand::Rng; +#[cfg(any(test, feature = "std"))] extern crate core; + +use core::{fmt, ptr, str}; #[macro_use] mod macros; @@ -152,7 +154,7 @@ pub mod key; pub use key::SecretKey; pub use key::PublicKey; -use std::marker::PhantomData; +use core::marker::PhantomData; /// A tag used for recovering the public key from a compact signature #[derive(Copy, Clone, PartialEq, Eq, Debug)] @@ -519,15 +521,7 @@ pub enum Error { // Passthrough Debug to Display, since errors should be user-visible impl fmt::Display for Error { fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { - f.write_str(error::Error::description(self)) - } -} - -impl error::Error for Error { - fn cause(&self) -> Option<&error::Error> { None } - - fn description(&self) -> &str { - match *self { + let res = match *self { Error::IncorrectSignature => "secp: signature failed verification", Error::InvalidMessage => "secp: message was not 32 bytes (do you need to hash?)", Error::InvalidPublicKey => "secp: malformed public key", @@ -535,10 +529,14 @@ impl error::Error for Error { Error::InvalidSecretKey => "secp: malformed or out-of-range secret key", Error::InvalidRecoveryId => "secp: bad recovery id", Error::InvalidTweak => "secp: bad tweak", - } + }; + f.write_str(res) } } +#[cfg(feature = "std")] +impl std::error::Error for Error {} + /// Marker trait for indicating that an instance of `Secp256k1` can be used for signing. pub trait Signing {} diff --git a/src/macros.rs b/src/macros.rs index 4d51403..90f9ee3 100644 --- a/src/macros.rs +++ b/src/macros.rs @@ -53,14 +53,14 @@ macro_rules! impl_array_newtype { impl PartialOrd for $thing { #[inline] - fn partial_cmp(&self, other: &$thing) -> Option<::std::cmp::Ordering> { + fn partial_cmp(&self, other: &$thing) -> Option<::core::cmp::Ordering> { self[..].partial_cmp(&other[..]) } } impl Ord for $thing { #[inline] - fn cmp(&self, other: &$thing) -> ::std::cmp::Ordering { + fn cmp(&self, other: &$thing) -> ::core::cmp::Ordering { self[..].cmp(&other[..]) } } @@ -69,8 +69,8 @@ macro_rules! impl_array_newtype { #[inline] fn clone(&self) -> $thing { unsafe { - use std::intrinsics::copy_nonoverlapping; - use std::mem; + use core::intrinsics::copy_nonoverlapping; + use core::mem; let mut ret: $thing = mem::uninitialized(); copy_nonoverlapping(self.as_ptr(), ret.as_mut_ptr(), @@ -80,7 +80,7 @@ macro_rules! impl_array_newtype { } } - impl ::std::ops::Index for $thing { + impl ::core::ops::Index for $thing { type Output = $ty; #[inline] @@ -90,41 +90,41 @@ macro_rules! impl_array_newtype { } } - impl ::std::ops::Index<::std::ops::Range> for $thing { + impl ::core::ops::Index<::core::ops::Range> for $thing { type Output = [$ty]; #[inline] - fn index(&self, index: ::std::ops::Range) -> &[$ty] { + fn index(&self, index: ::core::ops::Range) -> &[$ty] { let &$thing(ref dat) = self; &dat[index] } } - impl ::std::ops::Index<::std::ops::RangeTo> for $thing { + impl ::core::ops::Index<::core::ops::RangeTo> for $thing { type Output = [$ty]; #[inline] - fn index(&self, index: ::std::ops::RangeTo) -> &[$ty] { + fn index(&self, index: ::core::ops::RangeTo) -> &[$ty] { let &$thing(ref dat) = self; &dat[index] } } - impl ::std::ops::Index<::std::ops::RangeFrom> for $thing { + impl ::core::ops::Index<::core::ops::RangeFrom> for $thing { type Output = [$ty]; #[inline] - fn index(&self, index: ::std::ops::RangeFrom) -> &[$ty] { + fn index(&self, index: ::core::ops::RangeFrom) -> &[$ty] { let &$thing(ref dat) = self; &dat[index] } } - impl ::std::ops::Index<::std::ops::RangeFull> for $thing { + impl ::core::ops::Index<::core::ops::RangeFull> for $thing { type Output = [$ty]; #[inline] - fn index(&self, _: ::std::ops::RangeFull) -> &[$ty] { + fn index(&self, _: ::core::ops::RangeFull) -> &[$ty] { let &$thing(ref dat) = self; &dat[..] } @@ -134,8 +134,8 @@ macro_rules! impl_array_newtype { macro_rules! impl_pretty_debug { ($thing:ident) => { - impl ::std::fmt::Debug for $thing { - fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + impl ::core::fmt::Debug for $thing { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { try!(write!(f, "{}(", stringify!($thing))); for i in self[..].iter().cloned() { try!(write!(f, "{:02x}", i)); @@ -148,8 +148,8 @@ macro_rules! impl_pretty_debug { macro_rules! impl_raw_debug { ($thing:ident) => { - impl ::std::fmt::Debug for $thing { - fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + impl ::core::fmt::Debug for $thing { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { for i in self[..].iter().cloned() { try!(write!(f, "{:02x}", i)); }