user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

std::vec: convert to(_mut)_ptr to as_... methods on &[] and &mut [].

Browse source
This commit is contained in:
Huon Wilson 2013-12-15 23:35:12 +11:00
parent f53292f7ee
commit 164f7a290e
22 changed files with 115 additions and 113 deletions
Download patch file Download diff file Expand all files Collapse all files

10
doc/po/ja/tutorial-ffi.md.po
View file

@ -168,7 +168,7 @@ msgid ""
"~~~~ {.xfail-test}\n"
"pub fn validate_compressed_buffer(src: &[u8]) -> bool {\n"
" unsafe {\n"
" snappy_validate_compressed_buffer(vec::raw::to_ptr(src), src.len() as size_t) == 0\n"
" snappy_validate_compressed_buffer(src.as_ptr(), src.len() as size_t) == 0\n"
" }\n"
"}\n"
"~~~~\n"
@ -207,7 +207,7 @@ msgid ""
"pub fn compress(src: &[u8]) -> ~[u8] {\n"
" unsafe {\n"
" let srclen = src.len() as size_t;\n"
" let psrc = vec::raw::to_ptr(src);\n"
" let psrc = src.as_ptr();\n"
msgstr ""
#. type: Plain text
@ -216,7 +216,7 @@ msgstr ""
msgid ""
" let mut dstlen = snappy_max_compressed_length(srclen);\n"
" let mut dst = vec::with_capacity(dstlen as uint);\n"
" let pdst = vec::raw::to_mut_ptr(dst);\n"
" let pdst = dst.as_mut_ptr();\n"
msgstr ""
#. type: Plain text
@ -247,7 +247,7 @@ msgid ""
"pub fn uncompress(src: &[u8]) -> Option<~[u8]> {\n"
" unsafe {\n"
" let srclen = src.len() as size_t;\n"
" let psrc = vec::raw::to_ptr(src);\n"
" let psrc = src.as_ptr();\n"
msgstr ""
#. type: Plain text
@ -263,7 +263,7 @@ msgstr ""
#, no-wrap
msgid ""
" let mut dst = vec::with_capacity(dstlen as uint);\n"
" let pdst = vec::raw::to_mut_ptr(dst);\n"
" let pdst = dst.as_mut_ptr();\n"
msgstr ""
#. type: Plain text

10
doc/po/tutorial-ffi.md.pot
View file

@ -168,7 +168,7 @@ msgid ""
"~~~~ {.xfail-test}\n"
"pub fn validate_compressed_buffer(src: &[u8]) -> bool {\n"
" unsafe {\n"
" snappy_validate_compressed_buffer(vec::raw::to_ptr(src), src.len() as size_t) == 0\n"
" snappy_validate_compressed_buffer(src.as_ptr(), src.len() as size_t) == 0\n"
" }\n"
"}\n"
"~~~~\n"
@ -207,7 +207,7 @@ msgid ""
"pub fn compress(src: &[u8]) -> ~[u8] {\n"
" unsafe {\n"
" let srclen = src.len() as size_t;\n"
" let psrc = vec::raw::to_ptr(src);\n"
" let psrc = src.as_ptr();\n"
msgstr ""
#. type: Plain text
@ -216,7 +216,7 @@ msgstr ""
msgid ""
" let mut dstlen = snappy_max_compressed_length(srclen);\n"
" let mut dst = vec::with_capacity(dstlen as uint);\n"
" let pdst = vec::raw::to_mut_ptr(dst);\n"
" let pdst = dst.as_mut_ptr();\n"
msgstr ""
#. type: Plain text
@ -247,7 +247,7 @@ msgid ""
"pub fn uncompress(src: &[u8]) -> Option<~[u8]> {\n"
" unsafe {\n"
" let srclen = src.len() as size_t;\n"
" let psrc = vec::raw::to_ptr(src);\n"
" let psrc = src.as_ptr();\n"
msgstr ""
#. type: Plain text
@ -263,7 +263,7 @@ msgstr ""
#, no-wrap
msgid ""
" let mut dst = vec::with_capacity(dstlen as uint);\n"
" let pdst = vec::raw::to_mut_ptr(dst);\n"
" let pdst = dst.as_mut_ptr();\n"
msgstr ""
#. type: Plain text

10
doc/tutorial-ffi.md
View file

@ -79,7 +79,7 @@ the allocated memory. The length is less than or equal to the capacity.
~~~~ {.xfail-test}
pub fn validate_compressed_buffer(src: &[u8]) -> bool {
unsafe {
snappy_validate_compressed_buffer(vec::raw::to_ptr(src), src.len() as size_t) == 0
snappy_validate_compressed_buffer(src.as_ptr(), src.len() as size_t) == 0
}
}
~~~~
@ -100,11 +100,11 @@ the true length after compression for setting the length.
pub fn compress(src: &[u8]) -> ~[u8] {
unsafe {
let srclen = src.len() as size_t;
let psrc = vec::raw::to_ptr(src);
let psrc = src.as_ptr();
let mut dstlen = snappy_max_compressed_length(srclen);
let mut dst = vec::with_capacity(dstlen as uint);
let pdst = vec::raw::to_mut_ptr(dst);
let pdst = dst.as_mut_ptr();
snappy_compress(psrc, srclen, pdst, &mut dstlen);
dst.set_len(dstlen as uint);
@ -120,13 +120,13 @@ format and `snappy_uncompressed_length` will retrieve the exact buffer size requ
pub fn uncompress(src: &[u8]) -> Option<~[u8]> {
unsafe {
let srclen = src.len() as size_t;
let psrc = vec::raw::to_ptr(src);
let psrc = src.as_ptr();
let mut dstlen: size_t = 0;
snappy_uncompressed_length(psrc, srclen, &mut dstlen);
let mut dst = vec::with_capacity(dstlen as uint);
let pdst = vec::raw::to_mut_ptr(dst);
let pdst = dst.as_mut_ptr();
if snappy_uncompress(psrc, srclen, pdst, &mut dstlen) == 0 {
dst.set_len(dstlen as uint);

7
src/libextra/arena.rs
View file

@ -44,7 +44,6 @@ use std::num;
use std::ptr;
use std::mem;
use std::uint;
use std::vec;
use std::unstable::intrinsics;
use std::unstable::intrinsics::{TyDesc, get_tydesc};
@ -115,7 +114,7 @@ fn round_up_to(base: uint, align: uint) -> uint {
// in it.
unsafe fn destroy_chunk(chunk: &Chunk) {
let mut idx = 0;
let buf = vec::raw::to_ptr(chunk.data);
let buf = chunk.data.as_ptr();
let fill = chunk.fill;
while idx < fill {
@ -179,7 +178,7 @@ impl Arena {
//debug!("idx = {}, size = {}, align = {}, fill = {}",
// start, n_bytes, align, head.fill);
ptr::offset(vec::raw::to_ptr(this.pod_head.data), start as int)
ptr::offset(this.pod_head.data.as_ptr(), start as int)
}
}
@ -235,7 +234,7 @@ impl Arena {
//debug!("idx = {}, size = {}, align = {}, fill = {}",
// start, n_bytes, align, head.fill);
let buf = vec::raw::to_ptr(self.head.data);
let buf = self.head.data.as_ptr();
return (ptr::offset(buf, tydesc_start as int), ptr::offset(buf, start as int));
}
}

5
src/librustc/back/lto.rs
View file

@ -16,7 +16,6 @@ use metadata::cstore;
use util::common::time;
use std::libc;
use std::vec;
pub fn run(sess: session::Session, llmod: ModuleRef,
tm: TargetMachineRef, reachable: &[~str]) {
@ -48,7 +47,7 @@ pub fn run(sess: session::Session, llmod: ModuleRef,
debug!("reading {}", name);
let bc = time(sess.time_passes(), format!("read {}.bc", name), (), |_|
archive.read(format!("{}.bc", name)));
let ptr = vec::raw::to_ptr(bc);
let ptr = bc.as_ptr();
debug!("linking {}", name);
time(sess.time_passes(), format!("ll link {}", name), (), |()| unsafe {
if !llvm::LLVMRustLinkInExternalBitcode(llmod,
@ -62,7 +61,7 @@ pub fn run(sess: session::Session, llmod: ModuleRef,
// Internalize everything but the reachable symbols of the current module
let cstrs = reachable.map(|s| s.to_c_str());
let arr = cstrs.map(|c| c.with_ref(|p| p));
let ptr = vec::raw::to_ptr(arr);
let ptr = arr.as_ptr();
unsafe {
llvm::LLVMRustRunRestrictionPass(llmod, ptr as **libc::c_char,
arr.len() as libc::size_t);

17
src/librustc/middle/trans/builder.rs
View file

@ -20,7 +20,6 @@ use middle::trans::type_::Type;
use std::cast;
use std::hashmap::HashMap;
use std::libc::{c_uint, c_ulonglong, c_char};
use std::vec;
use syntax::codemap::Span;
use std::ptr::is_not_null;
@ -118,7 +117,7 @@ impl Builder {
pub fn aggregate_ret(&self, ret_vals: &[ValueRef]) {
unsafe {
llvm::LLVMBuildAggregateRet(self.llbuilder,
vec::raw::to_ptr(ret_vals),
ret_vals.as_ptr(),
ret_vals.len() as c_uint);
}
}
@ -161,7 +160,7 @@ impl Builder {
unsafe {
let v = llvm::LLVMBuildInvoke(self.llbuilder,
llfn,
vec::raw::to_ptr(args),
args.as_ptr(),
args.len() as c_uint,
then,
catch,
@ -500,7 +499,7 @@ impl Builder {
pub fn gep(&self, ptr: ValueRef, indices: &[ValueRef]) -> ValueRef {
self.count_insn("gep");
unsafe {
llvm::LLVMBuildGEP(self.llbuilder, ptr, vec::raw::to_ptr(indices),
llvm::LLVMBuildGEP(self.llbuilder, ptr, indices.as_ptr(),
indices.len() as c_uint, noname())
}
}
@ -528,7 +527,7 @@ impl Builder {
self.count_insn("inboundsgep");
unsafe {
llvm::LLVMBuildInBoundsGEP(
self.llbuilder, ptr, vec::raw::to_ptr(indices), indices.len() as c_uint, noname())
self.llbuilder, ptr, indices.as_ptr(), indices.len() as c_uint, noname())
}
}
@ -716,8 +715,8 @@ impl Builder {
let phi = self.empty_phi(ty);
self.count_insn("addincoming");
unsafe {
llvm::LLVMAddIncoming(phi, vec::raw::to_ptr(vals),
vec::raw::to_ptr(bbs),
llvm::LLVMAddIncoming(phi, vals.as_ptr(),
bbs.as_ptr(),
vals.len() as c_uint);
phi
}
@ -775,7 +774,7 @@ impl Builder {
attributes: &[(uint, lib::llvm::Attribute)]) -> ValueRef {
self.count_insn("call");
unsafe {
let v = llvm::LLVMBuildCall(self.llbuilder, llfn, vec::raw::to_ptr(args),
let v = llvm::LLVMBuildCall(self.llbuilder, llfn, args.as_ptr(),
args.len() as c_uint, noname());
for &(idx, attr) in attributes.iter() {
llvm::LLVMAddInstrAttribute(v, idx as c_uint, attr as c_uint);
@ -885,7 +884,7 @@ impl Builder {
let args: &[ValueRef] = [];
self.count_insn("trap");
llvm::LLVMBuildCall(
self.llbuilder, T, vec::raw::to_ptr(args), args.len() as c_uint, noname());
self.llbuilder, T, args.as_ptr(), args.len() as c_uint, noname());
}
}

6
src/librustc/middle/trans/common.rs
View file

@ -946,7 +946,7 @@ pub fn C_zero_byte_arr(size: uint) -> ValueRef {
let mut elts: ~[ValueRef] = ~[];
while i < size { elts.push(C_u8(0u)); i += 1u; }
return llvm::LLVMConstArray(Type::i8().to_ref(),
vec::raw::to_ptr(elts), elts.len() as c_uint);
elts.as_ptr(), elts.len() as c_uint);
}
}
@ -968,13 +968,13 @@ pub fn C_named_struct(T: Type, elts: &[ValueRef]) -> ValueRef {
pub fn C_array(ty: Type, elts: &[ValueRef]) -> ValueRef {
unsafe {
return llvm::LLVMConstArray(ty.to_ref(), vec::raw::to_ptr(elts), elts.len() as c_uint);
return llvm::LLVMConstArray(ty.to_ref(), elts.as_ptr(), elts.len() as c_uint);
}
}
pub fn C_bytes(bytes: &[u8]) -> ValueRef {
unsafe {
let ptr = cast::transmute(vec::raw::to_ptr(bytes));
let ptr = cast::transmute(bytes.as_ptr());
return llvm::LLVMConstStringInContext(base::task_llcx(), ptr, bytes.len() as c_uint, True);
}
}

3
src/librustc/middle/trans/context.rs
View file

@ -31,7 +31,6 @@ use util::sha2::Sha256;
use std::c_str::ToCStr;
use std::hashmap::{HashMap, HashSet};
use std::local_data;
use std::vec;
use std::libc::c_uint;
use syntax::ast;
@ -261,7 +260,7 @@ impl CrateContext {
indices.iter().map(|i| C_i32(*i as i32)).collect();
unsafe {
llvm::LLVMConstInBoundsGEP(pointer,
vec::raw::to_ptr(v),
v.as_ptr(),
indices.len() as c_uint)
}
}

6
src/librustc/middle/trans/debuginfo.rs
View file

@ -860,7 +860,7 @@ pub fn create_function_debug_context(cx: &mut CrateContext,
fn create_DIArray(builder: DIBuilderRef, arr: &[DIDescriptor]) -> DIArray {
return unsafe {
llvm::LLVMDIBuilderGetOrCreateArray(builder, vec::raw::to_ptr(arr), arr.len() as u32)
llvm::LLVMDIBuilderGetOrCreateArray(builder, arr.as_ptr(), arr.len() as u32)
};
}
@ -949,7 +949,7 @@ fn declare_local(bcx: @mut Block,
file_metadata,
loc.line as c_uint,
type_metadata,
vec::raw::to_ptr(address_operations),
address_operations.as_ptr(),
address_operations.len() as c_uint,
argument_index)
}
@ -2133,7 +2133,7 @@ fn set_debug_location(cx: &mut CrateContext, debug_location: DebugLocation) {
let elements = [C_i32(line as i32), C_i32(col as i32), scope, ptr::null()];
unsafe {
metadata_node = llvm::LLVMMDNodeInContext(debug_context(cx).llcontext,
vec::raw::to_ptr(elements),
elements.as_ptr(),
elements.len() as c_uint);
}
}

12
src/librustc/middle/trans/type_.rs
View file

@ -150,13 +150,13 @@ impl Type {
pub fn func(args: &[Type], ret: &Type) -> Type {
let vec : &[TypeRef] = unsafe { cast::transmute(args) };
ty!(llvm::LLVMFunctionType(ret.to_ref(), vec::raw::to_ptr(vec),
ty!(llvm::LLVMFunctionType(ret.to_ref(), vec.as_ptr(),
args.len() as c_uint, False))
}
pub fn variadic_func(args: &[Type], ret: &Type) -> Type {
let vec : &[TypeRef] = unsafe { cast::transmute(args) };
ty!(llvm::LLVMFunctionType(ret.to_ref(), vec::raw::to_ptr(vec),
ty!(llvm::LLVMFunctionType(ret.to_ref(), vec.as_ptr(),
args.len() as c_uint, True))
}
@ -170,7 +170,7 @@ impl Type {
pub fn struct_(els: &[Type], packed: bool) -> Type {
let els : &[TypeRef] = unsafe { cast::transmute(els) };
ty!(llvm::LLVMStructTypeInContext(base::task_llcx(), vec::raw::to_ptr(els),
ty!(llvm::LLVMStructTypeInContext(base::task_llcx(), els.as_ptr(),
els.len() as c_uint, packed as Bool))
}
@ -297,7 +297,7 @@ impl Type {
pub fn set_struct_body(&mut self, els: &[Type], packed: bool) {
unsafe {
let vec : &[TypeRef] = cast::transmute(els);
llvm::LLVMStructSetBody(self.to_ref(), vec::raw::to_ptr(vec),
llvm::LLVMStructSetBody(self.to_ref(), vec.as_ptr(),
els.len() as c_uint, packed as Bool)
}
}
@ -311,7 +311,7 @@ impl Type {
let num_fields = llvm::LLVMCountStructElementTypes(self.to_ref()) as uint;
let mut elems = vec::from_elem(num_fields, 0 as TypeRef);
llvm::LLVMGetStructElementTypes(self.to_ref(), vec::raw::to_mut_ptr(elems));
llvm::LLVMGetStructElementTypes(self.to_ref(), elems.as_mut_ptr());
Type::from_ref(elems[idx])
}
@ -355,7 +355,7 @@ impl Type {
unsafe {
let n_args = llvm::LLVMCountParamTypes(self.to_ref()) as uint;
let args = vec::from_elem(n_args, 0 as TypeRef);
llvm::LLVMGetParamTypes(self.to_ref(), vec::raw::to_ptr(args));
llvm::LLVMGetParamTypes(self.to_ref(), args.as_ptr());
cast::transmute(args)
}
}

5
src/librustuv/file.rs
View file

@ -20,7 +20,6 @@ use std::io;
use std::rt::local::Local;
use std::rt::rtio;
use std::rt::sched::{Scheduler, SchedHandle};
use std::vec;
use super::{Loop, UvError, uv_error_to_io_error, wait_until_woken_after};
use uvio::HomingIO;
@ -78,7 +77,7 @@ impl FsRequest {
{
execute_nop(|req, cb| unsafe {
uvll::uv_fs_write(loop_.handle, req,
fd, vec::raw::to_ptr(buf) as *c_void,
fd, buf.as_ptr() as *c_void,
buf.len() as size_t, offset, cb)
})
}
@ -88,7 +87,7 @@ impl FsRequest {
{
execute(|req, cb| unsafe {
uvll::uv_fs_read(loop_.handle, req,
fd, vec::raw::to_ptr(buf) as *c_void,
fd, buf.as_ptr() as *c_void,
buf.len() as size_t, offset, cb)
}).map(|req| {
req.get_result() as int

3
src/librustuv/lib.rs
View file

@ -60,7 +60,6 @@ use std::str::raw::from_c_str;
use std::str;
use std::task;
use std::unstable::finally::Finally;
use std::vec;
use std::io::IoError;
@ -388,7 +387,7 @@ pub fn empty_buf() -> Buf {
/// Borrow a slice to a Buf
pub fn slice_to_uv_buf(v: &[u8]) -> Buf {
let data = vec::raw::to_ptr(v);
let data = v.as_ptr();
uvll::uv_buf_t { base: data, len: v.len() as uvll::uv_buf_len_t }
}

2
src/librustuv/net.rs
View file

@ -62,7 +62,7 @@ pub fn sockaddr_to_socket_addr(addr: *sockaddr) -> SocketAddr {
// apparently there's an off-by-one in libuv?
let ip_size = ip_size + 1;
let buf = vec::from_elem(ip_size + 1 /*null terminated*/, 0u8);
let buf_ptr = vec::raw::to_ptr(buf);
let buf_ptr = buf.as_ptr();
let ret = if uvll::rust_is_ipv4_sockaddr(addr) == 1 {
uvll::uv_ip4_name(addr, buf_ptr as *c_char, ip_size as size_t)
} else {

5
src/librustuv/uvll.rs
View file

@ -33,7 +33,6 @@ use std::libc::{size_t, c_int, c_uint, c_void, c_char, c_double};
use std::libc::ssize_t;
use std::libc::{malloc, free};
use std::libc;
use std::vec;
#[cfg(test)]
use std::libc::uintptr_t;
@ -419,7 +418,7 @@ pub unsafe fn uv_write(req: *uv_write_t,
cb: uv_write_cb) -> c_int;
}
let buf_ptr = vec::raw::to_ptr(buf_in);
let buf_ptr = buf_in.as_ptr();
let buf_cnt = buf_in.len() as i32;
return uv_write(req, stream, buf_ptr, buf_cnt, cb);
}
@ -435,7 +434,7 @@ pub unsafe fn uv_udp_send(req: *uv_udp_send_t,
cb: uv_udp_send_cb) -> c_int;
}
let buf_ptr = vec::raw::to_ptr(buf_in);
let buf_ptr = buf_in.as_ptr();
let buf_cnt = buf_in.len() as i32;
return uv_udp_send(req, handle, buf_ptr, buf_cnt, addr, cb);
}

2
src/libstd/c_str.rs
View file

@ -385,7 +385,7 @@ mod tests {
fn test_str_multistring_parsing() {
unsafe {
let input = bytes!("zero", "\x00", "one", "\x00", "\x00");
let ptr = vec::raw::to_ptr(input);
let ptr = input.as_ptr();
let expected = ["zero", "one"];
let mut it = expected.iter();
let result = from_c_multistring(ptr as *libc::c_char, None, |c| {

6
src/libstd/io/native/file.rs
View file

@ -133,7 +133,7 @@ impl rtio::RtioFileStream for FileDesc {
self.inner_write(buf)
}
fn pread(&mut self, buf: &mut [u8], offset: u64) -> Result<int, IoError> {
return os_pread(self.fd, vec::raw::to_ptr(buf), buf.len(), offset);
return os_pread(self.fd, buf.as_ptr(), buf.len(), offset);
#[cfg(windows)]
fn os_pread(fd: c_int, buf: *u8, amt: uint, offset: u64) -> IoResult<int> {
@ -165,7 +165,7 @@ impl rtio::RtioFileStream for FileDesc {
}
}
fn pwrite(&mut self, buf: &[u8], offset: u64) -> Result<(), IoError> {
return os_pwrite(self.fd, vec::raw::to_ptr(buf), buf.len(), offset);
return os_pwrite(self.fd, buf.as_ptr(), buf.len(), offset);
#[cfg(windows)]
fn os_pwrite(fd: c_int, buf: *u8, amt: uint, offset: u64) -> IoResult<()> {
@ -700,7 +700,7 @@ pub fn readlink(p: &CString) -> IoResult<Path> {
}
let mut buf = vec::with_capacity::<u8>(len as uint);
match unsafe {
libc::readlink(p, vec::raw::to_ptr(buf) as *mut libc::c_char,
libc::readlink(p, buf.as_ptr() as *mut libc::c_char,
len as libc::size_t)
} {
-1 => Err(super::last_error()),

4
src/libstd/os.rs
View file

@ -358,13 +358,13 @@ pub fn self_exe_path() -> Option<Path> {
KERN_PROC as c_int,
KERN_PROC_PATHNAME as c_int, -1 as c_int];
let mut sz: size_t = 0;
let err = sysctl(vec::raw::to_ptr(mib), mib.len() as ::libc::c_uint,
let err = sysctl(mib.as_ptr(), mib.len() as ::libc::c_uint,
ptr::mut_null(), &mut sz, ptr::null(), 0u as size_t);
if err != 0 { return None; }
if sz == 0 { return None; }
let mut v: ~[u8] = vec::with_capacity(sz as uint);
let err = v.as_mut_buf(|buf,_| {
sysctl(vec::raw::to_ptr(mib), mib.len() as ::libc::c_uint,
sysctl(mib.as_ptr(), mib.len() as ::libc::c_uint,
buf as *mut c_void, &mut sz, ptr::null(), 0u as size_t)
});
if err != 0 { return None; }

26
src/libstd/ptr.rs
View file

@ -449,7 +449,7 @@ pub mod ptr_tests {
use cast;
use libc;
use str;
use vec;
use vec::{ImmutableVector, MutableVector};
#[test]
fn test() {
@ -474,15 +474,15 @@ pub mod ptr_tests {
let v0 = ~[32000u16, 32001u16, 32002u16];
let mut v1 = ~[0u16, 0u16, 0u16];
copy_memory(mut_offset(vec::raw::to_mut_ptr(v1), 1),
offset(vec::raw::to_ptr(v0), 1), 1);
copy_memory(mut_offset(v1.as_mut_ptr(), 1),
offset(v0.as_ptr(), 1), 1);
assert!((v1[0] == 0u16 && v1[1] == 32001u16 && v1[2] == 0u16));
copy_memory(vec::raw::to_mut_ptr(v1),
offset(vec::raw::to_ptr(v0), 2), 1);
copy_memory(v1.as_mut_ptr(),
offset(v0.as_ptr(), 2), 1);
assert!((v1[0] == 32002u16 && v1[1] == 32001u16 &&
v1[2] == 0u16));
copy_memory(mut_offset(vec::raw::to_mut_ptr(v1), 2),
vec::raw::to_ptr(v0), 1u);
copy_memory(mut_offset(v1.as_mut_ptr(), 2),
v0.as_ptr(), 1u);
assert!((v1[0] == 32002u16 && v1[1] == 32001u16 &&
v1[2] == 32000u16));
}
@ -558,7 +558,7 @@ pub mod ptr_tests {
unsafe {
let xs = ~[5, ..16];
let mut ptr = to_ptr(xs);
let mut ptr = xs.as_ptr();
let end = ptr.offset(16);
while ptr < end {
@ -567,7 +567,7 @@ pub mod ptr_tests {
}
let mut xs_mut = xs.clone();
let mut m_ptr = to_mut_ptr(xs_mut);
let mut m_ptr = xs_mut.as_mut_ptr();
let m_end = m_ptr.offset(16);
while m_ptr < m_end {
@ -581,12 +581,10 @@ pub mod ptr_tests {
#[test]
fn test_ptr_subtraction() {
use vec::raw::*;
unsafe {
let xs = ~[0,1,2,3,4,5,6,7,8,9];
let mut idx = 9i8;
let ptr = to_ptr(xs);
let ptr = xs.as_ptr();
while idx >= 0i8 {
assert_eq!(*(ptr.offset(idx as int)), idx as int);
@ -594,7 +592,7 @@ pub mod ptr_tests {
}
let mut xs_mut = xs.clone();
let m_start = to_mut_ptr(xs_mut);
let m_start = xs_mut.as_mut_ptr();
let mut m_ptr = m_start.offset(9);
while m_ptr >= m_start {
@ -700,7 +698,7 @@ pub mod ptr_tests {
#[test]
fn test_set_memory() {
let mut xs = [0u8, ..20];
let ptr = vec::raw::to_mut_ptr(xs);
let ptr = xs.as_mut_ptr();
unsafe { set_memory(ptr, 5u8, xs.len()); }
assert_eq!(xs, [5u8, ..20]);
}

4
src/libstd/rand/isaac.rs
View file

@ -49,7 +49,7 @@ impl IsaacRng {
let mut rng = EMPTY;
unsafe {
let ptr = raw::to_mut_ptr(rng.rsl);
let ptr = rng.rsl.as_mut_ptr();
raw::mut_buf_as_slice(ptr as *mut u8, mem::size_of_val(&rng.rsl), |slice| {
OSRng::new().fill_bytes(slice);
@ -254,7 +254,7 @@ impl Isaac64Rng {
let mut rng = EMPTY_64;
unsafe {
let ptr = raw::to_mut_ptr(rng.rsl);
let ptr = rng.rsl.as_mut_ptr();
raw::mut_buf_as_slice(ptr as *mut u8, mem::size_of_val(&rng.rsl), |slice| {
OSRng::new().fill_bytes(slice);

4
src/libstd/rt/stack.rs
View file

@ -39,13 +39,13 @@ impl StackSegment {
/// Point to the low end of the allocated stack
pub fn start(&self) -> *uint {
vec::raw::to_ptr(self.buf) as *uint
self.buf.as_ptr() as *uint
}
/// Point one word beyond the high end of the allocated stack
pub fn end(&self) -> *uint {
unsafe {
vec::raw::to_ptr(self.buf).offset(self.buf.len() as int) as *uint
self.buf.as_ptr().offset(self.buf.len() as int) as *uint
}
}
}

4
src/libstd/str.rs
View file

@ -1139,7 +1139,7 @@ pub mod raw {
fn test_from_buf_len() {
unsafe {
let a = ~[65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 0u8];
let b = vec::raw::to_ptr(a);
let b = a.as_ptr();
let c = from_buf_len(b, 3u);
assert_eq!(c, ~"AAA");
}
@ -3360,7 +3360,7 @@ mod tests {
fn test_raw_from_c_str() {
unsafe {
let a = ~[65, 65, 65, 65, 65, 65, 65, 0];
let b = vec::raw::to_ptr(a);
let b = a.as_ptr();
let c = raw::from_c_str(b);
assert_eq!(c, ~"AAAAAAA");
}

77
src/libstd/vec.rs
View file

@ -123,7 +123,6 @@ use unstable::finally::Finally;
use unstable::intrinsics;
use unstable::intrinsics::{get_tydesc, owns_managed};
use unstable::raw::{Box, Repr, Slice, Vec};
use vec;
use util;
/**
@ -135,7 +134,7 @@ use util;
pub fn from_fn<T>(n_elts: uint, op: |uint| -> T) -> ~[T] {
unsafe {
let mut v = with_capacity(n_elts);
let p = raw::to_mut_ptr(v);
let p = v.as_mut_ptr();
let mut i: uint = 0u;
(|| {
while i < n_elts {
@ -162,7 +161,7 @@ pub fn from_elem<T:Clone>(n_elts: uint, t: T) -> ~[T] {
// vec::with_capacity/ptr::set_memory for primitive types.
unsafe {
let mut v = with_capacity(n_elts);
let p = raw::to_mut_ptr(v);
let p = v.as_mut_ptr();
let mut i = 0u;
(|| {
while i < n_elts {
@ -955,6 +954,17 @@ pub trait ImmutableVector<'a, T> {
/// bounds checking.
unsafe fn unsafe_ref(&self, index: uint) -> *T;
/**
* Returns an unsafe pointer to the vector's buffer
*
* The caller must ensure that the vector outlives the pointer this
* function returns, or else it will end up pointing to garbage.
*
* Modifying the vector may cause its buffer to be reallocated, which
* would also make any pointers to it invalid.
*/
fn as_ptr(&self) -> *T;
/**
* Binary search a sorted vector with a comparator function.
*
@ -1043,7 +1053,7 @@ impl<'a,T> ImmutableVector<'a, T> for &'a [T] {
#[inline]
fn iter(self) -> VecIterator<'a, T> {
unsafe {
let p = vec::raw::to_ptr(self);
let p = self.as_ptr();
if mem::size_of::<T>() == 0 {
VecIterator{ptr: p,
end: (p as uint + self.len()) as *T,
@ -1156,6 +1166,12 @@ impl<'a,T> ImmutableVector<'a, T> for &'a [T] {
self.repr().data.offset(index as int)
}
#[inline]
fn as_ptr(&self) -> *T {
self.repr().data
}
fn bsearch(&self, f: |&T| -> Ordering) -> Option<uint> {
let mut base : uint = 0;
let mut lim : uint = self.len();
@ -1571,8 +1587,8 @@ impl<T> OwnedVector<T> for ~[T] {
let new_len = self_len + rhs_len;
self.reserve_additional(rhs.len());
unsafe { // Note: infallible.
let self_p = vec::raw::to_mut_ptr(*self);
let rhs_p = vec::raw::to_ptr(rhs);
let self_p = self.as_mut_ptr();
let rhs_p = rhs.as_ptr();
ptr::copy_memory(ptr::mut_offset(self_p, self_len as int), rhs_p, rhs_len);
self.set_len(new_len);
rhs.set_len(0);
@ -1648,7 +1664,7 @@ impl<T> OwnedVector<T> for ~[T] {
self.set_len(next_ln);
// Swap out the element we want from the end
let vp = raw::to_mut_ptr(*self);
let vp = self.as_mut_ptr();
let vp = ptr::mut_offset(vp, (next_ln - 1) as int);
Some(ptr::replace_ptr(vp, work_elt))
@ -1900,7 +1916,7 @@ impl<T:Eq> OwnedEqVector<T> for ~[T] {
if ln < 1 { return; }
// Avoid bounds checks by using unsafe pointers.
let p = vec::raw::to_mut_ptr(*self);
let p = self.as_mut_ptr();
let mut r = 1;
let mut w = 1;
@ -2038,6 +2054,17 @@ pub trait MutableVector<'a, T> {
/// Returns an unsafe mutable pointer to the element in index
unsafe fn unsafe_mut_ref(self, index: uint) -> *mut T;
/// Return an unsafe mutable pointer to the vector's buffer.
///
/// The caller must ensure that the vector outlives the pointer this
/// function returns, or else it will end up pointing to garbage.
///
/// Modifying the vector may cause its buffer to be reallocated, which
/// would also make any pointers to it invalid.
#[inline]
fn as_mut_ptr(self) -> *mut T;
/// Unsafely sets the element in index to the value
unsafe fn unsafe_set(self, index: uint, val: T);
@ -2083,7 +2110,7 @@ impl<'a,T> MutableVector<'a, T> for &'a mut [T] {
#[inline]
fn mut_iter(self) -> VecMutIterator<'a, T> {
unsafe {
let p = vec::raw::to_mut_ptr(self);
let p = self.as_mut_ptr();
if mem::size_of::<T>() == 0 {
VecMutIterator{ptr: p,
end: (p as uint + self.len()) as *mut T,
@ -2159,6 +2186,11 @@ impl<'a,T> MutableVector<'a, T> for &'a mut [T] {
ptr::mut_offset(self.repr().data as *mut T, index as int)
}
#[inline]
fn as_mut_ptr(self) -> *mut T {
self.repr().data as *mut T
}
#[inline]
unsafe fn unsafe_set(self, index: uint, val: T) {
*self.unsafe_mut_ref(index) = val;
@ -2206,31 +2238,10 @@ pub mod raw {
use cast;
use option::Some;
use ptr;
use mem;
use unstable::intrinsics;
use vec::{with_capacity, ImmutableVector, MutableVector};
use unstable::raw::Slice;
/**
* Returns an unsafe pointer to the vector's buffer
*
* The caller must ensure that the vector outlives the pointer this
* function returns, or else it will end up pointing to garbage.
*
* Modifying the vector may cause its buffer to be reallocated, which
* would also make any pointers to it invalid.
*/
#[inline]
pub fn to_ptr<T>(v: &[T]) -> *T {
v.repr().data
}
/** see `to_ptr()` */
#[inline]
pub fn to_mut_ptr<T>(v: &mut [T]) -> *mut T {
v.repr().data as *mut T
}
/**
* Form a slice from a pointer and length (as a number of units,
* not bytes).
@ -2755,7 +2766,7 @@ mod tests {
unsafe {
// Test on-stack copy-from-buf.
let a = ~[1, 2, 3];
let mut ptr = raw::to_ptr(a);
let mut ptr = a.as_ptr();
let b = from_buf(ptr, 3u);
assert_eq!(b.len(), 3u);
assert_eq!(b[0], 1);
@ -2764,7 +2775,7 @@ mod tests {
// Test on-heap copy-from-buf.
let c = ~[1, 2, 3, 4, 5];
ptr = raw::to_ptr(c);
ptr = c.as_ptr();
let d = from_buf(ptr, 5u);
assert_eq!(d.len(), 5u);
assert_eq!(d[0], 1);
@ -4291,7 +4302,7 @@ mod bench {
bh.iter(|| {
let mut v: ~[u8] = vec::with_capacity(1024);
unsafe {
let vp = vec::raw::to_mut_ptr(v);
let vp = v.as_mut_ptr();
ptr::set_memory(vp, 0, 1024);
v.set_len(1024);
}