diff --git a/src/libcore/comm.rs b/src/libcore/comm.rs index 4775e297795..cf146ad8aa0 100644 --- a/src/libcore/comm.rs +++ b/src/libcore/comm.rs @@ -99,7 +99,6 @@ fn listen(f: fn(Chan) -> U) -> U { struct PortPtr { let po: *rust_port; - new(po: *rust_port) { self.po = po; } drop unsafe { do task::unkillable { // Once the port is detached it's guaranteed not to receive further @@ -122,6 +121,12 @@ struct PortPtr { } } +fn PortPtr(po: *rust_port) -> PortPtr { + PortPtr { + po: po + } +} + /** * Internal function for converting from a channel to a port * @@ -134,7 +139,6 @@ fn as_raw_port(ch: comm::Chan, f: fn(*rust_port) -> U) -> U { struct PortRef { let p: *rust_port; - new(p: *rust_port) { self.p = p; } drop { if !ptr::is_null(self.p) { rustrt::rust_port_drop(self.p); @@ -142,6 +146,12 @@ fn as_raw_port(ch: comm::Chan, f: fn(*rust_port) -> U) -> U { } } + fn PortRef(p: *rust_port) -> PortRef { + PortRef { + p: p + } + } + let p = PortRef(rustrt::rust_port_take(*ch)); if ptr::is_null(p.p) { diff --git a/src/libcore/io.rs b/src/libcore/io.rs index 21047660e7d..483c96206b5 100644 --- a/src/libcore/io.rs +++ b/src/libcore/io.rs @@ -247,10 +247,15 @@ impl {base: T, cleanup: C}: Reader { struct FILERes { let f: *libc::FILE; - new(f: *libc::FILE) { self.f = f; } drop { libc::fclose(self.f); } } +fn FILERes(f: *libc::FILE) -> FILERes { + FILERes { + f: f + } +} + fn FILE_reader(f: *libc::FILE, cleanup: bool) -> Reader { if cleanup { {base: f, cleanup: FILERes(f)} as Reader @@ -417,10 +422,15 @@ impl fd_t: Writer { struct FdRes { let fd: fd_t; - new(fd: fd_t) { self.fd = fd; } drop { libc::close(self.fd); } } +fn FdRes(fd: fd_t) -> FdRes { + FdRes { + fd: fd + } +} + fn fd_writer(fd: fd_t, cleanup: bool) -> Writer { if cleanup { {base: fd, cleanup: FdRes(fd)} as Writer @@ -768,7 +778,6 @@ mod fsync { // Artifacts that need to fsync on destruction struct Res { let arg: Arg; - new(-arg: Arg) { self.arg <- arg; } drop { match self.arg.opt_level { option::None => (), @@ -780,6 +789,12 @@ mod fsync { } } + fn Res(-arg: Arg) -> Res{ + Res { + arg: move arg + } + } + type Arg = { val: t, opt_level: Option, diff --git a/src/libcore/option.rs b/src/libcore/option.rs index c9620e4df84..dfa02303751 100644 --- a/src/libcore/option.rs +++ b/src/libcore/option.rs @@ -292,9 +292,15 @@ fn test_unwrap_str() { fn test_unwrap_resource() { struct R { let i: @mut int; - new(i: @mut int) { self.i = i; } drop { *(self.i) += 1; } } + + fn R(i: @mut int) -> R { + R { + i: i + } + } + let i = @mut 0; { let x = R(i); diff --git a/src/libcore/pipes.rs b/src/libcore/pipes.rs index ae78c8108eb..f0b656ea649 100644 --- a/src/libcore/pipes.rs +++ b/src/libcore/pipes.rs @@ -135,12 +135,16 @@ struct BufferHeader { // get away with restricting it to 0 or 1, if we're careful. let mut ref_count: int; - new() { self.ref_count = 0; } - // We may want a drop, and to be careful about stringing this // thing along. } +fn BufferHeader() -> BufferHeader{ + BufferHeader { + ref_count: 0 + } +} + // XXX remove me #[cfg(stage0)] fn buffer_header() -> BufferHeader { BufferHeader() } @@ -160,12 +164,6 @@ struct PacketHeader { // to a buffer_header if need be. let mut buffer: *libc::c_void; - new() { - self.state = Empty; - self.blocked_task = ptr::null(); - self.buffer = ptr::null(); - } - // Returns the old state. unsafe fn mark_blocked(this: *rust_task) -> State { rustrt::rust_task_ref(this); @@ -197,6 +195,14 @@ struct PacketHeader { } } +fn PacketHeader() -> PacketHeader { + PacketHeader { + state: Empty, + blocked_task: ptr::null(), + buffer: ptr::null() + } +} + #[doc(hidden)] type Packet = { header: PacketHeader, @@ -368,12 +374,6 @@ unsafe fn get_buffer(p: *PacketHeader) -> ~Buffer { // This could probably be done with SharedMutableState to avoid move_it!(). struct BufferResource { let buffer: ~Buffer; - new(+b: ~Buffer) { - //let p = ptr::addr_of(*b); - //error!("take %?", p); - atomic_add_acq(&mut b.header.ref_count, 1); - self.buffer = b; - } drop unsafe { let b = move_it!(self.buffer); @@ -392,6 +392,16 @@ struct BufferResource { } } +fn BufferResource(+b: ~Buffer) -> BufferResource { + //let p = ptr::addr_of(*b); + //error!("take %?", p); + atomic_add_acq(&mut b.header.ref_count, 1); + + BufferResource { + buffer: b + } +} + #[doc(hidden)] fn send(+p: SendPacketBuffered, +payload: T) -> bool { @@ -770,15 +780,6 @@ fn send_packet(p: *packet) -> SendPacket { struct SendPacketBuffered { let mut p: Option<*Packet>; let mut buffer: Option>; - new(p: *Packet) { - //debug!("take send %?", p); - self.p = Some(p); - unsafe { - self.buffer = Some( - BufferResource( - get_buffer(ptr::addr_of((*p).header)))); - }; - } drop { //if self.p != none { // debug!("drop send %?", option::get(self.p)); @@ -819,6 +820,18 @@ struct SendPacketBuffered { } } +fn SendPacketBuffered(p: *Packet) + -> SendPacketBuffered { + //debug!("take send %?", p); + SendPacketBuffered { + p: Some(p), + buffer: unsafe { + Some(BufferResource( + get_buffer(ptr::addr_of((*p).header)))) + } + } +} + // XXX remove me #[cfg(stage0)] #[allow(non_camel_case_types)] @@ -848,15 +861,6 @@ fn recv_packet(p: *packet) -> RecvPacket { struct RecvPacketBuffered : Selectable { let mut p: Option<*Packet>; let mut buffer: Option>; - new(p: *Packet) { - //debug!("take recv %?", p); - self.p = Some(p); - unsafe { - self.buffer = Some( - BufferResource( - get_buffer(ptr::addr_of((*p).header)))); - }; - } drop { //if self.p != none { // debug!("drop recv %?", option::get(self.p)); @@ -897,6 +901,18 @@ struct RecvPacketBuffered : Selectable { } } +fn RecvPacketBuffered(p: *Packet) + -> RecvPacketBuffered { + //debug!("take recv %?", p); + RecvPacketBuffered { + p: Some(p), + buffer: unsafe { + Some(BufferResource( + get_buffer(ptr::addr_of((*p).header)))) + } + } +} + // XXX remove me #[cfg(stage0)] #[allow(non_camel_case_types)] @@ -1083,8 +1099,6 @@ impl Port: Recv { struct PortSet : Recv { let mut ports: ~[pipes::Port]; - new() { self.ports = ~[]; } - fn add(+port: pipes::Port) { vec::push(self.ports, port) } @@ -1131,6 +1145,12 @@ struct PortSet : Recv { } } +fn PortSet() -> PortSet{ + PortSet { + ports: ~[] + } +} + impl Port: Selectable { pure fn header() -> *PacketHeader unchecked { match self.endp { diff --git a/src/libcore/priv.rs b/src/libcore/priv.rs index 5db54650a6c..ae82e59efad 100644 --- a/src/libcore/priv.rs +++ b/src/libcore/priv.rs @@ -196,11 +196,16 @@ unsafe fn weaken_task(f: fn(comm::Port<()>)) { struct Unweaken { let ch: comm::Chan<()>; - new(ch: comm::Chan<()>) { self.ch = ch; } drop unsafe { rustrt::rust_task_unweaken(unsafe::reinterpret_cast(&self.ch)); } } + + fn Unweaken(ch: comm::Chan<()>) -> Unweaken { + Unweaken { + ch: ch + } + } } #[test] diff --git a/src/libcore/rand.rs b/src/libcore/rand.rs index 1a4592954e3..cdead813899 100644 --- a/src/libcore/rand.rs +++ b/src/libcore/rand.rs @@ -245,10 +245,15 @@ impl Rng { struct RandRes { let c: *rctx; - new(c: *rctx) { self.c = c; } drop { rustrt::rand_free(self.c); } } +fn RandRes(c: *rctx) -> RandRes { + RandRes { + c: c + } +} + impl @RandRes: Rng { fn next() -> u32 { return rustrt::rand_next((*self).c); } } diff --git a/src/libcore/run.rs b/src/libcore/run.rs index 2e8d07175c9..866fcb2275a 100644 --- a/src/libcore/run.rs +++ b/src/libcore/run.rs @@ -228,10 +228,15 @@ fn start_program(prog: &str, args: &[~str]) -> Program { } struct ProgRes { let r: ProgRepr; - new(+r: ProgRepr) { self.r = r; } drop { destroy_repr(&self.r); } } + fn ProgRes(+r: ProgRepr) -> ProgRes { + ProgRes { + r: r + } + } + impl ProgRes: Program { fn get_id() -> pid_t { return self.r.pid; } fn input() -> io::Writer { io::fd_writer(self.r.in_fd, false) } diff --git a/src/libcore/stackwalk.rs b/src/libcore/stackwalk.rs index 2d5518525fa..0f79a5b6f5f 100644 --- a/src/libcore/stackwalk.rs +++ b/src/libcore/stackwalk.rs @@ -8,9 +8,11 @@ type Word = uint; struct Frame { let fp: *Word; +} - new(fp: *Word) { - self.fp = fp; +fn Frame(fp: *Word) -> Frame { + Frame { + fp: fp } } diff --git a/src/libcore/task.rs b/src/libcore/task.rs index 5303c9d7bf2..8d1eb53cc79 100644 --- a/src/libcore/task.rs +++ b/src/libcore/task.rs @@ -610,10 +610,15 @@ fn get_task() -> Task { unsafe fn unkillable(f: fn() -> U) -> U { struct AllowFailure { let t: *rust_task; - new(t: *rust_task) { self.t = t; } drop { rustrt::rust_task_allow_kill(self.t); } } + fn AllowFailure(t: *rust_task) -> AllowFailure{ + AllowFailure { + t: t + } + } + let t = rustrt::rust_get_task(); let _allow_failure = AllowFailure(t); rustrt::rust_task_inhibit_kill(t); @@ -624,10 +629,15 @@ unsafe fn unkillable(f: fn() -> U) -> U { unsafe fn rekillable(f: fn() -> U) -> U { struct DisallowFailure { let t: *rust_task; - new(t: *rust_task) { self.t = t; } drop { rustrt::rust_task_inhibit_kill(self.t); } } + fn DisallowFailure(t: *rust_task) -> DisallowFailure { + DisallowFailure { + t: t + } + } + let t = rustrt::rust_get_task(); let _allow_failure = DisallowFailure(t); rustrt::rust_task_allow_kill(t); @@ -641,12 +651,18 @@ unsafe fn rekillable(f: fn() -> U) -> U { unsafe fn atomically(f: fn() -> U) -> U { struct DeferInterrupts { let t: *rust_task; - new(t: *rust_task) { self.t = t; } drop { rustrt::rust_task_allow_yield(self.t); rustrt::rust_task_allow_kill(self.t); } } + + fn DeferInterrupts(t: *rust_task) -> DeferInterrupts { + DeferInterrupts { + t: t + } + } + let t = rustrt::rust_get_task(); let _interrupts = DeferInterrupts(t); rustrt::rust_task_inhibit_kill(t); @@ -938,15 +954,6 @@ struct TCB { let mut ancestors: AncestorList; let is_main: bool; let notifier: Option; - new(me: *rust_task, -tasks: TaskGroupArc, -ancestors: AncestorList, - is_main: bool, -notifier: Option) { - self.me = me; - self.tasks = tasks; - self.ancestors = ancestors; - self.is_main = is_main; - self.notifier = notifier; - self.notifier.iter(|x| { x.failed = false; }); - } // Runs on task exit. drop { // If we are failing, the whole taskgroup needs to die. @@ -971,19 +978,37 @@ struct TCB { } } +fn TCB(me: *rust_task, +tasks: TaskGroupArc, +ancestors: AncestorList, + is_main: bool, +notifier: Option) -> TCB { + + let notifier = move notifier; + notifier.iter(|x| { x.failed = false; }); + + TCB { + me: me, + tasks: tasks, + ancestors: ancestors, + is_main: is_main, + notifier: move notifier + } +} + struct AutoNotify { let notify_chan: comm::Chan; let mut failed: bool; - new(chan: comm::Chan) { - self.notify_chan = chan; - self.failed = true; // Un-set above when taskgroup successfully made. - } drop { let result = if self.failed { Failure } else { Success }; comm::send(self.notify_chan, Exit(get_task(), result)); } } +fn AutoNotify(chan: comm::Chan) -> AutoNotify { + AutoNotify { + notify_chan: chan, + failed: true // Un-set above when taskgroup successfully made. + } +} + fn enlist_in_taskgroup(state: TaskGroupInner, me: *rust_task, is_member: bool) -> bool { let newstate = util::replace(state, None); diff --git a/src/libcore/unsafe.rs b/src/libcore/unsafe.rs index 86d78528e4d..e4a73c12921 100644 --- a/src/libcore/unsafe.rs +++ b/src/libcore/unsafe.rs @@ -95,7 +95,6 @@ struct ArcData { struct ArcDestruct { mut data: *libc::c_void; - new(data: *libc::c_void) { self.data = data; } drop unsafe { if self.data.is_null() { return; // Happens when destructing an unwrapper's handle. @@ -132,6 +131,12 @@ struct ArcDestruct { } } +fn ArcDestruct(data: *libc::c_void) -> ArcDestruct { + ArcDestruct { + data: data + } +} + unsafe fn unwrap_shared_mutable_state(+rc: SharedMutableState) -> T { struct DeathThroes { @@ -276,21 +281,29 @@ extern mod rustrt { struct LittleLock { let l: rust_little_lock; - new() { - self.l = rustrt::rust_create_little_lock(); - } drop { rustrt::rust_destroy_little_lock(self.l); } } +fn LittleLock() -> LittleLock { + LittleLock { + l: rustrt::rust_create_little_lock() + } +} + impl LittleLock { #[inline(always)] unsafe fn lock(f: fn() -> T) -> T { struct Unlock { let l: rust_little_lock; - new(l: rust_little_lock) { self.l = l; } drop { rustrt::rust_unlock_little_lock(self.l); } } + fn Unlock(l: rust_little_lock) -> Unlock { + Unlock { + l: l + } + } + do atomically { rustrt::rust_lock_little_lock(self.l); let _r = Unlock(self.l); diff --git a/src/libcore/util.rs b/src/libcore/util.rs index f0b4a344307..57590dbfc3e 100644 --- a/src/libcore/util.rs +++ b/src/libcore/util.rs @@ -55,10 +55,11 @@ fn replace(dest: &mut T, +src: T) -> T { /// A non-copyable dummy type. struct NonCopyable { i: (); - new() { self.i = (); } drop { } } +fn NonCopyable() -> NonCopyable { NonCopyable { i: () } } + mod tests { #[test] fn identity_crisis() {