squiid/rust
1
0
Fork 0
Code Issues Pull requests Projects Activity

Rollup merge of #21926 - mzabaluev:raw-lifetime, r=alexcrichton

Browse source 
New functions, `slice::from_raw_parts` and `slice::from_raw_parts_mut`,
are added to implement the lifetime convention as agreed in rust-lang/rfcs#556.
The functions `slice::from_raw_buf` and `slice::from_raw_mut_buf` are
left deprecated for the time being.

Holding back on changing the signature of `std::ffi::c_str_to_bytes` as consensus in rust-lang/rfcs#592 is building to replace it with a composition of other functions.

Contribution to #21923.
This commit is contained in:
Manish Goregaokar 2015-02-06 05:40:52 +05:30
commit 6c28ad61a2
10 changed files with 82 additions and 32 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
src/libcollections/slice.rs
View file

@ -113,6 +113,7 @@ pub use core::slice::{Iter, IterMut};
pub use core::slice::{IntSliceExt, SplitMut, ChunksMut, Split};
pub use core::slice::{SplitN, RSplitN, SplitNMut, RSplitNMut};
pub use core::slice::{bytes, mut_ref_slice, ref_slice};
pub use core::slice::{from_raw_parts, from_raw_parts_mut};
pub use core::slice::{from_raw_buf, from_raw_mut_buf};
////////////////////////////////////////////////////////////////////////////////

56
src/libcore/slice.rs
View file

@ -1357,6 +1357,52 @@ pub fn mut_ref_slice<'a, A>(s: &'a mut A) -> &'a mut [A] {
}
}
/// Forms a slice from a pointer and a length.
///
/// The `len` argument is the number of **elements**, not the number of bytes.
///
/// This function is unsafe as there is no guarantee that the given pointer is
/// valid for `len` elements, nor whether the lifetime inferred is a suitable
/// lifetime for the returned slice.
///
/// # Caveat
///
/// The lifetime for the returned slice is inferred from its usage. To
/// prevent accidental misuse, it's suggested to tie the lifetime to whichever
/// source lifetime is safe in the context, such as by providing a helper
/// function taking the lifetime of a host value for the slice, or by explicit
/// annotation.
///
/// # Example
///
/// ```rust
/// use std::slice;
///
/// // manifest a slice out of thin air!
/// let ptr = 0x1234 as *const uint;
/// let amt = 10;
/// unsafe {
/// let slice = slice::from_raw_parts(ptr, amt);
/// }
/// ```
#[inline]
#[unstable(feature = "core")]
pub unsafe fn from_raw_parts<'a, T>(p: *const T, len: uint) -> &'a [T] {
transmute(RawSlice { data: p, len: len })
}
/// Performs the same functionality as `from_raw_parts`, except that a mutable
/// slice is returned.
///
/// This function is unsafe for the same reasons as `from_raw_parts`, as well
/// as not being able to provide a non-aliasing guarantee of the returned
/// mutable slice.
#[inline]
#[unstable(feature = "core")]
pub unsafe fn from_raw_parts_mut<'a, T>(p: *mut T, len: uint) -> &'a mut [T] {
transmute(RawSlice { data: p, len: len })
}
/// Forms a slice from a pointer and a length.
///
/// The pointer given is actually a reference to the base of the slice. This
@ -1383,8 +1429,9 @@ pub fn mut_ref_slice<'a, A>(s: &'a mut A) -> &'a mut [A] {
/// }
/// ```
#[inline]
#[unstable(feature = "core",
reason = "should be renamed to from_raw_parts")]
#[unstable(feature = "core")]
#[deprecated(since = "1.0.0",
reason = "use from_raw_parts")]
pub unsafe fn from_raw_buf<'a, T>(p: &'a *const T, len: uint) -> &'a [T] {
transmute(RawSlice { data: *p, len: len })
}
@ -1396,8 +1443,9 @@ pub unsafe fn from_raw_buf<'a, T>(p: &'a *const T, len: uint) -> &'a [T] {
/// not being able to provide a non-aliasing guarantee of the returned mutable
/// slice.
#[inline]
#[unstable(feature = "core",
reason = "should be renamed to from_raw_parts_mut")]
#[unstable(feature = "core")]
#[deprecated(since = "1.0.0",
reason = "use from_raw_parts_mut")]
pub unsafe fn from_raw_mut_buf<'a, T>(p: &'a *mut T, len: uint) -> &'a mut [T] {
transmute(RawSlice { data: *p, len: len })
}

2
src/libflate/lib.rs
View file

@ -45,7 +45,7 @@ pub struct Bytes {
impl Deref for Bytes {
type Target = [u8];
fn deref(&self) -> &[u8] {
unsafe { slice::from_raw_mut_buf(&self.ptr.0, self.len) }
unsafe { slice::from_raw_parts_mut(self.ptr.0, self.len) }
}
}

4
src/librand/isaac.rs
View file

@ -246,7 +246,7 @@ impl Rand for IsaacRng {
unsafe {
let ptr = ret.rsl.as_mut_ptr() as *mut u8;
let slice = slice::from_raw_mut_buf(&ptr, (RAND_SIZE * 4) as uint);
let slice = slice::from_raw_parts_mut(ptr, (RAND_SIZE * 4) as uint);
other.fill_bytes(slice);
}
ret.cnt = 0;
@ -489,7 +489,7 @@ impl Rand for Isaac64Rng {
unsafe {
let ptr = ret.rsl.as_mut_ptr() as *mut u8;
let slice = slice::from_raw_mut_buf(&ptr, (RAND_SIZE_64 * 8) as uint);
let slice = slice::from_raw_parts_mut(ptr, (RAND_SIZE_64 * 8) as uint);
other.fill_bytes(slice);
}
ret.cnt = 0;

8
src/librustc/metadata/loader.rs
View file

@ -744,8 +744,8 @@ fn get_metadata_section_imp(is_osx: bool, filename: &Path) -> Result<MetadataBlo
while llvm::LLVMIsSectionIteratorAtEnd(of.llof, si.llsi) == False {
let mut name_buf = ptr::null();
let name_len = llvm::LLVMRustGetSectionName(si.llsi, &mut name_buf);
let name = slice::from_raw_buf(&(name_buf as *const u8),
name_len as uint).to_vec();
let name = slice::from_raw_parts(name_buf as *const u8,
name_len as uint).to_vec();
let name = String::from_utf8(name).unwrap();
debug!("get_metadata_section: name {}", name);
if read_meta_section_name(is_osx) == name {
@ -756,7 +756,7 @@ fn get_metadata_section_imp(is_osx: bool, filename: &Path) -> Result<MetadataBlo
debug!("checking {} bytes of metadata-version stamp",
vlen);
let minsz = cmp::min(vlen, csz);
let buf0 = slice::from_raw_buf(&cvbuf, minsz);
let buf0 = slice::from_raw_parts(cvbuf, minsz);
let version_ok = buf0 == encoder::metadata_encoding_version;
if !version_ok {
return Err((format!("incompatible metadata version found: '{}'",
@ -766,7 +766,7 @@ fn get_metadata_section_imp(is_osx: bool, filename: &Path) -> Result<MetadataBlo
let cvbuf1 = cvbuf.offset(vlen as int);
debug!("inflating {} bytes of compressed metadata",
csz - vlen);
let bytes = slice::from_raw_buf(&cvbuf1, csz-vlen);
let bytes = slice::from_raw_parts(cvbuf1, csz - vlen);
match flate::inflate_bytes(bytes) {
Some(inflated) => return Ok(MetadataVec(inflated)),
None => {}

28
src/librustdoc/html/markdown.rs
View file

@ -165,6 +165,13 @@ extern {
}
// hoedown_buffer helpers
impl hoedown_buffer {
fn as_bytes(&self) -> &[u8] {
unsafe { slice::from_raw_parts(self.data, self.size as usize) }
}
}
/// Returns Some(code) if `s` is a line that should be stripped from
/// documentation but used in example code. `code` is the portion of
/// `s` that should be used in tests. (None for lines that should be
@ -194,15 +201,13 @@ pub fn render(w: &mut fmt::Formatter, s: &str, print_toc: bool) -> fmt::Result {
let opaque = opaque as *mut hoedown_html_renderer_state;
let my_opaque: &MyOpaque = &*((*opaque).opaque as *const MyOpaque);
let text = slice::from_raw_buf(&(*orig_text).data,
(*orig_text).size as uint);
let text = (*orig_text).as_bytes();
let origtext = str::from_utf8(text).unwrap();
debug!("docblock: ==============\n{:?}\n=======", text);
let rendered = if lang.is_null() {
false
} else {
let rlang = slice::from_raw_buf(&(*lang).data,
(*lang).size as uint);
let rlang = (*lang).as_bytes();
let rlang = str::from_utf8(rlang).unwrap();
if !LangString::parse(rlang).rust {
(my_opaque.dfltblk)(ob, orig_text, lang,
@ -246,9 +251,7 @@ pub fn render(w: &mut fmt::Formatter, s: &str, print_toc: bool) -> fmt::Result {
let s = if text.is_null() {
"".to_string()
} else {
let s = unsafe {
slice::from_raw_buf(&(*text).data, (*text).size as uint)
};
let s = unsafe { (*text).as_bytes() };
str::from_utf8(s).unwrap().to_string()
};
@ -321,7 +324,7 @@ pub fn render(w: &mut fmt::Formatter, s: &str, print_toc: bool) -> fmt::Result {
};
if ret.is_ok() {
let buf = slice::from_raw_buf(&(*ob).data, (*ob).size as uint);
let buf = (*ob).as_bytes();
ret = w.write_str(str::from_utf8(buf).unwrap());
}
hoedown_buffer_free(ob);
@ -339,13 +342,12 @@ pub fn find_testable_code(doc: &str, tests: &mut ::test::Collector) {
let block_info = if lang.is_null() {
LangString::all_false()
} else {
let lang = slice::from_raw_buf(&(*lang).data,
(*lang).size as uint);
let lang = (*lang).as_bytes();
let s = str::from_utf8(lang).unwrap();
LangString::parse(s)
};
if !block_info.rust { return }
let text = slice::from_raw_buf(&(*text).data, (*text).size as uint);
let text = (*text).as_bytes();
let opaque = opaque as *mut hoedown_html_renderer_state;
let tests = &mut *((*opaque).opaque as *mut ::test::Collector);
let text = str::from_utf8(text).unwrap();
@ -368,7 +370,7 @@ pub fn find_testable_code(doc: &str, tests: &mut ::test::Collector) {
if text.is_null() {
tests.register_header("", level as u32);
} else {
let text = slice::from_raw_buf(&(*text).data, (*text).size as uint);
let text = (*text).as_bytes();
let text = str::from_utf8(text).unwrap();
tests.register_header(text, level as u32);
}
@ -508,7 +510,7 @@ pub fn plain_summary_line(md: &str) -> String {
hoedown_document_render(document, ob, md.as_ptr(),
md.len() as libc::size_t);
hoedown_document_free(document);
let plain_slice = slice::from_raw_buf(&(*ob).data, (*ob).size as uint);
let plain_slice = (*ob).as_bytes();
let plain = match str::from_utf8(plain_slice) {
Ok(s) => s.to_string(),
Err(_) => "".to_string(),

4
src/libstd/ffi/c_str.rs
View file

@ -162,7 +162,7 @@ impl fmt::Debug for CString {
/// ```
pub unsafe fn c_str_to_bytes<'a>(raw: &'a *const libc::c_char) -> &'a [u8] {
let len = libc::strlen(*raw);
slice::from_raw_buf(&*(raw as *const _ as *const *const u8), len as uint)
slice::from_raw_parts(*(raw as *const _ as *const *const u8), len as usize)
}
/// Interpret a C string as a byte slice with the nul terminator.
@ -171,7 +171,7 @@ pub unsafe fn c_str_to_bytes<'a>(raw: &'a *const libc::c_char) -> &'a [u8] {
/// will include the nul terminator of the string.
pub unsafe fn c_str_to_bytes_with_nul<'a>(raw: &'a *const libc::c_char) -> &'a [u8] {
let len = libc::strlen(*raw) + 1;
slice::from_raw_buf(&*(raw as *const _ as *const *const u8), len as uint)
slice::from_raw_parts(*(raw as *const _ as *const *const u8), len as usize)
}
#[cfg(test)]

5
src/libstd/io/mod.rs
View file

@ -24,7 +24,6 @@ use error::Error as StdError;
use fmt;
use iter::Iterator;
use marker::Sized;
use mem;
use ops::{Drop, FnOnce};
use option::Option::{self, Some, None};
use ptr::PtrExt;
@ -69,8 +68,8 @@ fn with_end_to_cap<F>(v: &mut Vec<u8>, f: F) -> Result<usize>
unsafe {
let n = try!(f({
let base = v.as_mut_ptr().offset(v.len() as isize);
black_box(slice::from_raw_mut_buf(mem::copy_lifetime(v, &base),
v.capacity() - v.len()))
black_box(slice::from_raw_parts_mut(base,
v.capacity() - v.len()))
}));
// If the closure (typically a `read` implementation) reported that it

2
src/libstd/os.rs
View file

@ -671,7 +671,7 @@ fn real_args() -> Vec<String> {
// Push it onto the list.
let ptr = ptr as *const u16;
let buf = slice::from_raw_buf(&ptr, len);
let buf = slice::from_raw_parts(ptr, len);
let opt_s = String::from_utf16(sys::truncate_utf16_at_nul(buf));
opt_s.ok().expect("CommandLineToArgvW returned invalid UTF-16")
}).collect();

4
src/libstd/sys/windows/os.rs
View file

@ -109,7 +109,7 @@ impl Iterator for Env {
len += 1;
}
let p = p as *const u16;
let s = slice::from_raw_buf(&p, len as usize);
let s = slice::from_raw_parts(p, len as usize);
self.cur = self.cur.offset(len + 1);
let (k, v) = match s.iter().position(|&b| b == '=' as u16) {
@ -296,7 +296,7 @@ impl Iterator for Args {
// Push it onto the list.
let ptr = ptr as *const u16;
let buf = slice::from_raw_buf(&ptr, len as usize);
let buf = slice::from_raw_parts(ptr, len as usize);
OsStringExt::from_wide(buf)
})
}