auto merge of #9749 : alexcrichton/rust/less-io, r=brson

This implements a number of the baby steps needed to start eliminating everything inside of `std::io`. It turns out that there are a *lot* of users of that module, so I'm going to try to tackle them separately instead of bringing down the whole system all at once.

This pull implements a large amount of unimplemented functionality inside of `std::rt::io` including:

* Native file I/O (file descriptors, *FILE)
* Native stdio (through the native file descriptors)
* Native processes (extracted from `std::run`)

I also found that there are a number of users of `std::io` which desire to read an input line-by-line, so I added an implementation of `read_until` and `read_line` to `BufferedReader`.

With all of these changes in place, I started to axe various usages of `std::io`. There's a lot of one-off uses here-and-there, but the major use-case remaining that doesn't have a fantastic solution is `extra::json`. I ran into a few compiler bugs when attempting to remove that, so I figured I'd come back to it later instead. 

There is one fairly major change in this pull, and it's moving from native stdio to uv stdio via `print` and `println`. Unfortunately logging still goes through native I/O (via `dumb_println`). This is going to need some thinking, because I still want the goal of logging/printing to be 0 allocations, and this is not possible if `io::stdio::stderr()` is called on each log message. Instead I think that this may need to be cached as the `logger` field inside the `Task` struct, but that will require a little more workings to get right (this is also a similar problem for print/println, do we cache `stdout()` to not have to re-create it every time?).

1 files changed, 17 insertions, 32 deletions

diff --git a/src/libstd/rt/logging.rs b/src/libstd/rt/logging.rs
index b08e76921d8..660d1cd4359 100644
--- a/src/libstd/rt/logging.rs
+++ b/src/libstd/rt/logging.rs
@@ -12,8 +12,6 @@ use fmt;
 use from_str::from_str;
 use libc::exit;
 use option::{Some, None, Option};
-use rt;
-use rt::util::dumb_println;
 use rt::crate_map::{ModEntry, CrateMap, iter_crate_map, get_crate_map};
 use str::StrSlice;
 use u32;
@@ -88,16 +86,16 @@ fn parse_logging_spec(spec: ~str) -> ~[LogDirective]{
                         log_level = num;
                     },
                     _ => {
-                        dumb_println(format!("warning: invalid logging spec \
-                                              '{}', ignoring it", parts[1]));
-                        continue;
+                        rterrln!("warning: invalid logging spec '{}', \
+                                  ignoring it", parts[1]);
+                        continue
                     }
                 }
             },
             _ => {
-                dumb_println(format!("warning: invalid logging spec '{}',\
-                                      ignoring it", s));
-                continue;
+                rterrln!("warning: invalid logging spec '{}', \
+                          ignoring it", s);
+                continue
             }
         }
         let dir = LogDirective {name: name, level: log_level};
@@ -141,9 +139,9 @@ fn update_log_settings(crate_map: &CrateMap, settings: ~str) {
     let mut dirs = ~[];
     if settings.len() > 0 {
         if settings == ~"::help" || settings == ~"?" {
-        dumb_println("\nCrate log map:\n");
+            rterrln!("\nCrate log map:\n");
             do iter_crate_map(crate_map) |entry| {
-                dumb_println(" "+entry.name);
+                rterrln!(" {}", entry.name);
             }
             unsafe { exit(1); }
         }
@@ -157,12 +155,10 @@ fn update_log_settings(crate_map: &CrateMap, settings: ~str) {
     }
 
     if n_matches < (dirs.len() as u32) {
-        dumb_println(format!("warning: got {} RUST_LOG specs but only matched\n\
-                              {} of them. You may have mistyped a RUST_LOG \
-                              spec. \n\
-                              Use RUST_LOG=::help to see the list of crates \
-                              and modules.\n",
-                             dirs.len(), n_matches));
+        rterrln!("warning: got {} RUST_LOG specs but only matched\n\
+                  {} of them. You may have mistyped a RUST_LOG spec. \n\
+                  Use RUST_LOG=::help to see the list of crates and modules.\n",
+                 dirs.len(), n_matches);
     }
 }
 
@@ -174,24 +170,13 @@ pub struct StdErrLogger;
 
 impl Logger for StdErrLogger {
     fn log(&mut self, args: &fmt::Arguments) {
-        fmt::writeln(self as &mut rt::io::Writer, args);
+        // FIXME(#6846): this should not call the blocking version of println,
+        //               or at least the default loggers for tasks shouldn't do
+        //               that
+        ::rt::util::dumb_println(args);
     }
 }
 
-impl rt::io::Writer for StdErrLogger {
-    fn write(&mut self, buf: &[u8]) {
-        // Nothing like swapping between I/O implementations! In theory this
-        // could use the libuv bindings for writing to file descriptors, but
-        // that may not necessarily be desirable because logging should work
-        // outside of the uv loop. (modify with caution)
-        use io::Writer;
-        let dbg = ::libc::STDERR_FILENO as ::io::fd_t;
-        dbg.write(buf);
-    }
-
-    fn flush(&mut self) {}
-}
-
 /// Configure logging by traversing the crate map and setting the
 /// per-module global logging flags based on the logging spec
 pub fn init() {
@@ -212,7 +197,7 @@ pub fn init() {
         _ => {
             match log_spec {
                 Some(_) => {
-                    dumb_println("warning: RUST_LOG set, but no crate map found.");
+                    rterrln!("warning: RUST_LOG set, but no crate map found.");
                 },
                 None => {}
             }