---

yaml
---
r: 110867
b: refs/heads/auto
c: f862e12
h: refs/heads/master
i:
  110865: 75197bf
  110863: fa51ea6
v: v3

Author: alexcrichton

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: ab0d8472777d2359492dfdee1d21230fbf144f70
+refs/heads/auto: f862e1256d846e235b749358ab6fe3a324c1b25c
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/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/auto/src/libgreen/sched.rs

@@ -1011,6 +1011,7 @@ fn new_sched_rng() -> XorShiftRng {
 mod test {
     use rustuv;
 
+    use std::comm;
     use std::task::TaskOpts;
     use std::rt::task::Task;
     use std::rt::local::Local;
@@ -1427,7 +1428,7 @@ mod test {
             // This task should not be able to starve the sender;
             // The sender should get stolen to another thread.
             spawn(proc() {
-                while rx.try_recv().is_err() { }
+                while rx.try_recv() != comm::Data(()) { }
             });
 
             tx.send(());
@@ -1444,7 +1445,7 @@ mod test {
             // This task should not be able to starve the other task.
             // The sends should eventually yield.
             spawn(proc() {
-                while rx1.try_recv().is_err() {
+                while rx1.try_recv() != comm::Data(()) {
                     tx2.send(());
                 }
             });
@@ -1498,7 +1499,7 @@ mod test {
                     let mut val = 20;
                     while val > 0 {
                         val = po.recv();
-                        let _ = ch.send_opt(val - 1);
+                        ch.try_send(val - 1);
                     }
                 }
 

branches/auto/src/libgreen/task.rs

@@ -515,7 +515,7 @@ mod tests {
             let _tx = tx;
             fail!()
         });
-        assert_eq!(rx.recv_opt(), Err(()));
+        assert_eq!(rx.recv_opt(), None);
     }
 
     #[test]

branches/auto/src/libnative/io/timer_other.rs

@@ -46,6 +46,7 @@
 //!
 //! Note that all time units in this file are in *milliseconds*.
 
+use std::comm::Data;
 use libc;
 use std::mem;
 use std::os;
@@ -118,7 +119,7 @@ fn helper(input: libc::c_int, messages: Receiver<Req>) {
             Some(timer) => timer, None => return
         };
         let tx = timer.tx.take_unwrap();
-        if tx.send_opt(()).is_ok() && timer.repeat {
+        if tx.try_send(()) && timer.repeat {
             timer.tx = Some(tx);
             timer.target += timer.interval;
             insert(timer, active);
@@ -161,14 +162,14 @@ fn helper(input: libc::c_int, messages: Receiver<Req>) {
             1 => {
                 loop {
                     match messages.try_recv() {
-                        Ok(Shutdown) => {
+                        Data(Shutdown) => {
                             assert!(active.len() == 0);
                             break 'outer;
                         }
 
-                        Ok(NewTimer(timer)) => insert(timer, &mut active),
+                        Data(NewTimer(timer)) => insert(timer, &mut active),
 
-                        Ok(RemoveTimer(id, ack)) => {
+                        Data(RemoveTimer(id, ack)) => {
                             match dead.iter().position(|&(i, _)| id == i) {
                                 Some(i) => {
                                     let (_, i) = dead.remove(i).unwrap();

branches/auto/src/libnative/io/timer_timerfd.rs

@@ -28,6 +28,7 @@
 //!
 //! As with timer_other, all units in this file are in units of millseconds.
 
+use std::comm::Data;
 use libc;
 use std::ptr;
 use std::os;
@@ -106,7 +107,7 @@ fn helper(input: libc::c_int, messages: Receiver<Req>) {
                     match list.as_slice().bsearch(|&(f, _, _)| f.cmp(&fd)) {
                         Some(i) => {
                             let (_, ref c, oneshot) = *list.get(i);
-                            (c.send_opt(()).is_err() || oneshot, i)
+                            (!c.try_send(()) || oneshot, i)
                         }
                         None => fail!("fd not active: {}", fd),
                     }
@@ -120,7 +121,7 @@ fn helper(input: libc::c_int, messages: Receiver<Req>) {
 
         while incoming {
             match messages.try_recv() {
-                Ok(NewTimer(fd, chan, one, timeval)) => {
+                Data(NewTimer(fd, chan, one, timeval)) => {
                     // acknowledge we have the new channel, we will never send
                     // another message to the old channel
                     chan.send(());
@@ -148,7 +149,7 @@ fn helper(input: libc::c_int, messages: Receiver<Req>) {
                     assert_eq!(ret, 0);
                 }
 
-                Ok(RemoveTimer(fd, chan)) => {
+                Data(RemoveTimer(fd, chan)) => {
                     match list.as_slice().bsearch(|&(f, _, _)| f.cmp(&fd)) {
                         Some(i) => {
                             drop(list.remove(i));
@@ -159,7 +160,7 @@ fn helper(input: libc::c_int, messages: Receiver<Req>) {
                     chan.send(());
                 }
 
-                Ok(Shutdown) => {
+                Data(Shutdown) => {
                     assert!(list.len() == 0);
                     break 'outer;
                 }

branches/auto/src/libnative/io/timer_win32.rs

@@ -20,6 +20,7 @@
 //! Other than that, the implementation is pretty straightforward in terms of
 //! the other two implementations of timers with nothing *that* new showing up.
 
+use std::comm::Data;
 use libc;
 use std::ptr;
 use std::rt::rtio;
@@ -53,11 +54,11 @@ fn helper(input: libc::HANDLE, messages: Receiver<Req>) {
         if idx == 0 {
             loop {
                 match messages.try_recv() {
-                    Ok(NewTimer(obj, c, one)) => {
+                    Data(NewTimer(obj, c, one)) => {
                         objs.push(obj);
                         chans.push((c, one));
                     }
-                    Ok(RemoveTimer(obj, c)) => {
+                    Data(RemoveTimer(obj, c)) => {
                         c.send(());
                         match objs.iter().position(|&o| o == obj) {
                             Some(i) => {
@@ -67,7 +68,7 @@ fn helper(input: libc::HANDLE, messages: Receiver<Req>) {
                             None => {}
                         }
                     }
-                    Ok(Shutdown) => {
+                    Data(Shutdown) => {
                         assert_eq!(objs.len(), 1);
                         assert_eq!(chans.len(), 0);
                         break 'outer;
@@ -78,7 +79,7 @@ fn helper(input: libc::HANDLE, messages: Receiver<Req>) {
         } else {
             let remove = {
                 match chans.get(idx as uint - 1) {
-                    &(ref c, oneshot) => c.send_opt(()).is_err() || oneshot
+                    &(ref c, oneshot) => !c.try_send(()) || oneshot
                 }
             };
             if remove {

branches/auto/src/libnative/task.rs

@@ -274,7 +274,7 @@ mod tests {
             let _tx = tx;
             fail!()
         });
-        assert_eq!(rx.recv_opt(), Err(()));
+        assert_eq!(rx.recv_opt(), None);
     }
 
     #[test]

branches/auto/src/librustuv/net.rs

@@ -1065,7 +1065,7 @@ mod test {
             }
             reads += 1;
 
-            let _ = tx2.send_opt(());
+            tx2.try_send(());
         }
 
         // Make sure we had multiple reads

branches/auto/src/librustuv/signal.rs

@@ -51,7 +51,7 @@ impl SignalWatcher {
 extern fn signal_cb(handle: *uvll::uv_signal_t, signum: c_int) {
     let s: &mut SignalWatcher = unsafe { UvHandle::from_uv_handle(&handle) };
     assert_eq!(signum as int, s.signal as int);
-    let _ = s.channel.send_opt(s.signal);
+    s.channel.try_send(s.signal);
 }
 
 impl HomingIO for SignalWatcher {