Remove use of std::num::Int

Author: cosmycoder

src/aessafe.rs

@@ -124,7 +124,6 @@ finite field which allows for efficient computation of the AES S-Boxes. See [7]
 */
 
 use std::ops::{BitAnd, BitXor, Not};
-use std::num::Int;
 use std::default::Default;
 
 use cryptoutil::{read_u32v_le, write_u32_le};

src/blake2b.rs

@@ -5,7 +5,6 @@
 // except according to those terms.
 
 use std::iter::repeat;
-use std::num::Int;
 use cryptoutil::{read_u64v_le, write_u64v_le};
 use std::slice::bytes::{copy_memory};
 use std::intrinsics::volatile_set_memory;

src/cryptoutil.rs

@@ -10,7 +10,6 @@
 
 use std;
 use std::{io, mem};
-use std::num::Int;
 use std::ptr;
 use std::slice::bytes::{MutableByteVector, copy_memory};
 
@@ -101,7 +100,7 @@ pub fn read_u64v_be(dst: &mut[u64], input: &[u8]) {
         for _ in (0..dst.len()) {
             let mut tmp: u64 = mem::uninitialized();
             ptr::copy_nonoverlapping(y, &mut tmp as *mut _ as *mut u8, 8);
-            *x = Int::from_be(tmp);
+            *x = u64::from_be(tmp);
             x = x.offset(1);
             y = y.offset(8);
         }
@@ -117,7 +116,7 @@ pub fn read_u64v_le(dst: &mut[u64], input: &[u8]) {
         for _ in (0..dst.len()) {
             let mut tmp: u64 = mem::uninitialized();
             ptr::copy_nonoverlapping(y, &mut tmp as *mut _ as *mut u8, 8);
-            *x = Int::from_le(tmp);
+            *x = u64::from_le(tmp);
             x = x.offset(1);
             y = y.offset(8);
         }
@@ -133,7 +132,7 @@ pub fn read_u32v_be(dst: &mut[u32], input: &[u8]) {
         for _ in (0..dst.len()) {
             let mut tmp: u32 = mem::uninitialized();
             ptr::copy_nonoverlapping(y, &mut tmp as *mut _ as *mut u8, 4);
-            *x = Int::from_be(tmp);
+            *x = u32::from_be(tmp);
             x = x.offset(1);
             y = y.offset(4);
         }
@@ -149,7 +148,7 @@ pub fn read_u32v_le(dst: &mut[u32], input: &[u8]) {
         for _ in (0..dst.len()) {
             let mut tmp: u32 = mem::uninitialized();
             ptr::copy_nonoverlapping(y, &mut tmp as *mut _ as *mut u8, 4);
-            *x = Int::from_le(tmp);
+            *x = u32::from_le(tmp);
             x = x.offset(1);
             y = y.offset(4);
         }
@@ -162,7 +161,7 @@ pub fn read_u32_le(input: &[u8]) -> u32 {
     unsafe {
         let mut tmp: u32 = mem::uninitialized();
         ptr::copy_nonoverlapping(input.get_unchecked(0), &mut tmp as *mut _ as *mut u8, 4);
-        Int::from_le(tmp)
+        u32::from_le(tmp)
     }
 }
 
@@ -172,7 +171,7 @@ pub fn read_u32_be(input: &[u8]) -> u32 {
     unsafe {
         let mut tmp: u32 = mem::uninitialized();
         ptr::copy_nonoverlapping(input.get_unchecked(0), &mut tmp as *mut _ as *mut u8, 4);
-        Int::from_be(tmp)
+        u32::from_be(tmp)
     }
 }
 
@@ -243,24 +242,18 @@ pub fn symm_enc_or_dec<S: SynchronousStreamCipher, R: ReadBuffer, W: WriteBuffer
     }
 }
 
-pub trait ToBits {
-    /// Convert the value in bytes to the number of bits, a tuple where the 1st item is the
-    /// high-order value and the 2nd item is the low order value.
-    fn to_bits(self) -> (Self, Self);
-}
-
-impl ToBits for u64 {
-    fn to_bits(self) -> (u64, u64) {
-        (self >> 61, self << 3)
-    }
+/// Convert the value in bytes to the number of bits, a tuple where the 1st item is the
+/// high-order value and the 2nd item is the low order value.
+fn to_bits(x: u64) -> (u64, u64) {
+    (x >> 61, x << 3)
 }
 
 /// Adds the specified number of bytes to the bit count. panic!() if this would cause numeric
 /// overflow.
-pub fn add_bytes_to_bits<T: Int + ToBits>(bits: T, bytes: T) -> T {
-    let (new_high_bits, new_low_bits) = bytes.to_bits();
+pub fn add_bytes_to_bits(bits: u64, bytes: u64) -> u64 {
+    let (new_high_bits, new_low_bits) = to_bits(bytes);
 
-    if new_high_bits > Int::zero() {
+    if new_high_bits > 0 {
         panic!("Numeric overflow occured.")
     }
 
@@ -270,17 +263,16 @@ pub fn add_bytes_to_bits<T: Int + ToBits>(bits: T, bytes: T) -> T {
 /// Adds the specified number of bytes to the bit count, which is a tuple where the first element is
 /// the high order value. panic!() if this would cause numeric overflow.
 pub fn add_bytes_to_bits_tuple
-        <T: Int + ToBits>
-        (bits: (T, T), bytes: T) -> (T, T) {
-    let (new_high_bits, new_low_bits) = bytes.to_bits();
+        (bits: (u64, u64), bytes: u64) -> (u64, u64) {
+    let (new_high_bits, new_low_bits) = to_bits(bytes);
     let (hi, low) = bits;
 
     // Add the low order value - if there is no overflow, then add the high order values
     // If the addition of the low order values causes overflow, add one to the high order values
     // before adding them.
     match low.checked_add(new_low_bits) {
         Some(x) => {
-            if new_high_bits == Int::zero() {
+            if new_high_bits == 0 {
                 // This is the fast path - every other alternative will rarely occur in practice
                 // considering how large an input would need to be for those paths to be used.
                 return (hi, x);
@@ -292,8 +284,7 @@ pub fn add_bytes_to_bits_tuple
             }
         },
         None => {
-            let one: T = Int::one();
-            let z = match new_high_bits.checked_add(one) {
+            let z = match new_high_bits.checked_add(1) {
                 Some(w) => w,
                 None => panic!("Numeric overflow occured.")
             };
@@ -496,8 +487,8 @@ impl <T: FixedBuffer> StandardPadding for T {
 
 #[cfg(test)]
 pub mod test {
+    use std;
     use std::iter::repeat;
-    use std::num::Int;
 
     use rand::IsaacRng;
     use rand::distributions::{IndependentSample, Range};
@@ -532,47 +523,47 @@ pub mod test {
     // A normal addition - no overflow occurs
     #[test]
     fn test_add_bytes_to_bits_ok() {
-        assert!(add_bytes_to_bits::<u64>(100, 10) == 180);
+        assert!(add_bytes_to_bits(100, 10) == 180);
     }
 
     // A simple failure case - adding 1 to the max value
     #[test]
     #[should_panic]
     fn test_add_bytes_to_bits_overflow() {
-        add_bytes_to_bits::<u64>(Int::max_value(), 1);
+        add_bytes_to_bits(std::u64::MAX, 1);
     }
 
     // A normal addition - no overflow occurs (fast path)
     #[test]
     fn test_add_bytes_to_bits_tuple_ok() {
-        assert!(add_bytes_to_bits_tuple::<u64>((5, 100), 10) == (5, 180));
+        assert!(add_bytes_to_bits_tuple((5, 100), 10) == (5, 180));
     }
 
     // The low order value overflows into the high order value
     #[test]
     fn test_add_bytes_to_bits_tuple_ok2() {
-        assert!(add_bytes_to_bits_tuple::<u64>((5, Int::max_value()), 1) == (6, 7));
+        assert!(add_bytes_to_bits_tuple((5, std::u64::MAX), 1) == (6, 7));
     }
 
     // The value to add is too large to be converted into bits without overflowing its type
     #[test]
     fn test_add_bytes_to_bits_tuple_ok3() {
-        assert!(add_bytes_to_bits_tuple::<u64>((5, 0), 0x4000000000000001) == (7, 8));
+        assert!(add_bytes_to_bits_tuple((5, 0), 0x4000000000000001) == (7, 8));
     }
 
     // A simple failure case - adding 1 to the max value
     #[test]
     #[should_panic]
     fn test_add_bytes_to_bits_tuple_overflow() {
-        add_bytes_to_bits_tuple::<u64>((Int::max_value(), Int::max_value()), 1);
+        add_bytes_to_bits_tuple((std::u64::MAX, std::u64::MAX), 1);
     }
 
     // The value to add is too large to convert to bytes without overflowing its type, but the high
     // order value from this conversion overflows when added to the existing high order value
     #[test]
     #[should_panic]
     fn test_add_bytes_to_bits_tuple_overflow2() {
-        let value: u64 = Int::max_value();
-        add_bytes_to_bits_tuple::<u64>((value - 1, 0), 0x8000000000000000);
+        let value: u64 = std::u64::MAX;
+        add_bytes_to_bits_tuple((value - 1, 0), 0x8000000000000000);
     }
 }

src/hc128.rs

@@ -9,7 +9,6 @@ use buffer::{BufferResult, RefReadBuffer, RefWriteBuffer};
 use symmetriccipher::{Encryptor, Decryptor, SynchronousStreamCipher, SymmetricCipherError};
 use cryptoutil::{read_u32_le, symm_enc_or_dec, write_u32_le};
 
-use std::num::Int;
 use std::ptr;
 
 

src/hkdf.rs

@@ -8,7 +8,6 @@
 //! Derivation Function as specified by  https://tools.ietf.org/html/rfc5869.
 
 use std::iter::repeat;
-use std::num::Int;
 use std::slice::bytes::copy_memory;
 
 use digest::Digest;

src/md5.rs

@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::num::Int;
-
 use cryptoutil::{write_u32_le, read_u32v_le, FixedBuffer, FixedBuffer64, StandardPadding};
 use digest::Digest;
 

src/pbkdf2.rs

@@ -11,7 +11,6 @@
 
 use std::iter::repeat;
 use std::io;
-use std::num::Int;
 use std::slice::bytes::copy_memory;
 
 use rand::{OsRng, Rng};

src/sha1.rs

@@ -60,7 +60,6 @@ Some of these functions are commonly found in all hash digest
 algorithms, but some, like "parity" is only found in SHA-1.
  */
 
-use std::num::Int;
 use digest::Digest;
 use cryptoutil::{write_u32_be, read_u32v_be, add_bytes_to_bits, FixedBuffer, FixedBuffer64, StandardPadding};
 use simd::u32x4;

src/sha2.rs

@@ -70,7 +70,6 @@ assert_eq!(hex,
 
  */
 
-use std::num::Int;
 use digest::Digest;
 use cryptoutil::{write_u32_be, read_u32v_be,
                  write_u64_be, read_u64v_be,

src/sosemanuk.rs

@@ -9,7 +9,6 @@ use buffer::{BufferResult, RefReadBuffer, RefWriteBuffer};
 use symmetriccipher::{Encryptor, Decryptor, SynchronousStreamCipher, SymmetricCipherError};
 use cryptoutil::{read_u32_le, symm_enc_or_dec, write_u32v_le};
 
-use std::num::Int;
 use std::slice::bytes::copy_memory;