core: Remove transitional code
This commit is contained in:
Tim Chevalier
parent
a71d004393
commit
a9587b8fcd
4 changed files with 0 additions and 1052 deletions
|
|
@ -499,12 +499,6 @@ pub mod rt {
|
|||
|
||||
pub enum Ty { TyDefault, TyBits, TyHexUpper, TyHexLower, TyOctal, }
|
||||
|
||||
#[cfg(stage0)]
|
||||
pub type Conv = {flags: u32, width: Count, precision: Count, ty: Ty};
|
||||
|
||||
#[cfg(stage1)]
|
||||
#[cfg(stage2)]
|
||||
#[cfg(stage3)]
|
||||
pub struct Conv {
|
||||
flags: u32,
|
||||
width: Count,
|
||||
|
|
|
|||
|
|
@ -142,10 +142,6 @@ pub fn BufferHeader() -> BufferHeader {
|
|||
|
||||
// This is for protocols to associate extra data to thread around.
|
||||
#[doc(hidden)]
|
||||
#[cfg(stage0)]
|
||||
#[cfg(stage1)]
|
||||
type Buffer<T> = { header: BufferHeader, data: T };
|
||||
#[cfg(stage2)]
|
||||
pub struct Buffer<T> {
|
||||
header: BufferHeader,
|
||||
data: T,
|
||||
|
|
@ -207,14 +203,6 @@ impl PacketHeader {
|
|||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
#[cfg(stage0)]
|
||||
pub struct Packet<T: Owned> {
|
||||
header: PacketHeader,
|
||||
mut payload: Option<T>,
|
||||
}
|
||||
#[doc(hidden)]
|
||||
#[cfg(stage1)]
|
||||
#[cfg(stage2)]
|
||||
pub struct Packet<T> {
|
||||
header: PacketHeader,
|
||||
mut payload: Option<T>,
|
||||
|
|
@ -223,16 +211,12 @@ pub struct Packet<T> {
|
|||
#[doc(hidden)]
|
||||
pub trait HasBuffer {
|
||||
fn set_buffer(b: *libc::c_void);
|
||||
// FIXME #4421 remove after snapshot
|
||||
fn set_buffer_(b: *libc::c_void);
|
||||
}
|
||||
|
||||
impl<T: Owned> Packet<T>: HasBuffer {
|
||||
fn set_buffer(b: *libc::c_void) {
|
||||
self.header.buffer = b;
|
||||
}
|
||||
// FIXME #4421 remove after snapshot
|
||||
fn set_buffer_(b: *libc::c_void) { self.set_buffer(b) }
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
|
|
@ -243,38 +227,6 @@ pub fn mk_packet<T: Owned>() -> Packet<T> {
|
|||
}
|
||||
}
|
||||
#[doc(hidden)]
|
||||
#[cfg(stage0)]
|
||||
fn unibuffer<T: Owned>() -> ~Buffer<Packet<T>> {
|
||||
let b = ~{
|
||||
header: BufferHeader(),
|
||||
data: Packet {
|
||||
header: PacketHeader(),
|
||||
payload: None,
|
||||
}
|
||||
};
|
||||
|
||||
unsafe {
|
||||
b.data.header.buffer = reinterpret_cast(&b);
|
||||
}
|
||||
move b
|
||||
}
|
||||
#[cfg(stage1)]
|
||||
fn unibuffer<T>() -> ~Buffer<Packet<T>> {
|
||||
let b = ~{
|
||||
header: BufferHeader(),
|
||||
data: Packet {
|
||||
header: PacketHeader(),
|
||||
payload: None,
|
||||
}
|
||||
};
|
||||
|
||||
unsafe {
|
||||
b.data.header.buffer = reinterpret_cast(&b);
|
||||
}
|
||||
move b
|
||||
}
|
||||
#[doc(hidden)]
|
||||
#[cfg(stage2)]
|
||||
fn unibuffer<T>() -> ~Buffer<Packet<T>> {
|
||||
let b = ~Buffer {
|
||||
header: BufferHeader(),
|
||||
|
|
@ -291,17 +243,6 @@ fn unibuffer<T>() -> ~Buffer<Packet<T>> {
|
|||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
#[cfg(stage0)]
|
||||
pub fn packet<T: Owned>() -> *Packet<T> {
|
||||
let b = unibuffer();
|
||||
let p = ptr::addr_of(&(b.data));
|
||||
// We'll take over memory management from here.
|
||||
unsafe { forget(move b) }
|
||||
p
|
||||
}
|
||||
#[doc(hidden)]
|
||||
#[cfg(stage1)]
|
||||
#[cfg(stage2)]
|
||||
pub fn packet<T>() -> *Packet<T> {
|
||||
let b = unibuffer();
|
||||
let p = ptr::addr_of(&(b.data));
|
||||
|
|
@ -412,42 +353,11 @@ fn swap_state_rel(dst: &mut State, src: State) -> State {
|
|||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
#[cfg(stage0)]
|
||||
pub unsafe fn get_buffer<T: Owned>(p: *PacketHeader) -> ~Buffer<T> {
|
||||
transmute((*p).buf_header())
|
||||
}
|
||||
#[doc(hidden)]
|
||||
#[cfg(stage1)]
|
||||
#[cfg(stage2)]
|
||||
pub unsafe fn get_buffer<T>(p: *PacketHeader) -> ~Buffer<T> {
|
||||
transmute((*p).buf_header())
|
||||
}
|
||||
|
||||
// This could probably be done with SharedMutableState to avoid move_it!().
|
||||
#[cfg(stage0)]
|
||||
struct BufferResource<T: Owned> {
|
||||
buffer: ~Buffer<T>,
|
||||
|
||||
drop {
|
||||
unsafe {
|
||||
let b = move_it!(self.buffer);
|
||||
//let p = ptr::addr_of(*b);
|
||||
//error!("drop %?", p);
|
||||
let old_count = atomic_sub_rel(&mut b.header.ref_count, 1);
|
||||
//let old_count = atomic_xchng_rel(b.header.ref_count, 0);
|
||||
if old_count == 1 {
|
||||
// The new count is 0.
|
||||
|
||||
// go go gadget drop glue
|
||||
}
|
||||
else {
|
||||
forget(move b)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
#[cfg(stage1)]
|
||||
#[cfg(stage2)]
|
||||
struct BufferResource<T> {
|
||||
buffer: ~Buffer<T>,
|
||||
|
||||
|
|
@ -470,19 +380,6 @@ struct BufferResource<T> {
|
|||
}
|
||||
}
|
||||
|
||||
#[cfg(stage0)]
|
||||
fn BufferResource<T: Owned>(b: ~Buffer<T>) -> BufferResource<T> {
|
||||
//let p = ptr::addr_of(*b);
|
||||
//error!("take %?", p);
|
||||
atomic_add_acq(&mut b.header.ref_count, 1);
|
||||
|
||||
BufferResource {
|
||||
// tjc: ????
|
||||
buffer: move b
|
||||
}
|
||||
}
|
||||
#[cfg(stage1)]
|
||||
#[cfg(stage2)]
|
||||
fn BufferResource<T>(b: ~Buffer<T>) -> BufferResource<T> {
|
||||
//let p = ptr::addr_of(*b);
|
||||
//error!("take %?", p);
|
||||
|
|
@ -495,51 +392,6 @@ fn BufferResource<T>(b: ~Buffer<T>) -> BufferResource<T> {
|
|||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
#[cfg(stage0)]
|
||||
pub fn send<T: Owned, Tbuffer: Owned>(p: SendPacketBuffered<T, Tbuffer>,
|
||||
payload: T) -> bool {
|
||||
let header = p.header();
|
||||
let p_ = p.unwrap();
|
||||
let p = unsafe { &*p_ };
|
||||
assert ptr::addr_of(&(p.header)) == header;
|
||||
assert p.payload.is_none();
|
||||
p.payload = move Some(move payload);
|
||||
let old_state = swap_state_rel(&mut p.header.state, Full);
|
||||
match old_state {
|
||||
Empty => {
|
||||
// Yay, fastpath.
|
||||
|
||||
// The receiver will eventually clean this up.
|
||||
//unsafe { forget(p); }
|
||||
return true;
|
||||
}
|
||||
Full => fail ~"duplicate send",
|
||||
Blocked => {
|
||||
debug!("waking up task for %?", p_);
|
||||
let old_task = swap_task(&mut p.header.blocked_task, ptr::null());
|
||||
if !old_task.is_null() {
|
||||
unsafe {
|
||||
rustrt::task_signal_event(
|
||||
old_task,
|
||||
ptr::addr_of(&(p.header)) as *libc::c_void);
|
||||
rustrt::rust_task_deref(old_task);
|
||||
}
|
||||
}
|
||||
|
||||
// The receiver will eventually clean this up.
|
||||
//unsafe { forget(p); }
|
||||
return true;
|
||||
}
|
||||
Terminated => {
|
||||
// The receiver will never receive this. Rely on drop_glue
|
||||
// to clean everything up.
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
#[doc(hidden)]
|
||||
#[cfg(stage1)]
|
||||
#[cfg(stage2)]
|
||||
pub fn send<T,Tbuffer>(p: SendPacketBuffered<T,Tbuffer>, payload: T) -> bool {
|
||||
let header = p.header();
|
||||
let p_ = p.unwrap();
|
||||
|
|
@ -925,44 +777,13 @@ pub fn select<T: Owned, Tb: Owned>(endpoints: ~[RecvPacketBuffered<T, Tb>])
|
|||
message.
|
||||
|
||||
*/
|
||||
#[cfg(stage0)]
|
||||
pub type SendPacket<T: Owned> = SendPacketBuffered<T, Packet<T>>;
|
||||
#[cfg(stage1)]
|
||||
#[cfg(stage2)]
|
||||
pub type SendPacket<T> = SendPacketBuffered<T, Packet<T>>;
|
||||
|
||||
#[doc(hidden)]
|
||||
#[cfg(stage0)]
|
||||
pub fn SendPacket<T: Owned>(p: *Packet<T>) -> SendPacket<T> {
|
||||
SendPacketBuffered(p)
|
||||
}
|
||||
#[cfg(stage1)]
|
||||
#[cfg(stage2)]
|
||||
pub fn SendPacket<T>(p: *Packet<T>) -> SendPacket<T> {
|
||||
SendPacketBuffered(p)
|
||||
}
|
||||
|
||||
#[cfg(stage0)]
|
||||
pub struct SendPacketBuffered<T: Owned, Tbuffer: Owned> {
|
||||
mut p: Option<*Packet<T>>,
|
||||
mut buffer: Option<BufferResource<Tbuffer>>,
|
||||
drop {
|
||||
//if self.p != none {
|
||||
// debug!("drop send %?", option::get(self.p));
|
||||
//}
|
||||
if self.p != None {
|
||||
let mut p = None;
|
||||
p <-> self.p;
|
||||
sender_terminate(option::unwrap(move p))
|
||||
}
|
||||
//unsafe { error!("send_drop: %?",
|
||||
// if self.buffer == none {
|
||||
// "none"
|
||||
// } else { "some" }); }
|
||||
}
|
||||
}
|
||||
#[cfg(stage1)]
|
||||
#[cfg(stage2)]
|
||||
pub struct SendPacketBuffered<T, Tbuffer> {
|
||||
mut p: Option<*Packet<T>>,
|
||||
mut buffer: Option<BufferResource<Tbuffer>>,
|
||||
|
|
@ -985,20 +806,6 @@ impl<T:Owned,Tbuffer:Owned> SendPacketBuffered<T,Tbuffer> : ::ops::Drop {
|
|||
}
|
||||
}
|
||||
|
||||
#[cfg(stage0)]
|
||||
pub fn SendPacketBuffered<T: Owned, Tbuffer: Owned>(p: *Packet<T>)
|
||||
-> SendPacketBuffered<T, Tbuffer> {
|
||||
//debug!("take send %?", p);
|
||||
SendPacketBuffered {
|
||||
p: Some(p),
|
||||
buffer: unsafe {
|
||||
Some(BufferResource(
|
||||
get_buffer(ptr::addr_of(&((*p).header)))))
|
||||
}
|
||||
}
|
||||
}
|
||||
#[cfg(stage1)]
|
||||
#[cfg(stage2)]
|
||||
pub fn SendPacketBuffered<T,Tbuffer>(p: *Packet<T>)
|
||||
-> SendPacketBuffered<T, Tbuffer> {
|
||||
//debug!("take send %?", p);
|
||||
|
|
@ -1011,35 +818,6 @@ pub fn SendPacketBuffered<T,Tbuffer>(p: *Packet<T>)
|
|||
}
|
||||
}
|
||||
|
||||
#[cfg(stage0)]
|
||||
impl<T:Owned,Tbuffer:Owned> SendPacketBuffered<T,Tbuffer> {
|
||||
fn unwrap() -> *Packet<T> {
|
||||
let mut p = None;
|
||||
p <-> self.p;
|
||||
option::unwrap(move p)
|
||||
}
|
||||
|
||||
pure fn header() -> *PacketHeader {
|
||||
match self.p {
|
||||
Some(packet) => unsafe {
|
||||
let packet = &*packet;
|
||||
let header = ptr::addr_of(&(packet.header));
|
||||
//forget(packet);
|
||||
header
|
||||
},
|
||||
None => fail ~"packet already consumed"
|
||||
}
|
||||
}
|
||||
|
||||
fn reuse_buffer() -> BufferResource<Tbuffer> {
|
||||
//error!("send reuse_buffer");
|
||||
let mut tmp = None;
|
||||
tmp <-> self.buffer;
|
||||
option::unwrap(move tmp)
|
||||
}
|
||||
}
|
||||
#[cfg(stage1)]
|
||||
#[cfg(stage2)]
|
||||
impl<T,Tbuffer> SendPacketBuffered<T,Tbuffer> {
|
||||
fn unwrap() -> *Packet<T> {
|
||||
let mut p = None;
|
||||
|
|
@ -1069,45 +847,12 @@ impl<T,Tbuffer> SendPacketBuffered<T,Tbuffer> {
|
|||
|
||||
/// Represents the receive end of a pipe. It can receive exactly one
|
||||
/// message.
|
||||
#[cfg(stage0)]
|
||||
pub type RecvPacket<T: Owned> = RecvPacketBuffered<T, Packet<T>>;
|
||||
#[cfg(stage1)]
|
||||
#[cfg(stage2)]
|
||||
pub type RecvPacket<T> = RecvPacketBuffered<T, Packet<T>>;
|
||||
|
||||
#[doc(hidden)]
|
||||
#[cfg(stage0)]
|
||||
pub fn RecvPacket<T: Owned>(p: *Packet<T>) -> RecvPacket<T> {
|
||||
RecvPacketBuffered(p)
|
||||
}
|
||||
#[doc(hidden)]
|
||||
#[cfg(stage1)]
|
||||
#[cfg(stage2)]
|
||||
pub fn RecvPacket<T>(p: *Packet<T>) -> RecvPacket<T> {
|
||||
RecvPacketBuffered(p)
|
||||
}
|
||||
|
||||
#[cfg(stage0)]
|
||||
pub struct RecvPacketBuffered<T: Owned, Tbuffer: Owned> {
|
||||
mut p: Option<*Packet<T>>,
|
||||
mut buffer: Option<BufferResource<Tbuffer>>,
|
||||
drop {
|
||||
//if self.p != none {
|
||||
// debug!("drop recv %?", option::get(self.p));
|
||||
//}
|
||||
if self.p != None {
|
||||
let mut p = None;
|
||||
p <-> self.p;
|
||||
receiver_terminate(option::unwrap(move p))
|
||||
}
|
||||
//unsafe { error!("recv_drop: %?",
|
||||
// if self.buffer == none {
|
||||
// "none"
|
||||
// } else { "some" }); }
|
||||
}
|
||||
}
|
||||
#[cfg(stage1)]
|
||||
#[cfg(stage2)]
|
||||
pub struct RecvPacketBuffered<T, Tbuffer> {
|
||||
mut p: Option<*Packet<T>>,
|
||||
mut buffer: Option<BufferResource<Tbuffer>>,
|
||||
|
|
@ -1159,20 +904,6 @@ impl<T: Owned, Tbuffer: Owned> RecvPacketBuffered<T, Tbuffer> : Selectable {
|
|||
}
|
||||
}
|
||||
|
||||
#[cfg(stage0)]
|
||||
pub fn RecvPacketBuffered<T: Owned, Tbuffer: Owned>(p: *Packet<T>)
|
||||
-> RecvPacketBuffered<T, Tbuffer> {
|
||||
//debug!("take recv %?", p);
|
||||
RecvPacketBuffered {
|
||||
p: Some(p),
|
||||
buffer: unsafe {
|
||||
Some(BufferResource(
|
||||
get_buffer(ptr::addr_of(&((*p).header)))))
|
||||
}
|
||||
}
|
||||
}
|
||||
#[cfg(stage1)]
|
||||
#[cfg(stage2)]
|
||||
pub fn RecvPacketBuffered<T,Tbuffer>(p: *Packet<T>)
|
||||
-> RecvPacketBuffered<T,Tbuffer> {
|
||||
//debug!("take recv %?", p);
|
||||
|
|
@ -1186,14 +917,6 @@ pub fn RecvPacketBuffered<T,Tbuffer>(p: *Packet<T>)
|
|||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
#[cfg(stage0)]
|
||||
pub fn entangle<T: Owned>() -> (SendPacket<T>, RecvPacket<T>) {
|
||||
let p = packet();
|
||||
(SendPacket(p), RecvPacket(p))
|
||||
}
|
||||
#[doc(hidden)]
|
||||
#[cfg(stage1)]
|
||||
#[cfg(stage2)]
|
||||
pub fn entangle<T>() -> (SendPacket<T>, RecvPacket<T>) {
|
||||
let p = packet();
|
||||
(SendPacket(p), RecvPacket(p))
|
||||
|
|
@ -1289,47 +1012,21 @@ pub trait Peekable<T> {
|
|||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
#[cfg(stage0)]
|
||||
struct Chan_<T:Owned> {
|
||||
mut endp: Option<streamp::client::Open<T>>
|
||||
}
|
||||
#[doc(hidden)]
|
||||
#[cfg(stage1)]
|
||||
#[cfg(stage2)]
|
||||
struct Chan_<T> {
|
||||
mut endp: Option<streamp::client::Open<T>>
|
||||
}
|
||||
|
||||
/// An endpoint that can send many messages.
|
||||
#[cfg(stage0)]
|
||||
pub enum Chan<T:Owned> {
|
||||
Chan_(Chan_<T>)
|
||||
}
|
||||
#[cfg(stage1)]
|
||||
#[cfg(stage2)]
|
||||
pub enum Chan<T> {
|
||||
Chan_(Chan_<T>)
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
#[cfg(stage0)]
|
||||
struct Port_<T:Owned> {
|
||||
mut endp: Option<streamp::server::Open<T>>,
|
||||
}
|
||||
#[doc(hidden)]
|
||||
#[cfg(stage1)]
|
||||
#[cfg(stage2)]
|
||||
struct Port_<T> {
|
||||
mut endp: Option<streamp::server::Open<T>>,
|
||||
}
|
||||
|
||||
/// An endpoint that can receive many messages.
|
||||
#[cfg(stage0)]
|
||||
pub enum Port<T:Owned> {
|
||||
Port_(Port_<T>)
|
||||
}
|
||||
#[cfg(stage1)]
|
||||
#[cfg(stage2)]
|
||||
pub enum Port<T> {
|
||||
Port_(Port_<T>)
|
||||
}
|
||||
|
|
@ -1418,12 +1115,6 @@ impl<T: Owned> Port<T>: Selectable {
|
|||
}
|
||||
|
||||
/// Treat many ports as one.
|
||||
#[cfg(stage0)]
|
||||
pub struct PortSet<T: Owned> {
|
||||
mut ports: ~[pipes::Port<T>],
|
||||
}
|
||||
#[cfg(stage1)]
|
||||
#[cfg(stage2)]
|
||||
pub struct PortSet<T> {
|
||||
mut ports: ~[pipes::Port<T>],
|
||||
}
|
||||
|
|
@ -1489,10 +1180,6 @@ impl<T: Owned> PortSet<T> : Peekable<T> {
|
|||
}
|
||||
|
||||
/// A channel that can be shared between many senders.
|
||||
#[cfg(stage0)]
|
||||
pub type SharedChan<T: Owned> = private::Exclusive<Chan<T>>;
|
||||
#[cfg(stage1)]
|
||||
#[cfg(stage2)]
|
||||
pub type SharedChan<T> = private::Exclusive<Chan<T>>;
|
||||
|
||||
impl<T: Owned> SharedChan<T>: GenericChan<T> {
|
||||
|
|
@ -1561,16 +1248,8 @@ proto! oneshot (
|
|||
)
|
||||
|
||||
/// The send end of a oneshot pipe.
|
||||
#[cfg(stage0)]
|
||||
pub type ChanOne<T: Owned> = oneshot::client::Oneshot<T>;
|
||||
#[cfg(stage1)]
|
||||
#[cfg(stage2)]
|
||||
pub type ChanOne<T> = oneshot::client::Oneshot<T>;
|
||||
/// The receive end of a oneshot pipe.
|
||||
#[cfg(stage0)]
|
||||
pub type PortOne<T: Owned> = oneshot::server::Oneshot<T>;
|
||||
#[cfg(stage1)]
|
||||
#[cfg(stage2)]
|
||||
pub type PortOne<T> = oneshot::server::Oneshot<T>;
|
||||
|
||||
/// Initialiase a (send-endpoint, recv-endpoint) oneshot pipe pair.
|
||||
|
|
|
|||
|
|
@ -75,434 +75,6 @@ impl<V: TyVisitor MovePtr> MovePtrAdaptor<V> {
|
|||
}
|
||||
|
||||
/// Abstract type-directed pointer-movement using the MovePtr trait
|
||||
#[cfg(stage0)]
|
||||
impl<V: TyVisitor MovePtr> MovePtrAdaptor<V>: TyVisitor {
|
||||
fn visit_bot() -> bool {
|
||||
self.align_to::<()>();
|
||||
if ! self.inner.visit_bot() { return false; }
|
||||
self.bump_past::<()>();
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_nil() -> bool {
|
||||
self.align_to::<()>();
|
||||
if ! self.inner.visit_nil() { return false; }
|
||||
self.bump_past::<()>();
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_bool() -> bool {
|
||||
self.align_to::<bool>();
|
||||
if ! self.inner.visit_bool() { return false; }
|
||||
self.bump_past::<bool>();
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_int() -> bool {
|
||||
self.align_to::<int>();
|
||||
if ! self.inner.visit_int() { return false; }
|
||||
self.bump_past::<int>();
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_i8() -> bool {
|
||||
self.align_to::<i8>();
|
||||
if ! self.inner.visit_i8() { return false; }
|
||||
self.bump_past::<i8>();
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_i16() -> bool {
|
||||
self.align_to::<i16>();
|
||||
if ! self.inner.visit_i16() { return false; }
|
||||
self.bump_past::<i16>();
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_i32() -> bool {
|
||||
self.align_to::<i32>();
|
||||
if ! self.inner.visit_i32() { return false; }
|
||||
self.bump_past::<i32>();
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_i64() -> bool {
|
||||
self.align_to::<i64>();
|
||||
if ! self.inner.visit_i64() { return false; }
|
||||
self.bump_past::<i64>();
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_uint() -> bool {
|
||||
self.align_to::<uint>();
|
||||
if ! self.inner.visit_uint() { return false; }
|
||||
self.bump_past::<uint>();
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_u8() -> bool {
|
||||
self.align_to::<u8>();
|
||||
if ! self.inner.visit_u8() { return false; }
|
||||
self.bump_past::<u8>();
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_u16() -> bool {
|
||||
self.align_to::<u16>();
|
||||
if ! self.inner.visit_u16() { return false; }
|
||||
self.bump_past::<u16>();
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_u32() -> bool {
|
||||
self.align_to::<u32>();
|
||||
if ! self.inner.visit_u32() { return false; }
|
||||
self.bump_past::<u32>();
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_u64() -> bool {
|
||||
self.align_to::<u64>();
|
||||
if ! self.inner.visit_u64() { return false; }
|
||||
self.bump_past::<u64>();
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_float() -> bool {
|
||||
self.align_to::<float>();
|
||||
if ! self.inner.visit_float() { return false; }
|
||||
self.bump_past::<float>();
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_f32() -> bool {
|
||||
self.align_to::<f32>();
|
||||
if ! self.inner.visit_f32() { return false; }
|
||||
self.bump_past::<f32>();
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_f64() -> bool {
|
||||
self.align_to::<f64>();
|
||||
if ! self.inner.visit_f64() { return false; }
|
||||
self.bump_past::<f64>();
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_char() -> bool {
|
||||
self.align_to::<char>();
|
||||
if ! self.inner.visit_char() { return false; }
|
||||
self.bump_past::<char>();
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_str() -> bool {
|
||||
self.align_to::<~str>();
|
||||
if ! self.inner.visit_str() { return false; }
|
||||
self.bump_past::<~str>();
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_estr_box() -> bool {
|
||||
self.align_to::<@str>();
|
||||
if ! self.inner.visit_estr_box() { return false; }
|
||||
self.bump_past::<@str>();
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_estr_uniq() -> bool {
|
||||
self.align_to::<~str>();
|
||||
if ! self.inner.visit_estr_uniq() { return false; }
|
||||
self.bump_past::<~str>();
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_estr_slice() -> bool {
|
||||
self.align_to::<&static/str>();
|
||||
if ! self.inner.visit_estr_slice() { return false; }
|
||||
self.bump_past::<&static/str>();
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_estr_fixed(n: uint,
|
||||
sz: uint,
|
||||
align: uint) -> bool {
|
||||
self.align(align);
|
||||
if ! self.inner.visit_estr_fixed(n, sz, align) { return false; }
|
||||
self.bump(sz);
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_box(mtbl: uint, inner: *TyDesc) -> bool {
|
||||
self.align_to::<@u8>();
|
||||
if ! self.inner.visit_box(mtbl, inner) { return false; }
|
||||
self.bump_past::<@u8>();
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_uniq(mtbl: uint, inner: *TyDesc) -> bool {
|
||||
self.align_to::<~u8>();
|
||||
if ! self.inner.visit_uniq(mtbl, inner) { return false; }
|
||||
self.bump_past::<~u8>();
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_ptr(mtbl: uint, inner: *TyDesc) -> bool {
|
||||
self.align_to::<*u8>();
|
||||
if ! self.inner.visit_ptr(mtbl, inner) { return false; }
|
||||
self.bump_past::<*u8>();
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_rptr(mtbl: uint, inner: *TyDesc) -> bool {
|
||||
self.align_to::<&static/u8>();
|
||||
if ! self.inner.visit_rptr(mtbl, inner) { return false; }
|
||||
self.bump_past::<&static/u8>();
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_unboxed_vec(mtbl: uint, inner: *TyDesc) -> bool {
|
||||
self.align_to::<vec::UnboxedVecRepr>();
|
||||
if ! self.inner.visit_vec(mtbl, inner) { return false; }
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_vec(mtbl: uint, inner: *TyDesc) -> bool {
|
||||
self.align_to::<~[u8]>();
|
||||
if ! self.inner.visit_vec(mtbl, inner) { return false; }
|
||||
self.bump_past::<~[u8]>();
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_evec_box(mtbl: uint, inner: *TyDesc) -> bool {
|
||||
self.align_to::<@[u8]>();
|
||||
if ! self.inner.visit_evec_box(mtbl, inner) { return false; }
|
||||
self.bump_past::<@[u8]>();
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_evec_uniq(mtbl: uint, inner: *TyDesc) -> bool {
|
||||
self.align_to::<~[u8]>();
|
||||
if ! self.inner.visit_evec_uniq(mtbl, inner) { return false; }
|
||||
self.bump_past::<~[u8]>();
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_evec_slice(mtbl: uint, inner: *TyDesc) -> bool {
|
||||
self.align_to::<&static/[u8]>();
|
||||
if ! self.inner.visit_evec_slice(mtbl, inner) { return false; }
|
||||
self.bump_past::<&static/[u8]>();
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_evec_fixed(n: uint, sz: uint, align: uint,
|
||||
mtbl: uint, inner: *TyDesc) -> bool {
|
||||
self.align(align);
|
||||
if ! self.inner.visit_evec_fixed(n, sz, align, mtbl, inner) {
|
||||
return false;
|
||||
}
|
||||
self.bump(sz);
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_enter_rec(n_fields: uint, sz: uint, align: uint) -> bool {
|
||||
self.align(align);
|
||||
if ! self.inner.visit_enter_rec(n_fields, sz, align) { return false; }
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_rec_field(i: uint, name: &str,
|
||||
mtbl: uint, inner: *TyDesc) -> bool {
|
||||
unsafe { self.align((*inner).align); }
|
||||
if ! self.inner.visit_rec_field(i, name, mtbl, inner) {
|
||||
return false;
|
||||
}
|
||||
unsafe { self.bump((*inner).size); }
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_leave_rec(n_fields: uint, sz: uint, align: uint) -> bool {
|
||||
if ! self.inner.visit_leave_rec(n_fields, sz, align) { return false; }
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_enter_class(n_fields: uint, sz: uint, align: uint)
|
||||
-> bool {
|
||||
self.align(align);
|
||||
if ! self.inner.visit_enter_class(n_fields, sz, align) {
|
||||
return false;
|
||||
}
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_class_field(i: uint, name: &str,
|
||||
mtbl: uint, inner: *TyDesc) -> bool {
|
||||
unsafe { self.align((*inner).align); }
|
||||
if ! self.inner.visit_class_field(i, name, mtbl, inner) {
|
||||
return false;
|
||||
}
|
||||
unsafe { self.bump((*inner).size); }
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_leave_class(n_fields: uint, sz: uint, align: uint)
|
||||
-> bool {
|
||||
if ! self.inner.visit_leave_class(n_fields, sz, align) {
|
||||
return false;
|
||||
}
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_enter_tup(n_fields: uint, sz: uint, align: uint) -> bool {
|
||||
self.align(align);
|
||||
if ! self.inner.visit_enter_tup(n_fields, sz, align) { return false; }
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_tup_field(i: uint, inner: *TyDesc) -> bool {
|
||||
unsafe { self.align((*inner).align); }
|
||||
if ! self.inner.visit_tup_field(i, inner) { return false; }
|
||||
unsafe { self.bump((*inner).size); }
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_leave_tup(n_fields: uint, sz: uint, align: uint) -> bool {
|
||||
if ! self.inner.visit_leave_tup(n_fields, sz, align) { return false; }
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_enter_fn(purity: uint, proto: uint,
|
||||
n_inputs: uint, retstyle: uint) -> bool {
|
||||
if ! self.inner.visit_enter_fn(purity, proto, n_inputs, retstyle) {
|
||||
return false
|
||||
}
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_fn_input(i: uint, mode: uint, inner: *TyDesc) -> bool {
|
||||
if ! self.inner.visit_fn_input(i, mode, inner) { return false; }
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_fn_output(retstyle: uint, inner: *TyDesc) -> bool {
|
||||
if ! self.inner.visit_fn_output(retstyle, inner) { return false; }
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_leave_fn(purity: uint, proto: uint,
|
||||
n_inputs: uint, retstyle: uint) -> bool {
|
||||
if ! self.inner.visit_leave_fn(purity, proto, n_inputs, retstyle) {
|
||||
return false;
|
||||
}
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_enter_enum(n_variants: uint, sz: uint, align: uint)
|
||||
-> bool {
|
||||
self.align(align);
|
||||
if ! self.inner.visit_enter_enum(n_variants, sz, align) {
|
||||
return false;
|
||||
}
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_enter_enum_variant(variant: uint,
|
||||
disr_val: int,
|
||||
n_fields: uint,
|
||||
name: &str) -> bool {
|
||||
self.inner.push_ptr();
|
||||
if ! self.inner.visit_enter_enum_variant(variant, disr_val,
|
||||
n_fields, name) {
|
||||
return false;
|
||||
}
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_enum_variant_field(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
|
||||
}
|
||||
|
||||
fn visit_leave_enum_variant(variant: uint,
|
||||
disr_val: int,
|
||||
n_fields: uint,
|
||||
name: &str) -> bool {
|
||||
if ! self.inner.visit_leave_enum_variant(variant, disr_val,
|
||||
n_fields, name) {
|
||||
return false;
|
||||
}
|
||||
self.inner.pop_ptr();
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_leave_enum(n_variants: uint, sz: uint, align: uint)
|
||||
-> bool {
|
||||
if ! self.inner.visit_leave_enum(n_variants, sz, align) {
|
||||
return false;
|
||||
}
|
||||
self.bump(sz);
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_trait() -> bool {
|
||||
self.align_to::<TyVisitor>();
|
||||
if ! self.inner.visit_trait() { return false; }
|
||||
self.bump_past::<TyVisitor>();
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_var() -> bool {
|
||||
if ! self.inner.visit_var() { return false; }
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_var_integral() -> bool {
|
||||
if ! self.inner.visit_var_integral() { return false; }
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_param(i: uint) -> bool {
|
||||
if ! self.inner.visit_param(i) { return false; }
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_self() -> bool {
|
||||
self.align_to::<&static/u8>();
|
||||
if ! self.inner.visit_self() { return false; }
|
||||
self.align_to::<&static/u8>();
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_type() -> bool {
|
||||
if ! self.inner.visit_type() { return false; }
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_opaque_box() -> bool {
|
||||
self.align_to::<@u8>();
|
||||
if ! self.inner.visit_opaque_box() { return false; }
|
||||
self.bump_past::<@u8>();
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_constr(inner: *TyDesc) -> bool {
|
||||
if ! self.inner.visit_constr(inner) { return false; }
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_closure_ptr(ck: uint) -> bool {
|
||||
self.align_to::<fn@()>();
|
||||
if ! self.inner.visit_closure_ptr(ck) { return false; }
|
||||
self.bump_past::<fn@()>();
|
||||
true
|
||||
}
|
||||
}
|
||||
|
||||
/// Abstract type-directed pointer-movement using the MovePtr trait
|
||||
#[cfg(stage1)]
|
||||
#[cfg(stage2)]
|
||||
impl<V: TyVisitor MovePtr> MovePtrAdaptor<V>: TyVisitor {
|
||||
fn visit_bot(&self) -> bool {
|
||||
self.align_to::<()>();
|
||||
|
|
|
|||
|
|
@ -265,303 +265,6 @@ impl ReprVisitor {
|
|||
|
||||
}
|
||||
|
||||
#[cfg(stage0)]
|
||||
impl ReprVisitor : TyVisitor {
|
||||
fn visit_bot() -> bool {
|
||||
self.writer.write_str("!");
|
||||
true
|
||||
}
|
||||
fn visit_nil() -> bool { self.write::<()>() }
|
||||
fn visit_bool() -> bool { self.write::<bool>() }
|
||||
fn visit_int() -> bool { self.write::<int>() }
|
||||
fn visit_i8() -> bool { self.write::<i8>() }
|
||||
fn visit_i16() -> bool { self.write::<i16>() }
|
||||
fn visit_i32() -> bool { self.write::<i32>() }
|
||||
fn visit_i64() -> bool { self.write::<i64>() }
|
||||
|
||||
fn visit_uint() -> bool { self.write::<uint>() }
|
||||
fn visit_u8() -> bool { self.write::<u8>() }
|
||||
fn visit_u16() -> bool { self.write::<u16>() }
|
||||
fn visit_u32() -> bool { self.write::<u32>() }
|
||||
fn visit_u64() -> bool { self.write::<u64>() }
|
||||
|
||||
fn visit_float() -> bool { self.write::<float>() }
|
||||
fn visit_f32() -> bool { self.write::<f32>() }
|
||||
fn visit_f64() -> bool { self.write::<f64>() }
|
||||
|
||||
fn visit_char() -> bool {
|
||||
do self.get::<char> |&ch| {
|
||||
self.writer.write_char('\'');
|
||||
self.writer.write_escaped_char(ch);
|
||||
self.writer.write_char('\'');
|
||||
}
|
||||
}
|
||||
|
||||
// Type no longer exists, vestigial function.
|
||||
fn visit_str() -> bool { fail; }
|
||||
|
||||
fn visit_estr_box() -> bool {
|
||||
do self.get::<@str> |s| {
|
||||
self.writer.write_char('@');
|
||||
self.write_escaped_slice(*s);
|
||||
}
|
||||
}
|
||||
fn visit_estr_uniq() -> bool {
|
||||
do self.get::<~str> |s| {
|
||||
self.writer.write_char('~');
|
||||
self.write_escaped_slice(*s);
|
||||
}
|
||||
}
|
||||
fn visit_estr_slice() -> bool {
|
||||
do self.get::<&str> |s| {
|
||||
self.write_escaped_slice(*s);
|
||||
}
|
||||
}
|
||||
|
||||
// Type no longer exists, vestigial function.
|
||||
fn visit_estr_fixed(_n: uint, _sz: uint,
|
||||
_align: uint) -> bool { fail; }
|
||||
|
||||
fn visit_box(mtbl: uint, inner: *TyDesc) -> bool {
|
||||
self.writer.write_char('@');
|
||||
self.write_mut_qualifier(mtbl);
|
||||
do self.get::<&managed::raw::BoxRepr> |b| {
|
||||
let p = ptr::to_unsafe_ptr(&b.data) as *c_void;
|
||||
self.visit_ptr_inner(p, inner);
|
||||
}
|
||||
}
|
||||
|
||||
fn visit_uniq(mtbl: uint, inner: *TyDesc) -> bool {
|
||||
self.writer.write_char('~');
|
||||
self.write_mut_qualifier(mtbl);
|
||||
do self.get::<&managed::raw::BoxRepr> |b| {
|
||||
let p = ptr::to_unsafe_ptr(&b.data) as *c_void;
|
||||
self.visit_ptr_inner(p, inner);
|
||||
}
|
||||
}
|
||||
|
||||
fn visit_ptr(_mtbl: uint, _inner: *TyDesc) -> bool {
|
||||
do self.get::<*c_void> |p| {
|
||||
self.writer.write_str(fmt!("(0x%x as *())",
|
||||
*p as uint));
|
||||
}
|
||||
}
|
||||
|
||||
fn visit_rptr(mtbl: uint, inner: *TyDesc) -> bool {
|
||||
self.writer.write_char('&');
|
||||
self.write_mut_qualifier(mtbl);
|
||||
do self.get::<*c_void> |p| {
|
||||
self.visit_ptr_inner(*p, inner);
|
||||
}
|
||||
}
|
||||
|
||||
// Type no longer exists, vestigial function.
|
||||
fn visit_vec(_mtbl: uint, _inner: *TyDesc) -> bool { fail; }
|
||||
|
||||
|
||||
fn visit_unboxed_vec(mtbl: uint, inner: *TyDesc) -> bool {
|
||||
do self.get::<vec::UnboxedVecRepr> |b| {
|
||||
self.write_unboxed_vec_repr(mtbl, b, inner);
|
||||
}
|
||||
}
|
||||
|
||||
fn visit_evec_box(mtbl: uint, inner: *TyDesc) -> bool {
|
||||
do self.get::<&VecRepr> |b| {
|
||||
self.writer.write_char('@');
|
||||
self.write_unboxed_vec_repr(mtbl, &b.unboxed, inner);
|
||||
}
|
||||
}
|
||||
|
||||
fn visit_evec_uniq(mtbl: uint, inner: *TyDesc) -> bool {
|
||||
do self.get::<&VecRepr> |b| {
|
||||
self.writer.write_char('~');
|
||||
self.write_unboxed_vec_repr(mtbl, &b.unboxed, inner);
|
||||
}
|
||||
}
|
||||
|
||||
fn visit_evec_slice(mtbl: uint, inner: *TyDesc) -> bool {
|
||||
do self.get::<SliceRepr> |s| {
|
||||
self.writer.write_char('&');
|
||||
self.write_vec_range(mtbl, s.data, s.len, inner);
|
||||
}
|
||||
}
|
||||
|
||||
fn visit_evec_fixed(_n: uint, sz: uint, _align: uint,
|
||||
mtbl: uint, inner: *TyDesc) -> bool {
|
||||
do self.get::<u8> |b| {
|
||||
self.write_vec_range(mtbl, ptr::to_unsafe_ptr(b), sz, inner);
|
||||
}
|
||||
}
|
||||
|
||||
fn visit_enter_rec(_n_fields: uint,
|
||||
_sz: uint, _align: uint) -> bool {
|
||||
self.writer.write_char('{');
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_rec_field(i: uint, name: &str,
|
||||
mtbl: uint, inner: *TyDesc) -> bool {
|
||||
if i != 0 {
|
||||
self.writer.write_str(", ");
|
||||
}
|
||||
self.write_mut_qualifier(mtbl);
|
||||
self.writer.write_str(name);
|
||||
self.writer.write_str(": ");
|
||||
self.visit_inner(inner);
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_leave_rec(_n_fields: uint,
|
||||
_sz: uint, _align: uint) -> bool {
|
||||
self.writer.write_char('}');
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_enter_class(_n_fields: uint,
|
||||
_sz: uint, _align: uint) -> bool {
|
||||
self.writer.write_char('{');
|
||||
true
|
||||
}
|
||||
fn visit_class_field(i: uint, name: &str,
|
||||
mtbl: uint, inner: *TyDesc) -> bool {
|
||||
if i != 0 {
|
||||
self.writer.write_str(", ");
|
||||
}
|
||||
self.write_mut_qualifier(mtbl);
|
||||
self.writer.write_str(name);
|
||||
self.writer.write_str(": ");
|
||||
self.visit_inner(inner);
|
||||
true
|
||||
}
|
||||
fn visit_leave_class(_n_fields: uint,
|
||||
_sz: uint, _align: uint) -> bool {
|
||||
self.writer.write_char('}');
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_enter_tup(_n_fields: uint,
|
||||
_sz: uint, _align: uint) -> bool {
|
||||
self.writer.write_char('(');
|
||||
true
|
||||
}
|
||||
fn visit_tup_field(i: uint, inner: *TyDesc) -> bool {
|
||||
if i != 0 {
|
||||
self.writer.write_str(", ");
|
||||
}
|
||||
self.visit_inner(inner);
|
||||
true
|
||||
}
|
||||
fn visit_leave_tup(_n_fields: uint,
|
||||
_sz: uint, _align: uint) -> bool {
|
||||
self.writer.write_char(')');
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_enter_enum(n_variants: uint,
|
||||
_sz: uint, _align: uint) -> bool {
|
||||
if n_variants == 1 {
|
||||
self.var_stk.push(Degenerate)
|
||||
} else {
|
||||
self.var_stk.push(TagMatch)
|
||||
}
|
||||
true
|
||||
}
|
||||
fn visit_enter_enum_variant(_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
|
||||
}
|
||||
fn visit_enum_variant_field(i: uint, inner: *TyDesc) -> bool {
|
||||
match self.var_stk.last() {
|
||||
Degenerate | TagMatch => {
|
||||
if i != 0 {
|
||||
self.writer.write_str(", ");
|
||||
}
|
||||
if ! self.visit_inner(inner) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
TagMismatch => ()
|
||||
}
|
||||
true
|
||||
}
|
||||
fn visit_leave_enum_variant(_variant: uint,
|
||||
_disr_val: int,
|
||||
n_fields: uint,
|
||||
_name: &str) -> bool {
|
||||
match self.var_stk.last() {
|
||||
Degenerate | TagMatch => {
|
||||
if n_fields > 0 {
|
||||
self.writer.write_char(')');
|
||||
}
|
||||
}
|
||||
TagMismatch => ()
|
||||
}
|
||||
true
|
||||
}
|
||||
fn visit_leave_enum(_n_variants: uint,
|
||||
_sz: uint, _align: uint) -> bool {
|
||||
self.var_stk.pop();
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_enter_fn(_purity: uint, _proto: uint,
|
||||
_n_inputs: uint, _retstyle: uint) -> bool { true }
|
||||
fn visit_fn_input(_i: uint, _mode: uint, _inner: *TyDesc) -> bool { true }
|
||||
fn visit_fn_output(_retstyle: uint, _inner: *TyDesc) -> bool { true }
|
||||
fn visit_leave_fn(_purity: uint, _proto: uint,
|
||||
_n_inputs: uint, _retstyle: uint) -> bool { true }
|
||||
|
||||
|
||||
fn visit_trait() -> bool { true }
|
||||
fn visit_var() -> bool { true }
|
||||
fn visit_var_integral() -> bool { true }
|
||||
fn visit_param(_i: uint) -> bool { true }
|
||||
fn visit_self() -> bool { true }
|
||||
fn visit_type() -> bool { true }
|
||||
|
||||
fn visit_opaque_box() -> bool {
|
||||
self.writer.write_char('@');
|
||||
do self.get::<&managed::raw::BoxRepr> |b| {
|
||||
let p = ptr::to_unsafe_ptr(&b.data) as *c_void;
|
||||
self.visit_ptr_inner(p, b.header.type_desc);
|
||||
}
|
||||
}
|
||||
|
||||
// Type no longer exists, vestigial function.
|
||||
fn visit_constr(_inner: *TyDesc) -> bool { fail; }
|
||||
|
||||
fn visit_closure_ptr(_ck: uint) -> bool { true }
|
||||
}
|
||||
|
||||
#[cfg(stage1)]
|
||||
#[cfg(stage2)]
|
||||
impl ReprVisitor : TyVisitor {
|
||||
fn visit_bot(&self) -> bool {
|
||||
self.writer.write_str("!");
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue