---

yaml
---
r: 140445
b: refs/heads/try2
c: c15fa3a
h: refs/heads/master
i:
  140443: 637629f
v: v3

Author: nikomatsakis

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 821979f9282decc1ba92391249140f49a7102319
+refs/heads/try2: c15fa3a02aa3e7e5111f0410abf7321387a7a97f
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libcore/cleanup.rs

@@ -126,22 +126,29 @@ struct AnnihilateStats {
     n_bytes_freed: uint
 }
 
-unsafe fn each_live_alloc(f: &fn(box: *mut BoxRepr, uniq: bool) -> bool) {
+unsafe fn each_live_alloc(read_next_before: bool,
+                          f: &fn(box: *mut BoxRepr, uniq: bool) -> bool) {
+    //! Walks the internal list of allocations
+
     use managed;
 
     let task: *Task = transmute(rustrt::rust_get_task());
     let box = (*task).boxed_region.live_allocs;
     let mut box: *mut BoxRepr = transmute(copy box);
     while box != mut_null() {
-        let next = transmute(copy (*box).header.next);
+        let next_before = transmute(copy (*box).header.next);
         let uniq =
             (*box).header.ref_count == managed::raw::RC_MANAGED_UNIQUE;
 
         if ! f(box, uniq) {
             break
         }
 
-        box = next
+        if read_next_before {
+            box = next_before;
+        } else {
+            box = transmute(copy (*box).header.next);
+        }
     }
 }
 
@@ -173,7 +180,10 @@ pub unsafe fn annihilate() {
     };
 
     // Pass 1: Make all boxes immortal.
-    for each_live_alloc |box, uniq| {
+    //
+    // In this pass, nothing gets freed, so it does not matter whether
+    // we read the next field before or after the callback.
+    for each_live_alloc(true) |box, uniq| {
         stats.n_total_boxes += 1;
         if uniq {
             stats.n_unique_boxes += 1;
@@ -183,7 +193,11 @@ pub unsafe fn annihilate() {
     }
 
     // Pass 2: Drop all boxes.
-    for each_live_alloc |box, uniq| {
+    //
+    // In this pass, unique-managed boxes may get freed, but not
+    // managed boxes, so we must read the `next` field *after* the
+    // callback, as the original value may have been freed.
+    for each_live_alloc(false) |box, uniq| {
         if !uniq {
             let tydesc: *TypeDesc = transmute(copy (*box).header.type_desc);
             let drop_glue: DropGlue = transmute(((*tydesc).drop_glue, 0));
@@ -192,7 +206,12 @@ pub unsafe fn annihilate() {
     }
 
     // Pass 3: Free all boxes.
-    for each_live_alloc |box, uniq| {
+    //
+    // In this pass, managed boxes may get freed (but not
+    // unique-managed boxes, though I think that none of those are
+    // left), so we must read the `next` field before, since it will
+    // not be valid after.
+    for each_live_alloc(true) |box, uniq| {
         if !uniq {
             stats.n_bytes_freed +=
                 (*((*box).header.type_desc)).size

branches/try2/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/try2/src/libcore/prelude.rs

@@ -31,7 +31,7 @@ pub use io::{print, println};
 /* Reexported types and traits */
 
 pub use clone::Clone;
-pub use cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering, Less, Equal, Greater, Equiv};
+pub use cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering, Less, Equal, Greater};
 pub use container::{Container, Mutable, Map, Set};
 pub use hash::Hash;
 pub use old_iter::{BaseIter, ReverseIter, MutableIter, ExtendedIter, EqIter};

branches/try2/src/libcore/str/ascii.rs

@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! Operations on ASCII strings and characters.
-
 use to_str::{ToStr,ToStrConsume};
 use str;
 use cast;

branches/try2/src/libcore/to_bytes.rs

@@ -419,7 +419,8 @@ impl<A> IterBytes for *const A {
     }
 }
 
-pub trait ToBytes {
+
+trait ToBytes {
     fn to_bytes(&self, lsb0: bool) -> ~[u8];
 }
 

branches/try2/src/librustc/back/link.rs

@@ -752,26 +752,18 @@ pub fn link_binary(sess: Session,
     // instead of hard-coded gcc.
     // For win32, there is no cc command,
     // so we add a condition to make it use gcc.
-    let cc_prog: ~str = match sess.opts.linker {
-        Some(copy linker) => linker,
-        None => {
-            if sess.targ_cfg.os == session::os_android {
-                match &sess.opts.android_cross_path {
-                    &Some(copy path) => {
-                        fmt!("%s/bin/arm-linux-androideabi-gcc", path)
-                    }
-                    &None => {
-                        sess.fatal(~"need Android NDK path for linking \
-                                     (--android-cross-path)")
-                    }
-                }
-            } else if sess.targ_cfg.os == session::os_win32 {
-                ~"gcc"
-            } else {
-                ~"cc"
+    let cc_prog: ~str = if sess.targ_cfg.os == session::os_android {
+        match &sess.opts.android_cross_path {
+            &Some(copy path) => {
+                fmt!("%s/bin/arm-linux-androideabi-gcc", path)
+            }
+            &None => {
+                sess.fatal(~"need Android NDK path for linking \
+                             (--android-cross-path)")
             }
         }
-    };
+    } else if sess.targ_cfg.os == session::os_win32 { ~"gcc" }
+    else { ~"cc" };
     // The invocations of cc share some flags across platforms
 
 

branches/try2/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/try2/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");
@@ -650,7 +650,7 @@ pub fn build_session_options(binary: @~str,
     };
 
     let addl_lib_search_paths = getopts::opt_strs(matches, ~"L").map(|s| Path(*s));
-    let linker = getopts::opt_maybe_str(matches, ~"linker");
+
     let linker_args = getopts::opt_strs(matches, ~"link-args").flat_map( |a| {
         let mut args = ~[];
         for str::each_split_char(*a, ' ') |arg| {
@@ -676,7 +676,6 @@ pub fn build_session_options(binary: @~str,
         jit: jit,
         output_type: output_type,
         addl_lib_search_paths: addl_lib_search_paths,
-        linker: linker,
         linker_args: linker_args,
         maybe_sysroot: sysroot_opt,
         target_triple: target,
@@ -761,7 +760,6 @@ pub fn optgroups() -> ~[getopts::groups::OptGroup] {
   optmulti("L", "",   "Add a directory to the library search path",
                               "PATH"),
   optflag("",  "lib", "Compile a library crate"),
-  optopt("", "linker", "Program to use for linking instead of the default.", "LINKER"),
   optmulti("",  "link-args", "FLAGS is a space-separated list of flags
                             passed to the linker", "FLAGS"),
   optflag("",  "ls",  "List the symbols defined by a library crate"),

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

@@ -124,9 +124,8 @@ pub struct options {
     jit: bool,
     output_type: back::link::output_type,
     addl_lib_search_paths: ~[Path],
-    linker: Option<~str>,
     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
@@ -303,8 +302,7 @@ pub fn basic_options() -> @options {
         jit: false,
         output_type: link::output_type_exe,
         addl_lib_search_paths: ~[],
-        linker: None,
-        linker_args: ~[],
+        linker_args:~[],
         maybe_sysroot: None,
         target_triple: host_triple(),
         target_feature: ~"",

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

@@ -20,48 +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");
-            // a little weird
-            self.addl_lib_search_paths.each(f);
-
-            debug!("filesearch: searching target lib path");
-            if !f(&make_target_lib_path(self.sysroot,
-                                        self.target_triple)) {
-                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 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
-           };
+            match get_rustpkg_lib_path() {
+              result::Ok(ref p) => paths.push((/*bad*/copy *p)),
+              result::Err(_) => ()
+            }
+            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)
@@ -79,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());
@@ -115,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()
     }
 }