}
impl<T: fmt::Show> ToString for T {
- // NOTE(stage0): Remove cfg after a snapshot
- #[cfg(not(stage0))]
fn to_string(&self) -> String {
let mut buf = Vec::<u8>::new();
let _ = fmt::write(&mut buf, format_args!("{}", *self));
String::from_utf8(buf).unwrap()
}
- // NOTE(stage0): Remove method after a snapshot
- #[cfg(stage0)]
- fn to_string(&self) -> String {
- let mut buf = Vec::<u8>::new();
- let _ = format_args!(|args| fmt::write(&mut buf, args), "{}", self);
- String::from_utf8(buf).unwrap()
- }
}
impl IntoCow<'static, String, str> for String {
let mut filler = Filler { buf: &mut buf, end: &mut end };
match sign {
- // NOTE(stage0): Remove cfg after a snapshot
- #[cfg(not(stage0))]
SignNeg => {
let _ = fmt::write(&mut filler, format_args!("{:-}", exp));
}
- // NOTE(stage0): Remove match arm after a snapshot
- #[cfg(stage0)]
- SignNeg => {
- let _ = format_args!(|args| {
- fmt::write(&mut filler, args)
- }, "{:-}", exp);
- }
}
}
}
/// This function will return an instance of `FormatError` on error.
fn write(&mut self, bytes: &[u8]) -> Result;
- // NOTE(stage0): Remove cfg after a snapshot
- #[cfg(not(stage0))]
/// Glue for usage of the `write!` macro with implementers of this trait.
///
/// This method should generally not be invoked manually, but rather through
/// the `write!` macro itself.
fn write_fmt(&mut self, args: Arguments) -> Result { write(self, args) }
-
- // NOTE(stage0): Remove method after a snapshot
- #[cfg(stage0)]
- /// Glue for usage of the `write!` macro with implementers of this trait.
- ///
- /// This method should generally not be invoked manually, but rather through
- /// the `write!` macro itself.
- fn write_fmt(&mut self, args: &Arguments) -> Result { write(self, args) }
}
/// A struct to represent both where to emit formatting strings to and how they
}
impl<'a> Show for Arguments<'a> {
- // NOTE(stage0): Remove cfg after a snapshot
- #[cfg(not(stage0))]
fn fmt(&self, fmt: &mut Formatter) -> Result {
write(fmt.buf, *self)
}
-
- // NOTE(stage0): Remove method after a snapshot
- #[cfg(stage0)]
- fn fmt(&self, fmt: &mut Formatter) -> Result {
- write(fmt.buf, self)
- }
}
/// When a format is not otherwise specified, types are formatted by ascribing
}
};
-// NOTE(stage0): Remove cfg after a snapshot
-#[cfg(not(stage0))]
/// The `write` function takes an output stream, a precompiled format string,
/// and a list of arguments. The arguments will be formatted according to the
/// specified format string into the output stream provided.
Ok(())
}
-// NOTE(stage0): Remove function after a snapshot
-#[cfg(stage0)]
-/// The `write` function takes an output stream, a precompiled format string,
-/// and a list of arguments. The arguments will be formatted according to the
-/// specified format string into the output stream provided.
-///
-/// # Arguments
-///
-/// * output - the buffer to write output to
-/// * args - the precompiled arguments generated by `format_args!`
-#[experimental = "libcore and I/O have yet to be reconciled, and this is an \
- implementation detail which should not otherwise be exported"]
-pub fn write(output: &mut FormatWriter, args: &Arguments) -> Result {
- let mut formatter = Formatter {
- flags: 0,
- width: None,
- precision: None,
- buf: output,
- align: rt::AlignUnknown,
- fill: ' ',
- args: args.args,
- curarg: args.args.iter(),
- };
-
- let mut pieces = args.pieces.iter();
-
- match args.fmt {
- None => {
- // We can use default formatting parameters for all arguments.
- for _ in range(0, args.args.len()) {
- try!(formatter.buf.write(pieces.next().unwrap().as_bytes()));
- try!(formatter.run(&DEFAULT_ARGUMENT));
- }
- }
- Some(fmt) => {
- // Every spec has a corresponding argument that is preceded by
- // a string piece.
- for (arg, piece) in fmt.iter().zip(pieces.by_ref()) {
- try!(formatter.buf.write(piece.as_bytes()));
- try!(formatter.run(arg));
- }
- }
- }
-
- // There can be only one trailing string piece left.
- match pieces.next() {
- Some(piece) => {
- try!(formatter.buf.write(piece.as_bytes()));
- }
- None => {}
- }
-
- Ok(())
-}
-
impl<'a> Formatter<'a> {
// First up is the collection of functions used to execute a format string
self.buf.write(data)
}
- // NOTE(stage0): Remove cfg after a snapshot
- #[cfg(not(stage0))]
/// Writes some formatted information into this instance
#[unstable = "reconciling core and I/O may alter this definition"]
pub fn write_fmt(&mut self, fmt: Arguments) -> Result {
write(self.buf, fmt)
}
- // NOTE(stage0): Remove method after a snapshot
- #[cfg(stage0)]
- /// Writes some formatted information into this instance
- #[unstable = "reconciling core and I/O may alter this definition"]
- pub fn write_fmt(&mut self, fmt: &Arguments) -> Result {
- write(self.buf, fmt)
- }
-
/// Flags for formatting (packed version of rt::Flag)
#[experimental = "return type may change and method was just created"]
pub fn flags(&self) -> uint { self.flags }
#![macro_escape]
-// NOTE(stage0): Remove cfg after a snapshot
-#[cfg(not(stage0))]
/// Entry point of task panic, for details, see std::macros
#[macro_export]
macro_rules! panic {
});
}
-// NOTE(stage0): Remove macro after a snapshot
-#[cfg(stage0)]
-/// Entry point of task panic, for details, see std::macros
-#[macro_export]
-macro_rules! panic {
- () => (
- panic!("{}", "explicit panic")
- );
- ($msg:expr) => ({
- static _MSG_FILE_LINE: (&'static str, &'static str, uint) = ($msg, file!(), line!());
- ::core::panicking::panic(&_MSG_FILE_LINE)
- });
- ($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 panic!()
- //
- // The leading _'s are to avoid dead code warnings if this is
- // used inside a dead function. Just `#[allow(dead_code)]` is
- // insufficient, since the user may have
- // `#[forbid(dead_code)]` and which cannot be overridden.
- #[inline(always)]
- fn _run_fmt(fmt: &::std::fmt::Arguments) -> ! {
- static _FILE_LINE: (&'static str, uint) = (file!(), line!());
- ::core::panicking::panic_fmt(fmt, &_FILE_LINE)
- }
- format_args!(_run_fmt, $fmt, $($arg)*)
- });
-}
-
/// Runtime assertion, for details see std::macros
#[macro_export]
macro_rules! assert {
($e:expr) => (match $e { Ok(e) => e, Err(e) => return Err(e) })
}
-// NOTE(stage0): Remove cfg after a snapshot
-#[cfg(not(stage0))]
/// Writing a formatted string into a writer
#[macro_export]
macro_rules! write {
($dst:expr, $($arg:tt)*) => ((&mut *$dst).write_fmt(format_args!($($arg)*)))
}
-// NOTE(stage0): Remove macro after a snapshot
-#[cfg(stage0)]
-/// Writing a formatted string into a writer
-#[macro_export]
-macro_rules! write {
- ($dst:expr, $($arg:tt)*) => ({
- let dst = &mut *$dst;
- format_args!(|args| { dst.write_fmt(args) }, $($arg)*)
- })
-}
-
/// Writing a formatted string plus a newline into a writer
#[macro_export]
macro_rules! writeln {
rem_float_impl! { f32, fmodf }
rem_float_impl! { f64, fmod }
-/// The `Neg` trait is used to specify the functionality of unary `-`.
-///
-/// # Example
-///
-/// A trivial implementation of `Neg`. When `-Foo` happens, it ends up calling
-/// `neg`, and therefore, `main` prints `Negating!`.
-///
-/// ```
-/// #[deriving(Copy)]
-/// struct Foo;
-///
-/// impl Neg<Foo> for Foo {
-/// fn neg(&self) -> Foo {
-/// println!("Negating!");
-/// *self
-/// }
-/// }
-///
-/// fn main() {
-/// -Foo;
-/// }
-/// ```
-// NOTE(stage0): Remove trait after a snapshot
-#[cfg(stage0)]
-#[lang="neg"]
-pub trait Neg<Result> for Sized? {
- /// The method for the unary `-` operator
- fn neg(&self) -> Result;
-}
-
-// NOTE(stage0): Remove macro after a snapshot
-#[cfg(stage0)]
-macro_rules! neg_impl {
- ($($t:ty)*) => ($(
- impl Neg<$t> for $t {
- #[inline]
- fn neg(&self) -> $t { -*self }
- }
- )*)
-}
-
-// NOTE(stage0): Remove macro after a snapshot
-#[cfg(stage0)]
-macro_rules! neg_uint_impl {
- ($t:ty, $t_signed:ty) => {
- impl Neg<$t> for $t {
- #[inline]
- fn neg(&self) -> $t { -(*self as $t_signed) as $t }
- }
- }
-}
-
/// The `Neg` trait is used to specify the functionality of unary `-`.
///
/// # Example
/// -Foo;
/// }
/// ```
-#[cfg(not(stage0))] // NOTE(stage0): Remove cfg after a snapshot
#[lang="neg"]
pub trait Neg<Result> {
/// The method for the unary `-` operator
fn neg(self) -> Result;
}
-#[cfg(not(stage0))] // NOTE(stage0): Remove cfg after a snapshot
macro_rules! neg_impl {
($($t:ty)*) => ($(
impl Neg<$t> for $t {
)*)
}
-#[cfg(not(stage0))] // NOTE(stage0): Remove cfg after a snapshot
macro_rules! neg_uint_impl {
($t:ty, $t_signed:ty) => {
impl Neg<$t> for $t {
neg_uint_impl! { u64, i64 }
-/// The `Not` trait is used to specify the functionality of unary `!`.
-///
-/// # Example
-///
-/// A trivial implementation of `Not`. When `!Foo` happens, it ends up calling
-/// `not`, and therefore, `main` prints `Not-ing!`.
-///
-/// ```
-/// #[deriving(Copy)]
-/// struct Foo;
-///
-/// impl Not<Foo> for Foo {
-/// fn not(&self) -> Foo {
-/// println!("Not-ing!");
-/// *self
-/// }
-/// }
-///
-/// fn main() {
-/// !Foo;
-/// }
-/// ```
-// NOTE(stage0): Remove macro after a snapshot
-#[cfg(stage0)]
-#[lang="not"]
-pub trait Not<Result> for Sized? {
- /// The method for the unary `!` operator
- fn not(&self) -> Result;
-}
-
-
-// NOTE(stage0): Remove macro after a snapshot
-#[cfg(stage0)]
-macro_rules! not_impl {
- ($($t:ty)*) => ($(
- impl Not<$t> for $t {
- #[inline]
- fn not(&self) -> $t { !*self }
- }
- )*)
-}
-
/// The `Not` trait is used to specify the functionality of unary `!`.
///
/// # Example
/// !Foo;
/// }
/// ```
-#[cfg(not(stage0))] // NOTE(stage0): Remove cfg after a snapshot
#[lang="not"]
pub trait Not<Result> {
/// The method for the unary `!` operator
fn not(self) -> Result;
}
-#[cfg(not(stage0))] // NOTE(stage0): Remove cfg after a snapshot
macro_rules! not_impl {
($($t:ty)*) => ($(
impl Not<$t> for $t {
#![allow(dead_code, missing_docs)]
use fmt;
-// NOTE(stage0): Remove import after a snapshot
-#[cfg(stage0)] use intrinsics;
-// NOTE(stage0): Remove cfg after a snapshot
-#[cfg(not(stage0))]
#[cold] #[inline(never)] // this is the slow path, always
#[lang="panic"]
pub fn panic(expr_file_line: &(&'static str, &'static str, uint)) -> ! {
panic_fmt(format_args!("{}", expr), &(file, line))
}
-// NOTE(stage0): Remove function after a snapshot
-#[cfg(stage0)]
-#[cold] #[inline(never)] // this is the slow path, always
-#[lang="panic"]
-pub fn panic(expr_file_line: &(&'static str, &'static str, uint)) -> ! {
- let (expr, file, line) = *expr_file_line;
- let ref file_line = (file, line);
- format_args!(|args| -> () {
- panic_fmt(args, file_line);
- }, "{}", expr);
-
- unsafe { intrinsics::abort() }
-}
-
-// NOTE(stage0): Remove cfg after a snapshot
-#[cfg(not(stage0))]
#[cold] #[inline(never)]
#[lang="panic_bounds_check"]
fn panic_bounds_check(file_line: &(&'static str, uint),
len, index), file_line)
}
-// NOTE(stage0): Remove function after a snapshot
-#[cfg(stage0)]
-#[cold] #[inline(never)]
-#[lang="panic_bounds_check"]
-fn panic_bounds_check(file_line: &(&'static str, uint),
- index: uint, len: uint) -> ! {
- format_args!(|args| -> () {
- panic_fmt(args, file_line);
- }, "index out of bounds: the len is {} but the index is {}", len, index);
- unsafe { intrinsics::abort() }
-}
-
-// NOTE(stage0): Remove cfg after a snapshot
-#[cfg(not(stage0))]
#[cold] #[inline(never)]
pub fn panic_fmt(fmt: fmt::Arguments, file_line: &(&'static str, uint)) -> ! {
#[allow(improper_ctypes)]
let (file, line) = *file_line;
unsafe { panic_impl(fmt, file, line) }
}
-
-// NOTE(stage0): Remove function after a snapshot
-#[cfg(stage0)]
-#[cold] #[inline(never)]
-pub fn panic_fmt(fmt: &fmt::Arguments, file_line: &(&'static str, uint)) -> ! {
- #[allow(improper_ctypes)]
- extern {
- #[lang = "panic_fmt"]
- fn panic_impl(fmt: &fmt::Arguments, file: &'static str,
- line: uint) -> !;
-
- }
- let (file, line) = *file_line;
- unsafe { panic_impl(fmt, file, line) }
-}
}
}
-// NOTE(stage0): Remove cfg after a snapshot
-#[cfg(not(stage0))]
/// This function is called directly by the compiler when using the logging
/// macros. This function does not take into account whether the log level
/// specified is active or not, it will always log something if this method is
set_logger(logger);
}
-// NOTE(stage0): Remove function after a snapshot
-#[cfg(stage0)]
-/// This function is called directly by the compiler when using the logging
-/// macros. This function does not take into account whether the log level
-/// specified is active or not, it will always log something if this method is
-/// called.
-///
-/// It is not recommended to call this function directly, rather it should be
-/// invoked through the logging family of macros.
-#[doc(hidden)]
-pub fn log(level: u32, loc: &'static LogLocation, args: &fmt::Arguments) {
- // Test the literal string from args against the current filter, if there
- // is one.
- match unsafe { FILTER.as_ref() } {
- Some(filter) if !filter.is_match(args.to_string().as_slice()) => return,
- _ => {}
- }
-
- // Completely remove the local logger from TLS in case anyone attempts to
- // frob the slot while we're doing the logging. This will destroy any logger
- // set during logging.
- let mut logger = LOCAL_LOGGER.with(|s| {
- s.borrow_mut().take()
- }).unwrap_or_else(|| {
- box DefaultLogger { handle: io::stderr() } as Box<Logger + Send>
- });
- logger.log(&LogRecord {
- level: LogLevel(level),
- args: *args,
- file: loc.file,
- module_path: loc.module_path,
- line: loc.line,
- });
- set_logger(logger);
-}
-
/// Getter for the global log level. This is a function so that it can be called
/// safely
#[doc(hidden)]
#![macro_escape]
-// NOTE(stage0): Remove cfg after a snapshot
-#[cfg(not(stage0))]
/// The standard logging macro
///
/// This macro will generically log over a provided level (of type u32) with a
})
}
-// NOTE(stage0): Remove macro after a snapshot
-#[cfg(stage0)]
-/// The standard logging macro
-///
-/// This macro will generically log over a provided level (of type u32) with a
-/// format!-based argument list. See documentation in `std::fmt` for details on
-/// how to use the syntax.
-///
-/// # Example
-///
-/// ```
-/// #![feature(phase)]
-/// #[phase(plugin, link)] extern crate log;
-///
-/// fn main() {
-/// log!(log::WARN, "this is a warning {}", "message");
-/// log!(log::DEBUG, "this is a debug message");
-/// log!(6, "this is a custom logging level: {level}", level=6u);
-/// }
-/// ```
-///
-/// Assumes the binary is `main`:
-///
-/// ```{.bash}
-/// $ RUST_LOG=warn ./main
-/// WARN:main: this is a warning message
-/// ```
-///
-/// ```{.bash}
-/// $ RUST_LOG=debug ./main
-/// DEBUG:main: this is a debug message
-/// WARN:main: this is a warning message
-/// ```
-///
-/// ```{.bash}
-/// $ RUST_LOG=6 ./main
-/// DEBUG:main: this is a debug message
-/// WARN:main: this is a warning message
-/// 6:main: this is a custom logging level: 6
-/// ```
-#[macro_export]
-macro_rules! log {
- ($lvl:expr, $($arg:tt)+) => ({
- static LOC: ::log::LogLocation = ::log::LogLocation {
- line: line!(),
- file: file!(),
- module_path: module_path!(),
- };
- let lvl = $lvl;
- if log_enabled!(lvl) {
- format_args!(|args| { ::log::log(lvl, &LOC, args) }, $($arg)+)
- }
- })
-}
-
/// A convenience macro for logging at the error log level.
///
/// # Example
}
}
- // NOTE(stage0): Remove impl after a snapshot
- #[cfg(stage0)]
- impl Not<$BitFlags> for $BitFlags {
- /// Returns the complement of this set of flags.
- #[inline]
- fn not(&self) -> $BitFlags {
- $BitFlags { bits: !self.bits } & $BitFlags::all()
- }
- }
-
- #[cfg(not(stage0))] // NOTE(stage0): Remove cfg after a snapshot
impl Not<$BitFlags> for $BitFlags {
/// Returns the complement of this set of flags.
#[inline]
#[doc(hidden)]
pub use core::fmt::{argument, argumentuint};
-// NOTE(stage0): Remove cfg after a snapshot
-#[cfg(not(stage0))]
/// The format function takes a precompiled format string and a list of
/// arguments, to return the resulting formatted string.
///
string::String::from_utf8(output).unwrap()
}
-// NOTE(stage0): Remove function after a snapshot
-#[cfg(stage0)]
-/// The format function takes a precompiled format string and a list of
-/// arguments, to return the resulting formatted string.
-///
-/// # Arguments
-///
-/// * args - a structure of arguments generated via the `format_args!` macro.
-///
-/// # Example
-///
-/// ```rust
-/// use std::fmt;
-///
-/// let s = format_args!(fmt::format, "Hello, {}!", "world");
-/// assert_eq!(s, "Hello, world!".to_string());
-/// ```
-#[experimental = "this is an implementation detail of format! and should not \
- be called directly"]
-pub fn format(args: &Arguments) -> string::String {
- let mut output = Vec::new();
- let _ = write!(&mut output as &mut Writer, "{}", args);
- string::String::from_utf8(output).unwrap()
-}
-
impl<'a> Writer for Formatter<'a> {
fn write(&mut self, b: &[u8]) -> io::IoResult<()> {
match (*self).write(b) {
/// decide whether their stream needs to be buffered or not.
fn flush(&mut self) -> IoResult<()> { Ok(()) }
- // NOTE(stage0): Remove cfg after a snapshot
- #[cfg(not(stage0))]
/// Writes a formatted string into this writer, returning any error
/// encountered.
///
}
- // NOTE(stage0): Remove method after a snapshot
- #[cfg(stage0)]
- /// Writes a formatted string into this writer, returning any error
- /// encountered.
- ///
- /// This method is primarily used to interface with the `format_args!`
- /// macro, but it is rare that this should explicitly be called. The
- /// `write!` macro should be favored to invoke this method instead.
- ///
- /// # Errors
- ///
- /// This function will return any I/O error reported while formatting.
- fn write_fmt(&mut self, fmt: &fmt::Arguments) -> IoResult<()> {
- // Create a shim which translates a Writer to a FormatWriter and saves
- // off I/O errors. instead of discarding them
- struct Adaptor<'a, T:'a> {
- inner: &'a mut T,
- error: IoResult<()>,
- }
-
- impl<'a, T: Writer> fmt::FormatWriter for Adaptor<'a, T> {
- fn write(&mut self, bytes: &[u8]) -> fmt::Result {
- match self.inner.write(bytes) {
- Ok(()) => Ok(()),
- Err(e) => {
- self.error = Err(e);
- Err(fmt::Error)
- }
- }
- }
- }
-
- let mut output = Adaptor { inner: self, error: Ok(()) };
- match fmt::write(&mut output, fmt) {
- Ok(()) => Ok(()),
- Err(..) => output.error
- }
- }
-
/// Write a rust string into this sink.
///
/// The bytes written will be the UTF-8 encoded version of the input string.
})
}
-// NOTE(stage0): Remove cfg after a snapshot
-#[cfg(not(stage0))]
/// Similar to `print`, but takes a `fmt::Arguments` structure to be compatible
/// with the `format_args!` macro.
pub fn print_args(fmt: fmt::Arguments) {
with_task_stdout(|io| write!(io, "{}", fmt))
}
-// NOTE(stage0): Remove function after a snapshot
-#[cfg(stage0)]
-/// Similar to `print`, but takes a `fmt::Arguments` structure to be compatible
-/// with the `format_args!` macro.
-pub fn print_args(fmt: &fmt::Arguments) {
- with_task_stdout(|io| write!(io, "{}", fmt))
-}
-
-// NOTE(stage0): Remove cfg after a snapshot
-#[cfg(not(stage0))]
/// Similar to `println`, but takes a `fmt::Arguments` structure to be
/// compatible with the `format_args!` macro.
pub fn println_args(fmt: fmt::Arguments) {
with_task_stdout(|io| writeln!(io, "{}", fmt))
}
-// NOTE(stage0): Remove function after a snapshot
-#[cfg(stage0)]
-/// Similar to `println`, but takes a `fmt::Arguments` structure to be
-/// compatible with the `format_args!` macro.
-pub fn println_args(fmt: &fmt::Arguments) {
- with_task_stdout(|io| writeln!(io, "{}", fmt))
-}
-
/// Representation of a reader of a standard input stream
pub struct StdReader {
inner: StdSource
#![experimental]
#![macro_escape]
-// NOTE(stage0): Remove cfg after a snapshot
-#[cfg(not(stage0))]
/// The entry point for panic of Rust tasks.
///
/// This macro is used to inject panic into a Rust task, causing the task to
});
}
-// NOTE(stage0): Remove macro after a snapshot
-#[cfg(stage0)]
-/// The entry point for panic of Rust tasks.
-///
-/// This macro is used to inject panic into a Rust task, causing the task to
-/// unwind and panic entirely. Each task's panic can be reaped as the
-/// `Box<Any>` type, and the single-argument form of the `panic!` macro will be
-/// the value which is transmitted.
-///
-/// The multi-argument form of this macro panics with a string and has the
-/// `format!` syntax for building a string.
-///
-/// # Example
-///
-/// ```should_fail
-/// # #![allow(unreachable_code)]
-/// panic!();
-/// panic!("this is a terrible mistake!");
-/// panic!(4i); // panic with the value of 4 to be collected elsewhere
-/// panic!("this is a {} {message}", "fancy", message = "message");
-/// ```
-#[macro_export]
-macro_rules! panic {
- () => ({
- panic!("explicit panic")
- });
- ($msg:expr) => ({
- // static requires less code at runtime, more constant data
- static _FILE_LINE: (&'static str, uint) = (file!(), line!());
- ::std::rt::begin_unwind($msg, &_FILE_LINE)
- });
- ($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 panic!()
- //
- // The leading _'s are to avoid dead code warnings if this is
- // used inside a dead function. Just `#[allow(dead_code)]` is
- // insufficient, since the user may have
- // `#[forbid(dead_code)]` and which cannot be overridden.
- #[inline(always)]
- fn _run_fmt(fmt: &::std::fmt::Arguments) -> ! {
- static _FILE_LINE: (&'static str, uint) = (file!(), line!());
- ::std::rt::begin_unwind_fmt(fmt, &_FILE_LINE)
- }
- format_args!(_run_fmt, $fmt, $($arg)*)
- });
-}
-
/// Ensure that a boolean expression is `true` at runtime.
///
/// This will invoke the `panic!` macro if the provided expression cannot be
() => (panic!("not yet implemented"))
}
-// NOTE(stage0): Remove cfg after a snapshot
-#[cfg(not(stage0))]
/// Use the syntax described in `std::fmt` to create a value of type `String`.
/// See `std::fmt` for more information.
///
($($arg:tt)*) => (::std::fmt::format(format_args!($($arg)*)))
}
-// NOTE(stage0): Remove macro after a snapshot
-#[cfg(stage0)]
-/// Use the syntax described in `std::fmt` to create a value of type `String`.
-/// See `std::fmt` for more information.
-///
-/// # Example
-///
-/// ```
-/// format!("test");
-/// format!("hello {}", "world!");
-/// format!("x = {}, y = {y}", 10i, y = 30i);
-/// ```
-#[macro_export]
-#[stable]
-macro_rules! format {
- ($($arg:tt)*) => (
- format_args!(::std::fmt::format, $($arg)*)
- )
-}
-
-// NOTE(stage0): Remove cfg after a snapshot
-#[cfg(not(stage0))]
/// Use the `format!` syntax to write data into a buffer of type `&mut Writer`.
/// See `std::fmt` for more information.
///
($dst:expr, $($arg:tt)*) => ((&mut *$dst).write_fmt(format_args!($($arg)*)))
}
-// NOTE(stage0): Remove macro after a snapshot
-#[cfg(stage0)]
-/// Use the `format!` syntax to write data into a buffer of type `&mut Writer`.
-/// See `std::fmt` for more information.
-///
-/// # Example
-///
-/// ```
-/// # #![allow(unused_must_use)]
-///
-/// let mut w = Vec::new();
-/// write!(&mut w, "test");
-/// write!(&mut w, "formatted {}", "arguments");
-/// ```
-#[macro_export]
-#[stable]
-macro_rules! write {
- ($dst:expr, $($arg:tt)*) => ({
- let dst = &mut *$dst;
- format_args!(|args| { dst.write_fmt(args) }, $($arg)*)
- })
-}
-
/// Equivalent to the `write!` macro, except that a newline is appended after
/// the message is written.
#[macro_export]
)
}
-// NOTE(stage0): Remove cfg after a snapshot
-#[cfg(not(stage0))]
/// Equivalent to the `println!` macro except that a newline is not printed at
/// the end of the message.
#[macro_export]
($($arg:tt)*) => (::std::io::stdio::print_args(format_args!($($arg)*)))
}
-// NOTE(stage0): Remove macro after a snapshot
-#[cfg(stage0)]
-/// Equivalent to the `println!` macro except that a newline is not printed at
-/// the end of the message.
-#[macro_export]
-#[stable]
-macro_rules! print {
- ($($arg:tt)*) => (format_args!(::std::io::stdio::print_args, $($arg)*))
-}
-
-// NOTE(stage0): Remove cfg after a snapshot
-#[cfg(not(stage0))]
/// Macro for printing to a task's stdout handle.
///
/// Each task can override its stdout handle via `std::io::stdio::set_stdout`.
($($arg:tt)*) => (::std::io::stdio::println_args(format_args!($($arg)*)))
}
-// NOTE(stage0): Remove macro after a snapshot
-#[cfg(stage0)]
-/// Macro for printing to a task's stdout handle.
-///
-/// Each task can override its stdout handle via `std::io::stdio::set_stdout`.
-/// The syntax of this macro is the same as that used for `format!`. For more
-/// information, see `std::fmt` and `std::io::stdio`.
-///
-/// # Example
-///
-/// ```
-/// println!("hello there!");
-/// println!("format {} arguments", "some");
-/// ```
-#[macro_export]
-#[stable]
-macro_rules! println {
- ($($arg:tt)*) => (format_args!(::std::io::stdio::println_args, $($arg)*))
-}
-
/// Helper macro for unwrapping `Result` values while returning early with an
/// error if the value of the expression is `Err`. For more information, see
/// `std::io`.
#![macro_escape]
-// NOTE(stage0): Remove cfg after a snapshot
-#[cfg(not(stage0))]
macro_rules! rterrln {
($fmt:expr $($arg:tt)*) => ( {
::rt::util::dumb_print(format_args!(concat!($fmt, "\n") $($arg)*))
} )
}
-// NOTE(stage0): Remove macro after a snapshot
-#[cfg(stage0)]
-macro_rules! rterrln {
- ($fmt:expr $($arg:tt)*) => ( {
- format_args!(::rt::util::dumb_print, concat!($fmt, "\n") $($arg)*)
- } )
-}
-
// Some basic logging. Enabled by passing `--cfg rtdebug` to the libstd build.
macro_rules! rtdebug {
($($arg:tt)*) => ( {
} )
}
-// NOTE(stage0): Remove cfg after a snapshot
-#[cfg(not(stage0))]
macro_rules! rtabort {
($($arg:tt)*) => (::rt::util::abort(format_args!($($arg)*)))
}
-
-// NOTE(stage0): Remove macro after a snapshot
-#[cfg(stage0)]
-macro_rules! rtabort {
- ($($arg:tt)*) => (format_args!(::rt::util::abort, $($arg)*))
-}
}
}
-// NOTE(stage0): Remove cfg after a snapshot
-#[cfg(not(stage0))]
#[cfg(not(test))]
/// Entry point of panic from the libcore crate.
#[lang = "panic_fmt"]
begin_unwind_fmt(msg, &(file, line))
}
-// NOTE(stage0): Remove function after a snapshot
-#[cfg(stage0)]
-#[cfg(not(test))]
-/// Entry point of panic from the libcore crate.
-#[lang = "panic_fmt"]
-pub extern fn rust_begin_unwind(msg: &fmt::Arguments,
- file: &'static str, line: uint) -> ! {
- begin_unwind_fmt(msg, &(file, line))
-}
-
-// NOTE(stage0): Remove cfg after a snapshot
-#[cfg(not(stage0))]
/// The entry point for unwinding with a formatted message.
///
/// This is designed to reduce the amount of code required at the call
begin_unwind_inner(msg, file_line)
}
-// NOTE(stage0): Remove function after a snapshot
-#[cfg(stage0)]
-/// The entry point for unwinding with a formatted message.
-///
-/// This is designed to reduce the amount of code required at the call
-/// site as much as possible (so that `panic!()` has as low an impact
-/// on (e.g.) the inlining of other functions as possible), by moving
-/// the actual formatting into this shared place.
-#[inline(never)] #[cold]
-pub fn begin_unwind_fmt(msg: &fmt::Arguments, file_line: &(&'static str, uint)) -> ! {
- use fmt::FormatWriter;
-
- // We do two allocations here, unfortunately. But (a) they're
- // required with the current scheme, and (b) we don't handle
- // panic + OOM properly anyway (see comment in begin_unwind
- // below).
-
- struct VecWriter<'a> { v: &'a mut Vec<u8> }
-
- impl<'a> fmt::FormatWriter for VecWriter<'a> {
- fn write(&mut self, buf: &[u8]) -> fmt::Result {
- self.v.push_all(buf);
- Ok(())
- }
- }
-
- let mut v = Vec::new();
- let _ = write!(&mut VecWriter { v: &mut v }, "{}", msg);
-
- let msg = box String::from_utf8_lossy(v.as_slice()).into_owned();
- begin_unwind_inner(msg, file_line)
-}
-
/// This is the entry point of unwinding for panic!() and assert!().
#[inline(never)] #[cold] // avoid code bloat at the call sites as much as possible
pub fn begin_unwind<M: Any + Send>(msg: M, file_line: &(&'static str, uint)) -> ! {
}
}
-// NOTE(stage0): Remove cfg after a snapshot
-#[cfg(not(stage0))]
pub fn dumb_print(args: fmt::Arguments) {
let _ = Stderr.write_fmt(args);
}
-// NOTE(stage0): Remove function after a snapshot
-#[cfg(stage0)]
-pub fn dumb_print(args: &fmt::Arguments) {
- let mut w = Stderr;
- let _ = write!(&mut w, "{}", args);
-}
-
-// NOTE(stage0): Remove wrappers after a snapshot
-#[cfg(not(stage0))] pub fn abort(args: fmt::Arguments) -> ! { abort_(&args) }
-#[cfg(stage0)] pub fn abort(args: &fmt::Arguments) -> ! { abort_(args) }
-
-// NOTE(stage0): Change to `pub fn abort(args: fmt::Arguments) -> !` after a snapshot
-fn abort_(args: &fmt::Arguments) -> ! {
+pub fn abort(args: fmt::Arguments) -> ! {
use fmt::FormatWriter;
struct BufWriter<'a> {
}
};
- #[cfg(all(stage0, not(any(target_os = "macos", target_os = "linux"))))]
- const INIT: ::std::thread_local::KeyInner<$t> = {
- unsafe extern fn __destroy(ptr: *mut u8) {
- ::std::thread_local::destroy_value::<$t>(ptr);
- }
-
- ::std::thread_local::KeyInner {
- inner: ::std::cell::UnsafeCell { value: $init },
- os: ::std::thread_local::OsStaticKey {
- inner: ::std::thread_local::OS_INIT_INNER,
- dtor: ::std::option::Option::Some(__destroy),
- },
- }
- };
-
- #[cfg(all(not(stage0), not(any(target_os = "macos", target_os = "linux"))))]
+ #[cfg(all(not(any(target_os = "macos", target_os = "linux"))))]
const INIT: ::std::thread_local::KeyInner<$t> = {
unsafe extern fn __destroy(ptr: *mut u8) {
::std::thread_local::destroy_value::<$t>(ptr);
// *should* be the case that this loop always terminates because we
// provide the guarantee that a TLS key cannot be set after it is
// flagged for destruction.
- #[cfg(not(stage0))]
static DTORS: os::StaticKey = os::StaticKey {
inner: os::INIT_INNER,
dtor: Some(run_dtors as unsafe extern "C" fn(*mut u8)),
};
- #[cfg(stage0)]
- static DTORS: os::StaticKey = os::StaticKey {
- inner: os::INIT_INNER,
- dtor: Some(run_dtors),
- };
type List = Vec<(*mut u8, unsafe extern fn(*mut u8))>;
if DTORS.get().is_null() {
let v: Box<List> = box Vec::new();
}
}
-// NOTE(stage0): Remove impl after a snapshot
-#[cfg(stage0)]
-impl Neg<Duration> for Duration {
- #[inline]
- fn neg(&self) -> Duration {
- if self.nanos == 0 {
- Duration { secs: -self.secs, nanos: 0 }
- } else {
- Duration { secs: -self.secs - 1, nanos: NANOS_PER_SEC - self.nanos }
- }
- }
-}
-
-#[cfg(not(stage0))] // NOTE(stage0): Remove cfg after a snapshot
impl Neg<Duration> for Duration {
#[inline]
fn neg(self) -> Duration {
#[cfg(test)] #[phase(plugin, link)] extern crate log;
-#[cfg(stage0)]
-extern crate serialize;
extern crate "serialize" as rustc_serialize;
extern crate libc;
+S 2014-12-30 023dfb0
+ freebsd-x86_64 41ecd0ac557c823831c46696c7d78dc250398f25
+ linux-i386 fe6b59bf70a397e18629cb82264f7c6a70df34d4
+ linux-x86_64 8ab3a223f65fbf6b0aa80fcf0564a6d0fb9122e8
+ macos-i386 d23edb1be58b8683782a473cdc249c58a959c165
+ macos-x86_64 ab87616fa5d427978db3acd2d705042133ca3c09
+ winnt-i386 f2c26ac1ccb9d9a00886da9b504190681de89a5f
+ winnt-x86_64 fa2c7636bb15583ae387554b561ab09babee281a
+
S 2014-12-20 8443b09
freebsd-x86_64 004f54dce86faeebc15abf92c8742634b53987e6
linux-i386 3daf531aed03f5769402f2fef852377e2838db98
projects / rust.git / commitdiff