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

Merge remote-tracking branch 'brson/companion' into incoming

Browse source 
Conflicts:
	src/compiletest/compiletest.rs
	src/libcargo/cargo.rs
	src/libcore/core.rs
	src/librustc/rustc.rs
	src/librustdoc/rustdoc.rc
This commit is contained in:
Brian Anderson 2012-11-28 12:38:53 -08:00
commit fc06114ddf
150 changed files with 4316 additions and 8444 deletions
Download patch file Download diff file Expand all files Collapse all files

8
src/libcore/bool.rs
View file

@ -66,15 +66,7 @@ pub fn all_values(blk: fn(v: bool)) {
pub pure fn to_bit(v: bool) -> u8 { if v { 1u8 } else { 0u8 } }
impl bool : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &bool) -> bool { self == (*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &bool) -> bool { (*self) == (*other) }
#[cfg(stage0)]
pure fn ne(other: &bool) -> bool { self != (*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &bool) -> bool { (*self) != (*other) }
}

24
src/libcore/box.rs
View file

@ -28,38 +28,14 @@ pub pure fn ptr_eq<T>(a: @T, b: @T) -> bool {
}
impl<T:Eq> @const T : Eq {
#[cfg(stage0)]
pure fn eq(other: &@const T) -> bool { *self == *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &@const T) -> bool { *(*self) == *(*other) }
#[cfg(stage0)]
pure fn ne(other: &@const T) -> bool { *self != *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &@const T) -> bool { *(*self) != *(*other) }
}
impl<T:Ord> @const T : Ord {
#[cfg(stage0)]
pure fn lt(other: &@const T) -> bool { *self < *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn lt(&self, other: &@const T) -> bool { *(*self) < *(*other) }
#[cfg(stage0)]
pure fn le(other: &@const T) -> bool { *self <= *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn le(&self, other: &@const T) -> bool { *(*self) <= *(*other) }
#[cfg(stage0)]
pure fn ge(other: &@const T) -> bool { *self >= *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ge(&self, other: &@const T) -> bool { *(*self) >= *(*other) }
#[cfg(stage0)]
pure fn gt(other: &@const T) -> bool { *self > *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn gt(&self, other: &@const T) -> bool { *(*self) > *(*other) }
}

8
src/libcore/char.rs
View file

@ -181,15 +181,7 @@ pub pure fn cmp(a: char, b: char) -> int {
}
impl char : Eq {
#[cfg(stage0)]
pure fn eq(other: &char) -> bool { self == (*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &char) -> bool { (*self) == (*other) }
#[cfg(stage0)]
pure fn ne(other: &char) -> bool { self != (*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &char) -> bool { (*self) != (*other) }
}

38
src/libcore/cmp.rs
View file

@ -30,17 +30,6 @@ mod nounittest {
* default implementations.
*/
#[lang="ord"]
#[cfg(stage0)]
pub trait Ord {
pure fn lt(other: &self) -> bool;
pure fn le(other: &self) -> bool;
pure fn ge(other: &self) -> bool;
pure fn gt(other: &self) -> bool;
}
#[lang="ord"]
#[cfg(stage1)]
#[cfg(stage2)]
pub trait Ord {
pure fn lt(&self, other: &self) -> bool;
pure fn le(&self, other: &self) -> bool;
@ -58,15 +47,6 @@ mod nounittest {
* a default implementation.
*/
#[lang="eq"]
#[cfg(stage0)]
pub trait Eq {
pure fn eq(other: &self) -> bool;
pure fn ne(other: &self) -> bool;
}
#[lang="eq"]
#[cfg(stage1)]
#[cfg(stage2)]
pub trait Eq {
pure fn eq(&self, other: &self) -> bool;
pure fn ne(&self, other: &self) -> bool;
@ -81,16 +61,6 @@ mod nounittest {
mod unittest {
#[legacy_exports];
#[cfg(stage0)]
pub trait Ord {
pure fn lt(other: &self) -> bool;
pure fn le(other: &self) -> bool;
pure fn ge(other: &self) -> bool;
pure fn gt(other: &self) -> bool;
}
#[cfg(stage1)]
#[cfg(stage2)]
pub trait Ord {
pure fn lt(&self, other: &self) -> bool;
pure fn le(&self, other: &self) -> bool;
@ -98,14 +68,6 @@ mod unittest {
pure fn gt(&self, other: &self) -> bool;
}
#[cfg(stage0)]
pub trait Eq {
pure fn eq(other: &self) -> bool;
pure fn ne(other: &self) -> bool;
}
#[cfg(stage1)]
#[cfg(stage2)]
pub trait Eq {
pure fn eq(&self, other: &self) -> bool;
pure fn ne(&self, other: &self) -> bool;

204
src/libcore/core.rc
View file

@ -45,80 +45,54 @@ Implicitly, all crates behave as if they included the following prologue:
// Built-in-type support modules
/// Operations and constants for `int`
#[path = "int-template"]
pub mod int {
pub use inst::{ pow };
#[path = "int.rs"]
pub mod inst;
}
#[path = "int-template.rs"]
#[merge = "int-template/intb.rs"]
pub mod int;
/// Operations and constants for `i8`
#[path = "int-template"]
pub mod i8 {
#[path = "i8.rs"]
pub mod inst;
}
#[path = "int-template.rs"]
#[merge = "int-template/i8b.rs"]
pub mod i8;
/// Operations and constants for `i16`
#[path = "int-template"]
pub mod i16 {
#[path = "i16.rs"]
pub mod inst;
}
#[path = "int-template.rs"]
#[merge = "int-template/i16b.rs"]
pub mod i16;
/// Operations and constants for `i32`
#[path = "int-template"]
pub mod i32 {
#[path = "i32.rs"]
pub mod inst;
}
#[path = "int-template.rs"]
#[merge = "int-template/i32b.rs"]
pub mod i32;
/// Operations and constants for `i64`
#[path = "int-template"]
pub mod i64 {
#[path = "i64.rs"]
pub mod inst;
}
#[path = "int-template.rs"]
#[merge = "int-template/i64b.rs"]
pub mod i64;
/// Operations and constants for `uint`
#[path = "uint-template"]
pub mod uint {
pub use inst::{
div_ceil, div_round, div_floor, iterate,
next_power_of_two
};
#[path = "uint.rs"]
pub mod inst;
}
#[path = "uint-template.rs"]
#[merge = "uint-template/uintb.rs"]
pub mod uint;
/// Operations and constants for `u8`
#[path = "uint-template"]
pub mod u8 {
pub use inst::is_ascii;
#[path = "u8.rs"]
pub mod inst;
}
#[path = "uint-template.rs"]
#[merge = "uint-template/u8b.rs"]
pub mod u8;
/// Operations and constants for `u16`
#[path = "uint-template"]
pub mod u16 {
#[path = "u16.rs"]
pub mod inst;
}
#[path = "uint-template.rs"]
#[merge = "uint-template/u16b.rs"]
pub mod u16;
/// Operations and constants for `u32`
#[path = "uint-template"]
pub mod u32 {
#[path = "u32.rs"]
pub mod inst;
}
#[path = "uint-template.rs"]
#[merge = "uint-template/u32b.rs"]
pub mod u32;
/// Operations and constants for `u64`
#[path = "uint-template"]
pub mod u64 {
#[path = "u64.rs"]
pub mod inst;
}
#[path = "uint-template.rs"]
#[merge = "uint-template/u64b.rs"]
pub mod u64;
pub mod box;
@ -146,11 +120,9 @@ pub mod either;
pub mod iter;
pub mod logging;
pub mod option;
#[path="iter-trait"]
pub mod option_iter {
#[path = "option.rs"]
pub mod inst;
}
#[path="iter-trait.rs"]
#[merge = "iter-trait/optionb.rs"]
pub mod option_iter;
pub mod result;
pub mod to_str;
pub mod to_bytes;
@ -161,27 +133,19 @@ pub mod clone;
// Data structure modules
pub mod dvec;
#[path="iter-trait"]
pub mod dvec_iter {
#[path = "dvec.rs"]
pub mod inst;
}
#[path="iter-trait.rs"]
#[merge = "iter-trait/dvecb.rs"]
pub mod dvec_iter;
pub mod dlist;
#[path="iter-trait"]
pub mod dlist_iter {
#[path ="dlist.rs"]
pub mod inst;
}
#[path="iter-trait.rs"]
#[merge = "iter-trait/dlistb.rs"]
pub mod dlist_iter;
pub mod send_map;
// Concurrency
pub mod comm;
pub mod task {
pub mod local_data;
mod local_data_priv;
pub mod spawn;
pub mod rt;
}
#[merge = "task/mod.rs"]
pub mod task;
pub mod pipes;
// Runtime and language-primitive support
@ -219,6 +183,92 @@ mod unicode;
mod cmath;
mod stackwalk;
// Top-level, visible-everywhere definitions.
// Export various ubiquitous types, constructors, methods.
pub use option::{Some, None};
pub use Option = option::Option;
pub use result::{Result, Ok, Err};
pub use Path = path::Path;
pub use GenericPath = path::GenericPath;
pub use WindowsPath = path::WindowsPath;
pub use PosixPath = path::PosixPath;
pub use tuple::{CopyableTuple, ImmutableTuple, ExtendedTupleOps};
pub use str::{StrSlice, Trimmable};
pub use vec::{ConstVector, CopyableVector, ImmutableVector};
pub use vec::{ImmutableEqVector, ImmutableCopyableVector};
pub use vec::{MutableVector, MutableCopyableVector};
pub use iter::{BaseIter, ExtendedIter, EqIter, CopyableIter};
pub use iter::{CopyableOrderedIter, CopyableNonstrictIter, Times};
pub use num::Num;
pub use ptr::Ptr;
pub use to_str::ToStr;
// The following exports are the core operators and kinds
// The compiler has special knowlege of these so we must not duplicate them
// when compiling for testing
#[cfg(notest)]
pub use ops::{Const, Copy, Send, Owned};
#[cfg(notest)]
pub use ops::{Drop};
#[cfg(notest)]
pub use ops::{Add, Sub, Mul, Div, Modulo, Neg, BitAnd, BitOr, BitXor};
#[cfg(notest)]
pub use ops::{Shl, Shr, Index};
#[cfg(test)]
extern mod coreops(name = "core", vers = "0.5");
#[cfg(test)]
pub use coreops::ops::{Const, Copy, Send, Owned};
#[cfg(test)]
pub use coreops::ops::{Drop};
#[cfg(test)]
pub use coreops::ops::{Add, Sub, Mul, Div, Modulo, Neg, BitAnd, BitOr};
#[cfg(test)]
pub use coreops::ops::{BitXor};
#[cfg(test)]
pub use coreops::ops::{Shl, Shr, Index};
#[cfg(notest)]
pub use clone::Clone;
#[cfg(test)]
pub use coreops::clone::Clone;
// Export the log levels as global constants. Higher levels mean
// more-verbosity. Error is the bottom level, default logging level is
// warn-and-below.
/// The error log level
pub const error : u32 = 1_u32;
/// The warning log level
pub const warn : u32 = 2_u32;
/// The info log level
pub const info : u32 = 3_u32;
/// The debug log level
pub const debug : u32 = 4_u32;
// A curious inner-module that's not exported that contains the binding
// 'core' so that macro-expanded references to core::error and such
// can be resolved within libcore.
#[doc(hidden)] // FIXME #3538
mod core {
pub const error : u32 = 1_u32;
pub const warn : u32 = 2_u32;
pub const info : u32 = 3_u32;
pub const debug : u32 = 4_u32;
}
// Similar to above. Some magic to make core testable.
#[cfg(test)]
mod std {
extern mod std(vers = "0.5");
pub use std::test;
}
// Local Variables:
// mode: rust;
// fill-column: 78;

85
src/libcore/core.rs
View file

@ -1,85 +0,0 @@
// Top-level, visible-everywhere definitions.
// Export various ubiquitous types, constructors, methods.
pub use option::{Some, None};
pub use Option = option::Option;
pub use result::{Result, Ok, Err};
pub use Path = path::Path;
pub use GenericPath = path::GenericPath;
pub use WindowsPath = path::WindowsPath;
pub use PosixPath = path::PosixPath;
pub use tuple::{CopyableTuple, ImmutableTuple, ExtendedTupleOps};
pub use str::{StrSlice, Trimmable};
pub use vec::{ConstVector, CopyableVector, ImmutableVector};
pub use vec::{ImmutableEqVector, ImmutableCopyableVector};
pub use vec::{MutableVector, MutableCopyableVector};
pub use iter::{BaseIter, ExtendedIter, EqIter, CopyableIter};
pub use iter::{CopyableOrderedIter, CopyableNonstrictIter, Times};
pub use num::Num;
pub use ptr::Ptr;
pub use to_str::ToStr;
// The following exports are the core operators and kinds
// The compiler has special knowlege of these so we must not duplicate them
// when compiling for testing
#[cfg(notest)]
pub use ops::{Const, Copy, Send, Owned};
#[cfg(notest)]
pub use ops::{Drop};
#[cfg(notest)]
pub use ops::{Add, Sub, Mul, Div, Modulo, Neg, BitAnd, BitOr, BitXor};
#[cfg(notest)]
pub use ops::{Shl, Shr, Index};
#[cfg(test)]
extern mod coreops(name = "core", vers = "0.5");
#[cfg(test)]
pub use coreops::ops::{Const, Copy, Send, Owned};
#[cfg(test)]
pub use coreops::ops::{Drop};
#[cfg(test)]
pub use coreops::ops::{Add, Sub, Mul, Div, Modulo, Neg, BitAnd, BitOr};
#[cfg(test)]
pub use coreops::ops::{BitXor};
#[cfg(test)]
pub use coreops::ops::{Shl, Shr, Index};
#[cfg(notest)]
pub use clone::Clone;
#[cfg(test)]
pub use coreops::clone::Clone;
// Export the log levels as global constants. Higher levels mean
// more-verbosity. Error is the bottom level, default logging level is
// warn-and-below.
/// The error log level
pub const error : u32 = 1_u32;
/// The warning log level
pub const warn : u32 = 2_u32;
/// The info log level
pub const info : u32 = 3_u32;
/// The debug log level
pub const debug : u32 = 4_u32;
// A curious inner-module that's not exported that contains the binding
// 'core' so that macro-expanded references to core::error and such
// can be resolved within libcore.
#[doc(hidden)] // FIXME #3538
mod core {
pub const error : u32 = 1_u32;
pub const warn : u32 = 2_u32;
pub const info : u32 = 3_u32;
pub const debug : u32 = 4_u32;
}
// Similar to above. Some magic to make core testable.
#[cfg(test)]
mod std {
extern mod std(vers = "0.5");
pub use std::test;
}

23
src/libcore/either.rs
View file

@ -132,25 +132,6 @@ pub pure fn unwrap_right<T,U>(eith: Either<T,U>) -> U {
}
impl<T:Eq,U:Eq> Either<T,U> : Eq {
#[cfg(stage0)]
pure fn eq(other: &Either<T,U>) -> bool {
match self {
Left(ref a) => {
match (*other) {
Left(ref b) => (*a).eq(b),
Right(_) => false
}
}
Right(ref a) => {
match (*other) {
Left(_) => false,
Right(ref b) => (*a).eq(b)
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Either<T,U>) -> bool {
match (*self) {
Left(ref a) => {
@ -167,10 +148,6 @@ impl<T:Eq,U:Eq> Either<T,U> : Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &Either<T,U>) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Either<T,U>) -> bool { !(*self).eq(other) }
}

19
src/libcore/extfmt.rs
View file

@ -438,21 +438,6 @@ pub mod rt {
pub enum PadMode { PadSigned, PadUnsigned, PadNozero, PadFloat }
pub impl PadMode : Eq {
#[cfg(stage0)]
pure fn eq(other: &PadMode) -> bool {
match (self, (*other)) {
(PadSigned, PadSigned) => true,
(PadUnsigned, PadUnsigned) => true,
(PadNozero, PadNozero) => true,
(PadFloat, PadFloat) => true,
(PadSigned, _) => false,
(PadUnsigned, _) => false,
(PadNozero, _) => false,
(PadFloat, _) => false
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &PadMode) -> bool {
match ((*self), (*other)) {
(PadSigned, PadSigned) => true,
@ -465,10 +450,6 @@ pub mod rt {
(PadFloat, _) => false
}
}
#[cfg(stage0)]
pure fn ne(other: &PadMode) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &PadMode) -> bool { !(*self).eq(other) }
}

24
src/libcore/float.rs
View file

@ -400,38 +400,14 @@ pub pure fn cos(x: float) -> float { f64::cos(x as f64) as float }
pub pure fn tan(x: float) -> float { f64::tan(x as f64) as float }
impl float : Eq {
#[cfg(stage0)]
pub pure fn eq(other: &float) -> bool { self == (*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &float) -> bool { (*self) == (*other) }
#[cfg(stage0)]
pub pure fn ne(other: &float) -> bool { self != (*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &float) -> bool { (*self) != (*other) }
}
impl float : Ord {
#[cfg(stage0)]
pub pure fn lt(other: &float) -> bool { self < (*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn lt(&self, other: &float) -> bool { (*self) < (*other) }
#[cfg(stage0)]
pub pure fn le(other: &float) -> bool { self <= (*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn le(&self, other: &float) -> bool { (*self) <= (*other) }
#[cfg(stage0)]
pub pure fn ge(other: &float) -> bool { self >= (*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ge(&self, other: &float) -> bool { (*self) >= (*other) }
#[cfg(stage0)]
pub pure fn gt(other: &float) -> bool { self > (*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn gt(&self, other: &float) -> bool { (*self) > (*other) }
}

24
src/libcore/int-template.rs
View file

@ -55,38 +55,14 @@ pub pure fn abs(i: T) -> T {
}
impl T : Ord {
#[cfg(stage0)]
pure fn lt(other: &T) -> bool { return self < (*other); }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn lt(&self, other: &T) -> bool { return (*self) < (*other); }
#[cfg(stage0)]
pure fn le(other: &T) -> bool { return self <= (*other); }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn le(&self, other: &T) -> bool { return (*self) <= (*other); }
#[cfg(stage0)]
pure fn ge(other: &T) -> bool { return self >= (*other); }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ge(&self, other: &T) -> bool { return (*self) >= (*other); }
#[cfg(stage0)]
pure fn gt(other: &T) -> bool { return self > (*other); }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn gt(&self, other: &T) -> bool { return (*self) > (*other); }
}
impl T : Eq {
#[cfg(stage0)]
pure fn eq(other: &T) -> bool { return self == (*other); }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &T) -> bool { return (*self) == (*other); }
#[cfg(stage0)]
pure fn ne(other: &T) -> bool { return self != (*other); }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &T) -> bool { return (*self) != (*other); }
}

4
src/libcore/int-template/i16b.rs Normal file
View file

@ -0,0 +1,4 @@
mod inst {
pub type T = i16;
pub const bits: uint = u16::bits;
}

4
src/libcore/int-template/i32b.rs Normal file
View file

@ -0,0 +1,4 @@
mod inst {
pub type T = i32;
pub const bits: uint = u32::bits;
}

4
src/libcore/int-template/i64b.rs Normal file
View file

@ -0,0 +1,4 @@
mod inst {
pub type T = i64;
pub const bits: uint = u64::bits;
}

4
src/libcore/int-template/i8b.rs Normal file
View file

@ -0,0 +1,4 @@
mod inst {
pub type T = i8;
pub const bits: uint = u8::bits;
}

45
src/libcore/int-template/intb.rs Normal file
View file

@ -0,0 +1,45 @@
pub use inst::pow;
mod inst {
pub type T = int;
pub const bits: uint = uint::bits;
/// Returns `base` raised to the power of `exponent`
pub fn pow(base: int, exponent: uint) -> int {
if exponent == 0u {
//Not mathemtically true if ~[base == 0]
return 1;
}
if base == 0 { return 0; }
let mut my_pow = exponent;
let mut acc = 1;
let mut multiplier = base;
while(my_pow > 0u) {
if my_pow % 2u == 1u {
acc *= multiplier;
}
my_pow /= 2u;
multiplier *= multiplier;
}
return acc;
}
#[test]
fn test_pow() {
assert (pow(0, 0u) == 1);
assert (pow(0, 1u) == 0);
assert (pow(0, 2u) == 0);
assert (pow(-1, 0u) == 1);
assert (pow(1, 0u) == 1);
assert (pow(-3, 2u) == 9);
assert (pow(-3, 3u) == -27);
assert (pow(4, 9u) == 262144);
}
#[test]
fn test_overflows() {
assert (max_value > 0);
assert (min_value <= 0);
assert (min_value + max_value + 1 == 0);
}
}

13
src/libcore/io.rs
View file

@ -516,25 +516,12 @@ pub enum FileFlag { Append, Create, Truncate, NoFlag, }
pub enum WriterType { Screen, File }
pub impl WriterType : Eq {
#[cfg(stage0)]
pure fn eq(other: &WriterType) -> bool {
match (self, (*other)) {
(Screen, Screen) | (File, File) => true,
(Screen, _) | (File, _) => false
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &WriterType) -> bool {
match ((*self), (*other)) {
(Screen, Screen) | (File, File) => true,
(Screen, _) | (File, _) => false
}
}
#[cfg(stage0)]
pure fn ne(other: &WriterType) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &WriterType) -> bool { !(*self).eq(other) }
}

38
src/libcore/iter-trait/dlistb.rs Normal file
View file

@ -0,0 +1,38 @@
mod inst {
#[allow(non_camel_case_types)]
pub type IMPL_T<A> = dlist::DList<A>;
/**
* Iterates through the current contents.
*
* Attempts to access this dlist during iteration are allowed (to
* allow for e.g. breadth-first search with in-place enqueues), but
* removing the current node is forbidden.
*/
pub pure fn EACH<A>(self: &IMPL_T<A>, f: fn(v: &A) -> bool) {
let mut link = self.peek_n();
while option::is_some(&link) {
let nobe = option::get(link);
assert nobe.linked;
if !f(&nobe.data) { break; }
// Check (weakly) that the user didn't do a remove.
if self.size == 0 {
fail ~"The dlist became empty during iteration??"
}
if !nobe.linked ||
(!((nobe.prev.is_some()
|| box::ptr_eq(*self.hd.expect(~"headless dlist?"),
*nobe))
&& (nobe.next.is_some()
|| box::ptr_eq(*self.tl.expect(~"tailless dlist?"),
*nobe)))) {
fail ~"Removing a dlist node during iteration is forbidden!"
}
link = nobe.next_link();
}
}
pub pure fn SIZE_HINT<A>(self: &IMPL_T<A>) -> Option<uint> {
Some(self.len())
}
}

22
src/libcore/iter-trait/dvecb.rs Normal file
View file

@ -0,0 +1,22 @@
mod inst {
#[allow(non_camel_case_types)]
pub type IMPL_T<A> = dvec::DVec<A>;
/**
* Iterates through the current contents.
*
* Attempts to access this dvec during iteration will fail.
*/
pub pure fn EACH<A>(self: &IMPL_T<A>, f: fn(v: &A) -> bool) {
unsafe {
do self.swap |v| {
v.each(f);
move v
}
}
}
pub pure fn SIZE_HINT<A>(self: &IMPL_T<A>) -> Option<uint> {
Some(self.len())
}
}

18
src/libcore/iter-trait/optionb.rs Normal file
View file

@ -0,0 +1,18 @@
mod inst {
#[allow(non_camel_case_types)]
pub type IMPL_T<A> = Option<A>;
pub pure fn EACH<A>(self: &IMPL_T<A>, f: fn(v: &A) -> bool) {
match *self {
None => (),
Some(ref a) => { f(a); }
}
}
pub pure fn SIZE_HINT<A>(self: &IMPL_T<A>) -> Option<uint> {
match *self {
None => Some(0),
Some(_) => Some(1)
}
}
}

24
src/libcore/option.rs
View file

@ -301,26 +301,6 @@ impl<T: Copy> Option<T> {
}
impl<T: Eq> Option<T> : Eq {
#[cfg(stage0)]
pure fn eq(other: &Option<T>) -> bool {
match self {
None => {
match (*other) {
None => true,
Some(_) => false
}
}
Some(ref self_contents) => {
match (*other) {
None => false,
Some(ref other_contents) =>
(*self_contents).eq(other_contents)
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Option<T>) -> bool {
match (*self) {
None => {
@ -338,10 +318,6 @@ impl<T: Eq> Option<T> : Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &Option<T>) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Option<T>) -> bool { !(*self).eq(other) }
}

24
src/libcore/owned.rs
View file

@ -7,38 +7,14 @@
use cmp::{Eq, Ord};
impl<T:Eq> ~const T : Eq {
#[cfg(stage0)]
pure fn eq(other: &~const T) -> bool { *self == *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &~const T) -> bool { *(*self) == *(*other) }
#[cfg(stage0)]
pure fn ne(other: &~const T) -> bool { *self != *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &~const T) -> bool { *(*self) != *(*other) }
}
impl<T:Ord> ~const T : Ord {
#[cfg(stage0)]
pure fn lt(other: &~const T) -> bool { *self < *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn lt(&self, other: &~const T) -> bool { *(*self) < *(*other) }
#[cfg(stage0)]
pure fn le(other: &~const T) -> bool { *self <= *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn le(&self, other: &~const T) -> bool { *(*self) <= *(*other) }
#[cfg(stage0)]
pure fn ge(other: &~const T) -> bool { *self >= *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ge(&self, other: &~const T) -> bool { *(*self) >= *(*other) }
#[cfg(stage0)]
pure fn gt(other: &~const T) -> bool { *self > *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn gt(&self, other: &~const T) -> bool { *(*self) > *(*other) }
}

24
src/libcore/path.rs
View file

@ -344,44 +344,20 @@ impl PosixPath : ToStr {
}
impl PosixPath : Eq {
#[cfg(stage0)]
pure fn eq(other: &PosixPath) -> bool {
return self.is_absolute == (*other).is_absolute &&
self.components == (*other).components;
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &PosixPath) -> bool {
return (*self).is_absolute == (*other).is_absolute &&
(*self).components == (*other).components;
}
#[cfg(stage0)]
pure fn ne(other: &PosixPath) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &PosixPath) -> bool { !(*self).eq(other) }
}
impl WindowsPath : Eq {
#[cfg(stage0)]
pure fn eq(other: &WindowsPath) -> bool {
return self.host == (*other).host &&
self.device == (*other).device &&
self.is_absolute == (*other).is_absolute &&
self.components == (*other).components;
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &WindowsPath) -> bool {
return (*self).host == (*other).host &&
(*self).device == (*other).device &&
(*self).is_absolute == (*other).is_absolute &&
(*self).components == (*other).components;
}
#[cfg(stage0)]
pure fn ne(other: &WindowsPath) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &WindowsPath) -> bool { !(*self).eq(other) }
}

10
src/libcore/pipes.rs
View file

@ -98,19 +98,9 @@ enum State {
}
impl State : Eq {
#[cfg(stage0)]
pure fn eq(other: &State) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &State) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &State) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &State) -> bool { !(*self).eq(other) }
}

68
src/libcore/ptr.rs
View file

@ -208,75 +208,31 @@ impl<T> *mut T: Ptr<T> {
// Equality for pointers
impl<T> *const T : Eq {
#[cfg(stage0)]
pure fn eq(other: &*const T) -> bool unsafe {
let a: uint = cast::reinterpret_cast(&self);
let b: uint = cast::reinterpret_cast(&(*other));
return a == b;
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &*const T) -> bool unsafe {
let a: uint = cast::reinterpret_cast(&(*self));
let b: uint = cast::reinterpret_cast(&(*other));
return a == b;
}
#[cfg(stage0)]
pure fn ne(other: &*const T) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &*const T) -> bool { !(*self).eq(other) }
}
// Comparison for pointers
impl<T> *const T : Ord {
#[cfg(stage0)]
pure fn lt(other: &*const T) -> bool unsafe {
let a: uint = cast::reinterpret_cast(&self);
let b: uint = cast::reinterpret_cast(&(*other));
return a < b;
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn lt(&self, other: &*const T) -> bool unsafe {
let a: uint = cast::reinterpret_cast(&(*self));
let b: uint = cast::reinterpret_cast(&(*other));
return a < b;
}
#[cfg(stage0)]
pure fn le(other: &*const T) -> bool unsafe {
let a: uint = cast::reinterpret_cast(&self);
let b: uint = cast::reinterpret_cast(&(*other));
return a <= b;
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn le(&self, other: &*const T) -> bool unsafe {
let a: uint = cast::reinterpret_cast(&(*self));
let b: uint = cast::reinterpret_cast(&(*other));
return a <= b;
}
#[cfg(stage0)]
pure fn ge(other: &*const T) -> bool unsafe {
let a: uint = cast::reinterpret_cast(&self);
let b: uint = cast::reinterpret_cast(&(*other));
return a >= b;
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ge(&self, other: &*const T) -> bool unsafe {
let a: uint = cast::reinterpret_cast(&(*self));
let b: uint = cast::reinterpret_cast(&(*other));
return a >= b;
}
#[cfg(stage0)]
pure fn gt(other: &*const T) -> bool unsafe {
let a: uint = cast::reinterpret_cast(&self);
let b: uint = cast::reinterpret_cast(&(*other));
return a > b;
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn gt(&self, other: &*const T) -> bool unsafe {
let a: uint = cast::reinterpret_cast(&(*self));
let b: uint = cast::reinterpret_cast(&(*other));
@ -286,17 +242,9 @@ impl<T> *const T : Ord {
// Equality for region pointers
impl<T:Eq> &const T : Eq {
#[cfg(stage0)]
pure fn eq(other: & &self/const T) -> bool { return *self == *(*other); }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: & &self/const T) -> bool {
return *(*self) == *(*other);
}
#[cfg(stage0)]
pure fn ne(other: & &self/const T) -> bool { return *self != *(*other); }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: & &self/const T) -> bool {
return *(*self) != *(*other);
}
@ -304,31 +252,15 @@ impl<T:Eq> &const T : Eq {
// Comparison for region pointers
impl<T:Ord> &const T : Ord {
#[cfg(stage0)]
pure fn lt(other: & &self/const T) -> bool { *self < *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn lt(&self, other: & &self/const T) -> bool {
*(*self) < *(*other)
}
#[cfg(stage0)]
pure fn le(other: & &self/const T) -> bool { *self <= *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn le(&self, other: & &self/const T) -> bool {
*(*self) <= *(*other)
}
#[cfg(stage0)]
pure fn ge(other: & &self/const T) -> bool { *self >= *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ge(&self, other: & &self/const T) -> bool {
*(*self) >= *(*other)
}
#[cfg(stage0)]
pure fn gt(other: & &self/const T) -> bool { *self > *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn gt(&self, other: & &self/const T) -> bool {
*(*self) > *(*other)
}

10
src/libcore/repr.rs
View file

@ -516,19 +516,9 @@ enum EnumVisitState {
}
impl EnumVisitState : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &EnumVisitState) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &EnumVisitState) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &EnumVisitState) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &EnumVisitState) -> bool { !(*self).eq(other) }
}

23
src/libcore/result.rs
View file

@ -365,25 +365,6 @@ pub fn unwrap_err<T, U>(res: Result<T, U>) -> U {
}
impl<T:Eq,U:Eq> Result<T,U> : Eq {
#[cfg(stage0)]
pure fn eq(other: &Result<T,U>) -> bool {
match self {
Ok(ref e0a) => {
match (*other) {
Ok(ref e0b) => *e0a == *e0b,
_ => false
}
}
Err(ref e0a) => {
match (*other) {
Err(ref e0b) => *e0a == *e0b,
_ => false
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Result<T,U>) -> bool {
match (*self) {
Ok(ref e0a) => {
@ -400,10 +381,6 @@ impl<T:Eq,U:Eq> Result<T,U> : Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &Result<T,U>) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Result<T,U>) -> bool { !(*self).eq(other) }
}

78
src/libcore/str.rs
View file

@ -737,139 +737,61 @@ pure fn gt(a: &str, b: &str) -> bool {
impl &str : Eq {
#[inline(always)]
#[cfg(stage0)]
pure fn eq(other: & &self/str) -> bool {
eq_slice(self, (*other))
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: & &self/str) -> bool {
eq_slice((*self), (*other))
}
#[inline(always)]
#[cfg(stage0)]
pure fn ne(other: & &self/str) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: & &self/str) -> bool { !(*self).eq(other) }
}
impl ~str : Eq {
#[inline(always)]
#[cfg(stage0)]
pure fn eq(other: &~str) -> bool {
eq_slice(self, (*other))
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &~str) -> bool {
eq_slice((*self), (*other))
}
#[inline(always)]
#[cfg(stage0)]
pure fn ne(other: &~str) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &~str) -> bool { !(*self).eq(other) }
}
impl @str : Eq {
#[inline(always)]
#[cfg(stage0)]
pure fn eq(other: &@str) -> bool {
eq_slice(self, (*other))
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &@str) -> bool {
eq_slice((*self), (*other))
}
#[inline(always)]
#[cfg(stage0)]
pure fn ne(other: &@str) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &@str) -> bool { !(*self).eq(other) }
}
impl ~str : Ord {
#[inline(always)]
#[cfg(stage0)]
pure fn lt(other: &~str) -> bool { lt(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn lt(&self, other: &~str) -> bool { lt((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn le(other: &~str) -> bool { le(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn le(&self, other: &~str) -> bool { le((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn ge(other: &~str) -> bool { ge(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ge(&self, other: &~str) -> bool { ge((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn gt(other: &~str) -> bool { gt(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn gt(&self, other: &~str) -> bool { gt((*self), (*other)) }
}
impl &str : Ord {
#[inline(always)]
#[cfg(stage0)]
pure fn lt(other: & &self/str) -> bool { lt(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn lt(&self, other: & &self/str) -> bool { lt((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn le(other: & &self/str) -> bool { le(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn le(&self, other: & &self/str) -> bool { le((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn ge(other: & &self/str) -> bool { ge(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ge(&self, other: & &self/str) -> bool { ge((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn gt(other: & &self/str) -> bool { gt(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn gt(&self, other: & &self/str) -> bool { gt((*self), (*other)) }
}
impl @str : Ord {
#[inline(always)]
#[cfg(stage0)]
pure fn lt(other: &@str) -> bool { lt(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn lt(&self, other: &@str) -> bool { lt((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn le(other: &@str) -> bool { le(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn le(&self, other: &@str) -> bool { le((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn ge(other: &@str) -> bool { ge(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ge(&self, other: &@str) -> bool { ge((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn gt(other: &@str) -> bool { gt(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn gt(&self, other: &@str) -> bool { gt((*self), (*other)) }
}

64
src/libcore/task.rs
View file

@ -43,15 +43,7 @@ pub enum Task {
}
impl Task : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &Task) -> bool { *self == *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Task) -> bool { *(*self) == *(*other) }
#[cfg(stage0)]
pure fn ne(other: &Task) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Task) -> bool { !(*self).eq(other) }
}
@ -72,25 +64,12 @@ pub enum TaskResult {
}
impl TaskResult : Eq {
#[cfg(stage0)]
pure fn eq(other: &TaskResult) -> bool {
match (self, (*other)) {
(Success, Success) | (Failure, Failure) => true,
(Success, _) | (Failure, _) => false
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &TaskResult) -> bool {
match ((*self), (*other)) {
(Success, Success) | (Failure, Failure) => true,
(Success, _) | (Failure, _) => false
}
}
#[cfg(stage0)]
pure fn ne(other: &TaskResult) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &TaskResult) -> bool { !(*self).eq(other) }
}
@ -114,43 +93,6 @@ pub enum SchedMode {
}
impl SchedMode : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &SchedMode) -> bool {
match self {
SingleThreaded => {
match (*other) {
SingleThreaded => true,
_ => false
}
}
ThreadPerCore => {
match (*other) {
ThreadPerCore => true,
_ => false
}
}
ThreadPerTask => {
match (*other) {
ThreadPerTask => true,
_ => false
}
}
ManualThreads(e0a) => {
match (*other) {
ManualThreads(e0b) => e0a == e0b,
_ => false
}
}
PlatformThread => {
match (*other) {
PlatformThread => true,
_ => false
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &SchedMode) -> bool {
match (*self) {
SingleThreaded => {
@ -185,12 +127,6 @@ impl SchedMode : cmp::Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &SchedMode) -> bool {
!self.eq(other)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &SchedMode) -> bool {
!(*self).eq(other)
}

12
src/libcore/task/local_data_priv.rs
View file

@ -7,23 +7,11 @@ pub trait LocalData { }
impl<T: Owned> @T: LocalData { }
impl LocalData: Eq {
#[cfg(stage0)]
pure fn eq(other: &@LocalData) -> bool unsafe {
let ptr_a: (uint, uint) = cast::reinterpret_cast(&self);
let ptr_b: (uint, uint) = cast::reinterpret_cast(other);
return ptr_a == ptr_b;
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &@LocalData) -> bool unsafe {
let ptr_a: (uint, uint) = cast::reinterpret_cast(&(*self));
let ptr_b: (uint, uint) = cast::reinterpret_cast(other);
return ptr_a == ptr_b;
}
#[cfg(stage0)]
pure fn ne(other: &@LocalData) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &@LocalData) -> bool { !(*self).eq(other) }
}

8
src/libcore/task/mod.rs Normal file
View file

@ -0,0 +1,8 @@
mod local_data_priv;
pub mod local_data;
pub mod rt;
pub mod spawn;

93
src/libcore/tuple.rs
View file

@ -95,18 +95,6 @@ impl<A: Copy, B: Copy> (~[A], ~[B]): ExtendedTupleOps<A,B> {
}
impl<A: Eq, B: Eq> (A, B) : Eq {
#[cfg(stage0)]
pure fn eq(other: &(A, B)) -> bool {
match self {
(ref self_a, ref self_b) => match other {
&(ref other_a, ref other_b) => {
(*self_a).eq(other_a) && (*self_b).eq(other_b)
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &(A, B)) -> bool {
match (*self) {
(ref self_a, ref self_b) => match other {
@ -116,31 +104,10 @@ impl<A: Eq, B: Eq> (A, B) : Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &(A, B)) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &(A, B)) -> bool { !(*self).eq(other) }
}
impl<A: Ord, B: Ord> (A, B) : Ord {
#[cfg(stage0)]
pure fn lt(other: &(A, B)) -> bool {
match self {
(ref self_a, ref self_b) => {
match (*other) {
(ref other_a, ref other_b) => {
if (*self_a).lt(other_a) { return true; }
if (*other_a).lt(self_a) { return false; }
if (*self_b).lt(other_b) { return true; }
return false;
}
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn lt(&self, other: &(A, B)) -> bool {
match (*self) {
(ref self_a, ref self_b) => {
@ -155,37 +122,12 @@ impl<A: Ord, B: Ord> (A, B) : Ord {
}
}
}
#[cfg(stage0)]
pure fn le(other: &(A, B)) -> bool { !(*other).lt(&self) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn le(&self, other: &(A, B)) -> bool { !(*other).lt(&(*self)) }
#[cfg(stage0)]
pure fn ge(other: &(A, B)) -> bool { !self.lt(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ge(&self, other: &(A, B)) -> bool { !(*self).lt(other) }
#[cfg(stage0)]
pure fn gt(other: &(A, B)) -> bool { (*other).lt(&self) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn gt(&self, other: &(A, B)) -> bool { (*other).lt(&(*self)) }
}
impl<A: Eq, B: Eq, C: Eq> (A, B, C) : Eq {
#[cfg(stage0)]
pure fn eq(other: &(A, B, C)) -> bool {
match self {
(ref self_a, ref self_b, ref self_c) => match other {
&(ref other_a, ref other_b, ref other_c) => {
(*self_a).eq(other_a) && (*self_b).eq(other_b)
&& (*self_c).eq(other_c)
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &(A, B, C)) -> bool {
match (*self) {
(ref self_a, ref self_b, ref self_c) => match other {
@ -196,33 +138,10 @@ impl<A: Eq, B: Eq, C: Eq> (A, B, C) : Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &(A, B, C)) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &(A, B, C)) -> bool { !(*self).eq(other) }
}
impl<A: Ord, B: Ord, C: Ord> (A, B, C) : Ord {
#[cfg(stage0)]
pure fn lt(other: &(A, B, C)) -> bool {
match self {
(ref self_a, ref self_b, ref self_c) => {
match (*other) {
(ref other_a, ref other_b, ref other_c) => {
if (*self_a).lt(other_a) { return true; }
if (*other_a).lt(self_a) { return false; }
if (*self_b).lt(other_b) { return true; }
if (*other_b).lt(self_b) { return false; }
if (*self_c).lt(other_c) { return true; }
return false;
}
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn lt(&self, other: &(A, B, C)) -> bool {
match (*self) {
(ref self_a, ref self_b, ref self_c) => {
@ -239,20 +158,8 @@ impl<A: Ord, B: Ord, C: Ord> (A, B, C) : Ord {
}
}
}
#[cfg(stage0)]
pure fn le(other: &(A, B, C)) -> bool { !(*other).lt(&self) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn le(&self, other: &(A, B, C)) -> bool { !(*other).lt(&(*self)) }
#[cfg(stage0)]
pure fn ge(other: &(A, B, C)) -> bool { !self.lt(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ge(&self, other: &(A, B, C)) -> bool { !(*self).lt(other) }
#[cfg(stage0)]
pure fn gt(other: &(A, B, C)) -> bool { (*other).lt(&self) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn gt(&self, other: &(A, B, C)) -> bool { (*other).lt(&(*self)) }
}

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

@ -49,38 +49,14 @@ pub pure fn compl(i: T) -> T {
}
impl T : Ord {
#[cfg(stage0)]
pure fn lt(other: &T) -> bool { self < (*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn lt(&self, other: &T) -> bool { (*self) < (*other) }
#[cfg(stage0)]
pure fn le(other: &T) -> bool { self <= (*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn le(&self, other: &T) -> bool { (*self) <= (*other) }
#[cfg(stage0)]
pure fn ge(other: &T) -> bool { self >= (*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ge(&self, other: &T) -> bool { (*self) >= (*other) }
#[cfg(stage0)]
pure fn gt(other: &T) -> bool { self > (*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn gt(&self, other: &T) -> bool { (*self) > (*other) }
}
impl T : Eq {
#[cfg(stage0)]
pure fn eq(other: &T) -> bool { return self == (*other); }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &T) -> bool { return (*self) == (*other); }
#[cfg(stage0)]
pure fn ne(other: &T) -> bool { return self != (*other); }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &T) -> bool { return (*self) != (*other); }
}

4
src/libcore/uint-template/u16b.rs Normal file
View file

@ -0,0 +1,4 @@
mod inst {
pub type T = u16;
pub const bits: uint = 16;
}

4
src/libcore/uint-template/u32b.rs Normal file
View file

@ -0,0 +1,4 @@
mod inst {
pub type T = u32;
pub const bits: uint = 32;
}

4
src/libcore/uint-template/u64b.rs Normal file
View file

@ -0,0 +1,4 @@
mod inst {
pub type T = u64;
pub const bits: uint = 64;
}

11
src/libcore/uint-template/u8b.rs Normal file
View file

@ -0,0 +1,11 @@
pub use inst::is_ascii;
mod inst {
pub type T = u8;
pub const bits: uint = 8;
// Type-specific functions here. These must be reexported by the
// parent module so that they appear in core::u8 and not core::u8::u8;
pub pure fn is_ascii(x: T) -> bool { return 0 as T == x & 128 as T; }
}

160
src/libcore/uint-template/uintb.rs Normal file
View file

@ -0,0 +1,160 @@
pub use inst::{
div_ceil, div_round, div_floor, iterate,
next_power_of_two
};
mod inst {
pub type T = uint;
#[cfg(target_arch = "x86")]
#[cfg(target_arch = "arm")]
pub const bits: uint = 32;
#[cfg(target_arch = "x86_64")]
pub const bits: uint = 64;
/**
* Divide two numbers, return the result, rounded up.
*
* # Arguments
*
* * x - an integer
* * y - an integer distinct from 0u
*
* # Return value
*
* The smallest integer `q` such that `x/y <= q`.
*/
pub pure fn div_ceil(x: uint, y: uint) -> uint {
let div = x / y;
if x % y == 0u { div }
else { div + 1u }
}
/**
* Divide two numbers, return the result, rounded to the closest integer.
*
* # Arguments
*
* * x - an integer
* * y - an integer distinct from 0u
*
* # Return value
*
* The integer `q` closest to `x/y`.
*/
pub pure fn div_round(x: uint, y: uint) -> uint {
let div = x / y;
if x % y * 2u < y { div }
else { div + 1u }
}
/**
* Divide two numbers, return the result, rounded down.
*
* Note: This is the same function as `div`.
*
* # Arguments
*
* * x - an integer
* * y - an integer distinct from 0u
*
* # Return value
*
* The smallest integer `q` such that `x/y <= q`. This
* is either `x/y` or `x/y + 1`.
*/
pub pure fn div_floor(x: uint, y: uint) -> uint { return x / y; }
/**
* Iterate over the range [`lo`..`hi`), or stop when requested
*
* # Arguments
*
* * lo - The integer at which to start the loop (included)
* * hi - The integer at which to stop the loop (excluded)
* * it - A block to execute with each consecutive integer of the range.
* Return `true` to continue, `false` to stop.
*
* # Return value
*
* `true` If execution proceeded correctly, `false` if it was interrupted,
* that is if `it` returned `false` at any point.
*/
pub pure fn iterate(lo: uint, hi: uint, it: fn(uint) -> bool) -> bool {
let mut i = lo;
while i < hi {
if (!it(i)) { return false; }
i += 1u;
}
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 {
let halfbits: uint = sys::size_of::<uint>() * 4u;
let mut tmp: uint = n - 1u;
let mut shift: uint = 1u;
while shift <= halfbits { tmp |= tmp >> shift; shift <<= 1u; }
return tmp + 1u;
}
#[test]
fn test_next_power_of_two() {
assert (uint::next_power_of_two(0u) == 0u);
assert (uint::next_power_of_two(1u) == 1u);
assert (uint::next_power_of_two(2u) == 2u);
assert (uint::next_power_of_two(3u) == 4u);
assert (uint::next_power_of_two(4u) == 4u);
assert (uint::next_power_of_two(5u) == 8u);
assert (uint::next_power_of_two(6u) == 8u);
assert (uint::next_power_of_two(7u) == 8u);
assert (uint::next_power_of_two(8u) == 8u);
assert (uint::next_power_of_two(9u) == 16u);
assert (uint::next_power_of_two(10u) == 16u);
assert (uint::next_power_of_two(11u) == 16u);
assert (uint::next_power_of_two(12u) == 16u);
assert (uint::next_power_of_two(13u) == 16u);
assert (uint::next_power_of_two(14u) == 16u);
assert (uint::next_power_of_two(15u) == 16u);
assert (uint::next_power_of_two(16u) == 16u);
assert (uint::next_power_of_two(17u) == 32u);
assert (uint::next_power_of_two(18u) == 32u);
assert (uint::next_power_of_two(19u) == 32u);
assert (uint::next_power_of_two(20u) == 32u);
assert (uint::next_power_of_two(21u) == 32u);
assert (uint::next_power_of_two(22u) == 32u);
assert (uint::next_power_of_two(23u) == 32u);
assert (uint::next_power_of_two(24u) == 32u);
assert (uint::next_power_of_two(25u) == 32u);
assert (uint::next_power_of_two(26u) == 32u);
assert (uint::next_power_of_two(27u) == 32u);
assert (uint::next_power_of_two(28u) == 32u);
assert (uint::next_power_of_two(29u) == 32u);
assert (uint::next_power_of_two(30u) == 32u);
assert (uint::next_power_of_two(31u) == 32u);
assert (uint::next_power_of_two(32u) == 32u);
assert (uint::next_power_of_two(33u) == 64u);
assert (uint::next_power_of_two(34u) == 64u);
assert (uint::next_power_of_two(35u) == 64u);
assert (uint::next_power_of_two(36u) == 64u);
assert (uint::next_power_of_two(37u) == 64u);
assert (uint::next_power_of_two(38u) == 64u);
assert (uint::next_power_of_two(39u) == 64u);
}
#[test]
fn test_overflows() {
assert (uint::max_value > 0u);
assert (uint::min_value <= 0u);
assert (uint::min_value + uint::max_value + 1u == 0u);
}
#[test]
fn test_div() {
assert(uint::div_floor(3u, 4u) == 0u);
assert(uint::div_ceil(3u, 4u) == 1u);
assert(uint::div_round(3u, 4u) == 1u);
}
}

24
src/libcore/unit.rs
View file

@ -11,38 +11,14 @@ Functions for the unit type.
use cmp::{Eq, Ord};
impl () : Eq {
#[cfg(stage0)]
pure fn eq(_other: &()) -> bool { true }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, _other: &()) -> bool { true }
#[cfg(stage0)]
pure fn ne(_other: &()) -> bool { false }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, _other: &()) -> bool { false }
}
impl () : Ord {
#[cfg(stage0)]
pure fn lt(_other: &()) -> bool { false }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn lt(&self, _other: &()) -> bool { false }
#[cfg(stage0)]
pure fn le(_other: &()) -> bool { true }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn le(&self, _other: &()) -> bool { true }
#[cfg(stage0)]
pure fn ge(_other: &()) -> bool { true }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ge(&self, _other: &()) -> bool { true }
#[cfg(stage0)]
pure fn gt(_other: &()) -> bool { false }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn gt(&self, _other: &()) -> bool { false }
}

72
src/libcore/vec.rs
View file

@ -1347,47 +1347,23 @@ pure fn eq<T: Eq>(a: &[T], b: &[T]) -> bool {
impl<T: Eq> &[T] : Eq {
#[inline(always)]
#[cfg(stage0)]
pure fn eq(other: & &self/[T]) -> bool { eq(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: & &self/[T]) -> bool { eq((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn ne(other: & &self/[T]) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: & &self/[T]) -> bool { !(*self).eq(other) }
}
impl<T: Eq> ~[T] : Eq {
#[inline(always)]
#[cfg(stage0)]
pure fn eq(other: &~[T]) -> bool { eq(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &~[T]) -> bool { eq((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn ne(other: &~[T]) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &~[T]) -> bool { !(*self).eq(other) }
}
impl<T: Eq> @[T] : Eq {
#[inline(always)]
#[cfg(stage0)]
pure fn eq(other: &@[T]) -> bool { eq(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &@[T]) -> bool { eq((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn ne(other: &@[T]) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &@[T]) -> bool { !(*self).eq(other) }
}
@ -1414,82 +1390,34 @@ pure fn gt<T: Ord>(a: &[T], b: &[T]) -> bool { lt(b, a) }
impl<T: Ord> &[T] : Ord {
#[inline(always)]
#[cfg(stage0)]
pure fn lt(other: & &self/[T]) -> bool { lt(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn lt(&self, other: & &self/[T]) -> bool { lt((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn le(other: & &self/[T]) -> bool { le(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn le(&self, other: & &self/[T]) -> bool { le((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn ge(other: & &self/[T]) -> bool { ge(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ge(&self, other: & &self/[T]) -> bool { ge((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn gt(other: & &self/[T]) -> bool { gt(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn gt(&self, other: & &self/[T]) -> bool { gt((*self), (*other)) }
}
impl<T: Ord> ~[T] : Ord {
#[inline(always)]
#[cfg(stage0)]
pure fn lt(other: &~[T]) -> bool { lt(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn lt(&self, other: &~[T]) -> bool { lt((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn le(other: &~[T]) -> bool { le(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn le(&self, other: &~[T]) -> bool { le((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn ge(other: &~[T]) -> bool { ge(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ge(&self, other: &~[T]) -> bool { ge((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn gt(other: &~[T]) -> bool { gt(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn gt(&self, other: &~[T]) -> bool { gt((*self), (*other)) }
}
impl<T: Ord> @[T] : Ord {
#[inline(always)]
#[cfg(stage0)]
pure fn lt(other: &@[T]) -> bool { lt(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn lt(&self, other: &@[T]) -> bool { lt((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn le(other: &@[T]) -> bool { le(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn le(&self, other: &@[T]) -> bool { le((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn ge(other: &@[T]) -> bool { ge(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ge(&self, other: &@[T]) -> bool { ge((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn gt(other: &@[T]) -> bool { gt(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn gt(&self, other: &@[T]) -> bool { gt((*self), (*other)) }
}