---

yaml
---
r: 65481
b: refs/heads/master
c: ed93cc1
h: refs/heads/master
i:
  65479: 6c9c7e5
v: v3

Author: thestinger

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 1dc4ea004eee73be098279832c4f6cf558a35269
+refs/heads/master: ed93cc1987842d05992376c25a02d21d049ef792
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 18e3db7392d2d0697b7e27d6d986139960144d85
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9

trunk/doc/tutorial-ffi.md

@@ -153,7 +153,6 @@ use std::cast;
 use std::libc::{c_void, size_t, malloc, free};
 use std::ptr;
 use std::unstable::intrinsics;
-use std::util;
 
 // a wrapper around the handle returned by the foreign code
 pub struct Unique<T> {
@@ -186,9 +185,9 @@ pub impl<T: Owned> Unique<T> {
 impl<T: Owned> Drop for Unique<T> {
     fn finalize(&self) {
         unsafe {
-            let mut x = intrinsics::init(); // dummy value to swap in
+            let x = intrinsics::init(); // dummy value to swap in
             // moving the object out is needed to call the destructor
-            util::replace_ptr(self.ptr, x);
+            ptr::replace_ptr(self.ptr, x);
             free(self.ptr as *c_void)
         }
     }

trunk/src/libextra/rc.rs

@@ -28,7 +28,6 @@ use core::libc::{c_void, size_t, malloc, free};
 use core::ptr;
 use core::sys;
 use core::unstable::intrinsics;
-use core::util;
 
 struct RcBox<T> {
     value: T,
@@ -73,7 +72,7 @@ impl<T> Drop for Rc<T> {
         unsafe {
             (*self.ptr).count -= 1;
             if (*self.ptr).count == 0 {
-                util::replace_ptr(self.ptr, intrinsics::uninit());
+                ptr::replace_ptr(self.ptr, intrinsics::uninit());
                 free(self.ptr as *c_void)
             }
         }
@@ -223,7 +222,7 @@ impl<T> Drop for RcMut<T> {
         unsafe {
             (*self.ptr).count -= 1;
             if (*self.ptr).count == 0 {
-                util::replace_ptr(self.ptr, uninit());
+                ptr::replace_ptr(self.ptr, uninit());
                 free(self.ptr as *c_void)
             }
         }

trunk/src/librustc/back/passes.rs

@@ -134,6 +134,7 @@ pub fn create_standard_passes(level:OptLevel) -> ~[~str] {
     passes.push(~"correlated-propagation");
     passes.push(~"dse");
 
+    passes.push(~"bb-vectorize");
     passes.push(~"instcombine");
     passes.push(~"early-cse");
 

trunk/src/libstd/bool.rs

@@ -38,7 +38,6 @@ Finally, some inquries into the nature of truth: `is_true` and `is_false`.
 use cmp::{Eq, Ord, TotalOrd, Ordering};
 use option::{None, Option, Some};
 use from_str::FromStr;
-use to_str::ToStr;
 
 /**
 * Negation of a boolean value.
@@ -130,6 +129,44 @@ pub fn xor(a: bool, b: bool) -> bool { (a && !b) || (!a && b) }
 */
 pub fn implies(a: bool, b: bool) -> bool { !a || b }
 
+/**
+* Equality between two boolean values.
+*
+* Two booleans are equal if they have the same value.
+*
+* # Examples
+*
+* ~~~ {.rust}
+* rusti> std::bool::eq(false, true)
+* false
+* ~~~
+*
+* ~~~ {.rust}
+* rusti> std::bool::eq(false, false)
+* true
+* ~~~
+*/
+pub fn eq(a: bool, b: bool) -> bool { a == b }
+
+/**
+* Non-equality between two boolean values.
+*
+* Two booleans are not equal if they have different values.
+*
+* # Examples
+*
+* ~~~ {.rust}
+* rusti> std::bool::ne(false, true)
+* true
+* ~~~
+*
+* ~~~ {.rust}
+* rusti> std::bool::ne(false, false)
+* false
+* ~~~
+*/
+pub fn ne(a: bool, b: bool) -> bool { a != b }
+
 /**
 * Is a given boolean value true?
 *
@@ -202,21 +239,16 @@ impl FromStr for bool {
 * # Examples
 *
 * ~~~ {.rust}
-* rusti> true.to_str()
+* rusti> std::bool::to_str(true)
 * "true"
 * ~~~
 *
 * ~~~ {.rust}
-* rusti> false.to_str()
+* rusti> std::bool::to_str(false)
 * "false"
 * ~~~
 */
-impl ToStr for bool {
-    #[inline(always)]
-    fn to_str(&self) -> ~str {
-        if *self { ~"true" } else { ~"false" }
-    }
-}
+pub fn to_str(v: bool) -> ~str { if v { ~"true" } else { ~"false" } }
 
 /**
 * Iterates over all truth values, passing them to the given block.
@@ -226,7 +258,7 @@ impl ToStr for bool {
 * # Examples
 * ~~~
 * do std::bool::all_values |x: bool| {
-*     println(x.to_str())
+*     println(std::bool::to_str(x));
 * }
 * ~~~
 */
@@ -271,31 +303,6 @@ impl TotalOrd for bool {
     fn cmp(&self, other: &bool) -> Ordering { to_bit(*self).cmp(&to_bit(*other)) }
 }
 
-/**
-* Equality between two boolean values.
-*
-* Two booleans are equal if they have the same value.
-*
-* ~~~ {.rust}
-* rusti> false.eq(&true)
-* false
-* ~~~
-*
-* ~~~ {.rust}
-* rusti> false == false
-* true
-* ~~~
-*
-* ~~~ {.rust}
-* rusti> false != true
-* true
-* ~~~
-*
-* ~~~ {.rust}
-* rusti> false.ne(&false)
-* false
-* ~~~
-*/
 #[cfg(not(test))]
 impl Eq for bool {
     #[inline(always)]
@@ -312,14 +319,14 @@ mod tests {
     #[test]
     fn test_bool_from_str() {
         do all_values |v| {
-            assert!(Some(v) == FromStr::from_str(v.to_str()))
+            assert!(Some(v) == FromStr::from_str(to_str(v)))
         }
     }
 
     #[test]
     fn test_bool_to_str() {
-        assert_eq!(false.to_str(), ~"false");
-        assert_eq!(true.to_str(), ~"true");
+        assert_eq!(to_str(false), ~"false");
+        assert_eq!(to_str(true), ~"true");
     }
 
     #[test]

trunk/src/libstd/ptr.rs

@@ -15,6 +15,7 @@ use cast;
 #[cfg(stage0)] use libc::{c_void, size_t};
 use option::{Option, Some, None};
 use sys;
+use unstable::intrinsics;
 
 #[cfg(not(test))] use cmp::{Eq, Ord};
 use uint;
@@ -71,11 +72,11 @@ pub unsafe fn position<T>(buf: *T, f: &fn(&T) -> bool) -> uint {
 
 /// Create an unsafe null pointer
 #[inline(always)]
-pub fn null<T>() -> *T { unsafe { cast::transmute(0u) } }
+pub fn null<T>() -> *T { 0 as *T }
 
 /// Create an unsafe mutable null pointer
 #[inline(always)]
-pub fn mut_null<T>() -> *mut T { unsafe { cast::transmute(0u) } }
+pub fn mut_null<T>() -> *mut T { 0 as *mut T }
 
 /// Returns true if the pointer is equal to the null pointer.
 #[inline(always)]
@@ -207,47 +208,57 @@ pub unsafe fn set_memory<T>(dst: *mut T, c: u8, count: uint) {
 }
 
 /**
-  Transform a region pointer - &T - to an unsafe pointer - *T.
-  This is safe, but is implemented with an unsafe block due to
-  transmute.
-*/
+ * Swap the values at two mutable locations of the same type, without
+ * deinitialising or copying either one.
+ */
+#[inline]
+pub unsafe fn swap_ptr<T>(x: *mut T, y: *mut T) {
+    // Give ourselves some scratch space to work with
+    let mut tmp: T = intrinsics::uninit();
+    let t: *mut T = &mut tmp;
+
+    // Perform the swap
+    copy_memory(t, x, 1);
+    copy_memory(x, y, 1);
+    copy_memory(y, t, 1);
+
+    // y and t now point to the same thing, but we need to completely forget `tmp`
+    // because it's no longer relevant.
+    cast::forget(tmp);
+}
+
+/**
+ * Replace the value at a mutable location with a new one, returning the old
+ * value, without deinitialising or copying either one.
+ */
+#[inline(always)]
+pub unsafe fn replace_ptr<T>(dest: *mut T, mut src: T) -> T {
+    swap_ptr(dest, &mut src);
+    src
+}
+
+/// Transform a region pointer - &T - to an unsafe pointer - *T.
 #[inline(always)]
 pub fn to_unsafe_ptr<T>(thing: &T) -> *T {
-    unsafe { cast::transmute(thing) }
+    thing as *T
 }
 
-/**
-  Transform a const region pointer - &const T - to a const unsafe pointer -
-  *const T. This is safe, but is implemented with an unsafe block due to
-  transmute.
-*/
+/// Transform a const region pointer - &const T - to a const unsafe pointer - *const T.
 #[inline(always)]
 pub fn to_const_unsafe_ptr<T>(thing: &const T) -> *const T {
-    unsafe { cast::transmute(thing) }
+    thing as *const T
 }
 
-/**
-  Transform a mutable region pointer - &mut T - to a mutable unsafe pointer -
-  *mut T. This is safe, but is implemented with an unsafe block due to
-  transmute.
-*/
+/// Transform a mutable region pointer - &mut T - to a mutable unsafe pointer - *mut T.
 #[inline(always)]
 pub fn to_mut_unsafe_ptr<T>(thing: &mut T) -> *mut T {
-    unsafe { cast::transmute(thing) }
+    thing as *mut T
 }
 
-/**
-  Cast a region pointer - &T - to a uint.
-  This is safe, but is implemented with an unsafe block due to
-  transmute.
-
-  (I couldn't think of a cutesy name for this one.)
-*/
+/// Cast a region pointer - &T - to a uint.
 #[inline(always)]
 pub fn to_uint<T>(thing: &T) -> uint {
-    unsafe {
-        cast::transmute(thing)
-    }
+    thing as *T as uint
 }
 
 /// Determine if two borrowed pointers point to the same thing.
@@ -373,50 +384,30 @@ impl<T> Ptr<T> for *mut T {
 impl<T> Eq for *const T {
     #[inline(always)]
     fn eq(&self, other: &*const T) -> bool {
-        unsafe {
-            let a: uint = cast::transmute(*self);
-            let b: uint = cast::transmute(*other);
-            return a == b;
-        }
+        (*self as uint) == (*other as uint)
     }
     #[inline(always)]
-    fn ne(&self, other: &*const T) -> bool { !(*self).eq(other) }
+    fn ne(&self, other: &*const T) -> bool { !self.eq(other) }
 }
 
 // Comparison for pointers
 #[cfg(not(test))]
 impl<T> Ord for *const T {
     #[inline(always)]
     fn lt(&self, other: &*const T) -> bool {
-        unsafe {
-            let a: uint = cast::transmute(*self);
-            let b: uint = cast::transmute(*other);
-            return a < b;
-        }
+        (*self as uint) < (*other as uint)
     }
     #[inline(always)]
     fn le(&self, other: &*const T) -> bool {
-        unsafe {
-            let a: uint = cast::transmute(*self);
-            let b: uint = cast::transmute(*other);
-            return a <= b;
-        }
+        (*self as uint) <= (*other as uint)
     }
     #[inline(always)]
     fn ge(&self, other: &*const T) -> bool {
-        unsafe {
-            let a: uint = cast::transmute(*self);
-            let b: uint = cast::transmute(*other);
-            return a >= b;
-        }
+        (*self as uint) >= (*other as uint)
     }
     #[inline(always)]
     fn gt(&self, other: &*const T) -> bool {
-        unsafe {
-            let a: uint = cast::transmute(*self);
-            let b: uint = cast::transmute(*other);
-            return a > b;
-        }
+        (*self as uint) > (*other as uint)
     }
 }
 
@@ -425,11 +416,11 @@ impl<T> Ord for *const T {
 impl<'self,T:Eq> Eq for &'self T {
     #[inline(always)]
     fn eq(&self, other: & &'self T) -> bool {
-        return *(*self) == *(*other);
+        *(*self) == *(*other)
     }
     #[inline(always)]
     fn ne(&self, other: & &'self T) -> bool {
-        return *(*self) != *(*other);
+        *(*self) != *(*other)
     }
 }
 

trunk/src/libstd/to_str.rs

@@ -34,6 +34,10 @@ pub trait ToStrConsume {
     fn to_str_consume(self) -> ~str;
 }
 
+impl ToStr for bool {
+    #[inline(always)]
+    fn to_str(&self) -> ~str { ::bool::to_str(*self) }
+}
 impl ToStr for () {
     #[inline(always)]
     fn to_str(&self) -> ~str { ~"()" }