---

yaml
---
r: 127287
b: refs/heads/try
c: d320235
h: refs/heads/master
i:
  127285: 013954d
  127283: 41a664d
  127279: b945e77
v: v3

Author: pnkfelix

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 87d2bf400ce1bc2cec832f9d5b8e763f06bb7f43
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 12e0f72f517516ac4fce2aed85e6142e9b874bce
-refs/heads/try: 8fe73f1166c0d3765cabb26680b82175ec4429cd
+refs/heads/try: d3202354f5fe3860c429adc4bab6e6dc88ee83bc
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/mk/platform.mk

@@ -377,7 +377,7 @@ RUSTC_CROSS_FLAGS_arm-unknown-linux-gnueabi :=
 # mipsel-linux configuration
 CC_mipsel-linux=mipsel-linux-gcc
 CXX_mipsel-linux=mipsel-linux-g++
-CPP_mipsel-linux=mipsel-linux-gcc
+CPP_mipsel-linux=mipsel-linux-gcc 
 AR_mipsel-linux=mipsel-linux-ar
 CFG_LIB_NAME_mipsel-linux=lib$(1).so
 CFG_STATIC_LIB_NAME_mipsel-linux=lib$(1).a
@@ -641,7 +641,7 @@ define CFG_MAKE_TOOLCHAIN
 	CXX_$(1)=$(CROSS_PREFIX_$(1))$(CXX_$(1))
 	CPP_$(1)=$(CROSS_PREFIX_$(1))$(CPP_$(1))
 	AR_$(1)=$(CROSS_PREFIX_$(1))$(AR_$(1))
-	RUSTC_CROSS_FLAGS_$(1)=-C linker=$$(call FIND_COMPILER,$$(CC_$(1))) \
+	RUSTC_CROSS_FLAGS_$(1)=-C linker=$$(call FIND_COMPILER,$$(CXX_$(1))) \
 	    -C ar=$$(call FIND_COMPILER,$$(AR_$(1))) $(RUSTC_CROSS_FLAGS_$(1))
 
 	RUSTC_FLAGS_$(1)=$$(RUSTC_CROSS_FLAGS_$(1)) $(RUSTC_FLAGS_$(1))

branches/try/src/doc/guide.md

@@ -3295,7 +3295,7 @@ fn times_four(x: int) -> int { x * 4 }
 #[cfg(test)]
 mod test {
     use super::add_three;
-    use super::times_four;
+    use super::add_four;
 
     #[test]
     fn test_add_three() {
@@ -3344,7 +3344,7 @@ about yet, and that's these lines:
 
 ```{rust,ignore}
 use super::add_three;
-use super::times_four;
+use super::add_four;
 ```
 
 Because we've made a nested module, we can import functions from the parent

branches/try/src/etc/ctags.rust

@@ -7,5 +7,5 @@
 --regex-Rust=/^[ \t]*(pub[ \t]+)?mod[ \t]+([a-zA-Z0-9_]+)/\2/m,modules,module names/
 --regex-Rust=/^[ \t]*(pub[ \t]+)?static[ \t]+([a-zA-Z0-9_]+)/\2/c,consts,static constants/
 --regex-Rust=/^[ \t]*(pub[ \t]+)?trait[ \t]+([a-zA-Z0-9_]+)/\2/t,traits,traits/
---regex-Rust=/^[ \t]*(pub[ \t]+)?impl([ \t\n]*<[^>]*>)?[ \t]+(([a-zA-Z0-9_:]+)[ \t]*(<[^>]*>)?[ \t]+(for)[ \t]+)?([a-zA-Z0-9_]+)/\4 \6 \7/i,impls,trait implementations/
+--regex-Rust=/^[ \t]*(pub[ \t]+)?impl([ \t\n]+<.*>)?[ \t]+([a-zA-Z0-9_]+)/\3/i,impls,trait implementations/
 --regex-Rust=/^[ \t]*macro_rules![ \t]+([a-zA-Z0-9_]+)/\1/d,macros,macro definitions/

branches/try/src/etc/gedit/share/gtksourceview-3.0/language-specs/rust.lang

@@ -266,7 +266,7 @@
 
     <define-regex id="common_escape" extended="true">
       '|"|
-      \\|n|r|t|0|
+      \\|n|r|t|
       x\%{hex_digit}{2}|
       u\%{hex_digit}{4}|
       U\%{hex_digit}{8}

branches/try/src/etc/get-snapshot.py

@@ -53,7 +53,7 @@ def unpack_snapshot(triple, dl_path):
   dl_path = sys.argv[2]
 else:
   # There are no 64-bit Windows snapshots yet, so we'll use 32-bit ones instead, for now
-  snap_triple = triple if triple != "x86_64-w64-mingw32" else "i686-w64-mingw32"
+  snap_triple = triple if triple != "x86_64-w64-mingw32" else "i686-pc-mingw32"
   snap = determine_curr_snapshot(snap_triple)
   dl = os.path.join(download_dir_base, snap)
   url = download_url_base + "/" + snap

branches/try/src/libcollections/str.rs

@@ -1457,7 +1457,7 @@ mod tests {
             109
         ];
         assert_eq!("".as_bytes(), &[]);
-        assert_eq!("abc".as_bytes(), b"abc");
+        assert_eq!("abc".as_bytes(), &['a' as u8, 'b' as u8, 'c' as u8]);
         assert_eq!("ศไทย中华Việt Nam".as_bytes(), v.as_slice());
     }
 
@@ -1475,11 +1475,11 @@ mod tests {
     fn test_as_ptr() {
         let buf = "hello".as_ptr();
         unsafe {
-            assert_eq!(*buf.offset(0), b'h');
-            assert_eq!(*buf.offset(1), b'e');
-            assert_eq!(*buf.offset(2), b'l');
-            assert_eq!(*buf.offset(3), b'l');
-            assert_eq!(*buf.offset(4), b'o');
+            assert_eq!(*buf.offset(0), 'h' as u8);
+            assert_eq!(*buf.offset(1), 'e' as u8);
+            assert_eq!(*buf.offset(2), 'l' as u8);
+            assert_eq!(*buf.offset(3), 'l' as u8);
+            assert_eq!(*buf.offset(4), 'o' as u8);
         }
     }
 

branches/try/src/libcollections/string.rs

@@ -1040,7 +1040,7 @@ mod tests {
     fn test_push_bytes() {
         let mut s = String::from_str("ABC");
         unsafe {
-            s.push_bytes([b'D']);
+            s.push_bytes([ 'D' as u8 ]);
         }
         assert_eq!(s.as_slice(), "ABCD");
     }

branches/try/src/libcore/fmt/float.rs

@@ -198,11 +198,11 @@ pub fn float_to_str_bytes_common<T: Primitive + Float, U>(
     // Decide what sign to put in front
     match sign {
         SignNeg | SignAll if neg => {
-            buf[end] = b'-';
+            buf[end] = '-' as u8;
             end += 1;
         }
         SignAll => {
-            buf[end] = b'+';
+            buf[end] = '+' as u8;
             end += 1;
         }
         _ => ()
@@ -218,7 +218,7 @@ pub fn float_to_str_bytes_common<T: Primitive + Float, U>(
     // Now emit the fractional part, if any
     deccum = num.fract();
     if deccum != _0 || (limit_digits && exact && digit_count > 0) {
-        buf[end] = b'.';
+        buf[end] = '.' as u8;
         end += 1;
         let mut dig = 0u;
 
@@ -269,8 +269,8 @@ pub fn float_to_str_bytes_common<T: Primitive + Float, U>(
                     // If reached left end of number, have to
                     // insert additional digit:
                     if i < 0
-                    || buf[i as uint] == b'-'
-                    || buf[i as uint] == b'+' {
+                    || buf[i as uint] == '-' as u8
+                    || buf[i as uint] == '+' as u8 {
                         for j in range(i as uint + 1, end).rev() {
                             buf[j + 1] = buf[j];
                         }
@@ -280,7 +280,7 @@ pub fn float_to_str_bytes_common<T: Primitive + Float, U>(
                     }
 
                     // Skip the '.'
-                    if buf[i as uint] == b'.' { i -= 1; continue; }
+                    if buf[i as uint] == '.' as u8 { i -= 1; continue; }
 
                     // Either increment the digit,
                     // or set to 0 if max and carry the 1.
@@ -306,14 +306,14 @@ pub fn float_to_str_bytes_common<T: Primitive + Float, U>(
         let mut i = buf_max_i;
 
         // discover trailing zeros of fractional part
-        while i > start_fractional_digits && buf[i] == b'0' {
+        while i > start_fractional_digits && buf[i] == '0' as u8 {
             i -= 1;
         }
 
         // Only attempt to truncate digits if buf has fractional digits
         if i >= start_fractional_digits {
             // If buf ends with '.', cut that too.
-            if buf[i] == b'.' { i -= 1 }
+            if buf[i] == '.' as u8 { i -= 1 }
 
             // only resize buf if we actually remove digits
             if i < buf_max_i {
@@ -323,7 +323,7 @@ pub fn float_to_str_bytes_common<T: Primitive + Float, U>(
     } // If exact and trailing '.', just cut that
     else {
         let max_i = end - 1;
-        if buf[max_i] == b'.' {
+        if buf[max_i] == '.' as u8 {
             end = max_i;
         }
     }

branches/try/src/libcore/fmt/num.rs

@@ -104,13 +104,13 @@ macro_rules! radix {
     }
 }
 
-radix!(Binary,    2, "0b", x @  0 .. 2 => b'0' + x)
-radix!(Octal,     8, "0o", x @  0 .. 7 => b'0' + x)
-radix!(Decimal,  10, "",   x @  0 .. 9 => b'0' + x)
-radix!(LowerHex, 16, "0x", x @  0 .. 9 => b'0' + x,
-                           x @ 10 ..15 => b'a' + (x - 10))
-radix!(UpperHex, 16, "0x", x @  0 .. 9 => b'0' + x,
-                           x @ 10 ..15 => b'A' + (x - 10))
+radix!(Binary,    2, "0b", x @  0 .. 2 => '0' as u8 + x)
+radix!(Octal,     8, "0o", x @  0 .. 7 => '0' as u8 + x)
+radix!(Decimal,  10, "",   x @  0 .. 9 => '0' as u8 + x)
+radix!(LowerHex, 16, "0x", x @  0 .. 9 => '0' as u8 + x,
+                           x @ 10 ..15 => 'a' as u8 + (x - 10))
+radix!(UpperHex, 16, "0x", x @  0 .. 9 => '0' as u8 + x,
+                           x @ 10 ..15 => 'A' as u8 + (x - 10))
 
 /// A radix with in the range of `2..36`.
 #[deriving(Clone, PartialEq)]
@@ -129,8 +129,8 @@ impl GenericRadix for Radix {
     fn base(&self) -> u8 { self.base }
     fn digit(&self, x: u8) -> u8 {
         match x {
-            x @  0 ..9 => b'0' + x,
-            x if x < self.base() => b'a' + (x - 10),
+            x @  0 ..9 => '0' as u8 + x,
+            x if x < self.base() => 'a' as u8 + (x - 10),
             x => fail!("number not in the range 0..{}: {}", self.base() - 1, x),
         }
     }

branches/try/src/libcore/iter.rs

@@ -481,11 +481,13 @@ pub trait Iterator<A> {
     /// ```
     #[inline]
     fn nth(&mut self, mut n: uint) -> Option<A> {
-        for x in *self {
-            if n == 0 { return Some(x) }
+        loop {
+            match self.next() {
+                Some(x) => if n == 0 { return Some(x) },
+                None => return None
+            }
             n -= 1;
         }
-        None
     }
 
     /// Loops through the entire iterator, returning the last element of the
@@ -516,8 +518,11 @@ pub trait Iterator<A> {
     #[inline]
     fn fold<B>(&mut self, init: B, f: |B, A| -> B) -> B {
         let mut accum = init;
-        for x in *self {
-            accum = f(accum, x);
+        loop {
+            match self.next() {
+                Some(x) => { accum = f(accum, x); }
+                None    => { break; }
+            }
         }
         accum
     }
@@ -715,10 +720,21 @@ pub trait ExactSize<A> : DoubleEndedIterator<A> {
     /// If no element matches, None is returned.
     #[inline]
     fn rposition(&mut self, predicate: |A| -> bool) -> Option<uint> {
-        let len = self.len();
-        for i in range(0, len).rev() {
-            if predicate(self.next_back().expect("rposition: incorrect ExactSize")) {
-                return Some(i);
+        let (lower, upper) = self.size_hint();
+        assert!(upper == Some(lower));
+        let mut i = lower;
+        loop {
+            match self.next_back() {
+                None => break,
+                Some(x) => {
+                    i = match i.checked_sub(&1) {
+                        Some(x) => x,
+                        None => fail!("rposition: incorrect ExactSize")
+                    };
+                    if predicate(x) {
+                        return Some(i)
+                    }
+                }
             }
         }
         None
@@ -728,7 +744,7 @@ pub trait ExactSize<A> : DoubleEndedIterator<A> {
     /// Return the exact length of the iterator.
     fn len(&self) -> uint {
         let (lower, upper) = self.size_hint();
-        assert_eq!(upper, Some(lower));
+        assert!(upper == Some(lower));
         lower
     }
 }
@@ -1314,12 +1330,18 @@ impl<'a, A, T: Iterator<A>> Iterator<A> for Filter<'a, A, T> {
 impl<'a, A, T: DoubleEndedIterator<A>> DoubleEndedIterator<A> for Filter<'a, A, T> {
     #[inline]
     fn next_back(&mut self) -> Option<A> {
-        for x in self.iter.by_ref().rev() {
-            if (self.predicate)(&x) {
-                return Some(x);
+        loop {
+            match self.iter.next_back() {
+                None => return None,
+                Some(x) => {
+                    if (self.predicate)(&x) {
+                        return Some(x);
+                    } else {
+                        continue
+                    }
+                }
             }
         }
-        None
     }
 }
 
@@ -1353,13 +1375,17 @@ impl<'a, A, B, T: DoubleEndedIterator<A>> DoubleEndedIterator<B>
 for FilterMap<'a, A, B, T> {
     #[inline]
     fn next_back(&mut self) -> Option<B> {
-        for x in self.iter.by_ref().rev() {
-            match (self.f)(x) {
-                Some(y) => return Some(y),
-                None => ()
+        loop {
+            match self.iter.next_back() {
+                None => return None,
+                Some(x) => {
+                    match (self.f)(x) {
+                        Some(y) => return Some(y),
+                        None => ()
+                    }
+                }
             }
         }
-        None
     }
 }
 
@@ -1481,13 +1507,25 @@ pub struct SkipWhile<'a, A, T> {
 impl<'a, A, T: Iterator<A>> Iterator<A> for SkipWhile<'a, A, T> {
     #[inline]
     fn next(&mut self) -> Option<A> {
-        for x in self.iter {
-            if self.flag || !(self.predicate)(&x) {
-                self.flag = true;
-                return Some(x);
+        let mut next = self.iter.next();
+        if self.flag {
+            next
+        } else {
+            loop {
+                match next {
+                    Some(x) => {
+                        if (self.predicate)(&x) {
+                            next = self.iter.next();
+                            continue
+                        } else {
+                            self.flag = true;
+                            return Some(x)
+                        }
+                    }
+                    None => return None
+                }
             }
         }
-        None
     }
 
     #[inline]

branches/try/src/libcore/kinds.rs

@@ -125,7 +125,7 @@ pub mod marker {
     ///
     /// The type system would currently infer that the value of
     /// the type parameter `T` is irrelevant, and hence a `S<int>` is
-    /// a subtype of `S<Box<int>>` (or, for that matter, `S<U>` for
+    /// a subtype of `S<~[int]>` (or, for that matter, `S<U>` for
     /// any `U`). But this is incorrect because `get()` converts the
     /// `*()` into a `*T` and reads from it. Therefore, we should include the
     /// a marker field `CovariantType<T>` to inform the type checker that
@@ -166,7 +166,7 @@ pub mod marker {
     ///
     /// The type system would currently infer that the value of
     /// the type parameter `T` is irrelevant, and hence a `S<int>` is
-    /// a subtype of `S<Box<int>>` (or, for that matter, `S<U>` for
+    /// a subtype of `S<~[int]>` (or, for that matter, `S<U>` for
     /// any `U`). But this is incorrect because `get()` converts the
     /// `*()` into a `fn(T)` and then passes a value of type `T` to it.
     ///

branches/try/src/libcore/str.rs

@@ -1755,7 +1755,7 @@ impl<'a> StrSlice<'a> for &'a str {
     fn lines_any(&self) -> AnyLines<'a> {
         self.lines().map(|line| {
             let l = line.len();
-            if l > 0 && line.as_bytes()[l - 1] == b'\r' { line.slice(0, l - 1) }
+            if l > 0 && line.as_bytes()[l - 1] == '\r' as u8 { line.slice(0, l - 1) }
             else { line }
         })
     }