ec7a50d20d
This commit is an implementation of [RFC 494][rfc] which removes the entire `std::c_vec` module and redesigns the `std::c_str` module as `std::ffi`. [rfc]: https://github.com/rust-lang/rfcs/blob/master/text/0494-c_str-and-c_vec-stability.md The interface of the new `CString` is outlined in the linked RFC, the primary changes being: * The `ToCStr` trait is gone, meaning the `with_c_str` and `to_c_str` methods are now gone. These two methods are replaced with a `CString::from_slice` method. * The `CString` type is now just a wrapper around `Vec<u8>` with a static guarantee that there is a trailing nul byte with no internal nul bytes. This means that `CString` now implements `Deref<Target = [c_char]>`, which is where it gains most of its methods from. A few helper methods are added to acquire a slice of `u8` instead of `c_char`, as well as including a slice with the trailing nul byte if necessary. * All usage of non-owned `CString` values is now done via two functions inside of `std::ffi`, called `c_str_to_bytes` and `c_str_to_bytes_with_nul`. These functions are now the one method used to convert a `*const c_char` to a Rust slice of `u8`. Many more details, including newly deprecated methods, can be found linked in the RFC. This is a: [breaking-change] Closes #20444
280 lines
8.5 KiB
Rust
280 lines
8.5 KiB
Rust
// Copyright 2012-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.
|
|
|
|
//! # The Rust Standard Library
|
|
//!
|
|
//! The Rust Standard Library provides the essential runtime
|
|
//! functionality for building portable Rust software.
|
|
//! It is linked to all Rust crates by default.
|
|
//!
|
|
//! ## Intrinsic types and operations
|
|
//!
|
|
//! The [`ptr`](ptr/index.html) and [`mem`](mem/index.html)
|
|
//! modules deal with unsafe pointers and memory manipulation.
|
|
//! [`kinds`](kinds/index.html) defines the special built-in traits,
|
|
//! and [`raw`](raw/index.html) the runtime representation of Rust types.
|
|
//! These are some of the lowest-level building blocks in Rust.
|
|
//!
|
|
//! ## Math on primitive types and math traits
|
|
//!
|
|
//! Although basic operations on primitive types are implemented
|
|
//! directly by the compiler, the standard library additionally
|
|
//! defines many common operations through traits defined in
|
|
//! mod [`num`](num/index.html).
|
|
//!
|
|
//! ## Pervasive types
|
|
//!
|
|
//! The [`option`](option/index.html) and [`result`](result/index.html)
|
|
//! modules define optional and error-handling types, `Option` and `Result`.
|
|
//! [`iter`](iter/index.html) defines Rust's iterator protocol
|
|
//! along with a wide variety of iterators.
|
|
//! [`Cell` and `RefCell`](cell/index.html) are for creating types that
|
|
//! manage their own mutability.
|
|
//!
|
|
//! ## Vectors, slices and strings
|
|
//!
|
|
//! The common container type, `Vec`, a growable vector backed by an
|
|
//! array, lives in the [`vec`](vec/index.html) module. References to
|
|
//! arrays, `&[T]`, more commonly called "slices", are built-in types
|
|
//! for which the [`slice`](slice/index.html) module defines many
|
|
//! methods.
|
|
//!
|
|
//! `&str`, a UTF-8 string, is a built-in type, and the standard library
|
|
//! defines methods for it on a variety of traits in the
|
|
//! [`str`](str/index.html) module. Rust strings are immutable;
|
|
//! use the `String` type defined in [`string`](string/index.html)
|
|
//! for a mutable string builder.
|
|
//!
|
|
//! For converting to strings use the [`format!`](fmt/index.html)
|
|
//! macro, and for converting from strings use the
|
|
//! [`FromStr`](str/trait.FromStr.html) trait.
|
|
//!
|
|
//! ## Platform abstractions
|
|
//!
|
|
//! Besides basic data types, the standard library is largely concerned
|
|
//! with abstracting over differences in common platforms, most notably
|
|
//! Windows and Unix derivatives. The [`os`](os/index.html) module
|
|
//! provides a number of basic functions for interacting with the
|
|
//! operating environment, including program arguments, environment
|
|
//! variables, and directory navigation. The [`path`](path/index.html)
|
|
//! module encapsulates the platform-specific rules for dealing
|
|
//! with file paths.
|
|
//!
|
|
//! `std` also includes modules for interoperating with the
|
|
//! C language: [`c_str`](c_str/index.html) and
|
|
//! [`c_vec`](c_vec/index.html).
|
|
//!
|
|
//! ## Concurrency, I/O, and the runtime
|
|
//!
|
|
//! The [`task`](task/index.html) module contains Rust's threading abstractions,
|
|
//! while [`comm`](comm/index.html) contains the channel types for message
|
|
//! passing. [`sync`](sync/index.html) contains further, primitive, shared
|
|
//! memory types, including [`atomic`](sync/atomic/index.html).
|
|
//!
|
|
//! Common types of I/O, including files, TCP, UDP, pipes, Unix domain sockets,
|
|
//! timers, and process spawning, are defined in the [`io`](io/index.html) module.
|
|
//!
|
|
//! Rust's I/O and concurrency depends on a small runtime interface
|
|
//! that lives, along with its support code, in mod [`rt`](rt/index.html).
|
|
//! While a notable part of the standard library's architecture, this
|
|
//! module is not intended for public use.
|
|
//!
|
|
//! ## The Rust prelude and macros
|
|
//!
|
|
//! Finally, the [`prelude`](prelude/index.html) defines a
|
|
//! common set of traits, types, and functions that are made available
|
|
//! to all code by default. [`macros`](macros/index.html) contains
|
|
//! all the standard macros, such as `assert!`, `panic!`, `println!`,
|
|
//! and `format!`, also available to all Rust code.
|
|
|
|
#![crate_name = "std"]
|
|
#![unstable]
|
|
#![crate_type = "rlib"]
|
|
#![crate_type = "dylib"]
|
|
#![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
|
|
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
|
|
html_root_url = "http://doc.rust-lang.org/nightly/",
|
|
html_playground_url = "http://play.rust-lang.org/")]
|
|
|
|
#![allow(unknown_features)]
|
|
#![feature(macro_rules, globs, linkage, thread_local, asm)]
|
|
#![feature(default_type_params, phase, lang_items, unsafe_destructor)]
|
|
#![feature(slicing_syntax, unboxed_closures)]
|
|
#![feature(old_orphan_check)]
|
|
#![feature(associated_types)]
|
|
|
|
// Don't link to std. We are std.
|
|
#![no_std]
|
|
|
|
#![deny(missing_docs)]
|
|
|
|
#![reexport_test_harness_main = "test_main"]
|
|
|
|
#[cfg(test)] #[phase(plugin, link)] extern crate log;
|
|
|
|
extern crate alloc;
|
|
extern crate unicode;
|
|
extern crate core;
|
|
extern crate "collections" as core_collections;
|
|
extern crate "rand" as core_rand;
|
|
extern crate libc;
|
|
|
|
// Make std testable by not duplicating lang items. See #2912
|
|
#[cfg(test)] extern crate "std" as realstd;
|
|
#[cfg(test)] pub use realstd::kinds;
|
|
#[cfg(test)] pub use realstd::ops;
|
|
#[cfg(test)] pub use realstd::cmp;
|
|
#[cfg(test)] pub use realstd::boxed;
|
|
|
|
|
|
// NB: These reexports are in the order they should be listed in rustdoc
|
|
|
|
pub use core::any;
|
|
pub use core::borrow;
|
|
pub use core::cell;
|
|
pub use core::clone;
|
|
#[cfg(not(test))] pub use core::cmp;
|
|
pub use core::default;
|
|
pub use core::finally;
|
|
pub use core::intrinsics;
|
|
pub use core::iter;
|
|
#[cfg(not(test))] pub use core::kinds;
|
|
pub use core::mem;
|
|
#[cfg(not(test))] pub use core::ops;
|
|
pub use core::ptr;
|
|
pub use core::raw;
|
|
pub use core::simd;
|
|
pub use core::result;
|
|
pub use core::option;
|
|
|
|
#[cfg(not(test))] pub use alloc::boxed;
|
|
pub use alloc::rc;
|
|
|
|
pub use core_collections::slice;
|
|
pub use core_collections::str;
|
|
pub use core_collections::string;
|
|
#[stable]
|
|
pub use core_collections::vec;
|
|
|
|
pub use unicode::char;
|
|
|
|
/* Exported macros */
|
|
|
|
pub mod macros;
|
|
pub mod bitflags;
|
|
|
|
mod rtdeps;
|
|
|
|
/* The Prelude. */
|
|
|
|
pub mod prelude;
|
|
|
|
|
|
/* Primitive types */
|
|
|
|
#[path = "num/float_macros.rs"] mod float_macros;
|
|
#[path = "num/int_macros.rs"] mod int_macros;
|
|
#[path = "num/uint_macros.rs"] mod uint_macros;
|
|
|
|
#[path = "num/int.rs"] pub mod int;
|
|
#[path = "num/i8.rs"] pub mod i8;
|
|
#[path = "num/i16.rs"] pub mod i16;
|
|
#[path = "num/i32.rs"] pub mod i32;
|
|
#[path = "num/i64.rs"] pub mod i64;
|
|
|
|
#[path = "num/uint.rs"] pub mod uint;
|
|
#[path = "num/u8.rs"] pub mod u8;
|
|
#[path = "num/u16.rs"] pub mod u16;
|
|
#[path = "num/u32.rs"] pub mod u32;
|
|
#[path = "num/u64.rs"] pub mod u64;
|
|
|
|
#[path = "num/f32.rs"] pub mod f32;
|
|
#[path = "num/f64.rs"] pub mod f64;
|
|
|
|
pub mod ascii;
|
|
pub mod thunk;
|
|
|
|
/* Common traits */
|
|
|
|
pub mod error;
|
|
pub mod num;
|
|
|
|
/* Runtime and platform support */
|
|
|
|
pub mod thread_local; // first for macros
|
|
|
|
pub mod dynamic_lib;
|
|
pub mod ffi;
|
|
pub mod fmt;
|
|
pub mod io;
|
|
pub mod os;
|
|
pub mod path;
|
|
pub mod rand;
|
|
pub mod time;
|
|
|
|
/* Common data structures */
|
|
|
|
pub mod collections;
|
|
pub mod hash;
|
|
|
|
/* Threads and communication */
|
|
|
|
pub mod thread;
|
|
pub mod sync;
|
|
|
|
#[cfg(unix)]
|
|
#[path = "sys/unix/mod.rs"] mod sys;
|
|
#[cfg(windows)]
|
|
#[path = "sys/windows/mod.rs"] mod sys;
|
|
|
|
#[path = "sys/common/mod.rs"] mod sys_common;
|
|
|
|
pub mod rt;
|
|
mod failure;
|
|
|
|
// Documentation for primitive types
|
|
|
|
mod bool;
|
|
mod unit;
|
|
mod tuple;
|
|
|
|
// A curious inner-module that's not exported that contains the binding
|
|
// 'std' so that macro-expanded references to std::error and such
|
|
// can be resolved within libstd.
|
|
#[doc(hidden)]
|
|
mod std {
|
|
// mods used for deriving
|
|
pub use clone;
|
|
pub use cmp;
|
|
pub use hash;
|
|
|
|
pub use sync; // used for select!()
|
|
pub use error; // used for try!()
|
|
pub use fmt; // used for any formatting strings
|
|
pub use io; // used for println!()
|
|
pub use option; // used for bitflags!{}
|
|
pub use rt; // used for panic!()
|
|
pub use vec; // used for vec![]
|
|
pub use cell; // used for tls!
|
|
pub use thread_local; // used for thread_local!
|
|
pub use kinds; // used for tls!
|
|
pub use ops; // used for bitflags!
|
|
|
|
// The test runner calls ::std::os::args() but really wants realstd
|
|
#[cfg(test)] pub use realstd::os as os;
|
|
// The test runner requires std::slice::Vector, so re-export std::slice just for it.
|
|
//
|
|
// It is also used in vec![]
|
|
pub use slice;
|
|
|
|
pub use boxed; // used for vec![]
|
|
|
|
}
|