OpenE2K
/
rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

auto merge of #6240 : brson/rust/snapshots, r=brson

This commit is contained in:
bors 2013-05-04 15:48:36 -07:00
parent b872900a5b 8081e8debf
commit d74ac9ea03
47 changed files with 16 additions and 5720 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
src/libcore/cast.rs
View File

@ -10,9 +10,7 @@
//! Unsafe casting functions
#[cfg(not(stage0))]
use sys;
#[cfg(not(stage0))]
use unstable;
pub mod rusti {
@ -21,35 +19,11 @@ pub mod rusti {
pub extern "rust-intrinsic" {
fn forget<T>(+x: T);
#[cfg(stage0)]
fn reinterpret_cast<T, U>(&&e: T) -> U;
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn transmute<T,U>(e: T) -> U;
}
}
/// Casts the value at `src` to U. The two types must have the same length.
#[inline(always)]
#[cfg(stage0)]
pub unsafe fn reinterpret_cast<T, U>(src: &T) -> U {
rusti::reinterpret_cast(*src)
}
/// Unsafely copies and casts the value at `src` to U, even if the value is
/// noncopyable. The two types must have the same length.
#[inline(always)]
#[cfg(stage0)]
pub unsafe fn transmute_copy<T, U>(src: &T) -> U {
rusti::reinterpret_cast(*src)
}
#[inline(always)]
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
pub unsafe fn transmute_copy<T, U>(src: &T) -> U {
let mut dest: U = unstable::intrinsics::init();
{
@ -90,17 +64,6 @@ pub unsafe fn bump_box_refcount<T>(t: @T) { forget(t); }
* assert!(transmute("L") == ~[76u8, 0u8]);
*/
#[inline(always)]
#[cfg(stage0)]
pub unsafe fn transmute<L, G>(thing: L) -> G {
let newthing: G = reinterpret_cast(&thing);
forget(thing);
newthing
}
#[inline(always)]
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
pub unsafe fn transmute<L, G>(thing: L) -> G {
rusti::transmute(thing)
}
@ -161,15 +124,6 @@ mod tests {
use cast::{bump_box_refcount, transmute};
#[test]
#[cfg(stage0)]
fn test_reinterpret_cast() {
assert!(1u == unsafe { ::cast::reinterpret_cast(&1) });
}
#[test]
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn test_transmute_copy() {
assert!(1u == unsafe { ::cast::transmute_copy(&1) });
}

36
src/libcore/container.rs
View File

@ -25,42 +25,6 @@ pub trait Mutable: Container {
fn clear(&mut self);
}
#[cfg(stage0)]
pub trait Map<K, V>: Mutable {
/// Return true if the map contains a value for the specified key
fn contains_key(&self, key: &K) -> bool;
// Visits all keys and values
fn each(&self, f: &fn(&K, &V) -> bool);
/// Visit all keys
fn each_key(&self, f: &fn(&K) -> bool);
/// Visit all values
fn each_value(&self, f: &fn(&V) -> bool);
/// Iterate over the map and mutate the contained values
fn mutate_values(&mut self, f: &fn(&K, &mut V) -> bool);
/// Return a reference to the value corresponding to the key
fn find(&self, key: &K) -> Option<&'self V>;
/// Return a mutable reference to the value corresponding to the key
fn find_mut(&mut self, key: &K) -> Option<&'self mut V>;
/// Insert a key-value pair into the map. An existing value for a
/// key is replaced by the new value. Return true if the key did
/// not already exist in the map.
fn insert(&mut self, key: K, value: V) -> bool;
/// Remove a key-value pair from the map. Return true if the key
/// was present in the map, otherwise false.
fn remove(&mut self, key: &K) -> bool;
}
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
pub trait Map<K, V>: Mutable {
/// Return true if the map contains a value for the specified key
fn contains_key(&self, key: &K) -> bool;

3
src/libcore/core.rc
View File

@ -74,9 +74,6 @@ they contained the following prologue:
pub use kinds::{Const, Copy, Owned, Durable};
pub use ops::{Drop};
#[cfg(stage0)]
pub use ops::{Add, Sub, Mul, Div, Modulo, Neg, Not};
#[cfg(not(stage0))]
pub use ops::{Add, Sub, Mul, Div, Rem, Neg, Not};
pub use ops::{BitAnd, BitOr, BitXor};
pub use ops::{Shl, Shr, Index};

168
src/libcore/hashmap.rs
View File

@ -184,18 +184,6 @@ priv impl<K:Hash + Eq,V> HashMap<K, V> {
}
}
#[cfg(stage0)]
#[inline(always)]
fn value_for_bucket(&self, idx: uint) -> &'self V {
match self.buckets[idx] {
Some(ref bkt) => &bkt.value,
None => fail!(~"HashMap::find: internal logic error"),
}
}
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
#[inline(always)]
fn value_for_bucket<'a>(&'a self, idx: uint) -> &'a V {
match self.buckets[idx] {
@ -204,18 +192,6 @@ priv impl<K:Hash + Eq,V> HashMap<K, V> {
}
}
#[cfg(stage0)]
#[inline(always)]
fn mut_value_for_bucket(&mut self, idx: uint) -> &'self mut V {
match self.buckets[idx] {
Some(ref mut bkt) => &mut bkt.value,
None => unreachable()
}
}
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
#[inline(always)]
fn mut_value_for_bucket<'a>(&'a mut self, idx: uint) -> &'a mut V {
match self.buckets[idx] {
@ -329,21 +305,6 @@ impl<K:Hash + Eq,V> Map<K, V> for HashMap<K, V> {
}
/// Visit all key-value pairs
#[cfg(stage0)]
fn each(&self, blk: &fn(&'self K, &'self V) -> bool) {
for uint::range(0, self.buckets.len()) |i| {
for self.buckets[i].each |bucket| {
if !blk(&bucket.key, &bucket.value) {
return;
}
}
}
}
/// Visit all key-value pairs
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn each<'a>(&'a self, blk: &fn(&'a K, &'a V) -> bool) {
for uint::range(0, self.buckets.len()) |i| {
for self.buckets[i].each |bucket| {
@ -360,15 +321,6 @@ impl<K:Hash + Eq,V> Map<K, V> for HashMap<K, V> {
}
/// Visit all values
#[cfg(stage0)]
fn each_value(&self, blk: &fn(v: &V) -> bool) {
self.each(|_, v| blk(v))
}
/// Visit all values
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn each_value<'a>(&'a self, blk: &fn(v: &'a V) -> bool) {
self.each(|_, v| blk(v))
}
@ -386,18 +338,6 @@ impl<K:Hash + Eq,V> Map<K, V> for HashMap<K, V> {
}
/// Return a reference to the value corresponding to the key
#[cfg(stage0)]
fn find(&self, k: &K) -> Option<&'self V> {
match self.bucket_for_key(k) {
FoundEntry(idx) => Some(self.value_for_bucket(idx)),
TableFull | FoundHole(_) => None,
}
}
/// Return a reference to the value corresponding to the key
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn find<'a>(&'a self, k: &K) -> Option<&'a V> {
match self.bucket_for_key(k) {
FoundEntry(idx) => Some(self.value_for_bucket(idx)),
@ -406,21 +346,6 @@ impl<K:Hash + Eq,V> Map<K, V> for HashMap<K, V> {
}
/// Return a mutable reference to the value corresponding to the key
#[cfg(stage0)]
fn find_mut(&mut self, k: &K) -> Option<&'self mut V> {
let idx = match self.bucket_for_key(k) {
FoundEntry(idx) => idx,
TableFull | FoundHole(_) => return None
};
unsafe { // FIXME(#4903)---requires flow-sensitive borrow checker
Some(::cast::transmute_mut_region(self.mut_value_for_bucket(idx)))
}
}
/// Return a mutable reference to the value corresponding to the key
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn find_mut<'a>(&'a mut self, k: &K) -> Option<&'a mut V> {
let idx = match self.bucket_for_key(k) {
FoundEntry(idx) => idx,
@ -503,40 +428,6 @@ pub impl<K: Hash + Eq, V> HashMap<K, V> {
/// Return the value corresponding to the key in the map, or insert
/// and return the value if it doesn't exist.
#[cfg(stage0)]
fn find_or_insert(&mut self, k: K, v: V) -> &'self V {
if self.size >= self.resize_at {
// n.b.: We could also do this after searching, so
// that we do not resize if this call to insert is
// simply going to update a key in place. My sense
// though is that it's worse to have to search through
// buckets to find the right spot twice than to just
// resize in this corner case.
self.expand();
}
let hash = k.hash_keyed(self.k0, self.k1) as uint;
let idx = match self.bucket_for_key_with_hash(hash, &k) {
TableFull => fail!(~"Internal logic error"),
FoundEntry(idx) => idx,
FoundHole(idx) => {
self.buckets[idx] = Some(Bucket{hash: hash, key: k,
value: v});
self.size += 1;
idx
},
};
unsafe { // FIXME(#4903)---requires flow-sensitive borrow checker
::cast::transmute_region(self.value_for_bucket(idx))
}
}
/// Return the value corresponding to the key in the map, or insert
/// and return the value if it doesn't exist.
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn find_or_insert<'a>(&'a mut self, k: K, v: V) -> &'a V {
if self.size >= self.resize_at {
// n.b.: We could also do this after searching, so
@ -567,41 +458,6 @@ pub impl<K: Hash + Eq, V> HashMap<K, V> {
/// Return the value corresponding to the key in the map, or create,
/// insert, and return a new value if it doesn't exist.
#[cfg(stage0)]
fn find_or_insert_with(&mut self, k: K, f: &fn(&K) -> V) -> &'self V {
if self.size >= self.resize_at {
// n.b.: We could also do this after searching, so
// that we do not resize if this call to insert is
// simply going to update a key in place. My sense
// though is that it's worse to have to search through
// buckets to find the right spot twice than to just
// resize in this corner case.
self.expand();
}
let hash = k.hash_keyed(self.k0, self.k1) as uint;
let idx = match self.bucket_for_key_with_hash(hash, &k) {
TableFull => fail!(~"Internal logic error"),
FoundEntry(idx) => idx,
FoundHole(idx) => {
let v = f(&k);
self.buckets[idx] = Some(Bucket{hash: hash, key: k,
value: v});
self.size += 1;
idx
},
};
unsafe { // FIXME(#4903)---requires flow-sensitive borrow checker
::cast::transmute_region(self.value_for_bucket(idx))
}
}
/// Return the value corresponding to the key in the map, or create,
/// insert, and return a new value if it doesn't exist.
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn find_or_insert_with<'a>(&'a mut self, k: K, f: &fn(&K) -> V) -> &'a V {
if self.size >= self.resize_at {
// n.b.: We could also do this after searching, so
@ -647,17 +503,6 @@ pub impl<K: Hash + Eq, V> HashMap<K, V> {
}
}
#[cfg(stage0)]
fn get(&self, k: &K) -> &'self V {
match self.find(k) {
Some(v) => v,
None => fail!(fmt!("No entry found for key: %?", k)),
}
}
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn get<'a>(&'a self, k: &K) -> &'a V {
match self.find(k) {
Some(v) => v,
@ -676,19 +521,6 @@ pub impl<K: Hash + Eq, V> HashMap<K, V> {
/// Return the value corresponding to the key in the map, using
/// equivalence
#[cfg(stage0)]
fn find_equiv<Q:Hash + Equiv<K>>(&self, k: &Q) -> Option<&'self V> {
match self.bucket_for_key_equiv(k) {
FoundEntry(idx) => Some(self.value_for_bucket(idx)),
TableFull | FoundHole(_) => None,
}
}
/// Return the value corresponding to the key in the map, using
/// equivalence
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn find_equiv<'a, Q:Hash + Equiv<K>>(&'a self, k: &Q) -> Option<&'a V> {
match self.bucket_for_key_equiv(k) {
FoundEntry(idx) => Some(self.value_for_bucket(idx)),

7
src/libcore/num/f32.rs
View File

@ -284,12 +284,7 @@ impl Div<f32,f32> for f32 {
fn div(&self, other: &f32) -> f32 { *self / *other }
}
#[cfg(stage0,notest)]
impl Modulo<f32,f32> for f32 {
#[inline(always)]
fn modulo(&self, other: &f32) -> f32 { *self % *other }
}
#[cfg(not(stage0),notest)]
#[cfg(notest)]
impl Rem<f32,f32> for f32 {
#[inline(always)]
fn rem(&self, other: &f32) -> f32 { *self % *other }

6
src/libcore/num/f64.rs
View File

@ -299,11 +299,7 @@ impl Mul<f64,f64> for f64 {
impl Div<f64,f64> for f64 {
fn div(&self, other: &f64) -> f64 { *self / *other }
}
#[cfg(stage0,notest)]
impl Modulo<f64,f64> for f64 {
fn modulo(&self, other: &f64) -> f64 { *self % *other }
}
#[cfg(not(stage0),notest)]
#[cfg(notest)]
impl Rem<f64,f64> for f64 {
#[inline(always)]
fn rem(&self, other: &f64) -> f64 { *self % *other }

7
src/libcore/num/float.rs
View File

@ -697,12 +697,7 @@ impl Div<float,float> for float {
fn div(&self, other: &float) -> float { *self / *other }
}
#[cfg(stage0,notest)]
impl Modulo<float,float> for float {
#[inline(always)]
fn modulo(&self, other: &float) -> float { *self % *other }
}
#[cfg(not(stage0),notest)]
#[cfg(notest)]
impl Rem<float,float> for float {
#[inline(always)]
fn rem(&self, other: &float) -> float { *self % *other }

7
src/libcore/num/int-template.rs
View File

@ -224,12 +224,7 @@ impl Div<T,T> for T {
fn div(&self, other: &T) -> T { *self / *other }
}
#[cfg(stage0,notest)]
impl Modulo<T,T> for T {
#[inline(always)]
fn modulo(&self, other: &T) -> T { *self % *other }
}
#[cfg(not(stage0),notest)]
#[cfg(notest)]
impl Rem<T,T> for T {
///
/// Returns the integer remainder after division, satisfying:

23
src/libcore/num/num.rs
View File

@ -10,11 +10,6 @@
//! An interface for numeric types
use cmp::{Eq, Ord};
#[cfg(stage0)]
use ops::{Add, Sub, Mul, Div, Neg};
#[cfg(stage0)]
use Rem = ops::Modulo;
#[cfg(not(stage0))]
use ops::{Add, Sub, Mul, Div, Rem, Neg};
use ops::{Not, BitAnd, BitOr, BitXor, Shl, Shr};
use option::Option;
@ -391,23 +386,7 @@ pub fn pow_with_uint<T:NumCast+One+Zero+Copy+Div<T,T>+Mul<T,T>>(
}
/// Helper function for testing numeric operations
#[cfg(stage0,test)]
pub fn test_num<T:Num + NumCast>(ten: T, two: T) {
assert_eq!(ten.add(&two), cast(12));
assert_eq!(ten.sub(&two), cast(8));
assert_eq!(ten.mul(&two), cast(20));
assert_eq!(ten.div(&two), cast(5));
assert_eq!(ten.modulo(&two), cast(0));
assert_eq!(ten.add(&two), ten + two);
assert_eq!(ten.sub(&two), ten - two);
assert_eq!(ten.mul(&two), ten * two);
assert_eq!(ten.div(&two), ten / two);
assert_eq!(ten.modulo(&two), ten % two);
}
#[cfg(stage1,test)]
#[cfg(stage2,test)]
#[cfg(stage3,test)]
#[cfg(test)]
pub fn test_num<T:Num + NumCast>(ten: T, two: T) {
assert_eq!(ten.add(&two), cast(12));
assert_eq!(ten.sub(&two), cast(8));

7
src/libcore/num/strconv.rs
View File

@ -9,13 +9,6 @@
// except according to those terms.
use core::cmp::{Ord, Eq};
#[cfg(stage0)]
use ops::{Add, Sub, Mul, Div, Neg};
#[cfg(stage0)]
use Rem = ops::Modulo;
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
use ops::{Add, Sub, Mul, Div, Rem, Neg};
use option::{None, Option, Some};
use char;

7
src/libcore/num/uint-template.rs
View File

@ -171,12 +171,7 @@ impl Div<T,T> for T {
fn div(&self, other: &T) -> T { *self / *other }
}
#[cfg(stage0,notest)]
impl Modulo<T,T> for T {
#[inline(always)]
fn modulo(&self, other: &T) -> T { *self % *other }
}
#[cfg(not(stage0),notest)]
#[cfg(notest)]
impl Rem<T,T> for T {
#[inline(always)]
fn rem(&self, other: &T) -> T { *self % *other }

6
src/libcore/ops.rs
View File

@ -35,13 +35,7 @@ pub trait Div<RHS,Result> {
fn div(&self, rhs: &RHS) -> Result;
}
#[lang="modulo"]
#[cfg(stage0)]
pub trait Modulo<RHS,Result> {
fn modulo(&self, rhs: &RHS) -> Result;
}
#[lang="rem"]
#[cfg(not(stage0))]
pub trait Rem<RHS,Result> {
fn rem(&self, rhs: &RHS) -> Result;
}

104
src/libcore/option.rs
View File

@ -100,16 +100,6 @@ 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
#[cfg(stage0)]
#[inline(always)]
fn each(&self, f: &fn(x: &'self T) -> bool) {
match *self { None => (), Some(ref t) => { f(t); } }
}
/// Performs an operation on the contained value by reference
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
#[inline(always)]
fn each<'a>(&'a self, f: &fn(x: &'a T) -> bool) {
match *self { None => (), Some(ref t) => { f(t); } }
@ -122,15 +112,6 @@ impl<T> BaseIter<T> for Option<T> {
}
impl<T> MutableIter<T> for Option<T> {
#[cfg(stage0)]
#[inline(always)]
fn each_mut(&mut self, f: &fn(&'self mut T) -> bool) {
match *self { None => (), Some(ref mut t) => { f(t); } }
}
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
#[inline(always)]
fn each_mut<'a>(&'a mut self, f: &fn(&'a mut T) -> bool) {
match *self { None => (), Some(ref mut t) => { f(t); } }
@ -200,35 +181,12 @@ pub impl<T> Option<T> {
* Update an optional value by optionally running its content by reference
* through a function that returns an option.
*/
#[cfg(stage0)]
#[inline(always)]
fn chain_ref<U>(&self, f: &fn(x: &'self T) -> Option<U>) -> Option<U> {
match *self { Some(ref x) => f(x), None => None }
}
/**
* Update an optional value by optionally running its content by reference
* through a function that returns an option.
*/
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
#[inline(always)]
fn chain_ref<'a, U>(&'a self, f: &fn(x: &'a T) -> Option<U>) -> Option<U> {
match *self { Some(ref x) => f(x), None => None }
}
/// Maps a `some` value from one type to another by reference
#[cfg(stage0)]
#[inline(always)]
fn map<U>(&self, f: &fn(&'self T) -> U) -> Option<U> {
match *self { Some(ref x) => Some(f(x)), None => None }
}
/// Maps a `some` value from one type to another by reference
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
#[inline(always)]
fn map<'a, U>(&self, f: &fn(&'a T) -> U) -> Option<U> {
match *self { Some(ref x) => Some(f(x)), None => None }
@ -242,16 +200,6 @@ pub impl<T> Option<T> {
}
/// Applies a function to the contained value or returns a default
#[cfg(stage0)]
#[inline(always)]
fn map_default<U>(&self, def: U, f: &fn(&'self T) -> U) -> U {
match *self { None => def, Some(ref t) => f(t) }
}
/// Applies a function to the contained value or returns a default
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
#[inline(always)]
fn map_default<'a, U>(&'a self, def: U, f: &fn(&'a T) -> U) -> U {
match *self { None => def, Some(ref t) => f(t) }
@ -295,32 +243,6 @@ pub impl<T> Option<T> {
case explicitly.
*/
#[inline(always)]
#[cfg(stage0)]
fn get_ref(&self) -> &'self T {
match *self {
Some(ref x) => x,
None => fail!(~"option::get_ref none")
}
}
/**
Gets an immutable reference to the value inside an option.
# Failure
Fails if the value equals `None`
# Safety note
In general, because this function may fail, its use is discouraged
(calling `get` on `None` is akin to dereferencing a null pointer).
Instead, prefer to use pattern matching and handle the `None`
case explicitly.
*/
#[inline(always)]
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn get_ref<'a>(&'a self) -> &'a T {
match *self {
Some(ref x) => x,
@ -343,32 +265,6 @@ pub impl<T> Option<T> {
case explicitly.
*/
#[inline(always)]
#[cfg(stage0)]
fn get_mut_ref(&mut self) -> &'self mut T {
match *self {
Some(ref mut x) => x,
None => fail!(~"option::get_mut_ref none")
}
}
/**
Gets a mutable reference to the value inside an option.
# Failure
Fails if the value equals `None`
# Safety note
In general, because this function may fail, its use is discouraged
(calling `get` on `None` is akin to dereferencing a null pointer).
Instead, prefer to use pattern matching and handle the `None`
case explicitly.
*/
#[inline(always)]
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn get_mut_ref<'a>(&'a mut self) -> &'a mut T {
match *self {
Some(ref mut x) => x,

3
src/libcore/prelude.rs
View File

@ -14,9 +14,6 @@
pub use either::{Either, Left, Right};
pub use kinds::{Const, Copy, Owned, Durable};
#[cfg(stage0)]
pub use ops::{Add, Sub, Mul, Div, Modulo, Neg, Not};
#[cfg(not(stage0))]
pub use ops::{Add, Sub, Mul, Div, Rem, Neg, Not};
pub use ops::{BitAnd, BitOr, BitXor};
pub use ops::{Drop};

33
src/libcore/reflect.rs
View File

@ -15,7 +15,7 @@ Runtime type reflection
*/
use intrinsic::{TyDesc, TyVisitor};
#[cfg(not(stage0))] use intrinsic::Opaque;
use intrinsic::Opaque;
use libc::c_void;
use sys;
use vec;
@ -394,17 +394,6 @@ impl<V:TyVisitor + MovePtr> TyVisitor for MovePtrAdaptor<V> {
true
}
#[cfg(stage0)]
fn visit_enter_enum(&self, n_variants: uint, sz: uint, align: uint)
-> bool {
self.align(align);
if ! self.inner.visit_enter_enum(n_variants, sz, align) {
return false;
}
true
}
#[cfg(not(stage0))]
fn visit_enter_enum(&self, n_variants: uint,
get_disr: extern unsafe fn(ptr: *Opaque) -> int,
sz: uint, align: uint)
@ -428,15 +417,6 @@ impl<V:TyVisitor + MovePtr> TyVisitor for MovePtrAdaptor<V> {
true
}
#[cfg(stage0)]
fn visit_enum_variant_field(&self, i: uint, inner: *TyDesc) -> bool {
unsafe { self.align((*inner).align); }
if ! self.inner.visit_enum_variant_field(i, inner) { return false; }
unsafe { self.bump((*inner).size); }
true
}
#[cfg(not(stage0))]
fn visit_enum_variant_field(&self, i: uint, offset: uint, inner: *TyDesc) -> bool {
self.inner.push_ptr();
self.bump(offset);
@ -457,17 +437,6 @@ impl<V:TyVisitor + MovePtr> TyVisitor for MovePtrAdaptor<V> {
true
}
#[cfg(stage0)]
fn visit_leave_enum(&self, n_variants: uint, sz: uint, align: uint)
-> bool {
if ! self.inner.visit_leave_enum(n_variants, sz, align) {
return false;
}
self.bump(sz);
true
}
#[cfg(not(stage0))]
fn visit_leave_enum(&self, n_variants: uint,
get_disr: extern unsafe fn(ptr: *Opaque) -> int,
sz: uint, align: uint) -> bool {

111
src/libcore/repr.rs
View File

@ -18,12 +18,11 @@ use cast::transmute;
use char;
use intrinsic;
use intrinsic::{TyDesc, TyVisitor, visit_tydesc};
#[cfg(not(stage0))] use intrinsic::Opaque;
use intrinsic::Opaque;
use io::{Writer, WriterUtil};
use libc::c_void;
use managed;
use ptr;
#[cfg(stage0)] use sys;
use reflect;
use reflect::{MovePtr, align};
use to_str::ToStr;
@ -138,14 +137,6 @@ impl Repr for char {
// New implementation using reflect::MovePtr
#[cfg(stage0)]
enum VariantState {
Degenerate,
TagMatch,
TagMismatch,
}
#[cfg(not(stage0))]
enum VariantState {
SearchingFor(int),
Matched,
@ -190,18 +181,6 @@ pub impl ReprVisitor {
true
}
#[cfg(stage0)] #[inline(always)]
fn bump(&self, sz: uint) {
do self.move_ptr() |p| {
((p as uint) + sz) as *c_void
};
}
#[cfg(stage0)] #[inline(always)]
fn bump_past<T>(&self) {
self.bump(sys::size_of::<T>());
}
#[inline(always)]
fn visit_inner(&self, inner: *TyDesc) -> bool {
self.visit_ptr_inner(self.ptr, inner)
@ -467,18 +446,6 @@ impl TyVisitor for ReprVisitor {
true
}
#[cfg(stage0)]
fn visit_enter_enum(&self, n_variants: uint,
_sz: uint, _align: uint) -> bool {
if n_variants == 1 {
self.var_stk.push(Degenerate)
} else {
self.var_stk.push(TagMatch)
}
true
}
#[cfg(not(stage0))]
fn visit_enter_enum(&self, _n_variants: uint,
get_disr: extern unsafe fn(ptr: *Opaque) -> int,
_sz: uint, _align: uint) -> bool {
@ -487,40 +454,6 @@ impl TyVisitor for ReprVisitor {
true
}
#[cfg(stage0)]
fn visit_enter_enum_variant(&self, _variant: uint,
disr_val: int,
n_fields: uint,
name: &str) -> bool {
let mut write = false;
match self.var_stk.pop() {
Degenerate => {
write = true;
self.var_stk.push(Degenerate);
}
TagMatch | TagMismatch => {
do self.get::<int>() |t| {
if disr_val == *t {
write = true;
self.var_stk.push(TagMatch);
} else {
self.var_stk.push(TagMismatch);
}
};
self.bump_past::<int>();
}
}
if write {
self.writer.write_str(name);
if n_fields > 0 {
self.writer.write_char('(');
}
}
true
}
#[cfg(not(stage0))]
fn visit_enter_enum_variant(&self, _variant: uint,
disr_val: int,
n_fields: uint,
@ -549,23 +482,6 @@ impl TyVisitor for ReprVisitor {
true
}
#[cfg(stage0)]
fn visit_enum_variant_field(&self, i: uint, inner: *TyDesc) -> bool {
match self.var_stk[vec::uniq_len(&const self.var_stk) - 1] {
Degenerate | TagMatch => {
if i != 0 {
self.writer.write_str(", ");
}
if ! self.visit_inner(inner) {
return false;
}
}
TagMismatch => ()
}
true
}
#[cfg(not(stage0))]
fn visit_enum_variant_field(&self, i: uint, _offset: uint, inner: *TyDesc) -> bool {
match self.var_stk[vec::uniq_len(&const self.var_stk) - 1] {
Matched => {
@ -581,23 +497,6 @@ impl TyVisitor for ReprVisitor {
true
}
#[cfg(stage0)]
fn visit_leave_enum_variant(&self, _variant: uint,
_disr_val: int,
n_fields: uint,
_name: &str) -> bool {
match self.var_stk[vec::uniq_len(&const self.var_stk) - 1] {
Degenerate | TagMatch => {
if n_fields > 0 {
self.writer.write_char(')');
}
}
TagMismatch => ()
}
true
}
#[cfg(not(stage0))]
fn visit_leave_enum_variant(&self, _variant: uint,
_disr_val: int,
n_fields: uint,
@ -613,14 +512,6 @@ impl TyVisitor for ReprVisitor {
true
}
#[cfg(stage0)]
fn visit_leave_enum(&self, _n_variants: uint,
_sz: uint, _align: uint) -> bool {
self.var_stk.pop();
true
}
#[cfg(not(stage0))]
fn visit_leave_enum(&self, _n_variants: uint,
_get_disr: extern unsafe fn(ptr: *Opaque) -> int,
_sz: uint, _align: uint) -> bool {

7
src/libcore/result.rs
View File

@ -226,13 +226,6 @@ pub fn map_err<T:Copy,E,F:Copy>(res: &Result<T, E>, op: &fn(&E) -> F)
}
pub impl<T, E> Result<T, E> {
#[cfg(stage0)]
#[inline(always)]
fn get_ref(&self) -> &'self T { get_ref(self) }
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
#[inline(always)]
fn get_ref<'a>(&'a self) -> &'a T { get_ref(self) }

3
src/libcore/rt/io/mod.rs
View File

@ -275,7 +275,6 @@ pub mod net {
}
/// Readers and Writers for memory buffers and strings.
#[cfg(not(stage0))] // XXX Using unsnapshotted features
pub mod mem;
/// Non-blocking access to stdin, stdout, stderr
@ -286,11 +285,9 @@ pub mod stdio;
mod option;
/// Basic stream compression. XXX: Belongs with other flate code
#[cfg(not(stage0))] // XXX Using unsnapshotted features
pub mod flate;
/// Interop between byte streams and pipes. Not sure where it belongs
#[cfg(not(stage0))] // XXX "
pub mod comm_adapters;
/// Extension traits

21
src/libcore/rt/mod.rs
View File

@ -37,27 +37,6 @@ mod local_heap;
#[cfg(test)]
pub mod test;
#[cfg(stage0)]
pub fn start(main: *u8, _argc: int, _argv: *c_char, _crate_map: *u8) -> int {
use self::sched::{Scheduler, Task};
use self::uvio::UvEventLoop;
let loop_ = ~UvEventLoop::new();
let mut sched = ~Scheduler::new(loop_);
let main_task = ~do Task::new(&mut sched.stack_pool) {
// XXX: Can't call a C function pointer from Rust yet
unsafe { rust_call_nullary_fn(main) };
};
sched.task_queue.push_back(main_task);
sched.run();
return 0;
extern {
fn rust_call_nullary_fn(f: *u8);
}
}
#[cfg(not(stage0))]
pub fn start(main: *u8, _argc: int, _argv: **c_char, _crate_map: *u8) -> int {
use self::sched::{Scheduler, Task};
use self::uvio::UvEventLoop;

5
src/libcore/rt/rtio.rs
View File

@ -24,11 +24,6 @@ pub trait EventLoop {
fn run(&mut self);
fn callback(&mut self, ~fn());
/// The asynchronous I/O services. Not all event loops may provide one
#[cfg(stage0)]
fn io(&mut self) -> Option<&'self mut IoFactoryObject>;
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn io<'a>(&'a mut self) -> Option<&'a mut IoFactoryObject>;
}

16
src/libcore/rt/uvio.rs
View File

@ -68,14 +68,6 @@ impl EventLoop for UvEventLoop {
}
}
#[cfg(stage0)]
fn io(&mut self) -> Option<&'self mut IoFactoryObject> {
Some(&mut self.uvio)
}
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn io<'a>(&'a mut self) -> Option<&'a mut IoFactoryObject> {
Some(&mut self.uvio)
}
@ -98,14 +90,6 @@ fn test_callback_run_once() {
pub struct UvIoFactory(Loop);
pub impl UvIoFactory {
#[cfg(stage0)]
fn uv_loop(&mut self) -> &'self mut Loop {
match self { &UvIoFactory(ref mut ptr) => ptr }
}
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn uv_loop<'a>(&'a mut self) -> &'a mut Loop {
match self { &UvIoFactory(ref mut ptr) => ptr }
}

3
src/libcore/stackwalk.rs
View File

@ -93,9 +93,6 @@ pub mod rustrt {
pub mod rusti {
#[abi = "rust-intrinsic"]
pub extern "rust-intrinsic" {
#[cfg(stage0)]
pub fn frame_address(f: &once fn(x: *u8));
#[cfg(not(stage0))]
pub fn frame_address(+f: &once fn(x: *u8));
}
}

22
src/libcore/sys.rs
View File

@ -200,21 +200,6 @@ impl FailWithCause for &'static str {
}
}
// NOTE: remove function after snapshot
#[cfg(stage0)]
pub fn begin_unwind(msg: ~str, file: ~str, line: uint) -> ! {
do str::as_buf(msg) |msg_buf, _msg_len| {
do str::as_buf(file) |file_buf, _file_len| {
unsafe {
let msg_buf = cast::transmute(msg_buf);
let file_buf = cast::transmute(file_buf);
begin_unwind_(msg_buf, file_buf, line as libc::size_t)
}
}
}
}
// FIXME #4427: Temporary until rt::rt_fail_ goes away
pub fn begin_unwind_(msg: *c_char, file: *c_char, line: size_t) -> ! {
use rt::{context, OldTaskContext};
@ -242,13 +227,6 @@ pub fn begin_unwind_(msg: *c_char, file: *c_char, line: size_t) -> ! {
}
}
// NOTE: remove function after snapshot
#[cfg(stage0)]
pub fn fail_assert(msg: &str, file: &str, line: uint) -> ! {
let (msg, file) = (msg.to_owned(), file.to_owned());
begin_unwind(~"assertion failed: " + msg, file, line)
}
#[cfg(test)]
mod tests {
use cast;

95
src/libcore/trie.rs
View File

@ -56,16 +56,6 @@ impl<T> Map<uint, T> for TrieMap<T> {
/// Visit all key-value pairs in order
#[inline(always)]
#[cfg(stage0)]
fn each(&self, f: &fn(&uint, &'self T) -> bool) {
self.root.each(f);
}
/// Visit all key-value pairs in order
#[inline(always)]
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn each<'a>(&'a self, f: &fn(&uint, &'a T) -> bool) {
self.root.each(f);
}
@ -78,16 +68,6 @@ impl<T> Map<uint, T> for TrieMap<T> {
/// Visit all values in order
#[inline(always)]
#[cfg(stage0)]
fn each_value(&self, f: &fn(&T) -> bool) {
self.each(|_, v| f(v))
}
/// Visit all values in order
#[inline(always)]
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn each_value<'a>(&'a self, f: &fn(&'a T) -> bool) {
self.each(|_, v| f(v))
}
@ -99,31 +79,6 @@ impl<T> Map<uint, T> for TrieMap<T> {
}
/// Return a reference to the value corresponding to the key
#[cfg(stage0)]
#[inline(hint)]
fn find(&self, key: &uint) -> Option<&'self T> {
let mut node: &'self TrieNode<T> = &self.root;
let mut idx = 0;
loop {
match node.children[chunk(*key, idx)] {
Internal(ref x) => node = &**x,
External(stored, ref value) => {
if stored == *key {
return Some(value)
} else {
return None
}
}
Nothing => return None
}
idx += 1;
}
}
/// Return a reference to the value corresponding to the key
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
#[inline(hint)]
fn find<'a>(&'a self, key: &uint) -> Option<&'a T> {
let mut node: &'a TrieNode<T> = &self.root;
@ -145,16 +100,6 @@ impl<T> Map<uint, T> for TrieMap<T> {
}
/// Return a mutable reference to the value corresponding to the key
#[cfg(stage0)]
#[inline(always)]
fn find_mut(&mut self, key: &uint) -> Option<&'self mut T> {
find_mut(&mut self.root.children[chunk(*key, 0)], *key, 1)
}
/// Return a mutable reference to the value corresponding to the key
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
#[inline(always)]
fn find_mut<'a>(&'a mut self, key: &uint) -> Option<&'a mut T> {
find_mut(&mut self.root.children[chunk(*key, 0)], *key, 1)
@ -193,16 +138,6 @@ pub impl<T> TrieMap<T> {
/// Visit all key-value pairs in reverse order
#[inline(always)]
#[cfg(stage0)]
fn each_reverse(&self, f: &fn(&uint, &'self T) -> bool) {
self.root.each_reverse(f);
}
/// Visit all key-value pairs in reverse order
#[inline(always)]
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn each_reverse<'a>(&'a self, f: &fn(&uint, &'a T) -> bool) {
self.root.each_reverse(f);
}
@ -298,21 +233,6 @@ impl<T> TrieNode<T> {
}
impl<T> TrieNode<T> {
#[cfg(stage0)]
fn each(&self, f: &fn(&uint, &'self T) -> bool) -> bool {
for uint::range(0, self.children.len()) |idx| {
match self.children[idx] {
Internal(ref x) => if !x.each(f) { return false },
External(k, ref v) => if !f(&k, v) { return false },
Nothing => ()
}
}
true
}
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn each<'a>(&'a self, f: &fn(&uint, &'a T) -> bool) -> bool {
for uint::range(0, self.children.len()) |idx| {
match self.children[idx] {
@ -324,21 +244,6 @@ impl<T> TrieNode<T> {
true
}
#[cfg(stage0)]
fn each_reverse(&self, f: &fn(&uint, &'self T) -> bool) -> bool {
for uint::range_rev(self.children.len(), 0) |idx| {
match self.children[idx - 1] {
Internal(ref x) => if !x.each_reverse(f) { return false },
External(k, ref v) => if !f(&k, v) { return false },
Nothing => ()
}
}
true
}
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn each_reverse<'a>(&'a self, f: &fn(&uint, &'a T) -> bool) -> bool {
for uint::range_rev(self.children.len(), 0) |idx| {
match self.children[idx - 1] {

28
src/libcore/tuple.rs
View File

@ -56,39 +56,11 @@ impl<T:Clone,U:Clone> Clone for (T, U) {
}
}
#[cfg(stage0)]
pub trait ImmutableTuple<T, U> {
fn first_ref(&self) -> &'self T;
fn second_ref(&self) -> &'self U;
}
#[cfg(stage0)]
impl<T, U> ImmutableTuple<T, U> for (T, U) {
#[inline(always)]
fn first_ref(&self) -> &'self T {
match *self {
(ref t, _) => t,
}
}
#[inline(always)]
fn second_ref(&self) -> &'self U {
match *self {
(_, ref u) => u,
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
pub trait ImmutableTuple<T, U> {
fn first_ref<'a>(&'a self) -> &'a T;
fn second_ref<'a>(&'a self) -> &'a U;
}
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
impl<T, U> ImmutableTuple<T, U> for (T, U) {
#[inline(always)]
fn first_ref<'a>(&'a self) -> &'a T {

4
src/libcore/unstable/intrinsics.rs
View File

@ -46,10 +46,6 @@ pub extern "rust-intrinsic" {
pub fn forget<T>(_: T) -> ();
// XXX: intrinsic uses legacy modes
#[cfg(stage0)]
fn reinterpret_cast<T,U>(&&src: T) -> U;
pub fn needs_drop<T>() -> bool;
// XXX: intrinsic uses legacy modes and has reference to TyDesc

47
src/libcore/unstable/lang.rs
View File

@ -17,9 +17,7 @@ use str;
use sys;
use unstable::exchange_alloc;
use cast::transmute;
#[cfg(not(stage0))]
use rt::{context, OldTaskContext};
#[cfg(not(stage0))]
use rt::local_services::borrow_local_services;
#[allow(non_camel_case_types)]
@ -91,14 +89,6 @@ pub unsafe fn exchange_free(ptr: *c_char) {
}
#[lang="malloc"]
#[inline(always)]
#[cfg(stage0)] // For some reason this isn't working on windows in stage0
pub unsafe fn local_malloc(td: *c_char, size: uintptr_t) -> *c_char {
return rustrt::rust_upcall_malloc_noswitch(td, size);
}
#[lang="malloc"]
#[cfg(not(stage0))]
pub unsafe fn local_malloc(td: *c_char, size: uintptr_t) -> *c_char {
match context() {
OldTaskContext => {
@ -118,17 +108,6 @@ pub unsafe fn local_malloc(td: *c_char, size: uintptr_t) -> *c_char {
// inside a landing pad may corrupt the state of the exception handler. If a
// problem occurs, call exit instead.
#[lang="free"]
#[inline(always)]
#[cfg(stage0)]
pub unsafe fn local_free(ptr: *c_char) {
rustrt::rust_upcall_free_noswitch(ptr);
}
// NB: Calls to free CANNOT be allowed to fail, as throwing an exception from
// inside a landing pad may corrupt the state of the exception handler. If a
// problem occurs, call exit instead.
#[lang="free"]
#[cfg(not(stage0))]
pub unsafe fn local_free(ptr: *c_char) {
match context() {
OldTaskContext => {
@ -176,32 +155,6 @@ pub unsafe fn strdup_uniq(ptr: *c_uchar, len: uint) -> ~str {
}
#[lang="start"]
#[cfg(stage0)]
pub fn start(main: *u8, argc: int, argv: *c_char,
crate_map: *u8) -> int {
use libc::getenv;
use rt::start;
unsafe {
let use_old_rt = do str::as_c_str("RUST_NEWRT") |s| {
getenv(s).is_null()
};
if use_old_rt {
return rust_start(main as *c_void, argc as c_int, argv,
crate_map as *c_void) as int;
} else {
return start(main, argc, argv, crate_map);
}
}
extern {
fn rust_start(main: *c_void, argc: c_int, argv: *c_char,
crate_map: *c_void) -> c_int;
}
}
#[lang="start"]
#[cfg(not(stage0))]
pub fn start(main: *u8, argc: int, argv: **c_char,
crate_map: *u8) -> int {
use libc::getenv;

226
src/libcore/vec.rs
View File

@ -19,9 +19,6 @@ use cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering, Less, Equal, Greater};
use clone::Clone;
use old_iter::BaseIter;
use old_iter;
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
use iterator::Iterator;
use kinds::Copy;
use libc;
@ -1566,16 +1563,6 @@ pub fn each_permutation<T:Copy>(v: &[T], put: &fn(ts: &[T]) -> bool) {
}
}
// see doc below
#[cfg(stage0)] // XXX: lifetimes!
pub fn windowed<T>(n: uint, v: &[T], it: &fn(&[T]) -> bool) {
assert!(1u <= n);
if n > v.len() { return; }
for uint::range(0, v.len() - n + 1) |i| {
if !it(v.slice(i, i+n)) { return }
}
}
/**
* Iterate over all contiguous windows of length `n` of the vector `v`.
*
@ -1590,9 +1577,6 @@ pub fn windowed<T>(n: uint, v: &[T], it: &fn(&[T]) -> bool) {
* ~~~
*
*/
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
pub fn windowed<'r, T>(n: uint, v: &'r [T], it: &fn(&'r [T]) -> bool) {
assert!(1u <= n);
if n > v.len() { return; }
@ -1854,150 +1838,6 @@ impl<'self,T:Copy> CopyableVector<T> for &'self const [T] {
}
}
#[cfg(stage0)]
pub trait ImmutableVector<T> {
fn slice(&self, start: uint, end: uint) -> &'self [T];
fn head(&self) -> &'self T;
fn head_opt(&self) -> Option<&'self T>;
fn tail(&self) -> &'self [T];
fn tailn(&self, n: uint) -> &'self [T];
fn init(&self) -> &'self [T];
fn initn(&self, n: uint) -> &'self [T];
fn last(&self) -> &'self T;
fn last_opt(&self) -> Option<&'self T>;
fn each_reverse(&self, blk: &fn(&T) -> bool);
fn eachi_reverse(&self, blk: &fn(uint, &T) -> bool);
fn foldr<U: Copy>(&self, z: U, p: &fn(t: &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];
fn map_r<U>(&self, f: &fn(x: &T) -> U) -> ~[U];
fn alli(&self, f: &fn(uint, t: &T) -> bool) -> bool;
fn flat_map<U>(&self, f: &fn(t: &T) -> ~[U]) -> ~[U];
fn filter_mapped<U:Copy>(&self, f: &fn(t: &T) -> Option<U>) -> ~[U];
unsafe fn unsafe_ref(&self, index: uint) -> *T;
}
/// Extension methods for vectors
#[cfg(stage0)]
impl<'self,T> ImmutableVector<T> for &'self [T] {
/// Return a slice that points into another slice.
#[inline]
fn slice(&self, start: uint, end: uint) -> &'self [T] {
slice(*self, start, end)
}
/// Returns the first element of a vector, failing if the vector is empty.
#[inline]
fn head(&self) -> &'self T { head(*self) }
/// Returns the first element of a vector
#[inline]
fn head_opt(&self) -> Option<&'self T> { head_opt(*self) }
/// Returns all but the first element of a vector
#[inline]
fn tail(&self) -> &'self [T] { tail(*self) }
/// Returns all but the first `n' elements of a vector
#[inline]
fn tailn(&self, n: uint) -> &'self [T] { tailn(*self, n) }
/// Returns all but the last elemnt of a vector
#[inline]
fn init(&self) -> &'self [T] { init(*self) }
/// Returns all but the last `n' elemnts of a vector
#[inline]
fn initn(&self, n: uint) -> &'self [T] { initn(*self, n) }
/// Returns the last element of a `v`, failing if the vector is empty.
#[inline]
fn last(&self) -> &'self T { last(*self) }
/// Returns the last element of a `v`, failing if the vector is empty.
#[inline]
fn last_opt(&self) -> Option<&'self T> { last_opt(*self) }
/// Iterates over a vector's elements in reverse.
#[inline]
fn each_reverse(&self, blk: &fn(&T) -> bool) {
each_reverse(*self, blk)
}
/// Iterates over a vector's elements and indices in reverse.
#[inline]
fn eachi_reverse(&self, blk: &fn(uint, &T) -> bool) {
eachi_reverse(*self, blk)
}
/// Reduce a vector from right to left
#[inline]
fn foldr<U:Copy>(&self, z: U, p: &fn(t: &T, u: U) -> U) -> U {
foldr(*self, z, p)
}
/// Apply a function to each element of a vector and return the results
#[inline]
fn map<U>(&self, f: &fn(t: &T) -> U) -> ~[U] { map(*self, f) }
/**
* Apply a function to the index and value of each element in the vector
* and return the results
*/
fn mapi<U>(&self, f: &fn(uint, t: &T) -> U) -> ~[U] {
mapi(*self, f)
}
#[inline]
fn map_r<U>(&self, f: &fn(x: &T) -> U) -> ~[U] {
let mut r = ~[];
let mut i = 0;
while i < self.len() {
r.push(f(&self[i]));
i += 1;
}
r
}
/**
* Returns true if the function returns true for all elements.
*
* If the vector is empty, true is returned.
*/
fn alli(&self, f: &fn(uint, t: &T) -> bool) -> bool {
alli(*self, f)
}
/**
* Apply a function to each element of a vector and return a concatenation
* of each result vector
*/
#[inline]
fn flat_map<U>(&self, f: &fn(t: &T) -> ~[U]) -> ~[U] {
flat_map(*self, f)
}
/**
* Apply a function to each element of a vector and return the results
*
* If function `f` returns `none` then that element is excluded from
* the resulting vector.
*/
#[inline]
fn filter_mapped<U:Copy>(&self, f: &fn(t: &T) -> Option<U>) -> ~[U] {
filter_mapped(*self, f)
}
/// Returns a pointer to the element at the given index, without doing
/// bounds checking.
#[inline(always)]
unsafe fn unsafe_ref(&self, index: uint) -> *T {
let (ptr, _): (*T, uint) = transmute(*self);
ptr.offset(index)
}
}
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
pub trait ImmutableVector<'self, T> {
fn slice(&self, start: uint, end: uint) -> &'self [T];
fn iter(self) -> VecIterator<'self, T>;
@ -2022,9 +1862,6 @@ pub trait ImmutableVector<'self, T> {
}
/// Extension methods for vectors
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
impl<'self,T> ImmutableVector<'self, T> for &'self [T] {
/// Return a slice that points into another slice.
#[inline]
@ -2634,17 +2471,6 @@ pub mod bytes {
// ___________________________________________________________________________
// ITERATION TRAIT METHODS
#[cfg(stage0)]
impl<'self,A> old_iter::BaseIter<A> for &'self [A] {
#[inline(always)]
fn each(&self, blk: &fn(v: &'self A) -> bool) { each(*self, blk) }
#[inline(always)]
fn size_hint(&self) -> Option<uint> { Some(self.len()) }
}
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
impl<'self,A> old_iter::BaseIter<A> for &'self [A] {
#[inline(always)]
fn each<'a>(&'a self, blk: &fn(v: &'a A) -> bool) { each(*self, blk) }
@ -2653,18 +2479,6 @@ impl<'self,A> old_iter::BaseIter<A> for &'self [A] {
}
// FIXME(#4148): This should be redundant
#[cfg(stage0)]
impl<A> old_iter::BaseIter<A> for ~[A] {
#[inline(always)]
fn each(&self, blk: &fn(v: &'self A) -> bool) { each(*self, blk) }
#[inline(always)]
fn size_hint(&self) -> Option<uint> { Some(self.len()) }
}
// FIXME(#4148): This should be redundant
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
impl<A> old_iter::BaseIter<A> for ~[A] {
#[inline(always)]
fn each<'a>(&'a self, blk: &fn(v: &'a A) -> bool) { each(*self, blk) }
@ -2673,18 +2487,6 @@ impl<A> old_iter::BaseIter<A> for ~[A] {
}
// FIXME(#4148): This should be redundant
#[cfg(stage0)]
impl<A> old_iter::BaseIter<A> for @[A] {
#[inline(always)]
fn each(&self, blk: &fn(v: &'self A) -> bool) { each(*self, blk) }
#[inline(always)]
fn size_hint(&self) -> Option<uint> { Some(self.len()) }
}
// FIXME(#4148): This should be redundant
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
impl<A> old_iter::BaseIter<A> for @[A] {
#[inline(always)]
fn each<'a>(&'a self, blk: &fn(v: &'a A) -> bool) { each(*self, blk) }
@ -2692,17 +2494,6 @@ impl<A> old_iter::BaseIter<A> for @[A] {
fn size_hint(&self) -> Option<uint> { Some(self.len()) }
}
#[cfg(stage0)]
impl<'self,A> old_iter::MutableIter<A> for &'self mut [A] {
#[inline(always)]
fn each_mut(&mut self, blk: &fn(v: &'self mut A) -> bool) {
each_mut(*self, blk)
}
}
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
impl<'self,A> old_iter::MutableIter<A> for &'self mut [A] {
#[inline(always)]
fn each_mut<'a>(&'a mut self, blk: &fn(v: &'a mut A) -> bool) {
@ -2711,17 +2502,6 @@ impl<'self,A> old_iter::MutableIter<A> for &'self mut [A] {
}
// FIXME(#4148): This should be redundant
#[cfg(stage0)]
impl<A> old_iter::MutableIter<A> for ~[A] {
#[inline(always)]
fn each_mut(&mut self, blk: &fn(v: &'self mut A) -> bool) {
each_mut(*self, blk)
}
}
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
impl<A> old_iter::MutableIter<A> for ~[A] {
#[inline(always)]
fn each_mut<'a>(&'a mut self, blk: &fn(v: &'a mut A) -> bool) {
@ -2927,18 +2707,12 @@ impl<A:Clone> Clone for ~[A] {
}
// could be implemented with &[T] with .slice(), but this avoids bounds checks
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
pub struct VecIterator<'self, T> {
priv ptr: *T,
priv end: *T,
priv lifetime: &'self T // FIXME: #5922
}
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
impl<'self, T> Iterator<&'self T> for VecIterator<'self, T> {
#[inline]
fn next(&mut self) -> Option<&'self T> {

8
src/librustc/metadata/decoder.rs
View File

@ -272,14 +272,6 @@ fn item_ty_param_defs(item: ebml::Doc, tcx: ty::ctxt, cdata: cmd,
@bounds
}
#[cfg(stage0)]
fn item_ty_region_param(item: ebml::Doc) -> Option<ty::region_variance> {
reader::maybe_get_doc(item, tag_region_param).map(|doc| {
Decodable::decode(&reader::Decoder(*doc))
})
}
#[cfg(not(stage0))]
fn item_ty_region_param(item: ebml::Doc) -> Option<ty::region_variance> {
reader::maybe_get_doc(item, tag_region_param).map(|doc| {
let mut decoder = reader::Decoder(*doc);

1304
src/librustc/metadata/encoder.rs
View File

File diff suppressed because it is too large Load Diff

774
src/librustc/middle/astencode.rs
View File

File diff suppressed because it is too large Load Diff

59
src/libstd/arena.rs
View File

@ -203,21 +203,6 @@ pub impl Arena {
}
#[inline(always)]
#[cfg(stage0)]
priv fn alloc_pod<T>(&mut self, op: &fn() -> T) -> &'self T {
unsafe {
let tydesc = sys::get_type_desc::<T>();
let ptr = self.alloc_pod_inner((*tydesc).size, (*tydesc).align);
let ptr: *mut T = transmute(ptr);
rusti::move_val_init(&mut (*ptr), op());
return transmute(ptr);
}
}
#[inline(always)]
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
priv fn alloc_pod<'a, T>(&'a mut self, op: &fn() -> T) -> &'a T {
unsafe {
let tydesc = sys::get_type_desc::<T>();
@ -265,31 +250,6 @@ pub impl Arena {
}
#[inline(always)]
#[cfg(stage0)]
priv fn alloc_nonpod<T>(&mut self, op: &fn() -> T) -> &'self T {
unsafe {
let tydesc = sys::get_type_desc::<T>();
let (ty_ptr, ptr) =
self.alloc_nonpod_inner((*tydesc).size, (*tydesc).align);
let ty_ptr: *mut uint = transmute(ty_ptr);
let ptr: *mut T = transmute(ptr);
// Write in our tydesc along with a bit indicating that it
// has *not* been initialized yet.
*ty_ptr = transmute(tydesc);
// Actually initialize it
rusti::move_val_init(&mut(*ptr), op());
// Now that we are done, update the tydesc to indicate that
// the object is there.
*ty_ptr = bitpack_tydesc_ptr(tydesc, true);
return transmute(ptr);
}
}
#[inline(always)]
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
priv fn alloc_nonpod<'a, T>(&'a mut self, op: &fn() -> T) -> &'a T {
unsafe {
let tydesc = sys::get_type_desc::<T>();
@ -312,25 +272,6 @@ pub impl Arena {
// The external interface
#[inline(always)]
#[cfg(stage0)]
fn alloc<T>(&mut self, op: &fn() -> T) -> &'self T {
unsafe {
// XXX: Borrow check
let this = transmute_mut_region(self);
if !rusti::needs_drop::<T>() {
return this.alloc_pod(op);
}
// XXX: Borrow check
let this = transmute_mut_region(self);
this.alloc_nonpod(op)
}
}
// The external interface
#[inline(always)]
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn alloc<'a, T>(&'a mut self, op: &fn() -> T) -> &'a T {
unsafe {
// XXX: Borrow check

122
src/libstd/deque.rs
View File

@ -37,128 +37,6 @@ impl<T> Mutable for Deque<T> {
}
}
#[cfg(stage0)]
pub impl<T> Deque<T> {
/// Create an empty Deque
fn new() -> Deque<T> {
Deque{nelts: 0, lo: 0, hi: 0,
elts: vec::from_fn(initial_capacity, |_| None)}
}
/// Return a reference to the first element in the deque
///
/// Fails if the deque is empty
#[cfg(stage0)]
fn peek_front(&self) -> &'self T { get(self.elts, self.lo) }
/// Return a reference to the first element in the deque
///
/// Fails if the deque is empty
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn peek_front<'a>(&'a self) -> &'a T { get(self.elts, self.lo) }
/// Return a reference to the last element in the deque
///
/// Fails if the deque is empty
#[cfg(stage0)]
fn peek_back(&self) -> &'self T { get(self.elts, self.hi - 1u) }
/// Return a reference to the last element in the deque
///
/// Fails if the deque is empty
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn peek_back<'a>(&'a self) -> &'a T { get(self.elts, self.hi - 1u) }
/// Retrieve an element in the deque by index
///
/// Fails if there is no element with the given index
#[cfg(stage0)]
fn get(&self, i: int) -> &'self T {
let idx = (self.lo + (i as uint)) % self.elts.len();
get(self.elts, idx)
}
/// Retrieve an element in the deque by index
///
/// Fails if there is no element with the given index
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn get<'a>(&'a self, i: int) -> &'a T {
let idx = (self.lo + (i as uint)) % self.elts.len();
get(self.elts, idx)
}
/// Iterate over the elements in the deque
fn each(&self, f: &fn(&T) -> bool) {
self.eachi(|_i, e| f(e))
}
/// Iterate over the elements in the deque by index
fn eachi(&self, f: &fn(uint, &T) -> bool) {
for uint::range(0, self.nelts) |i| {
if !f(i, self.get(i as int)) { return; }
}
}
/// Remove and return the first element in the deque
///
/// Fails if the deque is empty
fn pop_front(&mut self) -> T {
let result = self.elts[self.lo].swap_unwrap();
self.lo = (self.lo + 1u) % self.elts.len();
self.nelts -= 1u;
result
}
/// Remove and return the last element in the deque
///
/// Fails if the deque is empty
fn pop_back(&mut self) -> T {
if self.hi == 0u {
self.hi = self.elts.len() - 1u;
} else { self.hi -= 1u; }
let result = self.elts[self.hi].swap_unwrap();
self.elts[self.hi] = None;
self.nelts -= 1u;
result
}
/// Prepend an element to the deque
fn add_front(&mut self, t: T) {
let oldlo = self.lo;
if self.lo == 0u {
self.lo = self.elts.len() - 1u;
} else { self.lo -= 1u; }
if self.lo == self.hi {
self.elts = grow(self.nelts, oldlo, self.elts);
self.lo = self.elts.len() - 1u;
self.hi = self.nelts;
}
self.elts[self.lo] = Some(t);
self.nelts += 1u;
}
/// Append an element to the deque
fn add_back(&mut self, t: T) {
if self.lo == self.hi && self.nelts != 0u {
self.elts = grow(self.nelts, self.lo, self.elts);
self.lo = 0u;
self.hi = self.nelts;
}
self.elts[self.hi] = Some(t);
self.hi = (self.hi + 1u) % self.elts.len();
self.nelts += 1u;
}
}
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
pub impl<T> Deque<T> {
/// Create an empty Deque
fn new() -> Deque<T> {

539
src/libstd/ebml.rs
View File

@ -263,13 +263,6 @@ pub mod reader {
pub fn doc_as_i32(d: Doc) -> i32 { doc_as_u32(d) as i32 }
pub fn doc_as_i64(d: Doc) -> i64 { doc_as_u64(d) as i64 }
#[cfg(stage0)]
pub struct Decoder {
priv mut parent: Doc,
priv mut pos: uint,
}
#[cfg(not(stage0))]
pub struct Decoder {
priv parent: Doc,
priv pos: uint,
@ -283,25 +276,6 @@ pub mod reader {
}
priv impl Decoder {
#[cfg(stage0)]
fn _check_label(&self, lbl: &str) {
if self.pos < self.parent.end {
let TaggedDoc { tag: r_tag, doc: r_doc } =
doc_at(self.parent.data, self.pos);
if r_tag == (EsLabel as uint) {
self.pos = r_doc.end;
let str = doc_as_str(r_doc);
if lbl != str {
fail!(fmt!("Expected label %s but found %s",
lbl,
str));
}
}
}
}
#[cfg(not(stage0))]
fn _check_label(&mut self, lbl: &str) {
if self.pos < self.parent.end {
let TaggedDoc { tag: r_tag, doc: r_doc } =
@ -319,30 +293,6 @@ pub mod reader {
}
}
#[cfg(stage0)]
fn next_doc(&self, exp_tag: EbmlEncoderTag) -> Doc {
debug!(". next_doc(exp_tag=%?)", exp_tag);
if self.pos >= self.parent.end {
fail!(~"no more documents in current node!");
}
let TaggedDoc { tag: r_tag, doc: r_doc } =
doc_at(self.parent.data, self.pos);
debug!("self.parent=%?-%? self.pos=%? r_tag=%? r_doc=%?-%?",
copy self.parent.start, copy self.parent.end,
copy self.pos, r_tag, r_doc.start, r_doc.end);
if r_tag != (exp_tag as uint) {
fail!(fmt!("expected EBML doc with tag %? but found tag %?",
exp_tag, r_tag));
}
if r_doc.end > self.parent.end {
fail!(fmt!("invalid EBML, child extends to 0x%x, \
parent to 0x%x", r_doc.end, self.parent.end));
}
self.pos = r_doc.end;
r_doc
}
#[cfg(not(stage0))]
fn next_doc(&mut self, exp_tag: EbmlEncoderTag) -> Doc {
debug!(". next_doc(exp_tag=%?)", exp_tag);
if self.pos >= self.parent.end {
@ -365,19 +315,6 @@ pub mod reader {
r_doc
}
#[cfg(stage0)]
fn push_doc<T>(&self, d: Doc, f: &fn() -> T) -> T {
let old_parent = self.parent;
let old_pos = self.pos;
self.parent = d;
self.pos = d.start;
let r = f();
self.parent = old_parent;
self.pos = old_pos;
r
}
#[cfg(not(stage0))]
fn push_doc<T>(&mut self, d: Doc, f: &fn() -> T) -> T {
let old_parent = self.parent;
let old_pos = self.pos;
@ -389,14 +326,6 @@ pub mod reader {
r
}
#[cfg(stage0)]
fn _next_uint(&self, exp_tag: EbmlEncoderTag) -> uint {
let r = doc_as_u32(self.next_doc(exp_tag));
debug!("_next_uint exp_tag=%? result=%?", exp_tag, r);
r as uint
}
#[cfg(not(stage0))]
fn _next_uint(&mut self, exp_tag: EbmlEncoderTag) -> uint {
let r = doc_as_u32(self.next_doc(exp_tag));
debug!("_next_uint exp_tag=%? result=%?", exp_tag, r);
@ -405,14 +334,6 @@ pub mod reader {
}
pub impl Decoder {
#[cfg(stage0)]
fn read_opaque<R>(&self, op: &fn(Doc) -> R) -> R {
do self.push_doc(self.next_doc(EsOpaque)) {
op(copy self.parent)
}
}
#[cfg(not(stage0))]
fn read_opaque<R>(&mut self, op: &fn(&mut Decoder, Doc) -> R) -> R {
let doc = self.next_doc(EsOpaque);
@ -428,188 +349,6 @@ pub mod reader {
}
}
#[cfg(stage0)]
impl serialize::Decoder for Decoder {
fn read_nil(&self) -> () { () }
fn read_u64(&self) -> u64 { doc_as_u64(self.next_doc(EsU64)) }
fn read_u32(&self) -> u32 { doc_as_u32(self.next_doc(EsU32)) }
fn read_u16(&self) -> u16 { doc_as_u16(self.next_doc(EsU16)) }
fn read_u8 (&self) -> u8 { doc_as_u8 (self.next_doc(EsU8 )) }
fn read_uint(&self) -> uint {
let v = doc_as_u64(self.next_doc(EsUint));
if v > (::core::uint::max_value as u64) {
fail!(fmt!("uint %? too large for this architecture", v));
}
v as uint
}
fn read_i64(&self) -> i64 {
doc_as_u64(self.next_doc(EsI64)) as i64
}
fn read_i32(&self) -> i32 {
doc_as_u32(self.next_doc(EsI32)) as i32
}
fn read_i16(&self) -> i16 {
doc_as_u16(self.next_doc(EsI16)) as i16
}
fn read_i8 (&self) -> i8 {
doc_as_u8(self.next_doc(EsI8 )) as i8
}
fn read_int(&self) -> int {
let v = doc_as_u64(self.next_doc(EsInt)) as i64;
if v > (int::max_value as i64) || v < (int::min_value as i64) {
fail!(fmt!("int %? out of range for this architecture", v));
}
v as int
}
fn read_bool(&self) -> bool {
doc_as_u8(self.next_doc(EsBool)) as bool
}
fn read_f64(&self) -> f64 { fail!(~"read_f64()"); }
fn read_f32(&self) -> f32 { fail!(~"read_f32()"); }
fn read_float(&self) -> float { fail!(~"read_float()"); }
fn read_char(&self) -> char { fail!(~"read_char()"); }
fn read_str(&self) -> ~str { doc_as_str(self.next_doc(EsStr)) }
// Compound types:
fn read_enum<T>(&self, name: &str, f: &fn() -> T) -> T {
debug!("read_enum(%s)", name);
self._check_label(name);
self.push_doc(self.next_doc(EsEnum), f)
}
fn read_enum_variant<T>(&self,
_: &[&str],
f: &fn(uint) -> T)
-> T {
debug!("read_enum_variant()");
let idx = self._next_uint(EsEnumVid);
debug!(" idx=%u", idx);
do self.push_doc(self.next_doc(EsEnumBody)) {
f(idx)
}
}
fn read_enum_variant_arg<T>(&self,
idx: uint,
f: &fn() -> T) -> T {
debug!("read_enum_variant_arg(idx=%u)", idx);
f()
}
fn read_enum_struct_variant<T>(&self,
_: &[&str],
f: &fn(uint) -> T)
-> T {
debug!("read_enum_struct_variant()");
let idx = self._next_uint(EsEnumVid);
debug!(" idx=%u", idx);
do self.push_doc(self.next_doc(EsEnumBody)) {
f(idx)
}
}
fn read_enum_struct_variant_field<T>(&self,
name: &str,
idx: uint,
f: &fn() -> T)
-> T {
debug!("read_enum_struct_variant_arg(name=%?, idx=%u)", name, idx);
f()
}
fn read_struct<T>(&self,
name: &str,
_: uint,
f: &fn() -> T)
-> T {
debug!("read_struct(name=%s)", name);
f()
}
fn read_field<T>(&self,
name: &str,
idx: uint,
f: &fn() -> T)
-> T {
debug!("read_field(name=%?, idx=%u)", name, idx);
self._check_label(name);
f()
}
fn read_tuple<T>(&self, f: &fn(uint) -> T) -> T {
debug!("read_tuple()");
self.read_seq(f)
}
fn read_tuple_arg<T>(&self, idx: uint, f: &fn() -> T) -> T {
debug!("read_tuple_arg(idx=%u)", idx);
self.read_seq_elt(idx, f)
}
fn read_tuple_struct<T>(&self,
name: &str,
f: &fn(uint) -> T)
-> T {
debug!("read_tuple_struct(name=%?)", name);
self.read_tuple(f)
}
fn read_tuple_struct_arg<T>(&self,
idx: uint,
f: &fn() -> T)
-> T {
debug!("read_tuple_struct_arg(idx=%u)", idx);
self.read_tuple_arg(idx, f)
}
fn read_option<T>(&self, f: &fn(bool) -> T) -> T {
debug!("read_option()");
do self.read_enum("Option") || {
do self.read_enum_variant(["None", "Some"]) |idx| {
match idx {
0 => f(false),
1 => f(true),
_ => fail!(),
}
}
}
}
fn read_seq<T>(&self, f: &fn(uint) -> T) -> T {
debug!("read_seq()");
do self.push_doc(self.next_doc(EsVec)) {
let len = self._next_uint(EsVecLen);
debug!(" len=%u", len);
f(len)
}
}
fn read_seq_elt<T>(&self, idx: uint, f: &fn() -> T) -> T {
debug!("read_seq_elt(idx=%u)", idx);
self.push_doc(self.next_doc(EsVecElt), f)
}
fn read_map<T>(&self, _f: &fn(uint) -> T) -> T {
debug!("read_map()");
fail!(~"read_map is unimplemented");
}
fn read_map_elt_key<T>(&self, idx: uint, _f: &fn() -> T) -> T {
debug!("read_map_elt_key(idx=%u)", idx);
fail!(~"read_map_elt_val is unimplemented");
}
fn read_map_elt_val<T>(&self, idx: uint, _f: &fn() -> T) -> T {
debug!("read_map_elt_val(idx=%u)", idx);
fail!(~"read_map_elt_val is unimplemented");
}
}
#[cfg(not(stage0))]
impl serialize::Decoder for Decoder {
fn read_nil(&mut self) -> () { () }
@ -891,104 +630,6 @@ pub mod writer {
}
// FIXME (#2741): Provide a function to write the standard ebml header.
#[cfg(stage0)]
pub impl Encoder {
fn start_tag(&self, tag_id: uint) {
debug!("Start tag %u", tag_id);
// Write the enum ID:
write_vuint(self.writer, tag_id);
// Write a placeholder four-byte size.
self.size_positions.push(self.writer.tell());
let zeroes: &[u8] = &[0u8, 0u8, 0u8, 0u8];
self.writer.write(zeroes);
}
fn end_tag(&self) {
let last_size_pos = self.size_positions.pop();
let cur_pos = self.writer.tell();
self.writer.seek(last_size_pos as int, io::SeekSet);
let size = (cur_pos - last_size_pos - 4u);
write_sized_vuint(self.writer, size, 4u);
self.writer.seek(cur_pos as int, io::SeekSet);
debug!("End tag (size = %u)", size);
}
fn wr_tag(&self, tag_id: uint, blk: &fn()) {
self.start_tag(tag_id);
blk();
self.end_tag();
}
fn wr_tagged_bytes(&self, tag_id: uint, b: &[u8]) {
write_vuint(self.writer, tag_id);
write_vuint(self.writer, vec::len(b));
self.writer.write(b);
}
fn wr_tagged_u64(&self, tag_id: uint, v: u64) {
do io::u64_to_be_bytes(v, 8u) |v| {
self.wr_tagged_bytes(tag_id, v);
}
}
fn wr_tagged_u32(&self, tag_id: uint, v: u32) {
do io::u64_to_be_bytes(v as u64, 4u) |v| {
self.wr_tagged_bytes(tag_id, v);
}
}
fn wr_tagged_u16(&self, tag_id: uint, v: u16) {
do io::u64_to_be_bytes(v as u64, 2u) |v| {
self.wr_tagged_bytes(tag_id, v);
}
}
fn wr_tagged_u8(&self, tag_id: uint, v: u8) {
self.wr_tagged_bytes(tag_id, &[v]);
}
fn wr_tagged_i64(&self, tag_id: uint, v: i64) {
do io::u64_to_be_bytes(v as u64, 8u) |v| {
self.wr_tagged_bytes(tag_id, v);
}
}
fn wr_tagged_i32(&self, tag_id: uint, v: i32) {
do io::u64_to_be_bytes(v as u64, 4u) |v| {
self.wr_tagged_bytes(tag_id, v);
}
}
fn wr_tagged_i16(&self, tag_id: uint, v: i16) {
do io::u64_to_be_bytes(v as u64, 2u) |v| {
self.wr_tagged_bytes(tag_id, v);
}
}
fn wr_tagged_i8(&self, tag_id: uint, v: i8) {
self.wr_tagged_bytes(tag_id, &[v as u8]);
}
fn wr_tagged_str(&self, tag_id: uint, v: &str) {
str::byte_slice(v, |b| self.wr_tagged_bytes(tag_id, b));
}
fn wr_bytes(&self, b: &[u8]) {
debug!("Write %u bytes", vec::len(b));
self.writer.write(b);
}
fn wr_str(&self, s: &str) {
debug!("Write str: %?", s);
self.writer.write(str::to_bytes(s));
}
}
// FIXME (#2741): Provide a function to write the standard ebml header.
#[cfg(not(stage0))]
pub impl Encoder {
fn start_tag(&mut self, tag_id: uint) {
debug!("Start tag %u", tag_id);
@ -1091,26 +732,6 @@ pub mod writer {
// Totally lame approach.
static debug: bool = true;
#[cfg(stage0)]
priv impl Encoder {
// used internally to emit things like the vector length and so on
fn _emit_tagged_uint(&self, t: EbmlEncoderTag, v: uint) {
assert!(v <= 0xFFFF_FFFF_u);
self.wr_tagged_u32(t as uint, v as u32);
}
fn _emit_label(&self, label: &str) {
// There are various strings that we have access to, such as
// the name of a record field, which do not actually appear in
// the encoded EBML (normally). This is just for
// efficiency. When debugging, though, we can emit such
// labels and then they will be checked by decoder to
// try and check failures more quickly.
if debug { self.wr_tagged_str(EsLabel as uint, label) }
}
}
#[cfg(not(stage0))]
priv impl Encoder {
// used internally to emit things like the vector length and so on
fn _emit_tagged_uint(&mut self, t: EbmlEncoderTag, v: uint) {
@ -1129,16 +750,6 @@ pub mod writer {
}
}
#[cfg(stage0)]
pub impl Encoder {
fn emit_opaque(&self, f: &fn()) {
do self.wr_tag(EsOpaque as uint) {
f()
}
}
}
#[cfg(not(stage0))]
pub impl Encoder {
fn emit_opaque(&mut self, f: &fn(&mut Encoder)) {
self.start_tag(EsOpaque as uint);
@ -1147,156 +758,6 @@ pub mod writer {
}
}
#[cfg(stage0)]
impl ::serialize::Encoder for Encoder {
fn emit_nil(&self) {}
fn emit_uint(&self, v: uint) {
self.wr_tagged_u64(EsUint as uint, v as u64);
}
fn emit_u64(&self, v: u64) {
self.wr_tagged_u64(EsU64 as uint, v);
}
fn emit_u32(&self, v: u32) {
self.wr_tagged_u32(EsU32 as uint, v);
}
fn emit_u16(&self, v: u16) {
self.wr_tagged_u16(EsU16 as uint, v);
}
fn emit_u8(&self, v: u8) {
self.wr_tagged_u8(EsU8 as uint, v);
}
fn emit_int(&self, v: int) {
self.wr_tagged_i64(EsInt as uint, v as i64);
}
fn emit_i64(&self, v: i64) {
self.wr_tagged_i64(EsI64 as uint, v);
}
fn emit_i32(&self, v: i32) {
self.wr_tagged_i32(EsI32 as uint, v);
}
fn emit_i16(&self, v: i16) {
self.wr_tagged_i16(EsI16 as uint, v);
}
fn emit_i8(&self, v: i8) {
self.wr_tagged_i8(EsI8 as uint, v);
}
fn emit_bool(&self, v: bool) {
self.wr_tagged_u8(EsBool as uint, v as u8)
}
// FIXME (#2742): implement these
fn emit_f64(&self, _v: f64) {
fail!(~"Unimplemented: serializing an f64");
}
fn emit_f32(&self, _v: f32) {
fail!(~"Unimplemented: serializing an f32");
}
fn emit_float(&self, _v: float) {
fail!(~"Unimplemented: serializing a float");
}
fn emit_char(&self, _v: char) {
fail!(~"Unimplemented: serializing a char");
}
fn emit_str(&self, v: &str) {
self.wr_tagged_str(EsStr as uint, v)
}
fn emit_enum(&self, name: &str, f: &fn()) {
self._emit_label(name);
self.wr_tag(EsEnum as uint, f)
}
fn emit_enum_variant(&self,
_: &str,
v_id: uint,
_: uint,
f: &fn()) {
self._emit_tagged_uint(EsEnumVid, v_id);
self.wr_tag(EsEnumBody as uint, f)
}
fn emit_enum_variant_arg(&self, _: uint, f: &fn()) {
f()
}
fn emit_enum_struct_variant(&self,
v_name: &str,
v_id: uint,
cnt: uint,
f: &fn()) {
self.emit_enum_variant(v_name, v_id, cnt, f)
}
fn emit_enum_struct_variant_field(&self,
_: &str,
idx: uint,
f: &fn()) {
self.emit_enum_variant_arg(idx, f)
}
fn emit_struct(&self, _: &str, _len: uint, f: &fn()) {
f()
}
fn emit_field(&self, name: &str, _idx: uint, f: &fn()) {
self._emit_label(name);
f()
}
fn emit_tuple(&self, len: uint, f: &fn()) {
self.emit_seq(len, f)
}
fn emit_tuple_arg(&self, idx: uint, f: &fn()) {
self.emit_seq_elt(idx, f)
}
fn emit_tuple_struct(&self, _name: &str, len: uint, f: &fn()) {
self.emit_seq(len, f)
}
fn emit_tuple_struct_arg(&self, idx: uint, f: &fn()) {
self.emit_seq_elt(idx, f)
}
fn emit_option(&self, f: &fn()) {
self.emit_enum("Option", f);
}
fn emit_option_none(&self) {
self.emit_enum_variant("None", 0, 0, || ())
}
fn emit_option_some(&self, f: &fn()) {
self.emit_enum_variant("Some", 1, 1, f)
}
fn emit_seq(&self, len: uint, f: &fn()) {
do self.wr_tag(EsVec as uint) {
self._emit_tagged_uint(EsVecLen, len);
f()
}
}
fn emit_seq_elt(&self, _idx: uint, f: &fn()) {
self.wr_tag(EsVecElt as uint, f)
}
fn emit_map(&self, _len: uint, _f: &fn()) {
fail!(~"emit_map is unimplemented");
}
fn emit_map_elt_key(&self, _idx: uint, _f: &fn()) {
fail!(~"emit_map_elt_key is unimplemented");
}
fn emit_map_elt_val(&self, _idx: uint, _f: &fn()) {
fail!(~"emit_map_elt_val is unimplemented");
}
}
#[cfg(not(stage0))]
impl ::serialize::Encoder for Encoder {
fn emit_nil(&mut self) {}

25
src/libstd/flatpipes.rs
View File

@ -438,19 +438,6 @@ pub mod flatteners {
SerializingFlattener
*/
#[cfg(stage0)]
pub fn deserialize_buffer<D: Decoder + FromReader,
T: Decodable<D>>(
buf: &[u8])
-> T {
let buf = vec::from_slice(buf);
let buf_reader = @BufReader::new(buf);
let reader = buf_reader as @Reader;
let deser: D = FromReader::from_reader(reader);
Decodable::decode(&deser)
}
#[cfg(not(stage0))]
pub fn deserialize_buffer<D: Decoder + FromReader,
T: Decodable<D>>(
buf: &[u8])
@ -462,18 +449,6 @@ pub mod flatteners {
Decodable::decode(&mut deser)
}
#[cfg(stage0)]
pub fn serialize_value<D: Encoder + FromWriter,
T: Encodable<D>>(
val: &T)
-> ~[u8] {
do io::with_bytes_writer |writer| {
let ser = FromWriter::from_writer(writer);
val.encode(&ser);
}
}
#[cfg(not(stage0))]
pub fn serialize_value<D: Encoder + FromWriter,
T: Encodable<D>>(
val: &T)

29
src/libstd/future.rs
View File

@ -54,35 +54,6 @@ pub impl<A:Copy> Future<A> {
}
pub impl<A> Future<A> {
#[cfg(stage0)]
fn get_ref(&self) -> &'self A {
/*!
* Executes the future's closure and then returns a borrowed
* pointer to the result. The borrowed pointer lasts as long as
* the future.
*/
unsafe {
match self.state {
Forced(ref mut v) => { return cast::transmute(v); }
Evaluating => fail!(~"Recursive forcing of future!"),
Pending(_) => {}
}
let mut state = Evaluating;
self.state <-> state;
match state {
Forced(_) | Evaluating => fail!(~"Logic error."),
Pending(f) => {
self.state = Forced(f());
self.get_ref()
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn get_ref<'a>(&'a self) -> &'a A {
/*!
* Executes the future's closure and then returns a borrowed

631
src/libstd/json.rs
View File

@ -77,150 +77,6 @@ pub fn Encoder(wr: @io::Writer) -> Encoder {
}
}
#[cfg(stage0)]
impl serialize::Encoder for Encoder {
fn emit_nil(&self) { self.wr.write_str("null") }
fn emit_uint(&self, v: uint) { self.emit_float(v as float); }
fn emit_u64(&self, v: u64) { self.emit_float(v as float); }
fn emit_u32(&self, v: u32) { self.emit_float(v as float); }
fn emit_u16(&self, v: u16) { self.emit_float(v as float); }
fn emit_u8(&self, v: u8) { self.emit_float(v as float); }
fn emit_int(&self, v: int) { self.emit_float(v as float); }
fn emit_i64(&self, v: i64) { self.emit_float(v as float); }
fn emit_i32(&self, v: i32) { self.emit_float(v as float); }
fn emit_i16(&self, v: i16) { self.emit_float(v as float); }
fn emit_i8(&self, v: i8) { self.emit_float(v as float); }
fn emit_bool(&self, v: bool) {
if v {
self.wr.write_str("true");
} else {
self.wr.write_str("false");
}
}
fn emit_f64(&self, v: f64) { self.emit_float(v as float); }
fn emit_f32(&self, v: f32) { self.emit_float(v as float); }
fn emit_float(&self, v: float) {
self.wr.write_str(float::to_str_digits(v, 6u));
}
fn emit_char(&self, v: char) { self.emit_str(str::from_char(v)) }
fn emit_str(&self, v: &str) { self.wr.write_str(escape_str(v)) }
fn emit_enum(&self, _name: &str, f: &fn()) { f() }
fn emit_enum_variant(&self,
name: &str,
_id: uint,
cnt: uint,
f: &fn()) {
// enums are encoded as strings or vectors:
// Bunny => "Bunny"
// Kangaroo(34,"William") => ["Kangaroo",[34,"William"]]
if cnt == 0 {
self.wr.write_str(escape_str(name));
} else {
self.wr.write_char('[');
self.wr.write_str(escape_str(name));
self.wr.write_char(',');
f();
self.wr.write_char(']');
}
}
fn emit_enum_variant_arg(&self, idx: uint, f: &fn()) {
if idx != 0 {self.wr.write_char(',');}
f();
}
fn emit_enum_struct_variant(&self,
name: &str,
id: uint,
cnt: uint,
f: &fn()) {
self.emit_enum_variant(name, id, cnt, f)
}
fn emit_enum_struct_variant_field(&self,
_: &str,
idx: uint,
f: &fn()) {
self.emit_enum_variant_arg(idx, f)
}
fn emit_struct(&self, _: &str, _: uint, f: &fn()) {
self.wr.write_char('{');
f();
self.wr.write_char('}');
}
#[cfg(stage0)]
fn emit_field(&self, name: &str, idx: uint, f: &fn()) {
if idx != 0 { self.wr.write_char(','); }
self.wr.write_str(escape_str(name));
self.wr.write_char(':');
f();
}
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn emit_struct_field(&self, name: &str, idx: uint, f: &fn()) {
if idx != 0 { self.wr.write_char(','); }
self.wr.write_str(escape_str(name));
self.wr.write_char(':');
f();
}
fn emit_tuple(&self, len: uint, f: &fn()) { self.emit_seq(len, f) }
fn emit_tuple_arg(&self, idx: uint, f: &fn()) {
self.emit_seq_elt(idx, f)
}
fn emit_tuple_struct(&self, _name: &str, len: uint, f: &fn()) {
self.emit_seq(len, f)
}
fn emit_tuple_struct_arg(&self, idx: uint, f: &fn()) {
self.emit_seq_elt(idx, f)
}
fn emit_option(&self, f: &fn()) { f(); }
fn emit_option_none(&self) { self.emit_nil(); }
fn emit_option_some(&self, f: &fn()) { f(); }
fn emit_seq(&self, _len: uint, f: &fn()) {
self.wr.write_char('[');
f();
self.wr.write_char(']');
}
fn emit_seq_elt(&self, idx: uint, f: &fn()) {
if idx != 0 { self.wr.write_char(','); }
f()
}
fn emit_map(&self, _len: uint, f: &fn()) {
self.wr.write_char('{');
f();
self.wr.write_char('}');
}
fn emit_map_elt_key(&self, idx: uint, f: &fn()) {
if idx != 0 { self.wr.write_char(','); }
f()
}
fn emit_map_elt_val(&self, _idx: uint, f: &fn()) {
self.wr.write_char(':');
f()
}
}
#[cfg(not(stage0))]
impl serialize::Encoder for Encoder {
fn emit_nil(&mut self) { self.wr.write_str("null") }
@ -376,202 +232,6 @@ pub fn PrettyEncoder(wr: @io::Writer) -> PrettyEncoder {
}
}
#[cfg(stage0)]
impl serialize::Encoder for PrettyEncoder {
fn emit_nil(&self) { self.wr.write_str("null") }
fn emit_uint(&self, v: uint) { self.emit_float(v as float); }
fn emit_u64(&self, v: u64) { self.emit_float(v as float); }
fn emit_u32(&self, v: u32) { self.emit_float(v as float); }
fn emit_u16(&self, v: u16) { self.emit_float(v as float); }
fn emit_u8(&self, v: u8) { self.emit_float(v as float); }
fn emit_int(&self, v: int) { self.emit_float(v as float); }
fn emit_i64(&self, v: i64) { self.emit_float(v as float); }
fn emit_i32(&self, v: i32) { self.emit_float(v as float); }
fn emit_i16(&self, v: i16) { self.emit_float(v as float); }
fn emit_i8(&self, v: i8) { self.emit_float(v as float); }
fn emit_bool(&self, v: bool) {
if v {
self.wr.write_str("true");
} else {
self.wr.write_str("false");
}
}
fn emit_f64(&self, v: f64) { self.emit_float(v as float); }
fn emit_f32(&self, v: f32) { self.emit_float(v as float); }
fn emit_float(&self, v: float) {
self.wr.write_str(float::to_str_digits(v, 6u));
}
fn emit_char(&self, v: char) { self.emit_str(str::from_char(v)) }
fn emit_str(&self, v: &str) { self.wr.write_str(escape_str(v)); }
fn emit_enum(&self, _name: &str, f: &fn()) { f() }
fn emit_enum_variant(&self,
name: &str,
_: uint,
cnt: uint,
f: &fn()) {
if cnt == 0 {
self.wr.write_str(escape_str(name));
} else {
self.wr.write_char('[');
self.indent += 2;
self.wr.write_char('\n');
self.wr.write_str(spaces(self.indent));
self.wr.write_str(escape_str(name));
self.wr.write_str(",\n");
f();
self.wr.write_char('\n');
self.indent -= 2;
self.wr.write_str(spaces(self.indent));
self.wr.write_char(']');
}
}
fn emit_enum_variant_arg(&self, idx: uint, f: &fn()) {
if idx != 0 {
self.wr.write_str(",\n");
}
self.wr.write_str(spaces(self.indent));
f()
}
fn emit_enum_struct_variant(&self,
name: &str,
id: uint,
cnt: uint,
f: &fn()) {
self.emit_enum_variant(name, id, cnt, f)
}
fn emit_enum_struct_variant_field(&self,
_: &str,
idx: uint,
f: &fn()) {
self.emit_enum_variant_arg(idx, f)
}
fn emit_struct(&self, _name: &str, len: uint, f: &fn()) {
if len == 0 {
self.wr.write_str("{}");
} else {
self.wr.write_char('{');
self.indent += 2;
f();
self.wr.write_char('\n');
self.indent -= 2;
self.wr.write_str(spaces(self.indent));
self.wr.write_char('}');
}
}
#[cfg(stage0)]
fn emit_field(&self, name: &str, idx: uint, f: &fn()) {
if idx == 0 {
self.wr.write_char('\n');
} else {
self.wr.write_str(",\n");
}
self.wr.write_str(spaces(self.indent));
self.wr.write_str(escape_str(name));
self.wr.write_str(": ");
f();
}
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn emit_struct_field(&self, name: &str, idx: uint, f: &fn()) {
if idx == 0 {
self.wr.write_char('\n');
} else {
self.wr.write_str(",\n");
}
self.wr.write_str(spaces(self.indent));
self.wr.write_str(escape_str(name));
self.wr.write_str(": ");
f();
}
fn emit_tuple(&self, len: uint, f: &fn()) {
self.emit_seq(len, f)
}
fn emit_tuple_arg(&self, idx: uint, f: &fn()) {
self.emit_seq_elt(idx, f)
}
fn emit_tuple_struct(&self, _name: &str, len: uint, f: &fn()) {
self.emit_seq(len, f)
}
fn emit_tuple_struct_arg(&self, idx: uint, f: &fn()) {
self.emit_seq_elt(idx, f)
}
fn emit_option(&self, f: &fn()) { f(); }
fn emit_option_none(&self) { self.emit_nil(); }
fn emit_option_some(&self, f: &fn()) { f(); }
fn emit_seq(&self, len: uint, f: &fn()) {
if len == 0 {
self.wr.write_str("[]");
} else {
self.wr.write_char('[');
self.indent += 2;
f();
self.wr.write_char('\n');
self.indent -= 2;
self.wr.write_str(spaces(self.indent));
self.wr.write_char(']');
}
}
fn emit_seq_elt(&self, idx: uint, f: &fn()) {
if idx == 0 {
self.wr.write_char('\n');
} else {
self.wr.write_str(",\n");
}
self.wr.write_str(spaces(self.indent));
f()
}
fn emit_map(&self, len: uint, f: &fn()) {
if len == 0 {
self.wr.write_str("{}");
} else {
self.wr.write_char('{');
self.indent += 2;
f();
self.wr.write_char('\n');
self.indent -= 2;
self.wr.write_str(spaces(self.indent));
self.wr.write_char('}');
}
}
fn emit_map_elt_key(&self, idx: uint, f: &fn()) {
if idx == 0 {
self.wr.write_char('\n');
} else {
self.wr.write_str(",\n");
}
self.wr.write_str(spaces(self.indent));
f();
}
fn emit_map_elt_val(&self, _idx: uint, f: &fn()) {
self.wr.write_str(": ");
f();
}
}
#[cfg(not(stage0))]
impl serialize::Encoder for PrettyEncoder {
fn emit_nil(&mut self) { self.wr.write_str("null") }
@ -765,21 +425,6 @@ impl serialize::Encoder for PrettyEncoder {
}
}
#[cfg(stage0)]
impl<E: serialize::Encoder> serialize::Encodable<E> for Json {
fn encode(&self, e: &E) {
match *self {
Number(v) => v.encode(e),
String(ref v) => v.encode(e),
Boolean(v) => v.encode(e),
List(ref v) => v.encode(e),
Object(ref v) => v.encode(e),
Null => e.emit_nil(),
}
}
}
#[cfg(not(stage0))]
impl<E: serialize::Encoder> serialize::Encodable<E> for Json {
fn encode(&self, e: &mut E) {
match *self {
@ -794,14 +439,6 @@ impl<E: serialize::Encoder> serialize::Encodable<E> for Json {
}
/// Encodes a json value into a io::writer
#[cfg(stage0)]
pub fn to_writer(wr: @io::Writer, json: &Json) {
let encoder = Encoder(wr);
json.encode(&encoder)
}
/// Encodes a json value into a io::writer
#[cfg(not(stage0))]
pub fn to_writer(wr: @io::Writer, json: &Json) {
let mut encoder = Encoder(wr);
json.encode(&mut encoder)
@ -813,14 +450,6 @@ pub fn to_str(json: &Json) -> ~str {
}
/// Encodes a json value into a io::writer
#[cfg(stage0)]
pub fn to_pretty_writer(wr: @io::Writer, json: &Json) {
let encoder = PrettyEncoder(wr);
json.encode(&encoder)
}
/// Encodes a json value into a io::writer
#[cfg(not(stage0))]
pub fn to_pretty_writer(wr: @io::Writer, json: &Json) {
let mut encoder = PrettyEncoder(wr);
json.encode(&mut encoder)
@ -1219,243 +848,6 @@ pub fn Decoder(json: Json) -> Decoder {
}
}
#[cfg(stage0)]
impl serialize::Decoder for Decoder {
fn read_nil(&self) -> () {
debug!("read_nil");
match self.stack.pop() {
Null => (),
value => fail!(fmt!("not a null: %?", value))
}
}
fn read_u64(&self) -> u64 { self.read_float() as u64 }
fn read_u32(&self) -> u32 { self.read_float() as u32 }
fn read_u16(&self) -> u16 { self.read_float() as u16 }
fn read_u8 (&self) -> u8 { self.read_float() as u8 }
fn read_uint(&self) -> uint { self.read_float() as uint }
fn read_i64(&self) -> i64 { self.read_float() as i64 }
fn read_i32(&self) -> i32 { self.read_float() as i32 }
fn read_i16(&self) -> i16 { self.read_float() as i16 }
fn read_i8 (&self) -> i8 { self.read_float() as i8 }
fn read_int(&self) -> int { self.read_float() as int }
fn read_bool(&self) -> bool {
debug!("read_bool");
match self.stack.pop() {
Boolean(b) => b,
value => fail!(fmt!("not a boolean: %?", value))
}
}
fn read_f64(&self) -> f64 { self.read_float() as f64 }
fn read_f32(&self) -> f32 { self.read_float() as f32 }
fn read_float(&self) -> float {
debug!("read_float");
match self.stack.pop() {
Number(f) => f,
value => fail!(fmt!("not a number: %?", value))
}
}
fn read_char(&self) -> char {
let mut v = ~[];
for str::each_char(self.read_str()) |c| { v.push(c) }
if v.len() != 1 { fail!(~"string must have one character") }
v[0]
}
fn read_str(&self) -> ~str {
debug!("read_str");
match self.stack.pop() {
String(s) => s,
json => fail!(fmt!("not a string: %?", json))
}
}
fn read_enum<T>(&self, name: &str, f: &fn() -> T) -> T {
debug!("read_enum(%s)", name);
f()
}
fn read_enum_variant<T>(&self,
names: &[&str],
f: &fn(uint) -> T)
-> T {
debug!("read_enum_variant(names=%?)", names);
let name = match self.stack.pop() {
String(s) => s,
List(list) => {
do vec::consume_reverse(list) |_i, v| {
self.stack.push(v);
}
match self.stack.pop() {
String(s) => s,
value => fail!(fmt!("invalid variant name: %?", value)),
}
}
ref json => fail!(fmt!("invalid variant: %?", *json)),
};
let idx = match vec::position(names, |n| str::eq_slice(*n, name)) {
Some(idx) => idx,
None => fail!(fmt!("Unknown variant name: %?", name)),
};
f(idx)
}
fn read_enum_variant_arg<T>(&self, idx: uint, f: &fn() -> T) -> T {
debug!("read_enum_variant_arg(idx=%u)", idx);
f()
}
fn read_enum_struct_variant<T>(&self,
names: &[&str],
f: &fn(uint) -> T)
-> T {
debug!("read_enum_struct_variant(names=%?)", names);
self.read_enum_variant(names, f)
}
fn read_enum_struct_variant_field<T>(&self,
name: &str,
idx: uint,
f: &fn() -> T)
-> T {
debug!("read_enum_struct_variant_field(name=%?, idx=%u)", name, idx);
self.read_enum_variant_arg(idx, f)
}
fn read_struct<T>(&self, name: &str, len: uint, f: &fn() -> T) -> T {
debug!("read_struct(name=%s, len=%u)", name, len);
let value = f();
self.stack.pop();
value
}
#[cfg(stage0)]
fn read_field<T>(&self, name: &str, idx: uint, f: &fn() -> T) -> T {
debug!("read_field(name=%?, idx=%u)", name, idx);
match self.stack.pop() {
Object(obj) => {
let mut obj = obj;
let value = match obj.pop(&name.to_owned()) {
None => fail!(fmt!("no such field: %s", name)),
Some(json) => {
self.stack.push(json);
f()
}
};
self.stack.push(Object(obj));
value
}
value => fail!(fmt!("not an object: %?", value))
}
}
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn read_struct_field<T>(&self,
name: &str,
idx: uint,
f: &fn() -> T)
-> T {
debug!("read_struct_field(name=%?, idx=%u)", name, idx);
match self.stack.pop() {
Object(obj) => {
let mut obj = obj;
let value = match obj.pop(&name.to_owned()) {
None => fail!(fmt!("no such field: %s", name)),
Some(json) => {
self.stack.push(json);
f()
}
};
self.stack.push(Object(obj));
value
}
value => fail!(fmt!("not an object: %?", value))
}
}
fn read_tuple<T>(&self, f: &fn(uint) -> T) -> T {
debug!("read_tuple()");
self.read_seq(f)
}
fn read_tuple_arg<T>(&self, idx: uint, f: &fn() -> T) -> T {
debug!("read_tuple_arg(idx=%u)", idx);
self.read_seq_elt(idx, f)
}
fn read_tuple_struct<T>(&self, name: &str, f: &fn(uint) -> T) -> T {
debug!("read_tuple_struct(name=%?)", name);
self.read_tuple(f)
}
fn read_tuple_struct_arg<T>(&self, idx: uint, f: &fn() -> T) -> T {
debug!("read_tuple_struct_arg(idx=%u)", idx);
self.read_tuple_arg(idx, f)
}
fn read_option<T>(&self, f: &fn(bool) -> T) -> T {
match self.stack.pop() {
Null => f(false),
value => { self.stack.push(value); f(true) }
}
}
fn read_seq<T>(&self, f: &fn(uint) -> T) -> T {
debug!("read_seq()");
let len = match self.stack.pop() {
List(list) => {
let len = list.len();
do vec::consume_reverse(list) |_i, v| {
self.stack.push(v);
}
len
}
_ => fail!(~"not a list"),
};
f(len)
}
fn read_seq_elt<T>(&self, idx: uint, f: &fn() -> T) -> T {
debug!("read_seq_elt(idx=%u)", idx);
f()
}
fn read_map<T>(&self, f: &fn(uint) -> T) -> T {
debug!("read_map()");
let len = match self.stack.pop() {
Object(obj) => {
let mut obj = obj;
let len = obj.len();
do obj.consume |key, value| {
self.stack.push(value);
self.stack.push(String(key));
}
len
}
json => fail!(fmt!("not an object: %?", json)),
};
f(len)
}
fn read_map_elt_key<T>(&self, idx: uint, f: &fn() -> T) -> T {
debug!("read_map_elt_key(idx=%u)", idx);
f()
}
fn read_map_elt_val<T>(&self, idx: uint, f: &fn() -> T) -> T {
debug!("read_map_elt_val(idx=%u)", idx);
f()
}
}
#[cfg(not(stage0))]
impl serialize::Decoder for Decoder {
fn read_nil(&mut self) -> () {
debug!("read_nil");
@ -1577,29 +969,6 @@ impl serialize::Decoder for Decoder {
value
}
#[cfg(stage0)]
fn read_field<T>(&mut self, name: &str, idx: uint, f: &fn() -> T) -> T {
debug!("read_field(name=%?, idx=%u)", name, idx);
match self.stack.pop() {
Object(obj) => {
let mut obj = obj;
let value = match obj.pop(&name.to_owned()) {
None => fail!(fmt!("no such field: %s", name)),
Some(json) => {
self.stack.push(json);
f()
}
};
self.stack.push(Object(obj));
value
}
value => fail!(fmt!("not an object: %?", value))
}
}
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn read_struct_field<T>(&mut self,
name: &str,
idx: uint,

16
src/libstd/priority_queue.rs
View File

@ -45,25 +45,9 @@ impl<T:Ord> Mutable for PriorityQueue<T> {
pub impl <T:Ord> PriorityQueue<T> {
/// Returns the greatest item in the queue - fails if empty
#[cfg(stage0)]
fn top(&self) -> &'self T { &self.data[0] }
/// Returns the greatest item in the queue - fails if empty
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn top<'a>(&'a self) -> &'a T { &self.data[0] }
/// Returns the greatest item in the queue - None if empty
#[cfg(stage0)]
fn maybe_top(&self) -> Option<&'self T> {
if self.is_empty() { None } else { Some(self.top()) }
}
/// Returns the greatest item in the queue - None if empty
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn maybe_top<'a>(&'a self) -> Option<&'a T> {
if self.is_empty() { None } else { Some(self.top()) }
}

978
src/libstd/serialize.rs
View File

File diff suppressed because it is too large Load Diff

77
src/libstd/smallintmap.rs
View File

@ -50,20 +50,6 @@ impl<V> Map<uint, V> for SmallIntMap<V> {
}
/// Visit all key-value pairs in order
#[cfg(stage0)]
fn each(&self, it: &fn(&uint, &'self V) -> bool) {
for uint::range(0, self.v.len()) |i| {
match self.v[i] {
Some(ref elt) => if !it(&i, elt) { break },
None => ()
}
}
}
/// Visit all key-value pairs in order
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn each<'a>(&'a self, it: &fn(&uint, &'a V) -> bool) {
for uint::range(0, self.v.len()) |i| {
match self.v[i] {
@ -79,15 +65,6 @@ impl<V> Map<uint, V> for SmallIntMap<V> {
}
/// Visit all values in order
#[cfg(stage0)]
fn each_value(&self, blk: &fn(value: &V) -> bool) {
self.each(|_, v| blk(v))
}
/// Visit all values in order
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn each_value<'a>(&'a self, blk: &fn(value: &'a V) -> bool) {
self.each(|_, v| blk(v))
}
@ -103,22 +80,6 @@ impl<V> Map<uint, V> for SmallIntMap<V> {
}
/// Return a reference to the value corresponding to the key
#[cfg(stage0)]
fn find(&self, key: &uint) -> Option<&'self V> {
if *key < self.v.len() {
match self.v[*key] {
Some(ref value) => Some(value),
None => None
}
} else {
None
}
}
/// Return a reference to the value corresponding to the key
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn find<'a>(&'a self, key: &uint) -> Option<&'a V> {
if *key < self.v.len() {
match self.v[*key] {
@ -131,22 +92,6 @@ impl<V> Map<uint, V> for SmallIntMap<V> {
}
/// Return a mutable reference to the value corresponding to the key
#[cfg(stage0)]
fn find_mut(&mut self, key: &uint) -> Option<&'self mut V> {
if *key < self.v.len() {
match self.v[*key] {
Some(ref mut value) => Some(value),
None => None
}
} else {
None
}
}
/// Return a mutable reference to the value corresponding to the key
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn find_mut<'a>(&'a mut self, key: &uint) -> Option<&'a mut V> {
if *key < self.v.len() {
match self.v[*key] {
@ -188,20 +133,6 @@ pub impl<V> SmallIntMap<V> {
fn new() -> SmallIntMap<V> { SmallIntMap{v: ~[]} }
/// Visit all key-value pairs in reverse order
#[cfg(stage0)]
fn each_reverse(&self, it: &fn(uint, &'self V) -> bool) {
for uint::range_rev(self.v.len(), 0) |i| {
match self.v[i - 1] {
Some(ref elt) => if !it(i - 1, elt) { break },
None => ()
}
}
}
/// Visit all key-value pairs in reverse order
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn each_reverse<'a>(&'a self, it: &fn(uint, &'a V) -> bool) {
for uint::range_rev(self.v.len(), 0) |i| {
match self.v[i - 1] {
@ -211,14 +142,6 @@ pub impl<V> SmallIntMap<V> {
}
}
#[cfg(stage0)]
fn get(&self, key: &uint) -> &'self V {
self.find(key).expect("key not present")
}
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn get<'a>(&'a self, key: &uint) -> &'a V {
self.find(key).expect("key not present")
}

4
src/libstd/std.rc
View File

@ -71,7 +71,6 @@ pub mod rope;
pub mod smallintmap;
pub mod sort;
pub mod dlist;
#[cfg(not(stage0))]
pub mod treemap;
// And ... other stuff
@ -91,13 +90,10 @@ pub mod cmp;
pub mod base64;
pub mod rl;
pub mod workcache;
#[cfg(not(stage0))]
#[path="num/bigint.rs"]
pub mod bigint;
#[cfg(not(stage0))]
#[path="num/rational.rs"]
pub mod rational;
#[cfg(not(stage0))]
#[path="num/complex.rs"]
pub mod complex;
pub mod stats;

45
src/libstd/workcache.rs
View File

@ -138,19 +138,6 @@ impl WorkMap {
fn new() -> WorkMap { WorkMap(HashMap::new()) }
}
#[cfg(stage0)]
impl<S:Encoder> Encodable<S> for WorkMap {
fn encode(&self, s: &S) {
let mut d = ~[];
for self.each |k, v| {
d.push((copy *k, copy *v))
}
sort::tim_sort(d);
d.encode(s)
}
}
#[cfg(not(stage0))]
impl<S:Encoder> Encodable<S> for WorkMap {
fn encode(&self, s: &mut S) {
let mut d = ~[];
@ -162,19 +149,6 @@ impl<S:Encoder> Encodable<S> for WorkMap {
}
}
#[cfg(stage0)]
impl<D:Decoder> Decodable<D> for WorkMap {
fn decode(d: &D) -> WorkMap {
let v : ~[(WorkKey,~str)] = Decodable::decode(d);
let mut w = WorkMap::new();
for v.each |&(k, v)| {
w.insert(copy k, copy v);
}
w
}
}
#[cfg(not(stage0))]
impl<D:Decoder> Decodable<D> for WorkMap {
fn decode(d: &mut D) -> WorkMap {
let v : ~[(WorkKey,~str)] = Decodable::decode(d);
@ -253,14 +227,6 @@ struct Work<T> {
res: Option<Either<T,PortOne<(Exec,T)>>>
}
#[cfg(stage0)]
fn json_encode<T:Encodable<json::Encoder>>(t: &T) -> ~str {
do io::with_str_writer |wr| {
t.encode(&json::Encoder(wr));
}
}
#[cfg(not(stage0))]
fn json_encode<T:Encodable<json::Encoder>>(t: &T) -> ~str {
do io::with_str_writer |wr| {
let mut encoder = json::Encoder(wr);
@ -269,17 +235,6 @@ fn json_encode<T:Encodable<json::Encoder>>(t: &T) -> ~str {
}
// FIXME(#5121)
#[cfg(stage0)]
fn json_decode<T:Decodable<json::Decoder>>(s: &str) -> T {
do io::with_str_reader(s) |rdr| {
let j = result::unwrap(json::from_reader(rdr));
let decoder = json::Decoder(j);
Decodable::decode(&decoder)
}
}
// FIXME(#5121)
#[cfg(not(stage0))]
fn json_decode<T:Decodable<json::Decoder>>(s: &str) -> T {
do io::with_str_reader(s) |rdr| {
let j = result::unwrap(json::from_reader(rdr));

31
src/libsyntax/ast.rs
View File

@ -70,22 +70,6 @@ pub type Name = uint;
// with a macro expansion
pub type Mrk = uint;
#[cfg(stage0)]
impl<S:Encoder> Encodable<S> for ident {
fn encode(&self, s: &S) {
unsafe {
let intr =
match task::local_data::local_data_get(interner_key!()) {
None => fail!(~"encode: TLS interner not set up"),
Some(intr) => intr
};
s.emit_str(*(*intr).get(*self));
}
}
}
#[cfg(not(stage0))]
impl<S:Encoder> Encodable<S> for ident {
fn encode(&self, s: &mut S) {
unsafe {
@ -100,21 +84,6 @@ impl<S:Encoder> Encodable<S> for ident {
}
}
#[cfg(stage0)]
impl<D:Decoder> Decodable<D> for ident {
fn decode(d: &D) -> ident {
let intr = match unsafe {
task::local_data::local_data_get(interner_key!())
} {
None => fail!(~"decode: TLS interner not set up"),
Some(intr) => intr
};
(*intr).intern(@d.read_str())
}
}
#[cfg(not(stage0))]
impl<D:Decoder> Decodable<D> for ident {
fn decode(d: &mut D) -> ident {
let intr = match unsafe {

15
src/libsyntax/codemap.rs
View File

@ -125,13 +125,6 @@ impl cmp::Eq for span {
fn ne(&self, other: &span) -> bool { !(*self).eq(other) }
}
#[cfg(stage0)]
impl<S:Encoder> Encodable<S> for span {
/* Note #1972 -- spans are encoded but not decoded */
fn encode(&self, _s: &S) { _s.emit_nil() }
}
#[cfg(not(stage0))]
impl<S:Encoder> Encodable<S> for span {
/* Note #1972 -- spans are encoded but not decoded */
fn encode(&self, s: &mut S) {
@ -139,14 +132,6 @@ impl<S:Encoder> Encodable<S> for span {
}
}
#[cfg(stage0)]
impl<D:Decoder> Decodable<D> for span {
fn decode(_d: &D) -> span {
dummy_sp()
}
}
#[cfg(not(stage0))]
impl<D:Decoder> Decodable<D> for span {
fn decode(_d: &mut D) -> span {
dummy_sp()

11
src/libsyntax/ext/base.rs
View File

@ -451,17 +451,6 @@ impl <K: Eq + Hash + IterBytes ,V: Copy> MapChain<K,V>{
// ugh: can't get this to compile with mut because of the
// lack of flow sensitivity.
#[cfg(stage0)]
fn get_map(&self) -> &'self HashMap<K,@V> {
match *self {
BaseMapChain (~ref map) => map,
ConsMapChain (~ref map,_) => map
}
}
// ugh: can't get this to compile with mut because of the
// lack of flow sensitivity.
#[cfg(not(stage0))]
fn get_map<'a>(&'a self) -> &'a HashMap<K,@V> {
match *self {
BaseMapChain (~ref map) => map,

9
src/libsyntax/opt_vec.rs
View File

@ -61,15 +61,6 @@ impl<T> OptVec<T> {
}
}
#[cfg(stage0)]
fn get(&self, i: uint) -> &'self T {
match *self {
Empty => fail!(fmt!("Invalid index %u", i)),
Vec(ref v) => &v[i]
}
}
#[cfg(not(stage0))]
fn get<'a>(&'a self, i: uint) -> &'a T {
match *self {
Empty => fail!(fmt!("Invalid index %u", i)),

8
src/snapshots.txt
View File

@ -1,3 +1,11 @@
S 2013-05-03 213f7b2
macos-i386 0bf8b88ea01cc4cdd81ac4db1d301ea9b3371f13
macos-x86_64 2da3990639ab5a9c9d51b3478c437cb459de84e3
linux-i386 094500e587bfac27d7be752b635c242e07774c0d
linux-x86_64 75733a5a58f53aa783253c8cfd56923b78676705
winnt-i386 bd07c935a917c0796d4dc803d973b864d4794ade
freebsd-x86_64 b95d648d9bfeacdd04cc5213bdc803b0fd94add7
S 2013-03-28 f7a2371
macos-i386 2e05a33716fc4982db53946c3b0dccf0194826fe
macos-x86_64 fbd3feec8dd17a6b6c8df114e6e9b4cd17cc6172