---

yaml
---
r: 98297
b: refs/heads/master
c: eca980b
h: refs/heads/master
i:
  98295: cb5f9dd
v: v3

Author: alexcrichton

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 43cffe9d719170bd342b10d1bb81911f0e14a7c4
+refs/heads/master: eca980be57c62165244cc7b950c3b066571ff3ba
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: b6400f998497c3958f40997a71756ead344a776d
 refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36

trunk/doc/guide-ffi.md

@@ -249,143 +249,6 @@ fn main() {
 }
 ~~~~
 
-# Callbacks from C code to Rust functions
-
-Some external libraries require the usage of callbacks to report back their
-current state or intermediate data to the caller.
-It is possible to pass functions defined in Rust to an external library.
-The requirement for this is that the callback function is marked as `extern`
-with the correct calling convention to make it callable from C code.
-
-The callback function that can then be sent to through a registration call
-to the C library and afterwards be invoked from there.
-
-A basic example is:
-
-Rust code:
-~~~~ {.xfail-test}
-extern fn callback(a:i32) {
-    println!("I'm called from C with value {0}", a);
-}
-
-#[link(name = "extlib")]
-extern {
-   fn register_callback(cb: extern "C" fn(i32)) -> i32;
-   fn trigger_callback();
-}
-
-fn main() {
-    unsafe {
-        register_callback(callback);
-        trigger_callback(); // Triggers the callback
-    }
-}
-~~~~
-
-C code:
-~~~~ {.xfail-test}
-typedef void (*rust_callback)(int32_t);
-rust_callback cb;
-
-int32_t register_callback(rust_callback callback) {
-    cb = callback;
-    return 1;
-}
-
-void trigger_callback() {
-  cb(7); // Will call callback(7) in Rust
-}
-~~~~
-
-In this example will Rust's `main()` will call `do_callback()` in C,
-which would call back to `callback()` in Rust.
-
-
-## Targetting callbacks to Rust objects
-
-The former example showed how a global function can be called from C-Code.
-However it is often desired that the callback is targetted to a special
-Rust object. This could be the object that represents the wrapper for the
-respective C object. 
-
-This can be achieved by passing an unsafe pointer to the object down to the
-C library. The C library can then include the pointer to the Rust object in
-the notification. This will provide a unsafe possibility to access the 
-referenced Rust object in callback.
-
-Rust code:
-~~~~ {.xfail-test}
-
-struct RustObject {
-    a: i32,
-    // other members
-}
-
-extern fn callback(target: *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
-}
-
-#[link(name = "extlib")]
-extern {
-   fn register_callback(target: *RustObject, cb: extern "C" fn(*RustObject, i32)) -> i32;
-   fn trigger_callback();
-}
-
-fn main() {
-    // Create the object that will be referenced in the callback
-    let 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
-    }
-}
-~~~~
-
-C code:
-~~~~ {.xfail-test}
-typedef void (*rust_callback)(int32_t);
-void* cb_target;
-rust_callback cb;
-
-int32_t register_callback(void* callback_target, rust_callback callback) {
-    cb_target = callback_target;
-    cb = callback;
-    return 1;
-}
-
-void trigger_callback() {
-  cb(cb_target, 7); // Will call callback(&rustObject, 7) in Rust
-}
-~~~~
-
-## Asynchronous callbacks
-
-In the already given examples the callbacks are invoked as a direct reaction
-to a function call to the external C library.
-The control over the current thread switched from Rust to C to Rust for the
-execution of the callback, but in the end the callback is executed on the
-same thread (and Rust task) that lead called the function which triggered
-the callback.
-
-Things get more complicated when the external library spawns it's own threads
-and invokes callbacks from there.
-In these cases access to Rust data structures inside he callbacks is
-especially unsafe and proper synchronization mechanisms must be used.
-Besides classical synchronization mechanisms like mutexes one possibility in
-Rust is to use channels (in `std::comm`) to forward data from the C thread
-that invoked the callback into a Rust task.
-
-If an asychronous callback targets a special object in the Rust address space
-it is also absolutely necessary that no more callbacks are performed by the 
-C library after the respective Rust object get's destroyed. 
-This can be achieved by unregistering the callback it the object's
-destructor and designing the library in a way that guarantees that no
-callback will be performed after unregistration.
-
 # Linking
 
 The `link` attribute on `extern` blocks provides the basic building block for

trunk/doc/rust.md

@@ -484,7 +484,6 @@ include:
 
 * `fmt!` : format data into a string
 * `env!` : look up an environment variable's value at compile time
-* `file!`: return the path to the file being compiled
 * `stringify!` : pretty-print the Rust expression given as an argument
 * `include!` : include the Rust expression in the given file
 * `include_str!` : include the contents of the given file as a string

trunk/src/compiletest/compiletest.rs

@@ -140,9 +140,14 @@ pub fn parse_config(args: ~[~str]) -> config {
         adb_test_dir:
             opt_str2(matches.opt_str("adb-test-dir")).to_str(),
         adb_device_status:
-            "arm-linux-androideabi" == opt_str2(matches.opt_str("target")) &&
-            "(none)" != opt_str2(matches.opt_str("adb-test-dir")) &&
-            !opt_str2(matches.opt_str("adb-test-dir")).is_empty(),
+            if (opt_str2(matches.opt_str("target")) ==
+                ~"arm-linux-androideabi") {
+                if (opt_str2(matches.opt_str("adb-test-dir")) !=
+                    ~"(none)" &&
+                    opt_str2(matches.opt_str("adb-test-dir")) !=
+                    ~"") { true }
+                else { false }
+            } else { false },
         test_shard: test::opt_shard(matches.opt_str("test-shard")),
         verbose: matches.opt_present("verbose")
     }

trunk/src/compiletest/runtest.rs

@@ -206,8 +206,7 @@ fn run_pretty_test(config: &config, props: &TestProps, testfile: &Path) {
     }
 
     fn make_pp_args(config: &config, _testfile: &Path) -> ProcArgs {
-        let args = ~[~"-", ~"--pretty", ~"normal",
-                     ~"--target=" + config.target];
+        let args = ~[~"-", ~"--pretty", ~"normal"];
         // FIXME (#9639): This needs to handle non-utf8 paths
         return ProcArgs {prog: config.rustc_path.as_str().unwrap().to_owned(), args: args};
     }
@@ -532,9 +531,9 @@ fn check_expected_errors(expected_errors: ~[errors::ExpectedError],
             if !found_flags[i] {
                 debug!("prefix={} ee.kind={} ee.msg={} line={}",
                        prefixes[i], ee.kind, ee.msg, line);
-                if prefix_matches(line, prefixes[i]) &&
+                if (prefix_matches(line, prefixes[i]) &&
                     line.contains(ee.kind) &&
-                    line.contains(ee.msg) {
+                    line.contains(ee.msg)) {
                     found_flags[i] = true;
                     was_expected = true;
                     break;

trunk/src/libextra/ebml.rs

@@ -1025,15 +1025,15 @@ mod bench {
     pub fn vuint_at_A_aligned(bh: &mut BenchHarness) {
         use std::vec;
         let data = vec::from_fn(4*100, |i| {
-            match i % 2 {
+            match (i % 2) {
               0 => 0x80u8,
               _ => i as u8,
             }
         });
         let mut sum = 0u;
         bh.iter(|| {
             let mut i = 0;
-            while i < data.len() {
+            while (i < data.len()) {
                 sum += reader::vuint_at(data, i).val;
                 i += 4;
             }
@@ -1044,15 +1044,15 @@ mod bench {
     pub fn vuint_at_A_unaligned(bh: &mut BenchHarness) {
         use std::vec;
         let data = vec::from_fn(4*100+1, |i| {
-            match i % 2 {
+            match (i % 2) {
               1 => 0x80u8,
               _ => i as u8
             }
         });
         let mut sum = 0u;
         bh.iter(|| {
             let mut i = 1;
-            while i < data.len() {
+            while (i < data.len()) {
                 sum += reader::vuint_at(data, i).val;
                 i += 4;
             }
@@ -1063,7 +1063,7 @@ mod bench {
     pub fn vuint_at_D_aligned(bh: &mut BenchHarness) {
         use std::vec;
         let data = vec::from_fn(4*100, |i| {
-            match i % 4 {
+            match (i % 4) {
               0 => 0x10u8,
               3 => i as u8,
               _ => 0u8
@@ -1072,7 +1072,7 @@ mod bench {
         let mut sum = 0u;
         bh.iter(|| {
             let mut i = 0;
-            while i < data.len() {
+            while (i < data.len()) {
                 sum += reader::vuint_at(data, i).val;
                 i += 4;
             }
@@ -1083,7 +1083,7 @@ mod bench {
     pub fn vuint_at_D_unaligned(bh: &mut BenchHarness) {
         use std::vec;
         let data = vec::from_fn(4*100+1, |i| {
-            match i % 4 {
+            match (i % 4) {
               1 => 0x10u8,
               0 => i as u8,
               _ => 0u8
@@ -1092,7 +1092,7 @@ mod bench {
         let mut sum = 0u;
         bh.iter(|| {
             let mut i = 1;
-            while i < data.len() {
+            while (i < data.len()) {
                 sum += reader::vuint_at(data, i).val;
                 i += 4;
             }

trunk/src/libextra/enum_set.rs

@@ -114,7 +114,7 @@ impl<E:CLike> Items<E> {
 
 impl<E:CLike> Iterator<E> for Items<E> {
     fn next(&mut self) -> Option<E> {
-        if self.bits == 0 {
+        if (self.bits == 0) {
             return None;
         }
 

trunk/src/libextra/getopts.rs

@@ -195,7 +195,7 @@ impl Matches {
 
     fn opt_val(&self, nm: &str) -> Option<Optval> {
         let vals = self.opt_vals(nm);
-        if vals.is_empty() {
+        if (vals.is_empty()) {
             None
         } else {
             Some(vals[0].clone())
@@ -797,7 +797,7 @@ pub mod groups {
         let slice: || = || { cont = it(ss.slice(slice_start, last_end)) };
 
         // if the limit is larger than the string, lower it to save cycles
-        if lim >= fake_i {
+        if (lim >= fake_i) {
             lim = fake_i;
         }
 

trunk/src/libextra/json.rs

@@ -929,7 +929,7 @@ impl<T : Iterator<char>> Parser<T> {
                 return self.error(~"EOF while parsing string");
             }
 
-            if escape {
+            if (escape) {
                 match self.ch {
                   '"' => res.push_char('"'),
                   '\\' => res.push_char('\\'),
@@ -1360,7 +1360,7 @@ impl serialize::Decoder for Decoder {
 /// Test if two json values are less than one another
 impl Ord for Json {
     fn lt(&self, other: &Json) -> bool {
-        match *self {
+        match (*self) {
             Number(f0) => {
                 match *other {
                     Number(f1) => f0 < f1,

trunk/src/libextra/lib.rs

@@ -20,7 +20,8 @@ Rust extras are part of the standard Rust distribution.
 
 */
 
-#[crate_id = "extra#0.10-pre"];
+// NOTE: upgrade to 0.10-pre after the next snapshot
+#[crate_id = "extra#0.9"];
 #[comment = "Rust extras"];
 #[license = "MIT/ASL2"];
 #[crate_type = "rlib"];

trunk/src/libextra/num/bigint.rs

@@ -561,9 +561,9 @@ impl ToPrimitive for BigUint {
 impl FromPrimitive for BigUint {
     #[inline]
     fn from_i64(n: i64) -> Option<BigUint> {
-        if n > 0 {
+        if (n > 0) {
             FromPrimitive::from_u64(n as u64)
-        } else if n == 0 {
+        } else if (n == 0) {
             Some(Zero::zero())
         } else {
             None

trunk/src/libextra/terminfo/parser/compiled.rs

@@ -178,7 +178,7 @@ pub fn parse(file: &mut io::Reader,
 
     // Check magic number
     let magic = file.read_le_u16();
-    if magic != 0x011A {
+    if (magic != 0x011A) {
         return Err(format!("invalid magic number: expected {:x} but found {:x}",
                            0x011A, magic as uint));
     }

trunk/src/libextra/time.rs

@@ -808,7 +808,7 @@ pub fn strptime(s: &str, format: &str) -> Result<Tm, ~str> {
 /// Formats the time according to the format string.
 pub fn strftime(format: &str, tm: &Tm) -> ~str {
     fn days_in_year(year: int) -> i32 {
-        if (year % 4 == 0) && ((year % 100 != 0) || (year % 400 == 0)) {
+        if ((year % 4 == 0) && ((year % 100 != 0) || (year % 400 == 0))) {
             366    /* Days in a leap year */
         } else {
             365    /* Days in a non-leap year */
@@ -838,14 +838,14 @@ pub fn strftime(format: &str, tm: &Tm) -> ~str {
         let mut year: int = tm.tm_year as int + 1900;
         let mut days: int = iso_week_days (tm.tm_yday, tm.tm_wday);
 
-        if days < 0 {
+        if (days < 0) {
             /* This ISO week belongs to the previous year. */
             year -= 1;
             days = iso_week_days (tm.tm_yday + (days_in_year(year)), tm.tm_wday);
         } else {
             let d: int = iso_week_days (tm.tm_yday - (days_in_year(year)),
                                         tm.tm_wday);
-            if 0 <= d {
+            if (0 <= d) {
                 /* This ISO week belongs to the next year. */
                 year += 1;
                 days = d;

trunk/src/libextra/uuid.rs

@@ -614,16 +614,16 @@ mod test {
 
         // Test error reporting
         let e = Uuid::parse_string("67e5504410b1426f9247bb680e5fe0c").unwrap_err();
-        assert!(match e { ErrorInvalidLength(n) => n==31, _ => false });
+        assert!(match(e){ ErrorInvalidLength(n) => n==31, _ => false });
 
         let e = Uuid::parse_string("67e550X410b1426f9247bb680e5fe0cd").unwrap_err();
-        assert!(match e { ErrorInvalidCharacter(c, n) => c=='X' && n==6, _ => false });
+        assert!(match(e){ ErrorInvalidCharacter(c, n) => c=='X' && n==6, _ => false });
 
         let e = Uuid::parse_string("67e550-4105b1426f9247bb680e5fe0c").unwrap_err();
-        assert!(match e { ErrorInvalidGroups(n) => n==2, _ => false });
+        assert!(match(e){ ErrorInvalidGroups(n) => n==2, _ => false });
 
         let e = Uuid::parse_string("F9168C5E-CEB2-4faa-B6BF1-02BF39FA1E4").unwrap_err();
-        assert!(match e { ErrorInvalidGroupLength(g, n, e) => g==3 && n==5 && e==4, _ => false });
+        assert!(match(e){ ErrorInvalidGroupLength(g, n, e) => g==3 && n==5 && e==4, _ => false });
     }
 
     #[test]