---

yaml
---
r: 94798
b: refs/heads/try
c: aa5d779
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 0da105a8b7b6b1e0568e8ff20f6ff4b13cc7ecc2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d3e57dca68fde4effdda3e4ae2887aa535fcd6
-refs/heads/try: a9a7a427a1f1a61497105283594d32b976d7559f
+refs/heads/try: aa5d779a3590b1ed1559e0489138040a71ae688b
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/.gitmodules

@@ -8,4 +8,4 @@
 	branch = master
 [submodule "src/gyp"]
 	path = src/gyp
-	url = https://github.com/brson/gyp.git
+	url = https://github.com/alexcrichton/gyp.git

branches/try/doc/tutorial.md

@@ -3071,7 +3071,7 @@ Therefore, if you plan to compile your crate as a library, you should annotate i
 
 # #[crate_type = "lib"];
 // Package ID
-#[pkgid = "farm#2.5"];
+#[crate_id = "farm#2.5"];
 
 // ...
 # fn farm() {}
@@ -3095,7 +3095,7 @@ or setting the crate type (library or executable) explicitly:
 // ...
 
 // This crate is a library ("bin" is the default)
-#[pkgid = "farm#2.5"];
+#[crate_id = "farm#2.5"];
 #[crate_type = "lib"];
 
 // Turn on a warning
@@ -3116,7 +3116,7 @@ We define two crates, and use one of them as a library in the other.
 
 ~~~~
 // world.rs
-#[pkgid = "world#0.42"];
+#[crate_id = "world#0.42"];
 # extern mod extra;
 pub fn explore() -> &'static str { "world" }
 # fn main() {}

branches/try/mk/docs.mk

@@ -13,6 +13,7 @@
 ######################################################################
 
 DOCS :=
+CDOCS :=
 DOCS_L10N :=
 
 BASE_DOC_OPTS := --from=markdown --standalone --toc --number-sections
@@ -232,8 +233,21 @@ doc/$(1)/index.html: $$(RUSTDOC) $$(TLIB2_T_$(3)_H_$(3))/$(CFG_STDLIB_$(3))
 DOCS += doc/$(1)/index.html
 endef
 
+define compiledoc
+doc/$(1)/index.html: $$(RUSTDOC) $$(TLIB2_T_$(3)_H_$(3))/$(CFG_STDLIB_$(3))
+	@$$(call E, rustdoc: $$@)
+	$(Q)$(RUSTDOC) --cfg stage2 $(2)
+
+CDOCS += doc/$(1)/index.html
+endef
+
 $(eval $(call libdoc,std,$(STDLIB_CRATE),$(CFG_BUILD)))
 $(eval $(call libdoc,extra,$(EXTRALIB_CRATE),$(CFG_BUILD)))
+$(eval $(call libdoc,native,$(LIBNATIVE_CRATE),$(CFG_BUILD)))
+$(eval $(call libdoc,green,$(LIBGREEN_CRATE),$(CFG_BUILD)))
+
+$(eval $(call compiledoc,rustc,$(COMPILER_CRATE),$(CFG_BUILD)))
+$(eval $(call compiledoc,syntax,$(LIBSYNTAX_CRATE),$(CFG_BUILD)))
 
 
 ifdef CFG_DISABLE_DOCS
@@ -256,6 +270,7 @@ doc/version_info.html: version_info.html.template $(MKFILE_DEPS) \
 GENERATED += doc/version.md doc/version_info.html
 
 docs: $(DOCS)
+compiler-docs: $(CDOCS)
 
 docs-l10n: $(DOCS_L10N)
 

branches/try/src/etc/vim/syntax/rust.vim

@@ -78,7 +78,7 @@ syn keyword rustTrait Default
 syn keyword rustTrait Hash
 syn keyword rustTrait FromStr
 syn keyword rustTrait FromIterator Extendable
-syn keyword rustTrait Iterator DoubleEndedIterator RandomAccessIterator ClonableIterator
+syn keyword rustTrait Iterator DoubleEndedIterator RandomAccessIterator CloneableIterator
 syn keyword rustTrait OrdIterator MutableDoubleEndedIterator ExactSize
 syn keyword rustTrait Times
 

branches/try/src/gyp

@@ -1 +1 @@
-Subproject commit f407f09c94e00d2d570e8e42114e3f6848b2deb2
+Subproject commit 1e46da1000bc29679ab4cebf3c1034cb7d6f4487

branches/try/src/libextra/enum_set.rs

@@ -13,7 +13,7 @@
 //! This module defines a container which uses an efficient bit mask
 //! representation to hold C-like enum variants.
 
-#[deriving(Clone, Eq, IterBytes, ToStr)]
+#[deriving(Clone, Eq, IterBytes, ToStr, Encodable, Decodable)]
 /// A specialized Set implementation to use enum types.
 pub struct EnumSet<E> {
     // We must maintain the invariant that no bits are set

branches/try/src/libgreen/lib.rs

@@ -214,11 +214,7 @@ impl SchedPool {
             pool.handles.push(sched.make_handle());
             let sched = sched;
             pool.threads.push(do Thread::start {
-                let mut sched = sched;
-                let task = do GreenTask::new(&mut sched.stack_pool, None) {
-                    rtdebug!("boostraping a non-primary scheduler");
-                };
-                sched.bootstrap(task);
+                sched.bootstrap();
             });
         }
 
@@ -270,13 +266,7 @@ impl SchedPool {
         let ret = sched.make_handle();
         self.handles.push(sched.make_handle());
         let sched = sched;
-        self.threads.push(do Thread::start {
-            let mut sched = sched;
-            let task = do GreenTask::new(&mut sched.stack_pool, None) {
-                rtdebug!("boostraping a non-primary scheduler");
-            };
-            sched.bootstrap(task);
-        });
+        self.threads.push(do Thread::start { sched.bootstrap() });
 
         return ret;
     }

branches/try/src/libgreen/sched.rs

@@ -171,7 +171,7 @@ impl Scheduler {
 
     // Take a main task to run, and a scheduler to run it in. Create a
     // scheduler task and bootstrap into it.
-    pub fn bootstrap(mut ~self, task: ~GreenTask) {
+    pub fn bootstrap(mut ~self) {
 
         // Build an Idle callback.
         let cb = ~SchedRunner as ~Callback;
@@ -187,18 +187,11 @@ impl Scheduler {
         self.idle_callback.get_mut_ref().resume();
 
         // Now, as far as all the scheduler state is concerned, we are inside
-        // the "scheduler" context. So we can act like the scheduler and resume
-        // the provided task. Let it think that the currently running task is
-        // actually the sched_task so it knows where to squirrel it away.
-        let mut sched_task = self.resume_task_immediately(sched_task, task);
-
-        // Now we are back in the scheduler context, having
-        // successfully run the input task. Start by running the
-        // scheduler. Grab it out of TLS - performing the scheduler
-        // action will have given it away.
-        let sched = sched_task.sched.take_unwrap();
-        rtdebug!("starting scheduler {}", sched.sched_id());
-        let mut sched_task = sched.run(sched_task);
+        // the "scheduler" context. The scheduler immediately hands over control
+        // to the event loop, and this will only exit once the event loop no
+        // longer has any references (handles or I/O objects).
+        rtdebug!("starting scheduler {}", self.sched_id());
+        let mut sched_task = self.run(sched_task);
 
         // Close the idle callback.
         let mut sched = sched_task.sched.take_unwrap();
@@ -548,7 +541,10 @@ impl Scheduler {
         // We push the task onto our local queue clone.
         assert!(!task.is_sched());
         self.work_queue.push(task);
-        self.idle_callback.get_mut_ref().resume();
+        match self.idle_callback {
+            Some(ref mut idle) => idle.resume(),
+            None => {} // allow enqueuing before the scheduler starts
+        }
 
         // We've made work available. Notify a
         // sleeping scheduler.
@@ -1176,25 +1172,21 @@ mod test {
                 let mut sh = special_handle;
                 sh.send(Shutdown);
             };
-
+            normal_sched.enqueue_task(normal_task);
 
             let special_task = do GreenTask::new(&mut special_sched.stack_pool,
                                                  None) {
                 run(task1);
                 run(task3);
                 chan.send(());
             };
-
+            special_sched.enqueue_task(special_task);
 
             let normal_sched = normal_sched;
-            let normal_thread = do Thread::start {
-                normal_sched.bootstrap(normal_task);
-            };
+            let normal_thread = do Thread::start { normal_sched.bootstrap() };
 
             let special_sched = special_sched;
-            let special_thread = do Thread::start {
-                special_sched.bootstrap(special_task);
-            };
+            let special_thread = do Thread::start { special_sched.bootstrap() };
 
             normal_thread.join();
             special_thread.join();

branches/try/src/libnative/io/file.rs

@@ -26,7 +26,7 @@ use super::IoResult;
 #[cfg(windows)] use std::ptr;
 #[cfg(windows)] use std::str;
 
-fn keep_going(data: &[u8], f: |*u8, uint| -> i64) -> i64 {
+pub fn keep_going(data: &[u8], f: |*u8, uint| -> i64) -> i64 {
     #[cfg(windows)] static eintr: int = 0; // doesn't matter
     #[cfg(not(windows))] static eintr: int = libc::EINTR as int;
 
@@ -37,7 +37,7 @@ fn keep_going(data: &[u8], f: |*u8, uint| -> i64) -> i64 {
         let mut ret;
         loop {
             ret = f(data, amt);
-            if cfg!(not(windows)) { break } // windows has no eintr
+            if cfg!(windows) { break } // windows has no eintr
             // if we get an eintr, then try again
             if ret != -1 || os::errno() as int != eintr { break }
         }
@@ -73,7 +73,10 @@ impl FileDesc {
         FileDesc { fd: fd, close_on_drop: close_on_drop }
     }
 
-    fn inner_read(&mut self, buf: &mut [u8]) -> Result<uint, IoError> {
+    // FIXME(#10465) these functions should not be public, but anything in
+    //               native::io wanting to use them is forced to have all the
+    //               rtio traits in scope
+    pub fn inner_read(&mut self, buf: &mut [u8]) -> Result<uint, IoError> {
         #[cfg(windows)] type rlen = libc::c_uint;
         #[cfg(not(windows))] type rlen = libc::size_t;
         let ret = keep_going(buf, |buf, len| {
@@ -89,7 +92,7 @@ impl FileDesc {
             Ok(ret as uint)
         }
     }
-    fn inner_write(&mut self, buf: &[u8]) -> Result<(), IoError> {
+    pub fn inner_write(&mut self, buf: &[u8]) -> Result<(), IoError> {
         #[cfg(windows)] type wlen = libc::c_uint;
         #[cfg(not(windows))] type wlen = libc::size_t;
         let ret = keep_going(buf, |buf, len| {
@@ -103,6 +106,8 @@ impl FileDesc {
             Ok(())
         }
     }
+
+    pub fn fd(&self) -> fd_t { self.fd }
 }
 
 impl io::Reader for FileDesc {

branches/try/src/libnative/io/mod.rs

@@ -44,6 +44,7 @@ pub use self::process::Process;
 // Native I/O implementations
 pub mod file;
 pub mod process;
+pub mod net;
 
 type IoResult<T> = Result<T, IoError>;
 
@@ -55,12 +56,25 @@ fn unimpl() -> IoError {
     }
 }
 
-fn last_error() -> IoError {
+fn translate_error(errno: i32, detail: bool) -> IoError {
     #[cfg(windows)]
     fn get_err(errno: i32) -> (io::IoErrorKind, &'static str) {
         match errno {
             libc::EOF => (io::EndOfFile, "end of file"),
-            _ => (io::OtherIoError, "unknown error"),
+            libc::WSAECONNREFUSED => (io::ConnectionRefused, "connection refused"),
+            libc::WSAECONNRESET => (io::ConnectionReset, "connection reset"),
+            libc::WSAEACCES => (io::PermissionDenied, "permission denied"),
+            libc::WSAEWOULDBLOCK =>
+                (io::ResourceUnavailable, "resource temporarily unavailable"),
+            libc::WSAENOTCONN => (io::NotConnected, "not connected"),
+            libc::WSAECONNABORTED => (io::ConnectionAborted, "connection aborted"),
+            libc::WSAEADDRNOTAVAIL => (io::ConnectionRefused, "address not available"),
+            libc::WSAEADDRINUSE => (io::ConnectionRefused, "address in use"),
+
+            x => {
+                debug!("ignoring {}: {}", x, os::last_os_error());
+                (io::OtherIoError, "unknown error")
+            }
         }
     }
 
@@ -69,24 +83,38 @@ fn last_error() -> IoError {
         // XXX: this should probably be a bit more descriptive...
         match errno {
             libc::EOF => (io::EndOfFile, "end of file"),
+            libc::ECONNREFUSED => (io::ConnectionRefused, "connection refused"),
+            libc::ECONNRESET => (io::ConnectionReset, "connection reset"),
+            libc::EPERM | libc::EACCES =>
+                (io::PermissionDenied, "permission denied"),
+            libc::EPIPE => (io::BrokenPipe, "broken pipe"),
+            libc::ENOTCONN => (io::NotConnected, "not connected"),
+            libc::ECONNABORTED => (io::ConnectionAborted, "connection aborted"),
+            libc::EADDRNOTAVAIL => (io::ConnectionRefused, "address not available"),
+            libc::EADDRINUSE => (io::ConnectionRefused, "address in use"),
 
             // These two constants can have the same value on some systems, but
             // different values on others, so we can't use a match clause
             x if x == libc::EAGAIN || x == libc::EWOULDBLOCK =>
                 (io::ResourceUnavailable, "resource temporarily unavailable"),
 
-            _ => (io::OtherIoError, "unknown error"),
+            x => {
+                debug!("ignoring {}: {}", x, os::last_os_error());
+                (io::OtherIoError, "unknown error")
+            }
         }
     }
 
-    let (kind, desc) = get_err(os::errno() as i32);
+    let (kind, desc) = get_err(errno);
     IoError {
         kind: kind,
         desc: desc,
-        detail: Some(os::last_os_error())
+        detail: if detail {Some(os::last_os_error())} else {None},
     }
 }
 
+fn last_error() -> IoError { translate_error(os::errno() as i32, true) }
+
 // unix has nonzero values as errors
 fn mkerr_libc(ret: libc::c_int) -> IoResult<()> {
     if ret != 0 {
@@ -106,17 +134,37 @@ fn mkerr_winbool(ret: libc::c_int) -> IoResult<()> {
     }
 }
 
+#[cfg(unix)]
+fn retry(f: || -> libc::c_int) -> IoResult<libc::c_int> {
+    loop {
+        match f() {
+            -1 if os::errno() as int == libc::EINTR as int => {}
+            -1 => return Err(last_error()),
+            n => return Ok(n),
+        }
+    }
+}
+
 /// Implementation of rt::rtio's IoFactory trait to generate handles to the
 /// native I/O functionality.
-pub struct IoFactory;
+pub struct IoFactory {
+    priv cannot_construct_outside_of_this_module: ()
+}
+
+impl IoFactory {
+    pub fn new() -> IoFactory {
+        net::init();
+        IoFactory { cannot_construct_outside_of_this_module: () }
+    }
+}
 
 impl rtio::IoFactory for IoFactory {
     // networking
-    fn tcp_connect(&mut self, _addr: SocketAddr) -> IoResult<~RtioTcpStream> {
-        Err(unimpl())
+    fn tcp_connect(&mut self, addr: SocketAddr) -> IoResult<~RtioTcpStream> {
+        net::TcpStream::connect(addr).map(|s| ~s as ~RtioTcpStream)
     }
-    fn tcp_bind(&mut self, _addr: SocketAddr) -> IoResult<~RtioTcpListener> {
-        Err(unimpl())
+    fn tcp_bind(&mut self, addr: SocketAddr) -> IoResult<~RtioTcpListener> {
+        net::TcpListener::bind(addr).map(|s| ~s as ~RtioTcpListener)
     }
     fn udp_bind(&mut self, _addr: SocketAddr) -> IoResult<~RtioUdpSocket> {
         Err(unimpl())
@@ -204,9 +252,7 @@ impl rtio::IoFactory for IoFactory {
     }
     fn tty_open(&mut self, fd: c_int, _readable: bool) -> IoResult<~RtioTTY> {
         if unsafe { libc::isatty(fd) } != 0 {
-            // Don't ever close the stdio file descriptors, nothing good really
-            // comes of that.
-            Ok(~file::FileDesc::new(fd, fd > libc::STDERR_FILENO) as ~RtioTTY)
+            Ok(~file::FileDesc::new(fd, true) as ~RtioTTY)
         } else {
             Err(IoError {
                 kind: io::MismatchedFileTypeForOperation,