---

yaml
---
r: 56070
b: refs/heads/auto
c: 61b2999
h: refs/heads/master
v: v3

Author: thestinger

[refs]

@@ -14,6 +14,6 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: bfeb6d124dc924e52a218387a388caf87964162f
+refs/heads/auto: 61b29993ddd531c6f53f7d21ddf28d26d4d63a21
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c

branches/auto/configure

@@ -859,7 +859,7 @@ do
         LDFLAGS=$LLVM_LDFLAGS
 
         LLVM_FLAGS="$LLVM_TARGETS $LLVM_OPTS $LLVM_BUILD \
-                        $LLVM_HOST $LLVM_TARGET --with-python=$CFG_PYTHON"
+                        $LLVM_HOST $LLVM_TARGET"
 
         msg "configuring LLVM with:"
         msg "$LLVM_FLAGS"

branches/auto/src/libcore/bool.rs

@@ -8,14 +8,13 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-
 //! Boolean logic
 
+#[cfg(notest)]
+use cmp::{Eq, Ord, TotalOrd, Ordering};
 use option::{None, Option, Some};
 use from_str::FromStr;
 
-#[cfg(notest)] use cmp;
-
 /// Negation / inverse
 pub fn not(v: bool) -> bool { !v }
 
@@ -73,40 +72,86 @@ pub fn all_values(blk: &fn(v: bool)) {
 }
 
 /// converts truth value to an 8 bit byte
+#[inline(always)]
 pub fn to_bit(v: bool) -> u8 { if v { 1u8 } else { 0u8 } }
 
 #[cfg(notest)]
-impl cmp::Eq for bool {
+impl Ord for bool {
+    #[inline(always)]
+    fn lt(&self, other: &bool) -> bool { to_bit(*self) < to_bit(*other) }
+    #[inline(always)]
+    fn le(&self, other: &bool) -> bool { to_bit(*self) <= to_bit(*other) }
+    #[inline(always)]
+    fn gt(&self, other: &bool) -> bool { to_bit(*self) > to_bit(*other) }
+    #[inline(always)]
+    fn ge(&self, other: &bool) -> bool { to_bit(*self) >= to_bit(*other) }
+}
+
+#[cfg(notest)]
+impl TotalOrd for bool {
+    #[inline(always)]
+    fn cmp(&self, other: &bool) -> Ordering { to_bit(*self).cmp(&to_bit(*other)) }
+}
+
+#[cfg(notest)]
+impl Eq for bool {
+    #[inline(always)]
     fn eq(&self, other: &bool) -> bool { (*self) == (*other) }
+    #[inline(always)]
     fn ne(&self, other: &bool) -> bool { (*self) != (*other) }
 }
 
-#[test]
-pub fn test_bool_from_str() {
-    use from_str::FromStr;
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use prelude::*;
 
-    do all_values |v| {
-        assert!(Some(v) == FromStr::from_str(to_str(v)))
+    #[test]
+    fn test_bool_from_str() {
+        use from_str::FromStr;
+
+        do all_values |v| {
+            assert!(Some(v) == FromStr::from_str(to_str(v)))
+        }
     }
-}
 
-#[test]
-pub fn test_bool_to_str() {
-    assert!(to_str(false) == ~"false");
-    assert!(to_str(true) == ~"true");
-}
+    #[test]
+    fn test_bool_to_str() {
+        assert!(to_str(false) == ~"false");
+        assert!(to_str(true) == ~"true");
+    }
 
-#[test]
-pub fn test_bool_to_bit() {
-    do all_values |v| {
-        assert!(to_bit(v) == if is_true(v) { 1u8 } else { 0u8 });
+    #[test]
+    fn test_bool_to_bit() {
+        do all_values |v| {
+            assert!(to_bit(v) == if is_true(v) { 1u8 } else { 0u8 });
+        }
     }
-}
 
-// Local Variables:
-// mode: rust;
-// fill-column: 78;
-// indent-tabs-mode: nil
-// c-basic-offset: 4
-// buffer-file-coding-system: utf-8-unix
-// End:
+    #[test]
+    fn test_bool_ord() {
+        assert!(true > false);
+        assert!(!(false > true));
+
+        assert!(false < true);
+        assert!(!(true < false));
+
+        assert!(false <= false);
+        assert!(false >= false);
+        assert!(true <= true);
+        assert!(true >= true);
+
+        assert!(false <= true);
+        assert!(!(false >= true));
+        assert!(true >= false);
+        assert!(!(true <= false));
+    }
+
+    #[test]
+    fn test_bool_totalord() {
+        assert_eq!(true.cmp(&true), Equal);
+        assert_eq!(false.cmp(&false), Equal);
+        assert_eq!(true.cmp(&false), Greater);
+        assert_eq!(false.cmp(&true), Less);
+    }
+}

branches/auto/src/libcore/rand.rs

@@ -150,21 +150,7 @@ pub struct Weighted<T> {
 
 pub trait RngUtil {
     fn gen<T:Rand>(&self) -> T;
-    /**
-     * Return a random int
-     *
-     * *Example*
-     *
-     * ~~~
-     *
-     * use core::rand::RngUtil;
-     *
-     * fn main() {
-     *     rng = rand::Rng();
-     *     println(fmt!("%d",rng.gen_int()));
-     * }
-     * ~~~
-     */
+    /// Return a random int
     fn gen_int(&self) -> int;
     fn gen_int_range(&self, start: int, end: int) -> int;
     /// Return a random i8
@@ -190,21 +176,7 @@ pub trait RngUtil {
     fn gen_u32(&self) -> u32;
     /// Return a random u64
     fn gen_u64(&self) -> u64;
-    /**
-     * Return random float in the interval [0,1]
-     *
-     * *Example*
-     *
-     * ~~~
-     *
-     * use core::rand::RngUtil;
-     *
-     * fn main() {
-     *     rng = rand::Rng();
-     *     println(fmt!("%f",rng.gen_float()));
-     * }
-     * ~~~
-     */
+    /// Return a random float in the interval [0,1]
     fn gen_float(&self) -> float;
     /// Return a random f32 in the interval [0,1]
     fn gen_f32(&self) -> f32;
@@ -216,184 +188,38 @@ pub trait RngUtil {
      * Return a char randomly chosen from chars, failing if chars is empty
      */
     fn gen_char_from(&self, chars: &str) -> char;
-    /**
-     * Return a random bool
-     *
-     * *Example*
-     *
-     * ~~~
-     *
-     * use core::rand::RngUtil;
-     *
-     * fn main() {
-     *     rng = rand::Rng();
-     *     println(fmt!("%b",rng.gen_bool()));
-     * }
-     * ~~~
-     */
+    /// Return a random bool
     fn gen_bool(&self) -> bool;
-    /**
-     * Return a bool with a 1 in n chance of true
-     *
-     * *Example*
-     *
-     * ~~~
-     *
-     * use core::rand::RngUtil;
-     *
-     * fn main() {
-     *     rng = rand::Rng();
-     *     println(fmt!("%b",rng.gen_weighted_bool(3)));
-     * }
-     * ~~~
-     */
+    /// Return a bool with a 1 in n chance of true
     fn gen_weighted_bool(&self, n: uint) -> bool;
     /**
      * Return a random string of the specified length composed of A-Z,a-z,0-9
-     *
-     * *Example*
-     *
-     * ~~~
-     *
-     * use core::rand::RngUtil;
-     *
-     * fn main() {
-     *     rng = rand::Rng();
-     *     println(rng.gen_str(8));
-     * }
-     * ~~~
      */
     fn gen_str(&self, len: uint) -> ~str;
-    /**
-     * Return a random byte string of the specified length
-     *
-     * *Example*
-     *
-     * ~~~
-     *
-     * use core::rand::RngUtil;
-     *
-     * fn main() {
-     *     rng = rand::Rng();
-     *     println(fmt!("%?",rng.gen_bytes(8)));
-     * }
-     * ~~~
-     */
+    /// Return a random byte string of the specified length
     fn gen_bytes(&self, len: uint) -> ~[u8];
-    ///
-    /**
-     * Choose an item randomly, failing if values is empty
-     *
-     * *Example*
-     *
-     * ~~~
-     *
-     * use core::rand::RngUtil;
-     *
-     * fn main() {
-     *     rng = rand::Rng();
-     *     println(fmt!("%d",rng.choose([1,2,4,8,16,32])));
-     * }
-     * ~~~
-     */
+    /// Choose an item randomly, failing if values is empty
     fn choose<T:Copy>(&self, values: &[T]) -> T;
     /// Choose Some(item) randomly, returning None if values is empty
     fn choose_option<T:Copy>(&self, values: &[T]) -> Option<T>;
     /**
      * Choose an item respecting the relative weights, failing if the sum of
      * the weights is 0
-     *
-     * *Example*
-     *
-     * ~~~
-     *
-     * use core::rand::RngUtil;
-     *
-     * fn main() {
-     *     rng = rand::Rng();
-     *     let x = [rand::Weighted {weight: 4, item: 'a'},
-     *              rand::Weighted {weight: 2, item: 'b'},
-     *              rand::Weighted {weight: 2, item: 'c'}];
-     *     println(fmt!("%c",rng.choose_weighted(x)));
-     * }
-     * ~~~
      */
     fn choose_weighted<T:Copy>(&self, v : &[Weighted<T>]) -> T;
     /**
      * Choose Some(item) respecting the relative weights, returning none if
      * the sum of the weights is 0
-     *
-     * *Example*
-     *
-     * ~~~
-     *
-     * use core::rand::RngUtil;
-     *
-     * fn main() {
-     *     rng = rand::Rng();
-     *     let x = [rand::Weighted {weight: 4, item: 'a'},
-     *              rand::Weighted {weight: 2, item: 'b'},
-     *              rand::Weighted {weight: 2, item: 'c'}];
-     *     println(fmt!("%?",rng.choose_weighted_option(x)));
-     * }
-     * ~~~
      */
     fn choose_weighted_option<T:Copy>(&self, v: &[Weighted<T>]) -> Option<T>;
     /**
      * Return a vec containing copies of the items, in order, where
      * the weight of the item determines how many copies there are
-     *
-     * *Example*
-     *
-     * ~~~
-     *
-     * use core::rand::RngUtil;
-     *
-     * fn main() {
-     *     rng = rand::Rng();
-     *     let x = [rand::Weighted {weight: 4, item: 'a'},
-     *              rand::Weighted {weight: 2, item: 'b'},
-     *              rand::Weighted {weight: 2, item: 'c'}];
-     *     println(fmt!("%?",rng.weighted_vec(x)));
-     * }
-     * ~~~
      */
     fn weighted_vec<T:Copy>(&self, v: &[Weighted<T>]) -> ~[T];
-    /**
-     * Shuffle a vec
-     *
-     * *Example*
-     *
-     * ~~~
-     *
-     * use core::rand::RngUtil;
-     *
-     * fn main() {
-     *     rng = rand::Rng();
-     *     println(fmt!("%?",rng.shuffle([1,2,3])));
-     * }
-     * ~~~
-     */
+    /// Shuffle a vec
     fn shuffle<T:Copy>(&self, values: &[T]) -> ~[T];
-    /**
-     * Shuffle a mutable vec in place
-     *
-     * *Example*
-     *
-     * ~~~
-     *
-     * use core::rand::RngUtil;
-     *
-     * fn main() {
-     *     rng = rand::Rng();
-     *     let mut y = [1,2,3];
-     *     rng.shuffle_mut(y);
-     *     println(fmt!("%?",y));
-     *     rng.shuffle_mut(y);
-     *     println(fmt!("%?",y));
-     * }
-     * ~~~
-     */
+    /// Shuffle a mutable vec in place
     fn shuffle_mut<T>(&self, values: &mut [T]);
 }
 
@@ -511,7 +337,7 @@ impl RngUtil for @Rng {
         self.next() & 1u32 == 1u32
     }
 
-    /// Return a bool with a 1-in-n chance of true
+    /// Return a bool with a 1 in n chance of true
     fn gen_weighted_bool(&self, n: uint) -> bool {
         if n == 0u {
             true