---

yaml
---
r: 83239
b: refs/heads/try
c: a7cf7b7
h: refs/heads/master
i:
  83237: e2f5730
  83235: 7f32ae0
  83231: f8a293d
v: v3

Author: bors

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 0e4d1fc8cae42e15e00f71d9f439b01bb25a86ae
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6c08cc2db4f98e9f07ae7d50338396c4123c2f0a
-refs/heads/try: d84a22addf09f6c7daba070732593c1e3313ed77
+refs/heads/try: a7cf7b7b0b3392bc3219e2bea44a0a18283aae50
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/mk/rt.mk

@@ -71,7 +71,6 @@ RUNTIME_CXXS_$(1)_$(2) := \
               rt/sync/lock_and_signal.cpp \
               rt/sync/rust_thread.cpp \
               rt/rust_builtin.cpp \
-              rt/rust_run_program.cpp \
               rt/rust_rng.cpp \
               rt/rust_upcall.cpp \
               rt/rust_uv.cpp \

branches/try/src/libextra/num/bigint.rs

@@ -115,8 +115,8 @@ impl TotalOrd for BigUint {
         if s_len > o_len { return Greater;  }
 
         for (&self_i, &other_i) in self.data.rev_iter().zip(other.data.rev_iter()) {
-            cond!((self_i < other_i) { return Less; }
-                  (self_i > other_i) { return Greater; })
+            if self_i < other_i { return Less; }
+            if self_i > other_i { return Greater; }
         }
         return Equal;
     }

branches/try/src/librustpkg/api.rs

@@ -16,7 +16,6 @@ use target::*;
 use version::Version;
 use workcache_support::*;
 
-use std::os;
 use extra::arc::{Arc,RWArc};
 use extra::workcache;
 use extra::workcache::{Database, Logger, FreshnessMap};
@@ -41,13 +40,11 @@ pub fn new_default_context(c: workcache::Context, p: Path) -> BuildContext {
 }
 
 fn file_is_fresh(path: &str, in_hash: &str) -> bool {
-    let path = Path(path);
-    os::path_exists(&path) && in_hash == digest_file_with_date(&path)
+    in_hash == digest_file_with_date(&Path(path))
 }
 
 fn binary_is_fresh(path: &str, in_hash: &str) -> bool {
-    let path = Path(path);
-    os::path_exists(&path) && in_hash == digest_only_date(&path)
+    in_hash == digest_only_date(&Path(path))
 }
 
 pub fn new_workcache_context(p: &Path) -> workcache::Context {

branches/try/src/librustpkg/exit_codes.rs

@@ -8,4 +8,4 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-pub static COPY_FAILED_CODE: int = 65;
+pub static copy_failed_code: int = 65;

branches/try/src/librustpkg/path_util.rs

@@ -118,6 +118,7 @@ fn target_bin_dir(workspace: &Path) -> Path {
 /// directory is, and if the file exists, return it.
 pub fn built_executable_in_workspace(pkgid: &PkgId, workspace: &Path) -> Option<Path> {
     let mut result = target_build_dir(workspace);
+    // should use a target-specific subdirectory
     result = mk_output_path(Main, Build, pkgid, result);
     debug!("built_executable_in_workspace: checking whether %s exists",
            result.to_str());

branches/try/src/librustpkg/rustpkg.rs

@@ -47,7 +47,7 @@ use package_source::PkgSrc;
 use target::{WhatToBuild, Everything, is_lib, is_main, is_test, is_bench};
 // use workcache_support::{discover_outputs, digest_only_date};
 use workcache_support::digest_only_date;
-use exit_codes::COPY_FAILED_CODE;
+use exit_codes::copy_failed_code;
 
 pub mod api;
 mod conditions;
@@ -789,10 +789,10 @@ pub fn main_args(args: &[~str]) {
         }.run(sub_cmd, rm_args.clone())
     };
     // FIXME #9262: This is using the same error code for all errors,
-    // and at least one test case succeeds if rustpkg returns COPY_FAILED_CODE,
+    // and at least one test case succeeds if rustpkg returns copy_failed_code,
     // when actually, it might set the exit code for that even if a different
     // unhandled condition got raised.
-    if result.is_err() { os::set_exit_status(COPY_FAILED_CODE); }
+    if result.is_err() { os::set_exit_status(copy_failed_code); }
 
 }
 

branches/try/src/librustpkg/tests.rs

@@ -355,13 +355,6 @@ fn executable_exists(repo: &Path, short_name: &str) -> bool {
     os::path_exists(&exec) && is_rwx(&exec)
 }
 
-fn remove_executable_file(p: &PkgId, workspace: &Path) {
-    let exec = target_executable_in_workspace(&PkgId::new(p.short_name), workspace);
-    if os::path_exists(&exec) {
-        assert!(os::remove_file(&exec));
-    }
-}
-
 fn assert_built_executable_exists(repo: &Path, short_name: &str) {
     assert!(built_executable_exists(repo, short_name));
 }
@@ -375,14 +368,6 @@ fn built_executable_exists(repo: &Path, short_name: &str) -> bool {
     }
 }
 
-fn remove_built_executable_file(p: &PkgId, workspace: &Path) {
-    let exec = built_executable_in_workspace(&PkgId::new(p.short_name), workspace);
-    match exec {
-        Some(r) => assert!(os::remove_file(&r)),
-        None    => ()
-    }
-}
-
 fn object_file_exists(repo: &Path, short_name: &str) -> bool {
     file_exists(repo, short_name, "o")
 }
@@ -1720,44 +1705,6 @@ fn test_dependencies_terminate() {
     command_line_test([~"install", ~"b"], &workspace);
 }
 
-#[test]
-fn install_after_build() {
-    let b_id = PkgId::new("b");
-    let workspace = create_local_package(&b_id);
-    command_line_test([~"build", ~"b"], &workspace);
-    command_line_test([~"install", ~"b"], &workspace);
-    assert_executable_exists(&workspace, b_id.short_name);
-    assert_lib_exists(&workspace, &b_id.path, NoVersion);
-}
-
-#[test]
-fn reinstall() {
-    let b = PkgId::new("b");
-    let workspace = create_local_package(&b);
-    // 1. Install, then remove executable file, then install again,
-    // and make sure executable was re-installed
-    command_line_test([~"install", ~"b"], &workspace);
-    assert_executable_exists(&workspace, b.short_name);
-    assert_lib_exists(&workspace, &b.path, NoVersion);
-    remove_executable_file(&b, &workspace);
-    command_line_test([~"install", ~"b"], &workspace);
-    assert_executable_exists(&workspace, b.short_name);
-    // 2. Build, then remove build executable file, then build again,
-    // and make sure executable was re-built.
-    command_line_test([~"build", ~"b"], &workspace);
-    remove_built_executable_file(&b, &workspace);
-    command_line_test([~"build", ~"b"], &workspace);
-    assert_built_executable_exists(&workspace, b.short_name);
-    // 3. Install, then remove both executable and built executable,
-    // then install again, make sure both were recreated
-    command_line_test([~"install", ~"b"], &workspace);
-    remove_executable_file(&b, &workspace);
-    remove_built_executable_file(&b, &workspace);
-    command_line_test([~"install", ~"b"], &workspace);
-    assert_executable_exists(&workspace, b.short_name);
-    assert_built_executable_exists(&workspace, b.short_name);
-}
-
 /// Returns true if p exists and is executable
 fn is_executable(p: &Path) -> bool {
     use std::libc::consts::os::posix88::{S_IXUSR};

branches/try/src/librustpkg/util.rs

@@ -283,28 +283,7 @@ pub fn compile_input(context: &BuildContext,
 
     debug!("calling compile_crate_from_input, workspace = %s,
            building_library = %?", out_dir.to_str(), sess.building_library);
-    let result = compile_crate_from_input(in_file,
-                                          exec,
-                                          context.compile_upto(),
-                                          &out_dir,
-                                          sess,
-                                          crate);
-    // Discover the output
-    let discovered_output = if what == Lib  {
-        installed_library_in_workspace(&pkg_id.path, workspace)
-    }
-    else {
-        result
-    };
-    debug!("About to discover output %s", discovered_output.to_str());
-    for p in discovered_output.iter() {
-        if os::path_exists(p) {
-            exec.discover_output("binary", p.to_str(), digest_only_date(p));
-        }
-        // Nothing to do if it doesn't exist -- that could happen if we had the
-        // -S or -emit-llvm flags, etc.
-    }
-    discovered_output
+    compile_crate_from_input(in_file, exec, context.compile_upto(), &out_dir, sess, crate)
 }
 
 // Should use workcache to avoid recompiling when not necessary

branches/try/src/libstd/char.rs

@@ -281,11 +281,11 @@ pub fn escape_unicode(c: char, f: &fn(char)) {
     // avoid calling str::to_str_radix because we don't really need to allocate
     // here.
     f('\\');
-    let pad = cond!(
-        (c <= '\xff')   { f('x'); 2 }
-        (c <= '\uffff') { f('u'); 4 }
-        _               { f('U'); 8 }
-    );
+    let pad = match () {
+        _ if c <= '\xff'    => { f('x'); 2 }
+        _ if c <= '\uffff'  => { f('u'); 4 }
+        _                   => { f('U'); 8 }
+    };
     for offset in range_step::<i32>(4 * (pad - 1), -1, -4) {
         unsafe {
             match ((c as i32) >> offset) & 0xf {
@@ -329,13 +329,13 @@ pub fn len_utf8_bytes(c: char) -> uint {
     static MAX_FOUR_B:  uint = 2097152u;
 
     let code = c as uint;
-    cond!(
-        (code < MAX_ONE_B)   { 1u }
-        (code < MAX_TWO_B)   { 2u }
-        (code < MAX_THREE_B) { 3u }
-        (code < MAX_FOUR_B)  { 4u }
-        _ { fail!("invalid character!") }
-    )
+    match () {
+        _ if code < MAX_ONE_B   => 1u,
+        _ if code < MAX_TWO_B   => 2u,
+        _ if code < MAX_THREE_B => 3u,
+        _ if code < MAX_FOUR_B  => 4u,
+        _                       => fail!("invalid character!"),
+    }
 }
 
 impl ToStr for char {

branches/try/src/libstd/num/f32.rs

@@ -206,35 +206,35 @@ impl Orderable for f32 {
     /// Returns `NaN` if either of the numbers are `NaN`.
     #[inline]
     fn min(&self, other: &f32) -> f32 {
-        cond!(
-            (self.is_NaN())  { *self  }
-            (other.is_NaN()) { *other }
-            (*self < *other) { *self  }
-            _                { *other }
-        )
+        match () {
+            _ if self.is_NaN()  => *self,
+            _ if other.is_NaN() => *other,
+            _ if *self < *other => *self,
+            _                   => *other,
+        }
     }
 
     /// Returns `NaN` if either of the numbers are `NaN`.
     #[inline]
     fn max(&self, other: &f32) -> f32 {
-        cond!(
-            (self.is_NaN())  { *self  }
-            (other.is_NaN()) { *other }
-            (*self > *other) { *self  }
-            _                { *other }
-        )
+        match () {
+            _ if self.is_NaN()  => *self,
+            _ if other.is_NaN() => *other,
+            _ if *self > *other => *self,
+            _                   => *other,
+        }
     }
 
     /// Returns the number constrained within the range `mn <= self <= mx`.
     /// If any of the numbers are `NaN` then `NaN` is returned.
     #[inline]
     fn clamp(&self, mn: &f32, mx: &f32) -> f32 {
-        cond!(
-            (self.is_NaN())   { *self }
-            (!(*self <= *mx)) { *mx   }
-            (!(*self >= *mn)) { *mn   }
-            _                 { *self }
-        )
+        match () {
+            _ if self.is_NaN()   => *self,
+            _ if !(*self <= *mx) => *mx,
+            _ if !(*self >= *mn) => *mn,
+            _                    => *self,
+        }
     }
 }
 

branches/try/src/libstd/num/f64.rs

@@ -229,35 +229,35 @@ impl Orderable for f64 {
     /// Returns `NaN` if either of the numbers are `NaN`.
     #[inline]
     fn min(&self, other: &f64) -> f64 {
-        cond!(
-            (self.is_NaN())  { *self  }
-            (other.is_NaN()) { *other }
-            (*self < *other) { *self  }
-            _                { *other }
-        )
+        match () {
+            _ if self.is_NaN()  => *self,
+            _ if other.is_NaN() => *other,
+            _ if *self < *other => *self,
+            _                   => *other,
+        }
     }
 
     /// Returns `NaN` if either of the numbers are `NaN`.
     #[inline]
     fn max(&self, other: &f64) -> f64 {
-        cond!(
-            (self.is_NaN())  { *self  }
-            (other.is_NaN()) { *other }
-            (*self > *other) { *self  }
-            _                { *other }
-        )
+        match () {
+            _ if self.is_NaN()  => *self,
+            _ if other.is_NaN() => *other,
+            _ if *self > *other => *self,
+            _                   => *other,
+        }
     }
 
     /// Returns the number constrained within the range `mn <= self <= mx`.
     /// If any of the numbers are `NaN` then `NaN` is returned.
     #[inline]
     fn clamp(&self, mn: &f64, mx: &f64) -> f64 {
-        cond!(
-            (self.is_NaN())   { *self }
-            (!(*self <= *mx)) { *mx   }
-            (!(*self >= *mn)) { *mn   }
-            _                 { *self }
-        )
+        match () {
+            _ if self.is_NaN()   => *self,
+            _ if !(*self <= *mx) => *mx,
+            _ if !(*self >= *mn) => *mn,
+            _                    => *self,
+        }
     }
 }
 

branches/try/src/libstd/num/uint_macros.rs

@@ -70,11 +70,11 @@ impl Orderable for $T {
     /// Returns the number constrained within the range `mn <= self <= mx`.
     #[inline]
     fn clamp(&self, mn: &$T, mx: &$T) -> $T {
-        cond!(
-            (*self > *mx) { *mx   }
-            (*self < *mn) { *mn   }
-            _             { *self }
-        )
+        match () {
+            _ if (*self > *mx) => *mx,
+            _ if (*self < *mn) => *mn,
+            _                  => *self,
+        }
     }
 }
 

branches/try/src/libstd/run.rs

@@ -643,15 +643,28 @@ fn spawn_process_os(prog: &str, args: &[~str],
     use libc::funcs::bsd44::getdtablesize;
 
     mod rustrt {
-        use libc::c_void;
-
         #[abi = "cdecl"]
         extern {
             pub fn rust_unset_sigprocmask();
-            pub fn rust_set_environ(envp: *c_void);
         }
     }
 
+    #[cfg(windows)]
+    unsafe fn set_environ(_envp: *c_void) {}
+    #[cfg(target_os = "macos")]
+    unsafe fn set_environ(envp: *c_void) {
+        externfn!(fn _NSGetEnviron() -> *mut *c_void);
+
+        *_NSGetEnviron() = envp;
+    }
+    #[cfg(not(target_os = "macos"), not(windows))]
+    unsafe fn set_environ(envp: *c_void) {
+        extern {
+            static mut environ: *c_void;
+        }
+        environ = envp;
+    }
+
     unsafe {
 
         let pid = fork();
@@ -685,7 +698,7 @@ fn spawn_process_os(prog: &str, args: &[~str],
 
         do with_envp(env) |envp| {
             if !envp.is_null() {
-                rustrt::rust_set_environ(envp);
+                set_environ(envp);
             }
             do with_argv(prog, args) |argv| {
                 execvp(*argv, argv);