1
+ // tjc: I don't know why
2
+ // xfail-pretty
1
3
mod pipes {
2
4
#[ legacy_exports] ;
3
5
use cast:: { forget, transmute} ;
@@ -42,39 +44,39 @@ mod pipes {
42
44
// We should consider moving this to core::unsafe, although I
43
45
// suspect graydon would want us to use void pointers instead.
44
46
unsafe fn uniquify < T > ( +x: * T ) -> ~T {
45
- unsafe { cast:: transmute ( x) }
47
+ unsafe { cast:: transmute ( move x) }
46
48
}
47
49
48
50
fn swap_state_acq ( +dst : & mut state , src : state ) -> state {
49
51
unsafe {
50
- transmute ( rusti:: atomic_xchg_acq ( transmute ( dst) , src as int ) )
52
+ transmute ( rusti:: atomic_xchg_acq ( transmute ( move dst) , src as int ) )
51
53
}
52
54
}
53
55
54
56
fn swap_state_rel ( +dst : & mut state , src : state ) -> state {
55
57
unsafe {
56
- transmute ( rusti:: atomic_xchg_rel ( transmute ( dst) , src as int ) )
58
+ transmute ( rusti:: atomic_xchg_rel ( transmute ( move dst) , src as int ) )
57
59
}
58
60
}
59
61
60
62
fn send < T : Send > ( -p : send_packet < T > , -payload : T ) {
61
63
let p = p. unwrap ( ) ;
62
64
let p = unsafe { uniquify ( p) } ;
63
65
assert ( * p) . payload . is_none ( ) ;
64
- ( * p) . payload <- Some ( payload) ;
66
+ ( * p) . payload <- Some ( move payload) ;
65
67
let old_state = swap_state_rel ( & mut ( * p) . state , full) ;
66
68
match old_state {
67
69
empty => {
68
70
// Yay, fastpath.
69
71
70
72
// The receiver will eventually clean this up.
71
- unsafe { forget ( p) ; }
73
+ unsafe { forget ( move p) ; }
72
74
}
73
75
full => { fail ~"duplicate send" }
74
76
blocked => {
75
77
76
78
// The receiver will eventually clean this up.
77
- unsafe { forget ( p) ; }
79
+ unsafe { forget ( move p) ; }
78
80
}
79
81
terminated => {
80
82
// The receiver will never receive this. Rely on drop_glue
@@ -94,7 +96,7 @@ mod pipes {
94
96
full => {
95
97
let mut payload = None ;
96
98
payload <-> ( * p) . payload ;
97
- return Some ( option:: unwrap ( payload) )
99
+ return Some ( option:: unwrap ( move payload) )
98
100
}
99
101
terminated => {
100
102
assert old_state == terminated;
@@ -109,7 +111,7 @@ mod pipes {
109
111
match swap_state_rel ( & mut ( * p) . state , terminated) {
110
112
empty | blocked => {
111
113
// The receiver will eventually clean up.
112
- unsafe { forget ( p) }
114
+ unsafe { forget ( move p) }
113
115
}
114
116
full => {
115
117
// This is impossible
@@ -126,7 +128,7 @@ mod pipes {
126
128
match swap_state_rel ( & mut ( * p) . state , terminated) {
127
129
empty => {
128
130
// the sender will clean up
129
- unsafe { forget ( p) }
131
+ unsafe { forget ( move p) }
130
132
}
131
133
blocked => {
132
134
// this shouldn't happen.
@@ -144,7 +146,7 @@ mod pipes {
144
146
if self . p != None {
145
147
let mut p = None ;
146
148
p <-> self . p;
147
- sender_terminate( option : : unwrap ( p ) )
149
+ sender_terminate( option : : unwrap ( move p) )
148
150
}
149
151
}
150
152
}
@@ -153,7 +155,7 @@ mod pipes {
153
155
fn unwrap ( ) -> * packet < T > {
154
156
let mut p = None ;
155
157
p <-> self . p ;
156
- option:: unwrap ( p)
158
+ option:: unwrap ( move p)
157
159
}
158
160
}
159
161
@@ -169,7 +171,7 @@ mod pipes {
169
171
if self . p != None {
170
172
let mut p = None ;
171
173
p <-> self . p;
172
- receiver_terminate( option : : unwrap ( p ) )
174
+ receiver_terminate( option : : unwrap ( move p) )
173
175
}
174
176
}
175
177
}
@@ -178,7 +180,7 @@ mod pipes {
178
180
fn unwrap ( ) -> * packet < T > {
179
181
let mut p = None ;
180
182
p <-> self . p ;
181
- option:: unwrap ( p)
183
+ option:: unwrap ( move p)
182
184
}
183
185
}
184
186
@@ -204,17 +206,17 @@ mod pingpong {
204
206
ping( x) => { cast:: transmute( ptr:: addr_of( & x) ) }
205
207
} ;
206
208
let liberated_value <- * addr;
207
- cast:: forget ( p ) ;
208
- liberated_value
209
+ cast:: forget ( move p) ;
210
+ move liberated_value
209
211
}
210
212
211
213
fn liberate_pong ( -p : pong ) -> pipes:: send_packet < ping > unsafe {
212
214
let addr : * pipes:: send_packet < ping > = match p {
213
215
pong ( x) => { cast:: transmute ( ptr:: addr_of ( & x) ) }
214
216
} ;
215
217
let liberated_value <- * addr;
216
- cast:: forget ( p ) ;
217
- liberated_value
218
+ cast:: forget ( move p) ;
219
+ move liberated_value
218
220
}
219
221
220
222
fn init ( ) -> ( client:: ping , server:: ping ) {
@@ -229,16 +231,16 @@ mod pingpong {
229
231
fn do_ping ( -c : ping ) -> pong {
230
232
let ( sp, rp) = pipes:: entangle ( ) ;
231
233
232
- pipes:: send ( c, ping ( sp) ) ;
233
- rp
234
+ pipes:: send ( move c, ping ( move sp) ) ;
235
+ move rp
234
236
}
235
237
236
238
fn do_pong ( -c : pong ) -> ( ping , ( ) ) {
237
- let packet = pipes:: recv ( c) ;
239
+ let packet = pipes:: recv ( move c) ;
238
240
if packet. is_none ( ) {
239
241
fail ~"sender closed the connection"
240
242
}
241
- ( liberate_pong ( option:: unwrap ( packet) ) , ( ) )
243
+ ( liberate_pong ( option:: unwrap ( move packet) ) , ( ) )
242
244
}
243
245
}
244
246
@@ -248,32 +250,32 @@ mod pingpong {
248
250
type pong = pipes:: send_packet < pingpong:: pong > ;
249
251
250
252
fn do_ping ( -c : ping ) -> ( pong , ( ) ) {
251
- let packet = pipes:: recv ( c) ;
253
+ let packet = pipes:: recv ( move c) ;
252
254
if packet. is_none ( ) {
253
255
fail ~"sender closed the connection"
254
256
}
255
- ( liberate_ping ( option:: unwrap ( packet) ) , ( ) )
257
+ ( liberate_ping ( option:: unwrap ( move packet) ) , ( ) )
256
258
}
257
259
258
260
fn do_pong ( -c : pong ) -> ping {
259
261
let ( sp, rp) = pipes:: entangle ( ) ;
260
- pipes:: send ( c, pong ( sp) ) ;
261
- rp
262
+ pipes:: send ( move c, pong ( move sp) ) ;
263
+ move rp
262
264
}
263
265
}
264
266
}
265
267
266
268
fn client ( -chan: pingpong:: client:: ping) {
267
- let chan = pingpong:: client:: do_ping ( chan) ;
269
+ let chan = pingpong:: client:: do_ping ( move chan) ;
268
270
log ( error, ~"Sent ping") ;
269
- let ( chan , _data) = pingpong:: client:: do_pong ( chan) ;
271
+ let ( _chan , _data) = pingpong:: client:: do_pong ( move chan) ;
270
272
log ( error, ~"Received pong") ;
271
273
}
272
274
273
275
fn server ( -chan: pingpong:: server:: ping) {
274
- let ( chan, _data) = pingpong:: server:: do_ping ( chan) ;
276
+ let ( chan, _data) = pingpong:: server:: do_ping ( move chan) ;
275
277
log ( error, ~"Received ping") ;
276
- let chan = pingpong:: server:: do_pong ( chan) ;
278
+ let _chan = pingpong:: server:: do_pong ( move chan) ;
277
279
log ( error, ~"Sent pong") ;
278
280
}
279
281
0 commit comments