bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Move std::{str,vec}::raw::set_len to an unsafe method on Owned{Vector,Str}.

Browse source
This commit is contained in:
Huon Wilson 2013-12-15 23:05:30 +11:00
parent 4f62c969f6
commit f53292f7ee
11 changed files with 68 additions and 66 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -224,7 +224,7 @@ msgstr ""
#, no-wrap
msgid ""
" snappy_compress(psrc, srclen, pdst, &mut dstlen);\n"
" vec::raw::set_len(&mut dst, dstlen as uint);\n"
" dst.set_len(dstlen as uint);\n"
" dst\n"
" }\n"
"}\n"
@ -271,7 +271,7 @@ msgstr ""
#, no-wrap
msgid ""
" if snappy_uncompress(psrc, srclen, pdst, &mut dstlen) == 0 {\n"
" vec::raw::set_len(&mut dst, dstlen as uint);\n"
" dst.set_len(dstlen as uint);\n"
" Some(dst)\n"
" } else {\n"
" None // SNAPPY_INVALID_INPUT\n"

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

@ -224,7 +224,7 @@ msgstr ""
#, no-wrap
msgid ""
" snappy_compress(psrc, srclen, pdst, &mut dstlen);\n"
" vec::raw::set_len(&mut dst, dstlen as uint);\n"
" dst.set_len(dstlen as uint);\n"
" dst\n"
" }\n"
"}\n"
@ -271,7 +271,7 @@ msgstr ""
#, no-wrap
msgid ""
" if snappy_uncompress(psrc, srclen, pdst, &mut dstlen) == 0 {\n"
" vec::raw::set_len(&mut dst, dstlen as uint);\n"
" dst.set_len(dstlen as uint);\n"
" Some(dst)\n"
" } else {\n"
" None // SNAPPY_INVALID_INPUT\n"

4
doc/tutorial-ffi.md
View file

@ -107,7 +107,7 @@ pub fn compress(src: &[u8]) -> ~[u8] {
let pdst = vec::raw::to_mut_ptr(dst);
snappy_compress(psrc, srclen, pdst, &mut dstlen);
vec::raw::set_len(&mut dst, dstlen as uint);
dst.set_len(dstlen as uint);
dst
}
}
@ -129,7 +129,7 @@ pub fn uncompress(src: &[u8]) -> Option<~[u8]> {
let pdst = vec::raw::to_mut_ptr(dst);
if snappy_uncompress(psrc, srclen, pdst, &mut dstlen) == 0 {
vec::raw::set_len(&mut dst, dstlen as uint);
dst.set_len(dstlen as uint);
Some(dst)
} else {
None // SNAPPY_INVALID_INPUT

2
src/librustuv/process.rs
View file

@ -49,7 +49,7 @@ impl Process {
let mut stdio = vec::with_capacity::<uvll::uv_stdio_container_t>(io.len());
let mut ret_io = vec::with_capacity(io.len());
unsafe {
vec::raw::set_len(&mut stdio, io.len());
stdio.set_len(io.len());
for (slot, other) in stdio.iter().zip(io.iter()) {
let io = set_stdio(slot as *uvll::uv_stdio_container_t, other,
loop_);

4
src/libstd/io/buffered.rs
View file

@ -79,7 +79,7 @@ impl<R: Reader> BufferedReader<R> {
// to be very cheap (large mallocs are not nearly as expensive as large
// callocs).
let mut buf = vec::with_capacity(cap);
unsafe { vec::raw::set_len(&mut buf, cap); }
unsafe { buf.set_len(cap); }
BufferedReader {
inner: inner,
buf: buf,
@ -154,7 +154,7 @@ impl<W: Writer> BufferedWriter<W> {
pub fn with_capacity(cap: uint, inner: W) -> BufferedWriter<W> {
// See comments in BufferedReader for why this uses unsafe code.
let mut buf = vec::with_capacity(cap);
unsafe { vec::raw::set_len(&mut buf, cap); }
unsafe { buf.set_len(cap); }
BufferedWriter {
inner: inner,
buf: buf,

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

@ -523,7 +523,7 @@ pub trait Reader {
let mut total_read = 0;
buf.reserve_additional(len);
vec::raw::set_len(buf, start_len + len);
buf.set_len(start_len + len);
(|| {
while total_read < len {
@ -539,7 +539,7 @@ pub trait Reader {
}
}
}
}).finally(|| vec::raw::set_len(buf, start_len + total_read))
}).finally(|| buf.set_len(start_len + total_read))
}
}

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

@ -706,7 +706,7 @@ pub fn readlink(p: &CString) -> IoResult<Path> {
-1 => Err(super::last_error()),
n => {
assert!(n > 0);
unsafe { vec::raw::set_len(&mut buf, n as uint); }
unsafe { buf.set_len(n as uint); }
Ok(Path::new(buf))
}
}

4
src/libstd/os.rs
View file

@ -369,7 +369,7 @@ pub fn self_exe_path() -> Option<Path> {
});
if err != 0 { return None; }
if sz == 0 { return None; }
vec::raw::set_len(&mut v, sz as uint - 1); // chop off trailing NUL
v.set_len(sz as uint - 1); // chop off trailing NUL
Some(v)
}
}
@ -398,7 +398,7 @@ pub fn self_exe_path() -> Option<Path> {
_NSGetExecutablePath(buf as *mut i8, &mut sz)
});
if err != 0 { return None; }
vec::raw::set_len(&mut v, sz as uint - 1); // chop off trailing NUL
v.set_len(sz as uint - 1); // chop off trailing NUL
Some(v)
}
}

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

@ -24,7 +24,7 @@ impl StackSegment {
unsafe {
// Crate a block of uninitialized values
let mut stack = vec::with_capacity(size);
vec::raw::set_len(&mut stack, size);
stack.set_len(size);
let mut stk = StackSegment {
buf: stack,

38
src/libstd/str.rs
View file

@ -993,7 +993,7 @@ pub mod raw {
use cast;
use libc;
use ptr;
use str::is_utf8;
use str::{is_utf8, OwnedStr};
use vec;
use vec::MutableVector;
use unstable::raw::Slice;
@ -1002,7 +1002,7 @@ pub mod raw {
pub unsafe fn from_buf_len(buf: *u8, len: uint) -> ~str {
let mut v: ~[u8] = vec::with_capacity(len);
v.as_mut_buf(|vbuf, _len| ptr::copy_memory(vbuf, buf as *u8, len));
vec::raw::set_len(&mut v, len);
v.set_len(len);
assert!(is_utf8(v));
::cast::transmute(v)
@ -1109,7 +1109,7 @@ pub mod raw {
let len = s.len();
assert!((len > 0u));
let b = s[len - 1u];
set_len(s, len - 1u);
s.set_len(len - 1);
return b;
}
@ -1130,16 +1130,6 @@ pub mod raw {
cast::transmute(s)
}
/// Sets the length of a string
///
/// This will explicitly set the size of the string, without actually
/// modifying its buffers, so it is up to the caller to ensure that
/// the string is actually the specified size.
#[inline]
pub unsafe fn set_len(s: &mut ~str, new_len: uint) {
vec::raw::set_len(as_owned_vec(s), new_len)
}
/// Sets the length of a string
///
/// This will explicitly set the size of the string, without actually
@ -1339,7 +1329,7 @@ impl Mutable for ~str {
#[inline]
fn clear(&mut self) {
unsafe {
raw::set_len(self, 0)
self.set_len(0)
}
}
}
@ -2293,7 +2283,7 @@ impl<'a> StrSlice<'a> for &'a str {
let mut v = vec::with_capacity(len);
v.as_mut_buf(|dst, _| ptr::copy_memory(dst, src, len));
vec::raw::set_len(&mut v, len);
v.set_len(len);
::cast::transmute(v)
}
})
@ -2598,6 +2588,13 @@ pub trait OwnedStr {
/// The caller must make sure any mutations to this buffer keep the string
/// valid UTF-8!
fn as_mut_buf<T>(&mut self, f: |*mut u8, uint| -> T) -> T;
/// Sets the length of a string
///
/// This will explicitly set the size of the string, without actually
/// modifying its buffers, so it is up to the caller to ensure that
/// the string is actually the specified size.
unsafe fn set_len(&mut self, new_len: uint);
}
impl OwnedStr for ~str {
@ -2629,7 +2626,7 @@ impl OwnedStr for ~str {
c.encode_utf8(slc)
})
});
raw::set_len(self, cur_len + used);
self.set_len(cur_len + used);
}
}
@ -2638,7 +2635,7 @@ impl OwnedStr for ~str {
let end = self.len();
assert!(end > 0u);
let CharRange {ch, next} = self.char_range_at_reverse(end);
unsafe { raw::set_len(self, next); }
unsafe { self.set_len(next); }
return ch;
}
@ -2689,7 +2686,7 @@ impl OwnedStr for ~str {
fn truncate(&mut self, len: uint) {
assert!(len <= self.len());
assert!(self.is_char_boundary(len));
unsafe { raw::set_len(self, len); }
unsafe { self.set_len(len); }
}
#[inline]
@ -2703,6 +2700,11 @@ impl OwnedStr for ~str {
raw::as_owned_vec(self).as_mut_buf(f)
}
}
#[inline]
unsafe fn set_len(&mut self, new_len: uint) {
raw::as_owned_vec(self).set_len(new_len)
}
}
impl Clone for ~str {

66
src/libstd/vec.rs
View file

@ -143,7 +143,7 @@ pub fn from_fn<T>(n_elts: uint, op: |uint| -> T) -> ~[T] {
i += 1u;
}
}).finally(|| {
raw::set_len(&mut v, i);
v.set_len(i);
});
v
}
@ -170,7 +170,7 @@ pub fn from_elem<T:Clone>(n_elts: uint, t: T) -> ~[T] {
i += 1u;
}
}).finally(|| {
raw::set_len(&mut v, i);
v.set_len(i);
});
v
}
@ -1440,6 +1440,15 @@ pub trait OwnedVector<T> {
* value
*/
fn grow_fn(&mut self, n: uint, op: |uint| -> T);
/**
* Sets the length of a vector
*
* This will explicitly set the size of the vector, without actually
* modifying its buffers, so it is up to the caller to ensure that
* the vector is actually the specified size.
*/
unsafe fn set_len(&mut self, new_len: uint);
}
impl<T> OwnedVector<T> for ~[T] {
@ -1565,8 +1574,8 @@ impl<T> OwnedVector<T> for ~[T] {
let self_p = vec::raw::to_mut_ptr(*self);
let rhs_p = vec::raw::to_ptr(rhs);
ptr::copy_memory(ptr::mut_offset(self_p, self_len as int), rhs_p, rhs_len);
raw::set_len(self, new_len);
raw::set_len(&mut rhs, 0);
self.set_len(new_len);
rhs.set_len(0);
}
}
@ -1576,7 +1585,7 @@ impl<T> OwnedVector<T> for ~[T] {
ln => {
let valptr = ptr::to_mut_unsafe_ptr(&mut self[ln - 1u]);
unsafe {
raw::set_len(self, ln - 1u);
self.set_len(ln - 1u);
Some(ptr::read_ptr(&*valptr))
}
}
@ -1616,7 +1625,7 @@ impl<T> OwnedVector<T> for ~[T] {
assert!(self.capacity() >= ln);
// Pretend like we have the original length so we can use
// the vector copy_memory to overwrite the hole we just made
raw::set_len(self, ln);
self.set_len(ln);
// Memcopy the head element (the one we want) to the location we just
// popped. For the moment it unsafely exists at both the head and last
@ -1636,7 +1645,7 @@ impl<T> OwnedVector<T> for ~[T] {
}
// Set the new length. Now the vector is back to normal
raw::set_len(self, next_ln);
self.set_len(next_ln);
// Swap out the element we want from the end
let vp = raw::to_mut_ptr(*self);
@ -1692,7 +1701,7 @@ impl<T> OwnedVector<T> for ~[T] {
}
}
});
unsafe { raw::set_len(self, newlen); }
unsafe { self.set_len(newlen); }
}
fn retain(&mut self, f: |t: &T| -> bool) {
@ -1736,6 +1745,16 @@ impl<T> OwnedVector<T> for ~[T] {
i += 1u;
}
}
#[inline]
unsafe fn set_len(&mut self, new_len: uint) {
if owns_managed::<T>() {
let repr: **mut Box<Vec<()>> = cast::transmute(self);
(**repr).data.fill = new_len * mem::nonzero_size_of::<T>();
} else {
let repr: **mut Vec<()> = cast::transmute(self);
(**repr).fill = new_len * mem::nonzero_size_of::<T>();
}
}
}
impl<T> Mutable for ~[T] {
@ -2190,26 +2209,7 @@ pub mod raw {
use mem;
use unstable::intrinsics;
use vec::{with_capacity, ImmutableVector, MutableVector};
use unstable::raw::{Box, Vec, Slice};
use unstable::intrinsics::owns_managed;
/**
* Sets the length of a vector
*
* This will explicitly set the size of the vector, without actually
* modifying its buffers, so it is up to the caller to ensure that
* the vector is actually the specified size.
*/
#[inline]
pub unsafe fn set_len<T>(v: &mut ~[T], new_len: uint) {
if owns_managed::<T>() {
let repr: **mut Box<Vec<()>> = cast::transmute(v);
(**repr).data.fill = new_len * mem::nonzero_size_of::<T>();
} else {
let repr: **mut Vec<()> = cast::transmute(v);
(**repr).fill = new_len * mem::nonzero_size_of::<T>();
}
}
use unstable::raw::Slice;
/**
* Returns an unsafe pointer to the vector's buffer
@ -2287,7 +2287,7 @@ pub mod raw {
#[inline]
pub unsafe fn from_buf_raw<T>(ptr: *T, elts: uint) -> ~[T] {
let mut dst = with_capacity(elts);
set_len(&mut dst, elts);
dst.set_len(elts);
dst.as_mut_buf(|p_dst, _len_dst| ptr::copy_memory(p_dst, ptr, elts));
dst
}
@ -2379,7 +2379,7 @@ pub mod bytes {
ptr::copy_memory(p_dst.offset(len_dst as int), p_src, len_src)
})
});
raw::set_len(dst, old_len + src.len());
dst.set_len(old_len + src.len());
}
}
}
@ -4293,7 +4293,7 @@ mod bench {
unsafe {
let vp = vec::raw::to_mut_ptr(v);
ptr::set_memory(vp, 0, 1024);
vec::raw::set_len(&mut v, 1024);
v.set_len(1024);
}
});
}
@ -4312,7 +4312,7 @@ mod bench {
bh.iter(|| {
let mut v: ~[u8] = vec::with_capacity(1024);
unsafe {
vec::raw::set_len(&mut v, 1024);
v.set_len(1024);
}
for i in range(0, 1024) {
v[i] = 0;
@ -4325,7 +4325,7 @@ mod bench {
bh.iter(|| {
let mut v: ~[u8] = vec::with_capacity(1024);
unsafe {
vec::raw::set_len(&mut v, 1024);
v.set_len(1024);
}
for x in v.mut_iter() {
*x = 0;