+++ /dev/null
-// Copyright 2012 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.
-
-/*!
-
-Deprecated communication between tasks
-
-Communication between tasks is facilitated by ports (in the receiving
-task), and channels (in the sending task). Any number of channels may
-feed into a single port. Ports and channels may only transmit values
-of unique types; that is, values that are statically guaranteed to be
-accessed by a single 'owner' at a time. Unique types include scalars,
-vectors, strings, and records, tags, tuples and unique boxes (`~T`)
-thereof. Most notably, shared boxes (`@T`) may not be transmitted
-across channels.
-
-# Example
-
-~~~
-let po = comm::Port();
-let ch = comm::Chan(po);
-
-do task::spawn {
- comm::send(ch, "Hello, World");
-}
-
-io::println(comm::recv(p));
-~~~
-
-# Note
-
-Use of this module is deprecated in favor of `core::pipes`. In the
-`core::comm` will likely be rewritten with pipes, at which point it
-will once again be the preferred module for intertask communication.
-
-*/
-
-// NB: transitionary, de-mode-ing.
-#[forbid(deprecated_mode)];
-#[forbid(deprecated_pattern)];
-
-use either::Either;
-use libc::size_t;
-// After snapshot, change p2::addr_of => addr_of
-
-/**
- * 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.
- */
-pub enum Port<T: Owned> {
- Port_(@PortPtr<T>)
-}
-
-// 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.
-/**
- * A communication endpoint that can send messages
- *
- * Each channel is bound to a port when the channel is constructed, so
- * the destination port for a channel must exist before the channel
- * itself. Channels are weak: a channel does not keep the port it is
- * bound to alive. If a channel attempts to send data to a dead port that
- * data will be silently dropped. Channels may be duplicated and
- * themselves transmitted over other channels.
- */
-pub enum Chan<T: Owned> {
- Chan_(port_id)
-}
-
-/// Constructs a port
-pub fn Port<T: Owned>() -> Port<T> {
- Port_(@PortPtr(rustrt::new_port(sys::size_of::<T>() as size_t)))
-}
-
-impl<T: Owned> Port<T> {
-
- fn chan() -> Chan<T> { Chan(&self) }
- fn send(v: T) { self.chan().send(move v) }
- fn recv() -> T { recv(self) }
- fn peek() -> bool { peek(self) }
-
-}
-
-impl<T: Owned> Chan<T> {
-
- fn chan() -> Chan<T> { self }
- fn send(v: T) { send(self, move v) }
- fn recv() -> T { recv_chan(self) }
- fn peek() -> bool { peek_chan(self) }
-
-}
-
-/// Open a new receiving channel for the duration of a function
-pub fn listen<T: Owned, U>(f: fn(Chan<T>) -> U) -> U {
- let po = Port();
- f(po.chan())
-}
-
-struct PortPtr<T:Owned> {
- po: *rust_port,
- drop unsafe {
- do task::unkillable {
- // Once the port is detached it's guaranteed not to receive further
- // messages
- let yield = 0;
- let yieldp = ptr::addr_of(&yield);
- rustrt::rust_port_begin_detach(self.po, yieldp);
- if yield != 0 {
- // Need to wait for the port to be detached
- task::yield();
- }
- rustrt::rust_port_end_detach(self.po);
-
- // Drain the port so that all the still-enqueued items get dropped
- while rustrt::rust_port_size(self.po) > 0 as size_t {
- recv_::<T>(self.po);
- }
- rustrt::del_port(self.po);
- }
- }
-}
-
-fn PortPtr<T: Owned>(po: *rust_port) -> PortPtr<T> {
- PortPtr {
- po: po
- }
-}
-
-/**
- * Internal function for converting from a channel to a port
- *
- * # Failure
- *
- * Fails if the port is detached or dead. Fails if the port
- * is owned by a different task.
- */
-fn as_raw_port<T: Owned, U>(ch: comm::Chan<T>, f: fn(*rust_port) -> U) -> U {
-
- struct PortRef {
- p: *rust_port,
- drop {
- if !ptr::is_null(self.p) {
- rustrt::rust_port_drop(self.p);
- }
- }
- }
-
- fn PortRef(p: *rust_port) -> PortRef {
- PortRef {
- p: p
- }
- }
-
- let p = PortRef(rustrt::rust_port_take(*ch));
-
- if ptr::is_null(p.p) {
- fail ~"unable to locate port for channel"
- } else if rustrt::get_task_id() != rustrt::rust_port_task(p.p) {
- fail ~"unable to access unowned port"
- }
-
- f(p.p)
-}
-
-/**
- * Constructs a channel. The channel is bound to the port used to
- * construct it.
- */
-pub fn Chan<T: Owned>(p: &Port<T>) -> Chan<T> {
- Chan_(rustrt::get_port_id((**p).po))
-}
-
-/**
- * Sends data over a channel. The sent data is moved into the channel,
- * whereupon the caller loses access to it.
- */
-pub fn send<T: Owned>(ch: Chan<T>, data: T) {
- let Chan_(p) = ch;
- let data_ptr = ptr::addr_of(&data) as *();
- let res = rustrt::rust_port_id_send(p, data_ptr);
- if res != 0 unsafe {
- // Data sent successfully
- cast::forget(move data);
- }
- task::yield();
-}
-
-/**
- * Receive from a port. If no data is available on the port then the
- * task will block until data becomes available.
- */
-pub fn recv<T: Owned>(p: Port<T>) -> T { recv_((**p).po) }
-
-/// Returns true if there are messages available
-pub fn peek<T: Owned>(p: Port<T>) -> bool { peek_((**p).po) }
-
-#[doc(hidden)]
-pub fn recv_chan<T: Owned>(ch: comm::Chan<T>) -> T {
- as_raw_port(ch, |x|recv_(x))
-}
-
-fn peek_chan<T: Owned>(ch: comm::Chan<T>) -> bool {
- as_raw_port(ch, |x|peek_(x))
-}
-
-/// Receive on a raw port pointer
-fn recv_<T: Owned>(p: *rust_port) -> T {
- let yield = 0;
- let yieldp = ptr::addr_of(&yield);
- let mut res;
- res = rusti::init::<T>();
- rustrt::port_recv(ptr::addr_of(&res) as *uint, p, yieldp);
-
- if yield != 0 {
- // Data isn't available yet, so res has not been initialized.
- task::yield();
- } else {
- // In the absence of compiler-generated preemption points
- // this is a good place to yield
- task::yield();
- }
- move res
-}
-
-fn peek_(p: *rust_port) -> bool {
- // Yield here before we check to see if someone sent us a message
- // FIXME #524, if the compiler generates yields, we don't need this
- task::yield();
- rustrt::rust_port_size(p) != 0 as libc::size_t
-}
-
-/// Receive on one of two ports
-pub fn select2<A: Owned, B: Owned>(p_a: Port<A>, p_b: Port<B>)
- -> Either<A, B> {
- let ports = ~[(**p_a).po, (**p_b).po];
- let yield = 0, yieldp = ptr::addr_of(&yield);
-
- let mut resport: *rust_port;
- resport = rusti::init::<*rust_port>();
- do vec::as_imm_buf(ports) |ports, n_ports| {
- rustrt::rust_port_select(ptr::addr_of(&resport), ports,
- n_ports as size_t, yieldp);
- }
-
- if yield != 0 {
- // Wait for data
- task::yield();
- } else {
- // As in recv, this is a good place to yield anyway until
- // the compiler generates yield calls
- task::yield();
- }
-
- // Now we know the port we're supposed to receive from
- assert resport != ptr::null();
-
- if resport == (**p_a).po {
- either::Left(recv(p_a))
- } else if resport == (**p_b).po {
- either::Right(recv(p_b))
- } else {
- fail ~"unexpected result from rust_port_select";
- }
-}
-
-
-/* Implementation details */
-
-#[allow(non_camel_case_types)] // runtime type
-enum rust_port {}
-
-#[allow(non_camel_case_types)] // runtime type
-type port_id = int;
-
-#[abi = "cdecl"]
-extern mod rustrt {
- fn rust_port_id_send(target_port: port_id, data: *()) -> 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;
-}
-
-#[abi = "rust-intrinsic"]
-extern mod rusti {
- fn init<T>() -> T;
-}
-
-
-/* Tests */
-
-
-#[test]
-fn create_port_and_chan() { let p = Port::<int>(); Chan(&p); }
-
-#[test]
-fn send_int() {
- let p = Port::<int>();
- let c = Chan(&p);
- send(c, 22);
-}
-
-#[test]
-fn send_recv_fn() {
- let p = Port::<int>();
- let c = Chan::<int>(&p);
- send(c, 42);
- assert (recv(p) == 42);
-}
-
-#[test]
-fn send_recv_fn_infer() {
- let p = Port();
- let c = Chan(&p);
- send(c, 42);
- assert (recv(p) == 42);
-}
-
-#[test]
-fn chan_chan_infer() {
- let p = Port(), p2 = Port::<int>();
- let c = Chan(&p);
- send(c, Chan(&p2));
- recv(p);
-}
-
-#[test]
-fn chan_chan() {
- let p = Port::<Chan<int>>(), p2 = Port::<int>();
- let c = Chan(&p);
- send(c, Chan(&p2));
- recv(p);
-}
-
-#[test]
-fn test_peek() {
- let po = Port();
- let ch = Chan(&po);
- assert !peek(po);
- send(ch, ());
- assert peek(po);
- recv(po);
- assert !peek(po);
-}
-
-#[test]
-fn test_select2_available() {
- let po_a = Port();
- let po_b = Port();
- let ch_a = Chan(&po_a);
- let ch_b = Chan(&po_b);
-
- send(ch_a, ~"a");
-
- assert select2(po_a, po_b) == either::Left(~"a");
-
- send(ch_b, ~"b");
-
- assert select2(po_a, po_b) == either::Right(~"b");
-}
-
-#[test]
-fn test_select2_rendezvous() {
- let po_a = Port();
- let po_b = Port();
- let ch_a = Chan(&po_a);
- let ch_b = Chan(&po_b);
-
- for iter::repeat(10) {
- do task::spawn {
- for iter::repeat(10) { task::yield() }
- send(ch_a, ~"a");
- };
-
- assert select2(po_a, po_b) == either::Left(~"a");
-
- do task::spawn {
- for iter::repeat(10) { task::yield() }
- send(ch_b, ~"b");
- };
-
- assert select2(po_a, po_b) == either::Right(~"b");
- }
-}
-
-#[test]
-fn test_select2_stress() {
- let po_a = Port();
- let po_b = Port();
- let ch_a = Chan(&po_a);
- let ch_b = Chan(&po_b);
-
- let msgs = 100;
- let times = 4u;
-
- for iter::repeat(times) {
- do task::spawn {
- for iter::repeat(msgs) {
- send(ch_a, ~"a")
- }
- };
- do task::spawn {
- for iter::repeat(msgs) {
- send(ch_b, ~"b")
- }
- };
- }
-
- let mut as_ = 0;
- let mut bs = 0;
- for iter::repeat(msgs * times * 2u) {
- match select2(po_a, po_b) {
- either::Left(~"a") => as_ += 1,
- either::Right(~"b") => bs += 1,
- _ => fail ~"test_select_2_stress failed"
- }
- }
-
- assert as_ == 400;
- assert bs == 400;
-}
-
-#[test]
-fn test_recv_chan() {
- let po = Port();
- let ch = Chan(&po);
- send(ch, ~"flower");
- assert recv_chan(ch) == ~"flower";
-}
-
-#[test]
-#[should_fail]
-#[ignore(cfg(windows))]
-fn test_recv_chan_dead() {
- let ch = Chan(&Port());
- send(ch, ~"flower");
- recv_chan(ch);
-}
-
-#[test]
-#[ignore(cfg(windows))]
-fn test_recv_chan_wrong_task() {
- let po = Port();
- let ch = Chan(&po);
- send(ch, ~"flower");
- assert result::is_err(&task::try(||
- recv_chan(ch)
- ))
-}
-
-#[test]
-fn test_port_send() {
- let po = Port();
- po.send(());
- po.recv();
-}
-
-#[test]
-fn test_chan_peek() {
- let po = Port();
- let ch = po.chan();
- ch.send(());
- assert ch.peek();
-}
-
-#[test]
-fn test_listen() {
- do listen |parent| {
- do task::spawn {
- parent.send(~"oatmeal-salad");
- }
- assert parent.recv() == ~"oatmeal-salad";
- }
-}
-
-#[test]
-#[ignore(cfg(windows))]
-fn test_port_detach_fail() {
- for iter::repeat(100) {
- do task::spawn_unlinked {
- let po = Port();
- let ch = po.chan();
-
- do task::spawn {
- fail;
- }
-
- do task::spawn {
- ch.send(());
- }
- }
- }
-}
/* Tasks and communication */
-pub mod comm;
+pub mod oldcomm;
#[path = "task/mod.rs"]
pub mod task;
pub mod pipes;
--- /dev/null
+// Copyright 2012 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.
+
+/*!
+
+Deprecated communication between tasks
+
+Communication between tasks is facilitated by ports (in the receiving
+task), and channels (in the sending task). Any number of channels may
+feed into a single port. Ports and channels may only transmit values
+of unique types; that is, values that are statically guaranteed to be
+accessed by a single 'owner' at a time. Unique types include scalars,
+vectors, strings, and records, tags, tuples and unique boxes (`~T`)
+thereof. Most notably, shared boxes (`@T`) may not be transmitted
+across channels.
+
+# Example
+
+~~~
+let po = comm::Port();
+let ch = comm::Chan(po);
+
+do task::spawn {
+ comm::send(ch, "Hello, World");
+}
+
+io::println(comm::recv(p));
+~~~
+
+# Note
+
+Use of this module is deprecated in favor of `core::pipes`. In the
+`core::comm` will likely be rewritten with pipes, at which point it
+will once again be the preferred module for intertask communication.
+
+*/
+
+// NB: transitionary, de-mode-ing.
+#[forbid(deprecated_mode)];
+#[forbid(deprecated_pattern)];
+
+use either::Either;
+use libc::size_t;
+// After snapshot, change p2::addr_of => addr_of
+
+/**
+ * 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.
+ */
+pub enum Port<T: Owned> {
+ Port_(@PortPtr<T>)
+}
+
+// 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.
+/**
+ * A communication endpoint that can send messages
+ *
+ * Each channel is bound to a port when the channel is constructed, so
+ * the destination port for a channel must exist before the channel
+ * itself. Channels are weak: a channel does not keep the port it is
+ * bound to alive. If a channel attempts to send data to a dead port that
+ * data will be silently dropped. Channels may be duplicated and
+ * themselves transmitted over other channels.
+ */
+pub enum Chan<T: Owned> {
+ Chan_(port_id)
+}
+
+/// Constructs a port
+pub fn Port<T: Owned>() -> Port<T> {
+ Port_(@PortPtr(rustrt::new_port(sys::size_of::<T>() as size_t)))
+}
+
+impl<T: Owned> Port<T> {
+
+ fn chan() -> Chan<T> { Chan(&self) }
+ fn send(v: T) { self.chan().send(move v) }
+ fn recv() -> T { recv(self) }
+ fn peek() -> bool { peek(self) }
+
+}
+
+impl<T: Owned> Chan<T> {
+
+ fn chan() -> Chan<T> { self }
+ fn send(v: T) { send(self, move v) }
+ fn recv() -> T { recv_chan(self) }
+ fn peek() -> bool { peek_chan(self) }
+
+}
+
+/// Open a new receiving channel for the duration of a function
+pub fn listen<T: Owned, U>(f: fn(Chan<T>) -> U) -> U {
+ let po = Port();
+ f(po.chan())
+}
+
+struct PortPtr<T:Owned> {
+ po: *rust_port,
+ drop unsafe {
+ do task::unkillable {
+ // Once the port is detached it's guaranteed not to receive further
+ // messages
+ let yield = 0;
+ let yieldp = ptr::addr_of(&yield);
+ rustrt::rust_port_begin_detach(self.po, yieldp);
+ if yield != 0 {
+ // Need to wait for the port to be detached
+ task::yield();
+ }
+ rustrt::rust_port_end_detach(self.po);
+
+ // Drain the port so that all the still-enqueued items get dropped
+ while rustrt::rust_port_size(self.po) > 0 as size_t {
+ recv_::<T>(self.po);
+ }
+ rustrt::del_port(self.po);
+ }
+ }
+}
+
+fn PortPtr<T: Owned>(po: *rust_port) -> PortPtr<T> {
+ PortPtr {
+ po: po
+ }
+}
+
+/**
+ * Internal function for converting from a channel to a port
+ *
+ * # Failure
+ *
+ * Fails if the port is detached or dead. Fails if the port
+ * is owned by a different task.
+ */
+fn as_raw_port<T: Owned, U>(ch: Chan<T>, f: fn(*rust_port) -> U) -> U {
+
+ struct PortRef {
+ p: *rust_port,
+ drop {
+ if !ptr::is_null(self.p) {
+ rustrt::rust_port_drop(self.p);
+ }
+ }
+ }
+
+ fn PortRef(p: *rust_port) -> PortRef {
+ PortRef {
+ p: p
+ }
+ }
+
+ let p = PortRef(rustrt::rust_port_take(*ch));
+
+ if ptr::is_null(p.p) {
+ fail ~"unable to locate port for channel"
+ } else if rustrt::get_task_id() != rustrt::rust_port_task(p.p) {
+ fail ~"unable to access unowned port"
+ }
+
+ f(p.p)
+}
+
+/**
+ * Constructs a channel. The channel is bound to the port used to
+ * construct it.
+ */
+pub fn Chan<T: Owned>(p: &Port<T>) -> Chan<T> {
+ Chan_(rustrt::get_port_id((**p).po))
+}
+
+/**
+ * Sends data over a channel. The sent data is moved into the channel,
+ * whereupon the caller loses access to it.
+ */
+pub fn send<T: Owned>(ch: Chan<T>, data: T) {
+ let Chan_(p) = ch;
+ let data_ptr = ptr::addr_of(&data) as *();
+ let res = rustrt::rust_port_id_send(p, data_ptr);
+ if res != 0 unsafe {
+ // Data sent successfully
+ cast::forget(move data);
+ }
+ task::yield();
+}
+
+/**
+ * Receive from a port. If no data is available on the port then the
+ * task will block until data becomes available.
+ */
+pub fn recv<T: Owned>(p: Port<T>) -> T { recv_((**p).po) }
+
+/// Returns true if there are messages available
+pub fn peek<T: Owned>(p: Port<T>) -> bool { peek_((**p).po) }
+
+#[doc(hidden)]
+pub fn recv_chan<T: Owned>(ch: Chan<T>) -> T {
+ as_raw_port(ch, |x|recv_(x))
+}
+
+fn peek_chan<T: Owned>(ch: Chan<T>) -> bool {
+ as_raw_port(ch, |x|peek_(x))
+}
+
+/// Receive on a raw port pointer
+fn recv_<T: Owned>(p: *rust_port) -> T {
+ let yield = 0;
+ let yieldp = ptr::addr_of(&yield);
+ let mut res;
+ res = rusti::init::<T>();
+ rustrt::port_recv(ptr::addr_of(&res) as *uint, p, yieldp);
+
+ if yield != 0 {
+ // Data isn't available yet, so res has not been initialized.
+ task::yield();
+ } else {
+ // In the absence of compiler-generated preemption points
+ // this is a good place to yield
+ task::yield();
+ }
+ move res
+}
+
+fn peek_(p: *rust_port) -> bool {
+ // Yield here before we check to see if someone sent us a message
+ // FIXME #524, if the compiler generates yields, we don't need this
+ task::yield();
+ rustrt::rust_port_size(p) != 0 as libc::size_t
+}
+
+/// Receive on one of two ports
+pub fn select2<A: Owned, B: Owned>(p_a: Port<A>, p_b: Port<B>)
+ -> Either<A, B> {
+ let ports = ~[(**p_a).po, (**p_b).po];
+ let yield = 0, yieldp = ptr::addr_of(&yield);
+
+ let mut resport: *rust_port;
+ resport = rusti::init::<*rust_port>();
+ do vec::as_imm_buf(ports) |ports, n_ports| {
+ rustrt::rust_port_select(ptr::addr_of(&resport), ports,
+ n_ports as size_t, yieldp);
+ }
+
+ if yield != 0 {
+ // Wait for data
+ task::yield();
+ } else {
+ // As in recv, this is a good place to yield anyway until
+ // the compiler generates yield calls
+ task::yield();
+ }
+
+ // Now we know the port we're supposed to receive from
+ assert resport != ptr::null();
+
+ if resport == (**p_a).po {
+ either::Left(recv(p_a))
+ } else if resport == (**p_b).po {
+ either::Right(recv(p_b))
+ } else {
+ fail ~"unexpected result from rust_port_select";
+ }
+}
+
+
+/* Implementation details */
+
+#[allow(non_camel_case_types)] // runtime type
+enum rust_port {}
+
+#[allow(non_camel_case_types)] // runtime type
+type port_id = int;
+
+#[abi = "cdecl"]
+extern mod rustrt {
+ fn rust_port_id_send(target_port: port_id, data: *()) -> 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;
+}
+
+#[abi = "rust-intrinsic"]
+extern mod rusti {
+ fn init<T>() -> T;
+}
+
+
+/* Tests */
+
+
+#[test]
+fn create_port_and_chan() { let p = Port::<int>(); Chan(&p); }
+
+#[test]
+fn send_int() {
+ let p = Port::<int>();
+ let c = Chan(&p);
+ send(c, 22);
+}
+
+#[test]
+fn send_recv_fn() {
+ let p = Port::<int>();
+ let c = Chan::<int>(&p);
+ send(c, 42);
+ assert (recv(p) == 42);
+}
+
+#[test]
+fn send_recv_fn_infer() {
+ let p = Port();
+ let c = Chan(&p);
+ send(c, 42);
+ assert (recv(p) == 42);
+}
+
+#[test]
+fn chan_chan_infer() {
+ let p = Port(), p2 = Port::<int>();
+ let c = Chan(&p);
+ send(c, Chan(&p2));
+ recv(p);
+}
+
+#[test]
+fn chan_chan() {
+ let p = Port::<Chan<int>>(), p2 = Port::<int>();
+ let c = Chan(&p);
+ send(c, Chan(&p2));
+ recv(p);
+}
+
+#[test]
+fn test_peek() {
+ let po = Port();
+ let ch = Chan(&po);
+ assert !peek(po);
+ send(ch, ());
+ assert peek(po);
+ recv(po);
+ assert !peek(po);
+}
+
+#[test]
+fn test_select2_available() {
+ let po_a = Port();
+ let po_b = Port();
+ let ch_a = Chan(&po_a);
+ let ch_b = Chan(&po_b);
+
+ send(ch_a, ~"a");
+
+ assert select2(po_a, po_b) == either::Left(~"a");
+
+ send(ch_b, ~"b");
+
+ assert select2(po_a, po_b) == either::Right(~"b");
+}
+
+#[test]
+fn test_select2_rendezvous() {
+ let po_a = Port();
+ let po_b = Port();
+ let ch_a = Chan(&po_a);
+ let ch_b = Chan(&po_b);
+
+ for iter::repeat(10) {
+ do task::spawn {
+ for iter::repeat(10) { task::yield() }
+ send(ch_a, ~"a");
+ };
+
+ assert select2(po_a, po_b) == either::Left(~"a");
+
+ do task::spawn {
+ for iter::repeat(10) { task::yield() }
+ send(ch_b, ~"b");
+ };
+
+ assert select2(po_a, po_b) == either::Right(~"b");
+ }
+}
+
+#[test]
+fn test_select2_stress() {
+ let po_a = Port();
+ let po_b = Port();
+ let ch_a = Chan(&po_a);
+ let ch_b = Chan(&po_b);
+
+ let msgs = 100;
+ let times = 4u;
+
+ for iter::repeat(times) {
+ do task::spawn {
+ for iter::repeat(msgs) {
+ send(ch_a, ~"a")
+ }
+ };
+ do task::spawn {
+ for iter::repeat(msgs) {
+ send(ch_b, ~"b")
+ }
+ };
+ }
+
+ let mut as_ = 0;
+ let mut bs = 0;
+ for iter::repeat(msgs * times * 2u) {
+ match select2(po_a, po_b) {
+ either::Left(~"a") => as_ += 1,
+ either::Right(~"b") => bs += 1,
+ _ => fail ~"test_select_2_stress failed"
+ }
+ }
+
+ assert as_ == 400;
+ assert bs == 400;
+}
+
+#[test]
+fn test_recv_chan() {
+ let po = Port();
+ let ch = Chan(&po);
+ send(ch, ~"flower");
+ assert recv_chan(ch) == ~"flower";
+}
+
+#[test]
+#[should_fail]
+#[ignore(cfg(windows))]
+fn test_recv_chan_dead() {
+ let ch = Chan(&Port());
+ send(ch, ~"flower");
+ recv_chan(ch);
+}
+
+#[test]
+#[ignore(cfg(windows))]
+fn test_recv_chan_wrong_task() {
+ let po = Port();
+ let ch = Chan(&po);
+ send(ch, ~"flower");
+ assert result::is_err(&task::try(||
+ recv_chan(ch)
+ ))
+}
+
+#[test]
+fn test_port_send() {
+ let po = Port();
+ po.send(());
+ po.recv();
+}
+
+#[test]
+fn test_chan_peek() {
+ let po = Port();
+ let ch = po.chan();
+ ch.send(());
+ assert ch.peek();
+}
+
+#[test]
+fn test_listen() {
+ do listen |parent| {
+ do task::spawn {
+ parent.send(~"oatmeal-salad");
+ }
+ assert parent.recv() == ~"oatmeal-salad";
+ }
+}
+
+#[test]
+#[ignore(cfg(windows))]
+fn test_port_detach_fail() {
+ for iter::repeat(100) {
+ do task::spawn_unlinked {
+ let po = Port();
+ let ch = po.chan();
+
+ do task::spawn {
+ fail;
+ }
+
+ do task::spawn {
+ ch.send(());
+ }
+ }
+ }
+}
}
enum Msg {
- MsgGetEnv(~str, comm::Chan<Option<~str>>),
- MsgSetEnv(~str, ~str, comm::Chan<()>),
- MsgEnv(comm::Chan<~[(~str,~str)]>)
+ MsgGetEnv(~str, oldcomm::Chan<Option<~str>>),
+ MsgSetEnv(~str, ~str, oldcomm::Chan<()>),
+ MsgEnv(oldcomm::Chan<~[(~str,~str)]>)
}
pub fn getenv(n: &str) -> Option<~str> {
let env_ch = get_global_env_chan();
- let po = comm::Port();
- comm::send(env_ch, MsgGetEnv(str::from_slice(n),
- comm::Chan(&po)));
- comm::recv(po)
+ let po = oldcomm::Port();
+ oldcomm::send(env_ch, MsgGetEnv(str::from_slice(n),
+ oldcomm::Chan(&po)));
+ oldcomm::recv(po)
}
pub fn setenv(n: &str, v: &str) {
let env_ch = get_global_env_chan();
- let po = comm::Port();
- comm::send(env_ch, MsgSetEnv(str::from_slice(n),
+ let po = oldcomm::Port();
+ oldcomm::send(env_ch, MsgSetEnv(str::from_slice(n),
str::from_slice(v),
- comm::Chan(&po)));
- comm::recv(po)
+ oldcomm::Chan(&po)));
+ oldcomm::recv(po)
}
pub fn env() -> ~[(~str,~str)] {
let env_ch = get_global_env_chan();
- let po = comm::Port();
- comm::send(env_ch, MsgEnv(comm::Chan(&po)));
- comm::recv(po)
+ let po = oldcomm::Port();
+ oldcomm::send(env_ch, MsgEnv(oldcomm::Chan(&po)));
+ oldcomm::recv(po)
}
- fn get_global_env_chan() -> comm::Chan<Msg> {
+ fn get_global_env_chan() -> oldcomm::Chan<Msg> {
let global_ptr = rustrt::rust_global_env_chan_ptr();
unsafe {
private::chan_from_global_ptr(global_ptr, || {
}
}
- fn global_env_task(msg_po: comm::Port<Msg>) {
+ fn global_env_task(msg_po: oldcomm::Port<Msg>) {
unsafe {
do private::weaken_task |weak_po| {
loop {
- match comm::select2(msg_po, weak_po) {
+ match oldcomm::select2(msg_po, weak_po) {
either::Left(MsgGetEnv(ref n, resp_ch)) => {
- comm::send(resp_ch, impl_::getenv(*n))
+ oldcomm::send(resp_ch, impl_::getenv(*n))
}
either::Left(MsgSetEnv(ref n, ref v, resp_ch)) => {
- comm::send(resp_ch, impl_::setenv(*n, *v))
+ oldcomm::send(resp_ch, impl_::setenv(*n, *v))
}
either::Left(MsgEnv(resp_ch)) => {
- comm::send(resp_ch, impl_::env())
+ oldcomm::send(resp_ch, impl_::env())
}
either::Right(_) => break
}
pub unsafe fn chan_from_global_ptr<T: Owned>(
global: GlobalPtr,
task_fn: fn() -> task::TaskBuilder,
- f: fn~(comm::Port<T>)
-) -> comm::Chan<T> {
+ f: fn~(oldcomm::Port<T>)
+) -> oldcomm::Chan<T> {
enum Msg {
Proceed,
let (setup2_po, setup2_ch) = pipes::stream();
// XXX: Ugly type inference hints
- let setup1_po: pipes::Port<comm::Chan<T>> = setup1_po;
+ let setup1_po: pipes::Port<oldcomm::Chan<T>> = setup1_po;
let setup2_po: pipes::Port<Msg> = setup2_po;
do task_fn().spawn |move f, move setup1_ch, move setup2_po| {
- let po = comm::Port::<T>();
- let ch = comm::Chan(&po);
+ let po = oldcomm::Port::<T>();
+ let ch = oldcomm::Chan(&po);
setup1_ch.send(ch);
// Wait to hear if we are the official instance of
// Create the global channel, attached to a new task
let ch = unsafe {
do chan_from_global_ptr(globchanp, task::task) |po| {
- let ch = comm::recv(po);
- comm::send(ch, true);
- let ch = comm::recv(po);
- comm::send(ch, true);
+ let ch = oldcomm::recv(po);
+ oldcomm::send(ch, true);
+ let ch = oldcomm::recv(po);
+ oldcomm::send(ch, true);
}
};
// Talk to it
- let po = comm::Port();
- comm::send(ch, comm::Chan(&po));
- assert comm::recv(po) == true;
+ let po = oldcomm::Port();
+ oldcomm::send(ch, oldcomm::Chan(&po));
+ assert oldcomm::recv(po) == true;
// This one just reuses the previous channel
let ch = unsafe {
do chan_from_global_ptr(globchanp, task::task) |po| {
- let ch = comm::recv(po);
- comm::send(ch, false);
+ let ch = oldcomm::recv(po);
+ oldcomm::send(ch, false);
}
};
// Talk to the original global task
- let po = comm::Port();
- comm::send(ch, comm::Chan(&po));
- assert comm::recv(po) == true;
+ let po = oldcomm::Port();
+ oldcomm::send(ch, oldcomm::Chan(&po));
+ assert oldcomm::recv(po) == true;
}
#[test]
let globchan = 0;
let globchanp = ptr::addr_of(&globchan);
- let resultpo = comm::Port();
- let resultch = comm::Chan(&resultpo);
+ let resultpo = oldcomm::Port();
+ let resultch = oldcomm::Chan(&resultpo);
// Spawn a bunch of tasks that all want to compete to
// create the global channel
globchanp, task::task) |po| {
for uint::range(0, 10) |_j| {
- let ch = comm::recv(po);
- comm::send(ch, {i});
+ let ch = oldcomm::recv(po);
+ oldcomm::send(ch, {i});
}
}
};
- let po = comm::Port();
- comm::send(ch, comm::Chan(&po));
+ let po = oldcomm::Port();
+ oldcomm::send(ch, oldcomm::Chan(&po));
// We are The winner if our version of the
// task was installed
- let winner = comm::recv(po);
- comm::send(resultch, winner == i);
+ let winner = oldcomm::recv(po);
+ oldcomm::send(resultch, winner == i);
}
}
// There should be only one winner
let mut winners = 0u;
for uint::range(0u, 10u) |_i| {
- let res = comm::recv(resultpo);
+ let res = oldcomm::recv(resultpo);
if res { winners += 1u };
}
assert winners == 1u;
* * Weak tasks must not be supervised. A supervised task keeps
* a reference to its parent, so the parent will not die.
*/
-pub unsafe fn weaken_task(f: fn(comm::Port<()>)) {
- let po = comm::Port();
- let ch = comm::Chan(&po);
+pub unsafe fn weaken_task(f: fn(oldcomm::Port<()>)) {
+ let po = oldcomm::Port();
+ let ch = oldcomm::Chan(&po);
unsafe {
rustrt::rust_task_weaken(cast::reinterpret_cast(&ch));
}
f(po);
struct Unweaken {
- ch: comm::Chan<()>,
+ ch: oldcomm::Chan<()>,
drop unsafe {
rustrt::rust_task_unweaken(cast::reinterpret_cast(&self.ch));
}
}
- fn Unweaken(ch: comm::Chan<()>) -> Unweaken {
+ fn Unweaken(ch: oldcomm::Chan<()>) -> Unweaken {
Unweaken {
ch: ch
}
do task::spawn_unlinked {
unsafe {
do weaken_task |po| {
- comm::recv(po);
+ oldcomm::recv(po);
}
}
}
unsafe {
do weaken_task |po| {
// Wait for it to tell us to die
- comm::recv(po);
+ oldcomm::recv(po);
}
}
}
// in parallel so we don't deadlock while blocking on one
// or the other. FIXME (#2625): Surely there's a much more
// clever way to do this.
- let p = comm::Port();
- let ch = comm::Chan(&p);
+ let p = oldcomm::Port();
+ let ch = oldcomm::Chan(&p);
do task::spawn_sched(task::SingleThreaded) {
let errput = readclose(pipe_err.in);
- comm::send(ch, (2, move errput));
+ oldcomm::send(ch, (2, move errput));
};
do task::spawn_sched(task::SingleThreaded) {
let output = readclose(pipe_out.in);
- comm::send(ch, (1, move output));
+ oldcomm::send(ch, (1, move output));
};
let status = run::waitpid(pid);
let mut errs = ~"";
let mut outs = ~"";
let mut count = 2;
while count > 0 {
- let stream = comm::recv(p);
+ let stream = oldcomm::recv(p);
match stream {
(1, copy s) => {
outs = move s;
* Fails if a future_result was already set for this task.
*/
fn try<T: Owned>(f: fn~() -> T) -> Result<T,()> {
- let po = comm::Port();
- let ch = comm::Chan(&po);
+ let po = oldcomm::Port();
+ let ch = oldcomm::Chan(&po);
let mut result = None;
let fr_task_builder = self.future_result(|+r| {
result = Some(move r);
});
do fr_task_builder.spawn |move f| {
- comm::send(ch, f());
+ oldcomm::send(ch, f());
}
match option::unwrap(move result).recv() {
- Success => result::Ok(comm::recv(po)),
+ Success => result::Ok(oldcomm::recv(po)),
Failure => result::Err(())
}
}
#[test] #[ignore(cfg(windows))]
fn test_spawn_unlinked_unsup_no_fail_down() { // grandchild sends on a port
- let po = comm::Port();
- let ch = comm::Chan(&po);
+ let po = oldcomm::Port();
+ let ch = oldcomm::Chan(&po);
do spawn_unlinked {
do spawn_unlinked {
// Give middle task a chance to fail-but-not-kill-us.
for iter::repeat(16) { task::yield(); }
- comm::send(ch, ()); // If killed first, grandparent hangs.
+ oldcomm::send(ch, ()); // If killed first, grandparent hangs.
}
fail; // Shouldn't kill either (grand)parent or (grand)child.
}
- comm::recv(po);
+ oldcomm::recv(po);
}
#[test] #[ignore(cfg(windows))]
fn test_spawn_unlinked_unsup_no_fail_up() { // child unlinked fails
#[test] #[should_fail] #[ignore(cfg(windows))]
fn test_spawn_linked_sup_fail_up() { // child fails; parent fails
- let po = comm::Port::<()>();
- let _ch = comm::Chan(&po);
+ let po = oldcomm::Port::<()>();
+ let _ch = oldcomm::Chan(&po);
// Unidirectional "parenting" shouldn't override bidirectional linked.
// We have to cheat with opts - the interface doesn't support them because
// they don't make sense (redundant with task().supervised()).
.. b0
};
do b1.spawn { fail; }
- comm::recv(po); // We should get punted awake
+ oldcomm::recv(po); // We should get punted awake
}
#[test] #[should_fail] #[ignore(cfg(windows))]
fn test_spawn_linked_sup_fail_down() { // parent fails; child fails
}
#[test] #[should_fail] #[ignore(cfg(windows))]
fn test_spawn_linked_unsup_fail_up() { // child fails; parent fails
- let po = comm::Port::<()>();
- let _ch = comm::Chan(&po);
+ let po = oldcomm::Port::<()>();
+ let _ch = oldcomm::Chan(&po);
// Default options are to spawn linked & unsupervised.
do spawn { fail; }
- comm::recv(po); // We should get punted awake
+ oldcomm::recv(po); // We should get punted awake
}
#[test] #[should_fail] #[ignore(cfg(windows))]
fn test_spawn_linked_unsup_fail_down() { // parent fails; child fails
#[test]
fn test_run_basic() {
- let po = comm::Port();
- let ch = comm::Chan(&po);
+ let po = oldcomm::Port();
+ let ch = oldcomm::Chan(&po);
do task().spawn {
- comm::send(ch, ());
+ oldcomm::send(ch, ());
}
- comm::recv(po);
+ oldcomm::recv(po);
}
#[test]
fn test_add_wrapper() {
- let po = comm::Port();
- let ch = comm::Chan(&po);
+ let po = oldcomm::Port();
+ let ch = oldcomm::Chan(&po);
let b0 = task();
let b1 = do b0.add_wrapper |body| {
fn~(move body) {
body();
- comm::send(ch, ());
+ oldcomm::send(ch, ());
}
};
do b1.spawn { }
- comm::recv(po);
+ oldcomm::recv(po);
}
#[test]
#[test]
fn test_spawn_sched() {
- let po = comm::Port();
- let ch = comm::Chan(&po);
+ let po = oldcomm::Port();
+ let ch = oldcomm::Chan(&po);
- fn f(i: int, ch: comm::Chan<()>) {
+ fn f(i: int, ch: oldcomm::Chan<()>) {
let parent_sched_id = rt::rust_get_sched_id();
do spawn_sched(SingleThreaded) {
assert parent_sched_id != child_sched_id;
if (i == 0) {
- comm::send(ch, ());
+ oldcomm::send(ch, ());
} else {
f(i - 1, ch);
}
}
f(10, ch);
- comm::recv(po);
+ oldcomm::recv(po);
}
#[test]
fn test_spawn_sched_childs_on_same_sched() {
- let po = comm::Port();
- let ch = comm::Chan(&po);
+ let po = oldcomm::Port();
+ let ch = oldcomm::Chan(&po);
do spawn_sched(SingleThreaded) {
let parent_sched_id = rt::rust_get_sched_id();
let child_sched_id = rt::rust_get_sched_id();
// This should be on the same scheduler
assert parent_sched_id == child_sched_id;
- comm::send(ch, ());
+ oldcomm::send(ch, ());
};
};
- comm::recv(po);
+ oldcomm::recv(po);
}
#[nolink]
// without affecting other schedulers
for iter::repeat(20u) {
- let start_po = comm::Port();
- let start_ch = comm::Chan(&start_po);
- let fin_po = comm::Port();
- let fin_ch = comm::Chan(&fin_po);
+ let start_po = oldcomm::Port();
+ let start_ch = oldcomm::Chan(&start_po);
+ let fin_po = oldcomm::Port();
+ let fin_ch = oldcomm::Chan(&fin_po);
let lock = testrt::rust_dbg_lock_create();
do spawn_sched(SingleThreaded) {
testrt::rust_dbg_lock_lock(lock);
- comm::send(start_ch, ());
+ oldcomm::send(start_ch, ());
// Block the scheduler thread
testrt::rust_dbg_lock_wait(lock);
testrt::rust_dbg_lock_unlock(lock);
- comm::send(fin_ch, ());
+ oldcomm::send(fin_ch, ());
};
// Wait until the other task has its lock
- comm::recv(start_po);
+ oldcomm::recv(start_po);
- fn pingpong(po: comm::Port<int>, ch: comm::Chan<int>) {
+ fn pingpong(po: oldcomm::Port<int>, ch: oldcomm::Chan<int>) {
let mut val = 20;
while val > 0 {
- val = comm::recv(po);
- comm::send(ch, val - 1);
+ val = oldcomm::recv(po);
+ oldcomm::send(ch, val - 1);
}
}
- let setup_po = comm::Port();
- let setup_ch = comm::Chan(&setup_po);
- let parent_po = comm::Port();
- let parent_ch = comm::Chan(&parent_po);
+ let setup_po = oldcomm::Port();
+ let setup_ch = oldcomm::Chan(&setup_po);
+ let parent_po = oldcomm::Port();
+ let parent_ch = oldcomm::Chan(&parent_po);
do spawn {
- let child_po = comm::Port();
- comm::send(setup_ch, comm::Chan(&child_po));
+ let child_po = oldcomm::Port();
+ oldcomm::send(setup_ch, oldcomm::Chan(&child_po));
pingpong(child_po, parent_ch);
};
- let child_ch = comm::recv(setup_po);
- comm::send(child_ch, 20);
+ let child_ch = oldcomm::recv(setup_po);
+ oldcomm::send(child_ch, 20);
pingpong(parent_po, child_ch);
testrt::rust_dbg_lock_lock(lock);
testrt::rust_dbg_lock_signal(lock);
testrt::rust_dbg_lock_unlock(lock);
- comm::recv(fin_po);
+ oldcomm::recv(fin_po);
testrt::rust_dbg_lock_destroy(lock);
}
}
#[cfg(test)]
fn avoid_copying_the_body(spawnfn: fn(v: fn~())) {
- let p = comm::Port::<uint>();
- let ch = comm::Chan(&p);
+ let p = oldcomm::Port::<uint>();
+ let ch = oldcomm::Chan(&p);
let x = ~1;
let x_in_parent = ptr::addr_of(&(*x)) as uint;
do spawnfn |move x| {
let x_in_child = ptr::addr_of(&(*x)) as uint;
- comm::send(ch, x_in_child);
+ oldcomm::send(ch, x_in_child);
}
- let x_in_child = comm::recv(p);
+ let x_in_child = oldcomm::recv(p);
assert x_in_parent == x_in_child;
}
#[test]
fn test_platform_thread() {
- let po = comm::Port();
- let ch = comm::Chan(&po);
+ let po = oldcomm::Port();
+ let ch = oldcomm::Chan(&po);
do task().sched_mode(PlatformThread).spawn {
- comm::send(ch, ());
+ oldcomm::send(ch, ());
}
- comm::recv(po);
+ oldcomm::recv(po);
}
#[test]
#[ignore(cfg(windows))]
#[should_fail]
fn test_unkillable() {
- let po = comm::Port();
+ let po = oldcomm::Port();
let ch = po.chan();
// We want to do this after failing
#[test]
fn test_spawn_raw_simple() {
- let po = comm::Port();
- let ch = comm::Chan(&po);
+ let po = oldcomm::Port();
+ let ch = oldcomm::Chan(&po);
do spawn_raw(default_task_opts()) {
- comm::send(ch, ());
+ oldcomm::send(ch, ());
}
- comm::recv(po);
+ oldcomm::recv(po);
}
#[test]
bug and need to present an error.
*/
fn monitor(+f: fn~(diagnostic::emitter)) {
- let p = comm::Port();
- let ch = comm::Chan(&p);
+ let p = oldcomm::Port();
+ let ch = oldcomm::Chan(&p);
match do task::try |move f| {
let demitter = fn@(cmsp: Option<(@codemap::CodeMap, codemap::span)>,
msg: &str, lvl: diagnostic::level) {
if lvl == diagnostic::fatal {
- comm::send(ch, fatal);
+ oldcomm::send(ch, fatal);
}
diagnostic::emit(cmsp, msg, lvl);
};
struct finally {
- ch: comm::Chan<monitor_msg>,
- drop { comm::send(self.ch, done); }
+ ch: oldcomm::Chan<monitor_msg>,
+ drop { oldcomm::send(self.ch, done); }
}
let _finally = finally { ch: ch };
result::Ok(_) => { /* fallthrough */ }
result::Err(_) => {
// Task failed without emitting a fatal diagnostic
- if comm::recv(p) == done {
+ if oldcomm::recv(p) == done {
diagnostic::emit(
None,
diagnostic::ice_msg(~"unexpected failure"),
}
pub enum Srv = {
- ch: comm::Chan<Msg>
+ ch: oldcomm::Chan<Msg>
};
impl Srv: Clone {
});
let res = owner(srv_);
- comm::send(srv_.ch, Exit);
+ oldcomm::send(srv_.ch, Exit);
move res
}
-fn act(po: comm::Port<Msg>, source: ~str, parse: Parser) {
+fn act(po: oldcomm::Port<Msg>, source: ~str, parse: Parser) {
let sess = build_session();
let ctxt = build_ctxt(
let mut keep_going = true;
while keep_going {
- match comm::recv(po) {
+ match oldcomm::recv(po) {
HandleRequest(f) => {
f(ctxt);
}
srv: Srv,
+f: fn~(ctxt: Ctxt) -> T
) -> T {
- let po = comm::Port();
- let ch = comm::Chan(&po);
+ let po = oldcomm::Port();
+ let ch = oldcomm::Chan(&po);
let msg = HandleRequest(fn~(move f, ctxt: Ctxt) {
- comm::send(ch, f(ctxt))
+ oldcomm::send(ch, f(ctxt))
});
- comm::send(srv.ch, move msg);
- comm::recv(po)
+ oldcomm::send(srv.ch, move msg);
+ oldcomm::recv(po)
}
fn build_ctxt(sess: Session,
write_markdown(doc, move writer_factory);
// We expect two pages to have been written
for iter::repeat(2) {
- comm::recv(po);
+ oldcomm::recv(po);
}
}
let doc = (page_pass::mk_pass(config::DocPerMod).f)(srv, doc);
write_markdown(doc, move writer_factory);
for iter::repeat(2) {
- let (page, markdown) = comm::recv(po);
+ let (page, markdown) = oldcomm::recv(po);
match page {
doc::CratePage(_) => {
assert str::contains(markdown, ~"% Crate core");
assert str::contains(markdown, ~"# Module `a::b::c`");
}
-fn write_common(
+fn write_oldcommon(
ctxt: &Ctxt,
+desc: Option<~str>,
sections: &[doc::Section]
ctxt: &Ctxt,
+doc: doc::ModDoc
) {
- write_common(ctxt, doc.desc(), doc.sections());
+ write_oldcommon(ctxt, doc.desc(), doc.sections());
if doc.index.is_some() {
write_index(ctxt, doc.index.get());
}
}
fn write_nmod(ctxt: &Ctxt, +doc: doc::NmodDoc) {
- write_common(ctxt, doc.desc(), doc.sections());
+ write_oldcommon(ctxt, doc.desc(), doc.sections());
if doc.index.is_some() {
write_index(ctxt, doc.index.get());
}
sections: &[doc::Section]
) {
write_sig(ctxt, sig);
- write_common(ctxt, desc, sections);
+ write_oldcommon(ctxt, desc, sections);
}
fn write_sig(ctxt: &Ctxt, +sig: Option<~str>) {
+doc: doc::ConstDoc
) {
write_sig(ctxt, doc.sig);
- write_common(ctxt, doc.desc(), doc.sections());
+ write_oldcommon(ctxt, doc.desc(), doc.sections());
}
#[test]
ctxt: &Ctxt,
+doc: doc::EnumDoc
) {
- write_common(ctxt, doc.desc(), doc.sections());
+ write_oldcommon(ctxt, doc.desc(), doc.sections());
write_variants(ctxt, doc.variants);
}
}
fn write_trait(ctxt: &Ctxt, +doc: doc::TraitDoc) {
- write_common(ctxt, doc.desc(), doc.sections());
+ write_oldcommon(ctxt, doc.desc(), doc.sections());
write_methods(ctxt, doc.methods);
}
}
fn write_impl(ctxt: &Ctxt, +doc: doc::ImplDoc) {
- write_common(ctxt, doc.desc(), doc.sections());
+ write_oldcommon(ctxt, doc.desc(), doc.sections());
write_methods(ctxt, doc.methods);
}
+doc: doc::TyDoc
) {
write_sig(ctxt, doc.sig);
- write_common(ctxt, doc.desc(), doc.sections());
+ write_oldcommon(ctxt, doc.desc(), doc.sections());
}
#[test]
+doc: doc::StructDoc
) {
write_sig(ctxt, doc.sig);
- write_common(ctxt, doc.desc(), doc.sections());
+ write_oldcommon(ctxt, doc.desc(), doc.sections());
}
#[test]
) -> ~str {
let (writer_factory, po) = markdown_writer::future_writer_factory();
write_markdown(doc, move writer_factory);
- return comm::recv(po).second();
+ return oldcomm::recv(po).second();
}
fn write_markdown_str_srv(
let (writer_factory, po) = markdown_writer::future_writer_factory();
let pass = mk_pass(move writer_factory);
(pass.f)(srv, doc);
- return comm::recv(po).second();
+ return oldcomm::recv(po).second();
}
#[test]
fn generic_writer(+process: fn~(+markdown: ~str)) -> Writer {
let (setup_po, setup_ch) = pipes::stream();
do task::spawn |move process, move setup_ch| {
- let po: comm::Port<WriteInstr> = comm::Port();
- let ch = comm::Chan(&po);
+ let po: oldcomm::Port<WriteInstr> = oldcomm::Port();
+ let ch = oldcomm::Chan(&po);
setup_ch.send(ch);
let mut markdown = ~"";
let ch = setup_po.recv();
fn~(+instr: WriteInstr) {
- comm::send(ch, instr);
+ oldcomm::send(ch, instr);
}
}
}
pub fn future_writer_factory(
-) -> (WriterFactory, comm::Port<(doc::Page, ~str)>) {
- let markdown_po = comm::Port();
- let markdown_ch = comm::Chan(&markdown_po);
+) -> (WriterFactory, oldcomm::Port<(doc::Page, ~str)>) {
+ let markdown_po = oldcomm::Port();
+ let markdown_ch = oldcomm::Chan(&markdown_po);
let writer_factory = fn~(+page: doc::Page) -> Writer {
let (writer_po, writer_ch) = pipes::stream();
do task::spawn |move writer_ch| {
let (writer, future) = future_writer();
writer_ch.send(move writer);
let s = future.get();
- comm::send(markdown_ch, (page, s));
+ oldcomm::send(markdown_ch, (page, s));
}
writer_po.recv()
};
let (result_port, page_chan) = do util::spawn_conversation
|page_port, result_chan| {
- comm::send(result_chan, make_doc_from_pages(page_port));
+ oldcomm::send(result_chan, make_doc_from_pages(page_port));
};
find_pages(doc, page_chan);
- comm::recv(result_port)
+ oldcomm::recv(result_port)
}
-type PagePort = comm::Port<Option<doc::Page>>;
-type PageChan = comm::Chan<Option<doc::Page>>;
+type PagePort = oldcomm::Port<Option<doc::Page>>;
+type PageChan = oldcomm::Chan<Option<doc::Page>>;
type NominalPageChan = NominalOp<PageChan>;
fn make_doc_from_pages(page_port: PagePort) -> doc::Doc {
let mut pages = ~[];
loop {
- let val = comm::recv(page_port);
+ let val = oldcomm::recv(page_port);
if val.is_some() {
pages += ~[option::unwrap(move val)];
} else {
};
(fold.fold_doc)(&fold, doc);
- comm::send(page_chan, None);
+ oldcomm::send(page_chan, None);
}
fn fold_crate(
.. doc
});
- comm::send(fold.ctxt.op, Some(page));
+ oldcomm::send(fold.ctxt.op, Some(page));
doc
}
let doc = strip_mod(doc);
let page = doc::ItemPage(doc::ModTag(doc));
- comm::send(fold.ctxt.op, Some(page));
+ oldcomm::send(fold.ctxt.op, Some(page));
}
doc
) -> doc::NmodDoc {
let doc = fold::default_seq_fold_nmod(fold, doc);
let page = doc::ItemPage(doc::NmodTag(doc));
- comm::send(fold.ctxt.op, Some(page));
+ oldcomm::send(fold.ctxt.op, Some(page));
return doc;
}
}
pub fn spawn_listener<A: Owned>(
- +f: fn~(
comm::Port<A>)) -> comm::Chan<A> {
- let setup_po = comm::Port();
- let setup_ch = comm::Chan(&setup_po);
+ +f: fn~(
oldcomm::Port<A>)) -> oldcomm::Chan<A> {
+ let setup_po = oldcomm::Port();
+ let setup_ch = oldcomm::Chan(&setup_po);
do task::spawn |move f| {
- let po = comm::Port();
- let ch = comm::Chan(&po);
- comm::send(setup_ch, ch);
+ let po = oldcomm::Port();
+ let ch = oldcomm::Chan(&po);
+ oldcomm::send(setup_ch, ch);
f(move po);
}
- comm::recv(setup_po)
+ oldcomm::recv(setup_po)
}
pub fn spawn_conversation<A: Owned, B: Owned>
- (+f: fn~(comm::Port<A>, comm::Chan<B>))
- -> (
comm::Port<B>, comm::Chan<A>) {
- let from_child = comm::Port();
- let to_parent = comm::Chan(&from_child);
+ (+f: fn~(oldcomm::Port<A>, oldcomm::Chan<B>))
+ -> (
oldcomm::Port<B>, oldcomm::Chan<A>) {
+ let from_child = oldcomm::Port();
+ let to_parent = oldcomm::Chan(&from_child);
let to_child = do spawn_listener |move f, from_parent| {
f(from_parent, to_parent)
};
use set_data_for_req = uv::ll::set_data_for_req;
use get_data_for_req = uv::ll::get_data_for_req;
use ll = uv::ll;
-use comm = core::comm;
/// An IP address
pub enum IpAddr {
*/
pub fn get_addr(node: &str, iotask: iotask)
-> result::Result<~[IpAddr], IpGetAddrErr> {
- do core::comm::listen |output_ch| {
+ do oldcomm::listen |output_ch| {
do str::as_buf(node) |node_ptr, len| unsafe {
log(debug, fmt!("slice len %?", len));
let handle = create_uv_getaddrinfo_t();
}
type GetAddrData = {
- output_ch: comm::Chan<result::Result<~[IpAddr],IpGetAddrErr>>
+ output_ch: oldcomm::Chan<result::Result<~[IpAddr],IpGetAddrErr>>
};
extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int,
use result::{Result};
use libc::size_t;
use io::{Reader, ReaderUtil, Writer};
-use comm = core::comm;
#[nolink]
extern mod rustrt {
pub fn connect(input_ip: ip::IpAddr, port: uint,
iotask: IoTask)
-> result::Result<TcpSocket, TcpConnectErrData> unsafe {
- let result_po = core::comm::Port::<ConnAttempt>();
- let closed_signal_po = core::comm::Port::<()>();
+ let result_po = oldcomm::Port::<ConnAttempt>();
+ let closed_signal_po = oldcomm::Port::<()>();
let conn_data = {
- result_ch: core::comm::Chan(&result_po),
- closed_signal_ch: core::comm::Chan(&closed_signal_po)
+ result_ch: oldcomm::Chan(&result_po),
+ closed_signal_ch: oldcomm::Chan(&closed_signal_po)
};
let conn_data_ptr = ptr::addr_of(&conn_data);
- let reader_po = core::comm::Port::<result::Result<~[u8], TcpErrData>>();
+ let reader_po = oldcomm::Port::<result::Result<~[u8], TcpErrData>>();
let stream_handle_ptr = malloc_uv_tcp_t();
*(stream_handle_ptr as *mut uv::ll::uv_tcp_t) = uv::ll::tcp_t();
let socket_data = @{
reader_po: reader_po,
- reader_ch: core::comm::Chan(&reader_po),
+ reader_ch: oldcomm::Chan(&reader_po),
stream_handle_ptr: stream_handle_ptr,
connect_req: uv::ll::connect_t(),
write_req: uv::ll::write_t(),
// immediate connect failure.. probably a garbage
// ip or somesuch
let err_data = uv::ll::get_last_err_data(loop_ptr);
- core::comm::send((*conn_data_ptr).result_ch,
+ oldcomm::send((*conn_data_ptr).result_ch,
ConnFailure(err_data.to_tcp_err()));
uv::ll::set_data_for_uv_handle(stream_handle_ptr,
conn_data_ptr);
_ => {
// failure to create a tcp handle
let err_data = uv::ll::get_last_err_data(loop_ptr);
- core::comm::send((*conn_data_ptr).result_ch,
+ oldcomm::send((*conn_data_ptr).result_ch,
ConnFailure(err_data.to_tcp_err()));
}
}
};
- match core::comm::recv(result_po) {
+ match oldcomm::recv(result_po) {
ConnSuccess => {
log(debug, ~"tcp::connect - received success on result_po");
result::Ok(TcpSocket(socket_data))
}
ConnFailure(ref err_data) => {
- core::comm::recv(closed_signal_po);
+ oldcomm::recv(closed_signal_po);
log(debug, ~"tcp::connect - received failure on result_po");
// still have to free the malloc'd stream handle..
rustrt::rust_uv_current_kernel_free(stream_handle_ptr
* `tcp_err_data` record
*/
pub fn read_start(sock: &TcpSocket)
- -> result::Result<comm::Port<
+ -> result::Result<oldcomm::Port<
result::Result<~[u8], TcpErrData>>, TcpErrData> unsafe {
let socket_data = ptr::addr_of(&(*(sock.socket_data)));
read_start_common_impl(socket_data)
* * `sock` - a `net::tcp::tcp_socket` that you wish to stop reading on
*/
pub fn read_stop(sock: &TcpSocket,
- read_port: comm::Port<result::Result<~[u8], TcpErrData>>) ->
+ read_port: oldcomm::Port<result::Result<~[u8], TcpErrData>>) ->
result::Result<(), TcpErrData> unsafe {
log(debug, fmt!("taking the read_port out of commission %?", read_port));
let socket_data = ptr::addr_of(&(*sock.socket_data));
NewTcpConn(server_handle_ptr) => {
let server_data_ptr = uv::ll::get_data_for_uv_handle(
server_handle_ptr) as *TcpListenFcData;
- let reader_po = core::comm::Port();
+ let reader_po = oldcomm::Port();
let iotask = (*server_data_ptr).iotask;
let stream_handle_ptr = malloc_uv_tcp_t();
*(stream_handle_ptr as *mut uv::ll::uv_tcp_t) = uv::ll::tcp_t();
let client_socket_data = @{
reader_po: reader_po,
- reader_ch: core::comm::Chan(&reader_po),
+ reader_ch: oldcomm::Chan(&reader_po),
stream_handle_ptr : stream_handle_ptr,
connect_req : uv::ll::connect_t(),
write_req : uv::ll::write_t(),
let client_stream_handle_ptr =
(*client_socket_data_ptr).stream_handle_ptr;
- let result_po = core::comm::Port::<Option<TcpErrData>>();
- let result_ch = core::comm::Chan(&result_po);
+ let result_po = oldcomm::Port::<Option<TcpErrData>>();
+ let result_ch = oldcomm::Chan(&result_po);
// UNSAFE LIBUV INTERACTION BEGIN
// .. normally this happens within the context of
uv::ll::set_data_for_uv_handle(client_stream_handle_ptr,
client_socket_data_ptr
as *libc::c_void);
- core::comm::send(result_ch, None);
+ oldcomm::send(result_ch, None);
}
_ => {
log(debug, ~"failed to accept client conn");
- core::comm::send(result_ch, Some(
+ oldcomm::send(result_ch, Some(
uv::ll::get_last_err_data(loop_ptr).to_tcp_err()));
}
}
}
_ => {
log(debug, ~"failed to init client stream");
- core::comm::send(result_ch, Some(
+ oldcomm::send(result_ch, Some(
uv::ll::get_last_err_data(loop_ptr).to_tcp_err()));
}
}
// UNSAFE LIBUV INTERACTION END
- match core::comm::recv(result_po) {
+ match oldcomm::recv(result_po) {
Some(copy err_data) => result::Err(err_data),
None => result::Ok(TcpSocket(client_socket_data))
}
*/
pub fn listen(host_ip: ip::IpAddr, port: uint, backlog: uint,
iotask: IoTask,
- on_establish_cb: fn~(comm::Chan<Option<TcpErrData>>),
+ on_establish_cb: fn~(oldcomm::Chan<Option<TcpErrData>>),
new_connect_cb: fn~(TcpNewConnection,
- comm::Chan<Option<TcpErrData>>))
+ oldcomm::Chan<Option<TcpErrData>>))
-> result::Result<(), TcpListenErrData> unsafe {
do listen_common(move host_ip, port, backlog, iotask,
move on_establish_cb)
fn listen_common(host_ip: ip::IpAddr, port: uint, backlog: uint,
iotask: IoTask,
- on_establish_cb: fn~(comm::Chan<Option<TcpErrData>>),
+ on_establish_cb: fn~(oldcomm::Chan<Option<TcpErrData>>),
on_connect_cb: fn~(*uv::ll::uv_tcp_t))
-> result::Result<(), TcpListenErrData> unsafe {
- let stream_closed_po = core::comm::Port::<()>();
- let kill_po = core::comm::Port::<Option<TcpErrData>>();
- let kill_ch = core::comm::Chan(&kill_po);
+ let stream_closed_po = oldcomm::Port::<()>();
+ let kill_po = oldcomm::Port::<Option<TcpErrData>>();
+ let kill_ch = oldcomm::Chan(&kill_po);
let server_stream = uv::ll::tcp_t();
let server_stream_ptr = ptr::addr_of(&server_stream);
let server_data = {
server_stream_ptr: server_stream_ptr,
- stream_closed_ch: core::comm::Chan(&stream_closed_po),
+ stream_closed_ch: oldcomm::Chan(&stream_closed_po),
kill_ch: kill_ch,
on_connect_cb: move on_connect_cb,
iotask: iotask,
};
let server_data_ptr = ptr::addr_of(&server_data);
- let setup_result = do core::comm::listen |setup_ch| {
+ let setup_result = do oldcomm::listen |setup_ch| {
// this is to address a compiler warning about
// an implicit copy.. it seems that double nested
// will defeat a move sigil, as is done to the host_ip
match uv::ll::listen(server_stream_ptr,
backlog as libc::c_int,
tcp_lfc_on_connection_cb) {
- 0i32 => core::comm::send(setup_ch, None),
+ 0i32 => oldcomm::send(setup_ch, None),
_ => {
log(debug, ~"failure to uv_listen()");
let err_data = uv::ll::get_last_err_data(loop_ptr);
- core::comm::send(setup_ch, Some(err_data));
+ oldcomm::send(setup_ch, Some(err_data));
}
}
}
_ => {
log(debug, ~"failure to uv_tcp_bind");
let err_data = uv::ll::get_last_err_data(loop_ptr);
- core::comm::send(setup_ch, Some(err_data));
+ oldcomm::send(setup_ch, Some(err_data));
}
}
}
_ => {
log(debug, ~"failure to uv_tcp_init");
let err_data = uv::ll::get_last_err_data(loop_ptr);
- core::comm::send(setup_ch, Some(err_data));
+ oldcomm::send(setup_ch, Some(err_data));
}
}
};
}
None => {
on_establish_cb(kill_ch);
- let kill_result = core::comm::recv(kill_po);
+ let kill_result = oldcomm::recv(kill_po);
do iotask::interact(iotask) |loop_ptr| unsafe {
log(debug, fmt!("tcp::listen post-kill recv hl interact %?",
loop_ptr));
/// Convenience methods extending `net::tcp::tcp_socket`
impl TcpSocket {
- pub fn read_start() -> result::Result<comm::Port<
+ pub fn read_start() -> result::Result<oldcomm::Port<
result::Result<~[u8], TcpErrData>>, TcpErrData> {
read_start(&self)
}
pub fn read_stop(read_port:
- comm::Port<result::Result<~[u8], TcpErrData>>) ->
+ oldcomm::Port<result::Result<~[u8], TcpErrData>>) ->
result::Result<(), TcpErrData> {
read_stop(&self, move read_port)
}
// INTERNAL API
fn tear_down_socket_data(socket_data: @TcpSocketData) unsafe {
- let closed_po = core::comm::Port::<()>();
- let closed_ch = core::comm::Chan(&closed_po);
+ let closed_po = oldcomm::Port::<()>();
+ let closed_ch = oldcomm::Chan(&closed_po);
let close_data = {
closed_ch: closed_ch
};
close_data_ptr);
uv::ll::close(stream_handle_ptr, tcp_socket_dtor_close_cb);
};
- core::comm::recv(closed_po);
+ oldcomm::recv(closed_po);
//the line below will most likely crash
//log(debug, fmt!("about to free socket_data at %?", socket_data));
rustrt::rust_uv_current_kernel_free(stream_handle_ptr
timer::recv_timeout(
iotask, timeout_msecs, result::get(&rs_result))
} else {
- Some(core::comm::recv(result::get(&rs_result)))
+ Some(oldcomm::recv(result::get(&rs_result)))
};
log(debug, ~"tcp::read after recv_timeout");
match move read_result {
fn read_stop_common_impl(socket_data: *TcpSocketData) ->
result::Result<(), TcpErrData> unsafe {
let stream_handle_ptr = (*socket_data).stream_handle_ptr;
- let stop_po = core::comm::Port::<Option<TcpErrData>>();
- let stop_ch = core::comm::Chan(&stop_po);
+ let stop_po = oldcomm::Port::<Option<TcpErrData>>();
+ let stop_ch = oldcomm::Chan(&stop_po);
do iotask::interact((*socket_data).iotask) |loop_ptr| unsafe {
log(debug, ~"in interact cb for tcp::read_stop");
match uv::ll::read_stop(stream_handle_ptr as *uv::ll::uv_stream_t) {
0i32 => {
log(debug, ~"successfully called uv_read_stop");
- core::comm::send(stop_ch, None);
+ oldcomm::send(stop_ch, None);
}
_ => {
log(debug, ~"failure in calling uv_read_stop");
let err_data = uv::ll::get_last_err_data(loop_ptr);
- core::comm::send(stop_ch, Some(err_data.to_tcp_err()));
+ oldcomm::send(stop_ch, Some(err_data.to_tcp_err()));
}
}
};
- match core::comm::recv(stop_po) {
+ match oldcomm::recv(stop_po) {
Some(ref err_data) => result::Err(err_data.to_tcp_err()),
None => result::Ok(())
}
// shared impl for read_start
fn read_start_common_impl(socket_data: *TcpSocketData)
- -> result::Result<comm::Port<
+ -> result::Result<oldcomm::Port<
result::Result<~[u8], TcpErrData>>, TcpErrData> unsafe {
let stream_handle_ptr = (*socket_data).stream_handle_ptr;
- let start_po = core::comm::Port::<Option<uv::ll::uv_err_data>>();
- let start_ch = core::comm::Chan(&start_po);
+ let start_po = oldcomm::Port::<Option<uv::ll::uv_err_data>>();
+ let start_ch = oldcomm::Chan(&start_po);
log(debug, ~"in tcp::read_start before interact loop");
do iotask::interact((*socket_data).iotask) |loop_ptr| unsafe {
log(debug, fmt!("in tcp::read_start interact cb %?", loop_ptr));
on_tcp_read_cb) {
0i32 => {
log(debug, ~"success doing uv_read_start");
- core::comm::send(start_ch, None);
+ oldcomm::send(start_ch, None);
}
_ => {
log(debug, ~"error attempting uv_read_start");
let err_data = uv::ll::get_last_err_data(loop_ptr);
- core::comm::send(start_ch, Some(err_data));
+ oldcomm::send(start_ch, Some(err_data));
}
}
};
- match core::comm::recv(start_po) {
+ match oldcomm::recv(start_po) {
Some(ref err_data) => result::Err(err_data.to_tcp_err()),
None => result::Ok((*socket_data).reader_po)
}
vec::raw::to_ptr(raw_write_data),
vec::len(raw_write_data)) ];
let write_buf_vec_ptr = ptr::addr_of(&write_buf_vec);
- let result_po = core::comm::Port::<TcpWriteResult>();
+ let result_po = oldcomm::Port::<TcpWriteResult>();
let write_data = {
- result_ch: core::comm::Chan(&result_po)
+ result_ch: oldcomm::Chan(&result_po)
};
let write_data_ptr = ptr::addr_of(&write_data);
do iotask::interact((*socket_data_ptr).iotask) |loop_ptr| unsafe {
_ => {
log(debug, ~"error invoking uv_write()");
let err_data = uv::ll::get_last_err_data(loop_ptr);
- core::comm::send((*write_data_ptr).result_ch,
+ oldcomm::send((*write_data_ptr).result_ch,
TcpWriteError(err_data.to_tcp_err()));
}
}
// and waiting here for the write to complete, we should transfer
// ownership of everything to the I/O task and let it deal with the
// aftermath, so we don't have to sit here blocking.
- match core::comm::recv(result_po) {
+ match oldcomm::recv(result_po) {
TcpWriteSuccess => result::Ok(()),
TcpWriteError(ref err_data) => result::Err(err_data.to_tcp_err())
}
type TcpListenFcData = {
server_stream_ptr: *uv::ll::uv_tcp_t,
- stream_closed_ch: comm::Chan<()>,
- kill_ch: comm::Chan<Option<TcpErrData>>,
+ stream_closed_ch: oldcomm::Chan<()>,
+ kill_ch: oldcomm::Chan<Option<TcpErrData>>,
on_connect_cb: fn~(*uv::ll::uv_tcp_t),
iotask: IoTask,
ipv6: bool,
extern fn tcp_lfc_close_cb(handle: *uv::ll::uv_tcp_t) unsafe {
let server_data_ptr = uv::ll::get_data_for_uv_handle(
handle) as *TcpListenFcData;
- core::comm::send((*server_data_ptr).stream_closed_ch, ());
+ oldcomm::send((*server_data_ptr).stream_closed_ch, ());
}
extern fn tcp_lfc_on_connection_cb(handle: *uv::ll::uv_tcp_t,
0i32 => ((*server_data_ptr).on_connect_cb)(handle),
_ => {
let loop_ptr = uv::ll::get_loop_for_uv_handle(handle);
- core::comm::send(kill_ch,
+ oldcomm::send(kill_ch,
Some(uv::ll::get_last_err_data(loop_ptr)
.to_tcp_err()));
(*server_data_ptr).active = false;
}
enum TcpReadStartResult {
- TcpReadStartSuccess(comm::Port<TcpReadResult>),
+ TcpReadStartSuccess(oldcomm::Port<TcpReadResult>),
TcpReadStartError(TcpErrData)
}
log(debug, fmt!("on_tcp_read_cb: incoming err.. name %? msg %?",
err_data.err_name, err_data.err_msg));
let reader_ch = (*socket_data_ptr).reader_ch;
- core::comm::send(reader_ch, result::Err(err_data));
+ oldcomm::send(reader_ch, result::Err(err_data));
}
// do nothing .. unneeded buf
0 => (),
let reader_ch = (*socket_data_ptr).reader_ch;
let buf_base = uv::ll::get_base_from_buf(buf);
let new_bytes = vec::from_buf(buf_base, nread as uint);
- core::comm::send(reader_ch, result::Ok(new_bytes));
+ oldcomm::send(reader_ch, result::Ok(new_bytes));
}
}
uv::ll::free_base_of_buf(buf);
}
type TcpSocketCloseData = {
- closed_ch: comm::Chan<()>
+ closed_ch: oldcomm::Chan<()>
};
extern fn tcp_socket_dtor_close_cb(handle: *uv::ll::uv_tcp_t) unsafe {
let data = uv::ll::get_data_for_uv_handle(handle)
as *TcpSocketCloseData;
let closed_ch = (*data).closed_ch;
- core::comm::send(closed_ch, ());
+ oldcomm::send(closed_ch, ());
log(debug, ~"tcp_socket_dtor_close_cb exiting..");
}
as *WriteReqData;
if status == 0i32 {
log(debug, ~"successful write complete");
- core::comm::send((*write_data_ptr).result_ch, TcpWriteSuccess);
+ oldcomm::send((*write_data_ptr).result_ch, TcpWriteSuccess);
} else {
let stream_handle_ptr = uv::ll::get_stream_handle_from_write_req(
write_req);
let loop_ptr = uv::ll::get_loop_for_uv_handle(stream_handle_ptr);
let err_data = uv::ll::get_last_err_data(loop_ptr);
log(debug, ~"failure to write");
- core::comm::send((*write_data_ptr).result_ch,
+ oldcomm::send((*write_data_ptr).result_ch,
TcpWriteError(err_data));
}
}
type WriteReqData = {
- result_ch: comm::Chan<TcpWriteResult>
+ result_ch: oldcomm::Chan<TcpWriteResult>
};
type ConnectReqData = {
- result_ch: comm::Chan<ConnAttempt>,
- closed_signal_ch: comm::Chan<()>
+ result_ch: oldcomm::Chan<ConnAttempt>,
+ closed_signal_ch: oldcomm::Chan<()>
};
extern fn stream_error_close_cb(handle: *uv::ll::uv_tcp_t) unsafe {
let data = uv::ll::get_data_for_uv_handle(handle) as
*ConnectReqData;
- core::comm::send((*data).closed_signal_ch, ());
+ oldcomm::send((*data).closed_signal_ch, ());
log(debug, fmt!("exiting steam_error_close_cb for %?", handle));
}
match status {
0i32 => {
log(debug, ~"successful tcp connection!");
- core::comm::send(result_ch, ConnSuccess);
+ oldcomm::send(result_ch, ConnSuccess);
}
_ => {
log(debug, ~"error in tcp_connect_on_connect_cb");
let err_data = uv::ll::get_last_err_data(loop_ptr);
log(debug, fmt!("err_data %? %?", err_data.err_name,
err_data.err_msg));
- core::comm::send(result_ch, ConnFailure(err_data));
+ oldcomm::send(result_ch, ConnFailure(err_data));
uv::ll::set_data_for_uv_handle(tcp_stream_ptr,
conn_data_ptr);
uv::ll::close(tcp_stream_ptr, stream_error_close_cb);
}
type TcpSocketData = {
- reader_po: comm::Port<result::Result<~[u8], TcpErrData>>,
- reader_ch: comm::Chan<result::Result<~[u8], TcpErrData>>,
+ reader_po: oldcomm::Port<result::Result<~[u8], TcpErrData>>,
+ reader_ch: oldcomm::Chan<result::Result<~[u8], TcpErrData>>,
stream_handle_ptr: *uv::ll::uv_tcp_t,
connect_req: uv::ll::uv_connect_t,
write_req: uv::ll::uv_write_t,
let expected_req = ~"ping";
let expected_resp = ~"pong";
- let server_result_po = core::comm::Port::<~str>();
- let server_result_ch = core::comm::Chan(&server_result_po);
+ let server_result_po = oldcomm::Port::<~str>();
+ let server_result_ch = oldcomm::Chan(&server_result_po);
- let cont_po = core::comm::Port::<()>();
- let cont_ch = core::comm::Chan(&cont_po);
+ let cont_po = oldcomm::Port::<()>();
+ let cont_ch = oldcomm::Chan(&cont_po);
// server
do task::spawn_sched(task::ManualThreads(1u)) {
- let actual_req = do comm::listen |server_ch| {
+ let actual_req = do oldcomm::listen |server_ch| {
run_tcp_test_server(
server_ip,
server_port,
};
server_result_ch.send(actual_req);
};
- core::comm::recv(cont_po);
+ oldcomm::recv(cont_po);
// client
log(debug, ~"server started, firing up client..");
- let actual_resp_result = do core::comm::listen |client_ch| {
+ let actual_resp_result = do oldcomm::listen |client_ch| {
run_tcp_test_client(
server_ip,
server_port,
};
assert actual_resp_result.is_ok();
let actual_resp = actual_resp_result.get();
- let actual_req = core::comm::recv(server_result_po);
+ let actual_req = oldcomm::recv(server_result_po);
log(debug, fmt!("REQ: expected: '%s' actual: '%s'",
expected_req, actual_req));
log(debug, fmt!("RESP: expected: '%s' actual: '%s'",
let server_port = 8887u;
let expected_resp = ~"pong";
- let server_result_po = core::comm::Port::<~str>();
- let server_result_ch = core::comm::Chan(&server_result_po);
+ let server_result_po = oldcomm::Port::<~str>();
+ let server_result_ch = oldcomm::Chan(&server_result_po);
- let cont_po = core::comm::Port::<()>();
- let cont_ch = core::comm::Chan(&cont_po);
+ let cont_po = oldcomm::Port::<()>();
+ let cont_ch = oldcomm::Chan(&cont_po);
// server
do task::spawn_sched(task::ManualThreads(1u)) {
- let actual_req = do comm::listen |server_ch| {
+ let actual_req = do oldcomm::listen |server_ch| {
run_tcp_test_server(
server_ip,
server_port,
};
server_result_ch.send(actual_req);
};
- core::comm::recv(cont_po);
+ oldcomm::recv(cont_po);
// client
log(debug, ~"server started, firing up client..");
- do core::comm::listen |client_ch| {
+ do oldcomm::listen |client_ch| {
let server_ip_addr = ip::v4::parse_addr(server_ip);
let iotask = uv::global_loop::get();
let connect_result = connect(move server_ip_addr, server_port,
let expected_req = ~"ping";
// client
log(debug, ~"firing up client..");
- let actual_resp_result = do core::comm::listen |client_ch| {
+ let actual_resp_result = do oldcomm::listen |client_ch| {
run_tcp_test_client(
server_ip,
server_port,
let expected_req = ~"ping";
let expected_resp = ~"pong";
- let server_result_po = core::comm::Port::<~str>();
- let server_result_ch = core::comm::Chan(&server_result_po);
+ let server_result_po = oldcomm::Port::<~str>();
+ let server_result_ch = oldcomm::Chan(&server_result_po);
- let cont_po = core::comm::Port::<()>();
- let cont_ch = core::comm::Chan(&cont_po);
+ let cont_po = oldcomm::Port::<()>();
+ let cont_ch = oldcomm::Chan(&cont_po);
// server
do task::spawn_sched(task::ManualThreads(1u)) {
- let actual_req = do comm::listen |server_ch| {
+ let actual_req = do oldcomm::listen |server_ch| {
run_tcp_test_server(
server_ip,
server_port,
};
server_result_ch.send(actual_req);
};
- core::comm::recv(cont_po);
+ oldcomm::recv(cont_po);
// this one should fail..
let listen_err = run_tcp_test_server_fail(
server_ip,
hl_loop);
// client.. just doing this so that the first server tears down
log(debug, ~"server started, firing up client..");
- do core::comm::listen |client_ch| {
+ do oldcomm::listen |client_ch| {
run_tcp_test_client(
server_ip,
server_port,
let expected_req = ~"GET /";
let expected_resp = ~"A string\nwith multiple lines\n";
- let server_result_po = core::comm::Port::<~str>();
- let server_result_ch = core::comm::Chan(&server_result_po);
+ let server_result_po = oldcomm::Port::<~str>();
+ let server_result_ch = oldcomm::Chan(&server_result_po);
- let cont_po = core::comm::Port::<()>();
- let cont_ch = core::comm::Chan(&cont_po);
+ let cont_po = oldcomm::Port::<()>();
+ let cont_ch = oldcomm::Chan(&cont_po);
// server
do task::spawn_sched(task::ManualThreads(1u)) {
- let actual_req = do comm::listen |server_ch| {
+ let actual_req = do oldcomm::listen |server_ch| {
run_tcp_test_server(
server_ip,
server_port,
};
server_result_ch.send(actual_req);
};
- core::comm::recv(cont_po);
+ oldcomm::recv(cont_po);
// client
log(debug, ~"server started, firing up client..");
let server_addr = ip::v4::parse_addr(server_ip);
}
fn run_tcp_test_server(server_ip: &str, server_port: uint, resp: ~str,
- server_ch: comm::Chan<~str>,
- cont_ch: comm::Chan<()>,
+ server_ch: oldcomm::Chan<~str>,
+ cont_ch: oldcomm::Chan<()>,
iotask: IoTask) -> ~str {
let server_ip_addr = ip::v4::parse_addr(server_ip);
let listen_result = listen(move server_ip_addr, server_port, 128,
|kill_ch| {
log(debug, fmt!("establish_cb %?",
kill_ch));
- core::comm::send(cont_ch, ());
+ oldcomm::send(cont_ch, ());
},
// risky to run this on the loop, but some users
// will want the POWER
|new_conn, kill_ch| {
log(debug, ~"SERVER: new connection!");
- do comm::listen |cont_ch| {
+ do oldcomm::listen |cont_ch| {
do task::spawn_sched(task::ManualThreads(1u)) {
log(debug, ~"SERVER: starting worker for new req");
if result::is_err(&accept_result) {
log(debug, ~"SERVER: error accept connection");
let err_data = result::get_err(&accept_result);
- core::comm::send(kill_ch, Some(err_data));
+ oldcomm::send(kill_ch, Some(err_data));
log(debug,
~"SERVER/WORKER: send on err cont ch");
cont_ch.send(());
log(debug, ~"SERVER: before write");
tcp_write_single(&sock, str::to_bytes(resp));
log(debug, ~"SERVER: after write.. die");
- core::comm::send(kill_ch, None);
+ oldcomm::send(kill_ch, None);
}
result::Err(move err_data) => {
log(debug, fmt!("SERVER: error recvd: %s %s",
err_data.err_name, err_data.err_msg));
- core::comm::send(kill_ch, Some(err_data));
+ oldcomm::send(kill_ch, Some(err_data));
server_ch.send(~"");
}
}
}
fn run_tcp_test_client(server_ip: &str, server_port: uint, resp: &str,
- client_ch: comm::Chan<~str>,
+ client_ch: oldcomm::Chan<~str>,
iotask: IoTask) -> result::Result<~str,
TcpConnectErrData> {
let server_ip_addr = ip::v4::parse_addr(server_ip);
use io::WriterUtil;
use libc::size_t;
use task::TaskBuilder;
-use comm = core::comm;
#[abi = "cdecl"]
extern mod rustrt {
let mut wait_idx = 0;
let mut done_idx = 0;
- let p = core::comm::Port();
- let ch = core::comm::Chan(&p);
+ let p = oldcomm::Port();
+ let ch = oldcomm::Chan(&p);
while done_idx < total {
while wait_idx < concurrency && run_idx < total {
run_idx += 1;
}
- let (test, result) = core::comm::recv(p);
+ let (test, result) = oldcomm::recv(p);
if concurrency != 1 {
callback(TeWait(copy test));
}
type TestFuture = {test: TestDesc, wait: fn@() -> TestResult};
-fn run_test(test: TestDesc, monitor_ch: comm::Chan<MonitorMsg>) {
+fn run_test(test: TestDesc, monitor_ch: oldcomm::Chan<MonitorMsg>) {
if test.ignore {
- core::comm::send(monitor_ch, (copy test, TrIgnored));
+ oldcomm::send(monitor_ch, (copy test, TrIgnored));
return;
}
}).spawn(move testfn);
let task_result = option::unwrap(move result_future).recv();
let test_result = calc_result(&test, task_result == task::Success);
- comm::send(monitor_ch, (copy test, test_result));
+ oldcomm::send(monitor_ch, (copy test, test_result));
};
}
ignore: true,
should_fail: false
};
- let p = core::comm::Port();
- let ch = core::comm::Chan(&p);
+ let p = oldcomm::Port();
+ let ch = oldcomm::Chan(&p);
run_test(desc, ch);
- let (_, res) = core::comm::recv(p);
+ let (_, res) = oldcomm::recv(p);
assert res != TrOk;
}
ignore: true,
should_fail: false
};
- let p = core::comm::Port();
- let ch = core::comm::Chan(&p);
+ let p = oldcomm::Port();
+ let ch = oldcomm::Chan(&p);
run_test(desc, ch);
- let (_, res) = core::comm::recv(p);
+ let (_, res) = oldcomm::recv(p);
assert res == TrIgnored;
}
ignore: false,
should_fail: true
};
- let p = core::comm::Port();
- let ch = core::comm::Chan(&p);
+ let p = oldcomm::Port();
+ let ch = oldcomm::Chan(&p);
run_test(desc, ch);
- let (_, res) = core::comm::recv(p);
+ let (_, res) = oldcomm::recv(p);
assert res == TrOk;
}
ignore: false,
should_fail: true
};
- let p = core::comm::Port();
- let ch = core::comm::Chan(&p);
+ let p = oldcomm::Port();
+ let ch = oldcomm::Chan(&p);
run_test(desc, ch);
- let (_, res) = core::comm::recv(p);
+ let (_, res) = oldcomm::recv(p);
assert res == TrFailed;
}
use uv::iotask;
use uv::iotask::IoTask;
-use comm = core::comm;
/**
* Wait for timeout period then send provided value over a channel
* * val - a value of type T to send over the provided `ch`
*/
pub fn delayed_send<T: Owned>(iotask: IoTask,
- msecs: uint, ch: comm::Chan<T>, val: T) {
+ msecs: uint, ch: oldcomm::Chan<T>, val: T) {
unsafe {
- let timer_done_po = core::comm::Port::<()>();
- let timer_done_ch = core::comm::Chan(&timer_done_po);
+ let timer_done_po = oldcomm::Port::<()>();
+ let timer_done_ch = oldcomm::Chan(&timer_done_po);
let timer_done_ch_ptr = ptr::addr_of(&timer_done_ch);
let timer = uv::ll::timer_t();
let timer_ptr = ptr::addr_of(&timer);
}
};
// delayed_send_cb has been processed by libuv
- core::comm::recv(timer_done_po);
+ oldcomm::recv(timer_done_po);
// notify the caller immediately
- core::comm::send(ch, move(val));
+ oldcomm::send(ch, move(val));
// uv_close for this timer has been processed
- core::comm::recv(timer_done_po);
+ oldcomm::recv(timer_done_po);
};
}
* * msecs - an amount of time, in milliseconds, for the current task to block
*/
pub fn sleep(iotask: IoTask, msecs: uint) {
- let exit_po = core::comm::Port::<()>();
- let exit_ch = core::comm::Chan(&exit_po);
+ let exit_po = oldcomm::Port::<()>();
+ let exit_ch = oldcomm::Chan(&exit_po);
delayed_send(iotask, msecs, exit_ch, ());
- core::comm::recv(exit_po);
+ oldcomm::recv(exit_po);
}
/**
*/
pub fn recv_timeout<T: Copy Owned>(iotask: IoTask,
msecs: uint,
- wait_po: comm::Port<T>) -> Option<T> {
- let timeout_po = comm::Port::<()>();
- let timeout_ch = comm::Chan(&timeout_po);
+ wait_po: oldcomm::Port<T>) -> Option<T> {
+ let timeout_po = oldcomm::Port::<()>();
+ let timeout_ch = oldcomm::Chan(&timeout_po);
delayed_send(iotask, msecs, timeout_ch, ());
// FIXME: This could be written clearer (#2618)
either::either(
None
}, |right_val| {
Some(*right_val)
- }, &core::comm::select2(timeout_po, wait_po)
+ }, &oldcomm::select2(timeout_po, wait_po)
)
}
status: libc::c_int) unsafe {
log(debug, fmt!("delayed_send_cb handle %? status %?", handle, status));
let timer_done_ch =
- *(uv::ll::get_data_for_uv_handle(handle) as *comm::Chan<()>);
+ *(uv::ll::get_data_for_uv_handle(handle) as *oldcomm::Chan<()>);
let stop_result = uv::ll::timer_stop(handle);
if (stop_result == 0i32) {
- core::comm::send(timer_done_ch, ());
+ oldcomm::send(timer_done_ch, ());
uv::ll::close(handle, delayed_send_close_cb);
}
else {
extern fn delayed_send_close_cb(handle: *uv::ll::uv_timer_t) unsafe {
log(debug, fmt!("delayed_send_close_cb handle %?", handle));
let timer_done_ch =
- *(uv::ll::get_data_for_uv_handle(handle) as *comm::Chan<()>);
- comm::send(timer_done_ch, ());
+ *(uv::ll::get_data_for_uv_handle(handle) as *oldcomm::Chan<()>);
+ oldcomm::send(timer_done_ch, ());
}
#[cfg(test)]
#[test]
fn test_gl_timer_sleep_stress2() {
- let po = core::comm::Port();
- let ch = core::comm::Chan(&po);
+ let po = oldcomm::Port();
+ let ch = oldcomm::Chan(&po);
let hl_loop = uv::global_loop::get();
let repeat = 20u;
for iter::repeat(times) {
sleep(hl_loop, rng.next() as uint % maxms);
}
- core::comm::send(ch, ());
+ oldcomm::send(ch, ());
}
}
}
for iter::repeat(repeat * spec.len()) {
- core::comm::recv(po)
+ oldcomm::recv(po)
}
}
for iter::repeat(times as uint) {
let expected = rand::Rng().gen_str(16u);
- let test_po = core::comm::Port::<~str>();
- let test_ch = core::comm::Chan(&test_po);
+ let test_po = oldcomm::Port::<~str>();
+ let test_ch = oldcomm::Chan(&test_po);
do task::spawn() {
delayed_send(hl_loop, 50u, test_ch, expected);
use get_gl = get;
use uv_iotask::{IoTask, spawn_iotask};
use private::{chan_from_global_ptr, weaken_task};
-use comm = core::comm;
-use core::comm::{Port, Chan, select2, listen};
+use core::oldcomm::{Port, Chan, select2, listen};
use task::TaskBuilder;
use either::{Left, Right};
mod test {
extern fn simple_timer_close_cb(timer_ptr: *ll::uv_timer_t) unsafe {
let exit_ch_ptr = ll::get_data_for_uv_handle(
- timer_ptr as *libc::c_void) as *comm::Chan<bool>;
+ timer_ptr as *libc::c_void) as *oldcomm::Chan<bool>;
let exit_ch = *exit_ch_ptr;
- core::comm::send(exit_ch, true);
+ oldcomm::send(exit_ch, true);
log(debug, fmt!("EXIT_CH_PTR simple_timer_close_cb exit_ch_ptr: %?",
exit_ch_ptr));
}
}
fn impl_uv_hl_simple_timer(iotask: IoTask) unsafe {
- let exit_po = core::comm::Port::<bool>();
- let exit_ch = core::comm::Chan(&exit_po);
+ let exit_po = oldcomm::Port::<bool>();
+ let exit_ch = oldcomm::Chan(&exit_po);
let exit_ch_ptr = ptr::addr_of(&exit_ch);
log(debug, fmt!("EXIT_CH_PTR newly created exit_ch_ptr: %?",
exit_ch_ptr));
fail ~"failure on ll::timer_init()";
}
};
- core::comm::recv(exit_po);
+ oldcomm::recv(exit_po);
log(debug, ~"global_loop timer test: msg recv on exit_po, done..");
}
#[test]
fn test_gl_uv_global_loop_high_level_global_timer() unsafe {
let hl_loop = get_gl();
- let exit_po = comm::Port::<()>();
- let exit_ch = comm::Chan(&exit_po);
+ let exit_po = oldcomm::Port::<()>();
+ let exit_ch = oldcomm::Chan(&exit_po);
task::spawn_sched(task::ManualThreads(1u), || {
impl_uv_hl_simple_timer(hl_loop);
- core::comm::send(exit_ch, ());
+ oldcomm::send(exit_ch, ());
});
impl_uv_hl_simple_timer(hl_loop);
- core::comm::recv(exit_po);
+ oldcomm::recv(exit_po);
}
// keeping this test ignored until some kind of stress-test-harness
#[ignore]
fn test_stress_gl_uv_global_loop_high_level_global_timer() unsafe {
let hl_loop = get_gl();
- let exit_po = core::comm::Port::<()>();
- let exit_ch = core::comm::Chan(&exit_po);
+ let exit_po = oldcomm::Port::<()>();
+ let exit_ch = oldcomm::Chan(&exit_po);
let cycles = 5000u;
for iter::repeat(cycles) {
task::spawn_sched(task::ManualThreads(1u), || {
impl_uv_hl_simple_timer(hl_loop);
- core::comm::send(exit_ch, ());
+ oldcomm::send(exit_ch, ());
});
};
for iter::repeat(cycles) {
- core::comm::recv(exit_po);
+ oldcomm::recv(exit_po);
};
log(debug, ~"test_stress_gl_uv_global_loop_high_level_global_timer"+
~" exiting sucessfully!");
use libc::c_void;
use ptr::addr_of;
-use comm = core::comm;
-use core::comm::{Port, Chan, listen};
+use core::oldcomm::{Port, Chan, listen};
use task::TaskBuilder;
use ll = uv_ll;
log(debug, fmt!("async_close_cb handle %?", handle));
let exit_ch = (*(ll::get_data_for_uv_handle(handle)
as *AhData)).exit_ch;
- core::comm::send(exit_ch, ());
+ oldcomm::send(exit_ch, ());
}
extern fn async_handle_cb(handle: *ll::uv_async_t, status: libc::c_int)
unsafe {
}
type AhData = {
iotask: IoTask,
- exit_ch: comm::Chan<()>
+ exit_ch: oldcomm::Chan<()>
};
fn impl_uv_iotask_async(iotask: IoTask) unsafe {
let async_handle = ll::async_t();
let ah_ptr = ptr::addr_of(&async_handle);
- let exit_po = core::comm::Port::<()>();
- let exit_ch = core::comm::Chan(&exit_po);
+ let exit_po = oldcomm::Port::<()>();
+ let exit_ch = oldcomm::Chan(&exit_po);
let ah_data = {
iotask: iotask,
exit_ch: exit_ch
ll::set_data_for_uv_handle(ah_ptr, ah_data_ptr as *libc::c_void);
ll::async_send(ah_ptr);
};
- core::comm::recv(exit_po);
+ oldcomm::recv(exit_po);
}
// this fn documents the bear minimum neccesary to roll your own
// high_level_loop
- unsafe fn spawn_test_loop(exit_ch: comm::Chan<()>) -> IoTask {
- let iotask_port = comm::Port::<IoTask>();
- let iotask_ch = comm::Chan(&iotask_port);
+ unsafe fn spawn_test_loop(exit_ch: oldcomm::Chan<()>) -> IoTask {
+ let iotask_port = oldcomm::Port::<IoTask>();
+ let iotask_ch = oldcomm::Chan(&iotask_port);
do task::spawn_sched(task::ManualThreads(1u)) {
run_loop(iotask_ch);
exit_ch.send(());
};
- return core::comm::recv(iotask_port);
+ return oldcomm::recv(iotask_port);
}
extern fn lifetime_handle_close(handle: *libc::c_void) unsafe {
#[test]
fn test_uv_iotask_async() unsafe {
- let exit_po = core::comm::Port::<()>();
- let exit_ch = core::comm::Chan(&exit_po);
+ let exit_po = oldcomm::Port::<()>();
+ let exit_ch = oldcomm::Chan(&exit_po);
let iotask = spawn_test_loop(exit_ch);
// using this handle to manage the lifetime of the high_level_loop,
// under race-condition type situations.. this ensures that the loop
// lives until, at least, all of the impl_uv_hl_async() runs have been
// called, at least.
- let work_exit_po = core::comm::Port::<()>();
- let work_exit_ch = core::comm::Chan(&work_exit_po);
+ let work_exit_po = oldcomm::Port::<()>();
+ let work_exit_ch = oldcomm::Chan(&work_exit_po);
for iter::repeat(7u) {
do task::spawn_sched(task::ManualThreads(1u)) {
impl_uv_iotask_async(iotask);
- core::comm::send(work_exit_ch, ());
+ oldcomm::send(work_exit_ch, ());
};
};
for iter::repeat(7u) {
- core::comm::recv(work_exit_po);
+ oldcomm::recv(work_exit_po);
};
log(debug, ~"sending teardown_loop msg..");
exit(iotask);
- core::comm::recv(exit_po);
+ oldcomm::recv(exit_po);
log(debug, ~"after recv on exit_po.. exiting..");
}
}
#[allow(non_camel_case_types)]; // C types
use libc::size_t;
-use comm = core::comm;
use ptr::to_unsafe_ptr;
// libuv struct mappings
type request_wrapper = {
write_req: *uv_write_t,
req_buf: *~[uv_buf_t],
- read_chan: *comm::Chan<~str>
+ read_chan: *oldcomm::Chan<~str>
};
extern fn after_close_cb(handle: *libc::c_void) {
let bytes = vec::from_buf(buf_base, buf_len as uint);
let read_chan = *((*client_data).read_chan);
let msg_from_server = str::from_bytes(bytes);
- core::comm::send(read_chan, msg_from_server);
+ oldcomm::send(read_chan, msg_from_server);
close(stream as *libc::c_void, after_close_cb)
}
else if (nread == -1) {
}
fn impl_uv_tcp_request(ip: &str, port: int, req_str: &str,
- client_chan: *comm::Chan<~str>) unsafe {
+ client_chan: *oldcomm::Chan<~str>) unsafe {
let test_loop = loop_new();
let tcp_handle = tcp_t();
let tcp_handle_ptr = ptr::addr_of(&tcp_handle);
log(debug, ~"SERVER: sending response to client");
read_stop(client_stream_ptr);
let server_chan = *((*client_data).server_chan);
- core::comm::send(server_chan, request_str);
+ oldcomm::send(server_chan, request_str);
let write_result = write(
write_req,
client_stream_ptr as *libc::c_void,
server: *uv_tcp_t,
server_kill_msg: ~str,
server_resp_buf: *~[uv_buf_t],
- server_chan: *comm::Chan<~str>,
+ server_chan: *oldcomm::Chan<~str>,
server_write_req: *uv_write_t
};
type async_handle_data = {
- continue_chan: *comm::Chan<bool>
+ continue_chan: *oldcomm::Chan<bool>
};
extern fn async_close_cb(handle: *libc::c_void) {
async_handle as *libc::c_void) as *async_handle_data;
let continue_chan = *((*data).continue_chan);
let should_continue = status == 0i32;
- core::comm::send(continue_chan, should_continue);
+ oldcomm::send(continue_chan, should_continue);
close(async_handle as *libc::c_void, async_close_cb);
}
server_port: int,
+kill_server_msg: ~str,
+server_resp_msg: ~str,
- server_chan: *comm::Chan<~str>,
- continue_chan: *comm::Chan<bool>) unsafe {
+ server_chan: *oldcomm::Chan<~str>,
+ continue_chan: *oldcomm::Chan<bool>) unsafe {
let test_loop = loop_new();
let tcp_server = tcp_t();
let tcp_server_ptr = ptr::addr_of(&tcp_server);
let port = 8886;
let kill_server_msg = ~"does a dog have buddha nature?";
let server_resp_msg = ~"mu!";
- let client_port = core::comm::Port::<~str>();
- let client_chan = core::comm::Chan::<~str>(&client_port);
- let server_port = core::comm::Port::<~str>();
- let server_chan = core::comm::Chan::<~str>(&server_port);
+ let client_port = oldcomm::Port::<~str>();
+ let client_chan = oldcomm::Chan::<~str>(&client_port);
+ let server_port = oldcomm::Port::<~str>();
+ let server_chan = oldcomm::Chan::<~str>(&server_port);
- let continue_port = core::comm::Port::<bool>();
- let continue_chan = core::comm::Chan::<bool>(&continue_port);
+ let continue_port = oldcomm::Port::<bool>();
+ let continue_chan = oldcomm::Chan::<bool>(&continue_port);
let continue_chan_ptr = ptr::addr_of(&continue_chan);
do task::spawn_sched(task::ManualThreads(1)) {
// block until the server up is.. possibly a race?
log(debug, ~"before receiving on server continue_port");
- core::comm::recv(continue_port);
+ oldcomm::recv(continue_port);
log(debug, ~"received on continue port, set up tcp client");
do task::spawn_sched(task::ManualThreads(1u)) {
ptr::addr_of(&client_chan));
};
- let msg_from_client = core::comm::recv(server_port);
- let msg_from_server = core::comm::recv(client_port);
+ let msg_from_client = oldcomm::recv(server_port);
+ let msg_from_server = oldcomm::recv(client_port);
assert str::contains(msg_from_client, kill_server_msg);
assert str::contains(msg_from_server, server_resp_msg);
export foo;
-use core::comm::*;
+use core::oldcomm::*;
fn foo<T: Owned Copy>(x: T) -> Port<T> {
let p = Port();
// except according to those terms.
/*
- Minimized version of core::comm for testing.
+ Minimized version of core::oldcomm for testing.
Could probably be more minimal.
*/
/**
- * A communication endpoint that can receive messages
+ * A oldcommunication 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
use std::deque::Deque;
use std::par;
use io::WriterUtil;
-use comm::*;
+use oldcomm::*;
use int::abs;
type node_id = i64;
// that things will look really good once we get that lock out of the
// message path.
-use comm::*;
+use oldcomm::*;
extern mod std;
use std::time;
fn thread_ring(i: uint,
count: uint,
- num_chan: comm::Chan<uint>,
- num_port: comm::Port<uint>) {
+ num_chan: oldcomm::Chan<uint>,
+ num_port: oldcomm::Port<uint>) {
// Send/Receive lots of messages.
for uint::range(0u, count) |j| {
num_chan.send(i * j);
fn creature(
name: uint,
color: color,
- from_rendezvous: comm::Port<Option<creature_info>>,
- to_rendezvous: comm::Chan<creature_info>,
- to_rendezvous_log: comm::Chan<~str>
+ from_rendezvous: oldcomm::Port<Option<creature_info>>,
+ to_rendezvous: oldcomm::Chan<creature_info>,
+ to_rendezvous_log: oldcomm::Chan<~str>
) {
let mut color = color;
let mut creatures_met = 0;
loop {
// ask for a pairing
- comm::send(to_rendezvous, {name: name, color: color});
- let resp = comm::recv(from_rendezvous);
+ oldcomm::send(to_rendezvous, {name: name, color: color});
+ let resp = oldcomm::recv(from_rendezvous);
// log and change, or print and quit
match resp {
// log creatures met and evil clones of self
let report = fmt!("%u", creatures_met) + ~" " +
show_number(evil_clones_met);
- comm::send(to_rendezvous_log, report);
+ oldcomm::send(to_rendezvous_log, report);
break;
}
}
fn rendezvous(nn: uint, set: ~[color]) {
- pub fn spawn_listener<A: Send>(+f: fn~(
comm::Port<A>)) -> comm::Chan<A> {
- let setup_po = comm::Port();
- let setup_ch = comm::Chan(&setup_po);
+ pub fn spawn_listener<A: Send>(+f: fn~(
oldcomm::Port<A>)) -> oldcomm::Chan<A> {
+ let setup_po = oldcomm::Port();
+ let setup_ch = oldcomm::Chan(&setup_po);
do task::spawn |move f| {
- let po = comm::Port();
- let ch = comm::Chan(&po);
- comm::send(setup_ch, ch);
+ let po = oldcomm::Port();
+ let ch = oldcomm::Chan(&po);
+ oldcomm::send(setup_ch, ch);
f(move po);
}
- comm::recv(setup_po)
+ oldcomm::recv(setup_po)
}
// these ports will allow us to hear from the creatures
- let from_creatures: comm::Port<creature_info> = comm::Port();
- let from_creatures_log: comm::Port<~str> = comm::Port();
+ let from_creatures: oldcomm::Port<creature_info> = oldcomm::Port();
+ let from_creatures_log: oldcomm::Port<~str> = oldcomm::Port();
// these channels will be passed to the creatures so they can talk to us
- let to_rendezvous = comm::Chan(&from_creatures);
- let to_rendezvous_log = comm::Chan(&from_creatures_log);
+ let to_rendezvous = oldcomm::Chan(&from_creatures);
+ let to_rendezvous_log = oldcomm::Chan(&from_creatures_log);
// these channels will allow us to talk to each creature by 'name'/index
- let to_creature: ~[comm::Chan<Option<creature_info>>] =
+ let to_creature: ~[oldcomm::Chan<Option<creature_info>>] =
vec::mapi(set, |ii, col| {
// create each creature as a listener with a port, and
// give us a channel to talk to each
// set up meetings...
for nn.times {
- let fst_creature: creature_info = comm::recv(from_creatures);
- let snd_creature: creature_info = comm::recv(from_creatures);
+ let fst_creature: creature_info = oldcomm::recv(from_creatures);
+ let snd_creature: creature_info = oldcomm::recv(from_creatures);
creatures_met += 2;
- comm::send(to_creature[fst_creature.name], Some(snd_creature));
- comm::send(to_creature[snd_creature.name], Some(fst_creature));
+ oldcomm::send(to_creature[fst_creature.name], Some(snd_creature));
+ oldcomm::send(to_creature[snd_creature.name], Some(fst_creature));
}
// tell each creature to stop
for vec::eachi(to_creature) |_ii, to_one| {
- comm::send(*to_one, None);
+ oldcomm::send(*to_one, None);
}
// save each creature's meeting stats
let mut report = ~[];
for vec::each(to_creature) |_to_one| {
- report.push(comm::recv(from_creatures_log));
+ report.push(oldcomm::recv(from_creatures_log));
}
// print each color in the set
_ => { ~"" }
};
- //comm::send(to_parent, fmt!("yay{%u}", sz));
+ //oldcomm::send(to_parent, fmt!("yay{%u}", sz));
to_parent.send(move buffer);
}
rv
}
-fn chanmb(i: uint, size: uint, ch: comm::Chan<line>) -> ()
+fn chanmb(i: uint, size: uint, ch: oldcomm::Chan<line>) -> ()
{
let mut crv = ~[];
let incr = 2f64/(size as f64);
let x = cmplx {re: xincr*(j as f64) - 1.5f64, im: y};
crv.push(fillbyte(x, incr));
};
- comm::send(ch, {i:i, b:crv});
+ oldcomm::send(ch, {i:i, b:crv});
}
type devnull = {dn: int};
fn get_type() -> io::WriterType { io::File }
}
-fn writer(path: ~str, writech: comm::Chan<comm::Chan<line>>, size: uint)
+fn writer(path: ~str, writech: oldcomm::Chan<oldcomm::Chan<line>>, size: uint)
{
- let p: comm::Port<line> = comm::Port();
- let ch = comm::Chan(&p);
- comm::send(writech, ch);
+ let p: oldcomm::Port<line> = oldcomm::Port();
+ let ch = oldcomm::Chan(&p);
+ oldcomm::send(writech, ch);
let cout: io::Writer = match path {
~"" => {
{dn: 0} as io::Writer
let mut done = 0_u;
let mut i = 0_u;
while i < size {
- let aline = comm::recv(p);
+ let aline = oldcomm::recv(p);
if aline.i == done {
debug!("W %u", aline.i);
cout.write(aline.b);
let size = if vec::len(args) < 2_u { 80_u }
else { uint::from_str(args[1]).get() };
- let writep = comm::Port();
- let writech = comm::Chan(&writep);
+ let writep = oldcomm::Port();
+ let writech = oldcomm::Chan(&writep);
do task::spawn |move path| {
writer(copy path, writech, size);
};
- let ch = comm::recv(writep);
+ let ch = oldcomm::recv(writep);
for uint::range(0_u, size) |j| {
task::spawn(|| chanmb(j, size, ch) );
if j % yieldevery == 0_u {
A parallel version of fibonacci numbers.
This version is meant mostly as a way of stressing and benchmarking
- the task system. It supports a lot of command-line arguments to
+ the task system. It supports a lot of oldcommand-line arguments to
control how it runs.
*/
// Creates in the background 'num_tasks' tasks, all blocked forever.
// Doesn't return until all such tasks are ready, but doesn't block forever itself.
fn grandchild_group(num_tasks: uint) {
- let po = comm::Port();
- let ch = comm::Chan(&po);
+ let po = oldcomm::Port();
+ let ch = oldcomm::Chan(&po);
for num_tasks.times {
do task::spawn { // linked
- comm::send(ch, ());
- comm::recv(comm::Port::<()>()); // block forever
+ oldcomm::send(ch, ());
+ oldcomm::recv(oldcomm::Port::<()>()); // block forever
}
}
error!("Grandchild group getting started");
for num_tasks.times {
// Make sure all above children are fully spawned; i.e., enlisted in
// their ancestor groups.
- comm::recv(po);
+ oldcomm::recv(po);
}
error!("Grandchild group ready to go.");
// Master grandchild task exits early.
// Test for concurrent tasks
enum msg {
- ready(comm::Chan<msg>),
+ ready(oldcomm::Chan<msg>),
start,
done(int),
}
-fn calc(children: uint, parent_ch: comm::Chan<msg>) {
- let port = comm::Port();
- let chan = comm::Chan(&port);
+fn calc(children: uint, parent_ch: oldcomm::Chan<msg>) {
+ let port = oldcomm::Port();
+ let chan = oldcomm::Chan(&port);
let mut child_chs = ~[];
let mut sum = 0;
}
for iter::repeat (children) {
- match comm::recv(port) {
+ match oldcomm::recv(port) {
ready(child_ch) => {
child_chs.push(child_ch);
}
}
}
- comm::send(parent_ch, ready(chan));
+ oldcomm::send(parent_ch, ready(chan));
- match comm::recv(port) {
+ match oldcomm::recv(port) {
start => {
for vec::each(child_chs) |child_ch| {
- comm::send(*child_ch, start);
+ oldcomm::send(*child_ch, start);
}
}
_ => fail ~"task-perf-one-million failed (port not in start state)"
}
for iter::repeat (children) {
- match comm::recv(port) {
+ match oldcomm::recv(port) {
done(child_sum) => { sum += child_sum; }
_ => fail ~"task-perf-one-million failed (port not done)"
}
}
- comm::send(parent_ch, done(sum + 1));
+ oldcomm::send(parent_ch, done(sum + 1));
}
fn main() {
};
let children = uint::from_str(args[1]).get();
- let port = comm::Port();
- let chan = comm::Chan(&port);
+ let port = oldcomm::Port();
+ let chan = oldcomm::Chan(&port);
do task::spawn {
calc(children, chan);
};
- match comm::recv(port) {
+ match oldcomm::recv(port) {
ready(chan) => {
- comm::send(chan, start);
+ oldcomm::send(chan, start);
}
_ => fail ~"task-perf-one-million failed (port not ready)"
}
- let sum = match comm::recv(port) {
+ let sum = match oldcomm::recv(port) {
done(sum) => { sum }
_ => fail ~"task-perf-one-million failed (port not done)"
};
This is meant primarily to demonstrate Rust's MapReduce framework.
- It takes a list of files on the command line and outputs a list of
+ It takes a list of files on the oldcommand line and outputs a list of
words along with how many times each word is used.
*/
use std::time;
-use comm::Chan;
-use comm::Port;
-use comm::recv;
-use comm::send;
+use oldcomm::Chan;
+use oldcomm::Port;
+use oldcomm::recv;
+use oldcomm::send;
use cmp::Eq;
use to_bytes::IterBytes;
extern mod std;
use std::arc;
-use comm::*;
+use oldcomm::*;
fn main() {
let v = ~[1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
extern mod std;
use std::arc;
-use comm::*;
+use oldcomm::*;
fn main() {
let v = ~[1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
fn main() {
struct foo {
- _x: comm::Port<()>,
+ _x: oldcomm::Port<()>,
}
impl foo : Drop {
fn finalize(&self) {}
}
- fn foo(x: comm::Port<()>) -> foo {
+ fn foo(x: oldcomm::Port<()>) -> foo {
foo {
_x: x
}
}
- let x = ~mut Some(foo(comm::Port()));
+ let x = ~mut Some(foo(oldcomm::Port()));
do task::spawn |move x| { //~ ERROR not a sendable value
let mut y = None;
fn main() {
let cat = ~"kitty";
- let po = comm::Port(); //~ ERROR missing `owned`
- let ch = comm::Chan(&po); //~ ERROR missing `owned`
- comm::send(ch, foo(42, @(move cat))); //~ ERROR missing `owned`
+ let po = oldcomm::Port(); //~ ERROR missing `owned`
+ let ch = oldcomm::Chan(&po); //~ ERROR missing `owned`
+ oldcomm::send(ch, foo(42, @(move cat))); //~ ERROR missing `owned`
}
// error-pattern:1 == 2
extern mod std;
-use comm::Port;
-use comm::recv;
+use oldcomm::Port;
+use oldcomm::recv;
fn child() { assert (1 == 2); }
// error-pattern:fail
extern mod std;
-use comm::Chan;
-use comm::Port;
-use comm::recv;
+use oldcomm::Chan;
+use oldcomm::Port;
+use oldcomm::recv;
fn child() { fail; }
// error-pattern:fail
extern mod std;
-use comm::Port;
-use comm::recv;
+use oldcomm::Port;
+use oldcomm::recv;
fn grandchild() { fail ~"grandchild dies"; }
// error-pattern:1 == 2
extern mod std;
-use comm::Chan;
-use comm::Port;
-use comm::recv;
+use oldcomm::Chan;
+use oldcomm::Port;
+use oldcomm::recv;
fn child() { assert (1 == 2); }
// error-pattern:meep
extern mod std;
-use comm::Chan;
-use comm::Port;
-use comm::send;
-use comm::recv;
+use oldcomm::Chan;
+use oldcomm::Port;
+use oldcomm::send;
+use oldcomm::recv;
fn echo<T: Owned>(c: Chan<T>, oc: Chan<Chan<T>>) {
// Tests that the type argument in port gets
fn main() {
task::spawn(|| goodfail() );
- let po = comm::Port();
+ let po = oldcomm::Port();
// We shouldn't be able to get past this recv since there's no
// message available
- let i: int = comm::recv(po);
+ let i: int = oldcomm::recv(po);
fail ~"badfail";
}
extern mod std;
-fn f(c: comm::_chan<int>) {
+fn f(c: oldcomm::_chan<int>) {
type t = {_0: int, _1: int, _2: int};
// Allocate a box.
let x: @t = @{_0: 1, _1: 2, _2: 3};
// Signal parent that we've allocated a box.
- comm::send(c, 1);
+ oldcomm::send(c, 1);
loop {
// sending to the channel are never received
// by the parent, therefore this test cases drops
// messages on the floor
- comm::send(c, 1);
+ oldcomm::send(c, 1);
}
}
fn main() {
- let p = comm::mk_port();
+ let p = oldcomm::mk_port();
task::_spawn(bind f(p.mk_chan()));
let i: int;
extern mod std;
// These tests used to be separate files, but I wanted to refactor all
-// the common code.
+// the oldcommon code.
use cmp::Eq;
use std::ebml;
// except according to those terms.
-fn a(c: core::comm::Chan<int>) { core::comm::send(c, 10); }
+fn a(c: core::oldcomm::Chan<int>) { core::oldcomm::send(c, 10); }
fn main() {
- let p = core::comm::Port();
- let ch = core::comm::Chan(&p);
+ let p = core::oldcomm::Port();
+ let ch = core::oldcomm::Chan(&p);
task::spawn(|| a(ch) );
task::spawn(|| a(ch) );
let mut n: int = 0;
- n = core::comm::recv(p);
- n = core::comm::recv(p);
+ n = core::oldcomm::recv(p);
+ n = core::oldcomm::recv(p);
// debug!("Finished.");
}
-fn b(c: core::comm::Chan<int>) {
+fn b(c: core::oldcomm::Chan<int>) {
// debug!("task b0");
// debug!("task b1");
// debug!("task b2");
// debug!("task b3");
// debug!("task b4");
// debug!("task b5");
- core::comm::send(c, 10);
+ core::oldcomm::send(c, 10);
}
// except according to those terms.
-fn a(c: core::comm::Chan<int>) {
+fn a(c: core::oldcomm::Chan<int>) {
debug!("task a0");
debug!("task a1");
- core::comm::send(c, 10);
+ core::oldcomm::send(c, 10);
}
fn main() {
- let p = core::comm::Port();
- let ch = core::comm::Chan(&p);
+ let p = core::oldcomm::Port();
+ let ch = core::oldcomm::Chan(&p);
task::spawn(|| a(ch) );
task::spawn(|| b(ch) );
let mut n: int = 0;
- n = core::comm::recv(p);
- n = core::comm::recv(p);
+ n = core::oldcomm::recv(p);
+ n = core::oldcomm::recv(p);
debug!("Finished.");
}
-fn b(c: core::comm::Chan<int>) {
+fn b(c: core::oldcomm::Chan<int>) {
debug!("task b0");
debug!("task b1");
debug!("task b2");
debug!("task b2");
debug!("task b3");
- core::comm::send(c, 10);
+ core::oldcomm::send(c, 10);
}
// except according to those terms.
-fn a(c: core::comm::Chan<int>) {
+fn a(c: core::oldcomm::Chan<int>) {
if true {
debug!("task a");
debug!("task a");
debug!("task a");
debug!("task a");
}
- core::comm::send(c, 10);
+ core::oldcomm::send(c, 10);
}
fn k(x: int) -> int { return 15; }
fn main() {
let mut n: int = 2 + 3 * 7;
let s: ~str = ~"hello there";
- let p = comm::Port();
- let ch = core::comm::Chan(&p);
+ let p = oldcomm::Port();
+ let ch = core::oldcomm::Chan(&p);
task::spawn(|| a(ch) );
task::spawn(|| b(ch) );
let mut x: int = 10;
x = g(n, s);
log(debug, x);
- n = core::comm::recv(p);
- n = core::comm::recv(p);
+ n = core::oldcomm::recv(p);
+ n = core::oldcomm::recv(p);
debug!("children finished, root finishing");
}
-fn b(c: core::comm::Chan<int>) {
+fn b(c: core::oldcomm::Chan<int>) {
if true {
debug!("task b");
debug!("task b");
debug!("task b");
debug!("task b");
}
- core::comm::send(c, 10);
+ core::oldcomm::send(c, 10);
}
// course preferable, as the value itself is
// irrelevant).
-fn foo(&&x: ()) -> core::comm::Port<()> {
- let p = core::comm::Port();
- let c = core::comm::Chan(&p);
+fn foo(&&x: ()) -> core::oldcomm::Port<()> {
+ let p = core::oldcomm::Port();
+ let c = core::oldcomm::Chan(&p);
do task::spawn() |copy c, copy x| {
c.send(x);
}
extern mod cci_capture_clause;
-use comm::recv;
+use oldcomm::recv;
fn main() {
cci_capture_clause::foo(()).recv()
// Issue #763
-enum request { quit, close(core::comm::Chan<bool>), }
+enum request { quit, close(core::oldcomm::Chan<bool>), }
-type ctx = core::comm::Chan<request>;
+type ctx = core::oldcomm::Chan<request>;
-fn request_task(c: core::comm::Chan<ctx>) {
- let p = core::comm::Port();
- core::comm::send(c, core::comm::Chan(&p));
+fn request_task(c: core::oldcomm::Chan<ctx>) {
+ let p = core::oldcomm::Port();
+ core::oldcomm::send(c, core::oldcomm::Chan(&p));
let mut req: request;
- req = core::comm::recv(p);
+ req = core::oldcomm::recv(p);
// Need to drop req before receiving it again
- req = core::comm::recv(p);
+ req = core::oldcomm::recv(p);
}
fn new_cx() -> ctx {
- let p = core::comm::Port();
- let ch = core::comm::Chan(&p);
+ let p = core::oldcomm::Port();
+ let ch = core::oldcomm::Chan(&p);
let t = task::spawn(|| request_task(ch) );
let mut cx: ctx;
- cx = core::comm::recv(p);
+ cx = core::oldcomm::recv(p);
return cx;
}
fn main() {
let cx = new_cx();
- let p = core::comm::Port::<bool>();
- core::comm::send(cx, close(core::comm::Chan(&p)));
- core::comm::send(cx, quit);
+ let p = core::oldcomm::Port::<bool>();
+ core::oldcomm::send(cx, close(core::oldcomm::Chan(&p)));
+ core::oldcomm::send(cx, quit);
}
fn main() {
- let p = comm::Port();
- let ch = core::comm::Chan(&p);
+ let p = oldcomm::Port();
+ let ch = core::oldcomm::Chan(&p);
let t = task::spawn(|| child(ch) );
- let y = core::comm::recv(p);
+ let y = core::oldcomm::recv(p);
error!("received");
log(error, y);
assert (y == 10);
}
-fn child(c: core::comm::Chan<int>) {
+fn child(c: core::oldcomm::Chan<int>) {
error!("sending");
- core::comm::send(c, 10);
+ core::oldcomm::send(c, 10);
error!("value sent");
}
fn main() {
- let po = core::comm::Port();
- let ch = core::comm::Chan(&po);
- core::comm::send(ch, 10);
- let i = core::comm::recv(po);
+ let po = core::oldcomm::Port();
+ let ch = core::oldcomm::Chan(&po);
+ core::oldcomm::send(ch, 10);
+ let i = core::oldcomm::recv(po);
assert (i == 10);
- core::comm::send(ch, 11);
- let j = core::comm::recv(po);
+ core::oldcomm::send(ch, 11);
+ let j = core::oldcomm::recv(po);
assert (j == 11);
}
use std::map;
use std::map::HashMap;
-use comm::Chan;
-use comm::Port;
-use comm::send;
-use comm::recv;
+use oldcomm::Chan;
+use oldcomm::Port;
+use oldcomm::send;
+use oldcomm::recv;
fn map(filename: ~str, emit: map_reduce::putter) { emit(filename, ~"1"); }
https://github.com/graydon/rust/issues/507
*/
-fn grandchild(c: core::comm::Chan<int>) { core::comm::send(c, 42); }
+fn grandchild(c: core::oldcomm::Chan<int>) { core::oldcomm::send(c, 42); }
-fn child(c: core::comm::Chan<int>) {
+fn child(c: core::oldcomm::Chan<int>) {
task::spawn(|| grandchild(c) )
}
fn main() {
- let p = core::comm::Port();
- let ch = core::comm::Chan(&p);
+ let p = core::oldcomm::Port();
+ let ch = core::oldcomm::Chan(&p);
task::spawn(|| child(ch) );
- let x: int = core::comm::recv(p);
+ let x: int = core::oldcomm::recv(p);
log(debug, x);
enum msg { closed, received(~[u8]), }
-fn producer(c: core::comm::Chan<~[u8]>) {
- core::comm::send(c, ~[1u8, 2u8, 3u8, 4u8]);
+fn producer(c: core::oldcomm::Chan<~[u8]>) {
+ core::oldcomm::send(c, ~[1u8, 2u8, 3u8, 4u8]);
let empty: ~[u8] = ~[];
- core::comm::send(c, empty);
+ core::oldcomm::send(c, empty);
}
-fn packager(cb: core::comm::Chan<core::comm::Chan<~[u8]>>, msg: core::comm::Chan<msg>) {
- let p: core::comm::Port<~[u8]> = core::comm::Port();
- core::comm::send(cb, core::comm::Chan(&p));
+fn packager(cb: core::oldcomm::Chan<core::oldcomm::Chan<~[u8]>>, msg: core::oldcomm::Chan<msg>) {
+ let p: core::oldcomm::Port<~[u8]> = core::oldcomm::Port();
+ core::oldcomm::send(cb, core::oldcomm::Chan(&p));
loop {
debug!("waiting for bytes");
- let data = core::comm::recv(p);
+ let data = core::oldcomm::recv(p);
debug!("got bytes");
if vec::len(data) == 0u {
debug!("got empty bytes, quitting");
}
debug!("sending non-empty buffer of length");
log(debug, vec::len(data));
- core::comm::send(msg, received(data));
+ core::oldcomm::send(msg, received(data));
debug!("sent non-empty buffer");
}
debug!("sending closed message");
- core::comm::send(msg, closed);
+ core::oldcomm::send(msg, closed);
debug!("sent closed message");
}
fn main() {
- let p: core::comm::Port<msg> = core::comm::Port();
- let ch = core::comm::Chan(&p);
- let recv_reader: core::comm::Port<core::comm::Chan<~[u8]>> = core::comm::Port();
- let recv_reader_chan = core::comm::Chan(&recv_reader);
+ let p: core::oldcomm::Port<msg> = core::oldcomm::Port();
+ let ch = core::oldcomm::Chan(&p);
+ let recv_reader: core::oldcomm::Port<core::oldcomm::Chan<~[u8]>> = core::oldcomm::Port();
+ let recv_reader_chan = core::oldcomm::Chan(&recv_reader);
let pack = task::spawn(|| packager(recv_reader_chan, ch) );
- let source_chan: core::comm::Chan<~[u8]> = core::comm::recv(recv_reader);
+ let source_chan: core::oldcomm::Chan<~[u8]> = core::oldcomm::recv(recv_reader);
let prod = task::spawn(|| producer(source_chan) );
loop {
- let msg = core::comm::recv(p);
+ let msg = core::oldcomm::recv(p);
match msg {
closed => { debug!("Got close message"); break; }
received(data) => {
fn a() {
fn doit() {
- fn b(c: core::comm::Chan<core::comm::Chan<int>>) {
- let p = core::comm::Port();
- core::comm::send(c, core::comm::Chan(&p));
+ fn b(c: core::oldcomm::Chan<core::oldcomm::Chan<int>>) {
+ let p = core::oldcomm::Port();
+ core::oldcomm::send(c, core::oldcomm::Chan(&p));
}
- let p = core::comm::Port();
- let ch = core::comm::Chan(&p);
+ let p = core::oldcomm::Port();
+ let ch = core::oldcomm::Chan(&p);
task::spawn(|| b(ch) );
- core::comm::recv(p);
+ core::oldcomm::recv(p);
}
let mut i = 0;
while i < 100 {
-fn producer(c: core::comm::Chan<~[u8]>) {
- core::comm::send(c,
+fn producer(c: core::oldcomm::Chan<~[u8]>) {
+ core::oldcomm::send(c,
~[1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8, 8u8, 9u8, 10u8, 11u8, 12u8,
13u8]);
}
fn main() {
- let p: core::comm::Port<~[u8]> = core::comm::Port();
- let ch = core::comm::Chan(&p);
+ let p: core::oldcomm::Port<~[u8]> = core::oldcomm::Port();
+ let ch = core::oldcomm::Chan(&p);
let prod = task::spawn(|| producer(ch) );
- let data: ~[u8] = core::comm::recv(p);
+ let data: ~[u8] = core::oldcomm::recv(p);
}
// except according to those terms.
fn main() {
- let p = core::comm::Port();
- let ch = core::comm::Chan(&p);
+ let p = core::oldcomm::Port();
+ let ch = core::oldcomm::Chan(&p);
let mut y: int;
task::spawn(|| child(ch) );
- y = core::comm::recv(p);
+ y = core::oldcomm::recv(p);
debug!("received 1");
log(debug, y);
assert (y == 10);
task::spawn(|| child(ch) );
- y = core::comm::recv(p);
+ y = core::oldcomm::recv(p);
debug!("received 2");
log(debug, y);
assert (y == 10);
}
-fn child(c: core::comm::Chan<int>) { core::comm::send(c, 10); }
+fn child(c: core::oldcomm::Chan<int>) { core::oldcomm::send(c, 10); }
extern mod std;
-fn sub(parent: comm::Chan<int>, id: int) {
+fn sub(parent: oldcomm::Chan<int>, id: int) {
if id == 0 {
- comm::send(parent, 0);
+ oldcomm::send(parent, 0);
} else {
- let p = comm::Port();
- let ch = comm::Chan(&p);
+ let p = oldcomm::Port();
+ let ch = oldcomm::Chan(&p);
let child = task::spawn(|| sub(ch, id - 1) );
- let y = comm::recv(p);
- comm::send(parent, y + 1);
+ let y = oldcomm::recv(p);
+ oldcomm::send(parent, y + 1);
}
}
fn main() {
- let p = comm::Port();
- let ch = comm::Chan(&p);
+ let p = oldcomm::Port();
+ let ch = oldcomm::Chan(&p);
let child = task::spawn(|| sub(ch, 200) );
- let y = comm::recv(p);
+ let y = oldcomm::recv(p);
debug!("transmission complete");
log(debug, y);
assert (y == 200);
/*
- * This is a multi-line comment.
+ * This is a multi-line oldcomment.
*/
fn main() { }
// Regression tests for circular_buffer when using a unit
// that has a size that is not a power of two
-// A 12-byte unit to core::comm::send over the channel
+// A 12-byte unit to core::oldcomm::send over the channel
type record = {val1: u32, val2: u32, val3: u32};
// power of two so needs to be rounded up. Don't trigger any
// assertions.
fn test_init() {
- let myport = core::comm::Port();
- let mychan = core::comm::Chan(&myport);
+ let myport = core::oldcomm::Port();
+ let mychan = core::oldcomm::Chan(&myport);
let val: record = {val1: 0u32, val2: 0u32, val3: 0u32};
- core::comm::send(mychan, val);
+ core::oldcomm::send(mychan, val);
}
// Dump lots of items into the channel so it has to grow.
// Don't trigger any assertions.
fn test_grow() {
- let myport = core::comm::Port();
- let mychan = core::comm::Chan(&myport);
+ let myport = core::oldcomm::Port();
+ let mychan = core::oldcomm::Chan(&myport);
for uint::range(0u, 100u) |i| {
let val: record = {val1: 0u32, val2: 0u32, val3: 0u32};
- core::comm::send(mychan, val);
+ core::oldcomm::send(mychan, val);
}
}
// Don't allow the buffer to shrink below it's original size
fn test_shrink1() {
- let myport = core::comm::Port();
- let mychan = core::comm::Chan(&myport);
- core::comm::send(mychan, 0i8);
- let x = core::comm::recv(myport);
+ let myport = core::oldcomm::Port();
+ let mychan = core::oldcomm::Chan(&myport);
+ core::oldcomm::send(mychan, 0i8);
+ let x = core::oldcomm::recv(myport);
}
fn test_shrink2() {
- let myport = core::comm::Port();
- let mychan = core::comm::Chan(&myport);
+ let myport = core::oldcomm::Port();
+ let mychan = core::oldcomm::Chan(&myport);
for uint::range(0u, 100u) |_i| {
let val: record = {val1: 0u32, val2: 0u32, val3: 0u32};
- core::comm::send(mychan, val);
+ core::oldcomm::send(mychan, val);
}
- for uint::range(0u, 100u) |_i| { let x = core::comm::recv(myport); }
+ for uint::range(0u, 100u) |_i| { let x = core::oldcomm::recv(myport); }
}
// Test rotating the buffer when the unit size is not a power of two
fn test_rotate() {
- let myport = core::comm::Port();
- let mychan = core::comm::Chan(&myport);
+ let myport = core::oldcomm::Port();
+ let mychan = core::oldcomm::Chan(&myport);
for uint::range(0u, 100u) |i| {
let val = {val1: i as u32, val2: i as u32, val3: i as u32};
- core::comm::send(mychan, val);
- let x = core::comm::recv(myport);
+ core::oldcomm::send(mychan, val);
+ let x = core::oldcomm::recv(myport);
assert (x.val1 == i as u32);
assert (x.val2 == i as u32);
assert (x.val3 == i as u32);
// Test rotating and growing the buffer when
// the unit size is not a power of two
fn test_rotate_grow() {
- let myport = core::comm::Port::<record>();
- let mychan = core::comm::Chan(&myport);
+ let myport = core::oldcomm::Port::<record>();
+ let mychan = core::oldcomm::Chan(&myport);
for uint::range(0u, 10u) |j| {
for uint::range(0u, 10u) |i| {
let val: record =
{val1: i as u32, val2: i as u32, val3: i as u32};
- core::comm::send(mychan, val);
+ core::oldcomm::send(mychan, val);
}
for uint::range(0u, 10u) |i| {
- let x = core::comm::recv(myport);
+ let x = core::oldcomm::recv(myport);
assert (x.val1 == i as u32);
assert (x.val2 == i as u32);
assert (x.val3 == i as u32);
}
fn main() unsafe {
- let po = comm::Port();
- let ch = comm::Chan(&po);
+ let po = oldcomm::Port();
+ let ch = oldcomm::Chan(&po);
let parent_sched_id = rustrt::rust_get_sched_id();
error!("parent %?", parent_sched_id);
let num_threads = 1u;
error!("child_sched_id %?", child_sched_id);
assert child_sched_id != parent_sched_id;
assert child_sched_id == new_sched_id;
- comm::send(ch, ());
+ oldcomm::send(ch, ());
};
let fptr = cast::reinterpret_cast(&ptr::addr_of(&f));
rustrt::start_task(new_task_id, fptr);
cast::forget(move f);
- comm::recv(po);
+ oldcomm::recv(po);
}
fn iloop() {
task::spawn(|| die() );
- let p = comm::Port::<()>();
- let c = comm::Chan(&p);
+ let p = oldcomm::Port::<()>();
+ let c = oldcomm::Chan(&p);
loop {
// Sending and receiving here because these actions yield,
// at which point our child can kill us
- comm::send(c, ());
- comm::recv(p);
+ oldcomm::send(c, ());
+ oldcomm::recv(p);
}
}
}
fn main() {
- let p = core::comm::Port();
- let c = core::comm::Chan(&p);
+ let p = core::oldcomm::Port();
+ let c = core::oldcomm::Chan(&p);
do task::spawn() {
- let p = core::comm::Port();
- c.send(core::comm::Chan(&p));
+ let p = core::oldcomm::Port();
+ c.send(core::oldcomm::Chan(&p));
let _r = p.recv();
}
// tests that ctrl's type gets inferred properly
type command<K: Owned, V: Owned> = {key: K, val: V};
-fn cache_server<K: Owned, V: Owned>(c: core::comm::Chan<core::comm::Chan<command<K, V>>>) {
- let ctrl = core::comm::Port();
- core::comm::send(c, core::comm::Chan(&ctrl));
+fn cache_server<K: Owned, V: Owned>(c: oldcomm::Chan<oldcomm::Chan<command<K, V>>>) {
+ let ctrl = oldcomm::Port();
+ oldcomm::send(c, oldcomm::Chan(&ctrl));
}
fn main() { }
}
fn main() {
- let po = comm::Port::<foo>();
- let ch = comm::Chan(&po);
- comm::send(ch, foo(42, 'c'));
+ let po = oldcomm::Port::<foo>();
+ let ch = oldcomm::Chan(&po);
+ oldcomm::send(ch, foo(42, 'c'));
}
\ No newline at end of file
extern mod std;
-use comm::Chan;
-use comm::send;
+use oldcomm::Chan;
+use oldcomm::send;
fn main() { test05(); }
extern mod std;
-type ctx = comm::Chan<int>;
+type ctx = oldcomm::Chan<int>;
fn iotask(cx: ctx, ip: ~str) {
assert (ip == ~"localhost");
}
fn main() {
- let p = comm::Port::<int>();
- let ch = comm::Chan(&p);
+ let p = oldcomm::Port::<int>();
+ let ch = oldcomm::Chan(&p);
task::spawn(|| iotask(ch, ~"localhost") );
}
extern mod std;
fn main() {
- let p = comm::Port();
- let c = comm::Chan(&p);
- comm::send(c, ~"coffee");
+ let p = oldcomm::Port();
+ let c = oldcomm::Chan(&p);
+ oldcomm::send(c, ~"coffee");
}
\ No newline at end of file
extern mod std;
fn main() {
- let p = comm::Port();
- let c = comm::Chan(&p);
- comm::send(c, ~"coffee");
+ let p = oldcomm::Port();
+ let c = oldcomm::Chan(&p);
+ oldcomm::send(c, ~"coffee");
}
\ No newline at end of file
fn main() {
let c = {
- let p = comm::Port();
- comm::Chan(&p)
+ let p = oldcomm::Port();
+ oldcomm::Chan(&p)
};
- comm::send(c, ~"coffee");
+ oldcomm::send(c, ~"coffee");
}
\ No newline at end of file
// We're trying to trigger a race between send and port destruction that
// results in the string not being freed
-fn starship(&&ch: comm::Chan<~str>) {
+fn starship(&&ch: oldcomm::Chan<~str>) {
for int::range(0, 10) |_i| {
- comm::send(ch, ~"pew pew");
+ oldcomm::send(ch, ~"pew pew");
}
}
fn starbase() {
for int::range(0, 10) |_i| {
- let p = comm::Port();
- let c = comm::Chan(&p);
+ let p = oldcomm::Port();
+ let c = oldcomm::Chan(&p);
task::spawn(|| starship(c) );
task::yield();
}
// any size, but rustc currently can because they do have size. Whether
// or not this is desirable I don't know, but here's a regression test.
fn main() {
- let po = comm::Port();
- let ch = comm::Chan(&po);
- comm::send(ch, ());
- let n: () = comm::recv(po);
+ let po = oldcomm::Port();
+ let ch = oldcomm::Chan(&po);
+ oldcomm::send(ch, ());
+ let n: () = oldcomm::recv(po);
assert (n == ());
}
test06();
}
-fn test00_start(ch: core::comm::Chan<int>, message: int, count: int) {
+fn test00_start(ch: core::oldcomm::Chan<int>, message: int, count: int) {
debug!("Starting test00_start");
let mut i: int = 0;
while i < count {
debug!("Sending Message");
- core::comm::send(ch, message + 0);
+ core::oldcomm::send(ch, message + 0);
i = i + 1;
}
debug!("Ending test00_start");
let number_of_messages: int = 4;
debug!("Creating tasks");
- let po = core::comm::Port();
- let ch = core::comm::Chan(&po);
+ let po = core::oldcomm::Port();
+ let ch = core::oldcomm::Chan(&po);
let mut i: int = 0;
let mut sum: int = 0;
for results.each |r| {
i = 0;
- while i < number_of_messages { sum += core::comm::recv(po); i = i + 1; }
+ while i < number_of_messages { sum += core::oldcomm::recv(po); i = i + 1; }
}
for results.each |r| { r.recv(); }
}
fn test01() {
- let p = core::comm::Port();
+ let p = core::oldcomm::Port();
debug!("Reading from a port that is never written to.");
- let value: int = core::comm::recv(p);
+ let value: int = core::oldcomm::recv(p);
log(debug, value);
}
fn test02() {
- let p = core::comm::Port();
- let c = core::comm::Chan(&p);
+ let p = core::oldcomm::Port();
+ let c = core::oldcomm::Chan(&p);
debug!("Writing to a local task channel.");
- core::comm::send(c, 42);
+ core::oldcomm::send(c, 42);
debug!("Reading from a local task port.");
- let value: int = core::comm::recv(p);
+ let value: int = core::oldcomm::recv(p);
log(debug, value);
}
debug!("Finishing up.");
}
-fn test05_start(ch: core::comm::Chan<int>) {
- core::comm::send(ch, 10);
- core::comm::send(ch, 20);
- core::comm::send(ch, 30);
- core::comm::send(ch, 30);
- core::comm::send(ch, 30);
+fn test05_start(ch: core::oldcomm::Chan<int>) {
+ core::oldcomm::send(ch, 10);
+ core::oldcomm::send(ch, 20);
+ core::oldcomm::send(ch, 30);
+ core::oldcomm::send(ch, 30);
+ core::oldcomm::send(ch, 30);
}
fn test05() {
- let po = core::comm::Port();
- let ch = core::comm::Chan(&po);
+ let po = core::oldcomm::Port();
+ let ch = core::oldcomm::Chan(&po);
task::spawn(|| test05_start(ch) );
let mut value: int;
- value = core::comm::recv(po);
- value = core::comm::recv(po);
- value = core::comm::recv(po);
+ value = core::oldcomm::recv(po);
+ value = core::oldcomm::recv(po);
+ value = core::oldcomm::recv(po);
log(debug, value);
}
fn child() { }
struct notify {
- ch: comm::Chan<bool>, v: @mut bool,
+ ch: oldcomm::Chan<bool>, v: @mut bool,
}
impl notify : Drop {
task::failing(),
*(self.v));
let b = *(self.v);
- comm::send(self.ch, b);
+ oldcomm::send(self.ch, b);
}
}
-fn notify(ch: comm::Chan<bool>, v: @mut bool) -> notify {
+fn notify(ch: oldcomm::Chan<bool>, v: @mut bool) -> notify {
notify {
ch: ch,
v: v
}
}
-fn joinable(+f: fn~()) -> comm::Port<bool> {
- fn wrapper(+c: comm::Chan<bool>, +f: fn()) {
+fn joinable(+f: fn~()) -> oldcomm::Port<bool> {
+ fn wrapper(+c: oldcomm::Chan<bool>, +f: fn()) {
let b = @mut false;
error!("wrapper: task=%? allocated v=%x",
task::get_task(),
f();
*b = true;
}
- let p = comm::Port();
- let c = comm::Chan(&p);
+ let p = oldcomm::Port();
+ let c = oldcomm::Chan(&p);
do task::spawn_unlinked { wrapper(c, copy f) };
p
}
-fn join(port: comm::Port<bool>) -> bool {
- comm::recv(port)
+fn join(port: oldcomm::Port<bool>) -> bool {
+ oldcomm::recv(port)
}
fn main() {
let p1;
let p2;
- p1 = comm::Port::<int>();
- p2 = comm::Port::<int>();
+ p1 = oldcomm::Port::<int>();
+ p2 = oldcomm::Port::<int>();
assert (p1 == p1);
assert (p1 != p2);
// channels
- let c1 = comm::Chan(p1);
- let c2 = comm::Chan(p2);
+ let c1 = oldcomm::Chan(p1);
+ let c2 = oldcomm::Chan(p2);
assert (c1 == c1);
assert (c1 != c2);
// the join.
struct notify {
- ch: comm::Chan<bool>, v: @mut bool,
+ ch: oldcomm::Chan<bool>, v: @mut bool,
}
impl notify : Drop {
task::failing(),
*(self.v));
let b = *(self.v);
- comm::send(self.ch, b);
+ oldcomm::send(self.ch, b);
}
}
-fn notify(ch: comm::Chan<bool>, v: @mut bool) -> notify {
+fn notify(ch: oldcomm::Chan<bool>, v: @mut bool) -> notify {
notify {
ch: ch,
v: v
}
}
-fn joinable(+f: fn~()) -> comm::Port<bool> {
- fn wrapper(+c: comm::Chan<bool>, +f: fn()) {
+fn joinable(+f: fn~()) -> oldcomm::Port<bool> {
+ fn wrapper(+c: oldcomm::Chan<bool>, +f: fn()) {
let b = @mut false;
error!("wrapper: task=%? allocated v=%x",
task::get_task(),
f();
*b = true;
}
- let p = comm::Port();
- let c = comm::Chan(&p);
+ let p = oldcomm::Port();
+ let c = oldcomm::Chan(&p);
do task::spawn_unlinked { wrapper(c, f) };
p
}
-fn join(port: comm::Port<bool>) -> bool {
- comm::recv(port)
+fn join(port: oldcomm::Port<bool>) -> bool {
+ oldcomm::recv(port)
}
fn supervised() {
// except according to those terms.
fn main() {
- let p = comm::Port::<uint>();
- let ch = comm::Chan(&p);
+ let p = oldcomm::Port::<uint>();
+ let ch = oldcomm::Chan(&p);
let x = ~1;
let x_in_parent = ptr::addr_of(&(*x)) as uint;
task::spawn(fn~(copy ch, copy y, move x) {
let x_in_child = ptr::addr_of(&(*x)) as uint;
- comm::send(ch, x_in_child);
+ oldcomm::send(ch, x_in_child);
let y_in_child = ptr::addr_of(&(*y)) as uint;
- comm::send(ch, y_in_child);
+ oldcomm::send(ch, y_in_child);
});
// Ensure last-use analysis doesn't move y to child.
let _q = y;
- let x_in_child = comm::recv(p);
+ let x_in_child = oldcomm::recv(p);
assert x_in_parent == x_in_child;
- let y_in_child = comm::recv(p);
+ let y_in_child = oldcomm::recv(p);
assert y_in_parent != y_in_child;
}
extern mod std;
-fn child(c: comm::Chan<~uint>, i: uint) {
- comm::send(c, ~i);
+fn child(c: oldcomm::Chan<~uint>, i: uint) {
+ oldcomm::send(c, ~i);
}
fn main() {
- let p = comm::Port();
- let ch = comm::Chan(&p);
+ let p = oldcomm::Port();
+ let ch = oldcomm::Chan(&p);
let n = 100u;
let mut expected = 0u;
for uint::range(0u, n) |i| {
let mut actual = 0u;
for uint::range(0u, n) |_i| {
- let j = comm::recv(p);
+ let j = oldcomm::recv(p);
actual += *j;
}
extern mod std;
fn main() {
- let p = comm::Port();
- let c = comm::Chan(&p);
- comm::send(c, ~100);
- let v = comm::recv(p);
+ let p = oldcomm::Port();
+ let c = oldcomm::Chan(&p);
+ oldcomm::send(c, ~100);
+ let v = oldcomm::recv(p);
assert v == ~100;
}
\ No newline at end of file
extern mod std;
struct complainer {
- c: comm::Chan<bool>,
+ c: oldcomm::Chan<bool>,
}
impl complainer : Drop {
fn finalize(&self) {
error!("About to send!");
- comm::send(self.c, true);
+ oldcomm::send(self.c, true);
error!("Sent!");
}
}
-fn complainer(c: comm::Chan<bool>) -> complainer {
+fn complainer(c: oldcomm::Chan<bool>) -> complainer {
error!("Hello!");
complainer {
c: c
}
}
-fn f(c: comm::Chan<bool>) {
+fn f(c: oldcomm::Chan<bool>) {
let _c = move complainer(c);
fail;
}
fn main() {
- let p = comm::Port();
- let c = comm::Chan(&p);
+ let p = oldcomm::Port();
+ let c = oldcomm::Chan(&p);
task::spawn_unlinked(|| f(c) );
error!("hiiiiiiiii");
- assert comm::recv(p);
+ assert oldcomm::recv(p);
}
#[captain]
jean_luc_picard,
- #[commander]
+ #[oldcommander]
william_t_riker,
#[chief_medical_officer]
#[ships_councellor]
deanna_troi,
- #[lieutenant_commander]
+ #[lieutenant_oldcommander]
data,
#[chief_of_security]
projects / rust.git / commitdiff