mirror of
https://github.com/rust-lang/rust.git
synced 2025-05-14 02:49:40 +00:00
b1c9ce9c6f
This commit is the final step in the libstd facade, #13851. The purpose of this commit is to move libsync underneath the standard library, behind the facade. This will allow core primitives like channels, queues, and atomics to all live in the same location. There were a few notable changes and a few breaking changes as part of this movement: * The `Vec` and `String` types are reexported at the top level of libcollections * The `unreachable!()` macro was copied to libcore * The `std::rt::thread` module was moved to librustrt, but it is still reexported at the same location. * The `std::comm` module was moved to libsync * The `sync::comm` module was moved under `sync::comm`, and renamed to `duplex`. It is now a private module with types/functions being reexported under `sync::comm`. This is a breaking change for any existing users of duplex streams. * All concurrent queues/deques were moved directly under libsync. They are also all marked with #![experimental] for now if they are public. * The `task_pool` and `future` modules no longer live in libsync, but rather live under `std::sync`. They will forever live at this location, but they may move to libsync if the `std::task` module moves as well. [breaking-change]
137 lines
3.8 KiB
Rust
137 lines
3.8 KiB
Rust
// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
|
|
// file at the top-level directory of this distribution and at
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
|
|
#![macro_escape]
|
|
|
|
/// Entry point of failure, for details, see std::macros
|
|
#[macro_export]
|
|
macro_rules! fail(
|
|
() => (
|
|
fail!("{}", "explicit failure")
|
|
);
|
|
($msg:expr) => (
|
|
fail!("{}", $msg)
|
|
);
|
|
($fmt:expr, $($arg:tt)*) => ({
|
|
// a closure can't have return type !, so we need a full
|
|
// function to pass to format_args!, *and* we need the
|
|
// file and line numbers right here; so an inner bare fn
|
|
// is our only choice.
|
|
//
|
|
// LLVM doesn't tend to inline this, presumably because begin_unwind_fmt
|
|
// is #[cold] and #[inline(never)] and because this is flagged as cold
|
|
// as returning !. We really do want this to be inlined, however,
|
|
// because it's just a tiny wrapper. Small wins (156K to 149K in size)
|
|
// were seen when forcing this to be inlined, and that number just goes
|
|
// up with the number of calls to fail!()
|
|
#[inline(always)]
|
|
fn run_fmt(fmt: &::std::fmt::Arguments) -> ! {
|
|
::core::failure::begin_unwind(fmt, file!(), line!())
|
|
}
|
|
format_args!(run_fmt, $fmt, $($arg)*)
|
|
});
|
|
)
|
|
|
|
/// Runtime assertion, for details see std::macros
|
|
#[macro_export]
|
|
macro_rules! assert(
|
|
($cond:expr) => (
|
|
if !$cond {
|
|
fail!(concat!("assertion failed: ", stringify!($cond)))
|
|
}
|
|
);
|
|
($cond:expr, $($arg:tt)*) => (
|
|
if !$cond {
|
|
fail!($($arg)*)
|
|
}
|
|
);
|
|
)
|
|
|
|
/// Runtime assertion, only without `--cfg ndebug`
|
|
#[macro_export]
|
|
macro_rules! debug_assert(
|
|
($(a:tt)*) => ({
|
|
if cfg!(not(ndebug)) {
|
|
assert!($($a)*);
|
|
}
|
|
})
|
|
)
|
|
|
|
/// Runtime assertion for equality, for details see std::macros
|
|
#[macro_export]
|
|
macro_rules! assert_eq(
|
|
($cond1:expr, $cond2:expr) => ({
|
|
let c1 = $cond1;
|
|
let c2 = $cond2;
|
|
if c1 != c2 || c2 != c1 {
|
|
fail!("expressions not equal, left: {}, right: {}", c1, c2);
|
|
}
|
|
})
|
|
)
|
|
|
|
/// Runtime assertion for equality, only without `--cfg ndebug`
|
|
#[macro_export]
|
|
macro_rules! debug_assert_eq(
|
|
($($a:tt)*) => ({
|
|
if cfg!(not(ndebug)) {
|
|
assert_eq!($($a)*);
|
|
}
|
|
})
|
|
)
|
|
|
|
/// Runtime assertion, disableable at compile time
|
|
#[macro_export]
|
|
macro_rules! debug_assert(
|
|
($($arg:tt)*) => (if cfg!(not(ndebug)) { assert!($($arg)*); })
|
|
)
|
|
|
|
/// Short circuiting evaluation on Err
|
|
#[macro_export]
|
|
macro_rules! try(
|
|
($e:expr) => (match $e { Ok(e) => e, Err(e) => return Err(e) })
|
|
)
|
|
|
|
/// Writing a formatted string into a writer
|
|
#[macro_export]
|
|
macro_rules! write(
|
|
($dst:expr, $($arg:tt)*) => (format_args_method!($dst, write_fmt, $($arg)*))
|
|
)
|
|
|
|
/// Writing a formatted string plus a newline into a writer
|
|
#[macro_export]
|
|
macro_rules! writeln(
|
|
($dst:expr, $fmt:expr $($arg:tt)*) => (
|
|
write!($dst, concat!($fmt, "\n") $($arg)*)
|
|
)
|
|
)
|
|
|
|
#[cfg(test)]
|
|
macro_rules! vec( ($($e:expr),*) => ({
|
|
let mut _v = ::std::vec::Vec::new();
|
|
$(_v.push($e);)*
|
|
_v
|
|
}) )
|
|
|
|
#[cfg(test)]
|
|
macro_rules! format( ($($arg:tt)*) => (format_args!(::fmt::format, $($arg)*)) )
|
|
|
|
/// Write some formatted data into a stream.
|
|
///
|
|
/// Identical to the macro in `std::macros`
|
|
#[macro_export]
|
|
macro_rules! write(
|
|
($dst:expr, $($arg:tt)*) => ({
|
|
format_args_method!($dst, write_fmt, $($arg)*)
|
|
})
|
|
)
|
|
|
|
#[macro_export]
|
|
macro_rules! unreachable( () => (fail!("unreachable code")) )
|