Add workspace and #[no_std] support

.gitignore

@@ -1,16 +1,2 @@
-pinky-devui/target
-pinky-devui/Cargo.lock
-pinky-libretro/target
-pinky-libretro/Cargo.lock
-pinky-web/target
-pinky-web/Cargo.lock
-nes-testsuite/target
-nes-testsuite/Cargo.lock
-mos6502/target
-mos6502/Cargo.lock
-nes/target
-nes/Cargo.lock
-emumisc/target
-emumisc/Cargo.lock
-rp2c02-testsuite/target
-rp2c02-testsuite/Cargo.lock
+Cargo.toml
+Cargo.lock

Cargo.toml

@@ -0,0 +1,14 @@
+[workspace]
+members = [
+    "emumisc",
+    "mos6502",
+    "nes",
+    "nes-testsuite",
+    "pinky-devui",
+    "pinky-libretro",
+    "pinky-web",
+    "rp2c02-testsuite"
+]
+
+[profile.test]
+opt-level = 2

emumisc/src/bits.rs

@@ -1,4 +1,4 @@
-use std::mem;
+use core::mem;
 
 #[inline(always)] pub fn is_b0_set( value: u8 ) -> bool { (value & (1 << 0)) != 0 }
 #[inline(always)] pub fn is_b1_set( value: u8 ) -> bool { (value & (1 << 1)) != 0 }
@@ -11,8 +11,6 @@ use std::mem;
 
 #[inline(always)]
 pub fn to_bit( bit: u8, value: bool ) -> u8 {
-    use std::mem;
-
     debug_assert!( bit < 8 );
     let converted: u8 = unsafe { mem::transmute( value ) };
     debug_assert!( converted == 0 || converted == 1 );
@@ -37,7 +35,7 @@ macro_rules! impl_bit_extra {
         impl BitExtra for $typ {
             #[inline(always)]
             fn mask_to_shift( mask: Self ) -> u8 {
-                use std::mem::size_of;
+                use core::mem::size_of;
                 debug_assert!( mask != 0 );
 
                 for n_bit in 0..(size_of::< Self >() * 8) as u8 {

emumisc/src/lib.rs

@@ -1,4 +1,7 @@
+#![no_std]
+
 extern crate unreachable;
+extern crate alloc;
 
 #[macro_use]
 mod misc;
@@ -31,7 +34,7 @@ pub use memory::{as_bytes, allocate_slice, copy_memory};
 #[macro_export]
 macro_rules! impl_deref {
     ($container: ty, $field_type: ty, $field: ident) => (
-        impl ::std::ops::Deref for $container {
+        impl ::core::ops::Deref for $container {
             type Target = $field_type;
 
             #[inline(always)]
@@ -40,7 +43,7 @@ macro_rules! impl_deref {
             }
         }
 
-        impl ::std::ops::DerefMut for $container {
+        impl ::core::ops::DerefMut for $container {
             #[inline(always)]
             fn deref_mut( &mut self ) -> &mut Self::Target {
                 &mut self.$field
@@ -52,14 +55,14 @@ macro_rules! impl_deref {
 #[macro_export]
 macro_rules! impl_as_ref {
     ($container: ty, $field_type: ty, $field: ident) => (
-        impl ::std::convert::AsRef< $field_type > for $container {
+        impl ::core::convert::AsRef< $field_type > for $container {
             #[inline(always)]
             fn as_ref( &self ) -> &$field_type {
                 &self.$field
             }
         }
 
-        impl ::std::convert::AsMut< $field_type > for $container {
+        impl ::core::convert::AsMut< $field_type > for $container {
             #[inline(always)]
             fn as_mut( &mut self ) -> &mut $field_type {
                 &mut self.$field
@@ -74,7 +77,7 @@ macro_rules! newtype {
         $(#[$attr])*
         pub struct $new( pub $old );
 
-        impl ::std::ops::Deref for $new {
+        impl ::core::ops::Deref for $new {
             type Target = $old;
 
             #[inline(always)]
@@ -83,21 +86,21 @@ macro_rules! newtype {
             }
         }
 
-        impl ::std::ops::DerefMut for $new {
+        impl ::core::ops::DerefMut for $new {
             #[inline(always)]
             fn deref_mut( &mut self ) -> &mut Self::Target {
                 &mut self.0
             }
         }
 
-        impl ::std::convert::AsRef< $old > for $new {
+        impl ::core::convert::AsRef< $old > for $new {
             #[inline(always)]
             fn as_ref( &self ) -> &$old {
                 &self.0
             }
         }
 
-        impl ::std::convert::AsMut< $old > for $new {
+        impl ::core::convert::AsMut< $old > for $new {
             #[inline(always)]
             fn as_mut( &mut self ) -> &mut $old {
                 &mut self.0

emumisc/src/memory.rs

@@ -1,6 +1,8 @@
-use std::ptr;
-use std::slice;
-use std::mem;
+use core::ptr;
+use core::slice;
+use core::mem;
+use alloc::boxed::Box;
+use alloc::vec::Vec;
 
 #[inline]
 pub fn as_bytes< T: Copy >( array: &[T] ) -> &[u8] {

mos6502/Cargo.toml

@@ -9,3 +9,6 @@ bitflags = "0.7"
 [dependencies.emumisc]
 path = "../emumisc"
 
+[features]
+default = ["std"]
+std = []

mos6502/src/generate_decoder.rb

@@ -345,9 +345,8 @@ def generate_opcode_attributes
 
             #[inline(always)]
             fn get_register( &self ) -> Register8 {
-                use std::mem;
                 unsafe {
-                    mem::transmute( (self.attr & 0b00011000) >> 3 )
+                    core::mem::transmute( (self.attr & 0b00011000) >> 3 )
                 }
             }
 

mos6502/src/lib.rs

@@ -1,6 +1,12 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+#![cfg_attr(not(feature = "std"), feature(error_in_core))]
+
 #![allow(non_snake_case)]
 #![allow(non_upper_case_globals)]
 
+#[cfg(feature = "std")]
+extern crate std as core;
+
 #[macro_use]
 extern crate emumisc;
 

mos6502/src/virtual_mos6502.rs

@@ -1,10 +1,9 @@
 use self::Register8::*;
 use self::Direction::*;
 
-use std::mem::transmute;
-use std::fmt;
-use std::ops::Deref;
-use std::error;
+use core::mem::transmute;
+use core::fmt;
+use core::ops::Deref;
 
 use emumisc::WrappingExtra;
 
@@ -227,7 +226,7 @@ impl fmt::Display for EmulationError {
     }
 }
 
-impl error::Error for EmulationError {
+impl core::error::Error for EmulationError {
     fn description( &self ) -> &str {
         use self::EmulationError::*;
         match *self {
@@ -1018,6 +1017,7 @@ trait Private: Sized + Context {
         result
     }
 
+    #[cfg(feature = "std")]
     fn print_registers( &self ) {
         println!( "            NV-BDIZC  A  X  Y   PC" );
         println!( "            {:08b} {:02X} {:02X} {:02X} {:04X}", self.state().status, self.state().a, self.state().x, self.state().y, self.state().pc );

mos6502/src/virtual_mos6502_decoder.rs

@@ -761,9 +761,8 @@ macro_rules! decoding_logic {
 
             #[inline(always)]
             fn get_register( &self ) -> Register8 {
-                use std::mem;
                 unsafe {
-                    mem::transmute( (self.attr & 0b00011000) >> 3 )
+                    core::mem::transmute( (self.attr & 0b00011000) >> 3 )
                 }
             }
 

nes/Cargo.toml

@@ -4,26 +4,22 @@ version = "0.1.0"
 authors = ["Jan Bujak <[email protected]>"]
 
 [dependencies]
-byteorder = "0.5"
-log = "0.3"
+log = { version = "0.4", default-features = false, optional = true }
 bitflags = "0.7"
 
 [dependencies.emumisc]
 path = "../emumisc"
 
 [dependencies.mos6502]
 path = "../mos6502"
+default-features = false
 
 [dev-dependencies.nes-testsuite]
 path = "../nes-testsuite"
 
 [dev-dependencies.rp2c02-testsuite]
 path = "../rp2c02-testsuite"
 
-[profile.test]
-opt-level = 2
-debug = true
-rpath = false
-lto = false
-debug-assertions = true
-codegen-units = 4
+[features]
+default = ["std"]
+std = ["mos6502/std", "log", "log/std"]

nes/src/generic_mapper.rs

@@ -1,4 +1,6 @@
-use std::fmt;
+use core::fmt;
+use alloc::vec::Vec;
+
 use emumisc::{PeekPoke, At};
 use rom::Mirroring;
 use mappers::Mapper;
@@ -464,6 +466,7 @@ impl GenericMapper {
     #[inline]
     pub fn poke_cpu_memory_space( &mut self, address: u16, value: u8 ) {
         if self.is_cpu_address_writable( address ) == false {
+            #[cfg(feature = "log")]
             warn!( "Unhandled write to 0x{:04X} (value=0x{:02X})", address, value );
             return;
         }
@@ -523,7 +526,7 @@ impl Mapper for GenericMapper {
     }
 }
 
-use std::ops::Sub;
+use core::ops::Sub;
 use rom::{NesRom, LoadError};
 #[inline]
 fn wraparound< T: Sub< Output = T > + PartialOrd + Copy >( limit: T, mut value: T ) -> T {

nes/src/lib.rs

@@ -1,11 +1,22 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+#![cfg_attr(not(feature = "std"), feature(error_in_core))]
+
 #![allow(dead_code)]
 #![allow(non_camel_case_types)]
 #![allow(non_upper_case_globals)]
 #![allow(non_snake_case)]
 #![allow(missing_copy_implementations)]
 
-extern crate byteorder;
+#[cfg(feature = "std")]
+extern crate std as core;
+
+#[cfg(feature = "std")]
+extern crate std as alloc;
+
+#[cfg(not(feature = "std"))]
+extern crate alloc;
 
+#[cfg(feature = "log")]
 #[macro_use]
 extern crate log;
 

nes/src/mapper_mmc1.rs

@@ -152,6 +152,7 @@ impl Mapper for MapperMMC1 {
                     _ => unsafe { fast_unreachable!() }
                 };
 
+                #[cfg(feature = "log")]
                 debug!( "ROM switching mode = {:?}, VROM switching mode = {:?}",
                     self.rom_switching_mode,
                     self.vrom_switching_mode

nes/src/mappers.rs

@@ -1,3 +1,6 @@
+use alloc::boxed::Box;
+use alloc::format;
+
 use rom::{NesRom, LoadError};
 use generic_mapper::GenericMapper;
 use mapper_mmc1::MapperMMC1;
@@ -10,20 +13,24 @@ pub trait Mapper {
     fn poke_rom( &mut self, address: u16, value: u8 );
 
     fn peek_sram( &self, address: u16 ) -> u8 {
+        #[cfg(feature = "log")]
         warn!( "Unhandled read from the save RAM at 0x{:04X}", address );
         0
     }
 
     fn poke_sram( &mut self, address: u16, value: u8 ) {
+        #[cfg(feature = "log")]
         warn!( "Unhandled write to the save RAM at 0x{:04X} (value=0x{:02X})", address, value );
     }
 
     fn peek_expansion_rom( &self, address: u16 ) -> u8 {
+        #[cfg(feature = "log")]
         warn!( "Unhandled read from the expansion ROM at 0x{:04X}", address );
         0
     }
 
     fn poke_expansion_rom( &self, address: u16, value: u8 ) {
+        #[cfg(feature = "log")]
         warn!( "Unhandled write to the expansion ROM at 0x{:04X} (value=0x{:02X})", address, value );
     }
 
@@ -35,20 +42,24 @@ pub struct MapperNull;
 
 impl Mapper for MapperNull {
     fn peek_rom( &self, address: u16 ) -> u8 {
+        #[cfg(feature = "log")]
         warn!( "Unhandled read from the ROM at 0x{:04X}", address );
         0
     }
 
     fn poke_rom( &mut self, address: u16, value: u8 ) {
+        #[cfg(feature = "log")]
         warn!( "Unhandled write to the ROM at 0x{:04X} (value=0x{:02X})", address, value );
     }
 
     fn peek_video_memory( &self, address: u16 ) -> u8 {
+        #[cfg(feature = "log")]
         warn!( "Unhandled read from the VROM at 0x{:04X}", address );
         0
     }
 
     fn poke_video_memory( &mut self, address: u16, value: u8 ) {
+        #[cfg(feature = "log")]
         warn!( "Unhandled write to the VROM at 0x{:04X} (value=0x{:02X})", address, value );
     }
 }
@@ -65,6 +76,7 @@ pub fn create_mapper( rom: NesRom ) -> Result< Box< Mapper >, LoadError > {
             mapper.initialize_video_rom( &rom.video_rom[..] );
             mapper.initialize_background_tilemaps( rom.mirroring );
 
+            #[cfg(feature = "log")]
             debug!( "Initialized mapper: {:?}", mapper );
             Ok( Box::new( mapper ) )
         },

nes/src/orphan.rs

@@ -1,5 +1,5 @@
-use std::mem;
-use std::ops::{Deref, DerefMut};
+use core::mem;
+use core::ops::{Deref, DerefMut};
 
 // A shim like this is necessary to implement an orphaned instance in Rust.
 // It's very important to keep the structure opaque to keep it safe to use.