Merge pull request #27 from Neotron-Compute/use-neotron-ffi

Use neotron FFI crate

Author: jonathanpallant

Cargo.toml

@@ -1,16 +1,17 @@
 [package]
-name = "neotron-common-bios"
-version = "0.8.0"
 authors = ["Jonathan 'theJPster' Pallant <[email protected]>"]
-edition = "2018"
 description = "Common BIOS code and API for all Neotron systems."
-license = "GPL-3.0-or-later"
-repository = "https://github.com/neotron-compute/neotron-common-bios.git"
+edition = "2018"
 homepage = "https://github.com/neotron-compute/neotron-common-bios"
+license = "GPL-3.0-or-later"
+name = "neotron-common-bios"
 readme = "README.md"
+repository = "https://github.com/neotron-compute/neotron-common-bios.git"
+version = "0.8.0"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-chrono = { version = "0.4", default-features=false }
+chrono = {version = "0.4", default-features = false}
+neotron-ffi = "0.1"
 pc-keyboard = "0.7"

src/audio.rs

@@ -89,7 +89,7 @@ pub enum Direction {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct MixerChannelInfo {
 	/// The name of this Audio Mixer Channel (e.g. `Line In`)
-	pub name: crate::ApiString<'static>,
+	pub name: crate::FfiString<'static>,
 	/// Is this an Input or an Output?
 	pub direction: Direction,
 	/// What value of `current_level` gives the loudest audio? All values

src/block_dev.rs

@@ -55,7 +55,7 @@ pub enum DeviceType {
 pub struct DeviceInfo {
 	/// Some human-readable name for this block device (e.g. `SdCard0` or
 	/// `CF1`)
-	pub name: crate::ApiString<'static>,
+	pub name: crate::FfiString<'static>,
 	/// The kind of block device this is.
 	pub device_type: DeviceType,
 	/// The size of an addressable block, in bytes.

src/bus.rs

@@ -56,7 +56,7 @@ pub enum PeripheralKind {
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct PeripheralInfo {
 	/// A name, such as `slot0`
-	pub name: crate::ApiString<'static>,
+	pub name: crate::FfiString<'static>,
 	/// The kind of peripheral
 	pub kind: PeripheralKind,
 }

src/i2c.rs

@@ -42,7 +42,7 @@
 pub struct BusInfo {
 	/// Some human-readable name for this I²C device (e.g. `I²C0` or
 	/// `DDC0`)
-	pub name: crate::ApiString<'static>,
+	pub name: crate::FfiString<'static>,
 }
 
 // ============================================================================

src/lib.rs

@@ -140,7 +140,7 @@ pub struct Config {
 pub struct DeviceInfo {
 	/// Some human-readable name for this serial device (e.g. `RS232` or
 	/// `USB0`)
-	pub name: crate::ApiString<'static>,
+	pub name: crate::FfiString<'static>,
 	/// The type of this serial device
 	pub device_type: DeviceType,
 }

src/serial.rs

@@ -60,65 +60,11 @@ pub enum Error {
 	BlockOutOfBounds,
 }
 
-/// All API functions which can fail return this type. We don't use the
-/// `Result` type from the standard library because that isn't FFI safe and
-/// may change layout between compiler versions.
-#[repr(C)]
-pub enum Result<T> {
-	/// The operation succeeded (the same as `core::result::Result::Ok`).
-	Ok(T),
-	/// The operation failed (the same as `core::result::Result::Err`).
-	Err(Error),
-}
-
-/// All API functions which take/return optional values return this type. We
-/// don't use the `Option` type from the standard library because that isn't
-/// FFI safe and may change layout between compiler versions.
-#[repr(C)]
-pub enum Option<T> {
-	/// There is some data (the same as `core::option::Option::Some`)
-	Some(T),
-	/// There is no data (the same as `core::option::Option::None`)
-	None,
-}
-
 /// Describes a period of time, after which the BIOS should give up.
 #[repr(C)]
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Timeout(u32);
 
-/// A Rust UTF-8 string, but compatible with FFI. Assume the lifetime is only
-/// valid until the callee returns to the caller. Is not null-terminated.
-#[repr(C)]
-#[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
-pub struct ApiString<'a>(ApiByteSlice<'a>);
-
-/// A Rust u8 slice, but compatible with FFI. Assume the lifetime is only valid
-/// until the callee returns to the caller.
-#[repr(C)]
-#[derive(Clone)]
-pub struct ApiByteSlice<'a> {
-	/// A pointer to the data
-	pub data: *const u8,
-	/// The number of bytes we are pointing at
-	pub data_len: usize,
-	/// A phantom object to hold the lifetime
-	_phantom: core::marker::PhantomData<&'a [u8]>,
-}
-
-/// A Rust u8 mutable slice, but compatible with FFI. Assume the lifetime is
-/// only valid until the callee returns to the caller.
-#[repr(C)]
-#[derive(Clone)]
-pub struct ApiBuffer<'a> {
-	/// A pointer to where the data can be put
-	pub data: *mut u8,
-	/// The maximum number of bytes we can store in this buffer
-	pub data_len: usize,
-	/// A phantom object to hold the lifetime
-	_phantom: core::marker::PhantomData<&'a [u8]>,
-}
-
 /// Represents an instant in time between 2000-01-01T00:00:00Z and
 /// 2136-02-07T06:28:16Z.
 #[repr(C)]
@@ -165,61 +111,8 @@ pub struct MemoryRegion {
 
 // OsStartFn
 
-// Error
-
-impl<T> Result<T> {
-	/// Obtain the inner value, or panic - just like `core::Result::unwrap`.
-	pub fn unwrap(self) -> T {
-		let r: core::result::Result<T, Error> = self.into();
-		r.unwrap()
-	}
-}
-
-impl<T> From<core::result::Result<T, Error>> for Result<T> {
-	fn from(value: core::result::Result<T, Error>) -> Self {
-		match value {
-			Ok(inner) => Result::Ok(inner),
-			Err(inner) => Result::Err(inner),
-		}
-	}
-}
-
-impl<T> From<Result<T>> for core::result::Result<T, Error> {
-	fn from(value: Result<T>) -> Self {
-		match value {
-			Result::Ok(inner) => core::result::Result::Ok(inner),
-			Result::Err(inner) => core::result::Result::Err(inner),
-		}
-	}
-}
-
-impl<T> Option<T> {
-	/// Obtain the inner value, or panic - just like `core::Option::unwrap`.
-	pub fn unwrap(self) -> T {
-		let o: core::option::Option<T> = self.into();
-		o.unwrap()
-	}
-}
-
-impl<T> From<core::option::Option<T>> for Option<T> {
-	fn from(value: core::option::Option<T>) -> Self {
-		match value {
-			Some(inner) => Option::Some(inner),
-			None => Option::None,
-		}
-	}
-}
-
-impl<T> From<Option<T>> for core::option::Option<T> {
-	fn from(value: Option<T>) -> Self {
-		match value {
-			Option::Some(inner) => core::option::Option::Some(inner),
-			Option::None => core::option::Option::None,
-		}
-	}
-}
-
 // Timeout
+
 impl Timeout {
 	/// Create a new timeout, in milliseconds.
 	pub fn new_ms(milliseconds: u32) -> Timeout {
@@ -238,191 +131,6 @@ impl Timeout {
 	}
 }
 
-// ApiString
-
-impl<'a> ApiString<'a> {
-	/// Create a new string slice we can send over the FFI.
-	pub fn new(s: &'a str) -> ApiString<'a> {
-		ApiString(ApiByteSlice::new(s.as_bytes()))
-	}
-
-	/// Turn this FFI string into a Rust string slice.
-	pub fn as_str(&'a self) -> &'a str {
-		unsafe { core::str::from_utf8_unchecked(self.0.as_slice()) }
-	}
-}
-
-impl<'a> From<&'a str> for ApiString<'a> {
-	/// Create a new FFI string from a string slice.
-	fn from(input: &'a str) -> ApiString<'a> {
-		ApiString::new(input)
-	}
-}
-
-impl core::fmt::Debug for ApiString<'_> {
-	fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
-		let buffer = unsafe { core::slice::from_raw_parts(self.0.data, self.0.data_len) };
-		let s = unsafe { core::str::from_utf8_unchecked(buffer) };
-		write!(f, "{:?}", s)
-	}
-}
-
-impl core::fmt::Display for ApiString<'_> {
-	fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
-		let buffer = unsafe { core::slice::from_raw_parts(self.0.data, self.0.data_len) };
-		let s = unsafe { core::str::from_utf8_unchecked(buffer) };
-		write!(f, "{}", s)
-	}
-}
-
-// ApiByteSlice
-
-impl<'a> ApiByteSlice<'a> {
-	/// Create a new byte slice we can send over the FFI.
-	pub fn new(s: &'a [u8]) -> ApiByteSlice<'a> {
-		ApiByteSlice {
-			data: s.as_ptr(),
-			data_len: s.len(),
-			_phantom: core::marker::PhantomData,
-		}
-	}
-
-	/// Make an empty slice.
-	pub fn empty() -> ApiByteSlice<'static> {
-		static EMPTY: &[u8] = &[];
-		ApiByteSlice::new(EMPTY)
-	}
-
-	/// Turn this byte slice into a Rust byte slice.
-	pub fn as_slice(&self) -> &[u8] {
-		unsafe { core::slice::from_raw_parts(self.data, self.data_len) }
-	}
-}
-
-impl core::fmt::Debug for ApiByteSlice<'_> {
-	fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
-		let slice = self.as_slice();
-		write!(f, "[ ")?;
-		if let Some((last, rest)) = slice.split_last() {
-			for i in rest.iter() {
-				write!(f, "0x{:02x}, ", i)?;
-			}
-			write!(f, "0x{:02x} ", last)?;
-		}
-		write!(f, "]")
-	}
-}
-
-impl<'a> From<&'a [u8]> for ApiByteSlice<'a> {
-	/// Convert from a Rust byte slice into an FFI compatible byte slice
-	fn from(input: &'a [u8]) -> ApiByteSlice<'a> {
-		ApiByteSlice::new(input)
-	}
-}
-
-impl<'a> core::cmp::PartialEq for ApiByteSlice<'a> {
-	/// Check if two ApiByteSlices are equal.
-	///
-	/// We just make some actual slices and compare then.
-	fn eq(&self, rhs: &Self) -> bool {
-		if self.data_len != rhs.data_len {
-			return false;
-		}
-		let this_slice = self.as_slice();
-		let that_slice = rhs.as_slice();
-		this_slice == that_slice
-	}
-}
-
-impl<'a> core::cmp::Eq for ApiByteSlice<'a> {}
-
-impl<'a> core::cmp::Ord for ApiByteSlice<'a> {
-	/// Compare two ApiByteSlices.
-	///
-	/// We just make some actual slices and compare then.
-	fn cmp(&self, rhs: &Self) -> core::cmp::Ordering {
-		let this_slice = self.as_slice();
-		let that_slice = rhs.as_slice();
-		this_slice.cmp(that_slice)
-	}
-}
-
-impl<'a> core::cmp::PartialOrd for ApiByteSlice<'a> {
-	/// Compare two ApiByteSlices.
-	///
-	/// We are `Ord` so we can defer to that.
-	fn partial_cmp(&self, rhs: &Self) -> core::option::Option<core::cmp::Ordering> {
-		Some(self.cmp(rhs))
-	}
-}
-
-// ApiBuffer
-
-impl<'a> ApiBuffer<'a> {
-	/// Create a new buffer we can send over the FFI.
-	///
-	/// This buffer is a mutable borrow of some storage space allocated
-	/// elsewhere. If you are given this type in an API, assume it is only
-	/// valid for as long as the function call you were given in it.
-	pub fn new(s: &'a mut [u8]) -> ApiBuffer<'a> {
-		ApiBuffer {
-			data: s.as_mut_ptr(),
-			data_len: s.len(),
-			_phantom: core::marker::PhantomData,
-		}
-	}
-
-	/// Make an empty slice.
-	pub fn empty() -> ApiBuffer<'static> {
-		ApiBuffer {
-			data: core::ptr::null_mut(),
-			data_len: 0,
-			_phantom: core::marker::PhantomData,
-		}
-	}
-
-	/// Turn this buffer into a Rust byte slice.
-	pub fn as_slice(&self) -> &[u8] {
-		if self.data.is_null() {
-			&[]
-		} else {
-			unsafe { core::slice::from_raw_parts(self.data, self.data_len) }
-		}
-	}
-
-	/// Turn this buffer into a Rust mutable byte slice.
-	///
-	/// You will get `None` if the buffer is empty (i.e. has zero length).
-	pub fn as_mut_slice(&mut self) -> core::option::Option<&mut [u8]> {
-		if self.data.is_null() {
-			None
-		} else {
-			Some(unsafe { core::slice::from_raw_parts_mut(self.data, self.data_len) })
-		}
-	}
-}
-
-impl core::fmt::Debug for ApiBuffer<'_> {
-	fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
-		let slice = self.as_slice();
-		write!(f, "[ ")?;
-		if let Some((last, rest)) = slice.split_last() {
-			for i in rest.iter() {
-				write!(f, "0x{:02x}, ", i)?;
-			}
-			write!(f, "0x{:02x} ", last)?;
-		}
-		write!(f, "]")
-	}
-}
-
-impl<'a> From<&'a mut [u8]> for ApiBuffer<'a> {
-	/// Convert from a Rust byte slice into an FFI compatible byte slice
-	fn from(input: &'a mut [u8]) -> ApiBuffer<'a> {
-		ApiBuffer::new(input)
-	}
-}
-
 // Time
 
 impl core::fmt::Display for Time {