---

yaml
---
r: 148691
b: refs/heads/try2
c: e3b1f3c
h: refs/heads/master
i:
  148689: 7915c9f
  148687: 7627a63
v: v3

Author: bors

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 8cd935f52a9af8620f608e1baad94282f038a864
+refs/heads/try2: e3b1f3c443c048913e2d573fcc5a9c2be3484a78
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/.gitignore

@@ -74,11 +74,15 @@ src/.DS_Store
 /doc/html
 /doc/latex
 /doc/std
+/doc/arena
 /doc/extra
+/doc/flate
+/doc/glob
 /doc/green
 /doc/native
 /doc/rustc
 /doc/syntax
+/doc/rustdoc
 /doc/rustuv
 /doc/rustpkg
 /nd/

branches/try2/AUTHORS.txt

@@ -351,7 +351,7 @@ Vincent Belliard <[email protected]>
 Vivek Galatage <[email protected]>
 Volker Mische <[email protected]>
 Wade Mealing <[email protected]>
-William Ting <william.h.ting@gmail.com>
+William Ting <io@williamting.com>
 Yasuhiro Fujii <[email protected]>
 Young-il Choi <[email protected]>
 Youngmin Yoo <[email protected]>

branches/try2/Makefile.in

@@ -124,7 +124,7 @@ endif
 ifdef TRACE
   CFG_RUSTC_FLAGS += -Z trace
 endif
-ifdef DISABLE_RPATH
+ifdef CFG_DISABLE_RPATH
 # NOTE: make this CFG_RUSTC_FLAGS after stage0 snapshot
 RUSTFLAGS_STAGE1 += --no-rpath
 RUSTFLAGS_STAGE2 += --no-rpath

branches/try2/doc/complement-cheatsheet.md

@@ -48,7 +48,7 @@ let y: i64 = x.unwrap();
 
 Use [`File::open`](http://static.rust-lang.org/doc/master/std/io/fs/struct.File.html#method.open) to create a [`File`](http://static.rust-lang.org/doc/master/std/io/fs/struct.File.html) struct, which implements the [`Reader`](http://static.rust-lang.org/doc/master/std/io/trait.Reader.html) trait.
 
-~~~ {.xfail-test}
+~~~ {.ignore}
 use std::path::Path;
 use std::io::fs::File;
 
@@ -168,7 +168,7 @@ let _ = close(Door::<Open>(~"front"));
 
 Attempting to close a closed door is prevented statically:
 
-~~~ {.xfail-test}
+~~~ {.ignore}
 let _ = close(Door::<Closed>(~"front")); // error: mismatched types: expected `main::Door<main::Open>` but found `main::Door<main::Closed>`
 ~~~
 
@@ -196,7 +196,7 @@ Window* createWindow(int width, int height);
 
 You can use a zero-element `enum` ([phantom type](#how-do-i-express-phantom-types)) to represent the opaque object handle. The FFI would look like this:
 
-~~~ {.xfail-test}
+~~~ {.ignore}
 enum Window {}
 extern "C" {
     fn createWindow(width: c_int, height: c_int) -> *Window;

branches/try2/doc/guide-conditions.md

@@ -45,7 +45,6 @@ An example program that does this task reads like this:
 
 ~~~~
 # #[allow(unused_imports)];
-# extern mod extra;
 use std::io::{BufferedReader, File};
 # mod BufferedReader {
 #     use std::io::File;
@@ -243,7 +242,6 @@ and trapping its exit status using `task::try`:
 
 ~~~~
 # #[allow(unused_imports)];
-# extern mod extra;
 use std::io::{BufferedReader, File};
 use std::task;
 # mod BufferedReader {
@@ -263,15 +261,15 @@ use std::task;
 fn main() {
 
     // Isolate failure within a subtask.
-    let result = do task::try {
+    let result = task::try(proc() {
 
         // The protected logic.
         let pairs = read_int_pairs();
         for &(a,b) in pairs.iter() {
             println!("{:4.4d}, {:4.4d}", a, b);
         }
 
-    };
+    });
     if result.is_err() {
             println!("parsing failed");
     }
@@ -347,7 +345,6 @@ but similarly clear as the version that used `fail!` in the logic where the erro
 
 ~~~~
 # #[allow(unused_imports)];
-# extern mod extra;
 use std::io::{BufferedReader, File};
 # mod BufferedReader {
 #     use std::io::File;
@@ -416,7 +413,6 @@ and replaces bad input lines with the pair `(-1,-1)`:
 
 ~~~~
 # #[allow(unused_imports)];
-# extern mod extra;
 use std::io::{BufferedReader, File};
 # mod BufferedReader {
 #     use std::io::File;
@@ -491,7 +487,6 @@ Changing the condition's return type from `(int,int)` to `Option<(int,int)>` wil
 
 ~~~~
 # #[allow(unused_imports)];
-# extern mod extra;
 use std::io::{BufferedReader, File};
 # mod BufferedReader {
 #     use std::io::File;
@@ -576,8 +571,7 @@ This can be encoded in the handler API by introducing a helper type: `enum Malfo
 
 ~~~~
 # #[allow(unused_imports)];
-# extern mod extra;
-use std::io::File;
+use std::io::{BufferedReader, File};
 # mod BufferedReader {
 #     use std::io::File;
 #     use std::io::MemReader;
@@ -700,7 +694,6 @@ a second condition and a helper function will suffice:
 
 ~~~~
 # #[allow(unused_imports)];
-# extern mod extra;
 use std::io::{BufferedReader, File};
 # mod BufferedReader {
 #     use std::io::File;

branches/try2/doc/guide-container.md

@@ -270,7 +270,7 @@ Containers can provide conversion from iterators through `collect` by
 implementing the `FromIterator` trait. For example, the implementation for
 vectors is as follows:
 
-~~~ {.xfail-test}
+~~~ {.ignore}
 impl<A> FromIterator<A> for ~[A] {
     pub fn from_iterator<T: Iterator<A>>(iterator: &mut T) -> ~[A] {
         let (lower, _) = iterator.size_hint();
@@ -288,7 +288,7 @@ impl<A> FromIterator<A> for ~[A] {
 The `Iterator` trait provides a `size_hint` default method, returning a lower
 bound and optionally on upper bound on the length of the iterator:
 
-~~~ {.xfail-test}
+~~~ {.ignore}
 fn size_hint(&self) -> (uint, Option<uint>) { (0, None) }
 ~~~
 

branches/try2/doc/guide-ffi.md

@@ -11,7 +11,7 @@ snappy includes a C interface (documented in
 The following is a minimal example of calling a foreign function which will
 compile if snappy is installed:
 
-~~~~ {.xfail-test}
+~~~~ {.ignore}
 use std::libc::size_t;
 
 #[link(name = "snappy")]
@@ -43,7 +43,7 @@ keeping the binding correct at runtime.
 
 The `extern` block can be extended to cover the entire snappy API:
 
-~~~~ {.xfail-test}
+~~~~ {.ignore}
 use std::libc::{c_int, size_t};
 
 #[link(name = "snappy")]
@@ -76,7 +76,7 @@ vectors as pointers to memory. Rust's vectors are guaranteed to be a contiguous
 length is number of elements currently contained, and the capacity is the total size in elements of
 the allocated memory. The length is less than or equal to the capacity.
 
-~~~~ {.xfail-test}
+~~~~ {.ignore}
 pub fn validate_compressed_buffer(src: &[u8]) -> bool {
     unsafe {
         snappy_validate_compressed_buffer(src.as_ptr(), src.len() as size_t) == 0
@@ -96,7 +96,7 @@ required capacity to hold the compressed output. The vector can then be passed t
 `snappy_compress` function as an output parameter. An output parameter is also passed to retrieve
 the true length after compression for setting the length.
 
-~~~~ {.xfail-test}
+~~~~ {.ignore}
 pub fn compress(src: &[u8]) -> ~[u8] {
     unsafe {
         let srclen = src.len() as size_t;
@@ -116,7 +116,7 @@ pub fn compress(src: &[u8]) -> ~[u8] {
 Decompression is similar, because snappy stores the uncompressed size as part of the compression
 format and `snappy_uncompressed_length` will retrieve the exact buffer size required.
 
-~~~~ {.xfail-test}
+~~~~ {.ignore}
 pub fn uncompress(src: &[u8]) -> Option<~[u8]> {
     unsafe {
         let srclen = src.len() as size_t;
@@ -263,7 +263,7 @@ to the C library and afterwards be invoked from there.
 A basic example is:
 
 Rust code:
-~~~~ {.xfail-test}
+~~~~ {.ignore}
 extern fn callback(a:i32) {
     println!("I'm called from C with value {0}", a);
 }
@@ -283,7 +283,7 @@ fn main() {
 ~~~~
 
 C code:
-~~~~ {.xfail-test}
+~~~~ {.ignore}
 typedef void (*rust_callback)(int32_t);
 rust_callback cb;
 
@@ -314,7 +314,7 @@ the notification. This will allow the callback to unsafely access the
 referenced Rust object.
 
 Rust code:
-~~~~ {.xfail-test}
+~~~~ {.ignore}
 
 struct RustObject {
     a: i32,
@@ -346,7 +346,7 @@ fn main() {
 ~~~~
 
 C code:
-~~~~ {.xfail-test}
+~~~~ {.ignore}
 typedef void (*rust_callback)(int32_t);
 void* cb_target;
 rust_callback cb;
@@ -440,7 +440,7 @@ the `link_args` attribute. This attribute is applied to `extern` blocks and
 specifies raw flags which need to get passed to the linker when producing an
 artifact. An example usage would be:
 
-~~~ {.xfail-test}
+~~~ {.ignore}
 #[link_args = "-foo -bar -baz"]
 extern {}
 ~~~
@@ -476,7 +476,7 @@ Foreign APIs often export a global variable which could do something like track
 global state. In order to access these variables, you declare them in `extern`
 blocks with the `static` keyword:
 
-~~~{.xfail-test}
+~~~{.ignore}
 use std::libc;
 
 #[link(name = "readline")]
@@ -494,7 +494,7 @@ Alternatively, you may need to alter global state provided by a foreign
 interface. To do this, statics can be declared with `mut` so rust can mutate
 them.
 
-~~~{.xfail-test}
+~~~{.ignore}
 use std::libc;
 use std::ptr;
 

branches/try2/doc/guide-lifetimes.md

@@ -299,7 +299,7 @@ _as soon as its owning reference changes or goes out of
 scope_. Therefore, a program like this is illegal (and would be
 rejected by the compiler):
 
-~~~ {.xfail-test}
+~~~ {.ignore}
 fn example3() -> int {
     let mut x = ~X {f: 3};
     let y = &x.f;
@@ -346,7 +346,7 @@ modify the previous example to introduce additional owned pointers
 and structs, and the compiler will still be able to detect possible
 mutations:
 
-~~~ {.xfail-test}
+~~~ {.ignore}
 fn example3() -> int {
     struct R { g: int }
     struct S { f: ~R }
@@ -524,7 +524,7 @@ the compiler accepts the function `get_x()`.
 To emphasize this point, let’s look at a variation on the example, this
 time one that does not compile:
 
-~~~ {.xfail-test}
+~~~ {.ignore}
 struct Point {x: f64, y: f64}
 fn get_x_sh(p: @Point) -> &f64 {
     &p.x // Error reported here

branches/try2/doc/guide-pointers.md

@@ -21,7 +21,7 @@ fn succ(x: &int) -> int { *x + 1 }
 
 So I wrote this code to try it out:
 
-~~~rust{.xfail-test}
+~~~rust{.ignore}
 fn main() {
     let number = 5;
     let succ_number = succ(number);
@@ -221,9 +221,9 @@ struct Point {
 
 fn main() {
     let a = Point { x: 10, y: 20 };
-    do spawn {
+    spawn(proc() {
         println!("{}", a.x);
-    }
+    });
 }
 ~~~
 
@@ -238,9 +238,9 @@ struct Point {
 
 fn main() {
     let a = ~Point { x: 10, y: 20 };
-    do spawn {
+    spawn(proc() {
         println!("{}", a.x);
-    }
+    });
 }
 ~~~
 
@@ -261,7 +261,7 @@ program is very large and complicated.
 
 For example, let's say you're using an owned pointer, and you want to do this:
 
-~~~rust{.xfail-test}
+~~~rust{.ignore}
 struct Point {
     x: int,
     y: int,
@@ -369,7 +369,7 @@ This theory is called 'region pointers,' and involve a concept called
 'lifetimes'. Here's the simple explanation: would you expect this code to
 compile?
 
-~~~rust{.xfail-test}
+~~~rust{.ignore}
 fn main() {
     println!("{}", x);
     let x = 5;
@@ -398,7 +398,7 @@ Here, we're borrowing a pointer to `x` inside of the `if`. The compiler, however
 is able to determine that that pointer will go out of scope without `x` being
 mutated, and therefore, lets us pass. This wouldn't work:
 
-~~~rust{.xfail-test}
+~~~rust{.ignore}
 fn main() {
     let mut x = ~5;
     if *x < 10 {

branches/try2/doc/guide-runtime.md

@@ -176,7 +176,7 @@ implemented in user-space.
 The primary concern of an M:N runtime is that a Rust task cannot block itself in
 a syscall. If this happens, then the entire OS thread is frozen and unavailable
 for running more Rust tasks, making this a (M-1):N runtime (and you can see how
-this can reach 0/deadlock. By using asynchronous I/O under the hood (all I/O
+this can reach 0/deadlock). By using asynchronous I/O under the hood (all I/O
 still looks synchronous in terms of code), OS threads are never blocked until
 the appropriate time comes.
 
@@ -236,9 +236,9 @@ extern mod green;
 
 #[start]
 fn start(argc: int, argv: **u8) -> int {
-    do green::start(argc, argv) {
+    green::start(argc, argv, proc() {
         main();
-    }
+    })
 }
 
 fn main() {}