---

yaml
---
r: 105110
b: refs/heads/snap-stage3
c: e30ab71
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 62f1d68439dcfd509eaca29887afa97f22938373
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 1e6e98c0c2bd6b736fc6bef9bc1fb8e34d24e488
+refs/heads/snap-stage3: e30ab71e086746c6db7d49f5b0be5fc8cceda514
 refs/heads/try: db814977d07bd798feb24f6b74c00800ef458a13
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/mk/dist.mk

@@ -106,7 +106,7 @@ distcheck: dist
 
 else
 
-dist: $(PKG_TAR) $(PKG_OSX)
+dist: $(PKG_TAR)
 
 distcheck: $(PKG_TAR)
 	$(Q)rm -Rf dist

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

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

branches/snap-stage3/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;
+            let task_numbers = local_arc.get();
             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;
+let task_numbers = local_arc.get();
 # }
 ~~~
 

branches/snap-stage3/src/driver/driver.rs

@@ -14,4 +14,9 @@ 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/snap-stage3/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/mpsc_intrusive.rs", # BSD
+    "libsync/sync/mpsc_intrusive.rs", # BSD
 ]
 
 def check_license(name, contents):

branches/snap-stage3/src/libgreen/lib.rs

@@ -207,6 +207,16 @@ 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/snap-stage3/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 guard = (*me).lock.lock();
+            let mut 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 guard = (*me).lock.lock();
+            let mut guard = (*me).lock.lock();
             (*me).awoken = true;
             guard.signal();
         }

branches/snap-stage3/src/libnative/io/process.rs

@@ -446,129 +446,132 @@ fn spawn_process_os(config: p::ProcessConfig,
         assert_eq!(ret, 0);
     }
 
-    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) }
-            }
+    let pipe = os::pipe();
+    let mut input = file::FileDesc::new(pipe.input, true);
+    let mut output = file::FileDesc::new(pipe.out, true);
 
-            rustrt::rust_unset_sigprocmask();
+    unsafe { set_cloexec(output.fd()) };
 
-            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);
+    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()
+                    })
+                }
+                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 => {}
             }
-            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);
+            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);
 
-                    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);
             }
-            let _ = execvp(*argv, argv);
-            fail(&mut output);
+            with_argv(config.program, config.args, |argv| {
+                let _ = execvp(*argv, argv);
+                fail(&mut output);
+            })
         })
-    })
+    }
 }
 
 #[cfg(unix)]
-fn with_argv<T>(prog: &str, args: &[~str], cb: proc:(**libc::c_char) -> T) -> T {
+fn with_argv<T>(prog: &str, args: &[~str], cb: |**libc::c_char| -> T) -> T {
     use std::slice;
 
     // We can't directly convert `str`s into `*char`s, as someone needs to hold
@@ -594,7 +597,7 @@ fn with_argv<T>(prog: &str, args: &[~str], cb: proc:(**libc::c_char) -> T) -> T
 }
 
 #[cfg(unix)]
-fn with_envp<T>(env: Option<~[(~str, ~str)]>, cb: proc:(*c_void) -> T) -> T {
+fn with_envp<T>(env: Option<~[(~str, ~str)]>, cb: |*c_void| -> T) -> T {
     use std::slice;
 
     // On posixy systems we can pass a char** for envp, which is a
@@ -642,7 +645,6 @@ 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/snap-stage3/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 guard = TIMER_HELPER_EXIT.lock();
+        let mut guard = TIMER_HELPER_EXIT.lock();
         send(Shutdown);
         guard.wait();
         drop(guard);

branches/snap-stage3/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))]
+#[cfg(not(test), not(stage0))]
 pub fn lang_start(main: *u8, argc: int, argv: **u8) -> int {
     use std::cast;
     start(argc, argv, proc() {

branches/snap-stage3/src/libnative/task.rs

@@ -190,7 +190,7 @@ impl rt::Runtime for Ops {
             let task = BlockedTask::block(cur_task);
 
             if times == 1 {
-                let guard = (*me).lock.lock();
+                let mut 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 guard = (*me).lock.lock();
+                let mut 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 guard = (*me).lock.lock();
+            let mut guard = (*me).lock.lock();
             (*me).awoken = true;
             guard.signal();
         }