bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

std: Remove usage of fmt!

Browse source
This commit is contained in:
Alex Crichton 2013-09-27 17:02:31 -07:00
parent aaf6cc3a84
commit a8ba31dbf3
68 changed files with 497 additions and 509 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/libstd/at_vec.rs
View file

@ -236,7 +236,7 @@ pub mod raw {
let alloc = n * (*ty).size; let alloc = n * (*ty).size;
let total_size = alloc + sys::size_of::<Vec<()>>(); let total_size = alloc + sys::size_of::<Vec<()>>();
if alloc / (*ty).size != n || total_size < alloc { if alloc / (*ty).size != n || total_size < alloc {
fail!("vector size is too large: %u", n); fail2!("vector size is too large: {}", n);
} }
(*ptr) = local_realloc(*ptr as *(), total_size) as *mut Box<Vec<()>>; (*ptr) = local_realloc(*ptr as *(), total_size) as *mut Box<Vec<()>>;
(**ptr).data.alloc = alloc; (**ptr).data.alloc = alloc;

8
src/libstd/c_str.rs
View file

@ -116,7 +116,7 @@ impl CString {
/// ///
/// Fails if the CString is null. /// Fails if the CString is null.
pub fn with_ref<T>(&self, f: &fn(*libc::c_char) -> T) -> T { pub fn with_ref<T>(&self, f: &fn(*libc::c_char) -> T) -> T {
if self.buf.is_null() { fail!("CString is null!"); } if self.buf.is_null() { fail2!("CString is null!"); }
f(self.buf) f(self.buf)
} }
@ -126,7 +126,7 @@ impl CString {
/// ///
/// Fails if the CString is null. /// Fails if the CString is null.
pub fn with_mut_ref<T>(&mut self, f: &fn(*mut libc::c_char) -> T) -> T { pub fn with_mut_ref<T>(&mut self, f: &fn(*mut libc::c_char) -> T) -> T {
if self.buf.is_null() { fail!("CString is null!"); } if self.buf.is_null() { fail2!("CString is null!"); }
f(unsafe { cast::transmute_mut_unsafe(self.buf) }) f(unsafe { cast::transmute_mut_unsafe(self.buf) })
} }
@ -152,7 +152,7 @@ impl CString {
/// Fails if the CString is null. /// Fails if the CString is null.
#[inline] #[inline]
pub fn as_bytes<'a>(&'a self) -> &'a [u8] { pub fn as_bytes<'a>(&'a self) -> &'a [u8] {
if self.buf.is_null() { fail!("CString is null!"); } if self.buf.is_null() { fail2!("CString is null!"); }
unsafe { unsafe {
cast::transmute((self.buf, self.len() + 1)) cast::transmute((self.buf, self.len() + 1))
} }
@ -273,7 +273,7 @@ impl<'self> ToCStr for &'self [u8] {
do self.as_imm_buf |self_buf, self_len| { do self.as_imm_buf |self_buf, self_len| {
let buf = libc::malloc(self_len as libc::size_t + 1) as *mut u8; let buf = libc::malloc(self_len as libc::size_t + 1) as *mut u8;
if buf.is_null() { if buf.is_null() {
fail!("failed to allocate memory!"); fail2!("failed to allocate memory!");
} }
ptr::copy_memory(buf, self_buf, self_len); ptr::copy_memory(buf, self_buf, self_len);

4
src/libstd/cell.rs
View file

@ -44,7 +44,7 @@ impl<T> Cell<T> {
pub fn take(&self) -> T { pub fn take(&self) -> T {
let this = unsafe { transmute_mut(self) }; let this = unsafe { transmute_mut(self) };
if this.is_empty() { if this.is_empty() {
fail!("attempt to take an empty cell"); fail2!("attempt to take an empty cell");
} }
this.value.take_unwrap() this.value.take_unwrap()
@ -60,7 +60,7 @@ impl<T> Cell<T> {
pub fn put_back(&self, value: T) { pub fn put_back(&self, value: T) {
let this = unsafe { transmute_mut(self) }; let this = unsafe { transmute_mut(self) };
if !this.is_empty() { if !this.is_empty() {
fail!("attempt to put a value back into a full cell"); fail2!("attempt to put a value back into a full cell");
} }
this.value = Some(value); this.value = Some(value);
} }

6
src/libstd/char.rs
View file

@ -187,7 +187,7 @@ pub fn is_digit_radix(c: char, radix: uint) -> bool {
#[inline] #[inline]
pub fn to_digit(c: char, radix: uint) -> Option<uint> { pub fn to_digit(c: char, radix: uint) -> Option<uint> {
if radix > 36 { if radix > 36 {
fail!("to_digit: radix %? is to high (maximum 36)", radix); fail2!("to_digit: radix {} is to high (maximum 36)", radix);
} }
let val = match c { let val = match c {
'0' .. '9' => c as uint - ('0' as uint), '0' .. '9' => c as uint - ('0' as uint),
@ -214,7 +214,7 @@ pub fn to_digit(c: char, radix: uint) -> Option<uint> {
#[inline] #[inline]
pub fn from_digit(num: uint, radix: uint) -> Option<char> { pub fn from_digit(num: uint, radix: uint) -> Option<char> {
if radix > 36 { if radix > 36 {
fail!("from_digit: radix %? is to high (maximum 36)", num); fail2!("from_digit: radix {} is to high (maximum 36)", num);
} }
if num < radix { if num < radix {
unsafe { unsafe {
@ -342,7 +342,7 @@ pub fn len_utf8_bytes(c: char) -> uint {
_ if code < MAX_TWO_B => 2u, _ if code < MAX_TWO_B => 2u,
_ if code < MAX_THREE_B => 3u, _ if code < MAX_THREE_B => 3u,
_ if code < MAX_FOUR_B => 4u, _ if code < MAX_FOUR_B => 4u,
_ => fail!("invalid character!"), _ => fail2!("invalid character!"),
} }
} }

40
src/libstd/condition.rs
View file

@ -56,7 +56,7 @@ do my_error::cond.trap(|raised_int| {
Condition handling is useful in cases where propagating errors is either to Condition handling is useful in cases where propagating errors is either to
cumbersome or just not necessary in the first place. It should also be noted, cumbersome or just not necessary in the first place. It should also be noted,
though, that if there is not handler installed when a condition is raised, then though, that if there is not handler installed when a condition is raised, then
the task invokes `fail!()` and will terminate. the task invokes `fail2!()` and will terminate.
## More Info ## More Info
@ -127,8 +127,8 @@ impl<T, U> Condition<T, U> {
/// If a handler is found, its return value is returned, otherwise this /// If a handler is found, its return value is returned, otherwise this
/// function will not return. /// function will not return.
pub fn raise(&self, t: T) -> U { pub fn raise(&self, t: T) -> U {
let msg = fmt!("Unhandled condition: %s: %?", self.name, t); let msg = format!("Unhandled condition: {}: {:?}", self.name, t);
self.raise_default(t, || fail!(msg.clone())) self.raise_default(t, || fail2!("{}", msg.clone()))
} }
/// Performs the same functionality as `raise`, except that when no handler /// Performs the same functionality as `raise`, except that when no handler
@ -136,11 +136,11 @@ impl<T, U> Condition<T, U> {
pub fn raise_default(&self, t: T, default: &fn() -> U) -> U { pub fn raise_default(&self, t: T, default: &fn() -> U) -> U {
match local_data::pop(self.key) { match local_data::pop(self.key) {
None => { None => {
debug!("Condition.raise: found no handler"); debug2!("Condition.raise: found no handler");
default() default()
} }
Some(handler) => { Some(handler) => {
debug!("Condition.raise: found handler"); debug2!("Condition.raise: found handler");
match handler.prev { match handler.prev {
None => {} None => {}
Some(hp) => local_data::set(self.key, hp) Some(hp) => local_data::set(self.key, hp)
@ -183,7 +183,7 @@ impl<'self, T, U> Trap<'self, T, U> {
/// ``` /// ```
pub fn inside<V>(&self, inner: &'self fn() -> V) -> V { pub fn inside<V>(&self, inner: &'self fn() -> V) -> V {
let _g = Guard { cond: self.cond }; let _g = Guard { cond: self.cond };
debug!("Trap: pushing handler to TLS"); debug2!("Trap: pushing handler to TLS");
local_data::set(self.cond.key, self.handler); local_data::set(self.cond.key, self.handler);
inner() inner()
} }
@ -197,7 +197,7 @@ struct Guard<'self, T, U> {
#[unsafe_destructor] #[unsafe_destructor]
impl<'self, T, U> Drop for Guard<'self, T, U> { impl<'self, T, U> Drop for Guard<'self, T, U> {
fn drop(&mut self) { fn drop(&mut self) {
debug!("Guard: popping handler from TLS"); debug2!("Guard: popping handler from TLS");
let curr = local_data::pop(self.cond.key); let curr = local_data::pop(self.cond.key);
match curr { match curr {
None => {} None => {}
@ -216,20 +216,20 @@ mod test {
} }
fn trouble(i: int) { fn trouble(i: int) {
debug!("trouble: raising condition"); debug2!("trouble: raising condition");
let j = sadness::cond.raise(i); let j = sadness::cond.raise(i);
debug!("trouble: handler recovered with %d", j); debug2!("trouble: handler recovered with {}", j);
} }
fn nested_trap_test_inner() { fn nested_trap_test_inner() {
let mut inner_trapped = false; let mut inner_trapped = false;
do sadness::cond.trap(|_j| { do sadness::cond.trap(|_j| {
debug!("nested_trap_test_inner: in handler"); debug2!("nested_trap_test_inner: in handler");
inner_trapped = true; inner_trapped = true;
0 0
}).inside { }).inside {
debug!("nested_trap_test_inner: in protected block"); debug2!("nested_trap_test_inner: in protected block");
trouble(1); trouble(1);
} }
@ -241,10 +241,10 @@ mod test {
let mut outer_trapped = false; let mut outer_trapped = false;
do sadness::cond.trap(|_j| { do sadness::cond.trap(|_j| {
debug!("nested_trap_test_outer: in handler"); debug2!("nested_trap_test_outer: in handler");
outer_trapped = true; 0 outer_trapped = true; 0
}).inside { }).inside {
debug!("nested_guard_test_outer: in protected block"); debug2!("nested_guard_test_outer: in protected block");
nested_trap_test_inner(); nested_trap_test_inner();
trouble(1); trouble(1);
} }
@ -256,13 +256,13 @@ mod test {
let mut inner_trapped = false; let mut inner_trapped = false;
do sadness::cond.trap(|_j| { do sadness::cond.trap(|_j| {
debug!("nested_reraise_trap_test_inner: in handler"); debug2!("nested_reraise_trap_test_inner: in handler");
inner_trapped = true; inner_trapped = true;
let i = 10; let i = 10;
debug!("nested_reraise_trap_test_inner: handler re-raising"); debug2!("nested_reraise_trap_test_inner: handler re-raising");
sadness::cond.raise(i) sadness::cond.raise(i)
}).inside { }).inside {
debug!("nested_reraise_trap_test_inner: in protected block"); debug2!("nested_reraise_trap_test_inner: in protected block");
trouble(1); trouble(1);
} }
@ -274,10 +274,10 @@ mod test {
let mut outer_trapped = false; let mut outer_trapped = false;
do sadness::cond.trap(|_j| { do sadness::cond.trap(|_j| {
debug!("nested_reraise_trap_test_outer: in handler"); debug2!("nested_reraise_trap_test_outer: in handler");
outer_trapped = true; 0 outer_trapped = true; 0
}).inside { }).inside {
debug!("nested_reraise_trap_test_outer: in protected block"); debug2!("nested_reraise_trap_test_outer: in protected block");
nested_reraise_trap_test_inner(); nested_reraise_trap_test_inner();
} }
@ -289,10 +289,10 @@ mod test {
let mut trapped = false; let mut trapped = false;
do sadness::cond.trap(|j| { do sadness::cond.trap(|j| {
debug!("test_default: in handler"); debug2!("test_default: in handler");
sadness::cond.raise_default(j, || { trapped=true; 5 }) sadness::cond.raise_default(j, || { trapped=true; 5 })
}).inside { }).inside {
debug!("test_default: in protected block"); debug2!("test_default: in protected block");
trouble(1); trouble(1);
} }

4
src/libstd/either.rs
View file

@ -78,7 +78,7 @@ impl<L, R> Either<L, R> {
pub fn expect_left(self, reason: &str) -> L { pub fn expect_left(self, reason: &str) -> L {
match self { match self {
Left(x) => x, Left(x) => x,
Right(_) => fail!(reason.to_owned()) Right(_) => fail2!("{}", reason.to_owned())
} }
} }
@ -94,7 +94,7 @@ impl<L, R> Either<L, R> {
pub fn expect_right(self, reason: &str) -> R { pub fn expect_right(self, reason: &str) -> R {
match self { match self {
Right(x) => x, Right(x) => x,
Left(_) => fail!(reason.to_owned()) Left(_) => fail2!("{}", reason.to_owned())
} }
} }

11
src/libstd/fmt/parse.rs
View file

@ -234,7 +234,7 @@ impl<'self> Parser<'self> {
Some((_, c @ '#')) | Some((_, c @ '{')) | Some((_, c @ '#')) | Some((_, c @ '{')) |
Some((_, c @ '\\')) | Some((_, c @ '}')) => { c } Some((_, c @ '\\')) | Some((_, c @ '}')) => { c }
Some((_, c)) => { Some((_, c)) => {
self.err(fmt!("invalid escape character `%c`", c)); self.err(format!("invalid escape character `{}`", c));
c c
} }
None => { None => {
@ -378,7 +378,7 @@ impl<'self> Parser<'self> {
return None; return None;
} }
method => { method => {
self.err(fmt!("unknown method: `%s`", method)); self.err(format!("unknown method: `{}`", method));
return None; return None;
} }
} }
@ -448,8 +448,8 @@ impl<'self> Parser<'self> {
Some((_, 'f')) => { Some((_, 'f')) => {
let word = self.word(); let word = self.word();
if word != "offset" { if word != "offset" {
self.err(fmt!("expected `offset`, found `%s`", self.err(format!("expected `offset`, found `{}`",
word)); word));
} else { } else {
if !self.consume(':') { if !self.consume(':') {
self.err(~"`offset` must be followed by `:`"); self.err(~"`offset` must be followed by `:`");
@ -490,7 +490,8 @@ impl<'self> Parser<'self> {
"few" => Left(Few), "few" => Left(Few),
"many" => Left(Many), "many" => Left(Many),
word => { word => {
self.err(fmt!("unexpected plural selector `%s`", word)); self.err(format!("unexpected plural selector `{}`",
word));
if word == "" { if word == "" {
break break
} else { } else {

6
src/libstd/hash.rs
View file

@ -493,10 +493,10 @@ mod tests {
} }
while t < 64 { while t < 64 {
debug!("siphash test %?", t); debug2!("siphash test {}", t);
let vec = u8to64_le!(vecs[t], 0); let vec = u8to64_le!(vecs[t], 0);
let out = Bytes(buf.as_slice()).hash_keyed(k0, k1); let out = Bytes(buf.as_slice()).hash_keyed(k0, k1);
debug!("got %?, expected %?", out, vec); debug2!("got {:?}, expected {:?}", out, vec);
assert_eq!(vec, out); assert_eq!(vec, out);
stream_full.reset(); stream_full.reset();
@ -504,7 +504,7 @@ mod tests {
let f = stream_full.result_str(); let f = stream_full.result_str();
let i = stream_inc.result_str(); let i = stream_inc.result_str();
let v = to_hex_str(&vecs[t]); let v = to_hex_str(&vecs[t]);
debug!("%d: (%s) => inc=%s full=%s", t, v, i, f); debug2!("{}: ({}) => inc={} full={}", t, v, i, f);
assert!(f == i && f == v); assert!(f == i && f == v);

16
src/libstd/hashmap.rs
View file

@ -179,7 +179,7 @@ impl<K:Hash + Eq,V> HashMap<K, V> {
fn value_for_bucket<'a>(&'a self, idx: uint) -> &'a V { fn value_for_bucket<'a>(&'a self, idx: uint) -> &'a V {
match self.buckets[idx] { match self.buckets[idx] {
Some(ref bkt) => &bkt.value, Some(ref bkt) => &bkt.value,
None => fail!("HashMap::find: internal logic error"), None => fail2!("HashMap::find: internal logic error"),
} }
} }
@ -196,7 +196,7 @@ impl<K:Hash + Eq,V> HashMap<K, V> {
/// True if there was no previous entry with that key /// True if there was no previous entry with that key
fn insert_internal(&mut self, hash: uint, k: K, v: V) -> Option<V> { fn insert_internal(&mut self, hash: uint, k: K, v: V) -> Option<V> {
match self.bucket_for_key_with_hash(hash, &k) { match self.bucket_for_key_with_hash(hash, &k) {
TableFull => { fail!("Internal logic error"); } TableFull => { fail2!("Internal logic error"); }
FoundHole(idx) => { FoundHole(idx) => {
self.buckets[idx] = Some(Bucket{hash: hash, key: k, self.buckets[idx] = Some(Bucket{hash: hash, key: k,
value: v}); value: v});
@ -205,7 +205,7 @@ impl<K:Hash + Eq,V> HashMap<K, V> {
} }
FoundEntry(idx) => { FoundEntry(idx) => {
match self.buckets[idx] { match self.buckets[idx] {
None => { fail!("insert_internal: Internal logic error") } None => { fail2!("insert_internal: Internal logic error") }
Some(ref mut b) => { Some(ref mut b) => {
b.hash = hash; b.hash = hash;
b.key = k; b.key = k;
@ -374,7 +374,7 @@ impl<K: Hash + Eq, V> HashMap<K, V> {
let hash = k.hash_keyed(self.k0, self.k1) as uint; let hash = k.hash_keyed(self.k0, self.k1) as uint;
let idx = match self.bucket_for_key_with_hash(hash, &k) { let idx = match self.bucket_for_key_with_hash(hash, &k) {
TableFull => fail!("Internal logic error"), TableFull => fail2!("Internal logic error"),
FoundEntry(idx) => { found(&k, self.mut_value_for_bucket(idx), a); idx } FoundEntry(idx) => { found(&k, self.mut_value_for_bucket(idx), a); idx }
FoundHole(idx) => { FoundHole(idx) => {
let v = not_found(&k, a); let v = not_found(&k, a);
@ -413,7 +413,7 @@ impl<K: Hash + Eq, V> HashMap<K, V> {
pub fn get<'a>(&'a self, k: &K) -> &'a V { pub fn get<'a>(&'a self, k: &K) -> &'a V {
match self.find(k) { match self.find(k) {
Some(v) => v, Some(v) => v,
None => fail!("No entry found for key: %?", k), None => fail2!("No entry found for key: {:?}", k),
} }
} }
@ -422,7 +422,7 @@ impl<K: Hash + Eq, V> HashMap<K, V> {
pub fn get_mut<'a>(&'a mut self, k: &K) -> &'a mut V { pub fn get_mut<'a>(&'a mut self, k: &K) -> &'a mut V {
match self.find_mut(k) { match self.find_mut(k) {
Some(v) => v, Some(v) => v,
None => fail!("No entry found for key: %?", k), None => fail2!("No entry found for key: {:?}", k),
} }
} }
@ -826,7 +826,7 @@ mod test_map {
assert!(m.insert(5, 14)); assert!(m.insert(5, 14));
let new = 100; let new = 100;
match m.find_mut(&5) { match m.find_mut(&5) {
None => fail!(), Some(x) => *x = new None => fail2!(), Some(x) => *x = new
} }
assert_eq!(m.find(&5), Some(&new)); assert_eq!(m.find(&5), Some(&new));
} }
@ -943,7 +943,7 @@ mod test_map {
assert!(m.find(&1).is_none()); assert!(m.find(&1).is_none());
m.insert(1, 2); m.insert(1, 2);
match m.find(&1) { match m.find(&1) {
None => fail!(), None => fail2!(),
Some(v) => assert!(*v == 2) Some(v) => assert!(*v == 2)
} }
} }

41
src/libstd/io.rs
View file

@ -947,9 +947,8 @@ impl Reader for *libc::FILE {
match libc::ferror(*self) { match libc::ferror(*self) {
0 => (), 0 => (),
_ => { _ => {
error!("error reading buffer"); error2!("error reading buffer: {}", os::last_os_error());
error!("%s", os::last_os_error()); fail2!();
fail!();
} }
} }
} }
@ -1194,9 +1193,8 @@ impl Writer for *libc::FILE {
len as size_t, len as size_t,
*self); *self);
if nout != len as size_t { if nout != len as size_t {
error!("error writing buffer"); error2!("error writing buffer: {}", os::last_os_error());
error!("%s", os::last_os_error()); fail2!();
fail!();
} }
} }
} }
@ -1264,9 +1262,8 @@ impl Writer for fd_t {
let vb = ptr::offset(vbuf, count as int) as *c_void; let vb = ptr::offset(vbuf, count as int) as *c_void;
let nout = libc::write(*self, vb, len as IoSize); let nout = libc::write(*self, vb, len as IoSize);
if nout < 0 as IoRet { if nout < 0 as IoRet {
error!("error writing buffer"); error2!("error writing buffer: {}", os::last_os_error());
error!("%s", os::last_os_error()); fail2!();
fail!();
} }
count += nout as uint; count += nout as uint;
} }
@ -1274,12 +1271,12 @@ impl Writer for fd_t {
} }
} }
fn seek(&self, _offset: int, _whence: SeekStyle) { fn seek(&self, _offset: int, _whence: SeekStyle) {
error!("need 64-bit foreign calls for seek, sorry"); error2!("need 64-bit foreign calls for seek, sorry");
fail!(); fail2!();
} }
fn tell(&self) -> uint { fn tell(&self) -> uint {
error!("need 64-bit foreign calls for tell, sorry"); error2!("need 64-bit foreign calls for tell, sorry");
fail!(); fail2!();
} }
fn flush(&self) -> int { 0 } fn flush(&self) -> int { 0 }
fn get_type(&self) -> WriterType { fn get_type(&self) -> WriterType {
@ -1347,7 +1344,7 @@ pub fn mk_file_writer(path: &Path, flags: &[FileFlag])
} }
}; };
if fd < (0 as c_int) { if fd < (0 as c_int) {
Err(fmt!("error opening %s: %s", path.to_str(), os::last_os_error())) Err(format!("error opening {}: {}", path.to_str(), os::last_os_error()))
} else { } else {
Ok(fd_writer(fd, true)) Ok(fd_writer(fd, true))
} }
@ -1924,17 +1921,17 @@ mod tests {
#[test] #[test]
fn test_simple() { fn test_simple() {
let tmpfile = &Path("tmp/lib-io-test-simple.tmp"); let tmpfile = &Path("tmp/lib-io-test-simple.tmp");
debug!(tmpfile); debug2!("{:?}", tmpfile);
let frood: ~str = let frood: ~str =
~"A hoopy frood who really knows where his towel is."; ~"A hoopy frood who really knows where his towel is.";
debug!(frood.clone()); debug2!("{}", frood.clone());
{ {
let out = io::file_writer(tmpfile, [io::Create, io::Truncate]).unwrap(); let out = io::file_writer(tmpfile, [io::Create, io::Truncate]).unwrap();
out.write_str(frood); out.write_str(frood);
} }
let inp = io::file_reader(tmpfile).unwrap(); let inp = io::file_reader(tmpfile).unwrap();
let frood2: ~str = inp.read_c_str(); let frood2: ~str = inp.read_c_str();
debug!(frood2.clone()); debug2!("{}", frood2.clone());
assert_eq!(frood, frood2); assert_eq!(frood, frood2);
} }
@ -1951,14 +1948,14 @@ mod tests {
{ {
let file = io::file_reader(&path).unwrap(); let file = io::file_reader(&path).unwrap();
do file.each_byte() |_| { do file.each_byte() |_| {
fail!("must be empty") fail2!("must be empty")
}; };
} }
{ {
let file = io::file_reader(&path).unwrap(); let file = io::file_reader(&path).unwrap();
do file.each_char() |_| { do file.each_char() |_| {
fail!("must be empty") fail2!("must be empty")
}; };
} }
} }
@ -2045,7 +2042,7 @@ mod tests {
Err(e) => { Err(e) => {
assert_eq!(e, ~"error opening not a file"); assert_eq!(e, ~"error opening not a file");
} }
Ok(_) => fail!() Ok(_) => fail2!()
} }
} }
@ -2085,7 +2082,7 @@ mod tests {
Err(e) => { Err(e) => {
assert!(e.starts_with("error opening")); assert!(e.starts_with("error opening"));
} }
Ok(_) => fail!() Ok(_) => fail2!()
} }
} }
@ -2095,7 +2092,7 @@ mod tests {
Err(e) => { Err(e) => {
assert!(e.starts_with("error opening")); assert!(e.starts_with("error opening"));
} }
Ok(_) => fail!() Ok(_) => fail2!()
} }
} }

12
src/libstd/iter.rs
View file

@ -723,7 +723,7 @@ pub trait ExactSize<A> : DoubleEndedIterator<A> {
Some(x) => { Some(x) => {
i = match i.checked_sub(&1) { i = match i.checked_sub(&1) {
Some(x) => x, Some(x) => x,
None => fail!("rposition: incorrect ExactSize") None => fail2!("rposition: incorrect ExactSize")
}; };
if predicate(x) { if predicate(x) {
return Some(i) return Some(i)
@ -2452,7 +2452,7 @@ mod tests {
assert!(v.iter().all(|&x| x < 10)); assert!(v.iter().all(|&x| x < 10));
assert!(!v.iter().all(|&x| x.is_even())); assert!(!v.iter().all(|&x| x.is_even()));
assert!(!v.iter().all(|&x| x > 100)); assert!(!v.iter().all(|&x| x > 100));
assert!(v.slice(0, 0).iter().all(|_| fail!())); assert!(v.slice(0, 0).iter().all(|_| fail2!()));
} }
#[test] #[test]
@ -2461,7 +2461,7 @@ mod tests {
assert!(v.iter().any(|&x| x < 10)); assert!(v.iter().any(|&x| x < 10));
assert!(v.iter().any(|&x| x.is_even())); assert!(v.iter().any(|&x| x.is_even()));
assert!(!v.iter().any(|&x| x > 100)); assert!(!v.iter().any(|&x| x > 100));
assert!(!v.slice(0, 0).iter().any(|_| fail!())); assert!(!v.slice(0, 0).iter().any(|_| fail2!()));
} }
#[test] #[test]
@ -2602,7 +2602,7 @@ mod tests {
let mut i = 0; let mut i = 0;
do v.iter().rposition |_elt| { do v.iter().rposition |_elt| {
if i == 2 { if i == 2 {
fail!() fail2!()
} }
i += 1; i += 1;
false false
@ -2746,12 +2746,12 @@ mod tests {
fn test_double_ended_range() { fn test_double_ended_range() {
assert_eq!(range(11i, 14).invert().collect::<~[int]>(), ~[13i, 12, 11]); assert_eq!(range(11i, 14).invert().collect::<~[int]>(), ~[13i, 12, 11]);
for _ in range(10i, 0).invert() { for _ in range(10i, 0).invert() {
fail!("unreachable"); fail2!("unreachable");
} }
assert_eq!(range(11u, 14).invert().collect::<~[uint]>(), ~[13u, 12, 11]); assert_eq!(range(11u, 14).invert().collect::<~[uint]>(), ~[13u, 12, 11]);
for _ in range(10u, 0).invert() { for _ in range(10u, 0).invert() {
fail!("unreachable"); fail2!("unreachable");
} }
} }

22
src/libstd/local_data.rs
View file

@ -143,8 +143,8 @@ pub fn pop<T: 'static>(key: Key<T>) -> Option<T> {
match *entry { match *entry {
Some((k, _, loan)) if k == key_value => { Some((k, _, loan)) if k == key_value => {
if loan != NoLoan { if loan != NoLoan {
fail!("TLS value cannot be removed because it is currently \ fail2!("TLS value cannot be removed because it is currently \
borrowed as %s", loan.describe()); borrowed as {}", loan.describe());
} }
// Move the data out of the `entry` slot via util::replace. // Move the data out of the `entry` slot via util::replace.
// This is guaranteed to succeed because we already matched // This is guaranteed to succeed because we already matched
@ -240,8 +240,8 @@ fn get_with<T: 'static, U>(key: Key<T>,
} }
(ImmLoan, ImmLoan) => {} (ImmLoan, ImmLoan) => {}
(want, cur) => { (want, cur) => {
fail!("TLS slot cannot be borrowed as %s because \ fail2!("TLS slot cannot be borrowed as {} because \
it is already borrowed as %s", it is already borrowed as {}",
want.describe(), cur.describe()); want.describe(), cur.describe());
} }
} }
@ -304,8 +304,8 @@ pub fn set<T: 'static>(key: Key<T>, data: T) {
match *entry { match *entry {
Some((ekey, _, loan)) if key == ekey => { Some((ekey, _, loan)) if key == ekey => {
if loan != NoLoan { if loan != NoLoan {
fail!("TLS value cannot be overwritten because it is fail2!("TLS value cannot be overwritten because it is
already borrowed as %s", loan.describe()) already borrowed as {}", loan.describe())
} }
true true
} }
@ -388,15 +388,15 @@ mod tests {
static my_key: Key<@~str> = &Key; static my_key: Key<@~str> = &Key;
modify(my_key, |data| { modify(my_key, |data| {
match data { match data {
Some(@ref val) => fail!("unwelcome value: %s", *val), Some(@ref val) => fail2!("unwelcome value: {}", *val),
None => Some(@~"first data") None => Some(@~"first data")
} }
}); });
modify(my_key, |data| { modify(my_key, |data| {
match data { match data {
Some(@~"first data") => Some(@~"next data"), Some(@~"first data") => Some(@~"next data"),
Some(@ref val) => fail!("wrong value: %s", *val), Some(@ref val) => fail2!("wrong value: {}", *val),
None => fail!("missing value") None => fail2!("missing value")
} }
}); });
assert!(*(pop(my_key).unwrap()) == ~"next data"); assert!(*(pop(my_key).unwrap()) == ~"next data");
@ -456,11 +456,11 @@ mod tests {
set(str_key, @~"string data"); set(str_key, @~"string data");
set(box_key, @@()); set(box_key, @@());
set(int_key, @42); set(int_key, @42);
fail!(); fail2!();
} }
// Not quite nondeterministic. // Not quite nondeterministic.
set(int_key, @31337); set(int_key, @31337);
fail!(); fail2!();
} }
#[test] #[test]

19
src/libstd/macros.rs
View file

@ -12,16 +12,16 @@
#[doc(hidden)]; #[doc(hidden)];
macro_rules! rterrln ( macro_rules! rterrln (
($( $arg:expr),+) => ( { ($($arg:tt)*) => ( {
::rt::util::dumb_println(fmt!( $($arg),+ )); ::rt::util::dumb_println(format!($($arg)*));
} ) } )
) )
// Some basic logging. Enabled by passing `--cfg rtdebug` to the libstd build. // Some basic logging. Enabled by passing `--cfg rtdebug` to the libstd build.
macro_rules! rtdebug ( macro_rules! rtdebug (
($( $arg:expr),+) => ( { ($($arg:tt)*) => ( {
if cfg!(rtdebug) { if cfg!(rtdebug) {
rterrln!( $($arg),+ ) rterrln!($($arg)*)
} }
}) })
) )
@ -30,7 +30,7 @@ macro_rules! rtassert (
( $arg:expr ) => ( { ( $arg:expr ) => ( {
if ::rt::util::ENFORCE_SANITY { if ::rt::util::ENFORCE_SANITY {
if !$arg { if !$arg {
rtabort!("assertion failed: %s", stringify!($arg)); rtabort!("assertion failed: {}", stringify!($arg));
} }
} }
} ) } )
@ -38,13 +38,13 @@ macro_rules! rtassert (
macro_rules! rtabort( macro_rules! rtabort(
($( $msg:expr),+) => ( { ($($msg:tt)*) => ( {
::rt::util::abort(fmt!($($msg),+)); ::rt::util::abort(format!($($msg)*));
} ) } )
) )
macro_rules! assert_once_ever( macro_rules! assert_once_ever(
($( $msg:expr),+) => ( { ($($msg:tt)+) => ( {
// FIXME(#8472) extra function should not be needed to hide unsafe // FIXME(#8472) extra function should not be needed to hide unsafe
fn assert_once_ever() { fn assert_once_ever() {
unsafe { unsafe {
@ -52,7 +52,8 @@ macro_rules! assert_once_ever(
// Double-check lock to avoid a swap in the common case. // Double-check lock to avoid a swap in the common case.
if already_happened != 0 || if already_happened != 0 ||
::unstable::intrinsics::atomic_xchg_relaxed(&mut already_happened, 1) != 0 { ::unstable::intrinsics::atomic_xchg_relaxed(&mut already_happened, 1) != 0 {
fail!(fmt!("assert_once_ever happened twice: %s", fmt!($($msg),+))); fail2!("assert_once_ever happened twice: {}",
format!($($msg)+));
} }
} }
} }

4
src/libstd/num/f32.rs
View file

@ -816,8 +816,8 @@ impl num::ToStrRadix for f32 {
fn to_str_radix(&self, rdx: uint) -> ~str { fn to_str_radix(&self, rdx: uint) -> ~str {
let (r, special) = strconv::float_to_str_common( let (r, special) = strconv::float_to_str_common(
*self, rdx, true, strconv::SignNeg, strconv::DigAll); *self, rdx, true, strconv::SignNeg, strconv::DigAll);
if special { fail!("number has a special value, \ if special { fail2!("number has a special value, \
try to_str_radix_special() if those are expected") } try to_str_radix_special() if those are expected") }
r r
} }
} }

4
src/libstd/num/f64.rs
View file

@ -864,8 +864,8 @@ impl num::ToStrRadix for f64 {
fn to_str_radix(&self, rdx: uint) -> ~str { fn to_str_radix(&self, rdx: uint) -> ~str {
let (r, special) = strconv::float_to_str_common( let (r, special) = strconv::float_to_str_common(
*self, rdx, true, strconv::SignNeg, strconv::DigAll); *self, rdx, true, strconv::SignNeg, strconv::DigAll);
if special { fail!("number has a special value, \ if special { fail2!("number has a special value, \
try to_str_radix_special() if those are expected") } try to_str_radix_special() if those are expected") }
r r
} }
} }

14
src/libstd/num/float.rs
View file

@ -181,7 +181,7 @@ impl num::ToStrRadix for float {
fn to_str_radix(&self, radix: uint) -> ~str { fn to_str_radix(&self, radix: uint) -> ~str {
let (r, special) = strconv::float_to_str_common( let (r, special) = strconv::float_to_str_common(
*self, radix, true, strconv::SignNeg, strconv::DigAll); *self, radix, true, strconv::SignNeg, strconv::DigAll);
if special { fail!("number has a special value, \ if special { fail2!("number has a special value, \
try to_str_radix_special() if those are expected") } try to_str_radix_special() if those are expected") }
r r
} }
@ -1329,16 +1329,16 @@ mod tests {
// note: NaN != NaN, hence this slightly complex test // note: NaN != NaN, hence this slightly complex test
match from_str::<float>("NaN") { match from_str::<float>("NaN") {
Some(f) => assert!(f.is_nan()), Some(f) => assert!(f.is_nan()),
None => fail!() None => fail2!()
} }
// note: -0 == 0, hence these slightly more complex tests // note: -0 == 0, hence these slightly more complex tests
match from_str::<float>("-0") { match from_str::<float>("-0") {
Some(v) if v.is_zero() => assert!(v.is_negative()), Some(v) if v.is_zero() => assert!(v.is_negative()),
_ => fail!() _ => fail2!()
} }
match from_str::<float>("0") { match from_str::<float>("0") {
Some(v) if v.is_zero() => assert!(v.is_positive()), Some(v) if v.is_zero() => assert!(v.is_positive()),
_ => fail!() _ => fail2!()
} }
assert!(from_str::<float>("").is_none()); assert!(from_str::<float>("").is_none());
@ -1376,16 +1376,16 @@ mod tests {
// note: NaN != NaN, hence this slightly complex test // note: NaN != NaN, hence this slightly complex test
match from_str_hex("NaN") { match from_str_hex("NaN") {
Some(f) => assert!(f.is_nan()), Some(f) => assert!(f.is_nan()),
None => fail!() None => fail2!()
} }
// note: -0 == 0, hence these slightly more complex tests // note: -0 == 0, hence these slightly more complex tests
match from_str_hex("-0") { match from_str_hex("-0") {
Some(v) if v.is_zero() => assert!(v.is_negative()), Some(v) if v.is_zero() => assert!(v.is_negative()),
_ => fail!() _ => fail2!()
} }
match from_str_hex("0") { match from_str_hex("0") {
Some(v) if v.is_zero() => assert!(v.is_positive()), Some(v) if v.is_zero() => assert!(v.is_positive()),
_ => fail!() _ => fail2!()
} }
assert_eq!(from_str_hex("e"), Some(14.)); assert_eq!(from_str_hex("e"), Some(14.));
assert_eq!(from_str_hex("E"), Some(14.)); assert_eq!(from_str_hex("E"), Some(14.));

10
src/libstd/num/strconv.rs
View file

@ -474,19 +474,19 @@ pub fn from_str_bytes_common<T:NumCast+Zero+One+Eq+Ord+Div<T,T>+
) -> Option<T> { ) -> Option<T> {
match exponent { match exponent {
ExpDec if radix >= DIGIT_E_RADIX // decimal exponent 'e' ExpDec if radix >= DIGIT_E_RADIX // decimal exponent 'e'
=> fail!("from_str_bytes_common: radix %? incompatible with \ => fail2!("from_str_bytes_common: radix {:?} incompatible with \
use of 'e' as decimal exponent", radix), use of 'e' as decimal exponent", radix),
ExpBin if radix >= DIGIT_P_RADIX // binary exponent 'p' ExpBin if radix >= DIGIT_P_RADIX // binary exponent 'p'
=> fail!("from_str_bytes_common: radix %? incompatible with \ => fail2!("from_str_bytes_common: radix {:?} incompatible with \
use of 'p' as binary exponent", radix), use of 'p' as binary exponent", radix),
_ if special && radix >= DIGIT_I_RADIX // first digit of 'inf' _ if special && radix >= DIGIT_I_RADIX // first digit of 'inf'
=> fail!("from_str_bytes_common: radix %? incompatible with \ => fail2!("from_str_bytes_common: radix {:?} incompatible with \
special values 'inf' and 'NaN'", radix), special values 'inf' and 'NaN'", radix),
_ if (radix as int) < 2 _ if (radix as int) < 2
=> fail!("from_str_bytes_common: radix %? to low, \ => fail2!("from_str_bytes_common: radix {:?} to low, \
must lie in the range [2, 36]", radix), must lie in the range [2, 36]", radix),
_ if (radix as int) > 36 _ if (radix as int) > 36
=> fail!("from_str_bytes_common: radix %? to high, \ => fail2!("from_str_bytes_common: radix {:?} to high, \
must lie in the range [2, 36]", radix), must lie in the range [2, 36]", radix),
_ => () _ => ()
} }

34
src/libstd/option.rs
View file

@ -278,7 +278,7 @@ impl<T> Option<T> {
pub fn get_ref<'a>(&'a self) -> &'a T { pub fn get_ref<'a>(&'a self) -> &'a T {
match *self { match *self {
Some(ref x) => x, Some(ref x) => x,
None => fail!("called `Option::get_ref()` on a `None` value"), None => fail2!("called `Option::get_ref()` on a `None` value"),
} }
} }
@ -298,7 +298,7 @@ impl<T> Option<T> {
pub fn get_mut_ref<'a>(&'a mut self) -> &'a mut T { pub fn get_mut_ref<'a>(&'a mut self) -> &'a mut T {
match *self { match *self {
Some(ref mut x) => x, Some(ref mut x) => x,
None => fail!("called `Option::get_mut_ref()` on a `None` value"), None => fail2!("called `Option::get_mut_ref()` on a `None` value"),
} }
} }
@ -320,7 +320,7 @@ impl<T> Option<T> {
pub fn unwrap(self) -> T { pub fn unwrap(self) -> T {
match self { match self {
Some(x) => x, Some(x) => x,
None => fail!("called `Option::unwrap()` on a `None` value"), None => fail2!("called `Option::unwrap()` on a `None` value"),
} }
} }
@ -333,7 +333,7 @@ impl<T> Option<T> {
#[inline] #[inline]
pub fn take_unwrap(&mut self) -> T { pub fn take_unwrap(&mut self) -> T {
if self.is_none() { if self.is_none() {
fail!("called `Option::take_unwrap()` on a `None` value") fail2!("called `Option::take_unwrap()` on a `None` value")
} }
self.take().unwrap() self.take().unwrap()
} }
@ -348,7 +348,7 @@ impl<T> Option<T> {
pub fn expect(self, reason: &str) -> T { pub fn expect(self, reason: &str) -> T {
match self { match self {
Some(val) => val, Some(val) => val,
None => fail!(reason.to_owned()), None => fail2!("{}", reason.to_owned()),
} }
} }
@ -722,21 +722,23 @@ mod tests {
let new_val = 11; let new_val = 11;
let mut x = Some(val); let mut x = Some(val);
let mut it = x.mut_iter(); {
let mut it = x.mut_iter();
assert_eq!(it.size_hint(), (1, Some(1))); assert_eq!(it.size_hint(), (1, Some(1)));
match it.next() { match it.next() {
Some(interior) => { Some(interior) => {
assert_eq!(*interior, val); assert_eq!(*interior, val);
*interior = new_val; *interior = new_val;
assert_eq!(x, Some(new_val)); }
None => assert!(false),
} }
None => assert!(false),
}
assert_eq!(it.size_hint(), (0, Some(0))); assert_eq!(it.size_hint(), (0, Some(0)));
assert!(it.next().is_none()); assert!(it.next().is_none());
}
assert_eq!(x, Some(new_val));
} }
#[test] #[test]

80
src/libstd/os.rs
View file

@ -75,7 +75,7 @@ pub fn getcwd() -> Path {
do buf.as_mut_buf |buf, len| { do buf.as_mut_buf |buf, len| {
unsafe { unsafe {
if libc::getcwd(buf, len as size_t).is_null() { if libc::getcwd(buf, len as size_t).is_null() {
fail!() fail2!()
} }
Path(str::raw::from_c_str(buf as *c_char)) Path(str::raw::from_c_str(buf as *c_char))
@ -182,7 +182,8 @@ pub fn env() -> ~[(~str,~str)] {
}; };
let ch = GetEnvironmentStringsA(); let ch = GetEnvironmentStringsA();
if (ch as uint == 0) { if (ch as uint == 0) {
fail!("os::env() failure getting env string from OS: %s", os::last_os_error()); fail2!("os::env() failure getting env string from OS: {}",
os::last_os_error());
} }
let result = str::raw::from_c_multistring(ch as *libc::c_char, None); let result = str::raw::from_c_multistring(ch as *libc::c_char, None);
FreeEnvironmentStringsA(ch); FreeEnvironmentStringsA(ch);
@ -197,13 +198,13 @@ pub fn env() -> ~[(~str,~str)] {
} }
let environ = rust_env_pairs(); let environ = rust_env_pairs();
if (environ as uint == 0) { if (environ as uint == 0) {
fail!("os::env() failure getting env string from OS: %s", os::last_os_error()); fail2!("os::env() failure getting env string from OS: {}",
os::last_os_error());
} }
let mut result = ~[]; let mut result = ~[];
ptr::array_each(environ, |e| { ptr::array_each(environ, |e| {
let env_pair = str::raw::from_c_str(e); let env_pair = str::raw::from_c_str(e);
debug!("get_env_pairs: %s", debug2!("get_env_pairs: {}", env_pair);
env_pair);
result.push(env_pair); result.push(env_pair);
}); });
result result
@ -213,8 +214,7 @@ pub fn env() -> ~[(~str,~str)] {
let mut pairs = ~[]; let mut pairs = ~[];
for p in input.iter() { for p in input.iter() {
let vs: ~[&str] = p.splitn_iter('=', 1).collect(); let vs: ~[&str] = p.splitn_iter('=', 1).collect();
debug!("splitting: len: %u", debug2!("splitting: len: {}", vs.len());
vs.len());
assert_eq!(vs.len(), 2); assert_eq!(vs.len(), 2);
pairs.push((vs[0].to_owned(), vs[1].to_owned())); pairs.push((vs[0].to_owned(), vs[1].to_owned()));
} }
@ -443,7 +443,7 @@ fn dup2(src: c_int, dst: c_int) -> c_int {
/// Returns the proper dll filename for the given basename of a file. /// Returns the proper dll filename for the given basename of a file.
pub fn dll_filename(base: &str) -> ~str { pub fn dll_filename(base: &str) -> ~str {
fmt!("%s%s%s", DLL_PREFIX, base, DLL_SUFFIX) format!("{}{}{}", DLL_PREFIX, base, DLL_SUFFIX)
} }
/// Optionally returns the filesystem path to the current executable which is /// Optionally returns the filesystem path to the current executable which is
@ -722,14 +722,14 @@ pub fn list_dir(p: &Path) -> ~[~str] {
fn rust_list_dir_val(ptr: *dirent_t) -> *libc::c_char; fn rust_list_dir_val(ptr: *dirent_t) -> *libc::c_char;
} }
let mut strings = ~[]; let mut strings = ~[];
debug!("os::list_dir -- BEFORE OPENDIR"); debug2!("os::list_dir -- BEFORE OPENDIR");
let dir_ptr = do p.with_c_str |buf| { let dir_ptr = do p.with_c_str |buf| {
opendir(buf) opendir(buf)
}; };
if (dir_ptr as uint != 0) { if (dir_ptr as uint != 0) {
debug!("os::list_dir -- opendir() SUCCESS"); debug2!("os::list_dir -- opendir() SUCCESS");
let mut entry_ptr = readdir(dir_ptr); let mut entry_ptr = readdir(dir_ptr);
while (entry_ptr as uint != 0) { while (entry_ptr as uint != 0) {
strings.push(str::raw::from_c_str(rust_list_dir_val( strings.push(str::raw::from_c_str(rust_list_dir_val(
@ -739,11 +739,9 @@ pub fn list_dir(p: &Path) -> ~[~str] {
closedir(dir_ptr); closedir(dir_ptr);
} }
else { else {
debug!("os::list_dir -- opendir() FAILURE"); debug2!("os::list_dir -- opendir() FAILURE");
} }
debug!( debug2!("os::list_dir -- AFTER -- \\#: {}", strings.len());
"os::list_dir -- AFTER -- #: %?",
strings.len());
strings strings
} }
#[cfg(windows)] #[cfg(windows)]
@ -777,7 +775,7 @@ pub fn list_dir(p: &Path) -> ~[~str] {
while more_files != 0 { while more_files != 0 {
let fp_buf = rust_list_dir_wfd_fp_buf(wfd_ptr); let fp_buf = rust_list_dir_wfd_fp_buf(wfd_ptr);
if fp_buf as uint == 0 { if fp_buf as uint == 0 {
fail!("os::list_dir() failure: got null ptr from wfd"); fail2!("os::list_dir() failure: got null ptr from wfd");
} }
else { else {
let fp_vec = vec::from_buf( let fp_vec = vec::from_buf(
@ -1101,7 +1099,7 @@ pub fn last_os_error() -> ~str {
do buf.as_mut_buf |buf, len| { do buf.as_mut_buf |buf, len| {
unsafe { unsafe {
if strerror_r(errno() as c_int, buf, len as size_t) < 0 { if strerror_r(errno() as c_int, buf, len as size_t) < 0 {
fail!("strerror_r failure"); fail2!("strerror_r failure");
} }
str::raw::from_c_str(buf as *c_char) str::raw::from_c_str(buf as *c_char)
@ -1166,7 +1164,7 @@ pub fn last_os_error() -> ~str {
len as DWORD, len as DWORD,
ptr::null()); ptr::null());
if res == 0 { if res == 0 {
fail!("[%?] FormatMessage failure", errno()); fail2!("[%?] FormatMessage failure", errno());
} }
} }
@ -1222,7 +1220,7 @@ fn real_args() -> ~[~str] {
match rt::args::clone() { match rt::args::clone() {
Some(args) => args, Some(args) => args,
None => fail!("process arguments not initialized") None => fail2!("process arguments not initialized")
} }
} }
@ -1385,13 +1383,13 @@ impl to_str::ToStr for MapError {
negative length or unaligned offset", negative length or unaligned offset",
ErrNoMapSupport=> ~"File doesn't support mapping", ErrNoMapSupport=> ~"File doesn't support mapping",
ErrNoMem => ~"Invalid address, or not enough available memory", ErrNoMem => ~"Invalid address, or not enough available memory",
ErrUnknown(code) => fmt!("Unknown error=%?", code), ErrUnknown(code) => format!("Unknown error={}", code),
ErrUnsupProt => ~"Protection mode unsupported", ErrUnsupProt => ~"Protection mode unsupported",
ErrUnsupOffset => ~"Offset in virtual memory mode is unsupported", ErrUnsupOffset => ~"Offset in virtual memory mode is unsupported",
ErrAlreadyExists => ~"File mapping for specified file already exists", ErrAlreadyExists => ~"File mapping for specified file already exists",
ErrVirtualAlloc(code) => fmt!("VirtualAlloc failure=%?", code), ErrVirtualAlloc(code) => format!("VirtualAlloc failure={}", code),
ErrCreateFileMappingW(code) => fmt!("CreateFileMappingW failure=%?", code), ErrCreateFileMappingW(code) => format!("CreateFileMappingW failure={}", code),
ErrMapViewOfFile(code) => fmt!("MapViewOfFile failure=%?", code) ErrMapViewOfFile(code) => format!("MapViewOfFile failure={}", code)
} }
} }
} }
@ -1466,11 +1464,11 @@ impl Drop for MemoryMap {
unsafe { unsafe {
match libc::munmap(self.data as *c_void, self.len) { match libc::munmap(self.data as *c_void, self.len) {
0 => (), 0 => (),
-1 => error!(match errno() as c_int { -1 => match errno() as c_int {
libc::EINVAL => ~"invalid addr or len", libc::EINVAL => error2!("invalid addr or len"),
e => fmt!("unknown errno=%?", e) e => error2!("unknown errno={}", e)
}), },
r => error!(fmt!("Unexpected result %?", r)) r => error2!("Unexpected result {}", r)
} }
} }
} }
@ -1598,15 +1596,15 @@ impl Drop for MemoryMap {
if libc::VirtualFree(self.data as *mut c_void, if libc::VirtualFree(self.data as *mut c_void,
self.len, self.len,
libc::MEM_RELEASE) == FALSE { libc::MEM_RELEASE) == FALSE {
error!(fmt!("VirtualFree failed: %?", errno())); error!(format!("VirtualFree failed: {}", errno()));
} }
}, },
MapFile(mapping) => { MapFile(mapping) => {
if libc::UnmapViewOfFile(self.data as LPCVOID) == FALSE { if libc::UnmapViewOfFile(self.data as LPCVOID) == FALSE {
error!(fmt!("UnmapViewOfFile failed: %?", errno())); error!(format!("UnmapViewOfFile failed: {}", errno()));
} }
if libc::CloseHandle(mapping as HANDLE) == FALSE { if libc::CloseHandle(mapping as HANDLE) == FALSE {
error!(fmt!("CloseHandle failed: %?", errno())); error!(format!("CloseHandle failed: {}", errno()));
} }
} }
} }
@ -1727,7 +1725,7 @@ mod tests {
#[test] #[test]
pub fn last_os_error() { pub fn last_os_error() {
debug!(os::last_os_error()); debug2!("{}", os::last_os_error());
} }
#[test] #[test]
@ -1782,7 +1780,7 @@ mod tests {
} }
let n = make_rand_name(); let n = make_rand_name();
setenv(n, s); setenv(n, s);
debug!(s.clone()); debug2!("{}", s.clone());
assert_eq!(getenv(n), option::Some(s)); assert_eq!(getenv(n), option::Some(s));
} }
@ -1791,7 +1789,7 @@ mod tests {
let path = os::self_exe_path(); let path = os::self_exe_path();
assert!(path.is_some()); assert!(path.is_some());
let path = path.unwrap(); let path = path.unwrap();
debug!(path.clone()); debug2!("{:?}", path.clone());
// Hard to test this function // Hard to test this function
assert!(path.is_absolute); assert!(path.is_absolute);
@ -1804,7 +1802,7 @@ mod tests {
assert!(e.len() > 0u); assert!(e.len() > 0u);
for p in e.iter() { for p in e.iter() {
let (n, v) = (*p).clone(); let (n, v) = (*p).clone();
debug!(n.clone()); debug2!("{:?}", n.clone());
let v2 = getenv(n); let v2 = getenv(n);
// MingW seems to set some funky environment variables like // MingW seems to set some funky environment variables like
// "=C:=C:\MinGW\msys\1.0\bin" and "!::=::\" that are returned // "=C:=C:\MinGW\msys\1.0\bin" and "!::=::\" that are returned
@ -1829,10 +1827,10 @@ mod tests {
fn test() { fn test() {
assert!((!Path("test-path").is_absolute)); assert!((!Path("test-path").is_absolute));
debug!("Current working directory: %s", getcwd().to_str()); debug2!("Current working directory: {}", getcwd().to_str());
debug!(make_absolute(&Path("test-path"))); debug2!("{:?}", make_absolute(&Path("test-path")));
debug!(make_absolute(&Path("/usr/bin"))); debug2!("{:?}", make_absolute(&Path("/usr/bin")));
} }
#[test] #[test]
@ -1895,7 +1893,7 @@ mod tests {
assert!(dirs.len() > 0u); assert!(dirs.len() > 0u);
for dir in dirs.iter() { for dir in dirs.iter() {
debug!((*dir).clone()); debug2!("{:?}", (*dir).clone());
} }
} }
@ -1969,7 +1967,7 @@ mod tests {
let in_mode = input.get_mode(); let in_mode = input.get_mode();
let rs = os::copy_file(&input, &out); let rs = os::copy_file(&input, &out);
if (!os::path_exists(&input)) { if (!os::path_exists(&input)) {
fail!("%s doesn't exist", input.to_str()); fail2!("{} doesn't exist", input.to_str());
} }
assert!((rs)); assert!((rs));
let rslt = run::process_status("diff", [input.to_str(), out.to_str()]); let rslt = run::process_status("diff", [input.to_str(), out.to_str()]);
@ -2001,7 +1999,7 @@ mod tests {
os::MapWritable os::MapWritable
]) { ]) {
Ok(chunk) => chunk, Ok(chunk) => chunk,
Err(msg) => fail!(msg.to_str()) Err(msg) => fail2!(msg.to_str())
}; };
assert!(chunk.len >= 16); assert!(chunk.len >= 16);
@ -2057,7 +2055,7 @@ mod tests {
MapOffset(size / 2) MapOffset(size / 2)
]) { ]) {
Ok(chunk) => chunk, Ok(chunk) => chunk,
Err(msg) => fail!(msg.to_str()) Err(msg) => fail2!(msg.to_str())
}; };
assert!(chunk.len > 0); assert!(chunk.len > 0);

22
src/libstd/path.rs
View file

@ -134,8 +134,8 @@ pub trait GenericPath : Clone + Eq + ToStr {
match (t.len(), self.filestem()) { match (t.len(), self.filestem()) {
(0, None) => (*self).clone(), (0, None) => (*self).clone(),
(0, Some(ref s)) => self.with_filename(*s), (0, Some(ref s)) => self.with_filename(*s),
(_, None) => self.with_filename(fmt!(".%s", t)), (_, None) => self.with_filename(format!(".{}", t)),
(_, Some(ref s)) => self.with_filename(fmt!("%s.%s", *s, t)), (_, Some(ref s)) => self.with_filename(format!("{}.{}", *s, t)),
} }
} }
@ -190,7 +190,7 @@ pub trait GenericPath : Clone + Eq + ToStr {
/// True if `self` is an ancestor of `other`. /// True if `self` is an ancestor of `other`.
// See `test_is_ancestor_of` for examples. // See `test_is_ancestor_of` for examples.
fn is_ancestor_of(&self, other: &Self) -> bool { fn is_ancestor_of(&self, other: &Self) -> bool {
debug!("%s / %s %? %?", self.to_str(), other.to_str(), self.is_absolute(), debug2!("{} / {} {} {}", self.to_str(), other.to_str(), self.is_absolute(),
self.components().len()); self.components().len());
self == other || self == other ||
(!other.components().is_empty() && (!other.components().is_empty() &&
@ -1101,8 +1101,8 @@ mod tests {
let ss = wp.to_str(); let ss = wp.to_str();
let sss = s.to_owned(); let sss = s.to_owned();
if (ss != sss) { if (ss != sss) {
debug!("got %s", ss); debug2!("got {}", ss);
debug!("expected %s", sss); debug2!("expected {}", sss);
assert_eq!(ss, sss); assert_eq!(ss, sss);
} }
} }
@ -1167,8 +1167,8 @@ mod tests {
let ss = wp.to_str(); let ss = wp.to_str();
let sss = s.to_owned(); let sss = s.to_owned();
if (ss != sss) { if (ss != sss) {
debug!("got %s", ss); debug2!("got {}", ss);
debug!("expected %s", sss); debug2!("expected {}", sss);
assert_eq!(ss, sss); assert_eq!(ss, sss);
} }
} }
@ -1230,8 +1230,8 @@ mod tests {
let ss = wp.to_str(); let ss = wp.to_str();
let sss = s.to_owned(); let sss = s.to_owned();
if (ss != sss) { if (ss != sss) {
debug!("got %s", ss); debug2!("got {}", ss);
debug!("expected %s", sss); debug2!("expected {}", sss);
assert_eq!(ss, sss); assert_eq!(ss, sss);
} }
} }
@ -1448,7 +1448,7 @@ mod tests {
let p2 = PosixPath("/home/brian/Dev/rust/build/stage2/bin/..").push_rel( let p2 = PosixPath("/home/brian/Dev/rust/build/stage2/bin/..").push_rel(
&PosixPath("lib/rustc/i686-unknown-linux-gnu/lib/libstd.so")); &PosixPath("lib/rustc/i686-unknown-linux-gnu/lib/libstd.so"));
let res = p1.get_relative_to(&p2); let res = p1.get_relative_to(&p2);
debug!("test_relative_to8: %s vs. %s", debug2!("test_relative_to8: {} vs. {}",
res.to_str(), res.to_str(),
PosixPath(".").to_str()); PosixPath(".").to_str());
assert_eq!(res, PosixPath(".")); assert_eq!(res, PosixPath("."));
@ -1458,7 +1458,7 @@ mod tests {
let p2 = WindowsPath("\\home\\brian\\Dev\\rust\\build\\stage2\\bin\\..").push_rel( let p2 = WindowsPath("\\home\\brian\\Dev\\rust\\build\\stage2\\bin\\..").push_rel(
&WindowsPath("lib\\rustc\\i686-unknown-linux-gnu\\lib\\libstd.so")); &WindowsPath("lib\\rustc\\i686-unknown-linux-gnu\\lib\\libstd.so"));
let res = p1.get_relative_to(&p2); let res = p1.get_relative_to(&p2);
debug!("test_relative_to8: %s vs. %s", debug2!("test_relative_to8: {} vs. {}",
res.to_str(), res.to_str(),
WindowsPath(".").to_str()); WindowsPath(".").to_str());
assert_eq!(res, WindowsPath(".")); assert_eq!(res, WindowsPath("."));

19
src/libstd/ptr.rs
View file

@ -236,16 +236,16 @@ pub fn to_mut_unsafe_ptr<T>(thing: &mut T) -> *mut T {
SAFETY NOTE: Pointer-arithmetic. Dragons be here. SAFETY NOTE: Pointer-arithmetic. Dragons be here.
*/ */
pub unsafe fn array_each_with_len<T>(arr: **T, len: uint, cb: &fn(*T)) { pub unsafe fn array_each_with_len<T>(arr: **T, len: uint, cb: &fn(*T)) {
debug!("array_each_with_len: before iterate"); debug2!("array_each_with_len: before iterate");
if (arr as uint == 0) { if (arr as uint == 0) {
fail!("ptr::array_each_with_len failure: arr input is null pointer"); fail2!("ptr::array_each_with_len failure: arr input is null pointer");
} }
//let start_ptr = *arr; //let start_ptr = *arr;
for e in range(0, len) { for e in range(0, len) {
let n = offset(arr, e as int); let n = offset(arr, e as int);
cb(*n); cb(*n);
} }
debug!("array_each_with_len: after iterate"); debug2!("array_each_with_len: after iterate");
} }
/** /**
@ -259,11 +259,10 @@ pub unsafe fn array_each_with_len<T>(arr: **T, len: uint, cb: &fn(*T)) {
*/ */
pub unsafe fn array_each<T>(arr: **T, cb: &fn(*T)) { pub unsafe fn array_each<T>(arr: **T, cb: &fn(*T)) {
if (arr as uint == 0) { if (arr as uint == 0) {
fail!("ptr::array_each_with_len failure: arr input is null pointer"); fail2!("ptr::array_each_with_len failure: arr input is null pointer");
} }
let len = buf_len(arr); let len = buf_len(arr);
debug!("array_each inferred len: %u", debug2!("array_each inferred len: {}", len);
len);
array_each_with_len(arr, len, cb); array_each_with_len(arr, len, cb);
} }
@ -670,8 +669,8 @@ pub mod ptr_tests {
let expected = do expected_arr[ctr].with_ref |buf| { let expected = do expected_arr[ctr].with_ref |buf| {
str::raw::from_c_str(buf) str::raw::from_c_str(buf)
}; };
debug!( debug2!(
"test_ptr_array_each_with_len e: %s, a: %s", "test_ptr_array_each_with_len e: {}, a: {}",
expected, actual); expected, actual);
assert_eq!(actual, expected); assert_eq!(actual, expected);
ctr += 1; ctr += 1;
@ -707,8 +706,8 @@ pub mod ptr_tests {
let expected = do expected_arr[ctr].with_ref |buf| { let expected = do expected_arr[ctr].with_ref |buf| {
str::raw::from_c_str(buf) str::raw::from_c_str(buf)
}; };
debug!( debug2!(
"test_ptr_array_each e: %s, a: %s", "test_ptr_array_each e: {}, a: {}",
expected, actual); expected, actual);
assert_eq!(actual, expected); assert_eq!(actual, expected);
ctr += 1; ctr += 1;

10
src/libstd/rand/mod.rs
View file

@ -897,7 +897,7 @@ mod test {
let mut ra = IsaacRng::new_seeded(seed); let mut ra = IsaacRng::new_seeded(seed);
// Regression test that isaac is actually using the above vector // Regression test that isaac is actually using the above vector
let r = ra.next(); let r = ra.next();
error!("%?", r); debug2!("{:?}", r);
assert!(r == 890007737u32 // on x86_64 assert!(r == 890007737u32 // on x86_64
|| r == 2935188040u32); // on x86 || r == 2935188040u32); // on x86
} }
@ -940,7 +940,7 @@ mod test {
let mut r = rng(); let mut r = rng();
let a = r.gen::<float>(); let a = r.gen::<float>();
let b = r.gen::<float>(); let b = r.gen::<float>();
debug!((a, b)); debug2!("{:?}", (a, b));
} }
#[test] #[test]
@ -953,9 +953,9 @@ mod test {
#[test] #[test]
fn test_gen_ascii_str() { fn test_gen_ascii_str() {
let mut r = rng(); let mut r = rng();
debug!(r.gen_ascii_str(10u)); debug2!("{}", r.gen_ascii_str(10u));
debug!(r.gen_ascii_str(10u)); debug2!("{}", r.gen_ascii_str(10u));
debug!(r.gen_ascii_str(10u)); debug2!("{}", r.gen_ascii_str(10u));
assert_eq!(r.gen_ascii_str(0u).len(), 0u); assert_eq!(r.gen_ascii_str(0u).len(), 0u);
assert_eq!(r.gen_ascii_str(10u).len(), 10u); assert_eq!(r.gen_ascii_str(10u).len(), 10u);
assert_eq!(r.gen_ascii_str(16u).len(), 16u); assert_eq!(r.gen_ascii_str(16u).len(), 16u);

8
src/libstd/repr.rs
View file

@ -189,7 +189,7 @@ impl<'self> ReprVisitor<'self> {
} else if mtbl == 1 { } else if mtbl == 1 {
// skip, this is ast::m_imm // skip, this is ast::m_imm
} else { } else {
fail!("invalid mutability value"); fail2!("invalid mutability value");
} }
} }
@ -312,7 +312,7 @@ impl<'self> TyVisitor for ReprVisitor<'self> {
// Type no longer exists, vestigial function. // Type no longer exists, vestigial function.
fn visit_estr_fixed(&mut self, _n: uint, _sz: uint, fn visit_estr_fixed(&mut self, _n: uint, _sz: uint,
_align: uint) -> bool { fail!(); } _align: uint) -> bool { fail2!(); }
fn visit_box(&mut self, mtbl: uint, inner: *TyDesc) -> bool { fn visit_box(&mut self, mtbl: uint, inner: *TyDesc) -> bool {
self.writer.write(['@' as u8]); self.writer.write(['@' as u8]);
@ -355,7 +355,7 @@ impl<'self> TyVisitor for ReprVisitor<'self> {
} }
// Type no longer exists, vestigial function. // Type no longer exists, vestigial function.
fn visit_vec(&mut self, _mtbl: uint, _inner: *TyDesc) -> bool { fail!(); } fn visit_vec(&mut self, _mtbl: uint, _inner: *TyDesc) -> bool { fail2!(); }
fn visit_unboxed_vec(&mut self, mtbl: uint, inner: *TyDesc) -> bool { fn visit_unboxed_vec(&mut self, mtbl: uint, inner: *TyDesc) -> bool {
do self.get::<raw::Vec<()>> |this, b| { do self.get::<raw::Vec<()>> |this, b| {
@ -567,7 +567,7 @@ impl<'self> TyVisitor for ReprVisitor<'self> {
_align: uint) _align: uint)
-> bool { -> bool {
match self.var_stk.pop() { match self.var_stk.pop() {
SearchingFor(*) => fail!("enum value matched no variant"), SearchingFor(*) => fail2!("enum value matched no variant"),
_ => true _ => true
} }
} }

14
src/libstd/result.rs
View file

@ -46,7 +46,8 @@ impl<T, E: ToStr> Result<T, E> {
pub fn get_ref<'a>(&'a self) -> &'a T { pub fn get_ref<'a>(&'a self) -> &'a T {
match *self { match *self {
Ok(ref t) => t, Ok(ref t) => t,
Err(ref e) => fail!("called `Result::get_ref()` on `Err` value: %s", e.to_str()), Err(ref e) => fail2!("called `Result::get_ref()` on `Err` value: {}",
e.to_str()),
} }
} }
@ -106,7 +107,8 @@ impl<T, E: ToStr> Result<T, E> {
pub fn unwrap(self) -> T { pub fn unwrap(self) -> T {
match self { match self {
Ok(t) => t, Ok(t) => t,
Err(e) => fail!("called `Result::unwrap()` on `Err` value: %s", e.to_str()), Err(e) => fail2!("called `Result::unwrap()` on `Err` value: {}",
e.to_str()),
} }
} }
@ -123,7 +125,7 @@ impl<T, E: ToStr> Result<T, E> {
pub fn expect(self, reason: &str) -> T { pub fn expect(self, reason: &str) -> T {
match self { match self {
Ok(t) => t, Ok(t) => t,
Err(_) => fail!(reason.to_owned()), Err(_) => fail2!("{}", reason.to_owned()),
} }
} }
@ -133,7 +135,7 @@ impl<T, E: ToStr> Result<T, E> {
pub fn expect_err(self, reason: &str) -> E { pub fn expect_err(self, reason: &str) -> E {
match self { match self {
Err(e) => e, Err(e) => e,
Ok(_) => fail!(reason.to_owned()), Ok(_) => fail2!("{}", reason.to_owned()),
} }
} }
@ -547,7 +549,7 @@ mod tests {
Err(2)); Err(2));
// test that it does not take more elements than it needs // test that it does not take more elements than it needs
let functions = [|| Ok(()), || Err(1), || fail!()]; let functions = [|| Ok(()), || Err(1), || fail2!()];
assert_eq!(collect(functions.iter().map(|f| (*f)())), assert_eq!(collect(functions.iter().map(|f| (*f)())),
Err(1)); Err(1));
@ -567,7 +569,7 @@ mod tests {
Err(2)); Err(2));
// test that it does not take more elements than it needs // test that it does not take more elements than it needs
let functions = [|| Ok(()), || Err(1), || fail!()]; let functions = [|| Ok(()), || Err(1), || fail2!()];
assert_eq!(fold_(functions.iter() assert_eq!(fold_(functions.iter()
.map(|f| (*f)())), .map(|f| (*f)())),

6
src/libstd/rt/args.rs
View file

@ -163,14 +163,14 @@ mod imp {
} }
pub fn take() -> Option<~[~str]> { pub fn take() -> Option<~[~str]> {
fail!() fail2!()
} }
pub fn put(_args: ~[~str]) { pub fn put(_args: ~[~str]) {
fail!() fail2!()
} }
pub fn clone() -> Option<~[~str]> { pub fn clone() -> Option<~[~str]> {
fail!() fail2!()
} }
} }

4
src/libstd/rt/borrowck.rs
View file

@ -78,7 +78,7 @@ unsafe fn fail_borrowed(box: *mut raw::Box<()>, file: *c_char, line: size_t) {
msg.push_str(sep); msg.push_str(sep);
let filename = str::raw::from_c_str(entry.file); let filename = str::raw::from_c_str(entry.file);
msg.push_str(filename); msg.push_str(filename);
msg.push_str(fmt!(":%u", entry.line as uint)); msg.push_str(format!(":{}", entry.line));
sep = " and at "; sep = " and at ";
} }
} }
@ -221,7 +221,7 @@ pub unsafe fn unrecord_borrow(a: *u8, old_ref_count: uint,
assert!(!borrow_list.is_empty()); assert!(!borrow_list.is_empty());
let br = borrow_list.pop(); let br = borrow_list.pop();
if br.box != a || br.file != file || br.line != line { if br.box != a || br.file != file || br.line != line {
let err = fmt!("wrong borrow found, br=%?", br); let err = format!("wrong borrow found, br={:?}", br);
do err.with_c_str |msg_p| { do err.with_c_str |msg_p| {
sys::begin_unwind_(msg_p, file, line) sys::begin_unwind_(msg_p, file, line)
} }

8
src/libstd/rt/comm.rs
View file

@ -196,7 +196,7 @@ impl<T> PortOne<T> {
match self.try_recv() { match self.try_recv() {
Some(val) => val, Some(val) => val,
None => { None => {
fail!("receiving on closed channel"); fail2!("receiving on closed channel");
} }
} }
} }
@ -495,7 +495,7 @@ impl<T> GenericPort<T> for Port<T> {
match self.try_recv() { match self.try_recv() {
Some(val) => val, Some(val) => val,
None => { None => {
fail!("receiving on closed channel"); fail2!("receiving on closed channel");
} }
} }
} }
@ -650,7 +650,7 @@ impl<T: Send> GenericPort<T> for SharedPort<T> {
match self.try_recv() { match self.try_recv() {
Some(val) => val, Some(val) => val,
None => { None => {
fail!("receiving on a closed channel"); fail2!("receiving on a closed channel");
} }
} }
} }
@ -770,7 +770,7 @@ mod test {
port.recv(); port.recv();
}; };
// What is our res? // What is our res?
rtdebug!("res is: %?", res.is_err()); rtdebug!("res is: {:?}", res.is_err());
assert!(res.is_err()); assert!(res.is_err());
} }
} }

6
src/libstd/rt/context.rs
View file

@ -167,9 +167,9 @@ fn initialize_call_frame(regs: &mut Registers, fptr: *c_void, arg: *c_void,
unsafe { *sp = 0; } unsafe { *sp = 0; }
rtdebug!("creating call frame"); rtdebug!("creating call frame");
rtdebug!("fptr %x", fptr as uint); rtdebug!("fptr {}", fptr as uint);
rtdebug!("arg %x", arg as uint); rtdebug!("arg {}", arg as uint);
rtdebug!("sp %x", sp as uint); rtdebug!("sp {}", sp as uint);
regs[RUSTRT_ARG0] = arg as uint; regs[RUSTRT_ARG0] = arg as uint;
regs[RUSTRT_RSP] = sp as uint; regs[RUSTRT_RSP] = sp as uint;

4
src/libstd/rt/crate_map.rs
View file

@ -85,7 +85,7 @@ unsafe fn entries(crate_map: *CrateMap) -> *ModEntry {
return (*v0).entries; return (*v0).entries;
} }
1 => return (*crate_map).entries, 1 => return (*crate_map).entries,
_ => fail!("Unknown crate map version!") _ => fail2!("Unknown crate map version!")
} }
} }
@ -96,7 +96,7 @@ unsafe fn iterator(crate_map: *CrateMap) -> **CrateMap {
return vec::raw::to_ptr((*v0).children); return vec::raw::to_ptr((*v0).children);
} }
1 => return vec::raw::to_ptr((*crate_map).children), 1 => return vec::raw::to_ptr((*crate_map).children),
_ => fail!("Unknown crate map version!") _ => fail2!("Unknown crate map version!")
} }
} }

22
src/libstd/rt/io/comm_adapters.rs
View file

@ -15,45 +15,45 @@ use super::{Reader, Writer};
struct PortReader<P>; struct PortReader<P>;
impl<P: GenericPort<~[u8]>> PortReader<P> { impl<P: GenericPort<~[u8]>> PortReader<P> {
pub fn new(_port: P) -> PortReader<P> { fail!() } pub fn new(_port: P) -> PortReader<P> { fail2!() }
} }
impl<P: GenericPort<~[u8]>> Reader for PortReader<P> { impl<P: GenericPort<~[u8]>> Reader for PortReader<P> {
fn read(&mut self, _buf: &mut [u8]) -> Option<uint> { fail!() } fn read(&mut self, _buf: &mut [u8]) -> Option<uint> { fail2!() }
fn eof(&mut self) -> bool { fail!() } fn eof(&mut self) -> bool { fail2!() }
} }
struct ChanWriter<C>; struct ChanWriter<C>;
impl<C: GenericChan<~[u8]>> ChanWriter<C> { impl<C: GenericChan<~[u8]>> ChanWriter<C> {
pub fn new(_chan: C) -> ChanWriter<C> { fail!() } pub fn new(_chan: C) -> ChanWriter<C> { fail2!() }
} }
impl<C: GenericChan<~[u8]>> Writer for ChanWriter<C> { impl<C: GenericChan<~[u8]>> Writer for ChanWriter<C> {
fn write(&mut self, _buf: &[u8]) { fail!() } fn write(&mut self, _buf: &[u8]) { fail2!() }
fn flush(&mut self) { fail!() } fn flush(&mut self) { fail2!() }
} }
struct ReaderPort<R>; struct ReaderPort<R>;
impl<R: Reader> ReaderPort<R> { impl<R: Reader> ReaderPort<R> {
pub fn new(_reader: R) -> ReaderPort<R> { fail!() } pub fn new(_reader: R) -> ReaderPort<R> { fail2!() }
} }
impl<R: Reader> GenericPort<~[u8]> for ReaderPort<R> { impl<R: Reader> GenericPort<~[u8]> for ReaderPort<R> {
fn recv(&self) -> ~[u8] { fail!() } fn recv(&self) -> ~[u8] { fail2!() }
fn try_recv(&self) -> Option<~[u8]> { fail!() } fn try_recv(&self) -> Option<~[u8]> { fail2!() }
} }
struct WriterChan<W>; struct WriterChan<W>;
impl<W: Writer> WriterChan<W> { impl<W: Writer> WriterChan<W> {
pub fn new(_writer: W) -> WriterChan<W> { fail!() } pub fn new(_writer: W) -> WriterChan<W> { fail2!() }
} }
impl<W: Writer> GenericChan<~[u8]> for WriterChan<W> { impl<W: Writer> GenericChan<~[u8]> for WriterChan<W> {
fn send(&self, _x: ~[u8]) { fail!() } fn send(&self, _x: ~[u8]) { fail2!() }
} }

2
src/libstd/rt/io/extensions.rs
View file

@ -288,7 +288,7 @@ impl<T: Reader> ReaderUtil for T {
let mut buf = [0]; let mut buf = [0];
match self.read(buf) { match self.read(buf) {
Some(0) => { Some(0) => {
debug!("read 0 bytes. trying again"); debug2!("read 0 bytes. trying again");
self.read_byte() self.read_byte()
} }
Some(1) => Some(buf[0]), Some(1) => Some(buf[0]),

30
src/libstd/rt/io/file.rs
View file

@ -59,7 +59,7 @@ use path::Path;
/// }).inside { /// }).inside {
/// let stream = match open(p, Create, ReadWrite) { /// let stream = match open(p, Create, ReadWrite) {
/// Some(s) => s, /// Some(s) => s,
/// None => fail!("whoops! I'm sure this raised, anyways.."); /// None => fail2!("whoops! I'm sure this raised, anyways..");
/// } /// }
/// // do some stuff with that stream /// // do some stuff with that stream
/// ///
@ -223,7 +223,7 @@ pub fn rmdir<P: PathLike>(path: &P) {
/// }).inside { /// }).inside {
/// let info = match stat(p) { /// let info = match stat(p) {
/// Some(s) => s, /// Some(s) => s,
/// None => fail!("whoops! I'm sure this raised, anyways.."); /// None => fail2!("whoops! I'm sure this raised, anyways..");
/// } /// }
/// if stat.is_file { /// if stat.is_file {
/// // just imagine the possibilities ... /// // just imagine the possibilities ...
@ -271,7 +271,7 @@ pub fn stat<P: PathLike>(path: &P) -> Option<FileStat> {
/// else { cb(entry); } /// else { cb(entry); }
/// } /// }
/// } /// }
/// else { fail!("nope"); } /// else { fail2!("nope"); }
/// } /// }
/// ///
/// # Errors /// # Errors
@ -596,7 +596,7 @@ impl FileInfo for Path { }
/// else { cb(entry); } /// else { cb(entry); }
/// } /// }
/// } /// }
/// else { fail!("nope"); } /// else { fail2!("nope"); }
/// } /// }
/// ``` /// ```
trait DirectoryInfo : FileSystemInfo { trait DirectoryInfo : FileSystemInfo {
@ -631,7 +631,8 @@ trait DirectoryInfo : FileSystemInfo {
kind: PathAlreadyExists, kind: PathAlreadyExists,
desc: "Path already exists", desc: "Path already exists",
detail: detail:
Some(fmt!("%s already exists; can't mkdir it", self.get_path().to_str())) Some(format!("{} already exists; can't mkdir it",
self.get_path().to_str()))
}) })
}, },
None => mkdir(self.get_path()) None => mkdir(self.get_path())
@ -657,8 +658,8 @@ trait DirectoryInfo : FileSystemInfo {
let ioerr = IoError { let ioerr = IoError {
kind: MismatchedFileTypeForOperation, kind: MismatchedFileTypeForOperation,
desc: "Cannot do rmdir() on a non-directory", desc: "Cannot do rmdir() on a non-directory",
detail: Some(fmt!( detail: Some(format!(
"%s is a non-directory; can't rmdir it", "{} is a non-directory; can't rmdir it",
self.get_path().to_str())) self.get_path().to_str()))
}; };
io_error::cond.raise(ioerr); io_error::cond.raise(ioerr);
@ -669,7 +670,8 @@ trait DirectoryInfo : FileSystemInfo {
io_error::cond.raise(IoError { io_error::cond.raise(IoError {
kind: PathDoesntExist, kind: PathDoesntExist,
desc: "Path doesn't exist", desc: "Path doesn't exist",
detail: Some(fmt!("%s doesn't exist; can't rmdir it", self.get_path().to_str())) detail: Some(format!("{} doesn't exist; can't rmdir it",
self.get_path().to_str()))
}) })
} }
} }
@ -707,7 +709,7 @@ mod test {
let mut read_stream = open(filename, Open, Read).unwrap(); let mut read_stream = open(filename, Open, Read).unwrap();
let mut read_buf = [0, .. 1028]; let mut read_buf = [0, .. 1028];
let read_str = match read_stream.read(read_buf).unwrap() { let read_str = match read_stream.read(read_buf).unwrap() {
-1|0 => fail!("shouldn't happen"), -1|0 => fail2!("shouldn't happen"),
n => str::from_utf8(read_buf.slice_to(n)) n => str::from_utf8(read_buf.slice_to(n))
}; };
assert!(read_str == message.to_owned()); assert!(read_str == message.to_owned());
@ -875,7 +877,7 @@ mod test {
} }
let stat_res = match stat(filename) { let stat_res = match stat(filename) {
Some(s) => s, Some(s) => s,
None => fail!("shouldn't happen") None => fail2!("shouldn't happen")
}; };
assert!(stat_res.is_file); assert!(stat_res.is_file);
unlink(filename); unlink(filename);
@ -889,7 +891,7 @@ mod test {
mkdir(filename); mkdir(filename);
let stat_res = match stat(filename) { let stat_res = match stat(filename) {
Some(s) => s, Some(s) => s,
None => fail!("shouldn't happen") None => fail2!("shouldn't happen")
}; };
assert!(stat_res.is_dir); assert!(stat_res.is_dir);
rmdir(filename); rmdir(filename);
@ -942,7 +944,7 @@ mod test {
dir.mkdir(); dir.mkdir();
let prefix = "foo"; let prefix = "foo";
for n in range(0,3) { for n in range(0,3) {
let f = dir.push(fmt!("%d.txt", n)); let f = dir.push(format!("{}.txt", n));
let mut w = f.open_writer(Create); let mut w = f.open_writer(Create);
let msg_str = (prefix + n.to_str().to_owned()).to_owned(); let msg_str = (prefix + n.to_str().to_owned()).to_owned();
let msg = msg_str.as_bytes(); let msg = msg_str.as_bytes();
@ -959,14 +961,14 @@ mod test {
let read_str = str::from_utf8(mem); let read_str = str::from_utf8(mem);
let expected = match n { let expected = match n {
Some(n) => prefix+n, Some(n) => prefix+n,
None => fail!("really shouldn't happen..") None => fail2!("really shouldn't happen..")
}; };
assert!(expected == read_str); assert!(expected == read_str);
} }
f.unlink(); f.unlink();
} }
}, },
None => fail!("shouldn't happen") None => fail2!("shouldn't happen")
} }
dir.rmdir(); dir.rmdir();
} }

8
src/libstd/rt/io/flate.rs
View file

@ -29,9 +29,9 @@ impl<W: Writer> DeflateWriter<W> {
} }
impl<W: Writer> Writer for DeflateWriter<W> { impl<W: Writer> Writer for DeflateWriter<W> {
fn write(&mut self, _buf: &[u8]) { fail!() } fn write(&mut self, _buf: &[u8]) { fail2!() }
fn flush(&mut self) { fail!() } fn flush(&mut self) { fail2!() }
} }
impl<W: Writer> Decorator<W> for DeflateWriter<W> { impl<W: Writer> Decorator<W> for DeflateWriter<W> {
@ -68,9 +68,9 @@ impl<R: Reader> InflateReader<R> {
} }
impl<R: Reader> Reader for InflateReader<R> { impl<R: Reader> Reader for InflateReader<R> {
fn read(&mut self, _buf: &mut [u8]) -> Option<uint> { fail!() } fn read(&mut self, _buf: &mut [u8]) -> Option<uint> { fail2!() }
fn eof(&mut self) -> bool { fail!() } fn eof(&mut self) -> bool { fail2!() }
} }
impl<R: Reader> Decorator<R> for InflateReader<R> { impl<R: Reader> Decorator<R> for InflateReader<R> {

14
src/libstd/rt/io/mem.rs
View file

@ -40,7 +40,7 @@ impl Writer for MemWriter {
impl Seek for MemWriter { impl Seek for MemWriter {
fn tell(&self) -> u64 { self.buf.len() as u64 } fn tell(&self) -> u64 { self.buf.len() as u64 }
fn seek(&mut self, _pos: i64, _style: SeekStyle) { fail!() } fn seek(&mut self, _pos: i64, _style: SeekStyle) { fail2!() }
} }
impl Decorator<~[u8]> for MemWriter { impl Decorator<~[u8]> for MemWriter {
@ -102,7 +102,7 @@ impl Reader for MemReader {
impl Seek for MemReader { impl Seek for MemReader {
fn tell(&self) -> u64 { self.pos as u64 } fn tell(&self) -> u64 { self.pos as u64 }
fn seek(&mut self, _pos: i64, _style: SeekStyle) { fail!() } fn seek(&mut self, _pos: i64, _style: SeekStyle) { fail2!() }
} }
impl Decorator<~[u8]> for MemReader { impl Decorator<~[u8]> for MemReader {
@ -143,15 +143,15 @@ impl<'self> BufWriter<'self> {
} }
impl<'self> Writer for BufWriter<'self> { impl<'self> Writer for BufWriter<'self> {
fn write(&mut self, _buf: &[u8]) { fail!() } fn write(&mut self, _buf: &[u8]) { fail2!() }
fn flush(&mut self) { fail!() } fn flush(&mut self) { fail2!() }
} }
impl<'self> Seek for BufWriter<'self> { impl<'self> Seek for BufWriter<'self> {
fn tell(&self) -> u64 { fail!() } fn tell(&self) -> u64 { fail2!() }
fn seek(&mut self, _pos: i64, _style: SeekStyle) { fail!() } fn seek(&mut self, _pos: i64, _style: SeekStyle) { fail2!() }
} }
@ -193,7 +193,7 @@ impl<'self> Reader for BufReader<'self> {
impl<'self> Seek for BufReader<'self> { impl<'self> Seek for BufReader<'self> {
fn tell(&self) -> u64 { self.pos as u64 } fn tell(&self) -> u64 { self.pos as u64 }
fn seek(&mut self, _pos: i64, _style: SeekStyle) { fail!() } fn seek(&mut self, _pos: i64, _style: SeekStyle) { fail2!() }
} }
///Calls a function with a MemWriter and returns ///Calls a function with a MemWriter and returns

2
src/libstd/rt/io/mod.rs
View file

@ -585,7 +585,7 @@ pub fn standard_error(kind: IoErrorKind) -> IoError {
detail: None detail: None
} }
} }
_ => fail!() _ => fail2!()
} }
} }

28
src/libstd/rt/io/native/file.rs
View file

@ -25,25 +25,25 @@ impl FileDesc {
/// ///
/// The `FileDesc` takes ownership of the file descriptor /// The `FileDesc` takes ownership of the file descriptor
/// and will close it upon destruction. /// and will close it upon destruction.
pub fn new(_fd: fd_t) -> FileDesc { fail!() } pub fn new(_fd: fd_t) -> FileDesc { fail2!() }
} }
impl Reader for FileDesc { impl Reader for FileDesc {
fn read(&mut self, _buf: &mut [u8]) -> Option<uint> { fail!() } fn read(&mut self, _buf: &mut [u8]) -> Option<uint> { fail2!() }
fn eof(&mut self) -> bool { fail!() } fn eof(&mut self) -> bool { fail2!() }
} }
impl Writer for FileDesc { impl Writer for FileDesc {
fn write(&mut self, _buf: &[u8]) { fail!() } fn write(&mut self, _buf: &[u8]) { fail2!() }
fn flush(&mut self) { fail!() } fn flush(&mut self) { fail2!() }
} }
impl Seek for FileDesc { impl Seek for FileDesc {
fn tell(&self) -> u64 { fail!() } fn tell(&self) -> u64 { fail2!() }
fn seek(&mut self, _pos: i64, _style: SeekStyle) { fail!() } fn seek(&mut self, _pos: i64, _style: SeekStyle) { fail2!() }
} }
pub struct CFile(*FILE); pub struct CFile(*FILE);
@ -53,22 +53,22 @@ impl CFile {
/// ///
/// The `CFile` takes ownership of the file descriptor /// The `CFile` takes ownership of the file descriptor
/// and will close it upon destruction. /// and will close it upon destruction.
pub fn new(_file: *FILE) -> CFile { fail!() } pub fn new(_file: *FILE) -> CFile { fail2!() }
} }
impl Reader for CFile { impl Reader for CFile {
fn read(&mut self, _buf: &mut [u8]) -> Option<uint> { fail!() } fn read(&mut self, _buf: &mut [u8]) -> Option<uint> { fail2!() }
fn eof(&mut self) -> bool { fail!() } fn eof(&mut self) -> bool { fail2!() }
} }
impl Writer for CFile { impl Writer for CFile {
fn write(&mut self, _buf: &[u8]) { fail!() } fn write(&mut self, _buf: &[u8]) { fail2!() }
fn flush(&mut self) { fail!() } fn flush(&mut self) { fail2!() }
} }
impl Seek for CFile { impl Seek for CFile {
fn tell(&self) -> u64 { fail!() } fn tell(&self) -> u64 { fail2!() }
fn seek(&mut self, _pos: i64, _style: SeekStyle) { fail!() } fn seek(&mut self, _pos: i64, _style: SeekStyle) { fail2!() }
} }

32
src/libstd/rt/io/net/ip.rs
View file

@ -8,7 +8,6 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
use num::FromStrRadix;
use vec::MutableCloneableVector; use vec::MutableCloneableVector;
use to_str::ToStr; use to_str::ToStr;
use from_str::FromStr; use from_str::FromStr;
@ -27,37 +26,22 @@ impl ToStr for IpAddr {
fn to_str(&self) -> ~str { fn to_str(&self) -> ~str {
match *self { match *self {
Ipv4Addr(a, b, c, d) => Ipv4Addr(a, b, c, d) =>
fmt!("%u.%u.%u.%u", format!("{}.{}.{}.{}", a, b, c, d),
a as uint, b as uint, c as uint, d as uint),
// Ipv4 Compatible address // Ipv4 Compatible address
Ipv6Addr(0, 0, 0, 0, 0, 0, g, h) => { Ipv6Addr(0, 0, 0, 0, 0, 0, g, h) => {
let a = fmt!("%04x", g as uint); format!("::{}.{}.{}.{}", (g >> 8) as u8, g as u8,
let b = FromStrRadix::from_str_radix(a.slice(2, 4), 16).unwrap(); (h >> 8) as u8, h as u8)
let a = FromStrRadix::from_str_radix(a.slice(0, 2), 16).unwrap();
let c = fmt!("%04x", h as uint);
let d = FromStrRadix::from_str_radix(c.slice(2, 4), 16).unwrap();
let c = FromStrRadix::from_str_radix(c.slice(0, 2), 16).unwrap();
fmt!("::%u.%u.%u.%u", a, b, c, d)
} }
// Ipv4-Mapped address // Ipv4-Mapped address
Ipv6Addr(0, 0, 0, 0, 0, 0xFFFF, g, h) => { Ipv6Addr(0, 0, 0, 0, 0, 0xFFFF, g, h) => {
let a = fmt!("%04x", g as uint); format!("::FFFF:{}.{}.{}.{}", (g >> 8) as u8, g as u8,
let b = FromStrRadix::from_str_radix(a.slice(2, 4), 16).unwrap(); (h >> 8) as u8, h as u8)
let a = FromStrRadix::from_str_radix(a.slice(0, 2), 16).unwrap();
let c = fmt!("%04x", h as uint);
let d = FromStrRadix::from_str_radix(c.slice(2, 4), 16).unwrap();
let c = FromStrRadix::from_str_radix(c.slice(0, 2), 16).unwrap();
fmt!("::FFFF:%u.%u.%u.%u", a, b, c, d)
} }
Ipv6Addr(a, b, c, d, e, f, g, h) => Ipv6Addr(a, b, c, d, e, f, g, h) =>
fmt!("%x:%x:%x:%x:%x:%x:%x:%x", format!("{}:{}:{}:{}:{}:{}:{}:{}", a, b, c, d, e, f, g, h)
a as uint, b as uint, c as uint, d as uint,
e as uint, f as uint, g as uint, h as uint)
} }
} }
} }
@ -72,8 +56,8 @@ pub struct SocketAddr {
impl ToStr for SocketAddr { impl ToStr for SocketAddr {
fn to_str(&self) -> ~str { fn to_str(&self) -> ~str {
match self.ip { match self.ip {
Ipv4Addr(*) => fmt!("%s:%u", self.ip.to_str(), self.port as uint), Ipv4Addr(*) => format!("{}:{}", self.ip.to_str(), self.port),
Ipv6Addr(*) => fmt!("[%s]:%u", self.ip.to_str(), self.port as uint), Ipv6Addr(*) => format!("[{}]:{}", self.ip.to_str(), self.port),
} }
} }
} }

10
src/libstd/rt/io/net/tcp.rs
View file

@ -38,7 +38,7 @@ impl TcpStream {
match stream { match stream {
Ok(s) => Some(TcpStream::new(s)), Ok(s) => Some(TcpStream::new(s)),
Err(ioerr) => { Err(ioerr) => {
rtdebug!("failed to connect: %?", ioerr); rtdebug!("failed to connect: {:?}", ioerr);
io_error::cond.raise(ioerr); io_error::cond.raise(ioerr);
None None
} }
@ -49,7 +49,7 @@ impl TcpStream {
match (**self).peer_name() { match (**self).peer_name() {
Ok(pn) => Some(pn), Ok(pn) => Some(pn),
Err(ioerr) => { Err(ioerr) => {
rtdebug!("failed to get peer name: %?", ioerr); rtdebug!("failed to get peer name: {:?}", ioerr);
io_error::cond.raise(ioerr); io_error::cond.raise(ioerr);
None None
} }
@ -60,7 +60,7 @@ impl TcpStream {
match (**self).socket_name() { match (**self).socket_name() {
Ok(sn) => Some(sn), Ok(sn) => Some(sn),
Err(ioerr) => { Err(ioerr) => {
rtdebug!("failed to get socket name: %?", ioerr); rtdebug!("failed to get socket name: {:?}", ioerr);
io_error::cond.raise(ioerr); io_error::cond.raise(ioerr);
None None
} }
@ -82,7 +82,7 @@ impl Reader for TcpStream {
} }
} }
fn eof(&mut self) -> bool { fail!() } fn eof(&mut self) -> bool { fail2!() }
} }
impl Writer for TcpStream { impl Writer for TcpStream {
@ -117,7 +117,7 @@ impl TcpListener {
match (**self).socket_name() { match (**self).socket_name() {
Ok(sn) => Some(sn), Ok(sn) => Some(sn),
Err(ioerr) => { Err(ioerr) => {
rtdebug!("failed to get socket name: %?", ioerr); rtdebug!("failed to get socket name: {:?}", ioerr);
io_error::cond.raise(ioerr); io_error::cond.raise(ioerr);
None None
} }

30
src/libstd/rt/io/net/udp.rs
View file

@ -61,7 +61,7 @@ impl UdpSocket {
match (***self).socket_name() { match (***self).socket_name() {
Ok(sn) => Some(sn), Ok(sn) => Some(sn),
Err(ioerr) => { Err(ioerr) => {
rtdebug!("failed to get socket name: %?", ioerr); rtdebug!("failed to get socket name: {:?}", ioerr);
io_error::cond.raise(ioerr); io_error::cond.raise(ioerr);
None None
} }
@ -92,7 +92,7 @@ impl Reader for UdpStream {
} }
} }
fn eof(&mut self) -> bool { fail!() } fn eof(&mut self) -> bool { fail2!() }
} }
impl Writer for UdpStream { impl Writer for UdpStream {
@ -102,7 +102,7 @@ impl Writer for UdpStream {
} }
} }
fn flush(&mut self) { fail!() } fn flush(&mut self) { fail2!() }
} }
#[cfg(test)] #[cfg(test)]
@ -151,10 +151,10 @@ mod test {
assert_eq!(buf[0], 99); assert_eq!(buf[0], 99);
assert_eq!(src, client_ip); assert_eq!(src, client_ip);
} }
None => fail!() None => fail2!()
} }
} }
None => fail!() None => fail2!()
} }
} }
@ -164,7 +164,7 @@ mod test {
port.take().recv(); port.take().recv();
client.sendto([99], server_ip) client.sendto([99], server_ip)
} }
None => fail!() None => fail2!()
} }
} }
} }
@ -190,10 +190,10 @@ mod test {
assert_eq!(buf[0], 99); assert_eq!(buf[0], 99);
assert_eq!(src, client_ip); assert_eq!(src, client_ip);
} }
None => fail!() None => fail2!()
} }
} }
None => fail!() None => fail2!()
} }
} }
@ -203,7 +203,7 @@ mod test {
port.take().recv(); port.take().recv();
client.sendto([99], server_ip) client.sendto([99], server_ip)
} }
None => fail!() None => fail2!()
} }
} }
} }
@ -230,10 +230,10 @@ mod test {
assert_eq!(nread, 1); assert_eq!(nread, 1);
assert_eq!(buf[0], 99); assert_eq!(buf[0], 99);
} }
None => fail!() None => fail2!()
} }
} }
None => fail!() None => fail2!()
} }
} }
@ -245,7 +245,7 @@ mod test {
port.take().recv(); port.take().recv();
stream.write([99]); stream.write([99]);
} }
None => fail!() None => fail2!()
} }
} }
} }
@ -272,10 +272,10 @@ mod test {
assert_eq!(nread, 1); assert_eq!(nread, 1);
assert_eq!(buf[0], 99); assert_eq!(buf[0], 99);
} }
None => fail!() None => fail2!()
} }
} }
None => fail!() None => fail2!()
} }
} }
@ -287,7 +287,7 @@ mod test {
port.take().recv(); port.take().recv();
stream.write([99]); stream.write([99]);
} }
None => fail!() None => fail2!()
} }
} }
} }

16
src/libstd/rt/io/net/unix.rs
View file

@ -16,36 +16,36 @@ pub struct UnixStream;
impl UnixStream { impl UnixStream {
pub fn connect<P: PathLike>(_path: &P) -> Option<UnixStream> { pub fn connect<P: PathLike>(_path: &P) -> Option<UnixStream> {
fail!() fail2!()
} }
} }
impl Reader for UnixStream { impl Reader for UnixStream {
fn read(&mut self, _buf: &mut [u8]) -> Option<uint> { fail!() } fn read(&mut self, _buf: &mut [u8]) -> Option<uint> { fail2!() }
fn eof(&mut self) -> bool { fail!() } fn eof(&mut self) -> bool { fail2!() }
} }
impl Writer for UnixStream { impl Writer for UnixStream {
fn write(&mut self, _v: &[u8]) { fail!() } fn write(&mut self, _v: &[u8]) { fail2!() }
fn flush(&mut self) { fail!() } fn flush(&mut self) { fail2!() }
} }
pub struct UnixListener; pub struct UnixListener;
impl UnixListener { impl UnixListener {
pub fn bind<P: PathLike>(_path: &P) -> Option<UnixListener> { pub fn bind<P: PathLike>(_path: &P) -> Option<UnixListener> {
fail!() fail2!()
} }
} }
impl Listener<UnixStream, UnixAcceptor> for UnixListener { impl Listener<UnixStream, UnixAcceptor> for UnixListener {
fn listen(self) -> Option<UnixAcceptor> { fail!() } fn listen(self) -> Option<UnixAcceptor> { fail2!() }
} }
pub struct UnixAcceptor; pub struct UnixAcceptor;
impl Acceptor<UnixStream> for UnixAcceptor { impl Acceptor<UnixStream> for UnixAcceptor {
fn accept(&mut self) -> Option<UnixStream> { fail!() } fn accept(&mut self) -> Option<UnixStream> { fail2!() }
} }

4
src/libstd/rt/io/pipe.rs
View file

@ -59,7 +59,7 @@ impl Reader for PipeStream {
} }
} }
fn eof(&mut self) -> bool { fail!() } fn eof(&mut self) -> bool { fail2!() }
} }
impl Writer for PipeStream { impl Writer for PipeStream {
@ -72,5 +72,5 @@ impl Writer for PipeStream {
} }
} }
fn flush(&mut self) { fail!() } fn flush(&mut self) { fail2!() }
} }

22
src/libstd/rt/io/stdio.rs
View file

@ -11,15 +11,15 @@
use prelude::*; use prelude::*;
use super::{Reader, Writer}; use super::{Reader, Writer};
pub fn stdin() -> StdReader { fail!() } pub fn stdin() -> StdReader { fail2!() }
pub fn stdout() -> StdWriter { fail!() } pub fn stdout() -> StdWriter { fail2!() }
pub fn stderr() -> StdReader { fail!() } pub fn stderr() -> StdReader { fail2!() }
pub fn print(_s: &str) { fail!() } pub fn print(_s: &str) { fail2!() }
pub fn println(_s: &str) { fail!() } pub fn println(_s: &str) { fail2!() }
pub enum StdStream { pub enum StdStream {
StdIn, StdIn,
@ -30,23 +30,23 @@ pub enum StdStream {
pub struct StdReader; pub struct StdReader;
impl StdReader { impl StdReader {
pub fn new(_stream: StdStream) -> StdReader { fail!() } pub fn new(_stream: StdStream) -> StdReader { fail2!() }
} }
impl Reader for StdReader { impl Reader for StdReader {
fn read(&mut self, _buf: &mut [u8]) -> Option<uint> { fail!() } fn read(&mut self, _buf: &mut [u8]) -> Option<uint> { fail2!() }
fn eof(&mut self) -> bool { fail!() } fn eof(&mut self) -> bool { fail2!() }
} }
pub struct StdWriter; pub struct StdWriter;
impl StdWriter { impl StdWriter {
pub fn new(_stream: StdStream) -> StdWriter { fail!() } pub fn new(_stream: StdStream) -> StdWriter { fail2!() }
} }
impl Writer for StdWriter { impl Writer for StdWriter {
fn write(&mut self, _buf: &[u8]) { fail!() } fn write(&mut self, _buf: &[u8]) { fail2!() }
fn flush(&mut self) { fail!() } fn flush(&mut self) { fail2!() }
} }

2
src/libstd/rt/io/timer.rs
View file

@ -36,7 +36,7 @@ impl Timer {
match timer { match timer {
Ok(t) => Some(Timer(t)), Ok(t) => Some(Timer(t)),
Err(ioerr) => { Err(ioerr) => {
rtdebug!("Timer::init: failed to init: %?", ioerr); rtdebug!("Timer::init: failed to init: {:?}", ioerr);
io_error::cond.raise(ioerr); io_error::cond.raise(ioerr);
None None
} }

10
src/libstd/rt/kill.rs
View file

@ -306,7 +306,7 @@ impl BlockedTask {
match flag.compare_and_swap(KILL_RUNNING, task_ptr, Relaxed) { match flag.compare_and_swap(KILL_RUNNING, task_ptr, Relaxed) {
KILL_RUNNING => Right(Killable(flag_arc)), KILL_RUNNING => Right(Killable(flag_arc)),
KILL_KILLED => Left(revive_task_ptr(task_ptr, Some(flag_arc))), KILL_KILLED => Left(revive_task_ptr(task_ptr, Some(flag_arc))),
x => rtabort!("can't block task! kill flag = %?", x), x => rtabort!("can't block task! kill flag = {}", x),
} }
} }
} }
@ -403,7 +403,7 @@ impl KillHandle {
// FIXME(#7544)(bblum): is it really necessary to prohibit double kill? // FIXME(#7544)(bblum): is it really necessary to prohibit double kill?
match inner.unkillable.compare_and_swap(KILL_RUNNING, KILL_UNKILLABLE, Relaxed) { match inner.unkillable.compare_and_swap(KILL_RUNNING, KILL_UNKILLABLE, Relaxed) {
KILL_RUNNING => { }, // normal case KILL_RUNNING => { }, // normal case
KILL_KILLED => if !already_failing { fail!(KILLED_MSG) }, KILL_KILLED => if !already_failing { fail2!("{}", KILLED_MSG) },
_ => rtabort!("inhibit_kill: task already unkillable"), _ => rtabort!("inhibit_kill: task already unkillable"),
} }
} }
@ -416,7 +416,7 @@ impl KillHandle {
// FIXME(#7544)(bblum): is it really necessary to prohibit double kill? // FIXME(#7544)(bblum): is it really necessary to prohibit double kill?
match inner.unkillable.compare_and_swap(KILL_UNKILLABLE, KILL_RUNNING, Relaxed) { match inner.unkillable.compare_and_swap(KILL_UNKILLABLE, KILL_RUNNING, Relaxed) {
KILL_UNKILLABLE => { }, // normal case KILL_UNKILLABLE => { }, // normal case
KILL_KILLED => if !already_failing { fail!(KILLED_MSG) }, KILL_KILLED => if !already_failing { fail2!("{}", KILLED_MSG) },
_ => rtabort!("allow_kill: task already killable"), _ => rtabort!("allow_kill: task already killable"),
} }
} }
@ -624,7 +624,7 @@ impl Death {
// synchronization during unwinding or cleanup (for example, // synchronization during unwinding or cleanup (for example,
// sending on a notify port). In that case failing won't help. // sending on a notify port). In that case failing won't help.
if self.unkillable == 0 && (!already_failing) && kill_handle.killed() { if self.unkillable == 0 && (!already_failing) && kill_handle.killed() {
fail!(KILLED_MSG); fail2!("{}", KILLED_MSG);
}, },
// This may happen during task death (see comments in collect_failure). // This may happen during task death (see comments in collect_failure).
None => rtassert!(self.unkillable > 0), None => rtassert!(self.unkillable > 0),
@ -650,7 +650,7 @@ impl Death {
if self.unkillable == 0 { if self.unkillable == 0 {
// we need to decrement the counter before failing. // we need to decrement the counter before failing.
self.unkillable -= 1; self.unkillable -= 1;
fail!("Cannot enter a rekillable() block without a surrounding unkillable()"); fail2!("Cannot enter a rekillable() block without a surrounding unkillable()");
} }
self.unkillable -= 1; self.unkillable -= 1;
if self.unkillable == 0 { if self.unkillable == 0 {

18
src/libstd/rt/logging.rs
View file

@ -90,15 +90,15 @@ fn parse_logging_spec(spec: ~str) -> ~[LogDirective]{
log_level = num; log_level = num;
}, },
_ => { _ => {
dumb_println(fmt!("warning: invalid logging spec \ dumb_println(format!("warning: invalid logging spec \
'%s', ignoring it", parts[1])); '{}', ignoring it", parts[1]));
loop; loop;
} }
} }
}, },
_ => { _ => {
dumb_println(fmt!("warning: invalid logging spec '%s',\ dumb_println(format!("warning: invalid logging spec '{}',\
ignoring it", s)); ignoring it", s));
loop; loop;
} }
} }
@ -165,10 +165,12 @@ fn update_log_settings(crate_map: *u8, settings: ~str) {
} }
if n_matches < (dirs.len() as u32) { if n_matches < (dirs.len() as u32) {
dumb_println(fmt!("warning: got %u RUST_LOG specs but only matched %u of them.\n\ dumb_println(format!("warning: got {} RUST_LOG specs but only matched\n\
You may have mistyped a RUST_LOG spec.\n\ {} of them. You may have mistyped a RUST_LOG \
Use RUST_LOG=::help to see the list of crates and modules.\n", spec. \n\
dirs.len() as uint, n_matches as uint)); Use RUST_LOG=::help to see the list of crates \
and modules.\n",
dirs.len(), n_matches));
} }
} }

16
src/libstd/rt/sched.rs
View file

@ -191,7 +191,7 @@ impl Scheduler {
// action will have given it away. // action will have given it away.
let sched: ~Scheduler = Local::take(); let sched: ~Scheduler = Local::take();
rtdebug!("starting scheduler %u", sched.sched_id()); rtdebug!("starting scheduler {}", sched.sched_id());
sched.run(); sched.run();
// Close the idle callback. // Close the idle callback.
@ -207,7 +207,7 @@ impl Scheduler {
// the cleanup code it runs. // the cleanup code it runs.
let mut stask: ~Task = Local::take(); let mut stask: ~Task = Local::take();
rtdebug!("stopping scheduler %u", stask.sched.get_ref().sched_id()); rtdebug!("stopping scheduler {}", stask.sched.get_ref().sched_id());
// Should not have any messages // Should not have any messages
let message = stask.sched.get_mut_ref().message_queue.pop(); let message = stask.sched.get_mut_ref().message_queue.pop();
@ -999,7 +999,7 @@ mod test {
Sched(t1_handle)) || { Sched(t1_handle)) || {
rtassert!(Task::on_appropriate_sched()); rtassert!(Task::on_appropriate_sched());
}; };
rtdebug!("task1 id: **%u**", borrow::to_uint(task1)); rtdebug!("task1 id: **{}**", borrow::to_uint(task1));
let task2 = ~do Task::new_root(&mut normal_sched.stack_pool, None) { let task2 = ~do Task::new_root(&mut normal_sched.stack_pool, None) {
rtassert!(Task::on_appropriate_sched()); rtassert!(Task::on_appropriate_sched());
@ -1013,7 +1013,7 @@ mod test {
Sched(t4_handle)) { Sched(t4_handle)) {
rtassert!(Task::on_appropriate_sched()); rtassert!(Task::on_appropriate_sched());
}; };
rtdebug!("task4 id: **%u**", borrow::to_uint(task4)); rtdebug!("task4 id: **{}**", borrow::to_uint(task4));
let task1 = Cell::new(task1); let task1 = Cell::new(task1);
let task2 = Cell::new(task2); let task2 = Cell::new(task2);
@ -1038,7 +1038,7 @@ mod test {
sh.send(Shutdown); sh.send(Shutdown);
}; };
rtdebug!("normal task: %u", borrow::to_uint(normal_task)); rtdebug!("normal task: {}", borrow::to_uint(normal_task));
let special_task = ~do Task::new_root(&mut special_sched.stack_pool, None) { let special_task = ~do Task::new_root(&mut special_sched.stack_pool, None) {
rtdebug!("*about to submit task1*"); rtdebug!("*about to submit task1*");
@ -1049,7 +1049,7 @@ mod test {
chan.take().send(()); chan.take().send(());
}; };
rtdebug!("special task: %u", borrow::to_uint(special_task)); rtdebug!("special task: {}", borrow::to_uint(special_task));
let special_sched = Cell::new(special_sched); let special_sched = Cell::new(special_sched);
let normal_sched = Cell::new(normal_sched); let normal_sched = Cell::new(normal_sched);
@ -1238,12 +1238,12 @@ mod test {
while (true) { while (true) {
match p.recv() { match p.recv() {
(1, end_chan) => { (1, end_chan) => {
debug!("%d\n", id); debug2!("{}\n", id);
end_chan.send(()); end_chan.send(());
return; return;
} }
(token, end_chan) => { (token, end_chan) => {
debug!("thread: %d got token: %d", id, token); debug2!("thread: {} got token: {}", id, token);
ch.send((token - 1, end_chan)); ch.send((token - 1, end_chan));
if token <= n_tasks { if token <= n_tasks {
return; return;

12
src/libstd/rt/task.rs
View file

@ -225,7 +225,7 @@ impl Task {
} }
pub fn run(&mut self, f: &fn()) { pub fn run(&mut self, f: &fn()) {
rtdebug!("run called on task: %u", borrow::to_uint(self)); rtdebug!("run called on task: {}", borrow::to_uint(self));
// The only try/catch block in the world. Attempt to run the task's // The only try/catch block in the world. Attempt to run the task's
// client-specified code and catch any failures. // client-specified code and catch any failures.
@ -329,7 +329,7 @@ impl Task {
impl Drop for Task { impl Drop for Task {
fn drop(&mut self) { fn drop(&mut self) {
rtdebug!("called drop for a task: %u", borrow::to_uint(self)); rtdebug!("called drop for a task: {}", borrow::to_uint(self));
rtassert!(self.destroyed) rtassert!(self.destroyed)
} }
} }
@ -498,7 +498,7 @@ mod test {
let result = spawntask_try(||()); let result = spawntask_try(||());
rtdebug!("trying first assert"); rtdebug!("trying first assert");
assert!(result.is_ok()); assert!(result.is_ok());
let result = spawntask_try(|| fail!()); let result = spawntask_try(|| fail2!());
rtdebug!("trying second assert"); rtdebug!("trying second assert");
assert!(result.is_err()); assert!(result.is_err());
} }
@ -516,7 +516,7 @@ mod test {
#[test] #[test]
fn logging() { fn logging() {
do run_in_newsched_task() { do run_in_newsched_task() {
info!("here i am. logging in a newsched task"); info2!("here i am. logging in a newsched task");
} }
} }
@ -558,7 +558,7 @@ mod test {
fn linked_failure() { fn linked_failure() {
do run_in_newsched_task() { do run_in_newsched_task() {
let res = do spawntask_try { let res = do spawntask_try {
spawntask_random(|| fail!()); spawntask_random(|| fail2!());
}; };
assert!(res.is_err()); assert!(res.is_err());
} }
@ -599,7 +599,7 @@ mod test {
builder.future_result(|r| result = Some(r)); builder.future_result(|r| result = Some(r));
builder.unlinked(); builder.unlinked();
do builder.spawn { do builder.spawn {
fail!(); fail2!();
} }
assert_eq!(result.unwrap().recv(), Failure); assert_eq!(result.unwrap().recv(), Failure);
} }

6
src/libstd/rt/test.rs
View file

@ -114,7 +114,7 @@ mod darwin_fd_limit {
to_mut_unsafe_ptr(&mut size), to_mut_unsafe_ptr(&mut size),
mut_null(), 0) != 0 { mut_null(), 0) != 0 {
let err = last_os_error(); let err = last_os_error();
error!("raise_fd_limit: error calling sysctl: %s", err); error2!("raise_fd_limit: error calling sysctl: {}", err);
return; return;
} }
@ -122,7 +122,7 @@ mod darwin_fd_limit {
let mut rlim = rlimit{rlim_cur: 0, rlim_max: 0}; let mut rlim = rlimit{rlim_cur: 0, rlim_max: 0};
if getrlimit(RLIMIT_NOFILE, to_mut_unsafe_ptr(&mut rlim)) != 0 { if getrlimit(RLIMIT_NOFILE, to_mut_unsafe_ptr(&mut rlim)) != 0 {
let err = last_os_error(); let err = last_os_error();
error!("raise_fd_limit: error calling getrlimit: %s", err); error2!("raise_fd_limit: error calling getrlimit: {}", err);
return; return;
} }
@ -132,7 +132,7 @@ mod darwin_fd_limit {
// Set our newly-increased resource limit // Set our newly-increased resource limit
if setrlimit(RLIMIT_NOFILE, to_unsafe_ptr(&rlim)) != 0 { if setrlimit(RLIMIT_NOFILE, to_unsafe_ptr(&rlim)) != 0 {
let err = last_os_error(); let err = last_os_error();
error!("raise_fd_limit: error calling setrlimit: %s", err); error2!("raise_fd_limit: error calling setrlimit: {}", err);
return; return;
} }
} }

10
src/libstd/rt/util.rs
View file

@ -61,7 +61,7 @@ pub fn default_sched_threads() -> uint {
let opt_n: Option<uint> = FromStr::from_str(nstr); let opt_n: Option<uint> = FromStr::from_str(nstr);
match opt_n { match opt_n {
Some(n) if n > 0 => n, Some(n) if n > 0 => n,
_ => rtabort!("`RUST_THREADS` is `%s`, should be a positive integer", nstr) _ => rtabort!("`RUST_THREADS` is `{}`, should be a positive integer", nstr)
} }
} }
None => { None => {
@ -127,10 +127,10 @@ which at the time convulsed us with joy, yet which are now partly lost to my
memory and partly incapable of presentation to others.", memory and partly incapable of presentation to others.",
_ => "You've met with a terrible fate, haven't you?" _ => "You've met with a terrible fate, haven't you?"
}; };
rterrln!("%s", ""); rterrln!("{}", "");
rterrln!("%s", quote); rterrln!("{}", quote);
rterrln!("%s", ""); rterrln!("{}", "");
rterrln!("fatal runtime error: %s", msg); rterrln!("fatal runtime error: {}", msg);
abort(); abort();

4
src/libstd/rt/uv/file.rs
View file

@ -505,7 +505,7 @@ mod test {
let unlink_req = FsRequest::new(); let unlink_req = FsRequest::new();
let result = unlink_req.unlink_sync(&loop_, &Path(path_str)); let result = unlink_req.unlink_sync(&loop_, &Path(path_str));
assert!(result.is_ok()); assert!(result.is_ok());
} else { fail!("nread was 0.. wudn't expectin' that."); } } else { fail2!("nread was 0.. wudn't expectin' that."); }
loop_.close(); loop_.close();
} }
} }
@ -595,7 +595,7 @@ mod test {
assert!(uverr.is_none()); assert!(uverr.is_none());
let loop_ = req.get_loop(); let loop_ = req.get_loop();
let stat = req.get_stat(); let stat = req.get_stat();
naive_print(&loop_, fmt!("%?", stat)); naive_print(&loop_, format!("{:?}", stat));
assert!(stat.is_dir()); assert!(stat.is_dir());
let rmdir_req = FsRequest::new(); let rmdir_req = FsRequest::new();
do rmdir_req.rmdir(&loop_, &path) |req,uverr| { do rmdir_req.rmdir(&loop_, &path) |req,uverr| {

4
src/libstd/rt/uv/mod.rs
View file

@ -240,7 +240,7 @@ impl UvError {
impl ToStr for UvError { impl ToStr for UvError {
fn to_str(&self) -> ~str { fn to_str(&self) -> ~str {
fmt!("%s: %s", self.name(), self.desc()) format!("{}: {}", self.name(), self.desc())
} }
} }
@ -269,7 +269,7 @@ pub fn uv_error_to_io_error(uverr: UvError) -> IoError {
ECONNRESET => ConnectionReset, ECONNRESET => ConnectionReset,
EPIPE => BrokenPipe, EPIPE => BrokenPipe,
err => { err => {
rtdebug!("uverr.code %d", err as int); rtdebug!("uverr.code {}", err as int);
// XXX: Need to map remaining uv error types // XXX: Need to map remaining uv error types
OtherIoError OtherIoError
} }

30
src/libstd/rt/uv/net.rs
View file

@ -34,7 +34,7 @@ fn sockaddr_to_UvSocketAddr(addr: *uvll::sockaddr) -> UvSocketAddr {
match addr { match addr {
_ if is_ip4_addr(addr) => UvIpv4SocketAddr(addr as *uvll::sockaddr_in), _ if is_ip4_addr(addr) => UvIpv4SocketAddr(addr as *uvll::sockaddr_in),
_ if is_ip6_addr(addr) => UvIpv6SocketAddr(addr as *uvll::sockaddr_in6), _ if is_ip6_addr(addr) => UvIpv6SocketAddr(addr as *uvll::sockaddr_in6),
_ => fail!(), _ => fail2!(),
} }
} }
} }
@ -156,8 +156,8 @@ impl StreamWatcher {
} }
extern fn read_cb(stream: *uvll::uv_stream_t, nread: ssize_t, buf: Buf) { extern fn read_cb(stream: *uvll::uv_stream_t, nread: ssize_t, buf: Buf) {
rtdebug!("buf addr: %x", buf.base as uint); rtdebug!("buf addr: {}", buf.base);
rtdebug!("buf len: %d", buf.len as int); rtdebug!("buf len: {}", buf.len);
let mut stream_watcher: StreamWatcher = NativeHandle::from_native_handle(stream); let mut stream_watcher: StreamWatcher = NativeHandle::from_native_handle(stream);
let cb = stream_watcher.get_watcher_data().read_cb.get_ref(); let cb = stream_watcher.get_watcher_data().read_cb.get_ref();
let status = status_to_maybe_uv_error(nread as c_int); let status = status_to_maybe_uv_error(nread as c_int);
@ -266,7 +266,7 @@ impl TcpWatcher {
self.get_watcher_data().connect_cb = Some(cb); self.get_watcher_data().connect_cb = Some(cb);
let connect_handle = ConnectRequest::new().native_handle(); let connect_handle = ConnectRequest::new().native_handle();
rtdebug!("connect_t: %x", connect_handle as uint); rtdebug!("connect_t: {}", connect_handle);
do socket_addr_as_uv_socket_addr(address) |addr| { do socket_addr_as_uv_socket_addr(address) |addr| {
let result = match addr { let result = match addr {
UvIpv4SocketAddr(addr) => uvll::tcp_connect(connect_handle, UvIpv4SocketAddr(addr) => uvll::tcp_connect(connect_handle,
@ -278,7 +278,7 @@ impl TcpWatcher {
} }
extern fn connect_cb(req: *uvll::uv_connect_t, status: c_int) { extern fn connect_cb(req: *uvll::uv_connect_t, status: c_int) {
rtdebug!("connect_t: %x", req as uint); rtdebug!("connect_t: {}", req);
let connect_request: ConnectRequest = NativeHandle::from_native_handle(req); let connect_request: ConnectRequest = NativeHandle::from_native_handle(req);
let mut stream_watcher = connect_request.stream(); let mut stream_watcher = connect_request.stream();
connect_request.delete(); connect_request.delete();
@ -379,8 +379,8 @@ impl UdpWatcher {
return; return;
} }
rtdebug!("buf addr: %x", buf.base as uint); rtdebug!("buf addr: {}", buf.base);
rtdebug!("buf len: %d", buf.len as int); rtdebug!("buf len: {}", buf.len);
let mut udp_watcher: UdpWatcher = NativeHandle::from_native_handle(handle); let mut udp_watcher: UdpWatcher = NativeHandle::from_native_handle(handle);
let cb = udp_watcher.get_watcher_data().udp_recv_cb.get_ref(); let cb = udp_watcher.get_watcher_data().udp_recv_cb.get_ref();
let status = status_to_maybe_uv_error(nread as c_int); let status = status_to_maybe_uv_error(nread as c_int);
@ -652,11 +652,11 @@ mod test {
let buf = vec_from_uv_buf(buf); let buf = vec_from_uv_buf(buf);
let mut count = count_cell.take(); let mut count = count_cell.take();
if status.is_none() { if status.is_none() {
rtdebug!("got %d bytes", nread); rtdebug!("got {} bytes", nread);
let buf = buf.unwrap(); let buf = buf.unwrap();
for byte in buf.slice(0, nread as uint).iter() { for byte in buf.slice(0, nread as uint).iter() {
assert!(*byte == count as u8); assert!(*byte == count as u8);
rtdebug!("%u", *byte as uint); rtdebug!("{}", *byte as uint);
count += 1; count += 1;
} }
} else { } else {
@ -727,12 +727,12 @@ mod test {
let buf = vec_from_uv_buf(buf); let buf = vec_from_uv_buf(buf);
let mut count = count_cell.take(); let mut count = count_cell.take();
if status.is_none() { if status.is_none() {
rtdebug!("got %d bytes", nread); rtdebug!("got {} bytes", nread);
let buf = buf.unwrap(); let buf = buf.unwrap();
let r = buf.slice(0, nread as uint); let r = buf.slice(0, nread as uint);
for byte in r.iter() { for byte in r.iter() {
assert!(*byte == count as u8); assert!(*byte == count as u8);
rtdebug!("%u", *byte as uint); rtdebug!("{}", *byte as uint);
count += 1; count += 1;
} }
} else { } else {
@ -798,12 +798,12 @@ mod test {
let buf = vec_from_uv_buf(buf); let buf = vec_from_uv_buf(buf);
let mut count = 0; let mut count = 0;
rtdebug!("got %d bytes", nread); rtdebug!("got {} bytes", nread);
let buf = buf.unwrap(); let buf = buf.unwrap();
for &byte in buf.slice(0, nread as uint).iter() { for &byte in buf.slice(0, nread as uint).iter() {
assert!(byte == count as u8); assert!(byte == count as u8);
rtdebug!("%u", byte as uint); rtdebug!("{}", byte as uint);
count += 1; count += 1;
} }
assert_eq!(count, MAX); assert_eq!(count, MAX);
@ -858,12 +858,12 @@ mod test {
let buf = vec_from_uv_buf(buf); let buf = vec_from_uv_buf(buf);
let mut count = 0; let mut count = 0;
rtdebug!("got %d bytes", nread); rtdebug!("got {} bytes", nread);
let buf = buf.unwrap(); let buf = buf.unwrap();
for &byte in buf.slice(0, nread as uint).iter() { for &byte in buf.slice(0, nread as uint).iter() {
assert!(byte == count as u8); assert!(byte == count as u8);
rtdebug!("%u", byte as uint); rtdebug!("{}", byte as uint);
count += 1; count += 1;
} }
assert_eq!(count, MAX); assert_eq!(count, MAX);

2
src/libstd/rt/uv/process.rs
View file

@ -199,7 +199,7 @@ fn with_env<T>(env: Option<&[(~str, ~str)]>, f: &fn(**libc::c_char) -> T) -> T {
// As with argv, create some temporary storage and then the actual array // As with argv, create some temporary storage and then the actual array
let mut envp = vec::with_capacity(env.len()); let mut envp = vec::with_capacity(env.len());
for &(ref key, ref value) in env.iter() { for &(ref key, ref value) in env.iter() {
envp.push(fmt!("%s=%s", *key, *value).to_c_str()); envp.push(format!("{}={}", *key, *value).to_c_str());
} }
let mut c_envp = vec::with_capacity(envp.len() + 1); let mut c_envp = vec::with_capacity(envp.len() + 1);
for s in envp.iter() { for s in envp.iter() {

8
src/libstd/rt/uv/uvio.rs
View file

@ -1802,7 +1802,7 @@ fn test_simple_tcp_server_and_client() {
let nread = stream.read(buf).unwrap(); let nread = stream.read(buf).unwrap();
assert_eq!(nread, 8); assert_eq!(nread, 8);
for i in range(0u, nread) { for i in range(0u, nread) {
rtdebug!("%u", buf[i] as uint); rtdebug!("{}", buf[i]);
assert_eq!(buf[i], i as u8); assert_eq!(buf[i], i as u8);
} }
} }
@ -1919,7 +1919,7 @@ fn test_simple_udp_server_and_client() {
let (nread,src) = server_socket.recvfrom(buf).unwrap(); let (nread,src) = server_socket.recvfrom(buf).unwrap();
assert_eq!(nread, 8); assert_eq!(nread, 8);
for i in range(0u, nread) { for i in range(0u, nread) {
rtdebug!("%u", buf[i] as uint); rtdebug!("{}", buf[i]);
assert_eq!(buf[i], i as u8); assert_eq!(buf[i], i as u8);
} }
assert_eq!(src, client_addr); assert_eq!(src, client_addr);
@ -2031,13 +2031,13 @@ fn test_read_read_read() {
let mut total_bytes_read = 0; let mut total_bytes_read = 0;
while total_bytes_read < MAX { while total_bytes_read < MAX {
let nread = stream.read(buf).unwrap(); let nread = stream.read(buf).unwrap();
rtdebug!("read %u bytes", nread as uint); rtdebug!("read {} bytes", nread);
total_bytes_read += nread; total_bytes_read += nread;
for i in range(0u, nread) { for i in range(0u, nread) {
assert_eq!(buf[i], 1); assert_eq!(buf[i], 1);
} }
} }
rtdebug!("read %u bytes total", total_bytes_read as uint); rtdebug!("read {} bytes total", total_bytes_read);
} }
} }
} }

52
src/libstd/run.rs
View file

@ -199,7 +199,7 @@ impl Process {
fn input_fd(&mut self) -> c_int { fn input_fd(&mut self) -> c_int {
match self.input { match self.input {
Some(fd) => fd, Some(fd) => fd,
None => fail!("This Process's stdin was redirected to an \ None => fail2!("This Process's stdin was redirected to an \
existing file descriptor.") existing file descriptor.")
} }
} }
@ -207,7 +207,7 @@ impl Process {
fn output_file(&mut self) -> *libc::FILE { fn output_file(&mut self) -> *libc::FILE {
match self.output { match self.output {
Some(file) => file, Some(file) => file,
None => fail!("This Process's stdout was redirected to an \ None => fail2!("This Process's stdout was redirected to an \
existing file descriptor.") existing file descriptor.")
} }
} }
@ -215,7 +215,7 @@ impl Process {
fn error_file(&mut self) -> *libc::FILE { fn error_file(&mut self) -> *libc::FILE {
match self.error { match self.error {
Some(file) => file, Some(file) => file,
None => fail!("This Process's stderr was redirected to an \ None => fail2!("This Process's stderr was redirected to an \
existing file descriptor.") existing file descriptor.")
} }
} }
@ -373,7 +373,7 @@ impl Process {
((1, o), (2, e)) => (e, o), ((1, o), (2, e)) => (e, o),
((2, e), (1, o)) => (e, o), ((2, e), (1, o)) => (e, o),
((x, _), (y, _)) => { ((x, _), (y, _)) => {
fail!("unexpected file numbers: %u, %u", x, y); fail2!("unexpected file numbers: {}, {}", x, y);
} }
}; };
@ -482,29 +482,29 @@ fn spawn_process_os(prog: &str, args: &[~str],
let orig_std_in = get_osfhandle(in_fd) as HANDLE; let orig_std_in = get_osfhandle(in_fd) as HANDLE;
if orig_std_in == INVALID_HANDLE_VALUE as HANDLE { if orig_std_in == INVALID_HANDLE_VALUE as HANDLE {
fail!("failure in get_osfhandle: %s", os::last_os_error()); fail2!("failure in get_osfhandle: {}", os::last_os_error());
} }
if DuplicateHandle(cur_proc, orig_std_in, cur_proc, &mut si.hStdInput, if DuplicateHandle(cur_proc, orig_std_in, cur_proc, &mut si.hStdInput,
0, TRUE, DUPLICATE_SAME_ACCESS) == FALSE { 0, TRUE, DUPLICATE_SAME_ACCESS) == FALSE {
fail!("failure in DuplicateHandle: %s", os::last_os_error()); fail2!("failure in DuplicateHandle: {}", os::last_os_error());
} }
let orig_std_out = get_osfhandle(out_fd) as HANDLE; let orig_std_out = get_osfhandle(out_fd) as HANDLE;
if orig_std_out == INVALID_HANDLE_VALUE as HANDLE { if orig_std_out == INVALID_HANDLE_VALUE as HANDLE {
fail!("failure in get_osfhandle: %s", os::last_os_error()); fail2!("failure in get_osfhandle: {}", os::last_os_error());
} }
if DuplicateHandle(cur_proc, orig_std_out, cur_proc, &mut si.hStdOutput, if DuplicateHandle(cur_proc, orig_std_out, cur_proc, &mut si.hStdOutput,
0, TRUE, DUPLICATE_SAME_ACCESS) == FALSE { 0, TRUE, DUPLICATE_SAME_ACCESS) == FALSE {
fail!("failure in DuplicateHandle: %s", os::last_os_error()); fail2!("failure in DuplicateHandle: {}", os::last_os_error());
} }
let orig_std_err = get_osfhandle(err_fd) as HANDLE; let orig_std_err = get_osfhandle(err_fd) as HANDLE;
if orig_std_err == INVALID_HANDLE_VALUE as HANDLE { if orig_std_err == INVALID_HANDLE_VALUE as HANDLE {
fail!("failure in get_osfhandle: %s", os::last_os_error()); fail2!("failure in get_osfhandle: {}", os::last_os_error());
} }
if DuplicateHandle(cur_proc, orig_std_err, cur_proc, &mut si.hStdError, if DuplicateHandle(cur_proc, orig_std_err, cur_proc, &mut si.hStdError,
0, TRUE, DUPLICATE_SAME_ACCESS) == FALSE { 0, TRUE, DUPLICATE_SAME_ACCESS) == FALSE {
fail!("failure in DuplicateHandle: %s", os::last_os_error()); fail2!("failure in DuplicateHandle: {}", os::last_os_error());
} }
let cmd = make_command_line(prog, args); let cmd = make_command_line(prog, args);
@ -529,7 +529,7 @@ fn spawn_process_os(prog: &str, args: &[~str],
CloseHandle(si.hStdError); CloseHandle(si.hStdError);
for msg in create_err.iter() { for msg in create_err.iter() {
fail!("failure in CreateProcess: %s", *msg); fail2!("failure in CreateProcess: {}", *msg);
} }
// We close the thread handle because we don't care about keeping the thread id valid, // We close the thread handle because we don't care about keeping the thread id valid,
@ -669,7 +669,7 @@ fn spawn_process_os(prog: &str, args: &[~str],
let pid = fork(); let pid = fork();
if pid < 0 { if pid < 0 {
fail!("failure in fork: %s", os::last_os_error()); fail2!("failure in fork: {}", os::last_os_error());
} else if pid > 0 { } else if pid > 0 {
return SpawnProcessResult {pid: pid, handle: ptr::null()}; return SpawnProcessResult {pid: pid, handle: ptr::null()};
} }
@ -677,13 +677,13 @@ fn spawn_process_os(prog: &str, args: &[~str],
rustrt::rust_unset_sigprocmask(); rustrt::rust_unset_sigprocmask();
if dup2(in_fd, 0) == -1 { if dup2(in_fd, 0) == -1 {
fail!("failure in dup2(in_fd, 0): %s", os::last_os_error()); fail2!("failure in dup2(in_fd, 0): {}", os::last_os_error());
} }
if dup2(out_fd, 1) == -1 { if dup2(out_fd, 1) == -1 {
fail!("failure in dup2(out_fd, 1): %s", os::last_os_error()); fail2!("failure in dup2(out_fd, 1): {}", os::last_os_error());
} }
if dup2(err_fd, 2) == -1 { if dup2(err_fd, 2) == -1 {
fail!("failure in dup3(err_fd, 2): %s", os::last_os_error()); fail2!("failure in dup3(err_fd, 2): {}", os::last_os_error());
} }
// close all other fds // close all other fds
for fd in range(3, getdtablesize()).invert() { for fd in range(3, getdtablesize()).invert() {
@ -692,7 +692,7 @@ fn spawn_process_os(prog: &str, args: &[~str],
do with_dirp(dir) |dirp| { do with_dirp(dir) |dirp| {
if !dirp.is_null() && chdir(dirp) == -1 { if !dirp.is_null() && chdir(dirp) == -1 {
fail!("failure in chdir: %s", os::last_os_error()); fail2!("failure in chdir: {}", os::last_os_error());
} }
} }
@ -703,7 +703,7 @@ fn spawn_process_os(prog: &str, args: &[~str],
do with_argv(prog, args) |argv| { do with_argv(prog, args) |argv| {
execvp(*argv, argv); execvp(*argv, argv);
// execvp only returns if an error occurred // execvp only returns if an error occurred
fail!("failure in execvp: %s", os::last_os_error()); fail2!("failure in execvp: {}", os::last_os_error());
} }
} }
} }
@ -749,7 +749,7 @@ fn with_envp<T>(env: Option<~[(~str, ~str)]>, cb: &fn(*c_void) -> T) -> T {
let mut tmps = vec::with_capacity(env.len()); let mut tmps = vec::with_capacity(env.len());
for pair in env.iter() { for pair in env.iter() {
let kv = fmt!("%s=%s", pair.first(), pair.second()); let kv = format!("{}={}", pair.first(), pair.second());
tmps.push(kv.to_c_str()); tmps.push(kv.to_c_str());
} }
@ -777,7 +777,7 @@ fn with_envp<T>(env: Option<~[(~str, ~str)]>, cb: &fn(*mut c_void) -> T) -> T {
let mut blk = ~[]; let mut blk = ~[];
for pair in env.iter() { for pair in env.iter() {
let kv = fmt!("%s=%s", pair.first(), pair.second()); let kv = format!("{}={}", pair.first(), pair.second());
blk.push_all(kv.as_bytes()); blk.push_all(kv.as_bytes());
blk.push(0); blk.push(0);
} }
@ -890,14 +890,14 @@ fn waitpid(pid: pid_t) -> int {
let proc = OpenProcess(SYNCHRONIZE | PROCESS_QUERY_INFORMATION, FALSE, pid as DWORD); let proc = OpenProcess(SYNCHRONIZE | PROCESS_QUERY_INFORMATION, FALSE, pid as DWORD);
if proc.is_null() { if proc.is_null() {
fail!("failure in OpenProcess: %s", os::last_os_error()); fail2!("failure in OpenProcess: {}", os::last_os_error());
} }
loop { loop {
let mut status = 0; let mut status = 0;
if GetExitCodeProcess(proc, &mut status) == FALSE { if GetExitCodeProcess(proc, &mut status) == FALSE {
CloseHandle(proc); CloseHandle(proc);
fail!("failure in GetExitCodeProcess: %s", os::last_os_error()); fail2!("failure in GetExitCodeProcess: {}", os::last_os_error());
} }
if status != STILL_ACTIVE { if status != STILL_ACTIVE {
CloseHandle(proc); CloseHandle(proc);
@ -905,7 +905,7 @@ fn waitpid(pid: pid_t) -> int {
} }
if WaitForSingleObject(proc, INFINITE) == WAIT_FAILED { if WaitForSingleObject(proc, INFINITE) == WAIT_FAILED {
CloseHandle(proc); CloseHandle(proc);
fail!("failure in WaitForSingleObject: %s", os::last_os_error()); fail2!("failure in WaitForSingleObject: {}", os::last_os_error());
} }
} }
} }
@ -943,7 +943,7 @@ fn waitpid(pid: pid_t) -> int {
let mut status = 0 as c_int; let mut status = 0 as c_int;
if unsafe { waitpid(pid, &mut status, 0) } == -1 { if unsafe { waitpid(pid, &mut status, 0) } == -1 {
fail!("failure in waitpid: %s", os::last_os_error()); fail2!("failure in waitpid: {}", os::last_os_error());
} }
return if WIFEXITED(status) { return if WIFEXITED(status) {
@ -1342,7 +1342,7 @@ mod tests {
let r = os::env(); let r = os::env();
for &(ref k, ref v) in r.iter() { for &(ref k, ref v) in r.iter() {
// don't check windows magical empty-named variables // don't check windows magical empty-named variables
assert!(k.is_empty() || output.contains(fmt!("%s=%s", *k, *v))); assert!(k.is_empty() || output.contains(format!("{}={}", *k, *v)));
} }
} }
#[test] #[test]
@ -1357,8 +1357,8 @@ mod tests {
for &(ref k, ref v) in r.iter() { for &(ref k, ref v) in r.iter() {
// don't check android RANDOM variables // don't check android RANDOM variables
if *k != ~"RANDOM" { if *k != ~"RANDOM" {
assert!(output.contains(fmt!("%s=%s", *k, *v)) || assert!(output.contains(format!("{}={}", *k, *v)) ||
output.contains(fmt!("%s=\'%s\'", *k, *v))); output.contains(format!("{}=\'{}\'", *k, *v)));
} }
} }
} }

6
src/libstd/select.rs
View file

@ -35,7 +35,7 @@ pub trait SelectPort<T> : SelectPortInner<T> { }
/// port whose data is ready. (If multiple are ready, returns the lowest index.) /// port whose data is ready. (If multiple are ready, returns the lowest index.)
pub fn select<A: Select>(ports: &mut [A]) -> uint { pub fn select<A: Select>(ports: &mut [A]) -> uint {
if ports.is_empty() { if ports.is_empty() {
fail!("can't select on an empty list"); fail2!("can't select on an empty list");
} }
for (index, port) in ports.mut_iter().enumerate() { for (index, port) in ports.mut_iter().enumerate() {
@ -116,7 +116,7 @@ pub fn select2<TA, A: SelectPort<TA>, TB, B: SelectPort<TB>>(mut a: A, mut b: B)
match result { match result {
0 => Left ((a.recv_ready(), b)), 0 => Left ((a.recv_ready(), b)),
1 => Right((a, b.recv_ready())), 1 => Right((a, b.recv_ready())),
x => fail!("impossible case in select2: %?", x) x => fail2!("impossible case in select2: {:?}", x)
} }
} }
@ -335,7 +335,7 @@ mod test {
let _ = dead_cs; let _ = dead_cs;
} }
do task::spawn { do task::spawn {
fail!(); // should kill sibling awake fail2!(); // should kill sibling awake
} }
// wait for killed selector to close (NOT send on) its c. // wait for killed selector to close (NOT send on) its c.

28
src/libstd/str.rs
View file

@ -134,8 +134,8 @@ pub fn from_utf8(vv: &[u8]) -> ~str {
match from_utf8_opt(vv) { match from_utf8_opt(vv) {
None => { None => {
let first_bad_byte = *vv.iter().find(|&b| !is_utf8([*b])).unwrap(); let first_bad_byte = *vv.iter().find(|&b| !is_utf8([*b])).unwrap();
cond.raise(fmt!("from_utf8: input is not UTF-8; first bad byte is %u", cond.raise(format!("from_utf8: input is not UTF-8; first bad \
first_bad_byte as uint)) byte is {}", first_bad_byte))
} }
Some(s) => s Some(s) => s
} }
@ -161,8 +161,8 @@ pub fn from_utf8_owned(vv: ~[u8]) -> ~str {
if !is_utf8(vv) { if !is_utf8(vv) {
let first_bad_byte = *vv.iter().find(|&b| !is_utf8([*b])).unwrap(); let first_bad_byte = *vv.iter().find(|&b| !is_utf8([*b])).unwrap();
cond.raise(fmt!("from_utf8: input is not UTF-8; first bad byte is %u", cond.raise(format!("from_utf8: input is not UTF-8; first bad byte is {}",
first_bad_byte as uint)) first_bad_byte))
} else { } else {
unsafe { raw::from_utf8_owned(vv) } unsafe { raw::from_utf8_owned(vv) }
} }
@ -1229,7 +1229,7 @@ pub mod raw {
match ctr { match ctr {
0 => assert_eq!(x, &~"zero"), 0 => assert_eq!(x, &~"zero"),
1 => assert_eq!(x, &~"one"), 1 => assert_eq!(x, &~"one"),
_ => fail!("shouldn't happen!") _ => fail2!("shouldn't happen!")
} }
ctr += 1; ctr += 1;
} }
@ -2000,8 +2000,8 @@ impl<'self> StrSlice<'self> for &'self str {
if end_byte.is_none() && count == end { end_byte = Some(self.len()) } if end_byte.is_none() && count == end { end_byte = Some(self.len()) }
match (begin_byte, end_byte) { match (begin_byte, end_byte) {
(None, _) => fail!("slice_chars: `begin` is beyond end of string"), (None, _) => fail2!("slice_chars: `begin` is beyond end of string"),
(_, None) => fail!("slice_chars: `end` is beyond end of string"), (_, None) => fail2!("slice_chars: `end` is beyond end of string"),
(Some(a), Some(b)) => unsafe { raw::slice_bytes(*self, a, b) } (Some(a), Some(b)) => unsafe { raw::slice_bytes(*self, a, b) }
} }
} }
@ -2723,12 +2723,12 @@ mod tests {
#[test] #[test]
fn test_collect() { fn test_collect() {
let empty = ""; let empty = ~"";
let s: ~str = empty.iter().collect(); let s: ~str = empty.iter().collect();
assert_eq!(empty, s.as_slice()); assert_eq!(empty, s);
let data = "ประเทศไทย中"; let data = ~"ประเทศไทย中";
let s: ~str = data.iter().collect(); let s: ~str = data.iter().collect();
assert_eq!(data, s.as_slice()); assert_eq!(data, s);
} }
#[test] #[test]
@ -3242,7 +3242,7 @@ mod tests {
// original problem code path anymore.) // original problem code path anymore.)
let s = ~""; let s = ~"";
let _bytes = s.as_bytes(); let _bytes = s.as_bytes();
fail!(); fail2!();
} }
#[test] #[test]
@ -3300,8 +3300,8 @@ mod tests {
while i < n1 { while i < n1 {
let a: u8 = s1[i]; let a: u8 = s1[i];
let b: u8 = s2[i]; let b: u8 = s2[i];
debug!(a); debug2!("{}", a);
debug!(b); debug2!("{}", b);
assert_eq!(a, b); assert_eq!(a, b);
i += 1u; i += 1u;
} }

4
src/libstd/sys.rs
View file

@ -134,7 +134,7 @@ pub fn begin_unwind_(msg: *c_char, file: *c_char, line: size_t) -> ! {
use str::Str; use str::Str;
unsafe { unsafe {
// XXX: Bad re-allocations. fail! needs some refactoring // XXX: Bad re-allocations. fail2! needs some refactoring
let msg = str::raw::from_c_str(msg); let msg = str::raw::from_c_str(msg);
let file = str::raw::from_c_str(file); let file = str::raw::from_c_str(file);
@ -148,7 +148,7 @@ pub fn begin_unwind_(msg: *c_char, file: *c_char, line: size_t) -> ! {
n, msg.as_slice(), file.as_slice(), line); n, msg.as_slice(), file.as_slice(), line);
} }
} else { } else {
rterrln!("failed in non-task context at '%s', %s:%i", rterrln!("failed in non-task context at '{}', {}:{}",
msg, file, line as int); msg, file, line as int);
} }

54
src/libstd/task/mod.rs
View file

@ -181,7 +181,7 @@ pub fn task() -> TaskBuilder {
impl TaskBuilder { impl TaskBuilder {
fn consume(&mut self) -> TaskBuilder { fn consume(&mut self) -> TaskBuilder {
if self.consumed { if self.consumed {
fail!("Cannot copy a task_builder"); // Fake move mode on self fail2!("Cannot copy a task_builder"); // Fake move mode on self
} }
self.consumed = true; self.consumed = true;
let gen_body = self.gen_body.take(); let gen_body = self.gen_body.take();
@ -271,7 +271,7 @@ impl TaskBuilder {
// sending out messages. // sending out messages.
if self.opts.notify_chan.is_some() { if self.opts.notify_chan.is_some() {
fail!("Can't set multiple future_results for one task!"); fail2!("Can't set multiple future_results for one task!");
} }
// Construct the future and give it to the caller. // Construct the future and give it to the caller.
@ -532,7 +532,7 @@ pub fn with_task_name<U>(blk: &fn(Option<&str>) -> U) -> U {
} }
} }
} else { } else {
fail!("no task name exists in non-green task context") fail2!("no task name exists in non-green task context")
} }
} }
@ -640,7 +640,7 @@ fn test_kill_unkillable_task() {
do run_in_newsched_task { do run_in_newsched_task {
do task::try { do task::try {
do task::spawn { do task::spawn {
fail!(); fail2!();
} }
do task::unkillable { } do task::unkillable { }
}; };
@ -659,7 +659,7 @@ fn test_kill_rekillable_task() {
do task::unkillable { do task::unkillable {
do task::rekillable { do task::rekillable {
do task::spawn { do task::spawn {
fail!(); fail2!();
} }
} }
} }
@ -689,7 +689,7 @@ fn test_rekillable_nested_failure() {
do unkillable { do unkillable {
do rekillable { do rekillable {
let (port,chan) = comm::stream(); let (port,chan) = comm::stream();
do task::spawn { chan.send(()); fail!(); } do task::spawn { chan.send(()); fail2!(); }
port.recv(); // wait for child to exist port.recv(); // wait for child to exist
port.recv(); // block forever, expect to get killed. port.recv(); // block forever, expect to get killed.
} }
@ -733,7 +733,7 @@ fn test_spawn_unlinked_unsup_no_fail_down() { // grandchild sends on a port
do 16.times { task::deschedule(); } do 16.times { task::deschedule(); }
ch.send(()); // If killed first, grandparent hangs. ch.send(()); // If killed first, grandparent hangs.
} }
fail!(); // Shouldn't kill either (grand)parent or (grand)child. fail2!(); // Shouldn't kill either (grand)parent or (grand)child.
} }
po.recv(); po.recv();
} }
@ -743,7 +743,7 @@ fn test_spawn_unlinked_unsup_no_fail_down() { // grandchild sends on a port
fn test_spawn_unlinked_unsup_no_fail_up() { // child unlinked fails fn test_spawn_unlinked_unsup_no_fail_up() { // child unlinked fails
use rt::test::run_in_newsched_task; use rt::test::run_in_newsched_task;
do run_in_newsched_task { do run_in_newsched_task {
do spawn_unlinked { fail!(); } do spawn_unlinked { fail2!(); }
} }
} }
#[ignore(reason = "linked failure")] #[ignore(reason = "linked failure")]
@ -751,7 +751,7 @@ fn test_spawn_unlinked_unsup_no_fail_up() { // child unlinked fails
fn test_spawn_unlinked_sup_no_fail_up() { // child unlinked fails fn test_spawn_unlinked_sup_no_fail_up() { // child unlinked fails
use rt::test::run_in_newsched_task; use rt::test::run_in_newsched_task;
do run_in_newsched_task { do run_in_newsched_task {
do spawn_supervised { fail!(); } do spawn_supervised { fail2!(); }
// Give child a chance to fail-but-not-kill-us. // Give child a chance to fail-but-not-kill-us.
do 16.times { task::deschedule(); } do 16.times { task::deschedule(); }
} }
@ -763,7 +763,7 @@ fn test_spawn_unlinked_sup_fail_down() {
do run_in_newsched_task { do run_in_newsched_task {
let result: Result<(),()> = do try { let result: Result<(),()> = do try {
do spawn_supervised { block_forever(); } do spawn_supervised { block_forever(); }
fail!(); // Shouldn't leave a child hanging around. fail2!(); // Shouldn't leave a child hanging around.
}; };
assert!(result.is_err()); assert!(result.is_err());
} }
@ -783,7 +783,7 @@ fn test_spawn_linked_sup_fail_up() { // child fails; parent fails
b0.opts.supervised = true; b0.opts.supervised = true;
do b0.spawn { do b0.spawn {
fail!(); fail2!();
} }
block_forever(); // We should get punted awake block_forever(); // We should get punted awake
}; };
@ -802,7 +802,7 @@ fn test_spawn_linked_sup_fail_down() { // parent fails; child fails
b0.opts.linked = true; b0.opts.linked = true;
b0.opts.supervised = true; b0.opts.supervised = true;
do b0.spawn { block_forever(); } do b0.spawn { block_forever(); }
fail!(); // *both* mechanisms would be wrong if this didn't kill the child fail2!(); // *both* mechanisms would be wrong if this didn't kill the child
}; };
assert!(result.is_err()); assert!(result.is_err());
} }
@ -814,7 +814,7 @@ fn test_spawn_linked_unsup_fail_up() { // child fails; parent fails
do run_in_newsched_task { do run_in_newsched_task {
let result: Result<(),()> = do try { let result: Result<(),()> = do try {
// Default options are to spawn linked & unsupervised. // Default options are to spawn linked & unsupervised.
do spawn { fail!(); } do spawn { fail2!(); }
block_forever(); // We should get punted awake block_forever(); // We should get punted awake
}; };
assert!(result.is_err()); assert!(result.is_err());
@ -828,7 +828,7 @@ fn test_spawn_linked_unsup_fail_down() { // parent fails; child fails
let result: Result<(),()> = do try { let result: Result<(),()> = do try {
// Default options are to spawn linked & unsupervised. // Default options are to spawn linked & unsupervised.
do spawn { block_forever(); } do spawn { block_forever(); }
fail!(); fail2!();
}; };
assert!(result.is_err()); assert!(result.is_err());
} }
@ -843,7 +843,7 @@ fn test_spawn_linked_unsup_default_opts() { // parent fails; child fails
let mut builder = task(); let mut builder = task();
builder.linked(); builder.linked();
do builder.spawn { block_forever(); } do builder.spawn { block_forever(); }
fail!(); fail2!();
}; };
assert!(result.is_err()); assert!(result.is_err());
} }
@ -863,7 +863,7 @@ fn test_spawn_failure_propagate_grandchild() {
do spawn_supervised { block_forever(); } do spawn_supervised { block_forever(); }
} }
do 16.times { task::deschedule(); } do 16.times { task::deschedule(); }
fail!(); fail2!();
}; };
assert!(result.is_err()); assert!(result.is_err());
} }
@ -880,7 +880,7 @@ fn test_spawn_failure_propagate_secondborn() {
do spawn { block_forever(); } // linked do spawn { block_forever(); } // linked
} }
do 16.times { task::deschedule(); } do 16.times { task::deschedule(); }
fail!(); fail2!();
}; };
assert!(result.is_err()); assert!(result.is_err());
} }
@ -897,7 +897,7 @@ fn test_spawn_failure_propagate_nephew_or_niece() {
do spawn_supervised { block_forever(); } do spawn_supervised { block_forever(); }
} }
do 16.times { task::deschedule(); } do 16.times { task::deschedule(); }
fail!(); fail2!();
}; };
assert!(result.is_err()); assert!(result.is_err());
} }
@ -914,7 +914,7 @@ fn test_spawn_linked_sup_propagate_sibling() {
do spawn { block_forever(); } // linked do spawn { block_forever(); } // linked
} }
do 16.times { task::deschedule(); } do 16.times { task::deschedule(); }
fail!(); fail2!();
}; };
assert!(result.is_err()); assert!(result.is_err());
} }
@ -994,7 +994,7 @@ fn test_future_result() {
builder.future_result(|r| result = Some(r)); builder.future_result(|r| result = Some(r));
builder.unlinked(); builder.unlinked();
do builder.spawn { do builder.spawn {
fail!(); fail2!();
} }
assert_eq!(result.unwrap().recv(), Failure); assert_eq!(result.unwrap().recv(), Failure);
} }
@ -1012,17 +1012,17 @@ fn test_try_success() {
~"Success!" ~"Success!"
} { } {
result::Ok(~"Success!") => (), result::Ok(~"Success!") => (),
_ => fail!() _ => fail2!()
} }
} }
#[test] #[test]
fn test_try_fail() { fn test_try_fail() {
match do try { match do try {
fail!() fail2!()
} { } {
result::Err(()) => (), result::Err(()) => (),
result::Ok(()) => fail!() result::Ok(()) => fail2!()
} }
} }
@ -1212,7 +1212,7 @@ fn test_unkillable() {
deschedule(); deschedule();
// We want to fail after the unkillable task // We want to fail after the unkillable task
// blocks on recv // blocks on recv
fail!(); fail2!();
} }
unsafe { unsafe {
@ -1247,7 +1247,7 @@ fn test_unkillable_nested() {
deschedule(); deschedule();
// We want to fail after the unkillable task // We want to fail after the unkillable task
// blocks on recv // blocks on recv
fail!(); fail2!();
} }
unsafe { unsafe {
@ -1312,7 +1312,7 @@ fn test_spawn_watched() {
t.watched(); t.watched();
do t.spawn { do t.spawn {
task::deschedule(); task::deschedule();
fail!(); fail2!();
} }
} }
}; };
@ -1348,7 +1348,7 @@ fn test_indestructible() {
do t.spawn { do t.spawn {
p3.recv(); p3.recv();
task::deschedule(); task::deschedule();
fail!(); fail2!();
} }
c3.send(()); c3.send(());
p2.recv(); p2.recv();

4
src/libstd/task/spawn.rs
View file

@ -712,7 +712,7 @@ fn test_spawn_raw_unsupervise() {
.. default_task_opts() .. default_task_opts()
}; };
do spawn_raw(opts) { do spawn_raw(opts) {
fail!(); fail2!();
} }
} }
@ -741,7 +741,7 @@ fn test_spawn_raw_notify_failure() {
.. default_task_opts() .. default_task_opts()
}; };
do spawn_raw(opts) { do spawn_raw(opts) {
fail!(); fail2!();
} }
assert_eq!(notify_po.recv(), Failure); assert_eq!(notify_po.recv(), Failure);
} }

8
src/libstd/to_str.rs
View file

@ -45,7 +45,7 @@ impl<A:ToStr> ToStr for (A,) {
fn to_str(&self) -> ~str { fn to_str(&self) -> ~str {
match *self { match *self {
(ref a,) => { (ref a,) => {
fmt!("(%s,)", (*a).to_str()) format!("({},)", (*a).to_str())
} }
} }
} }
@ -98,7 +98,7 @@ impl<A:ToStr,B:ToStr> ToStr for (A, B) {
//let &(ref a, ref b) = self; //let &(ref a, ref b) = self;
match *self { match *self {
(ref a, ref b) => { (ref a, ref b) => {
fmt!("(%s, %s)", (*a).to_str(), (*b).to_str()) format!("({}, {})", (*a).to_str(), (*b).to_str())
} }
} }
} }
@ -111,7 +111,7 @@ impl<A:ToStr,B:ToStr,C:ToStr> ToStr for (A, B, C) {
//let &(ref a, ref b, ref c) = self; //let &(ref a, ref b, ref c) = self;
match *self { match *self {
(ref a, ref b, ref c) => { (ref a, ref b, ref c) => {
fmt!("(%s, %s, %s)", format!("({}, {}, {})",
(*a).to_str(), (*a).to_str(),
(*b).to_str(), (*b).to_str(),
(*c).to_str() (*c).to_str()
@ -221,7 +221,7 @@ mod tests {
impl ToStr for StructWithToStrWithoutEqOrHash { impl ToStr for StructWithToStrWithoutEqOrHash {
fn to_str(&self) -> ~str { fn to_str(&self) -> ~str {
fmt!("s%d", self.value) format!("s{}", self.value)
} }
} }

4
src/libstd/trie.rs
View file

@ -422,7 +422,7 @@ fn remove<T>(count: &mut uint, child: &mut Child<T>, key: uint,
External(stored, _) if stored == key => { External(stored, _) if stored == key => {
match replace(child, Nothing) { match replace(child, Nothing) {
External(_, value) => (Some(value), true), External(_, value) => (Some(value), true),
_ => fail!() _ => fail2!()
} }
} }
External(*) => (None, false), External(*) => (None, false),
@ -531,7 +531,7 @@ mod test_map {
assert!(m.insert(5, 14)); assert!(m.insert(5, 14));
let new = 100; let new = 100;
match m.find_mut(&5) { match m.find_mut(&5) {
None => fail!(), Some(x) => *x = new None => fail2!(), Some(x) => *x = new
} }
assert_eq!(m.find(&5), Some(&new)); assert_eq!(m.find(&5), Some(&new));
} }

12
src/libstd/unstable/dynamic_lib.rs
View file

@ -33,7 +33,7 @@ impl Drop for DynamicLibrary {
} }
} { } {
Ok(()) => {}, Ok(()) => {},
Err(str) => fail!(str) Err(str) => fail2!("{}", str)
} }
} }
} }
@ -96,7 +96,7 @@ mod test {
// The math library does not need to be loaded since it is already // The math library does not need to be loaded since it is already
// statically linked in // statically linked in
let libm = match DynamicLibrary::open(None) { let libm = match DynamicLibrary::open(None) {
Err(error) => fail!("Could not load self as module: %s", error), Err(error) => fail2!("Could not load self as module: {}", error),
Ok(libm) => libm Ok(libm) => libm
}; };
@ -104,7 +104,7 @@ mod test {
// this as a C function // this as a C function
let cosine: extern fn(libc::c_double) -> libc::c_double = unsafe { let cosine: extern fn(libc::c_double) -> libc::c_double = unsafe {
match libm.symbol("cos") { match libm.symbol("cos") {
Err(error) => fail!("Could not load function cos: %s", error), Err(error) => fail2!("Could not load function cos: {}", error),
Ok(cosine) => cosine Ok(cosine) => cosine
} }
}; };
@ -113,7 +113,7 @@ mod test {
let expected_result = 1.0; let expected_result = 1.0;
let result = cosine(argument); let result = cosine(argument);
if result != expected_result { if result != expected_result {
fail!("cos(%?) != %? but equaled %? instead", argument, fail2!("cos({:?}) != {:?} but equaled {:?} instead", argument,
expected_result, result) expected_result, result)
} }
} }
@ -129,7 +129,7 @@ mod test {
let path = GenericPath::from_str("/dev/null"); let path = GenericPath::from_str("/dev/null");
match DynamicLibrary::open(Some(&path)) { match DynamicLibrary::open(Some(&path)) {
Err(_) => {} Err(_) => {}
Ok(_) => fail!("Successfully opened the empty library.") Ok(_) => fail2!("Successfully opened the empty library.")
} }
} }
} }
@ -241,7 +241,7 @@ pub mod dl {
if 0 == error { if 0 == error {
Ok(result) Ok(result)
} else { } else {
Err(fmt!("Error code %?", error)) Err(format!("Error code {}", error))
} }
} }
} }

6
src/libstd/unstable/extfmt.rs
View file

@ -333,14 +333,14 @@ pub mod ct {
'f' => TyFloat, 'f' => TyFloat,
'p' => TyPointer, 'p' => TyPointer,
'?' => TyPoly, '?' => TyPoly,
_ => err(fmt!("unknown type in conversion: %c", s.char_at(i))) _ => err(format!("unknown type in conversion: {}", s.char_at(i)))
}; };
Parsed::new(t, i + 1) Parsed::new(t, i + 1)
} }
#[cfg(test)] #[cfg(test)]
fn die(s: &str) -> ! { fail!(s.to_owned()) } fn die(s: &str) -> ! { fail2!(s.to_owned()) }
#[test] #[test]
fn test_parse_count() { fn test_parse_count() {
@ -698,6 +698,6 @@ mod test {
#[test] #[test]
fn fmt_slice() { fn fmt_slice() {
let s = "abc"; let s = "abc";
let _s = fmt!("%s", s); let _s = format!("{}", s);
} }
} }

2
src/libstd/unstable/finally.rs
View file

@ -87,7 +87,7 @@ fn test_fail() {
let mut i = 0; let mut i = 0;
do (|| { do (|| {
i = 10; i = 10;
fail!(); fail2!();
}).finally { }).finally {
assert!(failing()); assert!(failing());
assert_eq!(i, 10); assert_eq!(i, 10);

4
src/libstd/unstable/lang.rs
View file

@ -27,8 +27,8 @@ pub fn fail_(expr: *c_char, file: *c_char, line: size_t) -> ! {
#[lang="fail_bounds_check"] #[lang="fail_bounds_check"]
pub fn fail_bounds_check(file: *c_char, line: size_t, pub fn fail_bounds_check(file: *c_char, line: size_t,
index: size_t, len: size_t) { index: size_t, len: size_t) {
let msg = fmt!("index out of bounds: the len is %d but the index is %d", let msg = format!("index out of bounds: the len is {} but the index is {}",
len as int, index as int); len as int, index as int);
do msg.with_c_str |buf| { do msg.with_c_str |buf| {
fail_(buf, file, line); fail_(buf, file, line);
} }

6
src/libstd/unstable/sync.rs
View file

@ -172,7 +172,7 @@ impl<T: Send> UnsafeArc<T> {
// If 'put' returns the server end back to us, we were rejected; // If 'put' returns the server end back to us, we were rejected;
// someone else was trying to unwrap. Avoid guaranteed deadlock. // someone else was trying to unwrap. Avoid guaranteed deadlock.
cast::forget(data); cast::forget(data);
fail!("Another task is already unwrapping this Arc!"); fail2!("Another task is already unwrapping this Arc!");
} }
} }
} }
@ -386,7 +386,7 @@ impl<T:Send> Exclusive<T> {
let rec = self.x.get(); let rec = self.x.get();
do (*rec).lock.lock { do (*rec).lock.lock {
if (*rec).failed { if (*rec).failed {
fail!("Poisoned Exclusive::new - another task failed inside!"); fail2!("Poisoned Exclusive::new - another task failed inside!");
} }
(*rec).failed = true; (*rec).failed = true;
let result = f(&mut (*rec).data); let result = f(&mut (*rec).data);
@ -618,7 +618,7 @@ mod tests {
let x2 = x.clone(); let x2 = x.clone();
do task::spawn { do task::spawn {
do 10.times { task::deschedule(); } // try to let the unwrapper go do 10.times { task::deschedule(); } // try to let the unwrapper go
fail!(); // punt it awake from its deadlock fail2!(); // punt it awake from its deadlock
} }
let _z = x.unwrap(); let _z = x.unwrap();
unsafe { do x2.with |_hello| { } } unsafe { do x2.with |_hello| { } }

36
src/libstd/vec.rs
View file

@ -1022,7 +1022,7 @@ impl<'self,T> ImmutableVector<'self, T> for &'self [T] {
/// Returns the first element of a vector, failing if the vector is empty. /// Returns the first element of a vector, failing if the vector is empty.
#[inline] #[inline]
fn head(&self) -> &'self T { fn head(&self) -> &'self T {
if self.len() == 0 { fail!("head: empty vector") } if self.len() == 0 { fail2!("head: empty vector") }
&self[0] &self[0]
} }
@ -1055,7 +1055,7 @@ impl<'self,T> ImmutableVector<'self, T> for &'self [T] {
/// Returns the last element of a vector, failing if the vector is empty. /// Returns the last element of a vector, failing if the vector is empty.
#[inline] #[inline]
fn last(&self) -> &'self T { fn last(&self) -> &'self T {
if self.len() == 0 { fail!("last: empty vector") } if self.len() == 0 { fail2!("last: empty vector") }
&self[self.len() - 1] &self[self.len() - 1]
} }
@ -1301,7 +1301,7 @@ impl<T> OwnedVector<T> for ~[T] {
let alloc = n * sys::nonzero_size_of::<T>(); let alloc = n * sys::nonzero_size_of::<T>();
let size = alloc + sys::size_of::<Vec<()>>(); let size = alloc + sys::size_of::<Vec<()>>();
if alloc / sys::nonzero_size_of::<T>() != n || size < alloc { if alloc / sys::nonzero_size_of::<T>() != n || size < alloc {
fail!("vector size is too large: %u", n); fail2!("vector size is too large: {}", n);
} }
*ptr = realloc_raw(*ptr as *mut c_void, size) *ptr = realloc_raw(*ptr as *mut c_void, size)
as *mut Vec<()>; as *mut Vec<()>;
@ -1343,7 +1343,7 @@ impl<T> OwnedVector<T> for ~[T] {
fn reserve_additional(&mut self, n: uint) { fn reserve_additional(&mut self, n: uint) {
if self.capacity() - self.len() < n { if self.capacity() - self.len() < n {
match self.len().checked_add(&n) { match self.len().checked_add(&n) {
None => fail!("vec::reserve_additional: `uint` overflow"), None => fail2!("vec::reserve_additional: `uint` overflow"),
Some(new_cap) => self.reserve_at_least(new_cap) Some(new_cap) => self.reserve_at_least(new_cap)
} }
} }
@ -1570,7 +1570,7 @@ impl<T> OwnedVector<T> for ~[T] {
fn swap_remove(&mut self, index: uint) -> T { fn swap_remove(&mut self, index: uint) -> T {
let ln = self.len(); let ln = self.len();
if index >= ln { if index >= ln {
fail!("vec::swap_remove - index %u >= length %u", index, ln); fail2!("vec::swap_remove - index {} >= length {}", index, ln);
} }
if index < ln - 1 { if index < ln - 1 {
self.swap(index, ln - 1); self.swap(index, ln - 1);
@ -2958,7 +2958,7 @@ mod tests {
3 => assert_eq!(v, [2, 3, 1]), 3 => assert_eq!(v, [2, 3, 1]),
4 => assert_eq!(v, [2, 1, 3]), 4 => assert_eq!(v, [2, 1, 3]),
5 => assert_eq!(v, [1, 2, 3]), 5 => assert_eq!(v, [1, 2, 3]),
_ => fail!(), _ => fail2!(),
} }
} }
} }
@ -3205,7 +3205,7 @@ mod tests {
#[should_fail] #[should_fail]
fn test_from_fn_fail() { fn test_from_fn_fail() {
do from_fn(100) |v| { do from_fn(100) |v| {
if v == 50 { fail!() } if v == 50 { fail2!() }
(~0, @0) (~0, @0)
}; };
} }
@ -3224,7 +3224,7 @@ mod tests {
fn clone(&self) -> S { fn clone(&self) -> S {
let s = unsafe { cast::transmute_mut(self) }; let s = unsafe { cast::transmute_mut(self) };
s.f += 1; s.f += 1;
if s.f == 10 { fail!() } if s.f == 10 { fail2!() }
S { f: s.f, boxes: s.boxes.clone() } S { f: s.f, boxes: s.boxes.clone() }
} }
} }
@ -3241,7 +3241,7 @@ mod tests {
push((~0, @0)); push((~0, @0));
push((~0, @0)); push((~0, @0));
push((~0, @0)); push((~0, @0));
fail!(); fail2!();
}; };
} }
@ -3251,7 +3251,7 @@ mod tests {
let mut v = ~[]; let mut v = ~[];
do v.grow_fn(100) |i| { do v.grow_fn(100) |i| {
if i == 50 { if i == 50 {
fail!() fail2!()
} }
(~0, @0) (~0, @0)
} }
@ -3264,7 +3264,7 @@ mod tests {
let mut i = 0; let mut i = 0;
do v.map |_elt| { do v.map |_elt| {
if i == 2 { if i == 2 {
fail!() fail2!()
} }
i += 1; i += 1;
~[(~0, @0)] ~[(~0, @0)]
@ -3278,7 +3278,7 @@ mod tests {
let mut i = 0; let mut i = 0;
do flat_map(v) |_elt| { do flat_map(v) |_elt| {
if i == 2 { if i == 2 {
fail!() fail2!()
} }
i += 1; i += 1;
~[(~0, @0)] ~[(~0, @0)]
@ -3292,7 +3292,7 @@ mod tests {
let mut i = 0; let mut i = 0;
for _ in v.permutations_iter() { for _ in v.permutations_iter() {
if i == 2 { if i == 2 {
fail!() fail2!()
} }
i += 1; i += 1;
} }
@ -3303,7 +3303,7 @@ mod tests {
fn test_as_imm_buf_fail() { fn test_as_imm_buf_fail() {
let v = [(~0, @0), (~0, @0), (~0, @0), (~0, @0)]; let v = [(~0, @0), (~0, @0), (~0, @0), (~0, @0)];
do v.as_imm_buf |_buf, _i| { do v.as_imm_buf |_buf, _i| {
fail!() fail2!()
} }
} }
@ -3312,7 +3312,7 @@ mod tests {
fn test_as_mut_buf_fail() { fn test_as_mut_buf_fail() {
let mut v = [(~0, @0), (~0, @0), (~0, @0), (~0, @0)]; let mut v = [(~0, @0), (~0, @0), (~0, @0), (~0, @0)];
do v.as_mut_buf |_buf, _i| { do v.as_mut_buf |_buf, _i| {
fail!() fail2!()
} }
} }
@ -3702,11 +3702,11 @@ mod tests {
assert_eq!(cnt, 11); assert_eq!(cnt, 11);
let xs = ~[Foo, Foo, Foo]; let xs = ~[Foo, Foo, Foo];
assert_eq!(fmt!("%?", xs.slice(0, 2).to_owned()), assert_eq!(format!("{:?}", xs.slice(0, 2).to_owned()),
~"~[vec::tests::Foo, vec::tests::Foo]"); ~"~[vec::tests::Foo, vec::tests::Foo]");
let xs: [Foo, ..3] = [Foo, Foo, Foo]; let xs: [Foo, ..3] = [Foo, Foo, Foo];
assert_eq!(fmt!("%?", xs.slice(0, 2).to_owned()), assert_eq!(format!("{:?}", xs.slice(0, 2).to_owned()),
~"~[vec::tests::Foo, vec::tests::Foo]"); ~"~[vec::tests::Foo, vec::tests::Foo]");
cnt = 0; cnt = 0;
for f in xs.iter() { for f in xs.iter() {
@ -3749,7 +3749,7 @@ mod bench {
sum += *x; sum += *x;
} }
// sum == 11806, to stop dead code elimination. // sum == 11806, to stop dead code elimination.
if sum == 0 {fail!()} if sum == 0 {fail2!()}
} }
} }