---

yaml
---
r: 105970
b: refs/heads/auto
c: 6d7e86d
h: refs/heads/master
v: v3

Author: crabtw

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 42fc32f293eb7de7139f058fa06f580a503b87b5
+refs/heads/auto: 6d7e86d099cf33821398731f750b36df564ca5d2
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/compiletest/compiletest.rs

@@ -12,7 +12,6 @@
 
 #[allow(non_camel_case_types)];
 #[deny(warnings)];
-#[allow(deprecated_owned_vector)];
 
 extern crate test;
 extern crate getopts;

branches/auto/src/doc/guide-tasks.md

@@ -351,6 +351,8 @@ fn pnorm(nums: &~[f64], p: uint) -> f64 {
 
 fn main() {
     let numbers = vec::from_fn(1000000, |_| rand::random::<f64>());
+    println!("Inf-norm = {}",  *numbers.iter().max().unwrap());
+
     let numbers_arc = Arc::new(numbers);
 
     for num in range(1u, 10) {

branches/auto/src/libarena/lib.rs

@@ -21,7 +21,6 @@
 #[license = "MIT/ASL2"];
 #[allow(missing_doc)];
 #[feature(managed_boxes)];
-#[allow(deprecated_owned_vector)];
 
 extern crate collections;
 

branches/auto/src/libcollections/hashmap.rs

@@ -9,6 +9,56 @@
 // except according to those terms.
 
 //! Unordered containers, implemented as hash-tables (`HashSet` and `HashMap` types)
+//!
+//! The tables use a keyed hash with new random keys generated for each container, so the ordering
+//! of a set of keys in a hash table is randomized.
+//!
+//! This is currently implemented with robin hood hashing, as described in [1][2][3].
+//!
+//! # Example
+//!
+//! ```rust
+//! use collections::HashMap;
+//!
+//! // type inference lets us omit an explicit type signature (which
+//! // would be `HashMap<&str, &str>` in this example).
+//! let mut book_reviews = HashMap::new();
+//!
+//! // review some books.
+//! book_reviews.insert("Adventures of Hucklebury Fin",      "My favorite book.");
+//! book_reviews.insert("Grimms' Fairy Tales",               "Masterpiece.");
+//! book_reviews.insert("Pride and Prejudice",               "Very enjoyable.");
+//! book_reviews.insert("The Adventures of Sherlock Holmes", "Eye lyked it alot.");
+//!
+//! // check for a specific one.
+//! if !book_reviews.contains_key(& &"Les Misérables") {
+//!     println!("We've got {} reviews, but Les Misérables ain't one.",
+//!              book_reviews.len());
+//! }
+//!
+//! // oops, this review has a lot of spelling mistakes, let's delete it.
+//! book_reviews.remove(& &"The Adventures of Sherlock Holmes");
+//!
+//! // look up the values associated with some keys.
+//! let to_find = ["Pride and Prejudice", "Alice's Adventure in Wonderland"];
+//! for book in to_find.iter() {
+//!     match book_reviews.find(book) {
+//!         Some(review) => println!("{}: {}", *book, *review),
+//!         None => println!("{} is unreviewed.", *book)
+//!     }
+//! }
+//!
+//! // iterate over everything.
+//! for (book, review) in book_reviews.iter() {
+//!     println!("{}: \"{}\"", *book, *review);
+//! }
+//! ```
+//!
+//! Relevant papers/articles:
+//!
+//! [1]: Pedro Celis. ["Robin Hood Hashing"](https://cs.uwaterloo.ca/research/tr/1986/CS-86-14.pdf)
+//! [2]: (http://codecapsule.com/2013/11/11/robin-hood-hashing/)
+//! [3]: (http://codecapsule.com/2013/11/17/robin-hood-hashing-backward-shift-deletion/)
 
 use std::container::{Container, Mutable, Map, MutableMap, Set, MutableSet};
 use std::clone::Clone;
@@ -617,64 +667,14 @@ static INITIAL_LOAD_FACTOR: Fraction = (9, 10);
 // `table::RawTable::new`, but I'm not confident it works for all sane alignments,
 // especially if a type needs more alignment than `malloc` provides.
 
-/// A hash map implementation which uses linear probing with Robin
-/// Hood bucket stealing.
+/// A hash map implementation which uses linear probing with Robin Hood bucket
+/// stealing.
 ///
 /// The hashes are all keyed by the task-local random number generator
-/// on creation by default, this means the ordering of the keys is
-/// randomized, but makes the tables more resistant to
-/// denial-of-service attacks (Hash DoS). This behaviour can be
-/// overriden with one of the constructors.
+/// on creation by default. This can be overriden with one of the constructors.
 ///
 /// It is required that the keys implement the `Eq` and `Hash` traits, although
 /// this can frequently be achieved by using `#[deriving(Eq, Hash)]`.
-///
-/// Relevant papers/articles:
-///
-/// 1. Pedro Celis. ["Robin Hood Hashing"](https://cs.uwaterloo.ca/research/tr/1986/CS-86-14.pdf)
-/// 2. Emmanuel Goossaert. ["Robin Hood
-///    hashing"](http://codecapsule.com/2013/11/11/robin-hood-hashing/)
-/// 3. Emmanuel Goossaert. ["Robin Hood hashing: backward shift
-///    deletion"](http://codecapsule.com/2013/11/17/robin-hood-hashing-backward-shift-deletion/)
-///
-/// # Example
-///
-/// ```rust
-/// use collections::HashMap;
-///
-/// // type inference lets us omit an explicit type signature (which
-/// // would be `HashMap<&str, &str>` in this example).
-/// let mut book_reviews = HashMap::new();
-///
-/// // review some books.
-/// book_reviews.insert("Adventures of Hucklebury Fin",      "My favorite book.");
-/// book_reviews.insert("Grimms' Fairy Tales",               "Masterpiece.");
-/// book_reviews.insert("Pride and Prejudice",               "Very enjoyable.");
-/// book_reviews.insert("The Adventures of Sherlock Holmes", "Eye lyked it alot.");
-///
-/// // check for a specific one.
-/// if !book_reviews.contains_key(& &"Les Misérables") {
-///     println!("We've got {} reviews, but Les Misérables ain't one.",
-///              book_reviews.len());
-/// }
-///
-/// // oops, this review has a lot of spelling mistakes, let's delete it.
-/// book_reviews.remove(& &"The Adventures of Sherlock Holmes");
-///
-/// // look up the values associated with some keys.
-/// let to_find = ["Pride and Prejudice", "Alice's Adventure in Wonderland"];
-/// for book in to_find.iter() {
-///     match book_reviews.find(book) {
-///         Some(review) => println!("{}: {}", *book, *review),
-///         None => println!("{} is unreviewed.", *book)
-///     }
-/// }
-///
-/// // iterate over everything.
-/// for (book, review) in book_reviews.iter() {
-///     println!("{}: \"{}\"", *book, *review);
-/// }
-/// ```
 #[deriving(Clone)]
 pub struct HashMap<K, V, H = sip::SipHasher> {
     // All hashes are keyed on these values, to prevent hash collision attacks.
@@ -1069,49 +1069,41 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
     /// so we have some sort of upper bound on the number of probes to do.
     ///
     /// 'hash', 'k', and 'v' are the elements to robin hood into the hashtable.
-    fn robin_hood(&mut self, mut index: table::FullIndex, mut dib_param: uint,
-                  mut hash: table::SafeHash, mut k: K, mut v: V) {
-        'outer: loop {
-            let (old_hash, old_key, old_val) = {
-                let (old_hash_ref, old_key_ref, old_val_ref) =
-                        self.table.read_all_mut(&index);
-
-                let old_hash = replace(old_hash_ref, hash);
-                let old_key  = replace(old_key_ref,  k);
-                let old_val  = replace(old_val_ref,  v);
-
-                (old_hash, old_key, old_val)
+    fn robin_hood(&mut self, index: table::FullIndex, dib_param: uint,
+                  hash: table::SafeHash, k: K, v: V) {
+        let (old_hash, old_key, old_val) = {
+            let (old_hash_ref, old_key_ref, old_val_ref) = self.table.read_all_mut(&index);
+
+            let old_hash = replace(old_hash_ref, hash);
+            let old_key  = replace(old_key_ref,  k);
+            let old_val  = replace(old_val_ref,  v);
+
+            (old_hash, old_key, old_val)
+        };
+
+        let mut probe = self.probe_next(index.raw_index());
+
+        for dib in range(dib_param + 1, self.table.size()) {
+            let full_index = match self.table.peek(probe) {
+                table::Empty(idx) => {
+                    // Finally. A hole!
+                    self.table.put(idx, old_hash, old_key, old_val);
+                    return;
+                },
+                table::Full(idx) => idx
             };
 
-            let mut probe = self.probe_next(index.raw_index());
-
-            for dib in range(dib_param + 1, self.table.size()) {
-                let full_index = match self.table.peek(probe) {
-                    table::Empty(idx) => {
-                        // Finally. A hole!
-                        self.table.put(idx, old_hash, old_key, old_val);
-                        return;
-                    },
-                    table::Full(idx) => idx
-                };
-
-                let probe_dib = self.bucket_distance(&full_index);
-
-                // Robin hood! Steal the spot.
-                if probe_dib < dib {
-                    index = full_index;
-                    dib_param = probe_dib;
-                    hash = old_hash;
-                    k = old_key;
-                    v = old_val;
-                    continue 'outer;
-                }
+            let probe_dib = self.bucket_distance(&full_index);
 
-                probe = self.probe_next(probe);
+            if probe_dib < dib {
+                // Robin hood! Steal the spot. This had better be tail call.
+                return self.robin_hood(full_index, probe_dib, old_hash, old_key, old_val);
             }
 
-            fail!("HashMap fatal error: 100% load factor?");
+            probe = self.probe_next(probe);
         }
+
+        fail!("HashMap fatal error: 100% load factor?");
     }
 
     /// Manually insert a pre-hashed key-value pair, without first checking
@@ -1956,6 +1948,7 @@ mod test_map {
 
 #[cfg(test)]
 mod test_set {
+    use super::HashMap;
     use super::HashSet;
     use std::container::Container;
     use std::vec::ImmutableEqVector;
@@ -2200,6 +2193,7 @@ mod test_set {
 mod bench {
     extern crate test;
     use self::test::BenchHarness;
+    use std::iter;
     use std::iter::{range_inclusive};
 
     #[bench]

branches/auto/src/libcollections/lib.rs

@@ -22,7 +22,6 @@
 // NOTE remove the following two attributes after the next snapshot.
 #[allow(unrecognized_lint)];
 #[allow(default_type_param_usage)];
-#[allow(deprecated_owned_vector)];
 
 extern crate rand;
 

branches/auto/src/libextra/lib.rs

@@ -31,7 +31,6 @@ Rust extras are part of the standard Rust distribution.
 
 #[feature(macro_rules, globs, managed_boxes, asm, default_type_params)];
 
-#[allow(deprecated_owned_vector)];
 #[deny(non_camel_case_types)];
 #[deny(missing_doc)];
 

branches/auto/src/libflate/lib.rs

@@ -90,7 +90,6 @@ pub fn inflate_bytes_zlib(bytes: &[u8]) -> CVec<u8> {
 
 #[cfg(test)]
 mod tests {
-    #[allow(deprecated_owned_vector)];
     extern crate rand;
 
     use super::{inflate_bytes, deflate_bytes};

branches/auto/src/libgetopts/lib.rs

@@ -81,7 +81,6 @@
 #[crate_type = "dylib"];
 #[license = "MIT/ASL2"];
 #[allow(missing_doc)];
-#[allow(deprecated_owned_vector)];
 
 #[feature(globs)];
 

branches/auto/src/libglob/lib.rs

@@ -27,7 +27,6 @@
 #[crate_type = "rlib"];
 #[crate_type = "dylib"];
 #[license = "MIT/ASL2"];
-#[allow(deprecated_owned_vector)];
 
 use std::cell::Cell;
 use std::{cmp, os, path};

branches/auto/src/libgreen/context.rs

@@ -283,6 +283,8 @@ fn initialize_call_frame(regs: &mut Registers, fptr: InitFn, arg: uint,
     unsafe { *sp = 0; }
 
     regs[4] = arg as uint;
+    regs[5] = procedure.code as uint;
+    regs[6] = procedure.env as uint;
     regs[29] = sp as uint;
     regs[25] = fptr as uint;
     regs[31] = fptr as uint;

branches/auto/src/libgreen/lib.rs

@@ -174,7 +174,6 @@
 // NB this does *not* include globs, please keep it that way.
 #[feature(macro_rules)];
 #[allow(visible_private_types)];
-#[allow(deprecated_owned_vector)];
 
 extern crate rand;
 

branches/auto/src/libnative/io/net.rs

@@ -351,11 +351,6 @@ impl rtio::RtioTcpStream for TcpStream {
     fn clone(&self) -> ~rtio::RtioTcpStream {
         ~TcpStream { inner: self.inner.clone() } as ~rtio::RtioTcpStream
     }
-    fn close_write(&mut self) -> IoResult<()> {
-        super::mkerr_libc(unsafe {
-            libc::shutdown(self.fd(), libc::SHUT_WR)
-        })
-    }
 }
 
 impl rtio::RtioSocket for TcpStream {

branches/auto/src/libnative/lib.rs

@@ -50,7 +50,6 @@
       html_root_url = "http://static.rust-lang.org/doc/master")];
 #[deny(unused_result, unused_must_use)];
 #[allow(non_camel_case_types)];
-#[allow(deprecated_owned_vector)];
 
 // NB this crate explicitly does *not* allow glob imports, please seriously
 //    consider whether they're needed before adding that feature here (the

branches/auto/src/libnum/lib.rs

@@ -14,7 +14,6 @@
 #[crate_type = "rlib"];
 #[crate_type = "dylib"];
 #[license = "MIT/ASL2"];
-#[allow(deprecated_owned_vector)];
 
 extern crate rand;
 

branches/auto/src/librand/lib.rs

@@ -71,7 +71,6 @@ println!("{:?}", tuple_ptr)
       html_root_url = "http://static.rust-lang.org/doc/master")];
 
 #[feature(macro_rules, managed_boxes)];
-#[allow(deprecated_owned_vector)];
 
 use std::cast;
 use std::kinds::marker;

branches/auto/src/librustc/back/mips.rs

@@ -22,39 +22,39 @@ pub fn get_target_strs(target_triple: ~str, target_os: abi::Os) -> target_strs::
 
         data_layout: match target_os {
           abi::OsMacos => {
-            ~"e-p:32:32:32" +
+            ~"E-p:32:32:32" +
                 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" +
                 "-f32:32:32-f64:64:64" +
                 "-v64:64:64-v128:64:128" +
                 "-a0:0:64-n32"
           }
 
           abi::OsWin32 => {
-            ~"e-p:32:32:32" +
+            ~"E-p:32:32:32" +
                 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" +
                 "-f32:32:32-f64:64:64" +
                 "-v64:64:64-v128:64:128" +
                 "-a0:0:64-n32"
           }
 
           abi::OsLinux => {
-            ~"e-p:32:32:32" +
+            ~"E-p:32:32:32" +
                 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" +
                 "-f32:32:32-f64:64:64" +
                 "-v64:64:64-v128:64:128" +
                 "-a0:0:64-n32"
           }
 
           abi::OsAndroid => {
-            ~"e-p:32:32:32" +
+            ~"E-p:32:32:32" +
                 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" +
                 "-f32:32:32-f64:64:64" +
                 "-v64:64:64-v128:64:128" +
                 "-a0:0:64-n32"
           }
 
           abi::OsFreebsd => {
-            ~"e-p:32:32:32" +
+            ~"E-p:32:32:32" +
                 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" +
                 "-f32:32:32-f64:64:64" +
                 "-v64:64:64-v128:64:128" +