---

yaml
---
r: 65037
b: refs/heads/master
c: a10974d
h: refs/heads/master
i:
  65035: 91a3569
v: v3

Author: brendanzab

[refs]

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

trunk/mk/platform.mk

@@ -239,32 +239,6 @@ CFG_RUN_arm-linux-androideabi=
 CFG_RUN_TARG_arm-linux-androideabi=
 RUSTC_FLAGS_arm-linux-androideabi :=--android-cross-path=$(CFG_ANDROID_CROSS_PATH)
 
-# arm-unknown-linux-gnueabihf configuration
-CC_arm-unknown-linux-gnueabihf=arm-linux-gnueabihf-gcc
-CXX_arm-unknown-linux-gnueabihf=arm-linux-gnueabihf-g++
-CPP_arm-unknown-linux-gnueabihf=arm-linux-gnueabihf-gcc -E
-AR_arm-unknown-linux-gnueabihf=arm-linux-gnueabihf-ar
-CFG_LIB_NAME_arm-unknown-linux-gnueabihf=lib$(1).so
-CFG_LIB_GLOB_arm-unknown-linux-gnueabihf=lib$(1)-*.so
-CFG_LIB_DSYM_GLOB_arm-unknown-linux-gnueabihf=lib$(1)-*.dylib.dSYM
-CFG_GCCISH_CFLAGS_arm-unknown-linux-gnueabihf := -Wall -g -fPIC
-CFG_GCCISH_CXXFLAGS_arm-unknown-linux-gnueabihf := -fno-rtti
-CFG_GCCISH_LINK_FLAGS_arm-unknown-linux-gnueabihf := -shared -fPIC -g
-CFG_GCCISH_DEF_FLAG_arm-unknown-linux-gnueabihf := -Wl,--export-dynamic,--dynamic-list=
-CFG_GCCISH_PRE_LIB_FLAGS_arm-unknown-linux-gnueabihf := -Wl,-whole-archive
-CFG_GCCISH_POST_LIB_FLAGS_arm-unknown-linux-gnueabihf := -Wl,-no-whole-archive
-CFG_DEF_SUFFIX_arm-unknown-linux-gnueabihf := .linux.def
-CFG_INSTALL_NAME_ar,-unknown-linux-gnueabihf =
-CFG_LIBUV_LINK_FLAGS_arm-unknown-linux-gnueabihf =
-CFG_EXE_SUFFIX_arm-unknown-linux-gnueabihf :=
-CFG_WINDOWSY_arm-unknown-linux-gnueabihf :=
-CFG_UNIXY_arm-unknown-linux-gnueabihf := 1
-CFG_PATH_MUNGE_arm-unknown-linux-gnueabihf := true
-CFG_LDPATH_arm-unknown-linux-gnueabihf :=
-CFG_RUN_arm-unknown-linux-gnueabihf=
-CFG_RUN_TARG_arm-unknown-linux-gnueabihf=
-RUSTC_FLAGS_arm-unknown-linux-gnueabihf := --linker=$(CC_arm-unknown-linux-gnueabihf)
-
 # mips-unknown-linux-gnu configuration
 CC_mips-unknown-linux-gnu=mips-linux-gnu-gcc
 CXX_mips-unknown-linux-gnu=mips-linux-gnu-g++

trunk/mk/rt.mk

@@ -26,11 +26,7 @@
 # Hack for passing flags into LIBUV, see below.
 LIBUV_FLAGS_i386 = -m32 -fPIC
 LIBUV_FLAGS_x86_64 = -m64 -fPIC
-ifeq ($(OSTYPE_$(1)), linux-androideabi)
 LIBUV_FLAGS_arm = -fPIC -DANDROID -std=gnu99
-else
-LIBUV_FLAGS_arm = -fPIC -std=gnu99
-endif
 LIBUV_FLAGS_mips = -fPIC -mips32r2 -msoft-float -mabi=32
 
 # when we're doing a snapshot build, we intentionally degrade as many

trunk/src/libcore/iterator.rs

@@ -18,7 +18,6 @@ implementing the `Iterator` trait.
 */
 
 use prelude::*;
-use num::{Zero, One};
 
 pub trait Iterator<A> {
     /// Advance the iterator and return the next value. Return `None` when the end is reached.
@@ -35,7 +34,6 @@ pub trait IteratorUtil<A> {
     // FIXME: #5898: should be called map
     fn transform<'r, B>(self, f: &'r fn(A) -> B) -> MapIterator<'r, A, B, Self>;
     fn filter<'r>(self, predicate: &'r fn(&A) -> bool) -> FilterIterator<'r, A, Self>;
-    fn filter_map<'r,  B>(self, f: &'r fn(A) -> Option<B>) -> FilterMapIterator<'r, A, B, Self>;
     fn enumerate(self) -> EnumerateIterator<Self>;
     fn skip_while<'r>(self, predicate: &'r fn(&A) -> bool) -> SkipWhileIterator<'r, A, Self>;
     fn take_while<'r>(self, predicate: &'r fn(&A) -> bool) -> TakeWhileIterator<'r, A, Self>;
@@ -47,14 +45,6 @@ pub trait IteratorUtil<A> {
     fn advance(&mut self, f: &fn(A) -> bool);
     #[cfg(not(stage0))]
     fn advance(&mut self, f: &fn(A) -> bool) -> bool;
-    fn to_vec(self) -> ~[A];
-    fn nth(&mut self, n: uint) -> A;
-    fn first(&mut self) -> A;
-    fn last(&mut self) -> A;
-    fn fold<B>(&mut self, start: B, f: &fn(B, A) -> B) -> B;
-    fn count(&mut self) -> uint;
-    fn all(&mut self, f: &fn(&A) -> bool) -> bool;
-    fn any(&mut self, f: &fn(&A) -> bool) -> bool;
 }
 
 /// Iterator adaptors provided for every `Iterator` implementation. The adaptor objects are also
@@ -83,11 +73,6 @@ impl<A, T: Iterator<A>> IteratorUtil<A> for T {
         FilterIterator{iter: self, predicate: predicate}
     }
 
-    #[inline(always)]
-    fn filter_map<'r, B>(self, f: &'r fn(A) -> Option<B>) -> FilterMapIterator<'r, A, B, T> {
-        FilterMapIterator { iter: self, f: f }
-    }
-
     #[inline(always)]
     fn enumerate(self) -> EnumerateIterator<T> {
         EnumerateIterator{iter: self, count: 0}
@@ -146,123 +131,6 @@ impl<A, T: Iterator<A>> IteratorUtil<A> for T {
             }
         }
     }
-
-    #[inline(always)]
-    fn to_vec(self) -> ~[A] {
-        let mut v = ~[];
-        let mut it = self;
-        for it.advance() |x| { v.push(x); }
-        return v;
-    }
-
-    /// Get `n`th element of an iterator.
-    #[inline(always)]
-    fn nth(&mut self, n: uint) -> A {
-        let mut i = n;
-        loop {
-            match self.next() {
-                Some(x) => { if i == 0 { return x; }}
-                None => { fail!("cannot get %uth element", n) }
-            }
-            i -= 1;
-        }
-    }
-
-    // Get first elemet of an iterator.
-    #[inline(always)]
-    fn first(&mut self) -> A {
-        match self.next() {
-            Some(x) => x ,
-            None => fail!("cannot get first element")
-        }
-    }
-
-    // Get last element of an iterator.
-    //
-    // If the iterator have an infinite length, this method won't return.
-    #[inline(always)]
-    fn last(&mut self) -> A {
-        let mut elm = match self.next() {
-            Some(x) => x,
-            None    => fail!("cannot get last element")
-        };
-        for self.advance |e| { elm = e; }
-        return elm;
-    }
-
-    /// Reduce an iterator to an accumulated value
-    #[inline]
-    fn fold<B>(&mut self, init: B, f: &fn(B, A) -> B) -> B {
-        let mut accum = init;
-        loop {
-            match self.next() {
-                Some(x) => { accum = f(accum, x); }
-                None    => { break; }
-            }
-        }
-        return accum;
-    }
-
-    /// Count the number of an iterator elemenrs
-    #[inline(always)]
-    fn count(&mut self) -> uint { self.fold(0, |cnt, _x| cnt + 1) }
-
-    #[inline(always)]
-    fn all(&mut self, f: &fn(&A) -> bool) -> bool {
-        for self.advance |x| { if !f(&x) { return false; } }
-        return true;
-    }
-
-    #[inline(always)]
-    fn any(&mut self, f: &fn(&A) -> bool) -> bool {
-        for self.advance |x| { if f(&x) { return true; } }
-        return false;
-    }
-}
-
-pub trait AdditiveIterator<A> {
-    fn sum(&mut self) -> A;
-}
-
-impl<A: Add<A, A> + Zero, T: Iterator<A>> AdditiveIterator<A> for T {
-    #[inline(always)]
-    fn sum(&mut self) -> A { self.fold(Zero::zero::<A>(), |s, x| s + x) }
-}
-
-pub trait MultiplicativeIterator<A> {
-    fn product(&mut self) -> A;
-}
-
-impl<A: Mul<A, A> + One, T: Iterator<A>> MultiplicativeIterator<A> for T {
-    #[inline(always)]
-    fn product(&mut self) -> A { self.fold(One::one::<A>(), |p, x| p * x) }
-}
-
-pub trait OrdIterator<A> {
-    fn max(&mut self) -> Option<A>;
-    fn min(&mut self) -> Option<A>;
-}
-
-impl<A: Ord, T: Iterator<A>> OrdIterator<A> for T {
-    #[inline(always)]
-    fn max(&mut self) -> Option<A> {
-        self.fold(None, |max, x| {
-            match max {
-                None    => Some(x),
-                Some(y) => Some(cmp::max(x, y))
-            }
-        })
-    }
-
-    #[inline(always)]
-    fn min(&mut self) -> Option<A> {
-        self.fold(None, |min, x| {
-            match min {
-                None    => Some(x),
-                Some(y) => Some(cmp::min(x, y))
-            }
-        })
-    }
 }
 
 pub struct ChainIterator<T, U> {
@@ -336,28 +204,6 @@ impl<'self, A, T: Iterator<A>> Iterator<A> for FilterIterator<'self, A, T> {
     }
 }
 
-pub struct FilterMapIterator<'self, A, B, T> {
-    priv iter: T,
-    priv f: &'self fn(A) -> Option<B>
-}
-
-impl<'self, A, B, T: Iterator<A>> Iterator<B> for FilterMapIterator<'self, A, B, T> {
-    #[inline]
-    fn next(&mut self) -> Option<B> {
-        loop {
-            match self.iter.next() {
-                None    => { return None; }
-                Some(a) => {
-                    match (self.f)(a) {
-                        Some(b) => { return Some(b); }
-                        None    => { loop; }
-                    }
-                }
-            }
-        }
-    }
-}
-
 pub struct EnumerateIterator<T> {
     priv iter: T,
     priv count: uint
@@ -577,13 +423,6 @@ mod tests {
         assert_eq!(i, expected.len());
     }
 
-    #[test]
-    fn test_filter_map() {
-        let it  = Counter::new(0u, 1u).take(10)
-            .filter_map(|x: uint| if x.is_even() { Some(x*x) } else { None });
-        assert_eq!(it.to_vec(), ~[0*0, 2*2, 4*4, 6*6, 8*8]);
-    }
-
     #[test]
     fn test_iterator_enumerate() {
         let xs = [0u, 1, 2, 3, 4, 5];
@@ -684,105 +523,4 @@ mod tests {
         }
         assert_eq!(i, 10);
     }
-
-    #[test]
-    fn test_iterator_nth() {
-        let v = &[0, 1, 2, 3, 4];
-        for uint::range(0, v.len()) |i| {
-            assert_eq!(v.iter().nth(i), &v[i]);
-        }
-    }
-
-    #[test]
-    #[should_fail]
-    fn test_iterator_nth_fail() {
-        let v = &[0, 1, 2, 3, 4];
-        v.iter().nth(5);
-    }
-
-    #[test]
-    fn test_iterator_first() {
-        let v = &[0, 1, 2, 3, 4];
-        assert_eq!(v.iter().first(), &0);
-        assert_eq!(v.slice(2, 5).iter().first(), &2);
-    }
-
-    #[test]
-    #[should_fail]
-    fn test_iterator_first_fail() {
-        let v: &[uint] = &[];
-        v.iter().first();
-    }
-
-    #[test]
-    fn test_iterator_last() {
-        let v = &[0, 1, 2, 3, 4];
-        assert_eq!(v.iter().last(), &4);
-        assert_eq!(v.slice(0, 1).iter().last(), &0);
-    }
-
-    #[test]
-    #[should_fail]
-    fn test_iterator_last_fail() {
-        let v: &[uint] = &[];
-        v.iter().last();
-    }
-
-    #[test]
-    fn test_iterator_count() {
-        let v = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-        assert_eq!(v.slice(0, 4).iter().count(), 4);
-        assert_eq!(v.slice(0, 10).iter().count(), 10);
-        assert_eq!(v.slice(0, 0).iter().count(), 0);
-    }
-
-    #[test]
-    fn test_iterator_sum() {
-        let v = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-        assert_eq!(v.slice(0, 4).iter().transform(|&x| x).sum(), 6);
-        assert_eq!(v.iter().transform(|&x| x).sum(), 55);
-        assert_eq!(v.slice(0, 0).iter().transform(|&x| x).sum(), 0);
-    }
-
-    #[test]
-    fn test_iterator_product() {
-        let v = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-        assert_eq!(v.slice(0, 4).iter().transform(|&x| x).product(), 0);
-        assert_eq!(v.slice(1, 5).iter().transform(|&x| x).product(), 24);
-        assert_eq!(v.slice(0, 0).iter().transform(|&x| x).product(), 1);
-    }
-
-    #[test]
-    fn test_iterator_max() {
-        let v = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-        assert_eq!(v.slice(0, 4).iter().transform(|&x| x).max(), Some(3));
-        assert_eq!(v.iter().transform(|&x| x).max(), Some(10));
-        assert_eq!(v.slice(0, 0).iter().transform(|&x| x).max(), None);
-    }
-
-    #[test]
-    fn test_iterator_min() {
-        let v = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-        assert_eq!(v.slice(0, 4).iter().transform(|&x| x).min(), Some(0));
-        assert_eq!(v.iter().transform(|&x| x).min(), Some(0));
-        assert_eq!(v.slice(0, 0).iter().transform(|&x| x).min(), None);
-    }
-
-    #[test]
-    fn test_all() {
-        let v = ~&[1, 2, 3, 4, 5];
-        assert!(v.iter().all(|&x| *x < 10));
-        assert!(!v.iter().all(|&x| x.is_even()));
-        assert!(!v.iter().all(|&x| *x > 100));
-        assert!(v.slice(0, 0).iter().all(|_| fail!()));
-    }
-
-    #[test]
-    fn test_any() {
-        let v = ~&[1, 2, 3, 4, 5];
-        assert!(v.iter().any(|&x| *x < 10));
-        assert!(v.iter().any(|&x| x.is_even()));
-        assert!(!v.iter().any(|&x| *x > 100));
-        assert!(!v.slice(0, 0).iter().any(|_| fail!()));
-    }
 }

trunk/src/libcore/num/f32.rs

@@ -248,15 +248,27 @@ impl Orderable for f32 {
         if self.is_NaN() || other.is_NaN() { Float::NaN() } else { fmax(*self, *other) }
     }
 
-    /// Returns the number constrained within the range `mn <= self <= mx`.
-    /// If any of the numbers are `NaN` then `NaN` is returned.
+    #[cfg(stage0)]
     #[inline(always)]
     fn clamp(&self, mn: &f32, mx: &f32) -> f32 {
         if self.is_NaN() { *self }
         else if !(*self <= *mx) { *mx }
         else if !(*self >= *mn) { *mn }
         else { *self }
     }
+
+    /// Returns the number constrained within the range `mn <= self <= mx`.
+    /// If any of the numbers are `NaN` then `NaN` is returned.
+    #[cfg(not(stage0))]
+    #[inline(always)]
+    fn clamp(&self, mn: &f32, mx: &f32) -> f32 {
+        cond!(
+            (self.is_NaN())   { *self }
+            (!(*self <= *mx)) { *mx   }
+            (!(*self >= *mn)) { *mn   }
+            _                 { *self }
+        )
+    }
 }
 
 impl Zero for f32 {