bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Remove stage0 stuff that was awaiting snapshot

Browse source 
and re-register snapshots

Just removing unneeded code, no review
This commit is contained in:
Tim Chevalier 2012-11-03 13:23:01 -07:00
parent c1fb590854
commit a006608276
11 changed files with 9 additions and 739 deletions
Download patch file Download diff file Expand all files Collapse all files

15
src/libcore/at_vec.rs
View file

@ -135,18 +135,6 @@ pub pure fn from_elem<T: Copy>(n_elts: uint, t: T) -> @[T] {
#[cfg(notest)]
pub mod traits {
#[legacy_exports];
#[cfg(stage0)]
pub impl<T: Copy> @[T] : Add<&[const T],@[T]> {
#[inline(always)]
pure fn add(rhs: & &[const T]) -> @[T] {
append(self, (*rhs))
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pub impl<T: Copy> @[T] : Add<&[const T],@[T]> {
#[inline(always)]
pure fn add(rhs: & &self/[const T]) -> @[T] {
@ -156,8 +144,7 @@ pub mod traits {
}
#[cfg(test)]
pub mod traits {
#[legacy_exports];}
pub mod traits {}
pub mod raw {
pub type VecRepr = vec::raw::VecRepr;

65
src/libcore/extfmt.rs
View file

@ -65,15 +65,6 @@ pub mod ct {
FlagSignAlways,
FlagAlternate,
}
#[cfg(stage0)]
pub enum Count {
CountIs(int),
CountIsParam(int),
CountIsNextParam,
CountImplied,
}
#[cfg(stage1)]
#[cfg(stage2)]
pub enum Count {
CountIs(uint),
CountIsParam(uint),
@ -81,15 +72,6 @@ pub mod ct {
CountImplied,
}
#[cfg(stage0)]
pub type Conv =
{param: Option<int>,
flags: ~[Flag],
width: Count,
precision: Count,
ty: Ty};
#[cfg(stage1)]
#[cfg(stage2)]
// A formatted conversion from an expression to a string
pub type Conv =
{param: Option<uint>,
@ -176,24 +158,6 @@ pub mod ct {
ty: ty.ty}),
next: ty.next};
}
#[cfg(stage0)]
pub fn parse_parameter(s: &str, i: uint, lim: uint) ->
{param: Option<int>, next: uint} {
if i >= lim { return {param: None, next: i}; }
let num = peek_num(s, i, lim);
return match num {
None => {param: None, next: i},
Some(t) => {
let n = t.num as int;
let j = t.next;
if j < lim && s[j] == '$' as u8 {
{param: Some(n), next: j + 1}
} else { {param: None, next: i} }
}
};
}
#[cfg(stage1)]
#[cfg(stage2)]
pub fn parse_parameter(s: &str, i: uint, lim: uint) ->
{param: Option<uint>, next: uint} {
if i >= lim { return {param: None, next: i}; }
@ -237,31 +201,6 @@ pub mod ct {
more(FlagAlternate, s, i, lim)
} else { {flags: move noflags, next: i} };
}
#[cfg(stage0)]
pub fn parse_count(s: &str, i: uint, lim: uint)
-> {count: Count, next: uint} {
return if i >= lim {
{count: CountImplied, next: i}
} else if s[i] == '*' as u8 {
let param = parse_parameter(s, i + 1, lim);
let j = param.next;
match param.param {
None => {count: CountIsNextParam, next: j},
Some(n) => {count: CountIsParam(n), next: j}
}
} else {
let num = peek_num(s, i, lim);
match num {
None => {count: CountImplied, next: i},
Some(num) => {
count: CountIs(num.num as int),
next: num.next
}
}
};
}
#[cfg(stage1)]
#[cfg(stage2)]
pub fn parse_count(s: &str, i: uint, lim: uint)
-> {count: Count, next: uint} {
return if i >= lim {
@ -346,10 +285,6 @@ pub mod rt {
pub const flag_sign_always : u32 = 0b00000000001000u32;
pub const flag_alternate : u32 = 0b00000000010000u32;
#[cfg(stage0)]
pub enum Count { CountIs(int), CountImplied, }
#[cfg(stage1)]
#[cfg(stage2)]
pub enum Count { CountIs(uint), CountImplied, }
pub enum Ty { TyDefault, TyBits, TyHexUpper, TyHexLower, TyOctal, }

12
src/libcore/private.rs
View file

@ -27,7 +27,6 @@ extern mod rustrt {
#[abi = "rust-intrinsic"]
extern mod rusti {
#[cfg(stage1)] #[cfg(stage2)] #[cfg(stage3)]
fn atomic_cxchg(dst: &mut int, old: int, src: int) -> int;
fn atomic_xadd(dst: &mut int, src: int) -> int;
fn atomic_xsub(dst: &mut int, src: int) -> int;
@ -38,17 +37,6 @@ type rust_port_id = uint;
type GlobalPtr = *libc::uintptr_t;
// FIXME #3527: Remove once snapshots have atomic_cxchg
#[cfg(stage0)]
fn compare_and_swap(address: &mut libc::uintptr_t,
oldval: libc::uintptr_t,
newval: libc::uintptr_t) -> bool {
rustrt::rust_compare_and_swap_ptr(address, oldval, newval)
}
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn compare_and_swap(address: &mut int, oldval: int, newval: int) -> bool {
let old = rusti::atomic_cxchg(address, oldval, newval);
old == oldval

18
src/libcore/ptr.rs
View file

@ -226,30 +226,12 @@ impl<T> *const T : Ord {
}
// Equality for region pointers
#[cfg(stage0)]
impl<T:Eq> &const T : Eq {
pure fn eq(other: & &const T) -> bool { return *self == *(*other); }
pure fn ne(other: & &const T) -> bool { return *self != *(*other); }
}
#[cfg(stage1)]
#[cfg(stage2)]
impl<T:Eq> &const T : Eq {
pure fn eq(other: & &self/const T) -> bool { return *self == *(*other); }
pure fn ne(other: & &self/const T) -> bool { return *self != *(*other); }
}
// Comparison for region pointers
#[cfg(stage0)]
impl<T:Ord> &const T : Ord {
pure fn lt(other: & &const T) -> bool { *self < *(*other) }
pure fn le(other: & &const T) -> bool { *self <= *(*other) }
pure fn ge(other: & &const T) -> bool { *self >= *(*other) }
pure fn gt(other: & &const T) -> bool { *self > *(*other) }
}
#[cfg(stage1)]
#[cfg(stage2)]
impl<T:Ord> &const T : Ord {
pure fn lt(other: & &self/const T) -> bool { *self < *(*other) }
pure fn le(other: & &self/const T) -> bool { *self <= *(*other) }

36
src/libcore/str.rs
View file

@ -735,18 +735,6 @@ pure fn gt(a: &str, b: &str) -> bool {
!le(a, b)
}
#[cfg(stage0)]
impl &str : Eq {
#[inline(always)]
pure fn eq(other: & &str) -> bool {
eq_slice(self, (*other))
}
#[inline(always)]
pure fn ne(other: & &str) -> bool { !self.eq(other) }
}
#[cfg(stage1)]
#[cfg(stage2)]
impl &str : Eq {
#[inline(always)]
pure fn eq(other: & &self/str) -> bool {
@ -785,20 +773,6 @@ impl ~str : Ord {
pure fn gt(other: &~str) -> bool { gt(self, (*other)) }
}
#[cfg(stage0)]
impl &str : Ord {
#[inline(always)]
pure fn lt(other: & &str) -> bool { lt(self, (*other)) }
#[inline(always)]
pure fn le(other: & &str) -> bool { le(self, (*other)) }
#[inline(always)]
pure fn ge(other: & &str) -> bool { ge(self, (*other)) }
#[inline(always)]
pure fn gt(other: & &str) -> bool { gt(self, (*other)) }
}
#[cfg(stage1)]
#[cfg(stage2)]
impl &str : Ord {
#[inline(always)]
pure fn lt(other: & &self/str) -> bool { lt(self, (*other)) }
@ -2122,16 +2096,6 @@ impl ~str: Trimmable {
#[cfg(notest)]
pub mod traits {
#[cfg(stage0)]
impl ~str : Add<&str,~str> {
#[inline(always)]
pure fn add(rhs: & &str) -> ~str {
append(copy self, (*rhs))
}
}
#[cfg(stage1)]
#[cfg(stage2)]
impl ~str : Add<&str,~str> {
#[inline(always)]
pure fn add(rhs: & &self/str) -> ~str {

44
src/libcore/vec.rs
View file

@ -1317,16 +1317,6 @@ pure fn eq<T: Eq>(a: &[T], b: &[T]) -> bool {
return true;
}
#[cfg(stage0)]
impl<T: Eq> &[T] : Eq {
#[inline(always)]
pure fn eq(other: & &[T]) -> bool { eq(self, (*other)) }
#[inline(always)]
pure fn ne(other: & &[T]) -> bool { !self.eq(other) }
}
#[cfg(stage1)]
#[cfg(stage2)]
impl<T: Eq> &[T] : Eq {
#[inline(always)]
pure fn eq(other: & &self/[T]) -> bool { eq(self, (*other)) }
@ -1370,20 +1360,6 @@ pure fn le<T: Ord>(a: &[T], b: &[T]) -> bool { !lt(b, a) }
pure fn ge<T: Ord>(a: &[T], b: &[T]) -> bool { !lt(a, b) }
pure fn gt<T: Ord>(a: &[T], b: &[T]) -> bool { lt(b, a) }
#[cfg(stage0)]
impl<T: Ord> &[T] : Ord {
#[inline(always)]
pure fn lt(other: & &[T]) -> bool { lt(self, (*other)) }
#[inline(always)]
pure fn le(other: & &[T]) -> bool { le(self, (*other)) }
#[inline(always)]
pure fn ge(other: & &[T]) -> bool { ge(self, (*other)) }
#[inline(always)]
pure fn gt(other: & &[T]) -> bool { gt(self, (*other)) }
}
#[cfg(stage1)]
#[cfg(stage2)]
impl<T: Ord> &[T] : Ord {
#[inline(always)]
pure fn lt(other: & &self/[T]) -> bool { lt(self, (*other)) }
@ -1419,16 +1395,6 @@ impl<T: Ord> @[T] : Ord {
#[cfg(notest)]
pub mod traits {
#[cfg(stage0)]
impl<T: Copy> ~[T] : Add<&[const T],~[T]> {
#[inline(always)]
pure fn add(rhs: & &[const T]) -> ~[T] {
append(copy self, (*rhs))
}
}
#[cfg(stage1)]
#[cfg(stage2)]
impl<T: Copy> ~[T] : Add<&[const T],~[T]> {
#[inline(always)]
pure fn add(rhs: & &self/[const T]) -> ~[T] {
@ -1436,16 +1402,6 @@ pub mod traits {
}
}
#[cfg(stage0)]
impl<T: Copy> ~[mut T] : Add<&[const T],~[mut T]> {
#[inline(always)]
pure fn add(rhs: & &[const T]) -> ~[mut T] {
append_mut(copy self, (*rhs))
}
}
#[cfg(stage1)]
#[cfg(stage2)]
impl<T: Copy> ~[mut T] : Add<&[const T],~[mut T]> {
#[inline(always)]
pure fn add(rhs: & &self/[const T]) -> ~[mut T] {

26
src/libstd/json.rs
View file

@ -273,32 +273,6 @@ pub impl PrettySerializer: serialization::Serializer {
}
}
#[cfg(stage0)]
pub impl Json: serialization::Serializable {
fn serialize<S: serialization::Serializer>(&self, s: &S) {
match *self {
Number(v) => v.serialize(s),
String(ref v) => v.serialize(s),
Boolean(v) => v.serialize(s),
List(v) => v.serialize(s),
Object(ref v) => {
do s.emit_rec || {
let mut idx = 0;
for v.each |key, value| {
do s.emit_field(*key, idx) {
value.serialize(s);
}
idx += 1;
}
}
},
Null => s.emit_nil(),
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pub impl<
S: serialization::Serializer
> Json: serialization::Serializable<S> {

475
src/libstd/serialization.rs
View file

@ -92,481 +92,6 @@ pub trait Deserializer {
fn read_tup_elt<T>(&self, idx: uint, f: fn() -> T) -> T;
}
#[cfg(stage0)]
pub mod traits {
pub trait Serializable {
fn serialize<S: Serializer>(&self, s: &S);
}
pub trait Deserializable {
static fn deserialize<D: Deserializer>(&self, d: &D) -> self;
}
pub impl uint: Serializable {
fn serialize<S: Serializer>(&self, s: &S) { s.emit_uint(*self) }
}
pub impl uint: Deserializable {
static fn deserialize<D: Deserializer>(&self, d: &D) -> uint {
d.read_uint()
}
}
pub impl u8: Serializable {
fn serialize<S: Serializer>(&self, s: &S) { s.emit_u8(*self) }
}
pub impl u8: Deserializable {
static fn deserialize<D: Deserializer>(&self, d: &D) -> u8 {
d.read_u8()
}
}
pub impl u16: Serializable {
fn serialize<S: Serializer>(&self, s: &S) { s.emit_u16(*self) }
}
pub impl u16: Deserializable {
static fn deserialize<D: Deserializer>(&self, d: &D) -> u16 {
d.read_u16()
}
}
pub impl u32: Serializable {
fn serialize<S: Serializer>(&self, s: &S) { s.emit_u32(*self) }
}
pub impl u32: Deserializable {
static fn deserialize<D: Deserializer>(&self, d: &D) -> u32 {
d.read_u32()
}
}
pub impl u64: Serializable {
fn serialize<S: Serializer>(&self, s: &S) { s.emit_u64(*self) }
}
pub impl u64: Deserializable {
static fn deserialize<D: Deserializer>(&self, d: &D) -> u64 {
d.read_u64()
}
}
pub impl int: Serializable {
fn serialize<S: Serializer>(&self, s: &S) { s.emit_int(*self) }
}
pub impl int: Deserializable {
static fn deserialize<D: Deserializer>(&self, d: &D) -> int {
d.read_int()
}
}
pub impl i8: Serializable {
fn serialize<S: Serializer>(&self, s: &S) { s.emit_i8(*self) }
}
pub impl i8: Deserializable {
static fn deserialize<D: Deserializer>(&self, d: &D) -> i8 {
d.read_i8()
}
}
pub impl i16: Serializable {
fn serialize<S: Serializer>(&self, s: &S) { s.emit_i16(*self) }
}
pub impl i16: Deserializable {
static fn deserialize<D: Deserializer>(&self, d: &D) -> i16 {
d.read_i16()
}
}
pub impl i32: Serializable {
fn serialize<S: Serializer>(&self, s: &S) { s.emit_i32(*self) }
}
pub impl i32: Deserializable {
static fn deserialize<D: Deserializer>(&self, d: &D) -> i32 {
d.read_i32()
}
}
pub impl i64: Serializable {
fn serialize<S: Serializer>(&self, s: &S) { s.emit_i64(*self) }
}
pub impl i64: Deserializable {
static fn deserialize<D: Deserializer>(&self, d: &D) -> i64 {
d.read_i64()
}
}
pub impl &str: Serializable {
fn serialize<S: Serializer>(&self, s: &S) { s.emit_borrowed_str(*self) }
}
pub impl ~str: Serializable {
fn serialize<S: Serializer>(&self, s: &S) { s.emit_owned_str(*self) }
}
pub impl ~str: Deserializable {
static fn deserialize<D: Deserializer>(&self, d: &D) -> ~str {
d.read_owned_str()
}
}
pub impl @str: Serializable {
fn serialize<S: Serializer>(&self, s: &S) { s.emit_managed_str(*self) }
}
pub impl @str: Deserializable {
static fn deserialize<D: Deserializer>(&self, d: &D) -> @str {
d.read_managed_str()
}
}
pub impl float: Serializable {
fn serialize<S: Serializer>(&self, s: &S) { s.emit_float(*self) }
}
pub impl float: Deserializable {
static fn deserialize<D: Deserializer>(&self, d: &D) -> float {
d.read_float()
}
}
pub impl f32: Serializable {
fn serialize<S: Serializer>(&self, s: &S) { s.emit_f32(*self) }
}
pub impl f32: Deserializable {
static fn deserialize<D: Deserializer>(&self, d: &D) -> f32 {
d.read_f32() }
}
pub impl f64: Serializable {
fn serialize<S: Serializer>(&self, s: &S) { s.emit_f64(*self) }
}
pub impl f64: Deserializable {
static fn deserialize<D: Deserializer>(&self, d: &D) -> f64 {
d.read_f64()
}
}
pub impl bool: Serializable {
fn serialize<S: Serializer>(&self, s: &S) { s.emit_bool(*self) }
}
pub impl bool: Deserializable {
static fn deserialize<D: Deserializer>(&self, d: &D) -> bool {
d.read_bool()
}
}
pub impl (): Serializable {
fn serialize<S: Serializer>(&self, s: &S) { s.emit_nil() }
}
pub impl (): Deserializable {
static fn deserialize<D: Deserializer>(&self, d: &D) -> () {
d.read_nil()
}
}
pub impl<T: Serializable> &T: Serializable {
fn serialize<S: Serializer>(&self, s: &S) {
s.emit_borrowed(|| (**self).serialize(s))
}
}
pub impl<T: Serializable> ~T: Serializable {
fn serialize<S: Serializer>(&self, s: &S) {
s.emit_owned(|| (**self).serialize(s))
}
}
pub impl<T: Deserializable> ~T: Deserializable {
static fn deserialize<D: Deserializer>(&self, d: &D) -> ~T {
d.read_owned(|| ~deserialize(d))
}
}
pub impl<T: Serializable> @T: Serializable {
fn serialize<S: Serializer>(&self, s: &S) {
s.emit_managed(|| (**self).serialize(s))
}
}
pub impl<T: Deserializable> @T: Deserializable {
static fn deserialize<D: Deserializer>(&self, d: &D) -> @T {
d.read_managed(|| @deserialize(d))
}
}
pub impl<T: Serializable> &[T]: Serializable {
fn serialize<S: Serializer>(&self, s: &S) {
do s.emit_borrowed_vec(self.len()) {
for self.eachi |i, e| {
s.emit_vec_elt(i, || e.serialize(s))
}
}
}
}
pub impl<T: Serializable> ~[T]: Serializable {
fn serialize<S: Serializer>(&self, s: &S) {
do s.emit_owned_vec(self.len()) {
for self.eachi |i, e| {
s.emit_vec_elt(i, || e.serialize(s))
}
}
}
}
pub impl<T: Deserializable> ~[T]: Deserializable {
static fn deserialize<D: Deserializer>(&self, d: &D) -> ~[T] {
do d.read_owned_vec |len| {
do vec::from_fn(len) |i| {
d.read_vec_elt(i, || deserialize(d))
}
}
}
}
pub impl<T: Serializable> @[T]: Serializable {
fn serialize<S: Serializer>(&self, s: &S) {
do s.emit_managed_vec(self.len()) {
for self.eachi |i, e| {
s.emit_vec_elt(i, || e.serialize(s))
}
}
}
}
pub impl<T: Deserializable> @[T]: Deserializable {
static fn deserialize<D: Deserializer>(&self, d: &D) -> @[T] {
do d.read_managed_vec |len| {
do at_vec::from_fn(len) |i| {
d.read_vec_elt(i, || deserialize(d))
}
}
}
}
pub impl<T: Serializable> Option<T>: Serializable {
fn serialize<S: Serializer>(&self, s: &S) {
do s.emit_enum(~"option") {
match *self {
None => do s.emit_enum_variant(~"none", 0u, 0u) {
},
Some(ref v) => do s.emit_enum_variant(~"some", 1u, 1u) {
s.emit_enum_variant_arg(0u, || v.serialize(s))
}
}
}
}
}
pub impl<T: Deserializable> Option<T>: Deserializable {
static fn deserialize<D: Deserializer>(&self, d: &D) -> Option<T> {
do d.read_enum(~"option") {
do d.read_enum_variant |i| {
match i {
0 => None,
1 => Some(d.read_enum_variant_arg(0u, || deserialize(d))),
_ => fail(fmt!("Bad variant for option: %u", i))
}
}
}
}
}
pub impl<
T0: Serializable,
T1: Serializable
> (T0, T1): Serializable {
fn serialize<S: Serializer>(&self, s: &S) {
match *self {
(ref t0, ref t1) => {
do s.emit_tup(2) {
s.emit_tup_elt(0, || t0.serialize(s));
s.emit_tup_elt(1, || t1.serialize(s));
}
}
}
}
}
pub impl<
T0: Deserializable,
T1: Deserializable
> (T0, T1): Deserializable {
static fn deserialize<D: Deserializer>(&self, d: &D) -> (T0, T1) {
do d.read_tup(2) {
(
d.read_tup_elt(0, || deserialize(d)),
d.read_tup_elt(1, || deserialize(d))
)
}
}
}
pub impl<
T0: Serializable,
T1: Serializable,
T2: Serializable
> (T0, T1, T2): Serializable {
fn serialize<S: Serializer>(&self, s: &S) {
match *self {
(ref t0, ref t1, ref t2) => {
do s.emit_tup(3) {
s.emit_tup_elt(0, || t0.serialize(s));
s.emit_tup_elt(1, || t1.serialize(s));
s.emit_tup_elt(2, || t2.serialize(s));
}
}
}
}
}
pub impl<
T0: Deserializable,
T1: Deserializable,
T2: Deserializable
> (T0, T1, T2): Deserializable {
static fn deserialize<D: Deserializer>(&self, d: &D) -> (T0, T1, T2) {
do d.read_tup(3) {
(
d.read_tup_elt(0, || deserialize(d)),
d.read_tup_elt(1, || deserialize(d)),
d.read_tup_elt(2, || deserialize(d))
)
}
}
}
pub impl<
T0: Serializable,
T1: Serializable,
T2: Serializable,
T3: Serializable
> (T0, T1, T2, T3): Serializable {
fn serialize<S: Serializer>(&self, s: &S) {
match *self {
(ref t0, ref t1, ref t2, ref t3) => {
do s.emit_tup(4) {
s.emit_tup_elt(0, || t0.serialize(s));
s.emit_tup_elt(1, || t1.serialize(s));
s.emit_tup_elt(2, || t2.serialize(s));
s.emit_tup_elt(3, || t3.serialize(s));
}
}
}
}
}
pub impl<
T0: Deserializable,
T1: Deserializable,
T2: Deserializable,
T3: Deserializable
> (T0, T1, T2, T3): Deserializable {
static fn deserialize<D: Deserializer>(&self, d: &D) -> (T0, T1, T2, T3) {
do d.read_tup(4) {
(
d.read_tup_elt(0, || deserialize(d)),
d.read_tup_elt(1, || deserialize(d)),
d.read_tup_elt(2, || deserialize(d)),
d.read_tup_elt(3, || deserialize(d))
)
}
}
}
pub impl<
T0: Serializable,
T1: Serializable,
T2: Serializable,
T3: Serializable,
T4: Serializable
> (T0, T1, T2, T3, T4): Serializable {
fn serialize<S: Serializer>(&self, s: &S) {
match *self {
(ref t0, ref t1, ref t2, ref t3, ref t4) => {
do s.emit_tup(5) {
s.emit_tup_elt(0, || t0.serialize(s));
s.emit_tup_elt(1, || t1.serialize(s));
s.emit_tup_elt(2, || t2.serialize(s));
s.emit_tup_elt(3, || t3.serialize(s));
s.emit_tup_elt(4, || t4.serialize(s));
}
}
}
}
}
pub impl<
T0: Deserializable,
T1: Deserializable,
T2: Deserializable,
T3: Deserializable,
T4: Deserializable
> (T0, T1, T2, T3, T4): Deserializable {
static fn deserialize<D: Deserializer>(&self, d: &D)
-> (T0, T1, T2, T3, T4) {
do d.read_tup(5) {
(
d.read_tup_elt(0, || deserialize(d)),
d.read_tup_elt(1, || deserialize(d)),
d.read_tup_elt(2, || deserialize(d)),
d.read_tup_elt(3, || deserialize(d)),
d.read_tup_elt(4, || deserialize(d))
)
}
}
}
// ___________________________________________________________________________
// Helper routines
//
// In some cases, these should eventually be coded as traits.
pub trait SerializerHelpers {
fn emit_from_vec<T>(&self, v: &[T], f: fn(&T));
}
pub impl<S: Serializer> S: SerializerHelpers {
fn emit_from_vec<T>(&self, v: &[T], f: fn(&T)) {
do self.emit_owned_vec(v.len()) {
for v.eachi |i, e| {
do self.emit_vec_elt(i) {
f(e)
}
}
}
}
}
pub trait DeserializerHelpers {
fn read_to_vec<T>(&self, f: fn() -> T) -> ~[T];
}
pub impl<D: Deserializer> D: DeserializerHelpers {
fn read_to_vec<T>(&self, f: fn() -> T) -> ~[T] {
do self.read_owned_vec |len| {
do vec::from_fn(len) |i| {
self.read_vec_elt(i, || f())
}
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pub mod traits {
pub trait Serializable<S: Serializer> {
fn serialize(&self, s: &S);

32
src/libsyntax/ast.rs
View file

@ -23,36 +23,6 @@ macro_rules! interner_key (
// implemented.
struct ident { repr: uint }
#[cfg(stage0)]
impl ident: Serializable {
fn serialize<S: Serializer>(&self, s: &S) {
let intr = match unsafe {
task::local_data::local_data_get(interner_key!())
} {
None => fail ~"serialization: TLS interner not set up",
Some(intr) => intr
};
s.emit_owned_str(*(*intr).get(*self));
}
}
#[cfg(stage0)]
impl ident: Deserializable {
static fn deserialize<D: Deserializer>(d: &D) -> ident {
let intr = match unsafe {
task::local_data::local_data_get(interner_key!())
} {
None => fail ~"deserialization: TLS interner not set up",
Some(intr) => intr
};
(*intr).intern(@d.read_owned_str())
}
}
#[cfg(stage1)]
#[cfg(stage2)]
impl<S: Serializer> ident: Serializable<S> {
fn serialize(&self, s: &S) {
let intr = match unsafe {
@ -66,8 +36,6 @@ impl<S: Serializer> ident: Serializable<S> {
}
}
#[cfg(stage1)]
#[cfg(stage2)]
impl<D: Deserializer> ident: Deserializable<D> {
static fn deserialize(d: &D) -> ident {
let intr = match unsafe {

17
src/libsyntax/codemap.rs
View file

@ -182,28 +182,11 @@ impl span : cmp::Eq {
pure fn ne(other: &span) -> bool { !self.eq(other) }
}
#[cfg(stage0)]
impl span: Serializable {
/* Note #1972 -- spans are serialized but not deserialized */
fn serialize<S: Serializer>(&self, _s: &S) { }
}
#[cfg(stage0)]
impl span: Deserializable {
static fn deserialize<D: Deserializer>(_d: &D) -> span {
ast_util::dummy_sp()
}
}
#[cfg(stage1)]
#[cfg(stage2)]
impl<S: Serializer> span: Serializable<S> {
/* Note #1972 -- spans are serialized but not deserialized */
fn serialize(&self, _s: &S) { }
}
#[cfg(stage1)]
#[cfg(stage2)]
impl<D: Deserializer> span: Deserializable<D> {
static fn deserialize(_d: &D) -> span {
ast_util::dummy_sp()

8
src/snapshots.txt
View file

@ -1,3 +1,11 @@
S 2012-11-02 4876eb7
macos-i386 e391b167f0361c70440ef2b45541b0832f77fa44
macos-x86_64 480a9f39b995a4bd7213275f6048b08ec599a22e
freebsd-x86_64 4253e538863c4d668d145587a296c92595db0a3e
linux-i386 cd666d55fe54b80a28dfe940598dd54987decdad
linux-x86_64 549ab5b90f0118b8b02e00da7cc396d96066bbff
winnt-i386 5fda5900795d2c137602140e8618f37b7e42b4cd
S 2012-10-09 cd6f24f
macos-i386 7f2f2857eac33ff0792e4ea7a3ff91a09304fcab
macos-x86_64 bb3d191e2e31cb754223ab162281fd9727e63ea9