---

yaml
---
r: 152527
b: refs/heads/try2
c: d64f18c
h: refs/heads/master
i:
  152525: 321af1b
  152523: 56cb09a
  152519: b23b675
  152511: 0724393
v: v3

Author: bors

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 09eb95f24165b2a7eec6a599b0a4bad86ff6892d
+refs/heads/try2: d64f18c490981f33f33e9c24e1ed1316e63f11fc
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libarena/lib.rs

@@ -406,7 +406,8 @@ impl<T> TypedArenaChunk<T> {
             None => {}
             Some(mut next) => {
                 // We assume that the next chunk is completely filled.
-                next.destroy(next.capacity)
+                let capacity = next.capacity;
+                next.destroy(capacity)
             }
         }
     }

branches/try2/src/libcollections/ringbuf.rs

@@ -66,7 +66,8 @@ impl<T> Deque<T> for RingBuf<T> {
 
     /// Return a mutable reference to the last element in the RingBuf
     fn back_mut<'a>(&'a mut self) -> Option<&'a mut T> {
-        if self.nelts > 0 { Some(self.get_mut(self.nelts - 1)) } else { None }
+        let nelts = self.nelts;
+        if nelts > 0 { Some(self.get_mut(nelts - 1)) } else { None }
     }
 
     /// Remove and return the first element in the RingBuf, or None if it is empty

branches/try2/src/libcollections/vec.rs

@@ -114,7 +114,8 @@ impl<T> Vec<T> {
         unsafe {
             let mut xs = Vec::with_capacity(length);
             while xs.len < length {
-                ptr::write(xs.as_mut_slice().unsafe_mut_ref(xs.len), op(xs.len));
+                let len = xs.len;
+                ptr::write(xs.as_mut_slice().unsafe_mut_ref(len), op(len));
                 xs.len += 1;
             }
             xs
@@ -210,7 +211,8 @@ impl<T: Clone> Vec<T> {
         unsafe {
             let mut xs = Vec::with_capacity(length);
             while xs.len < length {
-                ptr::write(xs.as_mut_slice().unsafe_mut_ref(xs.len),
+                let len = xs.len;
+                ptr::write(xs.as_mut_slice().unsafe_mut_ref(len),
                            value.clone());
                 xs.len += 1;
             }
@@ -321,9 +323,10 @@ impl<T:Clone> Clone for Vec<T> {
             let this_slice = self.as_slice();
             while vector.len < len {
                 unsafe {
+                    let len = vector.len;
                     ptr::write(
-                        vector.as_mut_slice().unsafe_mut_ref(vector.len),
-                        this_slice.unsafe_ref(vector.len).clone());
+                        vector.as_mut_slice().unsafe_mut_ref(len),
+                        this_slice.unsafe_ref(len).clone());
                 }
                 vector.len += 1;
             }

branches/try2/src/libcore/num/int_macros.rs

@@ -113,6 +113,33 @@ mod tests {
         assert!((0b1111001 as $T).count_zeros() == BITS as $T - 5);
     }
 
+    #[test]
+    fn test_swap_bytes() {
+        let n: $T = 0b0101100; assert_eq!(n.swap_bytes().swap_bytes(), n);
+        let n: $T = 0b0100001; assert_eq!(n.swap_bytes().swap_bytes(), n);
+        let n: $T = 0b1111001; assert_eq!(n.swap_bytes().swap_bytes(), n);
+
+        // Swapping these should make no difference
+        let n: $T = 0;   assert_eq!(n.swap_bytes(), n);
+        let n: $T = -1;  assert_eq!(n.swap_bytes(), n);
+    }
+
+    #[test]
+    fn test_rotate() {
+        let n: $T = 0b0101100; assert_eq!(n.rotate_left(6).rotate_right(2).rotate_right(4), n);
+        let n: $T = 0b0100001; assert_eq!(n.rotate_left(3).rotate_left(2).rotate_right(5),  n);
+        let n: $T = 0b1111001; assert_eq!(n.rotate_left(6).rotate_right(2).rotate_right(4), n);
+
+        // Rotating these should make no difference
+        //
+        // We test using 124 bits because to ensure that overlong bit shifts do
+        // not cause undefined behaviour. See #10183.
+        let n: $T = 0;   assert_eq!(n.rotate_left(124), n);
+        let n: $T = -1;  assert_eq!(n.rotate_left(124), n);
+        let n: $T = 0;   assert_eq!(n.rotate_right(124), n);
+        let n: $T = -1;  assert_eq!(n.rotate_right(124), n);
+    }
+
     #[test]
     fn test_signed_checked_div() {
         assert!(10i.checked_div(&2) == Some(5));

branches/try2/src/libcore/num/mod.rs

@@ -436,57 +436,135 @@ pub trait Bitwise: Bounded
     /// assert_eq!(n.trailing_zeros(), 3);
     /// ```
     fn trailing_zeros(&self) -> Self;
+
+    /// Reverses the byte order of a binary number.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use std::num::Bitwise;
+    ///
+    /// let n = 0x0123456789ABCDEFu64;
+    /// let m = 0xEFCDAB8967452301u64;
+    /// assert_eq!(n.swap_bytes(), m);
+    /// ```
+    fn swap_bytes(&self) -> Self;
+
+    /// Shifts the bits to the left by a specified amount amount, `r`, wrapping
+    /// the truncated bits to the end of the resulting value.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use std::num::Bitwise;
+    ///
+    /// let n = 0x0123456789ABCDEFu64;
+    /// let m = 0x3456789ABCDEF012u64;
+    /// assert_eq!(n.rotate_left(12), m);
+    /// ```
+    fn rotate_left(&self, r: uint) -> Self;
+
+    /// Shifts the bits to the right by a specified amount amount, `r`, wrapping
+    /// the truncated bits to the beginning of the resulting value.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use std::num::Bitwise;
+    ///
+    /// let n = 0x0123456789ABCDEFu64;
+    /// let m = 0xDEF0123456789ABCu64;
+    /// assert_eq!(n.rotate_right(12), m);
+    /// ```
+    fn rotate_right(&self, r: uint) -> Self;
 }
 
+/// Swapping a single byte does nothing. This is unsafe to be consistent with
+/// the other `bswap` intrinsics.
+#[inline]
+unsafe fn bswap8(x: u8) -> u8 { x }
+
 macro_rules! bitwise_impl(
-    ($t:ty, $co:path, $lz:path, $tz:path) => {
+    ($t:ty, $bits:expr, $co:ident, $lz:ident, $tz:ident, $bs:path) => {
         impl Bitwise for $t {
             #[inline]
-            fn count_ones(&self) -> $t { unsafe { $co(*self) } }
+            fn count_ones(&self) -> $t { unsafe { intrinsics::$co(*self) } }
 
             #[inline]
-            fn leading_zeros(&self) -> $t { unsafe { $lz(*self) } }
+            fn leading_zeros(&self) -> $t { unsafe { intrinsics::$lz(*self) } }
 
             #[inline]
-            fn trailing_zeros(&self) -> $t { unsafe { $tz(*self) } }
+            fn trailing_zeros(&self) -> $t { unsafe { intrinsics::$tz(*self) } }
+
+            #[inline]
+            fn swap_bytes(&self) -> $t { unsafe { $bs(*self) } }
+
+            #[inline]
+            fn rotate_left(&self, r: uint) -> $t {
+                // Protect against undefined behaviour for overlong bit shifts
+                let r = r % $bits;
+                (*self << r) | (*self >> ($bits - r))
+            }
+
+            #[inline]
+            fn rotate_right(&self, r: uint) -> $t {
+                // Protect against undefined behaviour for overlong bit shifts
+                let r = r % $bits;
+                (*self >> r) | (*self << ($bits - r))
+            }
         }
     }
 )
 
 macro_rules! bitwise_cast_impl(
-    ($t:ty, $t_cast:ty,  $co:path, $lz:path, $tz:path) => {
+    ($t:ty, $t_cast:ty, $bits:expr,  $co:ident, $lz:ident, $tz:ident, $bs:path) => {
         impl Bitwise for $t {
             #[inline]
-            fn count_ones(&self) -> $t { unsafe { $co(*self as $t_cast) as $t } }
+            fn count_ones(&self) -> $t { unsafe { intrinsics::$co(*self as $t_cast) as $t } }
+
+            #[inline]
+            fn leading_zeros(&self) -> $t { unsafe { intrinsics::$lz(*self as $t_cast) as $t } }
+
+            #[inline]
+            fn trailing_zeros(&self) -> $t { unsafe { intrinsics::$tz(*self as $t_cast) as $t } }
 
             #[inline]
-            fn leading_zeros(&self) -> $t { unsafe { $lz(*self as $t_cast) as $t } }
+            fn swap_bytes(&self) -> $t { unsafe { $bs(*self as $t_cast) as $t } }
 
             #[inline]
-            fn trailing_zeros(&self) -> $t { unsafe { $tz(*self as $t_cast) as $t } }
+            fn rotate_left(&self, r: uint) -> $t {
+                // cast to prevent the sign bit from being corrupted
+                (*self as $t_cast).rotate_left(r) as $t
+            }
+
+            #[inline]
+            fn rotate_right(&self, r: uint) -> $t {
+                // cast to prevent the sign bit from being corrupted
+                (*self as $t_cast).rotate_right(r) as $t
+            }
         }
     }
 )
 
 #[cfg(target_word_size = "32")]
-bitwise_cast_impl!(uint, u32, intrinsics::ctpop32, intrinsics::ctlz32, intrinsics::cttz32)
+bitwise_cast_impl!(uint, u32, 32, ctpop32, ctlz32, cttz32, intrinsics::bswap32)
 #[cfg(target_word_size = "64")]
-bitwise_cast_impl!(uint, u64, intrinsics::ctpop64, intrinsics::ctlz64, intrinsics::cttz64)
+bitwise_cast_impl!(uint, u64, 64, ctpop64, ctlz64, cttz64, intrinsics::bswap64)
 
-bitwise_impl!(u8, intrinsics::ctpop8, intrinsics::ctlz8, intrinsics::cttz8)
-bitwise_impl!(u16, intrinsics::ctpop16, intrinsics::ctlz16, intrinsics::cttz16)
-bitwise_impl!(u32, intrinsics::ctpop32, intrinsics::ctlz32, intrinsics::cttz32)
-bitwise_impl!(u64, intrinsics::ctpop64, intrinsics::ctlz64, intrinsics::cttz64)
+bitwise_impl!(u8, 8, ctpop8, ctlz8, cttz8, bswap8)
+bitwise_impl!(u16, 16, ctpop16, ctlz16, cttz16, intrinsics::bswap16)
+bitwise_impl!(u32, 32, ctpop32, ctlz32, cttz32, intrinsics::bswap32)
+bitwise_impl!(u64, 64, ctpop64, ctlz64, cttz64, intrinsics::bswap64)
 
 #[cfg(target_word_size = "32")]
-bitwise_cast_impl!(int, u32, intrinsics::ctpop32, intrinsics::ctlz32, intrinsics::cttz32)
+bitwise_cast_impl!(int, u32, 32, ctpop32, ctlz32, cttz32, intrinsics::bswap32)
 #[cfg(target_word_size = "64")]
-bitwise_cast_impl!(int, u64, intrinsics::ctpop64, intrinsics::ctlz64, intrinsics::cttz64)
+bitwise_cast_impl!(int, u64, 64, ctpop64, ctlz64, cttz64, intrinsics::bswap64)
 
-bitwise_cast_impl!(i8, u8, intrinsics::ctpop8, intrinsics::ctlz8, intrinsics::cttz8)
-bitwise_cast_impl!(i16, u16, intrinsics::ctpop16, intrinsics::ctlz16, intrinsics::cttz16)
-bitwise_cast_impl!(i32, u32, intrinsics::ctpop32, intrinsics::ctlz32, intrinsics::cttz32)
-bitwise_cast_impl!(i64, u64, intrinsics::ctpop64, intrinsics::ctlz64, intrinsics::cttz64)
+bitwise_cast_impl!(i8, u8, 8, ctpop8, ctlz8, cttz8, bswap8)
+bitwise_cast_impl!(i16, u16, 16, ctpop16, ctlz16, cttz16, intrinsics::bswap16)
+bitwise_cast_impl!(i32, u32, 32, ctpop32, ctlz32, cttz32, intrinsics::bswap32)
+bitwise_cast_impl!(i64, u64, 64, ctpop64, ctlz64, cttz64, intrinsics::bswap64)
 
 /// Specifies the available operations common to all of Rust's core numeric primitives.
 /// These may not always make sense from a purely mathematical point of view, but

branches/try2/src/libcore/num/uint_macros.rs

@@ -64,6 +64,33 @@ mod tests {
         assert!((0b1111001 as $T).count_zeros() == BITS as $T - 5);
     }
 
+    #[test]
+    fn test_swap_bytes() {
+        let n: $T = 0b0101100; assert_eq!(n.swap_bytes().swap_bytes(), n);
+        let n: $T = 0b0100001; assert_eq!(n.swap_bytes().swap_bytes(), n);
+        let n: $T = 0b1111001; assert_eq!(n.swap_bytes().swap_bytes(), n);
+
+        // Swapping these should make no difference
+        let n: $T = 0;   assert_eq!(n.swap_bytes(), n);
+        let n: $T = MAX; assert_eq!(n.swap_bytes(), n);
+    }
+
+    #[test]
+    fn test_rotate() {
+        let n: $T = 0b0101100; assert_eq!(n.rotate_left(6).rotate_right(2).rotate_right(4), n);
+        let n: $T = 0b0100001; assert_eq!(n.rotate_left(3).rotate_left(2).rotate_right(5),  n);
+        let n: $T = 0b1111001; assert_eq!(n.rotate_left(6).rotate_right(2).rotate_right(4), n);
+
+        // Rotating these should make no difference
+        //
+        // We test using 124 bits because to ensure that overlong bit shifts do
+        // not cause undefined behaviour. See #10183.
+        let n: $T = 0;   assert_eq!(n.rotate_left(124), n);
+        let n: $T = MAX; assert_eq!(n.rotate_left(124), n);
+        let n: $T = 0;   assert_eq!(n.rotate_right(124), n);
+        let n: $T = MAX; assert_eq!(n.rotate_right(124), n);
+    }
+
     #[test]
     fn test_unsigned_checked_div() {
         assert!(10u.checked_div(&2) == Some(5));

branches/try2/src/libdebug/repr.rs

@@ -127,13 +127,15 @@ impl<'a> ReprVisitor<'a> {
     #[inline]
     pub fn get<T>(&mut self, f: |&mut ReprVisitor, &T| -> bool) -> bool {
         unsafe {
-            f(self, mem::transmute::<*u8,&T>(self.ptr))
+            let ptr = self.ptr;
+            f(self, mem::transmute::<*u8,&T>(ptr))
         }
     }
 
     #[inline]
     pub fn visit_inner(&mut self, inner: *TyDesc) -> bool {
-        self.visit_ptr_inner(self.ptr, inner)
+        let ptr = self.ptr;
+        self.visit_ptr_inner(ptr, inner)
     }
 
     #[inline]

branches/try2/src/libnative/io/net.rs

@@ -637,16 +637,15 @@ impl rtio::RtioUdpSocket for UdpSocket {
                 mem::size_of::<libc::sockaddr_storage>() as libc::socklen_t;
 
         let dolock = || self.lock_nonblocking();
-        let doread = |nb| unsafe {
+        let n = try!(read(fd, self.read_deadline, dolock, |nb| unsafe {
             let flags = if nb {c::MSG_DONTWAIT} else {0};
             libc::recvfrom(fd,
                            buf.as_mut_ptr() as *mut libc::c_void,
                            buf.len() as msglen_t,
                            flags,
                            storagep,
                            &mut addrlen) as libc::c_int
-        };
-        let n = try!(read(fd, self.read_deadline, dolock, doread));
+        }));
         sockaddr_to_addr(&storage, addrlen as uint).and_then(|addr| {
             Ok((n as uint, addr))
         })

branches/try2/src/libregex/parse/mod.rs

@@ -345,18 +345,19 @@ impl<'a> Parser<'a> {
     }
 
     fn push_literal(&mut self, c: char) -> Result<(), Error> {
+        let flags = self.flags;
         match c {
             '.' => {
-                self.push(Dot(self.flags))
+                self.push(Dot(flags))
             }
             '^' => {
-                self.push(Begin(self.flags))
+                self.push(Begin(flags))
             }
             '$' => {
-                self.push(End(self.flags))
+                self.push(End(flags))
             }
             _ => {
-                self.push(Literal(c, self.flags))
+                self.push(Literal(c, flags))
             }
         }
         Ok(())