---

yaml
---
r: 59382
b: refs/heads/snap-stage3
c: 7b2020f
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: c081ffbd1e845687202a975ea2e698b623e5722f
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 930908aa90af3635af3744b08bf2aaaee4e3b381
+refs/heads/snap-stage3: 7b2020f2c3f51de0dd4dcfe4a107673eda6f25e7
 refs/heads/try: c50a9d5b664478e533ba1d1d353213d70c8ad589
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/mk/host.mk

@@ -130,10 +130,8 @@ $$(HLIB$(2)_H_$(4))/$(CFG_RUSTLLVM_$(4)): \
 $$(HBIN$(2)_H_$(4))/:
 	mkdir -p $$@
 
-ifneq ($(CFG_LIBDIR),bin)
 $$(HLIB$(2)_H_$(4))/:
 	mkdir -p $$@
-endif
 
 endef
 

branches/snap-stage3/mk/rt.mk

@@ -163,6 +163,8 @@ endif
 ifdef CFG_WINDOWSY_$(1)
 $$(LIBUV_LIB_$(1)): $$(LIBUV_DEPS)
 	$$(Q)$$(MAKE) -C $$(S)src/libuv/ \
+		CFLAGS="$$(CFG_GCCISH_CFLAGS)" \
+		LDFLAGS="$$(CFG_GCCISH_LINK_FLAGS)" \
 		builddir_name="$$(CFG_BUILD_DIR)/rt/$(1)/libuv" \
 		OS=mingw \
 		V=$$(VERBOSE)

branches/snap-stage3/mk/target.mk

@@ -86,10 +86,8 @@ endif
 $$(TBIN$(1)_T_$(2)_H_$(3))/:
 	mkdir -p $$@
 
-ifneq ($(CFG_LIBDIR),bin)
 $$(TLIB$(1)_T_$(2)_H_$(3))/:
 	mkdir -p $$@
-endif
 
 endef
 

branches/snap-stage3/src/libcore/char.rs

@@ -16,7 +16,7 @@ use option::{None, Option, Some};
 use str;
 use u32;
 use uint;
-use unicode;
+use unicode::{derived_property, general_category};
 
 #[cfg(notest)] use cmp::Eq;
 
@@ -53,18 +53,17 @@ use unicode;
     Cn  Unassigned  a reserved unassigned code point or a noncharacter
 */
 
-pub use is_alphabetic = unicode::derived_property::Alphabetic;
-pub use is_XID_start = unicode::derived_property::XID_Start;
-pub use is_XID_continue = unicode::derived_property::XID_Continue;
-
+pub fn is_alphabetic(c: char) -> bool   { derived_property::Alphabetic(c) }
+pub fn is_XID_start(c: char) -> bool    { derived_property::XID_Start(c) }
+pub fn is_XID_continue(c: char) -> bool { derived_property::XID_Continue(c) }
 
 /**
  * Indicates whether a character is in lower case, defined
  * in terms of the Unicode General Category 'Ll'
  */
 #[inline(always)]
 pub fn is_lowercase(c: char) -> bool {
-    return unicode::general_category::Ll(c);
+    return general_category::Ll(c);
 }
 
 /**
@@ -73,7 +72,7 @@ pub fn is_lowercase(c: char) -> bool {
  */
 #[inline(always)]
 pub fn is_uppercase(c: char) -> bool {
-    return unicode::general_category::Lu(c);
+    return general_category::Lu(c);
 }
 
 /**
@@ -84,9 +83,9 @@ pub fn is_uppercase(c: char) -> bool {
 #[inline(always)]
 pub fn is_whitespace(c: char) -> bool {
     return ('\x09' <= c && c <= '\x0d')
-        || unicode::general_category::Zs(c)
-        || unicode::general_category::Zl(c)
-        || unicode::general_category::Zp(c);
+        || general_category::Zs(c)
+        || general_category::Zl(c)
+        || general_category::Zp(c);
 }
 
 /**
@@ -96,18 +95,18 @@ pub fn is_whitespace(c: char) -> bool {
  */
 #[inline(always)]
 pub fn is_alphanumeric(c: char) -> bool {
-    return unicode::derived_property::Alphabetic(c) ||
-        unicode::general_category::Nd(c) ||
-        unicode::general_category::Nl(c) ||
-        unicode::general_category::No(c);
+    return derived_property::Alphabetic(c) ||
+        general_category::Nd(c) ||
+        general_category::Nl(c) ||
+        general_category::No(c);
 }
 
 /// Indicates whether the character is numeric (Nd, Nl, or No)
 #[inline(always)]
 pub fn is_digit(c: char) -> bool {
-    return unicode::general_category::Nd(c) ||
-        unicode::general_category::Nl(c) ||
-        unicode::general_category::No(c);
+    return general_category::Nd(c) ||
+        general_category::Nl(c) ||
+        general_category::No(c);
 }
 
 /**

branches/snap-stage3/src/libcore/container.rs

@@ -55,6 +55,14 @@ pub trait Map<K, V>: Mutable {
     /// Remove a key-value pair from the map. Return true if the key
     /// was present in the map, otherwise false.
     fn remove(&mut self, key: &K) -> bool;
+
+    /// Insert a key-value pair from the map. If the key already had a value
+    /// present in the map, that value is returned. Otherwise None is returned.
+    fn swap(&mut self, k: K, v: V) -> Option<V>;
+
+    /// Removes a key from the map, returning the value at the key if the key
+    /// was previously in the map.
+    fn pop(&mut self, k: &K) -> Option<V>;
 }
 
 pub trait Set<T>: Mutable {

branches/snap-stage3/src/libcore/core.rc

@@ -244,12 +244,12 @@ pub mod unstable;
 
 /* For internal use, not exported */
 
-pub mod unicode;
+mod unicode;
 #[path = "num/cmath.rs"]
-pub mod cmath;
-pub mod stackwalk;
+mod cmath;
+mod stackwalk;
 #[path = "rt/mod.rs"]
-pub mod rt;
+mod rt;
 
 // A curious inner-module that's not exported that contains the binding
 // 'core' so that macro-expanded references to core::error and such

branches/snap-stage3/src/libcore/gc.rs

@@ -44,7 +44,7 @@ use libc::{size_t, uintptr_t};
 use option::{None, Option, Some};
 use ptr;
 use hashmap::HashSet;
-use stackwalk;
+use stackwalk::walk_stack;
 use sys;
 
 pub use stackwalk::Word;
@@ -230,7 +230,7 @@ unsafe fn walk_gc_roots(mem: Memory, sentinel: **Word, visitor: Visitor) {
     // frame is marked by a sentinel, which is a box pointer stored on
     // the stack.
     let mut reached_sentinel = ptr::is_null(sentinel);
-    for stackwalk::walk_stack |frame| {
+    for walk_stack |frame| {
         let pc = last_ret;
         let Segment {segment: next_segment, boundary: boundary} =
             find_segment_for_frame(frame.fp, segment);

branches/snap-stage3/src/libcore/hashmap.rs

@@ -24,8 +24,8 @@ use rand::RngUtil;
 use rand;
 use uint;
 use vec;
-use util::unreachable;
 use kinds::Copy;
+use util::{replace, unreachable};
 
 static INITIAL_CAPACITY: uint = 32u; // 2^5
 
@@ -204,7 +204,7 @@ priv impl<K:Hash + Eq,V> HashMap<K, V> {
     /// Inserts the key value pair into the buckets.
     /// Assumes that there will be a bucket.
     /// True if there was no previous entry with that key
-    fn insert_internal(&mut self, hash: uint, k: K, v: V) -> bool {
+    fn insert_internal(&mut self, hash: uint, k: K, v: V) -> Option<V> {
         match self.bucket_for_key_with_hash(hash, &k) {
             TableFull => { fail!(~"Internal logic error"); }
             FoundHole(idx) => {
@@ -213,14 +213,19 @@ priv impl<K:Hash + Eq,V> HashMap<K, V> {
                 self.buckets[idx] = Some(Bucket{hash: hash, key: k,
                                                 value: v});
                 self.size += 1;
-                true
+                None
             }
             FoundEntry(idx) => {
                 debug!("insert overwrite (%?->%?) at idx %?, hash %?",
                        k, v, idx, hash);
-                self.buckets[idx] = Some(Bucket{hash: hash, key: k,
-                                                value: v});
-                false
+                match self.buckets[idx] {
+                    None => { fail!(~"insert_internal: Internal logic error") }
+                    Some(ref mut b) => {
+                        b.hash = hash;
+                        b.key = k;
+                        Some(replace(&mut b.value, v))
+                    }
+                }
             }
         }
     }
@@ -361,6 +366,20 @@ impl<K:Hash + Eq,V> Map<K, V> for HashMap<K, V> {
     /// key is replaced by the new value. Return true if the key did
     /// not already exist in the map.
     fn insert(&mut self, k: K, v: V) -> bool {
+        self.swap(k, v).is_none()
+    }
+
+    /// Remove a key-value pair from the map. Return true if the key
+    /// was present in the map, otherwise false.
+    fn remove(&mut self, k: &K) -> bool {
+        self.pop(k).is_some()
+    }
+
+    /// Insert a key-value pair from the map. If the key already had a value
+    /// present in the map, that value is returned. Otherwise None is returned.
+    fn swap(&mut self, k: K, v: V) -> Option<V> {
+        // this could be faster.
+
         if self.size >= self.resize_at {
             // n.b.: We could also do this after searching, so
             // that we do not resize if this call to insert is
@@ -375,10 +394,11 @@ impl<K:Hash + Eq,V> Map<K, V> for HashMap<K, V> {
         self.insert_internal(hash, k, v)
     }
 
-    /// Remove a key-value pair from the map. Return true if the key
-    /// was present in the map, otherwise false.
-    fn remove(&mut self, k: &K) -> bool {
-        self.pop(k).is_some()
+    /// Removes a key from the map, returning the value at the key if the key
+    /// was previously in the map.
+    fn pop(&mut self, k: &K) -> Option<V> {
+        let hash = k.hash_keyed(self.k0, self.k1) as uint;
+        self.pop_internal(hash, k)
     }
 }
 
@@ -402,31 +422,6 @@ pub impl<K: Hash + Eq, V> HashMap<K, V> {
         }
     }
 
-    fn pop(&mut self, k: &K) -> Option<V> {
-        let hash = k.hash_keyed(self.k0, self.k1) as uint;
-        self.pop_internal(hash, k)
-    }
-
-    fn swap(&mut self, k: K, v: V) -> Option<V> {
-        // this could be faster.
-        let hash = k.hash_keyed(self.k0, self.k1) as uint;
-        let old_value = self.pop_internal(hash, &k);
-
-        if self.size >= self.resize_at {
-            // n.b.: We could also do this after searching, so
-            // that we do not resize if this call to insert is
-            // simply going to update a key in place.  My sense
-            // though is that it's worse to have to search through
-            // buckets to find the right spot twice than to just
-            // resize in this corner case.
-            self.expand();
-        }
-
-        self.insert_internal(hash, k, v);
-
-        old_value
-    }
-
     /// Return the value corresponding to the key in the map, or insert
     /// and return the value if it doesn't exist.
     fn find_or_insert<'a>(&'a mut self, k: K, v: V) -> &'a V {

branches/snap-stage3/src/libcore/run.rs

@@ -855,74 +855,4 @@ mod tests {
     fn waitpid_non_existant_pid() {
         run::waitpid(123456789); // assume that this pid doesn't exist
     }
-
-    #[test]
-    fn test_destroy_once() {
-        let mut p = run::start_program("echo", []);
-        p.destroy(); // this shouldn't crash (and nor should the destructor)
-    }
-
-    #[test]
-    fn test_destroy_twice() {
-        let mut p = run::start_program("echo", []);
-        p.destroy(); // this shouldnt crash...
-        p.destroy(); // ...and nor should this (and nor should the destructor)
-    }
-
-    fn test_destroy_actually_kills(force: bool) {
-
-        #[cfg(unix)]
-        static BLOCK_COMMAND: &'static str = "cat";
-
-        #[cfg(windows)]
-        static BLOCK_COMMAND: &'static str = "cmd";
-
-        #[cfg(unix)]
-        fn process_exists(pid: libc::pid_t) -> bool {
-            run::program_output("ps", [~"-p", pid.to_str()]).out.contains(pid.to_str())
-        }
-
-        #[cfg(windows)]
-        fn process_exists(pid: libc::pid_t) -> bool {
-
-            use libc::types::os::arch::extra::DWORD;
-            use libc::funcs::extra::kernel32::{CloseHandle, GetExitCodeProcess, OpenProcess};
-            use libc::consts::os::extra::{FALSE, PROCESS_QUERY_INFORMATION, STILL_ACTIVE };
-
-            unsafe {
-                let proc = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, pid as DWORD);
-                if proc.is_null() {
-                    return false;
-                }
-                // proc will be non-null if the process is alive, or if it died recently
-                let mut status = 0;
-                GetExitCodeProcess(proc, &mut status);
-                CloseHandle(proc);
-                return status == STILL_ACTIVE;
-            }
-        }
-
-        // this program will stay alive indefinitely trying to read from stdin
-        let mut p = run::start_program(BLOCK_COMMAND, []);
-
-        assert!(process_exists(p.get_id()));
-
-        if force {
-            p.force_destroy();
-        } else {
-            p.destroy();
-        }
-
-        assert!(!process_exists(p.get_id()));
-    }
-
-    #[test]
-    fn test_unforced_destroy_actually_kills() {
-        test_destroy_actually_kills(false);
-    }
-
-    #[test]
-    fn test_forced_destroy_actually_kills() {
-        test_destroy_actually_kills(true);
-    }
 }