about summary refs log tree commit diff
path: root/src/libstd
diff options
context:
space:
mode:
Diffstat (limited to 'src/libstd')
-rw-r--r--src/libstd/deque.rs2
-rw-r--r--src/libstd/net_tcp.rs60
-rw-r--r--src/libstd/net_url.rs10
-rw-r--r--src/libstd/smallintmap.rs4
-rw-r--r--src/libstd/tempfile.rs2
-rw-r--r--src/libstd/test.rs20
-rw-r--r--src/libstd/timer.rs24
-rw-r--r--src/libstd/uv_global_loop.rs14
-rw-r--r--src/libstd/uv_iotask.rs20
-rw-r--r--src/libstd/uv_ll.rs12
10 files changed, 84 insertions, 84 deletions
diff --git a/src/libstd/deque.rs b/src/libstd/deque.rs
index 215f1667922..838bd695d9d 100644
--- a/src/libstd/deque.rs
+++ b/src/libstd/deque.rs
@@ -1,7 +1,7 @@
 //! A deque. Untested as of yet. Likely buggy
 
 import option::{Some, None};
-import dvec::{DVec, dvec};
+import dvec::DVec;
 
 trait t<T> {
     fn size() -> uint;
diff --git a/src/libstd/net_tcp.rs b/src/libstd/net_tcp.rs
index 07c5319ae3d..cb0fddcfe61 100644
--- a/src/libstd/net_tcp.rs
+++ b/src/libstd/net_tcp.rs
@@ -121,19 +121,19 @@ enum tcp_connect_err_data {
 fn connect(-input_ip: ip::ip_addr, port: uint,
            iotask: iotask)
     -> result::Result<tcp_socket, tcp_connect_err_data> unsafe {
-    let result_po = core::comm::port::<conn_attempt>();
-    let closed_signal_po = core::comm::port::<()>();
+    let result_po = core::comm::Port::<conn_attempt>();
+    let closed_signal_po = core::comm::Port::<()>();
     let conn_data = {
-        result_ch: core::comm::chan(result_po),
-        closed_signal_ch: core::comm::chan(closed_signal_po)
+        result_ch: core::comm::Chan(result_po),
+        closed_signal_ch: core::comm::Chan(closed_signal_po)
     };
     let conn_data_ptr = ptr::addr_of(conn_data);
-    let reader_po = core::comm::port::<result::Result<~[u8], tcp_err_data>>();
+    let reader_po = core::comm::Port::<result::Result<~[u8], tcp_err_data>>();
     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: core::comm::Chan(reader_po),
         stream_handle_ptr: stream_handle_ptr,
         connect_req: uv::ll::connect_t(),
         write_req: uv::ll::write_t(),
@@ -468,13 +468,13 @@ fn accept(new_conn: tcp_new_connection)
       new_tcp_conn(server_handle_ptr) => {
         let server_data_ptr = uv::ll::get_data_for_uv_handle(
             server_handle_ptr) as *tcp_listen_fc_data;
-        let reader_po = core::comm::port();
+        let reader_po = core::comm::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: core::comm::Chan(reader_po),
             stream_handle_ptr : stream_handle_ptr,
             connect_req : uv::ll::connect_t(),
             write_req : uv::ll::write_t(),
@@ -484,8 +484,8 @@ fn accept(new_conn: tcp_new_connection)
         let client_stream_handle_ptr =
             (*client_socket_data_ptr).stream_handle_ptr;
 
-        let result_po = core::comm::port::<Option<tcp_err_data>>();
-        let result_ch = core::comm::chan(result_po);
+        let result_po = core::comm::Port::<Option<tcp_err_data>>();
+        let result_ch = core::comm::Chan(result_po);
 
         // UNSAFE LIBUV INTERACTION BEGIN
         // .. normally this happens within the context of
@@ -581,14 +581,14 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
           on_establish_cb: fn~(comm::Chan<Option<tcp_err_data>>),
           -on_connect_cb: fn~(*uv::ll::uv_tcp_t))
     -> result::Result<(), tcp_listen_err_data> unsafe {
-    let stream_closed_po = core::comm::port::<()>();
-    let kill_po = core::comm::port::<Option<tcp_err_data>>();
-    let kill_ch = core::comm::chan(kill_po);
+    let stream_closed_po = core::comm::Port::<()>();
+    let kill_po = core::comm::Port::<Option<tcp_err_data>>();
+    let kill_ch = core::comm::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: core::comm::Chan(stream_closed_po),
         kill_ch: kill_ch,
         on_connect_cb: on_connect_cb,
         iotask: iotask,
@@ -833,8 +833,8 @@ impl tcp_socket_buf: io::Writer {
 // INTERNAL API
 
 fn tear_down_socket_data(socket_data: @tcp_socket_data) unsafe {
-    let closed_po = core::comm::port::<()>();
-    let closed_ch = core::comm::chan(closed_po);
+    let closed_po = core::comm::Port::<()>();
+    let closed_ch = core::comm::Chan(closed_po);
     let close_data = {
         closed_ch: closed_ch
     };
@@ -896,8 +896,8 @@ fn read_common_impl(socket_data: *tcp_socket_data, timeout_msecs: uint)
 fn read_stop_common_impl(socket_data: *tcp_socket_data) ->
     result::Result<(), tcp_err_data> unsafe {
     let stream_handle_ptr = (*socket_data).stream_handle_ptr;
-    let stop_po = core::comm::port::<Option<tcp_err_data>>();
-    let stop_ch = core::comm::chan(stop_po);
+    let stop_po = core::comm::Port::<Option<tcp_err_data>>();
+    let stop_ch = core::comm::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) {
@@ -923,8 +923,8 @@ fn read_start_common_impl(socket_data: *tcp_socket_data)
     -> result::Result<comm::Port<
         result::Result<~[u8], tcp_err_data>>, tcp_err_data> unsafe {
     let stream_handle_ptr = (*socket_data).stream_handle_ptr;
-    let start_po = core::comm::port::<Option<uv::ll::uv_err_data>>();
-    let start_ch = core::comm::chan(start_po);
+    let start_po = core::comm::Port::<Option<uv::ll::uv_err_data>>();
+    let start_ch = core::comm::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));
@@ -961,9 +961,9 @@ fn write_common_impl(socket_data_ptr: *tcp_socket_data,
         vec::unsafe::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::<tcp_write_result>();
+    let result_po = core::comm::Port::<tcp_write_result>();
     let write_data = {
-        result_ch: core::comm::chan(result_po)
+        result_ch: core::comm::Chan(result_po)
     };
     let write_data_ptr = ptr::addr_of(write_data);
     do iotask::interact((*socket_data_ptr).iotask) |loop_ptr| unsafe {
@@ -1278,11 +1278,11 @@ 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 = core::comm::Port::<~str>();
+        let server_result_ch = core::comm::Chan(server_result_po);
 
-        let cont_po = core::comm::port::<()>();
-        let cont_ch = core::comm::chan(cont_po);
+        let cont_po = core::comm::Port::<()>();
+        let cont_ch = core::comm::Chan(cont_po);
         // server
         do task::spawn_sched(task::ManualThreads(1u)) {
             let actual_req = do comm::listen |server_ch| {
@@ -1344,11 +1344,11 @@ 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 = core::comm::Port::<~str>();
+        let server_result_ch = core::comm::Chan(server_result_po);
 
-        let cont_po = core::comm::port::<()>();
-        let cont_ch = core::comm::chan(cont_po);
+        let cont_po = core::comm::Port::<()>();
+        let cont_ch = core::comm::Chan(cont_po);
         // server
         do task::spawn_sched(task::ManualThreads(1u)) {
             let actual_req = do comm::listen |server_ch| {
diff --git a/src/libstd/net_url.rs b/src/libstd/net_url.rs
index 8e8a7419902..7770d376f9b 100644
--- a/src/libstd/net_url.rs
+++ b/src/libstd/net_url.rs
@@ -3,7 +3,7 @@
 import map;
 import map::{hashmap, str_hash};
 import io::{Reader, ReaderUtil};
-import dvec::{DVec, dvec};
+import dvec::DVec;
 
 export url, userinfo, query;
 export from_str, to_str;
@@ -217,7 +217,7 @@ fn decode_form_urlencoded(s: ~[u8]) ->
                     let values = match m.find(key) {
                       Some(values) => values,
                       None => {
-                        let values = @dvec();
+                        let values = @DVec();
                         m.insert(key, values);
                         values
                       }
@@ -252,7 +252,7 @@ fn decode_form_urlencoded(s: ~[u8]) ->
             let values = match m.find(key) {
               Some(values) => values,
               None => {
-                let values = @dvec();
+                let values = @DVec();
                 m.insert(key, values);
                 values
               }
@@ -1010,8 +1010,8 @@ mod tests {
         let m = str_hash();
         assert encode_form_urlencoded(m) == ~"";
 
-        m.insert(~"", @dvec());
-        m.insert(~"foo", @dvec());
+        m.insert(~"", @DVec());
+        m.insert(~"foo", @DVec());
         assert encode_form_urlencoded(m) == ~"";
 
         let m = str_hash();
diff --git a/src/libstd/smallintmap.rs b/src/libstd/smallintmap.rs
index 8883e0eb079..db3aafb9747 100644
--- a/src/libstd/smallintmap.rs
+++ b/src/libstd/smallintmap.rs
@@ -4,7 +4,7 @@
  */
 import core::option;
 import core::option::{Some, None};
-import dvec::{DVec, dvec};
+import dvec::DVec;
 import map::map;
 
 // FIXME (#2347): Should not be @; there's a bug somewhere in rustc that
@@ -17,7 +17,7 @@ enum smallintmap<T:copy> {
 
 /// Create a smallintmap
 fn mk<T: copy>() -> smallintmap<T> {
-    let v = dvec();
+    let v = DVec();
     return smallintmap_(@{v: v});
 }
 
diff --git a/src/libstd/tempfile.rs b/src/libstd/tempfile.rs
index 2abaaa11fa0..a10e4605f61 100644
--- a/src/libstd/tempfile.rs
+++ b/src/libstd/tempfile.rs
@@ -5,7 +5,7 @@ import option::{None, Some};
 import rand;
 
 fn mkdtemp(tmpdir: &Path, suffix: &str) -> Option<Path> {
-    let r = rand::rng();
+    let r = rand::Rng();
     let mut i = 0u;
     while (i < 1000u) {
         let p = tmpdir.push(r.gen_str(16u) +
diff --git a/src/libstd/test.rs b/src/libstd/test.rs
index 46ad1a95dc3..2ebf8827154 100644
--- a/src/libstd/test.rs
+++ b/src/libstd/test.rs
@@ -286,8 +286,8 @@ fn run_tests(opts: test_opts, tests: ~[test_desc],
     let mut wait_idx = 0u;
     let mut done_idx = 0u;
 
-    let p = core::comm::port();
-    let ch = core::comm::chan(p);
+    let p = core::comm::Port();
+    let ch = core::comm::Chan(p);
 
     while done_idx < total {
         while wait_idx < concurrency && run_idx < total {
@@ -420,8 +420,8 @@ mod tests {
             ignore: true,
             should_fail: false
         };
-        let p = core::comm::port();
-        let ch = core::comm::chan(p);
+        let p = core::comm::Port();
+        let ch = core::comm::Chan(p);
         run_test(desc, ch);
         let (_, res) = core::comm::recv(p);
         assert res != tr_ok;
@@ -436,8 +436,8 @@ mod tests {
             ignore: true,
             should_fail: false
         };
-        let p = core::comm::port();
-        let ch = core::comm::chan(p);
+        let p = core::comm::Port();
+        let ch = core::comm::Chan(p);
         run_test(desc, ch);
         let (_, res) = core::comm::recv(p);
         assert res == tr_ignored;
@@ -453,8 +453,8 @@ mod tests {
             ignore: false,
             should_fail: true
         };
-        let p = core::comm::port();
-        let ch = core::comm::chan(p);
+        let p = core::comm::Port();
+        let ch = core::comm::Chan(p);
         run_test(desc, ch);
         let (_, res) = core::comm::recv(p);
         assert res == tr_ok;
@@ -469,8 +469,8 @@ mod tests {
             ignore: false,
             should_fail: true
         };
-        let p = core::comm::port();
-        let ch = core::comm::chan(p);
+        let p = core::comm::Port();
+        let ch = core::comm::Chan(p);
         run_test(desc, ch);
         let (_, res) = core::comm::recv(p);
         assert res == tr_failed;
diff --git a/src/libstd/timer.rs b/src/libstd/timer.rs
index 3c706bbddc6..a30e28f6953 100644
--- a/src/libstd/timer.rs
+++ b/src/libstd/timer.rs
@@ -29,8 +29,8 @@ export delayed_send, sleep, recv_timeout;
 fn delayed_send<T: copy send>(iotask: iotask,
                               msecs: uint, ch: comm::Chan<T>, +val: T) {
         unsafe {
-            let timer_done_po = core::comm::port::<()>();
-            let timer_done_ch = core::comm::chan(timer_done_po);
+            let timer_done_po = core::comm::Port::<()>();
+            let timer_done_ch = core::comm::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);
@@ -76,8 +76,8 @@ fn delayed_send<T: copy send>(iotask: iotask,
  * * msecs - an amount of time, in milliseconds, for the current task to block
  */
 fn sleep(iotask: iotask, msecs: uint) {
-    let exit_po = core::comm::port::<()>();
-    let exit_ch = core::comm::chan(exit_po);
+    let exit_po = core::comm::Port::<()>();
+    let exit_ch = core::comm::Chan(exit_po);
     delayed_send(iotask, msecs, exit_ch, ());
     core::comm::recv(exit_po);
 }
@@ -105,8 +105,8 @@ fn sleep(iotask: iotask, msecs: uint) {
 fn recv_timeout<T: copy send>(iotask: iotask,
                               msecs: uint,
                               wait_po: comm::Port<T>) -> Option<T> {
-    let timeout_po = comm::port::<()>();
-    let timeout_ch = comm::chan(timeout_po);
+    let timeout_po = comm::Port::<()>();
+    let timeout_ch = comm::Chan(timeout_po);
     delayed_send(iotask, msecs, timeout_ch, ());
     // FIXME: This could be written clearer (#2618)
     either::either(
@@ -163,8 +163,8 @@ mod test {
 
     #[test]
     fn test_gl_timer_sleep_stress2() {
-        let po = core::comm::port();
-        let ch = core::comm::chan(po);
+        let po = core::comm::Port();
+        let ch = core::comm::Chan(po);
         let hl_loop = uv::global_loop::get();
 
         let repeat = 20u;
@@ -182,7 +182,7 @@ mod test {
                 let (times, maxms) = spec;
                 do task::spawn {
                     import rand::*;
-                    let rng = rng();
+                    let rng = Rng();
                     for iter::repeat(times) {
                         sleep(hl_loop, rng.next() as uint % maxms);
                     }
@@ -240,9 +240,9 @@ mod test {
         let hl_loop = uv::global_loop::get();
 
         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 expected = rand::Rng().gen_str(16u);
+            let test_po = core::comm::Port::<~str>();
+            let test_ch = core::comm::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 6fe2cdb8223..29a4749b89c 100644
--- a/src/libstd/uv_global_loop.rs
+++ b/src/libstd/uv_global_loop.rs
@@ -8,7 +8,7 @@ import get_gl = get;
 import iotask::{iotask, spawn_iotask};
 import priv::{chan_from_global_ptr, weaken_task};
 import comm = core::comm;
-import comm::{Port, Chan, port, chan, select2, listen};
+import comm::{Port, Chan, select2, listen};
 import task::TaskBuilder;
 import either::{Left, Right};
 
@@ -132,8 +132,8 @@ mod test {
     }
 
     fn impl_uv_hl_simple_timer(iotask: iotask) unsafe {
-        let exit_po = core::comm::port::<bool>();
-        let exit_ch = core::comm::chan(exit_po);
+        let exit_po = core::comm::Port::<bool>();
+        let exit_ch = core::comm::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));
@@ -165,8 +165,8 @@ mod test {
     #[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 = comm::Port::<()>();
+        let exit_ch = comm::Chan(exit_po);
         task::spawn_sched(task::ManualThreads(1u), || {
             impl_uv_hl_simple_timer(hl_loop);
             core::comm::send(exit_ch, ());
@@ -181,8 +181,8 @@ 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 = core::comm::Port::<()>();
+        let exit_ch = core::comm::Chan(exit_po);
         let cycles = 5000u;
         for iter::repeat(cycles) {
             task::spawn_sched(task::ManualThreads(1u), || {
diff --git a/src/libstd/uv_iotask.rs b/src/libstd/uv_iotask.rs
index bb7f4f56782..4567decf479 100644
--- a/src/libstd/uv_iotask.rs
+++ b/src/libstd/uv_iotask.rs
@@ -13,7 +13,7 @@ export exit;
 import libc::c_void;
 import ptr::addr_of;
 import comm = core::comm;
-import comm::{Port, port, Chan, chan, listen};
+import comm::{Port, Chan, listen};
 import task::TaskBuilder;
 import ll = uv_ll;
 
@@ -102,7 +102,7 @@ fn run_loop(iotask_ch: Chan<iotask>) unsafe {
     // initialize our loop data and store it in the loop
     let data: iotask_loop_data = {
         async_handle: async_handle,
-        msg_po: port()
+        msg_po: Port()
     };
     ll::set_data_for_uv_handle(async_handle, addr_of(data));
 
@@ -186,8 +186,8 @@ mod test {
     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 = core::comm::Port::<()>();
+        let exit_ch = core::comm::Chan(exit_po);
         let ah_data = {
             iotask: iotask,
             exit_ch: exit_ch
@@ -204,8 +204,8 @@ mod test {
     // this fn documents the bear minimum neccesary to roll your own
     // high_level_loop
     unsafe fn spawn_test_loop(exit_ch: comm::Chan<()>) -> iotask {
-        let iotask_port = comm::port::<iotask>();
-        let iotask_ch = comm::chan(iotask_port);
+        let iotask_port = comm::Port::<iotask>();
+        let iotask_ch = comm::Chan(iotask_port);
         do task::spawn_sched(task::ManualThreads(1u)) {
             run_loop(iotask_ch);
             exit_ch.send(());
@@ -225,8 +225,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 = core::comm::Port::<()>();
+        let exit_ch = core::comm::Chan(exit_po);
         let iotask = spawn_test_loop(exit_ch);
 
         // using this handle to manage the lifetime of the high_level_loop,
@@ -235,8 +235,8 @@ 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 = core::comm::Port::<()>();
+        let work_exit_ch = core::comm::Chan(work_exit_po);
         for iter::repeat(7u) {
             do task::spawn_sched(task::ManualThreads(1u)) {
                 impl_uv_iotask_async(iotask);
diff --git a/src/libstd/uv_ll.rs b/src/libstd/uv_ll.rs
index c45b49849bc..1e7c2c2c824 100644
--- a/src/libstd/uv_ll.rs
+++ b/src/libstd/uv_ll.rs
@@ -1461,13 +1461,13 @@ mod test {
         let port = 8887;
         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 = 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 continue_port = core::comm::port::<bool>();
-        let continue_chan = core::comm::chan::<bool>(continue_port);
+        let continue_port = core::comm::Port::<bool>();
+        let continue_chan = core::comm::Chan::<bool>(continue_port);
         let continue_chan_ptr = ptr::addr_of(continue_chan);
 
         do task::spawn_sched(task::ManualThreads(1u)) {
generated by cgit-pink 1.4.1-3-g733a5 (git 2.37.1) at 2026-01-14 20:56:07 +0000