---

yaml
---
r: 106398
b: refs/heads/auto
c: 9ed33c0
h: refs/heads/master
v: v3

Author: sfackler

[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: a7085940499748558f4236368a145b03f521843b
+refs/heads/auto: 9ed33c00ead8ad048488476310da434c461f4a4e
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/configure

@@ -274,12 +274,6 @@ case $CFG_OSTYPE in
     MINGW32*)
         CFG_OSTYPE=pc-mingw32
         ;;
-
-    MINGW64*)
-        # msys2, MSYSTEM=MINGW64
-        CFG_OSTYPE=w64-mingw32
-        ;;
-
 # Thad's Cygwin identifers below
 
 #   Vista 32 bit
@@ -413,7 +407,7 @@ valopt mandir "${CFG_PREFIX}/share/man" "install man pages in PATH"
 # --libdir is used to configure the installation directory.
 # FIXME: Thise needs to parameterized over target triples. Do it in platform.mk
 CFG_LIBDIR_RELATIVE=lib
-if [ "$CFG_OSTYPE" = "pc-mingw32" ] || [ "$CFG_OSTYPE" = "w64-mingw32" ]
+if [ "$CFG_OSTYPE" = "pc-mingw32" ]
 then
     CFG_LIBDIR_RELATIVE=bin
 fi
@@ -539,7 +533,7 @@ then
 fi
 
 BIN_SUF=
-if [ "$CFG_OSTYPE" = "pc-mingw32" ] || [ "$CFG_OSTYPE" = "w64-mingw32" ]
+if [ $CFG_OSTYPE = "pc-mingw32" ]
 then
     BIN_SUF=.exe
 fi

branches/auto/src/libarena/lib.rs

@@ -27,6 +27,8 @@
 
 extern crate collections;
 
+use collections::list::{List, Cons, Nil};
+
 use std::cast::{transmute, transmute_mut, transmute_mut_region};
 use std::cast;
 use std::cell::{Cell, RefCell};
@@ -85,7 +87,7 @@ pub struct Arena {
     // access the head.
     priv head: Chunk,
     priv copy_head: Chunk,
-    priv chunks: RefCell<Vec<Chunk>>,
+    priv chunks: RefCell<@List<Chunk>>,
 }
 
 impl Arena {
@@ -97,7 +99,7 @@ impl Arena {
         Arena {
             head: chunk(initial_size, false),
             copy_head: chunk(initial_size, true),
-            chunks: RefCell::new(Vec::new()),
+            chunks: RefCell::new(@Nil),
         }
     }
 }
@@ -115,7 +117,7 @@ impl Drop for Arena {
     fn drop(&mut self) {
         unsafe {
             destroy_chunk(&self.head);
-            for chunk in self.chunks.borrow().iter() {
+            for chunk in self.chunks.get().iter() {
                 if !chunk.is_copy.get() {
                     destroy_chunk(chunk);
                 }
@@ -177,7 +179,7 @@ impl Arena {
     fn alloc_copy_grow(&mut self, n_bytes: uint, align: uint) -> *u8 {
         // Allocate a new chunk.
         let new_min_chunk_size = cmp::max(n_bytes, self.chunk_size());
-        self.chunks.borrow_mut().push(self.copy_head.clone());
+        self.chunks.set(@Cons(self.copy_head.clone(), self.chunks.get()));
         self.copy_head =
             chunk(num::next_power_of_two(new_min_chunk_size + 1u), true);
 
@@ -217,7 +219,7 @@ impl Arena {
                          -> (*u8, *u8) {
         // Allocate a new chunk.
         let new_min_chunk_size = cmp::max(n_bytes, self.chunk_size());
-        self.chunks.borrow_mut().push(self.head.clone());
+        self.chunks.set(@Cons(self.head.clone(), self.chunks.get()));
         self.head =
             chunk(num::next_power_of_two(new_min_chunk_size + 1u), false);
 

branches/auto/src/libcollections/lib.rs

@@ -33,6 +33,7 @@ pub use deque::Deque;
 pub use dlist::DList;
 pub use enum_set::EnumSet;
 pub use hashmap::{HashMap, HashSet};
+pub use list::List;
 pub use lru_cache::LruCache;
 pub use priority_queue::PriorityQueue;
 pub use ringbuf::RingBuf;
@@ -46,6 +47,7 @@ pub mod deque;
 pub mod dlist;
 pub mod enum_set;
 pub mod hashmap;
+pub mod list;
 pub mod lru_cache;
 pub mod priority_queue;
 pub mod ringbuf;

branches/auto/src/libcollections/list.rs

@@ -0,0 +1,237 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! A standard, garbage-collected linked list.
+
+use std::container::Container;
+
+#[deriving(Clone, Eq)]
+#[allow(missing_doc)]
+pub enum List<T> {
+    Cons(T, @List<T>),
+    Nil,
+}
+
+pub struct Items<'a, T> {
+    priv head: &'a List<T>,
+    priv next: Option<&'a @List<T>>
+}
+
+impl<'a, T> Iterator<&'a T> for Items<'a, T> {
+    fn next(&mut self) -> Option<&'a T> {
+        match self.next {
+            None => match *self.head {
+                Nil => None,
+                Cons(ref value, ref tail) => {
+                    self.next = Some(tail);
+                    Some(value)
+                }
+            },
+            Some(next) => match **next {
+                Nil => None,
+                Cons(ref value, ref tail) => {
+                    self.next = Some(tail);
+                    Some(value)
+                }
+            }
+        }
+    }
+}
+
+impl<T> List<T> {
+    /// Returns a forward iterator
+    pub fn iter<'a>(&'a self) -> Items<'a, T> {
+        Items {
+            head: self,
+            next: None
+        }
+    }
+
+    /// Returns the first element of a list
+    pub fn head<'a>(&'a self) -> Option<&'a T> {
+        match *self {
+          Nil => None,
+          Cons(ref head, _) => Some(head)
+        }
+    }
+
+    /// Returns all but the first element of a list
+    pub fn tail(&self) -> Option<@List<T>> {
+        match *self {
+            Nil => None,
+            Cons(_, tail) => Some(tail)
+        }
+    }
+}
+
+impl<T> Container for List<T> {
+    /// Returns the length of a list
+    fn len(&self) -> uint { self.iter().len() }
+
+    /// Returns true if the list is empty
+    fn is_empty(&self) -> bool { match *self { Nil => true, _ => false } }
+}
+
+impl<T:Eq> List<T> {
+    /// Returns true if a list contains an element with the given value
+    pub fn contains(&self, element: T) -> bool {
+        self.iter().any(|list_element| *list_element == element)
+    }
+}
+
+impl<T:'static + Clone> List<T> {
+    /// Create a list from a vector
+    pub fn from_vec(v: &[T]) -> List<T> {
+        match v.len() {
+            0 => Nil,
+            _ => v.rev_iter().fold(Nil, |tail, value: &T| Cons(value.clone(), @tail))
+        }
+    }
+
+    /// Appends one list to another, returning a new list
+    pub fn append(&self, other: List<T>) -> List<T> {
+        match other {
+            Nil => return self.clone(),
+            _ => match *self {
+                Nil => return other,
+                Cons(ref value, tail) => Cons(value.clone(), @tail.append(other))
+            }
+        }
+    }
+
+    /// Push one element into the front of a list, returning a new list
+    pub fn unshift(&self, element: T) -> List<T> {
+        Cons(element, @(self.clone()))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use list::{List, Nil};
+    use list;
+
+    #[test]
+    fn test_iter() {
+        let list = List::from_vec([0, 1, 2]);
+        let mut iter = list.iter();
+        assert_eq!(&0, iter.next().unwrap());
+        assert_eq!(&1, iter.next().unwrap());
+        assert_eq!(&2, iter.next().unwrap());
+        assert_eq!(None, iter.next());
+    }
+
+    #[test]
+    fn test_is_empty() {
+        let empty : list::List<int> = List::from_vec([]);
+        let full1 = List::from_vec([1]);
+        let full2 = List::from_vec(['r', 'u']);
+
+        assert!(empty.is_empty());
+        assert!(!full1.is_empty());
+        assert!(!full2.is_empty());
+    }
+
+    #[test]
+    fn test_from_vec() {
+        let list = List::from_vec([0, 1, 2]);
+        assert_eq!(list.head().unwrap(), &0);
+
+        let mut tail = list.tail().unwrap();
+        assert_eq!(tail.head().unwrap(), &1);
+
+        tail = tail.tail().unwrap();
+        assert_eq!(tail.head().unwrap(), &2);
+    }
+
+    #[test]
+    fn test_from_vec_empty() {
+        let empty : list::List<int> = List::from_vec([]);
+        assert!(empty == Nil::<int>);
+    }
+
+    #[test]
+    fn test_fold() {
+        fn add_(a: uint, b: &uint) -> uint { a + *b }
+        fn subtract_(a: uint, b: &uint) -> uint { a - *b }
+
+        let empty = Nil::<uint>;
+        assert_eq!(empty.iter().fold(0u, add_), 0u);
+        assert_eq!(empty.iter().fold(10u, subtract_), 10u);
+
+        let list = List::from_vec([0u, 1u, 2u, 3u, 4u]);
+        assert_eq!(list.iter().fold(0u, add_), 10u);
+        assert_eq!(list.iter().fold(10u, subtract_), 0u);
+    }
+
+    #[test]
+    fn test_find_success() {
+        fn match_(i: & &int) -> bool { **i == 2 }
+
+        let list = List::from_vec([0, 1, 2]);
+        assert_eq!(list.iter().find(match_).unwrap(), &2);
+    }
+
+    #[test]
+    fn test_find_fail() {
+        fn match_(_i: & &int) -> bool { false }
+
+        let empty = Nil::<int>;
+        assert_eq!(empty.iter().find(match_), None);
+
+        let list = List::from_vec([0, 1, 2]);
+        assert_eq!(list.iter().find(match_), None);
+    }
+
+    #[test]
+    fn test_any() {
+        fn match_(i: &int) -> bool { *i == 2 }
+
+        let empty = Nil::<int>;
+        assert_eq!(empty.iter().any(match_), false);
+
+        let list = List::from_vec([0, 1, 2]);
+        assert_eq!(list.iter().any(match_), true);
+    }
+
+    #[test]
+    fn test_contains() {
+        let empty = Nil::<int>;
+        assert!((!empty.contains(5)));
+
+        let list = List::from_vec([5, 8, 6]);
+        assert!((list.contains(5)));
+        assert!((!list.contains(7)));
+        assert!((list.contains(8)));
+    }
+
+    #[test]
+    fn test_len() {
+        let empty = Nil::<int>;
+        assert_eq!(empty.len(), 0u);
+
+        let list = List::from_vec([0, 1, 2]);
+        assert_eq!(list.len(), 3u);
+    }
+
+    #[test]
+    fn test_append() {
+        assert!(List::from_vec([1, 2, 3, 4]) ==
+                List::from_vec([1, 2]).append(List::from_vec([3, 4])));
+    }
+
+    #[test]
+    fn test_unshift() {
+        let list = List::from_vec([1]);
+        let new_list = list.unshift(0);
+        assert_eq!(list.len(), 1u);
+        assert_eq!(new_list.len(), 2u);
+        assert!(new_list == List::from_vec([0, 1]));
+    }
+}

branches/auto/src/libgreen/sched.rs

@@ -1473,7 +1473,7 @@ mod test {
             let mut handle = pool.spawn_sched();
             handle.send(PinnedTask(pool.task(TaskOpts::new(), proc() {
                 unsafe {
-                    let guard = LOCK.lock();
+                    let mut guard = LOCK.lock();
 
                     start_tx.send(());
                     guard.wait();   // block the scheduler thread
@@ -1509,7 +1509,7 @@ mod test {
                 child_tx.send(20);
                 pingpong(&parent_rx, &child_tx);
                 unsafe {
-                    let guard = LOCK.lock();
+                    let mut guard = LOCK.lock();
                     guard.signal();   // wakeup waiting scheduler
                     guard.wait();     // wait for them to grab the lock
                 }

branches/auto/src/librustc/front/test.rs

@@ -282,7 +282,7 @@ fn add_test_module(cx: &TestCtxt, m: &ast::Mod) -> ast::Mod {
 We're going to be building a module that looks more or less like:
 
 mod __test {
-  #[!resolve_unexported]
+  #![!resolve_unexported]
   extern crate test (name = "test", vers = "...");
   fn main() {
     test::test_main_static(::os::args(), tests)
@@ -326,8 +326,8 @@ fn mk_test_module(cx: &TestCtxt) -> @ast::Item {
     // with our list of tests
     let mainfn = (quote_item!(&cx.ext_cx,
         pub fn main() {
-            #[allow(deprecated_owned_vector)];
-            #[main];
+            #![main]
+            #![allow(deprecated_owned_vector)]
             test::test_main_static(::std::os::args(), TESTS);
         }
     )).unwrap();