Fix errors due to changing nightly version

- Remove invalid feature
- Fix mem.rs errors
- Fix cpu.rs errors
- Note: One of the unit tests still fail. To investigate.

src/cpu.rs

@@ -698,7 +698,7 @@ impl Cpu {
     fn compare<A: Accessor>(&mut self, accessor: A, val: u8)
     {
         let aval = accessor.read(self);
-        let result = (val as u16).wrapping_add(-(aval as u16));
+        let result = (val as u16).wrapping_sub(aval as u16);
         let u = (result & 0x0100) != 0; // underflow occurred
 
         self.regs.status.c = !u;
@@ -731,23 +731,23 @@ impl Cpu {
     fn inst_dec<A: Accessor>(&mut self, accessor: A)
     {
         let val = accessor.read(self);
-        let result = self.update_zn(val.wrapping_add(-1));
+        let result = self.update_zn(val.wrapping_sub(1));
         accessor.write(self, result);
     }
 
     /// DEX - Decrement X Register
     fn inst_dex(&mut self)
     {
         let x = self.regs.x;
-        let result = self.update_zn(x.wrapping_add(-1));
+        let result = self.update_zn(x.wrapping_sub(1));
         self.regs.x = result;
     }
 
     /// DEY - Decrement Y Register
     fn inst_dey(&mut self)
     {
         let y = self.regs.y;
-        let result = self.update_zn(y.wrapping_add(-1));
+        let result = self.update_zn(y.wrapping_sub(1));
         self.regs.y = result;
     }
 
@@ -928,8 +928,8 @@ impl Cpu {
     {
         let v = accessor.read(self);
         let result = (self.regs.a as u16)
-            .wrapping_add(- v as u16)
-            .wrapping_add(- if !self.regs.status.c {1} else {0});
+            .wrapping_sub(v as u16)
+            .wrapping_sub(if !self.regs.status.c {1} else {0});
         self.regs.status.c = (result & 0x100) == 0;
         let a = self.regs.a;
         self.regs.status.v = (a ^ v) & 0x80 == 0x80 && (a^(result as u8)) & 0x80 == 0x80;

src/lib.rs

@@ -1,5 +1,4 @@
-#![feature(zero_one)]
-#![feature(negate_unsigned)]
+#![feature(step_trait)]
 #![feature(read_exact)] 
 // Disable dead_code and unused_imports after initial development.
 // This is harmless, though, apart from adding bloat/encouraging bad habits

src/mem.rs

@@ -1,11 +1,11 @@
-use std::num::One;
+use std::iter::Step;
 use std::ops::Add;
 
 /// A generic representation of memory
 ///
 /// `A` refers to the addressing type
 /// `W` refers to the word type
-pub trait Mem<A: Add<A, Output=A> + One + Copy, W: Sized + Copy> 
+pub trait Mem<A: Add<A, Output=A> + Step + Copy, W: Sized + Copy>
 {
     /// Read a word from address `addr`
     fn read_word(&self, addr: A) -> W;
@@ -14,13 +14,13 @@ pub trait Mem<A: Add<A, Output=A> + One + Copy, W: Sized + Copy>
     /// Same as `read_word`, but reads two words
     fn read_2words(&self, addr: A) -> [W;2]
     {
-        [self.read_word(addr), self.read_word(addr+A::one())]
+        [self.read_word(addr), self.read_word(addr.add_one())]
     }
     /// Same as `write_word`, but writes two words
     fn write_2words(&mut self, addr: A, words: [W;2])
     {
         self.write_word(addr, words[0]);
-        self.write_word(addr+A::one(), words[1]);
+        self.write_word(addr.add_one(), words[1]);
     }
 }