---

yaml
---
r: 15742
b: refs/heads/try
c: 18f8983
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -2,5 +2,5 @@
 refs/heads/master: 61b1875c16de39c166b0f4d54bba19f9c6777d1a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
-refs/heads/try: beb1a59f82e7689b72bf10d2a86d0d1b6060983e
+refs/heads/try: 18f898315a6b94fec729da65b536e311bc0a9f3d
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

branches/try/src/libcore/comm.rs

@@ -26,46 +26,26 @@ io::println(comm::recv(p));
 
 import either::either;
 
+export port::{};
+export chan::{};
 export send;
 export recv;
-export recv_chan;
 export peek;
+export recv_chan;
 export select2;
-export chan::{};
-export port::{};
 
-enum rust_port {}
 
-#[abi = "cdecl"]
-native mod rustrt {
-    fn rust_port_id_send<T: send>(target_port: port_id,
-                                  data: T) -> libc::uintptr_t;
-
-    fn new_port(unit_sz: libc::size_t) -> *rust_port;
-    fn del_port(po: *rust_port);
-    fn rust_port_begin_detach(po: *rust_port,
-                              yield: *libc::uintptr_t);
-    fn rust_port_end_detach(po: *rust_port);
-    fn get_port_id(po: *rust_port) -> port_id;
-    fn rust_port_size(po: *rust_port) -> libc::size_t;
-    fn port_recv(dptr: *uint, po: *rust_port,
-                 yield: *libc::uintptr_t);
-    fn rust_port_select(dptr: **rust_port, ports: **rust_port,
-                        n_ports: libc::size_t,
-                        yield: *libc::uintptr_t);
-    fn rust_port_take(port_id: port_id) -> *rust_port;
-    fn rust_port_drop(p: *rust_port);
-    fn rust_port_task(p: *rust_port) -> libc::uintptr_t;
-    fn get_task_id() -> libc::uintptr_t;
-}
+#[doc = "
+A communication endpoint that can receive messages
 
-#[abi = "rust-intrinsic"]
-native mod rusti {
-    fn init<T>() -> T;
+Each port has a unique per-task identity and may not be replicated or
+transmitted. If a port value is copied, both copies refer to the same
+port.  Ports may be associated with multiple `chan`s.
+"]
+enum port<T: send> {
+    port_t(@port_ptr<T>)
 }
 
-type port_id = int;
-
 // It's critical that this only have one variant, so it has a record
 // layout, and will work in the rust_task structure in task.rs.
 #[doc = "
@@ -82,35 +62,18 @@ enum chan<T: send> {
     chan_t(port_id)
 }
 
-resource port_ptr<T: send>(po: *rust_port) {
-    // Once the port is detached it's guaranteed not to receive further
-    // messages
-    let yield = 0u;
-    let yieldp = ptr::addr_of(yield);
-    rustrt::rust_port_begin_detach(po, yieldp);
-    if yield != 0u {
-        // Need to wait for the port to be detached
-        // FIXME: If this fails then we're going to leave our port
-        // in a bogus state. (Issue #1988)
-        task::yield();
-    }
-    rustrt::rust_port_end_detach(po);
-
-    // Drain the port so that all the still-enqueued items get dropped
-    while rustrt::rust_port_size(po) > 0u {
-       recv_::<T>(po);
-    }
-    rustrt::del_port(po);
+#[doc = "Constructs a port"]
+fn port<T: send>() -> port<T> {
+    port_t(@port_ptr(rustrt::new_port(sys::size_of::<T>())))
 }
 
 #[doc = "
-A communication endpoint that can receive messages
-
-Each port has a unique per-task identity and may not be replicated or
-transmitted. If a port value is copied, both copies refer to the same
-port.  Ports may be associated with multiple `chan`s.
+Constructs a channel. The channel is bound to the port used to
+construct it.
 "]
-enum port<T: send> { port_t(@port_ptr<T>) }
+fn chan<T: send>(p: port<T>) -> chan<T> {
+    chan_t(rustrt::get_port_id(***p))
+}
 
 #[doc = "
 Sends data over a channel. The sent data is moved into the channel,
@@ -126,17 +89,39 @@ fn send<T: send>(ch: chan<T>, -data: T) {
     task::yield();
 }
 
-#[doc = "Constructs a port"]
-fn port<T: send>() -> port<T> {
-    port_t(@port_ptr(rustrt::new_port(sys::size_of::<T>())))
-}
-
 #[doc = "
 Receive from a port.  If no data is available on the port then the
 task will block until data becomes available.
 "]
 fn recv<T: send>(p: port<T>) -> T { recv_(***p) }
 
+#[doc = "Returns true if there are messages available"]
+fn peek<T: send>(p: port<T>) -> bool {
+    rustrt::rust_port_size(***p) != 0u as libc::size_t
+}
+
+resource port_ptr<T: send>(po: *rust_port) {
+    // Once the port is detached it's guaranteed not to receive further
+    // messages
+    let yield = 0u;
+    let yieldp = ptr::addr_of(yield);
+    rustrt::rust_port_begin_detach(po, yieldp);
+    if yield != 0u {
+        // Need to wait for the port to be detached
+        // FIXME: If this fails then we're going to leave our port
+        // in a bogus state. (Issue #1988)
+        task::yield();
+    }
+    rustrt::rust_port_end_detach(po);
+
+    // Drain the port so that all the still-enqueued items get dropped
+    while rustrt::rust_port_size(po) > 0u {
+       recv_::<T>(po);
+    }
+    rustrt::del_port(po);
+}
+
+
 #[doc(hidden)]
 fn recv_chan<T: send>(ch: comm::chan<T>) -> T {
     resource portref(p: *rust_port) {
@@ -210,19 +195,46 @@ fn select2<A: send, B: send>(p_a: port<A>, p_b: port<B>)
     }
 }
 
-#[doc = "Returns true if there are messages available"]
-fn peek<T: send>(p: port<T>) -> bool {
-    rustrt::rust_port_size(***p) != 0u as libc::size_t
+
+/* Implementation details */
+
+
+enum rust_port {}
+
+type port_id = int;
+
+#[abi = "cdecl"]
+native mod rustrt {
+    fn rust_port_id_send<T: send>(target_port: port_id,
+                                  data: T) -> libc::uintptr_t;
+
+    fn new_port(unit_sz: libc::size_t) -> *rust_port;
+    fn del_port(po: *rust_port);
+    fn rust_port_begin_detach(po: *rust_port,
+                              yield: *libc::uintptr_t);
+    fn rust_port_end_detach(po: *rust_port);
+    fn get_port_id(po: *rust_port) -> port_id;
+    fn rust_port_size(po: *rust_port) -> libc::size_t;
+    fn port_recv(dptr: *uint, po: *rust_port,
+                 yield: *libc::uintptr_t);
+    fn rust_port_select(dptr: **rust_port, ports: **rust_port,
+                        n_ports: libc::size_t,
+                        yield: *libc::uintptr_t);
+    fn rust_port_take(port_id: port_id) -> *rust_port;
+    fn rust_port_drop(p: *rust_port);
+    fn rust_port_task(p: *rust_port) -> libc::uintptr_t;
+    fn get_task_id() -> libc::uintptr_t;
 }
 
-#[doc = "
-Constructs a channel. The channel is bound to the port used to
-construct it.
-"]
-fn chan<T: send>(p: port<T>) -> chan<T> {
-    chan_t(rustrt::get_port_id(***p))
+#[abi = "rust-intrinsic"]
+native mod rusti {
+    fn init<T>() -> T;
 }
 
+
+/* Tests */
+
+
 #[test]
 fn create_port_and_chan() { let p = port::<int>(); chan(p); }