From 11258310e2b67f734d4d520e6f995342892ecc3a Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Tue, 14 Aug 2012 13:38:35 -0700 Subject: [PATCH] Convert more core types to camel case --- src/cargo/cargo.rs | 2 +- src/compiletest/procsrv.rs | 2 +- src/compiletest/runtest.rs | 6 +- src/etc/combine-tests.py | 2 +- src/fuzzer/fuzzer.rs | 8 +- src/libcore/core.rc | 6 + src/libcore/core.rs | 4 +- src/libcore/hash.rs | 12 +- src/libcore/io.rs | 224 +++++++++--------- src/libcore/libc.rs | 2 + src/libcore/os.rs | 102 ++++---- src/libcore/path.rs | 32 +-- src/libcore/rand.rs | 37 +-- src/libcore/run.rs | 50 ++-- src/libcore/str.rs | 2 +- src/libstd/base64.rs | 2 +- src/libstd/ebml.rs | 12 +- src/libstd/json.rs | 8 +- src/libstd/map.rs | 4 +- src/libstd/net_tcp.rs | 22 +- src/libstd/net_url.rs | 2 +- src/libstd/prettyprint.rs | 6 +- src/libstd/term.rs | 10 +- src/libstd/test.rs | 18 +- src/libstd/time.rs | 2 +- src/libsyntax/diagnostic.rs | 4 +- src/libsyntax/ext/log_syntax.rs | 2 +- src/libsyntax/ext/source_util.rs | 2 +- src/libsyntax/parse/comments.rs | 2 +- src/libsyntax/print/pp.rs | 6 +- src/libsyntax/print/pprust.rs | 8 +- src/rustc/back/link.rs | 2 +- src/rustc/back/rpath.rs | 28 +-- src/rustc/driver/driver.rs | 4 +- src/rustc/metadata/decoder.rs | 12 +- src/rustc/metadata/encoder.rs | 8 +- src/rustc/metadata/filesearch.rs | 50 ++-- src/rustc/metadata/loader.rs | 4 +- src/rustc/metadata/tyencode.rs | 28 +-- src/rustc/middle/lint.rs | 2 +- src/rustc/middle/liveness.rs | 4 +- src/rustdoc/markdown_writer.rs | 6 +- src/test/bench/core-std.rs | 2 +- src/test/bench/core-vec-append.rs | 2 +- src/test/bench/graph500-bfs.rs | 4 +- src/test/bench/msgsend-pipes-shared.rs | 4 +- src/test/bench/msgsend-pipes.rs | 4 +- src/test/bench/msgsend.rs | 4 +- src/test/bench/shootout-fasta.rs | 8 +- src/test/bench/shootout-mandelbrot.rs | 14 +- src/test/bench/shootout-pfib.rs | 2 +- src/test/bench/std-smallintmap.rs | 2 +- src/test/bench/sudoku.rs | 6 +- .../bench/task-perf-word-count-generic.rs | 8 +- src/test/run-fail/issue-2156.rs | 2 +- src/test/run-pass-fulldeps/qquote.rs | 2 +- src/test/run-pass/auto_serialize.rs | 6 +- src/test/run-pass/issue-2804.rs | 2 +- src/test/run-pass/issue-2904.rs | 4 +- 59 files changed, 419 insertions(+), 406 deletions(-) diff --git a/src/cargo/cargo.rs b/src/cargo/cargo.rs index 2f162db325c..115ae566c24 100644 --- a/src/cargo/cargo.rs +++ b/src/cargo/cargo.rs @@ -8,7 +8,7 @@ import rustc::metadata::filesearch::{get_cargo_root, get_cargo_root_nearest, import syntax::diagnostic; import result::{ok, err}; -import io::writer_util; +import io::WriterUtil; import std::{map, json, tempfile, term, sort, getopts}; import map::hashmap; import to_str::to_str; diff --git a/src/compiletest/procsrv.rs b/src/compiletest/procsrv.rs index 84165c857f0..d5cddf0a4e0 100644 --- a/src/compiletest/procsrv.rs +++ b/src/compiletest/procsrv.rs @@ -1,5 +1,5 @@ import run::spawn_process; -import io::writer_util; +import io::WriterUtil; import libc::{c_int, pid_t}; import pipes::chan; diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs index 7a2d3456ed6..a6800053966 100644 --- a/src/compiletest/runtest.rs +++ b/src/compiletest/runtest.rs @@ -1,4 +1,4 @@ -import io::writer_util; +import io::WriterUtil; import common::mode_run_pass; import common::mode_run_fail; @@ -339,7 +339,7 @@ fn compose_and_run_compiler( config.compile_lib_path, input) } -fn ensure_dir(path: path) { +fn ensure_dir(path: Path) { if os::path_is_dir(path) { return; } if !os::make_dir(path, 0x1c0i32) { fail fmt!{"can't make dir %s", path}; @@ -455,7 +455,7 @@ fn dump_output_file(config: config, testfile: ~str, out: ~str, extension: ~str) { let outfile = make_out_name(config, testfile, extension); let writer = result::get( - io::file_writer(outfile, ~[io::create, io::truncate])); + io::file_writer(outfile, ~[io::Create, io::Truncate])); writer.write_str(out); } diff --git a/src/etc/combine-tests.py b/src/etc/combine-tests.py index 38c69bf6af0..028fc4732e0 100755 --- a/src/etc/combine-tests.py +++ b/src/etc/combine-tests.py @@ -54,7 +54,7 @@ d.write("// AUTO-GENERATED FILE: DO NOT EDIT\n") d.write("use std;\n") d.write("use run_pass_stage2;\n") d.write("import run_pass_stage2::*;\n") -d.write("import io::writer_util;\n"); +d.write("import io::WriterUtil;\n"); d.write("fn main() {\n"); d.write(" let out = io::stdout();\n"); i = 0 diff --git a/src/fuzzer/fuzzer.rs b/src/fuzzer/fuzzer.rs index 956e48396fc..352831c86e6 100644 --- a/src/fuzzer/fuzzer.rs +++ b/src/fuzzer/fuzzer.rs @@ -1,4 +1,4 @@ -import io::writer_util; +import io::WriterUtil; import syntax::{ast, ast_util, fold, visit, codemap}; import syntax::parse; @@ -10,7 +10,7 @@ type context = { mode: test_mode }; // + rng fn write_file(filename: ~str, content: ~str) { result::get( - io::file_writer(filename, ~[io::create, io::truncate])) + io::file_writer(filename, ~[io::Create, io::Truncate])) .write_str(content); } @@ -216,9 +216,9 @@ fn under(n: uint, it: fn(uint)) { while i < n { it(i); i += 1u; } } -fn devnull() -> io::writer { io::mem_buffer_writer(io::mem_buffer()) } +fn devnull() -> io::Writer { io::mem_buffer_writer(io::mem_buffer()) } -fn as_str(f: fn@(io::writer)) -> ~str { +fn as_str(f: fn@(io::Writer)) -> ~str { let buf = io::mem_buffer(); f(io::mem_buffer_writer(buf)); io::mem_buffer_str(buf) diff --git a/src/libcore/core.rc b/src/libcore/core.rc index 96324c1b297..f5c9039ad25 100644 --- a/src/libcore/core.rc +++ b/src/libcore/core.rc @@ -54,6 +54,7 @@ export send_map; export hash; export cmp; export num; +export path; // NDM seems to be necessary for resolve to work export option_iter; @@ -214,11 +215,16 @@ mod pipes; // Runtime and language-primitive support +#[warn(non_camel_case_types)] mod io; mod libc; +#[warn(non_camel_case_types)] mod os; +#[warn(non_camel_case_types)] mod path; +#[warn(non_camel_case_types)] mod rand; +#[warn(non_camel_case_types)] mod run; #[warn(non_camel_case_types)] mod sys; diff --git a/src/libcore/core.rs b/src/libcore/core.rs index 2f5e2cf6e0b..f6a721d102a 100644 --- a/src/libcore/core.rs +++ b/src/libcore/core.rs @@ -4,7 +4,7 @@ import option::{some, none}; import option = option::option; -import path = path::path; +import Path = path::Path; import tuple::{TupleOps, ExtendedTupleOps}; import str::{str_slice, unique_str}; import vec::{const_vector, copyable_vector, immutable_vector}; @@ -14,7 +14,7 @@ import num::Num; import ptr::ptr; import to_str::ToStr; -export path, option, some, none, unreachable; +export Path, option, some, none, unreachable; export extensions; // The following exports are the extension impls for numeric types export Num, times, timesi; diff --git a/src/libcore/hash.rs b/src/libcore/hash.rs index f653ce1fb8e..2237dad299f 100644 --- a/src/libcore/hash.rs +++ b/src/libcore/hash.rs @@ -13,8 +13,8 @@ * CPRNG like rand::rng. */ -import io::writer; -import io::writer_util; +import io::Writer; +import io::WriterUtil; export Streaming, State; export default_state; @@ -126,7 +126,7 @@ fn SipState(key0: u64, key1: u64) -> SipState { } -impl &SipState : io::writer { +impl &SipState : io::Writer { // Methods for io::writer fn write(msg: &[const u8]) { @@ -209,7 +209,7 @@ impl &SipState : io::writer { self.ntail = left; } - fn seek(_x: int, _s: io::seek_style) { + fn seek(_x: int, _s: io::SeekStyle) { fail; } fn tell() -> uint { @@ -218,8 +218,8 @@ impl &SipState : io::writer { fn flush() -> int { 0 } - fn get_type() -> io::writer_type { - io::file + fn get_type() -> io::WriterType { + io::File } } diff --git a/src/libcore/io.rs b/src/libcore/io.rs index 571fc8587ef..c01672b5c73 100644 --- a/src/libcore/io.rs +++ b/src/libcore/io.rs @@ -11,6 +11,7 @@ import libc::{c_int, c_long, c_uint, c_void, size_t, ssize_t}; import libc::consts::os::posix88::*; import libc::consts::os::extra::*; +#[allow(non_camel_case_types)] // not sure what to do about this type fd_t = c_int; #[abi = "cdecl"] @@ -24,11 +25,11 @@ extern mod rustrt { // FIXME (#2004): This is all buffered. We might need an unbuffered variant // as well -enum seek_style { seek_set, seek_end, seek_cur, } +enum SeekStyle { SeekSet, SeekEnd, SeekCur, } // The raw underlying reader trait. All readers must implement this. -trait reader { +trait Reader { // FIXME (#2004): Seekable really should be orthogonal. // FIXME (#2982): This should probably return an error. @@ -36,13 +37,13 @@ trait reader { fn read_byte() -> int; fn unread_byte(int); fn eof() -> bool; - fn seek(int, seek_style); + fn seek(int, SeekStyle); fn tell() -> uint; } // Generic utility functions defined on readers -impl reader { +impl Reader { fn read_bytes(len: uint) -> ~[u8] { let mut buf = ~[mut]; vec::reserve(buf, len); @@ -195,15 +196,15 @@ impl reader { // Reader implementations -fn convert_whence(whence: seek_style) -> i32 { +fn convert_whence(whence: SeekStyle) -> i32 { return match whence { - seek_set => 0i32, - seek_cur => 1i32, - seek_end => 2i32 + SeekSet => 0i32, + SeekCur => 1i32, + SeekEnd => 2i32 }; } -impl *libc::FILE: reader { +impl *libc::FILE: Reader { fn read(buf: &[mut u8], len: uint) -> uint { do vec::as_buf(buf) |buf_p, buf_len| { assert buf_len <= len; @@ -217,7 +218,7 @@ impl *libc::FILE: reader { fn read_byte() -> int { return libc::fgetc(self) as int; } fn unread_byte(byte: int) { libc::ungetc(byte as c_int, self); } fn eof() -> bool { return libc::feof(self) != 0 as c_int; } - fn seek(offset: int, whence: seek_style) { + fn seek(offset: int, whence: SeekStyle) { assert libc::fseek(self, offset as c_long, convert_whence(whence)) == 0 as c_int; } @@ -227,26 +228,26 @@ impl *libc::FILE: reader { // A forwarding impl of reader that also holds on to a resource for the // duration of its lifetime. // FIXME there really should be a better way to do this // #2004 -impl {base: T, cleanup: C}: reader { +impl {base: T, cleanup: C}: Reader { fn read(buf: &[mut u8], len: uint) -> uint { self.base.read(buf, len) } fn read_byte() -> int { self.base.read_byte() } fn unread_byte(byte: int) { self.base.unread_byte(byte); } fn eof() -> bool { self.base.eof() } - fn seek(off: int, whence: seek_style) { self.base.seek(off, whence) } + fn seek(off: int, whence: SeekStyle) { self.base.seek(off, whence) } fn tell() -> uint { self.base.tell() } } -class FILE_res { +class FILERes { let f: *libc::FILE; new(f: *libc::FILE) { self.f = f; } drop { libc::fclose(self.f); } } -fn FILE_reader(f: *libc::FILE, cleanup: bool) -> reader { +fn FILE_reader(f: *libc::FILE, cleanup: bool) -> Reader { if cleanup { - {base: f, cleanup: FILE_res(f)} as reader + {base: f, cleanup: FILERes(f)} as Reader } else { - f as reader + f as Reader } } @@ -254,9 +255,9 @@ fn FILE_reader(f: *libc::FILE, cleanup: bool) -> reader { // top-level functions that take a reader, or a set of default methods on // reader (which can then be called reader) -fn stdin() -> reader { rustrt::rust_get_stdin() as reader } +fn stdin() -> Reader { rustrt::rust_get_stdin() as Reader } -fn file_reader(path: ~str) -> result { +fn file_reader(path: ~str) -> result { let f = os::as_c_charp(path, |pathbuf| { os::as_c_charp(~"r", |modebuf| libc::fopen(pathbuf, modebuf) @@ -271,9 +272,9 @@ fn file_reader(path: ~str) -> result { // Byte buffer readers -type byte_buf = {buf: ~[const u8], mut pos: uint, len: uint}; +type ByteBuf = {buf: ~[const u8], mut pos: uint, len: uint}; -impl byte_buf: reader { +impl ByteBuf: Reader { fn read(buf: &[mut u8], len: uint) -> uint { let count = uint::min(len, self.len - self.pos); @@ -293,65 +294,65 @@ impl byte_buf: reader { // FIXME (#2738): implement this fn unread_byte(_byte: int) { error!{"Unimplemented: unread_byte"}; fail; } fn eof() -> bool { self.pos == self.len } - fn seek(offset: int, whence: seek_style) { + fn seek(offset: int, whence: SeekStyle) { let pos = self.pos; self.pos = seek_in_buf(offset, pos, self.len, whence); } fn tell() -> uint { self.pos } } -fn bytes_reader(bytes: ~[u8]) -> reader { +fn bytes_reader(bytes: ~[u8]) -> Reader { bytes_reader_between(bytes, 0u, vec::len(bytes)) } -fn bytes_reader_between(bytes: ~[u8], start: uint, end: uint) -> reader { - {buf: bytes, mut pos: start, len: end} as reader +fn bytes_reader_between(bytes: ~[u8], start: uint, end: uint) -> Reader { + {buf: bytes, mut pos: start, len: end} as Reader } -fn with_bytes_reader(bytes: ~[u8], f: fn(reader) -> t) -> t { +fn with_bytes_reader(bytes: ~[u8], f: fn(Reader) -> t) -> t { f(bytes_reader(bytes)) } fn with_bytes_reader_between(bytes: ~[u8], start: uint, end: uint, - f: fn(reader) -> t) -> t { + f: fn(Reader) -> t) -> t { f(bytes_reader_between(bytes, start, end)) } -fn str_reader(s: ~str) -> reader { +fn str_reader(s: ~str) -> Reader { bytes_reader(str::bytes(s)) } -fn with_str_reader(s: ~str, f: fn(reader) -> T) -> T { +fn with_str_reader(s: ~str, f: fn(Reader) -> T) -> T { do str::as_bytes(s) |bytes| { with_bytes_reader_between(bytes, 0u, str::len(s), f) } } // Writing -enum fileflag { append, create, truncate, no_flag, } +enum FileFlag { Append, Create, Truncate, NoFlag, } // What type of writer are we? -enum writer_type { screen, file } +enum WriterType { Screen, File } // FIXME (#2004): Seekable really should be orthogonal. // FIXME (#2004): eventually u64 -trait writer { +trait Writer { fn write(v: &[const u8]); - fn seek(int, seek_style); + fn seek(int, SeekStyle); fn tell() -> uint; fn flush() -> int; - fn get_type() -> writer_type; + fn get_type() -> WriterType; } -impl {base: T, cleanup: C}: writer { +impl {base: T, cleanup: C}: Writer { fn write(bs: &[const u8]) { self.base.write(bs); } - fn seek(off: int, style: seek_style) { self.base.seek(off, style); } + fn seek(off: int, style: SeekStyle) { self.base.seek(off, style); } fn tell() -> uint { self.base.tell() } fn flush() -> int { self.base.flush() } - fn get_type() -> writer_type { file } + fn get_type() -> WriterType { File } } -impl *libc::FILE: writer { +impl *libc::FILE: Writer { fn write(v: &[const u8]) { do vec::as_const_buf(v) |vbuf, len| { let nout = libc::fwrite(vbuf as *c_void, len as size_t, @@ -363,28 +364,28 @@ impl *libc::FILE: writer { } } } - fn seek(offset: int, whence: seek_style) { + fn seek(offset: int, whence: SeekStyle) { assert libc::fseek(self, offset as c_long, convert_whence(whence)) == 0 as c_int; } fn tell() -> uint { libc::ftell(self) as uint } fn flush() -> int { libc::fflush(self) as int } - fn get_type() -> writer_type { + fn get_type() -> WriterType { let fd = libc::fileno(self); - if libc::isatty(fd) == 0 { file } - else { screen } + if libc::isatty(fd) == 0 { File } + else { Screen } } } -fn FILE_writer(f: *libc::FILE, cleanup: bool) -> writer { +fn FILE_writer(f: *libc::FILE, cleanup: bool) -> Writer { if cleanup { - {base: f, cleanup: FILE_res(f)} as writer + {base: f, cleanup: FILERes(f)} as Writer } else { - f as writer + f as Writer } } -impl fd_t: writer { +impl fd_t: Writer { fn write(v: &[const u8]) { let mut count = 0u; do vec::as_const_buf(v) |vbuf, len| { @@ -400,7 +401,7 @@ impl fd_t: writer { } } } - fn seek(_offset: int, _whence: seek_style) { + fn seek(_offset: int, _whence: SeekStyle) { error!{"need 64-bit foreign calls for seek, sorry"}; fail; } @@ -409,28 +410,28 @@ impl fd_t: writer { fail; } fn flush() -> int { 0 } - fn get_type() -> writer_type { - if libc::isatty(self) == 0 { file } else { screen } + fn get_type() -> WriterType { + if libc::isatty(self) == 0 { File } else { Screen } } } -class fd_res { +class FdRes { let fd: fd_t; new(fd: fd_t) { self.fd = fd; } drop { libc::close(self.fd); } } -fn fd_writer(fd: fd_t, cleanup: bool) -> writer { +fn fd_writer(fd: fd_t, cleanup: bool) -> Writer { if cleanup { - {base: fd, cleanup: fd_res(fd)} as writer + {base: fd, cleanup: FdRes(fd)} as Writer } else { - fd as writer + fd as Writer } } -fn mk_file_writer(path: ~str, flags: ~[fileflag]) - -> result { +fn mk_file_writer(path: ~str, flags: ~[FileFlag]) + -> result { #[cfg(windows)] fn wb() -> c_int { (O_WRONLY | O_BINARY) as c_int } @@ -441,10 +442,10 @@ fn mk_file_writer(path: ~str, flags: ~[fileflag]) let mut fflags: c_int = wb(); for vec::each(flags) |f| { match f { - append => fflags |= O_APPEND as c_int, - create => fflags |= O_CREAT as c_int, - truncate => fflags |= O_TRUNC as c_int, - no_flag => () + Append => fflags |= O_APPEND as c_int, + Create => fflags |= O_CREAT as c_int, + Truncate => fflags |= O_TRUNC as c_int, + NoFlag => () } } let fd = do os::as_c_charp(path) |pathbuf| { @@ -535,7 +536,7 @@ fn u64_from_be_bytes(data: ~[u8], start: uint, size: uint) -> u64 { // FIXME: #3048 combine trait+impl (or just move these to // default methods on writer) -trait writer_util { +trait WriterUtil { fn write_char(ch: char); fn write_str(s: &str); fn write_line(s: &str); @@ -560,7 +561,7 @@ trait writer_util { fn write_u8(n: u8); } -impl T : writer_util { +impl T : WriterUtil { fn write_char(ch: char) { if ch as uint < 128u { self.write(&[ch as u8]); @@ -631,13 +632,13 @@ impl T : writer_util { fn write_u8(n: u8) { self.write(&[n]) } } -fn file_writer(path: ~str, flags: ~[fileflag]) -> result { +fn file_writer(path: ~str, flags: ~[FileFlag]) -> result { result::chain(mk_file_writer(path, flags), |w| result::ok(w)) } // FIXME: fileflags // #2004 -fn buffered_file_writer(path: ~str) -> result { +fn buffered_file_writer(path: ~str) -> result { let f = do os::as_c_charp(path) |pathbuf| { do os::as_c_charp(~"w") |modebuf| { libc::fopen(pathbuf, modebuf) @@ -650,15 +651,15 @@ fn buffered_file_writer(path: ~str) -> result { // FIXME (#2004) it would be great if this could be a const // FIXME (#2004) why are these different from the way stdin() is // implemented? -fn stdout() -> writer { fd_writer(libc::STDOUT_FILENO as c_int, false) } -fn stderr() -> writer { fd_writer(libc::STDERR_FILENO as c_int, false) } +fn stdout() -> Writer { fd_writer(libc::STDOUT_FILENO as c_int, false) } +fn stderr() -> Writer { fd_writer(libc::STDERR_FILENO as c_int, false) } fn print(s: &str) { stdout().write_str(s); } fn println(s: &str) { stdout().write_line(s); } -type mem_buffer = @{buf: dvec, mut pos: uint}; +type MemBuffer = @{buf: dvec, mut pos: uint}; -impl mem_buffer: writer { +impl MemBuffer: Writer { fn write(v: &[const u8]) { // Fast path. let vlen = vec::len(v); @@ -679,33 +680,33 @@ impl mem_buffer: writer { self.buf.push_slice(v, vpos, vlen); self.pos += vlen; } - fn seek(offset: int, whence: seek_style) { + fn seek(offset: int, whence: SeekStyle) { let pos = self.pos; let len = self.buf.len(); self.pos = seek_in_buf(offset, pos, len, whence); } fn tell() -> uint { self.pos } fn flush() -> int { 0 } - fn get_type() -> writer_type { file } + fn get_type() -> WriterType { File } } -fn mem_buffer() -> mem_buffer { +fn mem_buffer() -> MemBuffer { @{buf: dvec(), mut pos: 0u} } -fn mem_buffer_writer(b: mem_buffer) -> writer { b as writer } -fn mem_buffer_buf(b: mem_buffer) -> ~[u8] { b.buf.get() } -fn mem_buffer_str(b: mem_buffer) -> ~str { +fn mem_buffer_writer(b: MemBuffer) -> Writer { b as Writer } +fn mem_buffer_buf(b: MemBuffer) -> ~[u8] { b.buf.get() } +fn mem_buffer_str(b: MemBuffer) -> ~str { str::from_bytes(b.buf.get()) } -fn with_str_writer(f: fn(writer)) -> ~str { +fn with_str_writer(f: fn(Writer)) -> ~str { let buf = mem_buffer(); let wr = mem_buffer_writer(buf); f(wr); io::mem_buffer_str(buf) } -fn with_buf_writer(f: fn(writer)) -> ~[u8] { +fn with_buf_writer(f: fn(Writer)) -> ~[u8] { let buf = mem_buffer(); let wr = mem_buffer_writer(buf); f(wr); @@ -713,14 +714,14 @@ fn with_buf_writer(f: fn(writer)) -> ~[u8] { } // Utility functions -fn seek_in_buf(offset: int, pos: uint, len: uint, whence: seek_style) -> +fn seek_in_buf(offset: int, pos: uint, len: uint, whence: SeekStyle) -> uint { let mut bpos = pos as int; let blen = len as int; match whence { - seek_set => bpos = offset, - seek_cur => bpos += offset, - seek_end => bpos = blen + offset + SeekSet => bpos = offset, + SeekCur => bpos += offset, + SeekEnd => bpos = blen + offset } if bpos < 0 { bpos = 0; } else if bpos > blen { bpos = blen; } return bpos as uint; @@ -748,24 +749,24 @@ fn read_whole_file(file: ~str) -> result<~[u8], ~str> { mod fsync { - enum level { + enum Level { // whatever fsync does on that platform - fsync, + FSync, // fdatasync on linux, similiar or more on other platforms - fdatasync, + FDataSync, // full fsync // // You must additionally sync the parent directory as well! - fullfsync, + FullFSync, } // Artifacts that need to fsync on destruction - class res { - let arg: arg; - new(-arg: arg) { self.arg <- arg; } + class Res { + let arg: Arg; + new(-arg: Arg) { self.arg <- arg; } drop { match self.arg.opt_level { option::none => (), @@ -777,44 +778,47 @@ mod fsync { } } - type arg = { + type Arg = { val: t, - opt_level: option, - fsync_fn: fn@(t, level) -> int + opt_level: option, + fsync_fn: fn@(t, Level) -> int }; // fsync file after executing blk // FIXME (#2004) find better way to create resources within lifetime of // outer res - fn FILE_res_sync(&&file: FILE_res, opt_level: option, - blk: fn(&&res<*libc::FILE>)) { - blk(res({ + fn FILE_res_sync(&&file: FILERes, opt_level: option, + blk: fn(&&Res<*libc::FILE>)) { + blk(Res({ val: file.f, opt_level: opt_level, - fsync_fn: fn@(&&file: *libc::FILE, l: level) -> int { + fsync_fn: fn@(&&file: *libc::FILE, l: Level) -> int { return os::fsync_fd(libc::fileno(file), l) as int; } })); } // fsync fd after executing blk - fn fd_res_sync(&&fd: fd_res, opt_level: option, - blk: fn(&&res)) { - blk(res({ + fn fd_res_sync(&&fd: FdRes, opt_level: option, + blk: fn(&&Res)) { + blk(Res({ val: fd.fd, opt_level: opt_level, - fsync_fn: fn@(&&fd: fd_t, l: level) -> int { + fsync_fn: fn@(&&fd: fd_t, l: Level) -> int { return os::fsync_fd(fd, l) as int; } })); } // Type of objects that may want to fsync - trait t { fn fsync(l: level) -> int; } + trait FSyncable { fn fsync(l: Level) -> int; } // Call o.fsync after executing blk - fn obj_sync(&&o: t, opt_level: option, blk: fn(&&res)) { - blk(res({ + fn obj_sync(&&o: FSyncable, opt_level: option, + blk: fn(&&Res)) { + blk(Res({ val: o, opt_level: opt_level, - fsync_fn: fn@(&&o: t, l: level) -> int { return o.fsync(l); } + fsync_fn: fn@(&&o: FSyncable, l: Level) -> int { + return o.fsync(l); + } })); } } @@ -830,12 +834,12 @@ mod tests { ~"A hoopy frood who really knows where his towel is."; log(debug, frood); { - let out: io::writer = + let out: io::Writer = result::get( - io::file_writer(tmpfile, ~[io::create, io::truncate])); + io::file_writer(tmpfile, ~[io::Create, io::Truncate])); out.write_str(frood); } - let inp: io::reader = result::get(io::file_reader(tmpfile)); + let inp: io::Reader = result::get(io::file_reader(tmpfile)); let frood2: ~str = inp.read_c_str(); log(debug, frood2); assert frood == frood2; @@ -843,7 +847,7 @@ mod tests { #[test] fn test_readchars_empty() { - let inp : io::reader = io::str_reader(~""); + let inp : io::Reader = io::str_reader(~""); let res : ~[char] = inp.read_chars(128u); assert(vec::len(res) == 0u); } @@ -858,7 +862,7 @@ mod tests { 29983, 38152, 30340, 27748, 21273, 20999, 32905, 27748]; fn check_read_ln(len : uint, s: ~str, ivals: ~[int]) { - let inp : io::reader = io::str_reader(s); + let inp : io::Reader = io::str_reader(s); let res : ~[char] = inp.read_chars(len); if (len <= vec::len(ivals)) { assert(vec::len(res) == len); @@ -877,14 +881,14 @@ mod tests { #[test] fn test_readchar() { - let inp : io::reader = io::str_reader(~"生"); + let inp : io::Reader = io::str_reader(~"生"); let res : char = inp.read_char(); assert(res as int == 29983); } #[test] fn test_readchar_empty() { - let inp : io::reader = io::str_reader(~""); + let inp : io::Reader = io::str_reader(~""); let res : char = inp.read_char(); assert(res as int == -1); } @@ -924,12 +928,12 @@ mod tests { let mbuf = mem_buffer(); mbuf.write(~[0u8, 1u8, 2u8, 3u8]); assert mem_buffer_buf(mbuf) == ~[0u8, 1u8, 2u8, 3u8]; - mbuf.seek(-2, seek_cur); + mbuf.seek(-2, SeekCur); mbuf.write(~[4u8, 5u8, 6u8, 7u8]); assert mem_buffer_buf(mbuf) == ~[0u8, 1u8, 4u8, 5u8, 6u8, 7u8]; - mbuf.seek(-2, seek_end); + mbuf.seek(-2, SeekEnd); mbuf.write(~[8u8]); - mbuf.seek(1, seek_set); + mbuf.seek(1, SeekSet); mbuf.write(~[9u8]); assert mem_buffer_buf(mbuf) == ~[0u8, 9u8, 4u8, 5u8, 8u8, 7u8]; } diff --git a/src/libcore/libc.rs b/src/libcore/libc.rs index fc87d64e786..09dd614525e 100644 --- a/src/libcore/libc.rs +++ b/src/libcore/libc.rs @@ -37,6 +37,8 @@ * dissolved. */ +#[allow(non_camel_case_types)]; + // Initial glob-exports mean that all the contents of all the modules // wind up exported, if you're interested in writing platform-specific code. diff --git a/src/libcore/os.rs b/src/libcore/os.rs index c080088674a..ec4485bb123 100644 --- a/src/libcore/os.rs +++ b/src/libcore/os.rs @@ -134,34 +134,34 @@ mod global_env { fn rust_global_env_chan_ptr() -> *libc::uintptr_t; } - enum msg { - msg_getenv(~str, comm::chan>), - msg_setenv(~str, ~str, comm::chan<()>), - msg_env(comm::chan<~[(~str,~str)]>) + enum Msg { + MsgGetEnv(~str, comm::chan>), + MsgSetEnv(~str, ~str, comm::chan<()>), + MsgEnv(comm::chan<~[(~str,~str)]>) } fn getenv(n: ~str) -> option<~str> { let env_ch = get_global_env_chan(); let po = comm::port(); - comm::send(env_ch, msg_getenv(n, comm::chan(po))); + comm::send(env_ch, MsgGetEnv(n, comm::chan(po))); comm::recv(po) } fn setenv(n: ~str, v: ~str) { let env_ch = get_global_env_chan(); let po = comm::port(); - comm::send(env_ch, msg_setenv(n, v, comm::chan(po))); + comm::send(env_ch, MsgSetEnv(n, v, comm::chan(po))); comm::recv(po) } fn env() -> ~[(~str,~str)] { let env_ch = get_global_env_chan(); let po = comm::port(); - comm::send(env_ch, msg_env(comm::chan(po))); + comm::send(env_ch, MsgEnv(comm::chan(po))); comm::recv(po) } - fn get_global_env_chan() -> comm::chan { + fn get_global_env_chan() -> comm::chan { let global_ptr = rustrt::rust_global_env_chan_ptr(); unsafe { priv::chan_from_global_ptr(global_ptr, || { @@ -172,18 +172,18 @@ mod global_env { } } - fn global_env_task(msg_po: comm::port) { + fn global_env_task(msg_po: comm::port) { unsafe { do priv::weaken_task |weak_po| { loop { match comm::select2(msg_po, weak_po) { - either::left(msg_getenv(n, resp_ch)) => { + either::left(MsgGetEnv(n, resp_ch)) => { comm::send(resp_ch, impl::getenv(n)) } - either::left(msg_setenv(n, v, resp_ch)) => { + either::left(MsgSetEnv(n, v, resp_ch)) => { comm::send(resp_ch, impl::setenv(n, v)) } - either::left(msg_env(resp_ch)) => { + either::left(MsgEnv(resp_ch)) => { comm::send(resp_ch, impl::env()) } either::right(_) => break @@ -272,28 +272,28 @@ fn fdopen(fd: c_int) -> *FILE { // fsync related #[cfg(windows)] -fn fsync_fd(fd: c_int, _level: io::fsync::level) -> c_int { +fn fsync_fd(fd: c_int, _level: io::fsync::Level) -> c_int { import libc::funcs::extra::msvcrt::*; return commit(fd); } #[cfg(target_os = "linux")] -fn fsync_fd(fd: c_int, level: io::fsync::level) -> c_int { +fn fsync_fd(fd: c_int, level: io::fsync::Level) -> c_int { import libc::funcs::posix01::unistd::*; match level { - io::fsync::fsync - | io::fsync::fullfsync => return fsync(fd), - io::fsync::fdatasync => return fdatasync(fd) + io::fsync::FSync + | io::fsync::FullFSync => return fsync(fd), + io::fsync::FDataSync => return fdatasync(fd) } } #[cfg(target_os = "macos")] -fn fsync_fd(fd: c_int, level: io::fsync::level) -> c_int { +fn fsync_fd(fd: c_int, level: io::fsync::Level) -> c_int { import libc::consts::os::extra::*; import libc::funcs::posix88::fcntl::*; import libc::funcs::posix01::unistd::*; match level { - io::fsync::fsync => return fsync(fd), + io::fsync::FSync => return fsync(fd), _ => { // According to man fnctl, the ok retval is only specified to be !=-1 if (fcntl(F_FULLFSYNC as c_int, fd) == -1 as c_int) @@ -305,7 +305,7 @@ fn fsync_fd(fd: c_int, level: io::fsync::level) -> c_int { } #[cfg(target_os = "freebsd")] -fn fsync_fd(fd: c_int, _l: io::fsync::level) -> c_int { +fn fsync_fd(fd: c_int, _l: io::fsync::Level) -> c_int { import libc::funcs::posix01::unistd::*; return fsync(fd); } @@ -369,10 +369,10 @@ fn dll_filename(base: ~str) -> ~str { } -fn self_exe_path() -> option { +fn self_exe_path() -> option { #[cfg(target_os = "freebsd")] - fn load_self() -> option { + fn load_self() -> option { unsafe { import libc::funcs::bsd44::*; import libc::consts::os::extra::*; @@ -388,7 +388,7 @@ fn self_exe_path() -> option { } #[cfg(target_os = "linux")] - fn load_self() -> option { + fn load_self() -> option { import libc::funcs::posix01::unistd::readlink; do fill_charp_buf() |buf, sz| { do as_c_charp(~"/proc/self/exe") |proc_self_buf| { @@ -398,7 +398,7 @@ fn self_exe_path() -> option { } #[cfg(target_os = "macos")] - fn load_self() -> option { + fn load_self() -> option { // FIXME: remove imports when export globs work properly. #1238 import libc::funcs::extra::*; do fill_charp_buf() |buf, sz| { @@ -408,7 +408,7 @@ fn self_exe_path() -> option { } #[cfg(windows)] - fn load_self() -> option { + fn load_self() -> option { // FIXME: remove imports when export globs work properly. #1238 import libc::types::os::arch::extra::*; import libc::funcs::extra::kernel32::*; @@ -437,7 +437,7 @@ fn self_exe_path() -> option { * * Otherwise, homedir returns option::none. */ -fn homedir() -> option { +fn homedir() -> option { return match getenv(~"HOME") { some(p) => if !str::is_empty(p) { some(p) @@ -448,12 +448,12 @@ fn homedir() -> option { }; #[cfg(unix)] - fn secondary() -> option { + fn secondary() -> option { none } #[cfg(windows)] - fn secondary() -> option { + fn secondary() -> option { do option::chain(getenv(~"USERPROFILE")) |p| { if !str::is_empty(p) { some(p) @@ -465,11 +465,11 @@ fn homedir() -> option { } /// Recursively walk a directory structure -fn walk_dir(p: path, f: fn(path) -> bool) { +fn walk_dir(p: Path, f: fn(Path) -> bool) { walk_dir_(p, f); - fn walk_dir_(p: path, f: fn(path) -> bool) -> bool { + fn walk_dir_(p: Path, f: fn(Path) -> bool) -> bool { let mut keepgoing = true; do list_dir(p).each |q| { let path = path::connect(p, q); @@ -494,14 +494,14 @@ fn walk_dir(p: path, f: fn(path) -> bool) { } /// Indicates whether a path represents a directory -fn path_is_dir(p: path) -> bool { +fn path_is_dir(p: Path) -> bool { do str::as_c_str(p) |buf| { rustrt::rust_path_is_dir(buf) != 0 as c_int } } /// Indicates whether a path exists -fn path_exists(p: path) -> bool { +fn path_exists(p: Path) -> bool { do str::as_c_str(p) |buf| { rustrt::rust_path_exists(buf) != 0 as c_int } @@ -519,7 +519,7 @@ fn path_exists(p: path) -> bool { // NB: this is here rather than in path because it is a form of environment // querying; what it does depends on the process working directory, not just // the input paths. -fn make_absolute(p: path) -> path { +fn make_absolute(p: Path) -> Path { if path::path_is_absolute(p) { p } else { @@ -529,11 +529,11 @@ fn make_absolute(p: path) -> path { /// Creates a directory at the specified path -fn make_dir(p: path, mode: c_int) -> bool { +fn make_dir(p: Path, mode: c_int) -> bool { return mkdir(p, mode); #[cfg(windows)] - fn mkdir(p: path, _mode: c_int) -> bool { + fn mkdir(p: Path, _mode: c_int) -> bool { // FIXME: remove imports when export globs work properly. #1238 import libc::types::os::arch::extra::*; import libc::funcs::extra::kernel32::*; @@ -546,7 +546,7 @@ fn make_dir(p: path, mode: c_int) -> bool { } #[cfg(unix)] - fn mkdir(p: path, mode: c_int) -> bool { + fn mkdir(p: Path, mode: c_int) -> bool { do as_c_charp(p) |c| { libc::mkdir(c, mode as mode_t) == (0 as c_int) } @@ -554,7 +554,7 @@ fn make_dir(p: path, mode: c_int) -> bool { } /// Lists the contents of a directory -fn list_dir(p: path) -> ~[~str] { +fn list_dir(p: Path) -> ~[~str] { #[cfg(unix)] fn star(p: ~str) -> ~str { p } @@ -580,7 +580,7 @@ fn list_dir(p: path) -> ~[~str] { * * This version prepends each entry with the directory. */ -fn list_dir_path(p: path) -> ~[~str] { +fn list_dir_path(p: Path) -> ~[~str] { let mut p = p; let pl = str::len(p); if pl == 0u || (p[pl - 1u] as char != path::consts::path_sep @@ -591,11 +591,11 @@ fn list_dir_path(p: path) -> ~[~str] { } /// Removes a directory at the specified path -fn remove_dir(p: path) -> bool { +fn remove_dir(p: Path) -> bool { return rmdir(p); #[cfg(windows)] - fn rmdir(p: path) -> bool { + fn rmdir(p: Path) -> bool { // FIXME: remove imports when export globs work properly. #1238 import libc::funcs::extra::kernel32::*; import libc::types::os::arch::extra::*; @@ -606,18 +606,18 @@ fn remove_dir(p: path) -> bool { } #[cfg(unix)] - fn rmdir(p: path) -> bool { + fn rmdir(p: Path) -> bool { return do as_c_charp(p) |buf| { libc::rmdir(buf) == (0 as c_int) }; } } -fn change_dir(p: path) -> bool { +fn change_dir(p: Path) -> bool { return chdir(p); #[cfg(windows)] - fn chdir(p: path) -> bool { + fn chdir(p: Path) -> bool { // FIXME: remove imports when export globs work properly. #1238 import libc::funcs::extra::kernel32::*; import libc::types::os::arch::extra::*; @@ -628,7 +628,7 @@ fn change_dir(p: path) -> bool { } #[cfg(unix)] - fn chdir(p: path) -> bool { + fn chdir(p: Path) -> bool { return do as_c_charp(p) |buf| { libc::chdir(buf) == (0 as c_int) }; @@ -636,11 +636,11 @@ fn change_dir(p: path) -> bool { } /// Copies a file from one location to another -fn copy_file(from: path, to: path) -> bool { +fn copy_file(from: Path, to: Path) -> bool { return do_copy_file(from, to); #[cfg(windows)] - fn do_copy_file(from: path, to: path) -> bool { + fn do_copy_file(from: Path, to: Path) -> bool { // FIXME: remove imports when export globs work properly. #1238 import libc::funcs::extra::kernel32::*; import libc::types::os::arch::extra::*; @@ -653,7 +653,7 @@ fn copy_file(from: path, to: path) -> bool { } #[cfg(unix)] - fn do_copy_file(from: path, to: path) -> bool { + fn do_copy_file(from: Path, to: Path) -> bool { let istream = do as_c_charp(from) |fromp| { do as_c_charp(~"rb") |modebuf| { libc::fopen(fromp, modebuf) @@ -699,11 +699,11 @@ fn copy_file(from: path, to: path) -> bool { } /// Deletes an existing file -fn remove_file(p: path) -> bool { +fn remove_file(p: Path) -> bool { return unlink(p); #[cfg(windows)] - fn unlink(p: path) -> bool { + fn unlink(p: Path) -> bool { // FIXME (similar to Issue #2006): remove imports when export globs // work properly. import libc::funcs::extra::kernel32::*; @@ -715,7 +715,7 @@ fn remove_file(p: path) -> bool { } #[cfg(unix)] - fn unlink(p: path) -> bool { + fn unlink(p: Path) -> bool { return do as_c_charp(p) |buf| { libc::unlink(buf) == (0 as c_int) }; @@ -792,7 +792,7 @@ mod tests { fn make_rand_name() -> ~str { import rand; - let rng: rand::rng = rand::rng(); + let rng: rand::Rng = rand::rng(); let n = ~"TEST" + rng.gen_str(10u); assert option::is_none(getenv(n)); n diff --git a/src/libcore/path.rs b/src/libcore/path.rs index 1f239605131..12c5dd90ead 100644 --- a/src/libcore/path.rs +++ b/src/libcore/path.rs @@ -1,6 +1,6 @@ //! Path data type and helper functions -export path; +export Path; export consts; export path_is_absolute; export path_sep; @@ -14,7 +14,7 @@ export normalize; // FIXME: This type should probably be constrained (#2624) /// A path or fragment of a filesystem path -type path = ~str; +type Path = ~str; #[cfg(unix)] mod consts { @@ -45,7 +45,7 @@ mod consts { * on Windows, begins with a drive letter. */ #[cfg(unix)] -fn path_is_absolute(p: path) -> bool { +fn path_is_absolute(p: Path) -> bool { str::char_at(p, 0u) == '/' } @@ -60,7 +60,7 @@ fn path_is_absolute(p: ~str) -> bool { /// Get the default path separator for the host platform fn path_sep() -> ~str { return str::from_char(consts::path_sep); } -fn split_dirname_basename (pp: path) -> {dirname: ~str, basename: ~str} { +fn split_dirname_basename (pp: Path) -> {dirname: ~str, basename: ~str} { match str::rfind(pp, |ch| ch == consts::path_sep || ch == consts::alt_path_sep ) { @@ -81,7 +81,7 @@ fn split_dirname_basename (pp: path) -> {dirname: ~str, basename: ~str} { * * If the path is not prefixed with a directory, then "." is returned. */ -fn dirname(pp: path) -> path { +fn dirname(pp: Path) -> Path { return split_dirname_basename(pp).dirname; } @@ -94,7 +94,7 @@ fn dirname(pp: path) -> path { * the provided path. If an empty path is provided or the path ends * with a path separator then an empty path is returned. */ -fn basename(pp: path) -> path { +fn basename(pp: Path) -> Path { return split_dirname_basename(pp).basename; } @@ -105,7 +105,7 @@ fn basename(pp: path) -> path { * and any leading path separator on `post`, and returns the concatenation of * the two with a single path separator between them. */ -fn connect(pre: path, post: path) -> path { +fn connect(pre: Path, post: Path) -> Path { let mut pre_ = pre; let mut post_ = post; let sep = consts::path_sep as u8; @@ -127,7 +127,7 @@ fn connect(pre: path, post: path) -> path { * * Inserts path separators as needed. */ -fn connect_many(paths: ~[path]) -> path { +fn connect_many(paths: ~[Path]) -> Path { return if vec::len(paths) == 1u { paths[0] } else { @@ -144,7 +144,7 @@ fn connect_many(paths: ~[path]) -> path { * the first element of the returned vector will be the drive letter * followed by a colon. */ -fn split(p: path) -> ~[path] { +fn split(p: Path) -> ~[Path] { str::split_nonempty(p, |c| { c == consts::path_sep || c == consts::alt_path_sep }) @@ -159,7 +159,7 @@ fn split(p: path) -> ~[path] { * ignored. If the path includes directory components then they are included * in the filename part of the result pair. */ -fn splitext(p: path) -> (~str, ~str) { +fn splitext(p: Path) -> (~str, ~str) { if str::is_empty(p) { (~"", ~"") } else { let parts = str::split_char(p, '.'); @@ -212,7 +212,7 @@ fn splitext(p: path) -> (~str, ~str) { * * 'a/b/../../../' becomes '..' * * '/a/b/c/../d/./../../e/' becomes '/a/e/' */ -fn normalize(p: path) -> path { +fn normalize(p: Path) -> Path { let s = split(p); let s = strip_dots(s); let s = rollup_doubledots(s); @@ -233,7 +233,7 @@ fn normalize(p: path) -> path { return s; - fn strip_dots(s: ~[path]) -> ~[path] { + fn strip_dots(s: ~[Path]) -> ~[Path] { vec::filter_map(s, |elem| if elem == ~"." { option::none @@ -242,7 +242,7 @@ fn normalize(p: path) -> path { }) } - fn rollup_doubledots(s: ~[path]) -> ~[path] { + fn rollup_doubledots(s: ~[Path]) -> ~[Path] { if vec::is_empty(s) { return ~[]; } @@ -271,7 +271,7 @@ fn normalize(p: path) -> path { } #[cfg(unix)] - fn reabsolute(orig: path, n: path) -> path { + fn reabsolute(orig: Path, n: Path) -> Path { if path_is_absolute(orig) { path_sep() + n } else { @@ -280,7 +280,7 @@ fn normalize(p: path) -> path { } #[cfg(windows)] - fn reabsolute(orig: path, newp: path) -> path { + fn reabsolute(orig: Path, newp: Path) -> Path { if path_is_absolute(orig) && orig[0] == consts::path_sep as u8 { str::from_char(consts::path_sep) + newp } else { @@ -288,7 +288,7 @@ fn normalize(p: path) -> path { } } - fn reterminate(orig: path, newp: path) -> path { + fn reterminate(orig: Path, newp: Path) -> Path { let last = orig[str::len(orig) - 1u]; if last == consts::path_sep as u8 || last == consts::path_sep as u8 { diff --git a/src/libcore/rand.rs b/src/libcore/rand.rs index 2bf983c373e..fa197a365c3 100644 --- a/src/libcore/rand.rs +++ b/src/libcore/rand.rs @@ -1,8 +1,9 @@ //! Random number generation -export rng, seed, seeded_rng, weighted, extensions; +export Rng, rng, seed, seeded_rng, Weighted, extensions; export xorshift, seeded_xorshift; +#[allow(non_camel_case_types)] // runtime type enum rctx {} #[abi = "cdecl"] @@ -15,16 +16,16 @@ extern mod rustrt { } /// A random number generator -trait rng { +trait Rng { /// Return the next random integer fn next() -> u32; } /// A value with a particular weight compared to other values -type weighted = { weight: uint, item: T }; +type Weighted = { weight: uint, item: T }; /// Extension methods for random number generators -impl rng { +impl Rng { /// Return a random int fn gen_int() -> int { @@ -181,7 +182,7 @@ impl rng { * Choose an item respecting the relative weights, failing if the sum of * the weights is 0 */ - fn choose_weighted(v : ~[weighted]) -> T { + fn choose_weighted(v : ~[Weighted]) -> T { self.choose_weighted_option(v).get() } @@ -189,7 +190,7 @@ impl rng { * Choose some(item) respecting the relative weights, returning none if * the sum of the weights is 0 */ - fn choose_weighted_option(v: ~[weighted]) -> option { + fn choose_weighted_option(v: ~[Weighted]) -> option { let mut total = 0u; for v.each |item| { total += item.weight; @@ -212,7 +213,7 @@ impl rng { * Return a vec containing copies of the items, in order, where * the weight of the item determines how many copies there are */ - fn weighted_vec(v: ~[weighted]) -> ~[T] { + fn weighted_vec(v: ~[Weighted]) -> ~[T] { let mut r = ~[]; for v.each |item| { for uint::range(0u, item.weight) |_i| { @@ -242,13 +243,13 @@ impl rng { } -class rand_res { +class RandRes { let c: *rctx; new(c: *rctx) { self.c = c; } drop { rustrt::rand_free(self.c); } } -impl @rand_res: rng { +impl @RandRes: Rng { fn next() -> u32 { return rustrt::rand_next((*self).c); } } @@ -258,8 +259,8 @@ fn seed() -> ~[u8] { } /// Create a random number generator with a system specified seed -fn rng() -> rng { - @rand_res(rustrt::rand_new()) as rng +fn rng() -> Rng { + @RandRes(rustrt::rand_new()) as Rng } /** @@ -268,18 +269,18 @@ fn rng() -> rng { * all other generators constructed with the same seed. The seed may be any * length. */ -fn seeded_rng(seed: ~[u8]) -> rng { - @rand_res(rustrt::rand_new_seeded(seed)) as rng +fn seeded_rng(seed: ~[u8]) -> Rng { + @RandRes(rustrt::rand_new_seeded(seed)) as Rng } -type xorshift_state = { +type XorShiftState = { mut x: u32, mut y: u32, mut z: u32, mut w: u32 }; -impl xorshift_state: rng { +impl XorShiftState: Rng { fn next() -> u32 { let x = self.x; let mut t = x ^ (x << 11); @@ -292,13 +293,13 @@ impl xorshift_state: rng { } } -fn xorshift() -> rng { +fn xorshift() -> Rng { // constants taken from http://en.wikipedia.org/wiki/Xorshift seeded_xorshift(123456789u32, 362436069u32, 521288629u32, 88675123u32) } -fn seeded_xorshift(x: u32, y: u32, z: u32, w: u32) -> rng { - {mut x: x, mut y: y, mut z: z, mut w: w} as rng +fn seeded_xorshift(x: u32, y: u32, z: u32, w: u32) -> Rng { + {mut x: x, mut y: y, mut z: z, mut w: w} as Rng } #[cfg(test)] diff --git a/src/libcore/run.rs b/src/libcore/run.rs index 8eb62f96a82..f754391a50d 100644 --- a/src/libcore/run.rs +++ b/src/libcore/run.rs @@ -6,7 +6,7 @@ import option::{some, none}; import libc::{pid_t, c_void, c_int}; -export program; +export Program; export run_program; export start_program; export program_output; @@ -22,18 +22,18 @@ extern mod rustrt { } /// A value representing a child process -trait program { +trait Program { /// Returns the process id of the program fn get_id() -> pid_t; /// Returns an io::writer that can be used to write to stdin - fn input() -> io::writer; + fn input() -> io::Writer; /// Returns an io::reader that can be used to read from stdout - fn output() -> io::reader; + fn output() -> io::Reader; /// Returns an io::reader that can be used to read from stderr - fn err() -> io::reader; + fn err() -> io::Reader; /// Closes the handle to the child processes standard input fn close_input(); @@ -187,7 +187,7 @@ fn run_program(prog: &str, args: &[~str]) -> int { * * A class with a field */ -fn start_program(prog: &str, args: &[~str]) -> program { +fn start_program(prog: &str, args: &[~str]) -> Program { let pipe_input = os::pipe(); let pipe_output = os::pipe(); let pipe_err = os::pipe(); @@ -201,41 +201,41 @@ fn start_program(prog: &str, args: &[~str]) -> program { libc::close(pipe_output.out); libc::close(pipe_err.out); - type prog_repr = {pid: pid_t, - mut in_fd: c_int, - out_file: *libc::FILE, - err_file: *libc::FILE, - mut finished: bool}; + type ProgRepr = {pid: pid_t, + mut in_fd: c_int, + out_file: *libc::FILE, + err_file: *libc::FILE, + mut finished: bool}; - fn close_repr_input(r: &prog_repr) { + fn close_repr_input(r: &ProgRepr) { let invalid_fd = -1i32; if r.in_fd != invalid_fd { libc::close(r.in_fd); r.in_fd = invalid_fd; } } - fn finish_repr(r: &prog_repr) -> int { + fn finish_repr(r: &ProgRepr) -> int { if r.finished { return 0; } r.finished = true; close_repr_input(r); return waitpid(r.pid); } - fn destroy_repr(r: &prog_repr) { + fn destroy_repr(r: &ProgRepr) { finish_repr(r); libc::fclose(r.out_file); libc::fclose(r.err_file); } - class prog_res { - let r: prog_repr; - new(+r: prog_repr) { self.r = r; } + class ProgRes { + let r: ProgRepr; + new(+r: ProgRepr) { self.r = r; } drop { destroy_repr(&self.r); } } - impl prog_res: program { + impl ProgRes: Program { fn get_id() -> pid_t { return self.r.pid; } - fn input() -> io::writer { io::fd_writer(self.r.in_fd, false) } - fn output() -> io::reader { io::FILE_reader(self.r.out_file, false) } - fn err() -> io::reader { io::FILE_reader(self.r.err_file, false) } + fn input() -> io::Writer { io::fd_writer(self.r.in_fd, false) } + fn output() -> io::Reader { io::FILE_reader(self.r.out_file, false) } + fn err() -> io::Reader { io::FILE_reader(self.r.err_file, false) } fn close_input() { close_repr_input(&self.r); } fn finish() -> int { finish_repr(&self.r) } fn destroy() { destroy_repr(&self.r); } @@ -245,10 +245,10 @@ fn start_program(prog: &str, args: &[~str]) -> program { out_file: os::fdopen(pipe_output.in), err_file: os::fdopen(pipe_err.in), mut finished: false}; - return prog_res(move repr) as program; + return ProgRes(move repr) as Program; } -fn read_all(rd: io::reader) -> ~str { +fn read_all(rd: io::Reader) -> ~str { let mut buf = ~""; while !rd.eof() { let bytes = rd.read_bytes(4096u); @@ -326,7 +326,7 @@ fn program_output(prog: &str, args: &[~str]) -> } fn writeclose(fd: c_int, s: &str) { - import io::writer_util; + import io::WriterUtil; error!{"writeclose %d, %s", fd as int, s}; let writer = io::fd_writer(fd, false); @@ -392,7 +392,7 @@ fn waitpid(pid: pid_t) -> int { #[cfg(test)] mod tests { - import io::writer_util; + import io::WriterUtil; // Regression test for memory leaks #[ignore(cfg(windows))] // FIXME (#2626) diff --git a/src/libcore/str.rs b/src/libcore/str.rs index 5c02571ef97..181c36932d0 100644 --- a/src/libcore/str.rs +++ b/src/libcore/str.rs @@ -8,7 +8,7 @@ */ import libc::size_t; -import io::writer_util; +import io::WriterUtil; export // Creating a string diff --git a/src/libstd/base64.rs b/src/libstd/base64.rs index 2b9a1dccb36..b22fe2b9582 100644 --- a/src/libstd/base64.rs +++ b/src/libstd/base64.rs @@ -1,4 +1,4 @@ -import io::reader; +import io::Reader; trait to_base64 { fn to_base64() -> ~str; diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs index ca58d6f5f86..5a587752093 100644 --- a/src/libstd/ebml.rs +++ b/src/libstd/ebml.rs @@ -172,13 +172,13 @@ fn doc_as_i32(d: doc) -> i32 { doc_as_u32(d) as i32 } fn doc_as_i64(d: doc) -> i64 { doc_as_u64(d) as i64 } // ebml writing -type writer_ = {writer: io::writer, mut size_positions: ~[uint]}; +type writer_ = {writer: io::Writer, mut size_positions: ~[uint]}; enum writer { writer_(writer_) } -fn write_sized_vuint(w: io::writer, n: uint, size: uint) { +fn write_sized_vuint(w: io::Writer, n: uint, size: uint) { match size { 1u => w.write(&[0x80u8 | (n as u8)]), 2u => w.write(&[0x40u8 | ((n >> 8_u) as u8), n as u8]), @@ -190,7 +190,7 @@ fn write_sized_vuint(w: io::writer, n: uint, size: uint) { }; } -fn write_vuint(w: io::writer, n: uint) { +fn write_vuint(w: io::Writer, n: uint) { if n < 0x7f_u { write_sized_vuint(w, n, 1u); return; } if n < 0x4000_u { write_sized_vuint(w, n, 2u); return; } if n < 0x200000_u { write_sized_vuint(w, n, 3u); return; } @@ -198,7 +198,7 @@ fn write_vuint(w: io::writer, n: uint) { fail fmt!{"vint to write too big: %?", n}; } -fn writer(w: io::writer) -> writer { +fn writer(w: io::Writer) -> writer { let size_positions: ~[uint] = ~[]; return writer_({writer: w, mut size_positions: size_positions}); } @@ -220,10 +220,10 @@ impl writer { fn end_tag() { let last_size_pos = vec::pop::(self.size_positions); let cur_pos = self.writer.tell(); - self.writer.seek(last_size_pos as int, io::seek_set); + self.writer.seek(last_size_pos as int, io::SeekSet); let size = (cur_pos - last_size_pos - 4u); write_sized_vuint(self.writer, size, 4u); - self.writer.seek(cur_pos as int, io::seek_set); + self.writer.seek(cur_pos as int, io::SeekSet); debug!{"End tag (size = %u)", size}; } diff --git a/src/libstd/json.rs b/src/libstd/json.rs index f78e4be06da..715062a06c9 100644 --- a/src/libstd/json.rs +++ b/src/libstd/json.rs @@ -5,7 +5,7 @@ import result::{result, ok, err}; import io; -import io::writer_util; +import io::WriterUtil; import map; import map::hashmap; import map::map; @@ -43,7 +43,7 @@ type error = { }; /// Serializes a json value into a io::writer -fn to_writer(wr: io::writer, j: json) { +fn to_writer(wr: io::Writer, j: json) { match j { num(n) => wr.write_str(float::to_str(n, 6u)), string(s) => wr.write_str(escape_str(*s)), @@ -109,7 +109,7 @@ fn to_str(j: json) -> ~str { } type parser_ = { - rdr: io::reader, + rdr: io::Reader, mut ch: char, mut line: uint, mut col: uint, @@ -458,7 +458,7 @@ impl parser { } /// Deserializes a json value from an io::reader -fn from_reader(rdr: io::reader) -> result { +fn from_reader(rdr: io::Reader) -> result { let parser = parser_({ rdr: rdr, mut ch: rdr.read_char(), diff --git a/src/libstd/map.rs b/src/libstd/map.rs index 699cf7a66e9..e6f44d76b4c 100644 --- a/src/libstd/map.rs +++ b/src/libstd/map.rs @@ -2,7 +2,7 @@ #[warn(deprecated_mode)]; -import io::writer_util; +import io::WriterUtil; import to_str::ToStr; export hashmap, hashfn, eqfn, set, map, chained, hashmap, str_hash; export box_str_hash; @@ -328,7 +328,7 @@ mod chained { } impl t: ToStr { - fn to_writer(wr: io::writer) { + fn to_writer(wr: io::Writer) { if self.count == 0u { wr.write_str(~"{}"); return; diff --git a/src/libstd/net_tcp.rs b/src/libstd/net_tcp.rs index c32186fdd3c..b07c2fdfda7 100644 --- a/src/libstd/net_tcp.rs +++ b/src/libstd/net_tcp.rs @@ -8,7 +8,7 @@ import future_spawn = future::spawn; // should be able to, but can't atm, replace w/ result::{result, extensions}; import result::*; import libc::size_t; -import io::{reader, writer}; +import io::{Reader, Writer}; // tcp interfaces export tcp_socket; @@ -752,7 +752,7 @@ impl tcp_socket { } /// Implementation of `io::reader` trait for a buffered `net::tcp::tcp_socket` -impl @tcp_socket_buf: io::reader { +impl @tcp_socket_buf: io::Reader { fn read(buf: &[mut u8], len: uint) -> uint { // Loop until our buffer has enough data in it for us to read from. while self.data.buf.len() < len { @@ -795,7 +795,7 @@ impl @tcp_socket_buf: io::reader { fn eof() -> bool { false // noop } - fn seek(dist: int, seek: io::seek_style) { + fn seek(dist: int, seek: io::SeekStyle) { log(debug, fmt!{"tcp_socket_buf seek stub %? %?", dist, seek}); // noop } @@ -805,7 +805,7 @@ impl @tcp_socket_buf: io::reader { } /// Implementation of `io::reader` trait for a buffered `net::tcp::tcp_socket` -impl @tcp_socket_buf: io::writer { +impl @tcp_socket_buf: io::Writer { fn write(data: &[const u8]) unsafe { let socket_data_ptr = ptr::addr_of(*((*(self.data)).sock).socket_data); @@ -817,7 +817,7 @@ impl @tcp_socket_buf: io::writer { err_data.err_name, err_data.err_msg}); } } - fn seek(dist: int, seek: io::seek_style) { + fn seek(dist: int, seek: io::SeekStyle) { log(debug, fmt!{"tcp_socket_buf seek stub %? %?", dist, seek}); // noop } @@ -827,8 +827,8 @@ impl @tcp_socket_buf: io::writer { fn flush() -> int { 0 } - fn get_type() -> io::writer_type { - io::file + fn get_type() -> io::WriterType { + io::File } } @@ -1441,11 +1441,11 @@ mod test { assert false; } let sock_buf = @socket_buf(result::unwrap(conn_result)); - buf_write(sock_buf as io::writer, expected_req); + buf_write(sock_buf as io::Writer, expected_req); // so contrived! let actual_resp = do str::as_bytes(expected_resp) |resp_buf| { - buf_read(sock_buf as io::reader, + buf_read(sock_buf as io::Reader, vec::len(resp_buf)) }; @@ -1458,7 +1458,7 @@ mod test { assert str::contains(actual_resp, expected_resp); } - fn buf_write(+w: io::writer, val: ~str) { + fn buf_write(+w: io::Writer, val: ~str) { log(debug, fmt!{"BUF_WRITE: val len %?", str::len(val)}); do str::byte_slice(val) |b_slice| { log(debug, fmt!{"BUF_WRITE: b_slice len %?", @@ -1467,7 +1467,7 @@ mod test { } } - fn buf_read(+r: io::reader, len: uint) -> ~str { + fn buf_read(+r: io::Reader, len: uint) -> ~str { let new_bytes = r.read_bytes(len); log(debug, fmt!{"in buf_read.. new_bytes len: %?", vec::len(new_bytes)}); diff --git a/src/libstd/net_url.rs b/src/libstd/net_url.rs index e39eb777156..927fe75b1a9 100644 --- a/src/libstd/net_url.rs +++ b/src/libstd/net_url.rs @@ -2,7 +2,7 @@ import map; import map::{hashmap, str_hash}; -import io::reader; +import io::Reader; import dvec::dvec; export url, userinfo, query; diff --git a/src/libstd/prettyprint.rs b/src/libstd/prettyprint.rs index a33ad7ca65d..49fe0f4c0bf 100644 --- a/src/libstd/prettyprint.rs +++ b/src/libstd/prettyprint.rs @@ -1,8 +1,8 @@ -import io::writer; -import io::writer_util; +import io::Writer; +import io::WriterUtil; import serialization::serializer; -impl writer: serializer { +impl Writer: serializer { fn emit_nil() { self.write_str(~"()") } diff --git a/src/libstd/term.rs b/src/libstd/term.rs index 0d311223847..be189151287 100644 --- a/src/libstd/term.rs +++ b/src/libstd/term.rs @@ -23,10 +23,10 @@ const color_bright_magenta: u8 = 13u8; const color_bright_cyan: u8 = 14u8; const color_bright_white: u8 = 15u8; -fn esc(writer: io::writer) { writer.write(~[0x1bu8, '[' as u8]); } +fn esc(writer: io::Writer) { writer.write(~[0x1bu8, '[' as u8]); } /// Reset the foreground and background colors to default -fn reset(writer: io::writer) { +fn reset(writer: io::Writer) { esc(writer); writer.write(~['0' as u8, 'm' as u8]); } @@ -46,7 +46,7 @@ fn color_supported() -> bool { }; } -fn set_color(writer: io::writer, first_char: u8, color: u8) { +fn set_color(writer: io::Writer, first_char: u8, color: u8) { assert (color < 16u8); esc(writer); let mut color = color; @@ -55,12 +55,12 @@ fn set_color(writer: io::writer, first_char: u8, color: u8) { } /// Set the foreground color -fn fg(writer: io::writer, color: u8) { +fn fg(writer: io::Writer, color: u8) { return set_color(writer, '3' as u8, color); } /// Set the background color -fn bg(writer: io::writer, color: u8) { +fn bg(writer: io::Writer, color: u8) { return set_color(writer, '4' as u8, color); } diff --git a/src/libstd/test.rs b/src/libstd/test.rs index 104826afbac..9d33431f000 100644 --- a/src/libstd/test.rs +++ b/src/libstd/test.rs @@ -7,7 +7,7 @@ import either::either; import result::{ok, err}; -import io::writer_util; +import io::WriterUtil; import libc::size_t; import task::task_builder; @@ -91,8 +91,8 @@ fn parse_opts(args: ~[~str]) -> opt_res { enum test_result { tr_ok, tr_failed, tr_ignored, } type console_test_state = - @{out: io::writer, - log_out: option, + @{out: io::Writer, + log_out: option, use_color: bool, mut total: uint, mut passed: uint, @@ -141,7 +141,7 @@ fn run_tests_console(opts: test_opts, let log_out = match opts.logfile { some(path) => match io::file_writer(path, - ~[io::create, io::truncate]) { + ~[io::Create, io::Truncate]) { result::ok(w) => some(w), result::err(s) => { fail(fmt!{"can't open output file: %s", s}) @@ -179,7 +179,7 @@ fn run_tests_console(opts: test_opts, return success; - fn write_log(out: io::writer, result: test_result, test: test_desc) { + fn write_log(out: io::Writer, result: test_result, test: test_desc) { out.write_line(fmt!{"%s %s", match result { tr_ok => ~"ok", @@ -188,19 +188,19 @@ fn run_tests_console(opts: test_opts, }, test.name}); } - fn write_ok(out: io::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: io::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: io::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: io::writer, word: ~str, color: u8, use_color: bool) { + fn write_pretty(out: io::Writer, word: ~str, color: u8, use_color: bool) { if use_color && term::color_supported() { term::fg(out, color); } diff --git a/src/libstd/time.rs b/src/libstd/time.rs index 3f6602ffcda..47dbff2ccb1 100644 --- a/src/libstd/time.rs +++ b/src/libstd/time.rs @@ -1,5 +1,5 @@ import libc::{c_char, c_int, c_long, size_t, time_t}; -import io::reader; +import io::Reader; import result::{result, ok, err}; export diff --git a/src/libsyntax/diagnostic.rs b/src/libsyntax/diagnostic.rs index c71422d198f..38c8131147c 100644 --- a/src/libsyntax/diagnostic.rs +++ b/src/libsyntax/diagnostic.rs @@ -1,5 +1,5 @@ import std::term; -import io::writer_util; +import io::WriterUtil; import codemap::span; export emitter, emit; @@ -166,7 +166,7 @@ fn diagnosticcolor(lvl: level) -> u8 { fn print_diagnostic(topic: ~str, lvl: level, msg: ~str) { let use_color = term::color_supported() && - io::stderr().get_type() == io::screen; + io::stderr().get_type() == io::Screen; if str::is_not_empty(topic) { io::stderr().write_str(fmt!{"%s ", topic}); } diff --git a/src/libsyntax/ext/log_syntax.rs b/src/libsyntax/ext/log_syntax.rs index 3be74cba2e4..4ab3bb29045 100644 --- a/src/libsyntax/ext/log_syntax.rs +++ b/src/libsyntax/ext/log_syntax.rs @@ -1,5 +1,5 @@ import base::*; -import io::writer_util; +import io::WriterUtil; fn expand_syntax_ext(cx: ext_ctxt, sp: codemap::span, tt: ~[ast::token_tree]) -> base::mac_result { diff --git a/src/libsyntax/ext/source_util.rs b/src/libsyntax/ext/source_util.rs index 3fdd5239e65..8664277bcdc 100644 --- a/src/libsyntax/ext/source_util.rs +++ b/src/libsyntax/ext/source_util.rs @@ -99,7 +99,7 @@ fn expand_include_bin(cx: ext_ctxt, sp: codemap::span, arg: ast::mac_arg, } } -fn res_rel_file(cx: ext_ctxt, sp: codemap::span, +arg: path) -> path { +fn res_rel_file(cx: ext_ctxt, sp: codemap::span, +arg: Path) -> Path { // NB: relative paths are resolved relative to the compilation unit if !path::path_is_absolute(arg) { let cu = codemap::span_to_filename(sp, cx.codemap()); diff --git a/src/libsyntax/parse/comments.rs b/src/libsyntax/parse/comments.rs index d3c17b81298..2da34539321 100644 --- a/src/libsyntax/parse/comments.rs +++ b/src/libsyntax/parse/comments.rs @@ -273,7 +273,7 @@ type lit = {lit: ~str, pos: uint}; fn gather_comments_and_literals(span_diagnostic: diagnostic::span_handler, path: ~str, - srdr: io::reader) -> + srdr: io::Reader) -> {cmnts: ~[cmnt], lits: ~[lit]} { let src = @str::from_bytes(srdr.read_whole_stream()); let itr = @interner::mk::<@~str>( diff --git a/src/libsyntax/print/pp.rs b/src/libsyntax/print/pp.rs index a04b5ebe3c9..0d81d40ca8c 100644 --- a/src/libsyntax/print/pp.rs +++ b/src/libsyntax/print/pp.rs @@ -1,4 +1,4 @@ -import io::writer_util; +import io::WriterUtil; import dvec::dvec; /* @@ -95,7 +95,7 @@ type print_stack_elt = {offset: int, pbreak: print_stack_break}; const size_infinity: int = 0xffff; -fn mk_printer(out: io::writer, linewidth: uint) -> printer { +fn mk_printer(out: io::Writer, linewidth: uint) -> printer { // Yes 3, it makes the ring buffers big enough to never // fall behind. let n: uint = 3u * linewidth; @@ -201,7 +201,7 @@ fn mk_printer(out: io::writer, linewidth: uint) -> printer { * called 'print'. */ type printer_ = { - out: io::writer, + out: io::Writer, buf_len: uint, mut margin: int, // width of lines we're constrained to mut space: int, // number of spaces left on line diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index f4b6b74d1b5..05b6ca8c504 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -48,7 +48,7 @@ fn end(s: ps) { pp::end(s.s); } -fn rust_printer(writer: io::writer) -> ps { +fn rust_printer(writer: io::Writer) -> ps { return @{s: pp::mk_printer(writer, default_columns), cm: none::, intr: @interner::mk::<@~str>(|x| str::hash(*x), @@ -61,7 +61,7 @@ fn rust_printer(writer: io::writer) -> ps { ann: no_ann()}; } -fn unexpanded_rust_printer(writer: io::writer, intr: ident_interner) -> ps { +fn unexpanded_rust_printer(writer: io::Writer, intr: ident_interner) -> ps { return @{s: pp::mk_printer(writer, default_columns), cm: none::, intr: intr, @@ -83,8 +83,8 @@ const default_columns: uint = 78u; // copy forward. fn print_crate(cm: codemap, intr: @interner::interner<@~str>, span_diagnostic: diagnostic::span_handler, - crate: @ast::crate, filename: ~str, in: io::reader, - out: io::writer, ann: pp_ann, is_expanded: bool) { + crate: @ast::crate, filename: ~str, in: io::Reader, + out: io::Writer, ann: pp_ann, is_expanded: bool) { let r = comments::gather_comments_and_literals(span_diagnostic, filename, in); let s = diff --git a/src/rustc/back/link.rs b/src/rustc/back/link.rs index e7fe5fa3e3d..8ac75916da0 100644 --- a/src/rustc/back/link.rs +++ b/src/rustc/back/link.rs @@ -15,7 +15,7 @@ import lib::llvm::{ModuleRef, mk_pass_manager, mk_target_data, True, False, FileType}; import metadata::filesearch; import syntax::ast_map::{path, path_mod, path_name}; -import io::{writer, writer_util}; +import io::{Writer, WriterUtil}; enum output_type { output_type_none, diff --git a/src/rustc/back/rpath.rs b/src/rustc/back/rpath.rs index e06b0a2fe72..85975897fac 100644 --- a/src/rustc/back/rpath.rs +++ b/src/rustc/back/rpath.rs @@ -36,7 +36,7 @@ fn get_rpath_flags(sess: session::session, out_filename: ~str) -> ~[~str] { rpaths_to_flags(rpaths) } -fn get_sysroot_absolute_rt_lib(sess: session::session) -> path::path { +fn get_sysroot_absolute_rt_lib(sess: session::session) -> path::Path { let mut path = vec::append(~[sess.filesearch.sysroot()], filesearch::relative_target_lib_path( sess.opts.target_triple)); @@ -48,8 +48,8 @@ fn rpaths_to_flags(rpaths: ~[~str]) -> ~[~str] { vec::map(rpaths, |rpath| fmt!{"-Wl,-rpath,%s",rpath} ) } -fn get_rpaths(os: session::os, cwd: path::path, sysroot: path::path, - output: path::path, libs: ~[path::path], +fn get_rpaths(os: session::os, cwd: path::Path, sysroot: path::Path, + output: path::Path, libs: ~[path::Path], target_triple: ~str) -> ~[~str] { debug!{"cwd: %s", cwd}; debug!{"sysroot: %s", sysroot}; @@ -93,18 +93,18 @@ fn get_rpaths(os: session::os, cwd: path::path, sysroot: path::path, } fn get_rpaths_relative_to_output(os: session::os, - cwd: path::path, - output: path::path, - libs: ~[path::path]) -> ~[~str] { + cwd: path::Path, + output: path::Path, + libs: ~[path::Path]) -> ~[~str] { vec::map(libs, |a| { get_rpath_relative_to_output(os, cwd, output, a) }) } fn get_rpath_relative_to_output(os: session::os, - cwd: path::path, - output: path::path, - &&lib: path::path) -> ~str { + cwd: path::Path, + output: path::Path, + &&lib: path::Path) -> ~str { assert not_win32(os); // Mac doesn't appear to support $ORIGIN @@ -121,7 +121,7 @@ fn get_rpath_relative_to_output(os: session::os, } // Find the relative path from one file to another -fn get_relative_to(abs1: path::path, abs2: path::path) -> path::path { +fn get_relative_to(abs1: path::Path, abs2: path::Path) -> path::Path { assert path::path_is_absolute(abs1); assert path::path_is_absolute(abs2); debug!{"finding relative path from %s to %s", @@ -154,15 +154,15 @@ fn get_relative_to(abs1: path::path, abs2: path::path) -> path::path { } } -fn get_absolute_rpaths(cwd: path::path, libs: ~[path::path]) -> ~[~str] { +fn get_absolute_rpaths(cwd: path::Path, libs: ~[path::Path]) -> ~[~str] { vec::map(libs, |a| get_absolute_rpath(cwd, a) ) } -fn get_absolute_rpath(cwd: path::path, &&lib: path::path) -> ~str { +fn get_absolute_rpath(cwd: path::Path, &&lib: path::Path) -> ~str { path::dirname(get_absolute(cwd, lib)) } -fn get_absolute(cwd: path::path, lib: path::path) -> path::path { +fn get_absolute(cwd: path::Path, lib: path::Path) -> path::Path { if path::path_is_absolute(lib) { lib } else { @@ -170,7 +170,7 @@ fn get_absolute(cwd: path::path, lib: path::path) -> path::path { } } -fn get_install_prefix_rpath(cwd: path::path, target_triple: ~str) -> ~str { +fn get_install_prefix_rpath(cwd: path::Path, target_triple: ~str) -> ~str { let install_prefix = env!{"CFG_PREFIX"}; if install_prefix == ~"" { diff --git a/src/rustc/driver/driver.rs b/src/rustc/driver/driver.rs index fefbb2bcc5f..5f21d46adc9 100644 --- a/src/rustc/driver/driver.rs +++ b/src/rustc/driver/driver.rs @@ -10,7 +10,7 @@ import util::ppaux; import back::link; import result::{ok, err}; import std::getopts; -import io::writer_util; +import io::WriterUtil; import getopts::{optopt, optmulti, optflag, optflagopt, opt_present}; import back::{x86, x86_64}; import std::map::hashmap; @@ -701,7 +701,7 @@ fn early_error(emitter: diagnostic::emitter, msg: ~str) -> ! { fail; } -fn list_metadata(sess: session, path: ~str, out: io::writer) { +fn list_metadata(sess: session, path: ~str, out: io::Writer) { metadata::loader::list_file_metadata( session::sess_os_to_meta_os(sess.targ_cfg.os), path, out); } diff --git a/src/rustc/metadata/decoder.rs b/src/rustc/metadata/decoder.rs index 379982f4a2d..d6d9b2701e4 100644 --- a/src/rustc/metadata/decoder.rs +++ b/src/rustc/metadata/decoder.rs @@ -3,7 +3,7 @@ import std::{ebml, map}; import std::map::{hashmap, str_hash}; import dvec::dvec; -import io::writer_util; +import io::WriterUtil; import syntax::{ast, ast_util}; import syntax::attr; import middle::ty; @@ -846,13 +846,13 @@ fn get_attributes(md: ebml::doc) -> ~[ast::attribute] { return attrs; } -fn list_meta_items(meta_items: ebml::doc, out: io::writer) { +fn list_meta_items(meta_items: ebml::doc, out: io::Writer) { for get_meta_items(meta_items).each |mi| { out.write_str(fmt!{"%s\n", pprust::meta_item_to_str(*mi)}); } } -fn list_crate_attributes(md: ebml::doc, hash: @~str, out: io::writer) { +fn list_crate_attributes(md: ebml::doc, hash: @~str, out: io::Writer) { out.write_str(fmt!{"=Crate Attributes (%s)=\n", *hash}); for get_attributes(md).each |attr| { @@ -887,7 +887,7 @@ fn get_crate_deps(data: @~[u8]) -> ~[crate_dep] { return deps; } -fn list_crate_deps(data: @~[u8], out: io::writer) { +fn list_crate_deps(data: @~[u8], out: io::Writer) { out.write_str(~"=External Dependencies=\n"); for get_crate_deps(data).each |dep| { @@ -913,7 +913,7 @@ fn get_crate_vers(data: @~[u8]) -> @~str { }; } -fn list_crate_items(bytes: @~[u8], md: ebml::doc, out: io::writer) { +fn list_crate_items(bytes: @~[u8], md: ebml::doc, out: io::Writer) { out.write_str(~"=Items=\n"); let items = ebml::get_doc(md, tag_items); do iter_crate_items(bytes) |tag, path, did| { @@ -969,7 +969,7 @@ fn get_crate_module_paths(bytes: @~[u8]) -> ~[(ast::def_id, ~str)] { } } -fn list_crate_metadata(bytes: @~[u8], out: io::writer) { +fn list_crate_metadata(bytes: @~[u8], out: io::Writer) { let hash = get_crate_hash(bytes); let md = ebml::doc(bytes); list_crate_attributes(md, hash, out); diff --git a/src/rustc/metadata/encoder.rs b/src/rustc/metadata/encoder.rs index 47414e48462..7d006369359 100644 --- a/src/rustc/metadata/encoder.rs +++ b/src/rustc/metadata/encoder.rs @@ -4,7 +4,7 @@ import util::ppaux::ty_to_str; import std::{ebml, map}; import std::map::hashmap; -import io::writer_util; +import io::WriterUtil; import ebml::writer; import syntax::ast::*; import syntax::print::pprust; @@ -1005,7 +1005,7 @@ fn create_index(index: ~[entry], hash_fn: fn@(T) -> uint) -> } fn encode_index(ebml_w: ebml::writer, buckets: ~[@~[entry]], - write_fn: fn(io::writer, T)) { + write_fn: fn(io::Writer, T)) { let writer = ebml_w.writer; ebml_w.start_tag(tag_index); let mut bucket_locs: ~[uint] = ~[]; @@ -1032,9 +1032,9 @@ fn encode_index(ebml_w: ebml::writer, buckets: ~[@~[entry]], ebml_w.end_tag(); } -fn write_str(writer: io::writer, &&s: ~str) { writer.write_str(s); } +fn write_str(writer: io::Writer, &&s: ~str) { writer.write_str(s); } -fn write_int(writer: io::writer, &&n: int) { +fn write_int(writer: io::Writer, &&n: int) { assert n < 0x7fff_ffff; writer.write_be_u32(n as u32); } diff --git a/src/rustc/metadata/filesearch.rs b/src/rustc/metadata/filesearch.rs index eb8b2ffec63..24e6d3267cc 100644 --- a/src/rustc/metadata/filesearch.rs +++ b/src/rustc/metadata/filesearch.rs @@ -14,31 +14,31 @@ export get_cargo_root; export get_cargo_root_nearest; export libdir; -import path::path; +import path::Path; -type pick = fn(path: path) -> option; +type pick = fn(path: Path) -> option; -fn pick_file(file: path, path: path) -> option { +fn pick_file(file: Path, path: Path) -> option { if path::basename(path) == file { option::some(path) } else { option::none } } trait filesearch { - fn sysroot() -> path; - fn lib_search_paths() -> ~[path]; - fn get_target_lib_path() -> path; - fn get_target_lib_file_path(file: path) -> path; + fn sysroot() -> Path; + fn lib_search_paths() -> ~[Path]; + fn get_target_lib_path() -> Path; + fn get_target_lib_file_path(file: Path) -> Path; } -fn mk_filesearch(maybe_sysroot: option, +fn mk_filesearch(maybe_sysroot: option, target_triple: ~str, - addl_lib_search_paths: ~[path]) -> filesearch { - type filesearch_impl = {sysroot: path, - addl_lib_search_paths: ~[path], + addl_lib_search_paths: ~[Path]) -> filesearch { + type filesearch_impl = {sysroot: Path, + addl_lib_search_paths: ~[Path], target_triple: ~str}; impl filesearch_impl: filesearch { - fn sysroot() -> path { self.sysroot } - fn lib_search_paths() -> ~[path] { + fn sysroot() -> Path { self.sysroot } + fn lib_search_paths() -> ~[Path] { let mut paths = self.addl_lib_search_paths; vec::push(paths, @@ -53,10 +53,10 @@ fn mk_filesearch(maybe_sysroot: option, } paths } - fn get_target_lib_path() -> path { + fn get_target_lib_path() -> Path { make_target_lib_path(self.sysroot, self.target_triple) } - fn get_target_lib_file_path(file: path) -> path { + fn get_target_lib_file_path(file: Path) -> Path { path::connect(self.get_target_lib_path(), file) } } @@ -88,38 +88,38 @@ fn search(filesearch: filesearch, pick: pick) -> option { return rslt; } -fn relative_target_lib_path(target_triple: ~str) -> ~[path] { +fn relative_target_lib_path(target_triple: ~str) -> ~[Path] { ~[libdir(), ~"rustc", target_triple, libdir()] } -fn make_target_lib_path(sysroot: path, - target_triple: ~str) -> path { +fn make_target_lib_path(sysroot: Path, + target_triple: ~str) -> Path { let path = vec::append(~[sysroot], relative_target_lib_path(target_triple)); let path = path::connect_many(path); return path; } -fn get_default_sysroot() -> path { +fn get_default_sysroot() -> Path { match os::self_exe_path() { option::some(p) => path::normalize(path::connect(p, ~"..")), option::none => fail ~"can't determine value for sysroot" } } -fn get_sysroot(maybe_sysroot: option) -> path { +fn get_sysroot(maybe_sysroot: option) -> Path { match maybe_sysroot { option::some(sr) => sr, option::none => get_default_sysroot() } } -fn get_cargo_sysroot() -> result { +fn get_cargo_sysroot() -> result { let path = ~[get_default_sysroot(), libdir(), ~"cargo"]; result::ok(path::connect_many(path)) } -fn get_cargo_root() -> result { +fn get_cargo_root() -> result { match os::getenv(~"CARGO_ROOT") { some(_p) => result::ok(_p), none => match os::homedir() { @@ -129,7 +129,7 @@ fn get_cargo_root() -> result { } } -fn get_cargo_root_nearest() -> result { +fn get_cargo_root_nearest() -> result { do result::chain(get_cargo_root()) |p| { let cwd = os::getcwd(); let mut dirname = path::dirname(cwd); @@ -153,13 +153,13 @@ fn get_cargo_root_nearest() -> result { } } -fn get_cargo_lib_path() -> result { +fn get_cargo_lib_path() -> result { do result::chain(get_cargo_root()) |p| { result::ok(path::connect(p, libdir())) } } -fn get_cargo_lib_path_nearest() -> result { +fn get_cargo_lib_path_nearest() -> result { do result::chain(get_cargo_root_nearest()) |p| { result::ok(path::connect(p, libdir())) } diff --git a/src/rustc/metadata/loader.rs b/src/rustc/metadata/loader.rs index e5a2e0848e9..d1e24642927 100644 --- a/src/rustc/metadata/loader.rs +++ b/src/rustc/metadata/loader.rs @@ -6,7 +6,7 @@ import syntax::print::pprust; import syntax::codemap::span; import lib::llvm::{False, llvm, mk_object_file, mk_section_iter}; import filesearch::filesearch; -import io::writer_util; +import io::WriterUtil; export os; export os_macos, os_win32, os_linux, os_freebsd; @@ -206,7 +206,7 @@ fn meta_section_name(os: os) -> ~str { } // A diagnostic function for dumping crate metadata to an output stream -fn list_file_metadata(os: os, path: ~str, out: io::writer) { +fn list_file_metadata(os: os, path: ~str, out: io::Writer) { match get_metadata_section(os, path) { option::some(bytes) => decoder::list_crate_metadata(bytes, out), option::none => { diff --git a/src/rustc/metadata/tyencode.rs b/src/rustc/metadata/tyencode.rs index 30b2a21167a..f26ccff1806 100644 --- a/src/rustc/metadata/tyencode.rs +++ b/src/rustc/metadata/tyencode.rs @@ -1,6 +1,6 @@ // Type encoding -import io::writer_util; +import io::WriterUtil; import std::map::hashmap; import syntax::ast::*; import syntax::diagnostic::span_handler; @@ -40,7 +40,7 @@ fn cx_uses_abbrevs(cx: @ctxt) -> bool { } } -fn enc_ty(w: io::writer, cx: @ctxt, t: ty::t) { +fn enc_ty(w: io::Writer, cx: @ctxt, t: ty::t) { match cx.abbrevs { ac_no_abbrevs => { let result_str = match cx.tcx.short_names_cache.find(t) { @@ -95,7 +95,7 @@ fn enc_ty(w: io::writer, cx: @ctxt, t: ty::t) { } } } -fn enc_mt(w: io::writer, cx: @ctxt, mt: ty::mt) { +fn enc_mt(w: io::Writer, cx: @ctxt, mt: ty::mt) { match mt.mutbl { m_imm => (), m_mutbl => w.write_char('m'), @@ -104,7 +104,7 @@ fn enc_mt(w: io::writer, cx: @ctxt, mt: ty::mt) { enc_ty(w, cx, mt.ty); } -fn enc_opt(w: io::writer, t: option, enc_f: fn(T)) { +fn enc_opt(w: io::Writer, t: option, enc_f: fn(T)) { match t { none => w.write_char('n'), some(v) => { @@ -114,7 +114,7 @@ fn enc_opt(w: io::writer, t: option, enc_f: fn(T)) { } } -fn enc_substs(w: io::writer, cx: @ctxt, substs: ty::substs) { +fn enc_substs(w: io::Writer, cx: @ctxt, substs: ty::substs) { do enc_opt(w, substs.self_r) |r| { enc_region(w, cx, r) } do enc_opt(w, substs.self_ty) |t| { enc_ty(w, cx, t) } w.write_char('['); @@ -122,7 +122,7 @@ fn enc_substs(w: io::writer, cx: @ctxt, substs: ty::substs) { w.write_char(']'); } -fn enc_region(w: io::writer, cx: @ctxt, r: ty::region) { +fn enc_region(w: io::Writer, cx: @ctxt, r: ty::region) { match r { ty::re_bound(br) => { w.write_char('b'); @@ -151,7 +151,7 @@ fn enc_region(w: io::writer, cx: @ctxt, r: ty::region) { } } -fn enc_bound_region(w: io::writer, br: ty::bound_region) { +fn enc_bound_region(w: io::Writer, br: ty::bound_region) { match br { ty::br_self => w.write_char('s'), ty::br_anon => w.write_char('a'), @@ -169,7 +169,7 @@ fn enc_bound_region(w: io::writer, br: ty::bound_region) { } } -fn enc_vstore(w: io::writer, cx: @ctxt, v: ty::vstore) { +fn enc_vstore(w: io::Writer, cx: @ctxt, v: ty::vstore) { w.write_char('/'); match v { ty::vstore_fixed(u) => { @@ -189,7 +189,7 @@ fn enc_vstore(w: io::writer, cx: @ctxt, v: ty::vstore) { } } -fn enc_sty(w: io::writer, cx: @ctxt, st: ty::sty) { +fn enc_sty(w: io::Writer, cx: @ctxt, st: ty::sty) { match st { ty::ty_nil => w.write_char('n'), ty::ty_bot => w.write_char('z'), @@ -307,7 +307,7 @@ fn enc_sty(w: io::writer, cx: @ctxt, st: ty::sty) { } } -fn enc_proto(w: io::writer, cx: @ctxt, proto: ty::fn_proto) { +fn enc_proto(w: io::Writer, cx: @ctxt, proto: ty::fn_proto) { w.write_str(&"f"); match proto { ty::proto_bare => w.write_str(&"n"), @@ -318,7 +318,7 @@ fn enc_proto(w: io::writer, cx: @ctxt, proto: ty::fn_proto) { } } -fn enc_mode(w: io::writer, cx: @ctxt, m: mode) { +fn enc_mode(w: io::Writer, cx: @ctxt, m: mode) { match ty::resolved_mode(cx.tcx, m) { by_mutbl_ref => w.write_char('&'), by_move => w.write_char('-'), @@ -328,7 +328,7 @@ fn enc_mode(w: io::writer, cx: @ctxt, m: mode) { } } -fn enc_purity(w: io::writer, p: purity) { +fn enc_purity(w: io::Writer, p: purity) { match p { pure_fn => w.write_char('p'), impure_fn => w.write_char('i'), @@ -337,7 +337,7 @@ fn enc_purity(w: io::writer, p: purity) { } } -fn enc_ty_fn(w: io::writer, cx: @ctxt, ft: ty::fn_ty) { +fn enc_ty_fn(w: io::Writer, cx: @ctxt, ft: ty::fn_ty) { enc_proto(w, cx, ft.proto); enc_purity(w, ft.purity); enc_bounds(w, cx, ft.bounds); @@ -353,7 +353,7 @@ fn enc_ty_fn(w: io::writer, cx: @ctxt, ft: ty::fn_ty) { } } -fn enc_bounds(w: io::writer, cx: @ctxt, bs: @~[ty::param_bound]) { +fn enc_bounds(w: io::Writer, cx: @ctxt, bs: @~[ty::param_bound]) { for vec::each(*bs) |bound| { match bound { ty::bound_send => w.write_char('S'), diff --git a/src/rustc/middle/lint.rs b/src/rustc/middle/lint.rs index d224a56628c..ca4a5866a0a 100644 --- a/src/rustc/middle/lint.rs +++ b/src/rustc/middle/lint.rs @@ -6,7 +6,7 @@ import syntax::attr; import syntax::codemap::span; import std::map::{map,hashmap,int_hash,hash_from_strs}; import std::smallintmap::{map,smallintmap}; -import io::writer_util; +import io::WriterUtil; import util::ppaux::{ty_to_str}; import middle::pat_util::{pat_bindings}; import syntax::ast_util::{path_to_ident}; diff --git a/src/rustc/middle/liveness.rs b/src/rustc/middle/liveness.rs index 14a8fa1af5b..61feb22f1b4 100644 --- a/src/rustc/middle/liveness.rs +++ b/src/rustc/middle/liveness.rs @@ -108,7 +108,7 @@ import visit::vt; import syntax::codemap::span; import syntax::ast::*; import driver::session::session; -import io::writer_util; +import io::WriterUtil; import capture::{cap_move, cap_drop, cap_copy, cap_ref}; export check_crate; @@ -647,7 +647,7 @@ class liveness { } } - fn write_vars(wr: io::writer, + fn write_vars(wr: io::Writer, ln: live_node, test: fn(uint) -> live_node) { let node_base_idx = self.idx(ln, variable(0u)); diff --git a/src/rustdoc/markdown_writer.rs b/src/rustdoc/markdown_writer.rs index 5bd7be94948..8265bbe17d8 100644 --- a/src/rustdoc/markdown_writer.rs +++ b/src/rustdoc/markdown_writer.rs @@ -88,7 +88,7 @@ fn pandoc_writer( ]; do generic_writer |markdown| { - import io::writer_util; + import io::WriterUtil; debug!{"pandoc cmd: %s", pandoc_cmd}; debug!{"pandoc args: %s", str::connect(pandoc_args, ~" ")}; @@ -254,9 +254,9 @@ mod test { } fn write_file(path: ~str, s: ~str) { - import io::writer_util; + import io::WriterUtil; - match io::file_writer(path, ~[io::create, io::truncate]) { + match io::file_writer(path, ~[io::Create, io::Truncate]) { result::ok(writer) => { writer.write_str(s); } diff --git a/src/test/bench/core-std.rs b/src/test/bench/core-std.rs index c6a11eca75b..d58cd1ef4cf 100644 --- a/src/test/bench/core-std.rs +++ b/src/test/bench/core-std.rs @@ -6,7 +6,7 @@ import std::time::precise_time_s; import std::map; import std::map::{map, hashmap}; -import io::reader; +import io::Reader; fn main(argv: ~[~str]) { #macro[ diff --git a/src/test/bench/core-vec-append.rs b/src/test/bench/core-vec-append.rs index 6456f5db39b..b480d92a0d8 100644 --- a/src/test/bench/core-vec-append.rs +++ b/src/test/bench/core-vec-append.rs @@ -2,7 +2,7 @@ use std; import dvec::dvec; -import io::writer_util; +import io::WriterUtil; fn collect_raw(num: uint) -> ~[uint] { let mut result = ~[]; diff --git a/src/test/bench/graph500-bfs.rs b/src/test/bench/graph500-bfs.rs index 99e7c167bbc..35ff2e648c9 100644 --- a/src/test/bench/graph500-bfs.rs +++ b/src/test/bench/graph500-bfs.rs @@ -13,7 +13,7 @@ import std::map::hashmap; import std::deque; import std::deque::t; import std::par; -import io::writer_util; +import io::WriterUtil; import comm::*; import int::abs; @@ -24,7 +24,7 @@ type bfs_result = ~[node_id]; fn make_edges(scale: uint, edgefactor: uint) -> ~[(node_id, node_id)] { let r = rand::xorshift(); - fn choose_edge(i: node_id, j: node_id, scale: uint, r: rand::rng) + fn choose_edge(i: node_id, j: node_id, scale: uint, r: rand::Rng) -> (node_id, node_id) { let A = 0.57; diff --git a/src/test/bench/msgsend-pipes-shared.rs b/src/test/bench/msgsend-pipes-shared.rs index f4bf118cfa2..8b0eeb15cb3 100644 --- a/src/test/bench/msgsend-pipes-shared.rs +++ b/src/test/bench/msgsend-pipes-shared.rs @@ -11,8 +11,8 @@ // xfail-pretty use std; -import io::writer; -import io::writer_util; +import io::Writer; +import io::WriterUtil; import pipes::{port, chan, shared_chan}; diff --git a/src/test/bench/msgsend-pipes.rs b/src/test/bench/msgsend-pipes.rs index 4753faaba28..06b4213970b 100644 --- a/src/test/bench/msgsend-pipes.rs +++ b/src/test/bench/msgsend-pipes.rs @@ -7,8 +7,8 @@ // xfail-pretty use std; -import io::writer; -import io::writer_util; +import io::Writer; +import io::WriterUtil; import pipes::{port, port_set, chan}; diff --git a/src/test/bench/msgsend.rs b/src/test/bench/msgsend.rs index 6be65ebb65c..abcf9f4ed54 100644 --- a/src/test/bench/msgsend.rs +++ b/src/test/bench/msgsend.rs @@ -5,8 +5,8 @@ // I *think* it's the same, more or less. use std; -import io::writer; -import io::writer_util; +import io::Writer; +import io::WriterUtil; enum request { get_count, diff --git a/src/test/bench/shootout-fasta.rs b/src/test/bench/shootout-fasta.rs index a1cb8933893..4b83b14c98f 100644 --- a/src/test/bench/shootout-fasta.rs +++ b/src/test/bench/shootout-fasta.rs @@ -10,7 +10,7 @@ import vec; import uint; import int; import str; -import io::writer_util; +import io::WriterUtil; fn LINE_LENGTH() -> uint { return 60u; } @@ -43,7 +43,7 @@ fn select_random(r: u32, genelist: ~[aminoacids]) -> char { return bisect(genelist, 0u, vec::len::(genelist) - 1u, r); } -fn make_random_fasta(wr: io::writer, id: ~str, desc: ~str, genelist: ~[aminoacids], n: int) { +fn make_random_fasta(wr: io::Writer, id: ~str, desc: ~str, genelist: ~[aminoacids], n: int) { wr.write_line(~">" + id + ~" " + desc); let rng = @{mut last: rand::rng().next()}; let mut op: ~str = ~""; @@ -58,7 +58,7 @@ fn make_random_fasta(wr: io::writer, id: ~str, desc: ~str, genelist: ~[aminoacid if str::len(op) > 0u { wr.write_line(op); } } -fn make_repeat_fasta(wr: io::writer, id: ~str, desc: ~str, s: ~str, n: int) unsafe { +fn make_repeat_fasta(wr: io::Writer, id: ~str, desc: ~str, s: ~str, n: int) unsafe { wr.write_line(~">" + id + ~" " + desc); let mut op: ~str = ~""; let sl: uint = str::len(s); @@ -85,7 +85,7 @@ fn main(args: ~[~str]) { }; let writer = if os::getenv(~"RUST_BENCH").is_some() { - result::get(io::file_writer(~"./shootout-fasta.data", ~[io::truncate, io::create])) + result::get(io::file_writer(~"./shootout-fasta.data", ~[io::Truncate, io::Create])) } else { io::stdout() }; diff --git a/src/test/bench/shootout-mandelbrot.rs b/src/test/bench/shootout-mandelbrot.rs index 3ff45e6f713..fcbd2e6fed0 100644 --- a/src/test/bench/shootout-mandelbrot.rs +++ b/src/test/bench/shootout-mandelbrot.rs @@ -13,7 +13,7 @@ // writes pbm image to output path use std; -import io::writer_util; +import io::WriterUtil; import std::map::hashmap; struct cmplx { @@ -90,12 +90,12 @@ fn chanmb(i: uint, size: uint, ch: comm::chan) -> () type devnull = {dn: int}; -impl devnull: io::writer { +impl devnull: io::Writer { fn write(_b: &[const u8]) {} - fn seek(_i: int, _s: io::seek_style) {} + fn seek(_i: int, _s: io::SeekStyle) {} fn tell() -> uint {0_u} fn flush() -> int {0} - fn get_type() -> io::writer_type { io::file } + fn get_type() -> io::WriterType { io::File } } fn writer(path: ~str, writech: comm::chan>, size: uint) @@ -103,9 +103,9 @@ fn writer(path: ~str, writech: comm::chan>, size: uint) let p: comm::port = comm::port(); let ch = comm::chan(p); comm::send(writech, ch); - let cout: io::writer = match path { + let cout: io::Writer = match path { ~"" => { - {dn: 0} as io::writer + {dn: 0} as io::Writer } ~"-" => { io::stdout() @@ -113,7 +113,7 @@ fn writer(path: ~str, writech: comm::chan>, size: uint) _ => { result::get( io::file_writer(path, - ~[io::create, io::truncate])) + ~[io::Create, io::Truncate])) } }; cout.write_line(~"P4"); diff --git a/src/test/bench/shootout-pfib.rs b/src/test/bench/shootout-pfib.rs index fe4dda581e4..7942392f2b8 100644 --- a/src/test/bench/shootout-pfib.rs +++ b/src/test/bench/shootout-pfib.rs @@ -13,7 +13,7 @@ use std; import std::{time, getopts}; -import io::writer_util; +import io::WriterUtil; import int::range; import pipes::port; import pipes::chan; diff --git a/src/test/bench/std-smallintmap.rs b/src/test/bench/std-smallintmap.rs index e166688e457..a9cab862e2e 100644 --- a/src/test/bench/std-smallintmap.rs +++ b/src/test/bench/std-smallintmap.rs @@ -3,7 +3,7 @@ use std; import std::smallintmap; import std::smallintmap::smallintmap; -import io::writer_util; +import io::WriterUtil; fn append_sequential(min: uint, max: uint, map: smallintmap) { for uint::range(min, max) |i| { diff --git a/src/test/bench/sudoku.rs b/src/test/bench/sudoku.rs index 4f100f0581f..7c722442133 100644 --- a/src/test/bench/sudoku.rs +++ b/src/test/bench/sudoku.rs @@ -1,7 +1,7 @@ use std; import std::bitv; -import io::writer_util; +import io::WriterUtil; // Computes a single solution to a given 9x9 sudoku // @@ -28,7 +28,7 @@ type grid = ~[~[mut u8]]; enum grid_t { grid_ctor(grid), } // read a sudoku problem from file f -fn read_grid(f: io::reader) -> grid_t { +fn read_grid(f: io::Reader) -> grid_t { assert f.read_line() == ~"9,9"; /* assert first line is exactly "9,9" */ let g = vec::from_fn(10u, {|_i| @@ -116,7 +116,7 @@ fn solve_grid(g: grid_t) { } } -fn write_grid(f: io::writer, g: grid_t) { +fn write_grid(f: io::Writer, g: grid_t) { for u8::range(0u8, 9u8) |row| { f.write_str(fmt!{"%u", (*g)[row][0] as uint}); for u8::range(1u8, 9u8) |col| { diff --git a/src/test/bench/task-perf-word-count-generic.rs b/src/test/bench/task-perf-word-count-generic.rs index 086aba0ac40..f48b05d0f17 100644 --- a/src/test/bench/task-perf-word-count-generic.rs +++ b/src/test/bench/task-perf-word-count-generic.rs @@ -20,7 +20,7 @@ import std::map; import std::map::hashmap; import vec; import io; -import io::writer_util; +import io::WriterUtil; import std::time; import u64; @@ -73,7 +73,7 @@ fn join(t: joinable_task) { t.recv() } -impl io::reader: word_reader { +impl io::Reader: word_reader { fn read_word() -> option<~str> { read_word(self) } } @@ -331,7 +331,7 @@ fn main(argv: ~[~str]) { + u64::str(elapsed) + ~"ms"); } -fn read_word(r: io::reader) -> option<~str> { +fn read_word(r: io::Reader) -> option<~str> { let mut w = ~""; while !r.eof() { @@ -350,7 +350,7 @@ fn is_word_char(c: char) -> bool { class random_word_reader: word_reader { let mut remaining: uint; - let rng: rand::rng; + let rng: rand::Rng; new(count: uint) { self.remaining = count; self.rng = rand::rng(); diff --git a/src/test/run-fail/issue-2156.rs b/src/test/run-fail/issue-2156.rs index f0ef08b6558..8084558ab69 100644 --- a/src/test/run-fail/issue-2156.rs +++ b/src/test/run-fail/issue-2156.rs @@ -1,7 +1,7 @@ // error-pattern:explicit failure // Don't double free the string use std; -import io::reader; +import io::Reader; fn main() { do io::with_str_reader(~"") |rdr| { diff --git a/src/test/run-pass-fulldeps/qquote.rs b/src/test/run-pass-fulldeps/qquote.rs index d531c5ca647..4a36e7a1c46 100644 --- a/src/test/run-pass-fulldeps/qquote.rs +++ b/src/test/run-pass-fulldeps/qquote.rs @@ -85,7 +85,7 @@ fn main() { fn check_pp(expr: T, f: fn(pprust::ps, T), expect: ~str) { let buf = mem_buffer(); - let pp = pprust::rust_printer(buf as io::writer); + let pp = pprust::rust_printer(buf as io::Writer); f(pp, expr); pp::eof(pp.s); let str = mem_buffer_str(buf); diff --git a/src/test/run-pass/auto_serialize.rs b/src/test/run-pass/auto_serialize.rs index 25ade45e2d6..cd7abd4b400 100644 --- a/src/test/run-pass/auto_serialize.rs +++ b/src/test/run-pass/auto_serialize.rs @@ -4,14 +4,14 @@ use std; // the common code. import std::ebml; -import io::writer; +import io::Writer; import std::serialization::{serialize_uint, deserialize_uint}; fn test_ser_and_deser(a1: A, expected: ~str, ebml_ser_fn: fn(ebml::writer, A), ebml_deser_fn: fn(ebml::ebml_deserializer) -> A, - io_ser_fn: fn(io::writer, A)) { + io_ser_fn: fn(io::Writer, A)) { // check the pretty printer: io_ser_fn(io::stdout(), a1); @@ -21,7 +21,7 @@ fn test_ser_and_deser(a1: A, // check the EBML serializer: let buf = io::mem_buffer(); - let w = ebml::writer(buf as io::writer); + let w = ebml::writer(buf as io::Writer); ebml_ser_fn(w, a1); let d = ebml::doc(@io::mem_buffer_buf(buf)); let a2 = ebml_deser_fn(ebml::ebml_deserializer(d)); diff --git a/src/test/run-pass/issue-2804.rs b/src/test/run-pass/issue-2804.rs index 5066ff573b9..e245fba4f66 100644 --- a/src/test/run-pass/issue-2804.rs +++ b/src/test/run-pass/issue-2804.rs @@ -1,6 +1,6 @@ use std; import io; -import io::writer_util; +import io::WriterUtil; import std::map::hashmap; enum object diff --git a/src/test/run-pass/issue-2904.rs b/src/test/run-pass/issue-2904.rs index 467ebd824ce..c75880e146a 100644 --- a/src/test/run-pass/issue-2904.rs +++ b/src/test/run-pass/issue-2904.rs @@ -45,8 +45,8 @@ fn square_from_char(c: char) -> square { } } -fn read_board_grid(+in: rdr) -> ~[~[square]] { - let in = in as io::reader; +fn read_board_grid(+in: rdr) -> ~[~[square]] { + let in = in as io::Reader; let mut grid = ~[]; for in.each_line |line| { let mut row = ~[];