diff --git a/doc/tutorial-tasks.md b/doc/tutorial-tasks.md index 799fcb99fd0..d29eb8a98fd 100644 --- a/doc/tutorial-tasks.md +++ b/doc/tutorial-tasks.md @@ -461,7 +461,7 @@ and child both need to exchange messages with each other. The function `std::comm::DuplexStream()` supports this pattern. We'll look briefly at how to use it. -To see how `spawn_conversation()` works, we will create a child task +To see how `DuplexStream()` works, we will create a child task that repeatedly receives a `uint` message, converts it to a string, and sends the string in response. The child terminates when it receives `0`. Here is the function that implements the child task: diff --git a/src/libcore/core.rc b/src/libcore/core.rc index eb7d753ea08..70d6e0898c7 100644 --- a/src/libcore/core.rc +++ b/src/libcore/core.rc @@ -139,7 +139,7 @@ pub mod send_map; /* Tasks and communication */ -pub mod comm; +pub mod oldcomm; #[path = "task/mod.rs"] pub mod task; pub mod pipes; diff --git a/src/libcore/comm.rs b/src/libcore/oldcomm.rs similarity index 98% rename from src/libcore/comm.rs rename to src/libcore/oldcomm.rs index 0f3c7fc4edc..a5b0336ab60 100644 --- a/src/libcore/comm.rs +++ b/src/libcore/oldcomm.rs @@ -144,7 +144,7 @@ fn PortPtr(po: *rust_port) -> PortPtr { * Fails if the port is detached or dead. Fails if the port * is owned by a different task. */ -fn as_raw_port(ch: comm::Chan, f: fn(*rust_port) -> U) -> U { +fn as_raw_port(ch: Chan, f: fn(*rust_port) -> U) -> U { struct PortRef { p: *rust_port, @@ -205,11 +205,11 @@ pub fn recv(p: Port) -> T { recv_((**p).po) } pub fn peek(p: Port) -> bool { peek_((**p).po) } #[doc(hidden)] -pub fn recv_chan(ch: comm::Chan) -> T { +pub fn recv_chan(ch: Chan) -> T { as_raw_port(ch, |x|recv_(x)) } -fn peek_chan(ch: comm::Chan) -> bool { +fn peek_chan(ch: Chan) -> bool { as_raw_port(ch, |x|peek_(x)) } diff --git a/src/libcore/os.rs b/src/libcore/os.rs index e32ac2019db..b5e0983a420 100644 --- a/src/libcore/os.rs +++ b/src/libcore/os.rs @@ -133,36 +133,36 @@ mod global_env { } enum Msg { - MsgGetEnv(~str, comm::Chan>), - MsgSetEnv(~str, ~str, comm::Chan<()>), - MsgEnv(comm::Chan<~[(~str,~str)]>) + MsgGetEnv(~str, oldcomm::Chan>), + 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 { + fn get_global_env_chan() -> oldcomm::Chan { let global_ptr = rustrt::rust_global_env_chan_ptr(); unsafe { private::chan_from_global_ptr(global_ptr, || { @@ -173,19 +173,19 @@ mod global_env { } } - fn global_env_task(msg_po: comm::Port) { + fn global_env_task(msg_po: oldcomm::Port) { 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 } diff --git a/src/libcore/private.rs b/src/libcore/private.rs index 1f3d6ba75be..2d597bfb1b5 100644 --- a/src/libcore/private.rs +++ b/src/libcore/private.rs @@ -55,8 +55,8 @@ fn compare_and_swap(address: &mut int, oldval: int, newval: int) -> bool { pub unsafe fn chan_from_global_ptr( global: GlobalPtr, task_fn: fn() -> task::TaskBuilder, - f: fn~(comm::Port) -) -> comm::Chan { + f: fn~(oldcomm::Port) +) -> oldcomm::Chan { enum Msg { Proceed, @@ -70,15 +70,21 @@ pub unsafe fn chan_from_global_ptr( log(debug,~"is probably zero..."); // There's no global channel. We must make it - let (setup_po, setup_ch) = do task_fn().spawn_conversation - |move f, setup_po, setup_ch| { - let po = comm::Port::(); - let ch = comm::Chan(&po); - comm::send(setup_ch, ch); + let (setup1_po, setup1_ch) = pipes::stream(); + let (setup2_po, setup2_ch) = pipes::stream(); + + // XXX: Ugly type inference hints + let setup1_po: pipes::Port> = setup1_po; + let setup2_po: pipes::Port = setup2_po; + + do task_fn().spawn |move f, move setup1_ch, move setup2_po| { + let po = oldcomm::Port::(); + let ch = oldcomm::Chan(&po); + setup1_ch.send(ch); // Wait to hear if we are the official instance of // this global task - match comm::recv::(setup_po) { + match setup2_po.recv() { Proceed => f(move po), Abort => () } @@ -86,7 +92,7 @@ pub unsafe fn chan_from_global_ptr( log(debug,~"before setup recv.."); // This is the proposed global channel - let ch = comm::recv(setup_po); + let ch = setup1_po.recv(); // 0 is our sentinal value. It is not a valid channel assert *ch != 0; @@ -99,11 +105,11 @@ pub unsafe fn chan_from_global_ptr( if swapped { // Success! - comm::send(setup_ch, Proceed); + setup2_ch.send(Proceed); ch } else { // Somebody else got in before we did - comm::send(setup_ch, Abort); + setup2_ch.send(Abort); cast::reinterpret_cast(&*global) } } else { @@ -124,29 +130,29 @@ pub fn test_from_global_chan1() { // 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] @@ -157,8 +163,8 @@ pub fn test_from_global_chan2() { 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 @@ -169,23 +175,23 @@ pub fn test_from_global_chan2() { 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; @@ -211,9 +217,9 @@ pub fn test_from_global_chan2() { * * 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)); } @@ -221,13 +227,13 @@ pub unsafe fn weaken_task(f: fn(comm::Port<()>)) { 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 } @@ -249,7 +255,7 @@ pub fn test_weaken_task_wait() { do task::spawn_unlinked { unsafe { do weaken_task |po| { - comm::recv(po); + oldcomm::recv(po); } } } @@ -269,7 +275,7 @@ pub fn test_weaken_task_stress() { unsafe { do weaken_task |po| { // Wait for it to tell us to die - comm::recv(po); + oldcomm::recv(po); } } } diff --git a/src/libcore/run.rs b/src/libcore/run.rs index daebe0d31b4..3af854236e1 100644 --- a/src/libcore/run.rs +++ b/src/libcore/run.rs @@ -307,22 +307,22 @@ pub fn program_output(prog: &str, args: &[~str]) -> // 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; diff --git a/src/libcore/task/mod.rs b/src/libcore/task/mod.rs index 6db7aae16b0..3cd12a5ba66 100644 --- a/src/libcore/task/mod.rs +++ b/src/libcore/task/mod.rs @@ -433,43 +433,6 @@ impl TaskBuilder { } } - /** - * Runs a new task while providing a channel from the parent to the child - * - * Sets up a communication channel from the current task to the new - * child task, passes the port to child's body, and returns a channel - * linked to the port to the parent. - * - * This encapsulates some boilerplate handshaking logic that would - * otherwise be required to establish communication from the parent - * to the child. - */ - fn spawn_listener(f: fn~(comm::Port)) -> comm::Chan { - let setup_po = comm::Port(); - let setup_ch = comm::Chan(&setup_po); - do self.spawn |move f| { - let po = comm::Port(); - let ch = comm::Chan(&po); - comm::send(setup_ch, ch); - f(move po); - } - comm::recv(setup_po) - } - - /** - * Runs a new task, setting up communication in both directions - */ - fn spawn_conversation - (f: fn~(comm::Port, comm::Chan)) - -> (comm::Port, comm::Chan) { - let from_child = comm::Port(); - let to_parent = comm::Chan(&from_child); - let to_child = do self.spawn_listener |move f, from_parent| { - f(from_parent, to_parent) - }; - (from_child, to_child) - } - /** * Execute a function in another task and return either the return value * of the function or result::err. @@ -484,18 +447,18 @@ impl TaskBuilder { * Fails if a future_result was already set for this task. */ fn try(f: fn~() -> T) -> Result { - 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(()) } } @@ -567,28 +530,6 @@ pub fn spawn_with(arg: A, f: fn~(v: A)) { task().spawn_with(move arg, move f) } -pub fn spawn_listener(f: fn~(comm::Port)) -> comm::Chan { - /*! - * Runs a new task while providing a channel from the parent to the child - * - * This function is equivalent to `task().spawn_listener(f)`. - */ - - task().spawn_listener(move f) -} - -pub fn spawn_conversation - (f: fn~(comm::Port, comm::Chan)) - -> (comm::Port, comm::Chan) { - /*! - * Runs a new task, setting up communication in both directions - * - * This function is equivalent to `task().spawn_conversation(f)`. - */ - - task().spawn_conversation(move f) -} - pub fn spawn_sched(mode: SchedMode, f: fn~()) { /*! * Creates a new scheduler and executes a task on it @@ -738,17 +679,17 @@ fn test_cant_dup_task_builder() { #[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 @@ -768,8 +709,8 @@ fn test_spawn_unlinked_sup_fail_down() { #[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()). @@ -787,7 +728,7 @@ fn test_spawn_linked_sup_fail_up() { // child fails; parent fails .. 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 @@ -811,11 +752,11 @@ 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 @@ -883,27 +824,27 @@ fn test_spawn_linked_sup_propagate_sibling() { #[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] @@ -926,34 +867,6 @@ fn test_back_to_the_future_result() { let _ = task().future_result(util::ignore).future_result(util::ignore); } -#[test] -fn test_spawn_listiner_bidi() { - let po = comm::Port(); - let ch = comm::Chan(&po); - let ch = do spawn_listener |po| { - // Now the child has a port called 'po' to read from and - // an environment-captured channel called 'ch'. - let res: ~str = comm::recv(po); - assert res == ~"ping"; - comm::send(ch, ~"pong"); - }; - // Likewise, the parent has both a 'po' and 'ch' - comm::send(ch, ~"ping"); - let res: ~str = comm::recv(po); - assert res == ~"pong"; -} - -#[test] -fn test_spawn_conversation() { - let (recv_str, send_int) = do spawn_conversation |recv_int, send_str| { - let input = comm::recv(recv_int); - let output = int::str(input); - comm::send(send_str, move output); - }; - comm::send(send_int, 1); - assert comm::recv(recv_str) == ~"1"; -} - #[test] fn test_try_success() { match do try { @@ -984,10 +897,10 @@ fn test_spawn_sched_no_threads() { #[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) { @@ -995,7 +908,7 @@ fn test_spawn_sched() { assert parent_sched_id != child_sched_id; if (i == 0) { - comm::send(ch, ()); + oldcomm::send(ch, ()); } else { f(i - 1, ch); } @@ -1003,13 +916,13 @@ fn test_spawn_sched() { } 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(); @@ -1017,11 +930,11 @@ fn test_spawn_sched_childs_on_same_sched() { 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] @@ -1042,71 +955,71 @@ fn test_spawn_sched_blocking() { // 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, ch: comm::Chan) { + fn pingpong(po: oldcomm::Port, ch: oldcomm::Chan) { 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::(); - let ch = comm::Chan(&p); + let p = oldcomm::Port::(); + 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; } @@ -1115,15 +1028,6 @@ fn test_avoid_copying_the_body_spawn() { avoid_copying_the_body(spawn); } -#[test] -fn test_avoid_copying_the_body_spawn_listener() { - do avoid_copying_the_body |f| { - spawn_listener(fn~(move f, _po: comm::Port) { - f(); - }); - } -} - #[test] fn test_avoid_copying_the_body_task_spawn() { do avoid_copying_the_body |f| { @@ -1133,15 +1037,6 @@ fn test_avoid_copying_the_body_task_spawn() { } } -#[test] -fn test_avoid_copying_the_body_spawn_listener_1() { - do avoid_copying_the_body |f| { - task().spawn_listener(fn~(move f, _po: comm::Port) { - f(); - }); - } -} - #[test] fn test_avoid_copying_the_body_try() { do avoid_copying_the_body |f| { @@ -1162,19 +1057,19 @@ fn test_avoid_copying_the_body_unlinked() { #[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 diff --git a/src/libcore/task/spawn.rs b/src/libcore/task/spawn.rs index e2ed853ee29..77acf3967e8 100644 --- a/src/libcore/task/spawn.rs +++ b/src/libcore/task/spawn.rs @@ -646,12 +646,12 @@ pub fn spawn_raw(opts: TaskOpts, f: fn~()) { #[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] diff --git a/src/librustc/rustc.rc b/src/librustc/rustc.rc index 45aa78be026..c934b09a7c4 100644 --- a/src/librustc/rustc.rc +++ b/src/librustc/rustc.rc @@ -434,8 +434,8 @@ fails without recording a fatal error then we've encountered a compiler 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| { @@ -444,14 +444,14 @@ fn monitor(+f: fn~(diagnostic::emitter)) { 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, - drop { comm::send(self.ch, done); } + ch: oldcomm::Chan, + drop { oldcomm::send(self.ch, done); } } let _finally = finally { ch: ch }; @@ -461,7 +461,7 @@ fn monitor(+f: fn~(diagnostic::emitter)) { 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"), diff --git a/src/librustdoc/astsrv.rs b/src/librustdoc/astsrv.rs index 0c3154bf8f8..14b7b52e4d3 100644 --- a/src/librustdoc/astsrv.rs +++ b/src/librustdoc/astsrv.rs @@ -46,7 +46,7 @@ enum Msg { } pub enum Srv = { - ch: comm::Chan + ch: oldcomm::Chan }; impl Srv: Clone { @@ -64,17 +64,17 @@ pub fn from_file(file: ~str, owner: SrvOwner) -> T { fn run(owner: SrvOwner, source: ~str, +parse: Parser) -> T { let srv_ = Srv({ - ch: do task::spawn_listener |move parse, po| { + ch: do util::spawn_listener |move parse, po| { act(po, source, parse); } }); let res = owner(srv_); - comm::send(srv_.ch, Exit); + oldcomm::send(srv_.ch, Exit); move res } -fn act(po: comm::Port, source: ~str, parse: Parser) { +fn act(po: oldcomm::Port, source: ~str, parse: Parser) { let sess = build_session(); let ctxt = build_ctxt( @@ -84,7 +84,7 @@ fn act(po: comm::Port, source: ~str, parse: Parser) { let mut keep_going = true; while keep_going { - match comm::recv(po) { + match oldcomm::recv(po) { HandleRequest(f) => { f(ctxt); } @@ -99,13 +99,13 @@ pub fn exec( 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, diff --git a/src/librustdoc/markdown_pass.rs b/src/librustdoc/markdown_pass.rs index 193a824b550..3328cdd527a 100644 --- a/src/librustdoc/markdown_pass.rs +++ b/src/librustdoc/markdown_pass.rs @@ -129,7 +129,7 @@ fn should_request_new_writer_for_each_page() { write_markdown(doc, move writer_factory); // We expect two pages to have been written for iter::repeat(2) { - comm::recv(po); + oldcomm::recv(po); } } @@ -160,7 +160,7 @@ fn should_write_title_for_each_page() { 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"); @@ -304,7 +304,7 @@ fn should_write_full_path_to_mod() { assert str::contains(markdown, ~"# Module `a::b::c`"); } -fn write_common( +fn write_oldcommon( ctxt: &Ctxt, +desc: Option<~str>, sections: &[doc::Section] @@ -353,7 +353,7 @@ fn write_mod_contents( 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()); } @@ -456,7 +456,7 @@ fn should_write_index_for_foreign_mods() { } 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()); } @@ -507,7 +507,7 @@ fn write_fnlike( 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>) { @@ -576,7 +576,7 @@ fn write_const( +doc: doc::ConstDoc ) { write_sig(ctxt, doc.sig); - write_common(ctxt, doc.desc(), doc.sections()); + write_oldcommon(ctxt, doc.desc(), doc.sections()); } #[test] @@ -597,7 +597,7 @@ fn write_enum( ctxt: &Ctxt, +doc: doc::EnumDoc ) { - write_common(ctxt, doc.desc(), doc.sections()); + write_oldcommon(ctxt, doc.desc(), doc.sections()); write_variants(ctxt, doc.variants); } @@ -678,7 +678,7 @@ fn should_write_variant_list_with_signatures() { } 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); } @@ -726,7 +726,7 @@ fn should_write_trait_method_signature() { } 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); } @@ -768,7 +768,7 @@ fn write_type( +doc: doc::TyDoc ) { write_sig(ctxt, doc.sig); - write_common(ctxt, doc.desc(), doc.sections()); + write_oldcommon(ctxt, doc.desc(), doc.sections()); } #[test] @@ -795,7 +795,7 @@ fn write_struct( +doc: doc::StructDoc ) { write_sig(ctxt, doc.sig); - write_common(ctxt, doc.desc(), doc.sections()); + write_oldcommon(ctxt, doc.desc(), doc.sections()); } #[test] @@ -854,7 +854,7 @@ mod 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( @@ -864,7 +864,7 @@ mod test { 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] diff --git a/src/librustdoc/markdown_writer.rs b/src/librustdoc/markdown_writer.rs index 0f03e7f4594..9cf404e0533 100644 --- a/src/librustdoc/markdown_writer.rs +++ b/src/librustdoc/markdown_writer.rs @@ -151,8 +151,8 @@ fn readclose(fd: libc::c_int) -> ~str { 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 = comm::Port(); - let ch = comm::Chan(&po); + let po: oldcomm::Port = oldcomm::Port(); + let ch = oldcomm::Chan(&po); setup_ch.send(ch); let mut markdown = ~""; @@ -168,7 +168,7 @@ fn generic_writer(+process: fn~(+markdown: ~str)) -> Writer { let ch = setup_po.recv(); fn~(+instr: WriteInstr) { - comm::send(ch, instr); + oldcomm::send(ch, instr); } } @@ -275,16 +275,16 @@ fn write_file(path: &Path, +s: ~str) { } 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() }; diff --git a/src/librustdoc/page_pass.rs b/src/librustdoc/page_pass.rs index 5125f7c1da6..af8ac5f1427 100644 --- a/src/librustdoc/page_pass.rs +++ b/src/librustdoc/page_pass.rs @@ -39,24 +39,24 @@ fn run( return doc; } - let (result_port, page_chan) = do task::spawn_conversation + 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>; -type PageChan = comm::Chan>; +type PagePort = oldcomm::Port>; +type PageChan = oldcomm::Chan>; type NominalPageChan = NominalOp; 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 { @@ -77,7 +77,7 @@ fn find_pages(doc: doc::Doc, page_chan: PageChan) { }; (fold.fold_doc)(&fold, doc); - comm::send(page_chan, None); + oldcomm::send(page_chan, None); } fn fold_crate( @@ -92,7 +92,7 @@ fn fold_crate( .. doc }); - comm::send(fold.ctxt.op, Some(page)); + oldcomm::send(fold.ctxt.op, Some(page)); doc } @@ -108,7 +108,7 @@ fn fold_mod( 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 @@ -133,7 +133,7 @@ fn fold_nmod( ) -> 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; } diff --git a/src/librustdoc/util.rs b/src/librustdoc/util.rs index 7fdd3c80a98..ebeb9346d3c 100644 --- a/src/librustdoc/util.rs +++ b/src/librustdoc/util.rs @@ -17,3 +17,26 @@ impl NominalOp: Clone { fn clone(&self) -> NominalOp { copy *self } } +pub fn spawn_listener( + +f: fn~(oldcomm::Port)) -> oldcomm::Chan { + let setup_po = oldcomm::Port(); + let setup_ch = oldcomm::Chan(&setup_po); + do task::spawn |move f| { + let po = oldcomm::Port(); + let ch = oldcomm::Chan(&po); + oldcomm::send(setup_ch, ch); + f(move po); + } + oldcomm::recv(setup_po) +} + +pub fn spawn_conversation + (+f: fn~(oldcomm::Port, oldcomm::Chan)) + -> (oldcomm::Port, oldcomm::Chan) { + 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) + }; + (from_child, to_child) +} diff --git a/src/libstd/net_ip.rs b/src/libstd/net_ip.rs index 31a62b50d90..1eb970526c3 100644 --- a/src/libstd/net_ip.rs +++ b/src/libstd/net_ip.rs @@ -30,7 +30,6 @@ use create_uv_getaddrinfo_t = uv::ll::getaddrinfo_t; 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 { @@ -108,7 +107,7 @@ enum IpGetAddrErr { */ 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(); @@ -268,7 +267,7 @@ pub mod v6 { } type GetAddrData = { - output_ch: comm::Chan> + output_ch: oldcomm::Chan> }; extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int, diff --git a/src/libstd/net_tcp.rs b/src/libstd/net_tcp.rs index 624824dede4..c94a7fd1125 100644 --- a/src/libstd/net_tcp.rs +++ b/src/libstd/net_tcp.rs @@ -19,7 +19,6 @@ use future_spawn = future::spawn; use result::{Result}; use libc::size_t; use io::{Reader, ReaderUtil, Writer}; -use comm = core::comm; #[nolink] extern mod rustrt { @@ -133,19 +132,19 @@ pub enum TcpConnectErrData { pub fn connect(input_ip: ip::IpAddr, port: uint, iotask: IoTask) -> result::Result unsafe { - let result_po = core::comm::Port::(); - let closed_signal_po = core::comm::Port::<()>(); + let result_po = oldcomm::Port::(); + 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::>(); + let reader_po = oldcomm::Port::>(); 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(), @@ -217,7 +216,7 @@ pub fn connect(input_ip: ip::IpAddr, port: uint, // 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); @@ -228,18 +227,18 @@ pub fn connect(input_ip: ip::IpAddr, port: uint, _ => { // 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 @@ -329,7 +328,7 @@ pub fn write_future(sock: &TcpSocket, raw_write_data: ~[u8]) * `tcp_err_data` record */ pub fn read_start(sock: &TcpSocket) - -> result::Result result::Result>, TcpErrData> unsafe { let socket_data = ptr::addr_of(&(*(sock.socket_data))); read_start_common_impl(socket_data) @@ -343,7 +342,7 @@ pub fn read_start(sock: &TcpSocket) * * `sock` - a `net::tcp::tcp_socket` that you wish to stop reading on */ pub fn read_stop(sock: &TcpSocket, - read_port: comm::Port>) -> + read_port: oldcomm::Port>) -> 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)); @@ -484,13 +483,13 @@ pub fn accept(new_conn: TcpNewConnection) 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(), @@ -501,8 +500,8 @@ pub fn accept(new_conn: TcpNewConnection) let client_stream_handle_ptr = (*client_socket_data_ptr).stream_handle_ptr; - let result_po = core::comm::Port::>(); - let result_ch = core::comm::Chan(&result_po); + let result_po = oldcomm::Port::>(); + let result_ch = oldcomm::Chan(&result_po); // UNSAFE LIBUV INTERACTION BEGIN // .. normally this happens within the context of @@ -524,23 +523,23 @@ pub fn accept(new_conn: TcpNewConnection) 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)) } @@ -578,9 +577,9 @@ pub fn accept(new_conn: TcpNewConnection) */ pub fn listen(host_ip: ip::IpAddr, port: uint, backlog: uint, iotask: IoTask, - on_establish_cb: fn~(comm::Chan>), + on_establish_cb: fn~(oldcomm::Chan>), new_connect_cb: fn~(TcpNewConnection, - comm::Chan>)) + oldcomm::Chan>)) -> result::Result<(), TcpListenErrData> unsafe { do listen_common(move host_ip, port, backlog, iotask, move on_establish_cb) @@ -596,17 +595,17 @@ pub fn listen(host_ip: ip::IpAddr, port: uint, backlog: uint, fn listen_common(host_ip: ip::IpAddr, port: uint, backlog: uint, iotask: IoTask, - on_establish_cb: fn~(comm::Chan>), + on_establish_cb: fn~(oldcomm::Chan>), 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::>(); - let kill_ch = core::comm::Chan(&kill_po); + let stream_closed_po = oldcomm::Port::<()>(); + let kill_po = oldcomm::Port::>(); + 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, @@ -618,7 +617,7 @@ fn listen_common(host_ip: ip::IpAddr, port: uint, backlog: uint, }; 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 @@ -652,25 +651,25 @@ fn listen_common(host_ip: ip::IpAddr, port: uint, backlog: uint, 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)); } } }; @@ -704,7 +703,7 @@ fn listen_common(host_ip: ip::IpAddr, port: uint, backlog: uint, } 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)); @@ -745,12 +744,12 @@ pub fn socket_buf(sock: TcpSocket) -> TcpSocketBuf { /// Convenience methods extending `net::tcp::tcp_socket` impl TcpSocket { - pub fn read_start() -> result::Result result::Result>, TcpErrData> { read_start(&self) } pub fn read_stop(read_port: - comm::Port>) -> + oldcomm::Port>) -> result::Result<(), TcpErrData> { read_stop(&self, move read_port) } @@ -877,8 +876,8 @@ impl TcpSocketBuf: io::Writer { // 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 }; @@ -891,7 +890,7 @@ fn tear_down_socket_data(socket_data: @TcpSocketData) unsafe { 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 @@ -915,7 +914,7 @@ fn read_common_impl(socket_data: *TcpSocketData, timeout_msecs: uint) 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 { @@ -941,23 +940,23 @@ fn read_common_impl(socket_data: *TcpSocketData, timeout_msecs: uint) 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::>(); - let stop_ch = core::comm::Chan(&stop_po); + let stop_po = oldcomm::Port::>(); + 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(()) } @@ -965,11 +964,11 @@ fn read_stop_common_impl(socket_data: *TcpSocketData) -> // shared impl for read_start fn read_start_common_impl(socket_data: *TcpSocketData) - -> result::Result result::Result>, TcpErrData> unsafe { let stream_handle_ptr = (*socket_data).stream_handle_ptr; - let start_po = core::comm::Port::>(); - let start_ch = core::comm::Chan(&start_po); + let start_po = oldcomm::Port::>(); + 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)); @@ -978,16 +977,16 @@ fn read_start_common_impl(socket_data: *TcpSocketData) 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) } @@ -1006,9 +1005,9 @@ fn write_common_impl(socket_data_ptr: *TcpSocketData, 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::(); + let result_po = oldcomm::Port::(); 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 { @@ -1024,7 +1023,7 @@ fn write_common_impl(socket_data_ptr: *TcpSocketData, _ => { 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())); } } @@ -1033,7 +1032,7 @@ fn write_common_impl(socket_data_ptr: *TcpSocketData, // 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()) } @@ -1045,8 +1044,8 @@ enum TcpNewConnection { type TcpListenFcData = { server_stream_ptr: *uv::ll::uv_tcp_t, - stream_closed_ch: comm::Chan<()>, - kill_ch: comm::Chan>, + stream_closed_ch: oldcomm::Chan<()>, + kill_ch: oldcomm::Chan>, on_connect_cb: fn~(*uv::ll::uv_tcp_t), iotask: IoTask, ipv6: bool, @@ -1056,7 +1055,7 @@ type TcpListenFcData = { 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, @@ -1069,7 +1068,7 @@ 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; @@ -1094,7 +1093,7 @@ enum TcpWriteResult { } enum TcpReadStartResult { - TcpReadStartSuccess(comm::Port), + TcpReadStartSuccess(oldcomm::Port), TcpReadStartError(TcpErrData) } @@ -1129,7 +1128,7 @@ extern fn on_tcp_read_cb(stream: *uv::ll::uv_stream_t, 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 => (), @@ -1140,7 +1139,7 @@ extern fn on_tcp_read_cb(stream: *uv::ll::uv_stream_t, 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); @@ -1160,14 +1159,14 @@ extern fn on_alloc_cb(handle: *libc::c_void, } 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.."); } @@ -1177,31 +1176,31 @@ extern fn tcp_write_complete_cb(write_req: *uv::ll::uv_write_t, 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 + result_ch: oldcomm::Chan }; type ConnectReqData = { - result_ch: comm::Chan, - closed_signal_ch: comm::Chan<()> + result_ch: oldcomm::Chan, + 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)); } @@ -1220,7 +1219,7 @@ extern fn tcp_connect_on_connect_cb(connect_req_ptr: *uv::ll::uv_connect_t, 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"); @@ -1228,7 +1227,7 @@ extern fn tcp_connect_on_connect_cb(connect_req_ptr: *uv::ll::uv_connect_t, 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); @@ -1243,8 +1242,8 @@ enum ConnAttempt { } type TcpSocketData = { - reader_po: comm::Port>, - reader_ch: comm::Chan>, + reader_po: oldcomm::Port>, + reader_ch: oldcomm::Chan>, stream_handle_ptr: *uv::ll::uv_tcp_t, connect_req: uv::ll::uv_connect_t, write_req: uv::ll::uv_write_t, @@ -1337,14 +1336,14 @@ mod test { 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, @@ -1355,10 +1354,10 @@ mod test { }; 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, @@ -1368,7 +1367,7 @@ mod test { }; 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'", @@ -1382,14 +1381,14 @@ mod test { 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, @@ -1400,10 +1399,10 @@ mod test { }; 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, @@ -1430,7 +1429,7 @@ mod test { 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, @@ -1450,14 +1449,14 @@ mod test { 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, @@ -1468,7 +1467,7 @@ mod test { }; 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, @@ -1476,7 +1475,7 @@ mod test { 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, @@ -1574,14 +1573,14 @@ mod test { 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, @@ -1592,7 +1591,7 @@ mod test { }; 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); @@ -1626,8 +1625,8 @@ mod test { } 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, @@ -1636,13 +1635,13 @@ mod test { |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"); @@ -1651,7 +1650,7 @@ mod test { 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(()); @@ -1677,12 +1676,12 @@ mod test { 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(~""); } } @@ -1738,7 +1737,7 @@ mod test { } 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); diff --git a/src/libstd/test.rs b/src/libstd/test.rs index 2bf735dd584..d365077d063 100644 --- a/src/libstd/test.rs +++ b/src/libstd/test.rs @@ -23,7 +23,6 @@ use result::{Ok, Err}; use io::WriterUtil; use libc::size_t; use task::TaskBuilder; -use comm = core::comm; #[abi = "cdecl"] extern mod rustrt { @@ -289,8 +288,8 @@ fn run_tests(opts: &TestOpts, tests: &[TestDesc], 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 { @@ -306,7 +305,7 @@ fn run_tests(opts: &TestOpts, tests: &[TestDesc], run_idx += 1; } - let (test, result) = core::comm::recv(p); + let (test, result) = oldcomm::recv(p); if concurrency != 1 { callback(TeWait(copy test)); } @@ -383,9 +382,9 @@ fn filter_tests(opts: &TestOpts, type TestFuture = {test: TestDesc, wait: fn@() -> TestResult}; -fn run_test(test: TestDesc, monitor_ch: comm::Chan) { +fn run_test(test: TestDesc, monitor_ch: oldcomm::Chan) { if test.ignore { - core::comm::send(monitor_ch, (copy test, TrIgnored)); + oldcomm::send(monitor_ch, (copy test, TrIgnored)); return; } @@ -397,7 +396,7 @@ fn run_test(test: TestDesc, monitor_ch: comm::Chan) { }).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)); }; } @@ -424,10 +423,10 @@ mod tests { 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; } @@ -440,10 +439,10 @@ mod tests { 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; } @@ -457,10 +456,10 @@ mod tests { 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; } @@ -473,10 +472,10 @@ mod tests { 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; } diff --git a/src/libstd/timer.rs b/src/libstd/timer.rs index a9638ad05c3..c3a2a11e1f8 100644 --- a/src/libstd/timer.rs +++ b/src/libstd/timer.rs @@ -14,7 +14,6 @@ use uv::iotask; use uv::iotask::IoTask; -use comm = core::comm; /** * Wait for timeout period then send provided value over a channel @@ -33,10 +32,10 @@ use comm = core::comm; * * val - a value of type T to send over the provided `ch` */ pub fn delayed_send(iotask: IoTask, - msecs: uint, ch: comm::Chan, val: T) { + msecs: uint, ch: oldcomm::Chan, 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); @@ -62,11 +61,11 @@ pub fn delayed_send(iotask: IoTask, } }; // 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); }; } @@ -82,10 +81,10 @@ pub fn delayed_send(iotask: IoTask, * * 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); } /** @@ -110,9 +109,9 @@ pub fn sleep(iotask: IoTask, msecs: uint) { */ pub fn recv_timeout(iotask: IoTask, msecs: uint, - wait_po: comm::Port) -> Option { - let timeout_po = comm::Port::<()>(); - let timeout_ch = comm::Chan(&timeout_po); + wait_po: oldcomm::Port) -> Option { + 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( @@ -122,7 +121,7 @@ pub fn recv_timeout(iotask: IoTask, None }, |right_val| { Some(*right_val) - }, &core::comm::select2(timeout_po, wait_po) + }, &oldcomm::select2(timeout_po, wait_po) ) } @@ -131,10 +130,10 @@ extern fn delayed_send_cb(handle: *uv::ll::uv_timer_t, 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 { @@ -147,8 +146,8 @@ extern fn delayed_send_cb(handle: *uv::ll::uv_timer_t, 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)] @@ -170,8 +169,8 @@ mod 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; @@ -193,13 +192,13 @@ mod test { 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) } } @@ -248,8 +247,8 @@ mod test { 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); diff --git a/src/libstd/uv_global_loop.rs b/src/libstd/uv_global_loop.rs index 58b9a8d3d94..2efbfae3da4 100644 --- a/src/libstd/uv_global_loop.rs +++ b/src/libstd/uv_global_loop.rs @@ -17,8 +17,7 @@ use iotask = uv_iotask; 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}; @@ -121,9 +120,9 @@ fn spawn_loop() -> IoTask { 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; + timer_ptr as *libc::c_void) as *oldcomm::Chan; 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)); } @@ -142,8 +141,8 @@ mod test { } fn impl_uv_hl_simple_timer(iotask: IoTask) 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 exit_ch_ptr = ptr::addr_of(&exit_ch); log(debug, fmt!("EXIT_CH_PTR newly created exit_ch_ptr: %?", exit_ch_ptr)); @@ -168,21 +167,21 @@ mod test { 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 @@ -191,17 +190,17 @@ mod test { #[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!"); diff --git a/src/libstd/uv_iotask.rs b/src/libstd/uv_iotask.rs index 19f5997a57d..d778606075d 100644 --- a/src/libstd/uv_iotask.rs +++ b/src/libstd/uv_iotask.rs @@ -18,8 +18,7 @@ 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; @@ -178,7 +177,7 @@ mod test { 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 { @@ -187,13 +186,13 @@ mod test { } 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 @@ -204,19 +203,19 @@ mod test { 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::(); - let iotask_ch = comm::Chan(&iotask_port); + unsafe fn spawn_test_loop(exit_ch: oldcomm::Chan<()>) -> IoTask { + let iotask_port = oldcomm::Port::(); + 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 { @@ -231,8 +230,8 @@ mod test { #[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, @@ -241,20 +240,20 @@ mod test { // 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.."); } } diff --git a/src/libstd/uv_ll.rs b/src/libstd/uv_ll.rs index d52adbc7873..65333b41864 100644 --- a/src/libstd/uv_ll.rs +++ b/src/libstd/uv_ll.rs @@ -33,7 +33,6 @@ #[allow(non_camel_case_types)]; // C types use libc::size_t; -use comm = core::comm; use ptr::to_unsafe_ptr; // libuv struct mappings @@ -1045,7 +1044,7 @@ pub mod test { 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) { @@ -1083,7 +1082,7 @@ pub mod test { 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) { @@ -1143,7 +1142,7 @@ pub mod test { } 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); @@ -1268,7 +1267,7 @@ pub mod test { 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, @@ -1360,12 +1359,12 @@ pub mod test { 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 + continue_chan: *oldcomm::Chan }; extern fn async_close_cb(handle: *libc::c_void) { @@ -1383,7 +1382,7 @@ pub mod test { 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); } @@ -1391,8 +1390,8 @@ pub mod test { server_port: int, +kill_server_msg: ~str, +server_resp_msg: ~str, - server_chan: *comm::Chan<~str>, - continue_chan: *comm::Chan) unsafe { + server_chan: *oldcomm::Chan<~str>, + continue_chan: *oldcomm::Chan) unsafe { let test_loop = loop_new(); let tcp_server = tcp_t(); let tcp_server_ptr = ptr::addr_of(&tcp_server); @@ -1497,13 +1496,13 @@ pub mod test { 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::(); - let continue_chan = core::comm::Chan::(&continue_port); + let continue_port = oldcomm::Port::(); + let continue_chan = oldcomm::Chan::(&continue_port); let continue_chan_ptr = ptr::addr_of(&continue_chan); do task::spawn_sched(task::ManualThreads(1)) { @@ -1516,7 +1515,7 @@ pub mod test { // 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)) { @@ -1525,8 +1524,8 @@ pub mod test { 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); diff --git a/src/test/auxiliary/cci_capture_clause.rs b/src/test/auxiliary/cci_capture_clause.rs index 67dc05bc31d..a558de33876 100644 --- a/src/test/auxiliary/cci_capture_clause.rs +++ b/src/test/auxiliary/cci_capture_clause.rs @@ -12,7 +12,7 @@ export foo; -use core::comm::*; +use core::oldcomm::*; fn foo(x: T) -> Port { let p = Port(); diff --git a/src/test/auxiliary/test_comm.rs b/src/test/auxiliary/test_comm.rs index d8ce8076e41..0ae2dc5340e 100644 --- a/src/test/auxiliary/test_comm.rs +++ b/src/test/auxiliary/test_comm.rs @@ -9,7 +9,7 @@ // except according to those terms. /* - Minimized version of core::comm for testing. + Minimized version of core::oldcomm for testing. Could probably be more minimal. */ @@ -22,7 +22,7 @@ export recv; /** - * 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 diff --git a/src/test/bench/graph500-bfs.rs b/src/test/bench/graph500-bfs.rs index a40c87aa3f1..774e0b2e53a 100644 --- a/src/test/bench/graph500-bfs.rs +++ b/src/test/bench/graph500-bfs.rs @@ -26,7 +26,7 @@ use std::deque; use std::deque::Deque; use std::par; use io::WriterUtil; -use comm::*; +use oldcomm::*; use int::abs; type node_id = i64; diff --git a/src/test/bench/msgsend-ring.rs b/src/test/bench/msgsend-ring.rs index e51cb7bab14..62226a1c44d 100644 --- a/src/test/bench/msgsend-ring.rs +++ b/src/test/bench/msgsend-ring.rs @@ -14,7 +14,7 @@ // 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; @@ -22,8 +22,8 @@ use std::future; fn thread_ring(i: uint, count: uint, - num_chan: comm::Chan, - num_port: comm::Port) { + num_chan: oldcomm::Chan, + num_port: oldcomm::Port) { // Send/Receive lots of messages. for uint::range(0u, count) |j| { num_chan.send(i * j); diff --git a/src/test/bench/msgsend.rs b/src/test/bench/msgsend.rs deleted file mode 100644 index 390202f1af7..00000000000 --- a/src/test/bench/msgsend.rs +++ /dev/null @@ -1,83 +0,0 @@ -// 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 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -// A port of the simplistic benchmark from -// -// http://github.com/PaulKeeble/ScalaVErlangAgents -// -// I *think* it's the same, more or less. - -extern mod std; -use io::Writer; -use io::WriterUtil; - -enum request { - get_count, - bytes(uint), - stop -} - -fn server(requests: comm::Port, responses: comm::Chan) { - let mut count = 0u; - let mut done = false; - while !done { - match comm::recv(requests) { - get_count => { comm::send(responses, copy count); } - bytes(b) => { count += b; } - stop => { done = true; } - } - } - comm::send(responses, count); -} - -fn run(args: ~[~str]) { - let (from_child, to_child) = do task::spawn_conversation |po, ch| { - server(po, ch); - }; - let size = uint::from_str(args[1]).get(); - let workers = uint::from_str(args[2]).get(); - let start = std::time::precise_time_s(); - let mut worker_results = ~[]; - for uint::range(0, workers) |_i| { - do task::task().future_result(|+r| { - worker_results.push(move r); - }).spawn { - for uint::range(0, size / workers) |_i| { - comm::send(to_child, bytes(100)); - } - }; - } - for vec::each(worker_results) |r| { - r.recv(); - } - comm::send(to_child, stop); - let result = comm::recv(from_child); - let end = std::time::precise_time_s(); - let elapsed = end - start; - io::stdout().write_str(fmt!("Count is %?\n", result)); - io::stdout().write_str(fmt!("Test took %? seconds\n", elapsed)); - let thruput = ((size / workers * workers) as float) / (elapsed as float); - io::stdout().write_str(fmt!("Throughput=%f per sec\n", thruput)); -} - -fn main() { - let args = os::args(); - let args = if os::getenv(~"RUST_BENCH").is_some() { - ~[~"", ~"1000000", ~"10000"] - } else if args.len() <= 1u { - ~[~"", ~"10000", ~"4"] - } else { - args - }; - - debug!("%?", args); - run(args); -} - diff --git a/src/test/bench/shootout-chameneos-redux.rs b/src/test/bench/shootout-chameneos-redux.rs index 651a4cc3048..3625dd048b5 100644 --- a/src/test/bench/shootout-chameneos-redux.rs +++ b/src/test/bench/shootout-chameneos-redux.rs @@ -95,9 +95,9 @@ fn transform(aa: color, bb: color) -> color { fn creature( name: uint, color: color, - from_rendezvous: comm::Port>, - to_rendezvous: comm::Chan, - to_rendezvous_log: comm::Chan<~str> + from_rendezvous: oldcomm::Port>, + to_rendezvous: oldcomm::Chan, + to_rendezvous_log: oldcomm::Chan<~str> ) { let mut color = color; let mut creatures_met = 0; @@ -105,8 +105,8 @@ fn creature( 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 { @@ -123,7 +123,7 @@ fn creature( // 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; } } @@ -131,22 +131,35 @@ fn creature( } fn rendezvous(nn: uint, set: ~[color]) { + + pub fn spawn_listener(+f: fn~(oldcomm::Port)) -> oldcomm::Chan { + let setup_po = oldcomm::Port(); + let setup_ch = oldcomm::Chan(&setup_po); + do task::spawn |move f| { + let po = oldcomm::Port(); + let ch = oldcomm::Chan(&po); + oldcomm::send(setup_ch, ch); + f(move po); + } + oldcomm::recv(setup_po) + } + // these ports will allow us to hear from the creatures - let from_creatures: comm::Port = comm::Port(); - let from_creatures_log: comm::Port<~str> = comm::Port(); + let from_creatures: oldcomm::Port = 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>] = + let to_creature: ~[oldcomm::Chan>] = vec::mapi(set, |ii, col| { // create each creature as a listener with a port, and // give us a channel to talk to each let ii = ii; let col = *col; - do task::spawn_listener |from_rendezvous, move ii, move col| { + do spawn_listener |from_rendezvous, move ii, move col| { creature(ii, col, from_rendezvous, to_rendezvous, to_rendezvous_log); } @@ -156,24 +169,24 @@ fn rendezvous(nn: uint, set: ~[color]) { // 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 diff --git a/src/test/bench/shootout-k-nucleotide-pipes.rs b/src/test/bench/shootout-k-nucleotide-pipes.rs index 83f9e77edc5..2420a02aa23 100644 --- a/src/test/bench/shootout-k-nucleotide-pipes.rs +++ b/src/test/bench/shootout-k-nucleotide-pipes.rs @@ -129,7 +129,7 @@ fn make_sequence_processor(sz: uint, from_parent: pipes::Port<~[u8]>, _ => { ~"" } }; - //comm::send(to_parent, fmt!("yay{%u}", sz)); + //oldcomm::send(to_parent, fmt!("yay{%u}", sz)); to_parent.send(move buffer); } diff --git a/src/test/bench/shootout-mandelbrot.rs b/src/test/bench/shootout-mandelbrot.rs index 8c234f9e11d..a45138d72d9 100644 --- a/src/test/bench/shootout-mandelbrot.rs +++ b/src/test/bench/shootout-mandelbrot.rs @@ -87,7 +87,7 @@ fn fillbyte(x: cmplx, incr: f64) -> u8 { rv } -fn chanmb(i: uint, size: uint, ch: comm::Chan) -> () +fn chanmb(i: uint, size: uint, ch: oldcomm::Chan) -> () { let mut crv = ~[]; let incr = 2f64/(size as f64); @@ -97,7 +97,7 @@ fn chanmb(i: uint, size: uint, ch: comm::Chan) -> () 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}; @@ -110,11 +110,11 @@ impl devnull: io::Writer { fn get_type() -> io::WriterType { io::File } } -fn writer(path: ~str, writech: comm::Chan>, size: uint) +fn writer(path: ~str, writech: oldcomm::Chan>, size: uint) { - let p: comm::Port = comm::Port(); - let ch = comm::Chan(&p); - comm::send(writech, ch); + let p: oldcomm::Port = oldcomm::Port(); + let ch = oldcomm::Chan(&p); + oldcomm::send(writech, ch); let cout: io::Writer = match path { ~"" => { {dn: 0} as io::Writer @@ -134,7 +134,7 @@ fn writer(path: ~str, writech: comm::Chan>, size: uint) 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); @@ -178,12 +178,12 @@ fn main() { 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 { diff --git a/src/test/bench/shootout-pfib.rs b/src/test/bench/shootout-pfib.rs index c5429086c43..80bcb834054 100644 --- a/src/test/bench/shootout-pfib.rs +++ b/src/test/bench/shootout-pfib.rs @@ -14,7 +14,7 @@ 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. */ diff --git a/src/test/bench/shootout-threadring.rs b/src/test/bench/shootout-threadring.rs deleted file mode 100644 index 40e05ec39b7..00000000000 --- a/src/test/bench/shootout-threadring.rs +++ /dev/null @@ -1,63 +0,0 @@ -// 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 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -// Based on threadring.erlang by Jira Isa -extern mod std; - -const n_threads: int = 503; - -fn start(+token: int) { - use iter::*; - - let p = comm::Port(); - let mut ch = comm::Chan(&p); - for int::range(2, n_threads + 1) |i| { - let id = n_threads + 2 - i; - let to_child = do task::spawn_listener:: |p, copy ch| { - roundtrip(id, p, ch) - }; - ch = to_child; - } - comm::send(ch, token); - roundtrip(1, p, ch); -} - -fn roundtrip(id: int, p: comm::Port, ch: comm::Chan) { - while (true) { - match comm::recv(p) { - 1 => { - io::println(fmt!("%d\n", id)); - return; - } - token => { - debug!("%d %d", id, token); - comm::send(ch, token - 1); - if token <= n_threads { - return; - } - } - } - } -} - -fn main() { - let args = os::args(); - let args = if os::getenv(~"RUST_BENCH").is_some() { - ~[~"", ~"2000000"] - } else if args.len() <= 1u { - ~[~"", ~"1000"] - } else { - args - }; - - let token = int::from_str(args[1]).get(); - - start(token); -} diff --git a/src/test/bench/task-perf-linked-failure.rs b/src/test/bench/task-perf-linked-failure.rs index 1b60cfcd38b..c58f07dad2e 100644 --- a/src/test/bench/task-perf-linked-failure.rs +++ b/src/test/bench/task-perf-linked-failure.rs @@ -20,20 +20,20 @@ // 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. diff --git a/src/test/bench/task-perf-one-million.rs b/src/test/bench/task-perf-one-million.rs index d6ae6979510..e4c7718325f 100644 --- a/src/test/bench/task-perf-one-million.rs +++ b/src/test/bench/task-perf-one-million.rs @@ -11,14 +11,14 @@ // Test for concurrent tasks enum msg { - ready(comm::Chan), + ready(oldcomm::Chan), start, done(int), } -fn calc(children: uint, parent_ch: comm::Chan) { - let port = comm::Port(); - let chan = comm::Chan(&port); +fn calc(children: uint, parent_ch: oldcomm::Chan) { + let port = oldcomm::Port(); + let chan = oldcomm::Chan(&port); let mut child_chs = ~[]; let mut sum = 0; @@ -29,7 +29,7 @@ fn calc(children: uint, parent_ch: comm::Chan) { } for iter::repeat (children) { - match comm::recv(port) { + match oldcomm::recv(port) { ready(child_ch) => { child_chs.push(child_ch); } @@ -37,25 +37,25 @@ fn calc(children: uint, parent_ch: comm::Chan) { } } - 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() { @@ -69,18 +69,18 @@ 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)" }; diff --git a/src/test/bench/task-perf-word-count-generic.rs b/src/test/bench/task-perf-word-count-generic.rs index 8cee0b5f7f3..5c09248b59c 100644 --- a/src/test/bench/task-perf-word-count-generic.rs +++ b/src/test/bench/task-perf-word-count-generic.rs @@ -13,7 +13,7 @@ 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. */ @@ -32,10 +32,10 @@ use io::{ReaderUtil, WriterUtil}; 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; diff --git a/src/test/compile-fail/no-capture-arc.rs b/src/test/compile-fail/no-capture-arc.rs index 6143e869988..98220195e61 100644 --- a/src/test/compile-fail/no-capture-arc.rs +++ b/src/test/compile-fail/no-capture-arc.rs @@ -12,7 +12,7 @@ extern mod std; use std::arc; -use comm::*; +use oldcomm::*; fn main() { let v = ~[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; diff --git a/src/test/compile-fail/no-reuse-move-arc.rs b/src/test/compile-fail/no-reuse-move-arc.rs index cd059e32550..8cb8f31c489 100644 --- a/src/test/compile-fail/no-reuse-move-arc.rs +++ b/src/test/compile-fail/no-reuse-move-arc.rs @@ -10,7 +10,7 @@ extern mod std; use std::arc; -use comm::*; +use oldcomm::*; fn main() { let v = ~[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; diff --git a/src/test/compile-fail/no-send-res-ports.rs b/src/test/compile-fail/no-send-res-ports.rs index fee93e9b838..4dd0df31aab 100644 --- a/src/test/compile-fail/no-send-res-ports.rs +++ b/src/test/compile-fail/no-send-res-ports.rs @@ -10,20 +10,20 @@ 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; diff --git a/src/test/compile-fail/unsendable-class.rs b/src/test/compile-fail/unsendable-class.rs index ef9e0aae95e..7f60e3ec87a 100644 --- a/src/test/compile-fail/unsendable-class.rs +++ b/src/test/compile-fail/unsendable-class.rs @@ -25,7 +25,7 @@ fn foo(i:int, j: @~str) -> foo { 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` } diff --git a/src/test/run-fail/linked-failure.rs b/src/test/run-fail/linked-failure.rs index c1c9142fdd9..8154329f7ae 100644 --- a/src/test/run-fail/linked-failure.rs +++ b/src/test/run-fail/linked-failure.rs @@ -12,8 +12,8 @@ // error-pattern:1 == 2 extern mod std; -use comm::Port; -use comm::recv; +use oldcomm::Port; +use oldcomm::recv; fn child() { assert (1 == 2); } diff --git a/src/test/run-fail/linked-failure2.rs b/src/test/run-fail/linked-failure2.rs index 6a53980ad92..1a95118d0a6 100644 --- a/src/test/run-fail/linked-failure2.rs +++ b/src/test/run-fail/linked-failure2.rs @@ -12,9 +12,9 @@ // 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; } diff --git a/src/test/run-fail/linked-failure3.rs b/src/test/run-fail/linked-failure3.rs index 589cc889035..5df06ff6f81 100644 --- a/src/test/run-fail/linked-failure3.rs +++ b/src/test/run-fail/linked-failure3.rs @@ -12,8 +12,8 @@ // error-pattern:fail extern mod std; -use comm::Port; -use comm::recv; +use oldcomm::Port; +use oldcomm::recv; fn grandchild() { fail ~"grandchild dies"; } diff --git a/src/test/run-fail/linked-failure4.rs b/src/test/run-fail/linked-failure4.rs index cdea1f14a95..ea9c9f22e22 100644 --- a/src/test/run-fail/linked-failure4.rs +++ b/src/test/run-fail/linked-failure4.rs @@ -11,9 +11,9 @@ // 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); } diff --git a/src/test/run-fail/port-type.rs b/src/test/run-fail/port-type.rs index 8b4c1e3ea30..bd1541302a4 100644 --- a/src/test/run-fail/port-type.rs +++ b/src/test/run-fail/port-type.rs @@ -10,10 +10,10 @@ // 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(c: Chan, oc: Chan>) { // Tests that the type argument in port gets diff --git a/src/test/run-fail/task-comm-recv-block.rs b/src/test/run-fail/task-comm-recv-block.rs index 9f23fa0044b..6c70dd09d57 100644 --- a/src/test/run-fail/task-comm-recv-block.rs +++ b/src/test/run-fail/task-comm-recv-block.rs @@ -19,9 +19,9 @@ fn goodfail() { 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"; } diff --git a/src/test/run-pass/acyclic-unwind.rs b/src/test/run-pass/acyclic-unwind.rs index ede596c32e1..8f315205573 100644 --- a/src/test/run-pass/acyclic-unwind.rs +++ b/src/test/run-pass/acyclic-unwind.rs @@ -13,14 +13,14 @@ extern mod std; -fn f(c: comm::_chan) { +fn f(c: oldcomm::_chan) { 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 { @@ -31,12 +31,12 @@ fn f(c: comm::_chan) { // 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; diff --git a/src/test/run-pass/auto_serialize.rs b/src/test/run-pass/auto_serialize.rs index 5472903f32b..1a0ba61eb19 100644 --- a/src/test/run-pass/auto_serialize.rs +++ b/src/test/run-pass/auto_serialize.rs @@ -15,7 +15,7 @@ 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; diff --git a/src/test/run-pass/basic-1.rs b/src/test/run-pass/basic-1.rs index 834040e0e57..7f7da086df3 100644 --- a/src/test/run-pass/basic-1.rs +++ b/src/test/run-pass/basic-1.rs @@ -10,25 +10,25 @@ // except according to those terms. -fn a(c: core::comm::Chan) { core::comm::send(c, 10); } +fn a(c: core::oldcomm::Chan) { 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) { +fn b(c: core::oldcomm::Chan) { // 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); } diff --git a/src/test/run-pass/basic-2.rs b/src/test/run-pass/basic-2.rs index df8eb39da30..36ed4c5162b 100644 --- a/src/test/run-pass/basic-2.rs +++ b/src/test/run-pass/basic-2.rs @@ -10,28 +10,28 @@ // except according to those terms. -fn a(c: core::comm::Chan) { +fn a(c: core::oldcomm::Chan) { 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) { +fn b(c: core::oldcomm::Chan) { 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); } diff --git a/src/test/run-pass/basic.rs b/src/test/run-pass/basic.rs index bc7b194d7b4..a84bfdcdbb7 100644 --- a/src/test/run-pass/basic.rs +++ b/src/test/run-pass/basic.rs @@ -10,7 +10,7 @@ // except according to those terms. -fn a(c: core::comm::Chan) { +fn a(c: core::oldcomm::Chan) { if true { debug!("task a"); debug!("task a"); @@ -18,7 +18,7 @@ fn a(c: core::comm::Chan) { debug!("task a"); debug!("task a"); } - core::comm::send(c, 10); + core::oldcomm::send(c, 10); } fn k(x: int) -> int { return 15; } @@ -33,19 +33,19 @@ fn g(x: int, y: ~str) -> int { 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) { +fn b(c: core::oldcomm::Chan) { if true { debug!("task b"); debug!("task b"); @@ -54,5 +54,5 @@ fn b(c: core::comm::Chan) { debug!("task b"); debug!("task b"); } - core::comm::send(c, 10); + core::oldcomm::send(c, 10); } diff --git a/src/test/run-pass/capture_nil.rs b/src/test/run-pass/capture_nil.rs index c82fc0bcd68..8f9049ac27b 100644 --- a/src/test/run-pass/capture_nil.rs +++ b/src/test/run-pass/capture_nil.rs @@ -24,9 +24,9 @@ // 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); } diff --git a/src/test/run-pass/cci_capture_clause.rs b/src/test/run-pass/cci_capture_clause.rs index 447363117bc..be64fcd8992 100644 --- a/src/test/run-pass/cci_capture_clause.rs +++ b/src/test/run-pass/cci_capture_clause.rs @@ -18,7 +18,7 @@ extern mod cci_capture_clause; -use comm::recv; +use oldcomm::recv; fn main() { cci_capture_clause::foo(()).recv() diff --git a/src/test/run-pass/chan-leak.rs b/src/test/run-pass/chan-leak.rs index b88799c4475..bb429a07f39 100644 --- a/src/test/run-pass/chan-leak.rs +++ b/src/test/run-pass/chan-leak.rs @@ -10,32 +10,32 @@ // Issue #763 -enum request { quit, close(core::comm::Chan), } +enum request { quit, close(core::oldcomm::Chan), } -type ctx = core::comm::Chan; +type ctx = core::oldcomm::Chan; -fn request_task(c: core::comm::Chan) { - let p = core::comm::Port(); - core::comm::send(c, core::comm::Chan(&p)); +fn request_task(c: core::oldcomm::Chan) { + 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::(); - core::comm::send(cx, close(core::comm::Chan(&p))); - core::comm::send(cx, quit); + let p = core::oldcomm::Port::(); + core::oldcomm::send(cx, close(core::oldcomm::Chan(&p))); + core::oldcomm::send(cx, quit); } diff --git a/src/test/run-pass/comm.rs b/src/test/run-pass/comm.rs index cae462c4d5d..453ae679523 100644 --- a/src/test/run-pass/comm.rs +++ b/src/test/run-pass/comm.rs @@ -11,17 +11,17 @@ 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) { +fn child(c: core::oldcomm::Chan) { error!("sending"); - core::comm::send(c, 10); + core::oldcomm::send(c, 10); error!("value sent"); } diff --git a/src/test/run-pass/decl-with-recv.rs b/src/test/run-pass/decl-with-recv.rs index 4d1ad84225d..4b4d6a86806 100644 --- a/src/test/run-pass/decl-with-recv.rs +++ b/src/test/run-pass/decl-with-recv.rs @@ -11,12 +11,12 @@ 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); } diff --git a/src/test/run-pass/hashmap-memory.rs b/src/test/run-pass/hashmap-memory.rs index e8204d48f33..c8fbb0dd741 100644 --- a/src/test/run-pass/hashmap-memory.rs +++ b/src/test/run-pass/hashmap-memory.rs @@ -20,10 +20,10 @@ extern mod std; 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"); } diff --git a/src/test/run-pass/issue-507.rs b/src/test/run-pass/issue-507.rs index 5d267f9d914..556e597a86d 100644 --- a/src/test/run-pass/issue-507.rs +++ b/src/test/run-pass/issue-507.rs @@ -15,19 +15,19 @@ https://github.com/graydon/rust/issues/507 */ -fn grandchild(c: core::comm::Chan) { core::comm::send(c, 42); } +fn grandchild(c: core::oldcomm::Chan) { core::oldcomm::send(c, 42); } -fn child(c: core::comm::Chan) { +fn child(c: core::oldcomm::Chan) { 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); diff --git a/src/test/run-pass/issue-687.rs b/src/test/run-pass/issue-687.rs index bac6dc67ac2..9cfec06007c 100644 --- a/src/test/run-pass/issue-687.rs +++ b/src/test/run-pass/issue-687.rs @@ -10,18 +10,18 @@ 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>, msg: core::comm::Chan) { - let p: core::comm::Port<~[u8]> = core::comm::Port(); - core::comm::send(cb, core::comm::Chan(&p)); +fn packager(cb: core::oldcomm::Chan>, msg: core::oldcomm::Chan) { + 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"); @@ -29,26 +29,26 @@ fn packager(cb: core::comm::Chan>, msg: core::comm::Chan } 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 = core::comm::Port(); - let ch = core::comm::Chan(&p); - let recv_reader: core::comm::Port> = core::comm::Port(); - let recv_reader_chan = core::comm::Chan(&recv_reader); + let p: core::oldcomm::Port = core::oldcomm::Port(); + let ch = core::oldcomm::Chan(&p); + let recv_reader: core::oldcomm::Port> = 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) => { diff --git a/src/test/run-pass/issue-783.rs b/src/test/run-pass/issue-783.rs index 2654a738599..3820ff77022 100644 --- a/src/test/run-pass/issue-783.rs +++ b/src/test/run-pass/issue-783.rs @@ -10,14 +10,14 @@ fn a() { fn doit() { - fn b(c: core::comm::Chan>) { - let p = core::comm::Port(); - core::comm::send(c, core::comm::Chan(&p)); + fn b(c: core::oldcomm::Chan>) { + 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 { diff --git a/src/test/run-pass/ivec-tag.rs b/src/test/run-pass/ivec-tag.rs index 4a33d770872..7066b5f63cd 100644 --- a/src/test/run-pass/ivec-tag.rs +++ b/src/test/run-pass/ivec-tag.rs @@ -1,13 +1,13 @@ -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); } diff --git a/src/test/run-pass/lazychan.rs b/src/test/run-pass/lazychan.rs index a093b89b70f..34244c2ef01 100644 --- a/src/test/run-pass/lazychan.rs +++ b/src/test/run-pass/lazychan.rs @@ -10,21 +10,21 @@ // 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) { core::comm::send(c, 10); } +fn child(c: core::oldcomm::Chan) { core::oldcomm::send(c, 10); } diff --git a/src/test/run-pass/many.rs b/src/test/run-pass/many.rs index dd0ff175260..23153b79cd9 100644 --- a/src/test/run-pass/many.rs +++ b/src/test/run-pass/many.rs @@ -12,23 +12,23 @@ extern mod std; -fn sub(parent: comm::Chan, id: int) { +fn sub(parent: oldcomm::Chan, 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); diff --git a/src/test/run-pass/multiline-comment.rs b/src/test/run-pass/multiline-comment.rs index 397415150ca..993dea560cf 100644 --- a/src/test/run-pass/multiline-comment.rs +++ b/src/test/run-pass/multiline-comment.rs @@ -11,6 +11,6 @@ /* - * This is a multi-line comment. + * This is a multi-line oldcomment. */ fn main() { } diff --git a/src/test/run-pass/rt-circular-buffer.rs b/src/test/run-pass/rt-circular-buffer.rs index 6fde5bef741..dca62e0f9df 100644 --- a/src/test/run-pass/rt-circular-buffer.rs +++ b/src/test/run-pass/rt-circular-buffer.rs @@ -13,7 +13,7 @@ // 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}; @@ -22,52 +22,52 @@ 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); @@ -78,16 +78,16 @@ fn test_rotate() { // 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::(); - let mychan = core::comm::Chan(&myport); + let myport = core::oldcomm::Port::(); + 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); diff --git a/src/test/run-pass/rt-sched-1.rs b/src/test/run-pass/rt-sched-1.rs index ed45627a379..09f9bee7527 100644 --- a/src/test/run-pass/rt-sched-1.rs +++ b/src/test/run-pass/rt-sched-1.rs @@ -25,8 +25,8 @@ extern mod rustrt { } 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; @@ -39,10 +39,10 @@ fn main() unsafe { 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); } diff --git a/src/test/run-pass/send-iloop.rs b/src/test/run-pass/send-iloop.rs index 613c5a86eec..6e6c64f4533 100644 --- a/src/test/run-pass/send-iloop.rs +++ b/src/test/run-pass/send-iloop.rs @@ -17,13 +17,13 @@ fn die() { 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); } } diff --git a/src/test/run-pass/send-resource.rs b/src/test/run-pass/send-resource.rs index 75d526aa2c7..a85b01acc8e 100644 --- a/src/test/run-pass/send-resource.rs +++ b/src/test/run-pass/send-resource.rs @@ -23,12 +23,12 @@ fn test(f: int) -> test { } 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(); } diff --git a/src/test/run-pass/send-type-inference.rs b/src/test/run-pass/send-type-inference.rs index a8878075b26..8476e256cd2 100644 --- a/src/test/run-pass/send-type-inference.rs +++ b/src/test/run-pass/send-type-inference.rs @@ -11,8 +11,8 @@ // tests that ctrl's type gets inferred properly type command = {key: K, val: V}; -fn cache_server(c: core::comm::Chan>>) { - let ctrl = core::comm::Port(); - core::comm::send(c, core::comm::Chan(&ctrl)); +fn cache_server(c: oldcomm::Chan>>) { + let ctrl = oldcomm::Port(); + oldcomm::send(c, oldcomm::Chan(&ctrl)); } fn main() { } diff --git a/src/test/run-pass/sendable-class.rs b/src/test/run-pass/sendable-class.rs index 53298cee2c8..e027bddb8f1 100644 --- a/src/test/run-pass/sendable-class.rs +++ b/src/test/run-pass/sendable-class.rs @@ -23,7 +23,7 @@ fn foo(i:int, j: char) -> foo { } fn main() { - let po = comm::Port::(); - let ch = comm::Chan(&po); - comm::send(ch, foo(42, 'c')); + let po = oldcomm::Port::(); + let ch = oldcomm::Chan(&po); + oldcomm::send(ch, foo(42, 'c')); } \ No newline at end of file diff --git a/src/test/run-pass/sendfn-generic-fn.rs b/src/test/run-pass/sendfn-generic-fn.rs index 64359bfae43..1a6cf7e04cc 100644 --- a/src/test/run-pass/sendfn-generic-fn.rs +++ b/src/test/run-pass/sendfn-generic-fn.rs @@ -13,8 +13,8 @@ extern mod std; -use comm::Chan; -use comm::send; +use oldcomm::Chan; +use oldcomm::send; fn main() { test05(); } diff --git a/src/test/run-pass/spawn-types.rs b/src/test/run-pass/spawn-types.rs index 96e02dfb73b..78914f0531f 100644 --- a/src/test/run-pass/spawn-types.rs +++ b/src/test/run-pass/spawn-types.rs @@ -17,14 +17,14 @@ extern mod std; -type ctx = comm::Chan; +type ctx = oldcomm::Chan; fn iotask(cx: ctx, ip: ~str) { assert (ip == ~"localhost"); } fn main() { - let p = comm::Port::(); - let ch = comm::Chan(&p); + let p = oldcomm::Port::(); + let ch = oldcomm::Chan(&p); task::spawn(|| iotask(ch, ~"localhost") ); } diff --git a/src/test/run-pass/task-comm-chan-cleanup.rs b/src/test/run-pass/task-comm-chan-cleanup.rs index 4379c89ba2e..f2c0c807e82 100644 --- a/src/test/run-pass/task-comm-chan-cleanup.rs +++ b/src/test/run-pass/task-comm-chan-cleanup.rs @@ -11,7 +11,7 @@ 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 diff --git a/src/test/run-pass/task-comm-chan-cleanup2.rs b/src/test/run-pass/task-comm-chan-cleanup2.rs index 4379c89ba2e..f2c0c807e82 100644 --- a/src/test/run-pass/task-comm-chan-cleanup2.rs +++ b/src/test/run-pass/task-comm-chan-cleanup2.rs @@ -11,7 +11,7 @@ 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 diff --git a/src/test/run-pass/task-comm-chan-cleanup3.rs b/src/test/run-pass/task-comm-chan-cleanup3.rs index f1062680982..23b87fb7352 100644 --- a/src/test/run-pass/task-comm-chan-cleanup3.rs +++ b/src/test/run-pass/task-comm-chan-cleanup3.rs @@ -12,8 +12,8 @@ extern mod std; 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 diff --git a/src/test/run-pass/task-comm-chan-cleanup4.rs b/src/test/run-pass/task-comm-chan-cleanup4.rs index 7c23609db7a..2afdcc63268 100644 --- a/src/test/run-pass/task-comm-chan-cleanup4.rs +++ b/src/test/run-pass/task-comm-chan-cleanup4.rs @@ -13,16 +13,16 @@ extern mod std; // 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(); } diff --git a/src/test/run-pass/task-comm-chan-nil.rs b/src/test/run-pass/task-comm-chan-nil.rs index 646d88124b9..620262065a5 100644 --- a/src/test/run-pass/task-comm-chan-nil.rs +++ b/src/test/run-pass/task-comm-chan-nil.rs @@ -16,9 +16,9 @@ extern mod std; // 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 == ()); } diff --git a/src/test/run-pass/task-comm.rs b/src/test/run-pass/task-comm.rs index 5147c2ba6e4..d95f4af791c 100644 --- a/src/test/run-pass/task-comm.rs +++ b/src/test/run-pass/task-comm.rs @@ -17,12 +17,12 @@ fn main() { test06(); } -fn test00_start(ch: core::comm::Chan, message: int, count: int) { +fn test00_start(ch: core::oldcomm::Chan, 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"); @@ -33,8 +33,8 @@ fn test00() { 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; @@ -50,7 +50,7 @@ fn test00() { 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(); } @@ -63,19 +63,19 @@ fn test00() { } 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); } @@ -93,22 +93,22 @@ fn test04() { debug!("Finishing up."); } -fn test05_start(ch: core::comm::Chan) { - 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) { + 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); } diff --git a/src/test/run-pass/task-compare.rs b/src/test/run-pass/task-compare.rs index a1d9d3aa411..fd45910ee88 100644 --- a/src/test/run-pass/task-compare.rs +++ b/src/test/run-pass/task-compare.rs @@ -18,7 +18,7 @@ extern mod std; fn child() { } struct notify { - ch: comm::Chan, v: @mut bool, + ch: oldcomm::Chan, v: @mut bool, } impl notify : Drop { @@ -29,19 +29,19 @@ 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, v: @mut bool) -> notify { +fn notify(ch: oldcomm::Chan, v: @mut bool) -> notify { notify { ch: ch, v: v } } -fn joinable(+f: fn~()) -> comm::Port { - fn wrapper(+c: comm::Chan, +f: fn()) { +fn joinable(+f: fn~()) -> oldcomm::Port { + fn wrapper(+c: oldcomm::Chan, +f: fn()) { let b = @mut false; error!("wrapper: task=%? allocated v=%x", task::get_task(), @@ -50,14 +50,14 @@ fn joinable(+f: fn~()) -> comm::Port { 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 { - comm::recv(port) +fn join(port: oldcomm::Port) -> bool { + oldcomm::recv(port) } fn main() { @@ -76,15 +76,15 @@ fn main() { let p1; let p2; - p1 = comm::Port::(); - p2 = comm::Port::(); + p1 = oldcomm::Port::(); + p2 = oldcomm::Port::(); 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); diff --git a/src/test/run-pass/task-killjoin-rsrc.rs b/src/test/run-pass/task-killjoin-rsrc.rs index 2fe24a7b38e..029bab51770 100644 --- a/src/test/run-pass/task-killjoin-rsrc.rs +++ b/src/test/run-pass/task-killjoin-rsrc.rs @@ -14,7 +14,7 @@ // the join. struct notify { - ch: comm::Chan, v: @mut bool, + ch: oldcomm::Chan, v: @mut bool, } impl notify : Drop { @@ -25,19 +25,19 @@ 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, v: @mut bool) -> notify { +fn notify(ch: oldcomm::Chan, v: @mut bool) -> notify { notify { ch: ch, v: v } } -fn joinable(+f: fn~()) -> comm::Port { - fn wrapper(+c: comm::Chan, +f: fn()) { +fn joinable(+f: fn~()) -> oldcomm::Port { + fn wrapper(+c: oldcomm::Chan, +f: fn()) { let b = @mut false; error!("wrapper: task=%? allocated v=%x", task::get_task(), @@ -46,14 +46,14 @@ fn joinable(+f: fn~()) -> comm::Port { 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 { - comm::recv(port) +fn join(port: oldcomm::Port) -> bool { + oldcomm::recv(port) } fn supervised() { diff --git a/src/test/run-pass/task-spawn-move-and-copy.rs b/src/test/run-pass/task-spawn-move-and-copy.rs index d9dadddf137..4ee2413ab19 100644 --- a/src/test/run-pass/task-spawn-move-and-copy.rs +++ b/src/test/run-pass/task-spawn-move-and-copy.rs @@ -9,8 +9,8 @@ // except according to those terms. fn main() { - let p = comm::Port::(); - let ch = comm::Chan(&p); + let p = oldcomm::Port::(); + let ch = oldcomm::Chan(&p); let x = ~1; let x_in_parent = ptr::addr_of(&(*x)) as uint; @@ -20,17 +20,17 @@ fn main() { 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; } diff --git a/src/test/run-pass/unique-send-2.rs b/src/test/run-pass/unique-send-2.rs index 299470e6cf9..c1709f2ca23 100644 --- a/src/test/run-pass/unique-send-2.rs +++ b/src/test/run-pass/unique-send-2.rs @@ -10,13 +10,13 @@ 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| { @@ -26,7 +26,7 @@ fn main() { let mut actual = 0u; for uint::range(0u, n) |_i| { - let j = comm::recv(p); + let j = oldcomm::recv(p); actual += *j; } diff --git a/src/test/run-pass/unique-send.rs b/src/test/run-pass/unique-send.rs index 47125c367d5..6bbfabc8757 100644 --- a/src/test/run-pass/unique-send.rs +++ b/src/test/run-pass/unique-send.rs @@ -11,9 +11,9 @@ 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 diff --git a/src/test/run-pass/unwind-resource.rs b/src/test/run-pass/unwind-resource.rs index 09070b7e7e2..263ac090c99 100644 --- a/src/test/run-pass/unwind-resource.rs +++ b/src/test/run-pass/unwind-resource.rs @@ -12,33 +12,33 @@ extern mod std; struct complainer { - c: comm::Chan, + c: oldcomm::Chan, } 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) -> complainer { +fn complainer(c: oldcomm::Chan) -> complainer { error!("Hello!"); complainer { c: c } } -fn f(c: comm::Chan) { +fn f(c: oldcomm::Chan) { 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); } diff --git a/src/test/run-pass/variant-attributes.rs b/src/test/run-pass/variant-attributes.rs index 0c342bf1b2b..86df25d5496 100644 --- a/src/test/run-pass/variant-attributes.rs +++ b/src/test/run-pass/variant-attributes.rs @@ -15,7 +15,7 @@ enum crew_of_enterprise_d { #[captain] jean_luc_picard, - #[commander] + #[oldcommander] william_t_riker, #[chief_medical_officer] @@ -24,7 +24,7 @@ enum crew_of_enterprise_d { #[ships_councellor] deanna_troi, - #[lieutenant_commander] + #[lieutenant_oldcommander] data, #[chief_of_security]