let keycolon = format!("{}:", directive);
match line.find_str(keycolon.as_slice()) {
Some(colon) => {
- let value = line.slice(colon + keycolon.len(),
- line.len()).to_string();
+ let value = line[(colon + keycolon.len()) .. line.len()].to_string();
debug!("{}: {}", directive, value);
Some(value)
}
break;
}
Some(i) => {
- rest = rest.slice_from(i + frag.len());
+ rest = &rest[(i + frag.len())..];
}
}
first = false;
if *idx >= haystack.len() {
return false;
}
- let opt = haystack.slice_from(*idx).find(needle);
+ let opt = haystack[(*idx)..].find(needle);
if opt.is_none() {
return false;
}
Thread::spawn(move || {
let mut array = number.lock().unwrap();
- (*array)[i] += 1;
+ array[i as usize] += 1;
- println!("numbers[{}] is {}", i, (*array)[i]);
+ println!("numbers[{}] is {}", i, array[i as usize]);
});
}
}
use core::borrow::BorrowFrom;
use core::cmp::Ordering::{Greater, Less, Equal};
use core::iter::Zip;
-use core::ops::{Deref, DerefMut};
+use core::ops::{Deref, DerefMut, Index, IndexMut};
use core::ptr::Unique;
use core::{slice, mem, ptr, cmp, num, raw};
use alloc::heap;
macro_rules! node_slice_impl {
($NodeSlice:ident, $Traversal:ident,
- $as_slices_internal:ident, $slice_from:ident, $slice_to:ident, $iter:ident) => {
+ $as_slices_internal:ident, $index:ident, $iter:ident) => {
impl<'a, K: Ord + 'a, V: 'a> $NodeSlice<'a, K, V> {
/// Performs linear search in a slice. Returns a tuple of (index, is_exact_match).
fn search_linear<Q: ?Sized>(&self, key: &Q) -> (uint, bool)
edges: if !self.has_edges {
self.edges
} else {
- self.edges.$slice_from(pos)
+ self.edges.$index(&(pos ..))
},
- keys: self.keys.slice_from(pos),
- vals: self.vals.$slice_from(pos),
+ keys: &self.keys[pos ..],
+ vals: self.vals.$index(&(pos ..)),
head_is_edge: !pos_is_kv,
tail_is_edge: self.tail_is_edge,
}
edges: if !self.has_edges {
self.edges
} else {
- self.edges.$slice_to(pos + 1)
+ self.edges.$index(&(.. (pos + 1)))
},
- keys: self.keys.slice_to(pos),
- vals: self.vals.$slice_to(pos),
+ keys: &self.keys[..pos],
+ vals: self.vals.$index(&(.. pos)),
head_is_edge: self.head_is_edge,
tail_is_edge: !pos_is_kv,
}
}
}
-node_slice_impl!(NodeSlice, Traversal, as_slices_internal, slice_from, slice_to, iter);
-node_slice_impl!(MutNodeSlice, MutTraversal, as_slices_internal_mut, slice_from_mut,
- slice_to_mut, iter_mut);
+node_slice_impl!(NodeSlice, Traversal, as_slices_internal, index, iter);
+node_slice_impl!(MutNodeSlice, MutTraversal, as_slices_internal_mut, index_mut, iter_mut);
if contiguous {
let (empty, buf) = buf.split_at_mut(0);
- (buf.slice_mut(tail, head), empty)
+ (&mut buf[tail .. head], empty)
} else {
let (mid, right) = buf.split_at_mut(tail);
let (left, _) = mid.split_at_mut(head);
#[inline]
fn move_from(&mut self, mut src: Vec<T>, start: uint, end: uint) -> uint {
- for (a, b) in self.iter_mut().zip(src.slice_mut(start, end).iter_mut()) {
+ for (a, b) in self.iter_mut().zip(src[start .. end].iter_mut()) {
mem::swap(a, b);
}
cmp::min(self.len(), end-start)
/// Deprecated: use `s[a .. b]` instead.
#[deprecated = "use slice notation [a..b] instead"]
- fn slice(&self, begin: uint, end: uint) -> &str {
- core_str::StrExt::slice(&self[], begin, end)
- }
+ fn slice(&self, begin: uint, end: uint) -> &str;
/// Deprecated: use `s[a..]` instead.
#[deprecated = "use slice notation [a..] instead"]
- fn slice_from(&self, begin: uint) -> &str {
- core_str::StrExt::slice_from(&self[], begin)
- }
+ fn slice_from(&self, begin: uint) -> &str;
/// Deprecated: use `s[..a]` instead.
#[deprecated = "use slice notation [..a] instead"]
- fn slice_to(&self, end: uint) -> &str {
- core_str::StrExt::slice_to(&self[], end)
- }
+ fn slice_to(&self, end: uint) -> &str;
/// Returns a slice of the string from the character range
/// [`begin`..`end`).
}
#[stable]
-impl StrExt for str {}
+impl StrExt for str {
+ fn slice(&self, begin: uint, end: uint) -> &str {
+ &self[begin..end]
+ }
+
+ fn slice_from(&self, begin: uint) -> &str {
+ &self[begin..]
+ }
+
+ fn slice_to(&self, end: uint) -> &str {
+ &self[..end]
+ }
+}
#[cfg(test)]
mod tests {
_ => ()
}
- buf.slice_to_mut(end).reverse();
+ buf[..end].reverse();
// Remember start of the fractional digits.
// Points one beyond end of buf if none get generated,
impl<'a> fmt::Writer for Filler<'a> {
fn write_str(&mut self, s: &str) -> fmt::Result {
- slice::bytes::copy_memory(self.buf.slice_from_mut(*self.end),
+ slice::bytes::copy_memory(&mut self.buf[(*self.end)..],
s.as_bytes());
*self.end += s.len();
Ok(())
// reset state
self.init(&[0u32; KEY_WORDS]);
// set key in place
- let key = self.state.slice_mut(4, 4+KEY_WORDS);
+ let key = &mut self.state[4 .. 4+KEY_WORDS];
for (k, s) in key.iter_mut().zip(seed.iter()) {
*k = *s;
}
}
}
}
-
// Do the necessary writes
if left.len() > 0 {
- slice::bytes::copy_memory(self.buf.slice_from_mut(self.pos), left);
+ slice::bytes::copy_memory(&mut self.buf[self.pos..], left);
}
if right.len() > 0 {
self.buf.push_all(right);
pub fn at(&self, i: uint) -> Option<&'t str> {
match self.pos(i) {
None => None,
- Some((s, e)) => Some(self.text.slice(s, e))
+ Some((s, e)) => Some(&self.text[s.. e])
}
}
((slice[2] as u32) << 8) |
((slice[3] as u32) << 0)) as uint;
if len + 4 <= slice.len() {
- slice.slice(4, len + 4)
+ &slice[4.. len + 4]
} else {
&[] // corrupt or old metadata
}
};
let (hash, rlib) = if file.starts_with(&rlib_prefix[]) &&
file.ends_with(".rlib") {
- (file.slice(rlib_prefix.len(), file.len() - ".rlib".len()),
+ (&file[(rlib_prefix.len()) .. (file.len() - ".rlib".len())],
true)
} else if file.starts_with(dylib_prefix.as_slice()) &&
file.ends_with(dypair.1.as_slice()) {
- (file.slice(dylib_prefix.len(), file.len() - dypair.1.len()),
+ (&file[(dylib_prefix.len()) .. (file.len() - dypair.1.len())],
false)
} else {
return FileDoesntMatch
}
ast::ExprMethodCall(_, _, ref args) => {
- self.call(expr, pred, &*args[0], args.slice_from(1).iter().map(|e| &**e))
+ self.call(expr, pred, &*args[0], args[1..].iter().map(|e| &**e))
}
ast::ExprIndex(ref l, ref r) |
assert!(self.bits_per_id > 0);
let cfgidx = to_cfgidx_or_die(id, &self.nodeid_to_index);
let (start, end) = self.compute_id_range(cfgidx);
- let on_entry = self.on_entry.slice(start, end);
+ let on_entry = &self.on_entry[start.. end];
let entry_str = bits_to_string(on_entry);
- let gens = self.gens.slice(start, end);
+ let gens = &self.gens[start.. end];
let gens_str = if gens.iter().any(|&u| u != 0) {
format!(" gen: {}", bits_to_string(gens))
} else {
"".to_string()
};
- let kills = self.kills.slice(start, end);
+ let kills = &self.kills[start .. end];
let kills_str = if kills.iter().any(|&u| u != 0) {
format!(" kill: {}", bits_to_string(kills))
} else {
let cfgidx = to_cfgidx_or_die(id, &self.nodeid_to_index);
let (start, end) = self.compute_id_range(cfgidx);
- let gens = self.gens.slice_mut(start, end);
+ let gens = &mut self.gens[start.. end];
set_bit(gens, bit);
}
let cfgidx = to_cfgidx_or_die(id, &self.nodeid_to_index);
let (start, end) = self.compute_id_range(cfgidx);
- let kills = self.kills.slice_mut(start, end);
+ let kills = &mut self.kills[start.. end];
set_bit(kills, bit);
}
assert!(self.bits_per_id > 0);
let (start, end) = self.compute_id_range(cfgidx);
- let gens = self.gens.slice(start, end);
+ let gens = &self.gens[start.. end];
bitwise(bits, gens, &Union);
- let kills = self.kills.slice(start, end);
+ let kills = &self.kills[start.. end];
bitwise(bits, kills, &Subtract);
debug!("{} apply_gen_kill(cfgidx={:?}, bits={}) [after]",
}
let (start, end) = self.compute_id_range(cfgidx);
- let on_entry = self.on_entry.slice(start, end);
+ let on_entry = &self.on_entry[start.. end];
let temp_bits;
let slice = match e {
Entry => on_entry,
let cfgidx = to_cfgidx_or_die(id, &self.nodeid_to_index);
let (start, end) = self.compute_id_range(cfgidx);
- let gens = self.gens.slice(start, end);
+ let gens = &self.gens[start.. end];
debug!("{} each_gen_bit(id={}, gens={})",
self.analysis_name, id, bits_to_string(gens));
self.each_bit(gens, f)
cfg.graph.each_edge(|_edge_index, edge| {
let flow_exit = edge.source();
let (start, end) = self.compute_id_range(flow_exit);
- let mut orig_kills = self.kills.slice(start, end).to_vec();
+ let mut orig_kills = self.kills[start.. end].to_vec();
let mut changed = false;
for &node_id in edge.data.exiting_scopes.iter() {
match opt_cfg_idx {
Some(cfg_idx) => {
let (start, end) = self.compute_id_range(cfg_idx);
- let kills = self.kills.slice(start, end);
+ let kills = &self.kills[start.. end];
if bitwise(orig_kills.as_mut_slice(), kills, &Union) {
changed = true;
}
}
if changed {
- let bits = self.kills.slice_mut(start, end);
+ let bits = &mut self.kills[start.. end];
debug!("{} add_kills_from_flow_exits flow_exit={:?} bits={} [before]",
self.analysis_name, flow_exit, mut_bits_to_string(bits));
bits.clone_from_slice(&orig_kills[]);
let (start, end) = self.dfcx.compute_id_range(node_index);
// Initialize local bitvector with state on-entry.
- in_out.clone_from_slice(self.dfcx.on_entry.slice(start, end));
+ in_out.clone_from_slice(&self.dfcx.on_entry[start.. end]);
// Compute state on-exit by applying transfer function to
// state on-entry.
let (start, end) = self.dfcx.compute_id_range(cfgidx);
let changed = {
// (scoping mutable borrow of self.dfcx.on_entry)
- let on_entry = self.dfcx.on_entry.slice_mut(start, end);
+ let on_entry = &mut self.dfcx.on_entry[start.. end];
bitwise(on_entry, pred_bits, &self.dfcx.oper)
};
if changed {
debug!("{} changed entry set for {:?} to {}",
self.dfcx.analysis_name, cfgidx,
- bits_to_string(self.dfcx.on_entry.slice(start, end)));
+ bits_to_string(&self.dfcx.on_entry[start.. end]));
self.changed = true;
}
}
pub fn vars_created_since_snapshot(&self, mark: &RegionSnapshot)
-> Vec<RegionVid>
{
- self.undo_log.borrow()
- .slice_from(mark.length)
+ self.undo_log.borrow()[mark.length..]
.iter()
.filter_map(|&elt| match elt {
AddVar(vid) => Some(vid),
debug!("result_index={}, r={:?}", result_index, r);
for undo_entry in
- self.undo_log.borrow().slice_from(mark.length).iter()
+ self.undo_log.borrow()[mark.length..].iter()
{
match undo_entry {
&AddConstraint(ConstrainVarSubVar(a, b)) => {
pub fn get_slice<'a>(&'a self, space: ParamSpace) -> &'a [T] {
let (start, limit) = self.limits(space);
- self.content.slice(start, limit)
+ &self.content[start.. limit]
}
pub fn get_mut_slice<'a>(&'a mut self, space: ParamSpace) -> &'a mut [T] {
let (start, limit) = self.limits(space);
- self.content.slice_mut(start, limit)
+ &mut self.content[start.. limit]
}
pub fn opt_get<'a>(&'a self,
pub fn add_path(&mut self, path: &str) {
let (kind, path) = if path.starts_with("native=") {
- (PathKind::Native, path.slice_from("native=".len()))
+ (PathKind::Native, &path["native=".len()..])
} else if path.starts_with("crate=") {
- (PathKind::Crate, path.slice_from("crate=".len()))
+ (PathKind::Crate, &path["crate=".len()..])
} else if path.starts_with("dependency=") {
- (PathKind::Dependency, path.slice_from("dependency=".len()))
+ (PathKind::Dependency, &path["dependency=".len()..])
} else if path.starts_with("all=") {
- (PathKind::All, path.slice_from("all=".len()))
+ (PathKind::All, &path["all=".len()..])
} else {
(PathKind::All, path)
};
for (i, &x) in new_loan_indices.iter().enumerate() {
let old_loan = &self.all_loans[x];
- for &y in new_loan_indices.slice_from(i+1).iter() {
+ for &y in new_loan_indices[(i+1) ..].iter() {
let new_loan = &self.all_loans[y];
self.report_error_if_loans_conflict(old_loan, new_loan);
}
fn truncated_hash_result(symbol_hasher: &mut Sha256) -> String {
let output = symbol_hasher.result_bytes();
// 64 bits should be enough to avoid collisions.
- output.slice_to(8).to_hex().to_string()
+ output[.. 8].to_hex().to_string()
}
return;
}
- let sub_paths = sub_paths.slice(0, len-1);
+ let sub_paths = &sub_paths[.. (len-1)];
for &(ref span, ref qualname) in sub_paths.iter() {
self.fmt.sub_mod_ref_str(path.span,
*span,
if len <= 1 {
return;
}
- let sub_paths = sub_paths.slice_to(len-1);
+ let sub_paths = &sub_paths[.. (len-1)];
// write the trait part of the sub-path
let (ref span, ref qualname) = sub_paths[len-2];
let prefix: &[u8] = &[dotdot[0], ::std::path::SEP_BYTE];
let mut path_bytes = p.as_vec().to_vec();
- if path_bytes.slice_to(2) != prefix &&
- path_bytes.slice_to(2) != dotdot {
+ if &path_bytes[..2] != prefix &&
+ &path_bytes[..2] != dotdot {
path_bytes.insert(0, prefix[0]);
path_bytes.insert(1, prefix[1]);
}
!ccx.sess().target.target.options.is_like_windows &&
ccx.sess().opts.debuginfo != NoDebugInfo
}
-
ty::ty_bare_fn(_, ref f) if f.abi == Rust || f.abi == RustCall => {
let fake_sig =
ty::Binder(ty::FnSig {
- inputs: f.sig.0.inputs.slice_from(1).to_vec(),
+ inputs: f.sig.0.inputs[1..].to_vec(),
output: f.sig.0.output,
variadic: f.sig.0.variadic,
});
}
_ => {
// skip the self parameter:
- sig.inputs.slice_from(1)
+ &sig.inputs[1..]
}
};
// HACK(eddyb) replace the fake self type in the AST with the actual type.
let input_params = if self_ty.is_some() {
- decl.inputs.slice_from(1)
+ &decl.inputs[1..]
} else {
&decl.inputs[]
};
let lifetimes_for_params = if implied_output_region.is_none() {
let input_tys = if self_ty.is_some() {
// Skip the first argument if `self` is present.
- self_and_input_tys.slice_from(1)
+ &self_and_input_tys[1..]
} else {
- self_and_input_tys.slice_from(0)
+ &self_and_input_tys[]
};
let (ior, lfp) = find_implied_output_region(input_tys, input_pats);
// of derived region bounds. If so, use that. Otherwise, report an
// error.
let r = derived_region_bounds[0];
- if derived_region_bounds.slice_from(1).iter().any(|r1| r != *r1) {
+ if derived_region_bounds[1..].iter().any(|r1| r != *r1) {
tcx.sess.span_err(
span,
&format!("ambiguous lifetime bound, \
ast::ExprMethodCall(_, _, ref args) => {
constrain_call(rcx, expr, Some(&*args[0]),
- args.slice_from(1).iter().map(|e| &**e), false);
+ args[1..].iter().map(|e| &**e), false);
visit::walk_expr(rcx, expr);
}
continue;
}
- for &impl2_def_id in trait_impls.slice_from(i+1).iter() {
+ for &impl2_def_id in trait_impls[(i+1)..].iter() {
self.check_if_impls_overlap(trait_def_id,
impl1_def_id,
impl2_def_id);
for (i, ch) in s.bytes().enumerate() {
match ch as char {
'<' | '>' | '&' | '\'' | '"' => {
- try!(fmt.write_str(pile_o_bits.slice(last, i)));
+ try!(fmt.write_str(&pile_o_bits[last.. i]));
let s = match ch as char {
'>' => ">",
'<' => "<",
}
if last < s.len() {
- try!(fmt.write_str(pile_o_bits.slice_from(last)));
+ try!(fmt.write_str(&pile_o_bits[last..]));
}
Ok(())
}
fn stripped_filtered_line<'a>(s: &'a str) -> Option<&'a str> {
let trimmed = s.trim();
if trimmed.starts_with("# ") {
- Some(trimmed.slice_from(2))
+ Some(&trimmed[2..])
} else {
None
}
// Remove the utf-8 BOM if any
let contents = if contents.starts_with("\u{feff}") {
- contents.slice_from(3)
+ &contents[3..]
} else {
contents
};
fn shorter<'a>(s: Option<&'a str>) -> &'a str {
match s {
Some(s) => match s.find_str("\n\n") {
- Some(pos) => s.slice_to(pos),
+ Some(pos) => &s[..pos],
None => s,
},
None => ""
for line in s.lines() {
if line.starts_with("%") {
// remove %<whitespace>
- metadata.push(line.slice_from(1).trim_left())
+ metadata.push(line[1..].trim_left())
} else {
let line_start_byte = s.subslice_offset(line);
- return (metadata, s.slice_from(line_start_byte));
+ return (metadata, &s[line_start_byte..]);
}
}
// if we're here, then all lines were metadata % lines.
line.to_string()
} else {
assert!(line.len() >= min_indent);
- line.slice_from(min_indent).to_string()
+ line[min_indent..].to_string()
}
}).collect::<Vec<_>>().as_slice());
unindented.connect("\n")
type Target = [libc::c_char];
fn deref(&self) -> &[libc::c_char] {
- self.inner.slice_to(self.inner.len() - 1)
+ &self.inner[..(self.inner.len() - 1)]
}
}
if buf.len() > self.buf.len() {
self.inner.as_mut().unwrap().write(buf)
} else {
- let dst = self.buf.slice_from_mut(self.pos);
+ let dst = &mut self.buf[self.pos..];
slice::bytes::copy_memory(dst, buf);
self.pos += buf.len();
Ok(())
if self.closed {
Err(io::standard_error(io::EndOfFile))
} else {
- Ok(self.buf.slice_from(self.pos))
+ Ok(&self.buf[self.pos..])
}
}
loop {
let count = match self.fill_buf().ok() {
Some(src) => {
- let dst = buf.slice_from_mut(num_read);
+ let dst = &mut buf[num_read..];
let count = cmp::min(src.len(), dst.len());
bytes::copy_memory(dst, &src[..count]);
count
let write_len = min(buf.len(), self.buf.len() - self.pos);
{
let input = &self.buf[self.pos.. (self.pos + write_len)];
- let output = buf.slice_to_mut(write_len);
+ let output = &mut buf[.. write_len];
assert_eq!(input.len(), output.len());
slice::bytes::copy_memory(output, input);
}
let write_len = min(buf.len(), self.len());
{
let input = &self[..write_len];
- let output = buf.slice_to_mut(write_len);
+ let output = &mut buf[.. write_len];
slice::bytes::copy_memory(output, input);
}
- *self = self.slice_from(write_len);
+ *self = &self[write_len..];
Ok(write_len)
}
impl<'a> Writer for BufWriter<'a> {
#[inline]
fn write(&mut self, src: &[u8]) -> IoResult<()> {
- let dst = self.buf.slice_from_mut(self.pos);
+ let dst = &mut self.buf[self.pos..];
let dst_len = dst.len();
if dst_len == 0 {
let write_len = min(buf.len(), self.buf.len() - self.pos);
{
let input = &self.buf[self.pos.. (self.pos + write_len)];
- let output = buf.slice_to_mut(write_len);
+ let output = &mut buf[.. write_len];
assert_eq!(input.len(), output.len());
slice::bytes::copy_memory(output, input);
}
while read < min {
let mut zeroes = 0;
loop {
- match self.read(buf.slice_from_mut(read)) {
+ match self.read(&mut buf[read..]) {
Ok(0) => {
zeroes += 1;
if zeroes >= NO_PROGRESS_LIMIT {
{
let mut start = 1;
while start < width {
- match try!(self.read(buf.slice_mut(start, width))) {
+ match try!(self.read(&mut buf[start .. width])) {
n if n == width - start => break,
n if n < width - start => { start += n; }
_ => return Err(standard_error(InvalidInput)),
assert!(head.len() + tail.len() <= 8);
let mut gs = [0u16; 8];
gs.clone_from_slice(head);
- gs.slice_mut(8 - tail.len(), 8).clone_from_slice(tail);
+ gs[(8 - tail.len()) .. 8].clone_from_slice(tail);
Ipv6Addr(gs[0], gs[1], gs[2], gs[3], gs[4], gs[5], gs[6], gs[7])
}
}
let len = cmp::min(self.limit, buf.len());
- let res = self.inner.read(buf.slice_to_mut(len));
+ let res = self.inner.read(&mut buf[..len]);
match res {
Ok(len) => self.limit -= len,
_ => {}
// only resize buf if we actually remove digits
if i < buf_max_i {
- buf = buf.slice(0, i + 1).to_vec();
+ buf = buf[.. (i + 1)].to_vec();
}
}
} // If exact and trailing '.', just cut that
else {
let max_i = buf.len() - 1;
if buf[max_i] == b'.' {
- buf = buf.slice(0, max_i).to_vec();
+ buf = buf[.. max_i].to_vec();
}
}
let mut read = 0;
let len = v.len();
while read < len {
- let result = getrandom(v.slice_from_mut(read));
+ let result = getrandom(&mut v[read..]);
if result == -1 {
let err = errno() as libc::c_int;
if err == libc::EINTR {
}
impl<'a> fmt::Writer for BufWriter<'a> {
fn write_str(&mut self, bytes: &str) -> fmt::Result {
- let left = self.buf.slice_from_mut(self.pos);
+ let left = &mut self.buf[self.pos..];
let to_write = &bytes.as_bytes()[..cmp::min(bytes.len(), left.len())];
slice::bytes::copy_memory(left, to_write);
self.pos += to_write.len();
let mut valid = true;
let mut inner = s;
if s.len() > 4 && s.starts_with("_ZN") && s.ends_with("E") {
- inner = s.slice(3, s.len() - 1);
+ inner = &s[3 .. s.len() - 1];
// On Windows, dbghelp strips leading underscores, so we accept "ZN...E" form too.
} else if s.len() > 3 && s.starts_with("ZN") && s.ends_with("E") {
- inner = s.slice(2, s.len() - 1);
+ inner = &s[2 .. s.len() - 1];
} else {
valid = false;
}
}
let mut rest = inner;
while rest.char_at(0).is_numeric() {
- rest = rest.slice_from(1);
+ rest = &rest[1..];
}
- let i: uint = inner.slice_to(inner.len() - rest.len()).parse().unwrap();
- inner = rest.slice_from(i);
- rest = rest.slice_to(i);
+ let i: uint = inner[.. (inner.len() - rest.len())].parse().unwrap();
+ inner = &rest[i..];
+ rest = &rest[..i];
while rest.len() > 0 {
if rest.starts_with("$") {
macro_rules! demangle {
None => rest.len(),
Some(i) => i,
};
- try!(writer.write_str(rest.slice_to(idx)));
- rest = rest.slice_from(idx);
+ try!(writer.write_str(&rest[..idx]));
+ rest = &rest[idx..];
}
}
}
let mut bytes = [0; 8];
return match input.read(&mut bytes) {
Ok(8) => {
- assert!(combine(CLOEXEC_MSG_FOOTER) == combine(bytes.slice(4, 8)),
+ assert!(combine(CLOEXEC_MSG_FOOTER) == combine(&bytes[4.. 8]),
"Validation on the CLOEXEC pipe failed: {:?}", bytes);
- let errno = combine(bytes.slice(0, 4));
+ let errno = combine(&bytes[0.. 4]);
assert!(p.wait(0).is_ok(), "wait(0) should either return Ok or panic");
Err(super::decode_error(errno))
}
});
let ret = match ret {
Some(ref s) if s.starts_with(r"\\?\") => { // "
- Ok(Path::new(s.slice_from(4)))
+ Ok(Path::new(&s[4..]))
}
Some(s) => Ok(Path::new(s)),
None => Err(super::last_error()),
done = true;
}
if k != 0 && done {
- let sub = buf.slice(0, k as uint);
+ let sub = &buf[.. (k as uint)];
// We want to explicitly catch the case when the
// closure returned invalid UTF-16, rather than
// set `res` to None and continue.
fn with_str_from_to<T, F>(&self, start: BytePos, end: BytePos, f: F) -> T where
F: FnOnce(&str) -> T,
{
- f(self.filemap.src.slice(
- self.byte_offset(start).to_uint(),
- self.byte_offset(end).to_uint()))
+ f(&self.filemap.src[
+ self.byte_offset(start).to_uint()..
+ self.byte_offset(end).to_uint()])
}
/// Converts CRLF to LF in the given string, raising an error on bare CR.
Some(i) => {
let mut err = String::from_str("circular modules: ");
let len = included_mod_stack.len();
- for p in included_mod_stack.slice(i, len).iter() {
+ for p in included_mod_stack[i.. len].iter() {
err.push_str(&p.display().as_cow()[]);
err.push_str(" -> ");
}
ident: ast::SpannedIdent,
tys: &[P<ast::Ty>],
args: &[P<ast::Expr>]) -> IoResult<()> {
- let base_args = args.slice_from(1);
+ let base_args = &args[1..];
try!(self.print_expr(&*args[0]));
try!(word(&mut self.s, "."));
try!(self.print_ident(ident.node));
let args = if first {
&decl.inputs[]
} else {
- decl.inputs.slice_from(1)
+ &decl.inputs[1..]
};
for arg in args.iter() {
Some(cat)
};
- let retstr = self.string.slice_to(idx);
- self.string = self.string.slice_from(idx);
+ let retstr = &self.string[..idx];
+ self.string = &self.string[idx..];
Some(retstr)
}
}
Some(cat)
};
- let retstr = self.string.slice_from(idx);
- self.string = self.string.slice_to(idx);
+ let retstr = &self.string[idx..];
+ self.string = &self.string[..idx];
Some(retstr)
}
}
projects / rust.git / commitdiff