From 7d05da96f72d96eae1367c21064d7ab3c9a3f2bb Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Thu, 11 Aug 2011 19:14:38 -0700 Subject: Rename std::ioivec to std::io --- src/lib/ebml.rs | 12 +- src/lib/io.rs | 478 +++++++++++++++++++++++++++++++++++++++++++++++++ src/lib/ioivec.rs | 478 ------------------------------------------------- src/lib/run_program.rs | 26 +-- src/lib/std.rc | 2 +- src/lib/term.rs | 10 +- src/lib/termivec.rs | 10 +- src/lib/test.rs | 12 +- 8 files changed, 514 insertions(+), 514 deletions(-) create mode 100644 src/lib/io.rs delete mode 100644 src/lib/ioivec.rs (limited to 'src/lib') diff --git a/src/lib/ebml.rs b/src/lib/ebml.rs index 1fb5860b4a0..a843cdbcd79 100644 --- a/src/lib/ebml.rs +++ b/src/lib/ebml.rs @@ -117,9 +117,9 @@ fn doc_as_uint(d: doc) -> uint { // ebml writing -type writer = {writer: ioivec::buf_writer, mutable size_positions: [uint]}; +type writer = {writer: io::buf_writer, mutable size_positions: [uint]}; -fn write_sized_vint(w: &ioivec::buf_writer, n: uint, size: uint) { +fn write_sized_vint(w: &io::buf_writer, n: uint, size: uint) { let buf: [u8]; alt size { 1u { buf = ~[0x80u8 | (n as u8)]; } @@ -139,7 +139,7 @@ fn write_sized_vint(w: &ioivec::buf_writer, n: uint, size: uint) { w.write(buf); } -fn write_vint(w: &ioivec::buf_writer, n: uint) { +fn write_vint(w: &io::buf_writer, n: uint) { if n < 0x7fu { write_sized_vint(w, n, 1u); ret; } if n < 0x4000u { write_sized_vint(w, n, 2u); ret; } if n < 0x200000u { write_sized_vint(w, n, 3u); ret; } @@ -148,7 +148,7 @@ fn write_vint(w: &ioivec::buf_writer, n: uint) { fail; } -fn create_writer(w: &ioivec::buf_writer) -> writer { +fn create_writer(w: &io::buf_writer) -> writer { let size_positions: [uint] = ~[]; ret {writer: w, mutable size_positions: size_positions}; } @@ -169,9 +169,9 @@ fn start_tag(w: &writer, tag_id: uint) { fn end_tag(w: &writer) { let last_size_pos = ivec::pop[uint](w.size_positions); let cur_pos = w.writer.tell(); - w.writer.seek(last_size_pos as int, ioivec::seek_set); + w.writer.seek(last_size_pos as int, io::seek_set); write_sized_vint(w.writer, cur_pos - last_size_pos - 4u, 4u); - w.writer.seek(cur_pos as int, ioivec::seek_set); + w.writer.seek(cur_pos as int, io::seek_set); } // TODO: optionally perform "relaxations" on end_tag to more efficiently // encode sizes; this is a fixed point iteration diff --git a/src/lib/io.rs b/src/lib/io.rs new file mode 100644 index 00000000000..382e93479e1 --- /dev/null +++ b/src/lib/io.rs @@ -0,0 +1,478 @@ + +import os::libc; + +native "rust" mod rustrt { + fn rust_get_stdin() -> os::libc::FILE; + fn rust_get_stdout() -> os::libc::FILE; +} + + +// Reading + +// FIXME This is all buffered. We might need an unbuffered variant as well +tag seek_style { seek_set; seek_end; seek_cur; } + + +// The raw underlying reader class. All readers must implement this. +type buf_reader = + + // FIXME: Seekable really should be orthogonal. We will need + // inheritance. + obj { + fn read(uint) -> [u8] ; + fn read_byte() -> int ; + fn unread_byte(int) ; + fn eof() -> bool ; + fn seek(int, seek_style) ; + fn tell() -> uint ; + }; + + +// Convenience methods for reading. +type reader = + + // FIXME: This should inherit from buf_reader. + // FIXME: eventually u64 + + obj { + fn get_buf_reader() -> buf_reader ; + fn read_byte() -> int ; + fn unread_byte(int) ; + fn read_bytes(uint) -> [u8] ; + fn read_char() -> char ; + fn eof() -> bool ; + fn read_line() -> str ; + fn read_c_str() -> str ; + fn read_le_uint(uint) -> uint ; + fn read_le_int(uint) -> int ; + fn read_be_uint(uint) -> uint ; + fn read_whole_stream() -> [u8] ; + fn seek(int, seek_style) ; + fn tell() -> uint ; + }; + +fn convert_whence(whence: seek_style) -> int { + ret alt whence { seek_set. { 0 } seek_cur. { 1 } seek_end. { 2 } }; +} + +resource FILE_res(f: os::libc::FILE) { + os::libc::fclose(f); +} + +obj FILE_buf_reader(f: os::libc::FILE, res: option::t[@FILE_res]) { + fn read(len: uint) -> [u8] { + let buf = ~[]; + ivec::reserve[u8](buf, len); + let read = os::libc_ivec::fread(ivec::to_ptr[u8](buf), 1u, len, f); + ivec::unsafe::set_len[u8](buf, read); + ret buf; + } + fn read_byte() -> int { ret os::libc::fgetc(f); } + fn unread_byte(byte: int) { os::libc::ungetc(byte, f); } + fn eof() -> bool { ret os::libc::feof(f) != 0; } + fn seek(offset: int, whence: seek_style) { + assert (os::libc::fseek(f, offset, convert_whence(whence)) == 0); + } + fn tell() -> uint { + ret os::libc::ftell(f) as uint; + } +} + + +// FIXME: Convert this into pseudomethods on buf_reader. +obj new_reader(rdr: buf_reader) { + fn get_buf_reader() -> buf_reader { ret rdr; } + fn read_byte() -> int { ret rdr.read_byte(); } + fn unread_byte(byte: int) { ret rdr.unread_byte(byte); } + fn read_bytes(len: uint) -> [u8] { ret rdr.read(len); } + fn read_char() -> char { + let c0 = rdr.read_byte(); + if c0 == -1 { + ret -1 as char; // FIXME will this stay valid? + + } + let b0 = c0 as u8; + let w = str::utf8_char_width(b0); + assert (w > 0u); + if w == 1u { ret b0 as char; } + let val = 0u; + while w > 1u { + w -= 1u; + let next = rdr.read_byte(); + assert (next > -1); + assert (next & 192 == 128); + val <<= 6u; + val += next & 63 as uint; + } + // See str::char_at + + val += (b0 << (w + 1u as u8) as uint) << (w - 1u) * 6u - w - 1u; + ret val as char; + } + fn eof() -> bool { ret rdr.eof(); } + fn read_line() -> str { + let buf: [u8] = ~[]; + // No break yet in rustc + + let go_on = true; + while go_on { + let ch = rdr.read_byte(); + if ch == -1 || ch == 10 { + go_on = false; + } else { buf += ~[ch as u8]; } + } + ret str::unsafe_from_bytes(buf); + } + fn read_c_str() -> str { + 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); + } + + // FIXME deal with eof? + fn read_le_uint(size: uint) -> uint { + let val = 0u; + let pos = 0u; + while size > 0u { + val += (rdr.read_byte() as uint) << pos; + pos += 8u; + size -= 1u; + } + ret val; + } + fn read_le_int(size: uint) -> int { + let val = 0u; + let pos = 0u; + while size > 0u { + val += (rdr.read_byte() as uint) << pos; + pos += 8u; + size -= 1u; + } + ret val as int; + } + + // FIXME deal with eof? + fn read_be_uint(sz: uint) -> uint { + let val = 0u; + + while sz > 0u { + sz -= 1u; + val += (rdr.read_byte() as uint) << sz * 8u; + } + ret val; + } + fn read_whole_stream() -> [u8] { + let buf: [u8] = ~[]; + while !rdr.eof() { buf += rdr.read(2048u); } + ret buf; + } + fn seek(offset: int, whence: seek_style) { ret rdr.seek(offset, whence); } + fn tell() -> uint { ret rdr.tell(); } +} + +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")); + if f as uint == 0u { log_err "error opening " + path; fail; } + ret new_reader(FILE_buf_reader(f, option::some(@FILE_res(f)))); +} + + +// FIXME: Remove me once objects are exported. +fn new_reader_(bufr: buf_reader) -> reader { ret new_reader(bufr); } + + +// Byte buffer readers + +// TODO: mutable? u8, but this fails with rustboot. +type byte_buf = @{buf: [u8], mutable pos: uint}; + +obj byte_buf_reader(bbuf: byte_buf) { + fn read(len: uint) -> [u8] { + let rest = ivec::len[u8](bbuf.buf) - bbuf.pos; + let to_read = len; + if rest < to_read { to_read = rest; } + let range = ivec::slice[u8](bbuf.buf, bbuf.pos, bbuf.pos + to_read); + bbuf.pos += to_read; + ret range; + } + fn read_byte() -> int { + if bbuf.pos == ivec::len[u8](bbuf.buf) { ret -1; } + let b = bbuf.buf.(bbuf.pos); + bbuf.pos += 1u; + ret b as int; + } + fn unread_byte(byte: int) { log_err "TODO: unread_byte"; fail; } + fn eof() -> bool { ret bbuf.pos == ivec::len[u8](bbuf.buf); } + fn seek(offset: int, whence: seek_style) { + let pos = bbuf.pos; + let len = ivec::len[u8](bbuf.buf); + bbuf.pos = seek_in_buf(offset, pos, len, whence); + } + fn tell() -> uint { ret bbuf.pos; } +} + +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))); +} + + +// Writing +tag fileflag { append; create; truncate; none; } + +type buf_writer = + + // FIXME: Seekable really should be orthogonal. We will need + // inheritance. + // FIXME: eventually u64 + + obj { + fn write(&[u8]) ; + fn seek(int, seek_style) ; + fn tell() -> uint ; + }; + +obj FILE_writer(f: os::libc::FILE, res: option::t[@FILE_res]) { + fn write(v: &[u8]) { + let len = ivec::len[u8](v); + let vbuf = ivec::to_ptr[u8](v); + let nout = os::libc_ivec::fwrite(vbuf, len, 1u, f); + if nout < 1u { log_err "error dumping buffer"; } + } + fn seek(offset: int, whence: seek_style) { + assert (os::libc::fseek(f, offset, convert_whence(whence)) == 0); + } + fn tell() -> uint { + ret os::libc::ftell(f) as uint; + } +} + +resource fd_res(fd: int) { + os::libc::close(fd); +} + +obj fd_buf_writer(fd: int, res: option::t[@fd_res]) { + fn write(v: &[u8]) { + let len = ivec::len[u8](v); + let count = 0u; + let vbuf; + while count < len { + vbuf = ptr::offset(ivec::to_ptr[u8](v), count); + let nout = os::libc_ivec::write(fd, vbuf, len); + if nout < 0 { + log_err "error dumping buffer"; + log_err sys::rustrt::last_os_error(); + fail; + } + count += nout as uint; + } + } + fn seek(offset: int, whence: seek_style) { + log_err "need 64-bit native calls for seek, sorry"; + fail; + } + fn tell() -> uint { + log_err "need 64-bit native calls for tell, sorry"; + fail; + } +} + +fn file_buf_writer(path: str, flags: &[fileflag]) -> buf_writer { + let fflags: int = + os::libc_constants::O_WRONLY() | os::libc_constants::O_BINARY(); + for f: fileflag in flags { + alt f { + append. { fflags |= os::libc_constants::O_APPEND(); } + create. { fflags |= os::libc_constants::O_CREAT(); } + truncate. { fflags |= os::libc_constants::O_TRUNC(); } + none. { } + } + } + let fd = + os::libc::open(str::buf(path), fflags, + os::libc_constants::S_IRUSR() | + os::libc_constants::S_IWUSR()); + if fd < 0 { + log_err "error opening file for writing"; + log_err sys::rustrt::last_os_error(); + fail; + } + ret fd_buf_writer(fd, option::some(@fd_res(fd))); +} + +type writer = + + // write_str will continue to do utf-8 output only. an alternative + // 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_char(char) ; + fn write_int(int) ; + fn write_uint(uint) ; + fn write_bytes(&[u8]) ; + fn write_le_uint(uint, uint) ; + fn write_le_int(int, uint) ; + fn write_be_uint(uint, uint) ; + }; + +fn uint_to_le_bytes(n: uint, size: uint) -> [u8] { + let bytes: [u8] = ~[]; + while size > 0u { bytes += ~[n & 255u as u8]; n >>= 8u; size -= 1u; } + ret bytes; +} + +fn uint_to_be_bytes(n: uint, size: uint) -> [u8] { + let bytes: [u8] = ~[]; + let i = size - 1u as int; + while i >= 0 { bytes += ~[n >> (i * 8 as uint) & 255u as u8]; i -= 1; } + ret bytes; +} + +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_char(ch: char) { + // FIXME needlessly consy + + out.write(str::bytes(str::from_char(ch))); + } + fn write_int(n: int) { out.write(str::bytes(int::to_str(n, 10u))); } + fn write_uint(n: uint) { + out.write(str::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)); + } + fn write_le_int(n: int, size: uint) { + out.write(uint_to_le_bytes(n as uint, size)); + } + fn write_be_uint(n: uint, size: uint) { + out.write(uint_to_be_bytes(n, size)); + } +} + + +// FIXME: Remove me once objects are exported. +fn new_writer_(out: buf_writer) -> writer { ret new_writer(out); } + +fn file_writer(path: str, 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")); + if f as uint == 0u { log_err "error opening " + path; fail; } + ret FILE_writer(f, option::some(@FILE_res(f))); +} + + +// FIXME it would be great if this could be a const +fn stdout() -> writer { ret new_writer(fd_buf_writer(1, option::none)); } + +type str_writer = + obj { + fn get_writer() -> writer ; + fn get_str() -> str ; + }; + +type mutable_byte_buf = @{mutable buf: [mutable u8], mutable pos: uint}; + +obj byte_buf_writer(buf: mutable_byte_buf) { + fn write(v: &[u8]) { + // Fast path. + + if buf.pos == ivec::len(buf.buf) { + for b: u8 in v { buf.buf += ~[mutable b]; } + buf.pos += ivec::len[u8](v); + ret; + } + // FIXME: Optimize: These should be unique pointers. + + let vlen = ivec::len[u8](v); + let vpos = 0u; + while vpos < vlen { + let b = v.(vpos); + if buf.pos == ivec::len(buf.buf) { + buf.buf += ~[mutable b]; + } else { buf.buf.(buf.pos) = b; } + buf.pos += 1u; + vpos += 1u; + } + } + fn seek(offset: int, whence: seek_style) { + let pos = buf.pos; + let len = ivec::len(buf.buf); + buf.pos = seek_in_buf(offset, pos, len, whence); + } + fn tell() -> uint { ret buf.pos; } +} + +fn string_writer() -> str_writer { + // FIXME: yikes, this is bad. Needs fixing of mutable syntax. + + let b: [mutable u8] = ~[mutable 0u8]; + ivec::pop(b); + 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); } + } + ret str_writer_wrap(new_writer(byte_buf_writer(buf)), buf); +} + + +// Utility functions +fn seek_in_buf(offset: int, pos: uint, len: uint, whence: seek_style) -> + uint { + let bpos = pos as int; + let blen = len as int; + alt whence { + seek_set. { bpos = offset; } + seek_cur. { bpos += offset; } + seek_end. { bpos = blen + offset; } + } + if bpos < 0 { bpos = 0; } else if (bpos > blen) { bpos = blen; } + ret bpos as uint; +} + +fn read_whole_file_str(file: &str) -> str { + str::unsafe_from_bytes(read_whole_file(file)) +} + +fn read_whole_file(file: &str) -> [u8] { + // FIXME: There's a lot of copying here + file_reader(file).read_whole_stream() +} + + + +// +// Local Variables: +// mode: rust +// fill-column: 78; +// indent-tabs-mode: nil +// c-basic-offset: 4 +// buffer-file-coding-system: utf-8-unix +// compile-command: "make -k -C $RBUILD 2>&1 | sed -e 's/\\/x\\//x:\\//g'"; +// End: +// diff --git a/src/lib/ioivec.rs b/src/lib/ioivec.rs deleted file mode 100644 index 382e93479e1..00000000000 --- a/src/lib/ioivec.rs +++ /dev/null @@ -1,478 +0,0 @@ - -import os::libc; - -native "rust" mod rustrt { - fn rust_get_stdin() -> os::libc::FILE; - fn rust_get_stdout() -> os::libc::FILE; -} - - -// Reading - -// FIXME This is all buffered. We might need an unbuffered variant as well -tag seek_style { seek_set; seek_end; seek_cur; } - - -// The raw underlying reader class. All readers must implement this. -type buf_reader = - - // FIXME: Seekable really should be orthogonal. We will need - // inheritance. - obj { - fn read(uint) -> [u8] ; - fn read_byte() -> int ; - fn unread_byte(int) ; - fn eof() -> bool ; - fn seek(int, seek_style) ; - fn tell() -> uint ; - }; - - -// Convenience methods for reading. -type reader = - - // FIXME: This should inherit from buf_reader. - // FIXME: eventually u64 - - obj { - fn get_buf_reader() -> buf_reader ; - fn read_byte() -> int ; - fn unread_byte(int) ; - fn read_bytes(uint) -> [u8] ; - fn read_char() -> char ; - fn eof() -> bool ; - fn read_line() -> str ; - fn read_c_str() -> str ; - fn read_le_uint(uint) -> uint ; - fn read_le_int(uint) -> int ; - fn read_be_uint(uint) -> uint ; - fn read_whole_stream() -> [u8] ; - fn seek(int, seek_style) ; - fn tell() -> uint ; - }; - -fn convert_whence(whence: seek_style) -> int { - ret alt whence { seek_set. { 0 } seek_cur. { 1 } seek_end. { 2 } }; -} - -resource FILE_res(f: os::libc::FILE) { - os::libc::fclose(f); -} - -obj FILE_buf_reader(f: os::libc::FILE, res: option::t[@FILE_res]) { - fn read(len: uint) -> [u8] { - let buf = ~[]; - ivec::reserve[u8](buf, len); - let read = os::libc_ivec::fread(ivec::to_ptr[u8](buf), 1u, len, f); - ivec::unsafe::set_len[u8](buf, read); - ret buf; - } - fn read_byte() -> int { ret os::libc::fgetc(f); } - fn unread_byte(byte: int) { os::libc::ungetc(byte, f); } - fn eof() -> bool { ret os::libc::feof(f) != 0; } - fn seek(offset: int, whence: seek_style) { - assert (os::libc::fseek(f, offset, convert_whence(whence)) == 0); - } - fn tell() -> uint { - ret os::libc::ftell(f) as uint; - } -} - - -// FIXME: Convert this into pseudomethods on buf_reader. -obj new_reader(rdr: buf_reader) { - fn get_buf_reader() -> buf_reader { ret rdr; } - fn read_byte() -> int { ret rdr.read_byte(); } - fn unread_byte(byte: int) { ret rdr.unread_byte(byte); } - fn read_bytes(len: uint) -> [u8] { ret rdr.read(len); } - fn read_char() -> char { - let c0 = rdr.read_byte(); - if c0 == -1 { - ret -1 as char; // FIXME will this stay valid? - - } - let b0 = c0 as u8; - let w = str::utf8_char_width(b0); - assert (w > 0u); - if w == 1u { ret b0 as char; } - let val = 0u; - while w > 1u { - w -= 1u; - let next = rdr.read_byte(); - assert (next > -1); - assert (next & 192 == 128); - val <<= 6u; - val += next & 63 as uint; - } - // See str::char_at - - val += (b0 << (w + 1u as u8) as uint) << (w - 1u) * 6u - w - 1u; - ret val as char; - } - fn eof() -> bool { ret rdr.eof(); } - fn read_line() -> str { - let buf: [u8] = ~[]; - // No break yet in rustc - - let go_on = true; - while go_on { - let ch = rdr.read_byte(); - if ch == -1 || ch == 10 { - go_on = false; - } else { buf += ~[ch as u8]; } - } - ret str::unsafe_from_bytes(buf); - } - fn read_c_str() -> str { - 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); - } - - // FIXME deal with eof? - fn read_le_uint(size: uint) -> uint { - let val = 0u; - let pos = 0u; - while size > 0u { - val += (rdr.read_byte() as uint) << pos; - pos += 8u; - size -= 1u; - } - ret val; - } - fn read_le_int(size: uint) -> int { - let val = 0u; - let pos = 0u; - while size > 0u { - val += (rdr.read_byte() as uint) << pos; - pos += 8u; - size -= 1u; - } - ret val as int; - } - - // FIXME deal with eof? - fn read_be_uint(sz: uint) -> uint { - let val = 0u; - - while sz > 0u { - sz -= 1u; - val += (rdr.read_byte() as uint) << sz * 8u; - } - ret val; - } - fn read_whole_stream() -> [u8] { - let buf: [u8] = ~[]; - while !rdr.eof() { buf += rdr.read(2048u); } - ret buf; - } - fn seek(offset: int, whence: seek_style) { ret rdr.seek(offset, whence); } - fn tell() -> uint { ret rdr.tell(); } -} - -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")); - if f as uint == 0u { log_err "error opening " + path; fail; } - ret new_reader(FILE_buf_reader(f, option::some(@FILE_res(f)))); -} - - -// FIXME: Remove me once objects are exported. -fn new_reader_(bufr: buf_reader) -> reader { ret new_reader(bufr); } - - -// Byte buffer readers - -// TODO: mutable? u8, but this fails with rustboot. -type byte_buf = @{buf: [u8], mutable pos: uint}; - -obj byte_buf_reader(bbuf: byte_buf) { - fn read(len: uint) -> [u8] { - let rest = ivec::len[u8](bbuf.buf) - bbuf.pos; - let to_read = len; - if rest < to_read { to_read = rest; } - let range = ivec::slice[u8](bbuf.buf, bbuf.pos, bbuf.pos + to_read); - bbuf.pos += to_read; - ret range; - } - fn read_byte() -> int { - if bbuf.pos == ivec::len[u8](bbuf.buf) { ret -1; } - let b = bbuf.buf.(bbuf.pos); - bbuf.pos += 1u; - ret b as int; - } - fn unread_byte(byte: int) { log_err "TODO: unread_byte"; fail; } - fn eof() -> bool { ret bbuf.pos == ivec::len[u8](bbuf.buf); } - fn seek(offset: int, whence: seek_style) { - let pos = bbuf.pos; - let len = ivec::len[u8](bbuf.buf); - bbuf.pos = seek_in_buf(offset, pos, len, whence); - } - fn tell() -> uint { ret bbuf.pos; } -} - -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))); -} - - -// Writing -tag fileflag { append; create; truncate; none; } - -type buf_writer = - - // FIXME: Seekable really should be orthogonal. We will need - // inheritance. - // FIXME: eventually u64 - - obj { - fn write(&[u8]) ; - fn seek(int, seek_style) ; - fn tell() -> uint ; - }; - -obj FILE_writer(f: os::libc::FILE, res: option::t[@FILE_res]) { - fn write(v: &[u8]) { - let len = ivec::len[u8](v); - let vbuf = ivec::to_ptr[u8](v); - let nout = os::libc_ivec::fwrite(vbuf, len, 1u, f); - if nout < 1u { log_err "error dumping buffer"; } - } - fn seek(offset: int, whence: seek_style) { - assert (os::libc::fseek(f, offset, convert_whence(whence)) == 0); - } - fn tell() -> uint { - ret os::libc::ftell(f) as uint; - } -} - -resource fd_res(fd: int) { - os::libc::close(fd); -} - -obj fd_buf_writer(fd: int, res: option::t[@fd_res]) { - fn write(v: &[u8]) { - let len = ivec::len[u8](v); - let count = 0u; - let vbuf; - while count < len { - vbuf = ptr::offset(ivec::to_ptr[u8](v), count); - let nout = os::libc_ivec::write(fd, vbuf, len); - if nout < 0 { - log_err "error dumping buffer"; - log_err sys::rustrt::last_os_error(); - fail; - } - count += nout as uint; - } - } - fn seek(offset: int, whence: seek_style) { - log_err "need 64-bit native calls for seek, sorry"; - fail; - } - fn tell() -> uint { - log_err "need 64-bit native calls for tell, sorry"; - fail; - } -} - -fn file_buf_writer(path: str, flags: &[fileflag]) -> buf_writer { - let fflags: int = - os::libc_constants::O_WRONLY() | os::libc_constants::O_BINARY(); - for f: fileflag in flags { - alt f { - append. { fflags |= os::libc_constants::O_APPEND(); } - create. { fflags |= os::libc_constants::O_CREAT(); } - truncate. { fflags |= os::libc_constants::O_TRUNC(); } - none. { } - } - } - let fd = - os::libc::open(str::buf(path), fflags, - os::libc_constants::S_IRUSR() | - os::libc_constants::S_IWUSR()); - if fd < 0 { - log_err "error opening file for writing"; - log_err sys::rustrt::last_os_error(); - fail; - } - ret fd_buf_writer(fd, option::some(@fd_res(fd))); -} - -type writer = - - // write_str will continue to do utf-8 output only. an alternative - // 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_char(char) ; - fn write_int(int) ; - fn write_uint(uint) ; - fn write_bytes(&[u8]) ; - fn write_le_uint(uint, uint) ; - fn write_le_int(int, uint) ; - fn write_be_uint(uint, uint) ; - }; - -fn uint_to_le_bytes(n: uint, size: uint) -> [u8] { - let bytes: [u8] = ~[]; - while size > 0u { bytes += ~[n & 255u as u8]; n >>= 8u; size -= 1u; } - ret bytes; -} - -fn uint_to_be_bytes(n: uint, size: uint) -> [u8] { - let bytes: [u8] = ~[]; - let i = size - 1u as int; - while i >= 0 { bytes += ~[n >> (i * 8 as uint) & 255u as u8]; i -= 1; } - ret bytes; -} - -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_char(ch: char) { - // FIXME needlessly consy - - out.write(str::bytes(str::from_char(ch))); - } - fn write_int(n: int) { out.write(str::bytes(int::to_str(n, 10u))); } - fn write_uint(n: uint) { - out.write(str::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)); - } - fn write_le_int(n: int, size: uint) { - out.write(uint_to_le_bytes(n as uint, size)); - } - fn write_be_uint(n: uint, size: uint) { - out.write(uint_to_be_bytes(n, size)); - } -} - - -// FIXME: Remove me once objects are exported. -fn new_writer_(out: buf_writer) -> writer { ret new_writer(out); } - -fn file_writer(path: str, 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")); - if f as uint == 0u { log_err "error opening " + path; fail; } - ret FILE_writer(f, option::some(@FILE_res(f))); -} - - -// FIXME it would be great if this could be a const -fn stdout() -> writer { ret new_writer(fd_buf_writer(1, option::none)); } - -type str_writer = - obj { - fn get_writer() -> writer ; - fn get_str() -> str ; - }; - -type mutable_byte_buf = @{mutable buf: [mutable u8], mutable pos: uint}; - -obj byte_buf_writer(buf: mutable_byte_buf) { - fn write(v: &[u8]) { - // Fast path. - - if buf.pos == ivec::len(buf.buf) { - for b: u8 in v { buf.buf += ~[mutable b]; } - buf.pos += ivec::len[u8](v); - ret; - } - // FIXME: Optimize: These should be unique pointers. - - let vlen = ivec::len[u8](v); - let vpos = 0u; - while vpos < vlen { - let b = v.(vpos); - if buf.pos == ivec::len(buf.buf) { - buf.buf += ~[mutable b]; - } else { buf.buf.(buf.pos) = b; } - buf.pos += 1u; - vpos += 1u; - } - } - fn seek(offset: int, whence: seek_style) { - let pos = buf.pos; - let len = ivec::len(buf.buf); - buf.pos = seek_in_buf(offset, pos, len, whence); - } - fn tell() -> uint { ret buf.pos; } -} - -fn string_writer() -> str_writer { - // FIXME: yikes, this is bad. Needs fixing of mutable syntax. - - let b: [mutable u8] = ~[mutable 0u8]; - ivec::pop(b); - 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); } - } - ret str_writer_wrap(new_writer(byte_buf_writer(buf)), buf); -} - - -// Utility functions -fn seek_in_buf(offset: int, pos: uint, len: uint, whence: seek_style) -> - uint { - let bpos = pos as int; - let blen = len as int; - alt whence { - seek_set. { bpos = offset; } - seek_cur. { bpos += offset; } - seek_end. { bpos = blen + offset; } - } - if bpos < 0 { bpos = 0; } else if (bpos > blen) { bpos = blen; } - ret bpos as uint; -} - -fn read_whole_file_str(file: &str) -> str { - str::unsafe_from_bytes(read_whole_file(file)) -} - -fn read_whole_file(file: &str) -> [u8] { - // FIXME: There's a lot of copying here - file_reader(file).read_whole_stream() -} - - - -// -// Local Variables: -// mode: rust -// fill-column: 78; -// indent-tabs-mode: nil -// c-basic-offset: 4 -// buffer-file-coding-system: utf-8-unix -// compile-command: "make -k -C $RBUILD 2>&1 | sed -e 's/\\/x\\//x:\\//g'"; -// End: -// diff --git a/src/lib/run_program.rs b/src/lib/run_program.rs index 3b5751c806f..7db81f96d5b 100644 --- a/src/lib/run_program.rs +++ b/src/lib/run_program.rs @@ -36,9 +36,9 @@ fn run_program(prog: str, args: vec[str]) -> int { type program = obj { fn get_id() -> int; - fn input() -> ioivec::writer; - fn output() -> ioivec::reader; - fn err() -> ioivec::reader; + fn input() -> io::writer; + fn output() -> io::reader; + fn err() -> io::reader; fn close_input(); fn finish() -> int; fn destroy(); @@ -65,17 +65,17 @@ fn start_program(prog: str, args: vec[str]) -> @program_res { err_file: os::libc::FILE, mutable finished: bool) { fn get_id() -> int { ret pid; } - fn input() -> ioivec::writer { - ret ioivec::new_writer( - ioivec::fd_buf_writer(in_fd, option::none)); + fn input() -> io::writer { + ret io::new_writer( + io::fd_buf_writer(in_fd, option::none)); } - fn output() -> ioivec::reader { - ret ioivec::new_reader( - ioivec::FILE_buf_reader(out_file, option::none)); + fn output() -> io::reader { + ret io::new_reader( + io::FILE_buf_reader(out_file, option::none)); } - fn err() -> ioivec::reader { - ret ioivec::new_reader( - ioivec::FILE_buf_reader(err_file, option::none)); + fn err() -> io::reader { + ret io::new_reader( + io::FILE_buf_reader(err_file, option::none)); } fn close_input() { let invalid_fd = -1; @@ -103,7 +103,7 @@ fn start_program(prog: str, args: vec[str]) -> @program_res { false)); } -fn read_all(rd: &ioivec::reader) -> str { +fn read_all(rd: &io::reader) -> str { let buf = ""; while !rd.eof() { let bytes = rd.read_bytes(4096u); diff --git a/src/lib/std.rc b/src/lib/std.rc index 6f642e1954b..eee4630db20 100644 --- a/src/lib/std.rc +++ b/src/lib/std.rc @@ -20,7 +20,7 @@ mod str; // General io and system-services modules. -mod ioivec; +mod io; mod sys; mod task; mod comm; diff --git a/src/lib/term.rs b/src/lib/term.rs index d13b0dee3de..f61611a9a15 100644 --- a/src/lib/term.rs +++ b/src/lib/term.rs @@ -40,9 +40,9 @@ const color_bright_cyan: u8 = 14u8; const color_bright_white: u8 = 15u8; -fn esc(writer: ioivec::buf_writer) { writer.write(~[0x1bu8, '[' as u8]); } +fn esc(writer: io::buf_writer) { writer.write(~[0x1bu8, '[' as u8]); } -fn reset(writer: ioivec::buf_writer) { +fn reset(writer: io::buf_writer) { esc(writer); writer.write(~['0' as u8, 'm' as u8]); } @@ -55,18 +55,18 @@ fn color_supported() -> bool { }; } -fn set_color(writer: ioivec::buf_writer, first_char: u8, color: u8) { +fn set_color(writer: io::buf_writer, first_char: u8, color: u8) { assert (color < 16u8); esc(writer); if color >= 8u8 { writer.write(~['1' as u8, ';' as u8]); color -= 8u8; } writer.write(~[first_char, ('0' as u8) + color, 'm' as u8]); } -fn fg(writer: ioivec::buf_writer, color: u8) { +fn fg(writer: io::buf_writer, color: u8) { ret set_color(writer, '3' as u8, color); } -fn bg(writer: ioivec::buf_writer, color: u8) { +fn bg(writer: io::buf_writer, color: u8) { ret set_color(writer, '4' as u8, color); } // export fg; diff --git a/src/lib/termivec.rs b/src/lib/termivec.rs index 29477ec925f..4d635e780b2 100644 --- a/src/lib/termivec.rs +++ b/src/lib/termivec.rs @@ -40,9 +40,9 @@ const color_bright_cyan: u8 = 14u8; const color_bright_white: u8 = 15u8; -fn esc(writer: ioivec::buf_writer) { writer.write(~[0x1bu8, '[' as u8]); } +fn esc(writer: io::buf_writer) { writer.write(~[0x1bu8, '[' as u8]); } -fn reset(writer: ioivec::buf_writer) { +fn reset(writer: io::buf_writer) { esc(writer); writer.write(~['0' as u8, 'm' as u8]); } @@ -60,18 +60,18 @@ fn color_supported() -> bool { }; } -fn set_color(writer: ioivec::buf_writer, first_char: u8, color: u8) { +fn set_color(writer: io::buf_writer, first_char: u8, color: u8) { assert (color < 16u8); esc(writer); if color >= 8u8 { writer.write(~['1' as u8, ';' as u8]); color -= 8u8; } writer.write(~[first_char, ('0' as u8) + color, 'm' as u8]); } -fn fg(writer: ioivec::buf_writer, color: u8) { +fn fg(writer: io::buf_writer, color: u8) { ret set_color(writer, '3' as u8, color); } -fn bg(writer: ioivec::buf_writer, color: u8) { +fn bg(writer: io::buf_writer, color: u8) { ret set_color(writer, '4' as u8, color); } // export fg; diff --git a/src/lib/test.rs b/src/lib/test.rs index 04472088789..70f9580bf73 100644 --- a/src/lib/test.rs +++ b/src/lib/test.rs @@ -106,7 +106,7 @@ fn run_tests_console_(opts: &test_opts, tests: &[test_desc], to_task: &test_to_task) -> bool { type test_state = @{ - out: ioivec::writer, + out: io::writer, use_color: bool, mutable total: uint, mutable passed: uint, @@ -148,7 +148,7 @@ fn run_tests_console_(opts: &test_opts, tests: &[test_desc], } let st = @{ - out: ioivec::stdout(), + out: io::stdout(), use_color: use_color(), mutable total: 0u, mutable passed: 0u, @@ -181,19 +181,19 @@ fn run_tests_console_(opts: &test_opts, tests: &[test_desc], ret success; - fn write_ok(out: &ioivec::writer, use_color: bool) { + fn write_ok(out: &io::writer, use_color: bool) { write_pretty(out, "ok", term::color_green, use_color); } - fn write_failed(out: &ioivec::writer, use_color: bool) { + fn write_failed(out: &io::writer, use_color: bool) { write_pretty(out, "FAILED", term::color_red, use_color); } - fn write_ignored(out: &ioivec::writer, use_color: bool) { + fn write_ignored(out: &io::writer, use_color: bool) { write_pretty(out, "ignored", term::color_yellow, use_color); } - fn write_pretty(out: &ioivec::writer, word: &str, color: u8, + fn write_pretty(out: &io::writer, word: &str, color: u8, use_color: bool) { if use_color && term::color_supported() { term::fg(out.get_buf_writer(), color); -- cgit 1.4.1-3-g733a5