---

yaml
---
r: 61309
b: refs/heads/try
c: 03f75b6
h: refs/heads/master
i:
  61307: c0652bd
v: v3

Author: emberian

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2d28d645422c1617be58c8ca7ad9a457264ca850
-refs/heads/try: b04fce6a901f490a9df378c64166dda26e0297a3
+refs/heads/try: 03f75b629a5d1d8e0a5916abdef4499f0c7c61d6
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/libcore/core.rc

@@ -205,11 +205,8 @@ mod unicode;
 #[path = "num/cmath.rs"]
 mod cmath;
 mod stackwalk;
-
-// XXX: This shouldn't be pub, and it should be reexported under 'unstable'
-// but name resolution doesn't work without it being pub.
 #[path = "rt/mod.rs"]
-pub mod rt;
+mod rt;
 
 // A curious inner-module that's not exported that contains the binding
 // 'core' so that macro-expanded references to core::error and such

branches/try/src/libcore/logging.rs

@@ -10,16 +10,17 @@
 
 //! Logging
 
-use option::*;
-use either::*;
-use rt;
-use rt::logging::{Logger, StdErrLogger};
-use io;
-use libc;
-use repr;
-use vec;
-use cast;
-use str;
+pub mod rustrt {
+    use libc;
+
+    pub extern {
+        unsafe fn rust_log_console_on();
+        unsafe fn rust_log_console_off();
+        unsafe fn rust_log_str(level: u32,
+                               string: *libc::c_char,
+                               size: libc::size_t);
+    }
+}
 
 /// Turns on logging to stdout globally
 pub fn console_on() {
@@ -54,46 +55,8 @@ pub fn log_type<T>(level: u32, object: &T) {
     let bytes = do io::with_bytes_writer |writer| {
         repr::write_repr(writer, object);
     };
-
-    match rt::context() {
-        rt::OldTaskContext => {
-            unsafe {
-                let len = bytes.len() as libc::size_t;
-                rustrt::rust_log_str(level, cast::transmute(vec::raw::to_ptr(bytes)), len);
-            }
-        }
-        _ => {
-            // XXX: Bad allocation
-            let msg = str::from_bytes(bytes);
-            newsched_log_str(msg);
-        }
-    }
-}
-
-fn newsched_log_str(msg: ~str) {
     unsafe {
-        match rt::local_services::unsafe_try_borrow_local_services() {
-            Some(local) => {
-                // Use the available logger
-                (*local).logger.log(Left(msg));
-            }
-            None => {
-                // There is no logger anywhere, just write to stderr
-                let mut logger = StdErrLogger;
-                logger.log(Left(msg));
-            }
-        }
-    }
-}
-
-pub mod rustrt {
-    use libc;
-
-    pub extern {
-        unsafe fn rust_log_console_on();
-        unsafe fn rust_log_console_off();
-        unsafe fn rust_log_str(level: u32,
-                               string: *libc::c_char,
-                               size: libc::size_t);
+        let len = bytes.len() as libc::size_t;
+        rustrt::rust_log_str(level, transmute(vec::raw::to_ptr(bytes)), len);
     }
 }

branches/try/src/libcore/macros.rs

@@ -30,24 +30,10 @@ macro_rules! rtdebug (
     ($( $arg:expr),+) => ( $(let _ = $arg)*; )
 )
 
-macro_rules! rtassert (
-    ( $arg:expr ) => ( {
-        if !$arg {
-            abort!("assertion failed: %s", stringify!($arg));
-        }
-    } )
-)
-
 macro_rules! abort(
     ($( $msg:expr),+) => ( {
         rtdebug!($($msg),+);
 
-        do_abort();
-
-        // NB: This is in a fn to avoid putting the `unsafe` block in a macro,
-        // which causes spurious 'unnecessary unsafe block' warnings.
-        fn do_abort() -> ! {
-            unsafe { ::libc::abort(); }
-        }
+        unsafe { ::libc::abort(); }
     } )
 )

branches/try/src/libcore/os.rs

@@ -722,7 +722,7 @@ pub fn list_dir(p: &Path) -> ~[~str] {
             use os::win32::{
                 as_utf16_p
             };
-            use rt::global_heap::{malloc_raw, free_raw};
+            use unstable::exchange_alloc::{malloc_raw, free_raw};
             #[nolink]
             extern {
                 unsafe fn rust_list_dir_wfd_size() -> libc::size_t;

branches/try/src/libcore/rt/context.rs

@@ -111,9 +111,9 @@ fn initialize_call_frame(regs: &mut Registers, fptr: *c_void, arg: *c_void, sp:
     let sp = align_down(sp);
     let sp = mut_offset(sp, -4);
 
-    unsafe { *sp = arg as uint };
+    unsafe { *sp = arg as uint; }
     let sp = mut_offset(sp, -1);
-    unsafe { *sp = 0 }; // The final return address
+    unsafe { *sp = 0; } // The final return address
 
     regs.esp = sp as u32;
     regs.eip = fptr as u32;
@@ -195,7 +195,7 @@ fn initialize_call_frame(regs: &mut Registers, fptr: *c_void, arg: *c_void, sp:
 
 fn align_down(sp: *mut uint) -> *mut uint {
     unsafe {
-        let sp: uint = transmute(sp);
+        let sp = transmute::<*mut uint, uint>(sp);
         let sp = sp & !(16 - 1);
         transmute::<uint, *mut uint>(sp)
     }

branches/try/src/libcore/rt/io/file.rs

@@ -10,7 +10,7 @@
 
 use prelude::*;
 use super::support::PathLike;
-use super::{Reader, Writer, Seek};
+use super::{Reader, Writer, Seek, Close};
 use super::SeekStyle;
 
 /// # XXX
@@ -69,6 +69,10 @@ impl Seek for FileStream {
     fn seek(&mut self, _pos: i64, _style: SeekStyle) { fail!() }
 }
 
+impl Close for FileStream {
+    fn close(&mut self) { fail!() }
+}
+
 #[test]
 #[ignore]
 fn super_simple_smoke_test_lets_go_read_some_files_and_have_a_good_time() {

branches/try/src/libcore/rt/io/mod.rs

@@ -238,7 +238,6 @@ Out of scope
 * How does I/O relate to the Iterator trait?
 * std::base64 filters
 * Using conditions is a big unknown since we don't have much experience with them
-* Too many uses of OtherIoError
 
 */
 
@@ -253,9 +252,7 @@ pub use self::stdio::println;
 
 pub use self::file::FileStream;
 pub use self::net::ip::IpAddr;
-#[cfg(not(stage0))]
 pub use self::net::tcp::TcpListener;
-#[cfg(not(stage0))]
 pub use self::net::tcp::TcpStream;
 pub use self::net::udp::UdpStream;
 
@@ -269,7 +266,6 @@ pub mod file;
 
 /// Synchronous, non-blocking network I/O.
 pub mod net {
-    #[cfg(not(stage0))]
     pub mod tcp;
     pub mod udp;
     pub mod ip;
@@ -330,14 +326,12 @@ pub struct IoError {
 
 #[deriving(Eq)]
 pub enum IoErrorKind {
-    PreviousIoError,
-    OtherIoError,
-    EndOfFile,
     FileNotFound,
-    PermissionDenied,
+    FilePermission,
     ConnectionFailed,
     Closed,
-    ConnectionRefused,
+    OtherIoError,
+    PreviousIoError
 }
 
 // XXX: Can't put doc comments on macros
@@ -389,7 +383,16 @@ pub trait Writer {
     fn flush(&mut self);
 }
 
-pub trait Stream: Reader + Writer { }
+/// I/O types that may be closed
+///
+/// Any further operations performed on a closed resource will raise
+/// on `io_error`
+pub trait Close {
+    /// Close the I/O resource
+    fn close(&mut self);
+}
+
+pub trait Stream: Reader + Writer + Close { }
 
 pub enum SeekStyle {
     /// Seek from the beginning of the stream

branches/try/src/libcore/rt/io/native/file.rs

@@ -40,6 +40,10 @@ impl Writer for FileDesc {
     fn flush(&mut self) { fail!() }
 }
 
+impl Close for FileDesc {
+    fn close(&mut self) { fail!() }
+}
+
 impl Seek for FileDesc {
     fn tell(&self) -> u64 { fail!() }
 
@@ -68,6 +72,10 @@ impl Writer for CFile {
     fn flush(&mut self) { fail!() }
 }
 
+impl Close for CFile {
+    fn close(&mut self) { fail!() }
+}
+
 impl Seek for CFile {
     fn tell(&self) -> u64 { fail!() }
     fn seek(&mut self, _pos: i64, _style: SeekStyle) { fail!() }