rust-lang/rust
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Convert vec::[mut_]slice to methods, remove vec::const_slice.

Browse Source
This commit is contained in:
Huon Wilson
2013-06-27 19:48:50 +10:00
parent f1e09d6f1f
commit d0512b1055
29 changed files with 151 additions and 198 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/compiletest/runtest.rs
View File

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

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

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

3
src/libextra/ebml.rs
View File

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

4
src/libextra/net_tcp.rs
View File

@@ -976,9 +976,7 @@ impl io::Writer for TcpSocketBuf {
let socket_data_ptr: *TcpSocketData = let socket_data_ptr: *TcpSocketData =
&(*((*(self.data)).sock).socket_data); &(*((*(self.data)).sock).socket_data);
let w_result = write_common_impl(socket_data_ptr, let w_result = write_common_impl(socket_data_ptr,
vec::slice(data, data.slice(0, data.len()).to_owned());
0,
data.len()).to_owned());
if w_result.is_err() { if w_result.is_err() {
let err_data = w_result.get_err(); let err_data = w_result.get_err();
debug!( debug!(

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) { fn cut_at(a: &BigUint, n: uint) -> (BigUint, BigUint) {
let mid = uint::min(a.data.len(), n); let mid = uint::min(a.data.len(), n);
return (BigUint::from_slice(vec::slice(a.data, mid, return (BigUint::from_slice(a.data.slice(mid, a.data.len())),
a.data.len())), BigUint::from_slice(a.data.slice(0, mid)));
BigUint::from_slice(vec::slice(a.data, 0, mid)));
} }
@@ -413,7 +412,7 @@ impl Integer for BigUint {
return (Zero::zero(), Zero::zero(), copy *a); 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 bn = *b.data.last();
let mut d = ~[]; let mut d = ~[];
let mut carry = 0; let mut carry = 0;
@@ -578,7 +577,7 @@ impl BigUint {
let mut power: BigUint = One::one(); let mut power: BigUint = One::one();
loop { loop {
let start = uint::max(end, unit_len) - unit_len; 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 // FIXME(#6102): Assignment operator for BigInt causes ICE
// Some(d) => n += BigUint::from_uint(d) * power, // Some(d) => n += BigUint::from_uint(d) * power,
Some(d) => n = 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 n_unit == 0 { return copy *self; }
if self.data.len() < n_unit { return Zero::zero(); } if self.data.len() < n_unit { return Zero::zero(); }
return BigUint::from_slice( 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; sign = Minus;
start = 1; 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)); .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] ] let data = [ &[], &[1], &[2], &[-1], &[0, 1], &[2, 1], &[1, 1, 1] ]
.map(|v| BigUint::from_slice(*v)); .map(|v| BigUint::from_slice(*v));
for data.iter().enumerate().advance |(i, ni)| { 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; let j = j0 + i;
if i == j { if i == j {
assert_eq!(ni.cmp(nj), Equal); 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))); nums.push_all_move(vs.map(|s| BigInt::from_slice(Plus, *s)));
for nums.iter().enumerate().advance |(i, ni)| { 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; let j = i + j0;
if i == j { if i == j {
assert_eq!(ni.cmp(nj), Equal); assert_eq!(ni.cmp(nj), Equal);

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

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 = ~[]; let mut path = ~[];
for uint::range(start_idx, len1 - 1) |_i| { path.push(~".."); }; 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() { return if !path.is_empty() {
Path("").push_many(path) Path("").push_many(path)

4
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; let belt = tag_index_buckets_bucket_elt;
for reader::tagged_docs(tagged_doc.doc, belt) |elt| { for reader::tagged_docs(tagged_doc.doc, belt) |elt| {
let pos = io::u64_from_be_bytes(*elt.data, elt.start, 4u) as uint; 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); 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> { pub fn maybe_find_item(item_id: int, items: ebml::Doc) -> Option<ebml::Doc> {
fn eq_item(bytes: &[u8], item_id: int) -> bool { fn eq_item(bytes: &[u8], item_id: int) -> bool {
return io::u64_from_be_bytes( 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; == item_id;
} }
lookup_hash(items, lookup_hash(items,

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

@@ -20,7 +20,6 @@ use middle::ty;
use core::str; use core::str;
use core::uint; use core::uint;
use core::vec;
use syntax::abi::AbiSet; use syntax::abi::AbiSet;
use syntax::abi; use syntax::abi;
use syntax::ast; use syntax::ast;
@@ -519,8 +518,8 @@ pub fn parse_def_id(buf: &[u8]) -> ast::def_id {
fail!(); fail!();
} }
let crate_part = vec::slice(buf, 0u, colon_idx); let crate_part = buf.slice(0u, colon_idx);
let def_part = vec::slice(buf, colon_idx + 1u, len); let def_part = buf.slice(colon_idx + 1u, len);
let crate_num = match uint::parse_bytes(crate_part, 10u) { let crate_num = match uint::parse_bytes(crate_part, 10u) {
Some(cn) => cn as int, 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); debug!("add_gen(id=%?, bit=%?)", id, bit);
let (start, end) = self.compute_id_range(id); 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); set_bit(gens, bit);
} }
} }
@@ -143,7 +143,7 @@ impl<O:DataFlowOperator> DataFlowContext<O> {
debug!("add_kill(id=%?, bit=%?)", id, bit); debug!("add_kill(id=%?, bit=%?)", id, bit);
let (start, end) = self.compute_id_range(id); 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); set_bit(kills, bit);
} }
} }
@@ -216,7 +216,7 @@ impl<O:DataFlowOperator> DataFlowContext<O> {
return true; return true;
} }
let (start, end) = self.compute_id_range_frozen(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);
debug!("each_bit_on_entry_frozen(id=%?, on_entry=%s)", debug!("each_bit_on_entry_frozen(id=%?, on_entry=%s)",
id, bits_to_str(on_entry)); id, bits_to_str(on_entry));
self.each_bit(on_entry, f) self.each_bit(on_entry, f)
@@ -229,7 +229,7 @@ impl<O:DataFlowOperator> DataFlowContext<O> {
//! Only useful after `propagate()` has been called. //! Only useful after `propagate()` has been called.
let (start, end) = self.compute_id_range(id); 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)", debug!("each_bit_on_entry(id=%?, on_entry=%s)",
id, bits_to_str(on_entry)); id, bits_to_str(on_entry));
self.each_bit(on_entry, f) 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`. //! Iterates through each bit in the gen set for `id`.
let (start, end) = self.compute_id_range(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)", debug!("each_gen_bit(id=%?, gens=%s)",
id, bits_to_str(gens)); id, bits_to_str(gens));
self.each_bit(gens, f) self.each_bit(gens, f)
@@ -255,7 +255,7 @@ impl<O:DataFlowOperator> DataFlowContext<O> {
return true; return true;
} }
let (start, end) = self.compute_id_range_frozen(id); 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)", debug!("each_gen_bit(id=%?, gens=%s)",
id, bits_to_str(gens)); id, bits_to_str(gens));
self.each_bit(gens, f) self.each_bit(gens, f)
@@ -338,17 +338,17 @@ impl<O:DataFlowOperator+Copy+'static> DataFlowContext<O> {
if self.nodeid_to_bitset.contains_key(&id) { if self.nodeid_to_bitset.contains_key(&id) {
let (start, end) = self.compute_id_range_frozen(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 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) { let gens_str = if gens.iter().any_(|&u| u != 0) {
fmt!(" gen: %s", bits_to_str(gens)) fmt!(" gen: %s", bits_to_str(gens))
} else { } 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) { let kills_str = if kills.iter().any_(|&u| u != 0) {
fmt!(" kill: %s", bits_to_str(kills)) fmt!(" kill: %s", bits_to_str(kills))
} else { } else {
@@ -953,7 +953,7 @@ impl<'self, O:DataFlowOperator> PropagationContext<'self, O> {
id, bits_to_str(pred_bits)); id, bits_to_str(pred_bits));
let (start, end) = self.dfcx.compute_id_range(id); let (start, end) = self.dfcx.compute_id_range(id);
let changed = { // FIXME(#5074) awkward construction 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) join_bits(&self.dfcx.oper, pred_bits, on_entry)
}; };
if changed { if changed {
@@ -970,7 +970,7 @@ impl<'self, O:DataFlowOperator> PropagationContext<'self, O> {
id, mut_bits_to_str(pred_bits)); id, mut_bits_to_str(pred_bits));
let (start, end) = self.dfcx.compute_id_range(id); let (start, end) = self.dfcx.compute_id_range(id);
let changed = { // FIXME(#5074) awkward construction 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); let changed = join_bits(&self.dfcx.oper, reslice(pred_bits), on_entry);
copy_bits(reslice(on_entry), pred_bits); copy_bits(reslice(on_entry), pred_bits);
changed changed

1
src/librustc/middle/kind.rs
View File

@@ -17,7 +17,6 @@ use middle::typeck;
use util::ppaux::{Repr, ty_to_str}; use util::ppaux::{Repr, ty_to_str};
use util::ppaux::UserString; use util::ppaux::UserString;
use core::vec;
use syntax::ast::*; use syntax::ast::*;
use syntax::attr::attrs_contains_name; use syntax::attr::attrs_contains_name;
use syntax::codemap::span; use syntax::codemap::span;

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

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

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

2
src/librustc/middle/trans/meth.rs
View File

@@ -528,7 +528,7 @@ pub fn combine_impl_and_methods_origins(bcx: block,
} = ty::lookup_item_type(tcx, mth_did); } = ty::lookup_item_type(tcx, mth_did);
let n_r_m_tps = r_m_generics.type_param_defs.len(); // rcvr + method tps let n_r_m_tps = r_m_generics.type_param_defs.len(); // rcvr + method tps
let m_type_param_defs = 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. // Flatten out to find the number of vtables the method expects.
let m_vtables = ty::count_traits_and_supertraits(tcx, m_type_param_defs); let m_vtables = ty::count_traits_and_supertraits(tcx, m_type_param_defs);

4
src/librusti/rusti.rs
View File

@@ -55,7 +55,7 @@ extern mod extra;
extern mod rustc; extern mod rustc;
extern mod syntax; extern mod syntax;
use std::{libc, io, os, task, vec}; use std::{libc, io, os, task};
use std::cell::Cell; use std::cell::Cell;
use extra::rl; 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() { if !cmd.is_empty() {
let args = if len > 1 { let args = if len > 1 {
vec::slice(split, 1, len).to_owned() split.slice(1, len).to_owned()
} else { ~[] }; } else { ~[] };
match run_cmd(repl, in, out, cmd, args, use_rl) { 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 package_id::PkgId;
use core::path::Path; use core::path::Path;
use core::option::*; use core::option::*;
use core::{os, run, str, vec}; use core::{os, run, str};
use context::*; use context::*;
use crate::Crate; use crate::Crate;
use messages::*; use messages::*;
@@ -146,8 +146,7 @@ impl PkgSrc {
fn push_crate(cs: &mut ~[Crate], prefix: uint, p: &Path) { fn push_crate(cs: &mut ~[Crate], prefix: uint, p: &Path) {
assert!(p.components.len() > prefix); assert!(p.components.len() > prefix);
let mut sub = Path(""); let mut sub = Path("");
for vec::slice(p.components, prefix, for p.components.slice(prefix, p.components.len()).iter().advance |c| {
p.components.len()).iter().advance |c| {
sub = sub.push(*c); sub = sub.push(*c);
} }
debug!("found crate %s", sub.to_str()); debug!("found crate %s", sub.to_str());

11
src/libstd/io.rs
View File

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

2
src/libstd/os.rs
View File

@@ -134,7 +134,7 @@ pub mod win32 {
} }
} }
if k != 0 && done { 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)); res = option::Some(str::from_utf16(sub));
} }
} }

2
src/libstd/rt/io/extensions.rs
View File

@@ -298,7 +298,7 @@ impl<T: Reader> ReaderUtil for T {
do (|| { do (|| {
while total_read < len { while total_read < len {
let len = buf.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) { match self.read(slice) {
Some(nread) => { Some(nread) => {
total_read += 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 write_len = min(buf.len(), self.buf.len() - self.pos);
{ {
let input = self.buf.slice(self.pos, self.pos + write_len); 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()); assert_eq!(input.len(), output.len());
vec::bytes::copy_memory(output, input, write_len); vec::bytes::copy_memory(output, input, write_len);
} }

100
src/libstd/vec.rs
View File

@@ -251,17 +251,17 @@ pub fn head_opt<'r,T>(v: &'r [T]) -> Option<&'r T> {
} }
/// Returns a vector containing all but the first element of a slice /// Returns a vector containing all but the first element of a slice
pub fn tail<'r,T>(v: &'r [T]) -> &'r [T] { slice(v, 1, v.len()) } pub fn tail<'r,T>(v: &'r [T]) -> &'r [T] { v.slice(1, v.len()) }
/// Returns a vector containing all but the first `n` elements of a slice /// Returns a vector containing all but the first `n` elements of a slice
pub fn tailn<'r,T>(v: &'r [T], n: uint) -> &'r [T] { slice(v, n, v.len()) } pub fn tailn<'r,T>(v: &'r [T], n: uint) -> &'r [T] { v.slice(n, v.len()) }
/// Returns a vector containing all but the last element of a slice /// Returns a vector containing all but the last element of a slice
pub fn init<'r,T>(v: &'r [T]) -> &'r [T] { slice(v, 0, v.len() - 1) } pub fn init<'r,T>(v: &'r [T]) -> &'r [T] { v.slice(0, v.len() - 1) }
/// Returns a vector containing all but the last `n' elements of a slice /// Returns a vector containing all but the last `n' elements of a slice
pub fn initn<'r,T>(v: &'r [T], n: uint) -> &'r [T] { pub fn initn<'r,T>(v: &'r [T], n: uint) -> &'r [T] {
slice(v, 0, v.len() - n) v.slice(0, v.len() - n)
} }
/// Returns the last element of the slice `v`, failing if the slice is empty. /// Returns the last element of the slice `v`, failing if the slice is empty.
@@ -276,47 +276,6 @@ pub fn last_opt<'r,T>(v: &'r [T]) -> Option<&'r T> {
if v.len() == 0 { None } else { Some(&v[v.len() - 1]) } if v.len() == 0 { None } else { Some(&v[v.len() - 1]) }
} }
/// Return a slice that points into another slice.
#[inline]
pub fn slice<'r,T>(v: &'r [T], start: uint, end: uint) -> &'r [T] {
assert!(start <= end);
assert!(end <= v.len());
do as_imm_buf(v) |p, _len| {
unsafe {
transmute((ptr::offset(p, start),
(end - start) * sys::nonzero_size_of::<T>()))
}
}
}
/// Return a slice that points into another slice.
#[inline]
pub fn mut_slice<'r,T>(v: &'r mut [T], start: uint, end: uint)
-> &'r mut [T] {
assert!(start <= end);
assert!(end <= v.len());
do as_mut_buf(v) |p, _len| {
unsafe {
transmute((ptr::mut_offset(p, start),
(end - start) * sys::nonzero_size_of::<T>()))
}
}
}
/// Return a slice that points into another slice.
#[inline]
pub fn const_slice<'r,T>(v: &'r const [T], start: uint, end: uint)
-> &'r const [T] {
assert!(start <= end);
assert!(end <= v.len());
do as_const_buf(v) |p, _len| {
unsafe {
transmute((ptr::const_offset(p, start),
(end - start) * sys::nonzero_size_of::<T>()))
}
}
}
/// Copies /// Copies
/// Split the vector `v` by applying each element against the predicate `f`. /// Split the vector `v` by applying each element against the predicate `f`.
@@ -330,12 +289,12 @@ pub fn split<T:Copy>(v: &[T], f: &fn(t: &T) -> bool) -> ~[~[T]] {
match position_between(v, start, ln, f) { match position_between(v, start, ln, f) {
None => break, None => break,
Some(i) => { Some(i) => {
result.push(slice(v, start, i).to_owned()); result.push(v.slice(start, i).to_owned());
start = i + 1u; start = i + 1u;
} }
} }
} }
result.push(slice(v, start, ln).to_owned()); result.push(v.slice(start, ln).to_owned());
result result
} }
@@ -354,14 +313,14 @@ pub fn splitn<T:Copy>(v: &[T], n: uint, f: &fn(t: &T) -> bool) -> ~[~[T]] {
match position_between(v, start, ln, f) { match position_between(v, start, ln, f) {
None => break, None => break,
Some(i) => { Some(i) => {
result.push(slice(v, start, i).to_owned()); result.push(v.slice(start, i).to_owned());
// Make sure to skip the separator. // Make sure to skip the separator.
start = i + 1u; start = i + 1u;
count -= 1u; count -= 1u;
} }
} }
} }
result.push(slice(v, start, ln).to_owned()); result.push(v.slice(start, ln).to_owned());
result result
} }
@@ -379,12 +338,12 @@ pub fn rsplit<T:Copy>(v: &[T], f: &fn(t: &T) -> bool) -> ~[~[T]] {
match rposition_between(v, 0, end, f) { match rposition_between(v, 0, end, f) {
None => break, None => break,
Some(i) => { Some(i) => {
result.push(slice(v, i + 1, end).to_owned()); result.push(v.slice(i + 1, end).to_owned());
end = i; end = i;
} }
} }
} }
result.push(slice(v, 0u, end).to_owned()); result.push(v.slice(0u, end).to_owned());
reverse(result); reverse(result);
result result
} }
@@ -404,14 +363,14 @@ pub fn rsplitn<T:Copy>(v: &[T], n: uint, f: &fn(t: &T) -> bool) -> ~[~[T]] {
match rposition_between(v, 0u, end, f) { match rposition_between(v, 0u, end, f) {
None => break, None => break,
Some(i) => { Some(i) => {
result.push(slice(v, i + 1u, end).to_owned()); result.push(v.slice(i + 1u, end).to_owned());
// Make sure to skip the separator. // Make sure to skip the separator.
end = i; end = i;
count -= 1u; count -= 1u;
} }
} }
} }
result.push(slice(v, 0u, end).to_owned()); result.push(v.slice(0u, end).to_owned());
reverse(result); reverse(result);
result result
} }
@@ -487,15 +446,15 @@ pub fn shift<T>(v: &mut ~[T]) -> T {
// popped. For the moment it unsafely exists at both the head and last // popped. For the moment it unsafely exists at both the head and last
// positions // positions
{ {
let first_slice = slice(*v, 0, 1); let first_slice = v.slice(0, 1);
let last_slice = slice(*v, next_ln, ln); let last_slice = v.slice(next_ln, ln);
raw::copy_memory(transmute(last_slice), first_slice, 1); raw::copy_memory(transmute(last_slice), first_slice, 1);
} }
// Memcopy everything to the left one element // Memcopy everything to the left one element
{ {
let init_slice = slice(*v, 0, next_ln); let init_slice = v.slice(0, next_ln);
let tail_slice = slice(*v, 1, ln); let tail_slice = v.slice(1, ln);
raw::copy_memory(transmute(init_slice), raw::copy_memory(transmute(init_slice),
tail_slice, tail_slice,
next_ln); next_ln);
@@ -1689,7 +1648,14 @@ impl<'self,T> ImmutableVector<'self, T> for &'self [T] {
/// Return a slice that points into another slice. /// Return a slice that points into another slice.
#[inline] #[inline]
fn slice(&self, start: uint, end: uint) -> &'self [T] { fn slice(&self, start: uint, end: uint) -> &'self [T] {
slice(*self, start, end) assert!(start <= end);
assert!(end <= self.len());
do as_imm_buf(*self) |p, _len| {
unsafe {
transmute((ptr::offset(p, start),
(end - start) * sys::nonzero_size_of::<T>()))
}
}
} }
#[inline] #[inline]
@@ -2042,9 +2008,17 @@ pub trait MutableVector<'self, T> {
} }
impl<'self,T> MutableVector<'self, T> for &'self mut [T] { impl<'self,T> MutableVector<'self, T> for &'self mut [T] {
/// Return a slice that points into another slice.
#[inline] #[inline]
fn mut_slice(self, start: uint, end: uint) -> &'self mut [T] { fn mut_slice(self, start: uint, end: uint) -> &'self mut [T] {
mut_slice(self, start, end) assert!(start <= end);
assert!(end <= self.len());
do as_mut_buf(self) |p, _len| {
unsafe {
transmute((ptr::mut_offset(p, start),
(end - start) * sys::nonzero_size_of::<T>()))
}
}
} }
#[inline] #[inline]
@@ -2713,7 +2687,7 @@ mod tests {
fn test_slice() { fn test_slice() {
// Test fixed length vector. // Test fixed length vector.
let vec_fixed = [1, 2, 3, 4]; let vec_fixed = [1, 2, 3, 4];
let v_a = slice(vec_fixed, 1u, vec_fixed.len()).to_owned(); let v_a = vec_fixed.slice(1u, vec_fixed.len()).to_owned();
assert_eq!(v_a.len(), 3u); assert_eq!(v_a.len(), 3u);
assert_eq!(v_a[0], 2); assert_eq!(v_a[0], 2);
assert_eq!(v_a[1], 3); assert_eq!(v_a[1], 3);
@@ -2721,14 +2695,14 @@ mod tests {
// Test on stack. // Test on stack.
let vec_stack = &[1, 2, 3]; let vec_stack = &[1, 2, 3];
let v_b = slice(vec_stack, 1u, 3u).to_owned(); let v_b = vec_stack.slice(1u, 3u).to_owned();
assert_eq!(v_b.len(), 2u); assert_eq!(v_b.len(), 2u);
assert_eq!(v_b[0], 2); assert_eq!(v_b[0], 2);
assert_eq!(v_b[1], 3); assert_eq!(v_b[1], 3);
// Test on managed heap. // Test on managed heap.
let vec_managed = @[1, 2, 3, 4, 5]; let vec_managed = @[1, 2, 3, 4, 5];
let v_c = slice(vec_managed, 0u, 3u).to_owned(); let v_c = vec_managed.slice(0u, 3u).to_owned();
assert_eq!(v_c.len(), 3u); assert_eq!(v_c.len(), 3u);
assert_eq!(v_c[0], 1); assert_eq!(v_c[0], 1);
assert_eq!(v_c[1], 2); assert_eq!(v_c[1], 2);
@@ -2736,7 +2710,7 @@ mod tests {
// Test on exchange heap. // Test on exchange heap.
let vec_unique = ~[1, 2, 3, 4, 5, 6]; let vec_unique = ~[1, 2, 3, 4, 5, 6];
let v_d = slice(vec_unique, 1u, 6u).to_owned(); let v_d = vec_unique.slice(1u, 6u).to_owned();
assert_eq!(v_d.len(), 5u); assert_eq!(v_d.len(), 5u);
assert_eq!(v_d[0], 2); assert_eq!(v_d[0], 2);
assert_eq!(v_d[1], 3); assert_eq!(v_d[1], 3);

3
src/libsyntax/diagnostic.rs
View File

@@ -13,7 +13,6 @@ use codemap;
use std::io; use std::io;
use std::uint; use std::uint;
use std::vec;
use extra::term; use extra::term;
pub type Emitter = @fn(cmsp: Option<(@codemap::CodeMap, span)>, 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 elided = false;
let mut display_lines = /* FIXME (#2543) */ copy lines.lines; let mut display_lines = /* FIXME (#2543) */ copy lines.lines;
if display_lines.len() > max_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; elided = true;
} }
// Print the offending lines // Print the offending lines

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

@@ -29,7 +29,7 @@ macro_rules! bench (
fn main() { fn main() {
let argv = os::args(); let argv = os::args();
let tests = vec::slice(argv, 1, argv.len()); let tests = argv.slice(1, argv.len());
bench!(shift_push); bench!(shift_push);
bench!(read_line); 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); copy_memory(buf, alu, alu_len);
let buf_len = buf.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, alu,
LINE_LEN); 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 // given a map, increment the counter for a key
fn update_freq(mm: &mut HashMap<~[u8], uint>, key: &[u8]) { 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) { let newval = match mm.pop(&key) {
Some(v) => v + 1, Some(v) => v + 1,
None => 1 None => 1
@@ -107,11 +107,11 @@ fn windows_with_carry(bb: &[u8], nn: uint,
let len = bb.len(); let len = bb.len();
while ii < len - (nn - 1u) { while ii < len - (nn - 1u) {
it(vec::slice(bb, ii, ii+nn)); it(bb.slice(ii, ii+nn));
ii += 1u; 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, 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::libc::{stat, strlen};
use std::ptr::null; use std::ptr::null;
use std::unstable::intrinsics::init; use std::unstable::intrinsics::init;
use std::vec::{reverse, slice}; use std::vec::{reverse};
use extra::sort::quick_sort3; use extra::sort::quick_sort3;
static LINE_LEN: uint = 80; 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] { fn next_char<'a>(mut buf: &'a [u8]) -> &'a [u8] {
loop { loop {
buf = slice(buf, 1, buf.len()); buf = buf.slice(1, buf.len());
if buf.len() == 0 { if buf.len() == 0 {
break; break;
} }
@@ -226,7 +226,7 @@ fn read_stdin() -> ~[u8] {
fgets(transmute(&mut window[0]), LINE_LEN as c_int, stdin); 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; break;
} }
} }
@@ -235,9 +235,7 @@ fn read_stdin() -> ~[u8] {
while fgets(transmute(&mut window[0]), while fgets(transmute(&mut window[0]),
LINE_LEN as c_int, LINE_LEN as c_int,
stdin) != null() { stdin) != null() {
window = vec::mut_slice(window, window = window.mut_slice(strlen(transmute(&window[0])) as uint, window.len());
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::task;
use std::u64; use std::u64;
use std::uint; use std::uint;
use std::vec;
fn fib(n: int) -> int { fn fib(n: int) -> int {
fn pfib(c: &Chan<int>, n: int) { fn pfib(c: &Chan<int>, n: int) {
@@ -62,7 +61,7 @@ struct Config {
fn parse_opts(argv: ~[~str]) -> Config { fn parse_opts(argv: ~[~str]) -> Config {
let opts = ~[getopts::optflag(~"stress")]; 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) { match getopts::getopts(opt_args, opts) {
Ok(ref m) => { Ok(ref m) => {

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 // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
use std::vec;
fn vec_peek<'r, T>(v: &'r [T]) -> &'r [T] { fn vec_peek<'r, T>(v: &'r [T]) -> &'r [T] {
// This doesn't work, and should. v.slice(1, 5)
// v.slice(1, 5)
vec::slice(v, 1, 5)
} }
pub fn main() {} 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 // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
use std::vec;
pub fn main() { pub fn main() {
let v = ~[1,2,3,4,5]; 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[0], 2);
assert_eq!(v2[1], 3); assert_eq!(v2[1], 3);
} }