---

yaml
---
r: 140694
b: refs/heads/try2
c: 9482ed7
h: refs/heads/master
v: v3

Author: nikomatsakis

[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: 842e304ab505f6c0d8f6b29ec3c0dfa8dc9e1aac
+refs/heads/try2: 9482ed729eaf9ade87a3aec057a56c4a48f49653
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/rust.md

@@ -1946,6 +1946,35 @@ fn avg(v: &[float]) -> float {
 }
 ~~~~
 
+#### Swap expressions
+
+A _swap expression_ consists of an [lvalue](#lvalues-rvalues-and-temporaries) followed by a bi-directional arrow (`<->`) and another [lvalue](#lvalues-rvalues-and-temporaries).
+
+Evaluating a swap expression causes, as a side effect, the values held in the left-hand-side and right-hand-side [lvalues](#lvalues-rvalues-and-temporaries) to be exchanged indivisibly.
+
+Evaluating a swap expression neither changes reference counts,
+nor deeply copies any owned structure pointed to by the moved [rvalue](#lvalues-rvalues-and-temporaries).
+Instead, the swap expression represents an indivisible *exchange of ownership*,
+between the right-hand-side and the left-hand-side of the expression.
+No allocation or destruction is entailed.
+
+An example of three different swap expressions:
+
+~~~~~~~~
+# let mut x = &mut [0];
+# let mut a = &mut [0];
+# let i = 0;
+# struct S1 { z: int };
+# struct S2 { c: int };
+# let mut y = S1{z: 0};
+# let mut b = S2{c: 0};
+
+x <-> a;
+x[i] <-> a[i];
+y.z <-> b.c;
+~~~~~~~~
+
+
 #### Assignment expressions
 
 An _assignment expression_ consists of an [lvalue](#lvalues-rvalues-and-temporaries) expression followed by an
@@ -1986,7 +2015,7 @@ as
 == !=
 &&
 ||
-=
+= <->
 ~~~~
 
 Operators at the same precedence level are evaluated left-to-right.

branches/try2/doc/tutorial-ffi.md

@@ -151,7 +151,6 @@ wrapping `malloc` and `free`:
 ~~~~
 use core::libc::{c_void, size_t, malloc, free};
 use core::unstable::intrinsics;
-use core::util;
 
 // a wrapper around the handle returned by the foreign code
 pub struct Unique<T> {
@@ -185,8 +184,7 @@ impl<T: Owned> Drop for Unique<T> {
     fn finalize(&self) {
         unsafe {
             let mut x = intrinsics::init(); // dummy value to swap in
-            // moving the object out is needed to call the destructor
-            util::replace_ptr(self.ptr, x);
+            x <-> *self.ptr; // moving the object out is needed to call the destructor
             free(self.ptr as *c_void)
         }
     }

branches/try2/mk/platform.mk

@@ -247,12 +247,12 @@ AR_mips-unknown-linux-gnu=mips-linux-gnu-ar
 CFG_LIB_NAME_mips-unknown-linux-gnu=lib$(1).so
 CFG_LIB_GLOB_mips-unknown-linux-gnu=lib$(1)-*.so
 CFG_LIB_DSYM_GLOB_mips-unknown-linux-gnu=lib$(1)-*.dylib.dSYM
-CFG_GCCISH_CFLAGS_mips-unknown-linux-gnu := -Wall -g -fPIC -mips32r2 -msoft-float -mabi=32 -mno-compact-eh
+CFG_GCCISH_CFLAGS_mips-unknown-linux-gnu := -Wall -g -fPIC -mips32r2 -msoft-float -mabi=32
 CFG_GCCISH_CXXFLAGS_mips-unknown-linux-gnu := -fno-rtti
 CFG_GCCISH_LINK_FLAGS_mips-unknown-linux-gnu := -shared -fPIC -g -mips32r2 -msoft-float -mabi=32
 CFG_GCCISH_DEF_FLAG_mips-unknown-linux-gnu := -Wl,--export-dynamic,--dynamic-list=
 CFG_GCCISH_PRE_LIB_FLAGS_mips-unknown-linux-gnu := -Wl,-whole-archive
-CFG_GCCISH_POST_LIB_FLAGS_mips-unknown-linux-gnu := -Wl,-no-whole-archive
+CFG_GCCISH_POST_LIB_FLAGS_mips-unknown-linux-gnu := -Wl,-no-whole-archive -Wl,-znoexecstack
 CFG_DEF_SUFFIX_mips-unknown-linux-gnu := .linux.def
 CFG_INSTALL_NAME_mips-unknown-linux-gnu =
 CFG_LIBUV_LINK_FLAGS_mips-unknown-linux-gnu =

branches/try2/src/libcore/cast.rs

@@ -24,20 +24,6 @@ pub mod rusti {
 }
 
 /// Casts the value at `src` to U. The two types must have the same length.
-#[cfg(not(stage0))]
-pub unsafe fn transmute_copy<T, U>(src: &T) -> U {
-    let mut dest: U = unstable::intrinsics::uninit();
-    {
-        let dest_ptr: *mut u8 = rusti::transmute(&mut dest);
-        let src_ptr: *u8 = rusti::transmute(src);
-        unstable::intrinsics::memmove64(dest_ptr,
-                                        src_ptr,
-                                        sys::size_of::<U>() as u64);
-    }
-    dest
-}
-
-#[cfg(stage0)]
 pub unsafe fn transmute_copy<T, U>(src: &T) -> U {
     let mut dest: U = unstable::intrinsics::init();
     {

branches/try2/src/libcore/cell.rs

@@ -12,7 +12,6 @@
 
 use cast::transmute_mut;
 use prelude::*;
-use util::replace;
 
 /*
 A dynamic, mutable location.
@@ -49,7 +48,9 @@ pub impl<T> Cell<T> {
             fail!(~"attempt to take an empty cell");
         }
 
-        replace(&mut self.value, None).unwrap()
+        let mut value = None;
+        value <-> self.value;
+        value.unwrap()
     }
 
     /// Returns the value, failing if the cell is full.

branches/try2/src/libcore/cleanup.rs

@@ -127,7 +127,6 @@ struct AnnihilateStats {
     n_bytes_freed: uint
 }
 
-#[cfg(stage0)]
 unsafe fn each_live_alloc(read_next_before: bool,
                           f: &fn(box: *mut BoxRepr, uniq: bool) -> bool) {
     //! Walks the internal list of allocations
@@ -142,8 +141,8 @@ unsafe fn each_live_alloc(read_next_before: bool,
         let uniq =
             (*box).header.ref_count == managed::raw::RC_MANAGED_UNIQUE;
 
-        if !f(box, uniq) {
-            return;
+        if ! f(box, uniq) {
+            break
         }
 
         if read_next_before {
@@ -153,33 +152,6 @@ unsafe fn each_live_alloc(read_next_before: bool,
         }
     }
 }
-#[cfg(not(stage0))]
-unsafe fn each_live_alloc(read_next_before: bool,
-                          f: &fn(box: *mut BoxRepr, uniq: bool) -> bool) -> bool {
-    //! Walks the internal list of allocations
-
-    use managed;
-
-    let task: *Task = transmute(rustrt::rust_get_task());
-    let box = (*task).boxed_region.live_allocs;
-    let mut box: *mut BoxRepr = transmute(copy box);
-    while box != mut_null() {
-        let next_before = transmute(copy (*box).header.next);
-        let uniq =
-            (*box).header.ref_count == managed::raw::RC_MANAGED_UNIQUE;
-
-        if !f(box, uniq) {
-            return false;
-        }
-
-        if read_next_before {
-            box = next_before;
-        } else {
-            box = transmute(copy (*box).header.next);
-        }
-    }
-    return true;
-}
 
 #[cfg(unix)]
 fn debug_mem() -> bool {

branches/try2/src/libcore/comm.rs

@@ -21,7 +21,6 @@ use uint;
 use unstable;
 use vec;
 use unstable::Exclusive;
-use util::replace;
 
 use pipes::{recv, try_recv, wait_many, peek, PacketHeader};
 
@@ -150,8 +149,9 @@ impl<T: Owned> GenericChan<T> for Chan<T> {
     #[inline(always)]
     fn send(&self, x: T) {
         unsafe {
+            let mut endp = None;
             let mut self_endp = transmute_mut(&self.endp);
-            let endp = replace(self_endp, None);
+            endp <-> *self_endp;
             *self_endp = Some(streamp::client::data(endp.unwrap(), x))
         }
     }
@@ -161,8 +161,9 @@ impl<T: Owned> GenericSmartChan<T> for Chan<T> {
     #[inline(always)]
     fn try_send(&self, x: T) -> bool {
         unsafe {
+            let mut endp = None;
             let mut self_endp = transmute_mut(&self.endp);
-            let endp = replace(self_endp, None);
+            endp <-> *self_endp;
             match streamp::client::try_data(endp.unwrap(), x) {
                 Some(next) => {
                     *self_endp = Some(next);
@@ -178,8 +179,9 @@ impl<T: Owned> GenericPort<T> for Port<T> {
     #[inline(always)]
     fn recv(&self) -> T {
         unsafe {
+            let mut endp = None;
             let mut self_endp = transmute_mut(&self.endp);
-            let endp = replace(self_endp, None);
+            endp <-> *self_endp;
             let streamp::data(x, endp) = recv(endp.unwrap());
             *self_endp = Some(endp);
             x
@@ -189,8 +191,9 @@ impl<T: Owned> GenericPort<T> for Port<T> {
     #[inline(always)]
     fn try_recv(&self) -> Option<T> {
         unsafe {
+            let mut endp = None;
             let mut self_endp = transmute_mut(&self.endp);
-            let endp = replace(self_endp, None);
+            endp <-> *self_endp;
             match try_recv(endp.unwrap()) {
                 Some(streamp::data(x, endp)) => {
                     *self_endp = Some(endp);
@@ -206,13 +209,14 @@ impl<T: Owned> Peekable<T> for Port<T> {
     #[inline(always)]
     fn peek(&self) -> bool {
         unsafe {
+            let mut endp = None;
             let mut self_endp = transmute_mut(&self.endp);
-            let mut endp = replace(self_endp, None);
+            endp <-> *self_endp;
             let peek = match endp {
                 Some(ref mut endp) => peek(endp),
                 None => fail!(~"peeking empty stream")
             };
-            *self_endp = endp;
+            *self_endp <-> endp;
             peek
         }
     }
@@ -263,7 +267,8 @@ impl<T:Owned> GenericPort<T> for PortSet<T> {
             let mut result = None;
             // we have to swap the ports array so we aren't borrowing
             // aliasable mutable memory.
-            let mut ports = replace(self_ports, ~[]);
+            let mut ports = ~[];
+            ports <-> *self_ports;
             while result.is_none() && ports.len() > 0 {
                 let i = wait_many(ports);
                 match ports[i].try_recv() {
@@ -276,7 +281,7 @@ impl<T:Owned> GenericPort<T> for PortSet<T> {
                     }
                 }
             }
-            *self_ports = ports;
+            ports <-> *self_ports;
             result
         }
     }
@@ -315,7 +320,8 @@ impl<T: Owned> GenericChan<T> for SharedChan<T> {
     fn send(&self, x: T) {
         let mut xx = Some(x);
         do self.ch.with_imm |chan| {
-            let x = replace(&mut xx, None);
+            let mut x = None;
+            x <-> xx;
             chan.send(x.unwrap())
         }
     }
@@ -325,7 +331,8 @@ impl<T: Owned> GenericSmartChan<T> for SharedChan<T> {
     fn try_send(&self, x: T) -> bool {
         let mut xx = Some(x);
         do self.ch.with_imm |chan| {
-            let x = replace(&mut xx, None);
+            let mut x = None;
+            x <-> xx;
             chan.try_send(x.unwrap())
         }
     }

branches/try2/src/libcore/condition.rs

@@ -12,7 +12,7 @@
 
 use prelude::*;
 use task;
-use local_data::{local_data_pop, local_data_set};
+use task::local_data::{local_data_pop, local_data_set};
 
 // helper for transmutation, shown below.
 type RustClosure = (int, int);
@@ -24,14 +24,14 @@ pub struct Handler<T, U> {
 
 pub struct Condition<'self, T, U> {
     name: &'static str,
-    key: local_data::LocalDataKey<'self, Handler<T, U>>
+    key: task::local_data::LocalDataKey<'self, Handler<T, U>>
 }
 
 pub impl<'self, T, U> Condition<'self, T, U> {
     fn trap(&'self self, h: &'self fn(T) -> U) -> Trap<'self, T, U> {
         unsafe {
             let p : *RustClosure = ::cast::transmute(&h);
-            let prev = local_data::local_data_get(self.key);
+            let prev = task::local_data::local_data_get(self.key);
             let h = @Handler { handle: *p, prev: prev };
             Trap { cond: self, handler: h }
         }

branches/try2/src/libcore/container.rs

@@ -30,32 +30,16 @@ pub trait Map<K, V>: Mutable {
     fn contains_key(&self, key: &K) -> bool;
 
     // Visits all keys and values
-    #[cfg(stage0)]
     fn each<'a>(&'a self, f: &fn(&K, &'a V) -> bool);
-    // Visits all keys and values
-    #[cfg(not(stage0))]
-    fn each<'a>(&'a self, f: &fn(&K, &'a V) -> bool) -> bool;
 
     /// Visit all keys
-    #[cfg(stage0)]
     fn each_key(&self, f: &fn(&K) -> bool);
-    /// Visit all keys
-    #[cfg(not(stage0))]
-    fn each_key(&self, f: &fn(&K) -> bool) -> bool;
 
     /// Visit all values
-    #[cfg(stage0)]
     fn each_value<'a>(&'a self, f: &fn(&'a V) -> bool);
-    /// Visit all values
-    #[cfg(not(stage0))]
-    fn each_value<'a>(&'a self, f: &fn(&'a V) -> bool) -> bool;
 
     /// Iterate over the map and mutate the contained values
-    #[cfg(stage0)]
     fn mutate_values(&mut self, f: &fn(&K, &mut V) -> bool);
-    /// Iterate over the map and mutate the contained values
-    #[cfg(not(stage0))]
-    fn mutate_values(&mut self, f: &fn(&K, &mut V) -> bool) -> bool;
 
     /// Return a reference to the value corresponding to the key
     fn find<'a>(&'a self, key: &K) -> Option<&'a V>;
@@ -81,7 +65,6 @@ pub trait Map<K, V>: Mutable {
     fn pop(&mut self, k: &K) -> Option<V>;
 }
 
-#[cfg(stage0)]
 pub trait Set<T>: Mutable {
     /// Return true if the set contains a value
     fn contains(&self, value: &T) -> bool;
@@ -116,39 +99,3 @@ pub trait Set<T>: Mutable {
     /// Visit the values representing the union
     fn union(&self, other: &Self, f: &fn(&T) -> bool);
 }
-
-#[cfg(not(stage0))]
-pub trait Set<T>: Mutable {
-    /// Return true if the set contains a value
-    fn contains(&self, value: &T) -> bool;
-
-    /// Add a value to the set. Return true if the value was not already
-    /// present in the set.
-    fn insert(&mut self, value: T) -> bool;
-
-    /// Remove a value from the set. Return true if the value was
-    /// present in the set.
-    fn remove(&mut self, value: &T) -> bool;
-
-    /// Return true if the set has no elements in common with `other`.
-    /// This is equivalent to checking for an empty intersection.
-    fn is_disjoint(&self, other: &Self) -> bool;
-
-    /// Return true if the set is a subset of another
-    fn is_subset(&self, other: &Self) -> bool;
-
-    /// Return true if the set is a superset of another
-    fn is_superset(&self, other: &Self) -> bool;
-
-    /// Visit the values representing the difference
-    fn difference(&self, other: &Self, f: &fn(&T) -> bool) -> bool;
-
-    /// Visit the values representing the symmetric difference
-    fn symmetric_difference(&self, other: &Self, f: &fn(&T) -> bool) -> bool;
-
-    /// Visit the values representing the intersection
-    fn intersection(&self, other: &Self, f: &fn(&T) -> bool) -> bool;
-
-    /// Visit the values representing the union
-    fn union(&self, other: &Self, f: &fn(&T) -> bool) -> bool;
-}