464cdff102
This commit is the standard API stabilization commit for the 1.6 release cycle. The list of issues and APIs below have all been through their cycle-long FCP and the libs team decisions are listed below Stabilized APIs * `Read::read_exact` * `ErrorKind::UnexpectedEof` (renamed from `UnexpectedEOF`) * libcore -- this was a bit of a nuanced stabilization, the crate itself is now marked as `#[stable]` and the methods appearing via traits for primitives like `char` and `str` are now also marked as stable. Note that the extension traits themeselves are marked as unstable as they're imported via the prelude. The `try!` macro was also moved from the standard library into libcore to have the same interface. Otherwise the functions all have copied stability from the standard library now. * The `#![no_std]` attribute * `fs::DirBuilder` * `fs::DirBuilder::new` * `fs::DirBuilder::recursive` * `fs::DirBuilder::create` * `os::unix::fs::DirBuilderExt` * `os::unix::fs::DirBuilderExt::mode` * `vec::Drain` * `vec::Vec::drain` * `string::Drain` * `string::String::drain` * `vec_deque::Drain` * `vec_deque::VecDeque::drain` * `collections::hash_map::Drain` * `collections::hash_map::HashMap::drain` * `collections::hash_set::Drain` * `collections::hash_set::HashSet::drain` * `collections::binary_heap::Drain` * `collections::binary_heap::BinaryHeap::drain` * `Vec::extend_from_slice` (renamed from `push_all`) * `Mutex::get_mut` * `Mutex::into_inner` * `RwLock::get_mut` * `RwLock::into_inner` * `Iterator::min_by_key` (renamed from `min_by`) * `Iterator::max_by_key` (renamed from `max_by`) Deprecated APIs * `ErrorKind::UnexpectedEOF` (renamed to `UnexpectedEof`) * `OsString::from_bytes` * `OsStr::to_cstring` * `OsStr::to_bytes` * `fs::walk_dir` and `fs::WalkDir` * `path::Components::peek` * `slice::bytes::MutableByteVector` * `slice::bytes::copy_memory` * `Vec::push_all` (renamed to `extend_from_slice`) * `Duration::span` * `IpAddr` * `SocketAddr::ip` * `Read::tee` * `io::Tee` * `Write::broadcast` * `io::Broadcast` * `Iterator::min_by` (renamed to `min_by_key`) * `Iterator::max_by` (renamed to `max_by_key`) * `net::lookup_addr` New APIs (still unstable) * `<[T]>::sort_by_key` (added to mirror `min_by_key`) Closes #27585 Closes #27704 Closes #27707 Closes #27710 Closes #27711 Closes #27727 Closes #27740 Closes #27744 Closes #27799 Closes #27801 cc #27801 (doesn't close as `Chars` is still unstable) Closes #28968
82 lines
2.7 KiB
Markdown
82 lines
2.7 KiB
Markdown
% Lang items
|
|
|
|
> **Note**: lang items are often provided by crates in the Rust distribution,
|
|
> and lang items themselves have an unstable interface. It is recommended to use
|
|
> officially distributed crates instead of defining your own lang items.
|
|
|
|
The `rustc` compiler has certain pluggable operations, that is,
|
|
functionality that isn't hard-coded into the language, but is
|
|
implemented in libraries, with a special marker to tell the compiler
|
|
it exists. The marker is the attribute `#[lang = "..."]` and there are
|
|
various different values of `...`, i.e. various different 'lang
|
|
items'.
|
|
|
|
For example, `Box` pointers require two lang items, one for allocation
|
|
and one for deallocation. A freestanding program that uses the `Box`
|
|
sugar for dynamic allocations via `malloc` and `free`:
|
|
|
|
```rust
|
|
#![feature(lang_items, box_syntax, start, libc)]
|
|
#![no_std]
|
|
|
|
extern crate libc;
|
|
|
|
extern {
|
|
fn abort() -> !;
|
|
}
|
|
|
|
#[lang = "owned_box"]
|
|
pub struct Box<T>(*mut T);
|
|
|
|
#[lang = "exchange_malloc"]
|
|
unsafe fn allocate(size: usize, _align: usize) -> *mut u8 {
|
|
let p = libc::malloc(size as libc::size_t) as *mut u8;
|
|
|
|
// malloc failed
|
|
if p as usize == 0 {
|
|
abort();
|
|
}
|
|
|
|
p
|
|
}
|
|
#[lang = "exchange_free"]
|
|
unsafe fn deallocate(ptr: *mut u8, _size: usize, _align: usize) {
|
|
libc::free(ptr as *mut libc::c_void)
|
|
}
|
|
|
|
#[start]
|
|
fn main(argc: isize, argv: *const *const u8) -> isize {
|
|
let x = box 1;
|
|
|
|
0
|
|
}
|
|
|
|
#[lang = "eh_personality"] extern fn eh_personality() {}
|
|
#[lang = "panic_fmt"] fn panic_fmt() -> ! { loop {} }
|
|
# #[lang = "eh_unwind_resume"] extern fn rust_eh_unwind_resume() {}
|
|
# #[no_mangle] pub extern fn rust_eh_register_frames () {}
|
|
# #[no_mangle] pub extern fn rust_eh_unregister_frames () {}
|
|
```
|
|
|
|
Note the use of `abort`: the `exchange_malloc` lang item is assumed to
|
|
return a valid pointer, and so needs to do the check internally.
|
|
|
|
Other features provided by lang items include:
|
|
|
|
- overloadable operators via traits: the traits corresponding to the
|
|
`==`, `<`, dereferencing (`*`) and `+` (etc.) operators are all
|
|
marked with lang items; those specific four are `eq`, `ord`,
|
|
`deref`, and `add` respectively.
|
|
- stack unwinding and general failure; the `eh_personality`, `fail`
|
|
and `fail_bounds_checks` lang items.
|
|
- the traits in `std::marker` used to indicate types of
|
|
various kinds; lang items `send`, `sync` and `copy`.
|
|
- the marker types and variance indicators found in
|
|
`std::marker`; lang items `covariant_type`,
|
|
`contravariant_lifetime`, etc.
|
|
|
|
Lang items are loaded lazily by the compiler; e.g. if one never uses
|
|
`Box` then there is no need to define functions for `exchange_malloc`
|
|
and `exchange_free`. `rustc` will emit an error when an item is needed
|
|
but not found in the current crate or any that it depends on.
|