rust-lang/rust
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Reformat for new syntax

Browse Source
This commit is contained in:
Marijn Haverbeke
2011-07-27 14:19:39 +02:00
parent 0e3ee39c41
commit df7f21db09
723 changed files with 28622 additions and 31631 deletions
Download Patch File Download Diff File Expand all files Collapse all files

323
src/lib/ioivec.rs
View File

@@ -15,25 +15,27 @@ 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 ;
// FIXME: Seekable really should be orthogonal. We will need
// inheritance.
fn seek(int, seek_style) ;
fn seek(int, seek_style) ;
fn tell() -> uint ;
};
// Convenience methods for reading.
type reader =
obj {
// FIXME: This should inherit from buf_reader.
fn get_buf_reader() -> buf_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[] ;
@@ -46,58 +48,53 @@ type reader =
fn read_be_uint(uint) -> uint ;
fn read_whole_stream() -> u8[] ;
fn seek(int, seek_style) ;
fn tell() -> uint ; // FIXME: eventually u64
fn tell() -> uint ;
};
fn convert_whence(seek_style whence) -> int {
ret alt (whence) {
case (seek_set) { 0 }
case (seek_cur) { 1 }
case (seek_end) { 2 }
};
fn convert_whence(whence: seek_style) -> int {
ret alt whence { seek_set. { 0 } seek_cur. { 1 } seek_end. { 2 } };
}
obj FILE_buf_reader(os::libc::FILE f, bool must_close) {
fn read(uint len) -> u8[] {
auto buf = ~[];
obj FILE_buf_reader(f: os::libc::FILE, must_close: bool) {
fn read(len: uint) -> u8[] {
let buf = ~[];
ivec::reserve[u8](buf, len);
auto read = os::libc_ivec::fread(ivec::to_ptr[u8](buf), 1u, len, f);
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(int byte) { os::libc::ungetc(byte, f); }
fn unread_byte(byte: int) { os::libc::ungetc(byte, f); }
fn eof() -> bool { ret os::libc::feof(f) != 0; }
fn seek(int offset, seek_style whence) {
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;
}drop { if (must_close) { os::libc::fclose(f); } }
}drop { if must_close { os::libc::fclose(f); } }
}
// FIXME: Convert this into pseudomethods on buf_reader.
obj new_reader(buf_reader rdr) {
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(int byte) { ret rdr.unread_byte(byte); }
fn read_bytes(uint len) -> u8[] { ret rdr.read(len); }
fn unread_byte(byte: int) { ret rdr.unread_byte(byte); }
fn read_bytes(len: uint) -> u8[] { ret rdr.read(len); }
fn read_char() -> char {
auto c0 = rdr.read_byte();
if (c0 == -1) {
let c0 = rdr.read_byte();
if c0 == -1 {
ret -1 as char; // FIXME will this stay valid?
}
auto b0 = c0 as u8;
auto w = str::utf8_char_width(b0);
let b0 = c0 as u8;
let w = str::utf8_char_width(b0);
assert (w > 0u);
if (w == 1u) { ret b0 as char; }
auto val = 0u;
while (w > 1u) {
if w == 1u { ret b0 as char; }
let val = 0u;
while w > 1u {
w -= 1u;
auto next = rdr.read_byte();
let next = rdr.read_byte();
assert (next > -1);
assert (next & 192 == 128);
val <<= 6u;
@@ -110,45 +107,43 @@ obj new_reader(buf_reader rdr) {
}
fn eof() -> bool { ret rdr.eof(); }
fn read_line() -> str {
let u8[] buf = ~[];
let buf: u8[] = ~[];
// No break yet in rustc
auto go_on = true;
while (go_on) {
auto ch = rdr.read_byte();
if (ch == -1 || ch == 10) {
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_ivec(buf);
}
fn read_c_str() -> str {
let u8[] buf = ~[];
auto go_on = true;
while (go_on) {
auto ch = rdr.read_byte();
if (ch < 1) {
go_on = false;
} else { buf += ~[ch as u8]; }
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_ivec(buf);
}
// FIXME deal with eof?
fn read_le_uint(uint size) -> uint {
auto val = 0u;
auto pos = 0u;
while (size > 0u) {
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(uint size) -> int {
auto val = 0u;
auto pos = 0u;
while (size > 0u) {
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;
@@ -157,21 +152,21 @@ obj new_reader(buf_reader rdr) {
}
// FIXME deal with eof?
fn read_be_uint(uint sz) -> uint {
auto val = 0u;
fn read_be_uint(sz: uint) -> uint {
let val = 0u;
while (sz > 0u) {
while sz > 0u {
sz -= 1u;
val += (rdr.read_byte() as uint) << sz * 8u;
}
ret val;
}
fn read_whole_stream() -> u8[] {
let u8[] buf = ~[];
while (!rdr.eof()) { buf += rdr.read(2048u); }
let buf: u8[] = ~[];
while !rdr.eof() { buf += rdr.read(2048u); }
ret buf;
}
fn seek(int offset, seek_style whence) { ret rdr.seek(offset, whence); }
fn seek(offset: int, whence: seek_style) { ret rdr.seek(offset, whence); }
fn tell() -> uint { ret rdr.tell(); }
}
@@ -179,52 +174,52 @@ fn stdin() -> reader {
ret new_reader(FILE_buf_reader(rustrt::rust_get_stdin(), false));
}
fn file_reader(str path) -> reader {
auto f = os::libc::fopen(str::buf(path), str::buf("r"));
if (f as uint == 0u) { log_err "error opening " + path; fail; }
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, true));
}
// FIXME: Remove me once objects are exported.
fn new_reader_(buf_reader bufr) -> reader { ret new_reader(bufr); }
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 = @rec(u8[] buf, mutable uint pos);
type byte_buf = @{buf: u8[], mutable pos: uint};
obj byte_buf_reader(byte_buf bbuf) {
fn read(uint len) -> u8[] {
auto rest = ivec::len[u8](bbuf.buf) - bbuf.pos;
auto to_read = len;
if (rest < to_read) { to_read = rest; }
auto range = ivec::slice[u8](bbuf.buf, bbuf.pos, bbuf.pos + to_read);
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; }
auto b = bbuf.buf.(bbuf.pos);
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(int byte) { log_err "TODO: unread_byte"; fail; }
fn unread_byte(byte: int) { log_err "TODO: unread_byte"; fail; }
fn eof() -> bool { ret bbuf.pos == ivec::len[u8](bbuf.buf); }
fn seek(int offset, seek_style whence) {
auto pos = bbuf.pos;
auto len = 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(&u8[] buf) -> buf_reader {
ret byte_buf_reader(@rec(buf=buf, mutable pos=0u));
fn new_byte_buf_reader(buf: &u8[]) -> buf_reader {
ret byte_buf_reader(@{buf: buf, mutable pos: 0u});
}
fn string_reader(&str s) -> reader {
fn string_reader(s: &str) -> reader {
ret new_reader(new_byte_buf_reader(str::bytes_ivec(s)));
}
@@ -233,40 +228,41 @@ fn string_reader(&str s) -> reader {
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[]) ;
// FIXME: Seekable really should be orthogonal. We will need
// inheritance.
fn seek(int, seek_style) ;
fn tell() -> uint ; // FIXME: eventually u64
fn seek(int, seek_style) ;
fn tell() -> uint ;
};
obj FILE_writer(os::libc::FILE f, bool must_close) {
fn write(&u8[] v) {
auto len = ivec::len[u8](v);
auto vbuf = ivec::to_ptr[u8](v);
auto nout = os::libc_ivec::fwrite(vbuf, len, 1u, f);
if (nout < 1u) { log_err "error dumping buffer"; }
obj FILE_writer(f: os::libc::FILE, must_close: bool) {
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(int offset, seek_style whence) {
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;
}drop { if (must_close) { os::libc::fclose(f); } }
}drop { if must_close { os::libc::fclose(f); } }
}
obj fd_buf_writer(int fd, bool must_close) {
fn write(&u8[] v) {
auto len = ivec::len[u8](v);
auto count = 0u;
auto vbuf;
while (count < len) {
obj fd_buf_writer(fd: int, must_close: bool) {
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);
auto nout = os::libc_ivec::write(fd, vbuf, len);
if (nout < 0) {
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;
@@ -274,32 +270,32 @@ obj fd_buf_writer(int fd, bool must_close) {
count += nout as uint;
}
}
fn seek(int offset, seek_style whence) {
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;
}drop { if (must_close) { os::libc::close(fd); } }
}drop { if must_close { os::libc::close(fd); } }
}
fn file_buf_writer(str path, &fileflag[] flags) -> buf_writer {
let int fflags =
fn file_buf_writer(path: str, flags: &fileflag[]) -> buf_writer {
let fflags: int =
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(); }
case (none) { }
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. { }
}
}
auto fd =
let fd =
os::libc::open(str::buf(path), fflags,
os::libc_constants::S_IRUSR() |
os::libc_constants::S_IWUSR());
if (fd < 0) {
if fd < 0 {
log_err "error opening file for writing";
log_err sys::rustrt::last_os_error();
fail;
@@ -308,12 +304,12 @@ fn file_buf_writer(str path, &fileflag[] flags) -> buf_writer {
}
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 ;
// write_str will continue to do utf-8 output only. an alternative
// function will be provided for general encoded string output
fn write_str(str) ;
fn write_str(str) ;
fn write_line(str) ;
fn write_char(char) ;
fn write_int(int) ;
@@ -324,60 +320,60 @@ type writer =
fn write_be_uint(uint, uint) ;
};
fn uint_to_le_bytes(uint n, uint size) -> u8[] {
let u8[] bytes = ~[];
while (size > 0u) { bytes += ~[n & 255u as u8]; n >>= 8u; size -= 1u; }
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(uint n, uint size) -> u8[] {
let u8[] bytes = ~[];
auto i = size - 1u as int;
while (i >= 0) { bytes += ~[n >> (i * 8 as uint) & 255u as u8]; i -= 1; }
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(buf_writer out) {
obj new_writer(out: buf_writer) {
fn get_buf_writer() -> buf_writer { ret out; }
fn write_str(str s) { out.write(str::bytes_ivec(s)); }
fn write_line(str s) {
fn write_str(s: str) { out.write(str::bytes_ivec(s)); }
fn write_line(s: str) {
out.write(str::bytes_ivec(s));
out.write(str::bytes_ivec("\n"));
}
fn write_char(char ch) {
fn write_char(ch: char) {
// FIXME needlessly consy
out.write(str::bytes_ivec(str::from_char(ch)));
}
fn write_int(int n) { out.write(str::bytes_ivec(int::to_str(n, 10u))); }
fn write_uint(uint n) {
fn write_int(n: int) { out.write(str::bytes_ivec(int::to_str(n, 10u))); }
fn write_uint(n: uint) {
out.write(str::bytes_ivec(uint::to_str(n, 10u)));
}
fn write_bytes(&u8[] bytes) { out.write(bytes); }
fn write_le_uint(uint n, uint size) {
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(int n, uint size) {
fn write_le_int(n: int, size: uint) {
out.write(uint_to_le_bytes(n as uint, size));
}
fn write_be_uint(uint n, 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_(buf_writer out) -> writer { ret new_writer(out); }
fn new_writer_(out: buf_writer) -> writer { ret new_writer(out); }
fn file_writer(str path, &fileflag[] flags) -> writer {
fn file_writer(path: str, flags: &fileflag[]) -> writer {
ret new_writer(file_buf_writer(path, flags));
}
// FIXME: fileflags
fn buffered_file_buf_writer(str path) -> buf_writer {
auto f = os::libc::fopen(str::buf(path), str::buf("w"));
if (f as uint == 0u) { log_err "error opening " + path; fail; }
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, true);
}
@@ -391,33 +387,33 @@ type str_writer =
fn get_str() -> str ;
};
type mutable_byte_buf = @rec(mutable u8[mutable] buf, mutable uint pos);
type mutable_byte_buf = @{mutable buf: u8[mutable ], mutable pos: uint};
obj byte_buf_writer(mutable_byte_buf buf) {
fn write(&u8[] v) {
obj byte_buf_writer(buf: mutable_byte_buf) {
fn write(v: &u8[]) {
// Fast path.
if (buf.pos == ivec::len(buf.buf)) {
for (u8 b in v) { buf.buf += ~[mutable b]; }
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.
auto vlen = ivec::len[u8](v);
auto vpos = 0u;
while (vpos < vlen) {
auto b = v.(vpos);
if (buf.pos == ivec::len(buf.buf)) {
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(int offset, seek_style whence) {
auto pos = buf.pos;
auto len = ivec::len(buf.buf);
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; }
@@ -426,10 +422,10 @@ obj byte_buf_writer(mutable_byte_buf buf) {
fn string_writer() -> str_writer {
// FIXME: yikes, this is bad. Needs fixing of mutable syntax.
let u8[mutable] b = ~[mutable 0u8];
let b: u8[mutable ] = ~[mutable 0u8];
ivec::pop(b);
let mutable_byte_buf buf = @rec(mutable buf=b, mutable pos=0u);
obj str_writer_wrap(writer wr, mutable_byte_buf buf) {
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_ivec(buf.buf); }
}
@@ -438,15 +434,16 @@ fn string_writer() -> str_writer {
// Utility functions
fn seek_in_buf(int offset, uint pos, uint len, seek_style whence) -> uint {
auto bpos = pos as int;
auto blen = len as int;
alt (whence) {
case (seek_set) { bpos = offset; }
case (seek_cur) { bpos += offset; }
case (seek_end) { bpos = blen + offset; }
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; }
if bpos < 0 { bpos = 0; } else if (bpos > blen) { bpos = blen; }
ret bpos as uint;
}
//