---

yaml
---
r: 64606
b: refs/heads/snap-stage3
c: 3169bb7
h: refs/heads/master
v: v3

Author: olsonjeffery

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 46394758aa7cc9a2532662cb29d3acfc382e4e18
+refs/heads/snap-stage3: 3169bb70d8bef4fea776916f900bf9e407e6469c
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/compiletest/runtest.rs

@@ -681,7 +681,7 @@ fn make_out_name(config: &config, testfile: &Path, extension: &str) -> Path {
 }
 
 fn aux_output_dir_name(config: &config, testfile: &Path) -> Path {
-    Path(output_base_name(config, testfile).to_str() + ".libaux")
+    output_base_name(config, testfile).with_filetype("libaux")
 }
 
 fn output_testname(testfile: &Path) -> Path {

branches/snap-stage3/src/libstd/rt/io/mod.rs

@@ -252,6 +252,7 @@ pub use self::stdio::print;
 pub use self::stdio::println;
 
 pub use self::file::FileStream;
+pub use self::timer::Timer;
 pub use self::net::ip::IpAddr;
 pub use self::net::tcp::TcpListener;
 pub use self::net::tcp::TcpStream;
@@ -296,6 +297,9 @@ mod extensions;
 /// Non-I/O things needed by the I/O module
 mod support;
 
+/// Basic Timer
+pub mod timer;
+
 /// Thread-blocking implementations
 pub mod native {
     /// Posix file I/O

branches/snap-stage3/src/libstd/rt/io/timer.rs

@@ -0,0 +1,64 @@
+// 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.
+
+use option::{Option, Some, None};
+use result::{Ok, Err};
+use rt::io::{io_error};
+use rt::rtio::{IoFactory, IoFactoryObject,
+               RtioTimer, RtioTimerObject};
+use rt::local::Local;
+
+pub struct Timer(~RtioTimerObject);
+
+impl Timer {
+    fn new_on_rt(i: ~RtioTimerObject) -> Timer {
+        Timer(i)
+    }
+
+    pub fn new() -> Option<Timer> {
+        let timer = unsafe {
+            rtdebug!("Timer::init: borrowing io to init timer");
+            let io = Local::unsafe_borrow::<IoFactoryObject>();
+            rtdebug!("about to init timer");
+            (*io).timer_init()
+        };
+        match timer {
+            Ok(t) => Some(Timer::new_on_rt(t)),
+            Err(ioerr) => {
+                rtdebug!("Timer::init: failed to init: %?", ioerr);
+                io_error::cond.raise(ioerr);
+                None
+            }
+        }
+    }
+}
+
+impl RtioTimer for Timer {
+    fn sleep(&self, msecs: u64) {
+        (**self).sleep(msecs);
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use rt::test::*;
+    use option::{Some, None};
+    #[test]
+    fn test_io_timer_sleep_simple() {
+        do run_in_newsched_task {
+            let timer = Timer::new();
+            match timer {
+                Some(t) => t.sleep(1),
+                None => assert!(false)
+            }
+        }
+    }
+}

branches/snap-stage3/src/libstd/rt/rtio.rs

@@ -23,6 +23,7 @@ pub type IoFactoryObject = uvio::UvIoFactory;
 pub type RtioTcpStreamObject = uvio::UvTcpStream;
 pub type RtioTcpListenerObject = uvio::UvTcpListener;
 pub type RtioUdpSocketObject = uvio::UvUdpSocket;
+pub type RtioTimerObject = uvio::UvTimer;
 
 pub trait EventLoop {
     fn run(&mut self);
@@ -46,6 +47,7 @@ pub trait IoFactory {
     fn tcp_connect(&mut self, addr: IpAddr) -> Result<~RtioTcpStreamObject, IoError>;
     fn tcp_bind(&mut self, addr: IpAddr) -> Result<~RtioTcpListenerObject, IoError>;
     fn udp_bind(&mut self, addr: IpAddr) -> Result<~RtioUdpSocketObject, IoError>;
+    fn timer_init(&mut self) -> Result<~RtioTimerObject, IoError>;
 }
 
 pub trait RtioTcpListener : RtioSocket {
@@ -84,3 +86,7 @@ pub trait RtioUdpSocket : RtioSocket {
     fn hear_broadcasts(&mut self);
     fn ignore_broadcasts(&mut self);
 }
+
+pub trait RtioTimer {
+    fn sleep(&self, msecs: u64);
+}

branches/snap-stage3/src/libstd/rt/uv/uvio.rs

@@ -280,6 +280,10 @@ impl IoFactory for UvIoFactory {
             }
         }
     }
+
+    fn timer_init(&mut self) -> Result<~RtioTimerObject, IoError> {
+        Ok(~UvTimer(TimerWatcher::new(self.uv_loop())))
+    }
 }
 
 // FIXME #6090: Prefer newtype structs but Drop doesn't work
@@ -562,6 +566,48 @@ impl RtioUdpSocket for UvUdpSocket {
     fn ignore_broadcasts(&mut self) { fail!(); }
 }
 
+pub struct UvTimer(timer::TimerWatcher);
+
+impl UvTimer {
+    fn new(w: timer::TimerWatcher) -> UvTimer {
+        UvTimer(w)
+    }
+}
+
+impl Drop for UvTimer {
+    fn drop(&self) {
+        rtdebug!("closing UvTimer");
+        let scheduler = Local::take::<Scheduler>();
+        do scheduler.deschedule_running_task_and_then |_, task| {
+            let task_cell = Cell::new(task);
+            do self.close {
+                let scheduler = Local::take::<Scheduler>();
+                scheduler.resume_blocked_task_immediately(task_cell.take());
+            }
+        }
+    }
+}
+
+impl RtioTimer for UvTimer {
+    fn sleep(&self, msecs: u64) {
+        let scheduler = Local::take::<Scheduler>();
+        assert!(scheduler.in_task_context());
+        do scheduler.deschedule_running_task_and_then |sched, task| {
+            rtdebug!("sleep: entered scheduler context");
+            assert!(!sched.in_task_context());
+            let task_cell = Cell::new(task);
+            let mut watcher = **self;
+            do watcher.start(msecs, 0) |_, status| {
+                assert!(status.is_none());
+                let scheduler = Local::take::<Scheduler>();
+                scheduler.resume_blocked_task_immediately(task_cell.take());
+            }
+        }
+        let mut w = **self;
+        w.stop();
+    }
+}
+
 #[test]
 fn test_simple_io_no_connect() {
     do run_in_newsched_task {
@@ -832,3 +878,20 @@ fn test_udp_many_read() {
         }
     }
 }
+
+fn test_timer_sleep_simple_impl() {
+    unsafe {
+        let io = Local::unsafe_borrow::<IoFactoryObject>();
+        let timer = (*io).timer_init();
+        match timer {
+            Ok(t) => t.sleep(1),
+            Err(_) => assert!(false)
+        }
+    }
+}
+#[test]
+fn test_timer_sleep_simple() {
+    do run_in_newsched_task {
+        test_timer_sleep_simple_impl();
+    }
+}

branches/snap-stage3/src/libsyntax/ast.rs

@@ -30,9 +30,9 @@ pub struct ident { name: Name, ctxt: SyntaxContext }
 /// Construct an identifier with the given name and an empty context:
 pub fn new_ident(name: Name) -> ident { ident {name: name, ctxt: empty_ctxt}}
 
-// a SyntaxContext represents a chain of macro-expandings
-// and renamings. Each macro expansion corresponds to
-// a fresh uint
+/// A SyntaxContext represents a chain of macro-expandings
+/// and renamings. Each macro expansion corresponds to
+/// a fresh uint
 
 // I'm representing this syntax context as an index into
 // a table, in order to work around a compiler bug
@@ -70,11 +70,10 @@ pub enum SyntaxContext_ {
     IllegalCtxt()
 }
 
-// a name is a part of an identifier, representing a string
-// or gensym. It's the result of interning.
+/// A name is a part of an identifier, representing a string or gensym. It's
+/// the result of interning.
 pub type Name = uint;
-// a mark represents a unique id associated
-// with a macro expansion
+/// A mark represents a unique id associated with a macro expansion
 pub type Mrk = uint;
 
 impl<S:Encoder> Encodable<S> for ident {
@@ -90,7 +89,7 @@ impl<D:Decoder> Decodable<D> for ident {
     }
 }
 
-// Functions may or may not have names.
+/// Function name (not all functions have names)
 pub type fn_ident = Option<ident>;
 
 #[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
@@ -107,9 +106,14 @@ pub struct Lifetime {
 #[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
 pub struct Path {
     span: span,
+    /// A `::foo` path, is relative to the crate root rather than current
+    /// module (like paths in an import).
     global: bool,
+    /// The segments in the path (the things separated by ::)
     idents: ~[ident],
+    /// "Region parameter", currently only one lifetime is allowed in a path.
     rp: Option<Lifetime>,
+    /// These are the type parameters, ie, the `a, b` in `foo::bar::<a, b>`
     types: ~[Ty],
 }