Convert std::io to istrs. Issue #855

2 files changed, 52 insertions, 41 deletions

diff --git a/src/lib/io.rs b/src/lib/io.rs
index 95945425a1d..4be9d380c8d 100644
--- a/src/lib/io.rs
+++ b/src/lib/io.rs
@@ -39,8 +39,8 @@ type reader =
         fn read_bytes(uint) -> [u8];
         fn read_char() -> char;
         fn eof() -> bool;
-        fn read_line() -> str;
-        fn read_c_str() -> str;
+        fn read_line() -> istr;
+        fn read_c_str() -> istr;
         fn read_le_uint(uint) -> uint;
         fn read_le_int(uint) -> int;
         fn read_be_uint(uint) -> uint;
@@ -104,7 +104,7 @@ obj new_reader(rdr: buf_reader) {
         ret val as char;
     }
     fn eof() -> bool { ret rdr.eof(); }
-    fn read_line() -> str {
+    fn read_line() -> istr {
         let buf: [u8] = [];
         // No break yet in rustc
 
@@ -115,16 +115,16 @@ obj new_reader(rdr: buf_reader) {
                 go_on = false;
             } else { buf += [ch as u8]; }
         }
-        ret str::unsafe_from_bytes(buf);
+        ret istr::unsafe_from_bytes(buf);
     }
-    fn read_c_str() -> str {
+    fn read_c_str() -> istr {
         let buf: [u8] = [];
         let go_on = true;
         while go_on {
             let ch = rdr.read_byte();
             if ch < 1 { go_on = false; } else { buf += [ch as u8]; }
         }
-        ret str::unsafe_from_bytes(buf);
+        ret istr::unsafe_from_bytes(buf);
     }
 
     // FIXME deal with eof?
@@ -172,8 +172,10 @@ fn stdin() -> reader {
     ret new_reader(FILE_buf_reader(rustrt::rust_get_stdin(), option::none));
 }
 
-fn file_reader(path: str) -> reader {
-    let f = os::libc::fopen(str::buf(path), str::buf("r"));
+fn file_reader(path: &istr) -> reader {
+    let path = istr::to_estr(path);
+    let mode = "r";
+    let f = os::libc::fopen(str::buf(path), str::buf(mode));
     if f as uint == 0u { log_err "error opening " + path; fail; }
     ret new_reader(FILE_buf_reader(f, option::some(@FILE_res(f))));
 }
@@ -213,8 +215,8 @@ fn new_byte_buf_reader(buf: &[u8]) -> buf_reader {
     ret byte_buf_reader(@{buf: buf, mutable pos: 0u});
 }
 
-fn string_reader(s: &str) -> reader {
-    ret new_reader(new_byte_buf_reader(str::bytes(s)));
+fn string_reader(s: &istr) -> reader {
+    ret new_reader(new_byte_buf_reader(istr::bytes(s)));
 }
 
 
@@ -273,7 +275,8 @@ obj fd_buf_writer(fd: int, res: option::t<@fd_res>) {
     }
 }
 
-fn file_buf_writer(path: str, flags: &[fileflag]) -> buf_writer {
+fn file_buf_writer(path: &istr, flags: &[fileflag]) -> buf_writer {
+    let path = istr::to_estr(path);
     let fflags: int =
         os::libc_constants::O_WRONLY() | os::libc_constants::O_BINARY();
     for f: fileflag in flags {
@@ -301,8 +304,8 @@ type writer =
     // function will be provided for general encoded string output
     obj {
         fn get_buf_writer() -> buf_writer;
-        fn write_str(str);
-        fn write_line(str);
+        fn write_str(&istr);
+        fn write_line(&istr);
         fn write_char(char);
         fn write_int(int);
         fn write_uint(uint);
@@ -327,20 +330,20 @@ fn uint_to_be_bytes(n: uint, size: uint) -> [u8] {
 
 obj new_writer(out: buf_writer) {
     fn get_buf_writer() -> buf_writer { ret out; }
-    fn write_str(s: str) { out.write(str::bytes(s)); }
-    fn write_line(s: str) {
-        out.write(str::bytes(s));
-        out.write(str::bytes("\n"));
+    fn write_str(s: &istr) { out.write(istr::bytes(s)); }
+    fn write_line(s: &istr) {
+        out.write(istr::bytes(s));
+        out.write(istr::bytes(~"\n"));
     }
     fn write_char(ch: char) {
         // FIXME needlessly consy
 
-        out.write(str::bytes(str::from_char(ch)));
+        out.write(istr::bytes(istr::from_char(ch)));
     }
-    fn write_int(n: int) { out.write(str::bytes(
-        istr::to_estr(int::to_str(n, 10u)))); }
-    fn write_uint(n: uint) { out.write(str::bytes(
-        istr::to_estr(uint::to_str(n, 10u)))); }
+    fn write_int(n: int) { out.write(istr::bytes(
+        int::to_str(n, 10u))); }
+    fn write_uint(n: uint) { out.write(istr::bytes(
+        uint::to_str(n, 10u))); }
     fn write_bytes(bytes: &[u8]) { out.write(bytes); }
     fn write_le_uint(n: uint, size: uint) {
         out.write(uint_to_le_bytes(n, size));
@@ -353,14 +356,16 @@ obj new_writer(out: buf_writer) {
     }
 }
 
-fn file_writer(path: str, flags: &[fileflag]) -> writer {
+fn file_writer(path: &istr, flags: &[fileflag]) -> writer {
     ret new_writer(file_buf_writer(path, flags));
 }
 
 
 // FIXME: fileflags
-fn buffered_file_buf_writer(path: str) -> buf_writer {
-    let f = os::libc::fopen(str::buf(path), str::buf("w"));
+fn buffered_file_buf_writer(path: &istr) -> buf_writer {
+    let path = istr::to_estr(path);
+    let mode = "w";
+    let f = os::libc::fopen(str::buf(path), str::buf(mode));
     if f as uint == 0u { log_err "error opening " + path; fail; }
     ret FILE_writer(f, option::some(@FILE_res(f)));
 }
@@ -372,7 +377,7 @@ fn stdout() -> writer { ret new_writer(fd_buf_writer(1, option::none)); }
 type str_writer =
     obj {
         fn get_writer() -> writer;
-        fn get_str() -> str;
+        fn get_str() -> istr;
     };
 
 type mutable_byte_buf = @{mutable buf: [mutable u8], mutable pos: uint};
@@ -415,7 +420,7 @@ fn string_writer() -> str_writer {
     let buf: mutable_byte_buf = @{mutable buf: b, mutable pos: 0u};
     obj str_writer_wrap(wr: writer, buf: mutable_byte_buf) {
         fn get_writer() -> writer { ret wr; }
-        fn get_str() -> str { ret str::unsafe_from_bytes(buf.buf); }
+        fn get_str() -> istr { ret istr::unsafe_from_bytes(buf.buf); }
     }
     ret str_writer_wrap(new_writer(byte_buf_writer(buf)), buf);
 }
@@ -435,11 +440,11 @@ fn seek_in_buf(offset: int, pos: uint, len: uint, whence: seek_style) ->
     ret bpos as uint;
 }
 
-fn read_whole_file_str(file: &str) -> str {
-    str::unsafe_from_bytes(read_whole_file(file))
+fn read_whole_file_str(file: &istr) -> istr {
+    istr::unsafe_from_bytes(read_whole_file(file))
 }
 
-fn read_whole_file(file: &str) -> [u8] {
+fn read_whole_file(file: &istr) -> [u8] {
 
     // FIXME: There's a lot of copying here
     file_reader(file).read_whole_stream()
diff --git a/src/lib/test.rs b/src/lib/test.rs
index ef3348dc36b..5c087b64814 100644
--- a/src/lib/test.rs
+++ b/src/lib/test.rs
@@ -119,26 +119,30 @@ fn run_tests_console_(opts: &test_opts, tests: &[test_desc],
         alt event {
           te_filtered(filtered_tests) {
             st.total = vec::len(filtered_tests);
-            st.out.write_line(#fmt["\nrunning %u tests", st.total]);
+            st.out.write_line(
+                istr::from_estr(#fmt["\nrunning %u tests", st.total]));
+          }
+          te_wait(test) {
+            st.out.write_str(
+                istr::from_estr(#fmt["test %s ... ", test.name]));
           }
-          te_wait(test) { st.out.write_str(#fmt["test %s ... ", test.name]); }
           te_result(test, result) {
             alt result {
               tr_ok. {
                 st.passed += 1u;
                 write_ok(st.out, st.use_color);
-                st.out.write_line("");
+                st.out.write_line(~"");
               }
               tr_failed. {
                 st.failed += 1u;
                 write_failed(st.out, st.use_color);
-                st.out.write_line("");
+                st.out.write_line(~"");
                 st.failures += [test];
               }
               tr_ignored. {
                 st.ignored += 1u;
                 write_ignored(st.out, st.use_color);
-                st.out.write_line("");
+                st.out.write_line(~"");
               }
             }
           }
@@ -160,20 +164,22 @@ fn run_tests_console_(opts: &test_opts, tests: &[test_desc],
     let success = st.failed == 0u;
 
     if !success {
-        st.out.write_line("\nfailures:");
+        st.out.write_line(~"\nfailures:");
         for test: test_desc in st.failures {
             let testname = test.name; // Satisfy alias analysis
-            st.out.write_line(#fmt["    %s", testname]);
+            st.out.write_line(istr::from_estr(#fmt["    %s", testname]));
         }
     }
 
-    st.out.write_str(#fmt["\nresult: "]);
+    st.out.write_str(istr::from_estr(#fmt["\nresult: "]));
     if success {
         // There's no parallelism at this point so it's safe to use color
         write_ok(st.out, true);
     } else { write_failed(st.out, true); }
-    st.out.write_str(#fmt[". %u passed; %u failed; %u ignored\n\n", st.passed,
-                          st.failed, st.ignored]);
+    st.out.write_str(
+        istr::from_estr(
+            #fmt[". %u passed; %u failed; %u ignored\n\n", st.passed,
+                          st.failed, st.ignored]));
 
     ret success;
 
@@ -194,7 +200,7 @@ fn run_tests_console_(opts: &test_opts, tests: &[test_desc],
         if use_color && term::color_supported() {
             term::fg(out.get_buf_writer(), color);
         }
-        out.write_str(word);
+        out.write_str(istr::from_estr(word));
         if use_color && term::color_supported() {
             term::reset(out.get_buf_writer());
         }