---

yaml
---
r: 59070
b: refs/heads/incoming
c: 1e241ce
h: refs/heads/master
v: v3

Author: thomaslee

[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: 4958e9b4b632b67050dc4de6df1f97329292dfbc
+refs/heads/incoming: 1e241ce52bbba72e1641f44f83ced0bfea4717f9
 refs/heads/dist-snap: 00dbbd01c2aee72982b3e0f9511ae1d4428c3ba9
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/mk/platform.mk

@@ -247,12 +247,12 @@ AR_mips-unknown-linux-gnu=mips-linux-gnu-ar
 CFG_LIB_NAME_mips-unknown-linux-gnu=lib$(1).so
 CFG_LIB_GLOB_mips-unknown-linux-gnu=lib$(1)-*.so
 CFG_LIB_DSYM_GLOB_mips-unknown-linux-gnu=lib$(1)-*.dylib.dSYM
-CFG_GCCISH_CFLAGS_mips-unknown-linux-gnu := -Wall -g -fPIC -mips32r2 -msoft-float -mabi=32 -mno-compact-eh
+CFG_GCCISH_CFLAGS_mips-unknown-linux-gnu := -Wall -g -fPIC -mips32r2 -msoft-float -mabi=32
 CFG_GCCISH_CXXFLAGS_mips-unknown-linux-gnu := -fno-rtti
 CFG_GCCISH_LINK_FLAGS_mips-unknown-linux-gnu := -shared -fPIC -g -mips32r2 -msoft-float -mabi=32
 CFG_GCCISH_DEF_FLAG_mips-unknown-linux-gnu := -Wl,--export-dynamic,--dynamic-list=
 CFG_GCCISH_PRE_LIB_FLAGS_mips-unknown-linux-gnu := -Wl,-whole-archive
-CFG_GCCISH_POST_LIB_FLAGS_mips-unknown-linux-gnu := -Wl,-no-whole-archive
+CFG_GCCISH_POST_LIB_FLAGS_mips-unknown-linux-gnu := -Wl,-no-whole-archive -Wl,-znoexecstack
 CFG_DEF_SUFFIX_mips-unknown-linux-gnu := .linux.def
 CFG_INSTALL_NAME_mips-unknown-linux-gnu =
 CFG_LIBUV_LINK_FLAGS_mips-unknown-linux-gnu =

branches/incoming/src/libcore/cleanup.rs

@@ -127,7 +127,6 @@ struct AnnihilateStats {
     n_bytes_freed: uint
 }
 
-#[cfg(stage0)]
 unsafe fn each_live_alloc(read_next_before: bool,
                           f: &fn(box: *mut BoxRepr, uniq: bool) -> bool) {
     //! Walks the internal list of allocations
@@ -142,8 +141,8 @@ unsafe fn each_live_alloc(read_next_before: bool,
         let uniq =
             (*box).header.ref_count == managed::raw::RC_MANAGED_UNIQUE;
 
-        if !f(box, uniq) {
-            return;
+        if ! f(box, uniq) {
+            break
         }
 
         if read_next_before {
@@ -153,33 +152,6 @@ unsafe fn each_live_alloc(read_next_before: bool,
         }
     }
 }
-#[cfg(not(stage0))]
-unsafe fn each_live_alloc(read_next_before: bool,
-                          f: &fn(box: *mut BoxRepr, uniq: bool) -> 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_before = transmute(copy (*box).header.next);
-        let uniq =
-            (*box).header.ref_count == managed::raw::RC_MANAGED_UNIQUE;
-
-        if !f(box, uniq) {
-            return false;
-        }
-
-        if read_next_before {
-            box = next_before;
-        } else {
-            box = transmute(copy (*box).header.next);
-        }
-    }
-    return true;
-}
 
 #[cfg(unix)]
 fn debug_mem() -> bool {

branches/incoming/src/libcore/condition.rs

@@ -12,7 +12,7 @@
 
 use prelude::*;
 use task;
-use local_data::{local_data_pop, local_data_set};
+use task::local_data::{local_data_pop, local_data_set};
 
 // helper for transmutation, shown below.
 type RustClosure = (int, int);
@@ -24,14 +24,14 @@ pub struct Handler<T, U> {
 
 pub struct Condition<'self, T, U> {
     name: &'static str,
-    key: local_data::LocalDataKey<'self, Handler<T, U>>
+    key: task::local_data::LocalDataKey<'self, Handler<T, U>>
 }
 
 pub impl<'self, T, U> Condition<'self, T, U> {
     fn trap(&'self self, h: &'self fn(T) -> U) -> Trap<'self, T, U> {
         unsafe {
             let p : *RustClosure = ::cast::transmute(&h);
-            let prev = local_data::local_data_get(self.key);
+            let prev = task::local_data::local_data_get(self.key);
             let h = @Handler { handle: *p, prev: prev };
             Trap { cond: self, handler: h }
         }

branches/incoming/src/libcore/container.rs

@@ -30,32 +30,16 @@ pub trait Map<K, V>: Mutable {
     fn contains_key(&self, key: &K) -> bool;
 
     // Visits all keys and values
-    #[cfg(stage0)]
     fn each<'a>(&'a self, f: &fn(&K, &'a V) -> bool);
-    // Visits all keys and values
-    #[cfg(not(stage0))]
-    fn each<'a>(&'a self, f: &fn(&K, &'a V) -> bool) -> bool;
 
     /// Visit all keys
-    #[cfg(stage0)]
     fn each_key(&self, f: &fn(&K) -> bool);
-    /// Visit all keys
-    #[cfg(not(stage0))]
-    fn each_key(&self, f: &fn(&K) -> bool) -> bool;
 
     /// Visit all values
-    #[cfg(stage0)]
     fn each_value<'a>(&'a self, f: &fn(&'a V) -> bool);
-    /// Visit all values
-    #[cfg(not(stage0))]
-    fn each_value<'a>(&'a self, f: &fn(&'a V) -> bool) -> bool;
 
     /// Iterate over the map and mutate the contained values
-    #[cfg(stage0)]
     fn mutate_values(&mut self, f: &fn(&K, &mut V) -> bool);
-    /// Iterate over the map and mutate the contained values
-    #[cfg(not(stage0))]
-    fn mutate_values(&mut self, f: &fn(&K, &mut V) -> bool) -> bool;
 
     /// Return a reference to the value corresponding to the key
     fn find<'a>(&'a self, key: &K) -> Option<&'a V>;
@@ -81,7 +65,6 @@ pub trait Map<K, V>: Mutable {
     fn pop(&mut self, k: &K) -> Option<V>;
 }
 
-#[cfg(stage0)]
 pub trait Set<T>: Mutable {
     /// Return true if the set contains a value
     fn contains(&self, value: &T) -> bool;
@@ -116,39 +99,3 @@ pub trait Set<T>: Mutable {
     /// Visit the values representing the union
     fn union(&self, other: &Self, f: &fn(&T) -> bool);
 }
-
-#[cfg(not(stage0))]
-pub trait Set<T>: Mutable {
-    /// Return true if the set contains a value
-    fn contains(&self, value: &T) -> bool;
-
-    /// Add a value to the set. Return true if the value was not already
-    /// present in the set.
-    fn insert(&mut self, value: T) -> bool;
-
-    /// Remove a value from the set. Return true if the value was
-    /// present in the set.
-    fn remove(&mut self, value: &T) -> bool;
-
-    /// Return true if the set has no elements in common with `other`.
-    /// This is equivalent to checking for an empty intersection.
-    fn is_disjoint(&self, other: &Self) -> bool;
-
-    /// Return true if the set is a subset of another
-    fn is_subset(&self, other: &Self) -> bool;
-
-    /// Return true if the set is a superset of another
-    fn is_superset(&self, other: &Self) -> bool;
-
-    /// Visit the values representing the difference
-    fn difference(&self, other: &Self, f: &fn(&T) -> bool) -> bool;
-
-    /// Visit the values representing the symmetric difference
-    fn symmetric_difference(&self, other: &Self, f: &fn(&T) -> bool) -> bool;
-
-    /// Visit the values representing the intersection
-    fn intersection(&self, other: &Self, f: &fn(&T) -> bool) -> bool;
-
-    /// Visit the values representing the union
-    fn union(&self, other: &Self, f: &fn(&T) -> bool) -> bool;
-}

branches/incoming/src/libcore/core.rc

@@ -215,7 +215,6 @@ pub mod trie;
 pub mod task;
 pub mod comm;
 pub mod pipes;
-pub mod local_data;
 
 
 /* Runtime and platform support */
@@ -228,6 +227,7 @@ pub mod rand;
 pub mod run;
 pub mod sys;
 pub mod cast;
+pub mod flate;
 pub mod repr;
 pub mod cleanup;
 pub mod reflect;

branches/incoming/src/libstd/flate.rs renamed to branches/incoming/src/libcore/flate.rs

@@ -15,14 +15,14 @@ Simple compression
 */
 
 use libc;
-use core::libc::{c_void, size_t, c_int};
+use libc::{c_void, size_t, c_int};
 use vec;
 
-#[cfg(test)] use core::rand;
-#[cfg(test)] use core::rand::RngUtil;
+#[cfg(test)] use rand;
+#[cfg(test)] use rand::RngUtil;
 
 pub mod rustrt {
-    use core::libc::{c_int, c_void, size_t};
+    use libc::{c_int, c_void, size_t};
 
     #[link_name = "rustrt"]
     pub extern {

branches/incoming/src/libcore/gc.rs

@@ -129,7 +129,7 @@ type Visitor<'self> = &'self fn(root: **Word, tydesc: *Word) -> bool;
 
 // Walks the list of roots for the given safe point, and calls visitor
 // on each root.
-unsafe fn _walk_safe_point(fp: *Word, sp: SafePoint, visitor: Visitor) -> bool {
+unsafe fn walk_safe_point(fp: *Word, sp: SafePoint, visitor: Visitor) {
     let fp_bytes: *u8 = cast::transmute(fp);
     let sp_meta: *u32 = cast::transmute(sp.sp_meta);
 
@@ -155,7 +155,7 @@ unsafe fn _walk_safe_point(fp: *Word, sp: SafePoint, visitor: Visitor) -> bool {
             } else {
                 ptr::null()
             };
-            if !visitor(root, tydesc) { return false; }
+            if !visitor(root, tydesc) { return; }
         }
         sri += 1;
     }
@@ -168,16 +168,6 @@ unsafe fn _walk_safe_point(fp: *Word, sp: SafePoint, visitor: Visitor) -> bool {
         }
         rri += 1;
     }
-    return true;
-}
-
-#[cfg(stage0)]
-unsafe fn walk_safe_point(fp: *Word, sp: SafePoint, visitor: Visitor) {
-    _walk_safe_point(fp, sp, visitor);
-}
-#[cfg(not(stage0))]
-unsafe fn walk_safe_point(fp: *Word, sp: SafePoint, visitor: Visitor) -> bool {
-    _walk_safe_point(fp, sp, visitor)
 }
 
 // Is fp contained in segment?
@@ -232,7 +222,7 @@ static need_cleanup:    Memory = exchange_heap | stack;
 
 // Walks stack, searching for roots of the requested type, and passes
 // each root to the visitor.
-unsafe fn _walk_gc_roots(mem: Memory, sentinel: **Word, visitor: Visitor) -> bool {
+unsafe fn walk_gc_roots(mem: Memory, sentinel: **Word, visitor: Visitor) {
     let mut segment = rustrt::rust_get_stack_segment();
     let mut last_ret: *Word = ptr::null();
     // To avoid collecting memory used by the GC itself, skip stack
@@ -284,14 +274,14 @@ unsafe fn _walk_gc_roots(mem: Memory, sentinel: **Word, visitor: Visitor) -> boo
                     // Root is a generic box.
                     let refcount = **root;
                     if mem | task_local_heap != 0 && refcount != -1 {
-                        if !visitor(root, tydesc) { return false; }
+                        if !visitor(root, tydesc) { return; }
                     } else if mem | exchange_heap != 0 && refcount == -1 {
-                        if !visitor(root, tydesc) { return false; }
+                        if !visitor(root, tydesc) { return; }
                     }
                 } else {
                     // Root is a non-immediate.
                     if mem | stack != 0 {
-                        if !visitor(root, tydesc) { return false; }
+                        if !visitor(root, tydesc) { return; }
                     }
                 }
             }
@@ -300,17 +290,8 @@ unsafe fn _walk_gc_roots(mem: Memory, sentinel: **Word, visitor: Visitor) -> boo
         }
         reached_sentinel = delay_reached_sentinel;
     }
-    return true;
 }
 
-#[cfg(stage0)]
-unsafe fn walk_gc_roots(mem: Memory, sentinel: **Word, visitor: Visitor) {
-    _walk_gc_roots(mem, sentinel, visitor);
-}
-#[cfg(not(stage0))]
-unsafe fn walk_gc_roots(mem: Memory, sentinel: **Word, visitor: Visitor) -> bool {
-    _walk_gc_roots(mem, sentinel, visitor)
-}
 pub fn gc() {
     unsafe {
         // Abort when GC is disabled.