---

yaml
---
r: 107402
b: refs/heads/dist-snap
c: 6141662
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: f64fdf524a434f0e5cd0bc91d09c144723f3c90d
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 0e94ae4d8a4d6aa103bca4e48885538f478c56b5
+refs/heads/dist-snap: 61416626acb53143f1b6856cbc0fcbfd9f9b59a8
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/Makefile.in

@@ -371,6 +371,9 @@ DRIVER_CRATE := $(S)src/driver/driver.rs
 LLVM_COMPONENTS=x86 arm mips ipo bitreader bitwriter linker asmparser jit mcjit \
                 interpreter instrumentation
 
+# Only build these LLVM tools
+LLVM_TOOLS=bugpoint llc llvm-ar llvm-as llvm-dis llvm-mc opt
+
 define DEF_LLVM_VARS
 # The configure script defines these variables with the target triples
 # separated by Z. This defines new ones with the expected format.

branches/dist-snap/doc/index.md

@@ -4,52 +4,54 @@
 <style type="text/css">
 #TOC { display: none; }
 .header-section-number { display: none; }
+li {list-style-type: none; }
 </style>
 
-[The Rust tutorial](tutorial.html)  ([PDF](tutorial.pdf))  
-[The Rust reference manual](rust.html) ([PDF](rust.pdf))  
+* [The Rust tutorial](tutorial.html)  (* [PDF](tutorial.pdf))
+* [The Rust reference manual](rust.html) (* [PDF](rust.pdf))
 
 # Guides
 
-[Pointers](guide-pointers.html)  
-[References and Lifetimes](guide-lifetimes.html)  
-[Containers and Iterators](guide-container.html)  
-[Tasks and Communication](guide-tasks.html)  
-[Foreign Function Interface](guide-ffi.html)  
-[Macros](guide-macros.html)  
-[Packaging](guide-rustpkg.html)  
-[Testing](guide-testing.html)  
-[Conditions](guide-conditions.html)  
-[Rust's Runtime](guide-runtime.html)
+* [Pointers](guide-pointers.html)
+* [References and Lifetimes](guide-lifetimes.html)
+* [Containers and Iterators](guide-container.html)
+* [Tasks and Communication](guide-tasks.html)
+* [Foreign Function Interface](guide-ffi.html)
+* [Macros](guide-macros.html)
+* [Packaging](guide-rustpkg.html)
+* [Testing](guide-testing.html)
+* [Conditions](guide-conditions.html)
+* [Rust's Runtime](guide-runtime.html)
 
 # Libraries
 
-[The standard library, `libstd`](std/index.html)  
-[The extra library, `libextra`](extra/index.html)
+* [The standard library, `libstd`](std/index.html)
+* [The extra library, `libextra`](extra/index.html)
 
-[The M:N runtime library, `libgreen`](green/index.html)  
-[The 1:1 runtime library, `libnative`](native/index.html)
+* [The M:N runtime library, `libgreen`](green/index.html)
+* [The 1:1 runtime library, `libnative`](native/index.html)
 
-[The Rust libuv library, `librustuv`](rustuv/index.html)  
-[The Rust packaging library, `librustpkg`](rustpkg/index.html)
+* [The Rust libuv library, `librustuv`](rustuv/index.html)
+* [The Rust packaging library, `librustpkg`](rustpkg/index.html)
 
-[The Rust parser, `libsyntax`](syntax/index.html)  
-[The Rust compiler, `librustc`](rustc/index.html)
+* [The Rust parser, `libsyntax`](syntax/index.html)
+* [The Rust compiler, `librustc`](rustc/index.html)
 
 # Tooling
 
-[The `rustpkg` manual](rustpkg.html)
+* [The `rustdoc` manual](rustdoc.html)
+* [The `rustpkg` manual](rustpkg.html)
 
 # FAQs
 
-[Language FAQ](complement-lang-faq.html)  
-[Project FAQ](complement-project-faq.html)  
-[Usage FAQ](complement-usage-faq.html)  
-[Code cheatsheet](complement-cheatsheet.html) - "How do I do X?"  
-[How to submit a bug report](complement-bugreport.html)
+* [Language FAQ](complement-lang-faq.html)
+* [Project FAQ](complement-project-faq.html)
+* [Usage FAQ](complement-usage-faq.html)
+* [Code cheatsheet](complement-cheatsheet.html) - "How do I do X?"  
+* [How to submit a bug report](complement-bugreport.html)
 
 # External resources
 
-The Rust [IRC channel](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust) - `#rust` on irc.mozilla.org  
-The Rust community on [Reddit](http://reddit.com/r/rust)  
-The Rust [wiki](http://github.com/mozilla/rust/wiki)
+* The Rust [IRC channel](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust) - `#rust` on irc.mozilla.org  
+* The Rust community on [Reddit](http://reddit.com/r/rust)
+* The Rust [wiki](http://github.com/mozilla/rust/wiki)

branches/dist-snap/mk/llvm.mk

@@ -28,7 +28,7 @@ LLVM_STAMP_$(1) = $$(CFG_LLVM_BUILD_DIR_$(1))/llvm-auto-clean-stamp
 
 $$(LLVM_CONFIG_$(1)): $$(LLVM_DEPS) $$(LLVM_STAMP_$(1))
 	@$$(call E, make: llvm)
-	$$(Q)$$(MAKE) -C $$(CFG_LLVM_BUILD_DIR_$(1)) $$(CFG_LLVM_BUILD_ENV_$(1))
+	$$(Q)$$(MAKE) -C $$(CFG_LLVM_BUILD_DIR_$(1)) $$(CFG_LLVM_BUILD_ENV_$(1)) ONLY_TOOLS="$$(LLVM_TOOLS)"
 	$$(Q)touch $$(LLVM_CONFIG_$(1))
 endif
 

branches/dist-snap/src/libextra/base64.rs

@@ -154,7 +154,25 @@ impl<'a> ToBase64 for &'a [u8] {
 pub trait FromBase64 {
     /// Converts the value of `self`, interpreted as base64 encoded data, into
     /// an owned vector of bytes, returning the vector.
-    fn from_base64(&self) -> Result<~[u8], ~str>;
+    fn from_base64(&self) -> Result<~[u8], FromBase64Error>;
+}
+
+/// Errors that can occur when decoding a base64 encoded string
+pub enum FromBase64Error {
+    /// The input contained a character not part of the base64 format
+    InvalidBase64Character(char, uint),
+    /// The input had an invalid length
+    InvalidBase64Length,
+}
+
+impl ToStr for FromBase64Error {
+    fn to_str(&self) -> ~str {
+        match *self {
+            InvalidBase64Character(ch, idx) =>
+                format!("Invalid character '{}' at position {}", ch, idx),
+            InvalidBase64Length => ~"Invalid length",
+        }
+    }
 }
 
 impl<'a> FromBase64 for &'a str {
@@ -188,7 +206,7 @@ impl<'a> FromBase64 for &'a str {
      * }
      * ```
      */
-    fn from_base64(&self) -> Result<~[u8], ~str> {
+    fn from_base64(&self) -> Result<~[u8], FromBase64Error> {
         let mut r = ~[];
         let mut buf: u32 = 0;
         let mut modulus = 0;
@@ -205,8 +223,7 @@ impl<'a> FromBase64 for &'a str {
                 '/'|'_' => buf |= 0x3F,
                 '\r'|'\n' => continue,
                 '=' => break,
-                _ => return Err(format!("Invalid character '{}' at position {}",
-                                     self.char_at(idx), idx))
+                _ => return Err(InvalidBase64Character(self.char_at(idx), idx)),
             }
 
             buf <<= 6;
@@ -221,8 +238,7 @@ impl<'a> FromBase64 for &'a str {
 
         for (idx, byte) in it {
             if (byte as char) != '=' {
-                return Err(format!("Invalid character '{}' at position {}",
-                                self.char_at(idx), idx));
+                return Err(InvalidBase64Character(self.char_at(idx), idx));
             }
         }
 
@@ -235,7 +251,7 @@ impl<'a> FromBase64 for &'a str {
                 r.push((buf >> 8 ) as u8);
             }
             0 => (),
-            _ => return Err(~"Invalid Base64 length")
+            _ => return Err(InvalidBase64Length),
         }
 
         Ok(r)

branches/dist-snap/src/libextra/comm.rs

@@ -127,9 +127,9 @@ mod test {
         // Rendezvous streams should be able to handle any number of messages being sent
         let (port, chan) = rendezvous();
         do spawn {
-            1000000.times(|| { chan.send(()) })
+            10000.times(|| { chan.send(()) })
         }
-        1000000.times(|| { port.recv() })
+        10000.times(|| { port.recv() })
     }
 
     #[test]

branches/dist-snap/src/libextra/hex.rs

@@ -53,7 +53,25 @@ impl<'a> ToHex for &'a [u8] {
 pub trait FromHex {
     /// Converts the value of `self`, interpreted as hexadecimal encoded data,
     /// into an owned vector of bytes, returning the vector.
-    fn from_hex(&self) -> Result<~[u8], ~str>;
+    fn from_hex(&self) -> Result<~[u8], FromHexError>;
+}
+
+/// Errors that can occur when decoding a hex encoded string
+pub enum FromHexError {
+    /// The input contained a character not part of the hex format
+    InvalidHexCharacter(char, uint),
+    /// The input had a invalid length
+    InvalidHexLength,
+}
+
+impl ToStr for FromHexError {
+    fn to_str(&self) -> ~str {
+        match *self {
+            InvalidHexCharacter(ch, idx) =>
+                format!("Invalid character '{}' at position {}", ch, idx),
+            InvalidHexLength => ~"Invalid input length",
+        }
+    }
 }
 
 impl<'a> FromHex for &'a str {
@@ -83,7 +101,7 @@ impl<'a> FromHex for &'a str {
      * }
      * ```
      */
-    fn from_hex(&self) -> Result<~[u8], ~str> {
+    fn from_hex(&self) -> Result<~[u8], FromHexError> {
         // This may be an overestimate if there is any whitespace
         let mut b = vec::with_capacity(self.len() / 2);
         let mut modulus = 0;
@@ -100,8 +118,7 @@ impl<'a> FromHex for &'a str {
                     buf >>= 4;
                     continue
                 }
-                _ => return Err(format!("Invalid character '{}' at position {}",
-                                        self.char_at(idx), idx))
+                _ => return Err(InvalidHexCharacter(self.char_at(idx), idx)),
             }
 
             modulus += 1;
@@ -113,7 +130,7 @@ impl<'a> FromHex for &'a str {
 
         match modulus {
             0 => Ok(b),
-            _ => Err(~"Invalid input length")
+            _ => Err(InvalidHexLength),
         }
     }
 }

branches/dist-snap/src/libnative/bookeeping.rs renamed to branches/dist-snap/src/libnative/bookkeeping.rs

@@ -1,4 +1,4 @@
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -8,13 +8,13 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! 1:1 Task bookeeping
+//! 1:1 Task bookkeeping
 //!
 //! This module keeps track of the number of running 1:1 tasks so that entry
 //! points with libnative know when it's possible to exit the program (once all
 //! tasks have exited).
 //!
-//! The green counterpart for this is bookeeping on sched pools.
+//! The green counterpart for this is bookkeeping on sched pools.
 
 use std::sync::atomics;
 use std::unstable::mutex::{Mutex, MUTEX_INIT};

branches/dist-snap/src/libnative/lib.rs

@@ -1,4 +1,4 @@
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -29,7 +29,7 @@
 use std::os;
 use std::rt;
 
-mod bookeeping;
+mod bookkeeping;
 pub mod io;
 pub mod task;
 
@@ -75,6 +75,6 @@ pub fn start(argc: int, argv: **u8, main: proc()) -> int {
 /// number of arguments.
 pub fn run(main: proc()) -> int {
     main();
-    bookeeping::wait_for_other_tasks();
+    bookkeeping::wait_for_other_tasks();
     os::get_exit_status()
 }

branches/dist-snap/src/libnative/task.rs

@@ -1,4 +1,4 @@
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -27,7 +27,7 @@ use std::unstable::stack;
 
 use io;
 use task;
-use bookeeping;
+use bookkeeping;
 
 /// Creates a new Task which is ready to execute as a 1:1 task.
 pub fn new(stack_bounds: (uint, uint)) -> ~Task {
@@ -82,7 +82,7 @@ pub fn spawn_opts(opts: TaskOpts, f: proc()) {
     // Note that this increment must happen *before* the spawn in order to
     // guarantee that if this task exits it will always end up waiting for the
     // spawned task to exit.
-    bookeeping::increment();
+    bookkeeping::increment();
 
     // Spawning a new OS thread guarantees that __morestack will never get
     // triggered, but we must manually set up the actual stack bounds once this
@@ -104,7 +104,7 @@ pub fn spawn_opts(opts: TaskOpts, f: proc()) {
         let mut task = task;
         task.put_runtime(ops as ~rt::Runtime);
         task.run(|| { f.take_unwrap()() });
-        bookeeping::decrement();
+        bookkeeping::decrement();
     })
 }
 

branches/dist-snap/src/libstd/path/windows.rs

@@ -261,8 +261,13 @@ impl GenericPathUnsafe for Path {
             let mut s = str::with_capacity(me.repr.len() + 1 + pathlen);
             s.push_str(me.repr);
             let plen = me.prefix_len();
-            if !(me.repr.len() > plen && me.repr[me.repr.len()-1] == sep as u8) {
-                s.push_char(sep);
+            // if me is "C:" we don't want to add a path separator
+            match me.prefix {
+                Some(DiskPrefix) if me.repr.len() == plen => (),
+                _ if !(me.repr.len() > plen && me.repr[me.repr.len()-1] == sep as u8) => {
+                    s.push_char(sep);
+                }
+                _ => ()
             }
             match path_ {
                 None => s.push_str(path),
@@ -1549,6 +1554,8 @@ mod tests {
         t!(s: "C:a\\b\\c", "C:d", "C:a\\b\\c\\d");
         t!(s: "C:a\\b", "..\\..\\..\\c", "C:..\\c");
         t!(s: "C:\\a\\b", "..\\..\\..\\c", "C:\\c");
+        t!(s: "C:", r"a\b\c", r"C:a\b\c");
+        t!(s: "C:", r"..\a", r"C:..\a");
         t!(s: "\\\\server\\share\\foo", "bar", "\\\\server\\share\\foo\\bar");
         t!(s: "\\\\server\\share\\foo", "..\\..\\bar", "\\\\server\\share\\bar");
         t!(s: "\\\\server\\share\\foo", "C:baz", "C:baz");