rust/src/lib/_io.rs

168 lines
4.1 KiB
Rust
Raw Normal View History

import std.os.libc;
import std._str;
import std._vec;
type stdio_reader = unsafe obj {
fn getc() -> int;
2010-08-20 14:12:11 -05:00
fn ungetc(int i);
};
fn new_stdio_reader(str path) -> stdio_reader {
2010-08-20 14:12:11 -05:00
unsafe obj stdio_FILE_reader(os.libc.FILE f) {
fn getc() -> int {
ret os.libc.fgetc(f);
}
fn ungetc(int i) {
os.libc.ungetc(i, f);
}
drop {
os.libc.fclose(f);
}
}
2010-08-20 14:12:11 -05:00
ret stdio_FILE_reader(os.libc.fopen(_str.buf(path),
_str.buf("r")));
}
type buf_reader = unsafe obj {
2010-08-20 14:12:11 -05:00
fn read() -> vec[u8];
2010-06-23 23:03:09 -05:00
};
type buf_writer = unsafe obj {
2010-08-20 14:12:11 -05:00
fn write(vec[u8] v);
};
fn default_bufsz() -> uint {
2010-08-20 14:12:11 -05:00
ret 4096u;
}
fn new_buf() -> vec[u8] {
2010-08-20 14:12:11 -05:00
ret _vec.alloc[u8](default_bufsz());
}
fn new_buf_reader(str path) -> buf_reader {
2010-06-23 23:03:09 -05:00
2010-08-20 14:12:11 -05:00
unsafe obj fd_buf_reader(int fd, mutable vec[u8] buf) {
2010-08-20 14:12:11 -05:00
fn read() -> vec[u8] {
2010-08-20 14:12:11 -05:00
// Ensure our buf is singly-referenced.
if (_vec.rustrt.refcount[u8](buf) != 1u) {
buf = new_buf();
}
2010-08-20 14:12:11 -05:00
auto len = default_bufsz();
auto vbuf = _vec.buf[u8](buf);
auto count = os.libc.read(fd, vbuf, len);
2010-06-23 23:03:09 -05:00
2010-08-20 14:12:11 -05:00
if (count < 0) {
log "error filling buffer";
log sys.rustrt.last_os_error();
fail;
}
_vec.len_set[u8](buf, count as uint);
ret buf;
}
2010-08-20 14:12:11 -05:00
drop {
os.libc.close(fd);
}
2010-06-23 23:03:09 -05:00
}
2010-08-20 14:12:11 -05:00
auto fd = os.libc.open(_str.buf(path),
os.libc_constants.O_RDONLY() |
os.libc_constants.O_BINARY(),
0u);
if (fd < 0) {
log "error opening file for reading";
log sys.rustrt.last_os_error();
fail;
2010-06-23 23:03:09 -05:00
}
2010-08-20 14:12:11 -05:00
ret fd_buf_reader(fd, new_buf());
2010-06-23 23:03:09 -05:00
}
type fileflag = tag(append(), create(), truncate());
fn new_buf_writer(str path, vec[fileflag] flags) -> buf_writer {
2010-08-20 14:12:11 -05:00
unsafe obj fd_buf_writer(int fd) {
fn write(vec[u8] v) {
auto len = _vec.len[u8](v);
auto count = 0u;
auto vbuf;
while (count < len) {
vbuf = _vec.buf_off[u8](v, count);
auto nout = os.libc.write(fd, vbuf, len);
if (nout < 0) {
log "error dumping buffer";
log sys.rustrt.last_os_error();
fail;
}
count += nout as uint;
}
}
drop {
os.libc.close(fd);
}
}
2010-08-20 14:12:11 -05:00
let int fflags =
os.libc_constants.O_WRONLY() |
os.libc_constants.O_BINARY();
for (fileflag f in flags) {
alt (f) {
case (append()) { fflags |= os.libc_constants.O_APPEND(); }
case (create()) { fflags |= os.libc_constants.O_CREAT(); }
case (truncate()) { fflags |= os.libc_constants.O_TRUNC(); }
}
}
2010-08-20 14:12:11 -05:00
auto fd = os.libc.open(_str.buf(path),
fflags,
os.libc_constants.S_IRUSR() |
os.libc_constants.S_IWUSR());
2010-08-20 14:12:11 -05:00
if (fd < 0) {
log "error opening file for writing";
log sys.rustrt.last_os_error();
fail;
}
2010-08-20 14:12:11 -05:00
ret fd_buf_writer(fd);
}
type writer =
2010-08-20 14:12:11 -05:00
unsafe obj {
fn write_str(str s);
fn write_int(int n);
fn write_uint(uint n);
};
fn file_writer(str path,
vec[fileflag] flags)
2010-08-20 14:12:11 -05:00
-> writer
{
2010-08-20 14:12:11 -05:00
unsafe obj fw(buf_writer out) {
fn write_str(str s) { out.write(_str.bytes(s)); }
fn write_int(int n) { out.write(_str.bytes(_int.to_str(n, 10u))); }
fn write_uint(uint n) { out.write(_str.bytes(_uint.to_str(n, 10u))); }
}
ret fw(new_buf_writer(path, flags));
}
//
// 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 .. 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
// End:
//