---

yaml
---
r: 15695
b: refs/heads/try
c: 2db4259
h: refs/heads/master
i:
  15693: 0fbd0a6
  15691: 9d4b9c5
  15687: 2bcbc45
  15679: d7021b0
v: v3

Author: nikomatsakis

[refs]

@@ -2,5 +2,5 @@
 refs/heads/master: 61b1875c16de39c166b0f4d54bba19f9c6777d1a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
-refs/heads/try: 22254c3b480df40d4d3ca48a36a0f7672b8e19a5
+refs/heads/try: 2db4259b3531e0cfa1f6df2ff95e30a4c871a105
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

branches/try/configure

@@ -259,9 +259,9 @@ esac
 
 DEFAULT_HOST_TRIPLE="${CFG_CPUTYPE}-${CFG_OSTYPE}"
 
-CFG_SELF=$(echo $0 | tr '\\' '/')
-CFG_SRC_DIR="$(dirname $CFG_SELF)/"
-CFG_BUILD_DIR="$(echo $PWD | tr '\\' '/')/"
+CFG_SRC_DIR="$(cd $(dirname $0) && pwd)/"
+CFG_BUILD_DIR="$(pwd)/"
+CFG_SELF=${CFG_SRC_DIR}$(basename $0)
 CFG_CONFIGURE_ARGS="$@"
 
 OPTIONS=""
@@ -509,32 +509,25 @@ step_msg "configuring submodules"
 if [ -z $CFG_DISABLE_MANAGE_SUBMODULES ]
 then
     cd ${CFG_SRC_DIR}
+
     msg "git: submodule sync"
-    "${CFG_GIT}" submodule sync --quiet
-    SUBMODULES=$("${CFG_GIT}" submodule status | awk '{print $2}')
-    for s in $SUBMODULES
-    do
-        msg "git: submodule status ${s}"
-        status=$("${CFG_GIT}" submodule status ${s} | awk '{print $1}')
-        case ${status} in
-            -*)
-                msg "${s} is not initialized, initializing"
-                "${CFG_GIT}" submodule init --quiet ${s}
-                need_ok "git failed"
-                msg "${s} updating"
-                "${CFG_GIT}" submodule update --quiet ${s}
-                need_ok "git failed"
-                ;;
-            +*)
-                msg "${s} is not up to date, updating"
-                "${CFG_GIT}" submodule update --quiet ${s}
-                need_ok "git failed"
-                ;;
-            *)
-                msg "${s} is clean"
-                ;;
-        esac
-    done
+    "${CFG_GIT}" submodule --quiet sync
+
+    # NB: this is just for the sake of getting the submodule SHA1 values
+    # and status written into the build log.
+    msg "git: submodule status"
+    "${CFG_GIT}" submodule status --recursive
+
+    msg "git: submodule update"
+    "${CFG_GIT}" submodule --quiet update --init --recursive
+    need_ok "git failed"
+
+    msg "git: submodule clobber"
+    "${CFG_GIT}" submodule --quiet foreach --recursive git clean -dxf
+    need_ok "git failed"
+    "${CFG_GIT}" submodule --quiet foreach --recursive git checkout .
+    need_ok "git failed"
+
     cd ${CFG_BUILD_DIR}
 fi
 

branches/try/mk/tests.mk

@@ -120,6 +120,7 @@ ALL_HS := $(filter-out $(S)src/rt/vg/valgrind.h \
 tidy:
 		@$(call E, check: formatting)
 		$(Q)find $(S)src -name '*.r[sc]' \
+		| grep '^$(S)src/test' -v \
 		| xargs -n 10 python $(S)src/etc/tidy.py
 		$(Q)find $(S)src/etc -name '*.py' \
 		| xargs -n 10 python $(S)src/etc/tidy.py

branches/try/src/etc/tidy.py

@@ -32,9 +32,7 @@ def report_err(s):
             report_err("trailing whitespace")
         line_len = len(line)-2 if autocrlf else len(line)-1
 
-        # Along long lines if they are part of an expected error message
-        # in a test, which is denoted with "//!":
-        if line_len > cols and "//!" not in line:
+        if line_len > cols:
             report_err("line longer than %d chars" % cols)
 except UnicodeDecodeError, e:
     report_err("UTF-8 decoding error " + str(e))

branches/try/src/libcore/os.rs

@@ -121,61 +121,141 @@ mod win32 {
     }
 }
 
+fn getenv(n: str) -> option<str> {
+    global_env::getenv(n)
+}
 
-#[cfg(target_os = "linux")]
-#[cfg(target_os = "macos")]
-#[cfg(target_os = "freebsd")]
-fn getenv(n: str) -> option<str> unsafe {
-    let s = as_c_charp(n, libc::getenv);
-    ret if unsafe::reinterpret_cast(s) == 0 {
-            option::none::<str>
-        } else {
-            let s = unsafe::reinterpret_cast(s);
-            option::some::<str>(str::unsafe::from_buf(s))
-        };
+fn setenv(n: str, v: str) {
+    global_env::setenv(n, v)
 }
 
-#[cfg(target_os = "win32")]
-fn getenv(n: str) -> option<str> unsafe {
-    import libc::types::os::arch::extra::*;
-    import libc::funcs::extra::kernel32::*;
-    import win32::*;
-    as_utf16_p(n) {|u|
-        fill_utf16_buf_and_decode() {|buf, sz|
-            GetEnvironmentVariableW(u, buf, sz)
-        }
+mod global_env {
+    #[doc = "Internal module for serializing access to getenv/setenv"];
+
+    export getenv;
+    export setenv;
+
+    native mod rustrt {
+        fn rust_global_env_chan_ptr() -> *libc::uintptr_t;
     }
-}
 
+    enum msg {
+        msg_getenv(str, comm::chan<option<str>>),
+        msg_setenv(str, str, comm::chan<()>)
+    }
 
-#[cfg(target_os = "linux")]
-#[cfg(target_os = "macos")]
-#[cfg(target_os = "freebsd")]
-fn setenv(n: str, v: str) {
+    fn getenv(n: str) -> option<str> {
+        let env_ch = get_global_env_chan();
+        let po = comm::port();
+        comm::send(env_ch, msg_getenv(n, comm::chan(po)));
+        comm::recv(po)
+    }
 
-    // FIXME: remove this when export globs work properly.
-    import libc::funcs::posix01::unistd::setenv;
-    as_c_charp(n) {|nbuf|
-        as_c_charp(v) {|vbuf|
-            setenv(nbuf, vbuf, 1i32);
+    fn setenv(n: str, v: str) {
+        let env_ch = get_global_env_chan();
+        let po = comm::port();
+        comm::send(env_ch, msg_setenv(n, v, comm::chan(po)));
+        comm::recv(po)
+    }
+
+    fn get_global_env_chan() -> comm::chan<msg> {
+        let global_ptr = rustrt::rust_global_env_chan_ptr();
+        let builder_fn = {||
+            let builder = task::builder();
+            task::unsupervise(builder);
+            task::set_opts(builder, {
+                sched:  some({
+                    mode: task::single_threaded,
+                    // FIXME: This would be a good place to use
+                    // a very small native stack
+                    native_stack_size: none
+                })
+                with task::get_opts(builder)
+            });
+            builder
+        };
+        unsafe {
+            priv::chan_from_global_ptr(
+                global_ptr, builder_fn, global_env_task)
         }
     }
-}
 
+    fn global_env_task(msg_po: comm::port<msg>) unsafe {
+        priv::weaken_task {|weak_po|
+            loop {
+                alt comm::select2(msg_po, weak_po) {
+                  either::left(msg_getenv(n, resp_ch)) {
+                    comm::send(resp_ch, impl::getenv(n))
+                  }
+                  either::left(msg_setenv(n, v, resp_ch)) {
+                    comm::send(resp_ch, impl::setenv(n, v))
+                  }
+                  either::right(_) {
+                    break;
+                  }
+                }
+            }
+        }
+    }
 
-#[cfg(target_os = "win32")]
-fn setenv(n: str, v: str) {
-    // FIXME: remove imports when export globs work properly.
-    import libc::funcs::extra::kernel32::*;
-    import win32::*;
-    as_utf16_p(n) {|nbuf|
-        as_utf16_p(v) {|vbuf|
-            SetEnvironmentVariableW(nbuf, vbuf);
+    mod impl {
+
+        #[cfg(target_os = "linux")]
+        #[cfg(target_os = "macos")]
+        #[cfg(target_os = "freebsd")]
+        fn getenv(n: str) -> option<str> unsafe {
+            let s = str::as_c_str(n, libc::getenv);
+            ret if unsafe::reinterpret_cast(s) == 0 {
+                option::none::<str>
+            } else {
+                let s = unsafe::reinterpret_cast(s);
+                option::some::<str>(str::unsafe::from_buf(s))
+            };
+        }
+
+        #[cfg(target_os = "win32")]
+        fn getenv(n: str) -> option<str> unsafe {
+            import libc::types::os::arch::extra::*;
+            import libc::funcs::extra::kernel32::*;
+            import win32::*;
+            as_utf16_p(n) {|u|
+                fill_utf16_buf_and_decode() {|buf, sz|
+                    GetEnvironmentVariableW(u, buf, sz)
+                }
+            }
+        }
+
+
+        #[cfg(target_os = "linux")]
+        #[cfg(target_os = "macos")]
+        #[cfg(target_os = "freebsd")]
+        fn setenv(n: str, v: str) {
+
+            // FIXME: remove this when export globs work properly.
+            import libc::funcs::posix01::unistd::setenv;
+            str::as_c_str(n) {|nbuf|
+                str::as_c_str(v) {|vbuf|
+                    setenv(nbuf, vbuf, 1i32);
+                }
+            }
+        }
+
+
+        #[cfg(target_os = "win32")]
+        fn setenv(n: str, v: str) {
+            // FIXME: remove imports when export globs work properly.
+            import libc::funcs::extra::kernel32::*;
+            import win32::*;
+            as_utf16_p(n) {|nbuf|
+                as_utf16_p(v) {|vbuf|
+                    SetEnvironmentVariableW(nbuf, vbuf);
+                }
+            }
         }
+
     }
 }
 
-
 fn fdopen(fd: c_int) -> *FILE {
     ret as_c_charp("r") {|modebuf|
         libc::fdopen(fd, modebuf)
@@ -726,15 +806,13 @@ mod tests {
     }
 
     #[test]
-    #[ignore(reason = "fails periodically on mac")]
     fn test_setenv() {
         let n = make_rand_name();
         setenv(n, "VALUE");
         assert getenv(n) == option::some("VALUE");
     }
 
     #[test]
-    #[ignore(reason = "fails periodically on mac")]
     fn test_setenv_overwrite() {
         let n = make_rand_name();
         setenv(n, "1");
@@ -747,7 +825,6 @@ mod tests {
     // Windows GetEnvironmentVariable requires some extra work to make sure
     // the buffer the variable is copied into is the right size
     #[test]
-    #[ignore(reason = "fails periodically on mac")]
     fn test_getenv_big() {
         let mut s = "";
         let mut i = 0;

branches/try/src/libcore/priv.rs

@@ -14,15 +14,15 @@ native mod rustrt {
     fn rust_task_unweaken(ch: rust_port_id);
 }
 
-type global_ptr<T: send> = *libc::uintptr_t;
+type global_ptr = *libc::uintptr_t;
 
 #[doc = "
 Atomically gets a channel from a pointer to a pointer-sized memory location
 or, if no channel exists creates and installs a new channel and sets up a new
 task to receive from it.
 "]
 unsafe fn chan_from_global_ptr<T: send>(
-    global: global_ptr<T>,
+    global: global_ptr,
     builder: fn() -> task::builder,
     f: fn~(comm::port<T>)
 ) -> comm::chan<T> {

branches/try/src/libcore/vec.rs

@@ -1168,7 +1168,9 @@ mod unsafe {
     #[inline(always)]
     unsafe fn form_slice<T,U>(p: *T, len: uint, f: fn([T]/&) -> U) -> U {
         let pair = (p, len * sys::size_of::<T>());
-        let v : *([T]/&) = ::unsafe::reinterpret_cast(ptr::addr_of(pair));
+        // FIXME: should use &blk not &static here, but a snapshot is req'd
+        let v : *([T]/&static) =
+            ::unsafe::reinterpret_cast(ptr::addr_of(pair));
         f(*v)
     }
 }

branches/try/src/librustsyntax/ast.rs

@@ -452,11 +452,7 @@ enum prim_ty {
 type region = {id: node_id, node: region_};
 
 #[auto_serialize]
-enum region_ {
-    re_anon,
-    re_named(ident),
-    re_static
-}
+enum region_ { re_anon, re_named(ident) }
 
 #[auto_serialize]
 enum ty_ {

branches/try/src/librustsyntax/diagnostic.rs

@@ -105,7 +105,7 @@ impl codemap_handler of handler for handler_t {
 }
 
 fn ice_msg(msg: str) -> str {
-    #fmt["internal compiler error %s", msg]
+    #fmt["internal compiler error: %s", msg]
 }
 
 fn mk_span_handler(handler: handler, cm: codemap::codemap) -> span_handler {

branches/try/src/librustsyntax/parse.rs

@@ -152,7 +152,7 @@ fn new_parser_from_file(sess: parse_sess, cfg: ast::crate_cfg, path: str,
    parser {
     let src = alt io::read_whole_file_str(path) {
       result::ok(src) {
-        // FIXME: This copy is unfortunate
+        // FIXME: This copy is unfortunate (#2319)
         @src
       }
       result::err(e) {

branches/try/src/librustsyntax/parse/parser.rs

@@ -250,16 +250,7 @@ fn parse_ret_ty(p: parser) -> (ast::ret_style, @ast::ty) {
 
 fn region_from_name(p: parser, s: option<str>) -> @ast::region {
     let r = alt s {
-      some (string) {
-        // FIXME: To be consistent with our type resolution, the
-        // static region should probably be resolved during type
-        // checking, not in the parser. (Issue #2256)
-        if string == "static" {
-            ast::re_static
-        } else {
-            ast::re_named(string)
-        }
-      }
+      some (string) { ast::re_named(string) }
       none { ast::re_anon }
     };
 

branches/try/src/librustsyntax/print/pprust.rs

@@ -329,7 +329,6 @@ fn print_native_mod(s: ps, nmod: ast::native_mod, attrs: [ast::attribute]) {
 fn print_region(s: ps, region: @ast::region) {
     alt region.node {
       ast::re_anon { word_space(s, "&"); }
-      ast::re_static { word_space(s, "&static"); }
       ast::re_named(name) {
         word(s.s, "&");
         word_space(s, name);

branches/try/src/libstd/getopts.rs

@@ -4,12 +4,12 @@ Simple getopt alternative.
 Construct a vector of options, either by using reqopt, optopt, and optflag or
 by building them from components yourself, and pass them to getopts, along
 with a vector of actual arguments (not including argv[0]). You'll either get a
-failure code back, or a match. You'll have to verify whether the amount of
+failure code back, or a match.  You'll have to verify whether the amount of
 'free' arguments in the match is what you expect. Use opt_* accessors to get
 argument values out of the match object.
 
 Single-character options are expected to appear on the command line with a
-single preceding dash; multiple-character options are expected to be
+single preceeding dash; multiple-character options are expected to be
 proceeded by two dashes. Options that expect an argument accept their argument
 following either a space or an equals sign.