From fcc031c5b4dc8f64c497b8dd1e066068e862bd72 Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Wed, 24 Aug 2011 21:26:19 -0700 Subject: Convert std::io to istrs. Issue #855 --- src/lib/io.rs | 65 +++++++++++++++++++++++++++++++-------------------------- src/lib/test.rs | 28 +++++++++++++++---------- 2 files changed, 52 insertions(+), 41 deletions(-) (limited to 'src/lib') 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()); } -- cgit 1.4.1-3-g733a5