---

yaml
---
r: 178719
b: refs/heads/master
c: a3d2d35
h: refs/heads/master
i:
  178717: 0da01e1
  178715: a9b8a04
  178711: 7ade4ff
  178703: 10ddefc
  178687: 17ab0db
v: v3

Author: dotdash

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 3d072a193bfcb76206aab576049e696d6d8db25d
+refs/heads/master: a3d2d35fcbdc4ef5afc1fff2cc6d5ba34004cef4
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 3b2ed14906fd9f9daa27cc7d1dad263d2f5ff450
 refs/heads/try: ccf8fedf1cffcb8f6f3581d53d220039e192fe77

trunk/COPYRIGHT

@@ -23,12 +23,12 @@ The following third party packages are included, and carry
 their own copyright notices and license terms:
 
 * Two header files that are part of the Valgrind
-  package. These files are found at src/rt/valgrind/valgrind.h and
-  src/rt/valgrind/memcheck.h, within this distribution. These files
+  package. These files are found at src/rt/vg/valgrind.h and
+  src/rt/vg/memcheck.h, within this distribution. These files
   are redistributed under the following terms, as noted in
   them:
 
-  for src/rt/valgrind/valgrind.h:
+  for src/rt/vg/valgrind.h:
 
     This file is part of Valgrind, a dynamic binary
     instrumentation framework.
@@ -74,7 +74,7 @@ their own copyright notices and license terms:
     USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
     OF SUCH DAMAGE.
 
-  for src/rt/valgrind/memcheck.h:
+  for src/rt/vg/memcheck.h:
 
     This file is part of MemCheck, a heavyweight Valgrind
     tool for detecting memory errors.
@@ -120,6 +120,18 @@ their own copyright notices and license terms:
     USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
     OF SUCH DAMAGE.
 
+* The auxiliary file src/etc/pkg/modpath.iss contains a
+  library routine compiled, by Inno Setup, into the Windows
+  installer binary. This file is licensed under the LGPL,
+  version 3, but, in our legal interpretation, this does not
+  affect the aggregate "collected work" license of the Rust
+  distribution (MIT/ASL2) nor any other components of it. We
+  believe that the terms governing distribution of the
+  binary Windows installer built from modpath.iss are
+  therefore LGPL, but not the terms governing distribution
+  of any of the files installed by such an installer (such
+  as the Rust compiler or runtime libraries themselves).
+
 * The src/rt/miniz.c file, carrying an implementation of
   RFC1950/RFC1951 DEFLATE, by Rich Geldreich
   <[email protected]>. All uses of this file are

trunk/configure

@@ -374,10 +374,6 @@ case $CFG_OSTYPE in
         CFG_OSTYPE=unknown-dragonfly
         ;;
 
-    OpenBSD)
-	CFG_OSTYPE=unknown-openbsd
-       ;;
-
     Darwin)
         CFG_OSTYPE=apple-darwin
         ;;

trunk/mk/cfg/x86_64-unknown-openbsd.mk

@@ -22,7 +22,6 @@
 #![feature(std_misc)]
 #![feature(test)]
 #![feature(unicode)]
-#![feature(env)]
 
 #![deny(warnings)]
 
@@ -32,7 +31,7 @@ extern crate getopts;
 #[macro_use]
 extern crate log;
 
-use std::env;
+use std::os;
 use std::old_io;
 use std::old_io::fs;
 use std::thunk::Thunk;
@@ -49,7 +48,7 @@ pub mod common;
 pub mod errors;
 
 pub fn main() {
-    let args = env::args().map(|s| s.into_string().unwrap()).collect();;
+    let args = os::args();
     let config = parse_config(args);
 
     if config.valgrind_path.is_none() && config.force_valgrind {
@@ -225,15 +224,15 @@ pub fn run_tests(config: &Config) {
         //arm-linux-androideabi debug-info test uses remote debugger
         //so, we test 1 task at once.
         // also trying to isolate problems with adb_run_wrapper.sh ilooping
-        env::set_var("RUST_TEST_TASKS","1");
+        os::setenv("RUST_TEST_TASKS","1");
     }
 
     match config.mode {
         DebugInfoLldb => {
             // Some older versions of LLDB seem to have problems with multiple
             // instances running in parallel, so only run one test task at a
             // time.
-            env::set_var("RUST_TEST_TASKS", "1");
+            os::setenv("RUST_TEST_TASKS", "1");
         }
         _ => { /* proceed */ }
     }
@@ -246,7 +245,7 @@ pub fn run_tests(config: &Config) {
     old_io::test::raise_fd_limit();
     // Prevent issue #21352 UAC blocking .exe containing 'patch' etc. on Windows
     // If #11207 is resolved (adding manifest to .exe) this becomes unnecessary
-    env::set_var("__COMPAT_LAYER", "RunAsInvoker");
+    os::setenv("__COMPAT_LAYER", "RunAsInvoker");
     let res = test::run_tests_console(&opts, tests.into_iter().collect());
     match res {
         Ok(true) => {}
@@ -277,7 +276,7 @@ pub fn make_tests(config: &Config) -> Vec<test::TestDescAndFn> {
            config.src_base.display());
     let mut tests = Vec::new();
     let dirs = fs::readdir(&config.src_base).unwrap();
-    for file in &dirs {
+    for file in dirs.iter() {
         let file = file.clone();
         debug!("inspecting file {:?}", file.display());
         if is_test(config, &file) {
@@ -305,13 +304,13 @@ pub fn is_test(config: &Config, testfile: &Path) -> bool {
 
     let mut valid = false;
 
-    for ext in &valid_extensions {
+    for ext in valid_extensions.iter() {
         if name.ends_with(ext.as_slice()) {
             valid = true;
         }
     }
 
-    for pre in &invalid_prefixes {
+    for pre in invalid_prefixes.iter() {
         if name.starts_with(pre.as_slice()) {
             valid = false;
         }

trunk/src/compiletest/compiletest.rs

@@ -300,8 +300,8 @@ fn parse_exec_env(line: &str) -> Option<(String, String)> {
                                       .collect();
 
         match strs.len() {
-          1 => (strs.pop().unwrap(), "".to_string()),
-          2 => {
+          1u => (strs.pop().unwrap(), "".to_string()),
+          2u => {
               let end = strs.pop().unwrap();
               (strs.pop().unwrap(), end)
           }

trunk/src/compiletest/header.rs

@@ -40,13 +40,13 @@ pub fn run(lib_path: &str,
     let mut cmd = Command::new(prog);
     cmd.args(args);
     add_target_env(&mut cmd, lib_path, aux_path);
-    for (key, val) in env {
+    for (key, val) in env.into_iter() {
         cmd.env(key, val);
     }
 
     match cmd.spawn() {
         Ok(mut process) => {
-            if let Some(input) = input {
+            for input in input.iter() {
                 process.stdin.as_mut().unwrap().write_all(input.as_bytes()).unwrap();
             }
             let ProcessOutput { status, output, error } =
@@ -72,13 +72,13 @@ pub fn run_background(lib_path: &str,
     let mut cmd = Command::new(prog);
     cmd.args(args);
     add_target_env(&mut cmd, lib_path, aux_path);
-    for (key, val) in env {
+    for (key, val) in env.into_iter() {
         cmd.env(key, val);
     }
 
     match cmd.spawn() {
         Ok(mut process) => {
-            if let Some(input) = input {
+            for input in input.iter() {
                 process.stdin.as_mut().unwrap().write_all(input.as_bytes()).unwrap();
             }
 

trunk/src/compiletest/procsrv.rs

@@ -31,7 +31,7 @@ use std::old_io::process::ProcessExit;
 use std::old_io::process;
 use std::old_io::timer;
 use std::old_io;
-use std::env;
+use std::os;
 use std::iter::repeat;
 use std::str;
 use std::string::String;
@@ -230,9 +230,9 @@ fn run_pretty_test(config: &Config, props: &TestProps, testfile: &Path) {
             let s = File::open(&filepath).read_to_end().unwrap();
             String::from_utf8(s).unwrap()
         }
-        None => { srcs[srcs.len() - 2].clone() }
+        None => { srcs[srcs.len() - 2u].clone() }
     };
-    let mut actual = srcs[srcs.len() - 1].clone();
+    let mut actual = srcs[srcs.len() - 1u].clone();
 
     if props.pp_exact.is_some() {
         // Now we have to care about line endings
@@ -547,7 +547,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
                                          exe_file.as_str().unwrap().replace("\\", "\\\\"))[]);
 
             // Add line breakpoints
-            for line in &breakpoint_lines {
+            for line in breakpoint_lines.iter() {
                 script_str.push_str(&format!("break '{}':{}\n",
                                              testfile.filename_display(),
                                              *line)[]);
@@ -683,13 +683,13 @@ fn run_debuginfo_lldb_test(config: &Config, props: &TestProps, testfile: &Path)
     script_str.push_str("type category enable Rust\n");
 
     // Set breakpoints on every line that contains the string "#break"
-    for line in &breakpoint_lines {
+    for line in breakpoint_lines.iter() {
         script_str.push_str(format!("breakpoint set --line {}\n",
                                     line).as_slice());
     }
 
     // Append the other commands
-    for line in &commands {
+    for line in commands.iter() {
         script_str.push_str(line.as_slice());
         script_str.push_str("\n");
     }
@@ -842,12 +842,12 @@ fn check_debugger_output(debugger_run_result: &ProcRes, check_lines: &[String])
             }).collect();
         // check if each line in props.check_lines appears in the
         // output (in order)
-        let mut i = 0;
+        let mut i = 0u;
         for line in debugger_run_result.stdout.lines() {
             let mut rest = line.trim();
             let mut first = true;
             let mut failed = false;
-            for frag in &check_fragments[i] {
+            for frag in check_fragments[i].iter() {
                 let found = if first {
                     if rest.starts_with(frag.as_slice()) {
                         Some(0)
@@ -869,7 +869,7 @@ fn check_debugger_output(debugger_run_result: &ProcRes, check_lines: &[String])
                 first = false;
             }
             if !failed && rest.len() == 0 {
-                i += 1;
+                i += 1u;
             }
             if i == num_check_lines {
                 // all lines checked
@@ -892,13 +892,13 @@ fn check_error_patterns(props: &TestProps,
         fatal(format!("no error pattern specified in {:?}",
                       testfile.display()).as_slice());
     }
-    let mut next_err_idx = 0;
+    let mut next_err_idx = 0u;
     let mut next_err_pat = &props.error_patterns[next_err_idx];
     let mut done = false;
     for line in output_to_check.lines() {
         if line.contains(next_err_pat.as_slice()) {
             debug!("found error pattern {}", next_err_pat);
-            next_err_idx += 1;
+            next_err_idx += 1u;
             if next_err_idx == props.error_patterns.len() {
                 debug!("found all error patterns");
                 done = true;
@@ -910,12 +910,12 @@ fn check_error_patterns(props: &TestProps,
     if done { return; }
 
     let missing_patterns = &props.error_patterns[next_err_idx..];
-    if missing_patterns.len() == 1 {
+    if missing_patterns.len() == 1u {
         fatal_proc_rec(format!("error pattern '{}' not found!",
                               missing_patterns[0]).as_slice(),
                       proc_res);
     } else {
-        for pattern in missing_patterns {
+        for pattern in missing_patterns.iter() {
             error(format!("error pattern '{}' not found!",
                           *pattern).as_slice());
         }
@@ -935,7 +935,7 @@ fn check_no_compiler_crash(proc_res: &ProcRes) {
 fn check_forbid_output(props: &TestProps,
                        output_to_check: &str,
                        proc_res: &ProcRes) {
-    for pat in &props.forbid_output {
+    for pat in props.forbid_output.iter() {
         if output_to_check.contains(pat.as_slice()) {
             fatal_proc_rec("forbidden pattern found in compiler output", proc_res);
         }
@@ -1025,7 +1025,7 @@ fn check_expected_errors(expected_errors: Vec<errors::ExpectedError> ,
 }
 
 fn is_compiler_error_or_warning(line: &str) -> bool {
-    let mut i = 0;
+    let mut i = 0u;
     return
         scan_until_char(line, ':', &mut i) &&
         scan_char(line, ':', &mut i) &&
@@ -1084,7 +1084,7 @@ fn scan_integer(haystack: &str, idx: &mut uint) -> bool {
 
 fn scan_string(haystack: &str, needle: &str, idx: &mut uint) -> bool {
     let mut haystack_i = *idx;
-    let mut needle_i = 0;
+    let mut needle_i = 0u;
     while needle_i < needle.len() {
         if haystack_i >= haystack.len() {
             return false;
@@ -1173,7 +1173,7 @@ fn compose_and_run_compiler(
     // FIXME (#9639): This needs to handle non-utf8 paths
     let extra_link_args = vec!("-L".to_string(), aux_dir.as_str().unwrap().to_string());
 
-    for rel_ab in &props.aux_builds {
+    for rel_ab in props.aux_builds.iter() {
         let abs_ab = config.aux_base.join(rel_ab.as_slice());
         let aux_props = header::load_props(&abs_ab);
         let mut crate_type = if aux_props.no_prefer_dynamic {
@@ -1298,9 +1298,9 @@ fn make_lib_name(config: &Config, auxfile: &Path, testfile: &Path) -> Path {
 
 fn make_exe_name(config: &Config, testfile: &Path) -> Path {
     let mut f = output_base_name(config, testfile);
-    if !env::consts::EXE_SUFFIX.is_empty() {
+    if !os::consts::EXE_SUFFIX.is_empty() {
         let mut fname = f.filename().unwrap().to_vec();
-        fname.extend(env::consts::EXE_SUFFIX.bytes());
+        fname.extend(os::consts::EXE_SUFFIX.bytes());
         f.set_filename(fname);
     }
     f
@@ -1503,14 +1503,14 @@ fn _arm_exec_compiled_test(config: &Config,
 
     // run test via adb_run_wrapper
     runargs.push("shell".to_string());
-    for (key, val) in env {
+    for (key, val) in env.into_iter() {
         runargs.push(format!("{}={}", key, val));
     }
     runargs.push(format!("{}/adb_run_wrapper.sh", config.adb_test_dir));
     runargs.push(format!("{}", config.adb_test_dir));
     runargs.push(format!("{}", prog_short));
 
-    for tv in &args.args {
+    for tv in args.args.iter() {
         runargs.push(tv.to_string());
     }
     procsrv::run("",
@@ -1591,7 +1591,7 @@ fn _arm_push_aux_shared_library(config: &Config, testfile: &Path) {
     let tdir = aux_output_dir_name(config, testfile);
 
     let dirs = fs::readdir(&tdir).unwrap();
-    for file in &dirs {
+    for file in dirs.iter() {
         if file.extension_str() == Some("so") {
             // FIXME (#9639): This needs to handle non-utf8 paths
             let copy_result = procsrv::run("",