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

auto merge of #7430 : huonw/rust/vec-kill, r=thestinger

Browse source
This commit is contained in:
bors 2013-06-27 15:01:58 -07:00
commit 63afb8ccc8
51 changed files with 546 additions and 719 deletions
Download patch file Download diff file Expand all files Collapse all files

2
doc/rust.md
View file

@ -2620,7 +2620,7 @@ assert!(b != "world");
The vector type constructor represents a homogeneous array of values of a given type.
A vector has a fixed size.
(Operations like `vec::push` operate solely on owned vectors.)
(Operations like `vec.push` operate solely on owned vectors.)
A vector type can be annotated with a _definite_ size,
written with a trailing asterisk and integer literal, such as `[int * 10]`.
Such a definite-sized vector type is a first-class type, since its size is known statically.

2
src/compiletest/compiletest.rs
View file

@ -75,7 +75,7 @@ pub fn parse_config(args: ~[~str]) -> config {
];
assert!(!args.is_empty());
let args_ = vec::tail(args);
let args_ = args.tail();
let matches =
&match getopts::getopts(args_, opts) {
Ok(m) => m,

3
src/compiletest/runtest.rs
View file

@ -321,8 +321,7 @@ fn check_error_patterns(props: &TestProps,
if done { return; }
let missing_patterns =
vec::slice(props.error_patterns, next_err_idx,
props.error_patterns.len());
props.error_patterns.slice(next_err_idx, props.error_patterns.len());
if missing_patterns.len() == 1u {
fatal_ProcRes(fmt!("error pattern '%s' not found!",
missing_patterns[0]), ProcRes);

1
src/libextra/arc.rs
View file

@ -517,7 +517,6 @@ mod tests {
use arc::*;
use core::vec;
use core::cell::Cell;
use core::comm;
use core::task;

3
src/libextra/c_vec.rs
View file

@ -159,8 +159,7 @@ mod tests {
assert!(mem as int != 0);
return c_vec_with_dtor(mem as *mut u8, n as uint,
|| unsafe { free(mem) });
c_vec_with_dtor(mem as *mut u8, n as uint, || free(mem))
}
}

79
src/libextra/crypto/sha2.rs
View file

@ -11,7 +11,6 @@
use core::prelude::*;
use core::uint;
use core::vec;
use digest::Digest;
@ -118,7 +117,7 @@ impl Engine512 {
}
while in.len() - i >= 8 {
let w = to_u64(vec::slice(in, i, i + 8));
let w = to_u64(in.slice(i, i + 8));
self.process_word(w);
self.bit_counter.add_bytes(8);
i += 8;
@ -274,43 +273,43 @@ impl Engine512 {
fn result_512(&mut self, out: &mut [u8]) {
self.finish();
from_u64(self.H0, vec::mut_slice(out, 0, 8));
from_u64(self.H1, vec::mut_slice(out, 8, 16));
from_u64(self.H2, vec::mut_slice(out, 16, 24));
from_u64(self.H3, vec::mut_slice(out, 24, 32));
from_u64(self.H4, vec::mut_slice(out, 32, 40));
from_u64(self.H5, vec::mut_slice(out, 40, 48));
from_u64(self.H6, vec::mut_slice(out, 48, 56));
from_u64(self.H7, vec::mut_slice(out, 56, 64));
from_u64(self.H0, out.mut_slice(0, 8));
from_u64(self.H1, out.mut_slice(8, 16));
from_u64(self.H2, out.mut_slice(16, 24));
from_u64(self.H3, out.mut_slice(24, 32));
from_u64(self.H4, out.mut_slice(32, 40));
from_u64(self.H5, out.mut_slice(40, 48));
from_u64(self.H6, out.mut_slice(48, 56));
from_u64(self.H7, out.mut_slice(56, 64));
}
fn result_384(&mut self, out: &mut [u8]) {
self.finish();
from_u64(self.H0, vec::mut_slice(out, 0, 8));
from_u64(self.H1, vec::mut_slice(out, 8, 16));
from_u64(self.H2, vec::mut_slice(out, 16, 24));
from_u64(self.H3, vec::mut_slice(out, 24, 32));
from_u64(self.H4, vec::mut_slice(out, 32, 40));
from_u64(self.H5, vec::mut_slice(out, 40, 48));
from_u64(self.H0, out.mut_slice(0, 8));
from_u64(self.H1, out.mut_slice(8, 16));
from_u64(self.H2, out.mut_slice(16, 24));
from_u64(self.H3, out.mut_slice(24, 32));
from_u64(self.H4, out.mut_slice(32, 40));
from_u64(self.H5, out.mut_slice(40, 48));
}
fn result_256(&mut self, out: &mut [u8]) {
self.finish();
from_u64(self.H0, vec::mut_slice(out, 0, 8));
from_u64(self.H1, vec::mut_slice(out, 8, 16));
from_u64(self.H2, vec::mut_slice(out, 16, 24));
from_u64(self.H3, vec::mut_slice(out, 24, 32));
from_u64(self.H0, out.mut_slice(0, 8));
from_u64(self.H1, out.mut_slice(8, 16));
from_u64(self.H2, out.mut_slice(16, 24));
from_u64(self.H3, out.mut_slice(24, 32));
}
fn result_224(&mut self, out: &mut [u8]) {
self.finish();
from_u64(self.H0, vec::mut_slice(out, 0, 8));
from_u64(self.H1, vec::mut_slice(out, 8, 16));
from_u64(self.H2, vec::mut_slice(out, 16, 24));
from_u32((self.H3 >> 32) as u32, vec::mut_slice(out, 24, 28));
from_u64(self.H0, out.mut_slice(0, 8));
from_u64(self.H1, out.mut_slice(8, 16));
from_u64(self.H2, out.mut_slice(16, 24));
from_u32((self.H3 >> 32) as u32, out.mut_slice(24, 28));
}
}
@ -400,7 +399,7 @@ impl Engine256 {
}
while in.len() - i >= 4 {
let w = to_u32(vec::slice(in, i, i + 4));
let w = to_u32(in.slice(i, i + 4));
self.process_word(w);
self.length_bytes += 4;
i += 4;
@ -556,26 +555,26 @@ impl Engine256 {
fn result_256(&mut self, out: &mut [u8]) {
self.finish();
from_u32(self.H0, vec::mut_slice(out, 0, 4));
from_u32(self.H1, vec::mut_slice(out, 4, 8));
from_u32(self.H2, vec::mut_slice(out, 8, 12));
from_u32(self.H3, vec::mut_slice(out, 12, 16));
from_u32(self.H4, vec::mut_slice(out, 16, 20));
from_u32(self.H5, vec::mut_slice(out, 20, 24));
from_u32(self.H6, vec::mut_slice(out, 24, 28));
from_u32(self.H7, vec::mut_slice(out, 28, 32));
from_u32(self.H0, out.mut_slice(0, 4));
from_u32(self.H1, out.mut_slice(4, 8));
from_u32(self.H2, out.mut_slice(8, 12));
from_u32(self.H3, out.mut_slice(12, 16));
from_u32(self.H4, out.mut_slice(16, 20));
from_u32(self.H5, out.mut_slice(20, 24));
from_u32(self.H6, out.mut_slice(24, 28));
from_u32(self.H7, out.mut_slice(28, 32));
}
fn result_224(&mut self, out: &mut [u8]) {
self.finish();
from_u32(self.H0, vec::mut_slice(out, 0, 4));
from_u32(self.H1, vec::mut_slice(out, 4, 8));
from_u32(self.H2, vec::mut_slice(out, 8, 12));
from_u32(self.H3, vec::mut_slice(out, 12, 16));
from_u32(self.H4, vec::mut_slice(out, 16, 20));
from_u32(self.H5, vec::mut_slice(out, 20, 24));
from_u32(self.H6, vec::mut_slice(out, 24, 28));
from_u32(self.H0, out.mut_slice(0, 4));
from_u32(self.H1, out.mut_slice(4, 8));
from_u32(self.H2, out.mut_slice(8, 12));
from_u32(self.H3, out.mut_slice(12, 16));
from_u32(self.H4, out.mut_slice(16, 20));
from_u32(self.H5, out.mut_slice(20, 24));
from_u32(self.H6, out.mut_slice(24, 28));
}
}

13
src/libextra/deque.rs
View file

@ -137,7 +137,7 @@ impl<T> Deque<T> {
///
/// * n - The number of elements to reserve space for
pub fn reserve(&mut self, n: uint) {
vec::reserve(&mut self.elts, n);
self.elts.reserve(n);
}
/// Reserve capacity for at least `n` elements in the given deque,
@ -151,7 +151,7 @@ impl<T> Deque<T> {
///
/// * n - The number of elements to reserve space for
pub fn reserve_at_least(&mut self, n: uint) {
vec::reserve_at_least(&mut self.elts, n);
self.elts.reserve_at_least(n);
}
/// Front-to-back iterator.
@ -256,7 +256,6 @@ mod tests {
use super::*;
use core::cmp::Eq;
use core::kinds::Copy;
use core::vec::capacity;
use core;
#[test]
@ -442,11 +441,11 @@ mod tests {
let mut d = Deque::new();
d.add_back(0u64);
d.reserve(50);
assert_eq!(capacity(&mut d.elts), 50);
assert_eq!(d.elts.capacity(), 50);
let mut d = Deque::new();
d.add_back(0u32);
d.reserve(50);
assert_eq!(capacity(&mut d.elts), 50);
assert_eq!(d.elts.capacity(), 50);
}
#[test]
@ -454,11 +453,11 @@ mod tests {
let mut d = Deque::new();
d.add_back(0u64);
d.reserve_at_least(50);
assert_eq!(capacity(&mut d.elts), 64);
assert_eq!(d.elts.capacity(), 64);
let mut d = Deque::new();
d.add_back(0u32);
d.reserve_at_least(50);
assert_eq!(capacity(&mut d.elts), 64);
assert_eq!(d.elts.capacity(), 64);
}
#[test]

2
src/libextra/dlist.rs
View file

@ -526,8 +526,6 @@ mod tests {
use super::*;
use core::vec;
#[test]
fn test_dlist_concat() {
let a = from_vec([1,2]);

3
src/libextra/ebml.rs
View file

@ -85,7 +85,6 @@ pub mod reader {
use core::ptr::offset;
use core::str;
use core::unstable::intrinsics::bswap32;
use core::vec;
// ebml reading
@ -248,7 +247,7 @@ pub mod reader {
}
pub fn with_doc_data<T>(d: Doc, f: &fn(x: &[u8]) -> T) -> T {
f(vec::slice(*d.data, d.start, d.end))
f(d.data.slice(d.start, d.end))
}

24
src/libextra/net_tcp.rs
View file

@ -976,9 +976,7 @@ impl io::Writer for TcpSocketBuf {
let socket_data_ptr: *TcpSocketData =
&(*((*(self.data)).sock).socket_data);
let w_result = write_common_impl(socket_data_ptr,
vec::slice(data,
0,
data.len()).to_owned());
data.slice(0, data.len()).to_owned());
if w_result.is_err() {
let err_data = w_result.get_err();
debug!(
@ -1459,33 +1457,23 @@ mod test {
#[test]
fn test_gl_tcp_server_and_client_ipv4() {
unsafe {
impl_gl_tcp_ipv4_server_and_client();
}
impl_gl_tcp_ipv4_server_and_client();
}
#[test]
fn test_gl_tcp_get_peer_addr() {
unsafe {
impl_gl_tcp_ipv4_get_peer_addr();
}
impl_gl_tcp_ipv4_get_peer_addr();
}
#[test]
fn test_gl_tcp_ipv4_client_error_connection_refused() {
unsafe {
impl_gl_tcp_ipv4_client_error_connection_refused();
}
impl_gl_tcp_ipv4_client_error_connection_refused();
}
#[test]
fn test_gl_tcp_server_address_in_use() {
unsafe {
impl_gl_tcp_ipv4_server_address_in_use();
}
impl_gl_tcp_ipv4_server_address_in_use();
}
#[test]
fn test_gl_tcp_server_access_denied() {
unsafe {
impl_gl_tcp_ipv4_server_access_denied();
}
impl_gl_tcp_ipv4_server_access_denied();
}
// Strange failure on Windows. --pcwalton
#[test]

17
src/libextra/num/bigint.rs
View file

@ -298,9 +298,8 @@ impl Mul<BigUint, BigUint> for BigUint {
fn cut_at(a: &BigUint, n: uint) -> (BigUint, BigUint) {
let mid = uint::min(a.data.len(), n);
return (BigUint::from_slice(vec::slice(a.data, mid,
a.data.len())),
BigUint::from_slice(vec::slice(a.data, 0, mid)));
return (BigUint::from_slice(a.data.slice(mid, a.data.len())),
BigUint::from_slice(a.data.slice(0, mid)));
}
@ -413,7 +412,7 @@ impl Integer for BigUint {
return (Zero::zero(), Zero::zero(), copy *a);
}
let an = vec::slice(a.data, a.data.len() - n, a.data.len());
let an = a.data.slice(a.data.len() - n, a.data.len());
let bn = *b.data.last();
let mut d = ~[];
let mut carry = 0;
@ -578,7 +577,7 @@ impl BigUint {
let mut power: BigUint = One::one();
loop {
let start = uint::max(end, unit_len) - unit_len;
match uint::parse_bytes(vec::slice(buf, start, end), radix) {
match uint::parse_bytes(buf.slice(start, end), radix) {
// FIXME(#6102): Assignment operator for BigInt causes ICE
// Some(d) => n += BigUint::from_uint(d) * power,
Some(d) => n = n + BigUint::from_uint(d) * power,
@ -634,7 +633,7 @@ impl BigUint {
if n_unit == 0 { return copy *self; }
if self.data.len() < n_unit { return Zero::zero(); }
return BigUint::from_slice(
vec::slice(self.data, n_unit, self.data.len())
self.data.slice(n_unit, self.data.len())
);
}
@ -1132,7 +1131,7 @@ impl BigInt {
sign = Minus;
start = 1;
}
return BigUint::parse_bytes(vec::slice(buf, start, buf.len()), radix)
return BigUint::parse_bytes(buf.slice(start, buf.len()), radix)
.map_consume(|bu| BigInt::from_biguint(sign, bu));
}
@ -1176,7 +1175,7 @@ mod biguint_tests {
let data = [ &[], &[1], &[2], &[-1], &[0, 1], &[2, 1], &[1, 1, 1] ]
.map(|v| BigUint::from_slice(*v));
for data.iter().enumerate().advance |(i, ni)| {
for vec::slice(data, i, data.len()).iter().enumerate().advance |(j0, nj)| {
for data.slice(i, data.len()).iter().enumerate().advance |(j0, nj)| {
let j = j0 + i;
if i == j {
assert_eq!(ni.cmp(nj), Equal);
@ -1654,7 +1653,7 @@ mod bigint_tests {
nums.push_all_move(vs.map(|s| BigInt::from_slice(Plus, *s)));
for nums.iter().enumerate().advance |(i, ni)| {
for vec::slice(nums, i, nums.len()).iter().enumerate().advance |(j0, nj)| {
for nums.slice(i, nums.len()).iter().enumerate().advance |(j0, nj)| {
let j = i + j0;
if i == j {
assert_eq!(ni.cmp(nj), Equal);

6
src/libextra/priority_queue.rs
View file

@ -52,12 +52,12 @@ impl<T:Ord> PriorityQueue<T> {
}
/// Returns the number of elements the queue can hold without reallocating
pub fn capacity(&self) -> uint { vec::capacity(&self.data) }
pub fn capacity(&self) -> uint { self.data.capacity() }
pub fn reserve(&mut self, n: uint) { vec::reserve(&mut self.data, n) }
pub fn reserve(&mut self, n: uint) { self.data.reserve(n) }
pub fn reserve_at_least(&mut self, n: uint) {
vec::reserve_at_least(&mut self.data, n)
self.data.reserve_at_least(n)
}
/// Pop the greatest item from the queue - fails if empty

24
src/libextra/sort.rs
View file

@ -57,8 +57,8 @@ pub fn merge_sort<T:Copy>(v: &[T], le: Le<T>) -> ~[T] {
a_ix += 1;
} else { rs.push(copy b[b_ix]); b_ix += 1; }
}
rs.push_all(vec::slice(a, a_ix, a_len));
rs.push_all(vec::slice(b, b_ix, b_len));
rs.push_all(a.slice(a_ix, a_len));
rs.push_all(b.slice(b_ix, b_len));
rs
}
}
@ -201,12 +201,12 @@ pub fn tim_sort<T:Copy + Ord>(array: &mut [T]) {
loop {
let run_len: uint = {
// This scope contains the slice `arr` here:
let arr = vec::mut_slice(array, idx, size);
let arr = array.mut_slice(idx, size);
let mut run_len: uint = count_run_ascending(arr);
if run_len < min_run {
let force = if remaining <= min_run {remaining} else {min_run};
let slice = vec::mut_slice(arr, 0, force);
let slice = arr.mut_slice(0, force);
binarysort(slice, run_len);
run_len = force;
}
@ -443,14 +443,14 @@ impl<T:Copy + Ord> MergeState<T> {
}
let k = { // constrain lifetime of slice below
let slice = vec::slice(array, b1, b1+l1);
let slice = array.slice(b1, b1+l1);
gallop_right(&array[b2], slice, 0)
};
b1 += k;
l1 -= k;
if l1 != 0 {
let l2 = { // constrain lifetime of slice below
let slice = vec::slice(array, b2, b2+l2);
let slice = array.slice(b2, b2+l2);
gallop_left(&array[b1+l1-1],slice,l2-1)
};
if l2 > 0 {
@ -526,7 +526,7 @@ impl<T:Copy + Ord> MergeState<T> {
assert!(len1 > 1 && len2 != 0);
count1 = {
let tmp_view = vec::slice(tmp, c1, c1+len1);
let tmp_view = tmp.slice(c1, c1+len1);
gallop_right(&array[c2], tmp_view, 0)
};
if count1 != 0 {
@ -539,7 +539,7 @@ impl<T:Copy + Ord> MergeState<T> {
if len2 == 0 { break_outer = true; break; }
count2 = {
let tmp_view = vec::slice(array, c2, c2+len2);
let tmp_view = array.slice(c2, c2+len2);
gallop_left(&tmp[c1], tmp_view, 0)
};
if count2 != 0 {
@ -638,7 +638,7 @@ impl<T:Copy + Ord> MergeState<T> {
assert!(len2 > 1 && len1 != 0);
{ // constrain scope of tmp_view:
let tmp_view = vec::mut_slice (array, base1, base1+len1);
let tmp_view = array.mut_slice(base1, base1+len1);
count1 = len1 - gallop_right(
&tmp[c2], tmp_view, len1-1);
}
@ -655,7 +655,7 @@ impl<T:Copy + Ord> MergeState<T> {
let count2;
{ // constrain scope of tmp_view
let tmp_view = vec::mut_slice(tmp, 0, len2);
let tmp_view = tmp.mut_slice(0, len2);
count2 = len2 - gallop_left(&array[c1],
tmp_view,
len2-1);
@ -1111,7 +1111,7 @@ mod big_tests {
isSorted(arr);
let mut arr = if n > 4 {
let part = vec::slice(arr, 0, 4);
let part = arr.slice(0, 4);
multiplyVec(part, n)
} else { arr };
tim_sort(arr); // ~sort
@ -1183,7 +1183,7 @@ mod big_tests {
isSorted(arr);
let mut arr = if n > 4 {
let part = vec::slice(arr, 0, 4);
let part = arr.slice(0, 4);
multiplyVec(part, n)
} else { arr };
tim_sort(arr); // ~sort

1
src/libextra/sync.rs
View file

@ -808,7 +808,6 @@ mod tests {
use core::comm;
use core::result;
use core::task;
use core::vec;
/************************************************************************
* Semaphore tests

4
src/libextra/test.rs
View file

@ -139,7 +139,7 @@ type OptRes = Either<TestOpts, ~str>;
// Parses command line arguments into test options
pub fn parse_opts(args: &[~str]) -> OptRes {
let args_ = vec::tail(args);
let args_ = args.tail();
let opts = ~[getopts::optflag("ignored"),
getopts::optflag("test"),
getopts::optflag("bench"),
@ -431,7 +431,7 @@ fn run_tests(opts: &TestOpts,
callback(TeFiltered(filtered_descs));
let (filtered_tests, filtered_benchs) =
do vec::partition(filtered_tests) |e| {
do filtered_tests.partition |e| {
match e.testfn {
StaticTestFn(_) | DynTestFn(_) => true,
StaticBenchFn(_) | DynBenchFn(_) => false

3
src/libextra/treemap.rs
View file

@ -695,7 +695,6 @@ mod test_treemap {
use core::rand::RngUtil;
use core::rand;
use core::vec;
#[test]
fn find_empty() {
@ -848,7 +847,7 @@ mod test_treemap {
for 30.times {
let r = rng.gen_uint_range(0, ctrl.len());
let (key, _) = vec::remove(&mut ctrl, r);
let (key, _) = ctrl.remove(r);
assert!(map.remove(&key));
check_structure(&map);
check_equal(ctrl, &map);

34
src/libextra/uv_global_loop.rs
View file

@ -150,9 +150,7 @@ mod test {
let hl_loop = &get_gl();
do iotask::interact(hl_loop) |_loop_ptr| {
debug!(~"closing timer");
unsafe {
ll::close(timer_ptr, simple_timer_close_cb);
}
ll::close(timer_ptr, simple_timer_close_cb);
debug!(~"about to deref exit_ch_ptr");
debug!(~"after msg sent on deref'd exit_ch");
};
@ -169,24 +167,22 @@ mod test {
let timer_handle = ll::timer_t();
let timer_ptr: *ll::uv_timer_t = &timer_handle;
do iotask::interact(iotask) |loop_ptr| {
unsafe {
debug!(~"user code inside interact loop!!!");
let init_status = ll::timer_init(loop_ptr, timer_ptr);
if(init_status == 0i32) {
ll::set_data_for_uv_handle(
timer_ptr as *libc::c_void,
exit_ch_ptr);
let start_status = ll::timer_start(timer_ptr,
simple_timer_cb,
1u, 0u);
if(start_status != 0i32) {
fail!("failure on ll::timer_start()");
}
}
else {
fail!("failure on ll::timer_init()");
debug!(~"user code inside interact loop!!!");
let init_status = ll::timer_init(loop_ptr, timer_ptr);
if(init_status == 0i32) {
ll::set_data_for_uv_handle(
timer_ptr as *libc::c_void,
exit_ch_ptr);
let start_status = ll::timer_start(timer_ptr,
simple_timer_cb,
1u, 0u);
if(start_status != 0i32) {
fail!("failure on ll::timer_start()");
}
}
else {
fail!("failure on ll::timer_init()");
}
};
exit_po.recv();
debug!(

4
src/libextra/uv_ll.rs
View file

@ -1767,9 +1767,7 @@ mod test {
mod impl64 {
#[test]
fn test_uv_ll_tcp_server_and_request() {
unsafe {
super::super::impl_uv_tcp_server_and_request();
}
super::super::impl_uv_tcp_server_and_request();
}
}
#[cfg(target_arch="x86")]

2
src/librustc/back/rpath.rs
View file

@ -154,7 +154,7 @@ pub fn get_relative_to(abs1: &Path, abs2: &Path) -> Path {
let mut path = ~[];
for uint::range(start_idx, len1 - 1) |_i| { path.push(~".."); };
path.push_all(vec::slice(split2, start_idx, len2 - 1));
path.push_all(split2.slice(start_idx, len2 - 1));
return if !path.is_empty() {
Path("").push_many(path)

7
src/librustc/metadata/decoder.rs
View file

@ -60,7 +60,7 @@ fn lookup_hash(d: ebml::Doc, eq_fn: &fn(x:&[u8]) -> bool, hash: uint) ->
let belt = tag_index_buckets_bucket_elt;
for reader::tagged_docs(tagged_doc.doc, belt) |elt| {
let pos = io::u64_from_be_bytes(*elt.data, elt.start, 4u) as uint;
if eq_fn(vec::slice(*elt.data, elt.start + 4u, elt.end)) {
if eq_fn(elt.data.slice(elt.start + 4u, elt.end)) {
return Some(reader::doc_at(d.data, pos).doc);
}
};
@ -72,7 +72,7 @@ pub type GetCrateDataCb<'self> = &'self fn(ast::crate_num) -> cmd;
pub fn maybe_find_item(item_id: int, items: ebml::Doc) -> Option<ebml::Doc> {
fn eq_item(bytes: &[u8], item_id: int) -> bool {
return io::u64_from_be_bytes(
vec::slice(bytes, 0u, 4u), 0u, 4u) as int
bytes.slice(0u, 4u), 0u, 4u) as int
== item_id;
}
lookup_hash(items,
@ -754,8 +754,7 @@ pub fn get_provided_trait_methods(intr: @ident_interner, cdata: cmd,
if item_method_sort(mth) != 'p' { loop; }
vec::push(&mut result,
@get_method(intr, cdata, did.node, tcx));
result.push(@get_method(intr, cdata, did.node, tcx));
}
return result;

5
src/librustc/metadata/tydecode.rs
View file

@ -20,7 +20,6 @@ use middle::ty;
use core::str;
use core::uint;
use core::vec;
use syntax::abi::AbiSet;
use syntax::abi;
use syntax::ast;
@ -518,8 +517,8 @@ pub fn parse_def_id(buf: &[u8]) -> ast::def_id {
fail!();
}
let crate_part = vec::slice(buf, 0u, colon_idx);
let def_part = vec::slice(buf, colon_idx + 1u, len);
let crate_part = buf.slice(0u, colon_idx);
let def_part = buf.slice(colon_idx + 1u, len);
let crate_num = match uint::parse_bytes(crate_part, 10u) {
Some(cn) => cn as int,

22
src/librustc/middle/dataflow.rs
View file

@ -132,7 +132,7 @@ impl<O:DataFlowOperator> DataFlowContext<O> {
debug!("add_gen(id=%?, bit=%?)", id, bit);
let (start, end) = self.compute_id_range(id);
{
let gens = vec::mut_slice(self.gens, start, end);
let gens = self.gens.mut_slice(start, end);
set_bit(gens, bit);
}
}
@ -143,7 +143,7 @@ impl<O:DataFlowOperator> DataFlowContext<O> {
debug!("add_kill(id=%?, bit=%?)", id, bit);
let (start, end) = self.compute_id_range(id);
{
let kills = vec::mut_slice(self.kills, start, end);
let kills = self.kills.mut_slice(start, end);
set_bit(kills, bit);
}
}
@ -216,7 +216,7 @@ impl<O:DataFlowOperator> DataFlowContext<O> {
return true;
}
let (start, end) = self.compute_id_range_frozen(id);
let on_entry = vec::slice(self.on_entry, start, end);
let on_entry = self.on_entry.slice(start, end);
debug!("each_bit_on_entry_frozen(id=%?, on_entry=%s)",
id, bits_to_str(on_entry));
self.each_bit(on_entry, f)
@ -229,7 +229,7 @@ impl<O:DataFlowOperator> DataFlowContext<O> {
//! Only useful after `propagate()` has been called.
let (start, end) = self.compute_id_range(id);
let on_entry = vec::slice(self.on_entry, start, end);
let on_entry = self.on_entry.slice(start, end);
debug!("each_bit_on_entry(id=%?, on_entry=%s)",
id, bits_to_str(on_entry));
self.each_bit(on_entry, f)
@ -241,7 +241,7 @@ impl<O:DataFlowOperator> DataFlowContext<O> {
//! Iterates through each bit in the gen set for `id`.
let (start, end) = self.compute_id_range(id);
let gens = vec::slice(self.gens, start, end);
let gens = self.gens.slice(start, end);
debug!("each_gen_bit(id=%?, gens=%s)",
id, bits_to_str(gens));
self.each_bit(gens, f)
@ -255,7 +255,7 @@ impl<O:DataFlowOperator> DataFlowContext<O> {
return true;
}
let (start, end) = self.compute_id_range_frozen(id);
let gens = vec::slice(self.gens, start, end);
let gens = self.gens.slice(start, end);
debug!("each_gen_bit(id=%?, gens=%s)",
id, bits_to_str(gens));
self.each_bit(gens, f)
@ -338,17 +338,17 @@ impl<O:DataFlowOperator+Copy+'static> DataFlowContext<O> {
if self.nodeid_to_bitset.contains_key(&id) {
let (start, end) = self.compute_id_range_frozen(id);
let on_entry = vec::slice(self.on_entry, start, end);
let on_entry = self.on_entry.slice(start, end);
let entry_str = bits_to_str(on_entry);
let gens = vec::slice(self.gens, start, end);
let gens = self.gens.slice(start, end);
let gens_str = if gens.iter().any_(|&u| u != 0) {
fmt!(" gen: %s", bits_to_str(gens))
} else {
~""
};
let kills = vec::slice(self.kills, start, end);
let kills = self.kills.slice(start, end);
let kills_str = if kills.iter().any_(|&u| u != 0) {
fmt!(" kill: %s", bits_to_str(kills))
} else {
@ -953,7 +953,7 @@ impl<'self, O:DataFlowOperator> PropagationContext<'self, O> {
id, bits_to_str(pred_bits));
let (start, end) = self.dfcx.compute_id_range(id);
let changed = { // FIXME(#5074) awkward construction
let on_entry = vec::mut_slice(self.dfcx.on_entry, start, end);
let on_entry = self.dfcx.on_entry.mut_slice(start, end);
join_bits(&self.dfcx.oper, pred_bits, on_entry)
};
if changed {
@ -970,7 +970,7 @@ impl<'self, O:DataFlowOperator> PropagationContext<'self, O> {
id, mut_bits_to_str(pred_bits));
let (start, end) = self.dfcx.compute_id_range(id);
let changed = { // FIXME(#5074) awkward construction
let on_entry = vec::mut_slice(self.dfcx.on_entry, start, end);
let on_entry = self.dfcx.on_entry.mut_slice(start, end);
let changed = join_bits(&self.dfcx.oper, reslice(pred_bits), on_entry);
copy_bits(reslice(on_entry), pred_bits);
changed

6
src/librustc/middle/resolve.rs
View file

@ -4862,8 +4862,8 @@ impl Resolver {
while j != 0 {
j -= 1;
for this.value_ribs[j].bindings.each_key |&k| {
vec::push(&mut maybes, this.session.str_of(k));
vec::push(&mut values, uint::max_value);
maybes.push(this.session.str_of(k));
values.push(uint::max_value);
}
}
@ -4882,7 +4882,7 @@ impl Resolver {
values[smallest] <= max_distance &&
name != maybes[smallest] {
Some(vec::swap_remove(&mut maybes, smallest))
Some(maybes.swap_remove(smallest))
} else {
None

14
src/librustc/middle/trans/_match.rs
View file

@ -388,9 +388,9 @@ pub fn expand_nested_bindings<'r>(bcx: block,
match br.pats[col].node {
ast::pat_ident(_, path, Some(inner)) => {
let pats = vec::append(
vec::slice(br.pats, 0u, col).to_owned(),
br.pats.slice(0u, col).to_owned(),
vec::append(~[inner],
vec::slice(br.pats, col + 1u,
br.pats.slice(col + 1u,
br.pats.len())));
let binding_info =
@ -437,8 +437,8 @@ pub fn enter_match<'r>(bcx: block,
Some(sub) => {
let pats =
vec::append(
vec::append(sub, vec::slice(br.pats, 0u, col)),
vec::slice(br.pats, col + 1u, br.pats.len()));
vec::append(sub, br.pats.slice(0u, col)),
br.pats.slice(col + 1u, br.pats.len()));
let this = br.pats[col];
match this.node {
@ -1290,7 +1290,7 @@ pub fn compile_submatch(bcx: block,
match data.arm.guard {
Some(guard_expr) => {
bcx = compile_guard(bcx, guard_expr, m[0].data,
vec::slice(m, 1, m.len()),
m.slice(1, m.len()),
vals, chk);
}
_ => ()
@ -1309,8 +1309,8 @@ pub fn compile_submatch(bcx: block,
}
};
let vals_left = vec::append(vec::slice(vals, 0u, col).to_owned(),
vec::slice(vals, col + 1u, vals.len()));
let vals_left = vec::append(vals.slice(0u, col).to_owned(),
vals.slice(col + 1u, vals.len()));
let ccx = bcx.fcx.ccx;
let mut pat_id = 0;
let mut pat_span = dummy_sp();

2
src/librustc/middle/trans/cabi_x86_64.rs
View file

@ -312,7 +312,7 @@ fn llreg_ty(cls: &[RegClass]) -> Type {
tys.push(Type::i64());
}
SSEFv => {
let vec_len = llvec_len(vec::tailn(cls, i + 1u)) * 2u;
let vec_len = llvec_len(cls.tailn(i + 1u)) * 2u;
let vec_ty = Type::vector(&Type::f32(), vec_len as u64);
tys.push(vec_ty);
i += vec_len;

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

@ -47,7 +47,6 @@ use util::ppaux::Repr;
use middle::trans::type_::Type;
use core::vec;
use syntax::ast;
use syntax::ast_map;
use syntax::visit;
@ -503,7 +502,7 @@ pub fn trans_call_inner(in_cx: block,
do base::with_scope(in_cx, call_info, "call") |cx| {
let ret_in_loop = match args {
ArgExprs(args) => {
args.len() > 0u && match vec::last(args).node {
args.len() > 0u && match args.last().node {
ast::expr_loop_body(@ast::expr {
node: ast::expr_fn_block(_, ref body),
_

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

@ -418,10 +418,9 @@ pub fn revoke_clean(cx: block, val: ValueRef) {
});
for cleanup_pos.iter().advance |i| {
scope_info.cleanups =
vec::append(vec::slice(scope_info.cleanups, 0u, *i).to_owned(),
vec::slice(scope_info.cleanups,
*i + 1u,
scope_info.cleanups.len()));
vec::append(scope_info.cleanups.slice(0u, *i).to_owned(),
scope_info.cleanups.slice(*i + 1u,
scope_info.cleanups.len()));
shrink_scope_clean(scope_info, *i);
}
}

7
src/librustc/middle/trans/meth.rs
View file

@ -492,8 +492,7 @@ pub fn combine_impl_and_methods_tps(bcx: block,
debug!("rcvr_substs=%?", rcvr_substs.map(|t| bcx.ty_to_str(*t)));
let ty_substs
= vec::append(rcvr_substs.to_owned(),
vec::tailn(node_substs,
node_substs.len() - n_m_tps));
node_substs.tailn(node_substs.len() - n_m_tps));
debug!("n_m_tps=%?", n_m_tps);
debug!("node_substs=%?", node_substs.map(|t| bcx.ty_to_str(*t)));
debug!("ty_substs=%?", ty_substs.map(|t| bcx.ty_to_str(*t)));
@ -528,7 +527,7 @@ pub fn combine_impl_and_methods_origins(bcx: block,
} = ty::lookup_item_type(tcx, mth_did);
let n_r_m_tps = r_m_generics.type_param_defs.len(); // rcvr + method tps
let m_type_param_defs =
vec::slice(*r_m_generics.type_param_defs, n_r_m_tps - n_m_tps, n_r_m_tps);
r_m_generics.type_param_defs.slice(n_r_m_tps - n_m_tps, n_r_m_tps);
// Flatten out to find the number of vtables the method expects.
let m_vtables = ty::count_traits_and_supertraits(tcx, m_type_param_defs);
@ -540,7 +539,7 @@ pub fn combine_impl_and_methods_origins(bcx: block,
};
// Extract those that belong to method:
let m_origins = vec::tailn(*r_m_origins, r_m_origins.len() - m_vtables);
let m_origins = r_m_origins.tailn(r_m_origins.len() - m_vtables);
// Combine rcvr + method to find the final result:
@vec::append(/*bad*/copy *rcvr_origins, m_origins)

2
src/librustc/middle/ty.rs
View file

@ -3954,7 +3954,7 @@ pub fn item_path(cx: ctxt, id: ast::def_id) -> ast_map::path {
}
ast_map::node_variant(ref variant, _, path) => {
vec::append_one(vec::to_owned(vec::init(*path)),
vec::append_one(vec::to_owned(path.init()),
ast_map::path_name((*variant).node.name))
}

2
src/librustc/middle/typeck/coherence.rs
View file

@ -788,7 +788,7 @@ impl CoherenceChecker {
`%s` to impl",
provided_method.method_info
.ident.repr(self.crate_context.tcx));
vec::push(all_methods, provided_method.method_info);
all_methods.push(provided_method.method_info);
}
}
}

4
src/librusti/rusti.rs
View file

@ -55,7 +55,7 @@ extern mod extra;
extern mod rustc;
extern mod syntax;
use std::{libc, io, os, task, vec};
use std::{libc, io, os, task};
use std::cell::Cell;
use extra::rl;
@ -430,7 +430,7 @@ pub fn run_line(repl: &mut Repl, in: @io::Reader, out: @io::Writer, line: ~str,
if !cmd.is_empty() {
let args = if len > 1 {
vec::slice(split, 1, len).to_owned()
split.slice(1, len).to_owned()
} else { ~[] };
match run_cmd(repl, in, out, cmd, args, use_rl) {

5
src/librustpkg/package_source.rs
View file

@ -12,7 +12,7 @@ use target::*;
use package_id::PkgId;
use core::path::Path;
use core::option::*;
use core::{os, run, str, vec};
use core::{os, run, str};
use context::*;
use crate::Crate;
use messages::*;
@ -146,8 +146,7 @@ impl PkgSrc {
fn push_crate(cs: &mut ~[Crate], prefix: uint, p: &Path) {
assert!(p.components.len() > prefix);
let mut sub = Path("");
for vec::slice(p.components, prefix,
p.components.len()).iter().advance |c| {
for p.components.slice(prefix, p.components.len()).iter().advance |c| {
sub = sub.push(*c);
}
debug!("found crate %s", sub.to_str());

13
src/libstd/io.rs
View file

@ -65,7 +65,7 @@ use str::StrSlice;
use to_str::ToStr;
use uint;
use vec;
use vec::{ImmutableVector, OwnedVector, OwnedCopyableVector, CopyableVector};
use vec::{MutableVector, ImmutableVector, OwnedVector, OwnedCopyableVector, CopyableVector};
#[allow(non_camel_case_types)] // not sure what to do about this
pub type fd_t = c_int;
@ -698,7 +698,7 @@ impl<T:Reader> ReaderUtil for T {
// over-read by reading 1-byte per char needed
nbread = if ncreq > nbreq { ncreq } else { nbreq };
if nbread > 0 {
bytes = vec::slice(bytes, offset, bytes.len()).to_owned();
bytes = bytes.slice(offset, bytes.len()).to_owned();
}
}
chars
@ -1053,7 +1053,7 @@ impl Reader for BytesReader {
fn read(&self, bytes: &mut [u8], len: uint) -> uint {
let count = uint::min(len, self.bytes.len() - *self.pos);
let view = vec::slice(self.bytes, *self.pos, self.bytes.len());
let view = self.bytes.slice(*self.pos, self.bytes.len());
vec::bytes::copy_memory(bytes, view, count);
*self.pos += count;
@ -1658,12 +1658,12 @@ impl Writer for BytesWriter {
let bytes = &mut *self.bytes;
let count = uint::max(bytes.len(), *self.pos + v_len);
vec::reserve(bytes, count);
bytes.reserve(count);
unsafe {
vec::raw::set_len(bytes, count);
let view = vec::mut_slice(*bytes, *self.pos, count);
let view = bytes.mut_slice(*self.pos, count);
vec::bytes::copy_memory(view, v, v_len);
}
@ -1909,8 +1909,7 @@ mod tests {
if len <= ivals.len() {
assert_eq!(res.len(), len);
}
assert!(vec::slice(ivals, 0u, res.len()) ==
vec::map(res, |x| *x as int));
assert!(ivals.slice(0u, res.len()) == vec::map(res, |x| *x as int));
}
}
let mut i = 0;

1
src/libstd/iterator.rs
View file

@ -1030,7 +1030,6 @@ mod tests {
use super::*;
use prelude::*;
use iter;
use uint;
#[test]

23
src/libstd/local_data.rs
View file

@ -92,14 +92,12 @@ fn test_tls_multitask() {
fn my_key(_x: @~str) { }
local_data_set(my_key, @~"parent data");
do task::spawn {
unsafe {
// TLS shouldn't carry over.
assert!(local_data_get(my_key).is_none());
local_data_set(my_key, @~"child data");
assert!(*(local_data_get(my_key).get()) ==
// TLS shouldn't carry over.
assert!(local_data_get(my_key).is_none());
local_data_set(my_key, @~"child data");
assert!(*(local_data_get(my_key).get()) ==
~"child data");
// should be cleaned up for us
}
// should be cleaned up for us
}
// Must work multiple times
assert!(*(local_data_get(my_key).get()) == ~"parent data");
@ -206,12 +204,11 @@ fn test_tls_cleanup_on_failure() {
local_data_set(str_key, @~"parent data");
local_data_set(box_key, @@());
do task::spawn {
unsafe { // spawn_linked
local_data_set(str_key, @~"string data");
local_data_set(box_key, @@());
local_data_set(int_key, @42);
fail!();
}
// spawn_linked
local_data_set(str_key, @~"string data");
local_data_set(box_key, @@());
local_data_set(int_key, @42);
fail!();
}
// Not quite nondeterministic.
local_data_set(int_key, @31337);

7
src/libstd/os.rs
View file

@ -134,7 +134,7 @@ pub mod win32 {
}
}
if k != 0 && done {
let sub = vec::slice(buf, 0u, k as uint);
let sub = buf.slice(0, k as uint);
res = option::Some(str::from_utf16(sub));
}
}
@ -1140,7 +1140,7 @@ pub fn set_exit_status(code: int) {
unsafe fn load_argc_and_argv(argc: c_int, argv: **c_char) -> ~[~str] {
let mut args = ~[];
for uint::range(0, argc as uint) |i| {
vec::push(&mut args, str::raw::from_c_str(*argv.offset(i)));
args.push(str::raw::from_c_str(*argv.offset(i)));
}
args
}
@ -1186,8 +1186,7 @@ pub fn real_args() -> ~[~str] {
while *ptr.offset(len) != 0 { len += 1; }
// Push it onto the list.
vec::push(&mut args,
vec::raw::buf_as_slice(ptr, len,
args.push(vec::raw::buf_as_slice(ptr, len,
str::from_utf16));
}
}

4
src/libstd/rt/io/extensions.rs
View file

@ -292,13 +292,13 @@ impl<T: Reader> ReaderUtil for T {
let start_len = buf.len();
let mut total_read = 0;
vec::reserve_at_least(buf, start_len + len);
buf.reserve_at_least(start_len + len);
vec::raw::set_len(buf, start_len + len);
do (|| {
while total_read < len {
let len = buf.len();
let slice = vec::mut_slice(*buf, start_len + total_read, len);
let slice = buf.mut_slice(start_len + total_read, len);
match self.read(slice) {
Some(nread) => {
total_read += nread;

2
src/libstd/rt/io/mem.rs
View file

@ -86,7 +86,7 @@ impl Reader for MemReader {
let write_len = min(buf.len(), self.buf.len() - self.pos);
{
let input = self.buf.slice(self.pos, self.pos + write_len);
let output = vec::mut_slice(buf, 0, write_len);
let output = buf.mut_slice(0, write_len);
assert_eq!(input.len(), output.len());
vec::bytes::copy_memory(output, input, write_len);
}

4
src/libstd/rt/uv/timer.rs
View file

@ -160,14 +160,14 @@ mod test {
let mut timer2 = TimerWatcher::new(&mut loop_);
do timer2.start(10, 0) |timer2, _| {
unsafe { *count_ptr += 1; }
*count_ptr += 1;
timer2.close(||());
// Restart the original timer
let mut timer = timer;
do timer.start(1, 0) |timer, _| {
unsafe { *count_ptr += 1; }
*count_ptr += 1;
timer.close(||());
}
}

9
src/libstd/str.rs
View file

@ -2081,7 +2081,7 @@ impl OwnedStr for ~str {
pub fn reserve(&mut self, n: uint) {
unsafe {
let v: *mut ~[u8] = cast::transmute(self);
vec::reserve(&mut *v, n + 1);
(*v).reserve(n + 1);
}
}
@ -2115,8 +2115,8 @@ impl OwnedStr for ~str {
* reallocating
*/
fn capacity(&self) -> uint {
let buf: &const ~[u8] = unsafe { cast::transmute(self) };
let vcap = vec::capacity(buf);
let buf: &~[u8] = unsafe { cast::transmute(self) };
let vcap = buf.capacity();
assert!(vcap > 0u);
vcap - 1u
}
@ -2249,7 +2249,7 @@ mod tests {
assert!("" <= "");
assert!("" <= "foo");
assert!("foo" <= "foo");
assert!("foo" != ~"bar");
assert!("foo" != "bar");
}
#[test]
@ -3156,6 +3156,7 @@ mod tests {
#[test]
fn test_add() {
#[allow(unnecessary_allocation)];
macro_rules! t (
($s1:expr, $s2:expr, $e:expr) => {
assert_eq!($s1 + $s2, $e);

14
src/libstd/task/mod.rs
View file

@ -934,17 +934,15 @@ fn test_spawn_sched_blocking() {
let lock = testrt::rust_dbg_lock_create();
do spawn_sched(SingleThreaded) {
unsafe {
testrt::rust_dbg_lock_lock(lock);
testrt::rust_dbg_lock_lock(lock);
start_ch.send(());
start_ch.send(());
// Block the scheduler thread
testrt::rust_dbg_lock_wait(lock);
testrt::rust_dbg_lock_unlock(lock);
// Block the scheduler thread
testrt::rust_dbg_lock_wait(lock);
testrt::rust_dbg_lock_unlock(lock);
fin_ch.send(());
}
fin_ch.send(());
};
// Wait until the other task has its lock

832
src/libstd/vec.rs
View file

File diff suppressed because it is too large Load diff

3
src/libsyntax/diagnostic.rs
View file

@ -13,7 +13,6 @@ use codemap;
use std::io;
use std::uint;
use std::vec;
use extra::term;
pub type Emitter = @fn(cmsp: Option<(@codemap::CodeMap, span)>,
@ -250,7 +249,7 @@ fn highlight_lines(cm: @codemap::CodeMap,
let mut elided = false;
let mut display_lines = /* FIXME (#2543) */ copy lines.lines;
if display_lines.len() > max_lines {
display_lines = vec::slice(display_lines, 0u, max_lines).to_owned();
display_lines = display_lines.slice(0u, max_lines).to_owned();
elided = true;
}
// Print the offending lines

2
src/test/bench/core-std.rs
View file

@ -29,7 +29,7 @@ macro_rules! bench (
fn main() {
let argv = os::args();
let tests = vec::slice(argv, 1, argv.len());
let tests = argv.slice(1, argv.len());
bench!(shift_push);
bench!(read_line);

2
src/test/bench/shootout-fasta-redux.rs
View file

@ -96,7 +96,7 @@ impl RepeatFasta {
copy_memory(buf, alu, alu_len);
let buf_len = buf.len();
copy_memory(vec::mut_slice(buf, alu_len, buf_len),
copy_memory(buf.mut_slice(alu_len, buf_len),
alu,
LINE_LEN);

6
src/test/bench/shootout-k-nucleotide-pipes.rs
View file

@ -90,7 +90,7 @@ fn find(mm: &HashMap<~[u8], uint>, key: ~str) -> uint {
// given a map, increment the counter for a key
fn update_freq(mm: &mut HashMap<~[u8], uint>, key: &[u8]) {
let key = vec::slice(key, 0, key.len()).to_owned();
let key = key.to_owned();
let newval = match mm.pop(&key) {
Some(v) => v + 1,
None => 1
@ -107,11 +107,11 @@ fn windows_with_carry(bb: &[u8], nn: uint,
let len = bb.len();
while ii < len - (nn - 1u) {
it(vec::slice(bb, ii, ii+nn));
it(bb.slice(ii, ii+nn));
ii += 1u;
}
return vec::slice(bb, len - (nn - 1u), len).to_owned();
return bb.slice(len - (nn - 1u), len).to_owned();
}
fn make_sequence_processor(sz: uint,

10
src/test/bench/shootout-k-nucleotide.rs
View file

@ -8,7 +8,7 @@ use std::libc::{STDIN_FILENO, c_int, fdopen, fgets, fileno, fopen, fstat};
use std::libc::{stat, strlen};
use std::ptr::null;
use std::unstable::intrinsics::init;
use std::vec::{reverse, slice};
use std::vec::{reverse};
use extra::sort::quick_sort3;
static LINE_LEN: uint = 80;
@ -194,7 +194,7 @@ fn unpack_symbol(c: u8) -> u8 {
fn next_char<'a>(mut buf: &'a [u8]) -> &'a [u8] {
loop {
buf = slice(buf, 1, buf.len());
buf = buf.slice(1, buf.len());
if buf.len() == 0 {
break;
}
@ -226,7 +226,7 @@ fn read_stdin() -> ~[u8] {
fgets(transmute(&mut window[0]), LINE_LEN as c_int, stdin);
{
if vec::slice(window, 0, 6) == header {
if window.slice(0, 6) == header {
break;
}
}
@ -235,9 +235,7 @@ fn read_stdin() -> ~[u8] {
while fgets(transmute(&mut window[0]),
LINE_LEN as c_int,
stdin) != null() {
window = vec::mut_slice(window,
strlen(transmute(&window[0])) as uint,
window.len());
window = window.mut_slice(strlen(transmute(&window[0])) as uint, window.len());
}
}

3
src/test/bench/shootout-pfib.rs
View file

@ -32,7 +32,6 @@ use std::str;
use std::task;
use std::u64;
use std::uint;
use std::vec;
fn fib(n: int) -> int {
fn pfib(c: &Chan<int>, n: int) {
@ -62,7 +61,7 @@ struct Config {
fn parse_opts(argv: ~[~str]) -> Config {
let opts = ~[getopts::optflag(~"stress")];
let opt_args = vec::slice(argv, 1, argv.len());
let opt_args = argv.slice(1, argv.len());
match getopts::getopts(opt_args, opts) {
Ok(ref m) => {

7
src/test/bench/shootout-reverse-complement.rs
View file

@ -5,7 +5,6 @@ use std::cast::transmute;
use std::libc::{STDOUT_FILENO, c_int, fdopen, fgets, fopen, fputc, fwrite};
use std::libc::{size_t};
use std::ptr::null;
use std::vec::{capacity, reserve, reserve_at_least};
use std::vec::raw::set_len;
static LINE_LEN: u32 = 80;
@ -103,13 +102,13 @@ fn main() {
let stdout = fdopen(STDOUT_FILENO as c_int, transmute(&mode[0]));
let mut out: ~[u8] = ~[];
reserve(&mut out, 12777888);
out.reserve(12777888);
let mut pos = 0;
loop {
let needed = pos + (LINE_LEN as uint) + 1;
if capacity(&out) < needed {
reserve_at_least(&mut out, needed);
if out.capacity() < needed {
out.reserve_at_least(needed);
}
let mut ptr = out.unsafe_mut_ref(pos);

6
src/test/run-pass/issue-3888-2.rs
View file

@ -8,12 +8,8 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use std::vec;
fn vec_peek<'r, T>(v: &'r [T]) -> &'r [T] {
// This doesn't work, and should.
// v.slice(1, 5)
vec::slice(v, 1, 5)
v.slice(1, 5)
}
pub fn main() {}

4
src/test/run-pass/vec-slice.rs
View file

@ -8,11 +8,9 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use std::vec;
pub fn main() {
let v = ~[1,2,3,4,5];
let v2 = vec::slice(v, 1, 3);
let v2 = v.slice(1, 3);
assert_eq!(v2[0], 2);
assert_eq!(v2[1], 3);
}