---

yaml
---
r: 150755
b: refs/heads/try2
c: 96aeb7e
h: refs/heads/master
i:
  150753: 0f978ed
  150751: 7ecff52
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: 9d570ad8c16970e1b2f629d224716f2d7a8b7820
+refs/heads/try2: 96aeb7e3c35ee0d0cf5b9ab8db5ef69e4cfb264e
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/doc/guide-ffi.md

@@ -11,14 +11,16 @@ 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:
 
-~~~~ {.ignore}
+~~~~
 extern crate libc;
 use libc::size_t;
 
 #[link(name = "snappy")]
+# #[cfg(ignore_this)]
 extern {
     fn snappy_max_compressed_length(source_length: size_t) -> size_t;
 }
+# unsafe fn snappy_max_compressed_length(a: size_t) -> size_t { a }
 
 fn main() {
     let x = unsafe { snappy_max_compressed_length(100) };
@@ -78,7 +80,11 @@ 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.
 
-~~~~ {.ignore}
+~~~~
+# extern crate libc;
+# use libc::{c_int, size_t};
+# unsafe fn snappy_validate_compressed_buffer(_: *u8, _: size_t) -> c_int { 0 }
+# fn main() {}
 pub fn validate_compressed_buffer(src: &[u8]) -> bool {
     unsafe {
         snappy_validate_compressed_buffer(src.as_ptr(), src.len() as size_t) == 0
@@ -98,14 +104,20 @@ 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.
 
-~~~~ {.ignore}
-pub fn compress(src: &[u8]) -> ~[u8] {
+~~~~
+# extern crate libc;
+# use libc::{size_t, c_int};
+# unsafe fn snappy_compress(a: *u8, b: size_t, c: *mut u8,
+#                           d: *mut size_t) -> c_int { 0 }
+# unsafe fn snappy_max_compressed_length(a: size_t) -> size_t { a }
+# fn main() {}
+pub fn compress(src: &[u8]) -> Vec<u8> {
     unsafe {
         let srclen = src.len() as size_t;
         let psrc = src.as_ptr();
 
         let mut dstlen = snappy_max_compressed_length(srclen);
-        let mut dst = slice::with_capacity(dstlen as uint);
+        let mut dst = Vec::with_capacity(dstlen as uint);
         let pdst = dst.as_mut_ptr();
 
         snappy_compress(psrc, srclen, pdst, &mut dstlen);
@@ -118,16 +130,26 @@ 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.
 
-~~~~ {.ignore}
-pub fn uncompress(src: &[u8]) -> Option<~[u8]> {
+~~~~
+# extern crate libc;
+# use libc::{size_t, c_int};
+# unsafe fn snappy_uncompress(compressed: *u8,
+#                             compressed_length: size_t,
+#                             uncompressed: *mut u8,
+#                             uncompressed_length: *mut size_t) -> c_int { 0 }
+# unsafe fn snappy_uncompressed_length(compressed: *u8,
+#                                      compressed_length: size_t,
+#                                      result: *mut size_t) -> c_int { 0 }
+# fn main() {}
+pub fn uncompress(src: &[u8]) -> Option<Vec<u8>> {
     unsafe {
         let srclen = src.len() as size_t;
         let psrc = src.as_ptr();
 
         let mut dstlen: size_t = 0;
         snappy_uncompressed_length(psrc, srclen, &mut dstlen);
 
-        let mut dst = slice::with_capacity(dstlen as uint);
+        let mut dst = Vec::with_capacity(dstlen as uint);
         let pdst = dst.as_mut_ptr();
 
         if snappy_uncompress(psrc, srclen, pdst, &mut dstlen) == 0 {
@@ -187,16 +209,19 @@ A basic example is:
 
 Rust code:
 
-~~~~ {.ignore}
+~~~~
 extern fn callback(a:i32) {
     println!("I'm called from C with value {0}", a);
 }
 
 #[link(name = "extlib")]
+# #[cfg(ignore)]
 extern {
-   fn register_callback(cb: extern "C" fn(i32)) -> i32;
+   fn register_callback(cb: extern fn(i32)) -> i32;
    fn trigger_callback();
 }
+# unsafe fn register_callback(cb: extern fn(i32)) -> i32 { 0 }
+# unsafe fn trigger_callback() { }
 
 fn main() {
     unsafe {
@@ -240,33 +265,39 @@ referenced Rust object.
 
 Rust code:
 
-~~~~ {.ignore}
+~~~~
 
 struct RustObject {
     a: i32,
     // other members
 }
 
-extern fn callback(target: *RustObject, a:i32) {
+extern fn callback(target: *mut RustObject, a:i32) {
     println!("I'm called from C with value {0}", a);
-    (*target).a = a; // Update the value in RustObject with the value received from the callback
+    unsafe {
+        // Update the value in RustObject with the value received from the callback
+        (*target).a = a;
+    }
 }
 
 #[link(name = "extlib")]
+# #[cfg(ignore)]
 extern {
-   fn register_callback(target: *RustObject, cb: extern "C" fn(*RustObject, i32)) -> i32;
+   fn register_callback(target: *mut RustObject,
+                        cb: extern fn(*mut RustObject, i32)) -> i32;
    fn trigger_callback();
 }
+# unsafe fn register_callback(a: *mut RustObject,
+#                             b: extern fn(*mut RustObject, i32)) -> i32 { 0 }
+# unsafe fn trigger_callback() {}
 
 fn main() {
     // Create the object that will be referenced in the callback
-    let rust_object = ~RustObject{a: 5, ...};
+    let mut rust_object = ~RustObject{ a: 5 };
 
     unsafe {
-        // Gets a raw pointer to the object
-        let target_addr:*RustObject = ptr::to_unsafe_ptr(rust_object);
-        register_callback(target_addr, callback);
-        trigger_callback(); // Triggers the callback
+        register_callback(&mut *rust_object, callback);
+        trigger_callback();
     }
 }
 ~~~~
@@ -403,13 +434,15 @@ 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:
 
-~~~{.ignore}
+~~~
 extern crate libc;
 
 #[link(name = "readline")]
+# #[cfg(ignore)]
 extern {
     static rl_readline_version: libc::c_int;
 }
+# static rl_readline_version: libc::c_int = 0;
 
 fn main() {
     println!("You have readline version {} installed.",
@@ -421,21 +454,23 @@ 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.
 
-~~~{.ignore}
+~~~
 extern crate libc;
 use std::ptr;
 
 #[link(name = "readline")]
+# #[cfg(ignore)]
 extern {
     static mut rl_prompt: *libc::c_char;
 }
+# static mut rl_prompt: *libc::c_char = 0 as *libc::c_char;
 
 fn main() {
-    do "[my-awesome-shell] $".as_c_str |buf| {
+    "[my-awesome-shell] $".with_c_str(|buf| {
         unsafe { rl_prompt = buf; }
         // get a line, process it
         unsafe { rl_prompt = ptr::null(); }
-    }
+    });
 }
 ~~~
 

branches/try2/src/doc/guide-testing.md

@@ -170,7 +170,7 @@ runner.
 
 The type signature of a benchmark function differs from a unit test:
 it takes a mutable reference to type
-`test::BenchHarness`. Inside the benchmark function, any
+`test::Bencher`. Inside the benchmark function, any
 time-variable or "setup" code should execute first, followed by a call
 to `iter` on the benchmark harness, passing a closure that contains
 the portion of the benchmark you wish to actually measure the
@@ -189,16 +189,16 @@ For example:
 extern crate test;
 
 use std::slice;
-use test::BenchHarness;
+use test::Bencher;
 
 #[bench]
-fn bench_sum_1024_ints(b: &mut BenchHarness) {
+fn bench_sum_1024_ints(b: &mut Bencher) {
     let v = slice::from_fn(1024, |n| n);
     b.iter(|| {v.iter().fold(0, |old, new| old + *new);} );
 }
 
 #[bench]
-fn initialise_a_vector(b: &mut BenchHarness) {
+fn initialise_a_vector(b: &mut Bencher) {
     b.iter(|| {slice::from_elem(1024, 0u64);} );
     b.bytes = 1024 * 8;
 }
@@ -249,11 +249,11 @@ it entirely.
 ~~~
 # #[allow(unused_imports)];
 extern crate test;
-use test::BenchHarness;
+use test::Bencher;
 
 #[bench]
-fn bench_xor_1000_ints(bh: &mut BenchHarness) {
-    bh.iter(|| {
+fn bench_xor_1000_ints(b: &mut Bencher) {
+    b.iter(|| {
             range(0, 1000).fold(0, |old, new| old ^ new);
         });
 }

branches/try2/src/libarena/lib.rs

@@ -481,9 +481,7 @@ impl<T> Drop for TypedArena<T> {
 #[cfg(test)]
 mod tests {
     extern crate test;
-
-
-    use self::test::BenchHarness;
+    use self::test::Bencher;
     use super::{Arena, TypedArena};
 
     struct Point {
@@ -505,9 +503,9 @@ mod tests {
     }
 
     #[bench]
-    pub fn bench_copy(bh: &mut BenchHarness) {
+    pub fn bench_copy(b: &mut Bencher) {
         let arena = TypedArena::new();
-        bh.iter(|| {
+        b.iter(|| {
             arena.alloc(Point {
                 x: 1,
                 y: 2,
@@ -517,8 +515,8 @@ mod tests {
     }
 
     #[bench]
-    pub fn bench_copy_nonarena(bh: &mut BenchHarness) {
-        bh.iter(|| {
+    pub fn bench_copy_nonarena(b: &mut Bencher) {
+        b.iter(|| {
             ~Point {
                 x: 1,
                 y: 2,
@@ -528,9 +526,9 @@ mod tests {
     }
 
     #[bench]
-    pub fn bench_copy_old_arena(bh: &mut BenchHarness) {
+    pub fn bench_copy_old_arena(b: &mut Bencher) {
         let arena = Arena::new();
-        bh.iter(|| {
+        b.iter(|| {
             arena.alloc(|| {
                 Point {
                     x: 1,
@@ -558,9 +556,9 @@ mod tests {
     }
 
     #[bench]
-    pub fn bench_noncopy(bh: &mut BenchHarness) {
+    pub fn bench_noncopy(b: &mut Bencher) {
         let arena = TypedArena::new();
-        bh.iter(|| {
+        b.iter(|| {
             arena.alloc(Noncopy {
                 string: ~"hello world",
                 array: vec!( 1, 2, 3, 4, 5 ),
@@ -569,8 +567,8 @@ mod tests {
     }
 
     #[bench]
-    pub fn bench_noncopy_nonarena(bh: &mut BenchHarness) {
-        bh.iter(|| {
+    pub fn bench_noncopy_nonarena(b: &mut Bencher) {
+        b.iter(|| {
             ~Noncopy {
                 string: ~"hello world",
                 array: vec!( 1, 2, 3, 4, 5 ),
@@ -579,9 +577,9 @@ mod tests {
     }
 
     #[bench]
-    pub fn bench_noncopy_old_arena(bh: &mut BenchHarness) {
+    pub fn bench_noncopy_old_arena(b: &mut Bencher) {
         let arena = Arena::new();
-        bh.iter(|| {
+        b.iter(|| {
             arena.alloc(|| Noncopy {
                 string: ~"hello world",
                 array: vec!( 1, 2, 3, 4, 5 ),