let size = calculate_size::<T>(self.capacity);
deallocate(self as *mut TypedArenaChunk<T> as *mut u8, size,
mem::min_align_of::<TypedArenaChunk<T>>());
- if next.is_not_null() {
+ if !next.is_null() {
let capacity = (*next).capacity;
(*next).destroy(capacity);
}
pub use core::ops::{Drop, Fn, FnMut, FnOnce};
pub use core::option::Option;
pub use core::option::Option::{Some, None};
- pub use core::ptr::RawPtr;
+ pub use core::ptr::PtrExt;
pub use core::result::Result;
pub use core::result::Result::{Ok, Err};
// in core and collections (may differ).
pub use slice::{PartialEqSliceExt, OrdSliceExt};
pub use slice::{AsSlice, SliceExt};
- pub use str::{from_str, Str};
+ pub use str::{from_str, Str, StrExt};
// from other crates.
pub use alloc::boxed::Box;
use core::default::Default;
use core::iter::AdditiveIterator;
- use super::{eq_slice, from_utf8, is_utf8, is_utf16, raw};
- use super::truncate_utf16_at_nul;
+ use super::{from_utf8, is_utf8, raw};
use super::MaybeOwned::{Owned, Slice};
- use std::slice::{AsSlice, SliceExt};
- use string::{String, ToString};
- use vec::Vec;
- use slice::CloneSliceExt;
-
- use unicode::char::UnicodeChar;
+ use super::Utf8Error;
#[test]
fn test_le() {
use prelude::*;
use test::Bencher;
- use str::{StrExt, Utf8Error};
+ use str::Utf8Error;
use str;
use super::as_string;
mod tests {
use super::*;
use prelude::{spawn, Some, None, Option, FnOnce, ToString, CloneSliceExt};
- use prelude::{Clone, RawPtr, Iterator, SliceExt, StrExt};
+ use prelude::{Clone, PtrExt, Iterator, SliceExt, StrExt};
use ptr;
use thread::Thread;
use libc;
///
/// impl Viking {
/// /// Create a new Viking.
-/// pub fn new(name: &str, country: &str) -> Viking {
+/// fn new(name: &str, country: &str) -> Viking {
/// Viking { name: name.to_string(), country: country.to_string() }
/// }
/// }
#[test]
#[cfg(windows)]
fn env_map_keys_ci() {
+ use c_str::ToCStr;
use super::EnvKey;
let mut cmd = Command::new("");
cmd.env("path", "foo");
let ptr = ptr as *const u16;
let buf = slice::from_raw_buf(&ptr, len);
let opt_s = String::from_utf16(sys::os::truncate_utf16_at_nul(buf));
- opt_s.expect("CommandLineToArgvW returned invalid UTF-16")
+ opt_s.ok().expect("CommandLineToArgvW returned invalid UTF-16")
});
unsafe {
t!("_ZN4$UP$E", "Box");
t!("_ZN8$UP$testE", "Boxtest");
t!("_ZN8$UP$test4foobE", "Boxtest::foob");
- t!("_ZN8$x20test4foobE", " test::foob");
+ t!("_ZN10$u{20}test4foobE", " test::foob");
}
#[test]
fn demangle_many_dollars() {
- t!("_ZN12test$x20test4foobE", "test test::foob");
+ t!("_ZN14test$u{20}test4foobE", "test test::foob");
t!("_ZN12test$UP$test4foobE", "testBoxtest::foob");
}
#[test]
fn demangle_windows() {
t!("ZN4testE", "test");
- t!("ZN12test$x20test4foobE", "test test::foob");
+ t!("ZN14test$u{20}test4foobE", "test test::foob");
t!("ZN12test$UP$test4foobE", "testBoxtest::foob");
}
}
}
}
-static DUMMY: UnsafeCell<()> = UnsafeCell { value: () };
+struct Dummy(UnsafeCell<()>);
+unsafe impl Sync for Dummy {}
+static DUMMY: Dummy = Dummy(UnsafeCell { value: () });
impl StaticMutex {
/// Acquires this lock, see `Mutex::lock`
#[unstable = "may be merged with Mutex in the future"]
pub fn lock(&'static self) -> LockResult<MutexGuard<()>> {
unsafe { self.lock.lock() }
- MutexGuard::new(self, &DUMMY)
+ MutexGuard::new(self, &DUMMY.0)
}
/// Attempts to grab this lock, see `Mutex::try_lock`
#[unstable = "may be merged with Mutex in the future"]
pub fn try_lock(&'static self) -> TryLockResult<MutexGuard<()>> {
if unsafe { self.lock.try_lock() } {
- Ok(try!(MutexGuard::new(self, &DUMMY)))
+ Ok(try!(MutexGuard::new(self, &DUMMY.0)))
} else {
Err(TryLockError::WouldBlock)
}
}
}
-static DUMMY: UnsafeCell<()> = UnsafeCell { value: () };
+struct Dummy(UnsafeCell<()>);
+unsafe impl Sync for Dummy {}
+static DUMMY: Dummy = Dummy(UnsafeCell { value: () });
impl StaticRWLock {
/// Locks this rwlock with shared read access, blocking the current thread
#[unstable = "may be merged with RWLock in the future"]
pub fn read(&'static self) -> LockResult<RWLockReadGuard<'static, ()>> {
unsafe { self.lock.read() }
- RWLockReadGuard::new(self, &DUMMY)
+ RWLockReadGuard::new(self, &DUMMY.0)
}
/// Attempt to acquire this lock with shared read access.
pub fn try_read(&'static self)
-> TryLockResult<RWLockReadGuard<'static, ()>> {
if unsafe { self.lock.try_read() } {
- Ok(try!(RWLockReadGuard::new(self, &DUMMY)))
+ Ok(try!(RWLockReadGuard::new(self, &DUMMY.0)))
} else {
Err(TryLockError::WouldBlock)
}
#[unstable = "may be merged with RWLock in the future"]
pub fn write(&'static self) -> LockResult<RWLockWriteGuard<'static, ()>> {
unsafe { self.lock.write() }
- RWLockWriteGuard::new(self, &DUMMY)
+ RWLockWriteGuard::new(self, &DUMMY.0)
}
/// Attempt to lock this rwlock with exclusive write access.
pub fn try_write(&'static self)
-> TryLockResult<RWLockWriteGuard<'static, ()>> {
if unsafe { self.lock.try_write() } {
- Ok(try!(RWLockWriteGuard::new(self, &DUMMY)))
+ Ok(try!(RWLockWriteGuard::new(self, &DUMMY.0)))
} else {
Err(TryLockError::WouldBlock)
}
fn lock_nonblocking<'a>(&'a self) -> Guard<'a> {
let ret = Guard {
fd: self.fd(),
- guard: self.inner.lock.lock(),
+ guard: self.inner.lock.lock().unwrap(),
};
assert!(set_nonblocking(self.fd(), true).is_ok());
ret
fn lock_nonblocking<'a>(&'a self) -> Guard<'a> {
let ret = Guard {
fd: self.fd(),
- guard: self.inner.lock.lock(),
+ guard: self.inner.lock.lock().unwrap(),
};
assert!(set_nonblocking(self.fd(), true).is_ok());
ret
fn lock_nonblocking<'a>(&'a self) -> Guard<'a> {
let ret = Guard {
fd: self.fd(),
- guard: unsafe { self.inner.lock.lock() },
+ guard: unsafe { self.inner.lock.lock().unwrap() },
};
assert!(set_nonblocking(self.fd(), true).is_ok());
ret
pub mod compat {
use intrinsics::{atomic_store_relaxed, transmute};
- use iter::IteratorExt;
use libc::types::os::arch::extra::{LPCWSTR, HMODULE, LPCSTR, LPVOID};
use prelude::*;
{
let filename = os::truncate_utf16_at_nul(&wfd.cFileName);
match String::from_utf16(filename) {
- Some(filename) => paths.push(Path::new(filename)),
- None => {
+ Ok(filename) => paths.push(Path::new(filename)),
+ Err(..) => {
assert!(libc::FindClose(find_handle) != 0);
return Err(IoError {
kind: io::InvalidInput,
let msg = String::from_utf16(truncate_utf16_at_nul(&buf));
match msg {
- Some(msg) => format!("OS Error {}: {}", errnum, msg),
- None => format!("OS Error {} (FormatMessageW() returned invalid UTF-16)", errnum),
+ Ok(msg) => format!("OS Error {}: {}", errnum, msg),
+ Err(..) => format!("OS Error {} (FormatMessageW() returned \
+ invalid UTF-16)", errnum),
}
}
}
// We want to explicitly catch the case when the
// closure returned invalid UTF-16, rather than
// set `res` to None and continue.
- let s = String::from_utf16(sub)
+ let s = String::from_utf16(sub).ok()
.expect("fill_utf16_buf_and_decode: closure created invalid UTF-16");
res = Some(s)
}
}
match String::from_utf16(truncate_utf16_at_nul(&buf)) {
- Some(ref cwd) => Ok(Path::new(cwd)),
- None => Err(IoError {
+ Ok(ref cwd) => Ok(Path::new(cwd)),
+ Err(..) => Err(IoError {
kind: OtherIoError,
desc: "GetCurrentDirectoryW returned invalid UTF-16",
detail: None,
};
utf16.truncate(num as uint);
let utf8 = match String::from_utf16(utf16.as_slice()) {
- Some(utf8) => utf8.into_bytes(),
- None => return Err(invalid_encoding()),
+ Ok(utf8) => utf8.into_bytes(),
+ Err(..) => return Err(invalid_encoding()),
};
self.utf8 = MemReader::new(utf8);
}
//~^ ERROR statics are not allowed to have custom pointers
//~| ERROR: the trait `core::kinds::Sync` is not implemented for the type
//~| ERROR: the trait `core::kinds::Sync` is not implemented for the type
-//~| ERROR: the trait `core::kinds::Sync` is not implemented for the type
fn main() { }
f(x);
//~^ ERROR `core::kinds::Sync` is not implemented
//~^^ ERROR `core::kinds::Sync` is not implemented
- //~^^^ ERROR `core::kinds::Sync` is not implemented
}
projects / rust.git / commitdiff