---

yaml
---
r: 55601
b: refs/heads/master
c: bd75463
h: refs/heads/master
i:
  55599: 57928bc
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: d2a81b95c3e2ccfdba0324caae531ce3528ed4e2
+refs/heads/master: bd75463839f0b52283b0806166c19eb0ffa75732
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 79a2b2eafc3c766cecec8a5f76317693bae9ed17
 refs/heads/try: 8eb2bab100b42f0ba751552d8eff00eb2134c55a

trunk/.gitignore

@@ -86,3 +86,4 @@ config.stamp
 .DS_Store
 src/etc/dl
 .settings/
+build/

trunk/doc/tutorial.md

@@ -1669,6 +1669,9 @@ do spawn {
 }
 ~~~~
 
+If you want to see the output of `debug!` statements, you will need to turn on `debug!` logging.
+To enable `debug!` logging, set the RUST_LOG environment variable to `debug` (e.g., with bash, `export RUST_LOG=debug`)
+
 ## For loops
 
 The most common way to express iteration in Rust is with a `for`

trunk/mk/rt.mk

@@ -76,7 +76,8 @@ RUNTIME_CXXS_$(1) := \
               rt/boxed_region.cpp \
               rt/arch/$$(HOST_$(1))/context.cpp \
               rt/arch/$$(HOST_$(1))/gpr.cpp \
-              rt/rust_android_dummy.cpp
+              rt/rust_android_dummy.cpp \
+              rt/rust_test_helpers.cpp
 
 RUNTIME_CS_$(1) := rt/linenoise/linenoise.c rt/linenoise/utf8.c
 

trunk/src/etc/x86.supp

@@ -654,3 +654,11 @@
    fun:_ZN5visit30visit_struct_dtor_helper_*
    ...
 }
+
+{
+   llvm-optimization-reads-uninitialized-memory-16
+   Memcheck:Cond
+   fun:_ZN7ast_map6map_fn*
+   fun:_ZN5visit30visit_struct_dtor_helper*
+   ...
+}

trunk/src/libcore/iterator.rs

@@ -22,6 +22,7 @@ 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 enumerate(self) -> EnumerateIterator<Self>;
     fn advance(&mut self, f: &fn(A) -> bool);
 }
 
@@ -42,6 +43,11 @@ impl<A, T: Iterator<A>> IteratorUtil<A> for T {
         FilterIterator{iter: self, predicate: predicate}
     }
 
+    #[inline(always)]
+    fn enumerate(self) -> EnumerateIterator<T> {
+        EnumerateIterator{iter: self, count: 0}
+    }
+
     /// A shim implementing the `for` loop iteration protocol for iterator objects
     #[inline]
     fn advance(&mut self, f: &fn(A) -> bool) {
@@ -104,3 +110,22 @@ impl<'self, A, B, T: Iterator<A>> Iterator<B> for MapIterator<'self, A, B, T> {
         }
     }
 }
+
+pub struct EnumerateIterator<T> {
+    priv iter: T,
+    priv count: uint
+}
+
+impl<A, T: Iterator<A>> Iterator<(uint, A)> for EnumerateIterator<T> {
+    #[inline]
+    fn next(&mut self) -> Option<(uint, A)> {
+        match self.iter.next() {
+            Some(a) => {
+                let ret = Some((self.count, a));
+                self.count += 1;
+                ret
+            }
+            _ => None
+        }
+    }
+}

trunk/src/libcore/num/int-template.rs

@@ -199,30 +199,6 @@ impl ops::Modulo<T,T> for T {
 impl ops::Neg<T> for T {
     fn neg(&self) -> T { -*self }
 }
-#[cfg(notest)]
-impl ops::BitOr<T,T> for T {
-    fn bitor(&self, other: &T) -> T { *self | *other }
-}
-#[cfg(notest)]
-impl ops::BitAnd<T,T> for T {
-    fn bitand(&self, other: &T) -> T { *self & *other }
-}
-#[cfg(notest)]
-impl ops::BitXor<T,T> for T {
-    fn bitxor(&self, other: &T) -> T { *self ^ *other }
-}
-#[cfg(notest)]
-impl ops::Shl<T,T> for T {
-    fn shl(&self, other: &T) -> T { *self << *other }
-}
-#[cfg(notest)]
-impl ops::Shr<T,T> for T {
-    fn shr(&self, other: &T) -> T { *self >> *other }
-}
-#[cfg(notest)]
-impl ops::Not<T> for T {
-    fn not(&self) -> T { !*self }
-}
 
 // String conversion functions and impl str -> num
 
@@ -307,16 +283,6 @@ mod tests {
     use super::inst::T;
     use prelude::*;
 
-    #[test]
-    fn test_bitwise_ops() {
-        assert!(0b1110 as T == (0b1100 as T).bitor(&(0b1010 as T)));
-        assert!(0b1000 as T == (0b1100 as T).bitand(&(0b1010 as T)));
-        assert!(0b0110 as T == (0b1100 as T).bitxor(&(0b1010 as T)));
-        assert!(0b1110 as T == (0b0111 as T).shl(&(1 as T)));
-        assert!(0b0111 as T == (0b1110 as T).shr(&(1 as T)));
-        assert!(-(0b11 as T) - (1 as T) == (0b11 as T).not());
-    }
-
     #[test]
     fn test_from_str() {
         assert!(from_str(~"0") == Some(0 as T));

trunk/src/libcore/num/uint-template.rs

@@ -164,30 +164,6 @@ impl ops::Modulo<T,T> for T {
 impl ops::Neg<T> for T {
     fn neg(&self) -> T { -*self }
 }
-#[cfg(notest)]
-impl ops::BitOr<T,T> for T {
-    fn bitor(&self, other: &T) -> T { *self | *other }
-}
-#[cfg(notest)]
-impl ops::BitAnd<T,T> for T {
-    fn bitand(&self, other: &T) -> T { *self & *other }
-}
-#[cfg(notest)]
-impl ops::BitXor<T,T> for T {
-    fn bitxor(&self, other: &T) -> T { *self ^ *other }
-}
-#[cfg(notest)]
-impl ops::Shl<T,T> for T {
-    fn shl(&self, other: &T) -> T { *self << *other }
-}
-#[cfg(notest)]
-impl ops::Shr<T,T> for T {
-    fn shr(&self, other: &T) -> T { *self >> *other }
-}
-#[cfg(notest)]
-impl ops::Not<T> for T {
-    fn not(&self) -> T { !*self }
-}
 
 // String conversion functions and impl str -> num
 
@@ -271,17 +247,6 @@ mod tests {
     use super::*;
     use super::inst::T;
     use prelude::*;
-
-    #[test]
-    fn test_bitwise_ops() {
-        assert!(0b1110 as T == (0b1100 as T).bitor(&(0b1010 as T)));
-        assert!(0b1000 as T == (0b1100 as T).bitand(&(0b1010 as T)));
-        assert!(0b0110 as T == (0b1100 as T).bitxor(&(0b1010 as T)));
-        assert!(0b1110 as T == (0b0111 as T).shl(&(1 as T)));
-        assert!(0b0111 as T == (0b1110 as T).shr(&(1 as T)));
-        assert!(max_value - (0b1011 as T) == (0b1011 as T).not());
-    }
-
     #[test]
     pub fn test_to_str() {
         assert!(to_str_radix(0 as T, 10u) == ~"0");

trunk/src/libcore/repr.rs

@@ -23,9 +23,9 @@ use io::{Writer, WriterUtil};
 use libc::c_void;
 use managed;
 use ptr;
+#[cfg(stage0)] use sys;
 use reflect;
 use reflect::{MovePtr, align};
-use sys;
 use to_str::ToStr;
 use vec::UnboxedVecRepr;
 use vec::raw::{VecRepr, SliceRepr};
@@ -479,7 +479,7 @@ impl TyVisitor for ReprVisitor {
     }
 
     #[cfg(not(stage0))]
-    fn visit_enter_enum(&self, n_variants: uint,
+    fn visit_enter_enum(&self, _n_variants: uint,
                         get_disr: extern unsafe fn(ptr: *Opaque) -> int,
                         _sz: uint, _align: uint) -> bool {
         let disr = unsafe { get_disr(transmute(self.ptr)) };

trunk/src/libcore/rt/mod.rs

@@ -32,6 +32,7 @@ macro_rules! rtdebug (
     ($( $arg:expr),+) => ( $(let _ = $arg)*; )
 )
 
+#[path = "sched/mod.rs"]
 mod sched;
 mod rtio;
 pub mod uvll;

trunk/src/libcore/rt/sched/local.rs

@@ -0,0 +1,100 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Access to the thread-local Scheduler
+
+use ptr::mut_null;
+use libc::c_void;
+use cast::transmute;
+
+use super::Scheduler;
+use tls = super::super::thread_local_storage;
+#[cfg(test)] use super::super::uvio::UvEventLoop;
+
+/// Give the Scheduler to thread-local storage
+pub fn put(sched: ~Scheduler) {
+    unsafe {
+        let key = tls_key();
+        let void_sched: *mut c_void = transmute::<~Scheduler, *mut c_void>(sched);
+        tls::set(key, void_sched);
+    }
+}
+
+/// Take ownership of the Scheduler from thread-local storage
+pub fn take() -> ~Scheduler {
+    unsafe {
+        let key = tls_key();
+        let void_sched: *mut c_void = tls::get(key);
+        assert!(void_sched.is_not_null());
+        let sched = transmute::<*mut c_void, ~Scheduler>(void_sched);
+        tls::set(key, mut_null());
+        return sched;
+    }
+}
+
+/// Borrow a mutable reference to the thread-local Scheduler
+/// # Safety Note
+/// Because this leaves the Scheduler in thread-local storage it is possible
+/// For the Scheduler pointer to be aliased
+pub unsafe fn borrow() -> &mut Scheduler {
+    unsafe {
+        let key = tls_key();
+        let mut void_sched: *mut c_void = tls::get(key);
+        assert!(void_sched.is_not_null());
+        {
+            let void_sched_ptr = &mut void_sched;
+            let sched: &mut ~Scheduler = {
+                transmute::<&mut *mut c_void, &mut ~Scheduler>(void_sched_ptr)
+            };
+            let sched: &mut Scheduler = &mut **sched;
+            return sched;
+        }
+    }
+}
+
+fn tls_key() -> tls::Key {
+    unsafe {
+        let key: *mut c_void = rust_get_sched_tls_key();
+        let key: &mut tls::Key = transmute(key);
+        return *key;
+    }
+}
+
+extern {
+    fn rust_get_sched_tls_key() -> *mut c_void;
+}
+
+#[test]
+fn thread_local_scheduler_smoke_test() {
+    let scheduler = ~UvEventLoop::new_scheduler();
+    put(scheduler);
+    let _scheduler = take();
+}
+
+#[test]
+fn thread_local_scheduler_two_instances() {
+    let scheduler = ~UvEventLoop::new_scheduler();
+    put(scheduler);
+    let _scheduler = take();
+    let scheduler = ~UvEventLoop::new_scheduler();
+    put(scheduler);
+    let _scheduler = take();
+}
+
+#[test]
+fn borrow_smoke_test() {
+    let scheduler = ~UvEventLoop::new_scheduler();
+    put(scheduler);
+    unsafe {
+        let _scheduler = borrow();
+    }
+    let _scheduler = take();
+}
+