mikros/rust
1
0
Fork 0
Code Issues Pull Requests 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
Show Stats 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; }
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);

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));
}
}

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))
}

4
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!(

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);

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

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)

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;
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,

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;
@ -519,8 +518,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

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::UserString;
use core::vec;
use syntax::ast::*;
use syntax::attr::attrs_contains_name;
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 {
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();

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| {
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);
}
}

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);
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);

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());

11
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;
@ -1663,7 +1663,7 @@ impl Writer for BytesWriter {
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;

2
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));
}
}

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

@ -298,7 +298,7 @@ impl<T: Reader> ReaderUtil for T {
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);
}

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
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
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
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
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.
@ -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]) }
}
/// 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
/// 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) {
None => break,
Some(i) => {
result.push(slice(v, start, i).to_owned());
result.push(v.slice(start, i).to_owned());
start = i + 1u;
}
}
}
result.push(slice(v, start, ln).to_owned());
result.push(v.slice(start, ln).to_owned());
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) {
None => break,
Some(i) => {
result.push(slice(v, start, i).to_owned());
result.push(v.slice(start, i).to_owned());
// Make sure to skip the separator.
start = i + 1u;
count -= 1u;
}
}
}
result.push(slice(v, start, ln).to_owned());
result.push(v.slice(start, ln).to_owned());
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) {
None => break,
Some(i) => {
result.push(slice(v, i + 1, end).to_owned());
result.push(v.slice(i + 1, end).to_owned());
end = i;
}
}
}
result.push(slice(v, 0u, end).to_owned());
result.push(v.slice(0u, end).to_owned());
reverse(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) {
None => break,
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.
end = i;
count -= 1u;
}
}
}
result.push(slice(v, 0u, end).to_owned());
result.push(v.slice(0u, end).to_owned());
reverse(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
// positions
{
let first_slice = slice(*v, 0, 1);
let last_slice = slice(*v, next_ln, ln);
let first_slice = v.slice(0, 1);
let last_slice = v.slice(next_ln, ln);
raw::copy_memory(transmute(last_slice), first_slice, 1);
}
// Memcopy everything to the left one element
{
let init_slice = slice(*v, 0, next_ln);
let tail_slice = slice(*v, 1, ln);
let init_slice = v.slice(0, next_ln);
let tail_slice = v.slice(1, ln);
raw::copy_memory(transmute(init_slice),
tail_slice,
next_ln);
@ -1689,7 +1648,14 @@ impl<'self,T> ImmutableVector<'self, T> for &'self [T] {
/// Return a slice that points into another slice.
#[inline]
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]
@ -2042,9 +2008,17 @@ pub trait MutableVector<'self, T> {
}
impl<'self,T> MutableVector<'self, T> for &'self mut [T] {
/// Return a slice that points into another slice.
#[inline]
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]
@ -2713,7 +2687,7 @@ mod tests {
fn test_slice() {
// Test fixed length vector.
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[0], 2);
assert_eq!(v_a[1], 3);
@ -2721,14 +2695,14 @@ mod tests {
// Test on stack.
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[0], 2);
assert_eq!(v_b[1], 3);
// Test on managed heap.
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[0], 1);
assert_eq!(v_c[1], 2);
@ -2736,7 +2710,7 @@ mod tests {
// Test on exchange heap.
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[0], 2);
assert_eq!(v_d[1], 3);

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) => {

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);
}