---

yaml
---
r: 98127
b: refs/heads/master
c: 3b32ea8
h: refs/heads/master
i:
  98125: 5d59e2a
  98123: 532c13e
  98119: 1b21ad0
  98111: 026a3f6
v: v3

Author: lucy

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: a5ed0c58cb9f38af940403c34e283b68c89f5aa2
+refs/heads/master: 3b32ea8c93bc68e7f690dcbcb3e40230ae9c6e9f
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: b6400f998497c3958f40997a71756ead344a776d
 refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36

trunk/Makefile.in

@@ -418,7 +418,6 @@ export CFG_PREFIX
 export CFG_LIBDIR
 export CFG_RUSTLIBDIR
 export CFG_LIBDIR_RELATIVE
-export CFG_DISABLE_INJECT_STD_VERSION
 
 ######################################################################
 # Subprograms

trunk/configure

@@ -381,7 +381,6 @@ opt clang 0 "prefer clang to gcc for building the runtime"
 opt ccache 0 "invoke gcc/clang via ccache to reuse object files between builds"
 opt local-rust 0 "use an installed rustc rather than downloading a snapshot"
 opt pax-flags 0 "apply PaX flags to rustc binaries (required for GRSecurity/PaX-patched kernels)"
-opt inject-std-version 1 "inject the current compiler version of libstd into programs"
 valopt prefix "/usr/local" "set installation prefix"
 valopt local-rust-root "/usr/local" "set prefix for local rust binary"
 valopt llvm-root "" "set LLVM root"
@@ -1043,7 +1042,6 @@ putvar CFG_DISABLE_MANAGE_SUBMODULES
 putvar CFG_ANDROID_CROSS_PATH
 putvar CFG_MINGW32_CROSS_PATH
 putvar CFG_MANDIR
-putvar CFG_DISABLE_INJECT_STD_VERSION
 
 # Avoid spurious warnings from clang by feeding it original source on
 # ccache-miss rather than preprocessed input.

trunk/src/libextra/comm.rs

@@ -16,8 +16,6 @@ Higher level communication abstractions.
 
 #[allow(missing_doc)];
 
-use std::comm;
-
 /// An extension of `pipes::stream` that allows both sending and receiving.
 pub struct DuplexStream<T, U> {
     priv chan: Chan<T>,
@@ -42,7 +40,7 @@ impl<T:Send,U:Send> DuplexStream<T, U> {
     pub fn recv(&self) -> U {
         self.port.recv()
     }
-    pub fn try_recv(&self) -> comm::TryRecvResult<U> {
+    pub fn try_recv(&self) -> Option<U> {
         self.port.try_recv()
     }
     pub fn recv_opt(&self) -> Option<U> {
@@ -79,11 +77,11 @@ impl<T: Send> SyncPort<T> {
         })
     }
 
-    pub fn try_recv(&self) -> comm::TryRecvResult<T> {
-        match self.duplex_stream.try_recv() {
-            comm::Data(t) => { self.duplex_stream.try_send(()); comm::Data(t) }
-            state => state,
-        }
+    pub fn try_recv(&self) -> Option<T> {
+        self.duplex_stream.try_recv().map(|val| {
+            self.duplex_stream.try_send(());
+            val
+        })
     }
 }
 

trunk/src/libextra/lib.rs

@@ -20,8 +20,7 @@ Rust extras are part of the standard Rust distribution.
 
 */
 
-// NOTE: upgrade to 0.10-pre after the next snapshot
-#[crate_id = "extra#0.9"];
+#[crate_id = "extra#0.10-pre"];
 #[comment = "Rust extras"];
 #[license = "MIT/ASL2"];
 #[crate_type = "rlib"];

trunk/src/libextra/sync.rs

@@ -19,7 +19,6 @@
 
 
 use std::borrow;
-use std::comm;
 use std::unstable::sync::Exclusive;
 use std::sync::arc::UnsafeArc;
 use std::sync::atomics;
@@ -50,7 +49,7 @@ impl WaitQueue {
     // Signals one live task from the queue.
     fn signal(&self) -> bool {
         match self.head.try_recv() {
-            comm::Data(ch) => {
+            Some(ch) => {
                 // Send a wakeup signal. If the waiter was killed, its port will
                 // have closed. Keep trying until we get a live task.
                 if ch.try_send_deferred(()) {
@@ -59,20 +58,20 @@ impl WaitQueue {
                     self.signal()
                 }
             }
-            _ => false
+            None => false
         }
     }
 
     fn broadcast(&self) -> uint {
         let mut count = 0;
         loop {
             match self.head.try_recv() {
-                comm::Data(ch) => {
+                None => break,
+                Some(ch) => {
                     if ch.try_send_deferred(()) {
                         count += 1;
                     }
                 }
-                _ => break
             }
         }
         count

trunk/src/libgreen/sched.rs

@@ -958,7 +958,6 @@ fn new_sched_rng() -> XorShiftRng {
 
 #[cfg(test)]
 mod test {
-    use std::comm;
     use std::task::TaskOpts;
     use std::rt::Runtime;
     use std::rt::task::Task;
@@ -1377,7 +1376,7 @@ mod test {
             // This task should not be able to starve the sender;
             // The sender should get stolen to another thread.
             do spawn {
-                while port.try_recv() != comm::Data(()) { }
+                while port.try_recv().is_none() { }
             }
 
             chan.send(());
@@ -1394,7 +1393,7 @@ mod test {
             // This task should not be able to starve the other task.
             // The sends should eventually yield.
             do spawn {
-                while port.try_recv() != comm::Data(()) {
+                while port.try_recv().is_none() {
                     chan2.send(());
                 }
             }

trunk/src/libnative/lib.rs

@@ -39,6 +39,30 @@ static OS_DEFAULT_STACK_ESTIMATE: uint = 1 << 20;
 #[cfg(unix, not(android))]
 static OS_DEFAULT_STACK_ESTIMATE: uint = 2 * (1 << 20);
 
+
+// XXX: this should not exist here
+#[cfg(stage0, nativestart)]
+#[lang = "start"]
+pub fn lang_start(main: *u8, argc: int, argv: **u8) -> int {
+    use std::cast;
+    use std::task;
+
+    do start(argc, argv) {
+        // Instead of invoking main directly on this thread, invoke it on
+        // another spawned thread that we are guaranteed to know the size of the
+        // stack of. Currently, we do not have a method of figuring out the size
+        // of the main thread's stack, so for stack overflow detection to work
+        // we must spawn the task in a subtask which we know the stack size of.
+        let main: extern "Rust" fn() = unsafe { cast::transmute(main) };
+        let mut task = task::task();
+        task.name("<main>");
+        match do task.try { main() } {
+            Ok(()) => { os::set_exit_status(0); }
+            Err(..) => { os::set_exit_status(rt::DEFAULT_ERROR_CODE); }
+        }
+    }
+}
+
 /// Executes the given procedure after initializing the runtime with the given
 /// argc/argv.
 ///

trunk/src/librustc/driver/driver.rs

@@ -1011,7 +1011,7 @@ pub fn optgroups() -> ~[getopts::groups::OptGroup] {
                           for details)", "FEATURE"),
   optopt("", "android-cross-path",
          "The path to the Android NDK", "PATH"),
-  optflagopt("W", "warn",
+  optmulti("W", "warn",
                         "Set lint warnings", "OPT"),
   optmulti("A", "allow",
                         "Set lint allowed", "OPT"),

trunk/src/librustc/front/std_inject.rs

@@ -21,9 +21,6 @@ use syntax::fold;
 use syntax::opt_vec;
 use syntax::util::small_vector::SmallVector;
 
-// NOTE: upgrade to 0.10-pre after the next snapshot
-pub static VERSION: &'static str = "0.9";
-
 pub fn maybe_inject_libstd_ref(sess: Session, crate: ast::Crate)
                                -> ast::Crate {
     if use_std(&crate) {
@@ -56,21 +53,11 @@ struct StandardLibraryInjector {
     sess: Session,
 }
 
-pub fn with_version(crate: &str) -> Option<(@str, ast::StrStyle)> {
-    match option_env!("CFG_DISABLE_INJECT_STD_VERSION") {
-        Some("1") => None,
-        _ => {
-            Some((format!("{}\\#{}", crate, VERSION).to_managed(),
-                  ast::CookedStr))
-        }
-    }
-}
-
 impl fold::Folder for StandardLibraryInjector {
     fn fold_crate(&mut self, crate: ast::Crate) -> ast::Crate {
         let mut vis = ~[ast::ViewItem {
             node: ast::ViewItemExternMod(self.sess.ident_of("std"),
-                                         with_version("std"),
+                                         None,
                                          ast::DUMMY_NODE_ID),
             attrs: ~[],
             vis: ast::Private,
@@ -80,15 +67,15 @@ impl fold::Folder for StandardLibraryInjector {
         if use_uv(&crate) && !self.sess.building_library.get() {
             vis.push(ast::ViewItem {
                 node: ast::ViewItemExternMod(self.sess.ident_of("green"),
-                                             with_version("green"),
+                                             None,
                                              ast::DUMMY_NODE_ID),
                 attrs: ~[],
                 vis: ast::Private,
                 span: DUMMY_SP
             });
             vis.push(ast::ViewItem {
                 node: ast::ViewItemExternMod(self.sess.ident_of("rustuv"),
-                                             with_version("rustuv"),
+                                             None,
                                              ast::DUMMY_NODE_ID),
                 attrs: ~[],
                 vis: ast::Private,

trunk/src/librustc/front/test.rs

@@ -13,7 +13,6 @@
 
 use driver::session;
 use front::config;
-use front::std_inject::with_version;
 
 use std::cell::RefCell;
 use std::vec;
@@ -293,7 +292,7 @@ fn mk_std(cx: &TestCtxt) -> ast::ViewItem {
                                           ast::DUMMY_NODE_ID))])
     } else {
         ast::ViewItemExternMod(id_extra,
-                               with_version("extra"),
+                               None,
                                ast::DUMMY_NODE_ID)
     };
     ast::ViewItem {

trunk/src/librustc/lib.rs

@@ -227,14 +227,9 @@ pub fn run_compiler(args: &[~str], demitter: @diagnostic::Emitter) {
         return;
     }
 
-    // Display the available lint options if "-W help" or only "-W" is given.
     let lint_flags = vec::append(matches.opt_strs("W"),
                                  matches.opt_strs("warn"));
-
-    let show_lint_options = lint_flags.iter().any(|x| x == &~"help") ||
-        (matches.opt_present("W") && lint_flags.is_empty());
-
-    if show_lint_options {
+    if lint_flags.iter().any(|x| x == &~"help") {
         describe_warnings();
         return;
     }

trunk/src/libstd/cleanup.rs

@@ -17,8 +17,6 @@ use unstable::raw;
 
 type DropGlue<'a> = 'a |**TyDesc, *c_void|;
 
-static RC_IMMORTAL : uint = 0x77777777;
-
 /*
  * Box annihilation
  *
@@ -27,21 +25,24 @@ static RC_IMMORTAL : uint = 0x77777777;
 
 struct AnnihilateStats {
     n_total_boxes: uint,
+    n_unique_boxes: uint,
     n_bytes_freed: uint
 }
 
 unsafe fn each_live_alloc(read_next_before: bool,
-                          f: |alloc: *mut raw::Box<()>| -> bool)
+                          f: |alloc: *mut raw::Box<()>, uniq: bool| -> bool)
                           -> bool {
     //! Walks the internal list of allocations
 
+    use managed;
     use rt::local_heap;
 
     let mut alloc = local_heap::live_allocs();
     while alloc != ptr::mut_null() {
         let next_before = (*alloc).next;
+        let uniq = (*alloc).ref_count == managed::RC_MANAGED_UNIQUE;
 
-        if !f(alloc) {
+        if !f(alloc, uniq) {
             return false;
         }
 
@@ -69,19 +70,25 @@ fn debug_mem() -> bool {
 pub unsafe fn annihilate() {
     use rt::local_heap::local_free;
     use mem;
+    use managed;
 
     let mut stats = AnnihilateStats {
         n_total_boxes: 0,
+        n_unique_boxes: 0,
         n_bytes_freed: 0
     };
 
     // Pass 1: Make all boxes immortal.
     //
     // In this pass, nothing gets freed, so it does not matter whether
     // we read the next field before or after the callback.
-    each_live_alloc(true, |alloc| {
+    each_live_alloc(true, |alloc, uniq| {
         stats.n_total_boxes += 1;
-        (*alloc).ref_count = RC_IMMORTAL;
+        if uniq {
+            stats.n_unique_boxes += 1;
+        } else {
+            (*alloc).ref_count = managed::RC_IMMORTAL;
+        }
         true
     });
 
@@ -90,10 +97,12 @@ pub unsafe fn annihilate() {
     // 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.
-    each_live_alloc(false, |alloc| {
-        let tydesc = (*alloc).type_desc;
-        let data = &(*alloc).data as *();
-        ((*tydesc).drop_glue)(data as *i8);
+    each_live_alloc(false, |alloc, uniq| {
+        if !uniq {
+            let tydesc = (*alloc).type_desc;
+            let data = &(*alloc).data as *();
+            ((*tydesc).drop_glue)(data as *i8);
+        }
         true
     });
 
@@ -103,19 +112,22 @@ pub unsafe fn annihilate() {
     // 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.
-    each_live_alloc(true, |alloc| {
-        stats.n_bytes_freed +=
-            (*((*alloc).type_desc)).size
-            + mem::size_of::<raw::Box<()>>();
-        local_free(alloc as *i8);
+    each_live_alloc(true, |alloc, uniq| {
+        if !uniq {
+            stats.n_bytes_freed +=
+                (*((*alloc).type_desc)).size
+                + mem::size_of::<raw::Box<()>>();
+            local_free(alloc as *i8);
+        }
         true
     });
 
     if debug_mem() {
         // We do logging here w/o allocation.
         debug!("annihilator stats:\n  \
                        total boxes: {}\n  \
+                      unique boxes: {}\n  \
                        bytes freed: {}",
-                stats.n_total_boxes, stats.n_bytes_freed);
+                stats.n_total_boxes, stats.n_unique_boxes, stats.n_bytes_freed);
     }
 }