From 151b7ed52d76a11a39888931056f1bcc9c45807a Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Fri, 22 Nov 2013 14:15:32 -0800 Subject: [PATCH] libstd: Fix Win32 and other bustage. --- src/libstd/condition.rs | 10 +++++----- src/libstd/gc.rs | 8 ++++---- src/libstd/io/native/file.rs | 4 +++- src/libstd/io/native/process.rs | 2 +- src/libstd/num/mod.rs | 2 +- src/libstd/num/uint.rs | 4 ++-- src/libstd/ops.rs | 4 ++-- src/libstd/rand/os.rs | 4 ++-- src/libstd/rt/args.rs | 10 +++++----- src/libstd/vec.rs | 32 ++++++++++++++++---------------- 10 files changed, 41 insertions(+), 39 deletions(-) diff --git a/src/libstd/condition.rs b/src/libstd/condition.rs index 80ff104e830..e34e94ac10c 100644 --- a/src/libstd/condition.rs +++ b/src/libstd/condition.rs @@ -30,14 +30,14 @@ parameters are used for, an example usage of this condition would be: ```rust -do my_error::cond.trap(|raised_int| { +my_error::cond.trap(|raised_int| { // the condition `my_error` was raised on, and the value it raised is stored // in `raised_int`. This closure must return a `~str` type (as specified in // the declaration of the condition if raised_int == 3 { ~"three" } else { ~"oh well" } -}).inside { +}).inside(|| { // The condition handler above is installed for the duration of this block. // That handler will override any previous handler, but the previous handler @@ -50,7 +50,7 @@ println(my_error::cond.raise(3)); // prints "three" println(my_error::cond.raise(4)); // prints "oh well" -} +}) ``` Condition handling is useful in cases where propagating errors is either to @@ -176,9 +176,9 @@ impl<'self, T, U> Trap<'self, T, U> { /// ```rust /// condition! { my_error: int -> int; } /// - /// let result = do my_error::cond.trap(|error| error + 3).inside { + /// let result = my_error::cond.trap(|error| error + 3).inside(|| { /// my_error::cond.raise(4) - /// }; + /// }); /// assert_eq!(result, 7); /// ``` pub fn inside(&self, inner: 'self || -> V) -> V { diff --git a/src/libstd/gc.rs b/src/libstd/gc.rs index 5fe11d310d4..d3bec8ca6c9 100644 --- a/src/libstd/gc.rs +++ b/src/libstd/gc.rs @@ -61,9 +61,9 @@ mod tests { fn test_clone() { let x = Gc::new(RefCell::new(5)); let y = x.clone(); - do x.borrow().with_mut |inner| { + x.borrow().with_mut(|inner| { *inner = 20; - } + }); assert_eq!(y.borrow().with(|x| *x), 20); } @@ -71,9 +71,9 @@ fn test_clone() { fn test_deep_clone() { let x = Gc::new(RefCell::new(5)); let y = x.deep_clone(); - do x.borrow().with_mut |inner| { + x.borrow().with_mut(|inner| { *inner = 20; - } + }); assert_eq!(y.borrow().with(|x| *x), 5); } diff --git a/src/libstd/io/native/file.rs b/src/libstd/io/native/file.rs index c21326262e4..9dd6daf66e9 100644 --- a/src/libstd/io/native/file.rs +++ b/src/libstd/io/native/file.rs @@ -576,7 +576,9 @@ pub fn unlink(p: &CString) -> IoResult<()> { #[cfg(windows)] fn os_unlink(p: &CString) -> IoResult<()> { super::mkerr_winbool(unsafe { - as_utf16_p(p.as_str().unwrap(), |buf| libc::DeleteFileW(buf)); + as_utf16_p(p.as_str().unwrap(), |buf| { + libc::DeleteFileW(buf) + }) }) } diff --git a/src/libstd/io/native/process.rs b/src/libstd/io/native/process.rs index ef531c8803c..038b6ec0ff2 100644 --- a/src/libstd/io/native/process.rs +++ b/src/libstd/io/native/process.rs @@ -499,7 +499,7 @@ fn with_envp(env: Option<~[(~str, ~str)]>, cb: |*mut c_void| -> T) -> T { blk.push(0); - blk.as_imm_buf(|p, _len| unsafe { cb(cast::transmute(p)) }); + blk.as_imm_buf(|p, _len| unsafe { cb(cast::transmute(p)) }) } _ => cb(ptr::mut_null()) } diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs index aeda3fa1cd1..456011d5172 100644 --- a/src/libstd/num/mod.rs +++ b/src/libstd/num/mod.rs @@ -104,7 +104,7 @@ pub trait Unsigned: Num {} /// use num::Times; /// let ten = 10 as uint; /// let mut accum = 0; -/// do ten.times { accum += 1; } +/// ten.times(|| { accum += 1; }) /// ``` /// pub trait Times { diff --git a/src/libstd/num/uint.rs b/src/libstd/num/uint.rs index cf7047bd068..cf28083bb09 100644 --- a/src/libstd/num/uint.rs +++ b/src/libstd/num/uint.rs @@ -77,13 +77,13 @@ impl num::Times for uint { #[inline] /// /// A convenience form for basic repetition. Given a uint `x`, - /// `do x.times { ... }` executes the given block x times. + /// `x.times(|| { ... })` executes the given block x times. /// /// Equivalent to `for uint::range(0, x) |_| { ... }`. /// /// Not defined on all integer types to permit unambiguous /// use with integer literals of inferred integer-type as - /// the self-value (eg. `do 100.times { ... }`). + /// the self-value (eg. `100.times(|| { ... })`). /// fn times(&self, it: ||) { let mut i = *self; diff --git a/src/libstd/ops.rs b/src/libstd/ops.rs index 62685b5dcd3..cdc63608122 100644 --- a/src/libstd/ops.rs +++ b/src/libstd/ops.rs @@ -481,8 +481,8 @@ fn drop(&mut self) { #[bench] fn alloc_obj_with_dtor(bh: &mut BenchHarness) { - do bh.iter { + bh.iter(|| { HasDtor { x : 10 }; - } + }) } } diff --git a/src/libstd/rand/os.rs b/src/libstd/rand/os.rs index cd90af113ec..5558b8b3348 100644 --- a/src/libstd/rand/os.rs +++ b/src/libstd/rand/os.rs @@ -111,9 +111,9 @@ fn rust_win32_rand_gen(hProv: HCRYPTPROV, dwLen: DWORD, pbBuffer: *mut BYTE); } - do v.as_mut_buf |ptr, len| { + v.as_mut_buf(|ptr, len| { unsafe {rust_win32_rand_gen(self.hcryptprov, len as DWORD, ptr)} - } + }) } } diff --git a/src/libstd/rt/args.rs b/src/libstd/rt/args.rs index a173be64356..82b98fa7f9a 100644 --- a/src/libstd/rt/args.rs +++ b/src/libstd/rt/args.rs @@ -109,16 +109,16 @@ pub fn clone() -> Option<~[~str]> { fn with_lock(f: || -> T) -> T { static mut lock: Mutex = MUTEX_INIT; - do (|| { + (|| { unsafe { lock.lock(); f() } - }).finally { + }).finally(|| { unsafe { lock.unlock(); } - } + }) } fn get_global_ptr() -> *mut Option<~~[~str]> { @@ -127,9 +127,9 @@ fn get_global_ptr() -> *mut Option<~~[~str]> { // Copied from `os`. unsafe fn load_argc_and_argv(argc: int, argv: **u8) -> ~[~str] { - do vec::from_fn(argc as uint) |i| { + vec::from_fn(argc as uint, |i| { str::raw::from_c_str(*(argv as **libc::c_char).offset(i as int)) - } + }) } #[cfg(test)] diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs index 9dc4f6ae377..22cf57979a1 100644 --- a/src/libstd/vec.rs +++ b/src/libstd/vec.rs @@ -3894,25 +3894,25 @@ fn connect(bh: &mut BenchHarness) { #[bench] fn push(bh: &mut BenchHarness) { let mut vec: ~[uint] = ~[0u]; - do bh.iter() { + bh.iter(|| { vec.push(0); - } + }) } #[bench] fn starts_with_same_vector(bh: &mut BenchHarness) { let vec: ~[uint] = vec::from_fn(100, |i| i); - do bh.iter() { + bh.iter(|| { vec.starts_with(vec); - } + }) } #[bench] fn starts_with_single_element(bh: &mut BenchHarness) { let vec: ~[uint] = ~[0u]; - do bh.iter() { + bh.iter(|| { vec.starts_with(vec); - } + }) } #[bench] @@ -3920,25 +3920,25 @@ fn starts_with_diff_one_element_at_end(bh: &mut BenchHarness) { let vec: ~[uint] = vec::from_fn(100, |i| i); let mut match_vec: ~[uint] = vec::from_fn(99, |i| i); match_vec.push(0); - do bh.iter() { + bh.iter(|| { vec.starts_with(match_vec); - } + }) } #[bench] fn ends_with_same_vector(bh: &mut BenchHarness) { let vec: ~[uint] = vec::from_fn(100, |i| i); - do bh.iter() { + bh.iter(|| { vec.ends_with(vec); - } + }) } #[bench] fn ends_with_single_element(bh: &mut BenchHarness) { let vec: ~[uint] = ~[0u]; - do bh.iter() { + bh.iter(|| { vec.ends_with(vec); - } + }) } #[bench] @@ -3946,16 +3946,16 @@ fn ends_with_diff_one_element_at_beginning(bh: &mut BenchHarness) { let vec: ~[uint] = vec::from_fn(100, |i| i); let mut match_vec: ~[uint] = vec::from_fn(100, |i| i); match_vec[0] = 200; - do bh.iter() { + bh.iter(|| { vec.starts_with(match_vec); - } + }) } #[bench] fn contains_last_element(bh: &mut BenchHarness) { let vec: ~[uint] = vec::from_fn(100, |i| i); - do bh.iter() { + bh.iter(|| { vec.contains(&99u); - } + }) } } -- GitLab