libcore: De-export logging and pipes

2 files changed, 53 insertions, 75 deletions

diff --git a/src/libcore/logging.rs b/src/libcore/logging.rs
index a9f63b57fa5..cd7321bf0d3 100644
--- a/src/libcore/logging.rs
+++ b/src/libcore/logging.rs
@@ -6,8 +6,6 @@
 
 use cast::transmute;
 
-export console_on, console_off, log_type;
-
 #[nolink]
 extern mod rustrt {
     #[legacy_exports];
@@ -17,7 +15,7 @@ extern mod rustrt {
 }
 
 /// Turns on logging to stdout globally
-fn console_on() {
+pub fn console_on() {
     rustrt::rust_log_console_on();
 }
 
@@ -28,7 +26,7 @@ fn console_on() {
  * runtime environment's logging spec, e.g. by setting
  * the RUST_LOG environment variable
  */
-fn console_off() {
+pub fn console_off() {
     rustrt::rust_log_console_off();
 }
 
diff --git a/src/libcore/pipes.rs b/src/libcore/pipes.rs
index b67f572d4f7..bbabceafe8e 100644
--- a/src/libcore/pipes.rs
+++ b/src/libcore/pipes.rs
@@ -81,26 +81,6 @@ use cast::{forget, reinterpret_cast, transmute};
 use either::{Either, Left, Right};
 use option::unwrap;
 
-// Things used by code generated by the pipe compiler.
-export entangle, get_buffer, drop_buffer;
-export SendPacketBuffered, RecvPacketBuffered;
-export Packet, packet, mk_packet, entangle_buffer, HasBuffer, BufferHeader;
-
-// export these so we can find them in the buffer_resource
-// destructor. This is probably a symptom of #3005.
-export atomic_add_acq, atomic_sub_rel;
-
-// User-level things
-export SendPacket, RecvPacket, send, recv, try_recv, peek;
-export select, select2, selecti, select2i, selectable;
-export spawn_service, spawn_service_recv;
-export stream, Port, Chan, SharedChan, PortSet, Channel;
-export oneshot, ChanOne, PortOne;
-export recv_one, try_recv_one, send_one, try_send_one;
-
-// Functions used by the protocol compiler
-export rt;
-
 #[doc(hidden)]
 const SPIN_COUNT: uint = 0;
 
@@ -123,7 +103,7 @@ impl State : Eq {
     pure fn ne(other: &State) -> bool { !self.eq(other) }
 }
 
-struct BufferHeader {
+pub struct BufferHeader {
     // Tracks whether this buffer needs to be freed. We can probably
     // get away with restricting it to 0 or 1, if we're careful.
     mut ref_count: int,
@@ -195,13 +175,13 @@ impl PacketHeader {
 }
 
 #[doc(hidden)]
-type Packet<T: Send> = {
+pub type Packet<T: Send> = {
     header: PacketHeader,
     mut payload: Option<T>,
 };
 
 #[doc(hidden)]
-trait HasBuffer {
+pub trait HasBuffer {
     // XXX This should not have a trailing underscore
     fn set_buffer_(b: *libc::c_void);
 }
@@ -213,7 +193,7 @@ impl<T: Send> Packet<T>: HasBuffer {
 }
 
 #[doc(hidden)]
-fn mk_packet<T: Send>() -> Packet<T> {
+pub fn mk_packet<T: Send>() -> Packet<T> {
     {
         header: PacketHeader(),
         mut payload: None
@@ -237,7 +217,7 @@ fn unibuffer<T: Send>() -> ~Buffer<Packet<T>> {
 }
 
 #[doc(hidden)]
-fn packet<T: Send>() -> *Packet<T> {
+pub fn packet<T: Send>() -> *Packet<T> {
     let b = unibuffer();
     let p = ptr::addr_of(b.data);
     // We'll take over memory management from here.
@@ -246,7 +226,7 @@ fn packet<T: Send>() -> *Packet<T> {
 }
 
 #[doc(hidden)]
-fn entangle_buffer<T: Send, Tstart: Send>(
+pub fn entangle_buffer<T: Send, Tstart: Send>(
     +buffer: ~Buffer<T>,
     init: fn(*libc::c_void, x: &T) -> *Packet<Tstart>)
     -> (SendPacketBuffered<Tstart, T>, RecvPacketBuffered<Tstart, T>)
@@ -286,22 +266,22 @@ extern mod rusti {
 // If I call the rusti versions directly from a polymorphic function,
 // I get link errors. This is a bug that needs investigated more.
 #[doc(hidden)]
-fn atomic_xchng_rel(dst: &mut int, src: int) -> int {
+pub fn atomic_xchng_rel(dst: &mut int, src: int) -> int {
     rusti::atomic_xchg_rel(dst, src)
 }
 
 #[doc(hidden)]
-fn atomic_add_acq(dst: &mut int, src: int) -> int {
+pub fn atomic_add_acq(dst: &mut int, src: int) -> int {
     rusti::atomic_xadd_acq(dst, src)
 }
 
 #[doc(hidden)]
-fn atomic_sub_rel(dst: &mut int, src: int) -> int {
+pub fn atomic_sub_rel(dst: &mut int, src: int) -> int {
     rusti::atomic_xsub_rel(dst, src)
 }
 
 #[doc(hidden)]
-fn swap_task(+dst: &mut *rust_task, src: *rust_task) -> *rust_task {
+pub fn swap_task(+dst: &mut *rust_task, src: *rust_task) -> *rust_task {
     // It might be worth making both acquire and release versions of
     // this.
     unsafe {
@@ -355,7 +335,7 @@ fn swap_state_rel(+dst: &mut State, src: State) -> State {
 }
 
 #[doc(hidden)]
-unsafe fn get_buffer<T: Send>(p: *PacketHeader) -> ~Buffer<T> {
+pub unsafe fn get_buffer<T: Send>(p: *PacketHeader) -> ~Buffer<T> {
     transmute((*p).buf_header())
 }
 
@@ -391,8 +371,8 @@ fn BufferResource<T: Send>(+b: ~Buffer<T>) -> BufferResource<T> {
 }
 
 #[doc(hidden)]
-fn send<T: Send, Tbuffer: Send>(+p: SendPacketBuffered<T, Tbuffer>,
-                                +payload: T) -> bool {
+pub fn send<T: Send, Tbuffer: Send>(+p: SendPacketBuffered<T, Tbuffer>,
+                                    +payload: T) -> bool {
     let header = p.header();
     let p_ = p.unwrap();
     let p = unsafe { &*p_ };
@@ -435,7 +415,7 @@ fn send<T: Send, Tbuffer: Send>(+p: SendPacketBuffered<T, Tbuffer>,
 Fails if the sender closes the connection.
 
 */
-fn recv<T: Send, Tbuffer: Send>(+p: RecvPacketBuffered<T, Tbuffer>) -> T {
+pub fn recv<T: Send, Tbuffer: Send>(+p: RecvPacketBuffered<T, Tbuffer>) -> T {
     option::unwrap_expect(try_recv(move p), "connection closed")
 }
 
@@ -445,7 +425,7 @@ Returns `none` if the sender has closed the connection without sending
 a message, or `Some(T)` if a message was received.
 
 */
-fn try_recv<T: Send, Tbuffer: Send>(+p: RecvPacketBuffered<T, Tbuffer>)
+pub fn try_recv<T: Send, Tbuffer: Send>(+p: RecvPacketBuffered<T, Tbuffer>)
     -> Option<T>
 {
     let p_ = p.unwrap();
@@ -539,7 +519,7 @@ fn try_recv<T: Send, Tbuffer: Send>(+p: RecvPacketBuffered<T, Tbuffer>)
 }
 
 /// Returns true if messages are available.
-pure fn peek<T: Send, Tb: Send>(p: &RecvPacketBuffered<T, Tb>) -> bool {
+pub pure fn peek<T: Send, Tb: Send>(p: &RecvPacketBuffered<T, Tb>) -> bool {
     match unsafe {(*p.header()).state} {
       Empty => false,
       Blocked => fail ~"peeking on blocked packet",
@@ -691,7 +671,7 @@ Sometimes messages will be available on both endpoints at once. In
 this case, `select2` may return either `left` or `right`.
 
 */
-fn select2<A: Send, Ab: Send, B: Send, Bb: Send>(
+pub fn select2<A: Send, Ab: Send, B: Send, Bb: Send>(
     +a: RecvPacketBuffered<A, Ab>,
     +b: RecvPacketBuffered<B, Bb>)
     -> Either<(Option<A>, RecvPacketBuffered<B, Bb>),
@@ -716,12 +696,13 @@ impl *PacketHeader: Selectable {
 }
 
 /// Returns the index of an endpoint that is ready to receive.
-fn selecti<T: Selectable>(endpoints: &[T]) -> uint {
+pub fn selecti<T: Selectable>(endpoints: &[T]) -> uint {
     wait_many(endpoints)
 }
 
 /// Returns 0 or 1 depending on which endpoint is ready to receive
-fn select2i<A: Selectable, B: Selectable>(a: &A, b: &B) -> Either<(), ()> {
+pub fn select2i<A: Selectable, B: Selectable>(a: &A, b: &B) ->
+        Either<(), ()> {
     match wait_many([a.header(), b.header()]/_) {
       0 => Left(()),
       1 => Right(()),
@@ -733,7 +714,7 @@ fn select2i<A: Selectable, B: Selectable>(a: &A, b: &B) -> Either<(), ()> {
  list of the remaining endpoints.
 
 */
-fn select<T: Send, Tb: Send>(+endpoints: ~[RecvPacketBuffered<T, Tb>])
+pub fn select<T: Send, Tb: Send>(+endpoints: ~[RecvPacketBuffered<T, Tb>])
     -> (uint, Option<T>, ~[RecvPacketBuffered<T, Tb>])
 {
     let ready = wait_many(endpoints.map(|p| p.header()));
@@ -747,14 +728,14 @@ fn select<T: Send, Tb: Send>(+endpoints: ~[RecvPacketBuffered<T, Tb>])
 message.
 
 */
-type SendPacket<T: Send> = SendPacketBuffered<T, Packet<T>>;
+pub type SendPacket<T: Send> = SendPacketBuffered<T, Packet<T>>;
 
 #[doc(hidden)]
-fn SendPacket<T: Send>(p: *Packet<T>) -> SendPacket<T> {
+pub fn SendPacket<T: Send>(p: *Packet<T>) -> SendPacket<T> {
     SendPacketBuffered(p)
 }
 
-struct SendPacketBuffered<T: Send, Tbuffer: Send> {
+pub struct SendPacketBuffered<T: Send, Tbuffer: Send> {
     mut p: Option<*Packet<T>>,
     mut buffer: Option<BufferResource<Tbuffer>>,
     drop {
@@ -773,7 +754,7 @@ struct SendPacketBuffered<T: Send, Tbuffer: Send> {
     }
 }
 
-fn SendPacketBuffered<T: Send, Tbuffer: Send>(p: *Packet<T>)
+pub fn SendPacketBuffered<T: Send, Tbuffer: Send>(p: *Packet<T>)
     -> SendPacketBuffered<T, Tbuffer> {
         //debug!("take send %?", p);
     SendPacketBuffered {
@@ -814,14 +795,14 @@ impl<T: Send, Tbuffer: Send> SendPacketBuffered<T, Tbuffer> {
 
 /// Represents the receive end of a pipe. It can receive exactly one
 /// message.
-type RecvPacket<T: Send> = RecvPacketBuffered<T, Packet<T>>;
+pub type RecvPacket<T: Send> = RecvPacketBuffered<T, Packet<T>>;
 
 #[doc(hidden)]
-fn RecvPacket<T: Send>(p: *Packet<T>) -> RecvPacket<T> {
+pub fn RecvPacket<T: Send>(p: *Packet<T>) -> RecvPacket<T> {
     RecvPacketBuffered(p)
 }
 
-struct RecvPacketBuffered<T: Send, Tbuffer: Send> {
+pub struct RecvPacketBuffered<T: Send, Tbuffer: Send> {
     mut p: Option<*Packet<T>>,
     mut buffer: Option<BufferResource<Tbuffer>>,
     drop {
@@ -867,7 +848,7 @@ impl<T: Send, Tbuffer: Send> RecvPacketBuffered<T, Tbuffer> : Selectable {
     }
 }
 
-fn RecvPacketBuffered<T: Send, Tbuffer: Send>(p: *Packet<T>)
+pub fn RecvPacketBuffered<T: Send, Tbuffer: Send>(p: *Packet<T>)
     -> RecvPacketBuffered<T, Tbuffer> {
     //debug!("take recv %?", p);
     RecvPacketBuffered {
@@ -880,7 +861,7 @@ fn RecvPacketBuffered<T: Send, Tbuffer: Send>(p: *Packet<T>)
 }
 
 #[doc(hidden)]
-fn entangle<T: Send>() -> (SendPacket<T>, RecvPacket<T>) {
+pub fn entangle<T: Send>() -> (SendPacket<T>, RecvPacket<T>) {
     let p = packet();
     (SendPacket(p), RecvPacket(p))
 }
@@ -892,7 +873,7 @@ endpoint. The send endpoint is returned to the caller and the receive
 endpoint is passed to the new task.
 
 */
-fn spawn_service<T: Send, Tb: Send>(
+pub fn spawn_service<T: Send, Tb: Send>(
     init: extern fn() -> (SendPacketBuffered<T, Tb>,
                           RecvPacketBuffered<T, Tb>),
     +service: fn~(+v: RecvPacketBuffered<T, Tb>))
@@ -916,7 +897,7 @@ fn spawn_service<T: Send, Tb: Send>(
 receive state.
 
 */
-fn spawn_service_recv<T: Send, Tb: Send>(
+pub fn spawn_service_recv<T: Send, Tb: Send>(
     init: extern fn() -> (RecvPacketBuffered<T, Tb>,
                           SendPacketBuffered<T, Tb>),
     +service: fn~(+v: SendPacketBuffered<T, Tb>))
@@ -945,7 +926,7 @@ proto! streamp (
 )
 
 /// A trait for things that can send multiple messages.
-trait Channel<T: Send> {
+pub trait Channel<T: Send> {
     // It'd be nice to call this send, but it'd conflict with the
     // built in send kind.
 
@@ -957,7 +938,7 @@ trait Channel<T: Send> {
 }
 
 /// A trait for things that can receive multiple messages.
-trait Recv<T: Send> {
+pub trait Recv<T: Send> {
     /// Receives a message, or fails if the connection closes.
     fn recv() -> T;
 
@@ -978,7 +959,7 @@ trait Recv<T: Send> {
 type Chan_<T:Send> = { mut endp: Option<streamp::client::Open<T>> };
 
 /// An endpoint that can send many messages.
-enum Chan<T:Send> {
+pub enum Chan<T:Send> {
     Chan_(Chan_<T>)
 }
 
@@ -986,7 +967,7 @@ enum Chan<T:Send> {
 type Port_<T:Send> = { mut endp: Option<streamp::server::Open<T>> };
 
 /// An endpoint that can receive many messages.
-enum Port<T:Send> {
+pub enum Port<T:Send> {
     Port_(Port_<T>)
 }
 
@@ -995,7 +976,7 @@ enum Port<T:Send> {
 These allow sending or receiving an unlimited number of messages.
 
 */
-fn stream<T:Send>() -> (Chan<T>, Port<T>) {
+pub fn stream<T:Send>() -> (Chan<T>, Port<T>) {
     let (c, s) = streamp::init();
 
     (Chan_({ mut endp: Some(move c) }), Port_({ mut endp: Some(move s) }))
@@ -1065,11 +1046,11 @@ impl<T: Send> Port<T>: Selectable {
 }
 
 /// Treat many ports as one.
-struct PortSet<T: Send> {
+pub struct PortSet<T: Send> {
     mut ports: ~[pipes::Port<T>],
 }
 
-fn PortSet<T: Send>() -> PortSet<T>{
+pub fn PortSet<T: Send>() -> PortSet<T>{
     PortSet {
         ports: ~[]
     }
@@ -1124,7 +1105,7 @@ impl<T: Send> PortSet<T> : Recv<T> {
 }
 
 /// A channel that can be shared between many senders.
-type SharedChan<T: Send> = private::Exclusive<Chan<T>>;
+pub type SharedChan<T: Send> = private::Exclusive<Chan<T>>;
 
 impl<T: Send> SharedChan<T>: Channel<T> {
     fn send(+x: T) {
@@ -1152,7 +1133,7 @@ fn SharedChan<T:Send>(+c: Chan<T>) -> SharedChan<T> {
 }
 
 /// Receive a message from one of two endpoints.
-trait Select2<T: Send, U: Send> {
+pub trait Select2<T: Send, U: Send> {
     /// Receive a message or return `none` if a connection closes.
     fn try_select() -> Either<Option<T>, Option<U>>;
     /// Receive a message or fail if a connection closes.
@@ -1188,12 +1169,12 @@ proto! oneshot (
 )
 
 /// The send end of a oneshot pipe.
-type ChanOne<T: Send> = oneshot::client::Oneshot<T>;
+pub type ChanOne<T: Send> = oneshot::client::Oneshot<T>;
 /// The receive end of a oneshot pipe.
-type PortOne<T: Send> = oneshot::server::Oneshot<T>;
+pub type PortOne<T: Send> = oneshot::server::Oneshot<T>;
 
 /// Initialiase a (send-endpoint, recv-endpoint) oneshot pipe pair.
-fn oneshot<T: Send>() -> (ChanOne<T>, PortOne<T>) {
+pub fn oneshot<T: Send>() -> (ChanOne<T>, PortOne<T>) {
     oneshot::init()
 }
 
@@ -1201,13 +1182,13 @@ fn oneshot<T: Send>() -> (ChanOne<T>, PortOne<T>) {
  * Receive a message from a oneshot pipe, failing if the connection was
  * closed.
  */
-fn recv_one<T: Send>(+port: PortOne<T>) -> T {
+pub fn recv_one<T: Send>(+port: PortOne<T>) -> T {
     let oneshot::send(message) = recv(move port);
     move message
 }
 
 /// Receive a message from a oneshot pipe unless the connection was closed.
-fn try_recv_one<T: Send> (+port: PortOne<T>) -> Option<T> {
+pub fn try_recv_one<T: Send> (+port: PortOne<T>) -> Option<T> {
     let message = try_recv(move port);
 
     if message.is_none() { None }
@@ -1218,7 +1199,7 @@ fn try_recv_one<T: Send> (+port: PortOne<T>) -> Option<T> {
 }
 
 /// Send a message on a oneshot pipe, failing if the connection was closed.
-fn send_one<T: Send>(+chan: ChanOne<T>, +data: T) {
+pub fn send_one<T: Send>(+chan: ChanOne<T>, +data: T) {
     oneshot::client::send(move chan, move data);
 }
 
@@ -1226,7 +1207,7 @@ fn send_one<T: Send>(+chan: ChanOne<T>, +data: T) {
  * Send a message on a oneshot pipe, or return false if the connection was
  * closed.
  */
-fn try_send_one<T: Send>(+chan: ChanOne<T>, +data: T)
+pub fn try_send_one<T: Send>(+chan: ChanOne<T>, +data: T)
         -> bool {
     oneshot::client::try_send(move chan, move data).is_some()
 }
@@ -1240,10 +1221,9 @@ mod rt {
 }
 
 #[cfg(test)]
-mod test {
-    #[legacy_exports];
+pub mod test {
     #[test]
-    fn test_select2() {
+    pub fn test_select2() {
         let (c1, p1) = pipes::stream();
         let (c2, p2) = pipes::stream();
 
@@ -1258,7 +1238,7 @@ mod test {
     }
 
     #[test]
-    fn test_oneshot() {
+    pub fn test_oneshot() {
         let (c, p) = oneshot::init();
 
         oneshot::client::send(c, ());