---

yaml
---
r: 150271
b: refs/heads/try2
c: b1091c3
h: refs/heads/master
i:
  150269: c2c6a72
  150267: badd866
  150263: 8f3a7f0
  150255: 02840b5
  150239: 4e521bf
  150207: 2fde5b9
  150143: e529907
  150015: 21fbe20
v: v3

Author: bors

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 39b48fb8836b130fa6bec09b4864b5a8eee0cd42
+refs/heads/try2: b1091c3141f2285fa9620c9e4df3fb86d911c5f6
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/compiletest/compiletest.rs

@@ -12,7 +12,6 @@
 #[feature(phase)];
 
 #[allow(non_camel_case_types)];
-#[allow(deprecated_owned_vector)]; // NOTE: remove after stage0
 #[deny(warnings)];
 
 extern crate test;

branches/try2/src/doc/guide-tasks.md

@@ -359,7 +359,7 @@ fn main() {
 
         spawn(proc() {
             let local_arc : Arc<~[f64]> = rx.recv();
-            let task_numbers = local_arc.get();
+            let task_numbers = &*local_arc;
             println!("{}-norm = {}", num, pnorm(task_numbers, num));
         });
     }
@@ -411,7 +411,7 @@ Each task recovers the underlying data by
 # let (tx, rx) = channel();
 # tx.send(numbers_arc.clone());
 # let local_arc : Arc<~[f64]> = rx.recv();
-let task_numbers = local_arc.get();
+let task_numbers = &*local_arc;
 # }
 ~~~
 

branches/try2/src/driver/driver.rs

@@ -14,9 +14,4 @@ extern crate this = "rustdoc";
 #[cfg(rustc)]
 extern crate this = "rustc";
 
-#[cfg(not(stage0))]
 fn main() { this::main() }
-
-#[cfg(stage0)]
-#[start]
-fn start(argc: int, argv: **u8) -> int { native::start(argc, argv, this::main) }

branches/try2/src/etc/licenseck.py

@@ -41,7 +41,7 @@
     "libstd/sync/mpsc_queue.rs", # BSD
     "libstd/sync/spsc_queue.rs", # BSD
     "libstd/sync/mpmc_bounded_queue.rs", # BSD
-    "libsync/sync/mpsc_intrusive.rs", # BSD
+    "libsync/mpsc_intrusive.rs", # BSD
 ]
 
 def check_license(name, contents):

branches/try2/src/libgreen/lib.rs

@@ -207,16 +207,6 @@ pub mod sleeper_list;
 pub mod stack;
 pub mod task;
 
-#[lang = "start"]
-#[cfg(not(test), stage0)]
-pub fn lang_start(main: *u8, argc: int, argv: **u8) -> int {
-    use std::cast;
-    start(argc, argv, proc() {
-        let main: extern "Rust" fn() = unsafe { cast::transmute(main) };
-        main();
-    })
-}
-
 /// Set up a default runtime configuration, given compiler-supplied arguments.
 ///
 /// This function will block until the entire pool of M:N schedulers have

branches/try2/src/libgreen/simple.rs

@@ -40,7 +40,7 @@ impl Runtime for SimpleTask {
         // See libnative/task.rs for what's going on here with the `awoken`
         // field and the while loop around wait()
         unsafe {
-            let mut guard = (*me).lock.lock();
+            let guard = (*me).lock.lock();
             (*me).awoken = false;
             match f(task) {
                 Ok(()) => {
@@ -60,7 +60,7 @@ impl Runtime for SimpleTask {
         to_wake.put_runtime(self as ~Runtime);
         unsafe {
             cast::forget(to_wake);
-            let mut guard = (*me).lock.lock();
+            let guard = (*me).lock.lock();
             (*me).awoken = true;
             guard.signal();
         }

branches/try2/src/libnative/io/process.rs

@@ -446,132 +446,129 @@ fn spawn_process_os(config: p::ProcessConfig,
         assert_eq!(ret, 0);
     }
 
-    let pipe = os::pipe();
-    let mut input = file::FileDesc::new(pipe.input, true);
-    let mut output = file::FileDesc::new(pipe.out, true);
+    let dirp = dir.map(|p| p.to_c_str());
+    let dirp = dirp.as_ref().map(|c| c.with_ref(|p| p)).unwrap_or(ptr::null());
+
+    with_envp(env, proc(envp) {
+        with_argv(config.program, config.args, proc(argv) unsafe {
+            let pipe = os::pipe();
+            let mut input = file::FileDesc::new(pipe.input, true);
+            let mut output = file::FileDesc::new(pipe.out, true);
+
+            set_cloexec(output.fd());
+
+            let pid = fork();
+            if pid < 0 {
+                fail!("failure in fork: {}", os::last_os_error());
+            } else if pid > 0 {
+                drop(output);
+                let mut bytes = [0, ..4];
+                return match input.inner_read(bytes) {
+                    Ok(4) => {
+                        let errno = (bytes[0] << 24) as i32 |
+                                    (bytes[1] << 16) as i32 |
+                                    (bytes[2] <<  8) as i32 |
+                                    (bytes[3] <<  0) as i32;
+                        Err(super::translate_error(errno, false))
+                    }
+                    Err(e) => {
+                        assert!(e.kind == io::BrokenPipe ||
+                                e.kind == io::EndOfFile,
+                                "unexpected error: {}", e);
+                        Ok(SpawnProcessResult {
+                            pid: pid,
+                            handle: ptr::null()
+                        })
+                    }
+                    Ok(..) => fail!("short read on the cloexec pipe"),
+                };
+            }
+            drop(input);
+
+            fn fail(output: &mut file::FileDesc) -> ! {
+                let errno = os::errno();
+                let bytes = [
+                    (errno << 24) as u8,
+                    (errno << 16) as u8,
+                    (errno <<  8) as u8,
+                    (errno <<  0) as u8,
+                ];
+                assert!(output.inner_write(bytes).is_ok());
+                unsafe { libc::_exit(1) }
+            }
 
-    unsafe { set_cloexec(output.fd()) };
+            rustrt::rust_unset_sigprocmask();
 
-    unsafe {
-        let pid = fork();
-        if pid < 0 {
-            fail!("failure in fork: {}", os::last_os_error());
-        } else if pid > 0 {
-            drop(output);
-            let mut bytes = [0, ..4];
-            return match input.inner_read(bytes) {
-                Ok(4) => {
-                    let errno = (bytes[0] << 24) as i32 |
-                                (bytes[1] << 16) as i32 |
-                                (bytes[2] <<  8) as i32 |
-                                (bytes[3] <<  0) as i32;
-                    Err(super::translate_error(errno, false))
-                }
-                Err(e) => {
-                    assert!(e.kind == io::BrokenPipe ||
-                            e.kind == io::EndOfFile,
-                            "unexpected error: {}", e);
-                    Ok(SpawnProcessResult {
-                        pid: pid,
-                        handle: ptr::null()
-                    })
+            if in_fd == -1 {
+                let _ = libc::close(libc::STDIN_FILENO);
+            } else if retry(|| dup2(in_fd, 0)) == -1 {
+                fail(&mut output);
+            }
+            if out_fd == -1 {
+                let _ = libc::close(libc::STDOUT_FILENO);
+            } else if retry(|| dup2(out_fd, 1)) == -1 {
+                fail(&mut output);
+            }
+            if err_fd == -1 {
+                let _ = libc::close(libc::STDERR_FILENO);
+            } else if retry(|| dup2(err_fd, 2)) == -1 {
+                fail(&mut output);
+            }
+            // close all other fds
+            for fd in range(3, getdtablesize()).rev() {
+                if fd != output.fd() {
+                    let _ = close(fd as c_int);
                 }
-                Ok(..) => fail!("short read on the cloexec pipe"),
-            };
-        }
-        drop(input);
-
-        fn fail(output: &mut file::FileDesc) -> ! {
-            let errno = os::errno();
-            let bytes = [
-                (errno << 24) as u8,
-                (errno << 16) as u8,
-                (errno <<  8) as u8,
-                (errno <<  0) as u8,
-            ];
-            assert!(output.inner_write(bytes).is_ok());
-            unsafe { libc::_exit(1) }
-        }
-
-        rustrt::rust_unset_sigprocmask();
-
-        if in_fd == -1 {
-            let _ = libc::close(libc::STDIN_FILENO);
-        } else if retry(|| dup2(in_fd, 0)) == -1 {
-            fail(&mut output);
-        }
-        if out_fd == -1 {
-            let _ = libc::close(libc::STDOUT_FILENO);
-        } else if retry(|| dup2(out_fd, 1)) == -1 {
-            fail(&mut output);
-        }
-        if err_fd == -1 {
-            let _ = libc::close(libc::STDERR_FILENO);
-        } else if retry(|| dup2(err_fd, 2)) == -1 {
-            fail(&mut output);
-        }
-        // close all other fds
-        for fd in range(3, getdtablesize()).rev() {
-            if fd != output.fd() {
-                let _ = close(fd as c_int);
             }
-        }
 
-        match config.gid {
-            Some(u) => {
-                if libc::setgid(u as libc::gid_t) != 0 {
-                    fail(&mut output);
+            match config.gid {
+                Some(u) => {
+                    if libc::setgid(u as libc::gid_t) != 0 {
+                        fail(&mut output);
+                    }
                 }
+                None => {}
             }
-            None => {}
-        }
-        match config.uid {
-            Some(u) => {
-                // When dropping privileges from root, the `setgroups` call will
-                // remove any extraneous groups. If we don't call this, then
-                // even though our uid has dropped, we may still have groups
-                // that enable us to do super-user things. This will fail if we
-                // aren't root, so don't bother checking the return value, this
-                // is just done as an optimistic privilege dropping function.
-                extern {
-                    fn setgroups(ngroups: libc::c_int,
-                                 ptr: *libc::c_void) -> libc::c_int;
-                }
-                let _ = setgroups(0, 0 as *libc::c_void);
+            match config.uid {
+                Some(u) => {
+                    // When dropping privileges from root, the `setgroups` call will
+                    // remove any extraneous groups. If we don't call this, then
+                    // even though our uid has dropped, we may still have groups
+                    // that enable us to do super-user things. This will fail if we
+                    // aren't root, so don't bother checking the return value, this
+                    // is just done as an optimistic privilege dropping function.
+                    extern {
+                        fn setgroups(ngroups: libc::c_int,
+                                     ptr: *libc::c_void) -> libc::c_int;
+                    }
+                    let _ = setgroups(0, 0 as *libc::c_void);
 
-                if libc::setuid(u as libc::uid_t) != 0 {
-                    fail(&mut output);
+                    if libc::setuid(u as libc::uid_t) != 0 {
+                        fail(&mut output);
+                    }
                 }
+                None => {}
+            }
+            if config.detach {
+                // Don't check the error of setsid because it fails if we're the
+                // process leader already. We just forked so it shouldn't return
+                // error, but ignore it anyway.
+                let _ = libc::setsid();
             }
-            None => {}
-        }
-        if config.detach {
-            // Don't check the error of setsid because it fails if we're the
-            // process leader already. We just forked so it shouldn't return
-            // error, but ignore it anyway.
-            let _ = libc::setsid();
-        }
-
-        with_dirp(dir, |dirp| {
             if !dirp.is_null() && chdir(dirp) == -1 {
                 fail(&mut output);
             }
-        });
-
-        with_envp(env, |envp| {
             if !envp.is_null() {
                 set_environ(envp);
             }
-            with_argv(config.program, config.args, |argv| {
-                let _ = execvp(*argv, argv);
-                fail(&mut output);
-            })
+            let _ = execvp(*argv, argv);
+            fail(&mut output);
         })
-    }
+    })
 }
 
 #[cfg(unix)]
-fn with_argv<T>(prog: &str, args: &[~str], cb: |**libc::c_char| -> T) -> T {
+fn with_argv<T>(prog: &str, args: &[~str], cb: proc:(**libc::c_char) -> T) -> T {
     use std::slice;
 
     // We can't directly convert `str`s into `*char`s, as someone needs to hold
@@ -597,7 +594,7 @@ fn with_argv<T>(prog: &str, args: &[~str], cb: |**libc::c_char| -> T) -> T {
 }
 
 #[cfg(unix)]
-fn with_envp<T>(env: Option<~[(~str, ~str)]>, cb: |*c_void| -> T) -> T {
+fn with_envp<T>(env: Option<~[(~str, ~str)]>, cb: proc:(*c_void) -> T) -> T {
     use std::slice;
 
     // On posixy systems we can pass a char** for envp, which is a
@@ -645,6 +642,7 @@ fn with_envp<T>(env: Option<~[(~str, ~str)]>, cb: |*mut c_void| -> T) -> T {
     }
 }
 
+#[cfg(windows)]
 fn with_dirp<T>(d: Option<&Path>, cb: |*libc::c_char| -> T) -> T {
     match d {
       Some(dir) => dir.with_c_str(|buf| cb(buf)),

branches/try2/src/libnative/io/timer_helper.rs

@@ -75,7 +75,7 @@ pub fn send(req: Req) {
 fn shutdown() {
     // Request a shutdown, and then wait for the task to exit
     unsafe {
-        let mut guard = TIMER_HELPER_EXIT.lock();
+        let guard = TIMER_HELPER_EXIT.lock();
         send(Shutdown);
         guard.wait();
         drop(guard);

branches/try2/src/libnative/lib.rs

@@ -69,7 +69,7 @@ static OS_DEFAULT_STACK_ESTIMATE: uint = 1 << 20;
 static OS_DEFAULT_STACK_ESTIMATE: uint = 2 * (1 << 20);
 
 #[lang = "start"]
-#[cfg(not(test), not(stage0))]
+#[cfg(not(test))]
 pub fn lang_start(main: *u8, argc: int, argv: **u8) -> int {
     use std::cast;
     start(argc, argv, proc() {

branches/try2/src/libnative/task.rs

@@ -190,7 +190,7 @@ impl rt::Runtime for Ops {
             let task = BlockedTask::block(cur_task);
 
             if times == 1 {
-                let mut guard = (*me).lock.lock();
+                let guard = (*me).lock.lock();
                 (*me).awoken = false;
                 match f(task) {
                     Ok(()) => {
@@ -202,7 +202,7 @@ impl rt::Runtime for Ops {
                 }
             } else {
                 let mut iter = task.make_selectable(times);
-                let mut guard = (*me).lock.lock();
+                let guard = (*me).lock.lock();
                 (*me).awoken = false;
                 let success = iter.all(|task| {
                     match f(task) {
@@ -232,7 +232,7 @@ impl rt::Runtime for Ops {
             let me = &mut *self as *mut Ops;
             to_wake.put_runtime(self as ~rt::Runtime);
             cast::forget(to_wake);
-            let mut guard = (*me).lock.lock();
+            let guard = (*me).lock.lock();
             (*me).awoken = true;
             guard.signal();
         }

branches/try2/src/librand/reader.rs

@@ -60,10 +60,8 @@ impl<R: Reader> Rng for ReaderRng<R> {
     }
     fn fill_bytes(&mut self, v: &mut [u8]) {
         if v.len() == 0 { return }
-        match self.reader.read(v) {
-            Ok(n) if n == v.len() => return,
-            Ok(n) => fail!("ReaderRng.fill_bytes could not fill buffer: \
-                            read {} out of {} bytes.", n, v.len()),
+        match self.reader.fill(v) {
+            Ok(()) => {}
             Err(e) => fail!("ReaderRng.fill_bytes error: {}", e)
         }
     }