---

yaml
---
r: 148463
b: refs/heads/try2
c: 1089bfe
h: refs/heads/master
i:
  148461: 60ad822
  148459: 9c827a6
  148455: 41d67d4
  148447: b4d38c1
v: v3

Author: flaper87

[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: e65a8b88cac97bdc01ee01a099915d861406edd6
+refs/heads/try2: 1089bfef608dc0f6d9efc57d8daa8da76db823a8
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/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

branches/try2/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

branches/try2/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};
     }
@@ -238,15 +237,9 @@ actual:\n\
 
     fn make_typecheck_args(config: &config, props: &TestProps, testfile: &Path) -> ProcArgs {
         let aux_dir = aux_output_dir_name(config, testfile);
-        let target = if props.force_host {
-            config.host.as_slice()
-        } else {
-            config.target.as_slice()
-        };
         // FIXME (#9639): This needs to handle non-utf8 paths
         let mut args = ~[~"-",
                          ~"--no-trans", ~"--lib",
-                         ~"--target=" + target,
                          ~"-L", config.build_base.as_str().unwrap().to_owned(),
                          ~"-L",
                          aux_dir.as_str().unwrap().to_owned()];

branches/try2/src/libextra/uuid.rs

@@ -57,7 +57,7 @@ Examples of string representations:
 
 use std::str;
 use std::vec;
-use std::num::FromStrRadix;
+use std::num::{FromStrRadix, Zero};
 use std::char::Char;
 use std::container::Container;
 use std::to_str::ToStr;
@@ -158,8 +158,9 @@ static UuidGroupLens: [uint, ..5] = [8u, 4u, 4u, 4u, 12u];
 
 /// UUID support
 impl Uuid {
+
     /// Returns a nil or empty UUID (containing all zeroes)
-    pub fn nil() -> Uuid {
+    pub fn new_nil() -> Uuid {
         let uuid = Uuid{ bytes: [0, .. 16] };
         uuid
     }
@@ -422,17 +423,24 @@ impl Uuid {
 
         Ok(Uuid::from_bytes(ub).unwrap())
     }
-
-    /// Tests if the UUID is nil
-    pub fn is_nil(&self) -> bool {
-        return self.bytes.iter().all(|&b| b == 0);
-    }
 }
 
 impl Default for Uuid {
     /// Returns the nil UUID, which is all zeroes
     fn default() -> Uuid {
-        Uuid::nil()
+        Uuid::new_nil()
+    }
+}
+
+impl Zero for Uuid {
+    /// Returns the nil UUID, which is all zeroes
+    fn zero() -> Uuid {
+        Uuid::new_nil()
+    }
+
+    /// Tests if the UUID is nil or all zeroes
+    fn is_zero(&self) -> bool {
+        return self.bytes.iter().all(|&b| b == 0);
     }
 }
 
@@ -513,15 +521,24 @@ mod test {
     use super::*;
     use std::str;
     use std::rand;
+    use std::num::Zero;
     use std::io::MemWriter;
 
     #[test]
-    fn test_nil() {
-        let nil = Uuid::nil();
-        let not_nil = Uuid::new_v4();
+    fn test_new_nil() {
+        let nil = Uuid::new_nil();
+        let nb = nil.to_bytes();
+
+        assert!(nb.iter().all(|&b| b == 0));
+    }
+
+    #[test]
+    fn test_zero() {
+        let uz: Uuid = Zero::zero();
+        let nz = Uuid::new_v4();
 
-        assert!(nil.is_nil());
-        assert!(!not_nil.is_nil());
+        assert!(uz.is_zero());
+        assert!(! nz.is_zero());
     }
 
     #[test]
@@ -602,7 +619,7 @@ mod test {
         assert!(Uuid::parse_string("urn:uuid:67e55044-10b1-426f-9247-bb680e5fe0c8").is_ok());
 
         // Nil
-        let nil = Uuid::nil();
+        let nil = Uuid::new_nil();
         assert!(Uuid::parse_string("00000000000000000000000000000000").unwrap()  == nil);
         assert!(Uuid::parse_string("00000000-0000-0000-0000-000000000000").unwrap() == nil);
 

branches/try2/src/librustc/middle/borrowck/doc.rs

@@ -179,7 +179,7 @@ checker uses a data flow propagation to compute the full set of loans
 in scope at each expression and then uses that set to decide whether
 that expression is legal.  Remember that the scope of loan is defined
 by its lifetime LT.  We sometimes say that a loan which is in-scope at
-a particular point is an "outstanding loan", aand the set of
+a particular point is an "outstanding loan", and the set of
 restrictions included in those loans as the "outstanding
 restrictions".
 

branches/try2/src/librustc/middle/check_const.rs

@@ -177,10 +177,11 @@ pub fn check_expr(v: &mut CheckCrateVisitor,
                 }
             }
           }
+          ExprParen(e) => { check_expr(v, sess, def_map, method_map,
+                                        tcx, e, is_const); }
           ExprVstore(_, ExprVstoreSlice) |
           ExprVec(_, MutImmutable) |
           ExprAddrOf(MutImmutable, _) |
-          ExprParen(..) |
           ExprField(..) |
           ExprIndex(..) |
           ExprTup(..) |

branches/try2/src/librustc/middle/lang_items.rs

@@ -33,27 +33,12 @@ use std::hashmap::HashMap;
 use std::iter::Enumerate;
 use std::vec;
 
-
-// Get the last "argument" (has to be done recursively to avoid phoney local ambiguity error)
-macro_rules! last {
-    ( $first:expr, $( $remainder:expr, )+ ) => ( last!( $( $remainder, )+ ) );
-    ( $first:expr, ) => ( $first )
-}
-
 // The actual lang items defined come at the end of this file in one handy table.
 // So you probably just want to nip down to the end.
 macro_rules! lets_do_this {
-    // secondary rule to allow us to use `$num` as both an expression
-    // and a pattern.
-    (
-        $( $num:tt, $variant:ident, $name:expr, $method:ident; )*
-    ) => {
-        lets_do_this!(count = 1 + last!($($num,)*),
-                      $($num, $variant, $name, $method; )*)
-    };
-
     (
-        count = $num_lang_items:expr, $( $num:pat, $variant:ident, $name:expr, $method:ident; )*
+        There are $num_lang_items:expr lang items.
+        $( $num:pat, $variant:ident, $name:expr, $method:ident; )*
     ) => {
 
 pub enum LangItem {
@@ -222,6 +207,8 @@ pub fn collect_language_items(crate: &ast::Crate,
 }
 
 lets_do_this! {
+    There are 40 lang items.
+
 //  ID, Variant name,                    Name,                      Method name;
     0,  FreezeTraitLangItem,             "freeze",                  freeze_trait;
     1,  SendTraitLangItem,               "send",                    send_trait;
@@ -274,3 +261,4 @@ lets_do_this! {
     38, ExchangeHeapLangItem,            "exchange_heap",           exchange_heap;
     39, GcLangItem,                      "gc",                      gc;
 }
+

branches/try2/src/librustc/middle/moves.rs

@@ -38,7 +38,7 @@ case, the value is read, and the container (`x`) is also read.
 In the second case, `y`, `x.b` is being assigned which has type
 `~int`.  Because this type moves by default, that will be a move
 reference.  Whenever we move from a compound expression like `x.b` (or
-`x[b]` or `*x` or `{x)[b].c`, etc), this invalidates all containing
+`x[b]` or `*x` or `{x}[b].c`, etc), this invalidates all containing
 expressions since we do not currently permit "incomplete" variables
 where part of them has been moved and part has not.  In this case,
 this means that the reference to `x` is also a move.  We'll see later,
@@ -56,7 +56,7 @@ For each binding in a match or let pattern, we also compute a read
 or move designation.  A move binding means that the value will be
 moved from the value being matched.  As a result, the expression
 being matched (aka, the 'discriminant') is either moved or read
-depending on whethe the bindings move the value they bind to out of
+depending on whether the bindings move the value they bind to out of
 the discriminant.
 
 For examples, consider this match expression:

branches/try2/src/librustc/middle/trans/base.rs

@@ -940,7 +940,7 @@ pub fn invoke<'a>(
         }
     }
 
-    if need_invoke(bcx) {
+    if bcx.fcx.needs_invoke() {
         unsafe {
             debug!("invoking {} at {}", llfn, bcx.llbb);
             for &llarg in llargs.iter() {

branches/try2/src/librustc/middle/ty.rs

@@ -2287,12 +2287,6 @@ pub fn is_instantiable(cx: ctxt, r_ty: t) -> bool {
                ::util::ppaux::ty_to_str(cx, ty));
 
         let r = match get(ty).sty {
-            // fixed length vectors need special treatment compared to
-            // normal vectors, since they don't necessarily have the
-            // possibilty to have length zero.
-            ty_vec(_, vstore_fixed(0)) => false, // don't need no contents
-            ty_vec(mt, vstore_fixed(_)) => type_requires(cx, seen, r_ty, mt.ty),
-
             ty_nil |
             ty_bot |
             ty_bool |