user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Convert std::io to istrs. Issue #855

Browse source
This commit is contained in:
Brian Anderson 2011-08-24 21:26:19 -07:00
parent 20178b9312
commit fcc031c5b4
23 changed files with 203 additions and 160 deletions
Download patch file Download diff file Expand all files Collapse all files

65
src/lib/io.rs
View file

@ -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()

28
src/lib/test.rs
View file

@ -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());
}