diff options
author | Brian Cully <bjc@kublai.com> | 2019-08-06 16:31:34 -0400 |
---|---|---|
committer | Brian Cully <bjc@kublai.com> | 2019-08-06 16:31:34 -0400 |
commit | 392239c7f522acb7ca5847a48dd9ab2480242924 (patch) | |
tree | b02f1f568085ae1dcb3c33c780d49a8d1a77a2eb /src/array.rs | |
parent | b0c6c4f9a45cf2b965acd3d10499e9df54929b36 (diff) | |
download | clint-392239c7f522acb7ca5847a48dd9ab2480242924.tar.gz clint-392239c7f522acb7ca5847a48dd9ab2480242924.zip |
Add compatibilty with rust-stable.
* Add feature flag for const-fn functionality, which simplifies some
things and lets this crate run on architectures where atomic CAS
isn't available (e.g., thumbv6).
* Remove `const fn` where necessary to compile under rust-stable.
* BREAKING CHANGE - Change signature of `Handler::replace` to take a
mutable borrow. This is required because the underlying type is
now a NonNull, which needs `mut`. The old behavior was never
desired, but a consequence of trying to avoid `Option` by using a
default handler.
* Use lazy_static crate for initialization of Handler/HandlerArray.
* Specify Sync for Handler. This is not amazing, since it isn't, but
it's necessary for initialization in static contexts inside
`lazy_static`. This should be fine, because any actual
manipulation of the handler is done in unsafe functions.
Diffstat (limited to 'src/array.rs')
-rw-r--r-- | src/array.rs | 23 |
1 files changed, 22 insertions, 1 deletions
diff --git a/src/array.rs b/src/array.rs index e01fe74..d460824 100644 --- a/src/array.rs +++ b/src/array.rs @@ -18,7 +18,12 @@ //! use clint::HandlerArray; //! use cortex_m_rt::exception; //! -//! static HANDLERS: HandlerArray = HandlerArray::new(); +//! #[macro_use] +//! extern crate lazy_static; +//! +//! lazy_static! { +//! static ref HANDLERS: HandlerArray<'static> = HandlerArray::new(); +//! } //! //! fn main() { //! // NB: This closure has to be created outside of `with_overrides` to @@ -75,12 +80,28 @@ pub struct HandlerArray<'a> { impl<'a> HandlerArray<'a> { /// Create a new `HandlerArray` filled with no-op handlers. + #[cfg(feature = "const-fn")] pub const fn new() -> Self { Self { h: UnsafeCell::new([Handler::new(); NR_ISR]), } } + #[cfg(not(feature = "const-fn"))] + pub fn new() -> Self { + let h = { + let mut ui_h: [core::mem::MaybeUninit<Handler>; NR_ISR] = + unsafe { core::mem::MaybeUninit::uninit().assume_init() }; + for h in &mut ui_h[..] { + unsafe { core::ptr::write(h.as_mut_ptr(), Handler::new()) } + } + unsafe { core::mem::transmute(ui_h) } + }; + Self { + h: UnsafeCell::new(h), + } + } + /// Register `f` for entry `nr` in this array using the default /// critical section locker. pub fn register<F>(&self, nr: usize, f: &'a mut F) |