---

yaml
---
r: 128893
b: refs/heads/try
c: 54cb0f6
h: refs/heads/master
i:
  128891: 801f0db
v: v3

Author: thestinger

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 07d86b46a949a94223da714e35b343243e4ecce4
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a86d9ad15e339ab343a12513f9c90556f677b9ca
-refs/heads/try: 01ec6fab21026bee34afe79d54521567de9e8517
+refs/heads/try: 54cb0f6368bcfe996c65d388a0516ac656c606d0
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/doc/README.md

@@ -19,7 +19,7 @@ for the 'std' and 'extra' libraries.
 To generate HTML documentation from one source file/crate, do something like:
 
 ~~~~
-rustdoc --output html-doc/ --output-format html ../src/libstd/path.rs
+rustdoc --output-dir html-doc/ --output-format html ../src/libstd/path.rs
 ~~~~
 
 (This, of course, requires a working build of the `rustdoc` tool.)

branches/try/src/etc/emacs/rust-mode.el

@@ -170,7 +170,7 @@
 (defconst rust-mode-keywords
   '("as"
     "box" "break"
-    "const" "continue" "crate"
+    "continue" "crate"
     "do"
     "else" "enum" "extern"
     "false" "fn" "for"
@@ -182,8 +182,7 @@
     "self" "static" "struct" "super"
     "true" "trait" "type"
     "unsafe" "use"
-    "virtual"
-    "where" "while"))
+    "while"))
 
 (defconst rust-special-types
   '("u8" "i8"

branches/try/src/etc/gedit/share/gtksourceview-3.0/language-specs/rust.lang

@@ -71,8 +71,6 @@
 		<keyword>trait</keyword>
 		<keyword>unsafe</keyword>
 		<keyword>use</keyword>
-		<keyword>virtual</keyword>
-		<keyword>where</keyword>
 		<keyword>while</keyword>
     </context>
 

branches/try/src/etc/kate/rust.xml

@@ -19,7 +19,6 @@
 		<item> as </item>
 		<item> break </item>
 		<item> box </item>
-		<item> const </item>
 		<item> continue </item>
 		<item> crate </item>
 		<item> do </item>
@@ -45,8 +44,6 @@
 		<item> trait </item>
 		<item> unsafe </item>
 		<item> use </item>
-		<item> virtual </item>
-		<item> where </item>
 		<item> while </item>
 	</list>
 	<list name="traits">

branches/try/src/etc/vim/syntax/rust.vim

@@ -26,7 +26,7 @@ syn keyword   rustKeyword     fn nextgroup=rustFuncName skipwhite skipempty
 syn keyword   rustKeyword     for in if impl let
 syn keyword   rustKeyword     loop once proc pub
 syn keyword   rustKeyword     return super
-syn keyword   rustKeyword     unsafe virtual where while
+syn keyword   rustKeyword     unsafe virtual while
 syn keyword   rustKeyword     use nextgroup=rustModPath,rustModPathInUse skipwhite skipempty
 " FIXME: Scoped impl's name is also fallen in this category
 syn keyword   rustKeyword     mod trait struct enum type nextgroup=rustIdentifier skipwhite skipempty

branches/try/src/libcollections/bitv.rs

@@ -75,25 +75,6 @@ use std::hash;
 use {Mutable, Set, MutableSet, MutableSeq};
 use vec::Vec;
 
-// Take two BitV's, and return iterators of their words, where the shorter one
-// has been padded with 0's
-macro_rules! match_words(
-    ($a_expr:expr, $b_expr:expr) => ({
-        let a = $a_expr;
-        let b = $b_expr;
-        let a_len = a.storage.len();
-        let b_len = b.storage.len();
-
-        // have to uselessly pretend to pad the longer one for type matching
-        if a_len < b_len {
-            (a.mask_words(0).chain(iter::Repeat::new(0u).enumerate().take(b_len).skip(a_len)),
-             b.mask_words(0).chain(iter::Repeat::new(0u).enumerate().take(0).skip(0)))
-        } else {
-            (a.mask_words(0).chain(iter::Repeat::new(0u).enumerate().take(0).skip(0)),
-             b.mask_words(0).chain(iter::Repeat::new(0u).enumerate().take(a_len).skip(b_len)))
-        }
-    })
-)
 
 static TRUE: bool = true;
 static FALSE: bool = false;
@@ -988,7 +969,7 @@ impl<'a> RandomAccessIterator<bool> for Bits<'a> {
 /// assert!(bv.eq_vec([true, true, false, true,
 ///                    false, false, false, false]));
 /// ```
-#[deriving(Clone)]
+#[deriving(Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub struct BitvSet(Bitv);
 
 impl Default for BitvSet {
@@ -1011,32 +992,6 @@ impl Extendable<bool> for BitvSet {
     }
 }
 
-impl PartialOrd for BitvSet {
-    #[inline]
-    fn partial_cmp(&self, other: &BitvSet) -> Option<Ordering> {
-        let (a_iter, b_iter) = match_words!(self.get_ref(), other.get_ref());
-        iter::order::partial_cmp(a_iter, b_iter)
-    }
-}
-
-impl Ord for BitvSet {
-    #[inline]
-    fn cmp(&self, other: &BitvSet) -> Ordering {
-        let (a_iter, b_iter) = match_words!(self.get_ref(), other.get_ref());
-        iter::order::cmp(a_iter, b_iter)
-    }
-}
-
-impl cmp::PartialEq for BitvSet {
-    #[inline]
-    fn eq(&self, other: &BitvSet) -> bool {
-        let (a_iter, b_iter) = match_words!(self.get_ref(), other.get_ref());
-        iter::order::eq(a_iter, b_iter)
-    }
-}
-
-impl cmp::Eq for BitvSet {}
-
 impl BitvSet {
     /// Create a new bit vector set with initially no contents.
     ///
@@ -1186,18 +1141,10 @@ impl BitvSet {
         // Unwrap Bitvs
         let &BitvSet(ref mut self_bitv) = self;
         let &BitvSet(ref other_bitv) = other;
-
         // Expand the vector if necessary
         self_bitv.reserve(other_bitv.capacity());
-
-        // virtually pad other with 0's for equal lengths
-        let self_len = self_bitv.storage.len();
-        let other_len =  other_bitv.storage.len();
-        let mut other_words = other_bitv.mask_words(0)
-         .chain(iter::Repeat::new(0u).enumerate().take(self_len).skip(other_len));
-
-        // Apply values found in other
-        for (i, w) in other_words {
+        // Apply values
+        for (i, w) in other_bitv.mask_words(0) {
             let old = self_bitv.storage[i];
             let new = f(old, w);
             *self_bitv.storage.get_mut(i) = new;
@@ -1324,7 +1271,7 @@ impl BitvSet {
     /// let a = BitvSet::from_bitv(bitv::from_bytes([0b01101000]));
     /// let b = BitvSet::from_bitv(bitv::from_bytes([0b10100000]));
     ///
-    /// // Print 1, 4 in arbitrary order
+    /// // Print 2, 4 in arbitrary order
     /// for x in a.difference(&b) {
     ///     println!("{}", x);
     /// }
@@ -2266,64 +2213,6 @@ mod tests {
         assert!(set1.is_subset(&set2)); // { 2 }  { 2, 4 }
     }
 
-    #[test]
-    fn test_bitv_set_intersect_with() {
-        // Explicitly 0'ed bits
-        let mut a = BitvSet::from_bitv(from_bytes([0b10100010]));
-        let mut b = BitvSet::from_bitv(from_bytes([0b00000000]));
-        let c = a.clone();
-        a.intersect_with(&b);
-        b.intersect_with(&c);
-        assert!(a.is_empty());
-        assert!(b.is_empty());
-
-        // Uninitialized bits should behave like 0's
-        let mut a = BitvSet::from_bitv(from_bytes([0b10100010]));
-        let mut b = BitvSet::new();
-        let c = a.clone();
-        a.intersect_with(&b);
-        b.intersect_with(&c);
-        assert!(a.is_empty());
-        assert!(b.is_empty());
-
-        // Standard
-        let mut a = BitvSet::from_bitv(from_bytes([0b10100010]));
-        let mut b = BitvSet::from_bitv(from_bytes([0b01100010]));
-        let c = a.clone();
-        a.intersect_with(&b);
-        b.intersect_with(&c);
-        assert_eq!(a.len(), 2);
-        assert_eq!(b.len(), 2);
-    }
-
-    #[test]
-    fn test_bitv_set_eq() {
-        let a = BitvSet::from_bitv(from_bytes([0b10100010]));
-        let b = BitvSet::from_bitv(from_bytes([0b00000000]));
-        let c = BitvSet::new();
-
-        assert!(a == a);
-        assert!(a != b);
-        assert!(a != c);
-        assert!(b == b);
-        assert!(b == c);
-        assert!(c == c);
-    }
-
-    #[test]
-    fn test_bitv_set_cmp() {
-        let a = BitvSet::from_bitv(from_bytes([0b10100010]));
-        let b = BitvSet::from_bitv(from_bytes([0b00000000]));
-        let c = BitvSet::new();
-
-        assert_eq!(a.cmp(&b), Greater);
-        assert_eq!(a.cmp(&c), Greater);
-        assert_eq!(b.cmp(&a), Less);
-        assert_eq!(b.cmp(&c), Equal);
-        assert_eq!(c.cmp(&a), Less);
-        assert_eq!(c.cmp(&b), Equal);
-    }
-
     #[test]
     fn test_bitv_remove() {
         let mut a = BitvSet::new();

branches/try/src/libcollections/btree.rs

@@ -11,13 +11,6 @@
 // btree.rs
 //
 
-// NB. this is not deprecated for removal, just deprecating the
-// current implementation. If the major pain-points are addressed
-// (overuse of by-value self and .clone), this can be removed.
-#![deprecated = "the current implementation is extremely inefficient, \
-                 prefer a HashMap, TreeMap or TrieMap"]
-#![allow(deprecated)]
-
 //! Starting implementation of a btree for rust.
 //! Structure inspired by github user davidhalperin's gist.
 

branches/try/src/libnum/bigint.rs

@@ -59,7 +59,7 @@
 use Integer;
 use rand::Rng;
 
-use std::{cmp, fmt, hash};
+use std::{cmp, fmt};
 use std::default::Default;
 use std::from_str::FromStr;
 use std::num::CheckedDiv;
@@ -150,22 +150,6 @@ impl Default for BigUint {
     fn default() -> BigUint { Zero::zero() }
 }
 
-impl<S: hash::Writer> hash::Hash<S> for BigUint {
-    fn hash(&self, state: &mut S) {
-        // hash 0 in case it's all 0's
-        0u32.hash(state);
-
-        let mut found_first_value = false;
-        for elem in self.data.iter().rev() {
-            // don't hash any leading 0's, they shouldn't affect the hash
-            if found_first_value || *elem != 0 {
-                found_first_value = true;
-                elem.hash(state);
-            }
-        }
-    }
-}
-
 impl fmt::Show for BigUint {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{}", self.to_str_radix(10))
@@ -897,13 +881,6 @@ impl fmt::Show for BigInt {
     }
 }
 
-impl<S: hash::Writer> hash::Hash<S> for BigInt {
-    fn hash(&self, state: &mut S) {
-        (self.sign == Plus).hash(state);
-        self.data.hash(state);
-    }
-}
-
 impl FromStr for BigInt {
     #[inline]
     fn from_str(s: &str) -> Option<BigInt> {
@@ -1432,7 +1409,6 @@ mod biguint_tests {
     use std::num::CheckedDiv;
     use std::rand::task_rng;
     use std::u64;
-    use std::hash::hash;
 
     #[test]
     fn test_from_slice() {
@@ -1484,19 +1460,6 @@ mod biguint_tests {
         }
     }
 
-    #[test]
-    fn test_hash() {
-        let a = BigUint::new(vec!());
-        let b = BigUint::new(vec!(0));
-        let c = BigUint::new(vec!(1));
-        let d = BigUint::new(vec!(1,0,0,0,0,0));
-        let e = BigUint::new(vec!(0,0,0,0,0,1));
-        assert!(hash(&a) == hash(&b));
-        assert!(hash(&b) != hash(&c));
-        assert!(hash(&c) == hash(&d));
-        assert!(hash(&d) != hash(&e));
-    }
-
     #[test]
     fn test_bitand() {
         fn check(left: &[BigDigit],
@@ -2294,7 +2257,6 @@ mod bigint_tests {
     use std::num::{ToPrimitive, FromPrimitive};
     use std::rand::task_rng;
     use std::u64;
-    use std::hash::hash;
 
     #[test]
     fn test_from_biguint() {
@@ -2352,21 +2314,6 @@ mod bigint_tests {
         }
     }
 
-    #[test]
-    fn test_hash() {
-        let a = BigInt::new(Zero, vec!());
-        let b = BigInt::new(Zero, vec!(0));
-        let c = BigInt::new(Plus, vec!(1));
-        let d = BigInt::new(Plus, vec!(1,0,0,0,0,0));
-        let e = BigInt::new(Plus, vec!(0,0,0,0,0,1));
-        let f = BigInt::new(Minus, vec!(1));
-        assert!(hash(&a) == hash(&b));
-        assert!(hash(&b) != hash(&c));
-        assert!(hash(&c) == hash(&d));
-        assert!(hash(&d) != hash(&e));
-        assert!(hash(&c) != hash(&f));
-    }
-
     #[test]
     fn test_convert_i64() {
         fn check(b1: BigInt, i: i64) {

branches/try/src/libnum/lib.rs

@@ -43,7 +43,6 @@
 //! [newt]: https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method
 
 #![feature(macro_rules)]
-#![feature(default_type_params)]
 
 #![crate_name = "num"]
 #![experimental]

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

@@ -1475,6 +1475,9 @@ fn link_args(cmd: &mut Command,
 
         // Always enable DEP (NX bit) when it is available
         cmd.arg("-Wl,--nxcompat");
+
+        // Mark all dynamic libraries and executables as compatible with ASLR
+        cmd.arg("-Wl,--dynamicbase");
     }
 
     if sess.targ_cfg.os == abi::OsAndroid {