---

yaml
---
r: 42683
b: refs/heads/try
c: 7ff7489
h: refs/heads/master
i:
  42681: bf82485
  42679: 58af19b
v: v3

Author: martica

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 19dfec2aaf746535de1521f68421f9980dbf25de
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2f46b763da2c098913884f101b6d71d69af41b49
-refs/heads/try: 1ef83945c1d76c9f2b9b0d087ceac65963087be7
+refs/heads/try: 7ff7489dc62bdcc0dbd507c52cba90d47cfdd129
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: a810c03263670238bccd64cabb12a23a46e3a278

branches/try/AUTHORS.txt

@@ -34,6 +34,7 @@ Brian Leibig <[email protected]>
 Chris Double <[email protected]>
 Chris Peterson <[email protected]>
 Chris Pressey <[email protected]>
+Cody Schroeder <[email protected]>
 Damian Gryski <[email protected]>
 Damien Grassart <[email protected]>
 Damien Schoof <[email protected]>

branches/try/src/libcore/os.rs

@@ -141,101 +141,169 @@ pub mod win32 {
     }
 }
 
-/*
-Accessing environment variables is not generally threadsafe.
-This uses a per-runtime lock to serialize access.
-XXX: It would probably be appropriate to make this a real global
-*/
-fn with_env_lock<T>(f: &fn() -> T) -> T {
-    use private::global::global_data_clone_create;
-    use private::{Exclusive, exclusive};
-
-    struct SharedValue(());
-    type ValueMutex = Exclusive<SharedValue>;
-    fn key(_: ValueMutex) { }
-
-    unsafe {
-        let lock: ValueMutex = global_data_clone_create(key, || {
-            ~exclusive(SharedValue(()))
-        });
+pub fn getenv(n: &str) -> Option<~str> {
+    global_env::getenv(n)
+}
 
-        lock.with_imm(|_| f() )
-    }
+pub fn setenv(n: &str, v: &str) {
+    global_env::setenv(n, v)
 }
 
 pub fn env() -> ~[(~str,~str)] {
+    global_env::env()
+}
+
+mod global_env {
+    //! Internal module for serializing access to getenv/setenv
+    use either;
+    use libc;
+    use oldcomm;
+    use option::Option;
+    use private;
+    use str;
+    use task;
+
     extern mod rustrt {
-        unsafe fn rust_env_pairs() -> ~[~str];
+        unsafe fn rust_global_env_chan_ptr() -> *libc::uintptr_t;
     }
 
-    unsafe {
-        do with_env_lock {
-            let mut pairs = ~[];
-            for vec::each(rustrt::rust_env_pairs()) |p| {
-                let vs = str::splitn_char(*p, '=', 1u);
-                assert vec::len(vs) == 2u;
-                pairs.push((copy vs[0], copy vs[1]));
-            }
-            move pairs
+    enum Msg {
+        MsgGetEnv(~str, oldcomm::Chan<Option<~str>>),
+        MsgSetEnv(~str, ~str, oldcomm::Chan<()>),
+        MsgEnv(oldcomm::Chan<~[(~str,~str)]>)
+    }
+
+    pub fn getenv(n: &str) -> Option<~str> {
+        let env_ch = get_global_env_chan();
+        let po = oldcomm::Port();
+        oldcomm::send(env_ch, MsgGetEnv(str::from_slice(n),
+                                        oldcomm::Chan(&po)));
+        oldcomm::recv(po)
+    }
+
+    pub fn setenv(n: &str, v: &str) {
+        let env_ch = get_global_env_chan();
+        let po = oldcomm::Port();
+        oldcomm::send(env_ch, MsgSetEnv(str::from_slice(n),
+                                        str::from_slice(v),
+                                        oldcomm::Chan(&po)));
+        oldcomm::recv(po)
+    }
+
+    pub fn env() -> ~[(~str,~str)] {
+        let env_ch = get_global_env_chan();
+        let po = oldcomm::Port();
+        oldcomm::send(env_ch, MsgEnv(oldcomm::Chan(&po)));
+        oldcomm::recv(po)
+    }
+
+    fn get_global_env_chan() -> oldcomm::Chan<Msg> {
+        unsafe {
+            let global_ptr = rustrt::rust_global_env_chan_ptr();
+            private::chan_from_global_ptr(global_ptr, || {
+                // FIXME (#2621): This would be a good place to use a very
+                // small foreign stack
+                task::task().sched_mode(task::SingleThreaded).unlinked()
+            }, global_env_task)
         }
     }
-}
 
-#[cfg(unix)]
-pub fn getenv(n: &str) -> Option<~str> {
-    unsafe {
-        do with_env_lock {
-            let s = str::as_c_str(n, |s| libc::getenv(s));
-            if ptr::null::<u8>() == cast::reinterpret_cast(&s) {
-                option::None::<~str>
-            } else {
-                let s = cast::reinterpret_cast(&s);
-                option::Some::<~str>(str::raw::from_buf(s))
+    fn global_env_task(msg_po: oldcomm::Port<Msg>) {
+        unsafe {
+            do private::weaken_task |weak_po| {
+                loop {
+                    match oldcomm::select2(msg_po, weak_po) {
+                      either::Left(MsgGetEnv(ref n, resp_ch)) => {
+                        oldcomm::send(resp_ch, impl_::getenv(*n))
+                      }
+                      either::Left(MsgSetEnv(ref n, ref v, resp_ch)) => {
+                        oldcomm::send(resp_ch, impl_::setenv(*n, *v))
+                      }
+                      either::Left(MsgEnv(resp_ch)) => {
+                        oldcomm::send(resp_ch, impl_::env())
+                      }
+                      either::Right(_) => break
+                    }
+                }
             }
         }
     }
-}
 
-#[cfg(windows)]
-pub fn getenv(n: &str) -> Option<~str> {
-    unsafe {
-        do with_env_lock {
-            use os::win32::{as_utf16_p, fill_utf16_buf_and_decode};
-            do as_utf16_p(n) |u| {
-                do fill_utf16_buf_and_decode() |buf, sz| {
-                    libc::GetEnvironmentVariableW(u, buf, sz)
+    mod impl_ {
+        use cast;
+        use libc;
+        use option::Option;
+        use option;
+        use ptr;
+        use str;
+        use vec;
+
+        extern mod rustrt {
+            unsafe fn rust_env_pairs() -> ~[~str];
+        }
+
+        pub fn env() -> ~[(~str,~str)] {
+            unsafe {
+                let mut pairs = ~[];
+                for vec::each(rustrt::rust_env_pairs()) |p| {
+                    let vs = str::splitn_char(*p, '=', 1u);
+                    assert vec::len(vs) == 2u;
+                    pairs.push((copy vs[0], copy vs[1]));
                 }
+                move pairs
             }
         }
-    }
-}
 
+        #[cfg(unix)]
+        pub fn getenv(n: &str) -> Option<~str> {
+            unsafe {
+                let s = str::as_c_str(n, |s| libc::getenv(s));
+                return if ptr::null::<u8>() == cast::reinterpret_cast(&s) {
+                    option::None::<~str>
+                } else {
+                    let s = cast::reinterpret_cast(&s);
+                    option::Some::<~str>(str::raw::from_buf(s))
+                };
+            }
+        }
 
-#[cfg(unix)]
-pub fn setenv(n: &str, v: &str) {
-    unsafe {
-        do with_env_lock {
-            do str::as_c_str(n) |nbuf| {
-                do str::as_c_str(v) |vbuf| {
-                    libc::funcs::posix01::unistd::setenv(nbuf, vbuf, 1);
+        #[cfg(windows)]
+        pub fn getenv(n: &str) -> Option<~str> {
+            unsafe {
+                use os::win32::{as_utf16_p, fill_utf16_buf_and_decode};
+                do as_utf16_p(n) |u| {
+                    do fill_utf16_buf_and_decode() |buf, sz| {
+                        libc::GetEnvironmentVariableW(u, buf, sz)
+                    }
                 }
             }
         }
-    }
-}
 
 
-#[cfg(windows)]
-pub fn setenv(n: &str, v: &str) {
-    unsafe {
-        do with_env_lock {
-            use os::win32::as_utf16_p;
-            do as_utf16_p(n) |nbuf| {
-                do as_utf16_p(v) |vbuf| {
-                    libc::SetEnvironmentVariableW(nbuf, vbuf);
+        #[cfg(unix)]
+        pub fn setenv(n: &str, v: &str) {
+            unsafe {
+                do str::as_c_str(n) |nbuf| {
+                    do str::as_c_str(v) |vbuf| {
+                        libc::funcs::posix01::unistd::setenv(nbuf, vbuf, 1);
+                    }
                 }
             }
         }
+
+
+        #[cfg(windows)]
+        pub fn setenv(n: &str, v: &str) {
+            unsafe {
+                use os::win32::as_utf16_p;
+                do as_utf16_p(n) |nbuf| {
+                    do as_utf16_p(v) |vbuf| {
+                        libc::SetEnvironmentVariableW(nbuf, vbuf);
+                    }
+                }
+            }
+        }
+
     }
 }
 

branches/try/src/libcore/pipes.rs

@@ -1286,16 +1286,6 @@ pub fn oneshot<T: Owned>() -> (PortOne<T>, ChanOne<T>) {
     (port, chan)
 }
 
-impl<T: Owned> PortOne<T> {
-    fn recv(self) -> T { recv_one(self) }
-    fn try_recv(self) -> Option<T> { try_recv_one(self) }
-}
-
-impl<T: Owned> ChanOne<T> {
-    fn send(self, data: T) { send_one(self, data) }
-    fn try_send(self, data: T) -> bool { try_send_one(self, data) }
-}
-
 /**
  * Receive a message from a oneshot pipe, failing if the connection was
  * closed.