---

yaml
---
r: 56218
b: refs/heads/auto
c: 24fb719
h: refs/heads/master
v: v3

Author: bors

[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: 19cc352302838dd379c0d4a335a093fbfd0df64b
+refs/heads/auto: 24fb719b8c0cf5c508799f50fefdf3d7a8cf0ed7
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c

branches/auto/src/libcore/io.rs

@@ -176,7 +176,7 @@ pub trait ReaderUtil {
     fn read_bytes(&self, len: uint) -> ~[u8];
 
     /**
-    * Reads up until a specific byte is seen or EOF.
+    * Reads up until a specific character or EOF.
     *
     * The `include` parameter specifies if the character should be included
     * in the returned string.
@@ -185,7 +185,7 @@ pub trait ReaderUtil {
     *
     * None right now.
     */
-    fn read_until(&self, c: u8, include: bool) -> ~str;
+    fn read_until(&self, c: char, include: bool) -> ~str;
 
     /**
     * Reads up until the first '\n' or EOF.
@@ -577,7 +577,7 @@ impl<T:Reader> ReaderUtil for T {
         bytes
     }
 
-    fn read_until(&self, c: u8, include: bool) -> ~str {
+    fn read_until(&self, c: char, include: bool) -> ~str {
         let mut bytes = ~[];
         loop {
             let ch = self.read_byte();
@@ -593,7 +593,7 @@ impl<T:Reader> ReaderUtil for T {
     }
 
     fn read_line(&self) -> ~str {
-        self.read_until('\n' as u8, false)
+        self.read_until('\n', false)
     }
 
     fn read_chars(&self, n: uint) -> ~[char] {
@@ -667,7 +667,7 @@ impl<T:Reader> ReaderUtil for T {
     }
 
     fn read_c_str(&self) -> ~str {
-        self.read_until(0u8, false)
+        self.read_until(0 as char, false)
     }
 
     fn read_whole_stream(&self) -> ~[u8] {
@@ -693,7 +693,7 @@ impl<T:Reader> ReaderUtil for T {
             // include the \n, so that we can distinguish an entirely empty
             // line read after "...\n", and the trailing empty line in
             // "...\n\n".
-            let mut line = self.read_until('\n' as u8, true);
+            let mut line = self.read_until('\n', true);
 
             // blank line at the end of the reader is ignored
             if self.eof() && line.is_empty() { break; }

branches/auto/src/libcore/str.rs

@@ -24,6 +24,7 @@ use clone::Clone;
 use cmp::{TotalOrd, Ordering, Less, Equal, Greater};
 use libc;
 use option::{None, Option, Some};
+use iterator::Iterator;
 use ptr;
 use str;
 use u8;
@@ -2358,6 +2359,10 @@ pub trait StrSlice<'self> {
     fn any(&self, it: &fn(char) -> bool) -> bool;
     fn contains<'a>(&self, needle: &'a str) -> bool;
     fn contains_char(&self, needle: char) -> bool;
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    #[cfg(stage3)]
+    fn char_iter(&self) -> StrCharIterator<'self>;
     fn each(&self, it: &fn(u8) -> bool);
     fn eachi(&self, it: &fn(uint, u8) -> bool);
     fn each_reverse(&self, it: &fn(u8) -> bool);
@@ -2419,6 +2424,18 @@ impl<'self> StrSlice<'self> for &'self str {
     fn contains_char(&self, needle: char) -> bool {
         contains_char(*self, needle)
     }
+
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    #[cfg(stage3)]
+    #[inline]
+    fn char_iter(&self) -> StrCharIterator<'self> {
+        StrCharIterator {
+            index: 0,
+            string: *self
+        }
+    }
+
     /// Iterate over the bytes in a string
     #[inline]
     fn each(&self, it: &fn(u8) -> bool) { each(*self, it) }
@@ -2609,6 +2626,30 @@ impl Clone for ~str {
     }
 }
 
+#[cfg(stage1)]
+#[cfg(stage2)]
+#[cfg(stage3)]
+pub struct StrCharIterator<'self> {
+    priv index: uint,
+    priv string: &'self str,
+}
+
+#[cfg(stage1)]
+#[cfg(stage2)]
+#[cfg(stage3)]
+impl<'self> Iterator<char> for StrCharIterator<'self> {
+    #[inline]
+    fn next(&mut self) -> Option<char> {
+        if self.index < self.string.len() {
+            let CharRange {ch, next} = char_range_at(self.string, self.index);
+            self.index = next;
+            Some(ch)
+        } else {
+            None
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use char;
@@ -3901,4 +3942,19 @@ mod tests {
         assert!(char_range_at_reverse("abc", 0).next == 0);
     }
 
+    #[test]
+    fn test_iterator() {
+        use iterator::*;
+        let s = ~"ศไทย中华Việt Nam";
+        let v = ~['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
+
+        let mut pos = 0;
+        let mut it = s.char_iter();
+
+        for it.advance |c| {
+            assert_eq!(c, v[pos]);
+            pos += 1;
+        }
+        assert_eq!(pos, v.len());
+    }
 }

branches/auto/src/libcore/task/mod.rs

@@ -466,8 +466,9 @@ pub fn spawn_unlinked(f: ~fn()) {
 
 pub fn spawn_supervised(f: ~fn()) {
     /*!
-     * Creates a child task unlinked from the current one. If either this
-     * task or the child task fails, the other will not be killed.
+     * Creates a child task supervised by the current one. If the child
+     * task fails, the parent will not be killed, but if the parent fails,
+     * the child will be killed.
      */
 
     task().supervised().spawn(f)

branches/auto/src/libstd/workcache.rs

@@ -1,4 +1,4 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -30,11 +30,12 @@ use core::to_bytes;
 
 /**
 *
-* This is a loose clone of the fbuild build system, made a touch more
-* generic (not wired to special cases on files) and much less metaprogram-y
-* due to rust's comparative weakness there, relative to python.
+* This is a loose clone of the [fbuild build system](https://github.com/felix-lang/fbuild),
+* made a touch more generic (not wired to special cases on files) and much
+* less metaprogram-y due to rust's comparative weakness there, relative to
+* python.
 *
-* It's based around _imperative bulids_ that happen to have some function
+* It's based around _imperative builds_ that happen to have some function
 * calls cached. That is, it's _just_ a mechanism for describing cached
 * functions. This makes it much simpler and smaller than a "build system"
 * that produces an IR and evaluates it. The evaluation order is normal
@@ -54,7 +55,7 @@ use core::to_bytes;
 * Works are conceptually single units, but we store them most of the time
 * in maps of the form (type,name) => value. These are WorkMaps.
 *
-* A cached function divides the works it's interested up into inputs and
+* A cached function divides the works it's interested in into inputs and
 * outputs, and subdivides those into declared (input) works and
 * discovered (input and output) works.
 *

branches/auto/src/rt/rust_exchange_alloc.cpp

@@ -48,8 +48,8 @@ rust_get_exchange_count_ptr() {
 void
 rust_check_exchange_count_on_exit() {
   if (exchange_count != 0) {
-    printf("exchange heap not empty on on exit");
-    printf("%d dangling allocations", (int)exchange_count);
+    printf("exchange heap not empty on exit\n");
+    printf("%d dangling allocations\n", (int)exchange_count);
     abort();
   }
 }