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

core: Use the new for protocol

Browse source
This commit is contained in:
Alex Crichton 2013-05-02 18:33:18 -04:00
parent 0cde8ba684
commit 28256052a4
19 changed files with 1497 additions and 176 deletions
Download patch file Download diff file Expand all files Collapse all files

32
src/libcore/cleanup.rs
View file

@ -127,6 +127,7 @@ struct AnnihilateStats {
n_bytes_freed: uint
}
#[cfg(stage0)]
unsafe fn each_live_alloc(read_next_before: bool,
f: &fn(box: *mut BoxRepr, uniq: bool) -> bool) {
//! Walks the internal list of allocations
@ -141,8 +142,8 @@ unsafe fn each_live_alloc(read_next_before: bool,
let uniq =
(*box).header.ref_count == managed::raw::RC_MANAGED_UNIQUE;
if ! f(box, uniq) {
break
if !f(box, uniq) {
return;
}
if read_next_before {
@ -152,6 +153,33 @@ unsafe fn each_live_alloc(read_next_before: bool,
}
}
}
#[cfg(not(stage0))]
unsafe fn each_live_alloc(read_next_before: bool,
f: &fn(box: *mut BoxRepr, uniq: bool) -> bool) -> bool {
//! Walks the internal list of allocations
use managed;
let task: *Task = transmute(rustrt::rust_get_task());
let box = (*task).boxed_region.live_allocs;
let mut box: *mut BoxRepr = transmute(copy box);
while box != mut_null() {
let next_before = transmute(copy (*box).header.next);
let uniq =
(*box).header.ref_count == managed::raw::RC_MANAGED_UNIQUE;
if !f(box, uniq) {
return false;
}
if read_next_before {
box = next_before;
} else {
box = transmute(copy (*box).header.next);
}
}
return true;
}
#[cfg(unix)]
fn debug_mem() -> bool {

53
src/libcore/container.rs
View file

@ -30,16 +30,32 @@ pub trait Map<K, V>: Mutable {
fn contains_key(&self, key: &K) -> bool;
// Visits all keys and values
#[cfg(stage0)]
fn each<'a>(&'a self, f: &fn(&K, &'a V) -> bool);
// Visits all keys and values
#[cfg(not(stage0))]
fn each<'a>(&'a self, f: &fn(&K, &'a V) -> bool) -> bool;
/// Visit all keys
#[cfg(stage0)]
fn each_key(&self, f: &fn(&K) -> bool);
/// Visit all keys
#[cfg(not(stage0))]
fn each_key(&self, f: &fn(&K) -> bool) -> bool;
/// Visit all values
#[cfg(stage0)]
fn each_value<'a>(&'a self, f: &fn(&'a V) -> bool);
/// Visit all values
#[cfg(not(stage0))]
fn each_value<'a>(&'a self, f: &fn(&'a V) -> bool) -> bool;
/// Iterate over the map and mutate the contained values
#[cfg(stage0)]
fn mutate_values(&mut self, f: &fn(&K, &mut V) -> bool);
/// Iterate over the map and mutate the contained values
#[cfg(not(stage0))]
fn mutate_values(&mut self, f: &fn(&K, &mut V) -> bool) -> bool;
/// Return a reference to the value corresponding to the key
fn find<'a>(&'a self, key: &K) -> Option<&'a V>;
@ -65,6 +81,7 @@ pub trait Map<K, V>: Mutable {
fn pop(&mut self, k: &K) -> Option<V>;
}
#[cfg(stage0)]
pub trait Set<T>: Mutable {
/// Return true if the set contains a value
fn contains(&self, value: &T) -> bool;
@ -99,3 +116,39 @@ pub trait Set<T>: Mutable {
/// Visit the values representing the union
fn union(&self, other: &Self, f: &fn(&T) -> bool);
}
#[cfg(not(stage0))]
pub trait Set<T>: Mutable {
/// Return true if the set contains a value
fn contains(&self, value: &T) -> bool;
/// Add a value to the set. Return true if the value was not already
/// present in the set.
fn insert(&mut self, value: T) -> bool;
/// Remove a value from the set. Return true if the value was
/// present in the set.
fn remove(&mut self, value: &T) -> bool;
/// Return true if the set has no elements in common with `other`.
/// This is equivalent to checking for an empty intersection.
fn is_disjoint(&self, other: &Self) -> bool;
/// Return true if the set is a subset of another
fn is_subset(&self, other: &Self) -> bool;
/// Return true if the set is a superset of another
fn is_superset(&self, other: &Self) -> bool;
/// Visit the values representing the difference
fn difference(&self, other: &Self, f: &fn(&T) -> bool) -> bool;
/// Visit the values representing the symmetric difference
fn symmetric_difference(&self, other: &Self, f: &fn(&T) -> bool) -> bool;
/// Visit the values representing the intersection
fn intersection(&self, other: &Self, f: &fn(&T) -> bool) -> bool;
/// Visit the values representing the union
fn union(&self, other: &Self, f: &fn(&T) -> bool) -> bool;
}

31
src/libcore/gc.rs
View file

@ -129,7 +129,7 @@ type Visitor<'self> = &'self fn(root: **Word, tydesc: *Word) -> bool;
// Walks the list of roots for the given safe point, and calls visitor
// on each root.
unsafe fn walk_safe_point(fp: *Word, sp: SafePoint, visitor: Visitor) {
unsafe fn _walk_safe_point(fp: *Word, sp: SafePoint, visitor: Visitor) -> bool {
let fp_bytes: *u8 = cast::transmute(fp);
let sp_meta: *u32 = cast::transmute(sp.sp_meta);
@ -155,7 +155,7 @@ unsafe fn walk_safe_point(fp: *Word, sp: SafePoint, visitor: Visitor) {
} else {
ptr::null()
};
if !visitor(root, tydesc) { return; }
if !visitor(root, tydesc) { return false; }
}
sri += 1;
}
@ -168,6 +168,16 @@ unsafe fn walk_safe_point(fp: *Word, sp: SafePoint, visitor: Visitor) {
}
rri += 1;
}
return true;
}
#[cfg(stage0)]
unsafe fn walk_safe_point(fp: *Word, sp: SafePoint, visitor: Visitor) {
_walk_safe_point(fp, sp, visitor);
}
#[cfg(not(stage0))]
unsafe fn walk_safe_point(fp: *Word, sp: SafePoint, visitor: Visitor) -> bool {
_walk_safe_point(fp, sp, visitor)
}
// Is fp contained in segment?
@ -222,7 +232,7 @@ static need_cleanup: Memory = exchange_heap | stack;
// Walks stack, searching for roots of the requested type, and passes
// each root to the visitor.
unsafe fn walk_gc_roots(mem: Memory, sentinel: **Word, visitor: Visitor) {
unsafe fn _walk_gc_roots(mem: Memory, sentinel: **Word, visitor: Visitor) -> bool {
let mut segment = rustrt::rust_get_stack_segment();
let mut last_ret: *Word = ptr::null();
// To avoid collecting memory used by the GC itself, skip stack
@ -274,14 +284,14 @@ unsafe fn walk_gc_roots(mem: Memory, sentinel: **Word, visitor: Visitor) {
// Root is a generic box.
let refcount = **root;
if mem | task_local_heap != 0 && refcount != -1 {
if !visitor(root, tydesc) { return; }
if !visitor(root, tydesc) { return false; }
} else if mem | exchange_heap != 0 && refcount == -1 {
if !visitor(root, tydesc) { return; }
if !visitor(root, tydesc) { return false; }
}
} else {
// Root is a non-immediate.
if mem | stack != 0 {
if !visitor(root, tydesc) { return; }
if !visitor(root, tydesc) { return false; }
}
}
}
@ -290,8 +300,17 @@ unsafe fn walk_gc_roots(mem: Memory, sentinel: **Word, visitor: Visitor) {
}
reached_sentinel = delay_reached_sentinel;
}
return true;
}
#[cfg(stage0)]
unsafe fn walk_gc_roots(mem: Memory, sentinel: **Word, visitor: Visitor) {
_walk_gc_roots(mem, sentinel, visitor);
}
#[cfg(not(stage0))]
unsafe fn walk_gc_roots(mem: Memory, sentinel: **Word, visitor: Visitor) -> bool {
_walk_gc_roots(mem, sentinel, visitor)
}
pub fn gc() {
unsafe {
// Abort when GC is disabled.

110
src/libcore/hashmap.rs
View file

@ -88,18 +88,32 @@ priv impl<K:Hash + Eq,V> HashMap<K, V> {
}
#[inline(always)]
#[cfg(stage0)]
fn bucket_sequence(&self, hash: uint,
op: &fn(uint) -> bool) -> uint {
op: &fn(uint) -> bool) {
let start_idx = self.to_bucket(hash);
let len_buckets = self.buckets.len();
let mut idx = start_idx;
loop {
if !op(idx) {
return idx;
}
if !op(idx) { return; }
idx = self.next_bucket(idx, len_buckets);
if idx == start_idx {
return start_idx;
return;
}
}
}
#[inline(always)]
#[cfg(not(stage0))]
fn bucket_sequence(&self, hash: uint,
op: &fn(uint) -> bool) -> bool {
let start_idx = self.to_bucket(hash);
let len_buckets = self.buckets.len();
let mut idx = start_idx;
loop {
if !op(idx) { return false; }
idx = self.next_bucket(idx, len_buckets);
if idx == start_idx {
return true;
}
}
}
@ -122,14 +136,14 @@ priv impl<K:Hash + Eq,V> HashMap<K, V> {
hash: uint,
k: &K)
-> SearchResult {
let _ = for self.bucket_sequence(hash) |i| {
for self.bucket_sequence(hash) |i| {
match self.buckets[i] {
Some(ref bkt) => if bkt.hash == hash && *k == bkt.key {
return FoundEntry(i);
},
None => return FoundHole(i)
}
};
}
TableFull
}
@ -138,7 +152,7 @@ priv impl<K:Hash + Eq,V> HashMap<K, V> {
hash: uint,
k: &Q)
-> SearchResult {
let _ = for self.bucket_sequence(hash) |i| {
for self.bucket_sequence(hash) |i| {
match self.buckets[i] {
Some(ref bkt) => {
if bkt.hash == hash && k.equiv(&bkt.key) {
@ -147,7 +161,7 @@ priv impl<K:Hash + Eq,V> HashMap<K, V> {
},
None => return FoundHole(i)
}
};
}
TableFull
}
@ -311,7 +325,8 @@ impl<K:Hash + Eq,V> Map<K, V> for HashMap<K, V> {
}
/// Visit all key-value pairs
fn each<'a>(&'a self, blk: &fn(&'a K, &'a V) -> bool) {
#[cfg(stage0)]
fn each<'a>(&'a self, blk: &fn(&K, &'a V) -> bool) {
for uint::range(0, self.buckets.len()) |i| {
for self.buckets[i].each |bucket| {
if !blk(&bucket.key, &bucket.value) {
@ -321,17 +336,45 @@ impl<K:Hash + Eq,V> Map<K, V> for HashMap<K, V> {
}
}
/// Visit all key-value pairs
#[cfg(not(stage0))]
fn each<'a>(&'a self, blk: &fn(&K, &'a V) -> bool) -> bool {
for uint::range(0, self.buckets.len()) |i| {
for self.buckets[i].each |bucket| {
if !blk(&bucket.key, &bucket.value) {
return false;
}
}
}
return true;
}
/// Visit all keys
#[cfg(stage0)]
fn each_key(&self, blk: &fn(k: &K) -> bool) {
self.each(|k, _| blk(k))
}
/// Visit all keys
#[cfg(not(stage0))]
fn each_key(&self, blk: &fn(k: &K) -> bool) -> bool {
self.each(|k, _| blk(k))
}
/// Visit all values
#[cfg(stage0)]
fn each_value<'a>(&'a self, blk: &fn(v: &'a V) -> bool) {
self.each(|_, v| blk(v))
}
/// Visit all values
#[cfg(not(stage0))]
fn each_value<'a>(&'a self, blk: &fn(v: &'a V) -> bool) -> bool {
self.each(|_, v| blk(v))
}
/// Iterate over the map and mutate the contained values
#[cfg(stage0)]
fn mutate_values(&mut self, blk: &fn(&K, &mut V) -> bool) {
for uint::range(0, self.buckets.len()) |i| {
match self.buckets[i] {
@ -343,6 +386,20 @@ impl<K:Hash + Eq,V> Map<K, V> for HashMap<K, V> {
}
}
/// Iterate over the map and mutate the contained values
#[cfg(not(stage0))]
fn mutate_values(&mut self, blk: &fn(&K, &mut V) -> bool) -> bool {
for uint::range(0, self.buckets.len()) |i| {
match self.buckets[i] {
Some(Bucket{key: ref key, value: ref mut value, _}) => {
if !blk(key, value) { return false; }
}
None => ()
}
}
return true;
}
/// Return a reference to the value corresponding to the key
fn find<'a>(&'a self, k: &K) -> Option<&'a V> {
match self.bucket_for_key(k) {
@ -632,7 +689,10 @@ pub struct HashSet<T> {
impl<T:Hash + Eq> BaseIter<T> for HashSet<T> {
/// Visit all values in order
#[cfg(stage0)]
fn each(&self, f: &fn(&T) -> bool) { self.map.each_key(f) }
#[cfg(not(stage0))]
fn each(&self, f: &fn(&T) -> bool) -> bool { self.map.each_key(f) }
fn size_hint(&self) -> Option<uint> { Some(self.len()) }
}
@ -683,6 +743,7 @@ impl<T:Hash + Eq> Set<T> for HashSet<T> {
}
/// Visit the values representing the difference
#[cfg(stage0)]
fn difference(&self, other: &HashSet<T>, f: &fn(&T) -> bool) {
for self.each |v| {
if !other.contains(v) {
@ -691,7 +752,14 @@ impl<T:Hash + Eq> Set<T> for HashSet<T> {
}
}
/// Visit the values representing the difference
#[cfg(not(stage0))]
fn difference(&self, other: &HashSet<T>, f: &fn(&T) -> bool) -> bool {
self.each(|v| other.contains(v) || f(v))
}
/// Visit the values representing the symmetric difference
#[cfg(stage0)]
fn symmetric_difference(&self,
other: &HashSet<T>,
f: &fn(&T) -> bool) {
@ -699,7 +767,16 @@ impl<T:Hash + Eq> Set<T> for HashSet<T> {
other.difference(self, f);
}
/// Visit the values representing the symmetric difference
#[cfg(not(stage0))]
fn symmetric_difference(&self,
other: &HashSet<T>,
f: &fn(&T) -> bool) -> bool {
self.difference(other, f) && other.difference(self, f)
}
/// Visit the values representing the intersection
#[cfg(stage0)]
fn intersection(&self, other: &HashSet<T>, f: &fn(&T) -> bool) {
for self.each |v| {
if other.contains(v) {
@ -708,7 +785,14 @@ impl<T:Hash + Eq> Set<T> for HashSet<T> {
}
}
/// Visit the values representing the intersection
#[cfg(not(stage0))]
fn intersection(&self, other: &HashSet<T>, f: &fn(&T) -> bool) -> bool {
self.each(|v| !other.contains(v) || f(v))
}
/// Visit the values representing the union
#[cfg(stage0)]
fn union(&self, other: &HashSet<T>, f: &fn(&T) -> bool) {
for self.each |v| {
if !f(v) { return }
@ -720,6 +804,12 @@ impl<T:Hash + Eq> Set<T> for HashSet<T> {
}
}
}
/// Visit the values representing the union
#[cfg(not(stage0))]
fn union(&self, other: &HashSet<T>, f: &fn(&T) -> bool) -> bool {
self.each(f) && other.each(|v| self.contains(v) || f(v))
}
}
pub impl <T:Hash + Eq> HashSet<T> {

47
src/libcore/io.rs
View file

@ -247,7 +247,10 @@ pub trait ReaderUtil {
*
* None right now.
*/
#[cfg(stage0)]
fn each_byte(&self, it: &fn(int) -> bool);
#[cfg(not(stage0))]
fn each_byte(&self, it: &fn(int) -> bool) -> bool;
/**
* Iterate over every char until EOF or the iterator breaks.
@ -256,7 +259,10 @@ pub trait ReaderUtil {
*
* None right now.
*/
#[cfg(stage0)]
fn each_char(&self, it: &fn(char) -> bool);
#[cfg(not(stage0))]
fn each_char(&self, it: &fn(char) -> bool) -> bool;
/**
* Iterate over every line until EOF or the iterator breaks.
@ -265,7 +271,10 @@ pub trait ReaderUtil {
*
* None right now.
*/
#[cfg(stage0)]
fn each_line(&self, it: &fn(&str) -> bool);
#[cfg(not(stage0))]
fn each_line(&self, it: &fn(&str) -> bool) -> bool;
/**
* Reads all of the lines in the stream.
@ -676,18 +685,35 @@ impl<T:Reader> ReaderUtil for T {
bytes
}
#[cfg(stage0)]
fn each_byte(&self, it: &fn(int) -> bool) {
while !self.eof() {
if !it(self.read_byte()) { break; }
}
}
#[cfg(not(stage0))]
fn each_byte(&self, it: &fn(int) -> bool) -> bool {
while !self.eof() {
if !it(self.read_byte()) { return false; }
}
return true;
}
#[cfg(stage0)]
fn each_char(&self, it: &fn(char) -> bool) {
while !self.eof() {
if !it(self.read_char()) { break; }
}
}
#[cfg(not(stage0))]
fn each_char(&self, it: &fn(char) -> bool) -> bool {
while !self.eof() {
if !it(self.read_char()) { return false; }
}
return true;
}
#[cfg(stage0)]
fn each_line(&self, it: &fn(s: &str) -> bool) {
while !self.eof() {
// include the \n, so that we can distinguish an entirely empty
@ -707,6 +733,27 @@ impl<T:Reader> ReaderUtil for T {
if !it(line) { break; }
}
}
#[cfg(not(stage0))]
fn each_line(&self, it: &fn(s: &str) -> bool) -> bool {
while !self.eof() {
// include the \n, so that we can distinguish an entirely empty
// line read after "...\n", and the trailing empty line in
// "...\n\n".
let mut line = self.read_until('\n' as u8, true);
// blank line at the end of the reader is ignored
if self.eof() && line.is_empty() { break; }
// trim the \n, so that each_line is consistent with read_line
let n = str::len(line);
if line[n-1] == '\n' as u8 {
unsafe { str::raw::set_len(&mut line, n-1); }
}
if !it(line) { return false; }
}
return true;
}
fn read_lines(&self) -> ~[~str] {
do vec::build |push| {

48
src/libcore/iter.rs
View file

@ -40,12 +40,17 @@ much easier to implement.
*/
use cmp::Ord;
use option::{Option, Some, None};
#[cfg(not(stage0))] use cmp::Ord;
#[cfg(not(stage0))] use option::{Option, Some, None};
#[cfg(stage0)]
pub trait Times {
fn times(&self, it: &fn() -> bool);
}
#[cfg(not(stage0))]
pub trait Times {
fn times(&self, it: &fn() -> bool) -> bool;
}
/**
* Transform an internal iterator into an owned vector.
@ -59,7 +64,8 @@ pub trait Times {
* ~~~
*/
#[inline(always)]
pub fn to_vec<T>(iter: &fn(f: &fn(T) -> bool)) -> ~[T] {
#[cfg(not(stage0))]
pub fn to_vec<T>(iter: &fn(f: &fn(T) -> bool) -> bool) -> ~[T] {
let mut v = ~[];
for iter |x| { v.push(x) }
v
@ -77,13 +83,12 @@ pub fn to_vec<T>(iter: &fn(f: &fn(T) -> bool)) -> ~[T] {
* ~~~~
*/
#[inline(always)]
pub fn any<T>(predicate: &fn(T) -> bool, iter: &fn(f: &fn(T) -> bool)) -> bool {
for iter |x| {
if predicate(x) {
return true
}
}
false
#[cfg(not(stage0))]
pub fn any<T>(predicate: &fn(T) -> bool,
iter: &fn(f: &fn(T) -> bool) -> bool) -> bool {
// If the predicate returns true, we break. If we ever broke, then we found
// something
!iter(|x| !predicate(x))
}
/**
@ -97,13 +102,12 @@ pub fn any<T>(predicate: &fn(T) -> bool, iter: &fn(f: &fn(T) -> bool)) -> bool {
* ~~~~
*/
#[inline(always)]
pub fn all<T>(predicate: &fn(T) -> bool, iter: &fn(f: &fn(T) -> bool)) -> bool {
for iter |x| {
if !predicate(x) {
return false
}
}
true
#[cfg(not(stage0))]
pub fn all<T>(predicate: &fn(T) -> bool,
iter: &fn(f: &fn(T) -> bool) -> bool) -> bool {
// If we ever break, iter will return false, so this will only return true
// if predicate returns true for everything.
iter(|x| predicate(x))
}
/**
@ -117,7 +121,9 @@ pub fn all<T>(predicate: &fn(T) -> bool, iter: &fn(f: &fn(T) -> bool)) -> bool {
* ~~~~
*/
#[inline(always)]
pub fn find<T>(predicate: &fn(&T) -> bool, iter: &fn(f: &fn(T) -> bool)) -> Option<T> {
#[cfg(not(stage0))]
pub fn find<T>(predicate: &fn(&T) -> bool,
iter: &fn(f: &fn(T) -> bool) -> bool) -> Option<T> {
for iter |x| {
if predicate(&x) {
return Some(x);
@ -137,7 +143,8 @@ pub fn find<T>(predicate: &fn(&T) -> bool, iter: &fn(f: &fn(T) -> bool)) -> Opti
* ~~~~
*/
#[inline]
pub fn max<T: Ord>(iter: &fn(f: &fn(T) -> bool)) -> Option<T> {
#[cfg(not(stage0))]
pub fn max<T: Ord>(iter: &fn(f: &fn(T) -> bool) -> bool) -> Option<T> {
let mut result = None;
for iter |x| {
match result {
@ -163,7 +170,8 @@ pub fn max<T: Ord>(iter: &fn(f: &fn(T) -> bool)) -> Option<T> {
* ~~~~
*/
#[inline]
pub fn min<T: Ord>(iter: &fn(f: &fn(T) -> bool)) -> Option<T> {
#[cfg(not(stage0))]
pub fn min<T: Ord>(iter: &fn(f: &fn(T) -> bool) -> bool) -> Option<T> {
let mut result = None;
for iter |x| {
match result {

22
src/libcore/iterator.rs
View file

@ -41,7 +41,10 @@ pub trait IteratorUtil<A> {
fn take(self, n: uint) -> TakeIterator<Self>;
fn scan<'r, St, B>(self, initial_state: St, f: &'r fn(&mut St, A) -> Option<B>)
-> ScanIterator<'r, A, B, Self, St>;
#[cfg(stage0)]
fn advance(&mut self, f: &fn(A) -> bool);
#[cfg(not(stage0))]
fn advance(&mut self, f: &fn(A) -> bool) -> bool;
}
/// Iterator adaptors provided for every `Iterator` implementation. The adaptor objects are also
@ -103,13 +106,28 @@ impl<A, T: Iterator<A>> IteratorUtil<A> for T {
/// A shim implementing the `for` loop iteration protocol for iterator objects
#[inline]
#[cfg(stage0)]
fn advance(&mut self, f: &fn(A) -> bool) {
loop {
match self.next() {
Some(x) => {
if !f(x) { return }
if !f(x) { return; }
}
None => return
None => { return; }
}
}
}
/// A shim implementing the `for` loop iteration protocol for iterator objects
#[inline]
#[cfg(not(stage0))]
fn advance(&mut self, f: &fn(A) -> bool) -> bool {
loop {
match self.next() {
Some(x) => {
if !f(x) { return false; }
}
None => { return true; }
}
}
}

35
src/libcore/num/int-template.rs
View file

@ -86,38 +86,63 @@ pub fn gt(x: T, y: T) -> bool { x > y }
///
#[inline(always)]
/// Iterate over the range [`start`,`start`+`step`..`stop`)
pub fn range_step(start: T, stop: T, step: T, it: &fn(T) -> bool) {
pub fn _range_step(start: T, stop: T, step: T, it: &fn(T) -> bool) -> bool {
let mut i = start;
if step == 0 {
fail!(~"range_step called with step == 0");
} else if step > 0 { // ascending
while i < stop {
if !it(i) { break }
if !it(i) { return false; }
// avoiding overflow. break if i + step > max_value
if i > max_value - step { break; }
if i > max_value - step { return true; }
i += step;
}
} else { // descending
while i > stop {
if !it(i) { break }
if !it(i) { return false; }
// avoiding underflow. break if i + step < min_value
if i < min_value - step { break; }
if i < min_value - step { return true; }
i += step;
}
}
return true;
}
#[cfg(stage0)]
pub fn range_step(start: T, stop: T, step: T, it: &fn(T) -> bool) {
_range_step(start, stop, step, it);
}
#[cfg(not(stage0))]
pub fn range_step(start: T, stop: T, step: T, it: &fn(T) -> bool) -> bool {
_range_step(start, stop, step, it)
}
#[inline(always)]
#[cfg(stage0)]
/// Iterate over the range [`lo`..`hi`)
pub fn range(lo: T, hi: T, it: &fn(T) -> bool) {
range_step(lo, hi, 1 as T, it);
}
#[inline(always)]
#[cfg(not(stage0))]
/// Iterate over the range [`lo`..`hi`)
pub fn range(lo: T, hi: T, it: &fn(T) -> bool) -> bool {
range_step(lo, hi, 1 as T, it)
}
#[inline(always)]
#[cfg(stage0)]
/// Iterate over the range [`hi`..`lo`)
pub fn range_rev(hi: T, lo: T, it: &fn(T) -> bool) {
range_step(hi, lo, -1 as T, it);
}
#[inline(always)]
#[cfg(not(stage0))]
/// Iterate over the range [`hi`..`lo`)
pub fn range_rev(hi: T, lo: T, it: &fn(T) -> bool) -> bool {
range_step(hi, lo, -1 as T, it)
}
/// Computes the bitwise complement
#[inline(always)]

42
src/libcore/num/uint-template.rs
View file

@ -51,43 +51,69 @@ pub fn gt(x: T, y: T) -> bool { x > y }
///
/// Iterate over the range [`start`,`start`+`step`..`stop`)
///
pub fn range_step(start: T,
stop: T,
step: T_SIGNED,
it: &fn(T) -> bool) {
pub fn _range_step(start: T,
stop: T,
step: T_SIGNED,
it: &fn(T) -> bool) -> bool {
let mut i = start;
if step == 0 {
fail!(~"range_step called with step == 0");
}
if step >= 0 {
while i < stop {
if !it(i) { break }
if !it(i) { return false; }
// avoiding overflow. break if i + step > max_value
if i > max_value - (step as T) { break; }
if i > max_value - (step as T) { return true; }
i += step as T;
}
} else {
while i > stop {
if !it(i) { break }
if !it(i) { return false; }
// avoiding underflow. break if i + step < min_value
if i < min_value + ((-step) as T) { break; }
if i < min_value + ((-step) as T) { return true; }
i -= -step as T;
}
}
return true;
}
#[cfg(stage0)]
pub fn range_step(start: T, stop: T, step: T_SIGNED, it: &fn(T) -> bool) {
_range_step(start, stop, step, it);
}
#[cfg(not(stage0))]
pub fn range_step(start: T, stop: T, step: T_SIGNED, it: &fn(T) -> bool) -> bool {
_range_step(start, stop, step, it)
}
#[inline(always)]
#[cfg(stage0)]
/// Iterate over the range [`lo`..`hi`)
pub fn range(lo: T, hi: T, it: &fn(T) -> bool) {
range_step(lo, hi, 1 as T_SIGNED, it);
}
#[inline(always)]
#[cfg(not(stage0))]
/// Iterate over the range [`lo`..`hi`)
pub fn range(lo: T, hi: T, it: &fn(T) -> bool) -> bool {
range_step(lo, hi, 1 as T_SIGNED, it)
}
#[inline(always)]
#[cfg(stage0)]
/// Iterate over the range [`hi`..`lo`)
pub fn range_rev(hi: T, lo: T, it: &fn(T) -> bool) {
range_step(hi, lo, -1 as T_SIGNED, it);
}
#[inline(always)]
#[cfg(not(stage0))]
/// Iterate over the range [`hi`..`lo`)
pub fn range_rev(hi: T, lo: T, it: &fn(T) -> bool) -> bool {
range_step(hi, lo, -1 as T_SIGNED, it)
}
/// Computes the bitwise complement
#[inline(always)]
pub fn compl(i: T) -> T {

24
src/libcore/num/uint-template/uint.rs
View file

@ -154,6 +154,7 @@ pub mod inst {
return true;
}
#[cfg(stage0)]
impl iter::Times for uint {
#[inline(always)]
///
@ -175,6 +176,29 @@ pub mod inst {
}
}
#[cfg(not(stage0))]
impl iter::Times for uint {
#[inline(always)]
///
/// A convenience form for basic iteration. Given a uint `x`,
/// `for x.times { ... }` executes the given block x times.
///
/// Equivalent to `for uint::range(0, x) |_| { ... }`.
///
/// Not defined on all integer types to permit unambiguous
/// use with integer literals of inferred integer-type as
/// the self-value (eg. `for 100.times { ... }`).
///
fn times(&self, it: &fn() -> bool) -> bool {
let mut i = *self;
while i > 0 {
if !it() { return false; }
i -= 1;
}
return true;
}
}
/// Returns the smallest power of 2 greater than or equal to `n`
#[inline(always)]
pub fn next_power_of_two(n: uint) -> uint {

49
src/libcore/old_iter.rs
View file

@ -22,21 +22,40 @@ use vec;
/// A function used to initialize the elements of a sequence
pub type InitOp<'self,T> = &'self fn(uint) -> T;
#[cfg(stage0)]
pub trait BaseIter<A> {
fn each(&self, blk: &fn(v: &A) -> bool);
fn size_hint(&self) -> Option<uint>;
}
#[cfg(not(stage0))]
pub trait BaseIter<A> {
fn each(&self, blk: &fn(v: &A) -> bool) -> bool;
fn size_hint(&self) -> Option<uint>;
}
#[cfg(stage0)]
pub trait ReverseIter<A>: BaseIter<A> {
fn each_reverse(&self, blk: &fn(&A) -> bool);
}
#[cfg(not(stage0))]
pub trait ReverseIter<A>: BaseIter<A> {
fn each_reverse(&self, blk: &fn(&A) -> bool) -> bool;
}
#[cfg(stage0)]
pub trait MutableIter<A>: BaseIter<A> {
fn each_mut(&mut self, blk: &fn(&mut A) -> bool);
}
#[cfg(not(stage0))]
pub trait MutableIter<A>: BaseIter<A> {
fn each_mut(&mut self, blk: &fn(&mut A) -> bool) -> bool;
}
pub trait ExtendedIter<A> {
#[cfg(stage0)]
fn eachi(&self, blk: &fn(uint, v: &A) -> bool);
#[cfg(not(stage0))]
fn eachi(&self, blk: &fn(uint, v: &A) -> bool) -> bool;
fn all(&self, blk: &fn(&A) -> bool) -> bool;
fn any(&self, blk: &fn(&A) -> bool) -> bool;
fn foldl<B>(&self, b0: B, blk: &fn(&B, &A) -> B) -> B;
@ -45,9 +64,14 @@ pub trait ExtendedIter<A> {
fn flat_map_to_vec<B,IB: BaseIter<B>>(&self, op: &fn(&A) -> IB) -> ~[B];
}
#[cfg(stage0)]
pub trait ExtendedMutableIter<A> {
fn eachi_mut(&mut self, blk: &fn(uint, &mut A) -> bool);
}
#[cfg(not(stage0))]
pub trait ExtendedMutableIter<A> {
fn eachi_mut(&mut self, blk: &fn(uint, &mut A) -> bool) -> bool;
}
pub trait EqIter<A:Eq> {
fn contains(&self, x: &A) -> bool;
@ -92,12 +116,22 @@ pub trait Buildable<A> {
}
#[inline(always)]
pub fn eachi<A,IA:BaseIter<A>>(self: &IA, blk: &fn(uint, &A) -> bool) {
pub fn _eachi<A,IA:BaseIter<A>>(self: &IA, blk: &fn(uint, &A) -> bool) -> bool {
let mut i = 0;
for self.each |a| {
if !blk(i, a) { break; }
if !blk(i, a) { return false; }
i += 1;
}
return true;
}
#[cfg(stage0)]
pub fn eachi<A,IA:BaseIter<A>>(self: &IA, blk: &fn(uint, &A) -> bool) {
_eachi(self, blk);
}
#[cfg(not(stage0))]
pub fn eachi<A,IA:BaseIter<A>>(self: &IA, blk: &fn(uint, &A) -> bool) -> bool {
_eachi(self, blk)
}
#[inline(always)]
@ -199,6 +233,7 @@ pub fn position<A,IA:BaseIter<A>>(self: &IA, f: &fn(&A) -> bool)
// it would have to be implemented with foldr, which is too inefficient.
#[inline(always)]
#[cfg(stage0)]
pub fn repeat(times: uint, blk: &fn() -> bool) {
let mut i = 0;
while i < times {
@ -206,6 +241,16 @@ pub fn repeat(times: uint, blk: &fn() -> bool) {
i += 1;
}
}
#[inline(always)]
#[cfg(not(stage0))]
pub fn repeat(times: uint, blk: &fn() -> bool) -> bool {
let mut i = 0;
while i < times {
if !blk() { return false; }
i += 1;
}
return true;
}
#[inline(always)]
pub fn min<A:Copy + Ord,IA:BaseIter<A>>(self: &IA) -> A {

18
src/libcore/option.rs
View file

@ -101,9 +101,16 @@ impl<T: Copy + Add<T,T>> Add<Option<T>, Option<T>> for Option<T> {
impl<T> BaseIter<T> for Option<T> {
/// Performs an operation on the contained value by reference
#[inline(always)]
#[cfg(stage0)]
fn each<'a>(&'a self, f: &fn(x: &'a T) -> bool) {
match *self { None => (), Some(ref t) => { f(t); } }
}
/// Performs an operation on the contained value by reference
#[inline(always)]
#[cfg(not(stage0))]
fn each<'a>(&'a self, f: &fn(x: &'a T) -> bool) -> bool {
match *self { None => true, Some(ref t) => { f(t) } }
}
#[inline(always)]
fn size_hint(&self) -> Option<uint> {
@ -112,16 +119,27 @@ impl<T> BaseIter<T> for Option<T> {
}
impl<T> MutableIter<T> for Option<T> {
#[cfg(stage0)]
#[inline(always)]
fn each_mut<'a>(&'a mut self, f: &fn(&'a mut T) -> bool) {
match *self { None => (), Some(ref mut t) => { f(t); } }
}
#[cfg(not(stage0))]
#[inline(always)]
fn each_mut<'a>(&'a mut self, f: &fn(&'a mut T) -> bool) -> bool {
match *self { None => true, Some(ref mut t) => { f(t) } }
}
}
impl<A> ExtendedIter<A> for Option<A> {
#[cfg(stage0)]
pub fn eachi(&self, blk: &fn(uint, v: &A) -> bool) {
old_iter::eachi(self, blk)
}
#[cfg(not(stage0))]
pub fn eachi(&self, blk: &fn(uint, v: &A) -> bool) -> bool {
old_iter::eachi(self, blk)
}
pub fn all(&self, blk: &fn(&A) -> bool) -> bool {
old_iter::all(self, blk)
}

9
src/libcore/os.rs
View file

@ -550,6 +550,7 @@ pub fn tmpdir() -> Path {
}
}
/// Recursively walk a directory structure
#[cfg(stage0)]
pub fn walk_dir(p: &Path, f: &fn(&Path) -> bool) {
walk_dir_(p, f);
@ -577,6 +578,14 @@ pub fn walk_dir(p: &Path, f: &fn(&Path) -> bool) {
return keepgoing;
}
}
/// Recursively walk a directory structure
#[cfg(not(stage0))]
pub fn walk_dir(p: &Path, f: &fn(&Path) -> bool) -> bool {
list_dir(p).each(|q| {
let path = &p.push(*q);
f(path) && (!path_is_dir(path) || walk_dir(path, f))
})
}
/// Indicates whether a path represents a directory
pub fn path_is_dir(p: &Path) -> bool {

30
src/libcore/stackwalk.rs
View file

@ -24,6 +24,7 @@ pub fn Frame(fp: *Word) -> Frame {
}
}
#[cfg(stage0)]
pub fn walk_stack(visit: &fn(Frame) -> bool) {
debug!("beginning stack walk");
@ -51,6 +52,35 @@ pub fn walk_stack(visit: &fn(Frame) -> bool) {
}
}
}
#[cfg(not(stage0))]
pub fn walk_stack(visit: &fn(Frame) -> bool) -> bool {
debug!("beginning stack walk");
do frame_address |frame_pointer| {
let mut frame_address: *Word = unsafe {
transmute(frame_pointer)
};
loop {
let fr = Frame(frame_address);
debug!("frame: %x", unsafe { transmute(fr.fp) });
visit(fr);
unsafe {
let next_fp: **Word = transmute(frame_address);
frame_address = *next_fp;
if *frame_address == 0u {
debug!("encountered task_start_wrapper. ending walk");
// This is the task_start_wrapper_frame. There is
// no stack beneath it and it is a foreign frame.
break;
}
}
}
}
return true;
}
#[test]
fn test_simple() {

439
src/libcore/str.rs
View file

@ -566,14 +566,30 @@ pub fn slice<'a>(s: &'a str, begin: uint, end: uint) -> &'a str {
}
/// Splits a string into substrings at each occurrence of a given character
#[cfg(stage0)]
pub fn each_split_char<'a>(s: &'a str, sep: char, it: &fn(&'a str) -> bool) {
each_split_char_inner(s, sep, len(s), true, true, it);
}
/// Splits a string into substrings at each occurrence of a given character
#[cfg(not(stage0))]
pub fn each_split_char<'a>(s: &'a str, sep: char,
it: &fn(&'a str) -> bool) -> bool {
each_split_char_inner(s, sep, len(s), true, true, it)
}
/// Like `each_split_char`, but a trailing empty string is omitted
#[cfg(stage0)]
pub fn each_split_char_no_trailing<'a>(s: &'a str,
sep: char,
it: &fn(&'a str) -> bool) {
each_split_char_inner(s, sep, len(s), true, false, it);
}
/// Like `each_split_char`, but a trailing empty string is omitted
#[cfg(not(stage0))]
pub fn each_split_char_no_trailing<'a>(s: &'a str,
sep: char,
it: &fn(&'a str) -> bool) -> bool {
each_split_char_inner(s, sep, len(s), true, false, it)
}
@ -583,17 +599,39 @@ pub fn each_split_char_no_trailing<'a>(s: &'a str,
*
* The character must be a valid UTF-8/ASCII character
*/
#[cfg(stage0)]
pub fn each_splitn_char<'a>(s: &'a str,
sep: char,
count: uint,
it: &fn(&'a str) -> bool) {
each_split_char_inner(s, sep, count, true, true, it);
}
/**
* Splits a string into substrings at each occurrence of a given
* character up to 'count' times.
*
* The character must be a valid UTF-8/ASCII character
*/
#[cfg(not(stage0))]
pub fn each_splitn_char<'a>(s: &'a str,
sep: char,
count: uint,
it: &fn(&'a str) -> bool) -> bool {
each_split_char_inner(s, sep, count, true, true, it)
}
/// Like `each_split_char`, but omits empty strings
#[cfg(stage0)]
pub fn each_split_char_nonempty<'a>(s: &'a str,
sep: char,
it: &fn(&'a str) -> bool) {
each_split_char_inner(s, sep, len(s), false, false, it);
}
/// Like `each_split_char`, but omits empty strings
#[cfg(not(stage0))]
pub fn each_split_char_nonempty<'a>(s: &'a str,
sep: char,
it: &fn(&'a str) -> bool) -> bool {
each_split_char_inner(s, sep, len(s), false, false, it)
}
@ -602,7 +640,7 @@ fn each_split_char_inner<'a>(s: &'a str,
count: uint,
allow_empty: bool,
allow_trailing_empty: bool,
it: &fn(&'a str) -> bool) {
it: &fn(&'a str) -> bool) -> bool {
if sep < 128u as char {
let b = sep as u8, l = len(s);
let mut done = 0u;
@ -610,7 +648,9 @@ fn each_split_char_inner<'a>(s: &'a str,
while i < l && done < count {
if s[i] == b {
if allow_empty || start < i {
if !it( unsafe{ raw::slice_bytes(s, start, i) } ) { return; }
if !it( unsafe{ raw::slice_bytes(s, start, i) } ) {
return false;
}
}
start = i + 1u;
done += 1u;
@ -619,24 +659,41 @@ fn each_split_char_inner<'a>(s: &'a str,
}
// only slice a non-empty trailing substring
if allow_trailing_empty || start < l {
if !it( unsafe{ raw::slice_bytes(s, start, l) } ) { return; }
if !it( unsafe{ raw::slice_bytes(s, start, l) } ) { return false; }
}
} else {
each_split_inner(s, |cur| cur == sep, count, allow_empty, allow_trailing_empty, it)
return true;
}
return each_split_inner(s, |cur| cur == sep, count,
allow_empty, allow_trailing_empty, it)
}
/// Splits a string into substrings using a character function
#[cfg(stage0)]
pub fn each_split<'a>(s: &'a str,
sepfn: &fn(char) -> bool,
it: &fn(&'a str) -> bool) {
each_split_inner(s, sepfn, len(s), true, true, it);
}
/// Splits a string into substrings using a character function
#[cfg(not(stage0))]
pub fn each_split<'a>(s: &'a str,
sepfn: &fn(char) -> bool,
it: &fn(&'a str) -> bool) -> bool {
each_split_inner(s, sepfn, len(s), true, true, it)
}
/// Like `each_split`, but a trailing empty string is omitted
#[cfg(stage0)]
pub fn each_split_no_trailing<'a>(s: &'a str,
sepfn: &fn(char) -> bool,
it: &fn(&'a str) -> bool) {
each_split_inner(s, sepfn, len(s), true, false, it);
}
/// Like `each_split`, but a trailing empty string is omitted
#[cfg(not(stage0))]
pub fn each_split_no_trailing<'a>(s: &'a str,
sepfn: &fn(char) -> bool,
it: &fn(&'a str) -> bool) -> bool {
each_split_inner(s, sepfn, len(s), true, false, it)
}
@ -644,17 +701,37 @@ pub fn each_split_no_trailing<'a>(s: &'a str,
* Splits a string into substrings using a character function, cutting at
* most `count` times.
*/
#[cfg(stage0)]
pub fn each_splitn<'a>(s: &'a str,
sepfn: &fn(char) -> bool,
count: uint,
it: &fn(&'a str) -> bool) {
each_split_inner(s, sepfn, count, true, true, it);
}
/**
* Splits a string into substrings using a character function, cutting at
* most `count` times.
*/
#[cfg(not(stage0))]
pub fn each_splitn<'a>(s: &'a str,
sepfn: &fn(char) -> bool,
count: uint,
it: &fn(&'a str) -> bool) -> bool {
each_split_inner(s, sepfn, count, true, true, it)
}
/// Like `each_split`, but omits empty strings
#[cfg(stage0)]
pub fn each_split_nonempty<'a>(s: &'a str,
sepfn: &fn(char) -> bool,
it: &fn(&'a str) -> bool) {
each_split_inner(s, sepfn, len(s), false, false, it);
}
/// Like `each_split`, but omits empty strings
#[cfg(not(stage0))]
pub fn each_split_nonempty<'a>(s: &'a str,
sepfn: &fn(char) -> bool,
it: &fn(&'a str) -> bool) -> bool {
each_split_inner(s, sepfn, len(s), false, false, it)
}
@ -663,14 +740,16 @@ fn each_split_inner<'a>(s: &'a str,
count: uint,
allow_empty: bool,
allow_trailing_empty: bool,
it: &fn(&'a str) -> bool) {
it: &fn(&'a str) -> bool) -> bool {
let l = len(s);
let mut i = 0u, start = 0u, done = 0u;
while i < l && done < count {
let CharRange {ch, next} = char_range_at(s, i);
if sepfn(ch) {
if allow_empty || start < i {
if !it( unsafe{ raw::slice_bytes(s, start, i) } ) { return; }
if !it( unsafe{ raw::slice_bytes(s, start, i) } ) {
return false;
}
}
start = next;
done += 1u;
@ -678,12 +757,15 @@ fn each_split_inner<'a>(s: &'a str,
i = next;
}
if allow_trailing_empty || start < l {
if !it( unsafe{ raw::slice_bytes(s, start, l) } ) { return; }
if !it( unsafe{ raw::slice_bytes(s, start, l) } ) { return false; }
}
return true;
}
// See Issue #1932 for why this is a naive search
fn iter_matches<'a,'b>(s: &'a str, sep: &'b str, f: &fn(uint, uint) -> bool) {
#[cfg(stage0)]
fn iter_matches<'a,'b>(s: &'a str, sep: &'b str,
f: &fn(uint, uint) -> bool) {
let sep_len = len(sep), l = len(s);
assert!(sep_len > 0u);
let mut i = 0u, match_start = 0u, match_i = 0u;
@ -709,7 +791,38 @@ fn iter_matches<'a,'b>(s: &'a str, sep: &'b str, f: &fn(uint, uint) -> bool) {
}
}
}
// See Issue #1932 for why this is a naive search
#[cfg(not(stage0))]
fn iter_matches<'a,'b>(s: &'a str, sep: &'b str,
f: &fn(uint, uint) -> bool) -> bool {
let sep_len = len(sep), l = len(s);
assert!(sep_len > 0u);
let mut i = 0u, match_start = 0u, match_i = 0u;
while i < l {
if s[i] == sep[match_i] {
if match_i == 0u { match_start = i; }
match_i += 1u;
// Found a match
if match_i == sep_len {
if !f(match_start, i + 1u) { return false; }
match_i = 0u;
}
i += 1u;
} else {
// Failed match, backtrack
if match_i > 0u {
match_i = 0u;
i = match_start + 1u;
} else {
i += 1u;
}
}
}
return true;
}
#[cfg(stage0)]
fn iter_between_matches<'a,'b>(s: &'a str,
sep: &'b str,
f: &fn(uint, uint) -> bool) {
@ -720,6 +833,17 @@ fn iter_between_matches<'a,'b>(s: &'a str,
}
f(last_end, len(s));
}
#[cfg(not(stage0))]
fn iter_between_matches<'a,'b>(s: &'a str,
sep: &'b str,
f: &fn(uint, uint) -> bool) -> bool {
let mut last_end = 0u;
for iter_matches(s, sep) |from, to| {
if !f(last_end, from) { return false; }
last_end = to;
}
return f(last_end, len(s));
}
/**
* Splits a string into a vector of the substrings separated by a given string
@ -732,6 +856,7 @@ fn iter_between_matches<'a,'b>(s: &'a str,
* assert!(v == ["", "XXX", "YYY", ""]);
* ~~~
*/
#[cfg(stage0)]
pub fn each_split_str<'a,'b>(s: &'a str,
sep: &'b str,
it: &fn(&'a str) -> bool) {
@ -739,7 +864,28 @@ pub fn each_split_str<'a,'b>(s: &'a str,
if !it( unsafe { raw::slice_bytes(s, from, to) } ) { return; }
}
}
/**
* Splits a string into a vector of the substrings separated by a given string
*
* # Example
*
* ~~~
* let mut v = ~[];
* for each_split_str(".XXX.YYY.", ".") |subs| { v.push(subs); }
* assert!(v == ["", "XXX", "YYY", ""]);
* ~~~
*/
#[cfg(not(stage0))]
pub fn each_split_str<'a,'b>(s: &'a str,
sep: &'b str,
it: &fn(&'a str) -> bool) -> bool {
for iter_between_matches(s, sep) |from, to| {
if !it( unsafe { raw::slice_bytes(s, from, to) } ) { return false; }
}
return true;
}
#[cfg(stage0)]
pub fn each_split_str_nonempty<'a,'b>(s: &'a str,
sep: &'b str,
it: &fn(&'a str) -> bool) {
@ -750,6 +896,18 @@ pub fn each_split_str_nonempty<'a,'b>(s: &'a str,
}
}
#[cfg(not(stage0))]
pub fn each_split_str_nonempty<'a,'b>(s: &'a str,
sep: &'b str,
it: &fn(&'a str) -> bool) -> bool {
for iter_between_matches(s, sep) |from, to| {
if to > from {
if !it( unsafe { raw::slice_bytes(s, from, to) } ) { return false; }
}
}
return true;
}
/// Levenshtein Distance between two strings
pub fn levdistance(s: &str, t: &str) -> uint {
@ -787,7 +945,15 @@ pub fn levdistance(s: &str, t: &str) -> uint {
/**
* Splits a string into substrings separated by LF ('\n').
*/
#[cfg(stage0)]
pub fn each_line<'a>(s: &'a str, it: &fn(&'a str) -> bool) {
each_split_char_no_trailing(s, '\n', it);
}
/**
* Splits a string into substrings separated by LF ('\n').
*/
#[cfg(not(stage0))]
pub fn each_line<'a>(s: &'a str, it: &fn(&'a str) -> bool) -> bool {
each_split_char_no_trailing(s, '\n', it)
}
@ -795,6 +961,7 @@ pub fn each_line<'a>(s: &'a str, it: &fn(&'a str) -> bool) {
* Splits a string into substrings separated by LF ('\n')
* and/or CR LF ("\r\n")
*/
#[cfg(stage0)]
pub fn each_line_any<'a>(s: &'a str, it: &fn(&'a str) -> bool) {
for each_line(s) |s| {
let l = s.len();
@ -805,9 +972,31 @@ pub fn each_line_any<'a>(s: &'a str, it: &fn(&'a str) -> bool) {
}
}
}
/**
* Splits a string into substrings separated by LF ('\n')
* and/or CR LF ("\r\n")
*/
#[cfg(not(stage0))]
pub fn each_line_any<'a>(s: &'a str, it: &fn(&'a str) -> bool) -> bool {
for each_line(s) |s| {
let l = s.len();
if l > 0u && s[l - 1u] == '\r' as u8 {
if !it( unsafe { raw::slice_bytes(s, 0, l - 1) } ) { return false; }
} else {
if !it( s ) { return false; }
}
}
return true;
}
/// Splits a string into substrings separated by whitespace
#[cfg(stage0)]
pub fn each_word<'a>(s: &'a str, it: &fn(&'a str) -> bool) {
each_split_nonempty(s, char::is_whitespace, it);
}
/// Splits a string into substrings separated by whitespace
#[cfg(not(stage0))]
pub fn each_word<'a>(s: &'a str, it: &fn(&'a str) -> bool) -> bool {
each_split_nonempty(s, char::is_whitespace, it)
}
@ -820,9 +1009,9 @@ pub fn each_word<'a>(s: &'a str, it: &fn(&'a str) -> bool) {
* Fails during iteration if the string contains a non-whitespace
* sequence longer than the limit.
*/
pub fn each_split_within<'a>(ss: &'a str,
lim: uint,
it: &fn(&'a str) -> bool) {
pub fn _each_split_within<'a>(ss: &'a str,
lim: uint,
it: &fn(&'a str) -> bool) -> bool {
// Just for fun, let's write this as an state machine:
enum SplitWithinState {
@ -880,6 +1069,20 @@ pub fn each_split_within<'a>(ss: &'a str,
machine(fake_i, ' ');
fake_i += 1;
}
return cont;
}
#[cfg(stage0)]
pub fn each_split_within<'a>(ss: &'a str,
lim: uint,
it: &fn(&'a str) -> bool) {
_each_split_within(ss, lim, it);
}
#[cfg(not(stage0))]
pub fn each_split_within<'a>(ss: &'a str,
lim: uint,
it: &fn(&'a str) -> bool) -> bool {
_each_split_within(ss, lim, it)
}
/**
@ -1158,12 +1361,20 @@ pub fn map(ss: &str, ff: &fn(char) -> char) -> ~str {
/// Iterate over the bytes in a string
#[inline(always)]
#[cfg(stage0)]
pub fn each(s: &str, it: &fn(u8) -> bool) {
eachi(s, |_i, b| it(b))
}
/// Iterate over the bytes in a string
#[inline(always)]
#[cfg(not(stage0))]
pub fn each(s: &str, it: &fn(u8) -> bool) -> bool {
eachi(s, |_i, b| it(b))
}
/// Iterate over the bytes in a string, with indices
#[inline(always)]
#[cfg(stage0)]
pub fn eachi(s: &str, it: &fn(uint, u8) -> bool) {
let mut pos = 0;
let len = s.len();
@ -1174,14 +1385,36 @@ pub fn eachi(s: &str, it: &fn(uint, u8) -> bool) {
}
}
/// Iterate over the bytes in a string, with indices
#[inline(always)]
#[cfg(not(stage0))]
pub fn eachi(s: &str, it: &fn(uint, u8) -> bool) -> bool {
let mut pos = 0;
let len = s.len();
while pos < len {
if !it(pos, s[pos]) { return false; }
pos += 1;
}
return true;
}
/// Iterate over the bytes in a string in reverse
#[inline(always)]
#[cfg(stage0)]
pub fn each_reverse(s: &str, it: &fn(u8) -> bool) {
eachi_reverse(s, |_i, b| it(b) )
}
/// Iterate over the bytes in a string in reverse
#[inline(always)]
#[cfg(not(stage0))]
pub fn each_reverse(s: &str, it: &fn(u8) -> bool) -> bool {
eachi_reverse(s, |_i, b| it(b) )
}
/// Iterate over the bytes in a string in reverse, with indices
#[inline(always)]
#[cfg(stage0)]
pub fn eachi_reverse(s: &str, it: &fn(uint, u8) -> bool) {
let mut pos = s.len();
while pos > 0 {
@ -1189,9 +1422,21 @@ pub fn eachi_reverse(s: &str, it: &fn(uint, u8) -> bool) {
if !it(pos, s[pos]) { break; }
}
}
/// Iterate over the bytes in a string in reverse, with indices
#[inline(always)]
#[cfg(not(stage0))]
pub fn eachi_reverse(s: &str, it: &fn(uint, u8) -> bool) -> bool {
let mut pos = s.len();
while pos > 0 {
pos -= 1;
if !it(pos, s[pos]) { return false; }
}
return true;
}
/// Iterate over each char of a string, without allocating
#[inline(always)]
#[cfg(stage0)]
pub fn each_char(s: &str, it: &fn(char) -> bool) {
let mut i = 0;
let len = len(s);
@ -1201,9 +1446,23 @@ pub fn each_char(s: &str, it: &fn(char) -> bool) {
i = next;
}
}
/// Iterate over each char of a string, without allocating
#[inline(always)]
#[cfg(not(stage0))]
pub fn each_char(s: &str, it: &fn(char) -> bool) -> bool {
let mut i = 0;
let len = len(s);
while i < len {
let CharRange {ch, next} = char_range_at(s, i);
if !it(ch) { return false; }
i = next;
}
return true;
}
/// Iterates over the chars in a string, with indices
#[inline(always)]
#[cfg(stage0)]
pub fn each_chari(s: &str, it: &fn(uint, char) -> bool) {
let mut pos = 0;
let mut ch_pos = 0u;
@ -1215,15 +1474,38 @@ pub fn each_chari(s: &str, it: &fn(uint, char) -> bool) {
ch_pos += 1u;
}
}
/// Iterates over the chars in a string, with indices
#[inline(always)]
#[cfg(not(stage0))]
pub fn each_chari(s: &str, it: &fn(uint, char) -> bool) -> bool {
let mut pos = 0;
let mut ch_pos = 0u;
let len = s.len();
while pos < len {
let CharRange {ch, next} = char_range_at(s, pos);
pos = next;
if !it(ch_pos, ch) { return false; }
ch_pos += 1u;
}
return true;
}
/// Iterates over the chars in a string in reverse
#[inline(always)]
#[cfg(stage0)]
pub fn each_char_reverse(s: &str, it: &fn(char) -> bool) {
each_chari_reverse(s, |_, c| it(c))
}
/// Iterates over the chars in a string in reverse
#[inline(always)]
#[cfg(not(stage0))]
pub fn each_char_reverse(s: &str, it: &fn(char) -> bool) -> bool {
each_chari_reverse(s, |_, c| it(c))
}
// Iterates over the chars in a string in reverse, with indices
#[inline(always)]
#[cfg(stage0)]
pub fn each_chari_reverse(s: &str, it: &fn(uint, char) -> bool) {
let mut pos = s.len();
let mut ch_pos = s.char_len();
@ -1236,6 +1518,21 @@ pub fn each_chari_reverse(s: &str, it: &fn(uint, char) -> bool) {
}
}
// Iterates over the chars in a string in reverse, with indices
#[inline(always)]
#[cfg(not(stage0))]
pub fn each_chari_reverse(s: &str, it: &fn(uint, char) -> bool) -> bool {
let mut pos = s.len();
let mut ch_pos = s.char_len();
while pos > 0 {
let CharRange {ch, next} = char_range_at_reverse(s, pos);
pos = next;
ch_pos -= 1;
if !it(ch_pos, ch) { return false; }
}
return true;
}
/*
Section: Searching
@ -2473,14 +2770,22 @@ pub trait StrSlice<'self> {
fn contains<'a>(&self, needle: &'a str) -> bool;
fn contains_char(&self, needle: char) -> bool;
fn char_iter(&self) -> StrCharIterator<'self>;
fn each(&self, it: &fn(u8) -> bool);
fn eachi(&self, it: &fn(uint, u8) -> bool);
fn each_reverse(&self, it: &fn(u8) -> bool);
fn eachi_reverse(&self, it: &fn(uint, u8) -> bool);
fn each_char(&self, it: &fn(char) -> bool);
fn each_chari(&self, it: &fn(uint, char) -> bool);
fn each_char_reverse(&self, it: &fn(char) -> bool);
fn each_chari_reverse(&self, it: &fn(uint, char) -> bool);
#[cfg(stage0)] fn each(&self, it: &fn(u8) -> bool);
#[cfg(not(stage0))] fn each(&self, it: &fn(u8) -> bool) -> bool;
#[cfg(stage0)] fn eachi(&self, it: &fn(uint, u8) -> bool);
#[cfg(not(stage0))] fn eachi(&self, it: &fn(uint, u8) -> bool) -> bool;
#[cfg(stage0)] fn each_reverse(&self, it: &fn(u8) -> bool);
#[cfg(not(stage0))] fn each_reverse(&self, it: &fn(u8) -> bool) -> bool;
#[cfg(stage0)] fn eachi_reverse(&self, it: &fn(uint, u8) -> bool);
#[cfg(not(stage0))] fn eachi_reverse(&self, it: &fn(uint, u8) -> bool) -> bool;
#[cfg(stage0)] fn each_char(&self, it: &fn(char) -> bool);
#[cfg(not(stage0))] fn each_char(&self, it: &fn(char) -> bool) -> bool;
#[cfg(stage0)] fn each_chari(&self, it: &fn(uint, char) -> bool);
#[cfg(not(stage0))] fn each_chari(&self, it: &fn(uint, char) -> bool) -> bool;
#[cfg(stage0)] fn each_char_reverse(&self, it: &fn(char) -> bool);
#[cfg(not(stage0))] fn each_char_reverse(&self, it: &fn(char) -> bool) -> bool;
#[cfg(stage0)] fn each_chari_reverse(&self, it: &fn(uint, char) -> bool);
#[cfg(not(stage0))] fn each_chari_reverse(&self, it: &fn(uint, char) -> bool) -> bool;
fn ends_with(&self, needle: &str) -> bool;
fn is_empty(&self) -> bool;
fn is_whitespace(&self) -> bool;
@ -2488,9 +2793,18 @@ pub trait StrSlice<'self> {
fn len(&self) -> uint;
fn char_len(&self) -> uint;
fn slice(&self, begin: uint, end: uint) -> &'self str;
#[cfg(stage0)]
fn each_split(&self, sepfn: &fn(char) -> bool, it: &fn(&'self str) -> bool);
#[cfg(not(stage0))]
fn each_split(&self, sepfn: &fn(char) -> bool, it: &fn(&'self str) -> bool) -> bool;
#[cfg(stage0)]
fn each_split_char(&self, sep: char, it: &fn(&'self str) -> bool);
#[cfg(not(stage0))]
fn each_split_char(&self, sep: char, it: &fn(&'self str) -> bool) -> bool;
#[cfg(stage0)]
fn each_split_str<'a>(&self, sep: &'a str, it: &fn(&'self str) -> bool);
#[cfg(not(stage0))]
fn each_split_str<'a>(&self, sep: &'a str, it: &fn(&'self str) -> bool) -> bool;
fn starts_with<'a>(&self, needle: &'a str) -> bool;
fn substr(&self, begin: uint, n: uint) -> &'self str;
fn escape_default(&self) -> ~str;
@ -2543,39 +2857,86 @@ impl<'self> StrSlice<'self> for &'self str {
/// Iterate over the bytes in a string
#[inline]
#[cfg(stage0)]
fn each(&self, it: &fn(u8) -> bool) { each(*self, it) }
/// Iterate over the bytes in a string, with indices
#[inline]
fn eachi(&self, it: &fn(uint, u8) -> bool) { eachi(*self, it) }
/// Iterate over the bytes in a string
#[inline]
fn each_reverse(&self, it: &fn(u8) -> bool) {
each_reverse(*self, it)
#[cfg(not(stage0))]
fn each(&self, it: &fn(u8) -> bool) -> bool { each(*self, it) }
/// Iterate over the bytes in a string, with indices
#[inline]
#[cfg(stage0)]
fn eachi(&self, it: &fn(uint, u8) -> bool) { eachi(*self, it) }
/// Iterate over the bytes in a string, with indices
#[inline]
#[cfg(not(stage0))]
fn eachi(&self, it: &fn(uint, u8) -> bool) -> bool { eachi(*self, it) }
/// Iterate over the bytes in a string
#[inline]
#[cfg(stage0)]
fn each_reverse(&self, it: &fn(u8) -> bool) { each_reverse(*self, it) }
/// Iterate over the bytes in a string
#[inline]
#[cfg(not(stage0))]
fn each_reverse(&self, it: &fn(u8) -> bool) -> bool { each_reverse(*self, it) }
/// Iterate over the bytes in a string, with indices
#[inline]
#[cfg(stage0)]
fn eachi_reverse(&self, it: &fn(uint, u8) -> bool) {
eachi_reverse(*self, it)
}
/// Iterate over the bytes in a string, with indices
#[inline]
fn eachi_reverse(&self, it: &fn(uint, u8) -> bool) {
#[cfg(not(stage0))]
fn eachi_reverse(&self, it: &fn(uint, u8) -> bool) -> bool {
eachi_reverse(*self, it)
}
/// Iterate over the chars in a string
#[inline]
#[cfg(stage0)]
fn each_char(&self, it: &fn(char) -> bool) { each_char(*self, it) }
/// Iterate over the chars in a string
#[inline]
#[cfg(not(stage0))]
fn each_char(&self, it: &fn(char) -> bool) -> bool { each_char(*self, it) }
/// Iterate over the chars in a string, with indices
#[inline]
#[cfg(stage0)]
fn each_chari(&self, it: &fn(uint, char) -> bool) {
each_chari(*self, it)
}
/// Iterate over the chars in a string, with indices
#[inline]
#[cfg(not(stage0))]
fn each_chari(&self, it: &fn(uint, char) -> bool) -> bool {
each_chari(*self, it)
}
/// Iterate over the chars in a string in reverse
#[inline]
#[cfg(stage0)]
fn each_char_reverse(&self, it: &fn(char) -> bool) {
each_char_reverse(*self, it)
}
/// Iterate over the chars in a string in reverse
#[inline]
#[cfg(not(stage0))]
fn each_char_reverse(&self, it: &fn(char) -> bool) -> bool {
each_char_reverse(*self, it)
}
/// Iterate over the chars in a string in reverse, with indices from the
/// end
#[inline]
#[cfg(stage0)]
fn each_chari_reverse(&self, it: &fn(uint, char) -> bool) {
each_chari_reverse(*self, it)
}
/// Iterate over the chars in a string in reverse, with indices from the
/// end
#[inline]
#[cfg(not(stage0))]
fn each_chari_reverse(&self, it: &fn(uint, char) -> bool) -> bool {
each_chari_reverse(*self, it)
}
/// Returns true if one string ends with another
#[inline]
fn ends_with(&self, needle: &str) -> bool {
@ -2617,24 +2978,50 @@ impl<'self> StrSlice<'self> for &'self str {
}
/// Splits a string into substrings using a character function
#[inline]
#[cfg(stage0)]
fn each_split(&self, sepfn: &fn(char) -> bool, it: &fn(&'self str) -> bool) {
each_split(*self, sepfn, it)
}
/// Splits a string into substrings using a character function
#[inline]
#[cfg(not(stage0))]
fn each_split(&self, sepfn: &fn(char) -> bool, it: &fn(&'self str) -> bool) -> bool {
each_split(*self, sepfn, it)
}
/**
* Splits a string into substrings at each occurrence of a given character
*/
#[inline]
#[cfg(stage0)]
fn each_split_char(&self, sep: char, it: &fn(&'self str) -> bool) {
each_split_char(*self, sep, it)
}
/**
* Splits a string into substrings at each occurrence of a given character
*/
#[inline]
#[cfg(not(stage0))]
fn each_split_char(&self, sep: char, it: &fn(&'self str) -> bool) -> bool {
each_split_char(*self, sep, it)
}
/**
* Splits a string into a vector of the substrings separated by a given
* string
*/
#[inline]
#[cfg(stage0)]
fn each_split_str<'a>(&self, sep: &'a str, it: &fn(&'self str) -> bool) {
each_split_str(*self, sep, it)
}
/**
* Splits a string into a vector of the substrings separated by a given
* string
*/
#[inline]
#[cfg(not(stage0))]
fn each_split_str<'a>(&self, sep: &'a str, it: &fn(&'self str) -> bool) -> bool {
each_split_str(*self, sep, it)
}
/// Returns true if one string starts with another
#[inline]
fn starts_with<'a>(&self, needle: &'a str) -> bool {

13
src/libcore/task/spawn.rs
View file

@ -110,9 +110,14 @@ fn taskset_remove(tasks: &mut TaskSet, task: *rust_task) {
let was_present = tasks.remove(&task);
assert!(was_present);
}
#[cfg(stage0)]
pub fn taskset_each(tasks: &TaskSet, blk: &fn(v: *rust_task) -> bool) {
tasks.each(|k| blk(*k))
}
#[cfg(not(stage0))]
pub fn taskset_each(tasks: &TaskSet, blk: &fn(v: *rust_task) -> bool) -> bool {
tasks.each(|k| blk(*k))
}
// One of these per group of linked-failure tasks.
struct TaskGroupData {
@ -685,13 +690,11 @@ fn spawn_raw_oldsched(mut opts: TaskOpts, f: ~fn()) {
};
// Attempt to join every ancestor group.
result =
for each_ancestor(ancestors, Some(bail)) |ancestor_tg| {
each_ancestor(ancestors, Some(bail), |ancestor_tg| {
// Enlist as a descendant, not as an actual member.
// Descendants don't kill ancestor groups on failure.
if !enlist_in_taskgroup(ancestor_tg, child, false) {
break;
}
};
enlist_in_taskgroup(ancestor_tg, child, false)
});
// If any ancestor group fails, need to exit this group too.
if !result {
do access_group(child_arc) |child_tg| {

396
src/libcore/to_bytes.rs
View file

@ -21,6 +21,11 @@ use str;
pub type Cb<'self> = &'self fn(buf: &[u8]) -> bool;
#[cfg(stage0)]
pub trait IterBytes {
fn iter_bytes(&self, lsb0: bool, f: Cb);
}
/**
* A trait to implement in order to make a type hashable;
* This works in combination with the trait `Hash::Hash`, and
@ -28,6 +33,7 @@ pub type Cb<'self> = &'self fn(buf: &[u8]) -> bool;
* modified when default methods and trait inheritence are
* completed.
*/
#[cfg(not(stage0))]
pub trait IterBytes {
/**
* Call the provided callback `f` one or more times with
@ -43,9 +49,10 @@ pub trait IterBytes {
* left-to-right in declaration order, regardless of
* underlying memory endianness.
*/
fn iter_bytes(&self, lsb0: bool, f: Cb);
fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool;
}
#[cfg(stage0)]
impl IterBytes for bool {
#[inline(always)]
fn iter_bytes(&self, _lsb0: bool, f: Cb) {
@ -54,7 +61,17 @@ impl IterBytes for bool {
]);
}
}
#[cfg(not(stage0))]
impl IterBytes for bool {
#[inline(always)]
fn iter_bytes(&self, _lsb0: bool, f: Cb) -> bool {
f([
*self as u8
])
}
}
#[cfg(stage0)]
impl IterBytes for u8 {
#[inline(always)]
fn iter_bytes(&self, _lsb0: bool, f: Cb) {
@ -63,7 +80,17 @@ impl IterBytes for u8 {
]);
}
}
#[cfg(not(stage0))]
impl IterBytes for u8 {
#[inline(always)]
fn iter_bytes(&self, _lsb0: bool, f: Cb) -> bool {
f([
*self
])
}
}
#[cfg(stage0)]
impl IterBytes for u16 {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) {
@ -80,7 +107,25 @@ impl IterBytes for u16 {
}
}
}
#[cfg(not(stage0))]
impl IterBytes for u16 {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
if lsb0 {
f([
*self as u8,
(*self >> 8) as u8
])
} else {
f([
(*self >> 8) as u8,
*self as u8
])
}
}
}
#[cfg(stage0)]
impl IterBytes for u32 {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) {
@ -101,7 +146,29 @@ impl IterBytes for u32 {
}
}
}
#[cfg(not(stage0))]
impl IterBytes for u32 {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
if lsb0 {
f([
*self as u8,
(*self >> 8) as u8,
(*self >> 16) as u8,
(*self >> 24) as u8,
])
} else {
f([
(*self >> 24) as u8,
(*self >> 16) as u8,
(*self >> 8) as u8,
*self as u8
])
}
}
}
#[cfg(stage0)]
impl IterBytes for u64 {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) {
@ -130,73 +197,157 @@ impl IterBytes for u64 {
}
}
}
#[cfg(not(stage0))]
impl IterBytes for u64 {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
if lsb0 {
f([
*self as u8,
(*self >> 8) as u8,
(*self >> 16) as u8,
(*self >> 24) as u8,
(*self >> 32) as u8,
(*self >> 40) as u8,
(*self >> 48) as u8,
(*self >> 56) as u8
])
} else {
f([
(*self >> 56) as u8,
(*self >> 48) as u8,
(*self >> 40) as u8,
(*self >> 32) as u8,
(*self >> 24) as u8,
(*self >> 16) as u8,
(*self >> 8) as u8,
*self as u8
])
}
}
}
#[cfg(stage0)]
impl IterBytes for i8 {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) {
(*self as u8).iter_bytes(lsb0, f)
}
}
#[cfg(not(stage0))]
impl IterBytes for i8 {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
(*self as u8).iter_bytes(lsb0, f)
}
}
#[cfg(stage0)]
impl IterBytes for i16 {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) {
(*self as u16).iter_bytes(lsb0, f)
}
}
#[cfg(not(stage0))]
impl IterBytes for i16 {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
(*self as u16).iter_bytes(lsb0, f)
}
}
#[cfg(stage0)]
impl IterBytes for i32 {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) {
(*self as u32).iter_bytes(lsb0, f)
}
}
#[cfg(not(stage0))]
impl IterBytes for i32 {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
(*self as u32).iter_bytes(lsb0, f)
}
}
#[cfg(stage0)]
impl IterBytes for i64 {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) {
(*self as u64).iter_bytes(lsb0, f)
}
}
#[cfg(not(stage0))]
impl IterBytes for i64 {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
(*self as u64).iter_bytes(lsb0, f)
}
}
#[cfg(stage0)]
impl IterBytes for char {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) {
(*self as u32).iter_bytes(lsb0, f)
}
}
#[cfg(target_word_size = "32")]
pub mod x32 {
use to_bytes::{Cb, IterBytes};
impl IterBytes for uint {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) {
(*self as u32).iter_bytes(lsb0, f)
}
#[cfg(not(stage0))]
impl IterBytes for char {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
(*self as u32).iter_bytes(lsb0, f)
}
}
#[cfg(target_word_size = "64")]
pub mod x64 {
use to_bytes::{Cb, IterBytes};
impl IterBytes for uint {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) {
(*self as u64).iter_bytes(lsb0, f)
}
#[cfg(target_word_size = "32", stage0)]
impl IterBytes for uint {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) {
(*self as u32).iter_bytes(lsb0, f)
}
}
#[cfg(target_word_size = "32", not(stage0))]
impl IterBytes for uint {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
(*self as u32).iter_bytes(lsb0, f)
}
}
#[cfg(target_word_size = "64", stage0)]
impl IterBytes for uint {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) {
(*self as u64).iter_bytes(lsb0, f)
}
}
#[cfg(target_word_size = "64", not(stage0))]
impl IterBytes for uint {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
(*self as u64).iter_bytes(lsb0, f)
}
}
#[cfg(stage0)]
impl IterBytes for int {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) {
(*self as uint).iter_bytes(lsb0, f)
}
}
#[cfg(not(stage0))]
impl IterBytes for int {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
(*self as uint).iter_bytes(lsb0, f)
}
}
#[cfg(stage0)]
impl<'self,A:IterBytes> IterBytes for &'self [A] {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) {
@ -207,7 +358,15 @@ impl<'self,A:IterBytes> IterBytes for &'self [A] {
}
}
}
#[cfg(not(stage0))]
impl<'self,A:IterBytes> IterBytes for &'self [A] {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
self.each(|elt| elt.iter_bytes(lsb0, |b| f(b)))
}
}
#[cfg(stage0)]
impl<A:IterBytes,B:IterBytes> IterBytes for (A,B) {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) {
@ -218,7 +377,17 @@ impl<A:IterBytes,B:IterBytes> IterBytes for (A,B) {
}
}
}
#[cfg(not(stage0))]
impl<A:IterBytes,B:IterBytes> IterBytes for (A,B) {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
match *self {
(ref a, ref b) => { a.iter_bytes(lsb0, f) && b.iter_bytes(lsb0, f) }
}
}
}
#[cfg(stage0)]
impl<A:IterBytes,B:IterBytes,C:IterBytes> IterBytes for (A,B,C) {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) {
@ -229,26 +398,57 @@ impl<A:IterBytes,B:IterBytes,C:IterBytes> IterBytes for (A,B,C) {
}
}
}
#[cfg(not(stage0))]
impl<A:IterBytes,B:IterBytes,C:IterBytes> IterBytes for (A,B,C) {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
match *self {
(ref a, ref b, ref c) => {
a.iter_bytes(lsb0, f) && b.iter_bytes(lsb0, f) && c.iter_bytes(lsb0, f)
}
}
}
}
// Move this to vec, probably.
fn borrow<'x,A>(a: &'x [A]) -> &'x [A] {
a
}
#[cfg(stage0)]
impl<A:IterBytes> IterBytes for ~[A] {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) {
borrow(*self).iter_bytes(lsb0, f)
}
}
#[cfg(not(stage0))]
impl<A:IterBytes> IterBytes for ~[A] {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
borrow(*self).iter_bytes(lsb0, f)
}
}
#[cfg(stage0)]
impl<A:IterBytes> IterBytes for @[A] {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) {
borrow(*self).iter_bytes(lsb0, f)
}
}
#[cfg(not(stage0))]
impl<A:IterBytes> IterBytes for @[A] {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
borrow(*self).iter_bytes(lsb0, f)
}
}
// NOTE: remove all of these after a snapshot, the new for-loop iteration
// protocol makes these unnecessary.
#[cfg(stage0)]
pub fn iter_bytes_2<A:IterBytes,B:IterBytes>(a: &A, b: &B,
lsb0: bool, z: Cb) {
let mut flag = true;
@ -256,11 +456,17 @@ pub fn iter_bytes_2<A:IterBytes,B:IterBytes>(a: &A, b: &B,
if !flag { return; }
b.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
}
#[cfg(not(stage0))]
pub fn iter_bytes_2<A:IterBytes,B:IterBytes>(a: &A, b: &B,
lsb0: bool, z: Cb) -> bool {
a.iter_bytes(lsb0, z) && b.iter_bytes(lsb0, z)
}
#[cfg(stage0)]
pub fn iter_bytes_3<A: IterBytes,
B: IterBytes,
C: IterBytes>(a: &A, b: &B, c: &C,
lsb0: bool, z: Cb) {
B: IterBytes,
C: IterBytes>(a: &A, b: &B, c: &C,
lsb0: bool, z: Cb) {
let mut flag = true;
a.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
if !flag { return; }
@ -268,7 +474,14 @@ pub fn iter_bytes_3<A: IterBytes,
if !flag { return; }
c.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
}
#[cfg(not(stage0))]
pub fn iter_bytes_3<A: IterBytes,
B: IterBytes,
C: IterBytes>(a: &A, b: &B, c: &C, lsb0: bool, z: Cb) -> bool {
a.iter_bytes(lsb0, z) && b.iter_bytes(lsb0, z) && c.iter_bytes(lsb0, z)
}
#[cfg(stage0)]
pub fn iter_bytes_4<A: IterBytes,
B: IterBytes,
C: IterBytes,
@ -284,7 +497,18 @@ pub fn iter_bytes_4<A: IterBytes,
if !flag { return; }
d.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
}
#[cfg(not(stage0))]
pub fn iter_bytes_4<A: IterBytes,
B: IterBytes,
C: IterBytes,
D: IterBytes>(a: &A, b: &B, c: &C,
d: &D,
lsb0: bool, z: Cb) -> bool {
a.iter_bytes(lsb0, z) && b.iter_bytes(lsb0, z) && c.iter_bytes(lsb0, z) &&
d.iter_bytes(lsb0, z)
}
#[cfg(stage0)]
pub fn iter_bytes_5<A: IterBytes,
B: IterBytes,
C: IterBytes,
@ -303,55 +527,19 @@ pub fn iter_bytes_5<A: IterBytes,
if !flag { return; }
e.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
}
pub fn iter_bytes_6<A: IterBytes,
#[cfg(not(stage0))]
pub fn iter_bytes_5<A: IterBytes,
B: IterBytes,
C: IterBytes,
D: IterBytes,
E: IterBytes,
F: IterBytes>(a: &A, b: &B, c: &C,
d: &D, e: &E, f: &F,
lsb0: bool, z: Cb) {
let mut flag = true;
a.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
if !flag { return; }
b.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
if !flag { return; }
c.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
if !flag { return; }
d.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
if !flag { return; }
e.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
if !flag { return; }
f.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
}
pub fn iter_bytes_7<A: IterBytes,
B: IterBytes,
C: IterBytes,
D: IterBytes,
E: IterBytes,
F: IterBytes,
G: IterBytes>(a: &A, b: &B, c: &C,
d: &D, e: &E, f: &F,
g: &G,
lsb0: bool, z: Cb) {
let mut flag = true;
a.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
if !flag { return; }
b.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
if !flag { return; }
c.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
if !flag { return; }
d.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
if !flag { return; }
e.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
if !flag { return; }
f.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
if !flag { return; }
g.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
E: IterBytes>(a: &A, b: &B, c: &C,
d: &D, e: &E,
lsb0: bool, z: Cb) -> bool {
a.iter_bytes(lsb0, z) && b.iter_bytes(lsb0, z) && c.iter_bytes(lsb0, z) &&
d.iter_bytes(lsb0, z) && e.iter_bytes(lsb0, z)
}
#[cfg(stage0)]
impl<'self> IterBytes for &'self str {
#[inline(always)]
fn iter_bytes(&self, _lsb0: bool, f: Cb) {
@ -360,7 +548,17 @@ impl<'self> IterBytes for &'self str {
}
}
}
#[cfg(not(stage0))]
impl<'self> IterBytes for &'self str {
#[inline(always)]
fn iter_bytes(&self, _lsb0: bool, f: Cb) -> bool {
do str::byte_slice(*self) |bytes| {
f(bytes)
}
}
}
#[cfg(stage0)]
impl IterBytes for ~str {
#[inline(always)]
fn iter_bytes(&self, _lsb0: bool, f: Cb) {
@ -369,7 +567,17 @@ impl IterBytes for ~str {
}
}
}
#[cfg(not(stage0))]
impl IterBytes for ~str {
#[inline(always)]
fn iter_bytes(&self, _lsb0: bool, f: Cb) -> bool {
do str::byte_slice(*self) |bytes| {
f(bytes)
}
}
}
#[cfg(stage0)]
impl IterBytes for @str {
#[inline(always)]
fn iter_bytes(&self, _lsb0: bool, f: Cb) {
@ -378,7 +586,17 @@ impl IterBytes for @str {
}
}
}
#[cfg(not(stage0))]
impl IterBytes for @str {
#[inline(always)]
fn iter_bytes(&self, _lsb0: bool, f: Cb) -> bool {
do str::byte_slice(*self) |bytes| {
f(bytes)
}
}
}
#[cfg(stage0)]
impl<A:IterBytes> IterBytes for Option<A> {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) {
@ -388,36 +606,80 @@ impl<A:IterBytes> IterBytes for Option<A> {
}
}
}
#[cfg(not(stage0))]
impl<A:IterBytes> IterBytes for Option<A> {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
match *self {
Some(ref a) => 0u8.iter_bytes(lsb0, f) && a.iter_bytes(lsb0, f),
None => 1u8.iter_bytes(lsb0, f)
}
}
}
#[cfg(stage0)]
impl<'self,A:IterBytes> IterBytes for &'self A {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) {
(**self).iter_bytes(lsb0, f);
}
}
#[cfg(not(stage0))]
impl<'self,A:IterBytes> IterBytes for &'self A {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
(**self).iter_bytes(lsb0, f)
}
}
#[cfg(stage0)]
impl<A:IterBytes> IterBytes for @A {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) {
(**self).iter_bytes(lsb0, f);
}
}
#[cfg(not(stage0))]
impl<A:IterBytes> IterBytes for @A {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
(**self).iter_bytes(lsb0, f)
}
}
#[cfg(stage0)]
impl<A:IterBytes> IterBytes for ~A {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) {
(**self).iter_bytes(lsb0, f);
}
}
#[cfg(not(stage0))]
impl<A:IterBytes> IterBytes for ~A {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
(**self).iter_bytes(lsb0, f)
}
}
// NB: raw-pointer IterBytes does _not_ dereference
// to the target; it just gives you the pointer-bytes.
#[cfg(stage0)]
impl<A> IterBytes for *const A {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) {
(*self as uint).iter_bytes(lsb0, f);
}
}
// NB: raw-pointer IterBytes does _not_ dereference
// to the target; it just gives you the pointer-bytes.
#[cfg(not(stage0))]
impl<A> IterBytes for *const A {
#[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
(*self as uint).iter_bytes(lsb0, f)
}
}
pub trait ToBytes {
fn to_bytes(&self, lsb0: bool) -> ~[u8];

62
src/libcore/trie.rs
View file

@ -57,28 +57,60 @@ impl<T> Map<uint, T> for TrieMap<T> {
/// Visit all key-value pairs in order
#[inline(always)]
#[cfg(stage0)]
fn each<'a>(&'a self, f: &fn(&uint, &'a T) -> bool) {
self.root.each(f);
}
/// Visit all key-value pairs in order
#[inline(always)]
#[cfg(not(stage0))]
fn each<'a>(&'a self, f: &fn(&uint, &'a T) -> bool) -> bool {
self.root.each(f)
}
/// Visit all keys in order
#[inline(always)]
#[cfg(stage0)]
fn each_key(&self, f: &fn(&uint) -> bool) {
self.each(|k, _| f(k))
}
/// Visit all keys in order
#[inline(always)]
#[cfg(not(stage0))]
fn each_key(&self, f: &fn(&uint) -> bool) -> bool {
self.each(|k, _| f(k))
}
/// Visit all values in order
#[inline(always)]
#[cfg(stage0)]
fn each_value<'a>(&'a self, f: &fn(&'a T) -> bool) {
self.each(|_, v| f(v))
}
/// Visit all values in order
#[inline(always)]
#[cfg(not(stage0))]
fn each_value<'a>(&'a self, f: &fn(&'a T) -> bool) -> bool {
self.each(|_, v| f(v))
}
/// Iterate over the map and mutate the contained values
#[inline(always)]
#[cfg(stage0)]
fn mutate_values(&mut self, f: &fn(&uint, &mut T) -> bool) {
self.root.mutate_values(f);
}
/// Iterate over the map and mutate the contained values
#[inline(always)]
#[cfg(not(stage0))]
fn mutate_values(&mut self, f: &fn(&uint, &mut T) -> bool) -> bool {
self.root.mutate_values(f)
}
/// Return a reference to the value corresponding to the key
#[inline(hint)]
fn find<'a>(&'a self, key: &uint) -> Option<&'a T> {
@ -151,21 +183,43 @@ pub impl<T> TrieMap<T> {
/// Visit all key-value pairs in reverse order
#[inline(always)]
#[cfg(stage0)]
fn each_reverse<'a>(&'a self, f: &fn(&uint, &'a T) -> bool) {
self.root.each_reverse(f);
}
/// Visit all key-value pairs in reverse order
#[inline(always)]
#[cfg(not(stage0))]
fn each_reverse<'a>(&'a self, f: &fn(&uint, &'a T) -> bool) -> bool {
self.root.each_reverse(f)
}
/// Visit all keys in reverse order
#[inline(always)]
#[cfg(stage0)]
fn each_key_reverse(&self, f: &fn(&uint) -> bool) {
self.each_reverse(|k, _| f(k))
}
/// Visit all keys in reverse order
#[inline(always)]
#[cfg(not(stage0))]
fn each_key_reverse(&self, f: &fn(&uint) -> bool) -> bool {
self.each_reverse(|k, _| f(k))
}
/// Visit all values in reverse order
#[inline(always)]
#[cfg(stage0)]
fn each_value_reverse(&self, f: &fn(&T) -> bool) {
self.each_reverse(|_, v| f(v))
}
/// Visit all values in reverse order
#[inline(always)]
#[cfg(not(stage0))]
fn each_value_reverse(&self, f: &fn(&T) -> bool) -> bool {
self.each_reverse(|_, v| f(v))
}
}
pub struct TrieSet {
@ -175,7 +229,10 @@ pub struct TrieSet {
impl BaseIter<uint> for TrieSet {
/// Visit all values in order
#[inline(always)]
#[cfg(stage0)]
fn each(&self, f: &fn(&uint) -> bool) { self.map.each_key(f) }
#[cfg(not(stage0))]
fn each(&self, f: &fn(&uint) -> bool) -> bool { self.map.each_key(f) }
#[inline(always)]
fn size_hint(&self) -> Option<uint> { Some(self.len()) }
}
@ -183,9 +240,14 @@ impl BaseIter<uint> for TrieSet {
impl ReverseIter<uint> for TrieSet {
/// Visit all values in reverse order
#[inline(always)]
#[cfg(stage0)]
fn each_reverse(&self, f: &fn(&uint) -> bool) {
self.map.each_key_reverse(f)
}
#[cfg(not(stage0))]
fn each_reverse(&self, f: &fn(&uint) -> bool) -> bool {
self.map.each_key_reverse(f)
}
}
impl Container for TrieSet {

213
src/libcore/vec.rs
View file

@ -1489,13 +1489,14 @@ pub fn reversed<T:Copy>(v: &const [T]) -> ~[T] {
* ~~~
*/
#[inline(always)]
pub fn each<'r,T>(v: &'r [T], f: &fn(&'r T) -> bool) {
pub fn _each<'r,T>(v: &'r [T], f: &fn(&'r T) -> bool) -> bool {
// ^^^^
// NB---this CANNOT be &const [T]! The reason
// is that you are passing it to `f()` using
// an immutable.
do vec::as_imm_buf(v) |p, n| {
let mut broke = false;
do as_imm_buf(v) |p, n| {
let mut n = n;
let mut p = p;
while n > 0u {
@ -1506,42 +1507,69 @@ pub fn each<'r,T>(v: &'r [T], f: &fn(&'r T) -> bool) {
}
n -= 1u;
}
broke = n > 0;
}
return true;
}
#[cfg(stage0)]
pub fn each<'r,T>(v: &'r [T], f: &fn(&'r T) -> bool) { _each(v, f); }
#[cfg(not(stage0))]
pub fn each<'r,T>(v: &'r [T], f: &fn(&'r T) -> bool) -> bool { _each(v, f) }
/// Like `each()`, but for the case where you have
/// a vector with mutable contents and you would like
/// to mutate the contents as you iterate.
#[inline(always)]
pub fn each_mut<'r,T>(v: &'r mut [T], f: &fn(elem: &'r mut T) -> bool) {
do vec::as_mut_buf(v) |p, n| {
pub fn _each_mut<'r,T>(v: &'r mut [T], f: &fn(elem: &'r mut T) -> bool) -> bool {
let mut broke = false;
do as_mut_buf(v) |p, n| {
let mut n = n;
let mut p = p;
while n > 0 {
unsafe {
let q: &'r mut T = cast::transmute_mut_region(&mut *p);
if !f(q) {
break;
}
if !f(q) { break; }
p = p.offset(1);
}
n -= 1;
}
broke = n > 0;
}
return broke;
}
#[cfg(stage0)]
pub fn each_mut<'r,T>(v: &'r mut [T], f: &fn(elem: &'r mut T) -> bool) {
_each_mut(v, f);
}
#[cfg(not(stage0))]
pub fn each_mut<'r,T>(v: &'r mut [T], f: &fn(elem: &'r mut T) -> bool) -> bool {
_each_mut(v, f)
}
/// Like `each()`, but for the case where you have a vector that *may or may
/// not* have mutable contents.
#[inline(always)]
pub fn each_const<T>(v: &const [T], f: &fn(elem: &const T) -> bool) {
pub fn _each_const<T>(v: &const [T], f: &fn(elem: &const T) -> bool) -> bool {
let mut i = 0;
let n = v.len();
while i < n {
if !f(&const v[i]) {
return;
return false;
}
i += 1;
}
return true;
}
#[cfg(stage0)]
pub fn each_const<t>(v: &const [t], f: &fn(elem: &const t) -> bool) {
_each_const(v, f);
}
#[cfg(not(stage0))]
pub fn each_const<t>(v: &const [t], f: &fn(elem: &const t) -> bool) -> bool {
_each_const(v, f)
}
/**
@ -1550,12 +1578,20 @@ pub fn each_const<T>(v: &const [T], f: &fn(elem: &const T) -> bool) {
* Return true to continue, false to break.
*/
#[inline(always)]
pub fn eachi<'r,T>(v: &'r [T], f: &fn(uint, v: &'r T) -> bool) {
pub fn _eachi<'r,T>(v: &'r [T], f: &fn(uint, v: &'r T) -> bool) -> bool {
let mut i = 0;
for each(v) |p| {
if !f(i, p) { return; }
if !f(i, p) { return false; }
i += 1;
}
return true;
}
#[cfg(stage0)]
pub fn eachi<'r,T>(v: &'r [T], f: &fn(uint, v: &'r T) -> bool) { _eachi(v, f); }
#[cfg(not(stage0))]
pub fn eachi<'r,T>(v: &'r [T], f: &fn(uint, v: &'r T) -> bool) -> bool {
_eachi(v, f)
}
/**
@ -1564,14 +1600,26 @@ pub fn eachi<'r,T>(v: &'r [T], f: &fn(uint, v: &'r T) -> bool) {
* Return true to continue, false to break.
*/
#[inline(always)]
pub fn eachi_mut<'r,T>(v: &'r mut [T], f: &fn(uint, v: &'r mut T) -> bool) {
pub fn _eachi_mut<'r,T>(v: &'r mut [T],
f: &fn(uint, v: &'r mut T) -> bool) -> bool {
let mut i = 0;
for each_mut(v) |p| {
if !f(i, p) {
return;
return false;
}
i += 1;
}
return true;
}
#[cfg(stage0)]
pub fn eachi_mut<'r,T>(v: &'r mut [T], f: &fn(uint, v: &'r mut T) -> bool) {
_eachi_mut(v, f);
}
#[cfg(not(stage0))]
pub fn eachi_mut<'r,T>(v: &'r mut [T],
f: &fn(uint, v: &'r mut T) -> bool) -> bool {
_eachi_mut(v, f)
}
/**
@ -1580,8 +1628,17 @@ pub fn eachi_mut<'r,T>(v: &'r mut [T], f: &fn(uint, v: &'r mut T) -> bool) {
* Return true to continue, false to break.
*/
#[inline(always)]
pub fn _each_reverse<'r,T>(v: &'r [T], blk: &fn(v: &'r T) -> bool) -> bool {
_eachi_reverse(v, |_i, v| blk(v))
}
#[cfg(stage0)]
pub fn each_reverse<'r,T>(v: &'r [T], blk: &fn(v: &'r T) -> bool) {
eachi_reverse(v, |_i, v| blk(v))
_each_reverse(v, blk);
}
#[cfg(not(stage0))]
pub fn each_reverse<'r,T>(v: &'r [T], blk: &fn(v: &'r T) -> bool) -> bool {
_each_reverse(v, blk)
}
/**
@ -1590,14 +1647,26 @@ pub fn each_reverse<'r,T>(v: &'r [T], blk: &fn(v: &'r T) -> bool) {
* Return true to continue, false to break.
*/
#[inline(always)]
pub fn eachi_reverse<'r,T>(v: &'r [T], blk: &fn(i: uint, v: &'r T) -> bool) {
pub fn _eachi_reverse<'r,T>(v: &'r [T],
blk: &fn(i: uint, v: &'r T) -> bool) -> bool {
let mut i = v.len();
while i > 0 {
i -= 1;
if !blk(i, &v[i]) {
return;
return false;
}
}
return true;
}
#[cfg(stage0)]
pub fn eachi_reverse<'r,T>(v: &'r [T], blk: &fn(i: uint, v: &'r T) -> bool) {
_eachi_reverse(v, blk);
}
#[cfg(not(stage0))]
pub fn eachi_reverse<'r,T>(v: &'r [T],
blk: &fn(i: uint, v: &'r T) -> bool) -> bool {
_eachi_reverse(v, blk)
}
/**
@ -1608,13 +1677,23 @@ pub fn eachi_reverse<'r,T>(v: &'r [T], blk: &fn(i: uint, v: &'r T) -> bool) {
* Both vectors must have the same length
*/
#[inline]
pub fn each2<U, T>(v1: &[U], v2: &[T], f: &fn(u: &U, t: &T) -> bool) {
pub fn _each2<U, T>(v1: &[U], v2: &[T], f: &fn(u: &U, t: &T) -> bool) -> bool {
assert!(len(v1) == len(v2));
for uint::range(0u, len(v1)) |i| {
if !f(&v1[i], &v2[i]) {
return;
return false;
}
}
return true;
}
#[cfg(stage0)]
pub fn each2<U, T>(v1: &[U], v2: &[T], f: &fn(u: &U, t: &T) -> bool) {
_each2(v1, v2, f);
}
#[cfg(not(stage0))]
pub fn each2<U, T>(v1: &[U], v2: &[T], f: &fn(u: &U, t: &T) -> bool) -> bool {
_each2(v1, v2, f)
}
/**
@ -1627,7 +1706,8 @@ pub fn each2<U, T>(v1: &[U], v2: &[T], f: &fn(u: &U, t: &T) -> bool) {
* The total number of permutations produced is `len(v)!`. If `v` contains
* repeated elements, then some permutations are repeated.
*/
pub fn each_permutation<T:Copy>(v: &[T], put: &fn(ts: &[T]) -> bool) {
#[cfg(not(stage0))]
pub fn each_permutation<T:Copy>(v: &[T], put: &fn(ts: &[T]) -> bool) -> bool {
let ln = len(v);
if ln <= 1 {
put(v);
@ -1641,12 +1721,13 @@ pub fn each_permutation<T:Copy>(v: &[T], put: &fn(ts: &[T]) -> bool) {
rest.push_all(const_slice(v, i+1u, ln));
for each_permutation(rest) |permutation| {
if !put(append(~[elt], permutation)) {
return;
return false;
}
}
i += 1u;
}
}
return true;
}
/**
@ -1932,8 +2013,14 @@ pub trait ImmutableVector<'self, T> {
fn initn(&self, n: uint) -> &'self [T];
fn last(&self) -> &'self T;
fn last_opt(&self) -> Option<&'self T>;
#[cfg(stage0)]
fn each_reverse(&self, blk: &fn(&T) -> bool);
#[cfg(not(stage0))]
fn each_reverse(&self, blk: &fn(&T) -> bool) -> bool;
#[cfg(stage0)]
fn eachi_reverse(&self, blk: &fn(uint, &T) -> bool);
#[cfg(not(stage0))]
fn eachi_reverse(&self, blk: &fn(uint, &T) -> bool) -> bool;
fn foldr<'a, U>(&'a self, z: U, p: &fn(t: &'a T, u: U) -> U) -> U;
fn map<U>(&self, f: &fn(t: &T) -> U) -> ~[U];
fn mapi<U>(&self, f: &fn(uint, t: &T) -> U) -> ~[U];
@ -1995,15 +2082,29 @@ impl<'self,T> ImmutableVector<'self, T> for &'self [T] {
/// Iterates over a vector's elements in reverse.
#[inline]
#[cfg(stage0)]
fn each_reverse(&self, blk: &fn(&T) -> bool) {
each_reverse(*self, blk)
}
/// Iterates over a vector's elements in reverse.
#[inline]
#[cfg(not(stage0))]
fn each_reverse(&self, blk: &fn(&T) -> bool) -> bool {
each_reverse(*self, blk)
}
/// Iterates over a vector's elements and indices in reverse.
#[cfg(stage0)]
#[inline]
fn eachi_reverse(&self, blk: &fn(uint, &T) -> bool) {
eachi_reverse(*self, blk)
}
/// Iterates over a vector's elements and indices in reverse.
#[cfg(not(stage0))]
#[inline]
fn eachi_reverse(&self, blk: &fn(uint, &T) -> bool) -> bool {
eachi_reverse(*self, blk)
}
/// Reduce a vector from right to left
#[inline]
@ -2555,44 +2656,81 @@ pub mod bytes {
// ITERATION TRAIT METHODS
impl<'self,A> old_iter::BaseIter<A> for &'self [A] {
#[cfg(stage0)]
#[inline(always)]
fn each<'a>(&'a self, blk: &fn(v: &'a A) -> bool) { each(*self, blk) }
fn each<'a>(&'a self, blk: &fn(v: &'a A) -> bool) {
each(*self, blk)
}
#[cfg(not(stage0))]
#[inline(always)]
fn each<'a>(&'a self, blk: &fn(v: &'a A) -> bool) -> bool {
each(*self, blk)
}
#[inline(always)]
fn size_hint(&self) -> Option<uint> { Some(self.len()) }
}
// FIXME(#4148): This should be redundant
impl<A> old_iter::BaseIter<A> for ~[A] {
#[cfg(stage0)]
#[inline(always)]
fn each<'a>(&'a self, blk: &fn(v: &'a A) -> bool) { each(*self, blk) }
fn each<'a>(&'a self, blk: &fn(v: &'a A) -> bool) {
each(*self, blk)
}
#[cfg(not(stage0))]
#[inline(always)]
fn each<'a>(&'a self, blk: &fn(v: &'a A) -> bool) -> bool {
each(*self, blk)
}
#[inline(always)]
fn size_hint(&self) -> Option<uint> { Some(self.len()) }
}
// FIXME(#4148): This should be redundant
impl<A> old_iter::BaseIter<A> for @[A] {
#[cfg(stage0)]
#[inline(always)]
fn each<'a>(&'a self, blk: &fn(v: &'a A) -> bool) { each(*self, blk) }
fn each<'a>(&'a self, blk: &fn(v: &'a A) -> bool) {
each(*self, blk)
}
#[cfg(not(stage0))]
#[inline(always)]
fn each<'a>(&'a self, blk: &fn(v: &'a A) -> bool) -> bool {
each(*self, blk)
}
#[inline(always)]
fn size_hint(&self) -> Option<uint> { Some(self.len()) }
}
impl<'self,A> old_iter::MutableIter<A> for &'self mut [A] {
#[cfg(stage0)]
#[inline(always)]
fn each_mut<'a>(&'a mut self, blk: &fn(v: &'a mut A) -> bool) {
each_mut(*self, blk)
}
#[cfg(not(stage0))]
#[inline(always)]
fn each_mut<'a>(&'a mut self, blk: &fn(v: &'a mut A) -> bool) -> bool {
each_mut(*self, blk)
}
}
// FIXME(#4148): This should be redundant
impl<A> old_iter::MutableIter<A> for ~[A] {
#[cfg(stage0)]
#[inline(always)]
fn each_mut<'a>(&'a mut self, blk: &fn(v: &'a mut A) -> bool) {
each_mut(*self, blk)
}
#[cfg(not(stage0))]
#[inline(always)]
fn each_mut<'a>(&'a mut self, blk: &fn(v: &'a mut A) -> bool) -> bool {
each_mut(*self, blk)
}
}
// FIXME(#4148): This should be redundant
#[cfg(stage0)]
impl<A> old_iter::MutableIter<A> for @mut [A] {
#[inline(always)]
fn each_mut(&mut self, blk: &fn(v: &mut A) -> bool) {
@ -2600,10 +2738,23 @@ impl<A> old_iter::MutableIter<A> for @mut [A] {
}
}
#[cfg(not(stage0))]
impl<A> old_iter::MutableIter<A> for @mut [A] {
#[inline(always)]
fn each_mut(&mut self, blk: &fn(v: &mut A) -> bool) -> bool {
each_mut(*self, blk)
}
}
impl<'self,A> old_iter::ExtendedIter<A> for &'self [A] {
#[cfg(stage0)]
pub fn eachi(&self, blk: &fn(uint, v: &A) -> bool) {
old_iter::eachi(self, blk)
}
#[cfg(not(stage0))]
pub fn eachi(&self, blk: &fn(uint, v: &A) -> bool) -> bool {
old_iter::eachi(self, blk)
}
pub fn all(&self, blk: &fn(&A) -> bool) -> bool {
old_iter::all(self, blk)
}
@ -2627,16 +2778,27 @@ impl<'self,A> old_iter::ExtendedIter<A> for &'self [A] {
impl<'self,A> old_iter::ExtendedMutableIter<A> for &'self mut [A] {
#[inline(always)]
#[cfg(stage0)]
pub fn eachi_mut(&mut self, blk: &fn(uint, v: &mut A) -> bool) {
eachi_mut(*self, blk)
}
#[inline(always)]
#[cfg(not(stage0))]
pub fn eachi_mut(&mut self, blk: &fn(uint, v: &mut A) -> bool) -> bool {
eachi_mut(*self, blk)
}
}
// FIXME(#4148): This should be redundant
impl<A> old_iter::ExtendedIter<A> for ~[A] {
#[cfg(stage0)]
pub fn eachi(&self, blk: &fn(uint, v: &A) -> bool) {
old_iter::eachi(self, blk)
}
#[cfg(not(stage0))]
pub fn eachi(&self, blk: &fn(uint, v: &A) -> bool) -> bool {
old_iter::eachi(self, blk)
}
pub fn all(&self, blk: &fn(&A) -> bool) -> bool {
old_iter::all(self, blk)
}
@ -2660,9 +2822,14 @@ impl<A> old_iter::ExtendedIter<A> for ~[A] {
// FIXME(#4148): This should be redundant
impl<A> old_iter::ExtendedIter<A> for @[A] {
#[cfg(stage0)]
pub fn eachi(&self, blk: &fn(uint, v: &A) -> bool) {
old_iter::eachi(self, blk)
}
#[cfg(not(stage0))]
pub fn eachi(&self, blk: &fn(uint, v: &A) -> bool) -> bool {
old_iter::eachi(self, blk)
}
pub fn all(&self, blk: &fn(&A) -> bool) -> bool {
old_iter::all(self, blk)
}