---

yaml
---
r: 69488
b: refs/heads/auto
c: f34fadd
h: refs/heads/master
v: v3

Author: bblum

[refs]

@@ -14,6 +14,6 @@ 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: aa89325cb01308f48b134f199a99c6d2f4e0bfe9
+refs/heads/auto: f34fadd126ce9ffcd5a79c3ad5d06ad58c6fd8a8
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c

branches/auto/mk/tests.mk

@@ -312,26 +312,28 @@ define TEST_RUNNER
 # If NO_REBUILD is set then break the dependencies on extra so we can
 # test crates without rebuilding std and extra first
 ifeq ($(NO_REBUILD),)
-STDTESTDEP_$(1)_$(2)_$(3) = $$(SREQ$(1)_T_$(2)_H_$(3)) \
-                            $$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_EXTRALIB_$(2))
+STDTESTDEP_$(1)_$(2)_$(3) = $$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_EXTRALIB_$(2))
 else
 STDTESTDEP_$(1)_$(2)_$(3) =
 endif
 
 $(3)/stage$(1)/test/stdtest-$(2)$$(X_$(2)):			\
 		$$(STDLIB_CRATE) $$(STDLIB_INPUTS)	\
+		$$(SREQ$(1)_T_$(2)_H_$(3)) \
 		$$(STDTESTDEP_$(1)_$(2)_$(3))
 	@$$(call E, compile_and_link: $$@)
 	$$(STAGE$(1)_T_$(2)_H_$(3)) -o $$@ $$< --test
 
 $(3)/stage$(1)/test/extratest-$(2)$$(X_$(2)):			\
 		$$(EXTRALIB_CRATE) $$(EXTRALIB_INPUTS)	\
+		$$(SREQ$(1)_T_$(2)_H_$(3)) \
 		$$(STDTESTDEP_$(1)_$(2)_$(3))
 	@$$(call E, compile_and_link: $$@)
 	$$(STAGE$(1)_T_$(2)_H_$(3)) -o $$@ $$< --test
 
 $(3)/stage$(1)/test/syntaxtest-$(2)$$(X_$(2)):			\
 		$$(LIBSYNTAX_CRATE) $$(LIBSYNTAX_INPUTS)	\
+		$$(SREQ$(1)_T_$(2)_H_$(3)) \
 		$$(STDTESTDEP_$(1)_$(2)_$(3))
 	@$$(call E, compile_and_link: $$@)
 	$$(STAGE$(1)_T_$(2)_H_$(3)) -o $$@ $$< --test

branches/auto/src/libextra/arena.rs

@@ -116,7 +116,7 @@ unsafe fn destroy_chunk(chunk: &Chunk) {
     let fill = chunk.fill;
 
     while idx < fill {
-        let tydesc_data: *uint = transmute(ptr::offset(buf, idx as int));
+        let tydesc_data: *uint = transmute(ptr::offset(buf, idx));
         let (tydesc, is_done) = un_bitpack_tydesc_ptr(*tydesc_data);
         let (size, align) = ((*tydesc).size, (*tydesc).align);
 
@@ -127,7 +127,7 @@ unsafe fn destroy_chunk(chunk: &Chunk) {
         //debug!("freeing object: idx = %u, size = %u, align = %u, done = %b",
         //       start, size, align, is_done);
         if is_done {
-            ((*tydesc).drop_glue)(ptr::offset(buf, start as int) as *i8);
+            ((*tydesc).drop_glue)(ptr::offset(buf, start) as *i8);
         }
 
         // Find where the next tydesc lives
@@ -176,7 +176,7 @@ impl Arena {
             //debug!("idx = %u, size = %u, align = %u, fill = %u",
             //       start, n_bytes, align, head.fill);
 
-            ptr::offset(vec::raw::to_ptr(this.pod_head.data), start as int)
+            ptr::offset(vec::raw::to_ptr(this.pod_head.data), start)
         }
     }
 
@@ -233,7 +233,7 @@ impl Arena {
             //       start, n_bytes, align, head.fill);
 
             let buf = vec::raw::to_ptr(self.head.data);
-            return (ptr::offset(buf, tydesc_start as int), ptr::offset(buf, start as int));
+            return (ptr::offset(buf, tydesc_start), ptr::offset(buf, start));
         }
     }
 

branches/auto/src/libextra/bitv.rs

@@ -12,13 +12,11 @@
 
 
 use std::cmp;
-use std::iterator::{DoubleEndedIterator, RandomAccessIterator, Invert};
 use std::num;
 use std::ops;
 use std::uint;
 use std::vec;
 
-
 #[deriving(Clone)]
 struct SmallBitv {
     /// only the lowest nbits of this value are used. the rest is undefined.
@@ -406,12 +404,7 @@ impl Bitv {
 
     #[inline]
     pub fn iter<'a>(&'a self) -> BitvIterator<'a> {
-        BitvIterator {bitv: self, next_idx: 0, end_idx: self.nbits}
-    }
-
-    #[inline]
-    pub fn rev_liter<'a>(&'a self) -> Invert<BitvIterator<'a>> {
-        self.iter().invert()
+        BitvIterator {bitv: self, next_idx: 0}
     }
 
     /// Returns true if all bits are 0
@@ -571,14 +564,13 @@ fn iterate_bits(base: uint, bits: uint, f: &fn(uint) -> bool) -> bool {
 /// An iterator for Bitv
 pub struct BitvIterator<'self> {
     priv bitv: &'self Bitv,
-    priv next_idx: uint,
-    priv end_idx: uint,
+    priv next_idx: uint
 }
 
 impl<'self> Iterator<bool> for BitvIterator<'self> {
     #[inline]
     fn next(&mut self) -> Option<bool> {
-        if self.next_idx != self.end_idx {
+        if self.next_idx < self.bitv.nbits {
             let idx = self.next_idx;
             self.next_idx += 1;
             Some(self.bitv.get(idx))
@@ -588,39 +580,11 @@ impl<'self> Iterator<bool> for BitvIterator<'self> {
     }
 
     fn size_hint(&self) -> (uint, Option<uint>) {
-        let rem = self.end_idx - self.next_idx;
+        let rem = self.bitv.nbits - self.next_idx;
         (rem, Some(rem))
     }
 }
 
-impl<'self> DoubleEndedIterator<bool> for BitvIterator<'self> {
-    #[inline]
-    fn next_back(&mut self) -> Option<bool> {
-        if self.next_idx != self.end_idx {
-            self.end_idx -= 1;
-            Some(self.bitv.get(self.end_idx))
-        } else {
-            None
-        }
-    }
-}
-
-impl<'self> RandomAccessIterator<bool> for BitvIterator<'self> {
-    #[inline]
-    fn indexable(&self) -> uint {
-        self.end_idx - self.next_idx
-    }
-
-    #[inline]
-    fn idx(&self, index: uint) -> Option<bool> {
-        if index >= self.indexable() {
-            None
-        } else {
-            Some(self.bitv.get(index))
-        }
-    }
-}
-
 /// An implementation of a set using a bit vector as an underlying
 /// representation for holding numerical elements.
 ///

branches/auto/src/libextra/c_vec.rs

@@ -122,7 +122,7 @@ pub unsafe fn c_vec_with_dtor<T>(base: *mut T, len: uint, dtor: @fn())
 pub fn get<T:Clone>(t: CVec<T>, ofs: uint) -> T {
     assert!(ofs < len(t));
     return unsafe {
-        (*ptr::mut_offset(t.base, ofs as int)).clone()
+        (*ptr::mut_offset(t.base, ofs)).clone()
     };
 }
 
@@ -133,7 +133,7 @@ pub fn get<T:Clone>(t: CVec<T>, ofs: uint) -> T {
  */
 pub fn set<T>(t: CVec<T>, ofs: uint, v: T) {
     assert!(ofs < len(t));
-    unsafe { *ptr::mut_offset(t.base, ofs as int) = v };
+    unsafe { *ptr::mut_offset(t.base, ofs) = v };
 }
 
 /*

branches/auto/src/libextra/dlist.rs

@@ -25,7 +25,7 @@
 use std::cast;
 use std::ptr;
 use std::util;
-use std::iterator::{FromIterator, Extendable, Invert};
+use std::iterator::{FromIterator, InvertIterator};
 
 use container::Deque;
 
@@ -356,7 +356,7 @@ impl<T> DList<T> {
 
     /// Provide a reverse iterator
     #[inline]
-    pub fn rev_iter<'a>(&'a self) -> Invert<DListIterator<'a, T>> {
+    pub fn rev_iter<'a>(&'a self) -> InvertIterator<DListIterator<'a, T>> {
         self.iter().invert()
     }
 
@@ -376,7 +376,7 @@ impl<T> DList<T> {
     }
     /// Provide a reverse iterator with mutable references
     #[inline]
-    pub fn mut_rev_iter<'a>(&'a mut self) -> Invert<MutDListIterator<'a, T>> {
+    pub fn mut_rev_iter<'a>(&'a mut self) -> InvertIterator<MutDListIterator<'a, T>> {
         self.mut_iter().invert()
     }
 
@@ -389,7 +389,7 @@ impl<T> DList<T> {
 
     /// Consume the list into an iterator yielding elements by value, in reverse
     #[inline]
-    pub fn consume_rev_iter(self) -> Invert<ConsumeIterator<T>> {
+    pub fn consume_rev_iter(self) -> InvertIterator<ConsumeIterator<T>> {
         self.consume_iter().invert()
     }
 }
@@ -541,17 +541,11 @@ impl<A> DoubleEndedIterator<A> for ConsumeIterator<A> {
 impl<A, T: Iterator<A>> FromIterator<A, T> for DList<A> {
     fn from_iterator(iterator: &mut T) -> DList<A> {
         let mut ret = DList::new();
-        ret.extend(iterator);
+        for iterator.advance |elt| { ret.push_back(elt); }
         ret
     }
 }
 
-impl<A, T: Iterator<A>> Extendable<A, T> for DList<A> {
-    fn extend(&mut self, iterator: &mut T) {
-        for iterator.advance |elt| { self.push_back(elt); }
-    }
-}
-
 impl<A: Eq> Eq for DList<A> {
     fn eq(&self, other: &DList<A>) -> bool {
         self.len() == other.len() &&

branches/auto/src/libextra/ebml.rs

@@ -150,7 +150,7 @@ pub mod reader {
 
         unsafe {
             let (ptr, _): (*u8, uint) = transmute(data);
-            let ptr = offset(ptr, start as int);
+            let ptr = offset(ptr, start);
             let ptr: *i32 = transmute(ptr);
             let val = bswap32(*ptr);
             let val: u32 = transmute(val);

branches/auto/src/libextra/getopts.rs

@@ -476,6 +476,7 @@ pub mod groups {
     use getopts::{HasArg, Long, Maybe, Multi, No, Occur, Opt, Optional, Req};
     use getopts::{Short, Yes};
 
+    use std::str;
     use std::vec;
 
     /** one group of options, e.g., both -h and --help, along with
@@ -666,7 +667,7 @@ pub mod groups {
 
             // FIXME: #5516
             let mut desc_rows = ~[];
-            for each_split_within(desc_normalized_whitespace, 54) |substr| {
+            for str::each_split_within(desc_normalized_whitespace, 54) |substr| {
                 desc_rows.push(substr.to_owned());
             }
 
@@ -682,103 +683,6 @@ pub mod groups {
                rows.collect::<~[~str]>().connect("\n") +
                "\n\n";
     }
-
-    /** Splits a string into substrings with possibly internal whitespace,
-     *  each of them at most `lim` bytes long. The substrings have leading and trailing
-     *  whitespace removed, and are only cut at whitespace boundaries.
-     *
-     *  Note: Function was moved here from `std::str` because this module is the only place that
-     *  uses it, and because it was to specific for a general string function.
-     *
-     *  #Failure:
-     *
-     *  Fails during iteration if the string contains a non-whitespace
-     *  sequence longer than the limit.
-     */
-    priv fn each_split_within<'a>(ss: &'a str,
-                                lim: uint,
-                                it: &fn(&'a str) -> bool) -> bool {
-        // Just for fun, let's write this as an state machine:
-
-        enum SplitWithinState {
-            A,  // leading whitespace, initial state
-            B,  // words
-            C,  // internal and trailing whitespace
-        }
-        enum Whitespace {
-            Ws, // current char is whitespace
-            Cr  // current char is not whitespace
-        }
-        enum LengthLimit {
-            UnderLim, // current char makes current substring still fit in limit
-            OverLim   // current char makes current substring no longer fit in limit
-        }
-
-        let mut slice_start = 0;
-        let mut last_start = 0;
-        let mut last_end = 0;
-        let mut state = A;
-        let mut fake_i = ss.len();
-        let mut lim = lim;
-
-        let mut cont = true;
-        let slice: &fn() = || { cont = it(ss.slice(slice_start, last_end)) };
-
-        // if the limit is larger than the string, lower it to save cycles
-        if (lim >= fake_i) {
-            lim = fake_i;
-        }
-
-        let machine: &fn((uint, char)) -> bool = |(i, c)| {
-            let whitespace = if ::std::char::is_whitespace(c) { Ws }       else { Cr };
-            let limit      = if (i - slice_start + 1) <= lim  { UnderLim } else { OverLim };
-
-            state = match (state, whitespace, limit) {
-                (A, Ws, _)        => { A }
-                (A, Cr, _)        => { slice_start = i; last_start = i; B }
-
-                (B, Cr, UnderLim) => { B }
-                (B, Cr, OverLim)  if (i - last_start + 1) > lim
-                                => fail!("word starting with %? longer than limit!",
-                                        ss.slice(last_start, i + 1)),
-                (B, Cr, OverLim)  => { slice(); slice_start = last_start; B }
-                (B, Ws, UnderLim) => { last_end = i; C }
-                (B, Ws, OverLim)  => { last_end = i; slice(); A }
-
-                (C, Cr, UnderLim) => { last_start = i; B }
-                (C, Cr, OverLim)  => { slice(); slice_start = i; last_start = i; last_end = i; B }
-                (C, Ws, OverLim)  => { slice(); A }
-                (C, Ws, UnderLim) => { C }
-            };
-
-            cont
-        };
-
-        ss.iter().enumerate().advance(|x| machine(x));
-
-        // Let the automaton 'run out' by supplying trailing whitespace
-        while cont && match state { B | C => true, A => false } {
-            machine((fake_i, ' '));
-            fake_i += 1;
-        }
-        return cont;
-    }
-
-    #[test]
-    priv fn test_split_within() {
-        fn t(s: &str, i: uint, u: &[~str]) {
-            let mut v = ~[];
-            for each_split_within(s, i) |s| { v.push(s.to_owned()) }
-            assert!(v.iter().zip(u.iter()).all(|(a,b)| a == b));
-        }
-        t("", 0, []);
-        t("", 15, []);
-        t("hello", 15, [~"hello"]);
-        t("\nMary had a little lamb\nLittle lamb\n", 15,
-            [~"Mary had a", ~"little lamb", ~"Little lamb"]);
-        t("\nMary had a little lamb\nLittle lamb\n", ::std::uint::max_value,
-            [~"Mary had a little lamb\nLittle lamb"]);
-    }
 } // end groups module
 
 #[cfg(test)]

branches/auto/src/libextra/par.rs

@@ -58,7 +58,7 @@ fn map_slices<A:Clone + Send,B:Clone + Send>(
                 let f = do future_spawn() || {
                     unsafe {
                         let len = end - base;
-                        let slice = (ptr::offset(p, base as int),
+                        let slice = (ptr::offset(p, base),
                                      len * sys::size_of::<A>());
                         info!("pre-slice: %?", (base, slice));
                         let slice : &[A] =