---

yaml
---
r: 58811
b: refs/heads/incoming
c: 5fb5a94
h: refs/heads/master
i:
  58809: 8509c35
  58807: a23a1a0
v: v3

Author: catamorphism

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c50a9d5b664478e533ba1d1d353213d70c8ad589
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/incoming: c42f1218a0a7b3a5c84502f9cb4b123d65148f4c
+refs/heads/incoming: 5fb5a94118399e50c50f25586266c317ee5ba69b
 refs/heads/dist-snap: 00dbbd01c2aee72982b3e0f9511ae1d4428c3ba9
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/src/libcore/os.rs

@@ -772,28 +772,6 @@ pub fn list_dir_path(p: &Path) -> ~[~Path] {
     list_dir(p).map(|f| ~p.push(*f))
 }
 
-/// Removes a directory at the specified path, after removing
-/// all its contents. Use carefully!
-pub fn remove_dir_recursive(p: &Path) -> bool {
-    let mut error_happened = false;
-    for walk_dir(p) |inner| {
-        if !error_happened {
-            if path_is_dir(inner) {
-                if !remove_dir_recursive(inner) {
-                    error_happened = true;
-                }
-            }
-            else {
-                if !remove_file(inner) {
-                    error_happened = true;
-                }
-            }
-        }
-    };
-    // Directory should now be empty
-    !error_happened && remove_dir(p)
-}
-
 /// Removes a directory at the specified path
 pub fn remove_dir(p: &Path) -> bool {
    return rmdir(p);
@@ -899,10 +877,6 @@ pub fn copy_file(from: &Path, to: &Path) -> bool {
             if istream as uint == 0u {
                 return false;
             }
-            // Preserve permissions
-            let from_mode = from.get_mode().expect("copy_file: couldn't get permissions \
-                                                    for source file");
-
             let ostream = do as_c_charp(to.to_str()) |top| {
                 do as_c_charp("w+b") |modebuf| {
                     libc::fopen(top, modebuf)
@@ -934,15 +908,6 @@ pub fn copy_file(from: &Path, to: &Path) -> bool {
             }
             fclose(istream);
             fclose(ostream);
-
-            // Give the new file the old file's permissions
-            unsafe {
-                if do str::as_c_str(to.to_str()) |to_buf| {
-                    libc::chmod(to_buf, from_mode as mode_t)
-                } != 0 {
-                    return false; // should be a condition...
-                }
-            }
             return ok;
         }
     }
@@ -1629,15 +1594,13 @@ mod tests {
                       == buf.len() as size_t))
           }
           assert!((libc::fclose(ostream) == (0u as c_int)));
-          let in_mode = in.get_mode();
           let rs = os::copy_file(&in, &out);
           if (!os::path_exists(&in)) {
             fail!(fmt!("%s doesn't exist", in.to_str()));
           }
           assert!((rs));
           let rslt = run::run_program(~"diff", ~[in.to_str(), out.to_str()]);
           assert!((rslt == 0));
-          assert!(out.get_mode() == in_mode);
           assert!((remove_file(&in)));
           assert!((remove_file(&out)));
         }

branches/incoming/src/libcore/task/mod.rs

@@ -39,7 +39,7 @@ use result::Result;
 use comm::{stream, Chan, GenericChan, GenericPort, Port};
 use prelude::*;
 use result;
-use task::rt::{task_id, sched_id, rust_task};
+use task::rt::{task_id, sched_id};
 use util;
 use util::replace;
 use unstable::finally::Finally;

branches/incoming/src/libcore/unstable/lang.rs

@@ -17,7 +17,9 @@ use str;
 use sys;
 use unstable::exchange_alloc;
 use cast::transmute;
+#[cfg(not(stage0))]
 use rt::{context, OldTaskContext};
+#[cfg(not(stage0))]
 use rt::local_services::borrow_local_services;
 
 #[allow(non_camel_case_types)]

branches/incoming/src/librustc/back/rpath.rs

@@ -40,7 +40,7 @@ pub fn get_rpath_flags(sess: session::Session, out_filename: &Path)
     // where rustrt is and we know every rust program needs it
     let libs = vec::append_one(libs, get_sysroot_absolute_rt_lib(sess));
 
-    let rpaths = get_rpaths(os, sysroot, output, libs,
+    let rpaths = get_rpaths(os, &sysroot, output, libs,
                             sess.opts.target_triple);
     rpaths_to_flags(rpaths)
 }

branches/incoming/src/librustc/driver/driver.rs

@@ -603,7 +603,7 @@ pub fn build_session_options(binary: @~str,
             link::output_type_bitcode
         } else { link::output_type_exe };
     let sysroot_opt = getopts::opt_maybe_str(matches, ~"sysroot");
-    let sysroot_opt = sysroot_opt.map(|m| @Path(*m));
+    let sysroot_opt = sysroot_opt.map(|m| Path(*m));
     let target_opt = getopts::opt_maybe_str(matches, ~"target");
     let target_feature_opt = getopts::opt_maybe_str(matches, ~"target-feature");
     let save_temps = getopts::opt_present(matches, ~"save-temps");

branches/incoming/src/librustc/driver/session.rs

@@ -125,7 +125,7 @@ pub struct options {
     output_type: back::link::output_type,
     addl_lib_search_paths: ~[Path],
     linker_args: ~[~str],
-    maybe_sysroot: Option<@Path>,
+    maybe_sysroot: Option<Path>,
     target_triple: ~str,
     target_feature: ~str,
     // User-specified cfg meta items. The compiler itself will add additional

branches/incoming/src/librustc/metadata/filesearch.rs

@@ -20,49 +20,41 @@ pub fn pick_file(file: Path, path: &Path) -> Option<Path> {
 }
 
 pub trait FileSearch {
-    fn sysroot(&self) -> @Path;
-    fn for_each_lib_search_path(&self, f: &fn(&Path) -> bool);
+    fn sysroot(&self) -> Path;
+    fn lib_search_paths(&self) -> ~[Path];
     fn get_target_lib_path(&self) -> Path;
     fn get_target_lib_file_path(&self, file: &Path) -> Path;
 }
 
-pub fn mk_filesearch(maybe_sysroot: &Option<@Path>,
+pub fn mk_filesearch(maybe_sysroot: &Option<Path>,
                      target_triple: &str,
                      addl_lib_search_paths: ~[Path])
                   -> @FileSearch {
     struct FileSearchImpl {
-        sysroot: @Path,
+        sysroot: Path,
         addl_lib_search_paths: ~[Path],
         target_triple: ~str
     }
     impl FileSearch for FileSearchImpl {
-        fn sysroot(&self) -> @Path { self.sysroot }
-        fn for_each_lib_search_path(&self, f: &fn(&Path) -> bool) {
-            debug!("filesearch: searching additional lib search paths");
-            if !self.addl_lib_search_paths.each(f) {
-                return;
+        fn sysroot(&self) -> Path { /*bad*/copy self.sysroot }
+        fn lib_search_paths(&self) -> ~[Path] {
+            let mut paths = /*bad*/copy self.addl_lib_search_paths;
+
+            paths.push(
+                make_target_lib_path(&self.sysroot,
+                                     self.target_triple));
+            match get_rustpkg_lib_path_nearest() {
+              result::Ok(ref p) => paths.push((/*bad*/copy *p)),
+              result::Err(_) => ()
             }
-
-            debug!("filesearch: searching target lib path");
-            if !f(&make_target_lib_path(self.sysroot,
-                                        self.target_triple)) {
-                return;
+            match get_rustpkg_lib_path() {
+              result::Ok(ref p) => paths.push((/*bad*/copy *p)),
+              result::Err(_) => ()
             }
-            debug!("filesearch: searching rustpkg lib path nearest");
-            if match get_rustpkg_lib_path_nearest() {
-                    result::Ok(ref p) => f(p),
-                    result::Err(_) => true
-                } {
-                    return;
-                }
-           debug!("filesearch: searching rustpkg lib path");
-           match get_rustpkg_lib_path() {
-              result::Ok(ref p) => f(p),
-              result::Err(_) => true
-           }
+            paths
         }
         fn get_target_lib_path(&self) -> Path {
-            make_target_lib_path(self.sysroot, self.target_triple)
+            make_target_lib_path(&self.sysroot, self.target_triple)
         }
         fn get_target_lib_file_path(&self, file: &Path) -> Path {
             self.get_target_lib_path().push_rel(file)
@@ -80,7 +72,7 @@ pub fn mk_filesearch(maybe_sysroot: &Option<@Path>,
 
 pub fn search<T:Copy>(filesearch: @FileSearch, pick: pick<T>) -> Option<T> {
     let mut rslt = None;
-    for filesearch.for_each_lib_search_path() |lib_search_path| {
+    for filesearch.lib_search_paths().each |lib_search_path| {
         debug!("searching %s", lib_search_path.to_str());
         for os::list_dir_path(lib_search_path).each |path| {
             debug!("testing %s", path.to_str());
@@ -116,10 +108,10 @@ fn get_or_default_sysroot() -> Path {
     }
 }
 
-fn get_sysroot(maybe_sysroot: &Option<@Path>) -> @Path {
+fn get_sysroot(maybe_sysroot: &Option<Path>) -> Path {
     match *maybe_sysroot {
-      option::Some(sr) => sr,
-      option::None => @get_or_default_sysroot()
+      option::Some(ref sr) => (/*bad*/copy *sr),
+      option::None => get_or_default_sysroot()
     }
 }
 

branches/incoming/src/librustpkg/conditions.rs

@@ -18,13 +18,5 @@ condition! {
 }
 
 condition! {
-    nonexistent_package: (super::PkgId, ~str) -> ();
-}
-
-condition! {
-    copy_failed: (super::Path, super::Path) -> ();
-}
-
-condition! {
-    missing_pkg_files: (super::PkgId) -> ();
+    nonexistent_package: (super::PkgId, ~str) -> super::Path;
 }

branches/incoming/src/librustpkg/context.rs

@@ -13,9 +13,6 @@
 use core::hashmap::HashMap;
 
 pub struct Ctx {
-    // Sysroot -- if this is None, uses rustc filesearch's
-    // idea of the default
-    sysroot_opt: Option<@Path>,
     // I'm not sure what this is for
     json: bool,
     // Cache of hashes of things already installed