---

yaml
---
r: 64316
b: refs/heads/snap-stage3
c: bbe03da
h: refs/heads/master
v: v3

Author: MarkJr94

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 9fd2ac7428afa4f414f32b8b4876ca817ee85f16
+refs/heads/snap-stage3: bbe03da9c6bad23d8e09077461c1616872e1aca0
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/mk/dist.mk

@@ -19,9 +19,7 @@ PKG_FILES := \
     $(S)LICENSE-APACHE                         \
     $(S)LICENSE-MIT                            \
     $(S)AUTHORS.txt                            \
-    $(S)CONTRIBUTING.md                        \
     $(S)README.md                              \
-    $(S)RELEASES.txt                           \
     $(S)configure $(S)Makefile.in              \
     $(S)man                                    \
     $(S)doc                                    \

branches/snap-stage3/mk/install.mk

@@ -183,11 +183,7 @@ uninstall:
         do rm -f $$i ; \
         done
 	$(Q)rm -Rf $(PHL)/rustc
-	$(Q)rm -f $(PREFIX_ROOT)/share/man/man1/rust.1
 	$(Q)rm -f $(PREFIX_ROOT)/share/man/man1/rustc.1
-	$(Q)rm -f $(PREFIX_ROOT)/share/man/man1/rustdoc.1
-	$(Q)rm -f $(PREFIX_ROOT)/share/man/man1/rusti.1
-	$(Q)rm -f $(PREFIX_ROOT)/share/man/man1/rustpkg.1
 
 # target platform specific variables
 # for arm-linux-androidabi

branches/snap-stage3/src/libextra/bitv.rs

@@ -718,6 +718,38 @@ impl Set<uint> for BitvSet {
         *value < self.bitv.storage.len() * uint::bits && self.bitv.get(*value)
     }
 
+    fn insert(&mut self, value: uint) -> bool {
+        if self.contains(&value) {
+            return false;
+        }
+        let nbits = self.capacity();
+        if value >= nbits {
+            let newsize = num::max(value, nbits * 2) / uint::bits + 1;
+            assert!(newsize > self.bitv.storage.len());
+            self.bitv.storage.grow(newsize, &0);
+        }
+        self.size += 1;
+        self.bitv.set(value, true);
+        return true;
+    }
+
+    fn remove(&mut self, value: &uint) -> bool {
+        if !self.contains(value) {
+            return false;
+        }
+        self.size -= 1;
+        self.bitv.set(*value, false);
+
+        // Attempt to truncate our storage
+        let mut i = self.bitv.storage.len();
+        while i > 1 && self.bitv.storage[i - 1] == 0 {
+            i -= 1;
+        }
+        self.bitv.storage.truncate(i);
+
+        return true;
+    }
+
     fn is_disjoint(&self, other: &BitvSet) -> bool {
         for self.intersection(other) |_| {
             return false;
@@ -784,40 +816,6 @@ impl Set<uint> for BitvSet {
     }
 }
 
-impl MutableSet<uint> for BitvSet {
-    fn insert(&mut self, value: uint) -> bool {
-        if self.contains(&value) {
-            return false;
-        }
-        let nbits = self.capacity();
-        if value >= nbits {
-            let newsize = num::max(value, nbits * 2) / uint::bits + 1;
-            assert!(newsize > self.bitv.storage.len());
-            self.bitv.storage.grow(newsize, &0);
-        }
-        self.size += 1;
-        self.bitv.set(value, true);
-        return true;
-    }
-
-    fn remove(&mut self, value: &uint) -> bool {
-        if !self.contains(value) {
-            return false;
-        }
-        self.size -= 1;
-        self.bitv.set(*value, false);
-
-        // Attempt to truncate our storage
-        let mut i = self.bitv.storage.len();
-        while i > 1 && self.bitv.storage[i - 1] == 0 {
-            i -= 1;
-        }
-        self.bitv.storage.truncate(i);
-
-        return true;
-    }
-}
-
 impl BitvSet {
     /// Visits each of the words that the two bit vectors (self and other)
     /// both have in common. The three yielded arguments are (bit location,

branches/snap-stage3/src/libextra/priority_queue.rs

@@ -16,6 +16,7 @@
 use std::unstable::intrinsics::{move_val_init, init};
 use std::util::{replace, swap};
 use std::vec;
+use std::iterator::FromIterator;
 
 /// A priority queue implemented with a binary heap
 pub struct PriorityQueue<T> {
@@ -191,6 +192,21 @@ impl<'self, T> Iterator<&'self T> for PriorityQueueIterator<'self, T> {
     fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
 }
 
+impl<T: Ord, Iter: Iterator<T>> FromIterator<T, Iter> for PriorityQueue<T> {
+    pub fn from_iterator(iter: &mut Iter) -> PriorityQueue<T> {
+        let (lower, _) = iter.size_hint();
+
+        let mut q = PriorityQueue::new();
+        q.reserve_at_least(lower);
+
+        for iter.advance |elem| {
+            q.push(elem);
+        }
+
+        q
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use sort::merge_sort;
@@ -341,4 +357,15 @@ mod tests {
     #[should_fail]
     #[ignore(cfg(windows))]
     fn test_empty_replace() { let mut heap = PriorityQueue::new(); heap.replace(5); }
+
+    #[test]
+    fn test_from_iter() {
+        let xs = ~[9u, 8, 7, 6, 5, 4, 3, 2, 1];
+
+        let mut q: PriorityQueue<uint> = xs.rev_iter().transform(|&x| x).collect();
+
+        for xs.iter().advance |&x| {
+            assert_eq!(q.pop(), x);
+        }
+    }
 }

branches/snap-stage3/src/libextra/rl.rs

@@ -66,28 +66,24 @@ pub unsafe fn read(prompt: &str) -> Option<~str> {
     }
 }
 
-pub type CompletionCb = @fn(~str, @fn(~str));
+pub type CompletionCb<'self> = @fn(~str, &'self fn(~str));
 
-#[cfg(not(stage0))]
-static complete_key: local_data::Key<@CompletionCb> = &local_data::Key;
-#[cfg(stage0)]
-fn complete_key(_: @CompletionCb) {}
+fn complete_key(_v: @CompletionCb) {}
 
 /// Bind to the main completion callback
 pub unsafe fn complete(cb: CompletionCb) {
-    local_data::set(complete_key, @cb);
+    local_data::set(complete_key, @(cb));
 
     extern fn callback(line: *c_char, completions: *()) {
-        do local_data::get(complete_key) |cb| {
-            let cb = **cb.unwrap();
-
-            unsafe {
-                do cb(str::raw::from_c_str(line)) |suggestion| {
-                    do str::as_c_str(suggestion) |buf| {
-                        rustrt::linenoiseAddCompletion(completions, buf);
-                    }
+        unsafe {
+            let cb = *local_data::get(complete_key, |k| k.map(|&k| *k))
+                .get();
+
+            do cb(str::raw::from_c_str(line)) |suggestion| {
+                do str::as_c_str(suggestion) |buf| {
+                    rustrt::linenoiseAddCompletion(completions, buf);
                 }
-}
+            }
         }
     }
 

branches/snap-stage3/src/libextra/smallintmap.rs

@@ -17,7 +17,8 @@
 
 
 use std::cmp;
-use std::iterator::{Iterator,IteratorUtil,ZipIterator,Counter,EnumerateIterator,FilterMapIterator};
+use std::container::{Container, Mutable, Map, Set};
+use std::iterator::*;
 use std::uint;
 use std::util::replace;
 use std::vec::{VecIterator,VecMutIterator,VecRevIterator,VecMutRevIterator};
@@ -67,9 +68,7 @@ impl<V> Map<uint, V> for SmallIntMap<V> {
             None
         }
     }
-}
 
-impl<V> MutableMap<uint, V> for SmallIntMap<V> {
     /// Return a mutable reference to the value corresponding to the key
     fn find_mut<'a>(&'a mut self, key: &uint) -> Option<&'a mut V> {
         if *key < self.v.len() {
@@ -350,6 +349,14 @@ impl Set<uint> for SmallIntSet {
     /// Return true if the set contains a value
     fn contains(&self, value: &uint) -> bool { self.map.contains_key(value) }
 
+    /// Add a value to the set. Return true if the value was not already
+    /// present in the set.
+    fn insert(&mut self, value: uint) -> bool { self.map.insert(value, ()) }
+
+    /// Remove a value from the set. Return true if the value was
+    /// present in the set.
+    fn remove(&mut self, value: &uint) -> bool { self.map.remove(value) }
+
     /// Return true if the set has no elements in common with `other`.
     /// This is equivalent to checking for an empty uintersection.
     fn is_disjoint(&self, other: &SmallIntSet) -> bool {
@@ -405,16 +412,6 @@ impl Set<uint> for SmallIntSet {
     }
 }
 
-impl MutableSet<uint> for SmallIntSet {
-    /// Add a value to the set. Return true if the value was not already
-    /// present in the set.
-    fn insert(&mut self, value: uint) -> bool { self.map.insert(value, ()) }
-
-    /// Remove a value from the set. Return true if the value was
-    /// present in the set.
-    fn remove(&mut self, value: &uint) -> bool { self.map.remove(value) }
-}
-
 impl SmallIntSet {
     /// Create an empty SmallIntSet
     pub fn new() -> SmallIntSet { SmallIntSet{map: SmallIntMap::new()} }

branches/snap-stage3/src/libextra/sort.rs

@@ -1195,4 +1195,39 @@ mod big_tests {
             isSorted(arr);
         }
     }
+
+    struct LVal<'self> {
+        val: uint,
+        key: &'self fn:Copy(@uint),
+    }
+
+    #[unsafe_destructor]
+    impl<'self> Drop for LVal<'self> {
+        fn drop(&self) {
+            let x = unsafe { local_data::get(self.key, |k| k.map(|&k| *k)) };
+            match x {
+                Some(@y) => {
+                    unsafe {
+                        local_data::set(self.key, @(y+1));
+                    }
+                }
+                _ => fail!("Expected key to work"),
+            }
+        }
+    }
+
+    impl<'self> Ord for LVal<'self> {
+        fn lt<'a>(&self, other: &'a LVal<'self>) -> bool {
+            (*self).val < other.val
+        }
+        fn le<'a>(&self, other: &'a LVal<'self>) -> bool {
+            (*self).val <= other.val
+        }
+        fn gt<'a>(&self, other: &'a LVal<'self>) -> bool {
+            (*self).val > other.val
+        }
+        fn ge<'a>(&self, other: &'a LVal<'self>) -> bool {
+            (*self).val >= other.val
+        }
+    }
 }