---

yaml
---
r: 64916
b: refs/heads/snap-stage3
c: 8261f2c
h: refs/heads/master
v: v3

Author: graydon

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: ebd14c92f8b15f6d9388ea9bf6f19793a1b77a59
+refs/heads/snap-stage3: 8261f2c37c7181fb4a40e8f8d9eaebb96deea9bb
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/configure

@@ -371,6 +371,7 @@ opt docs     1 "build documentation"
 opt optimize 1 "build optimized rust code"
 opt optimize-cxx 1 "build optimized C++ code"
 opt optimize-llvm 1 "build optimized LLVM"
+opt llvm-assertions 1 "build LLVM with assertions"
 opt debug 0 "build with extra debug fun"
 opt ratchet-bench 0 "ratchet benchmarks"
 opt fast-make 0 "use .gitmodules as timestamp for submodule deps"
@@ -793,10 +794,17 @@ do
             LLVM_DBG_OPTS="--enable-debug-symbols --disable-optimized"
             # Just use LLVM straight from its build directory to
             # avoid 'make install' time
-            LLVM_INST_DIR=$LLVM_BUILD_DIR/Debug+Asserts
+            LLVM_INST_DIR=$LLVM_BUILD_DIR/Debug
         else
             LLVM_DBG_OPTS="--enable-optimized"
-            LLVM_INST_DIR=$LLVM_BUILD_DIR/Release+Asserts
+            LLVM_INST_DIR=$LLVM_BUILD_DIR/Release
+        fi
+        if [ ! -z "$CFG_DISABLE_LLVM_ASSERTIONS" ]
+        then
+            LLVM_ASSERTION_OPTS="--disable-assertions"
+        else
+            LLVM_ASSERTION_OPTS="--enable-assertions"
+            LLVM_INST_DIR=${LLVM_INST_DIR}+Asserts
         fi
     else
         msg "not reconfiguring LLVM, external LLVM root"
@@ -836,7 +844,7 @@ do
         LLVM_TARGET="--target=$t"
 
         # Disable unused LLVM features
-        LLVM_OPTS="$LLVM_DBG_OPTS --disable-docs --enable-bindings=none"
+        LLVM_OPTS="$LLVM_DBG_OPTS $LLVM_ASSERTION_OPTS --disable-docs --enable-bindings=none"
 
         case "$CFG_C_COMPILER" in
             ("ccache clang")

branches/snap-stage3/src/libextra/arc.rs

@@ -576,12 +576,16 @@ mod tests {
         let (p, c) = comm::stream();
 
         do task::spawn() || {
+            let p = comm::PortSet::new();
+            c.send(p.chan());
+
             let arc_v : Arc<~[int]> = p.recv();
 
             let v = (*arc_v.get()).clone();
             assert_eq!(v[3], 4);
         };
 
+        let c = p.recv();
         c.send(arc_v.clone());
 
         assert_eq!(arc_v.get()[2], 3);

branches/snap-stage3/src/libstd/comm.rs

@@ -14,10 +14,14 @@ Message passing
 
 #[allow(missing_doc)];
 
-use cast::transmute;
+use cast::{transmute, transmute_mut};
+use container::Container;
 use either::{Either, Left, Right};
 use kinds::Send;
-use option::{Option, Some};
+use option::{Option, Some, None};
+use uint;
+use vec::OwnedVector;
+use util::replace;
 use unstable::sync::Exclusive;
 use rtcomm = rt::comm;
 use rt;
@@ -139,6 +143,81 @@ impl<T: Send> Selectable for Port<T> {
     }
 }
 
+/// Treat many ports as one.
+#[unsafe_mut_field(ports)]
+pub struct PortSet<T> {
+    ports: ~[pipesy::Port<T>],
+}
+
+impl<T: Send> PortSet<T> {
+    pub fn new() -> PortSet<T> {
+        PortSet {
+            ports: ~[]
+        }
+    }
+
+    pub fn add(&self, port: Port<T>) {
+        let Port { inner } = port;
+        let port = match inner {
+            Left(p) => p,
+            Right(_) => fail!("PortSet not implemented")
+        };
+        unsafe {
+            let self_ports = transmute_mut(&self.ports);
+            self_ports.push(port)
+        }
+    }
+
+    pub fn chan(&self) -> Chan<T> {
+        let (po, ch) = stream();
+        self.add(po);
+        ch
+    }
+}
+
+impl<T:Send> GenericPort<T> for PortSet<T> {
+    fn try_recv(&self) -> Option<T> {
+        unsafe {
+            let self_ports = transmute_mut(&self.ports);
+            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, ~[]);
+            while result.is_none() && ports.len() > 0 {
+                let i = wait_many(ports);
+                match ports[i].try_recv() {
+                    Some(m) => {
+                        result = Some(m);
+                    }
+                    None => {
+                        // Remove this port.
+                        let _ = ports.swap_remove(i);
+                    }
+                }
+            }
+            *self_ports = ports;
+            result
+        }
+    }
+    fn recv(&self) -> T {
+        self.try_recv().expect("port_set: endpoints closed")
+    }
+}
+
+impl<T: Send> Peekable<T> for PortSet<T> {
+    fn peek(&self) -> bool {
+        // It'd be nice to use self.port.each, but that version isn't
+        // pure.
+        for uint::range(0, self.ports.len()) |i| {
+            let port: &pipesy::Port<T> = &self.ports[i];
+            if port.peek() {
+                return true;
+            }
+        }
+        false
+    }
+}
+
 /// A channel that can be shared between many senders.
 pub struct SharedChan<T> {
     inner: Either<Exclusive<pipesy::Chan<T>>, rtcomm::SharedChan<T>>

branches/snap-stage3/src/libsyntax/ext/expand.rs

@@ -683,7 +683,7 @@ pub fn std_macros() -> @str {
         ($cond:expr) => {
             if !$cond {
                 ::std::sys::FailWithCause::fail_with(
-                    ~\"assertion failed: \" + stringify!($cond), file!(), line!())
+                    \"assertion failed: \" + stringify!($cond), file!(), line!())
             }
         };
         ($cond:expr, $msg:expr) => {

branches/snap-stage3/src/test/bench/msgsend-pipes.rs

@@ -16,7 +16,7 @@
 
 extern mod extra;
 
-use std::comm::{SharedChan, Chan, stream};
+use std::comm::{PortSet, Chan, stream};
 use std::io;
 use std::os;
 use std::task;
@@ -30,7 +30,7 @@ enum request {
     stop
 }
 
-fn server(requests: &Port<request>, responses: &Chan<uint>) {
+fn server(requests: &PortSet<request>, responses: &Chan<uint>) {
     let mut count: uint = 0;
     let mut done = false;
     while !done {
@@ -50,16 +50,18 @@ fn server(requests: &Port<request>, responses: &Chan<uint>) {
 
 fn run(args: &[~str]) {
     let (from_child, to_parent) = stream();
-    let (from_parent, to_child) = stream();
-    let to_child = SharedChan::new(to_child);
+    let (from_parent_, to_child) = stream();
+    let from_parent = PortSet::new();
+    from_parent.add(from_parent_);
 
     let size = uint::from_str(args[1]).get();
     let workers = uint::from_str(args[2]).get();
     let num_bytes = 100;
     let start = extra::time::precise_time_s();
     let mut worker_results = ~[];
     for uint::range(0, workers) |_i| {
-        let to_child = to_child.clone();
+        let (from_parent_, to_child) = stream();
+        from_parent.add(from_parent_);
         let mut builder = task::task();
         builder.future_result(|r| worker_results.push(r));
         do builder.spawn {

branches/snap-stage3/src/test/bench/shootout-pfib.rs

@@ -33,24 +33,22 @@ use std::u64;
 use std::uint;
 
 fn fib(n: int) -> int {
-    fn pfib(c: &SharedChan<int>, n: int) {
+    fn pfib(c: &Chan<int>, n: int) {
         if n == 0 {
             c.send(0);
         } else if n <= 2 {
             c.send(1);
         } else {
-            let (pp, cc) = stream();
-            let cc = SharedChan::new(cc);
-            let ch = cc.clone();
+            let p = PortSet::new();
+            let ch = p.chan();
             task::spawn(|| pfib(&ch, n - 1) );
-            let ch = cc.clone();
+            let ch = p.chan();
             task::spawn(|| pfib(&ch, n - 2) );
-            c.send(pp.recv() + pp.recv());
+            c.send(p.recv() + p.recv());
         }
     }
 
     let (p, ch) = stream();
-    let ch = SharedChan::new(ch);
     let _t = task::spawn(|| pfib(&ch, n) );
     p.recv()
 }

branches/snap-stage3/src/test/codegen/iterate-over-array.cc

@@ -1,3 +1,13 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
 #include <stdlib.h>
 #include <assert.h>
 

branches/snap-stage3/src/test/codegen/iterate-over-array.rs

@@ -1,3 +1,13 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
 #[no_mangle]
 fn test(x: &[int]) -> int {
     let mut y = 0;

branches/snap-stage3/src/test/codegen/scalar-function-call.cc

@@ -1,3 +1,13 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
 #include <stdlib.h>
 
 size_t foo(size_t x) {

branches/snap-stage3/src/test/codegen/scalar-function-call.rs

@@ -1,3 +1,13 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
 fn foo(x: int) -> int {
     x * x
 }

branches/snap-stage3/src/test/codegen/small-dense-int-switch.cc

@@ -1,3 +1,13 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
 #include <stdlib.h>
 
 extern "C"

branches/snap-stage3/src/test/codegen/small-dense-int-switch.rs

@@ -1,3 +1,13 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
 #[no_mangle]
 fn test(x: int, y: int) -> int {
     match x {

branches/snap-stage3/src/test/codegen/stack-alloc-string-slice.cc

@@ -1,3 +1,13 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
 #include <stddef.h>
 
 struct slice {

branches/snap-stage3/src/test/codegen/stack-alloc-string-slice.rs

@@ -1,3 +1,13 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
 #[no_mangle]
 fn test() {
     let _x = "hello";

branches/snap-stage3/src/test/codegen/static-method-call-multi.cc

@@ -0,0 +1,27 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#include <stdlib.h>
+
+struct Struct {
+  size_t field;
+  size_t method(size_t x) {
+	return this->field + x;
+  }
+};
+
+extern "C"
+size_t test(Struct &a,
+			Struct &b,
+			Struct &c,
+			Struct &d,
+			Struct &e) {
+  return a.method(b.method(c.method(d.method(e.method(1)))));
+}