Fix compiler breaking changes

Author: theemathas

Cargo.lock

@@ -1,4 +1,4 @@
-#![feature(std_misc)]
+#![feature(mpsc_select)]
 
 #[macro_use]
 extern crate log;

search/src/lib.rs

@@ -15,7 +15,7 @@ pub fn start(data: Timer, c: Color, tx: SyncSender<TimeOut>) {
         },
         Timer::Remain(val) => {
             // TODO what is the right default value for base time?
-            let base = val.time(c).unwrap_or(Duration::zero());
+            let base = val.time(c).unwrap_or(Duration::new(0, 0));
             let inc = val.inc(c);
             let val = calc_time(base, inc);
             send_after(val, tx);
@@ -24,7 +24,7 @@ pub fn start(data: Timer, c: Color, tx: SyncSender<TimeOut>) {
 }
 
 fn send_after(delay: Duration, tx: SyncSender<TimeOut>) {
-    thread::sleep_ms(delay.num_milliseconds() as u32);
+    thread::sleep_ms(delay.secs() as u32 * 1000 + delay.extra_nanos() / 1000000);
     let _ = tx.send(TimeOut(()));
 }
 

timer/src/control.rs

@@ -1,4 +1,4 @@
-#![feature(std_misc)]
+#![feature(duration)]
 
 extern crate game;
 
@@ -82,8 +82,8 @@ impl RemainData {
         RemainData {
             w_time: None,
             b_time: None,
-            w_inc: Duration::zero(),
-            b_inc: Duration::zero(),
+            w_inc: Duration::new(0, 0),
+            b_inc: Duration::new(0, 0),
             moves_to_go: None,
         }
     }

timer/src/lib.rs

@@ -1,4 +1,4 @@
-#![feature(std_misc, collections, scoped, str_parse_error, collections_drain)]
+#![feature(scoped, str_parse_error, duration, slice_position_elem, drain)]
 
 extern crate time;
 #[macro_use]

uci/src/lib.rs

@@ -178,18 +178,18 @@ where I: Iterator<Item = &'a str> {
         match next_word {
             "searchmoves" => parse_from_to_vec(&mut words).map(|x| GoParam::SearchMoves(x)),
             "ponder" => Some(GoParam::Ponder),
-            "wtime"     => words.next().and_then(|s| s.parse::<i64>().ok())
+            "wtime"     => words.next().and_then(|s| s.parse::<u64>().ok())
                                        .map(|x| GoParam::Time(White,
-                                                              Duration::milliseconds(x))),
-            "btime"     => words.next().and_then(|s| s.parse::<i64>().ok())
+                                                              Duration::from_millis(x))),
+            "btime"     => words.next().and_then(|s| s.parse::<u64>().ok())
                                        .map(|x| GoParam::Time(Black,
-                                                              Duration::milliseconds(x))),
-            "winc"      => words.next().and_then(|s| s.parse::<i64>().ok())
+                                                              Duration::from_millis(x))),
+            "winc"      => words.next().and_then(|s| s.parse::<u64>().ok())
                                        .map(|x| GoParam::IncTime(White,
-                                                                 Duration::milliseconds(x))),
-            "binc"      => words.next().and_then(|s| s.parse::<i64>().ok())
+                                                                 Duration::from_millis(x))),
+            "binc"      => words.next().and_then(|s| s.parse::<u64>().ok())
                                        .map(|x| GoParam::IncTime(Black,
-                                                                 Duration::milliseconds(x))),
+                                                                 Duration::from_millis(x))),
             "movestogo" => words.next().and_then(|s| s.parse::<u32>().ok())
                                        .map(|x| GoParam::MovesToGo(NumMoves(x))),
             "depth"     => words.next().and_then(|s| s.parse::<u32>().ok())
@@ -198,8 +198,8 @@ where I: Iterator<Item = &'a str> {
                                        .map(|x| GoParam::Nodes(NumNodes(x))),
             "mate"      => words.next().and_then(|s| s.parse::<u32>().ok())
                                        .map(|x| GoParam::Mate(NumMoves(x))),
-            "movetime"  => words.next().and_then(|s| s.parse::<i64>().ok())
-                                       .map(|x| GoParam::MoveTime(Duration::milliseconds(x))),
+            "movetime"  => words.next().and_then(|s| s.parse::<u64>().ok())
+                                       .map(|x| GoParam::MoveTime(Duration::from_millis(x))),
             "infinite" => Some(GoParam::Infinite),
             _ => None,
         }.map(|val| res.push(val));

uci/src/parse.rs

@@ -68,7 +68,8 @@ impl fmt::Display for InfoParam {
         match *self {
             InfoParam::Depth(val)          => write!(f, "depth {}", val.0),
             InfoParam::SelDepth(val)       => write!(f, "seldepth {}", val.0),
-            InfoParam::TimeSearched(val)   => write!(f, "time {}", val.num_milliseconds()),
+            InfoParam::TimeSearched(val)   => write!(f, "time {}", val.secs() as u32 * 1000 +
+                                                                   val.extra_nanos() / 1000000),
             InfoParam::NodesSearched(val)  => write!(f, "nodes {}", val.0),
             InfoParam::PrincipalVariation(ref moves) => {
                 try!(write!(f, "pv"));