---

yaml
---
r: 15694
b: refs/heads/try
c: 22254c3
h: refs/heads/master
v: v3

Author: bkircher

[refs]

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

branches/try/configure

@@ -259,9 +259,9 @@ esac
 
 DEFAULT_HOST_TRIPLE="${CFG_CPUTYPE}-${CFG_OSTYPE}"
 
-CFG_SRC_DIR="$(cd $(dirname $0) && pwd)/"
-CFG_BUILD_DIR="$(pwd)/"
-CFG_SELF=${CFG_SRC_DIR}$(basename $0)
+CFG_SELF=$(echo $0 | tr '\\' '/')
+CFG_SRC_DIR="$(dirname $CFG_SELF)/"
+CFG_BUILD_DIR="$(echo $PWD | tr '\\' '/')/"
 CFG_CONFIGURE_ARGS="$@"
 
 OPTIONS=""
@@ -509,25 +509,32 @@ step_msg "configuring submodules"
 if [ -z $CFG_DISABLE_MANAGE_SUBMODULES ]
 then
     cd ${CFG_SRC_DIR}
-
     msg "git: submodule sync"
-    "${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"
-
+    "${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
     cd ${CFG_BUILD_DIR}
 fi
 

branches/try/mk/tests.mk

@@ -120,7 +120,6 @@ 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,7 +32,9 @@ def report_err(s):
             report_err("trailing whitespace")
         line_len = len(line)-2 if autocrlf else len(line)-1
 
-        if line_len > cols:
+        # 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:
             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,141 +121,61 @@ mod win32 {
     }
 }
 
-fn getenv(n: str) -> option<str> {
-    global_env::getenv(n)
-}
-
-fn setenv(n: str, v: str) {
-    global_env::setenv(n, v)
-}
 
-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<()>)
-    }
-
-    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)
-    }
-
-    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
+#[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))
         };
-        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 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 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) {
+#[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);
-                }
-            }
+    // 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);
         }
+    }
+}
 
 
-        #[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);
-                }
-            }
+#[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)
@@ -806,13 +726,15 @@ 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");
@@ -825,6 +747,7 @@ 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/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 (#2319)
+        // FIXME: This copy is unfortunate
         @src
       }
       result::err(e) {

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 preceeding dash; multiple-character options are expected to be
+single preceding 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.