---

yaml
---
r: 64883
b: refs/heads/snap-stage3
c: a8840d7
h: refs/heads/master
i:
  64881: ab17861
  64879: b0ab78a
v: v3

Author: graydon

[refs]

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

branches/snap-stage3/doc/rustpkg.md

@@ -76,6 +76,14 @@ A package ID can also specify a version, like:
 `github.com/mozilla/rust#0.3`.
 In this case, `rustpkg` will check that the repository `github.com/mozilla/rust` has a tag named `0.3`,
 and report an error otherwise.
+A package ID can also specify a particular revision of a repository, like:
+`github.com/mozilla/rust#release-0.7`.
+When the refspec (portion of the package ID after the `#`) can't be parsed as a decimal number,
+rustpkg passes the refspec along to the version control system without interpreting it.
+rustpkg also interprets any dependencies on such a package ID literally
+(as opposed to versions, where a newer version satisfies a dependency on an older version).
+Thus, `github.com/mozilla/rust#5c4cd30f80` is also a valid package ID,
+since git can deduce that 5c4cd30f80 refers to a revision of the desired repository.
 
 ## Source files
 

branches/snap-stage3/doc/tutorial.md

@@ -309,7 +309,7 @@ was taken.
 
 In short, everything that's not a declaration (declarations are `let` for
 variables; `fn` for functions; and any top-level named items such as
-[traits](#traits), [enum types](#enums), and [constants](#constants)) is an
+[traits](#traits), [enum types](#enums), and static items) is an
 expression, including function bodies.
 
 ~~~~
@@ -992,7 +992,7 @@ task-local garbage collector. It will be destroyed at some point after there
 are no references left to the box, no later than the end of the task. Managed
 boxes lack an owner, so they start a new ownership tree and don't inherit
 mutability. They do own the contained object, and mutability is defined by the
-type of the shared box (`@` or `@mut`). An object containing a managed box is
+type of the managed box (`@` or `@mut`). An object containing a managed box is
 not `Owned`, and can't be sent between tasks.
 
 ~~~~
@@ -1089,10 +1089,8 @@ we might like to compute the distance between `on_the_stack` and
 to define a function that takes two arguments of type point—that is,
 it takes the points by value. But this will cause the points to be
 copied when we call the function. For points, this is probably not so
-bad, but often copies are expensive or, worse, if there are mutable
-fields, they can change the semantics of your program. So we’d like to
-define a function that takes the points by pointer. We can use
-borrowed pointers to do this:
+bad, but often copies are expensive. So we’d like to define a function
+that takes the points by pointer. We can use borrowed pointers to do this:
 
 ~~~
 # struct Point { x: float, y: float }
@@ -1375,7 +1373,7 @@ let exchange_crayons: ~str = ~"Black, BlizzardBlue, Blue";
 ~~~
 
 Both vectors and strings support a number of useful
-[methods](#functions-and-methods), defined in [`std::vec`]
+[methods](#methods), defined in [`std::vec`]
 and [`std::str`]. Here are some examples.
 
 [`std::vec`]: std/vec.html
@@ -1930,7 +1928,7 @@ that implements a trait includes the name of the trait at the start of
 the definition, as in the following impls of `Printable` for `int`
 and `~str`.
 
-[impls]: #functions-and-methods
+[impls]: #methods
 
 ~~~~
 # trait Printable { fn print(&self); }

branches/snap-stage3/mk/tests.mk

@@ -312,28 +312,26 @@ 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) = $$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_EXTRALIB_$(2))
+STDTESTDEP_$(1)_$(2)_$(3) = $$(SREQ$(1)_T_$(2)_H_$(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/snap-stage3/src/compiletest/compiletest.rs

@@ -85,6 +85,7 @@ pub fn parse_config(args: ~[~str]) -> config {
     if args[1] == ~"-h" || args[1] == ~"--help" {
         let message = fmt!("Usage: %s [OPTIONS] [TESTNAME...]", argv0);
         println(getopts::groups::usage(message, groups));
+        println("");
         fail!()
     }
 
@@ -97,6 +98,7 @@ pub fn parse_config(args: ~[~str]) -> config {
     if getopts::opt_present(matches, "h") || getopts::opt_present(matches, "help") {
         let message = fmt!("Usage: %s [OPTIONS]  [TESTNAME...]", argv0);
         println(getopts::groups::usage(message, groups));
+        println("");
         fail!()
     }
 

branches/snap-stage3/src/compiletest/runtest.rs

@@ -22,6 +22,7 @@ use util::logv;
 
 use std::io;
 use std::os;
+use std::str;
 use std::uint;
 use std::vec;
 
@@ -355,6 +356,30 @@ fn check_expected_errors(expected_errors: ~[errors::ExpectedError],
         fmt!("%s:%u:", testfile.to_str(), ee.line)
     }).collect::<~[~str]>();
 
+    fn to_lower( s : &str ) -> ~str {
+        let i = s.iter();
+        let c : ~[char] = i.transform( |c| {
+            if c.is_ascii() {
+                c.to_ascii().to_lower().to_char()
+            } else {
+                c
+            }
+        } ).collect();
+        str::from_chars( c )
+    }
+
+    #[cfg(target_os = "win32")]
+    fn prefix_matches( line : &str, prefix : &str ) -> bool {
+        to_lower(line).starts_with( to_lower(prefix) )
+    }
+
+    #[cfg(target_os = "linux")]
+    #[cfg(target_os = "macos")]
+    #[cfg(target_os = "freebsd")]
+    fn prefix_matches( line : &str, prefix : &str ) -> bool {
+        line.starts_with( prefix )
+    }
+
     // Scan and extract our error/warning messages,
     // which look like:
     //    filename:line1:col1: line2:col2: *error:* msg
@@ -367,7 +392,7 @@ fn check_expected_errors(expected_errors: ~[errors::ExpectedError],
             if !found_flags[i] {
                 debug!("prefix=%s ee.kind=%s ee.msg=%s line=%s",
                        prefixes[i], ee.kind, ee.msg, line);
-                if (line.starts_with(prefixes[i]) &&
+                if (prefix_matches(line, prefixes[i]) &&
                     line.contains(ee.kind) &&
                     line.contains(ee.msg)) {
                     found_flags[i] = true;

branches/snap-stage3/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));
+        let tydesc_data: *uint = transmute(ptr::offset(buf, idx as int));
         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 *i8);
+            ((*tydesc).drop_glue)(ptr::offset(buf, start as int) 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)
+            ptr::offset(vec::raw::to_ptr(this.pod_head.data), start as int)
         }
     }
 
@@ -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), ptr::offset(buf, start));
+            return (ptr::offset(buf, tydesc_start as int), ptr::offset(buf, start as int));
         }
     }
 

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

@@ -12,11 +12,13 @@
 
 
 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.
@@ -404,7 +406,12 @@ impl Bitv {
 
     #[inline]
     pub fn iter<'a>(&'a self) -> BitvIterator<'a> {
-        BitvIterator {bitv: self, next_idx: 0}
+        BitvIterator {bitv: self, next_idx: 0, end_idx: self.nbits}
+    }
+
+    #[inline]
+    pub fn rev_liter<'a>(&'a self) -> Invert<BitvIterator<'a>> {
+        self.iter().invert()
     }
 
     /// Returns true if all bits are 0
@@ -564,13 +571,14 @@ 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 next_idx: uint,
+    priv end_idx: uint,
 }
 
 impl<'self> Iterator<bool> for BitvIterator<'self> {
     #[inline]
     fn next(&mut self) -> Option<bool> {
-        if self.next_idx < self.bitv.nbits {
+        if self.next_idx != self.end_idx {
             let idx = self.next_idx;
             self.next_idx += 1;
             Some(self.bitv.get(idx))
@@ -580,11 +588,39 @@ impl<'self> Iterator<bool> for BitvIterator<'self> {
     }
 
     fn size_hint(&self) -> (uint, Option<uint>) {
-        let rem = self.bitv.nbits - self.next_idx;
+        let rem = self.end_idx - 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/snap-stage3/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)).clone()
+        (*ptr::mut_offset(t.base, ofs as int)).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) = v };
+    unsafe { *ptr::mut_offset(t.base, ofs as int) = v };
 }
 
 /*

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

@@ -25,7 +25,7 @@
 use std::cast;
 use std::ptr;
 use std::util;
-use std::iterator::{FromIterator, InvertIterator};
+use std::iterator::{FromIterator, Extendable, Invert};
 
 use container::Deque;
 
@@ -356,7 +356,7 @@ impl<T> DList<T> {
 
     /// Provide a reverse iterator
     #[inline]
-    pub fn rev_iter<'a>(&'a self) -> InvertIterator<DListIterator<'a, T>> {
+    pub fn rev_iter<'a>(&'a self) -> Invert<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) -> InvertIterator<MutDListIterator<'a, T>> {
+    pub fn mut_rev_iter<'a>(&'a mut self) -> Invert<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) -> InvertIterator<ConsumeIterator<T>> {
+    pub fn consume_rev_iter(self) -> Invert<ConsumeIterator<T>> {
         self.consume_iter().invert()
     }
 }
@@ -541,11 +541,17 @@ 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();
-        for iterator.advance |elt| { ret.push_back(elt); }
+        ret.extend(iterator);
         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/snap-stage3/src/libextra/ebml.rs

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