Merge branch 'master' of https://github.com/funmaker/iepass

Author: sebimoe

p8rs-log/src/lib.rs

@@ -168,7 +168,7 @@ cfg_if::cfg_if! {
 
 cfg_if::cfg_if! {
     if #[cfg(feature = "defmt")] {
-        pub use defmt::eprintln;
+        pub use defmt::error as eprintln;
     } else if #[cfg(all(feature = "std", feature = "std-error"))] {
         pub use std::eprintln;
     } else if #[cfg(feature = "log-04")] {

p8rs-macros/src/lib.rs

@@ -3,6 +3,7 @@ use syn::parse_macro_input;
 
 mod p8;
 mod api;
+mod transparent_ref;
 
 #[proc_macro]
 pub fn p8(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
@@ -20,3 +21,11 @@ pub fn api_callback(_attr: proc_macro::TokenStream, item: proc_macro::TokenStrea
 		#callback
 	).into()
 }
+
+#[proc_macro_derive(TransparentRef)]
+pub fn derive_transparent_ref(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
+	let item = parse_macro_input!(item as syn::DeriveInput);
+	let derive = transparent_ref::make_derive(&item).unwrap_or_else(syn::Error::into_compile_error);
+	
+	derive.into_token_stream().into()
+}

p8rs-macros/src/transparent_ref.rs

@@ -0,0 +1,62 @@
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{Data, Fields};
+
+pub fn make_derive(item: &syn::DeriveInput) -> syn::Result<TokenStream> {
+	let mut is_transparent = false;
+	for attr in &item.attrs {
+		if attr.path().is_ident("repr") {
+			attr.parse_nested_meta(|meta| {
+				if meta.path.is_ident("transparent") {
+					is_transparent = true;
+					Ok(())
+				} else {
+					Err(meta.error("expected `#[repr(transparent)]`"))
+				}
+			})?;
+		}
+	}
+	
+	if !is_transparent {
+		return Err(syn::Error::new(item.ident.span(), "Item must be `#[repr(transparent)]`"));
+	}
+	
+	let item_struct = match &item.data {
+		Data::Struct(item_struct) => item_struct,
+		_ => return Err(syn::Error::new(item.ident.span(), "Item must be a struct")),
+	};
+	
+	let field = match &item_struct.fields {
+		Fields::Named(fields) if fields.named.len() == 1 => &fields.named[0],
+		Fields::Unnamed(fields) if fields.unnamed.len() == 1 => &fields.unnamed[0],
+		_ => return Err(syn::Error::new(item.ident.span(), "Struct must have single field"))
+	};
+	
+	let ident = &item.ident;
+	let bits_type = &field.ty;
+	
+	Ok(quote!{
+		impl #ident {
+			fn from_bits_ref(inner: &#bits_type) -> &Self {
+				unsafe { ::core::mem::transmute(inner) }
+			}
+			fn from_bits_mut(inner: &mut #bits_type) -> &mut Self {
+				unsafe { ::core::mem::transmute(inner) }
+			}
+			fn from_bits_boxed<A: ::core::alloc::Allocator>(inner: Box<#bits_type, A>) -> Box<Self, A> {
+				let (ptr, alloc) = Box::into_raw_with_allocator(inner);
+				unsafe { Box::from_raw_in(ptr as *mut Self, alloc) }
+			}
+			fn to_bits_ref(&self) -> &#bits_type {
+				unsafe { ::core::mem::transmute(self) }
+			}
+			fn to_bits_mut(&mut self) -> &mut #bits_type {
+				unsafe { ::core::mem::transmute(self) }
+			}
+			fn to_bits_boxed<A: ::core::alloc::Allocator>(self: Box<Self, A>) -> Box<#bits_type, A> {
+				let (ptr, alloc) = Box::into_raw_with_allocator(self);
+				unsafe { Box::from_raw_in(ptr as *mut #bits_type, alloc) }
+			}
+		}
+	})
+}

p8rs/src/vm/api/print.rs

@@ -45,7 +45,7 @@ pub fn install_pico8_print<A: Allocator + 'static>(ctx: Context) {
 			}
 		};
 
-		let flags = rt.memory.machine_state().get_print_defaults();
+		let flags = *rt.memory.machine_state().print_defaults();
 
 		if y.is_none() {
 			let font_height = get_font_height(rt, flags);

p8rs/src/vm/memory/machine_state.rs

@@ -1,6 +1,6 @@
 use std::ops::{Deref, DerefMut};
 use bitflags::bitflags;
-
+use p8rs_macros::TransparentRef;
 use super::MemoryAccess;
 
 /// 0x5f00..=0x5f80
@@ -60,20 +60,12 @@ impl MachineState<'_> {
 		(&mut self[0x20..=0x23]).try_into().unwrap()
 	}
 
-	pub fn get_misc_chipset_flags(&self) -> MiscChipsetFeatureFlags {
-		MiscChipsetFeatureFlags::from_bits_truncate(self[0x36])
-	}
-	
-	pub fn set_misc_chipset_flags(&mut self, flags: MiscChipsetFeatureFlags) {
-		self[0x36] = flags.bits()
+	pub fn misc_chipset_flags(&mut self) -> &mut MiscChipsetFeatureFlags {
+		MiscChipsetFeatureFlags::from_bits_mut(&mut self[0x36])
 	}
 
-	pub fn get_print_defaults(&self) -> PrintAttributeFlags {
-		PrintAttributeFlags::from_bits_truncate(self[0x58])
-	}
-	
-	pub fn set_print_defaults(&mut self, flags: PrintAttributeFlags) {
-		self[0x58] = flags.bits();
+	pub fn print_defaults(&mut self) -> &mut PrintAttributeFlags {
+		PrintAttributeFlags::from_bits_mut(&mut self[0x58])
 	}
 
 	pub fn sprite_addr_map(&mut self) -> &mut u8 {
@@ -134,9 +126,16 @@ impl Palette {
 	}
 }
 
+#[derive(Copy, Clone, Debug, PartialEq, Eq, TransparentRef)]
+#[repr(transparent)]
+pub struct PrintAttributeFlags(u8);
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, TransparentRef)]
+#[repr(transparent)]
+pub struct MiscChipsetFeatureFlags(u8);
+
 bitflags! {
-	#[derive(Copy, Clone)]
-    pub struct PrintAttributeFlags: u8 {
+    impl PrintAttributeFlags: u8 {
         const ENABLE        = 1 << 0;
         const PADDING       = 1 << 1;
         const WIDE          = 1 << 2;
@@ -147,9 +146,8 @@ bitflags! {
         const CUSTOM_FONT   = 1 << 7;
     }
 
-	#[derive(Copy, Clone)]
-	pub struct MiscChipsetFeatureFlags: u8 {
-		/// the undocumented multi-screen feature is enabled
+	impl MiscChipsetFeatureFlags: u8 {
+		/// the undocumented multiscreen feature is enabled
         const MULTI_SCREEN       = 1 << 0;
 		/// the diameter of circles drawn using circ() and circfill() will be increased by 1 pixel rightward and 1 pixel downward if the fractional part of the radius is .5 or greater
         const FRACT_CIRCLE       = 1 << 1;

p8rs/src/vm/memory/mod.rs

@@ -3,6 +3,7 @@ use core::ops::{Deref, DerefMut};
 use alloc::boxed::Box;
 use alloc::alloc::Global;
 use p8rs_types::p8num::P8Num;
+use p8rs_macros::TransparentRef;
 
 pub mod sprites;
 pub mod map;
@@ -11,15 +12,16 @@ pub mod sound_effects;
 pub mod machine_state;
 pub mod screen;
 
+use crate::utils;
 use sprites::Sprites;
 use map::Map;
 use music::Music;
 use sound_effects::SoundEffects;
 use machine_state::MachineState;
 use screen::Screen;
 
+#[derive(Debug, Clone, TransparentRef)]
 #[repr(transparent)]
-#[derive(Debug)]
 pub struct Memory([u8; 0x10000]);
 
 impl Memory {
@@ -28,8 +30,7 @@ impl Memory {
 	}
 
 	pub fn new_in<A: Allocator>(alloc: A) -> Box<Self, A> {
-		// SAFETY: Memory is just a transparent, u8 array.
-		let mut mem = unsafe { Box::<Self, A>::new_zeroed_in(alloc).assume_init() };
+		let mut mem = Memory::from_bits_boxed(utils::new_zeroed_box_in(alloc));
 
 		mem.reset();