---

yaml
---
r: 53980
b: refs/heads/dist-snap
c: 4b0f29a
h: refs/heads/master
v: v3

Author: erickt

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
 refs/heads/incoming: 44d4d6de762f3f9aae1fedcf454c66b79b3ad58d
-refs/heads/dist-snap: 63a292fd8686f56efe7836aef46709a063efab4e
+refs/heads/dist-snap: 4b0f29a4669491348e963f86de7f6ccc9d666e60
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/libcore/libc.rs

@@ -1221,8 +1221,9 @@ pub mod funcs {
         #[nolink]
         #[abi = "cdecl"]
         pub mod fcntl {
-            use libc::types::os::arch::c95::{c_int, c_char};
             pub extern {
+                use libc::types::os::arch::c95::{c_int, c_char};
+
                 #[link_name = "_open"]
                 unsafe fn open(path: *c_char, oflag: c_int, mode: c_int)
                             -> c_int;
@@ -1561,11 +1562,11 @@ pub mod funcs {
     #[cfg(target_os = "macos")]
     #[cfg(target_os = "freebsd")]
     pub mod bsd44 {
-        use libc::types::common::c95::{c_void};
-        use libc::types::os::arch::c95::{c_char, c_int, c_uint, size_t};
-
         #[abi = "cdecl"]
         pub extern {
+            use libc::types::common::c95::{c_void};
+            use libc::types::os::arch::c95::{c_char, c_int, c_uint, size_t};
+
             unsafe fn sysctl(name: *c_int, namelen: c_uint,
                       oldp: *mut c_void, oldlenp: *mut size_t,
                       newp: *c_void, newlen: size_t) -> c_int;

branches/dist-snap/src/libcore/rt/env.rs

@@ -44,4 +44,4 @@ pub fn get() -> &Environment {
 
 extern {
     fn rust_get_rt_env() -> &Environment;
-}
+}

branches/dist-snap/src/libcore/rt/sched.rs

@@ -70,7 +70,7 @@ enum CleanupJob {
 
 pub impl Scheduler {
 
-    static pub fn new(event_loop: ~EventLoopObject) -> Scheduler {
+    static fn new(event_loop: ~EventLoopObject) -> Scheduler {
         Scheduler {
             event_loop: event_loop,
             task_queue: WorkQueue::new(),
@@ -296,7 +296,7 @@ pub struct Task {
 }
 
 impl Task {
-    static pub fn new(stack_pool: &mut StackPool, start: ~fn()) -> Task {
+    static fn new(stack_pool: &mut StackPool, start: ~fn()) -> Task {
         // XXX: Putting main into a ~ so it's a thin pointer and can
         // be passed to the spawn function.  Another unfortunate
         // allocation

branches/dist-snap/src/libcore/rt/stack.rs

@@ -37,7 +37,8 @@ pub impl StackSegment {
 pub struct StackPool(());
 
 impl StackPool {
-    static pub fn new() -> StackPool { StackPool(()) }
+
+    static fn new() -> StackPool { StackPool(()) }
 
     fn take_segment(&self, min_size: uint) -> StackSegment {
         StackSegment::new(min_size)

branches/dist-snap/src/libcore/rt/thread.rs

@@ -20,7 +20,7 @@ struct Thread {
 }
 
 impl Thread {
-    static pub fn start(main: ~fn()) -> Thread {
+    static fn start(main: ~fn()) -> Thread {
         fn substart(main: &fn()) -> *raw_thread {
             unsafe { rust_raw_thread_start(&main) }
         }

branches/dist-snap/src/libcore/str.rs

@@ -1769,7 +1769,7 @@ pub pure fn char_range_at(s: &str, i: uint) -> CharRange {
     return CharRange {ch: val as char, next: i};
 }
 
-/// Pluck a character out of a string
+/// Plucks the `n`th character from the beginning of a string
 pub pure fn char_at(s: &str, i: uint) -> char {
     return char_range_at(s, i).ch;
 }
@@ -1799,6 +1799,11 @@ pure fn char_range_at_reverse(ss: &str, start: uint) -> CharRange {
     return CharRange {ch:ch, next:prev};
 }
 
+/// Plucks the `n`th character from the end of a string
+pub pure fn char_at_reverse(s: &str, i: uint) -> char {
+    char_range_at_reverse(s, i).ch
+}
+
 /**
  * Loop through a substring, char by char
  *
@@ -2274,6 +2279,7 @@ pub trait StrSlice {
     pure fn to_owned(&self) -> ~str;
     pure fn to_managed(&self) -> @str;
     pure fn char_at(&self, i: uint) -> char;
+    pure fn char_at_reverse(&self, i: uint) -> char;
     fn to_bytes(&self) -> ~[u8];
 }
 
@@ -2419,6 +2425,11 @@ impl StrSlice for &'self str {
     #[inline]
     pure fn char_at(&self, i: uint) -> char { char_at(*self, i) }
 
+    #[inline]
+    pure fn char_at_reverse(&self, i: uint) -> char {
+        char_at_reverse(*self, i)
+    }
+
     fn to_bytes(&self) -> ~[u8] { to_bytes(*self) }
 }
 
@@ -3426,6 +3437,28 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_char_at() {
+        let s = ~"ศไทย中华Việt Nam";
+        let v = ~['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
+        let mut pos = 0;
+        for v.each |ch| {
+            fail_unless!(s.char_at(pos) == *ch);
+            pos += from_char(*ch).len();
+        }
+    }
+
+    #[test]
+    fn test_char_at_reverse() {
+        let s = ~"ศไทย中华Việt Nam";
+        let v = ~['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
+        let mut pos = s.len();
+        for v.each_reverse |ch| {
+            fail_unless!(s.char_at_reverse(pos) == *ch);
+            pos -= from_char(*ch).len();
+        }
+    }
+
     #[test]
     fn test_each_char() {
         let s = ~"abc";

branches/dist-snap/src/libcore/task/rt.rs

@@ -30,7 +30,7 @@ pub type rust_task = libc::c_void;
 #[allow(non_camel_case_types)] // runtime type
 pub type rust_closure = libc::c_void;
 
-pub extern {
+extern {
     #[rust_stack]
     fn rust_task_yield(task: *rust_task) -> bool;
 

branches/dist-snap/src/libcore/vec.rs

@@ -1005,7 +1005,7 @@ pub pure fn foldl<T, U>(z: T, v: &[U], p: &fn(t: T, u: &U) -> T) -> T {
  */
 pub pure fn foldr<T, U: Copy>(v: &[T], z: U, p: &fn(t: &T, u: U) -> U) -> U {
     let mut accum = z;
-    for rev_each(v) |elt| {
+    for v.each_reverse |elt| {
         accum = p(elt, accum);
     }
     accum
@@ -1411,8 +1411,8 @@ pub pure fn eachi<T>(v: &'r [T], f: &fn(uint, v: &'r T) -> bool) {
  * Return true to continue, false to break.
  */
 #[inline(always)]
-pub pure fn rev_each<T>(v: &'r [T], blk: &fn(v: &'r T) -> bool) {
-    rev_eachi(v, |_i, v| blk(v))
+pub pure fn each_reverse<T>(v: &'r [T], blk: &fn(v: &'r T) -> bool) {
+    eachi_reverse(v, |_i, v| blk(v))
 }
 
 /**
@@ -1421,7 +1421,7 @@ pub pure fn rev_each<T>(v: &'r [T], blk: &fn(v: &'r T) -> bool) {
  * Return true to continue, false to break.
  */
 #[inline(always)]
-pub pure fn rev_eachi<T>(v: &'r [T], blk: &fn(i: uint, v: &'r T) -> bool) {
+pub pure fn eachi_reverse<T>(v: &'r [T], blk: &fn(i: uint, v: &'r T) -> bool) {
     let mut i = v.len();
     while i > 0 {
         i -= 1;
@@ -1736,6 +1736,8 @@ pub trait ImmutableVector<T> {
     pure fn initn(&self, n: uint) -> &'self [T];
     pure fn last(&self) -> &'self T;
     pure fn last_opt(&self) -> Option<&'self T>;
+    pure fn each_reverse(&self, blk: &fn(&T) -> bool);
+    pure fn eachi_reverse(&self, blk: &fn(uint, &T) -> bool);
     pure fn foldr<U: Copy>(&self, z: U, p: &fn(t: &T, u: U) -> U) -> U;
     pure fn map<U>(&self, f: &fn(t: &T) -> U) -> ~[U];
     pure fn mapi<U>(&self, f: &fn(uint, t: &T) -> U) -> ~[U];
@@ -1785,6 +1787,18 @@ impl<T> ImmutableVector<T> for &'self [T] {
     #[inline]
     pure fn last_opt(&self) -> Option<&'self T> { last_opt(*self) }
 
+    /// Iterates over a vector's elements in reverse.
+    #[inline]
+    pure fn each_reverse(&self, blk: &fn(&T) -> bool) {
+        each_reverse(*self, blk)
+    }
+
+    /// Iterates over a vector's elements and indices in reverse.
+    #[inline]
+    pure fn eachi_reverse(&self, blk: &fn(uint, &T) -> bool) {
+        eachi_reverse(*self, blk)
+    }
+
     /// Reduce a vector from right to left
     #[inline]
     pure fn foldr<U:Copy>(&self, z: U, p: &fn(t: &T, u: U) -> U) -> U {
@@ -3131,33 +3145,42 @@ mod tests {
     }
 
     #[test]
-    fn test_reach_empty() {
-        for rev_each::<int>(~[]) |_v| {
+    fn test_each_reverse_empty() {
+        let v: ~[int] = ~[];
+        for v.each_reverse |_v| {
             fail!(); // should never execute
         }
     }
 
     #[test]
-    fn test_reach_nonempty() {
+    fn test_each_reverse_nonempty() {
         let mut i = 0;
-        for rev_each(~[1, 2, 3]) |v| {
+        for each_reverse(~[1, 2, 3]) |v| {
             if i == 0 { fail_unless!(*v == 3); }
             i += *v
         }
         fail_unless!(i == 6);
     }
 
     #[test]
-    fn test_reachi() {
+    fn test_eachi_reverse() {
         let mut i = 0;
-        for rev_eachi(~[0, 1, 2]) |j, v| {
+        for eachi_reverse(~[0, 1, 2]) |j, v| {
             if i == 0 { fail_unless!(*v == 2); }
             fail_unless!(j == *v as uint);
             i += *v;
         }
         fail_unless!(i == 3);
     }
 
+    #[test]
+    fn test_eachi_reverse_empty() {
+        let v: ~[int] = ~[];
+        for v.eachi_reverse |_i, _v| {
+            fail!(); // should never execute
+        }
+    }
+
     #[test]
     fn test_each_permutation() {
         let mut results: ~[~[int]];