---

yaml
---
r: 62786
b: refs/heads/snap-stage3
c: b4a3fe2
h: refs/heads/master
v: v3

Author: graydon

[refs]

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

branches/snap-stage3/mk/tests.mk

@@ -284,7 +284,7 @@ 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) = $$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_STDLIB_$(2))
 else
 STDTESTDEP_$(1)_$(2)_$(3) =
 endif

branches/snap-stage3/src/etc/vim/after/ftplugin/rust.vim

@@ -0,0 +1,5 @@
+"Highlight the 100th text column
+"Feature became available in v7.3
+if version >= 703
+    setlocal colorcolumn=100
+endif

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

@@ -17,7 +17,7 @@
  * In this example, a large vector of floats is shared between several tasks.
  * With simple pipes, without ARC, a copy would have to be made for each task.
  *
- * ~~~ {.rust}
+ * ~~~
  * extern mod std;
  * use std::arc;
  * let numbers=vec::from_fn(100, |ind| (ind as float)*rand::random());
@@ -370,10 +370,7 @@ pub impl<T:Const + Owned> RWARC<T> {
      * See sync::rwlock.write_downgrade(). The RWWriteMode token must be used
      * to obtain the &mut T, and can be transformed into a RWReadMode token by
      * calling downgrade(), after which a &T can be obtained instead.
-     *
-     * # Example
-     *
-     * ~~~ {.rust}
+     * ~~~
      * do arc.write_downgrade |write_mode| {
      *     do (&write_mode).write_cond |state, condvar| {
      *         ... exclusive access with mutable state ...
@@ -510,6 +507,7 @@ mod tests {
     use core::prelude::*;
     use core::cell::Cell;
     use arc::*;
+    use arc;
 
     #[test]
     fn manually_share_arc() {

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

@@ -28,17 +28,17 @@ impl<'self> ToBase64 for &'self [u8] {
     /**
      * Turn a vector of `u8` bytes into a base64 string.
      *
-     * # Example
+     * *Example*:
      *
-     * ~~~ {.rust}
+     * ~~~~
      * extern mod std;
      * use std::base64::ToBase64;
      *
      * fn main () {
      *     let str = [52,32].to_base64();
      *     println(fmt!("%s", str));
      * }
-     * ~~~
+     * ~~~~
      */
     fn to_base64(&self) -> ~str {
         let mut s = ~"";
@@ -91,17 +91,17 @@ impl<'self> ToBase64 for &'self str {
      * Convert any string (literal, `@`, `&`, or `~`) to base64 encoding.
      *
      *
-     * # Example
+     * *Example*:
      *
-     * ~~~ {.rust}
+     * ~~~~
      * extern mod std;
      * use std::base64::ToBase64;
      *
      * fn main () {
      *     let str = "Hello, World".to_base64();
      *     println(fmt!("%s",str));
      * }
-     * ~~~
+     * ~~~~
      *
      */
     fn to_base64(&self) -> ~str {
@@ -118,9 +118,9 @@ impl FromBase64 for ~[u8] {
      * Convert base64 `u8` vector into u8 byte values.
      * Every 4 encoded characters is converted into 3 octets, modulo padding.
      *
-     * # Example
+     * *Example*:
      *
-     * ~~~ {.rust}
+     * ~~~~
      * extern mod std;
      * use std::base64::ToBase64;
      * use std::base64::FromBase64;
@@ -131,7 +131,7 @@ impl FromBase64 for ~[u8] {
      *     let bytes = str.from_base64();
      *     println(fmt!("%?",bytes));
      * }
-     * ~~~
+     * ~~~~
      */
     fn from_base64(&self) -> ~[u8] {
         if self.len() % 4u != 0u { fail!("invalid base64 length"); }
@@ -196,11 +196,11 @@ impl FromBase64 for ~str {
      * You can use the `from_bytes` function in `core::str`
      * to turn a `[u8]` into a string with characters corresponding to those values.
      *
-     * # Example
+     * *Example*:
      *
      * This converts a string literal to base64 and back.
      *
-     * ~~~ {.rust}
+     * ~~~~
      * extern mod std;
      * use std::base64::ToBase64;
      * use std::base64::FromBase64;
@@ -214,7 +214,7 @@ impl FromBase64 for ~str {
      *     let result_str = str::from_bytes(bytes);
      *     println(fmt!("%s",result_str));
      * }
-     * ~~~
+     * ~~~~
      */
     fn from_base64(&self) -> ~[u8] {
         str::to_bytes(*self).from_base64()

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

@@ -1197,7 +1197,7 @@ mod tests {
     #[test]
     fn test_from_bytes() {
         let bitv = from_bytes([0b10110110, 0b00000000, 0b11111111]);
-        let str = ~"10110110" + "00000000" + "11111111";
+        let str = ~"10110110" + ~"00000000" + ~"11111111";
         assert_eq!(bitv.to_str(), str);
     }
 

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

@@ -125,31 +125,6 @@ pub impl<T> Deque<T> {
         self.hi = (self.hi + 1u) % self.elts.len();
         self.nelts += 1u;
     }
-
-    /// Reserve capacity for exactly `n` elements in the given deque,
-    /// doing nothing if `self`'s capacity is already equal to or greater
-    /// than the requested capacity
-    ///
-    /// # Arguments
-    ///
-    /// * n - The number of elements to reserve space for
-    fn reserve(&mut self, n: uint) {
-        vec::reserve(&mut self.elts, n);
-    }
-
-    /// Reserve capacity for at least `n` elements in the given deque,
-    /// over-allocating in case the caller needs to reserve additional
-    /// space.
-    ///
-    /// Do nothing if `self`'s capacity is already equal to or greater
-    /// than the requested capacity.
-    ///
-    /// # Arguments
-    ///
-    /// * n - The number of elements to reserve space for
-    fn reserve_at_least(&mut self, n: uint) {
-        vec::reserve_at_least(&mut self.elts, n);
-    }
 }
 
 /// Grow is only called on full elts, so nelts is also len(elts), unlike
@@ -174,7 +149,6 @@ mod tests {
     use super::*;
     use core::cmp::Eq;
     use core::kinds::Copy;
-    use core::vec::capacity;
 
     #[test]
     fn test_simple() {
@@ -354,29 +328,4 @@ mod tests {
         }
 
     }
-
-    #[test]
-    fn test_reserve() {
-        let mut d = Deque::new();
-        d.add_back(0u64);
-        d.reserve(50);
-        assert_eq!(capacity(&mut d.elts), 50);
-        let mut d = Deque::new();
-        d.add_back(0u32);
-        d.reserve(50);
-        assert_eq!(capacity(&mut d.elts), 50);
-    }
-
-    #[test]
-    fn test_reserve_at_least() {
-        let mut d = Deque::new();
-        d.add_back(0u64);
-        d.reserve_at_least(50);
-        assert_eq!(capacity(&mut d.elts), 64);
-        let mut d = Deque::new();
-        d.add_back(0u32);
-        d.reserve_at_least(50);
-        assert_eq!(capacity(&mut d.elts), 64);
-    }
-
 }

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

@@ -25,7 +25,7 @@ ports and channels.
 
 This example sends boxed integers across tasks using serialization.
 
-~~~ {.rust}
+~~~
 let (port, chan) = serial::pipe_stream();
 
 do task::spawn || {
@@ -927,7 +927,7 @@ mod test {
         fn test_try_recv_none3<P:BytePort>(loader: PortLoader<P>) {
             static CONTINUE: [u8, ..4] = [0xAA, 0xBB, 0xCC, 0xDD];
             // The control word is followed by garbage
-            let bytes = CONTINUE.to_vec() + [0];
+            let bytes = CONTINUE.to_vec() + ~[0];
             let port = loader(bytes);
             let res: Option<int> = port.try_recv();
             assert!(res.is_none());
@@ -951,7 +951,7 @@ mod test {
                     1, sys::size_of::<u64>()) |len_bytes| {
                     len_bytes.to_vec()
                 };
-                let bytes = CONTINUE.to_vec() + len_bytes + [0, 0, 0, 0];
+                let bytes = CONTINUE.to_vec() + len_bytes + ~[0, 0, 0, 0];
 
                 let port = loader(bytes);
 

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

@@ -14,7 +14,7 @@
  *
  * # Example
  *
- * ~~~ {.rust}
+ * ~~~
  * # fn fib(n: uint) -> uint {42};
  * # fn make_a_sandwich() {};
  * let mut delayed_fib = std::future::spawn (|| fib(5000) );

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

@@ -1880,13 +1880,13 @@ mod tests {
                   ]));
         assert_eq!(result::unwrap(from_str(
                       ~"{" +
-                          "\"a\": 1.0, " +
-                          "\"b\": [" +
-                              "true," +
-                              "\"foo\\nbar\", " +
-                              "{ \"c\": {\"d\": null} } " +
-                          "]" +
-                      "}")),
+                          ~"\"a\": 1.0, " +
+                          ~"\"b\": [" +
+                              ~"true," +
+                              ~"\"foo\\nbar\", " +
+                              ~"{ \"c\": {\"d\": null} } " +
+                          ~"]" +
+                      ~"}")),
                   mk_object([
                       (~"a", Number(1.0f)),
                       (~"b", List(~[

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

@@ -375,6 +375,7 @@ mod test {
     use uv;
 
     use core::result;
+    use core::vec;
 
     #[test]
     fn test_ip_ipv4_parse_and_format_ip() {

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

@@ -466,7 +466,7 @@ fn read_future(sock: &TcpSocket, timeout_msecs: uint)
  * Here, the `new_conn` is used in conjunction with `accept` from within
  * a task spawned by the `new_connect_cb` passed into `listen`
  *
- * ~~~ {.rust}
+ * ~~~~~~~~~~~
  * do net::tcp::listen(remote_ip, remote_port, backlog, iotask,
  *     // this callback is ran once after the connection is successfully
  *     // set up
@@ -497,7 +497,7 @@ fn read_future(sock: &TcpSocket, timeout_msecs: uint)
  *       None => ()
  *     }
  * };
- * ~~~
+ * ~~~~~~~~~~~
  *
  * # Arguments
  *

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

@@ -317,7 +317,7 @@ mod tests {
             Test {
                 input:
                      ~"abcdbcdecdefdefgefghfghighij" +
-                     "hijkijkljklmklmnlmnomnopnopq",
+                     ~"hijkijkljklmklmnlmnomnopnopq",
                 output: ~[
                     0x84u8, 0x98u8, 0x3Eu8, 0x44u8,
                     0x1Cu8, 0x3Bu8, 0xD2u8, 0x6Eu8,

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

@@ -746,6 +746,8 @@ fn shift_vec<T:Copy>(dest: &mut [T],
 
 #[cfg(test)]
 mod test_qsort3 {
+    use core::prelude::*;
+
     use sort::*;
 
     use core::vec;

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

@@ -545,10 +545,7 @@ pub impl RWlock {
      * the meantime (such as unlocking and then re-locking as a reader would
      * do). The block takes a "write mode token" argument, which can be
      * transformed into a "read mode token" by calling downgrade(). Example:
-     *
-     * # Example
-     *
-     * ~~~ {.rust}
+     * ~~~
      * do lock.write_downgrade |write_mode| {
      *     do (&write_mode).write_cond |condvar| {
      *         ... exclusive access ...
@@ -720,6 +717,7 @@ mod tests {
 
     use core::cast;
     use core::cell::Cell;
+    use core::ptr;
     use core::result;
     use core::task;
     use core::vec;

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

@@ -30,6 +30,7 @@ mod tests {
     use core::prelude::*;
 
     use tempfile::mkdtemp;
+    use tempfile;
     use core::os;
 
     #[test]

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

@@ -1,4 +1,4 @@
-// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// 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.
 //
@@ -22,11 +22,11 @@ pub mod rustrt {
         pub unsafe fn precise_time_ns(ns: &mut u64);
 
         pub unsafe fn rust_tzset();
-
+        // FIXME: The i64 values can be passed by-val when #2064 is fixed.
         pub unsafe fn rust_gmtime(sec: i64, nsec: i32, result: &mut Tm);
         pub unsafe fn rust_localtime(sec: i64, nsec: i32, result: &mut Tm);
-        pub unsafe fn rust_timegm(tm: &Tm) -> i64;
-        pub unsafe fn rust_mktime(tm: &Tm) -> i64;
+        pub unsafe fn rust_timegm(tm: &Tm, sec: &mut i64);
+        pub unsafe fn rust_mktime(tm: &Tm, sec: &mut i64);
     }
 }
 
@@ -177,11 +177,12 @@ pub impl Tm {
     /// Convert time to the seconds from January 1, 1970
     fn to_timespec(&self) -> Timespec {
         unsafe {
-            let sec = match self.tm_gmtoff {
-                0_i32 => rustrt::rust_timegm(self),
-                _     => rustrt::rust_mktime(self)
-            };
-
+            let mut sec = 0i64;
+            if self.tm_gmtoff == 0_i32 {
+                rustrt::rust_timegm(self, &mut sec);
+            } else {
+                rustrt::rust_mktime(self, &mut sec);
+            }
             Timespec::new(sec, self.tm_nsec)
         }
     }
@@ -1205,8 +1206,8 @@ mod tests {
         // abbreviation.
         let rfc822 = local.rfc822();
         let prefix = ~"Fri, 13 Feb 2009 15:31:30 ";
-        assert!(rfc822 == prefix + "PST" ||
-                     rfc822 == prefix + "Pacific Standard Time");
+        assert!(rfc822 == prefix + ~"PST" ||
+                     rfc822 == prefix + ~"Pacific Standard Time");
 
         assert_eq!(local.ctime(), ~"Fri Feb 13 15:31:30 2009");
         assert_eq!(local.rfc822z(), ~"Fri, 13 Feb 2009 15:31:30 -0800");